During resolution, record the target of break/continue statements.

pkg/analyzer/lib/src/generated/element_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.element_resolver;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'element.dart';
@@ skipping 158 matching lines @@
     if (operator.isUserDefinableOperator) {
       _resolveBinaryExpression(node, operator.lexeme);
     } else if (operator.type == sc.TokenType.BANG_EQ) {
       _resolveBinaryExpression(node, sc.TokenType.EQ_EQ.lexeme);
     }
     return null;
   }
 
   @override
   Object visitBreakStatement(BreakStatement node) {
-    _lookupLabel(node, node.label);
+    node.target = _lookupBreakOrContinueTarget(node, node.label, false);
     return null;
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     _setMetadata(node.element, node);
     return null;
   }
 
   @override
@@ skipping 170 matching lines @@
       constructor =
           interfaceType.lookUpConstructor(name.name, _definingLibrary);
       name.staticElement = constructor;
     }
     node.staticElement = constructor;
     return null;
   }
 
   @override
   Object visitContinueStatement(ContinueStatement node) {
-    _lookupLabel(node, node.label);
+    node.target = _lookupBreakOrContinueTarget(node, node.label, true);
     return null;
   }
 
   @override
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     _setMetadata(node.element, node);
     return null;
   }
 
   @override
@@ skipping 414 matching lines @@
       _recordUndefinedToken(
           propagatedType.element,
           HintCode.UNDEFINED_OPERATOR,
           node.operator,
           [methodName, propagatedType.displayName]);
     }
     return null;
   }
 
   @override
-  Object visitPrefixExpression(PrefixExpression node) {
-    sc.Token operator = node.operator;
-    sc.TokenType operatorType = operator.type;
-    if (operatorType.isUserDefinableOperator ||
-        operatorType == sc.TokenType.PLUS_PLUS ||
-        operatorType == sc.TokenType.MINUS_MINUS) {
-      Expression operand = node.operand;
-      String methodName = _getPrefixOperator(node);
-      DartType staticType = _getStaticType(operand);
-      MethodElement staticMethod =
-          _lookUpMethod(operand, staticType, methodName);
-      node.staticElement = staticMethod;
-      DartType propagatedType = _getPropagatedType(operand);
-      MethodElement propagatedMethod =
-          _lookUpMethod(operand, propagatedType, methodName);
-      node.propagatedElement = propagatedMethod;
-      if (_shouldReportMissingMember(staticType, staticMethod)) {
-        _recordUndefinedToken(
-            staticType.element,
-            StaticTypeWarningCode.UNDEFINED_OPERATOR,
-            operator,
-            [methodName, staticType.displayName]);
-      } else if (_enableHints &&
-          _shouldReportMissingMember(propagatedType, propagatedMethod) &&
-          !_memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
-        _recordUndefinedToken(
-            propagatedType.element,
-            HintCode.UNDEFINED_OPERATOR,
-            operator,
-            [methodName, propagatedType.displayName]);
-      }
-    }
-    return null;
-  }
-
-  @override
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefix = node.prefix;
     SimpleIdentifier identifier = node.identifier;
     //
     // First, check the "lib.loadLibrary" case
     //
     if (identifier.name == FunctionElement.LOAD_LIBRARY_NAME &&
         _isDeferredPrefix(prefix)) {
       LibraryElement importedLibrary = _getImportedLibrary(prefix);
       identifier.staticElement = importedLibrary.loadLibraryFunction;
@@ skipping 58 matching lines @@
     }
     //
     // Otherwise, the prefix is really an expression that happens to be a simple
     // identifier and this is really equivalent to a property access node.
     //
     _resolvePropertyAccess(prefix, identifier);
     return null;
   }
 
   @override
