Improve heuristic for unknown indexer vs method, fix missing params

Relates to #595

Author: GrahamTheCoder

CodeConverter/CSharp/ExpressionNodeVisitor.cs

@@ -838,7 +838,7 @@ private async Task<CSharpSyntaxNode> ConvertInvocationAsync(VBSyntax.InvocationE
             }
 
             if (expressionSymbol != null && expressionSymbol.IsKind(SymbolKind.Property) &&
-                invocationSymbol != null && invocationSymbol.GetParameters().Length == 0) {
+                invocationSymbol != null && invocationSymbol.GetParameters().Length == 0 && node.ArgumentList.Arguments.Count == 0) {
                 return convertedExpression; //Parameterless property access
             }
 
@@ -1444,12 +1444,15 @@ private static CSharpSyntaxNode ReplaceRightmostIdentifierText(CSharpSyntaxNode
         }
 
         /// <summary>
-        /// Chances of having an unknown delegate stored as a field/local seem lower than having an unknown non-delegate type with an indexer stored.
-        /// So for a standalone identifier err on the side of assuming it's an indexer.
+        /// If there's a single numeric arg, let's assume it's an indexer (probably an array).
+        /// Otherwise, err on the side of a method call.
         /// </summary>
-        private static bool ProbablyNotAMethodCall(VBasic.Syntax.InvocationExpressionSyntax node, ISymbol symbol, ITypeSymbol symbolReturnType)
+        private bool ProbablyNotAMethodCall(VBasic.Syntax.InvocationExpressionSyntax node, ISymbol symbol, ITypeSymbol symbolReturnType)
         {
-            return !node.IsParentKind(VBasic.SyntaxKind.CallStatement) && !(symbol is IMethodSymbol) && symbolReturnType.IsErrorType() && node.Expression is VBasic.Syntax.IdentifierNameSyntax && node.ArgumentList?.Arguments.Count() == 1;
+            return !node.IsParentKind(VBasic.SyntaxKind.CallStatement) && !(symbol is IMethodSymbol) &&
+                   symbolReturnType.IsErrorType() && node.Expression is VBasic.Syntax.IdentifierNameSyntax &&
+                   node.ArgumentList?.Arguments.OnlyOrDefault()?.GetExpression() is {} arg &&
+                   _semanticModel.GetTypeInfo(arg).Type.IsNumericType();
         }
 
         private async Task<ArgumentListSyntax> ConvertArgumentListOrEmptyAsync(SyntaxNode node, VBSyntax.ArgumentListSyntax argumentList)

Tests/CSharp/MissingSemanticModelInfo/ExpressionTests.cs

@@ -12,9 +12,11 @@ public async Task InvokeIndexerOnPropertyValueAsync()
             // Chances of having an unknown delegate stored as a field/property/local seem lower than having an unknown non-delegate
             // type with an indexer stored, so for a standalone identifier err on the side of assuming it's an indexer
             await TestConversionVisualBasicToCSharpAsync(@"Class TestClass
-Public Property SomeProperty As System.Some.UnknownType
+    Public Property SomeProperty As System.Some.UnknownType
     Private Sub TestMethod()
-        Dim value = SomeProperty(0)
+        Dim num = 0
+        Dim value = SomeProperty(num)
+        value = SomeProperty(0)
     End Sub
 End Class", @"
 internal partial class TestClass
@@ -23,7 +25,9 @@ internal partial class TestClass
 
     private void TestMethod()
     {
-        var value = SomeProperty[0];
+        int num = 0;
+        var value = SomeProperty[num];
+        value = SomeProperty[0];
     }
 }
 2 source compilation errors:
@@ -32,6 +36,33 @@ private void TestMethod()
 1 target compilation errors:
 CS0234: The type or namespace name 'Some' does not exist in the namespace 'System' (are you missing an assembly reference?)");
         }
+        [Fact]
+        public async Task InvokeMethodOnPropertyValueAsync()
+        {
+            // Chances of having an unknown delegate stored as a field/property/local seem lower than having an unknown non-delegate
+            // type with an indexer stored, so for a standalone identifier err on the side of assuming it's an indexer
+            await TestConversionVisualBasicToCSharpAsync(@"Class TestClass
+    Public Property SomeProperty As System.Some.UnknownType
+    Private Sub TestMethod()
+        Dim value = SomeProperty(New Object())
+    End Sub
+End Class", @"
+internal partial class TestClass
+{
+    public System.Some.UnknownType SomeProperty { get; set; }
+
+    private void TestMethod()
+    {
+        var value = SomeProperty(new object());
+    }
+}
+2 source compilation errors:
+BC30002: Type 'System.Some.UnknownType' is not defined.
+BC32016: 'Public Property SomeProperty As System.Some.UnknownType' has no parameters and its return type cannot be indexed.
+2 target compilation errors:
+CS0234: The type or namespace name 'Some' does not exist in the namespace 'System' (are you missing an assembly reference?)
+CS1955: Non-invocable member 'TestClass.SomeProperty' cannot be used like a method.");
+        }
 
         [Fact]
         public async Task InvokeMethodWithUnknownReturnTypeAsync()
@@ -310,14 +341,15 @@ internal partial class TestClass
 
     private void TestMethod()
     {
-        var a = DefaultDate.Blawer(1, 2, 3);
+        var a = DefaultDate(1, 2, 3).Blawer(1, 2, 3);
     }
 }
 2 source compilation errors:
 BC30002: Type 'System.SomeUnknownType' is not defined.
 BC32016: 'Private Property DefaultDate As System.SomeUnknownType' has no parameters and its return type cannot be indexed.
-1 target compilation errors:
-CS0234: The type or namespace name 'SomeUnknownType' does not exist in the namespace 'System' (are you missing an assembly reference?)");
+2 target compilation errors:
+CS0234: The type or namespace name 'SomeUnknownType' does not exist in the namespace 'System' (are you missing an assembly reference?)
+CS1955: Non-invocable member 'TestClass.DefaultDate' cannot be used like a method.");
         }
 
         [Fact]