Fall back on handling private or unknown cs symbols based on their syntax attributes

Author: GrahamTheCoder

CodeConverter/CSharp/ArgumentConverter.cs

@@ -32,7 +32,7 @@ public async Task<CSharpSyntaxNode> ConvertSimpleArgumentAsync(VBSyntax.SimpleAr
         var baseSymbol = symbol?.OriginalDefinition.GetBaseSymbol();
         var possibleParameters = (CommonConversions.GetCsOriginalSymbolOrNull(baseSymbol) ?? symbol)?.GetParameters();
         if (possibleParameters.HasValue) {
-            var refType = _semanticModel.GetRefConversionType(node, argList, possibleParameters.Value, out var argName, out var refKind);
+            var refType = CommonConversions.GetRefConversionType(node, argList, possibleParameters.Value, out var argName, out var refKind);
             token = CommonConversions.GetRefToken(refKind);
             if (refType != SemanticModelExtensions.RefConversion.Inline) {
                 convertedArgExpression = HoistByRefDeclaration(node, convertedArgExpression, refType, argName, refKind);

CodeConverter/CSharp/CommonConversions.cs

@@ -1,4 +1,5 @@
-using System.Linq.Expressions;
+using System.Collections.Immutable;
+using System.Linq.Expressions;
 using System.Runtime.CompilerServices;
 using ICSharpCode.CodeConverter.Util.FromRoslyn;
 using Microsoft.CodeAnalysis.Classification;
@@ -669,6 +670,7 @@ public ISymbol GetCsOriginalSymbolOrNull(ISymbol symbol)
         symbol = symbol.OriginalDefinition;
         // Construct throws an exception if ConstructedFrom differs from it, so let's use ConstructedFrom directly
         var symbolToFind = symbol is IMethodSymbol m ? m.ConstructedFrom : symbol;
+        // This no longer works for private members: https://github.com/dotnet/roslyn/issues/72369#issuecomment-1975066163
         var similarSymbol = SymbolFinder.FindSimilarSymbols(symbolToFind, _csCompilation).FirstOrDefault();
         return similarSymbol;
     }
@@ -747,6 +749,9 @@ public RefKind GetCsRefKind(IParameterSymbol vbParameter, Microsoft.CodeAnalysis
             return csParam.RefKind;
         }
 
+        var syntaxNodes = vbParameter?.DeclaringSyntaxReferences.Select(r => r.GetSyntax());
+        optionalParameterSyntax ??= syntaxNodes?.OfType<VBSyntax.ParameterSyntax>().FirstOrDefault();
+
         if (optionalParameterSyntax?.AttributeLists.Any(this.HasOutAttribute) == true) {
             return RefKind.Out;
         }
@@ -800,4 +805,19 @@ public async Task<CSharpSyntaxNode> WithRemovedRedundantConversionOrNullAsync(VB
         return writtenByUser ? null : this.TypeConversionAnalyzer.AddExplicitConversion(conversionArg, csharpArg,
             forceTargetType: forceTargetType, defaultToCast: true);
     }
+
+    public SemanticModelExtensions.RefConversion GetRefConversionType(VBSyntax.ArgumentSyntax node, VBSyntax.ArgumentListSyntax argList, ImmutableArray<IParameterSymbol> parameters, out string argName, out RefKind refKind)
+    {
+        var parameter = node.IsNamed && node is VBSyntax.SimpleArgumentSyntax sas
+            ? parameters.FirstOrDefault(p => p.Name.Equals(sas.NameColonEquals.Name.Identifier.Text, StringComparison.OrdinalIgnoreCase))
+            : parameters.ElementAtOrDefault(argList.Arguments.IndexOf(node));
+        if (parameter != null) {
+            refKind = GetCsRefKind(parameter);
+            argName = parameter.Name;
+        } else {
+            refKind = RefKind.None;
+            argName = null;
+        }
+        return SemanticModel.NeedsVariableForArgument(node, refKind);
+    }
 }

CodeConverter/CSharp/NameExpressionNodeVisitor.cs

@@ -452,7 +452,7 @@ private bool RequiresLocalFunction(VBSyntax.InvocationExpressionSyntax invocatio
 
         bool RequiresLocalFunction(RefConversion possibleInline, VBSyntax.InvocationExpressionSyntax invocation, IMethodSymbol invocationSymbol, VBSyntax.ArgumentSyntax a)
         {
-            var refConversion = _semanticModel.GetRefConversionType(a, invocation.ArgumentList, invocationSymbol.Parameters, out string _, out _);
+            var refConversion = CommonConversions.GetRefConversionType(a, invocation.ArgumentList, invocationSymbol.Parameters, out string _, out _);
             if (RefConversion.Inline == refConversion || possibleInline == refConversion) return false;
             if (!(a is VBSyntax.SimpleArgumentSyntax sas)) return false;
             var argExpression = sas.Expression.SkipIntoParens();

CodeConverter/CSharp/SemanticModelExtensions.cs

@@ -64,21 +64,6 @@ public static TSymbol GetSymbolInfoInDocument<TSymbol>(this SemanticModel semant
         return semanticModel.SyntaxTree == node.SyntaxTree ? semanticModel.GetSymbolInfo(node).ExtractBestMatch<TSymbol>() : null;
     }
 
-    public static RefConversion GetRefConversionType(this SemanticModel semanticModel, VBSyntax.ArgumentSyntax node, VBSyntax.ArgumentListSyntax argList, ImmutableArray<IParameterSymbol> parameters, out string argName, out RefKind refKind)
-    {
-        var parameter = node.IsNamed && node is VBSyntax.SimpleArgumentSyntax sas
-            ? parameters.FirstOrDefault(p => p.Name.Equals(sas.NameColonEquals.Name.Identifier.Text, StringComparison.OrdinalIgnoreCase))
-            : parameters.ElementAtOrDefault(argList.Arguments.IndexOf(node));
-        if (parameter != null) {
-            refKind = parameter.RefKind;
-            argName = parameter.Name;
-        } else {
-            refKind = RefKind.None;
-            argName = null;
-        }
-        return semanticModel.NeedsVariableForArgument(node, refKind);
-    }
-
     public static RefConversion NeedsVariableForArgument(this SemanticModel semanticModel, VBasic.Syntax.ArgumentSyntax node, RefKind refKind)
     {
         if (refKind == RefKind.None) return RefConversion.Inline;