Optimize and simplify resolution of ForNext and ForEach loops

Author: MDoerner

Rubberduck.Parsing/VBA/ReferenceManagement/IdentifierReferenceResolver.cs

@@ -614,97 +614,61 @@ public void Resolve(VBAParser.AsTypeClauseContext context)
 
         public void Resolve(VBAParser.ForNextStmtContext context)
         {
+            var expressions = context.expression();
+
             // In "For expr1 = expr2" the "expr1 = expr2" part is treated as a single expression.
-            var assignmentExpr = ((VBAParser.RelationalOpContext)context.expression()[0]);
-            var lExpr = assignmentExpr.expression()[0];
-            var withExpression = GetInnerMostWithExpression();
-            var firstExpression = _bindingService.ResolveDefault(
-                _moduleDeclaration,
-                _currentParent,
-                lExpr,
-                withExpression,
-                StatementResolutionContext.Undefined,
-                true);
-            if (firstExpression.Classification != ExpressionClassification.ResolutionFailed)
-            {
-                // each iteration counts as an assignment
+            var assignmentExpr = ((VBAParser.RelationalOpContext)expressions[0]);
+            ResolveStartValueAssignmentOfForNext(assignmentExpr);
 
-                _failedResolutionVisitor.CollectUnresolved(firstExpression, _currentParent, withExpression);
-                _boundExpressionVisitor.AddIdentifierReferences(
-                    firstExpression,
-                    _qualifiedModuleName,
-                    _currentScope,
-                    _currentParent,
-                    true);
-            }
-            var rExpr = assignmentExpr.expression()[1];
-            var secondExpression = _bindingService.ResolveDefault(
-                _moduleDeclaration,
-                _currentParent,
-                rExpr,
-                withExpression,
-                StatementResolutionContext.Undefined,
-                true);
-            _failedResolutionVisitor.CollectUnresolved(secondExpression, _currentParent, withExpression);
-            _boundExpressionVisitor.AddIdentifierReferences(
-                secondExpression,
-                _qualifiedModuleName,
-                _currentScope,
-                _currentParent);
-  
-            ResolveDefault(context.expression()[1], true);
+            ResolveToValueOfForNext(expressions[1]);
 
             var stepStatement = context.stepStmt();
             if (stepStatement != null)
             {
                 Resolve(stepStatement);
             }
 
-            for (var exprIndex = 2; exprIndex < context.expression().Length; exprIndex++)
+            const int firstNextExpressionIndex = 2;
+            for (var exprIndex = firstNextExpressionIndex; exprIndex < expressions.Length; exprIndex++)
             {
-                ResolveDefault(context.expression()[exprIndex], false);
+                ResolveDefault(expressions[exprIndex]);
             }
         }
 
+        private void ResolveStartValueAssignmentOfForNext(VBAParser.RelationalOpContext expression)
+        {
+            var expressions = expression.expression();
+            var elementVariableExpression = expressions[0];
+            ResolveDefault(elementVariableExpression, requiresLetCoercion: true, isAssignmentTarget: true);
+
+            var startValueExpression = expressions[1];
+            ResolveDefault(startValueExpression, requiresLetCoercion: true);
+        }
+
+        private void ResolveToValueOfForNext(ParserRuleContext expression)
+        {
+            ResolveDefault(expression, requiresLetCoercion: true);
+        }
+
         private void Resolve(VBAParser.StepStmtContext context)
         {
             ResolveDefault(context.expression(), true);
         }
 
         public void Resolve(VBAParser.ForEachStmtContext context)
         {
-            var withExpression = GetInnerMostWithExpression();
-            var firstExpression = _bindingService.ResolveDefault(
-                _moduleDeclaration,
-                _currentParent,
-                context.expression()[0],
-                withExpression,
-                StatementResolutionContext.Undefined,
-                false);
-            if (firstExpression.Classification == ExpressionClassification.ResolutionFailed)
-            {
+            var expressions = context.expression();
 
-                _failedResolutionVisitor.CollectUnresolved(firstExpression, _currentParent, withExpression);
-                _boundExpressionVisitor.AddIdentifierReferences(
-                    firstExpression,
-                    _qualifiedModuleName,
-                    _currentScope,
-                    _currentParent);
-            }
-            else
-            {
-                // each iteration counts as an assignment
-                _failedResolutionVisitor.CollectUnresolved(firstExpression, _currentParent, withExpression);
-                _boundExpressionVisitor.AddIdentifierReferences(
-                    firstExpression,
-                    _qualifiedModuleName,
-                    _currentScope,
-                    _currentParent,
-                    true);
-            }
-            for (var exprIndex = 1; exprIndex < context.expression().Length; exprIndex++)
+            var elementVariableExpression = expressions[0];
+            ResolveDefault(elementVariableExpression, isAssignmentTarget: true);
+
+            var collectionExpression = expressions[1];
+            ResolveDefault(collectionExpression);
+
+            const int firstNextExpressionIndex = 2;
+            for (var exprIndex = firstNextExpressionIndex; exprIndex < context.expression().Length; exprIndex++)
             {
-                ResolveDefault(context.expression()[exprIndex], false);
+                ResolveDefault(expressions[exprIndex]);
             }
         }