Propagate a type in asynchronous for-in statements (issue 23945)

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/context/context.dart' as newContext;
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 147 matching lines @@
           <ClassElement>[objectClassElement, objectClassElement], null),
       ElementFactory.functionElement3("print", VoidTypeImpl.instance.element,
           <ClassElement>[objectClassElement], null)
     ];
     TopLevelVariableElement proxyTopLevelVariableElt = ElementFactory
         .topLevelVariableElement3("proxy", true, false, proxyClassElement.type);
     ConstTopLevelVariableElementImpl deprecatedTopLevelVariableElt =
         ElementFactory.topLevelVariableElement3(
             "deprecated", true, false, provider.deprecatedType);
     deprecatedTopLevelVariableElt.constantInitializer = AstFactory
-        .instanceCreationExpression2(Keyword.CONST,
+        .instanceCreationExpression2(
+            Keyword.CONST,
             AstFactory.typeName(provider.deprecatedType.element),
             [AstFactory.string2('next release')]);
     coreUnit.accessors = <PropertyAccessorElement>[
       proxyTopLevelVariableElt.getter,
       deprecatedTopLevelVariableElt.getter
     ];
     coreUnit.topLevelVariables = <TopLevelVariableElement>[
       proxyTopLevelVariableElt,
       deprecatedTopLevelVariableElt
     ];
@@ skipping 43 matching lines @@
     ]);
     futureElement.methods = <MethodElement>[thenMethod];
     // Completer
     ClassElementImpl completerElement =
         ElementFactory.classElement2("Completer", ["T"]);
     ConstructorElementImpl completerConstructor =
         ElementFactory.constructorElement2(completerElement, null);
     (completerConstructor.type as FunctionTypeImpl).typeArguments =
         completerElement.type.typeArguments;
     completerElement.constructors = <ConstructorElement>[completerConstructor];
+    // StreamSubscription
+    ClassElementImpl streamSubscriptionElement =
+        ElementFactory.classElement2("StreamSubscription", ["T"]);
+    // Stream
+    ClassElementImpl streamElement =
+        ElementFactory.classElement2("Stream", ["T"]);
+    DartType returnType = streamSubscriptionElement.type
+        .substitute4(streamElement.type.typeArguments);
+    List<DartType> parameterTypes = <DartType>[
+      ElementFactory
+          .functionElement3('onData', VoidTypeImpl.instance.element,
+              <TypeDefiningElement>[streamElement.typeParameters[0]], null)
+          .type,
+    ];
+    // TODO(brianwilkerson) This is missing the optional parameters.
+    MethodElementImpl listenMethod =
+        ElementFactory.methodElement('listen', returnType, parameterTypes);
+    streamElement.methods = <MethodElement>[listenMethod];
+
     asyncUnit.types = <ClassElement>[
       completerElement,
       futureElement,
-      ElementFactory.classElement2("Stream", ["T"])
+      streamElement
     ];
     LibraryElementImpl asyncLibrary = new LibraryElementImpl.forNode(
         coreContext, AstFactory.libraryIdentifier2(["dart", "async"]));
     asyncLibrary.definingCompilationUnit = asyncUnit;
     //
     // dart:html
     //
     CompilationUnitElementImpl htmlUnit =
         new CompilationUnitElementImpl("html_dartium.dart");
     Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
@@ skipping 53 matching lines @@
         coreContext, AstFactory.libraryIdentifier2(["dart", "dom", "html"]));
     htmlLibrary.definingCompilationUnit = htmlUnit;
     //
     // dart:math
     //
     CompilationUnitElementImpl mathUnit =
         new CompilationUnitElementImpl("math.dart");
     Source mathSource = sourceFactory.forUri(_DART_MATH);
     coreContext.setContents(mathSource, "");
     mathUnit.librarySource = mathUnit.source = mathSource;
