Merge pull request #4924 from MDoerner/MakeResolverNonDynamic

retailcoder · web-flow · commit 7a21154f73c2 · 2019-04-20T11:58:22.000-04:00
Removes dymanic bindings from resolver.
diff --git a/Rubberduck.Core/Navigation/RegexSearchReplace/RegexSearchReplace.cs b/Rubberduck.Core/Navigation/RegexSearchReplace/RegexSearchReplace.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
+using Antlr4.Runtime;
 using Rubberduck.Common;
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.Symbols;
@@ -137,7 +138,15 @@ private List<RegexSearchResult> SearchCurrentBlock(string searchPattern)
                     var results = GetResultsFromModule(module, searchPattern);
 
                     var qualifiedSelection = pane.GetQualifiedSelection();
-                    dynamic block = state.AllDeclarations.FindTarget(qualifiedSelection.Value, declarationTypes).Context
+
+                    if (!qualifiedSelection.HasValue)
+                    {
+                        return new List<RegexSearchResult>();
+                    }
+
+                    var block = (ParserRuleContext)state.AllDeclarations
+                        .FindTarget(qualifiedSelection.Value, declarationTypes)
+                        .Context
                         .Parent;
                     var selection = new Selection(block.Start.Line, block.Start.Column, block.Stop.Line,
                         block.Stop.Column);
