Clean up resolution of unlabeled break/continue targets.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'ast.dart';
@@ skipping 5755 matching lines @@
       }
       for (int i = argumentCount; i < parameterCount; i++) {
         types[i] = dynamic;
       }
     }
     return types;
   }
 }
 
 /**
+ * Instances of the class `ImplicitLabelScope` represent the scope statements
+ * that can be the target of unlabeled break and continue statements.
+ */
+class ImplicitLabelScope {
+  /**
+   * The implicit label scope associated with the top level of a function.
+   */
+  static const ImplicitLabelScope ROOT = const ImplicitLabelScope._(null, null);
+
+  /**
+   * The implicit label scope enclosing this implicit label scope.
+   */
+  final ImplicitLabelScope outerScope;
+
+  /**
+   * The statement that acts as a target for break and/or continue statements
+   * at this scoping level.
+   */
+  final Statement statement;
+
+  /**
+   * Private constructor.
+   */
+  const ImplicitLabelScope._(this.outerScope, this.statement);
+
+  /**
+   * Get the statement which should be the target of an unlabeled `break` or
+   * `continue` statement, or `null` if there is no appropriate target.
+   */
+  Statement getTarget(bool isContinue) {
+    if (outerScope == null) {
+      // This scope represents the toplevel of a function body, so it doesn't
+      // match either break or continue.
+      return null;
+    }
+    if (isContinue && statement is SwitchStatement) {
+      return outerScope.getTarget(isContinue);
+    }
+    return statement;
+  }
+
+  /**
+   * Initialize a newly created scope to represent a switch statement or loop
+   * nested within the current scope.  [statement] is the statement associated
+   * with the newly created scope.
+   */
+  ImplicitLabelScope nest(Statement statement) =>
+      new ImplicitLabelScope._(this, statement);
+}
+
+/**
  * Instances of the class `ImportsVerifier` visit all of the referenced libraries in the
  * source code verifying that all of the imports are used, otherwise a
  * [HintCode.UNUSED_IMPORT] is generated with
  * [generateUnusedImportHints].
  *
  * While this class does not yet have support for an "Organize Imports" action, this logic built up
  * in this class could be used for such an action in the future.
  */
 class ImportsVerifier extends RecursiveAstVisitor<Object> {
   /**
@@ skipping 5233 matching lines @@
    * The object keeping track of which elements have had their types overridden.
    */
   TypeOverrideManager _overrideManager = new TypeOverrideManager();
 
   /**
    * The object keeping track of which elements have had their types promoted.
    */
   TypePromotionManager _promoteManager = new TypePromotionManager();
 
   /**
-   * The AST node representing the innermost enclosing statement that can be
-   * the target of an unlabeled "break" statement, or `null` if there is no
-   * such statement.
-   */
-  Statement _unlabeledBreakTarget;
-
-  /**
-   * The AST node representing the innermost enclosing statement that can be
-   * the target of an unlabeled "continue" statement, or `null` if there is no
-   * such statement.
-   */
-  Statement _unlabeledContinueTarget;
-
-  /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   ResolverVisitor.con1(Library library, Source source,
       TypeProvider typeProvider)
       : super.con1(library, source, typeProvider) {
     this._inheritanceManager = library.inheritanceManager;
@@ skipping 162 matching lines @@
     ElementKind kind = element.kind;
     if (kind == ElementKind.LOCAL_VARIABLE) {
       return element as VariableElement;
     }
     if (kind == ElementKind.PARAMETER) {
       return element as VariableElement;
     }
     return null;
   }
 
-  AstNode getUnlabeledBreakOrContinueTarget(bool isContinue) {
-    if (isContinue) {
-      return _unlabeledContinueTarget;
-    } else {
-      return _unlabeledBreakTarget;
-    }
-  }
-
   /**
    * If it is appropriate to do so, override the current type of the static and propagated elements
    * associated with the given expression with the given type. Generally speaking, it is appropriate
    * if the given type is more specific than the current type.
    *
    * @param expression the expression used to access the static and propagated elements whose types
    *          might be overridden
    * @param potentialType the potential type of the elements
    * @param allowPrecisionLoss see @{code overrideVariable} docs
    */
@@ skipping 132 matching lines @@
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   @override
   Object visitBlockFunctionBody(BlockFunctionBody node) {
     safelyVisit(_commentBeforeFunction);
     _overrideManager.enterScope();
-    Statement previousUnlabeledBreakTarget = _unlabeledBreakTarget;
-    Statement previousUnlabeledContinueTarget = _unlabeledContinueTarget;
     try {
-      _unlabeledBreakTarget = null;
-      _unlabeledContinueTarget = null;
       super.visitBlockFunctionBody(node);
     } finally {
       _overrideManager.exitScope();
-      _unlabeledBreakTarget = previousUnlabeledBreakTarget;
-      _unlabeledContinueTarget = previousUnlabeledContinueTarget;
     }
     return null;
   }
 
   @override
   Object visitBreakStatement(BreakStatement node) {
     //
     // We do not visit the label because it needs to be visited in the context
     // of the statement.
     //
@@ skipping 188 matching lines @@
     // We do not visit the label because it needs to be visited in the context
     // of the statement.
     //
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   @override
   Object visitDoStatement(DoStatement node) {
-    Statement previousUnlabeledBreakTarget = _unlabeledBreakTarget;
-    Statement previousUnlabeledContinueTarget = _unlabeledContinueTarget;
     _overrideManager.enterScope();
     try {
-      _unlabeledBreakTarget = node;
-      _unlabeledContinueTarget = node;
       super.visitDoStatement(node);
     } finally {
       _overrideManager.exitScope();
-      _unlabeledBreakTarget = previousUnlabeledBreakTarget;
-      _unlabeledContinueTarget = previousUnlabeledContinueTarget;
     }
     // TODO(brianwilkerson) If the loop can only be exited because the condition
     // is false, then propagateFalseState(node.getCondition());
     return null;
   }
 
   @override
   Object visitEmptyFunctionBody(EmptyFunctionBody node) {
     safelyVisit(_commentBeforeFunction);
     return super.visitEmptyFunctionBody(node);
@@ skipping 35 matching lines @@
       Map<VariableElement, DartType> overrides =
           _overrideManager.captureOverrides(node.fields);
       _overrideManager.exitScope();
       _overrideManager.applyOverrides(overrides);
     }
     return null;
   }
 
   @override
   Object visitForEachStatement(ForEachStatement node) {
-    Statement previousUnlabeledBreakTarget = _unlabeledBreakTarget;
-    Statement previousUnlabeledContinueTarget = _unlabeledContinueTarget;
     _overrideManager.enterScope();
     try {
-      _unlabeledBreakTarget = node;
-      _unlabeledContinueTarget = node;
       super.visitForEachStatement(node);
     } finally {
       _overrideManager.exitScope();
-      _unlabeledBreakTarget = previousUnlabeledBreakTarget;
-      _unlabeledContinueTarget = previousUnlabeledContinueTarget;
     }
     return null;
   }
 
   @override
   void visitForEachStatementInScope(ForEachStatement node) {
     //
     // We visit the iterator before the loop variable because the loop variable
     // cannot be in scope while visiting the iterator.
     //
@@ skipping 26 matching lines @@
       } finally {
         _overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
   }
 
   @override
   Object visitForStatement(ForStatement node) {
-    Statement previousUnlabeledBreakTarget = _unlabeledBreakTarget;
-    Statement previousUnlabeledContinueTarget = _unlabeledContinueTarget;
     _overrideManager.enterScope();
     try {
-      _unlabeledBreakTarget = node;
-      _unlabeledContinueTarget = node;
       super.visitForStatement(node);
     } finally {
       _overrideManager.exitScope();
-      _unlabeledBreakTarget = previousUnlabeledBreakTarget;
-      _unlabeledContinueTarget = previousUnlabeledContinueTarget;
     }
     return null;
   }
 
   @override
   void visitForStatementInScope(ForStatement node) {
     safelyVisit(node.variables);
     safelyVisit(node.initialization);
     safelyVisit(node.condition);
     _overrideManager.enterScope();
@@ skipping 241 matching lines @@
     _overrideManager.enterScope();
     try {
       super.visitSwitchDefault(node);
     } finally {
       _overrideManager.exitScope();
     }
     return null;
   }
 
   @override
-  Object visitSwitchStatement(SwitchStatement node) {
-    Statement previousUnlabeledBreakTarget = _unlabeledBreakTarget;
-    try {
-      _unlabeledBreakTarget = node;
-      super.visitSwitchStatement(node);
-    } finally {
-      _unlabeledBreakTarget = previousUnlabeledBreakTarget;
-    }
-    return null;
-  }
-
-  @override
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     _overrideManager.enterScope();
     try {
       super.visitTopLevelVariableDeclaration(node);
     } finally {
       Map<VariableElement, DartType> overrides =
           _overrideManager.captureOverrides(node.variables);
       _overrideManager.exitScope();
       _overrideManager.applyOverrides(overrides);
     }
     return null;
   }
 
   @override
   Object visitTypeName(TypeName node) => null;
 
   @override
   Object visitWhileStatement(WhileStatement node) {
-    Expression condition = node.condition;
-    safelyVisit(condition);
-    Statement body = node.body;
-    if (body != null) {
-      Statement previousUnlabeledBreakTarget = _unlabeledBreakTarget;
-      Statement previousUnlabeledContinueTarget = _unlabeledContinueTarget;
-      _overrideManager.enterScope();
-      try {
-        _unlabeledBreakTarget = node;
-        _unlabeledContinueTarget = node;
-        _propagateTrueState(condition);
-        visitStatementInScope(body);
-      } finally {
-        _overrideManager.exitScope();
-        _unlabeledBreakTarget = previousUnlabeledBreakTarget;
-        _unlabeledContinueTarget = previousUnlabeledContinueTarget;
+    // Note: since we don't call the base class, we have to maintain
+    // _implicitLabelScope ourselves.
+    ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
+    try {
+      _implicitLabelScope = _implicitLabelScope.nest(node);
+      Expression condition = node.condition;
+      safelyVisit(condition);
+      Statement body = node.body;
+      if (body != null) {
+        _overrideManager.enterScope();
+        try {
+          _propagateTrueState(condition);
+          visitStatementInScope(body);
+        } finally {
+          _overrideManager.exitScope();
+        }
       }
+    } finally {
+      _implicitLabelScope = outerImplicitScope;
     }
     // TODO(brianwilkerson) If the loop can only be exited because the condition
     // is false, then propagateFalseState(condition);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   /**
    * Checks each promoted variable in the current scope for compliance with the following
@@ skipping 588 matching lines @@
    * The scope used to resolve identifiers.
    */
   Scope _nameScope;
 
   /**
    * The object used to access the types from the core library.
    */
   final TypeProvider typeProvider;
 
   /**
+   * The scope used to resolve unlabeled `break` and `continue` statements.
+   */
+  ImplicitLabelScope _implicitLabelScope = ImplicitLabelScope.ROOT;
+
+  /**
    * The scope used to resolve labels for `break` and `continue` statements, or
    * `null` if no labels have been defined in the current context.
    */
   LabelScope _labelScope;
 
   /**
    * The class containing the AST nodes being visited,
    * or `null` if we are not in the scope of a class.
    */
   ClassElement enclosingClass;
@@ skipping 63 matching lines @@
   }
 
   /**
    * Return the library element for the library containing the compilation unit being resolved.
    *
    * @return the library element for the library containing the compilation unit being resolved
    */
   LibraryElement get definingLibrary => _definingLibrary;
 
   /**
+   * Return the implicit label scope in which the current node is being
+   * resolved.
+   */
+  ImplicitLabelScope get implicitLabelScope => _implicitLabelScope;
+
+  /**
    * Return the label scope in which the current node is being resolved.
    *
    * @return the label scope in which the current node is being resolved
    */
   LabelScope get labelScope => _labelScope;
 
   /**
    * Return the name scope in which the current node is being resolved.
    *
    * @return the name scope in which the current node is being resolved
@@ skipping 85 matching lines @@
       _hideNamesDefinedInBlock(enclosedScope, node);
       _nameScope = enclosedScope;
       super.visitBlock(node);
     } finally {
       _nameScope = outerScope;
     }
     return null;
   }
 
   @override
+  Object visitBlockFunctionBody(BlockFunctionBody node) {
+    ImplicitLabelScope implicitOuterScope = _implicitLabelScope;
+    try {
+      _implicitLabelScope = ImplicitLabelScope.ROOT;
+      super.visitBlockFunctionBody(node);
+    } finally {
+      _implicitLabelScope = implicitOuterScope;
+    }
+    return null;
+  }
+
+  @override
   Object visitCatchClause(CatchClause node) {
     SimpleIdentifier exception = node.exceptionParameter;
     if (exception != null) {
       Scope outerScope = _nameScope;
       try {
         _nameScope = new EnclosedScope(_nameScope);
         _nameScope.define(exception.staticElement);
         SimpleIdentifier stackTrace = node.stackTraceParameter;
         if (stackTrace != null) {
           _nameScope.define(stackTrace.staticElement);
@@ skipping 98 matching lines @@
     VariableElement element = node.element;
     if (element != null) {
       _nameScope.define(element);
     }
     super.visitDeclaredIdentifier(node);
     return null;
   }
 
   @override
   Object visitDoStatement(DoStatement node) {
-    visitStatementInScope(node.body);
-    safelyVisit(node.condition);
+    ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
+    try {
+      _implicitLabelScope = _implicitLabelScope.nest(node);
+      visitStatementInScope(node.body);
+      safelyVisit(node.condition);
+    } finally {
+      _implicitLabelScope = outerImplicitScope;
+    }
     return null;
   }
 
   @override
   Object visitForEachStatement(ForEachStatement node) {
     Scope outerNameScope = _nameScope;
+    ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
     try {
       _nameScope = new EnclosedScope(_nameScope);
+      _implicitLabelScope = _implicitLabelScope.nest(node);
       visitForEachStatementInScope(node);
     } finally {
       _nameScope = outerNameScope;
+      _implicitLabelScope = outerImplicitScope;
     }
     return null;
   }
 
   /**
    * Visit the given statement after it's scope has been created. This replaces the normal call to
    * the inherited visit method so that ResolverVisitor can intervene when type propagation is
    * enabled.
    *
    * @param node the statement to be visited
@@ skipping 19 matching lines @@
     }
     if (_nameScope is FunctionTypeScope) {
       (_nameScope as FunctionTypeScope).defineParameters();
     }
     return null;
   }
 
   @override
   Object visitForStatement(ForStatement node) {
     Scope outerNameScope = _nameScope;
+    ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
     try {
       _nameScope = new EnclosedScope(_nameScope);
+      _implicitLabelScope = _implicitLabelScope.nest(node);
       visitForStatementInScope(node);
     } finally {
       _nameScope = outerNameScope;
+      _implicitLabelScope = outerImplicitScope;
     }
     return null;
   }
 
   /**
    * Visit the given statement after it's scope has been created. This replaces the normal call to
    * the inherited visit method so that ResolverVisitor can intervene when type propagation is
    * enabled.
    *
    * @param node the statement to be visited
@@ skipping 159 matching lines @@
       node.statements.accept(this);
     } finally {
       _nameScope = outerNameScope;
     }
     return null;
   }
 
   @override
   Object visitSwitchStatement(SwitchStatement node) {
     LabelScope outerScope = _labelScope;
+    ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
     try {
+      _implicitLabelScope = _implicitLabelScope.nest(node);
       for (SwitchMember member in node.members) {
         for (Label label in member.labels) {
           SimpleIdentifier labelName = label.label;
           LabelElement labelElement = labelName.staticElement as LabelElement;
           _labelScope =
               new LabelScope(_labelScope, labelName.name, member, labelElement);
         }
       }
       super.visitSwitchStatement(node);
     } finally {
       _labelScope = outerScope;
+      _implicitLabelScope = outerImplicitScope;
     }
     return null;
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     if (node.parent.parent is! TopLevelVariableDeclaration &&
         node.parent.parent is! FieldDeclaration) {
       VariableElement element = node.element;
       if (element != null) {
         _nameScope.define(element);
       }
     }
     return null;
   }
 
   @override
   Object visitWhileStatement(WhileStatement node) {
     safelyVisit(node.condition);
-    visitStatementInScope(node.body);
+    ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
+    try {
+      _implicitLabelScope = _implicitLabelScope.nest(node);
+      visitStatementInScope(node.body);
+    } finally {
+      _implicitLabelScope = outerImplicitScope;
+    }
     return null;
   }
 
   /**
    * Add scopes for each of the given labels.
    *
    * @param labels the labels for which new scopes are to be added
    * @return the scope that was in effect before the new scopes were added
    */
   LabelScope _addScopesFor(NodeList<Label> labels, AstNode node) {
@@ skipping 2987 matching lines @@
    * library.
    */
   final HashSet<String> members = new HashSet<String>();
 
   /**
    * Names of resolved or unresolved class members that are read in the
    * library.
    */
   final HashSet<String> readMembers = new HashSet<String>();
 }