Collect failed indexed default member resolutions

This also fixes various small bugs in the reference resolver. Moreover, now we actually check whether the number or arguments provided fits for index expressions.

Author: MDoerner

Rubberduck.Parsing/Binding/Bindings/DictionaryAccessDefaultBinding.cs

@@ -108,6 +108,14 @@ private static IBoundExpression CreateFailedExpression(IBoundExpression lExpress
             return failedExpr.JoinAsFailedResolution(context, argumentExpressions);
         }
 
+        private static IBoundExpression CreateFailedDefaultMemberAccessExpression(IBoundExpression lExpression, ArgumentList argumentList, ParserRuleContext context)
+        {
+            var failedExpr = new DictionaryAccessExpression(lExpression.ReferencedDeclaration, ExpressionClassification.ResolutionFailed, context, lExpression, argumentList, context);
+
+            var argumentExpressions = argumentList.Arguments.Select(arg => arg.Expression);
+            return failedExpr.JoinAsFailedResolution(context, argumentExpressions.Concat(new []{ lExpression }));
+        }
+
         private static IBoundExpression ResolveViaDefaultMember(IBoundExpression lExpression, string asTypeName, Declaration asTypeDeclaration, ArgumentList argumentList, ParserRuleContext expression, ParserRuleContext defaultMemberContext, int recursionDepth = 1, RecursiveDefaultMemberAccessExpression containedExpression = null)
         {
             if (Tokens.Variant.Equals(asTypeName, StringComparison.InvariantCultureIgnoreCase) 
@@ -132,7 +140,7 @@ The declared type of <l-expression> is Object or Variant.
                 || !IsPublic(defaultMember))
             {
                 ResolveArgumentList(null, argumentList);
-                return CreateFailedExpression(lExpression, argumentList, expression);
+                return CreateFailedDefaultMemberAccessExpression(lExpression, argumentList, expression);
             }
 
             var defaultMemberClassification = DefaultMemberClassification(defaultMember);
@@ -147,7 +155,7 @@ The declared type of <l-expression> is Object or Variant.
                     declared type.  
                 */
                 ResolveArgumentList(defaultMember, argumentList);
-                return new DictionaryAccessExpression(defaultMember, defaultMemberClassification, expression, lExpression, argumentList, defaultMemberContext, recursionDepth, containedExpression);
+                return new DictionaryAccessExpression(defaultMember, ExpressionClassification.Variable, expression, lExpression, argumentList, defaultMemberContext, recursionDepth, containedExpression);
             }
 
             if (parameters.All(param => param.IsOptional) 
@@ -162,13 +170,13 @@ declared type.
             }
 
             ResolveArgumentList(null, argumentList);
-            return CreateFailedExpression(lExpression, argumentList, expression);
+            return CreateFailedDefaultMemberAccessExpression(lExpression, argumentList, expression);
         }
 
         private static bool IsCompatibleWithOneStringArgument(List<ParameterDeclaration> parameters)
         {
             return parameters.Count > 0 
-                   && parameters.Count(param => !param.IsOptional) <= 1 
+                   && parameters.Count(param => !param.IsOptional && !param.IsParamArray) <= 1 
                    && (Tokens.String.Equals(parameters[0].AsTypeName, StringComparison.InvariantCultureIgnoreCase)
                        || Tokens.Variant.Equals(parameters[0].AsTypeName, StringComparison.InvariantCultureIgnoreCase));
         }

Rubberduck.Parsing/Binding/Bindings/IndexDefaultBinding.cs

