Deal with missing arguments when resolving argument references

MDoerner · MDoerner · commit 6c704675a1b7 · 2019-09-01T22:57:18.000+02:00
diff --git a/Rubberduck.CodeAnalysis/Inspections/Concrete/ArgumentWithIncompatibleObjectTypeInspection.cs b/Rubberduck.CodeAnalysis/Inspections/Concrete/ArgumentWithIncompatibleObjectTypeInspection.cs
@@ -127,7 +127,8 @@ private static bool ToBeConsidered(Declaration declaration)
 
         private string ArgumentSetTypeName(IdentifierReference argumentReference, DeclarationFinder finder)
         {
-            return SetTypeNameOfExpression((VBAParser.ExpressionContext)argumentReference.Context, argumentReference.QualifiedModuleName, finder);
+            var argumentExpression = argumentReference.Context as VBAParser.ExpressionContext;
+            return SetTypeNameOfExpression(argumentExpression, argumentReference.QualifiedModuleName, finder);
         }
 
         private string SetTypeNameOfExpression(VBAParser.ExpressionContext expression, QualifiedModuleName containingModule, DeclarationFinder finder)
diff --git a/Rubberduck.Parsing/Binding/ArgumentListArgument.cs b/Rubberduck.Parsing/Binding/ArgumentListArgument.cs
@@ -42,6 +42,7 @@ public void Resolve(Declaration calledProcedure, int parameterIndex, bool isArra
                 ReferencedParameter = ResolveReferencedParameter(calledProcedure, parameterIndex);
 
                 if (!_isAddressOfArgument 
+                    && !(Context is VBAParser.MissingArgumentContext)
                     && (isArrayAccess 
                         ||  ReferencedParameter != null 
                             && !CanBeObject(ReferencedParameter)))
diff --git a/Rubberduck.Parsing/Binding/ArgumentListArgumentType.cs b/Rubberduck.Parsing/Binding/ArgumentListArgumentType.cs
@@ -3,6 +3,7 @@
     public enum ArgumentListArgumentType
     {
         Positional,
-        Named
+        Named,
+        Missing
     }
 }
diff --git a/Rubberduck.Parsing/Binding/Bindings/MissingArgumentBinding.cs b/Rubberduck.Parsing/Binding/Bindings/MissingArgumentBinding.cs
@@ -0,0 +1,21 @@
+﻿using Antlr4.Runtime;
+using Rubberduck.Parsing.Symbols;
+
+namespace Rubberduck.Parsing.Binding
+{
+    public sealed class MissingArgumentBinding : IExpressionBinding
+    {
+        private readonly Declaration _parent;
+        private readonly ParserRuleContext _missingArgumentContext;
+
+        public MissingArgumentBinding(ParserRuleContext missingArgumentContext)
+        {
+            _missingArgumentContext = missingArgumentContext;
+        }
+
+        public IBoundExpression Resolve()
+        {
+            return new MissingArgumentExpression(ExpressionClassification.Variable, _missingArgumentContext);
+        }
+    }
+}
diff --git a/Rubberduck.Parsing/Binding/DefaultBindingContext.cs b/Rubberduck.Parsing/Binding/DefaultBindingContext.cs
@@ -255,6 +255,16 @@ private ArgumentList VisitArgumentList(Declaration module, Declaration parent, V
                             CreateNamedArgumentExpressionCreator(expr.namedArgument().unrestrictedIdentifier().GetText(), expr.namedArgument().unrestrictedIdentifier()),
                             isAddressOfArgument));
                     }
+                    else if(expr.missingArgument() != null)
+                    {
+                        var missingArgumentContext = expr.missingArgument();
+                        var binding = new MissingArgumentBinding(missingArgumentContext);
+                        convertedList.AddArgument(new ArgumentListArgument(
+                            binding,
+                            missingArgumentContext,
+                            ArgumentListArgumentType.Missing,
+                            false));
+                    }
                 }
             }
             return convertedList;
diff --git a/Rubberduck.Parsing/Binding/Expressions/DictionaryAccessExpression.cs b/Rubberduck.Parsing/Binding/Expressions/DictionaryAccessExpression.cs
@@ -1,5 +1,4 @@
 ﻿using Antlr4.Runtime;
-using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Symbols;
 
 namespace Rubberduck.Parsing.Binding
