Add support for index expressions to SetTypeResolver

Author: MDoerner

Rubberduck.Parsing/Binding/Bindings/IndexDefaultBinding.cs

@@ -1,6 +1,8 @@
-using Antlr4.Runtime;
+using System;
+using Antlr4.Runtime;
 using Rubberduck.Parsing.Symbols;
 using System.Linq;
+using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.VBA.DeclarationCaching;
 
 namespace Rubberduck.Parsing.Binding
@@ -171,11 +173,11 @@ private IBoundExpression ResolveDefaultMember(IBoundExpression lExpression, stri
                 a declared type of Variant, referencing <l-expression> with no member name. 
              */
             if (
-                asTypeName != null
-                && (asTypeName.ToUpperInvariant() == "VARIANT" || asTypeName.ToUpperInvariant() == "OBJECT")
+                (Tokens.Variant.Equals(asTypeName, StringComparison.InvariantCultureIgnoreCase)
+                    || Tokens.Object.Equals(asTypeName, StringComparison.InvariantCultureIgnoreCase))
                 && !_argumentList.HasNamedArguments)
             {
-                return new IndexExpression(null, ExpressionClassification.Unbound, _expression, lExpression, _argumentList);
+                return new IndexExpression(null, ExpressionClassification.Unbound, _expression, lExpression, _argumentList, isDefaultMemberAccess: true);
             }
             /*
                 The declared type of <l-expression> is a specific class, which has a public default Property 
@@ -184,16 +186,8 @@ private IBoundExpression ResolveDefaultMember(IBoundExpression lExpression, stri
             if (asTypeDeclaration is ClassModuleDeclaration classModule
                 && classModule.DefaultMember is Declaration defaultMember)
             {
-                bool isPropertyGetLetFunctionProcedure =
-                    defaultMember.DeclarationType == DeclarationType.PropertyGet
-                    || defaultMember.DeclarationType == DeclarationType.PropertyLet
-                    || defaultMember.DeclarationType == DeclarationType.Function
-                    || defaultMember.DeclarationType == DeclarationType.Procedure;
-                bool isPublic =
-                    defaultMember.Accessibility == Accessibility.Global
-                    || defaultMember.Accessibility == Accessibility.Implicit
-                    || defaultMember.Accessibility == Accessibility.Public;
-                if (isPropertyGetLetFunctionProcedure && isPublic)
+                if (IsPropertyGetLetFunctionProcedure(defaultMember) 
+                    && IsPublic(defaultMember))
                 {
 
                     /*
@@ -216,7 +210,7 @@ declared type.
                         recursively, as if this default member was specified instead for <l-expression> with the 
                         same <argument-list>.
                     */
-                    if (((IParameterizedDeclaration)defaultMember).Parameters.Count() == 0)
+                    if (parameters.Count(parameter => !parameter.IsOptional) == 0)
                     {
                         // Recursion limit reached, abort.
                         if (DEFAULT_MEMBER_RECURSION_LIMIT == _defaultMemberRecursionLimitCounter)
@@ -245,6 +239,23 @@ declared type.
             return null;
         }
 
+        private static bool IsPropertyGetLetFunctionProcedure(Declaration declaration)
+        {
+            var declarationType = declaration.DeclarationType;
+            return declarationType == DeclarationType.PropertyGet
+                   || declarationType == DeclarationType.PropertyLet
+                   || declarationType == DeclarationType.Function
+                   || declarationType == DeclarationType.Procedure;
+        }
+
+        private static bool IsPublic(Declaration declaration)
+        {
+            var accessibility = declaration.Accessibility;
+            return accessibility == Accessibility.Global
+                   || accessibility == Accessibility.Implicit
+                   || accessibility == Accessibility.Public;
+        }
+
         private IBoundExpression ResolveLExpressionDeclaredTypeIsArray(IBoundExpression lExpression, Declaration asTypeDeclaration)
         {
             /*

Rubberduck.Parsing/TypeResolvers/SetTypeResolver.cs

@@ -145,7 +145,7 @@ private static string FullObjectTypeName(Declaration setTypeDeterminingDeclarati
                 case VBAParser.InstanceExprContext instanceExpression:
                     return SetTypeDeterminingDeclarationOfInstance(containingModule, finder);
                 case VBAParser.IndexExprContext indexExpression:
-                    throw new NotImplementedException();
+                    return SetTypeDeterminingDeclarationOfIndexExpression(indexExpression.lExpression(), containingModule, finder);
                 case VBAParser.MemberAccessExprContext memberAccessExpression:
                     return SetTypeDeterminingDeclarationOfExpression(memberAccessExpression.unrestrictedIdentifier(), containingModule, finder);
                 case VBAParser.WithMemberAccessExprContext withMemberAccessExpression:
@@ -155,12 +155,66 @@ private static string FullObjectTypeName(Declaration setTypeDeterminingDeclarati
                 case VBAParser.WithDictionaryAccessExprContext withDictionaryAccessExpression:
                     return SetTypeDeterminingDeclarationOfExpression(withDictionaryAccessExpression.dictionaryAccess(), containingModule, finder);
                 case VBAParser.WhitespaceIndexExprContext whitespaceIndexExpression:
-                    throw new NotImplementedException();
+                    return SetTypeDeterminingDeclarationOfIndexExpression(whitespaceIndexExpression.lExpression(), containingModule, finder);
                 default:
                     return (null, true);    //We should already cover every case. Return the value indicating that we have no idea.
             }
         }
 
+        private (Declaration declaration, bool mightHaveSetType) SetTypeDeterminingDeclarationOfIndexExpression(VBAParser.LExpressionContext lExpression, QualifiedModuleName containingModule, DeclarationFinder finder)
+        {
+            var declaration = ResolveIndexExpressionAsMethod(lExpression, containingModule, finder)
+                              ?? ResolveIndexExpressionAsDefaultMemberAccess(lExpression, containingModule, finder);
+                
+            if (declaration != null)
+            {
+                return (declaration, MightHaveSetType(declaration));
+            }
+
+            return ResolveIndexExpressionAsArrayAccess(lExpression, containingModule, finder);
+        }
+
+        private Declaration ResolveIndexExpressionAsMethod(VBAParser.LExpressionContext lExpression, QualifiedModuleName containingModule, DeclarationFinder finder)
+        {
+            //For functions and properties, the identifier will be at the end of the lExpression.
+            var qualifiedSelection = new QualifiedSelection(containingModule, lExpression.GetSelection().Collapse());
+            var candidate = finder
+                .ContainingIdentifierReferences(qualifiedSelection)
+                .LastOrDefault()
+                ?.Declaration;
+            return candidate?.DeclarationType.HasFlag(DeclarationType.Member) ?? false
+                ? candidate
+                : null;
+        }
+
+        private (Declaration declaration, bool mightHaveSetType) ResolveIndexExpressionAsArrayAccess(VBAParser.LExpressionContext lExpression, QualifiedModuleName containingModule, DeclarationFinder finder)
+        {
+            var (potentialArrayDeclaration, lExpressionMightHaveSetType) = SetTypeDeterminingDeclarationOfExpression(lExpression, containingModule, finder);
+
+            if (potentialArrayDeclaration == null)
+            {
+                return (null, lExpressionMightHaveSetType);
+            }
+
+            if (!potentialArrayDeclaration.IsArray)
+            {
+                //This is not an array access. So, we have no idea.
+                return (null, true);
+            }
+
+            return (potentialArrayDeclaration, MightHaveSetTypeOnArrayAccess(potentialArrayDeclaration));
+        }
+
+        private Declaration ResolveIndexExpressionAsDefaultMemberAccess(VBAParser.LExpressionContext lExpression, QualifiedModuleName containingModule, DeclarationFinder finder)
+        {
+            // A default member access references the entire lExpression.
+            var qualifiedSelection = new QualifiedSelection(containingModule, lExpression.GetSelection());
+            return finder
+                .IdentifierReferences(qualifiedSelection)
+                .FirstOrDefault(reference => reference.IsDefaultMemberAccess)
+                ?.Declaration;
+        }
+
         private (Declaration declaration, bool mightHaveSetType) SetTypeDeterminingDeclarationOfExpression(VBAParser.IdentifierContext identifier, QualifiedModuleName containingModule, DeclarationFinder finder)
         {
             var declaration = finder.IdentifierReferences(identifier, containingModule)
@@ -194,6 +248,30 @@ private static bool MightHaveSetType(Declaration declaration)
                    || declaration.DeclarationType.HasFlag(DeclarationType.ClassModule);
         }
 
+        private static bool MightHaveSetTypeOnArrayAccess(Declaration declaration)
+        {
+            return declaration == null
+                || IsObjectArray(declaration)
+                || declaration.AsTypeName == Tokens.Variant;
+        }
+
+        private static bool IsObjectArray(Declaration declaration)
+        {
+            if (!declaration.IsArray)
+            {
+                return false;
+            }
+
+            if (declaration.AsTypeName == Tokens.Object ||
+                (declaration.AsTypeDeclaration?.DeclarationType.HasFlag(DeclarationType.ClassModule) ?? false))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+
         private (Declaration declaration, bool mightHaveSetType) SetTypeDeterminingDeclarationOfInstance(QualifiedModuleName instance, DeclarationFinder finder)
         {
             var classDeclaration = finder.Classes.FirstOrDefault(cls => cls.QualifiedModuleName.Equals(instance));