Issue/1102

CHANGELOG.md

@@ -12,6 +12,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 ### VB -> C#
 
 * Escape parameter names [#1092](https://github.com/icsharpcode/CodeConverter/issues/1092)
+* Bitwise or is now correctly parenthesized within larger expression
 
 ### C# -> VB
 

CodeConverter/CSharp/ExpressionNodeVisitor.cs

@@ -381,7 +381,7 @@ public override async Task<CSharpSyntaxNode> VisitParenthesizedExpression(VBasic
     {
         var cSharpSyntaxNode = await node.Expression.AcceptAsync<CSharpSyntaxNode>(TriviaConvertingExpressionVisitor);
         // If structural changes are necessary the expression may have been lifted a statement (e.g. Type inferred lambda)
-        return cSharpSyntaxNode is ExpressionSyntax expr ? SyntaxFactory.ParenthesizedExpression(expr) : cSharpSyntaxNode;
+        return cSharpSyntaxNode is ExpressionSyntax expr ? expr.AddParens() : cSharpSyntaxNode;
     }
 
     public override async Task<CSharpSyntaxNode> VisitMemberAccessExpression(VBasic.Syntax.MemberAccessExpressionSyntax node)
@@ -767,7 +767,7 @@ public override async Task<CSharpSyntaxNode> VisitBinaryConditionalExpression(VB
             node.SecondExpression.ParenthesizeIfPrecedenceCouldChange(rightSide));
 
         if (node.Parent.IsKind(VBasic.SyntaxKind.Interpolation) || node.PrecedenceCouldChange())
-            return SyntaxFactory.ParenthesizedExpression(expr);
+            return expr.AddParens();
 
         return expr;
     }
@@ -787,7 +787,7 @@ public override async Task<CSharpSyntaxNode> VisitTernaryConditionalExpression(V
 
 
         if (node.Parent.IsKind(VBasic.SyntaxKind.Interpolation) || node.PrecedenceCouldChange())
-            return SyntaxFactory.ParenthesizedExpression(expr);
+            return expr.AddParens();
 
         return expr;
     }

CodeConverter/CSharp/MethodBodyExecutableStatementVisitor.cs

@@ -452,7 +452,7 @@ public override async Task<SyntaxList<StatementSyntax>> VisitReturnStatement(VBS
 
         var csExpression = await node.Expression.AcceptAsync<ExpressionSyntax>(_expressionVisitor);
         csExpression = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(node.Expression, csExpression);
-        return SingleStatement(SyntaxFactory.ReturnStatement(csExpression));
+        return SingleStatement(SyntaxFactory.ReturnStatement(csExpression.SkipIntoParens()));
     }
 
     public override async Task<SyntaxList<StatementSyntax>> VisitContinueStatement(VBSyntax.ContinueStatementSyntax node)

CodeConverter/CSharp/VbSyntaxNodeExtensions.cs

@@ -6,7 +6,7 @@ internal static class VbSyntaxNodeExtensions
 {
     public static CSSyntax.ExpressionSyntax ParenthesizeIfPrecedenceCouldChange(this VBasic.VisualBasicSyntaxNode node, CSSyntax.ExpressionSyntax expression)
     {
-        return PrecedenceCouldChange(node) ? SyntaxFactory.ParenthesizedExpression(expression) : expression;
+        return PrecedenceCouldChange(node) ? expression.AddParens() : expression;
     }
 
     public static bool PrecedenceCouldChange(this VBasic.VisualBasicSyntaxNode node)

CodeConverter/Common/DocumentExtensions.cs

@@ -50,7 +50,9 @@ private static bool VbWouldBeSimplifiedIncorrectly(SyntaxNode n)
 
     private static bool CsWouldBeSimplifiedIncorrectly(SyntaxNode n)
     {
-        return false;
+        // https://github.com/icsharpcode/CodeConverter/issues/1102
+        return n is CSSyntax.ParenthesizedExpressionSyntax {Expression: CSSyntax.BinaryExpressionSyntax {OperatorToken: var operatorToken}}
+               && operatorToken.IsKind(CS.SyntaxKind.BarToken);
     }
 
     public static async Task<Document> WithExpandedRootAsync(this Document document, CancellationToken cancellationToken)

CodeConverter/Util/CSharpUtil.cs

@@ -17,7 +17,7 @@ public static ExpressionSyntax InvertCondition(this ExpressionSyntax condition)
     private static ExpressionSyntax InvertConditionInternal(ExpressionSyntax condition)
     {
         if (condition is ParenthesizedExpressionSyntax) {
-            return SyntaxFactory.ParenthesizedExpression(InvertCondition(((ParenthesizedExpressionSyntax)condition).Expression));
+            return InvertCondition(((ParenthesizedExpressionSyntax)condition).Expression).AddParens();
         }
 
         if (condition is PrefixUnaryExpressionSyntax) {
@@ -131,7 +131,7 @@ public static SyntaxKind GetExpressionOperatorTokenKind(SyntaxKind op)
     /// </summary>
     public static ExpressionSyntax AddParens(this ExpressionSyntax expression)
     {
-        return SyntaxFactory.ParenthesizedExpression(expression);
+        return expression.IsKind(SyntaxKind.ParenthesizedExpression) || expression.IsKind(SyntaxKind.IdentifierName) || expression is LiteralExpressionSyntax ? expression : SyntaxFactory.ParenthesizedExpression(expression);
     }
 
     /// <summary>

Tests/CSharp/ExpressionTests/BinaryExpressionTests.cs

@@ -54,6 +54,19 @@ internal partial class TestClass
 }");
     }
 
+    [Fact]
+    public async Task OrAndAlsoAsync()
+    {
+        await TestConversionVisualBasicToCSharpAsync(
+            @"Public Function GetString(tb as Boolean, tc As Boolean, td as Boolean) As Boolean
+    Return (tb Or tc) AndAlso td
+End Function",
+            @"public bool GetString(bool tb, bool tc, bool td)
+{
+    return (tb | tc) && td;
+}");
+    }
+
     [Fact]
     public async Task LikeOperatorAsync()
     {