+  Object visitPrefixExpression(PrefixExpression node) {
+    sc.Token operator = node.operator;
+    sc.TokenType operatorType = operator.type;
+    if (operatorType.isUserDefinableOperator ||
+        operatorType == sc.TokenType.PLUS_PLUS ||
+        operatorType == sc.TokenType.MINUS_MINUS) {
+      Expression operand = node.operand;
+      String methodName = _getPrefixOperator(node);
+      DartType staticType = _getStaticType(operand);
+      MethodElement staticMethod =
+          _lookUpMethod(operand, staticType, methodName);
+      node.staticElement = staticMethod;
+      DartType propagatedType = _getPropagatedType(operand);
+      MethodElement propagatedMethod =
+          _lookUpMethod(operand, propagatedType, methodName);
+      node.propagatedElement = propagatedMethod;
+      if (_shouldReportMissingMember(staticType, staticMethod)) {
+        _recordUndefinedToken(
+            staticType.element,
+            StaticTypeWarningCode.UNDEFINED_OPERATOR,
+            operator,
+            [methodName, staticType.displayName]);
+      } else if (_enableHints &&
+          _shouldReportMissingMember(propagatedType, propagatedMethod) &&
+          !_memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
+        _recordUndefinedToken(
+            propagatedType.element,
+            HintCode.UNDEFINED_OPERATOR,
+            operator,
+            [methodName, propagatedType.displayName]);
+      }
+    }
+    return null;
+  }
+
+  @override
   Object visitPropertyAccess(PropertyAccess node) {
     Expression target = node.realTarget;
     if (target is SuperExpression && !_isSuperInValidContext(target)) {
       return null;
     }
     SimpleIdentifier propertyName = node.propertyName;
     _resolvePropertyAccess(target, propertyName);
     return null;
   }
 
