Stop considering index expressions on Variants as default member accesses

They might as well be array accesses. Now, no references will be generated for these anymore.

Author: MDoerner

Rubberduck.Parsing/Binding/Bindings/IndexDefaultBinding.cs

@@ -298,14 +298,21 @@ private IBoundExpression ResolveDefaultMember(string asTypeName, Declaration asT
                 named arguments. In this case, the index expression is classified as an unbound member with 
                 a declared type of Variant, referencing <l-expression> with no member name. 
              */
-            if (
-                (Tokens.Variant.Equals(asTypeName, StringComparison.InvariantCultureIgnoreCase)
-                    || Tokens.Object.Equals(asTypeName, StringComparison.InvariantCultureIgnoreCase))
+            if (Tokens.Variant.Equals(asTypeName, StringComparison.InvariantCultureIgnoreCase)
+                && !argumentList.HasNamedArguments)
+            {
+                ResolveArgumentList(null, argumentList);
+                //We do not treat unbound accesses on variables of type Variant as default member accesses because they could be array accesses as well. 
+                return new IndexExpression(null, ExpressionClassification.Unbound, expression, _lExpression, argumentList, isDefaultMemberAccess: false, defaultMemberRecursionDepth: defaultMemberResolutionRecursionDepth, containedDefaultMemberRecursionExpression: containedExpression);
+            }
+
+            if (Tokens.Object.Equals(asTypeName, StringComparison.InvariantCultureIgnoreCase)
                 && !argumentList.HasNamedArguments)
             {
                 ResolveArgumentList(null, argumentList);
                 return new IndexExpression(null, ExpressionClassification.Unbound, expression, _lExpression, argumentList, isDefaultMemberAccess: true, defaultMemberRecursionDepth: defaultMemberResolutionRecursionDepth, containedDefaultMemberRecursionExpression: containedExpression);
             }
+
             /*
                 The declared type of <l-expression> is a specific class, which has a public default Property 
                 Get, Property Let, function or subroutine, and one of the following is true:

Rubberduck.Parsing/VBA/ReferenceManagement/BoundExpressionVisitor.cs

@@ -250,6 +250,11 @@ private void Visit(
                 Visit(expression.LExpression, module, scope, parent, hasExplicitLetStatement: hasExplicitLetStatement);
                 AddArrayAccessReference(expression, module, scope, parent, isAssignmentTarget, hasExplicitLetStatement, isSetAssignment);
             }
+            else if (expression.Classification == ExpressionClassification.Unbound
+                     && expression.ReferencedDeclaration == null)
+            {
+                Visit(expression.LExpression, module, scope, parent);
+            }
             else
             {
                 // Index expressions are a bit special in that they can refer to parameterized properties and functions.

RubberduckTests/Inspections/IndexedUnboundDefaultMemberAccessInspectionTests.cs

@@ -184,6 +184,26 @@ End Function
             Assert.AreEqual(1, inspectionResults.Count());
         }
 
+        [Test]
+        [Category("Inspections")]
+        public void JaggedArray_NoResult()
+        {
+            var moduleCode = @"
+Private Function Foo() As Variant 
+    Dim outerArray() As Variant
+    Dim firstInnerArray() As Variant
+    Dim secondInnerArray() As Variant
+    outerArray = Array(firstInnerArray, secondInnerArray)
+    Foo = outerArray(0)(0)
+End Function
+";
+
+            var inspectionResults = InspectionResultsForStandardModule(moduleCode);
+
+            Assert.AreEqual(0, inspectionResults.Count());
+        }
+
+
         protected override IInspection InspectionUnderTest(RubberduckParserState state)
         {
             return new IndexedUnboundDefaultMemberAccessInspection(state);