@@ -116,21 +116,81 @@ private IBoundExpression Resolve(IBoundExpression lExpression, ArgumentList argu
                 || lExpression.Classification == ExpressionClassification.Function
                 || lExpression.Classification == ExpressionClassification.Subroutine)
             {
-                return ResolveLExpressionIsPropertyFunctionSubroutine(lExpression, argumentList, expression, defaultMemberResolutionRecursionDepth, containedExpression);
+                var procedureDeclaration = lExpression.ReferencedDeclaration as IParameterizedDeclaration;
+                var parameters = procedureDeclaration?.Parameters?.ToList();
+                if (parameters != null
+                   && ArgumentListIsCompatible(parameters, argumentList))
+                {
+                    return ResolveLExpressionIsPropertyFunctionSubroutine(lExpression, argumentList, expression, defaultMemberResolutionRecursionDepth, containedExpression);
+                }
             }
 
             ResolveArgumentList(null, argumentList);
             return CreateFailedExpression(lExpression, argumentList, expression, defaultMemberResolutionRecursionDepth > 0);
         }
 
         private static IBoundExpression CreateFailedExpression(IBoundExpression lExpression, ArgumentList argumentList, ParserRuleContext context, bool isDefaultMemberResolution)
+        {
+            if (IsFailedDefaultMemberResolution(lExpression))
+            {
+                return CreateFailedDefaultMemberAccessExpression(lExpression, argumentList, context);
+            }
+
+            return CreateResolutionFailedExpression(lExpression, argumentList, context, isDefaultMemberResolution);
+        }
+
+        private static bool IsFailedDefaultMemberResolution(IBoundExpression lExpression)
+        {
+            if (lExpression.Classification == ExpressionClassification.ResolutionFailed)
+            {
+                return false;
+            }
+
+            if (IsVariablePropertyFunctionWithoutParameters(lExpression))
+            {
+                return true;
+            }
+
+            if (lExpression is IndexExpression indexExpression)
+            {
+                var indexedDeclaration = indexExpression.ReferencedDeclaration;
+                if (indexedDeclaration != null
+                    && (!indexedDeclaration.IsArray
+                        || indexExpression.IsArrayAccess))
+                {
+                    return true;
+                }
+            }
+
+            if (lExpression is DictionaryAccessExpression dictionaryExpression)
+            {
+                var indexedDeclaration = dictionaryExpression.ReferencedDeclaration;
+                if (indexedDeclaration != null
+                    && !indexedDeclaration.IsArray)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static IBoundExpression CreateResolutionFailedExpression(IBoundExpression lExpression, ArgumentList argumentList, ParserRuleContext context, bool isDefaultMemberResolution)
         {
             var failedExpr = new ResolutionFailedExpression(context, isDefaultMemberResolution);
             failedExpr.AddSuccessfullyResolvedExpression(lExpression);
             var argumentExpressions = argumentList.Arguments.Select(arg => arg.Expression);
             return failedExpr.JoinAsFailedResolution(context, argumentExpressions);
         }
 
+        private static IBoundExpression CreateFailedDefaultMemberAccessExpression(IBoundExpression lExpression, ArgumentList argumentList, ParserRuleContext context)
+        {
+            var failedExpr = new IndexExpression(lExpression.ReferencedDeclaration, ExpressionClassification.ResolutionFailed, context, lExpression, argumentList, isDefaultMemberAccess: true);
+
+            var argumentExpressions = argumentList.Arguments.Select(arg => arg.Expression);
+            return failedExpr.JoinAsFailedResolution(context, argumentExpressions.Concat(new[] { lExpression }));
+        }
+
         private IBoundExpression ResolveLExpressionIsVariablePropertyFunctionNoParameters(IBoundExpression lExpression, ArgumentList argumentList, ParserRuleContext expression, int defaultMemberResolutionRecursionDepth, RecursiveDefaultMemberAccessExpression containedExpression)
         {
             /*
@@ -147,7 +207,7 @@ with a parameter list that cannot accept any parameters and an <argument-list> t
                 return null;
             }
 
-            if (indexedDeclaration.IsArray)
+            if (indexedDeclaration.IsArray && !(lExpression is IndexExpression indexExpression && indexExpression.IsArrayAccess))
             {
                 return ResolveLExpressionDeclaredTypeIsArray(lExpression.ReferencedDeclaration, lExpression.Classification, argumentList, expression, defaultMemberResolutionRecursionDepth, containedExpression);
             }
@@ -257,7 +317,7 @@ declared type.
                 if (ArgumentListIsCompatible(parameters, argumentList))
                 {
                     ResolveArgumentList(defaultMember, argumentList);
-                    return new IndexExpression(defaultMember, defaultMemberClassification, expression, _lExpression, argumentList, isDefaultMemberAccess: true, defaultMemberRecursionDepth: defaultMemberResolutionRecursionDepth, containedDefaultMemberRecursionExpression: containedExpression);
+                    return new IndexExpression(defaultMember, ExpressionClassification.Variable, expression, _lExpression, argumentList, isDefaultMemberAccess: true, defaultMemberRecursionDepth: defaultMemberResolutionRecursionDepth, containedDefaultMemberRecursionExpression: containedExpression);
                 }
 
                 /**
@@ -279,7 +339,7 @@ private static bool ArgumentListIsCompatible(ICollection<ParameterDeclaration> p
         {
             return (parameters.Count >= (argumentList?.Arguments.Count ?? 0) 
                         || parameters.Any(parameter => parameter.IsParamArray))
-                    && parameters.Count(parameter => !parameter.IsOptional) <= (argumentList?.Arguments.Count ?? 0);
+                    && parameters.Count(parameter => !parameter.IsOptional && !parameter.IsParamArray) <= (argumentList?.Arguments.Count ?? 0);
         }
 
         private IBoundExpression ResolveRecursiveDefaultMember(Declaration defaultMember, ExpressionClassification defaultMemberClassification, ArgumentList argumentList, ParserRuleContext expression, int defaultMemberResolutionRecursionDepth, RecursiveDefaultMemberAccessExpression containedExpression)
@@ -375,10 +435,10 @@ classification and declared type.
                     list>. In this case, the index expression references <l-expression> and takes on its classification 
                     and declared type.   
 
-                    Note: We assume compatibility through enforcement by the VBE.
+                    Note: Apart from a check of the number of arguments provided, we assume compatibility through enforcement by the VBE.
              */
             ResolveArgumentList(lExpression.ReferencedDeclaration, argumentList);
-            return new IndexExpression(lExpression.ReferencedDeclaration, lExpression.Classification, expression, _lExpression, argumentList, defaultMemberRecursionDepth: defaultMemberRecursionDepth, containedDefaultMemberRecursionExpression: containedExpression);
+            return new IndexExpression(lExpression.ReferencedDeclaration, ExpressionClassification.Variable, expression, _lExpression, argumentList, defaultMemberRecursionDepth: defaultMemberRecursionDepth, containedDefaultMemberRecursionExpression: containedExpression);
         }
 
         private IBoundExpression ResolveLExpressionIsUnbound(IBoundExpression lExpression, ArgumentList argumentList, ParserRuleContext expression, int defaultMemberResolutionRecursionDepth, RecursiveDefaultMemberAccessExpression containedExpression)

Rubberduck.Parsing/Binding/Bindings/LetCoercionDefaultBinding.cs

@@ -117,7 +117,7 @@ private static IBoundExpression ResolveViaDefaultMember(IBoundExpression wrapped
                 return new LetCoercionDefaultMemberAccessExpression(defaultMember, defaultMemberClassification, expression, wrappedExpression, recursionDepth, containedExpression);
             }
 
-            if (parameters.All(parameter => parameter.IsOptional))
+            if (parameters.All(parameter => parameter.IsOptional || parameter.IsParamArray))
             {
                 if (!defaultMember.IsObject)
                 {

Rubberduck.Parsing/Binding/Bindings/ProcedureCoercionDefaultBinding.cs

@@ -10,27 +10,32 @@ public sealed class ProcedureCoercionDefaultBinding : IExpressionBinding
     {
         private readonly ParserRuleContext _expression;
         private readonly IExpressionBinding _wrappedExpressionBinding;
+        private readonly bool _hasExplicitCall;
         private IBoundExpression _wrappedExpression;
 
         //This is a wrapper used to model procedure coercion in call statements without arguments.
         //The one with arguments is basically an index expression and uses its binding.
 
         public ProcedureCoercionDefaultBinding(
             ParserRuleContext expression,
-            IExpressionBinding wrappedExpressionBinding)
+            IExpressionBinding wrappedExpressionBinding,
+            bool hasExplicitCall)
             : this(
                 expression,
-                (IBoundExpression)null)
+                (IBoundExpression)null,
+                hasExplicitCall)
         {
             _wrappedExpressionBinding = wrappedExpressionBinding;
         }
 
         public ProcedureCoercionDefaultBinding(
             ParserRuleContext expression,
-            IBoundExpression wrappedExpression)
+            IBoundExpression wrappedExpression,
+            bool hasExplicitCall)
         {
             _expression = expression;
             _wrappedExpression = wrappedExpression;
+            _hasExplicitCall = hasExplicitCall;
         }
 
         public IBoundExpression Resolve()
@@ -40,10 +45,10 @@ public IBoundExpression Resolve()
                 _wrappedExpression = _wrappedExpressionBinding.Resolve();
             }
 
-            return Resolve(_wrappedExpression, _expression);
+            return Resolve(_wrappedExpression, _expression, _hasExplicitCall);
         }
 
