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

pkg/analyzer/test/generated/resolver_test.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_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 679 matching lines @@
 class A {
   final int x;
   const A(this.x);
 }
 var v = const A(null);''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_fieldFormalParameterAssignableToField_typeSubstitution() {
-    // foo has the runtime type dynamic -> dynamic, so it should be assignable
-    // to A.f.
-    Source source = addSource(r'''
-class A<T> {
-  final T x;
-  const A(this.x);
-}
-var v = const A<int>(3);''');
-    resolve(source);
-    assertNoErrors(source);
-    verify([source]);
-  }
-
   void test_fieldFormalParameterAssignableToField_typedef() {
     // foo has the runtime type dynamic -> dynamic, so it should be assignable
     // to A.f.
     Source source = addSource(r'''
 typedef String Int2String(int x);
 class A {
   final Int2String f;
   const A(this.f);
 }
 foo(x) => 1;
 var v = const A(foo);''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
+  }
+
+  void test_fieldFormalParameterAssignableToField_typeSubstitution() {
+    // foo has the runtime type dynamic -> dynamic, so it should be assignable
+    // to A.f.
+    Source source = addSource(r'''
+class A<T> {
+  final T x;
+  const A(this.x);
+}
+var v = const A<int>(3);''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField() {
     Source source = addSource(r'''
 class A {
   final int x;
   const A(this.x);
 }
 var v = const A('foo');''');
     resolve(source);
@@ skipping 602 matching lines @@
     left.propagatedType = numType;
     BinaryExpression expression =
         AstFactory.binaryExpression(left, TokenType.PLUS, AstFactory.identifier3("j"));
     _resolveNode(expression);
     expect(expression.staticElement, isNull);
     expect(expression.propagatedElement, getMethod(numType, "+"));
     _listener.assertNoErrors();
   }
 
   void test_visitBreakStatement_withLabel() {
+    // loop: while (true) {
+    //   break loop;
+    // }
     String label = "loop";
     LabelElementImpl labelElement =
         new LabelElementImpl(AstFactory.identifier3(label), false, false);
-    BreakStatement statement = AstFactory.breakStatement2(label);
-    expect(_resolveBreak(statement, labelElement), same(labelElement));
+    BreakStatement breakStatement = AstFactory.breakStatement2(label);
+    Expression condition = AstFactory.booleanLiteral(true);
+    WhileStatement whileStatement =
+        AstFactory.whileStatement(condition, breakStatement);
+    expect(
+        _resolveBreak(breakStatement, labelElement, whileStatement),
+        same(labelElement));
+    expect(breakStatement.target, same(whileStatement));
     _listener.assertNoErrors();
   }
 
   void test_visitBreakStatement_withoutLabel() {
     BreakStatement statement = AstFactory.breakStatement();
-    _resolveStatement(statement, null);
+    _resolveStatement(statement, null, null);
     _listener.assertNoErrors();
   }
 
   void test_visitConstructorName_named() {
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String constructorName = "a";
     ConstructorElement constructor =
         ElementFactory.constructorElement2(classA, constructorName);
     classA.constructors = <ConstructorElement>[constructor];
     ConstructorName name =
@@ skipping 10 matching lines @@
         ElementFactory.constructorElement2(classA, constructorName);
     classA.constructors = <ConstructorElement>[constructor];
     ConstructorName name =
         AstFactory.constructorName(AstFactory.typeName(classA), constructorName);
     _resolveNode(name);
     expect(name.staticElement, same(constructor));
     _listener.assertNoErrors();
   }
 
   void test_visitContinueStatement_withLabel() {
+    // loop: while (true) {
+    //   continue loop;
+    // }
     String label = "loop";
     LabelElementImpl labelElement =
         new LabelElementImpl(AstFactory.identifier3(label), false, false);
-    ContinueStatement statement = AstFactory.continueStatement(label);
-    expect(_resolveContinue(statement, labelElement), same(labelElement));
+    ContinueStatement continueStatement = AstFactory.continueStatement(label);
+    Expression condition = AstFactory.booleanLiteral(true);
+    WhileStatement whileStatement =
+        AstFactory.whileStatement(condition, continueStatement);
+    expect(
+        _resolveContinue(continueStatement, labelElement, whileStatement),
+        same(labelElement));
+    expect(continueStatement.target, same(whileStatement));
     _listener.assertNoErrors();
   }
 
   void test_visitContinueStatement_withoutLabel() {
     ContinueStatement statement = AstFactory.continueStatement();
-    _resolveStatement(statement, null);
+    _resolveStatement(statement, null, null);
     _listener.assertNoErrors();
   }
 
   void test_visitExportDirective_noCombinators() {
     ExportDirective directive = AstFactory.exportDirective2(null);
     directive.element = ElementFactory.exportFor(
         ElementFactory.library(_definingLibrary.context, "lib"));
     _resolveNode(directive);
     _listener.assertNoErrors();
   }
@@ skipping 191 matching lines @@
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier operand = AstFactory.identifier3("i");
     operand.staticType = numType;
     PostfixExpression expression =
         AstFactory.postfixExpression(operand, TokenType.PLUS_PLUS);
     _resolveNode(expression);
     expect(expression.staticElement, getMethod(numType, "+"));
     _listener.assertNoErrors();
   }
 
-  void test_visitPrefixExpression() {
-    InterfaceType numType = _typeProvider.numType;
-    SimpleIdentifier operand = AstFactory.identifier3("i");
-    operand.staticType = numType;
-    PrefixExpression expression =
-        AstFactory.prefixExpression(TokenType.PLUS_PLUS, operand);
-    _resolveNode(expression);
-    expect(expression.staticElement, getMethod(numType, "+"));
-    _listener.assertNoErrors();
-  }
-
   void test_visitPrefixedIdentifier_dynamic() {
     DartType dynamicType = _typeProvider.dynamicType;
     SimpleIdentifier target = AstFactory.identifier3("a");
     VariableElementImpl variable = ElementFactory.localVariableElement(target);
     variable.type = dynamicType;
     target.staticElement = variable;
     target.staticType = dynamicType;
     PrefixedIdentifier identifier =
         AstFactory.identifier(target, AstFactory.identifier3("b"));
     _resolveNode(identifier);
@@ skipping 90 matching lines @@
         identifier,
         TokenType.EQ,
         AstFactory.nullLiteral());
     // resolve
     _resolveNode(identifier);
     expect(identifier.staticElement, same(setter));
     expect(identifier.identifier.staticElement, same(setter));
     _listener.assertNoErrors();
   }
 
+  void test_visitPrefixExpression() {
+    InterfaceType numType = _typeProvider.numType;
+    SimpleIdentifier operand = AstFactory.identifier3("i");
+    operand.staticType = numType;
+    PrefixExpression expression =
+        AstFactory.prefixExpression(TokenType.PLUS_PLUS, operand);
+    _resolveNode(expression);
+    expect(expression.staticElement, getMethod(numType, "+"));
+    _listener.assertNoErrors();
+  }
+
   void test_visitPropertyAccess_getter_identifier() {
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "b";
     PropertyAccessorElement getter =
         ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement>[getter];
     SimpleIdentifier target = AstFactory.identifier3("a");
     target.staticType = classA.type;
     PropertyAccess access = AstFactory.propertyAccess2(target, getterName);
     _resolveNode(access);
@@ skipping 158 matching lines @@
     try {
       return _visitor.elementResolver_J2DAccessor as ElementResolver;
     } catch (exception) {
       throw new IllegalArgumentException(
           "Could not create resolver",
           exception);
     }
   }
 
   /**
-   * Return the element associated with the label of the given statement after the resolver has
-   * resolved the statement.
-   *
-   * @param statement the statement to be resolved
-   * @param labelElement the label element to be defined in the statement's label scope
-   * @return the element to which the statement's label was resolved
+   * Return the element associated with the label of [statement] after the
+   * resolver has resolved it.  [labelElement] is the label element to be
+   * defined in the statement's label scope, and [labelTarget] is the statement
+   * the label resolves to.
    */