diff --git a/Rubberduck.Parsing/Binding/BindingService.cs b/Rubberduck.Parsing/Binding/BindingService.cs
@@ -42,8 +42,7 @@ public IBoundExpression ResolveDefault(Declaration module, Declaration parent, P
         public IBoundExpression ResolveType(Declaration module, Declaration parent, ParserRuleContext expression)
         {
             var context = expression;
-            var opContext = expression as VBAParser.RelationalOpContext;
-            if (opContext != null && opContext.Parent is VBAParser.ComplexTypeContext)
+            if (context is VBAParser.RelationalOpContext opContext && opContext.Parent is VBAParser.ComplexTypeContext)
             {
                 context = opContext.GetChild<VBAParser.LExprContext>(0);
             }
diff --git a/Rubberduck.Parsing/Binding/DefaultBindingContext.cs b/Rubberduck.Parsing/Binding/DefaultBindingContext.cs
diff --git a/Rubberduck.Parsing/Binding/Expressions/IndexExpression.cs b/Rubberduck.Parsing/Binding/Expressions/IndexExpression.cs
@@ -5,9 +5,6 @@ namespace Rubberduck.Parsing.Binding
 {
     public sealed class IndexExpression : BoundExpression
     {
-        private readonly IBoundExpression _lExpression;
-        private readonly ArgumentList _argumentList;
-
         public IndexExpression(
             Declaration referencedDeclaration, 
             ExpressionClassification classification, 
@@ -16,24 +13,11 @@ public IndexExpression(
             ArgumentList argumentList)
             : base(referencedDeclaration, classification, context)
         {
-            _lExpression = lExpression;
-            _argumentList = argumentList;
-        }
-
-        public IBoundExpression LExpression
-        {
-            get
-            {
-                return _lExpression;
-            }
+            LExpression = lExpression;
+            ArgumentList = argumentList;
         }
 
-        public ArgumentList ArgumentList
-        {
-            get
-            {
-                return _argumentList;
-            }
-        }
+        public IBoundExpression LExpression { get; }
+        public ArgumentList ArgumentList { get; }
     }
 }
diff --git a/Rubberduck.Parsing/Binding/Expressions/MemberAccessExpression.cs b/Rubberduck.Parsing/Binding/Expressions/MemberAccessExpression.cs
@@ -5,9 +5,6 @@ namespace Rubberduck.Parsing.Binding
 {
     public sealed class MemberAccessExpression : BoundExpression
     {
-        private readonly IBoundExpression _lExpression;
-        private readonly ParserRuleContext _unrestrictedNameContext;
-
         public MemberAccessExpression(
             Declaration referencedDeclaration, 
             ExpressionClassification classification, 
@@ -16,24 +13,11 @@ public MemberAccessExpression(
             IBoundExpression lExpression)
             : base(referencedDeclaration, classification, context)
         {
-            _lExpression = lExpression;
-            _unrestrictedNameContext = unrestrictedNameContext;
-        }
-
-        public IBoundExpression LExpression
-        {
-            get
-            {
-                return _lExpression;
-            }
+            LExpression = lExpression;
+            UnrestrictedNameContext = unrestrictedNameContext;
         }
 
-        public ParserRuleContext UnrestrictedNameContext
-        {
-            get
-            {
-                return _unrestrictedNameContext;
-            }
-        }
+        public IBoundExpression LExpression { get; }
+        public ParserRuleContext UnrestrictedNameContext { get; }
     }
 }
diff --git a/Rubberduck.Parsing/Binding/Expressions/NewExpression.cs b/Rubberduck.Parsing/Binding/Expressions/NewExpression.cs
@@ -5,24 +5,16 @@ namespace Rubberduck.Parsing.Binding
 {
     public sealed class NewExpression : BoundExpression
     {
-        private readonly IBoundExpression _typeExpression;
-
         public NewExpression(
             Declaration referencedDeclaration,
             ParserRuleContext context,
             IBoundExpression typeExpression)
             // Marked as Variable instead of Value to integrate into rest of binding process.
             : base(referencedDeclaration, ExpressionClassification.Variable, context)
         {
-            _typeExpression = typeExpression;
+            TypeExpression = typeExpression;
         }
 
-        public IBoundExpression TypeExpression
-        {
-            get
-            {
-                return _typeExpression;
-            }
-        }
+        public IBoundExpression TypeExpression { get; }
     }
 }
diff --git a/Rubberduck.Parsing/Binding/Expressions/ParenthesizedExpression.cs b/Rubberduck.Parsing/Binding/Expressions/ParenthesizedExpression.cs
@@ -5,23 +5,15 @@ namespace Rubberduck.Parsing.Binding
 {
     public sealed class ParenthesizedExpression : BoundExpression
     {
-        private readonly IBoundExpression _expression;
-
         public ParenthesizedExpression(
             Declaration referencedDeclaration,
             ParserRuleContext context,
             IBoundExpression expression)
             : base(referencedDeclaration, ExpressionClassification.Value, context)
         {
-            _expression = expression;
+            Expression = expression;
         }
 
-        public IBoundExpression Expression
-        {
-            get
-            {
-                return _expression;
-            }
-        }
+        public IBoundExpression Expression { get; }
     }
 }
diff --git a/Rubberduck.Parsing/Binding/Expressions/ResolutionFailedExpression.cs b/Rubberduck.Parsing/Binding/Expressions/ResolutionFailedExpression.cs
@@ -8,17 +8,9 @@ public sealed class ResolutionFailedExpression : BoundExpression
 
         public ResolutionFailedExpression()
             : base(null, ExpressionClassification.ResolutionFailed, null)
-        {
-            _successfullyResolvedExpressions = new List<IBoundExpression>();
-        }
+        {}
 
-        public IReadOnlyList<IBoundExpression> SuccessfullyResolvedExpressions
-        {
-            get
-            {
-                return _successfullyResolvedExpressions;
-            }
-        }
+        public IReadOnlyList<IBoundExpression> SuccessfullyResolvedExpressions => _successfullyResolvedExpressions;
 
         public void AddSuccessfullyResolvedExpression(IBoundExpression expression)
         {
diff --git a/Rubberduck.Parsing/Binding/Expressions/TypeOfIsExpression.cs b/Rubberduck.Parsing/Binding/Expressions/TypeOfIsExpression.cs
@@ -5,34 +5,18 @@ namespace Rubberduck.Parsing.Binding
 {
     public sealed class TypeOfIsExpression : BoundExpression
     {
-        private readonly IBoundExpression _expression;
-        private readonly IBoundExpression _typeExpression;
-
         public TypeOfIsExpression(
             Declaration referencedDeclaration,
             ParserRuleContext context,
             IBoundExpression expression,
             IBoundExpression typeExpression)
             : base(referencedDeclaration, ExpressionClassification.Value, context)
         {
-            _expression = expression;
-            _typeExpression = typeExpression;
-        }
-
-        public IBoundExpression Expression
-        {
-            get
-            {
-                return _expression;
-            }
+            Expression = expression;
+            TypeExpression = typeExpression;
         }
 
-        public IBoundExpression TypeExpression
-        {
-            get
-            {
-                return _typeExpression;
-            }
-        }
+        public IBoundExpression Expression { get; }
+        public IBoundExpression TypeExpression { get; }
     }
 }
diff --git a/Rubberduck.Parsing/Binding/Expressions/UnaryOpExpression.cs b/Rubberduck.Parsing/Binding/Expressions/UnaryOpExpression.cs
@@ -5,23 +5,15 @@ namespace Rubberduck.Parsing.Binding
 {
     public sealed class UnaryOpExpression : BoundExpression
     {
-        private readonly IBoundExpression _expr;
-
         public UnaryOpExpression(
             Declaration referencedDeclaration,
             ParserRuleContext context,
             IBoundExpression expr)
             : base(referencedDeclaration, ExpressionClassification.Value, context)
         {
-            _expr = expr;
+            Expr = expr;
         }
 
-        public IBoundExpression Expr
-        {
-            get
-            {
-                return _expr;
-            }
-        }
+        public IBoundExpression Expr { get; }
     }
 }
diff --git a/Rubberduck.Parsing/Binding/IBindingContext.cs b/Rubberduck.Parsing/Binding/IBindingContext.cs
@@ -1,11 +1,11 @@
-﻿using Antlr4.Runtime;
+﻿using Antlr4.Runtime.Tree;
 using Rubberduck.Parsing.Symbols;
 
 namespace Rubberduck.Parsing.Binding
 {
     public interface IBindingContext
     {
-        IBoundExpression Resolve(Declaration module, Declaration parent, ParserRuleContext expression, IBoundExpression withBlockVariable, StatementResolutionContext statementContext);
-        IExpressionBinding BuildTree(Declaration module, Declaration parent, ParserRuleContext expression, IBoundExpression withBlockVariable, StatementResolutionContext statementContext);
+        IBoundExpression Resolve(Declaration module, Declaration parent, IParseTree expression, IBoundExpression withBlockVariable, StatementResolutionContext statementContext);
+        IExpressionBinding BuildTree(Declaration module, Declaration parent, IParseTree expression, IBoundExpression withBlockVariable, StatementResolutionContext statementContext);
     }
 }
diff --git a/Rubberduck.Parsing/Binding/ProcedurePointerBindingContext.cs b/Rubberduck.Parsing/Binding/ProcedurePointerBindingContext.cs
@@ -1,4 +1,5 @@
-﻿using Antlr4.Runtime;
+﻿using System;
+using Antlr4.Runtime.Tree;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA.DeclarationCaching;
@@ -14,7 +15,7 @@ public ProcedurePointerBindingContext(DeclarationFinder declarationFinder)
             _declarationFinder = declarationFinder;
         }
 
-        public IBoundExpression Resolve(Declaration module, Declaration parent, ParserRuleContext expression, IBoundExpression withBlockVariable, StatementResolutionContext statementContext)
+        public IBoundExpression Resolve(Declaration module, Declaration parent, IParseTree expression, IBoundExpression withBlockVariable, StatementResolutionContext statementContext)
         {
             IExpressionBinding bindingTree = BuildTree(module, parent, expression, withBlockVariable, statementContext);
             if (bindingTree != null)
@@ -24,26 +25,48 @@ public IBoundExpression Resolve(Declaration module, Declaration parent, ParserRu
             return null;
         }
 
-        public IExpressionBinding BuildTree(Declaration module, Declaration parent, ParserRuleContext expression, IBoundExpression withBlockVariable, StatementResolutionContext statementContext)
+        public IExpressionBinding BuildTree(Declaration module, Declaration parent, IParseTree expression, IBoundExpression withBlockVariable, StatementResolutionContext statementContext)
         {
-            dynamic dynamicExpression = expression;
-            return Visit(module, parent, dynamicExpression);
+            switch (expression)
+            {
+                case VBAParser.LExpressionContext lExpressionContext:
+                    return Visit(module, parent, lExpressionContext);
+                case VBAParser.ExpressionContext expressionContext:
+                    return Visit(module, parent, expressionContext);
+                case VBAParser.AddressOfExpressionContext addressOfExpressionContext:
+                    return Visit(module, parent, addressOfExpressionContext);
+                default:
+                    throw new NotSupportedException($"Unexpected context type {expression.GetType()}");
+            }
         }
 
-        private IExpressionBinding Visit(Declaration module, Declaration parent, VBAParser.ExpressionContext expression)
+        private IExpressionBinding Visit(Declaration module, Declaration parent, VBAParser.AddressOfExpressionContext expression)
         {
-            return Visit(module, parent, (dynamic)expression);
+            return Visit(module, parent, expression.expression());
         }
 
-        private IExpressionBinding Visit(Declaration module, Declaration parent, VBAParser.AddressOfExpressionContext expression)
+        private IExpressionBinding Visit(Declaration module, Declaration parent, VBAParser.ExpressionContext expression)
         {
-            return Visit(module, parent, (dynamic)expression.expression());
+            switch (expression)
+            {
+                case VBAParser.LExprContext lExprContext:
+                    return Visit(module, parent, lExprContext.lExpression());
+                default:
+                    throw new NotSupportedException($"Unexpected expression type {expression.GetType()}");
+            }
         }
 
-        private IExpressionBinding Visit(Declaration module, Declaration parent, VBAParser.LExprContext expression)
+        private IExpressionBinding Visit(Declaration module, Declaration parent, VBAParser.LExpressionContext expression)
         {
-            dynamic lexpr = expression.lExpression();
-            return Visit(module, parent, lexpr);
+            switch (expression)
+            {
+                case VBAParser.SimpleNameExprContext simpleNameExprContext:
+                    return Visit(module, parent, simpleNameExprContext);
+                case VBAParser.MemberAccessExprContext memberAccessExprContext:
+                    return Visit(module, parent, memberAccessExprContext);
+                default:
+                    throw new NotSupportedException($"Unexpected lExpression type {expression.GetType()}");
+            }
         }
 
         private IExpressionBinding Visit(Declaration module, Declaration parent, VBAParser.SimpleNameExprContext expression)
@@ -53,7 +76,7 @@ private IExpressionBinding Visit(Declaration module, Declaration parent, VBAPars
 
         private IExpressionBinding Visit(Declaration module, Declaration parent, VBAParser.MemberAccessExprContext expression)
         {
-            dynamic lExpression = expression.lExpression();
+            var lExpression = expression.lExpression();
             var lExpressionBinding = Visit(module, parent, lExpression);
             return new MemberAccessProcedurePointerBinding(_declarationFinder, Declaration.GetProjectParent(parent), module, parent, expression, expression.unrestrictedIdentifier(), lExpressionBinding);
         }
diff --git a/Rubberduck.Parsing/Binding/TypeBindingContext.cs b/Rubberduck.Parsing/Binding/TypeBindingContext.cs
diff --git a/Rubberduck.Parsing/Symbols/IdentifierReference.cs b/Rubberduck.Parsing/Symbols/IdentifierReference.cs
diff --git a/Rubberduck.Parsing/VBA/ReferenceManagement/BoundExpressionVisitor.cs b/Rubberduck.Parsing/VBA/ReferenceManagement/BoundExpressionVisitor.cs
diff --git a/Rubberduck.Refactorings/Common/DeclarationExtensions.cs b/Rubberduck.Refactorings/Common/DeclarationExtensions.cs

Original file line number	Diff line number	Diff line change
`@@ -42,8 +42,7 @@ public IBoundExpression ResolveDefault(Declaration module, Declaration parent, P`
`42`	`42`	`public IBoundExpression ResolveType(Declaration module, Declaration parent, ParserRuleContext expression)`
`43`	`43`	`{`
`44`	`44`	`var context = expression;`
`45`		`- var opContext = expression as VBAParser.RelationalOpContext;`
`46`		`- if (opContext != null && opContext.Parent is VBAParser.ComplexTypeContext)`
	`45`	`+ if (context is VBAParser.RelationalOpContext opContext && opContext.Parent is VBAParser.ComplexTypeContext)`
`47`	`46`	`{`
`48`	`47`	`context = opContext.GetChild<VBAParser.LExprContext>(0);`
`49`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,24 +5,16 @@ namespace Rubberduck.Parsing.Binding`
`5`	`5`	`{`
`6`	`6`	`public sealed class NewExpression : BoundExpression`
`7`	`7`	`{`
`8`		`- private readonly IBoundExpression _typeExpression;`
`9`		`-`
`10`	`8`	`public NewExpression(`
`11`	`9`	`Declaration referencedDeclaration,`
`12`	`10`	`ParserRuleContext context,`
`13`	`11`	`IBoundExpression typeExpression)`
`14`	`12`	`// Marked as Variable instead of Value to integrate into rest of binding process.`
`15`	`13`	`: base(referencedDeclaration, ExpressionClassification.Variable, context)`
`16`	`14`	`{`
`17`		`- _typeExpression = typeExpression;`
	`15`	`+ TypeExpression = typeExpression;`
`18`	`16`	`}`
`19`	`17`
`20`		`- public IBoundExpression TypeExpression`
`21`		`- {`
`22`		`- get`
`23`		`- {`
`24`		`- return _typeExpression;`
`25`		`- }`
`26`		`- }`
	`18`	`+ public IBoundExpression TypeExpression { get; }`
`27`	`19`	`}`
`28`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,23 +5,15 @@ namespace Rubberduck.Parsing.Binding`
`5`	`5`	`{`
`6`	`6`	`public sealed class ParenthesizedExpression : BoundExpression`
`7`	`7`	`{`
`8`		`- private readonly IBoundExpression _expression;`
`9`		`-`
`10`	`8`	`public ParenthesizedExpression(`
`11`	`9`	`Declaration referencedDeclaration,`
`12`	`10`	`ParserRuleContext context,`
`13`	`11`	`IBoundExpression expression)`
`14`	`12`	`: base(referencedDeclaration, ExpressionClassification.Value, context)`
`15`	`13`	`{`
`16`		`- _expression = expression;`
	`14`	`+ Expression = expression;`
`17`	`15`	`}`
`18`	`16`
`19`		`- public IBoundExpression Expression`
`20`		`- {`
`21`		`- get`
`22`		`- {`
`23`		`- return _expression;`
`24`		`- }`
`25`		`- }`
	`17`	`+ public IBoundExpression Expression { get; }`
`26`	`18`	`}`
`27`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,23 +5,15 @@ namespace Rubberduck.Parsing.Binding`
`5`	`5`	`{`
`6`	`6`	`public sealed class UnaryOpExpression : BoundExpression`
`7`	`7`	`{`
`8`		`- private readonly IBoundExpression _expr;`
`9`		`-`
`10`	`8`	`public UnaryOpExpression(`
`11`	`9`	`Declaration referencedDeclaration,`
`12`	`10`	`ParserRuleContext context,`
`13`	`11`	`IBoundExpression expr)`
`14`	`12`	`: base(referencedDeclaration, ExpressionClassification.Value, context)`
`15`	`13`	`{`
`16`		`- _expr = expr;`
	`14`	`+ Expr = expr;`
`17`	`15`	`}`
`18`	`16`
`19`		`- public IBoundExpression Expr`
`20`		`- {`
`21`		`- get`
`22`		`- {`
`23`		`- return _expr;`
`24`		`- }`
`25`		`- }`
	`17`	`+ public IBoundExpression Expr { get; }`
`26`	`18`	`}`
`27`	`19`	`}`