-        private static IBoundExpression Resolve(IBoundExpression wrappedExpression, ParserRuleContext expression)
+        private static IBoundExpression Resolve(IBoundExpression wrappedExpression, ParserRuleContext expression, bool hasExplicitCall)
         {
             //Procedure coercion only happens for expressions classified as variables.
             if (wrappedExpression.Classification != ExpressionClassification.Variable)
@@ -55,8 +60,8 @@ private static IBoundExpression Resolve(IBoundExpression wrappedExpression, Pars
             if (wrappedDeclaration == null
                 || !wrappedDeclaration.IsObject
                     && !(wrappedDeclaration.IsObjectArray
-                        && wrappedExpression is IndexExpression indexExpression
-                        && indexExpression.IsArrayAccess))
+                        && wrappedExpression is IndexExpression arrayExpression
+                        && arrayExpression.IsArrayAccess))
             {
                 return wrappedExpression;
             }
@@ -66,6 +71,15 @@ private static IBoundExpression Resolve(IBoundExpression wrappedExpression, Pars
             var asTypeName = wrappedDeclaration.AsTypeName;
             var asTypeDeclaration = wrappedDeclaration.AsTypeDeclaration;
 
+            //If there is an explicit call, a non-array (access) index expression or dictionary access expression already count as procedure call.
+            if (hasExplicitCall
+                && (wrappedExpression is IndexExpression indexExpression 
+                        && !indexExpression.IsArrayAccess
+                    || wrappedExpression is DictionaryAccessExpression))
+            {
+                return wrappedExpression;
+            }
+
             return ResolveViaDefaultMember(wrappedExpression, asTypeName, asTypeDeclaration, expression);
         }
 
