Dedupe logic

Author: GrahamTheCoder

CodeConverter/CSharp/NameExpressionNodeVisitor.cs

@@ -87,7 +87,7 @@ public async Task<CSharpSyntaxNode> ConvertMemberAccessExpressionAsync(VBasic.Sy
             if (IsSubPartOfConditionalAccess(node)) {
                 return isDefaultProperty ? SyntaxFactory.ElementBindingExpression()
                     : await AdjustForImplicitInvocationAsync(node, SyntaxFactory.MemberBindingExpression(simpleNameSyntax));
-            } else if (node.IsParentKind(Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.NamedFieldInitializer)) {
+            } else if (node.IsParentKind(VBasic.SyntaxKind.NamedFieldInitializer)) {
                 return ValidSyntaxFactory.IdentifierName(_tempNameForAnonymousScope[node.Name.Identifier.Text].Peek().TempName);
             }
             left = _withBlockLhs.Peek();
@@ -292,21 +292,10 @@ private async Task<ExpressionSyntax> ConvertInvocationAsync(VBSyntax.InvocationE
             var refKind = CommonConversions.GetCsRefKind(thisParam);
 
             bool requiresHoist = false;
-            SemanticModelExtensions.RefConversion refConversion = SemanticModelExtensions.RefConversion.Inline;
+            RefConversion refConversion = RefConversion.Inline;
             if (refKind != RefKind.None) {
-                var symbolInfo = _semanticModel.GetSymbolInfoInDocument<ISymbol>(maes.Expression);
-                if (symbolInfo is IPropertySymbol { ReturnsByRef: false, ReturnsByRefReadonly: false } propertySymbol) {
-                    refConversion = propertySymbol.IsReadOnly ? SemanticModelExtensions.RefConversion.PreAssigment : SemanticModelExtensions.RefConversion.PreAndPostAssignment;
-                } else if (symbolInfo is IFieldSymbol { IsConst: true } or ILocalSymbol { IsConst: true }) {
-                    refConversion = SemanticModelExtensions.RefConversion.PreAssigment;
-                } else if (symbolInfo is IMethodSymbol { ReturnsByRef: false, ReturnsByRefReadonly: false }) {
-                    refConversion = SemanticModelExtensions.RefConversion.PreAssigment;
-                } else {
-                    var typeInfo = _semanticModel.GetTypeInfo(maes.Expression);
-                    bool isTypeMismatch = typeInfo.Type == null || !typeInfo.Type.Equals(typeInfo.ConvertedType, SymbolEqualityComparer.IncludeNullability);
-                    if (isTypeMismatch) refConversion = SemanticModelExtensions.RefConversion.PreAndPostAssignment;
-                }
-                requiresHoist = refConversion != SemanticModelExtensions.RefConversion.Inline;
+                refConversion = _semanticModel.GetRefConversionForExpression(maes.Expression);
+                requiresHoist = refConversion != RefConversion.Inline;
             }
 
             if (requiresStaticInvocation || requiresHoist) {

CodeConverter/CSharp/SemanticModelExtensions.cs

@@ -70,11 +70,15 @@ public static RefConversion NeedsVariableForArgument(this SemanticModel semantic
         if (!(node is VBSyntax.SimpleArgumentSyntax sas) || sas is { Expression: VBSyntax.ParenthesizedExpressionSyntax }) return RefConversion.PreAssigment;
         var expression = sas.Expression;
 
-        return GetRefConversion(expression);
+        return semanticModel.GetRefConversionForExpression(expression);
 
-        RefConversion GetRefConversion(VBSyntax.ExpressionSyntax expression)
+    }
+
+    public static RefConversion GetRefConversionForExpression(this SemanticModel semanticModel, VBasic.Syntax.ExpressionSyntax expression)
+    {
+        RefConversion GetRefConversion(VBSyntax.ExpressionSyntax expr)
         {
-            var symbolInfo = semanticModel.GetSymbolInfoInDocument<ISymbol>(expression);
+            var symbolInfo = semanticModel.GetSymbolInfoInDocument<ISymbol>(expr);
             if (symbolInfo is IPropertySymbol { ReturnsByRef: false, ReturnsByRefReadonly: false } propertySymbol) {
                 // a property in VB.NET code can be ReturnsByRef if it's defined in a C# assembly the VB.NET code references
                 return propertySymbol.IsReadOnly ? RefConversion.PreAssigment : RefConversion.PreAndPostAssignment;
@@ -87,10 +91,10 @@ RefConversion GetRefConversion(VBSyntax.ExpressionSyntax expression)
 
             if (DeclaredInUsing(symbolInfo)) return RefConversion.PreAssigment;
 
-            if (expression is VBasic.Syntax.IdentifierNameSyntax || expression is VBSyntax.MemberAccessExpressionSyntax ||
-                IsRefArrayAcces(expression)) {
+            if (expr is VBasic.Syntax.IdentifierNameSyntax || expr is VBSyntax.MemberAccessExpressionSyntax ||
+                IsRefArrayAcces(expr)) {
 
-                var typeInfo = semanticModel.GetTypeInfo(expression);
+                var typeInfo = semanticModel.GetTypeInfo(expr);
                 bool isTypeMismatch = typeInfo.Type == null || !typeInfo.Type.Equals(typeInfo.ConvertedType, SymbolEqualityComparer.IncludeNullability);
 
                 if (isTypeMismatch) {
@@ -103,9 +107,9 @@ RefConversion GetRefConversion(VBSyntax.ExpressionSyntax expression)
             return RefConversion.PreAssigment;
         }
 
-        bool IsRefArrayAcces(VBSyntax.ExpressionSyntax expression)
+        bool IsRefArrayAcces(VBSyntax.ExpressionSyntax expr)
         {
-            if (!(expression is VBSyntax.InvocationExpressionSyntax ies)) return false;
+            if (!(expr is VBSyntax.InvocationExpressionSyntax ies)) return false;
             var op = semanticModel.GetOperation(ies);
             return (op.IsArrayElementAccess() || IsReturnsByRefPropertyElementAccess(op))
                 && GetRefConversion(ies.Expression) == RefConversion.Inline;
@@ -117,6 +121,8 @@ static bool IsReturnsByRefPropertyElementAccess(IOperation op)
                  && (prop.ReturnsByRef || prop.ReturnsByRefReadonly);
             }
         }
+
+        return GetRefConversion((VBSyntax.ExpressionSyntax)expression);
     }
 
     private static bool DeclaredInUsing(ISymbol symbolInfo)