-  Element _resolveBreak(BreakStatement statement,
-      LabelElementImpl labelElement) {
-    _resolveStatement(statement, labelElement);
+  Element _resolveBreak(BreakStatement statement, LabelElementImpl labelElement,
+      Statement labelTarget) {
+    _resolveStatement(statement, labelElement, labelTarget);
     return statement.label.staticElement;
   }
 
   /**
-   * Return the element associated with the label of the given statement after the resolver has
-   * resolved the statement.
+   * Return the element associated with the label [statement] after the
+   * resolver has resolved it.  [labelElement] is the label element to be
+   * defined in the statement's label scope, and [labelTarget] is the AST node
+   * the label resolves to.
    *
    * @param statement the statement to be resolved
    * @param labelElement the label element to be defined in the statement's label scope
    * @return the element to which the statement's label was resolved
    */
   Element _resolveContinue(ContinueStatement statement,
-      LabelElementImpl labelElement) {
-    _resolveStatement(statement, labelElement);
+      LabelElementImpl labelElement, AstNode labelTarget) {
+    _resolveStatement(statement, labelElement, labelTarget);
     return statement.label.staticElement;
   }
 
   /**
    * Return the element associated with the given identifier after the resolver has resolved the
    * identifier.
    *
    * @param node the expression to be resolved
    * @param definedElements the elements that are to be defined in the scope in which the element is
    *          being resolved
@@ skipping 76 matching lines @@
   }
 
   /**
    * Return the element associated with the label of the given statement after the resolver has
    * resolved the statement.
    *
    * @param statement the statement to be resolved
    * @param labelElement the label element to be defined in the statement's label scope
    * @return the element to which the statement's label was resolved
    */
-  void _resolveStatement(Statement statement, LabelElementImpl labelElement) {
+  void _resolveStatement(Statement statement, LabelElementImpl labelElement,
+      AstNode labelTarget) {
     try {
       LabelScope outerScope = _visitor.labelScope_J2DAccessor as LabelScope;
       try {
         LabelScope innerScope;
         if (labelElement == null) {
-          innerScope = new LabelScope.con1(outerScope, false, false);
+          innerScope = outerScope;
         } else {
           innerScope =
-              new LabelScope.con2(outerScope, labelElement.name, labelElement);
+              new LabelScope(outerScope, labelElement.name, labelTarget, labelElement);
         }
         _visitor.labelScope_J2DAccessor = innerScope;
         statement.accept(_resolver);
       } finally {
         _visitor.labelScope_J2DAccessor = outerScope;
       }
     } catch (exception) {
       throw new IllegalArgumentException("Could not resolve node", exception);
     }
   }
@@ skipping 602 matching lines @@
   return;
   var two = 2;
   return;
   var three = 3;
 }''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
-  void test_deprecatedAnnotationUse_Deprecated() {
-    Source source = addSource(r'''
-class A {
-  @Deprecated('0.9')
-  m() {}
-  n() {m();}
-}''');
-    resolve(source);
-    assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
-    verify([source]);
-  }
-
   void test_deprecatedAnnotationUse_assignment() {
     Source source = addSource(r'''
 class A {
   @deprecated
   A operator+(A a) { return a; }
 }
 f(A a) {
   A b;
   a += b;
 }''');
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
+    verify([source]);
+  }
+
+  void test_deprecatedAnnotationUse_Deprecated() {
+    Source source = addSource(r'''
+class A {
+  @Deprecated('0.9')
+  m() {}
+  n() {m();}
+}''');
+    resolve(source);
+    assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_deprecated() {
     Source source = addSource(r'''
 class A {
   @deprecated
   m() {}
   n() {m();}
 }''');
@@ skipping 900 matching lines @@
 _f(int p) {
   _f(p - 1);
 }
 main() {
 }''');
     resolve(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
+  void test_unusedElement_getter_isUsed_invocation_implicitThis() {
+    enableUnusedElement = true;
+    Source source = addSource(r'''
+class A {
+  get _g => null;
+  useGetter() {
+    var v = _g;
+  }
+}''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_unusedElement_getter_isUsed_invocation_PrefixedIdentifier() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   get _g => null;
 }
 main(A a) {
   var v = a._g;
 }
 ''');
     resolve(source);
-    assertNoErrors(source);
-    verify([source]);
-  }
-
-  void test_unusedElement_getter_isUsed_invocation_PropertyAccess() {
-    enableUnusedElement = true;
-    Source source = addSource(r'''
-class A {
-  get _g => null;
-}
-main() {
-  var v = new A()._g;
-}
-''');
-    resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_unusedElement_getter_isUsed_invocation_implicitThis() {
+  void test_unusedElement_getter_isUsed_invocation_PropertyAccess() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   get _g => null;
-  useGetter() {
-    var v = _g;
-  }
-}''');
+}
+main() {
+  var v = new A()._g;
+}
+''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_getter_notUsed_noReference() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   get _g => null;
 }''');
     resolve(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
   void test_unusedElement_getter_notUsed_referenceFromItself() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   get _g {
     return _g;
   }
 }''');
     resolve(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
-  void test_unusedElement_method_isUsed_hasReference_PrefixedIdentifier() {
-    enableUnusedElement = true;
-    Source source = addSource(r'''
-class A {
-  _m() {}
-}
-main(A a) {
-  a._m;
-}''');
-    resolve(source);
-    assertNoErrors(source);
-    verify([source]);
-  }
-
-  void test_unusedElement_method_isUsed_hasReference_PropertyAccess() {
-    enableUnusedElement = true;
-    Source source = addSource(r'''
-class A {
-  _m() {}
-}
-main() {
-  new A()._m;
-}''');
-    resolve(source);
-    assertNoErrors(source);
-    verify([source]);
-  }
-
   void test_unusedElement_method_isUsed_hasReference_implicitThis() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
+  _m() {}
+  useMethod() {
+    print(_m);
+  }
+}
+print(x) {}
+''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_unusedElement_method_isUsed_hasReference_implicitThis_subclass() {
+    enableUnusedElement = true;
+    Source source = addSource(r'''
+class A {
   _m() {}
   useMethod() {
     print(_m);
   }
 }
+class B extends A {
+  _m() {}
+}
 print(x) {}
 ''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_unusedElement_method_isUsed_hasReference_implicitThis_subclass() {
+  void test_unusedElement_method_isUsed_hasReference_PrefixedIdentifier() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   _m() {}
-  useMethod() {
-    print(_m);
-  }
 }
-class B extends A {
-  _m() {}
-}
-print(x) {}
-''');
+main(A a) {
+  a._m;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_unusedElement_method_isUsed_invocation_MemberElement() {
+  void test_unusedElement_method_isUsed_hasReference_PropertyAccess() {
     enableUnusedElement = true;
     Source source = addSource(r'''
-class A<T> {
-  _m(T t) {}
+class A {
+  _m() {}
 }
-main(A<int> a) {
-  a._m(0);
+main() {
+  new A()._m;
 }''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_method_isUsed_invocation_implicitThis() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
@@ skipping 17 matching lines @@
   }
 }
 class B extends A {
   _m() {}
 }''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_unusedElement_method_isUsed_invocation_MemberElement() {
+    enableUnusedElement = true;
+    Source source = addSource(r'''
+class A<T> {
+  _m(T t) {}
+}
+main(A<int> a) {
+  a._m(0);
+}''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_unusedElement_method_isUsed_invocation_propagated() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   _m() {}
 }
 main() {
   var a = new A();
   a._m();
 }''');
@@ skipping 78 matching lines @@
 class A {
   static _m(int p) {
     _m(p - 1);
   }
 }''');
     resolve(source);
     assertErrors(source, [HintCode.UNUSED_ELEMENT]);
     verify([source]);
   }
 
+  void test_unusedElement_setter_isUsed_invocation_implicitThis() {
+    enableUnusedElement = true;
+    Source source = addSource(r'''
+class A {
+  set _s(x) {}
+  useSetter() {
+    _s = 42;
+  }
+}''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_unusedElement_setter_isUsed_invocation_PrefixedIdentifier() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   set _s(x) {}
 }
 main(A a) {
   a._s = 42;
 }
 ''');
     resolve(source);
-    assertNoErrors(source);
-    verify([source]);
-  }
-
-  void test_unusedElement_setter_isUsed_invocation_PropertyAccess() {
-    enableUnusedElement = true;
-    Source source = addSource(r'''
-class A {
-  set _s(x) {}
-}
-main() {
-  new A()._s = 42;
-}
-''');
-    resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_unusedElement_setter_isUsed_invocation_implicitThis() {
+  void test_unusedElement_setter_isUsed_invocation_PropertyAccess() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   set _s(x) {}
-  useSetter() {
-    _s = 42;
-  }
-}''');
+}
+main() {
+  new A()._s = 42;
+}
+''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedElement_setter_notUsed_noReference() {
     enableUnusedElement = true;
     Source source = addSource(r'''
 class A {
   set _s(x) {}
@@ skipping 3541 matching lines @@
     if (operandType == null || operandType.isDynamic) {
       return null;
     }
     return _checkResolved(
         node,
         node.staticElement,
         (node) => node is MethodElement);
   }
 
   @override
+  Object visitPrefixedIdentifier(PrefixedIdentifier node) {
+    SimpleIdentifier prefix = node.prefix;
+    prefix.accept(this);
+    DartType prefixType = prefix.staticType;
+    if (prefixType == null || prefixType.isDynamic) {
+      return null;
+    }
+    return _checkResolved(node, node.staticElement, null);
+  }
+
+  @override
   Object visitPrefixExpression(PrefixExpression node) {
     node.visitChildren(this);
     if (!node.operator.isUserDefinableOperator) {
       return null;
     }
     DartType operandType = node.operand.staticType;
     if (operandType == null || operandType.isDynamic) {
       return null;
     }
     return _checkResolved(
         node,
         node.staticElement,
         (node) => node is MethodElement);
   }
 
   @override
-  Object visitPrefixedIdentifier(PrefixedIdentifier node) {
-    SimpleIdentifier prefix = node.prefix;
-    prefix.accept(this);
-    DartType prefixType = prefix.staticType;
-    if (prefixType == null || prefixType.isDynamic) {
-      return null;
-    }
-    return _checkResolved(node, node.staticElement, null);
-  }
-
-  @override
   Object visitPropertyAccess(PropertyAccess node) {
     Expression target = node.realTarget;
     target.accept(this);
     DartType targetType = target.staticType;
     if (targetType == null || targetType.isDynamic) {
       return null;
     }
     return node.propertyName.accept(this);
   }
 
@@ skipping 385 matching lines @@
    * @return the source that was created
    */
   FileBasedSource _createNamedSource(String fileName) {
     FileBasedSource source =
         new FileBasedSource.con1(FileUtilities2.createFile(fileName));
     analysisContext2.setContents(source, "");
     return source;
   }
 }
 
+class Scope_EnclosedScopeTest_test_define_duplicate extends Scope {
+  GatheringErrorListener listener;
+
+  Scope_EnclosedScopeTest_test_define_duplicate(this.listener) : super();
+
+  @override
+  AnalysisErrorListener get errorListener => listener;
+
+  @override
+  Element internalLookup(Identifier identifier, String name,
+      LibraryElement referencingLibrary) =>
+      null;
+}
+
+class Scope_EnclosedScopeTest_test_define_normal extends Scope {
+  GatheringErrorListener listener;
+
+  Scope_EnclosedScopeTest_test_define_normal(this.listener) : super();
+
+  @override
+  AnalysisErrorListener get errorListener => listener;
+
+  @override
+  Element internalLookup(Identifier identifier, String name,
+      LibraryElement referencingLibrary) =>
+      null;
+}
+
 class ScopeTest extends ResolverTestCase {
   void test_define_duplicate() {
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ScopeTest_TestScope scope = new ScopeTest_TestScope(errorListener);
     VariableElement element1 =
         ElementFactory.localVariableElement(AstFactory.identifier3("v1"));
     VariableElement element2 =
         ElementFactory.localVariableElement(AstFactory.identifier3("v1"));
     scope.define(element1);
     scope.define(element2);
@@ skipping 37 matching lines @@
   final AnalysisErrorListener errorListener;
 
   ScopeTest_TestScope(this.errorListener);
 
   @override
   Element internalLookup(Identifier identifier, String name,
       LibraryElement referencingLibrary) =>
       localLookup(name, referencingLibrary);
 }
 
-class Scope_EnclosedScopeTest_test_define_duplicate extends Scope {
-  GatheringErrorListener listener;
-
-  Scope_EnclosedScopeTest_test_define_duplicate(this.listener) : super();
-
-  @override
-  AnalysisErrorListener get errorListener => listener;
-
-  @override
-  Element internalLookup(Identifier identifier, String name,
-      LibraryElement referencingLibrary) =>
-      null;
-}
-
-class Scope_EnclosedScopeTest_test_define_normal extends Scope {
-  GatheringErrorListener listener;
-
-  Scope_EnclosedScopeTest_test_define_normal(this.listener) : super();
-
-  @override
-  AnalysisErrorListener get errorListener => listener;
-
-  @override
-  Element internalLookup(Identifier identifier, String name,
-      LibraryElement referencingLibrary) =>
-      null;
-}
-
 class SimpleResolverTest extends ResolverTestCase {
   void fail_staticInvocation() {
     Source source = addSource(r'''
 class A {
   static int get g => (a,b) => 0;
 }
 class B {
   f() {
     A.g(1,0);
   }
 }''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_argumentResolution_required_matching() {
+    Source source = addSource(r'''
+class A {
+  void f() {
+    g(1, 2, 3);
+  }
+  void g(a, b, c) {}
+}''');
+    _validateArgumentResolution(source, [0, 1, 2]);
+  }
+
+  void test_argumentResolution_required_tooFew() {
+    Source source = addSource(r'''
+class A {
+  void f() {
+    g(1, 2);
+  }
+  void g(a, b, c) {}
+}''');
+    _validateArgumentResolution(source, [0, 1]);
+  }
+
+  void test_argumentResolution_required_tooMany() {
+    Source source = addSource(r'''
+class A {
+  void f() {
+    g(1, 2, 3);
+  }
+  void g(a, b) {}
+}''');
+    _validateArgumentResolution(source, [0, 1, -1]);
+  }
+
   void test_argumentResolution_requiredAndNamed_extra() {
     Source source = addSource(r'''
 class A {
   void f() {
     g(1, 2, c: 3, d: 4);
   }
   void g(a, b, {c}) {}
 }''');
     _validateArgumentResolution(source, [0, 1, 2, -1]);
   }
@@ skipping 46 matching lines @@
     Source source = addSource(r'''
 class A {
   void f() {
     g(1, 2, 3, 4);
   }
   void g(a, b, [c]) {}
 }''');
     _validateArgumentResolution(source, [0, 1, 2, -1]);
   }
 
-  void test_argumentResolution_required_matching() {
-    Source source = addSource(r'''
-class A {
-  void f() {
-    g(1, 2, 3);
-  }
-  void g(a, b, c) {}
-}''');
-    _validateArgumentResolution(source, [0, 1, 2]);
-  }
-
-  void test_argumentResolution_required_tooFew() {
-    Source source = addSource(r'''
-class A {
-  void f() {
-    g(1, 2);
-  }
-  void g(a, b, c) {}
-}''');
-    _validateArgumentResolution(source, [0, 1]);
-  }
-
-  void test_argumentResolution_required_tooMany() {
-    Source source = addSource(r'''
-class A {
-  void f() {
-    g(1, 2, 3);
-  }
-  void g(a, b) {}
-}''');
-    _validateArgumentResolution(source, [0, 1, -1]);
-  }
-
   void test_argumentResolution_setter_propagated() {
     Source source = addSource(r'''
 main() {
   var a = new A();
   a.sss = 0;
 }
 class A {
   set sss(x) {}
 }''');
     LibraryElement library = resolve(source);
@@ skipping 116 matching lines @@
     Expression rhs = assignment.rightHandSide;
     ParameterElement parameter = rhs.staticParameterElement;
     expect(parameter, isNotNull);
     expect(parameter.displayName, "x");
     // validate
     ClassElement classB = unit.types[1];
     PropertyAccessorElement setter = classB.accessors[0];
     expect(setter.parameters[0], same(parameter));
   }
 
+  void test_breakTarget_labeled() {
+    // Verify that the target of the label is correctly found and is recorded
+    // as the unlabeled portion of the statement.
+    String text = r'''
+void f() {
+  loop1: while (true) {
+    loop2: for (int i = 0; i < 10; i++) {
+      break loop1;
+      break loop2;
+    }
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(text);
+    WhileStatement whileStatement = EngineTestCase.findNode(
+        unit,
+        text,
+        'while (true)',
+        (n) => n is WhileStatement);
+    ForStatement forStatement =
+        EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
+    BreakStatement break1 =
+        EngineTestCase.findNode(unit, text, 'break loop1', (n) => n is BreakStatement);
+    BreakStatement break2 =
+        EngineTestCase.findNode(unit, text, 'break loop2', (n) => n is BreakStatement);
+    expect(break1.target, same(whileStatement));
+    expect(break2.target, same(forStatement));
+  }
+
+  void test_breakTarget_unlabeledBreakFromDo() {
+    String text = r'''
+void f() {
+  do {
+    break;
+  } while (true);
+}
+''';
+    CompilationUnit unit = resolveSource(text);
+    DoStatement doStatement =
+        EngineTestCase.findNode(unit, text, 'do', (n) => n is DoStatement);
+    BreakStatement breakStatement =
+        EngineTestCase.findNode(unit, text, 'break', (n) => n is BreakStatement);
+    expect(breakStatement.target, same(doStatement));
+  }
+
+  void test_breakTarget_unlabeledBreakFromFor() {
+    String text = r'''
+void f() {
+  for (int i = 0; i < 10; i++) {
+    break;
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(text);
+    ForStatement forStatement =
+        EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
+    BreakStatement breakStatement =
+        EngineTestCase.findNode(unit, text, 'break', (n) => n is BreakStatement);
+    expect(breakStatement.target, same(forStatement));
+  }
+
+  void test_breakTarget_unlabeledBreakFromForEach() {
+    String text = r'''
+void f() {
+  for (x in []) {
+    break;
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(text);
+    ForEachStatement forStatement =
+        EngineTestCase.findNode(unit, text, 'for', (n) => n is ForEachStatement);
+    BreakStatement breakStatement =
+        EngineTestCase.findNode(unit, text, 'break', (n) => n is BreakStatement);
+    expect(breakStatement.target, same(forStatement));
+  }
+
+  void test_breakTarget_unlabeledBreakFromSwitch() {
+    String text = r'''
+void f() {
+  while (true) {
+    switch (0) {
+      case 0:
+        break;
+    }
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(text);
+    SwitchStatement switchStatement =
+        EngineTestCase.findNode(unit, text, 'switch', (n) => n is SwitchStatement);
+    BreakStatement breakStatement =
+        EngineTestCase.findNode(unit, text, 'break', (n) => n is BreakStatement);
+    expect(breakStatement.target, same(switchStatement));
+  }
+
+  void test_breakTarget_unlabeledBreakFromWhile() {
+    String text = r'''
+void f() {
+  while (true) {
+    break;
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(text);
+    WhileStatement whileStatement =
+        EngineTestCase.findNode(unit, text, 'while', (n) => n is WhileStatement);
+    BreakStatement breakStatement =
+        EngineTestCase.findNode(unit, text, 'break', (n) => n is BreakStatement);
+    expect(breakStatement.target, same(whileStatement));
+  }
+
+  void test_breakTarget_unlabeledBreakToOuterFunction() {
+    // Verify that unlabeled break statements can't resolve to loops in an
+    // outer function.
+    String text = r'''
+void f() {
+  while (true) {
+    void g() {
+      break;
+    }
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(text);
+    BreakStatement breakStatement =
+        EngineTestCase.findNode(unit, text, 'break', (n) => n is BreakStatement);
+    expect(breakStatement.target, isNull);
+  }
+
   void test_class_definesCall() {
     Source source = addSource(r'''
 class A {
   int call(int x) { return x; }
 }
 int f(A a) {
   return a(0);
 }''');
     resolve(source);
     assertNoErrors(source);
@@ skipping 39 matching lines @@
 
   void test_commentReference_singleLine() {
     Source source = addSource(r'''
 /// [A]
 class A {}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_continueTarget_labeled() {
+    // Verify that the target of the label is correctly found and is recorded
+    // as the unlabeled portion of the statement.
+    String text = r'''
+void f() {
+  loop1: while (true) {
+    loop2: for (int i = 0; i < 10; i++) {
+      continue loop1;
+      continue loop2;
+    }
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(text);
+    WhileStatement whileStatement = EngineTestCase.findNode(
+        unit,
+        text,
+        'while (true)',
+        (n) => n is WhileStatement);
+    ForStatement forStatement =
+        EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
+    ContinueStatement continue1 = EngineTestCase.findNode(
+        unit,
+        text,
+        'continue loop1',
+        (n) => n is ContinueStatement);
+    ContinueStatement continue2 = EngineTestCase.findNode(
+        unit,
+        text,
+        'continue loop2',
+        (n) => n is ContinueStatement);
+    expect(continue1.target, same(whileStatement));
+    expect(continue2.target, same(forStatement));
+  }
+
+  void test_continueTarget_unlabeledContinueFromDo() {
+    String text = r'''
+void f() {
+  do {
+    continue;
+  } while (true);
+}
+''';
+    CompilationUnit unit = resolveSource(text);
+    DoStatement doStatement =
+        EngineTestCase.findNode(unit, text, 'do', (n) => n is DoStatement);
+    ContinueStatement continueStatement =
+        EngineTestCase.findNode(unit, text, 'continue', (n) => n is ContinueStatement);
+    expect(continueStatement.target, same(doStatement));
+  }
+
+  void test_continueTarget_unlabeledContinueFromFor() {
+    String text = r'''
+void f() {
+  for (int i = 0; i < 10; i++) {
+    continue;
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(text);
+    ForStatement forStatement =
+        EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
+    ContinueStatement continueStatement =
+        EngineTestCase.findNode(unit, text, 'continue', (n) => n is ContinueStatement);
+    expect(continueStatement.target, same(forStatement));
+  }
+
+  void test_continueTarget_unlabeledContinueFromForEach() {
+    String text = r'''
+void f() {
+  for (x in []) {
+    continue;
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(text);
+    ForEachStatement forStatement =
+        EngineTestCase.findNode(unit, text, 'for', (n) => n is ForEachStatement);
+    ContinueStatement continueStatement =
+        EngineTestCase.findNode(unit, text, 'continue', (n) => n is ContinueStatement);
+    expect(continueStatement.target, same(forStatement));
+  }
+
+  void test_continueTarget_unlabeledContinueFromWhile() {
+    String text = r'''
+void f() {
+  while (true) {
+    continue;
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(text);
+    WhileStatement whileStatement =
+        EngineTestCase.findNode(unit, text, 'while', (n) => n is WhileStatement);
+    ContinueStatement continueStatement =
+        EngineTestCase.findNode(unit, text, 'continue', (n) => n is ContinueStatement);
+    expect(continueStatement.target, same(whileStatement));
+  }
+
+  void test_continueTarget_unlabeledContinueSkipsSwitch() {
+    String text = r'''
+void f() {
+  while (true) {
+    switch (0) {
+      case 0:
+        continue;
+    }
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(text);
+    WhileStatement whileStatement =
+        EngineTestCase.findNode(unit, text, 'while', (n) => n is WhileStatement);
+    ContinueStatement continueStatement =
+        EngineTestCase.findNode(unit, text, 'continue', (n) => n is ContinueStatement);
+    expect(continueStatement.target, same(whileStatement));
+  }
+
+  void test_continueTarget_unlabeledContinueToOuterFunction() {
+    // Verify that unlabeled continue statements can't resolve to loops in an
+    // outer function.
+    String text = r'''
+void f() {
+  while (true) {
+    void g() {
+      continue;
+    }
+  }
+}
+''';
+    CompilationUnit unit = resolveSource(text);
+    ContinueStatement continueStatement =
+        EngineTestCase.findNode(unit, text, 'continue', (n) => n is ContinueStatement);
+    expect(continueStatement.target, isNull);
+  }
+
   void test_empty() {
     Source source = addSource("");
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_entryPoint_exported() {
     addNamedSource("/two.dart", r'''
 library two;
@@ skipping 565 matching lines @@
     EngineTestCase.assertInstanceOf(
         (obj) => obj is PropertyInducingElement,
         PropertyInducingElement,
         expectedElement);
     expectedElement = (expectedElement as PropertyInducingElement).getter;
     Element actualElement =
         (declarations[1] as FunctionTypeAlias).metadata[0].name.staticElement;
     expect(actualElement, same(expectedElement));
   }
 
-  void test_methodCascades() {
-    Source source = addSource(r'''
-class A {
-  void m1() {}
-  void m2() {}
-  void m() {
-    A a = new A();
-    a..m1()
-     ..m2();
-  }
-}''');
-    resolve(source);
-    assertNoErrors(source);
-    verify([source]);
-  }
-
-  void test_methodCascades_withSetter() {
-    Source source = addSource(r'''
-class A {
-  String name;
-  void m1() {}
-  void m2() {}
-  void m() {
-    A a = new A();
-    a..m1()
-     ..name = 'name'
-     ..m2();
-  }
-}''');
-    resolve(source);
-    // failing with error code: INVOCATION_OF_NON_FUNCTION
-    assertNoErrors(source);
-    verify([source]);
-  }
-
   void test_method_fromMixin() {
     Source source = addSource(r'''
 class B {
   bar() => 1;
 }
 class A {
   foo() => 2;
 }
 
 class C extends B with A {
@@ skipping 15 matching lines @@
 class C extends B {
 }
 f(C c) {
   c.m1();
 }''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_methodCascades() {
+    Source source = addSource(r'''
+class A {
+  void m1() {}
+  void m2() {}
+  void m() {
+    A a = new A();
+    a..m1()
+     ..m2();
+  }
+}''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_methodCascades_withSetter() {
+    Source source = addSource(r'''
+class A {
+  String name;
+  void m1() {}
+  void m2() {}
+  void m() {
+    A a = new A();
+    a..m1()
+     ..name = 'name'
+     ..m2();
+  }
+}''');
+    resolve(source);
+    // failing with error code: INVOCATION_OF_NON_FUNCTION
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_resolveAgainstNull() {
     Source source = addSource(r'''
 f(var p) {
   return null == p;
 }''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_setter_inherited() {
@@ skipping 310 matching lines @@
     // 2 / 2
     BinaryExpression node = AstFactory.binaryExpression(
         _resolvedInteger(2),
         TokenType.SLASH,
         _resolvedInteger(2));
     node.staticElement = getMethod(_typeProvider.numType, "/");
     expect(_analyze(node), same(_typeProvider.doubleType));
     _listener.assertNoErrors();
   }
 
-  void test_visitBinaryExpression_starID() {
-    // 1 * 2.0
-    BinaryExpression node = AstFactory.binaryExpression(
-        _resolvedInteger(1),
-        TokenType.PLUS,
-        _resolvedDouble(2.0));
-    node.staticElement = getMethod(_typeProvider.numType, "*");
-    expect(_analyze(node), same(_typeProvider.doubleType));
-    _listener.assertNoErrors();
-  }
-
   void test_visitBinaryExpression_star_notSpecial() {
     // class A {
     //   A operator *(double value);
     // }
     // (a as A) * 2.0
     ClassElementImpl classA = ElementFactory.classElement2("A");
     InterfaceType typeA = classA.type;
     MethodElement operator =
         ElementFactory.methodElement("*", typeA, [_typeProvider.doubleType]);
     classA.methods = <MethodElement>[operator];
     BinaryExpression node = AstFactory.binaryExpression(
         AstFactory.asExpression(
             AstFactory.identifier3("a"),
             AstFactory.typeName(classA)),
         TokenType.PLUS,
         _resolvedDouble(2.0));
     node.staticElement = operator;
     expect(_analyze(node), same(typeA));
     _listener.assertNoErrors();
   }
 
+  void test_visitBinaryExpression_starID() {
+    // 1 * 2.0
+    BinaryExpression node = AstFactory.binaryExpression(
+        _resolvedInteger(1),
+        TokenType.PLUS,
+        _resolvedDouble(2.0));
+    node.staticElement = getMethod(_typeProvider.numType, "*");
+    expect(_analyze(node), same(_typeProvider.doubleType));
+    _listener.assertNoErrors();
+  }
+
   void test_visitBooleanLiteral_false() {
     // false
     Expression node = AstFactory.booleanLiteral(false);
     expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitBooleanLiteral_true() {
     // true
     Expression node = AstFactory.booleanLiteral(true);
@@ skipping 82 matching lines @@
     expectedNamedTypes["p"] = dynamicType;
     _assertFunctionType(
         _typeProvider.intType,
         null,
         null,
         expectedNamedTypes,
         resultType);
     _listener.assertNoErrors();
   }
 
+  void test_visitFunctionExpression_normal_block() {
+    // (p1, p2) {}
+    DartType dynamicType = _typeProvider.dynamicType;
+    FormalParameter p1 = AstFactory.simpleFormalParameter3("p1");
+    _setType(p1, dynamicType);
+    FormalParameter p2 = AstFactory.simpleFormalParameter3("p2");
+    _setType(p2, dynamicType);
+    FunctionExpression node = _resolvedFunctionExpression(
+        AstFactory.formalParameterList([p1, p2]),
+        AstFactory.blockFunctionBody2());
+    _analyze5(p1);
+    _analyze5(p2);
+    DartType resultType = _analyze(node);
+    _assertFunctionType(
+        dynamicType,
+        <DartType>[dynamicType, dynamicType],
+        null,
+        null,
+        resultType);
+    _listener.assertNoErrors();
+  }
+
+  void test_visitFunctionExpression_normal_expression() {
+    // (p1, p2) -> 0
+    DartType dynamicType = _typeProvider.dynamicType;
+    FormalParameter p = AstFactory.simpleFormalParameter3("p");
+    _setType(p, dynamicType);
+    FunctionExpression node = _resolvedFunctionExpression(
+        AstFactory.formalParameterList([p]),
+        AstFactory.expressionFunctionBody(_resolvedInteger(0)));
+    _analyze5(p);
+    DartType resultType = _analyze(node);
+    _assertFunctionType(
+        _typeProvider.intType,
+        <DartType>[dynamicType],
+        null,
+        null,
+        resultType);
+    _listener.assertNoErrors();
+  }
+
   void test_visitFunctionExpression_normalAndNamed_block() {
     // (p1, {p2 : 0}) {}
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = AstFactory.simpleFormalParameter3("p1");
     _setType(p1, dynamicType);
     FormalParameter p2 = AstFactory.namedFormalParameter(
         AstFactory.simpleFormalParameter3("p2"),
         _resolvedInteger(0));
     _setType(p2, dynamicType);
     FunctionExpression node = _resolvedFunctionExpression(
@@ skipping 78 matching lines @@
     DartType resultType = _analyze(node);
     _assertFunctionType(
         _typeProvider.intType,
         <DartType>[dynamicType],
         <DartType>[dynamicType],
         null,
         resultType);
     _listener.assertNoErrors();
   }
 
-  void test_visitFunctionExpression_normal_block() {
-    // (p1, p2) {}
-    DartType dynamicType = _typeProvider.dynamicType;
-    FormalParameter p1 = AstFactory.simpleFormalParameter3("p1");
-    _setType(p1, dynamicType);
-    FormalParameter p2 = AstFactory.simpleFormalParameter3("p2");
-    _setType(p2, dynamicType);
-    FunctionExpression node = _resolvedFunctionExpression(
-        AstFactory.formalParameterList([p1, p2]),
-        AstFactory.blockFunctionBody2());
-    _analyze5(p1);
-    _analyze5(p2);
-    DartType resultType = _analyze(node);
-    _assertFunctionType(
-        dynamicType,
-        <DartType>[dynamicType, dynamicType],
-        null,
-        null,
-        resultType);
-    _listener.assertNoErrors();
-  }
-
-  void test_visitFunctionExpression_normal_expression() {
-    // (p1, p2) -> 0
-    DartType dynamicType = _typeProvider.dynamicType;
-    FormalParameter p = AstFactory.simpleFormalParameter3("p");
-    _setType(p, dynamicType);
-    FunctionExpression node = _resolvedFunctionExpression(
-        AstFactory.formalParameterList([p]),
-        AstFactory.expressionFunctionBody(_resolvedInteger(0)));
-    _analyze5(p);
-    DartType resultType = _analyze(node);
-    _assertFunctionType(
-        _typeProvider.intType,
-        <DartType>[dynamicType],
-        null,
-        null,
-        resultType);
-    _listener.assertNoErrors();
-  }
-
   void test_visitFunctionExpression_positional_block() {
     // ([p1 = 0, p2 = 0]) {}
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = AstFactory.positionalFormalParameter(
         AstFactory.simpleFormalParameter3("p1"),
         _resolvedInteger(0));
     _setType(p1, dynamicType);
     FormalParameter p2 = AstFactory.positionalFormalParameter(
         AstFactory.simpleFormalParameter3("p2"),
         _resolvedInteger(0));
@@ skipping 274 matching lines @@
   }
 
   void test_visitPostfixExpression_plusPlus() {
     // 0++
     PostfixExpression node =
         AstFactory.postfixExpression(_resolvedInteger(0), TokenType.PLUS_PLUS);
     expect(_analyze(node), same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
+  void test_visitPrefixedIdentifier_getter() {
+    DartType boolType = _typeProvider.boolType;
+    PropertyAccessorElementImpl getter =
+        ElementFactory.getterElement("b", false, boolType);
+    PrefixedIdentifier node = AstFactory.identifier5("a", "b");
+    node.identifier.staticElement = getter;
+    expect(_analyze(node), same(boolType));
+    _listener.assertNoErrors();
+  }
+
+  void test_visitPrefixedIdentifier_setter() {
+    DartType boolType = _typeProvider.boolType;
+    FieldElementImpl field =
+        ElementFactory.fieldElement("b", false, false, false, boolType);
+    PropertyAccessorElement setter = field.setter;
+    PrefixedIdentifier node = AstFactory.identifier5("a", "b");
+    node.identifier.staticElement = setter;
+    expect(_analyze(node), same(boolType));
+    _listener.assertNoErrors();
+  }
+
+  void test_visitPrefixedIdentifier_variable() {
+    VariableElementImpl variable = ElementFactory.localVariableElement2("b");
+    variable.type = _typeProvider.boolType;
+    PrefixedIdentifier node = AstFactory.identifier5("a", "b");
+    node.identifier.staticElement = variable;
+    expect(_analyze(node), same(_typeProvider.boolType));
+    _listener.assertNoErrors();
+  }
+
   void test_visitPrefixExpression_bang() {
     // !0
     PrefixExpression node =
         AstFactory.prefixExpression(TokenType.BANG, _resolvedInteger(0));
     expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression_minus() {
     // -0
@@ skipping 36 matching lines @@
   void test_visitPrefixExpression_tilde() {
     // ~0
     PrefixExpression node =
         AstFactory.prefixExpression(TokenType.TILDE, _resolvedInteger(0));
     MethodElement tildeMethod = getMethod(_typeProvider.intType, "~");
     node.staticElement = tildeMethod;
     expect(_analyze(node), same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
-  void test_visitPrefixedIdentifier_getter() {
-    DartType boolType = _typeProvider.boolType;
-    PropertyAccessorElementImpl getter =
-        ElementFactory.getterElement("b", false, boolType);
-    PrefixedIdentifier node = AstFactory.identifier5("a", "b");
-    node.identifier.staticElement = getter;
-    expect(_analyze(node), same(boolType));
-    _listener.assertNoErrors();
-  }
-
-  void test_visitPrefixedIdentifier_setter() {
-    DartType boolType = _typeProvider.boolType;
-    FieldElementImpl field =
-        ElementFactory.fieldElement("b", false, false, false, boolType);
-    PropertyAccessorElement setter = field.setter;
-    PrefixedIdentifier node = AstFactory.identifier5("a", "b");
-    node.identifier.staticElement = setter;
-    expect(_analyze(node), same(boolType));
-    _listener.assertNoErrors();
-  }
-
-  void test_visitPrefixedIdentifier_variable() {
-    VariableElementImpl variable = ElementFactory.localVariableElement2("b");
-    variable.type = _typeProvider.boolType;
-    PrefixedIdentifier node = AstFactory.identifier5("a", "b");
-    node.identifier.staticElement = variable;
-    expect(_analyze(node), same(_typeProvider.boolType));
-    _listener.assertNoErrors();
-  }
-
   void test_visitPropertyAccess_propagated_getter() {
     DartType boolType = _typeProvider.boolType;
     PropertyAccessorElementImpl getter =
         ElementFactory.getterElement("b", false, boolType);
     PropertyAccess node =
         AstFactory.propertyAccess2(AstFactory.identifier3("a"), "b");
     node.propertyName.propagatedElement = getter;
     expect(_analyze2(node, false), same(boolType));
     _listener.assertNoErrors();
   }
@@ skipping 78 matching lines @@
 
   void test_visitThisExpression() {
     // this
     InterfaceType thisType =
         ElementFactory.classElement("B", ElementFactory.classElement2("A").type).type;
     Expression node = AstFactory.thisExpression();
     expect(_analyze3(node, thisType), same(thisType));
     _listener.assertNoErrors();
   }
 
+  void test_visitThrowExpression_withoutValue() {
+    // throw
+    Expression node = AstFactory.throwExpression();
+    expect(_analyze(node), same(_typeProvider.bottomType));
+    _listener.assertNoErrors();
+  }
+
   void test_visitThrowExpression_withValue() {
     // throw 0
     Expression node = AstFactory.throwExpression2(_resolvedInteger(0));
     expect(_analyze(node), same(_typeProvider.bottomType));
     _listener.assertNoErrors();
   }
-
-  void test_visitThrowExpression_withoutValue() {
-    // throw
-    Expression node = AstFactory.throwExpression();
-    expect(_analyze(node), same(_typeProvider.bottomType));
-    _listener.assertNoErrors();
-  }
 
   /**
    * Return the type associated with the given expression after the static type analyzer has
    * computed a type for it.
    *
    * @param node the expression with which the type is associated
    * @return the type associated with the expression
    */
   DartType _analyze(Expression node) => _analyze4(node, null, true);
 
@@ skipping 1395 matching lines @@
     String code = r'''
 main() {
   var v = (() {return 42;})();
 }''';
     _assertPropagatedReturnType(
         code,
         typeProvider.dynamicType,
         typeProvider.intType);
   }
 
-  void test_CanvasElement_getContext() {
-    String code = r'''
-import 'dart:html';
-main(CanvasElement canvas) {
-  var context = canvas.getContext('2d');
-}''';
-    Source source = addSource(code);
-    LibraryElement library = resolve(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
-    SimpleIdentifier identifier = EngineTestCase.findNode(
-        unit,
-        code,
-        "context",
-        (node) => node is SimpleIdentifier);
-    expect(identifier.propagatedType.name, "CanvasRenderingContext2D");
-  }
-
-  void test_Future_then() {
-    String code = r'''
-import 'dart:async';
-main(Future<int> firstFuture) {
-  firstFuture.then((p1) {
-    return 1.0;
-  }).then((p2) {
-    return new Future<String>.value('str');
-  }).then((p3) {
-  });
-}''';
-    Source source = addSource(code);
-    LibraryElement library = resolve(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
-    // p1
-    FormalParameter p1 = EngineTestCase.findNode(
-        unit,
-        code,
-        "p1) {",
-        (node) => node is SimpleFormalParameter);
-    expect(p1.identifier.propagatedType, same(typeProvider.intType));
-    // p2
-    FormalParameter p2 = EngineTestCase.findNode(
-        unit,
-        code,
-        "p2) {",
-        (node) => node is SimpleFormalParameter);
-    expect(p2.identifier.propagatedType, same(typeProvider.doubleType));
-    // p3
-    FormalParameter p3 = EngineTestCase.findNode(
-        unit,
-        code,
-        "p3) {",
-        (node) => node is SimpleFormalParameter);
-    expect(p3.identifier.propagatedType, same(typeProvider.stringType));
-  }
-
   void test_as() {
     Source source = addSource(r'''
 class A {
   bool get g => true;
 }
 A f(var p) {
   if ((p as A).g) {
     return p;
   } else {
     return null;
@@ skipping 111 matching lines @@
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit,
           code,
           "v; // return",
           (node) => node is SimpleIdentifier);
       expect(identifier.staticType, same(typeProvider.intType));
       expect(identifier.propagatedType, same(null));
     }
   }
 
+  void test_CanvasElement_getContext() {
+    String code = r'''
+import 'dart:html';
+main(CanvasElement canvas) {
+  var context = canvas.getContext('2d');
+}''';
+    Source source = addSource(code);
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    SimpleIdentifier identifier = EngineTestCase.findNode(
+        unit,
+        code,
+        "context",
+        (node) => node is SimpleIdentifier);
+    expect(identifier.propagatedType.name, "CanvasRenderingContext2D");
+  }
+
   void test_finalPropertyInducingVariable_classMember_instance() {
     addNamedSource("/lib.dart", r'''
 class A {
   final v = 0;
 }''');
     String code = r'''
 import 'lib.dart';
 f(A a) {
   return a.v; // marker
 }''';
@@ skipping 291 matching lines @@
         code,
         "v)",
         (node) => node is SimpleFormalParameter);
     expect(vParameter.identifier.propagatedType, same(stringType));
     expect(vParameter.identifier.staticType, same(typeProvider.objectType));
     SimpleIdentifier vIdentifier =
         EngineTestCase.findNode(unit, code, "v;", (node) => node is SimpleIdentifier);
     expect(vIdentifier.propagatedType, same(stringType));
   }
 
+  void test_Future_then() {
+    String code = r'''
+import 'dart:async';
+main(Future<int> firstFuture) {
+  firstFuture.then((p1) {
+    return 1.0;
+  }).then((p2) {
+    return new Future<String>.value('str');
+  }).then((p3) {
+  });
+}''';
+    Source source = addSource(code);
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    // p1
+    FormalParameter p1 = EngineTestCase.findNode(
+        unit,
+        code,
+        "p1) {",
+        (node) => node is SimpleFormalParameter);
+    expect(p1.identifier.propagatedType, same(typeProvider.intType));
+    // p2
+    FormalParameter p2 = EngineTestCase.findNode(
+        unit,
+        code,
+        "p2) {",
+        (node) => node is SimpleFormalParameter);
+    expect(p2.identifier.propagatedType, same(typeProvider.doubleType));
+    // p3
+    FormalParameter p3 = EngineTestCase.findNode(
+        unit,
+        code,
+        "p3) {",
+        (node) => node is SimpleFormalParameter);
+    expect(p3.identifier.propagatedType, same(typeProvider.stringType));
+  }
+
   void test_initializer() {
     Source source = addSource(r'''
 f() {
   var v = 0;
   return v;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
@@ skipping 62 matching lines @@
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit,
           code,
           "v; // marker",
           (node) => node is SimpleIdentifier);
       expect(identifier.staticType, same(typeProvider.intType));
       expect(identifier.propagatedType, same(null));
     }
   }
 
-  void test_isNot_conditional() {
+  void test_is_conditional() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
-  return (p is! A) ? null : p;
+  return (p is A) ? p : null;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     ConditionalExpression conditional =
         statement.expression as ConditionalExpression;
     SimpleIdentifier variableName =
-        conditional.elseExpression as SimpleIdentifier;
+        conditional.thenExpression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
-  void test_isNot_if() {
+  void test_is_if() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
-  if (p is! A) {
+  if (p is A) {
+    return p;
+  } else {
     return null;
-  } else {
-    return p;
   }
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
-        (ifStatement.elseStatement as Block).statements[0] as ReturnStatement;
+        (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
-  void test_isNot_if_logicalOr() {
+  void test_is_if_lessSpecific() {
     Source source = addSource(r'''
 class A {}
-A f(var p) {
-  if (p is! A || null == p) {
+A f(A p) {
+  if (p is String) {
+    return p;
+  } else {
     return null;
-  } else {
-    return p;
   }
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
+    verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
-    ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
-    InterfaceType typeA = classA.element.type;
+//    ClassDeclaration classA = (ClassDeclaration) unit.getDeclarations().get(0);
+//    InterfaceType typeA = classA.getElement().getType();
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
-        (ifStatement.elseStatement as Block).statements[0] as ReturnStatement;
+        (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    expect(variableName.propagatedType, same(typeA));
+    expect(variableName.propagatedType, same(null));
   }
 
-  void test_isNot_postConditional() {
+  void test_is_if_logicalAnd() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
-  A a = (p is! A) ? throw null : p;
-  return p;
+  if (p is A && p != null) {
+    return p;
+  } else {
+    return null;
+  }
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body.block.statements[1] as ReturnStatement;
+    IfStatement ifStatement = body.block.statements[0] as IfStatement;
+    ReturnStatement statement =
+        (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
-  void test_isNot_postIf() {
+  void test_is_postConditional() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
-  if (p is! A) {
-    return null;
-  }
+  A a = (p is A) ? p : throw null;
   return p;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
-  void test_is_conditional() {
+  void test_is_postIf() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
-  return (p is A) ? p : null;
+  if (p is A) {
+    A a = p;
+  } else {
+    return null;
+  }
+  return p;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body.block.statements[0] as ReturnStatement;
-    ConditionalExpression conditional =
-        statement.expression as ConditionalExpression;
-    SimpleIdentifier variableName =
-        conditional.thenExpression as SimpleIdentifier;
+    ReturnStatement statement = body.block.statements[1] as ReturnStatement;
+    SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
-  void test_is_if() {
+  void test_is_subclass() {
+    Source source = addSource(r'''
+class A {}
+class B extends A {
+  B m() => this;
+}
+A f(A p) {
+  if (p is B) {
+    return p.m();
+  }
+  return p;
+}''');
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    FunctionDeclaration function = unit.declarations[2] as FunctionDeclaration;
+    BlockFunctionBody body =
+        function.functionExpression.body as BlockFunctionBody;
+    IfStatement ifStatement = body.block.statements[0] as IfStatement;
+    ReturnStatement statement =
+        (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
+    MethodInvocation invocation = statement.expression as MethodInvocation;
+    expect(invocation.methodName.propagatedElement, isNotNull);
+  }
+
+  void test_is_while() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
-  if (p is A) {
+  while (p is A) {
     return p;
-  } else {
-    return null;
   }
+  return p;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
-    IfStatement ifStatement = body.block.statements[0] as IfStatement;
+    WhileStatement whileStatement = body.block.statements[0] as WhileStatement;
     ReturnStatement statement =
-        (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
+        (whileStatement.body as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
-  void test_is_if_lessSpecific() {
+  void test_isNot_conditional() {
     Source source = addSource(r'''
 class A {}
-A f(A p) {
-  if (p is String) {
-    return p;
-  } else {
-    return null;
-  }
+A f(var p) {
+  return (p is! A) ? null : p;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
-//    ClassDeclaration classA = (ClassDeclaration) unit.getDeclarations().get(0);
-//    InterfaceType typeA = classA.getElement().getType();
-    FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
-    BlockFunctionBody body =
-        function.functionExpression.body as BlockFunctionBody;
-    IfStatement ifStatement = body.block.statements[0] as IfStatement;
-    ReturnStatement statement =
-        (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
-    SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    expect(variableName.propagatedType, same(null));
-  }
-
-  void test_is_if_logicalAnd() {
-    Source source = addSource(r'''
-class A {}
-A f(var p) {
-  if (p is A && p != null) {
-    return p;
-  } else {
-    return null;
-  }
-}''');
-    LibraryElement library = resolve(source);
-    assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
-    IfStatement ifStatement = body.block.statements[0] as IfStatement;
-    ReturnStatement statement =
-        (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
-    SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
+    ReturnStatement statement = body.block.statements[0] as ReturnStatement;
+    ConditionalExpression conditional =
+        statement.expression as ConditionalExpression;
+    SimpleIdentifier variableName =
+        conditional.elseExpression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
-  void test_is_postConditional() {
+  void test_isNot_if() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
-  A a = (p is A) ? p : throw null;
-  return p;
+  if (p is! A) {
+    return null;
+  } else {
+    return p;
+  }
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
-    ReturnStatement statement = body.block.statements[1] as ReturnStatement;
+    IfStatement ifStatement = body.block.statements[0] as IfStatement;
+    ReturnStatement statement =
+        (ifStatement.elseStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
-  void test_is_postIf() {
+  void test_isNot_if_logicalOr() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
-  if (p is A) {
-    A a = p;
+  if (p is! A || null == p) {
+    return null;
   } else {
-    return null;
+    return p;
   }
+}''');
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
+    InterfaceType typeA = classA.element.type;
+    FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
+    BlockFunctionBody body =
+        function.functionExpression.body as BlockFunctionBody;
+    IfStatement ifStatement = body.block.statements[0] as IfStatement;
+    ReturnStatement statement =
+        (ifStatement.elseStatement as Block).statements[0] as ReturnStatement;
+    SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
+    expect(variableName.propagatedType, same(typeA));
+  }
+
+  void test_isNot_postConditional() {
+    Source source = addSource(r'''
+class A {}
+A f(var p) {
+  A a = (p is! A) ? throw null : p;
   return p;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
-  void test_is_subclass() {
+  void test_isNot_postIf() {
     Source source = addSource(r'''
 class A {}
-class B extends A {
-  B m() => this;
-}
-A f(A p) {
-  if (p is B) {
-    return p.m();
+A f(var p) {
+  if (p is! A) {
+    return null;
   }
   return p;
 }''');
-    LibraryElement library = resolve(source);
-    assertNoErrors(source);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
-    FunctionDeclaration function = unit.declarations[2] as FunctionDeclaration;
-    BlockFunctionBody body =
-        function.functionExpression.body as BlockFunctionBody;
-    IfStatement ifStatement = body.block.statements[0] as IfStatement;
-    ReturnStatement statement =
-        (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
-    MethodInvocation invocation = statement.expression as MethodInvocation;
-    expect(invocation.methodName.propagatedElement, isNotNull);
-  }
-
-  void test_is_while() {
-    Source source = addSource(r'''
-class A {}
-A f(var p) {
-  while (p is A) {
-    return p;
-  }
-  return p;
-}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
-    WhileStatement whileStatement = body.block.statements[0] as WhileStatement;
-    ReturnStatement statement =
-        (whileStatement.body as Block).statements[0] as ReturnStatement;
+    ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_2() {
     // https://code.google.com/p/dart/issues/detail?id=20904
     enableUnionTypes(false);
     String code = r'''
 f(var message) {
   if (message is Function) {
@@ skipping 1099 matching lines @@
         // check propagated type
         FunctionType propagatedType = node.propagatedType as FunctionType;
         expect(propagatedType.returnType, test.typeProvider.stringType);
       } on AnalysisException catch (e, stackTrace) {
         thrownException[0] = new CaughtException(e, stackTrace);
       }
     }
     return null;
   }
 }