@@ -94,7 +108,7 @@ private static IBoundExpression ResolveViaDefaultMember(IBoundExpression wrapped
             var defaultMemberClassification = DefaultMemberClassification(defaultMember);
 
             var parameters = ((IParameterizedDeclaration)defaultMember).Parameters.ToList();
-            if (parameters.All(parameter => parameter.IsOptional))
+            if (parameters.All(parameter => parameter.IsOptional || parameter.IsParamArray))
             {
                 //We found some default member accepting the empty argument list. So, we are done.
                 return new ProcedureCoercionExpression(defaultMember, defaultMemberClassification, expression, wrappedExpression);

Rubberduck.Parsing/Binding/DefaultBindingContext.cs

@@ -69,9 +69,11 @@ private IExpressionBinding Visit(Declaration module, Declaration parent, VBAPars
                 {
                     return new IndexDefaultBinding(expression.lExpression(), lExpressionBinding, argList);
                 }
+
+                return new ProcedureCoercionDefaultBinding(expression.lExpression(), lExpressionBinding, false);
             }
 
-            return new ProcedureCoercionDefaultBinding(expression.lExpression(), lExpressionBinding);
+            return new ProcedureCoercionDefaultBinding(expression.lExpression(), lExpressionBinding, true);
         }
 
         private static void SetLeftMatch(IExpressionBinding binding, int argumentCount)

Rubberduck.Parsing/VBA/ReferenceManagement/BoundExpressionVisitor.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using Rubberduck.Parsing.Annotations;
 using Rubberduck.Parsing.Binding;
 using Rubberduck.Parsing.Symbols;