Better implementation for inferring types

Author: GrahamTheCoder

ICSharpCode.CodeConverter/CSharp/ExpressionNodeVisitor.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Threading.Tasks;
@@ -975,14 +976,27 @@ public override async Task<CSharpSyntaxNode> VisitGenericName(VBasic.Syntax.Gene
         private async Task<SimpleNameSyntax> GenericNameAccountingForReducedParameters(VBSyntax.GenericNameSyntax node, ISymbol symbol)
         {
             SyntaxToken convertedIdentifier = ConvertIdentifier(node.Identifier);
-            var typeArgumentListSyntax = (TypeArgumentListSyntax)await node.TypeArgumentList.AcceptAsync(TriviaConvertingVisitor);
             if (symbol.IsReducedTypeParameterMethod()) {
-                var commentedText = "/* " + typeArgumentListSyntax.ToFullString() + " */";
-                var trailingTrivia = SyntaxFactory.Comment(commentedText);
-                return SyntaxFactory.IdentifierName(convertedIdentifier).WithTrailingTrivia(trailingTrivia);
+                if (symbol is IMethodSymbol vbMethod && CommonConversions.GetCsOriginalSymbolOrNull(symbol) is IMethodSymbol csSymbolWithInferredTypeParametersSet) {
+                    var argSubstitutions = vbMethod.TypeParameters
+                        .Zip(vbMethod.TypeArguments, (parameter, arg) => (parameter, arg))
+                        .ToDictionary(x => x.parameter.Name, x => x.arg);
+                    var allTypeArgs = csSymbolWithInferredTypeParametersSet.GetTypeArguments()
+                        .Select(a => a.Kind == SymbolKind.TypeParameter && argSubstitutions.TryGetValue(a.Name, out var t) ? t : a).ToArray();
+                    return (SimpleNameSyntax)CommonConversions.CsSyntaxGenerator.GenericName(convertedIdentifier.Text, allTypeArgs);
+                }
+                var commentedText = "/* " + (await ConvertTypeArgumentList(node)).ToFullString() + " */";
+                var error = SyntaxFactory.ParseLeadingTrivia($"#error Conversion error: Could not convert all type parameters, so they've been commented out. Inferred type may be different{Environment.NewLine}");
+                var partialConversion = SyntaxFactory.Comment(commentedText);
+                return SyntaxFactory.IdentifierName(convertedIdentifier).WithPrependedLeadingTrivia(error).WithTrailingTrivia(partialConversion);
             }
 
-            return SyntaxFactory.GenericName(convertedIdentifier, typeArgumentListSyntax);
+            return SyntaxFactory.GenericName(convertedIdentifier, await ConvertTypeArgumentList(node));
+        }
+
+        private async Task<TypeArgumentListSyntax> ConvertTypeArgumentList(VBSyntax.GenericNameSyntax node)
+        {
+            return (TypeArgumentListSyntax)await node.TypeArgumentList.AcceptAsync(TriviaConvertingVisitor);
         }
 
         public override async Task<CSharpSyntaxNode> VisitTypeArgumentList(VBasic.Syntax.TypeArgumentListSyntax node)

Tests/CSharp/ExpressionTests.cs

@@ -880,7 +880,7 @@ public void Foo()
         }
 
         [Fact]
-        public async Task ReducedTypeParametersCommented()
+        public async Task ReducedTypeParametersInferrable()
         {
             await TestConversionVisualBasicToCSharp(@"Imports System.Linq
 
@@ -894,7 +894,27 @@ public partial class Class1
 {
     public void Foo()
     {
-        var y = """".Split(',').Select/* <string> */(x => x);
+        var y = """".Split(',').Select(x => x);
+    }
+}");
+        }
+
+        [Fact]
+        public async Task ReducedTypeParametersNonInferrable()
+        {
+            await TestConversionVisualBasicToCSharp(@"Imports System.Linq
+
+Public Class Class1
+    Sub Foo()
+        Dim y = """".Split("",""c).Select(Of Object)(Function(x) x)
+    End Sub
+End Class", @"using System.Linq;
+
+public partial class Class1
+{
+    public void Foo()
+    {
+        var y = """".Split(',').Select<string, object>(x => x);
     }
 }");
         }