@@ skipping 638 matching lines @@
       return identical(parent.prefix, node);
     } else if (parent is PrefixedIdentifier) {
       return true;
     } else if (parent is MethodInvocation) {
       return identical(parent.target, node);
     }
     return false;
   }
 
   /**
+   * Return the target of a break or continue statement, and update the static
+   * element of its label (if any).  [parentNode] is the AST node of the break
+   * or continue statement, [labelNode] is the label contained in that
+   * statement (if any), and [isContinue] is true if the node being visited is
+   * a continue statement.
+   */
+  AstNode _lookupBreakOrContinueTarget(AstNode parentNode,
+      SimpleIdentifier labelNode, bool isContinue) {
+    if (labelNode == null) {
+      return _resolver.getUnlabeledBreakOrContinueTarget(isContinue);
+    } else {
+      LabelScope labelScope = _resolver.labelScope;
+      if (labelScope == null) {
+        // There are no labels in scope, so by definition the label is
+        // undefined.
+        _resolver.reportErrorForNode(
+            CompileTimeErrorCode.LABEL_UNDEFINED,
+            labelNode,
+            [labelNode.name]);
+        return null;
+      }
+      LabelScope definingScope = labelScope.lookup(labelNode.name);
+      if (definingScope == null) {
+        // No definition of the given label name could be found in any
+        // enclosing scope.
+        _resolver.reportErrorForNode(
+            CompileTimeErrorCode.LABEL_UNDEFINED,
+            labelNode,
+            [labelNode.name]);
+        return null;
+      }
+      // The target has been found.
+      labelNode.staticElement = definingScope.element;
+      ExecutableElement labelContainer =
+          definingScope.element.getAncestor((element) => element is ExecutableElement);
+      if (!identical(labelContainer, _resolver.enclosingFunction)) {
+        _resolver.reportErrorForNode(
+            CompileTimeErrorCode.LABEL_IN_OUTER_SCOPE,
+            labelNode,
+            [labelNode.name]);
+      }
+      return definingScope.node;
+    }
+  }
+
+  /**
    * Look up the getter with the given name in the given type. Return the element representing the
    * getter that was found, or `null` if there is no getter with the given name.
    *
    * @param target the target of the invocation, or `null` if there is no target
    * @param type the type in which the getter is defined
    * @param getterName the name of the getter being looked up
    * @return the element representing the getter that was found
    */
   PropertyAccessorElement _lookUpGetter(Expression target, DartType type,
       String getterName) {
@@ skipping 68 matching lines @@
       return null;
     }
     return _lookUpGetterInInterfaces(
         superclass,
         true,
         getterName,
         visitedInterfaces);
   }
 
   /**
+   * Look up the method or getter with the given name in the given type. Return the element
+   * representing the method or getter that was found, or `null` if there is no method or
+   * getter with the given name.
+   *
+   * @param type the type in which the method or getter is defined
+   * @param memberName the name of the method or getter being looked up
+   * @return the element representing the method or getter that was found
+   */
+  ExecutableElement _lookupGetterOrMethod(DartType type, String memberName) {
+    type = _resolveTypeParameter(type);
+    if (type is InterfaceType) {
+      InterfaceType interfaceType = type;
+      ExecutableElement member =
+          interfaceType.lookUpMethod(memberName, _definingLibrary);
+      if (member != null) {
+        return member;
+      }
+      member = interfaceType.lookUpGetter(memberName, _definingLibrary);
+      if (member != null) {
+        return member;
+      }
+      return _lookUpGetterOrMethodInInterfaces(
+          interfaceType,
+          false,
+          memberName,
+          new HashSet<ClassElement>());
+    }
+    return null;
+  }
+
+  /**
    * Look up the method or getter with the given name in the interfaces implemented by the given
    * type, either directly or indirectly. Return the element representing the method or getter that
    * was found, or `null` if there is no method or getter with the given name.
    *
    * @param targetType the type in which the method or getter might be defined
    * @param includeTargetType `true` if the search should include the target type
    * @param memberName the name of the method or getter being looked up
    * @param visitedInterfaces a set containing all of the interfaces that have been examined, used
    *          to prevent infinite recursion and to optimize the search
    * @return the element representing the method or getter that was found
@@ skipping 140 matching lines @@
       return null;
     }
     return _lookUpMethodInInterfaces(
         superclass,
         true,
         methodName,
         visitedInterfaces);
   }
 
   /**
+   * Look up all methods of a given name defined on a union type.
+   *
+   * @param target
+   * @param type
+   * @param methodName
+   * @return all methods named `methodName` defined on the union type `type`.
+   */
+  Set<ExecutableElement> _lookupMethods(Expression target, UnionType type,
+      String methodName) {
+    Set<ExecutableElement> methods = new HashSet<ExecutableElement>();
+    bool allElementsHaveMethod = true;
+    for (DartType t in type.elements) {
+      MethodElement m = _lookUpMethod(target, t, methodName);
+      if (m != null) {
+        methods.add(m);
+      } else {
+        allElementsHaveMethod = false;
+      }
+    }
+    // For strict union types we require that all types in the union define the
+    // method.
+    if (AnalysisEngine.instance.strictUnionTypes) {
+      if (allElementsHaveMethod) {
+        return methods;
+      } else {
+        return new Set<ExecutableElement>();
+      }
+    } else {
+      return methods;
+    }
+  }
+
+  /**
    * Look up the setter with the given name in the given type. Return the element representing the
    * setter that was found, or `null` if there is no setter with the given name.
    *
    * @param target the target of the invocation, or `null` if there is no target
    * @param type the type in which the setter is defined
    * @param setterName the name of the setter being looked up
    * @return the element representing the setter that was found
    */
   PropertyAccessorElement _lookUpSetter(Expression target, DartType type,
       String setterName) {
@@ skipping 68 matching lines @@
       return null;
     }
     return _lookUpSetterInInterfaces(
         superclass,
         true,
         setterName,
         visitedInterfaces);
   }
 
   /**
-   * Look up the method or getter with the given name in the given type. Return the element
-   * representing the method or getter that was found, or `null` if there is no method or
-   * getter with the given name.
-   *
-   * @param type the type in which the method or getter is defined
-   * @param memberName the name of the method or getter being looked up
-   * @return the element representing the method or getter that was found
-   */
-  ExecutableElement _lookupGetterOrMethod(DartType type, String memberName) {
-    type = _resolveTypeParameter(type);
-    if (type is InterfaceType) {
-      InterfaceType interfaceType = type;
-      ExecutableElement member =
-          interfaceType.lookUpMethod(memberName, _definingLibrary);
-      if (member != null) {
-        return member;
-      }
-      member = interfaceType.lookUpGetter(memberName, _definingLibrary);
-      if (member != null) {
-        return member;
-      }
-      return _lookUpGetterOrMethodInInterfaces(
-          interfaceType,
-          false,
-          memberName,
-          new HashSet<ClassElement>());
-    }
-    return null;
-  }
-
-  /**
-   * Find the element corresponding to the given label node in the current label scope.
-   *
-   * @param parentNode the node containing the given label
-   * @param labelNode the node representing the label being looked up
-   * @return the element corresponding to the given label node in the current scope
-   */
-  LabelElementImpl _lookupLabel(AstNode parentNode,
-      SimpleIdentifier labelNode) {
-    LabelScope labelScope = _resolver.labelScope;
-    LabelElementImpl labelElement = null;
-    if (labelNode == null) {
-      if (labelScope == null) {
-        // TODO(brianwilkerson) Do we need to report this error, or is this
-        // condition always caught in the parser?
-        // reportError(ResolverErrorCode.BREAK_OUTSIDE_LOOP);
-      } else {
-        labelElement =
-            labelScope.lookup(LabelScope.EMPTY_LABEL) as LabelElementImpl;
-        if (labelElement == null) {
-          // TODO(brianwilkerson) Do we need to report this error, or is this
-          // condition always caught in the parser?
-          // reportError(ResolverErrorCode.BREAK_OUTSIDE_LOOP);
-        }
-        //
-        // The label element that was returned was a marker for look-up and
-        // isn't stored in the element model.
-        //
-        labelElement = null;
-      }
-    } else {
-      if (labelScope == null) {
-        _resolver.reportErrorForNode(
-            CompileTimeErrorCode.LABEL_UNDEFINED,
-            labelNode,
-            [labelNode.name]);
-      } else {
-        labelElement = labelScope.lookup(labelNode.name) as LabelElementImpl;
-        if (labelElement == null) {
-          _resolver.reportErrorForNode(
-              CompileTimeErrorCode.LABEL_UNDEFINED,
-              labelNode,
-              [labelNode.name]);
-        } else {
-          labelNode.staticElement = labelElement;
-        }
-      }
-    }
-    if (labelElement != null) {
-      ExecutableElement labelContainer =
-          labelElement.getAncestor((element) => element is ExecutableElement);
-      if (!identical(labelContainer, _resolver.enclosingFunction)) {
-        _resolver.reportErrorForNode(
-            CompileTimeErrorCode.LABEL_IN_OUTER_SCOPE,
-            labelNode,
-            [labelNode.name]);
-        labelElement = null;
-      }
-    }
-    return labelElement;
-  }
-
-  /**
-   * Look up all methods of a given name defined on a union type.
-   *
-   * @param target
-   * @param type
-   * @param methodName
-   * @return all methods named `methodName` defined on the union type `type`.
-   */
-  Set<ExecutableElement> _lookupMethods(Expression target, UnionType type,
-      String methodName) {
-    Set<ExecutableElement> methods = new HashSet<ExecutableElement>();
-    bool allElementsHaveMethod = true;
-    for (DartType t in type.elements) {
-      MethodElement m = _lookUpMethod(target, t, methodName);
-      if (m != null) {
-        methods.add(m);
-      } else {
-        allElementsHaveMethod = false;
-      }
-    }
-    // For strict union types we require that all types in the union define the
-    // method.
-    if (AnalysisEngine.instance.strictUnionTypes) {
-      if (allElementsHaveMethod) {
-        return methods;
-      } else {
-        return new Set<ExecutableElement>();
-      }
-    } else {
-      return methods;
-    }
-  }
-
-  /**
    * Given some class element, this method uses [subtypeManager] to find the set of all
    * subtypes; the subtypes are then searched for a member (method, getter, or setter), that matches
    * a passed
    *
    * @param element the class element to search the subtypes of, if a non-ClassElement element is
    *          passed, then `false` is returned
    * @param memberName the member name to search for
    * @param asMethod `true` if the methods should be searched for in the subtypes
    * @param asAccessor `true` if the accessors (getters and setters) should be searched for in
    *          the subtypes
@@ skipping 1030 matching lines @@
   @override
   Element get staticElement => null;
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {
   }
 }