-    FunctionElement cosElement = ElementFactory.functionElement3("cos",
-        provider.doubleType.element, <ClassElement>[provider.numType.element],
+    FunctionElement cosElement = ElementFactory.functionElement3(
+        "cos",
+        provider.doubleType.element,
+        <ClassElement>[provider.numType.element],
         ClassElement.EMPTY_LIST);
     TopLevelVariableElement ln10Element = ElementFactory
         .topLevelVariableElement3("LN10", true, false, provider.doubleType);
     TopLevelVariableElement piElement = ElementFactory.topLevelVariableElement3(
         "PI", true, false, provider.doubleType);
     ClassElementImpl randomElement = ElementFactory.classElement2("Random");
     randomElement.abstract = true;
     ConstructorElementImpl randomConstructor =
         ElementFactory.constructorElement2(randomElement, null);
     randomConstructor.factory = true;
     ParameterElementImpl seedParam = new ParameterElementImpl("seed", 0);
     seedParam.parameterKind = ParameterKind.POSITIONAL;
     seedParam.type = provider.intType;
     randomConstructor.parameters = <ParameterElement>[seedParam];
     randomElement.constructors = <ConstructorElement>[randomConstructor];
-    FunctionElement sinElement = ElementFactory.functionElement3("sin",
-        provider.doubleType.element, <ClassElement>[provider.numType.element],
+    FunctionElement sinElement = ElementFactory.functionElement3(
+        "sin",
+        provider.doubleType.element,
+        <ClassElement>[provider.numType.element],
         ClassElement.EMPTY_LIST);
-    FunctionElement sqrtElement = ElementFactory.functionElement3("sqrt",
-        provider.doubleType.element, <ClassElement>[provider.numType.element],
+    FunctionElement sqrtElement = ElementFactory.functionElement3(
+        "sqrt",
+        provider.doubleType.element,
+        <ClassElement>[provider.numType.element],
         ClassElement.EMPTY_LIST);
     mathUnit.accessors = <PropertyAccessorElement>[
       ln10Element.getter,
       piElement.getter
     ];
     mathUnit.functions = <FunctionElement>[cosElement, sinElement, sqrtElement];
     mathUnit.topLevelVariables = <TopLevelVariableElement>[
       ln10Element,
       piElement
     ];
@@ skipping 860 matching lines @@
 
   /**
    * The resolver being used to resolve the test cases.
    */
   ElementResolver _resolver;
 
   void fail_visitExportDirective_combinators() {
     fail("Not yet tested");
     // Need to set up the exported library so that the identifier can be
     // resolved.
-    ExportDirective directive =
-        AstFactory.exportDirective2(null, [AstFactory.hideCombinator2(["A"])]);
+    ExportDirective directive = AstFactory.exportDirective2(null, [
+      AstFactory.hideCombinator2(["A"])
+    ]);
     _resolveNode(directive);
     _listener.assertNoErrors();
   }
 
   void fail_visitFunctionExpressionInvocation() {
     fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   void fail_visitImportDirective_combinators_noPrefix() {
     fail("Not yet tested");
     // Need to set up the imported library so that the identifier can be
     // resolved.
-    ImportDirective directive = AstFactory.importDirective3(
-        null, null, [AstFactory.showCombinator2(["A"])]);
+    ImportDirective directive = AstFactory.importDirective3(null, null, [
+      AstFactory.showCombinator2(["A"])
+    ]);
     _resolveNode(directive);
     _listener.assertNoErrors();
   }
 
   void fail_visitImportDirective_combinators_prefix() {
     fail("Not yet tested");
     // Need to set up the imported library so that the identifiers can be
     // resolved.
     String prefixName = "p";
     _definingLibrary.imports = <ImportElement>[
@@ skipping 79 matching lines @@
     // var j;
     // i == j
     InterfaceType stringType = _typeProvider.stringType;
     SimpleIdentifier left = AstFactory.identifier3("i");
     left.staticType = stringType;
     BinaryExpression expression = AstFactory.binaryExpression(
         left, TokenType.BANG_EQ, AstFactory.identifier3("j"));
     _resolveNode(expression);
     var stringElement = stringType.element;
     expect(expression.staticElement, isNotNull);
-    expect(expression.staticElement, stringElement.lookUpMethod(
-        TokenType.EQ_EQ.lexeme, stringElement.library));
+    expect(
+        expression.staticElement,
+        stringElement.lookUpMethod(
+            TokenType.EQ_EQ.lexeme, stringElement.library));
     expect(expression.propagatedElement, isNull);
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_eq() {
     // String i;
     // var j;
     // i == j
     InterfaceType stringType = _typeProvider.stringType;
     SimpleIdentifier left = AstFactory.identifier3("i");
     left.staticType = stringType;
     BinaryExpression expression = AstFactory.binaryExpression(
         left, TokenType.EQ_EQ, AstFactory.identifier3("j"));
     _resolveNode(expression);
     var stringElement = stringType.element;
-    expect(expression.staticElement, stringElement.lookUpMethod(
-        TokenType.EQ_EQ.lexeme, stringElement.library));
+    expect(
+        expression.staticElement,
+        stringElement.lookUpMethod(
+            TokenType.EQ_EQ.lexeme, stringElement.library));
     expect(expression.propagatedElement, isNull);
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_plus() {
     // num i;
     // var j;
     // i + j
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier left = AstFactory.identifier3("i");
@@ skipping 250 matching lines @@
     ConstructorElementImpl constructor =
         ElementFactory.constructorElement2(classA, constructorName);
     String parameterName = "a";
     ParameterElement parameter = ElementFactory.namedParameter(parameterName);
     constructor.parameters = <ParameterElement>[parameter];
     classA.constructors = <ConstructorElement>[constructor];
     ConstructorName name = AstFactory.constructorName(
         AstFactory.typeName(classA), constructorName);
     name.staticElement = constructor;
     InstanceCreationExpression creation = AstFactory.instanceCreationExpression(
-        Keyword.NEW, name,
+        Keyword.NEW,
+        name,
         [AstFactory.namedExpression2(parameterName, AstFactory.integer(0))]);
     _resolveNode(creation);
     expect(creation.staticElement, same(constructor));
-    expect((creation.argumentList.arguments[
-        0] as NamedExpression).name.label.staticElement, same(parameter));
+    expect(
+        (creation.argumentList.arguments[0] as NamedExpression)
+            .name
+            .label
+            .staticElement,
+        same(parameter));
     _listener.assertNoErrors();
   }
 
   void test_visitMethodInvocation() {
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier left = AstFactory.identifier3("i");
     left.staticType = numType;
     String methodName = "abs";
     MethodInvocation invocation = AstFactory.methodInvocation(left, methodName);
     _resolveNode(invocation);
     expect(invocation.methodName.staticElement,
         same(getMethod(numType, methodName)));
     _listener.assertNoErrors();
   }
 
   void test_visitMethodInvocation_namedParameter() {
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
     String parameterName = "p";
     MethodElementImpl method = ElementFactory.methodElement(methodName, null);
     ParameterElement parameter = ElementFactory.namedParameter(parameterName);
     method.parameters = <ParameterElement>[parameter];
     classA.methods = <MethodElement>[method];
     SimpleIdentifier left = AstFactory.identifier3("i");
     left.staticType = classA.type;
     MethodInvocation invocation = AstFactory.methodInvocation(left, methodName,
         [AstFactory.namedExpression2(parameterName, AstFactory.integer(0))]);
     _resolveNode(invocation);
     expect(invocation.methodName.staticElement, same(method));
-    expect((invocation.argumentList.arguments[
-        0] as NamedExpression).name.label.staticElement, same(parameter));
+    expect(
+        (invocation.argumentList.arguments[0] as NamedExpression)
+            .name
+            .label
+            .staticElement,
+        same(parameter));
     _listener.assertNoErrors();
   }
 
   void test_visitPostfixExpression() {
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier operand = AstFactory.identifier3("i");
     operand.staticType = numType;
     PostfixExpression expression =
         AstFactory.postfixExpression(operand, TokenType.PLUS_PLUS);
     _resolveNode(expression);
@@ skipping 138 matching lines @@
     // }
     //
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "b";
     PropertyAccessorElement getter =
         ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement>[getter];
     SuperExpression target = AstFactory.superExpression();
     target.staticType = ElementFactory.classElement("B", classA.type).type;
     PropertyAccess access = AstFactory.propertyAccess2(target, getterName);
-    AstFactory.methodDeclaration2(null, null, null, null,
-        AstFactory.identifier3("m"), AstFactory.formalParameterList(),
+    AstFactory.methodDeclaration2(
+        null,
+        null,
+        null,
+        null,
+        AstFactory.identifier3("m"),
+        AstFactory.formalParameterList(),
         AstFactory.expressionFunctionBody(access));
     _resolveNode(access);
     expect(access.propertyName.staticElement, same(getter));
     _listener.assertNoErrors();
   }
 
   void test_visitPropertyAccess_setter_this() {
     ClassElementImpl classA = ElementFactory.classElement2("A");
     String setterName = "b";
     PropertyAccessorElement setter =
@@ skipping 80 matching lines @@
         ElementFactory.classElement("B", superclass.type);
     ConstructorElementImpl subConstructor =
         ElementFactory.constructorElement2(subclass, null);
     subclass.constructors = <ConstructorElement>[subConstructor];
     SuperConstructorInvocation invocation = AstFactory
         .superConstructorInvocation([
       AstFactory.namedExpression2(parameterName, AstFactory.integer(0))
     ]);
     _resolveInClass(invocation, subclass);
     expect(invocation.staticElement, superConstructor);
-    expect((invocation.argumentList.arguments[
-        0] as NamedExpression).name.label.staticElement, same(parameter));
+    expect(
+        (invocation.argumentList.arguments[0] as NamedExpression)
+            .name
+            .label
+            .staticElement,
+        same(parameter));
     _listener.assertNoErrors();
   }
 
   /**
    * Create the resolver used by the tests.
    *
    * @return the resolver that was created
    */
   ElementResolver _createResolver() {
     InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
@@ skipping 309 matching lines @@
     verify([source]);
   }
 
   void fail_unusedImport_as_equalPrefixes() {
     // See todo at ImportsVerifier.prefixElementMap.
     Source source = addSource(r'''
 library L;
 import 'lib1.dart' as one;
 import 'lib2.dart' as one;
 one.A a;''');
-    Source source2 = addNamedSource("/lib1.dart", r'''
+    Source source2 = addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 class A {}''');
-    Source source3 = addNamedSource("/lib2.dart", r'''
+    Source source3 = addNamedSource(
+        "/lib2.dart",
+        r'''
 library lib2;
 class B {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_IMPORT]);
     assertNoErrors(source2);
     assertNoErrors(source3);
     verify([source, source2, source3]);
   }
 
   void test_argumentTypeNotAssignable_functionType() {
@@ skipping 452 matching lines @@
   m() {}
   n() {m();}
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_export() {
     Source source = addSource("export 'deprecated_library.dart';");
-    addNamedSource("/deprecated_library.dart", r'''
+    addNamedSource(
+        "/deprecated_library.dart",
+        r'''
 @deprecated
 library deprecated_library;
 class A {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_getter() {
     Source source = addSource(r'''
 class A {
   @deprecated
   get m => 1;
 }
 f(A a) {
   return a.m;
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_import() {
     Source source = addSource(r'''
 import 'deprecated_library.dart';
 f(A a) {}''');
-    addNamedSource("/deprecated_library.dart", r'''
+    addNamedSource(
+        "/deprecated_library.dart",
+        r'''
 @deprecated
 library deprecated_library;
 class A {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_indexExpression() {
     Source source = addSource(r'''
@@ skipping 136 matching lines @@
     assertErrors(source, [HintCode.DIVISION_OPTIMIZATION]);
     verify([source]);
   }
 
   void test_duplicateImport() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib1.dart';
 A a;''');
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 class A {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DUPLICATE_IMPORT]);
     verify([source]);
   }
 
   void test_duplicateImport2() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib1.dart';
 import 'lib1.dart';
 A a;''');
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 class A {}''');
     computeLibrarySourceErrors(source);
     assertErrors(
         source, [HintCode.DUPLICATE_IMPORT, HintCode.DUPLICATE_IMPORT]);
     verify([source]);
   }
 
   void test_duplicateImport3() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart' as M show A hide B;
 import 'lib1.dart' as M show A hide B;
 M.A a;''');
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 class A {}
 class B {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.DUPLICATE_IMPORT]);
     verify([source]);
   }
 
   void test_importDeferredLibraryWithLoadFunction() {
     resolveWithErrors(<String>[
       r'''
 library lib1;
 loadLibrary() {}
 f() {}''',
       r'''
 library root;
 import 'lib1.dart' deferred as lib1;
 main() { lib1.f(); }'''
-    ], <ErrorCode>[HintCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION]);
+    ], <ErrorCode>[
+      HintCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION
+    ]);
   }
 
   void test_invalidAssignment_instanceVariable() {
     Source source = addSource(r'''
 class A {
   int x;
 }
 f(var y) {
   A a;
   if(y is String) {
@@ skipping 1250 matching lines @@
     assertNoErrors(source2);
     verify([source, source2]);
   }
 
   void test_unusedImport_as() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib1.dart' as one;
 one.A a;''');
-    Source source2 = addNamedSource("/lib1.dart", r'''
+    Source source2 = addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 class A {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_IMPORT]);
     assertNoErrors(source2);
     verify([source, source2]);
   }
 
   void test_unusedImport_hide() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib1.dart' hide A;
 A a;''');
-    Source source2 = addNamedSource("/lib1.dart", r'''
+    Source source2 = addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 class A {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_IMPORT]);
     assertNoErrors(source2);
     verify([source, source2]);
   }
 
   void test_unusedImport_show() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart' show A;
 import 'lib1.dart' show B;
 A a;''');
-    Source source2 = addNamedSource("/lib1.dart", r'''
+    Source source2 = addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 class A {}
 class B {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNUSED_IMPORT]);
     assertNoErrors(source2);
     verify([source, source2]);
   }
 
   void test_unusedLocalVariable_inCatch_exception() {
@@ skipping 1515 matching lines @@
     _context = AnalysisContextFactory.contextWithCore();
   }
 
   @override
   void tearDown() {
     _context = null;
     super.tearDown();
   }
 
   void test_accessorsAcrossFiles() {
-    Source librarySource = addSource("/lib.dart", r'''
+    Source librarySource = addSource(
+        "/lib.dart",
+        r'''
 library lib;
 part 'first.dart';
 part 'second.dart';''');
-    addSource("/first.dart", r'''
+    addSource(
+        "/first.dart",
+        r'''
 part of lib;
 int get V => 0;''');
-    addSource("/second.dart", r'''
+    addSource(
+        "/second.dart",
+        r'''
 part of lib;
 void set V(int v) {}''');
     LibraryElement element = _buildLibrary(librarySource);
     expect(element, isNotNull);
     List<CompilationUnitElement> sourcedUnits = element.parts;
     expect(sourcedUnits, hasLength(2));
     List<PropertyAccessorElement> firstAccessors = sourcedUnits[0].accessors;
     expect(firstAccessors, hasLength(1));
     List<PropertyAccessorElement> secondAccessors = sourcedUnits[1].accessors;
     expect(secondAccessors, hasLength(1));
@@ skipping 25 matching lines @@
   void test_missingLibraryDirectiveWithPart() {
     addSource("/a.dart", "part of lib;");
     Source librarySource = addSource("/lib.dart", "part 'a.dart';");
     LibraryElement element = _buildLibrary(
         librarySource, [ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART]);
     expect(element, isNotNull);
   }
 
   void test_missingPartOfDirective() {
     addSource("/a.dart", "class A {}");
-    Source librarySource = addSource("/lib.dart", r'''
+    Source librarySource = addSource(
+        "/lib.dart",
+        r'''
 library lib;
 
 part 'a.dart';''');
     LibraryElement element =
         _buildLibrary(librarySource, [CompileTimeErrorCode.PART_OF_NON_PART]);
     expect(element, isNotNull);
   }
 
   void test_multipleFiles() {
-    Source librarySource = addSource("/lib.dart", r'''
+    Source librarySource = addSource(
+        "/lib.dart",
+        r'''
 library lib;
 part 'first.dart';
 part 'second.dart';
 
 class A {}''');
-    addSource("/first.dart", r'''
+    addSource(
+        "/first.dart",
+        r'''
 part of lib;
 class B {}''');
-    addSource("/second.dart", r'''
+    addSource(
+        "/second.dart",
+        r'''
 part of lib;
 class C {}''');
     LibraryElement element = _buildLibrary(librarySource);
     expect(element, isNotNull);
     List<CompilationUnitElement> sourcedUnits = element.parts;
     expect(sourcedUnits, hasLength(2));
     _assertTypes(element.definingCompilationUnit, ["A"]);
     if (sourcedUnits[0].name == "first.dart") {
       _assertTypes(sourcedUnits[0], ["B"]);
       _assertTypes(sourcedUnits[1], ["C"]);
     } else {
       _assertTypes(sourcedUnits[0], ["C"]);
       _assertTypes(sourcedUnits[1], ["B"]);
     }
   }
 
   void test_singleFile() {
-    Source librarySource = addSource("/lib.dart", r'''
+    Source librarySource = addSource(
+        "/lib.dart",
+        r'''
 library lib;
 
 class A {}''');
     LibraryElement element = _buildLibrary(librarySource);
     expect(element, isNotNull);
     _assertTypes(element.definingCompilationUnit, ["A"]);
   }
 
   /**
    * Ensure that there are elements representing all of the types in the given array of type names.
@@ skipping 48 matching lines @@
   void test_conflictingImports() {
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String typeNameA = "A";
     String typeNameB = "B";
     String typeNameC = "C";
     ClassElement typeA = ElementFactory.classElement2(typeNameA);
     ClassElement typeB1 = ElementFactory.classElement2(typeNameB);
     ClassElement typeB2 = ElementFactory.classElement2(typeNameB);
     ClassElement typeC = ElementFactory.classElement2(typeNameC);
     LibraryElement importedLibrary1 = createTestLibrary(context, "imported1");
-    (importedLibrary1.definingCompilationUnit as CompilationUnitElementImpl).types =
-        <ClassElement>[typeA, typeB1];
+    (importedLibrary1.definingCompilationUnit as CompilationUnitElementImpl)
+        .types = <ClassElement>[typeA, typeB1];
     ImportElementImpl import1 =
         ElementFactory.importFor(importedLibrary1, null);
     LibraryElement importedLibrary2 = createTestLibrary(context, "imported2");
-    (importedLibrary2.definingCompilationUnit as CompilationUnitElementImpl).types =
-        <ClassElement>[typeB2, typeC];
+    (importedLibrary2.definingCompilationUnit as CompilationUnitElementImpl)
+        .types = <ClassElement>[typeB2, typeC];
     ImportElementImpl import2 =
         ElementFactory.importFor(importedLibrary2, null);
     LibraryElementImpl importingLibrary =
         createTestLibrary(context, "importing");
     importingLibrary.imports = <ImportElement>[import1, import2];
     {
       GatheringErrorListener errorListener = new GatheringErrorListener();
       Scope scope = new LibraryImportScope(importingLibrary, errorListener);
       expect(scope.lookup(AstFactory.identifier3(typeNameA), importingLibrary),
           typeA);
@@ skipping 35 matching lines @@
     GatheringErrorListener errorListener = new GatheringErrorListener();
     new LibraryImportScope(definingLibrary, errorListener);
   }
 
   void test_creation_nonEmpty() {
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String importedTypeName = "A";
     ClassElement importedType =
         new ClassElementImpl.forNode(AstFactory.identifier3(importedTypeName));
     LibraryElement importedLibrary = createTestLibrary(context, "imported");
-    (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types =
-        <ClassElement>[importedType];
+    (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl)
+        .types = <ClassElement>[importedType];
     LibraryElementImpl definingLibrary =
         createTestLibrary(context, "importing");
     ImportElementImpl importElement = new ImportElementImpl(0);
     importElement.importedLibrary = importedLibrary;
     definingLibrary.imports = <ImportElement>[importElement];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(definingLibrary, errorListener);
     expect(
         scope.lookup(AstFactory.identifier3(importedTypeName), definingLibrary),
         importedType);
   }
 
   void test_getErrorListener() {
     LibraryElement definingLibrary = createDefaultTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
     LibraryImportScope scope =
         new LibraryImportScope(definingLibrary, errorListener);
     expect(scope.errorListener, errorListener);
   }
 
   void test_nonConflictingImports_fromSdk() {
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String typeName = "List";
     ClassElement type = ElementFactory.classElement2(typeName);
     LibraryElement importedLibrary = createTestLibrary(context, "lib");
-    (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types =
-        <ClassElement>[type];
+    (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl)
+        .types = <ClassElement>[type];
     ImportElementImpl importCore = ElementFactory.importFor(
         context.getLibraryElement(context.sourceFactory.forUri("dart:core")),
         null);
     ImportElementImpl importLib =
         ElementFactory.importFor(importedLibrary, null);
     LibraryElementImpl importingLibrary =
         createTestLibrary(context, "importing");
     importingLibrary.imports = <ImportElement>[importCore, importLib];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(importingLibrary, errorListener);
     expect(
         scope.lookup(AstFactory.identifier3(typeName), importingLibrary), type);
     errorListener
         .assertErrorsWithCodes([StaticWarningCode.CONFLICTING_DART_IMPORT]);
   }
 
   void test_nonConflictingImports_sameElement() {
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String typeNameA = "A";
     String typeNameB = "B";
     ClassElement typeA = ElementFactory.classElement2(typeNameA);
     ClassElement typeB = ElementFactory.classElement2(typeNameB);
     LibraryElement importedLibrary = createTestLibrary(context, "imported");
-    (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types =
-        <ClassElement>[typeA, typeB];
+    (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl)
+        .types = <ClassElement>[typeA, typeB];
     ImportElementImpl import1 = ElementFactory.importFor(importedLibrary, null);
     ImportElementImpl import2 = ElementFactory.importFor(importedLibrary, null);
     LibraryElementImpl importingLibrary =
         createTestLibrary(context, "importing");
     importingLibrary.imports = <ImportElement>[import1, import2];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(importingLibrary, errorListener);
     expect(scope.lookup(AstFactory.identifier3(typeNameA), importingLibrary),
         typeA);
     errorListener.assertNoErrors();
     expect(scope.lookup(AstFactory.identifier3(typeNameB), importingLibrary),
         typeB);
     errorListener.assertNoErrors();
   }
 
   void test_prefixedAndNonPrefixed() {
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String typeName = "C";
     String prefixName = "p";
     ClassElement prefixedType = ElementFactory.classElement2(typeName);
     ClassElement nonPrefixedType = ElementFactory.classElement2(typeName);
     LibraryElement prefixedLibrary =
         createTestLibrary(context, "import.prefixed");
-    (prefixedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types =
-        <ClassElement>[prefixedType];
+    (prefixedLibrary.definingCompilationUnit as CompilationUnitElementImpl)
+        .types = <ClassElement>[prefixedType];
     ImportElementImpl prefixedImport = ElementFactory.importFor(
         prefixedLibrary, ElementFactory.prefix(prefixName));
     LibraryElement nonPrefixedLibrary =
         createTestLibrary(context, "import.nonPrefixed");
-    (nonPrefixedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types =
-        <ClassElement>[nonPrefixedType];
+    (nonPrefixedLibrary.definingCompilationUnit as CompilationUnitElementImpl)
+        .types = <ClassElement>[nonPrefixedType];
     ImportElementImpl nonPrefixedImport =
         ElementFactory.importFor(nonPrefixedLibrary, null);
     LibraryElementImpl importingLibrary =
         createTestLibrary(context, "importing");
     importingLibrary.imports = <ImportElement>[
       prefixedImport,
       nonPrefixedImport
     ];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(importingLibrary, errorListener);
@@ skipping 24 matching lines @@
         analysisContext2.sourceFactory.forUri(DartSdk.DART_CORE);
     _asyncLibrarySource =
         analysisContext2.sourceFactory.forUri(DartSdk.DART_ASYNC);
   }
 
   void test_imports_relative() {
     Source sourceA = addSource(r'''
 library libA;
 import 'libB.dart';
 class A {}''');
-    Source sourceB = addNamedSource("/libB.dart", r'''
+    Source sourceB = addNamedSource(
+        "/libB.dart",
+        r'''
 library libB;
 import 'test.dart
 class B {}''');
     List<ResolvableLibrary> cycle = new List<ResolvableLibrary>();
     ResolvableLibrary coreLib = _createResolvableLibrary(_coreLibrarySource);
     coreLib.libraryElement = analysisContext2
         .computeLibraryElement(_coreLibrarySource) as LibraryElementImpl;
     ResolvableLibrary asyncLib = _createResolvableLibrary(_asyncLibrarySource);
     asyncLib.libraryElement = analysisContext2
         .computeLibraryElement(_asyncLibrarySource) as LibraryElementImpl;
@@ skipping 66 matching lines @@
     GatheringErrorListener errorListener = new GatheringErrorListener();
     new LibraryScope(definingLibrary, errorListener);
   }
 
   void test_creation_nonEmpty() {
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String importedTypeName = "A";
     ClassElement importedType =
         new ClassElementImpl.forNode(AstFactory.identifier3(importedTypeName));
     LibraryElement importedLibrary = createTestLibrary(context, "imported");
-    (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types =
-        <ClassElement>[importedType];
+    (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl)
+        .types = <ClassElement>[importedType];
     LibraryElementImpl definingLibrary =
         createTestLibrary(context, "importing");
     ImportElementImpl importElement = new ImportElementImpl(0);
     importElement.importedLibrary = importedLibrary;
     definingLibrary.imports = <ImportElement>[importElement];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryScope(definingLibrary, errorListener);
     expect(
         scope.lookup(AstFactory.identifier3(importedTypeName), definingLibrary),
         importedType);
@@ skipping 100 matching lines @@
   }
 
   void test_setLibraryElement() {
     LibraryElementImpl element = new LibraryElementImpl.forNode(
         _analysisContext, AstFactory.libraryIdentifier2(["lib"]));
     _library.libraryElement = element;
     expect(_library.libraryElement, same(element));
   }
 
   Library _createLibrary(String definingCompilationUnitPath) => new Library(
-      _analysisContext, _errorListener, new FileBasedSource(
+      _analysisContext,
+      _errorListener,
+      new FileBasedSource(
           FileUtilities2.createFile(definingCompilationUnitPath)));
 }
 
 @reflectiveTest
 class MemberMapTest {
   /**
    * The null type.
    */
   InterfaceType _nullType;
 
@@ skipping 139 matching lines @@
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if_debugConst_prefixedIdentifier2() {
     Source source = addSource(r'''
 library L;
 import 'lib2.dart';
 f() {
   if(A.DEBUG) {}
 }''');
-    addNamedSource("/lib2.dart", r'''
+    addNamedSource(
+        "/lib2.dart",
+        r'''
 library lib2;
 class A {
   static const bool DEBUG = false;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if_debugConst_propertyAccessor() {
     Source source = addSource(r'''
 library L;
 import 'lib2.dart' as LIB;
 f() {
   if(LIB.A.DEBUG) {}
 }''');
-    addNamedSource("/lib2.dart", r'''
+    addNamedSource(
+        "/lib2.dart",
+        r'''
 library lib2;
 class A {
   static const bool DEBUG = false;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if_debugConst_simpleIdentifier() {
@@ skipping 85 matching lines @@
     verify([source]);
   }
 
   void test_duplicateImport_as() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib1.dart' as one;
 A a;
 one.A a2;''');
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 class A {}''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_duplicateImport_hide() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib1.dart' hide A;
 A a;
 B b;''');
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 class A {}
 class B {}''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_duplicateImport_show() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 import 'lib1.dart' show A;
 A a;
 B b;''');
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 class A {}
 class B {}''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_importDeferredLibraryWithLoadFunction() {
     resolveWithErrors(<String>[
@@ skipping 527 matching lines @@
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_annotationOnDirective() {
     Source source = addSource(r'''
 library L;
 @A()
 import 'lib1.dart';''');
-    Source source2 = addNamedSource("/lib1.dart", r'''
+    Source source2 = addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 class A {
   const A() {}
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source);
     verify([source, source2]);
   }
 
   void test_unusedImport_as_equalPrefixes() {
     // 18818
     Source source = addSource(r'''
 library L;
 import 'lib1.dart' as one;
 import 'lib2.dart' as one;
 one.A a;
 one.B b;''');
-    Source source2 = addNamedSource("/lib1.dart", r'''
+    Source source2 = addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 class A {}''');
-    Source source3 = addNamedSource("/lib2.dart", r'''
+    Source source3 = addNamedSource(
+        "/lib2.dart",
+        r'''
 library lib2;
 class B {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source);
     assertNoErrors(source2);
     assertNoErrors(source3);
     verify([source, source2, source3]);
   }
 
   void test_unusedImport_core_library() {
     Source source = addSource(r'''
 library L;
 import 'dart:core';''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_export() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 Two two;''');
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 export 'lib2.dart';
 class One {}''');
-    addNamedSource("/lib2.dart", r'''
+    addNamedSource(
+        "/lib2.dart",
+        r'''
 library lib2;
 class Two {}''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_export2() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 Three three;''');
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 export 'lib2.dart';
 class One {}''');
-    addNamedSource("/lib2.dart", r'''
+    addNamedSource(
+        "/lib2.dart",
+        r'''
 library lib2;
 export 'lib3.dart';
 class Two {}''');
-    addNamedSource("/lib3.dart", r'''
+    addNamedSource(
+        "/lib3.dart",
+        r'''
 library lib3;
 class Three {}''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_export_infiniteLoop() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart';
 Two two;''');
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 export 'lib2.dart';
 class One {}''');
-    addNamedSource("/lib2.dart", r'''
+    addNamedSource(
+        "/lib2.dart",
+        r'''
 library lib2;
 export 'lib3.dart';
 class Two {}''');
-    addNamedSource("/lib3.dart", r'''
+    addNamedSource(
+        "/lib3.dart",
+        r'''
 library lib3;
 export 'lib2.dart';
 class Three {}''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_metadata() {
     Source source = addSource(r'''
 library L;
 @A(x)
 import 'lib1.dart';
 class A {
   final int value;
   const A(this.value);
 }''');
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 const x = 0;''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_prefix_topLevelFunction() {
     Source source = addSource(r'''
 library L;
 import 'lib1.dart' hide topLevelFunction;
 import 'lib1.dart' as one show topLevelFunction;
 class A {
   static void x() {
     One o;
     one.topLevelFunction();
   }
 }''');
-    addNamedSource("/lib1.dart", r'''
+    addNamedSource(
+        "/lib1.dart",
+        r'''
 library lib1;
 class One {}
 topLevelFunction() {}''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_useOfVoidResult_implicitReturnValue() {
     Source source = addSource(r'''
@@ skipping 503 matching lines @@
       createTestLibrary(AnalysisContextFactory.contextWithCore(), "test");
 
   /**
    * Create a library element that represents a library with the given name containing a single
    * empty compilation unit.
    *
    * @param libraryName the name of the library to be created
    * @return the library element that was created
    */
   LibraryElementImpl createTestLibrary(
-      AnalysisContext context, String libraryName, [List<String> typeNames]) {
+      AnalysisContext context, String libraryName,
+      [List<String> typeNames]) {
     String fileName = "$libraryName.dart";
     FileBasedSource definingCompilationUnitSource =
         _createNamedSource(fileName);
     List<CompilationUnitElement> sourcedCompilationUnits;
     if (typeNames == null) {
       sourcedCompilationUnits = CompilationUnitElement.EMPTY_LIST;
     } else {
       int count = typeNames.length;
       sourcedCompilationUnits = new List<CompilationUnitElement>(count);
       for (int i = 0; i < count; i++) {
@@ skipping 95 matching lines @@
       CompilationUnit unit =
           resolveSource2("/lib${i + 1}.dart", sourceTexts[i]);
       // reference the source if this is the last source
       if (i + 1 == sourceTexts.length) {
         return unit.element.source;
       }
     }
     return null;
   }
 
-  void resolveWithAndWithoutExperimental(List<String> strSources,
+  void resolveWithAndWithoutExperimental(
+      List<String> strSources,
       List<ErrorCode> codesWithoutExperimental,
       List<ErrorCode> codesWithExperimental) {
     // Setup analysis context as non-experimental
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
 //    options.enableDeferredLoading = false;
     resetWithOptions(options);
     // Analysis and assertions
     Source source = resolveSources(strSources);
     assertErrors(source, codesWithoutExperimental);
     verify([source]);
@@ skipping 55 matching lines @@
 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;
+          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;
+          LibraryElement referencingLibrary) =>
+      null;
 }
 
 @reflectiveTest
 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 =
@@ skipping 75 matching lines @@
     // the accessors defined in M2.
     FunctionDeclaration main =
         library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     ExpressionStatement stmt = body.block.statements[0];
     AssignmentExpression assignment = stmt.expression;
     PropertyAccess propertyAccess = assignment.leftHandSide;
     expect(
         propertyAccess.propertyName.staticElement.enclosingElement.name, 'M2');
     expect(
-        propertyAccess.propertyName.auxiliaryElements.staticElement.enclosingElement.name,
+        propertyAccess
+            .propertyName.auxiliaryElements.staticElement.enclosingElement.name,
         'M2');
   }
 
   void fail_staticInvocation() {
     Source source = addSource(r'''
 class A {
   static int get g => (a,b) => 0;
 }
 class B {
   f() {
@@ skipping 554 matching lines @@
   }
 
   void test_empty() {
     Source source = addSource("");
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_entryPoint_exported() {
-    addNamedSource("/two.dart", r'''
+    addNamedSource(
+        "/two.dart",
+        r'''
 library two;
 main() {}''');
-    Source source = addNamedSource("/one.dart", r'''
+    Source source = addNamedSource(
+        "/one.dart",
+        r'''
 library one;
 export 'two.dart';''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     FunctionElement main = library.entryPoint;
     expect(main, isNotNull);
     expect(main.library, isNot(same(library)));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_entryPoint_local() {
-    Source source = addNamedSource("/one.dart", r'''
+    Source source = addNamedSource(
+        "/one.dart",
+        r'''
 library one;
 main() {}''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     FunctionElement main = library.entryPoint;
     expect(main, isNotNull);
     expect(main.library, same(library));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_entryPoint_none() {
     Source source = addNamedSource("/one.dart", "library one;");
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     expect(library.entryPoint, isNull);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_enum_externalLibrary() {
-    addNamedSource("/my_lib.dart", r'''
+    addNamedSource(
+        "/my_lib.dart",
+        r'''
 library my_lib;
 enum EEE {A, B, C}''');
     Source source = addSource(r'''
 import 'my_lib.dart';
 main() {
   EEE e = null;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
@@ skipping 177 matching lines @@
     expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     expect(classes, hasLength(2));
     expect(classes[0].hasReferenceToSuper, isFalse);
     expect(classes[1].hasReferenceToSuper, isTrue);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_import_hide() {
-    addNamedSource("lib1.dart", r'''
+    addNamedSource(
+        "lib1.dart",
+        r'''
 library lib1;
 set foo(value) {}
 class A {}''');
-    addNamedSource("lib2.dart", r'''
+    addNamedSource(
+        "lib2.dart",
+        r'''
 library lib2;
 set foo(value) {}''');
-    Source source = addNamedSource("lib3.dart", r'''
+    Source source = addNamedSource(
+        "lib3.dart",
+        r'''
 import 'lib1.dart' hide foo;
 import 'lib2.dart';
 
 main() {
   foo = 0;
 }
 A a;''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_import_prefix() {
-    addNamedSource("/two.dart", r'''
+    addNamedSource(
+        "/two.dart",
+        r'''
 library two;
 f(int x) {
   return x * x;
 }''');
-    Source source = addNamedSource("/one.dart", r'''
+    Source source = addNamedSource(
+        "/one.dart",
+        r'''
 library one;
 import 'two.dart' as _two;
 main() {
   _two.f(0);
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_import_spaceInUri() {
-    addNamedSource("sub folder/lib.dart", r'''
+    addNamedSource(
+        "sub folder/lib.dart",
+        r'''
 library lib;
 foo() {}''');
-    Source source = addNamedSource("app.dart", r'''
+    Source source = addNamedSource(
+        "app.dart",
+        r'''
 import 'sub folder/lib.dart';
 
 main() {
   foo();
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
@@ skipping 171 matching lines @@
     expect(unitElement, isNotNull);
     List<ClassElement> classes = unitElement.types;
     expect(classes, hasLength(1));
     List<ElementAnnotation> annotations = classes[0].metadata;
     expect(annotations, hasLength(1));
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(2));
-    Element expectedElement = (declarations[
-            0] as TopLevelVariableDeclaration).variables.variables[
-        0].name.staticElement;
+    Element expectedElement = (declarations[0] as TopLevelVariableDeclaration)
+        .variables
+        .variables[0].name.staticElement;
     EngineTestCase.assertInstanceOf((obj) => obj is PropertyInducingElement,
         PropertyInducingElement, expectedElement);
     expectedElement = (expectedElement as PropertyInducingElement).getter;
     Element actualElement =
         (declarations[1] as ClassDeclaration).metadata[0].name.staticElement;
     expect(actualElement, same(expectedElement));
   }
 
   void test_metadata_field() {
     Source source = addSource(r'''
@@ skipping 168 matching lines @@
     expect(unitElement, isNotNull);
     List<FunctionTypeAliasElement> aliases = unitElement.functionTypeAliases;
     expect(aliases, hasLength(1));
     List<ElementAnnotation> annotations = aliases[0].metadata;
     expect(annotations, hasLength(1));
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(2));
-    Element expectedElement = (declarations[
-            0] as TopLevelVariableDeclaration).variables.variables[
-        0].name.staticElement;
+    Element expectedElement = (declarations[0] as TopLevelVariableDeclaration)
+        .variables
+        .variables[0].name.staticElement;
     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_method_fromMixin() {
     Source source = addSource(r'''
@@ skipping 500 matching lines @@
     InterfaceType numType = _typeProvider.numType;
     // class Derived<T> extends Future<T>
     ClassElementImpl derivedClass =
         ElementFactory.classElement2('Derived', ['T']);
     derivedClass.supertype = _typeProvider.futureType
         .substitute4([derivedClass.typeParameters[0].type]);
     InterfaceType derivedType = derivedClass.type;
     // class A extends Derived<int> implements Derived<num> { ... }
     ClassElementImpl classA =
         ElementFactory.classElement('A', derivedType.substitute4([intType]));
-    classA.interfaces = <InterfaceType>[derivedType.substitute4([numType])];
+    classA.interfaces = <InterfaceType>[
+      derivedType.substitute4([numType])
+    ];
     // class B extends Future<num> implements Future<int> { ... }
     ClassElementImpl classB =
         ElementFactory.classElement('B', derivedType.substitute4([numType]));
-    classB.interfaces = <InterfaceType>[derivedType.substitute4([intType])];
+    classB.interfaces = <InterfaceType>[
+      derivedType.substitute4([intType])
+    ];
     // flatten(A) = flatten(B) = int, since int is more specific than num.
     // The code in flatten() that inhibits infinite recursion shouldn't be
     // fooled by the fact that Derived appears twice in the type hierarchy.
     expect(_flatten(classA.type), intType);
     expect(_flatten(classB.type), intType);
   }
 
   void test_flatten_related_types() {
     InterfaceType futureType = _typeProvider.futureType;
     InterfaceType intType = _typeProvider.intType;
     InterfaceType numType = _typeProvider.numType;
     // class A extends Future<int> implements Future<num> { ... }
     ClassElementImpl classA =
         ElementFactory.classElement('A', futureType.substitute4([intType]));
-    classA.interfaces = <InterfaceType>[futureType.substitute4([numType])];
+    classA.interfaces = <InterfaceType>[
+      futureType.substitute4([numType])
+    ];
     // class B extends Future<num> implements Future<int> { ... }
     ClassElementImpl classB =
         ElementFactory.classElement('B', futureType.substitute4([numType]));
-    classB.interfaces = <InterfaceType>[futureType.substitute4([intType])];
+    classB.interfaces = <InterfaceType>[
+      futureType.substitute4([intType])
+    ];
     // flatten(A) = flatten(B) = int, since int is more specific than num.
     expect(_flatten(classA.type), intType);
     expect(_flatten(classB.type), intType);
   }
 
   void test_flatten_simple() {
     InterfaceType intType = _typeProvider.intType;
     DartType dynamicType = _typeProvider.dynamicType;
     InterfaceType futureDynamicType = _typeProvider.futureDynamicType;
     InterfaceType futureIntType =
@@ skipping 16 matching lines @@
     expect(_flatten(futureFutureIntType), intType);
   }
 
   void test_flatten_unrelated_types() {
     InterfaceType futureType = _typeProvider.futureType;
     InterfaceType intType = _typeProvider.intType;
     InterfaceType stringType = _typeProvider.stringType;
     // class A extends Future<int> implements Future<String> { ... }
     ClassElementImpl classA =
         ElementFactory.classElement('A', futureType.substitute4([intType]));
-    classA.interfaces = <InterfaceType>[futureType.substitute4([stringType])];
+    classA.interfaces = <InterfaceType>[
+      futureType.substitute4([stringType])
+    ];
     // class B extends Future<String> implements Future<int> { ... }
     ClassElementImpl classB =
         ElementFactory.classElement('B', futureType.substitute4([stringType]));
-    classB.interfaces = <InterfaceType>[futureType.substitute4([intType])];
+    classB.interfaces = <InterfaceType>[
+      futureType.substitute4([intType])
+    ];
     // flatten(A) = A and flatten(B) = B, since neither string nor int is more
     // specific than the other.
     expect(_flatten(classA.type), classA.type);
     expect(_flatten(classB.type), classB.type);
   }
 
   void test_visitAdjacentStrings() {
     // "a" "b"
     Expression node = AstFactory
         .adjacentStrings([_resolvedString("a"), _resolvedString("b")]);
@@ skipping 22 matching lines @@
     MethodElement plusMethod = getMethod(numType, "+");
     node.staticElement = plusMethod;
     expect(_analyze(node), same(numType));
     _listener.assertNoErrors();
   }
 
   void test_visitAssignmentExpression_compoundIfNull_differentTypes() {
     // double d; d ??= 0
     Expression node = AstFactory.assignmentExpression(
         _resolvedVariable(_typeProvider.doubleType, 'd'),
-        TokenType.QUESTION_QUESTION_EQ, _resolvedInteger(0));
+        TokenType.QUESTION_QUESTION_EQ,
+        _resolvedInteger(0));
     expect(_analyze(node), same(_typeProvider.numType));
     _listener.assertNoErrors();
   }
 
   void test_visitAssignmentExpression_compoundIfNull_sameTypes() {
     // int i; i ??= 0
     Expression node = AstFactory.assignmentExpression(
         _resolvedVariable(_typeProvider.intType, 'i'),
-        TokenType.QUESTION_QUESTION_EQ, _resolvedInteger(0));
+        TokenType.QUESTION_QUESTION_EQ,
+        _resolvedInteger(0));
     expect(_analyze(node), same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
   void test_visitAssignmentExpression_simple() {
     // i = 0
     InterfaceType intType = _typeProvider.intType;
     Expression node = AstFactory.assignmentExpression(
         _resolvedVariable(intType, "i"), TokenType.EQ, _resolvedInteger(0));
     expect(_analyze(node), same(intType));
@@ skipping 36 matching lines @@
     // 1 ?? 1.5
     Expression node = AstFactory.binaryExpression(
         _resolvedInteger(1), TokenType.QUESTION_QUESTION, _resolvedDouble(1.5));
     expect(_analyze(node), same(_typeProvider.numType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_logicalAnd() {
     // false && true
     Expression node = AstFactory.binaryExpression(
-        AstFactory.booleanLiteral(false), TokenType.AMPERSAND_AMPERSAND,
+        AstFactory.booleanLiteral(false),
+        TokenType.AMPERSAND_AMPERSAND,
         AstFactory.booleanLiteral(true));
     expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_logicalOr() {
     // false || true
     Expression node = AstFactory.binaryExpression(
-        AstFactory.booleanLiteral(false), TokenType.BAR_BAR,
+        AstFactory.booleanLiteral(false),
+        TokenType.BAR_BAR,
         AstFactory.booleanLiteral(true));
     expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_minusID_propagated() {
     // a - b
     BinaryExpression node = AstFactory.binaryExpression(
-        _propagatedVariable(_typeProvider.intType, 'a'), TokenType.MINUS,
+        _propagatedVariable(_typeProvider.intType, 'a'),
+        TokenType.MINUS,
         _propagatedVariable(_typeProvider.doubleType, 'b'));
     node.propagatedElement = getMethod(_typeProvider.numType, "+");
     _analyze(node);
     expect(node.propagatedType, same(_typeProvider.doubleType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_notEquals() {
     // 2 != 3
     Expression node = AstFactory.binaryExpression(
@@ skipping 16 matching lines @@
     BinaryExpression node = AstFactory.binaryExpression(
         _resolvedInteger(1), TokenType.PLUS, _resolvedInteger(2));
     node.staticElement = getMethod(_typeProvider.numType, "+");
     expect(_analyze(node), same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_plusII_propagated() {
     // a + b
     BinaryExpression node = AstFactory.binaryExpression(
-        _propagatedVariable(_typeProvider.intType, 'a'), TokenType.PLUS,
+        _propagatedVariable(_typeProvider.intType, 'a'),
+        TokenType.PLUS,
         _propagatedVariable(_typeProvider.intType, 'b'));
     node.propagatedElement = getMethod(_typeProvider.numType, "+");
     _analyze(node);
     expect(node.propagatedType, same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_slash() {
     // 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_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(
+    BinaryExpression node = AstFactory.binaryExpression(
+        AstFactory.asExpression(
             AstFactory.identifier3("a"), AstFactory.typeName(classA)),
-        TokenType.PLUS, _resolvedDouble(2.0));
+        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, "*");
@@ skipping 19 matching lines @@
     // a..length
     Expression node = AstFactory.cascadeExpression(
         _resolvedString("a"), [AstFactory.propertyAccess2(null, "length")]);
     expect(_analyze(node), same(_typeProvider.stringType));
     _listener.assertNoErrors();
   }
 
   void test_visitConditionalExpression_differentTypes() {
     // true ? 1.0 : 0
     Expression node = AstFactory.conditionalExpression(
-        AstFactory.booleanLiteral(true), _resolvedDouble(1.0),
+        AstFactory.booleanLiteral(true),
+        _resolvedDouble(1.0),
         _resolvedInteger(0));
     expect(_analyze(node), same(_typeProvider.numType));
     _listener.assertNoErrors();
   }
 
   void test_visitConditionalExpression_sameTypes() {
     // true ? 1 : 0
     Expression node = AstFactory.conditionalExpression(
-        AstFactory.booleanLiteral(true), _resolvedInteger(1),
+        AstFactory.booleanLiteral(true),
+        _resolvedInteger(1),
         _resolvedInteger(0));
     expect(_analyze(node), same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
   void test_visitDoubleLiteral() {
     // 4.33
     Expression node = AstFactory.doubleLiteral(4.33);
     expect(_analyze(node), same(_typeProvider.doubleType));
     _listener.assertNoErrors();
@@ skipping 131 matching lines @@
     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);
+    _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]),
@@ skipping 91 matching lines @@
     _setType(p1, dynamicType);
     FormalParameter p2 = AstFactory.positionalFormalParameter(
         AstFactory.simpleFormalParameter3("p2"), _resolvedInteger(0));
     _setType(p2, dynamicType);
     FunctionExpression node = _resolvedFunctionExpression(
         AstFactory.formalParameterList([p1, p2]),
         AstFactory.blockFunctionBody2());
     _analyze5(p1);
     _analyze5(p2);
     DartType resultType = _analyze(node);
-    _assertFunctionType(dynamicType, null, <DartType>[
-      dynamicType,
-      dynamicType
-    ], null, resultType);
+    _assertFunctionType(dynamicType, null, <DartType>[dynamicType, dynamicType],
+        null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_positional_expression() {
     // ([p1 = 0, p2 = 0]) -> 0
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p = AstFactory.positionalFormalParameter(
         AstFactory.simpleFormalParameter3("p"), _resolvedInteger(0));
     _setType(p, dynamicType);
     FunctionExpression node = _resolvedFunctionExpression(
@@ skipping 82 matching lines @@
     // new C.m()
     ClassElementImpl classElement = ElementFactory.classElement2("C");
     String constructorName = "m";
     ConstructorElementImpl constructor =
         ElementFactory.constructorElement2(classElement, constructorName);
     constructor.returnType = classElement.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl(constructor);
     constructor.type = constructorType;
     classElement.constructors = <ConstructorElement>[constructor];
     InstanceCreationExpression node = AstFactory.instanceCreationExpression2(
-        null, AstFactory.typeName(classElement),
+        null,
+        AstFactory.typeName(classElement),
         [AstFactory.identifier3(constructorName)]);
     node.staticElement = constructor;
     expect(_analyze(node), same(classElement.type));
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_typeParameters() {
     // new C<I>()
     ClassElementImpl elementC = ElementFactory.classElement2("C", ["E"]);
     ClassElementImpl elementI = ElementFactory.classElement2("I");
@@ skipping 52 matching lines @@
     Expression node = AstFactory.isExpression(
         _resolvedString("a"), false, AstFactory.typeName4("String"));
     expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitListLiteral_empty() {
     // []
     Expression node = AstFactory.listLiteral();
     DartType resultType = _analyze(node);
-    _assertType2(_typeProvider.listType
-        .substitute4(<DartType>[_typeProvider.dynamicType]), resultType);
+    _assertType2(
+        _typeProvider.listType
+            .substitute4(<DartType>[_typeProvider.dynamicType]),
+        resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitListLiteral_nonEmpty() {
     // [0]
     Expression node = AstFactory.listLiteral([_resolvedInteger(0)]);
     DartType resultType = _analyze(node);
-    _assertType2(_typeProvider.listType
-        .substitute4(<DartType>[_typeProvider.dynamicType]), resultType);
+    _assertType2(
+        _typeProvider.listType
+            .substitute4(<DartType>[_typeProvider.dynamicType]),
+        resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitMapLiteral_empty() {
     // {}
     Expression node = AstFactory.mapLiteral2();
     DartType resultType = _analyze(node);
-    _assertType2(_typeProvider.mapType.substitute4(
+    _assertType2(
+        _typeProvider.mapType.substitute4(
             <DartType>[_typeProvider.dynamicType, _typeProvider.dynamicType]),
         resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitMapLiteral_nonEmpty() {
     // {"k" : 0}
     Expression node = AstFactory
         .mapLiteral2([AstFactory.mapLiteralEntry("k", _resolvedInteger(0))]);
     DartType resultType = _analyze(node);
-    _assertType2(_typeProvider.mapType.substitute4(
+    _assertType2(
+        _typeProvider.mapType.substitute4(
             <DartType>[_typeProvider.dynamicType, _typeProvider.dynamicType]),
         resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitMethodInvocation_then() {
     // then()
     Expression node = AstFactory.methodInvocation(null, "then");
     _analyze(node);
     _listener.assertNoErrors();
@@ skipping 205 matching lines @@
     _listener.assertNoErrors();
   }
 
   void test_visitSymbolLiteral() {
     expect(_analyze(AstFactory.symbolLiteral(["a"])),
         same(_typeProvider.symbolType));
   }
 
   void test_visitThisExpression() {
     // this
-    InterfaceType thisType = ElementFactory.classElement(
-        "B", ElementFactory.classElement2("A").type).type;
+    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();
@@ skipping 78 matching lines @@
 
   /**
    * Assert that the actual type is a function type with the expected characteristics.
    *
    * @param expectedReturnType the expected return type of the function
    * @param expectedNormalTypes the expected types of the normal parameters
    * @param expectedOptionalTypes the expected types of the optional parameters
    * @param expectedNamedTypes the expected types of the named parameters
    * @param actualType the type being tested
    */
-  void _assertFunctionType(DartType expectedReturnType,
-      List<DartType> expectedNormalTypes, List<DartType> expectedOptionalTypes,
-      Map<String, DartType> expectedNamedTypes, DartType actualType) {
+  void _assertFunctionType(
+      DartType expectedReturnType,
+      List<DartType> expectedNormalTypes,
+      List<DartType> expectedOptionalTypes,
+      Map<String, DartType> expectedNamedTypes,
+      DartType actualType) {
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionType, FunctionType, actualType);
     FunctionType functionType = actualType as FunctionType;
     List<DartType> normalTypes = functionType.normalParameterTypes;
     if (expectedNormalTypes == null) {
       expect(normalTypes, hasLength(0));
     } else {
       int expectedCount = expectedNormalTypes.length;
       expect(normalTypes, hasLength(expectedCount));
       for (int i = 0; i < expectedCount; i++) {
@@ skipping 732 matching lines @@
 
   void test_getType_noScope() {
     TypeOverrideManager manager = new TypeOverrideManager();
     expect(manager.getType(ElementFactory.localVariableElement2("v")), isNull);
   }
 }
 
 @reflectiveTest
 class TypePropagationTest extends ResolverTestCase {
   void fail_finalPropertyInducingVariable_classMember_instance() {
-    addNamedSource("/lib.dart", r'''
+    addNamedSource(
+        "/lib.dart",
+        r'''
 class A {
   final v = 0;
 }''');
     String code = r'''
 import 'lib.dart';
 f(A a) {
   return a.v; // marker
 }''';
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void fail_finalPropertyInducingVariable_classMember_instance_inherited() {
-    addNamedSource("/lib.dart", r'''
+    addNamedSource(
+        "/lib.dart",
+        r'''
 class A {
   final v = 0;
 }''');
     String code = r'''
 import 'lib.dart';
 class B extends A {
   m() {
     return v; // marker
   }
 }''';
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void fail_finalPropertyInducingVariable_classMember_instance_propagatedTarget() {
-    addNamedSource("/lib.dart", r'''
+    addNamedSource(
+        "/lib.dart",
+        r'''
 class A {
   final v = 0;
 }''');
     String code = r'''
 import 'lib.dart';
 f(p) {
   if (p is A) {
     return p.v; // marker
   }
 }''';
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void fail_finalPropertyInducingVariable_classMember_static() {
-    addNamedSource("/lib.dart", r'''
+    addNamedSource(
+        "/lib.dart",
+        r'''
 class A {
   static final V = 0;
 }''');
     String code = r'''
 import 'lib.dart';
 f() {
   return A.V; // marker
 }''';
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
@@ skipping 16 matching lines @@
 import 'lib.dart';
 f() {
   return V; // marker simple
 }''';
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void fail_mergePropagatedTypesAtJoinPoint_1() {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    _assertTypeOfMarkedExpression(r'''
+    _assertTypeOfMarkedExpression(
+        r'''
 f1(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
     y = '';
   }
   // Propagated type is [List] here: incorrect.
   // Best we can do is [Object]?
   return y; // marker
-}''', null, typeProvider.dynamicType);
+}''',
+        null,
+        typeProvider.dynamicType);
   }
 
   void fail_mergePropagatedTypesAtJoinPoint_2() {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    _assertTypeOfMarkedExpression(r'''
+    _assertTypeOfMarkedExpression(
+        r'''
 f2(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
   }
   // Propagated type is [List] here: incorrect.
   // Best we can do is [Object]?
   return y; // marker
-}''', null, typeProvider.dynamicType);
+}''',
+        null,
+        typeProvider.dynamicType);
   }
 
   void fail_mergePropagatedTypesAtJoinPoint_3() {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    _assertTypeOfMarkedExpression(r'''
+    _assertTypeOfMarkedExpression(
+        r'''
 f4(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
     y = 1.5;
   }
   // Propagated type is [List] here: incorrect.
   // A correct answer is the least upper bound of [int] and [double],
   // i.e. [num].
   return y; // marker
-}''', null, typeProvider.numType);
+}''',
+        null,
+        typeProvider.numType);
   }
 
   void fail_mergePropagatedTypesAtJoinPoint_5() {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    _assertTypeOfMarkedExpression(r'''
+    _assertTypeOfMarkedExpression(
+        r'''
 f6(x,y) {
   var z = [];
   if (x || (z = y) < 0) {
   } else {
     z = 0;
   }
   // Propagated type is [List] here: incorrect.
   // Best we can do is [Object]?
   return z; // marker
-}''', null, typeProvider.dynamicType);
+}''',
+        null,
+        typeProvider.dynamicType);
   }
 
   void fail_mergePropagatedTypesAtJoinPoint_7() {
     // https://code.google.com/p/dart/issues/detail?id=19929
     //
     // In general [continue]s are unsafe for the purposes of
     // [isAbruptTerminationStatement].
     //
     // This is like example 6, but less tricky: the code in the branch that
     // [continue]s is in effect after the [if].
@@ skipping 219 matching lines @@
       expect(identifier.propagatedType, same(stringType));
     }
     // in the loop body
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "e;", (node) => node is SimpleIdentifier);
       expect(identifier.propagatedType, same(stringType));
     }
   }
 
+  void test_forEach_async() {
+    String code = r'''
+import 'dart:async';
+f(Stream<String> stream) async {
+  await for (var e in stream) {
+    e;
+  }
+}''';
+    Source source = addSource(code);
+    LibraryElement library = resolve2(source);
+    assertNoErrors(source);
+    verify([source]);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    InterfaceType stringType = typeProvider.stringType;
+    // in the declaration
+    {
+      SimpleIdentifier identifier = EngineTestCase.findNode(
+          unit, code, "e in", (node) => node is SimpleIdentifier);
+      expect(identifier.propagatedType, same(stringType));
+    }
+    // in the loop body
+    {
+      SimpleIdentifier identifier = EngineTestCase.findNode(
+          unit, code, "e;", (node) => node is SimpleIdentifier);
+      expect(identifier.propagatedType, same(stringType));
+    }
+  }
+
   void test_functionExpression_asInvocationArgument() {
     String code = r'''
 class MyMap<K, V> {
   forEach(f(K key, V value)) {}
 }
 f(MyMap<int, String> m) {
   m.forEach((k, v) {
     k;
     v;
   });
@@ skipping 802 matching lines @@
       SimpleIdentifier identifier = _findMarkedIdentifier(code, "v;");
       expect(identifier.propagatedType, null);
     }
     {
       SimpleIdentifier identifier = _findMarkedIdentifier(code, "v = '';");
       expect(identifier.propagatedType, typeProvider.stringType);
     }
   }
 
   void test_mergePropagatedTypes_afterIfThen_same() {
-    _assertTypeOfMarkedExpression(r'''
+    _assertTypeOfMarkedExpression(
+        r'''
 main() {
   var v = 1;
   if (v != null) {
     v = 2;
   }
   return v; // marker
-}''', null, typeProvider.intType);
+}''',
+        null,
+        typeProvider.intType);
   }
 
   void test_mergePropagatedTypes_afterIfThenElse_different() {
-    _assertTypeOfMarkedExpression(r'''
+    _assertTypeOfMarkedExpression(
+        r'''
 main() {
   var v = 1;
   if (v != null) {
     v = 2;
   } else {
     v = '3';
   }
   return v; // marker
-}''', null, null);
+}''',
+        null,
+        null);
   }
 
   void test_mergePropagatedTypes_afterIfThenElse_same() {
-    _assertTypeOfMarkedExpression(r'''
+    _assertTypeOfMarkedExpression(
+        r'''
 main() {
   var v = 1;
   if (v != null) {
     v = 2;
   } else {
     v = 3;
   }
   return v; // marker
-}''', null, typeProvider.intType);
+}''',
+        null,
+        typeProvider.intType);
   }
 
   void test_mergePropagatedTypesAtJoinPoint_4() {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    _assertTypeOfMarkedExpression(r'''
+    _assertTypeOfMarkedExpression(
+        r'''
 f5(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
     return y;
   }
   // Propagated type is [int] here: correct.
   return y; // marker
-}''', null, typeProvider.intType);
+}''',
+        null,
+        typeProvider.intType);
   }
 
   void test_mutatedOutsideScope() {
     // https://code.google.com/p/dart/issues/detail?id=22732
     Source source = addSource(r'''
 class Base {
 }
 
 class Derived extends Base {
   get y => null;
@@ skipping 20 matching lines @@
     assertNoErrors(source);
   }
 
   void test_objectMethodOnDynamicExpression_doubleEquals() {
     // https://code.google.com/p/dart/issues/detail?id=20342
     //
     // This was not actually part of Issue 20342, since the spec specifies a
     // static type of [bool] for [==] comparison and the implementation
     // was already consistent with the spec there. But, it's another
     // [Object] method, so it's included here.
-    _assertTypeOfMarkedExpression(r'''
+    _assertTypeOfMarkedExpression(
+        r'''
 f1(x) {
   var v = (x == x);
   return v; // marker
-}''', null, typeProvider.boolType);
+}''',
+        null,
+        typeProvider.boolType);
   }
 
   void test_objectMethodOnDynamicExpression_hashCode() {
     // https://code.google.com/p/dart/issues/detail?id=20342
-    _assertTypeOfMarkedExpression(r'''
+    _assertTypeOfMarkedExpression(
+        r'''
 f1(x) {
   var v = x.hashCode;
   return v; // marker
-}''', null, typeProvider.intType);
+}''',
+        null,
+        typeProvider.intType);
   }
 
   void test_objectMethodOnDynamicExpression_runtimeType() {
     // https://code.google.com/p/dart/issues/detail?id=20342
-    _assertTypeOfMarkedExpression(r'''
+    _assertTypeOfMarkedExpression(
+        r'''
 f1(x) {
   var v = x.runtimeType;
   return v; // marker
-}''', null, typeProvider.typeType);
+}''',
+        null,
+        typeProvider.typeType);
   }
 
   void test_objectMethodOnDynamicExpression_toString() {
     // https://code.google.com/p/dart/issues/detail?id=20342
-    _assertTypeOfMarkedExpression(r'''
+    _assertTypeOfMarkedExpression(
+        r'''
 f1(x) {
   var v = x.toString();
   return v; // marker
-}''', null, typeProvider.stringType);
+}''',
+        null,
+        typeProvider.stringType);
   }
 
   void test_propagatedReturnType_function_hasReturnType_returnsNull() {
     String code = r'''
 String f() => null;
 main() {
   var v = f();
 }''';
     _assertPropagatedReturnType(
         code, typeProvider.dynamicType, typeProvider.stringType);
@@ skipping 603 matching lines @@
   }
 
   void test_visitFunctionDeclaration() {
     // R f(P p) {}
     // class R {}
     // class P {}
     ClassElement elementR = ElementFactory.classElement2('R');
     ClassElement elementP = ElementFactory.classElement2('P');
     FunctionElement elementF = ElementFactory.functionElement('f');
     FunctionDeclaration declaration = AstFactory.functionDeclaration(
-        AstFactory.typeName4('R'), null, 'f', AstFactory.functionExpression2(
+        AstFactory.typeName4('R'),
+        null,
+        'f',
+        AstFactory.functionExpression2(
             AstFactory.formalParameterList([
-      AstFactory.simpleFormalParameter4(AstFactory.typeName4('P'), 'p')
-    ]), null));
+              AstFactory.simpleFormalParameter4(AstFactory.typeName4('P'), 'p')
+            ]),
+            null));
     declaration.name.staticElement = elementF;
     _resolveNode(declaration, [elementR, elementP]);
     expect(declaration.returnType.type, elementR.type);
     SimpleFormalParameter parameter =
         declaration.functionExpression.parameters.parameters[0];
     expect(parameter.type.type, elementP.type);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionDeclaration_typeParameter() {
     // E f<E>(E e) {}
     TypeParameterElement elementE = ElementFactory.typeParameterElement('E');
     FunctionElementImpl elementF = ElementFactory.functionElement('f');
     elementF.typeParameters = <TypeParameterElement>[elementE];
     FunctionDeclaration declaration = AstFactory.functionDeclaration(
-        AstFactory.typeName4('E'), null, 'f', AstFactory.functionExpression2(
+        AstFactory.typeName4('E'),
+        null,
+        'f',
+        AstFactory.functionExpression2(
             AstFactory.formalParameterList([
-      AstFactory.simpleFormalParameter4(AstFactory.typeName4('E'), 'e')
-    ]), null));
+              AstFactory.simpleFormalParameter4(AstFactory.typeName4('E'), 'e')
+            ]),
+            null));
     declaration.name.staticElement = elementF;
     _resolveNode(declaration, []);
     expect(declaration.returnType.type, elementE.type);
     SimpleFormalParameter parameter =
         declaration.functionExpression.parameters.parameters[0];
     expect(parameter.type.type, elementE.type);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionTypedFormalParameter() {
     // R f(R g(P p)) {}
     // class R {}
     // class P {}
     ClassElement elementR = ElementFactory.classElement2('R');
     ClassElement elementP = ElementFactory.classElement2('P');
     FunctionElement elementF = ElementFactory.functionElement('f');
     ParameterElementImpl requiredParameter =
         ElementFactory.requiredParameter('p');
     FunctionTypedFormalParameter parameterDeclaration = AstFactory
         .functionTypedFormalParameter(AstFactory.typeName4('R'), 'g', [
       AstFactory.simpleFormalParameter4(AstFactory.typeName4('P'), 'p')
     ]);
     parameterDeclaration.identifier.staticElement = requiredParameter;
     FunctionDeclaration declaration = AstFactory.functionDeclaration(
-        AstFactory.typeName4('R'), null, 'f', AstFactory.functionExpression2(
+        AstFactory.typeName4('R'),
+        null,
+        'f',
+        AstFactory.functionExpression2(
             AstFactory.formalParameterList([parameterDeclaration]), null));
     declaration.name.staticElement = elementF;
     _resolveNode(declaration, [elementR, elementP]);
     expect(declaration.returnType.type, elementR.type);
     FunctionTypedFormalParameter parameter =
         declaration.functionExpression.parameters.parameters[0];
     expect(parameter.returnType.type, elementR.type);
     SimpleFormalParameter innerParameter = parameter.parameters.parameters[0];
     expect(innerParameter.type.type, elementP.type);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionTypedFormalParameter_typeParameter() {
     // R f(R g<E>(E e)) {}
     // class R {}
     ClassElement elementR = ElementFactory.classElement2('R');
     TypeParameterElement elementE = ElementFactory.typeParameterElement('E');
     FunctionElement elementF = ElementFactory.functionElement('f');
     ParameterElementImpl requiredParameter =
         ElementFactory.requiredParameter('g');
     requiredParameter.typeParameters = <TypeParameterElement>[elementE];
     FunctionTypedFormalParameter parameterDeclaration = AstFactory
         .functionTypedFormalParameter(AstFactory.typeName4('R'), 'g', [
       AstFactory.simpleFormalParameter4(AstFactory.typeName4('E'), 'e')
     ]);
     parameterDeclaration.identifier.staticElement = requiredParameter;
     FunctionDeclaration declaration = AstFactory.functionDeclaration(
-        AstFactory.typeName4('R'), null, 'f', AstFactory.functionExpression2(
+        AstFactory.typeName4('R'),
+        null,
+        'f',
+        AstFactory.functionExpression2(
             AstFactory.formalParameterList([parameterDeclaration]), null));
     declaration.name.staticElement = elementF;
     _resolveNode(declaration, [elementR]);
     expect(declaration.returnType.type, elementR.type);
     FunctionTypedFormalParameter parameter =
         declaration.functionExpression.parameters.parameters[0];
     expect(parameter.returnType.type, elementR.type);
     SimpleFormalParameter innerParameter = parameter.parameters.parameters[0];
     expect(innerParameter.type.type, elementE.type);
     _listener.assertNoErrors();
   }
 
   void test_visitMethodDeclaration() {
     // class A {
     //   R m(P p) {}
     // }
     // class R {}
     // class P {}
     ClassElementImpl elementA = ElementFactory.classElement2('A');
     ClassElement elementR = ElementFactory.classElement2('R');
     ClassElement elementP = ElementFactory.classElement2('P');
     MethodElement elementM = ElementFactory.methodElement('m', null);
     elementA.methods = <MethodElement>[elementM];
-    MethodDeclaration declaration = AstFactory.methodDeclaration(null,
-        AstFactory.typeName4('R'), null, null, AstFactory.identifier3('m'),
+    MethodDeclaration declaration = AstFactory.methodDeclaration(
+        null,
+        AstFactory.typeName4('R'),
+        null,
+        null,
+        AstFactory.identifier3('m'),
         AstFactory.formalParameterList([
-      AstFactory.simpleFormalParameter4(AstFactory.typeName4('P'), 'p')
-    ]));
+          AstFactory.simpleFormalParameter4(AstFactory.typeName4('P'), 'p')
+        ]));
     declaration.name.staticElement = elementM;
     _resolveNode(declaration, [elementA, elementR, elementP]);
     expect(declaration.returnType.type, elementR.type);
     SimpleFormalParameter parameter = declaration.parameters.parameters[0];
     expect(parameter.type.type, elementP.type);
     _listener.assertNoErrors();
   }
 
   void test_visitMethodDeclaration_typeParameter() {
     // class A {
     //   E m<E>(E e) {}
     // }
     ClassElementImpl elementA = ElementFactory.classElement2('A');
     TypeParameterElement elementE = ElementFactory.typeParameterElement('E');
     MethodElementImpl elementM = ElementFactory.methodElement('m', null);
     elementM.typeParameters = <TypeParameterElement>[elementE];
     elementA.methods = <MethodElement>[elementM];
-    MethodDeclaration declaration = AstFactory.methodDeclaration(null,
-        AstFactory.typeName4('E'), null, null, AstFactory.identifier3('m'),
+    MethodDeclaration declaration = AstFactory.methodDeclaration(
+        null,
+        AstFactory.typeName4('E'),
+        null,
+        null,
+        AstFactory.identifier3('m'),
         AstFactory.formalParameterList([
-      AstFactory.simpleFormalParameter4(AstFactory.typeName4('E'), 'e')
-    ]));
+          AstFactory.simpleFormalParameter4(AstFactory.typeName4('E'), 'e')
+        ]));
     declaration.name.staticElement = elementM;
     _resolveNode(declaration, [elementA]);
     expect(declaration.returnType.type, elementE.type);
     SimpleFormalParameter parameter = declaration.parameters.parameters[0];
     expect(parameter.type.type, elementE.type);
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleFormalParameter_noType() {
     // p
@@ skipping 172 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;
   }
 }