Expose _flowAnalysis from ResolverVisitor.

This saves a lot of plumbing work in the analyzer, because it allows
the individual resolver components to access flow analysis via the
resolver field rather than needing to maintain their own field.  It
should be helpful in supporting the upcoming "why not promoted"
functionality (#38773), which will require flow analysis to be visible
to even more parts of the resolver.

Bug: #38773
Change-Id: Ibea0ec7e263461d6c512b3dad59f10622b2aac6f
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/181661
Reviewed-by: Samuel Rawlins <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

pkg/analyzer/lib/src/dart/resolver/assignment_expression_resolver.dart

@@ -12,7 +12,6 @@ import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/token.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
-import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
 import 'package:analyzer/src/dart/resolver/invocation_inference_helper.dart';
 import 'package:analyzer/src/dart/resolver/type_property_resolver.dart';
 import 'package:analyzer/src/error/codes.dart';
@@ -22,21 +21,17 @@ import 'package:meta/meta.dart';
 /// Helper for resolving [AssignmentExpression]s.
 class AssignmentExpressionResolver {
   final ResolverVisitor _resolver;
-  final FlowAnalysisHelper _flowAnalysis;
   final TypePropertyResolver _typePropertyResolver;
   final InvocationInferenceHelper _inferenceHelper;
   final AssignmentExpressionShared _assignmentShared;
 
   AssignmentExpressionResolver({
     @required ResolverVisitor resolver,
-    @required FlowAnalysisHelper flowAnalysis,
   })  : _resolver = resolver,
-        _flowAnalysis = flowAnalysis,
         _typePropertyResolver = resolver.typePropertyResolver,
         _inferenceHelper = resolver.inferenceHelper,
         _assignmentShared = AssignmentExpressionShared(
           resolver: resolver,
-          flowAnalysis: flowAnalysis,
         );
 
   ErrorReporter get _errorReporter => _resolver.errorReporter;
@@ -80,7 +75,7 @@ class AssignmentExpressionResolver {
       _setRhsContext(node, leftType, operator, right);
     }
 
-    var flow = _flowAnalysis?.flow;
+    var flow = _resolver.flowAnalysis?.flow;
     if (flow != null && isIfNull) {
       flow.ifNullExpression_rightBegin(left, node.readType);
     }
@@ -276,23 +271,22 @@ class AssignmentExpressionResolver {
 
 class AssignmentExpressionShared {
   final ResolverVisitor _resolver;
-  final FlowAnalysisHelper _flowAnalysis;
 
   AssignmentExpressionShared({
     @required ResolverVisitor resolver,
-    @required FlowAnalysisHelper flowAnalysis,
-  })  : _resolver = resolver,
-        _flowAnalysis = flowAnalysis;
+  }) : _resolver = resolver;
 
   ErrorReporter get _errorReporter => _resolver.errorReporter;
 
   void checkFinalAlreadyAssigned(Expression left) {
-    var flow = _flowAnalysis?.flow;
+    var flow = _resolver.flowAnalysis?.flow;
     if (flow != null && left is SimpleIdentifier) {
       var element = left.staticElement;
       if (element is VariableElement) {
-        var assigned = _flowAnalysis.isDefinitelyAssigned(left, element);
-        var unassigned = _flowAnalysis.isDefinitelyUnassigned(left, element);
+        var assigned =
+            _resolver.flowAnalysis.isDefinitelyAssigned(left, element);
+        var unassigned =
+            _resolver.flowAnalysis.isDefinitelyUnassigned(left, element);
 
         if (element.isFinal) {
           if (element.isLate) {

pkg/analyzer/lib/src/dart/resolver/binary_expression_resolver.dart

@@ -11,7 +11,6 @@ import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
-import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
 import 'package:analyzer/src/dart/resolver/invocation_inference_helper.dart';
 import 'package:analyzer/src/dart/resolver/resolution_result.dart';
 import 'package:analyzer/src/dart/resolver/type_property_resolver.dart';
@@ -24,17 +23,14 @@ import 'package:meta/meta.dart';
 class BinaryExpressionResolver {
   final ResolverVisitor _resolver;
   final TypePromotionManager _promoteManager;
-  final FlowAnalysisHelper _flowAnalysis;
   final TypePropertyResolver _typePropertyResolver;
   final InvocationInferenceHelper _inferenceHelper;
 
   BinaryExpressionResolver({
     @required ResolverVisitor resolver,
     @required TypePromotionManager promoteManager,
-    @required FlowAnalysisHelper flowAnalysis,
   })  : _resolver = resolver,
         _promoteManager = promoteManager,
-        _flowAnalysis = flowAnalysis,
         _typePropertyResolver = resolver.typePropertyResolver,
         _inferenceHelper = resolver.inferenceHelper;
 
@@ -111,7 +107,7 @@ class BinaryExpressionResolver {
     left.accept(_resolver);
     left = node.leftOperand;
 
-    var flow = _flowAnalysis?.flow;
+    var flow = _resolver.flowAnalysis?.flow;
     var leftExtensionOverride = left is ExtensionOverride;
     if (!leftExtensionOverride) {
       flow?.equalityOp_rightBegin(left, left.staticType);
@@ -136,7 +132,7 @@ class BinaryExpressionResolver {
   void _resolveIfNull(BinaryExpressionImpl node) {
     var left = node.leftOperand;
     var right = node.rightOperand;
-    var flow = _flowAnalysis?.flow;
+    var flow = _resolver.flowAnalysis?.flow;
 
     var leftContextType = InferenceContext.getContext(node);
     if (leftContextType != null && _isNonNullableByDefault) {
@@ -171,7 +167,7 @@ class BinaryExpressionResolver {
   void _resolveLogicalAnd(BinaryExpressionImpl node) {
     var left = node.leftOperand;
     var right = node.rightOperand;
-    var flow = _flowAnalysis?.flow;
+    var flow = _resolver.flowAnalysis?.flow;
 
     InferenceContext.setType(left, _typeProvider.boolType);
     InferenceContext.setType(right, _typeProvider.boolType);
@@ -180,7 +176,7 @@ class BinaryExpressionResolver {
     left.accept(_resolver);
     left = node.leftOperand;
 
-    if (_flowAnalysis != null) {
+    if (_resolver.flowAnalysis != null) {
       flow?.logicalBinaryOp_rightBegin(left, node, isAnd: true);
       _resolver.checkUnreachableNode(right);
 
@@ -209,7 +205,7 @@ class BinaryExpressionResolver {
   void _resolveLogicalOr(BinaryExpressionImpl node) {
     var left = node.leftOperand;
     var right = node.rightOperand;
-    var flow = _flowAnalysis?.flow;
+    var flow = _resolver.flowAnalysis?.flow;
 
     InferenceContext.setType(left, _typeProvider.boolType);
     InferenceContext.setType(right, _typeProvider.boolType);

pkg/analyzer/lib/src/dart/resolver/for_resolver.dart

@@ -10,21 +10,17 @@ import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_schema.dart';
 import 'package:analyzer/src/dart/resolver/assignment_expression_resolver.dart';
-import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:meta/meta.dart';
 
 /// Helper for resolving [ForStatement]s and [ForElement]s.
 class ForResolver {
   final ResolverVisitor _resolver;
-  final FlowAnalysisHelper _flowAnalysis;
 
   ForResolver({
     @required ResolverVisitor resolver,
-    @required FlowAnalysisHelper flowAnalysis,
-  })  : _resolver = resolver,
-        _flowAnalysis = flowAnalysis;
+  }) : _resolver = resolver;
 
   void resolveElement(ForElementImpl node) {
     var forLoopParts = node.forLoopParts;
@@ -89,7 +85,6 @@ class ForResolver {
       identifier?.accept(_resolver);
       AssignmentExpressionShared(
         resolver: _resolver,
-        flowAnalysis: _flowAnalysis,
       ).checkFinalAlreadyAssigned(identifier);
     }
 
@@ -134,10 +129,10 @@ class ForResolver {
     }
 
     if (loopVariable != null) {
-      _flowAnalysis?.flow?.declare(loopVariable.declaredElement, true);
+      _resolver.flowAnalysis?.flow?.declare(loopVariable.declaredElement, true);
     }
 
-    _flowAnalysis?.flow?.forEach_bodyBegin(
+    _resolver.flowAnalysis?.flow?.forEach_bodyBegin(
       node,
       identifierElement is VariableElement
           ? identifierElement
@@ -147,7 +142,7 @@ class ForResolver {
 
     _resolveBody(body);
 
-    _flowAnalysis?.flow?.forEach_end();
+    _resolver.flowAnalysis?.flow?.forEach_end();
   }
 
   void _forParts(AstNode node, ForParts forParts, AstNode body) {
@@ -157,7 +152,7 @@ class ForResolver {
       forParts.initialization?.accept(_resolver);
     }
 
-    _flowAnalysis?.for_conditionBegin(node);
+    _resolver.flowAnalysis?.for_conditionBegin(node);
 
     var condition = forParts.condition;
     if (condition != null) {
@@ -167,13 +162,13 @@ class ForResolver {
       _resolver.boolExpressionVerifier.checkForNonBoolCondition(condition);
     }
 
-    _flowAnalysis?.for_bodyBegin(node, condition);
+    _resolver.flowAnalysis?.for_bodyBegin(node, condition);
     _resolveBody(body);
 
-    _flowAnalysis?.flow?.for_updaterBegin();
+    _resolver.flowAnalysis?.flow?.for_updaterBegin();
     forParts.updaters.accept(_resolver);
 
-    _flowAnalysis?.flow?.for_end();
+    _resolver.flowAnalysis?.flow?.for_end();
   }
 
   void _resolveBody(AstNode body) {

pkg/analyzer/lib/src/dart/resolver/function_expression_resolver.dart

@@ -9,7 +9,6 @@ import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/dart/resolver/body_inference_context.dart';
-import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
 import 'package:analyzer/src/dart/resolver/invocation_inference_helper.dart';
 import 'package:analyzer/src/generated/migration.dart';
 import 'package:analyzer/src/generated/resolver.dart';
@@ -20,18 +19,15 @@ class FunctionExpressionResolver {
   final ResolverVisitor _resolver;
   final MigrationResolutionHooks _migrationResolutionHooks;
   final InvocationInferenceHelper _inferenceHelper;
-  final FlowAnalysisHelper _flowAnalysis;
   final TypePromotionManager _promoteManager;
 
   FunctionExpressionResolver({
     @required ResolverVisitor resolver,
     @required MigrationResolutionHooks migrationResolutionHooks,
-    @required FlowAnalysisHelper flowAnalysis,
     @required TypePromotionManager promoteManager,
   })  : _resolver = resolver,
         _migrationResolutionHooks = migrationResolutionHooks,
         _inferenceHelper = resolver.inferenceHelper,
-        _flowAnalysis = flowAnalysis,
         _promoteManager = promoteManager;
 
   bool get _isNonNullableByDefault => _typeSystem.isNonNullableByDefault;
@@ -42,9 +38,10 @@ class FunctionExpressionResolver {
     var isFunctionDeclaration = node.parent is FunctionDeclaration;
     var body = node.body;
 
-    if (_flowAnalysis != null) {
-      if (_flowAnalysis.flow != null && !isFunctionDeclaration) {
-        _flowAnalysis.executableDeclaration_enter(node, node.parameters, true);
+    if (_resolver.flowAnalysis != null) {
+      if (_resolver.flowAnalysis.flow != null && !isFunctionDeclaration) {
+        _resolver.flowAnalysis
+            .executableDeclaration_enter(node, node.parameters, true);
       }
     } else {
       _promoteManager.enterFunctionBody(body);
@@ -65,15 +62,15 @@ class FunctionExpressionResolver {
     node.visitChildren(_resolver);
     _resolve2(node);
 
-    if (_flowAnalysis != null) {
-      if (_flowAnalysis.flow != null && !isFunctionDeclaration) {
+    if (_resolver.flowAnalysis != null) {
+      if (_resolver.flowAnalysis.flow != null && !isFunctionDeclaration) {
         var bodyContext = BodyInferenceContext.of(node.body);
         _resolver.checkForBodyMayCompleteNormally(
           returnType: bodyContext?.contextType,
           body: body,
           errorNode: body,
         );
-        _flowAnalysis.flow?.functionExpression_end();
+        _resolver.flowAnalysis.flow?.functionExpression_end();
         _resolver.nullSafetyDeadCodeVerifier?.flowEnd(node);
       }
     } else {

pkg/analyzer/lib/src/dart/resolver/invocation_inference_helper.dart

@@ -10,7 +10,6 @@ import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_algebra.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
-import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/migration.dart';
 import 'package:analyzer/src/generated/resolver.dart';
@@ -19,7 +18,6 @@ import 'package:meta/meta.dart';
 class InvocationInferenceHelper {
   final ResolverVisitor _resolver;
   final ErrorReporter _errorReporter;
-  final FlowAnalysisHelper _flowAnalysis;
   final TypeSystemImpl _typeSystem;
   final MigrationResolutionHooks _migrationResolutionHooks;
 
@@ -29,13 +27,11 @@ class InvocationInferenceHelper {
   InvocationInferenceHelper(
       {@required ResolverVisitor resolver,
       @required ErrorReporter errorReporter,
-      @required FlowAnalysisHelper flowAnalysis,
       @required TypeSystemImpl typeSystem,
       @required MigrationResolutionHooks migrationResolutionHooks})
       : _resolver = resolver,
         _errorReporter = errorReporter,
         _typeSystem = typeSystem,
-        _flowAnalysis = flowAnalysis,
         _migrationResolutionHooks = migrationResolutionHooks;
 
   /// Compute the return type of the method or function represented by the given
@@ -200,7 +196,7 @@ class InvocationInferenceHelper {
     } else {
       expression.staticType = type;
       if (_typeSystem.isBottom(type)) {
-        _flowAnalysis?.flow?.handleExit();
+        _resolver.flowAnalysis?.flow?.handleExit();
       }
     }
   }

pkg/analyzer/lib/src/dart/resolver/postfix_expression_resolver.dart

@@ -12,7 +12,6 @@ import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/dart/error/syntactic_errors.dart';
 import 'package:analyzer/src/dart/resolver/assignment_expression_resolver.dart';
-import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
 import 'package:analyzer/src/dart/resolver/invocation_inference_helper.dart';
 import 'package:analyzer/src/dart/resolver/type_property_resolver.dart';
 import 'package:analyzer/src/error/codes.dart';
@@ -22,21 +21,17 @@ import 'package:meta/meta.dart';
 /// Helper for resolving [PostfixExpression]s.
 class PostfixExpressionResolver {
   final ResolverVisitor _resolver;
-  final FlowAnalysisHelper _flowAnalysis;
   final TypePropertyResolver _typePropertyResolver;
   final InvocationInferenceHelper _inferenceHelper;
   final AssignmentExpressionShared _assignmentShared;
 
   PostfixExpressionResolver({
     @required ResolverVisitor resolver,
-    @required FlowAnalysisHelper flowAnalysis,
   })  : _resolver = resolver,
-        _flowAnalysis = flowAnalysis,
         _typePropertyResolver = resolver.typePropertyResolver,
         _inferenceHelper = resolver.inferenceHelper,
         _assignmentShared = AssignmentExpressionShared(
           resolver: resolver,
-          flowAnalysis: flowAnalysis,
         );
 
   ErrorReporter get _errorReporter => _resolver.errorReporter;
@@ -180,7 +175,8 @@ class PostfixExpressionResolver {
       if (operand is SimpleIdentifier) {
         var element = operand.staticElement;
         if (element is PromotableElement) {
-          _flowAnalysis?.flow?.write(element, operatorReturnType, null);
+          _resolver.flowAnalysis?.flow
+              ?.write(element, operatorReturnType, null);
         }
       }
     }
@@ -219,6 +215,6 @@ class PostfixExpressionResolver {
     _inferenceHelper.recordStaticType(node, type);
 
     _resolver.nullShortingTermination(node);
-    _flowAnalysis?.flow?.nonNullAssert_end(operand);
+    _resolver.flowAnalysis?.flow?.nonNullAssert_end(operand);
   }
 }