diff --git a/Rubberduck.Parsing/Binding/Expressions/MissingArgumentExpression.cs b/Rubberduck.Parsing/Binding/Expressions/MissingArgumentExpression.cs
@@ -0,0 +1,13 @@
+﻿using Antlr4.Runtime;
+
+namespace Rubberduck.Parsing.Binding
+{
+    public sealed class MissingArgumentExpression : BoundExpression
+    {
+        public MissingArgumentExpression(
+            ExpressionClassification classification,
+            ParserRuleContext context)
+            : base(null, classification, context)
+        {}
+    }
+}
diff --git a/Rubberduck.Parsing/TypeResolvers/SetTypeResolver.cs b/Rubberduck.Parsing/TypeResolvers/SetTypeResolver.cs
@@ -22,6 +22,11 @@ public SetTypeResolver(IDeclarationFinderProvider declarationFinderProvider)
 
         public Declaration SetTypeDeclaration(VBAParser.ExpressionContext expression, QualifiedModuleName containingModule)
         {
+            if (expression == null)
+            {
+                return null;
+            }
+
             switch (expression)
             {
                 case VBAParser.LExprContext lExpression:
@@ -53,6 +58,11 @@ private Declaration SetTypeDeclaration(Declaration setTypeDeterminingDeclaration
 
         public string SetTypeName(VBAParser.ExpressionContext expression, QualifiedModuleName containingModule)
         {
+            if (expression == null)
+            {
+                return null;
+            }
+
             switch (expression)
             {
                 case VBAParser.LExprContext lExpression:
diff --git a/Rubberduck.Parsing/VBA/ReferenceManagement/BoundExpressionVisitor.cs b/Rubberduck.Parsing/VBA/ReferenceManagement/BoundExpressionVisitor.cs
@@ -87,6 +87,8 @@ private void Visit(
                 case ProcedureCoercionExpression procedureCoercionExpression:
                     Visit(procedureCoercionExpression, module, scope, parent);
                     break;
+                case MissingArgumentExpression missingArgumentExpression:
+                    break;
                 default:
                     throw new NotSupportedException($"Unexpected bound expression type {boundExpression.GetType()}");
             }
diff --git a/Rubberduck.Parsing/VBA/ReferenceManagement/FailedResolutionVisitor.cs b/Rubberduck.Parsing/VBA/ReferenceManagement/FailedResolutionVisitor.cs
@@ -70,6 +70,8 @@ private void Visit(IBoundExpression boundExpression, Declaration parent, IBoundE
                 case ProcedureCoercionExpression procedureCoercionExpression:
                     Visit(procedureCoercionExpression, parent, withExpression);
                     break;
+                case MissingArgumentExpression missingArgumentExpression:
+                    break;
                 default:
                     throw new NotSupportedException($"Unexpected bound expression type {boundExpression.GetType()}");
             }
diff --git a/RubberduckTests/Grammar/ResolverTests.cs b/RubberduckTests/Grammar/ResolverTests.cs
@@ -5186,6 +5186,7 @@ End Sub
         [TestCase("arg2:=42, arg1:=a+b", "arg1", "a+b")]
         [TestCase("42, a+b, (\"Hello\" & 42)", "arg3", "(\"Hello\" & 42)")]
         [TestCase("42, a+b, (\"Hello\" & 42), 15+2", "furtherArgs", "15+2")]
+        [TestCase("42, a+b, , (\"Hello\" & 42), 15+2", "arg3", "")]
         public void CorrectArgumentReferencesOnMethodAccess(string arguments, string parameterName, string expectedExpressionText)
         {
             var class1Code = @"
diff --git a/RubberduckTests/Inspections/ArgumentWithIncompatibleObjectTypeInspectionTests.cs b/RubberduckTests/Inspections/ArgumentWithIncompatibleObjectTypeInspectionTests.cs
@@ -120,6 +120,46 @@ End Sub
             Assert.IsFalse(inspectionResults.Any());
         }
 
+        [Test]
+        [Category("Inspections")]
+        public void MissingOptionalArgument_NoResult()
+        {
+            const string interface1 =
+                @"
+Private Sub Foo() 
+End Sub
+";
+            const string class1 =
+                @"Implements Interface1
+
+Private Sub Interface1_Foo()
+End Sub
+";
+
+            const string module1 =
+                @"
+Private Sub DoIt()
+    Bar  , Nothing
+End Sub
+
+Private Sub Bar(Optional baz As Class1 = Nothing, Optional bazBaz As Class1 = Nothing)
+End Sub
+";
+
+            var vbe = new MockVbeBuilder()
+                .ProjectBuilder("TestProject", ProjectProtection.Unprotected)
+                .AddComponent("Class1", ComponentType.ClassModule, class1)
+                .AddComponent("Interface1", ComponentType.ClassModule, interface1)
+                .AddComponent("Module1", ComponentType.StandardModule, module1)
+                .AddProjectToVbeBuilder()
+                .Build()
+                .Object;
+
+            var inspectionResults = InspectionResults(vbe).ToList();
+
+            Assert.IsFalse(inspectionResults.Any());
+        }
+
         private static IEnumerable<IInspectionResult> InspectionResults(params (string moduleName, string content, ComponentType componentType)[] testModules)
         {
             var vbe = MockVbeBuilder.BuildFromModules(testModules).Object;

Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,8 @@ private static bool ToBeConsidered(Declaration declaration)`
`127`	`127`
`128`	`128`	`private string ArgumentSetTypeName(IdentifierReference argumentReference, DeclarationFinder finder)`
`129`	`129`	`{`
`130`		`- return SetTypeNameOfExpression((VBAParser.ExpressionContext)argumentReference.Context, argumentReference.QualifiedModuleName, finder);`
	`130`	`+ var argumentExpression = argumentReference.Context as VBAParser.ExpressionContext;`
	`131`	`+ return SetTypeNameOfExpression(argumentExpression, argumentReference.QualifiedModuleName, finder);`
`131`	`132`	`}`
`132`	`133`
`133`	`134`	`private string SetTypeNameOfExpression(VBAParser.ExpressionContext expression, QualifiedModuleName containingModule, DeclarationFinder finder)`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`public enum ArgumentListArgumentType`
`4`	`4`	`{`
`5`	`5`	`Positional,`
`6`		`- Named`
	`6`	`+ Named,`
	`7`	`+ Missing`
`7`	`8`	`}`
`8`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -255,6 +255,16 @@ private ArgumentList VisitArgumentList(Declaration module, Declaration parent, V`
`255`	`255`	`CreateNamedArgumentExpressionCreator(expr.namedArgument().unrestrictedIdentifier().GetText(), expr.namedArgument().unrestrictedIdentifier()),`
`256`	`256`	`isAddressOfArgument));`
`257`	`257`	`}`
	`258`	`+ else if(expr.missingArgument() != null)`
	`259`	`+ {`
	`260`	`+ var missingArgumentContext = expr.missingArgument();`
	`261`	`+ var binding = new MissingArgumentBinding(missingArgumentContext);`
	`262`	`+ convertedList.AddArgument(new ArgumentListArgument(`
	`263`	`+ binding,`
	`264`	`+ missingArgumentContext,`
	`265`	`+ ArgumentListArgumentType.Missing,`
	`266`	`+ false));`
	`267`	`+ }`
`258`	`268`	`}`
`259`	`269`	`}`
`260`	`270`	`return convertedList;`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`using Antlr4.Runtime;`
`2`		`-using Rubberduck.Parsing.Grammar;`
`3`	`2`	`using Rubberduck.Parsing.Symbols;`
`4`	`3`
`5`	`4`	`namespace Rubberduck.Parsing.Binding`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,11 @@ public SetTypeResolver(IDeclarationFinderProvider declarationFinderProvider)`
`22`	`22`
`23`	`23`	`public Declaration SetTypeDeclaration(VBAParser.ExpressionContext expression, QualifiedModuleName containingModule)`
`24`	`24`	`{`
	`25`	`+ if (expression == null)`
	`26`	`+ {`
	`27`	`+ return null;`
	`28`	`+ }`
	`29`	`+`
`25`	`30`	`switch (expression)`
`26`	`31`	`{`
`27`	`32`	`case VBAParser.LExprContext lExpression:`
`@@ -53,6 +58,11 @@ private Declaration SetTypeDeclaration(Declaration setTypeDeterminingDeclaration`
`53`	`58`
`54`	`59`	`public string SetTypeName(VBAParser.ExpressionContext expression, QualifiedModuleName containingModule)`
`55`	`60`	`{`
	`61`	`+ if (expression == null)`
	`62`	`+ {`
	`63`	`+ return null;`
	`64`	`+ }`
	`65`	`+`
`56`	`66`	`switch (expression)`
`57`	`67`	`{`
`58`	`68`	`case VBAParser.LExprContext lExpression:`
Original file line number	Diff line number	Diff line change
`@@ -87,6 +87,8 @@ private void Visit(`
`87`	`87`	`case ProcedureCoercionExpression procedureCoercionExpression:`
`88`	`88`	`Visit(procedureCoercionExpression, module, scope, parent);`
`89`	`89`	`break;`
	`90`	`+ case MissingArgumentExpression missingArgumentExpression:`
	`91`	`+ break;`
`90`	`92`	`default:`
`91`	`93`	`throw new NotSupportedException($"Unexpected bound expression type {boundExpression.GetType()}");`
`92`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -70,6 +70,8 @@ private void Visit(IBoundExpression boundExpression, Declaration parent, IBoundE`
`70`	`70`	`case ProcedureCoercionExpression procedureCoercionExpression:`
`71`	`71`	`Visit(procedureCoercionExpression, parent, withExpression);`
`72`	`72`	`break;`
	`73`	`+ case MissingArgumentExpression missingArgumentExpression:`
	`74`	`+ break;`
`73`	`75`	`default:`
`74`	`76`	`throw new NotSupportedException($"Unexpected bound expression type {boundExpression.GetType()}");`
`75`	`77`	`}`