Format and sort analyzer and analysis_server packages.

pkg/analyzer/test/generated/all_the_rest.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.all_the_rest_test;
 
 import 'dart:collection';
@@ skipping 350 matching lines @@
         return ht.TokenType.DECLARATION;
       }
       if (lexeme.startsWith("<?")) {
         return ht.TokenType.DIRECTIVE;
       }
       if (_isTag(lexeme)) {
         return ht.TokenType.TAG;
       }
       return ht.TokenType.TEXT;
     }
-    fail("Unknown expected token $count: ${expected != null ? expected.runtimeType : "null"}");
+    fail(
+        "Unknown expected token $count: ${expected != null ? expected.runtimeType : "null"}");
     return null;
   }
 
   bool _isTag(String lexeme) {
     if (lexeme.length == 0 || !Character.isLetter(lexeme.codeUnitAt(0))) {
       return false;
     }
     for (int index = 1; index < lexeme.length; index++) {
       int ch = lexeme.codeUnitAt(index);
       if (!Character.isLetterOrDigit(ch) && ch != 0x2D && ch != 0x5F) {
@@ skipping 63 matching lines @@
         buffer.write(", ");
       }
       fail(buffer.toString());
     }
     return firstToken;
   }
 }
 
 
 class AngularCompilationUnitBuilderTest extends AngularTest {
+  void test_bad_notConstructorAnnotation() {
+    String mainContent = r'''
+const MY_ANNOTATION = null;
+@MY_ANNOTATION()
+class MyFilter {
+}''';
+    resolveMainSource(mainContent);
+    // prepare AngularFilterElement
+    ClassElement classElement = mainUnitElement.getType("MyFilter");
+    AngularFormatterElement filter =
+        getAngularElement(classElement, (e) => e is AngularFormatterElement);
+    expect(filter, isNull);
+  }
+
   void test_Decorator() {
     String mainContent = _createAngularSource(r'''
 @Decorator(selector: '[my-dir]',
              map: const {
                'my-dir' : '=>myPropA',
                '.' : '&myPropB',
              })
 class MyDirective {
   set myPropA(value) {}
   set myPropB(value) {}
@@ skipping 94 matching lines @@
     resolveMainSource(mainContent);
     // has error
     assertMainErrors([AngularCode.MISSING_NAME]);
     // no filter
     ClassElement classElement = mainUnitElement.getType("MyFilter");
     AngularFormatterElement filter =
         getAngularElement(classElement, (e) => e is AngularFormatterElement);
     expect(filter, isNull);
   }
 
+  void test_getElement_component_name() {
+    resolveMainSource(_createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
+class MyComponent {}'''));
+    SimpleStringLiteral node =
+        _findMainNode("ctrl'", (n) => n is SimpleStringLiteral);
+    int offset = node.offset;
+    // find AngularComponentElement
+    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is AngularComponentElement,
+        AngularComponentElement,
+        element);
+  }
+
+  void test_getElement_component_property_fromFieldAnnotation() {
+    resolveMainSource(_createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
+class MyComponent {
+  @NgOneWay('prop')
+  var field;
+}'''));
+    // prepare node
+    SimpleStringLiteral node =
+        _findMainNode("prop'", (n) => n is SimpleStringLiteral);
+    int offset = node.offset;
+    // prepare Element
+    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
+    expect(element, isNotNull);
+    // check AngularPropertyElement
+    AngularPropertyElement property = element as AngularPropertyElement;
+    expect(property.name, "prop");
+  }
+
+  void test_getElement_component_property_fromMap() {
+    resolveMainSource(_createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
+             map: const {
+               'prop' : '@field',
+             })
+class MyComponent {
+  var field;
+}'''));
+    // AngularPropertyElement
+    {
+      SimpleStringLiteral node =
+          _findMainNode("prop'", (n) => n is SimpleStringLiteral);
+      int offset = node.offset;
+      // prepare Element
+      Element element = AngularCompilationUnitBuilder.getElement(node, offset);
+      expect(element, isNotNull);
+      // check AngularPropertyElement
+      AngularPropertyElement property = element as AngularPropertyElement;
+      expect(property.name, "prop");
+    }
+    // FieldElement
+    {
+      SimpleStringLiteral node =
+          _findMainNode("@field'", (n) => n is SimpleStringLiteral);
+      int offset = node.offset;
+      // prepare Element
+      Element element = AngularCompilationUnitBuilder.getElement(node, offset);
+      expect(element, isNotNull);
+      // check FieldElement
+      FieldElement field = element as FieldElement;
+      expect(field.name, "field");
+    }
+  }
+
+  void test_getElement_component_selector() {
+    resolveMainSource(_createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
+class MyComponent {}'''));
+    SimpleStringLiteral node =
+        _findMainNode("myComp'", (n) => n is SimpleStringLiteral);
+    int offset = node.offset;
+    // find AngularSelectorElement
+    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is AngularSelectorElement,
+        AngularSelectorElement,
+        element);
+  }
+
+  void test_getElement_controller_name() {
+    resolveMainSource(_createAngularSource(r'''
+@Controller(publishAs: 'ctrl', selector: '[myApp]')
+class MyController {
+}'''));
+    SimpleStringLiteral node =
+        _findMainNode("ctrl'", (n) => n is SimpleStringLiteral);
+    int offset = node.offset;
+    // find AngularControllerElement
+    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is AngularControllerElement,
+        AngularControllerElement,
+        element);
+  }
+
+  void test_getElement_directive_property() {
+    resolveMainSource(_createAngularSource(r'''
+@Decorator(selector: '[my-dir]',
+             map: const {
+               'my-dir' : '=>field'
+             })
+class MyDirective {
+  set field(value) {}
+}'''));
+    // prepare node
+    SimpleStringLiteral node =
+        _findMainNode("my-dir'", (n) => n is SimpleStringLiteral);
+    int offset = node.offset;
+    // prepare Element
+    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
+    expect(element, isNotNull);
+    // check AngularPropertyElement
+    AngularPropertyElement property = element as AngularPropertyElement;
+    expect(property.name, "my-dir");
+  }
+
+  void test_getElement_directive_selector() {
+    resolveMainSource(_createAngularSource(r'''
+@Decorator(selector: '[my-dir]')
+class MyDirective {}'''));
+    SimpleStringLiteral node =
+        _findMainNode("my-dir]'", (n) => n is SimpleStringLiteral);
+    int offset = node.offset;
+    // find AngularSelectorElement
+    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is AngularSelectorElement,
+        AngularSelectorElement,
+        element);
+  }
+
+  void test_getElement_filter_name() {
+    resolveMainSource(_createAngularSource(r'''
+@Formatter(name: 'myFilter')
+class MyFilter {
+  call(p1, p2) {}
+}'''));
+    SimpleStringLiteral node =
+        _findMainNode("myFilter'", (n) => n is SimpleStringLiteral);
+    int offset = node.offset;
+    // find FilterElement
+    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is AngularFormatterElement,
+        AngularFormatterElement,
+        element);
+  }
+
+  void test_getElement_noClassDeclaration() {
+    resolveMainSource("var foo = 'bar';");
+    SimpleStringLiteral node =
+        _findMainNode("bar'", (n) => n is SimpleStringLiteral);
+    Element element = AngularCompilationUnitBuilder.getElement(node, 0);
+    expect(element, isNull);
+  }
+
+  void test_getElement_noClassElement() {
+    resolveMainSource(r'''
+class A {
+  const A(p);
+}
+
+@A('bar')
+class B {}''');
+    SimpleStringLiteral node =
+        _findMainNode("bar'", (n) => n is SimpleStringLiteral);
+    // reset B element
+    ClassDeclaration classDeclaration =
+        node.getAncestor((node) => node is ClassDeclaration);
+    classDeclaration.name.staticElement = null;
+    // class is not resolved - no element
+    Element element = AngularCompilationUnitBuilder.getElement(node, 0);
+    expect(element, isNull);
+  }
+
+  void test_getElement_noNode() {
+    Element element = AngularCompilationUnitBuilder.getElement(null, 0);
+    expect(element, isNull);
+  }
+
+  void test_getElement_notFound() {
+    resolveMainSource(r'''
+class MyComponent {
+  var str = 'some string';
+}''');
+    // prepare node
+    SimpleStringLiteral node =
+        _findMainNode("some string'", (n) => n is SimpleStringLiteral);
+    int offset = node.offset;
+    // no Element
+    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
+    expect(element, isNull);
+  }
+
+  void test_getElement_SimpleStringLiteral_withToolkitElement() {
+    SimpleStringLiteral literal = AstFactory.string2("foo");
+    Element element = new AngularScopePropertyElementImpl("foo", 0, null);
+    literal.toolkitElement = element;
+    expect(
+        AngularCompilationUnitBuilder.getElement(literal, -1),
+        same(element));
+  }
+
   void test_NgComponent_bad_cannotParseSelector() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
     String mainContent = _createAngularSource(r'''
 @Component(publishAs: 'ctrl', selector: '~myComp',
              templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
 class MyComponent {
 }''');
     resolveMainSource(mainContent);
     // has error
@@ skipping 13 matching lines @@
     assertMainErrors([AngularCode.MISSING_SELECTOR]);
   }
 
   /**
    *
    * https://code.google.com/p/dart/issues/detail?id=16346
    */
   void test_NgComponent_bad_notHtmlTemplate() {
     contextHelper.addSource("/my_template", "");
     contextHelper.addSource("/my_styles.css", "");
-    addMainSource(
-        _createAngularSource(r'''
+    addMainSource(_createAngularSource(r'''
 @NgComponent(publishAs: 'ctrl', selector: 'myComp',
              templateUrl: 'my_template', cssUrl: 'my_styles.css')
 class MyComponent {
 }'''));
     contextHelper.runTasks();
   }
 
   void test_NgComponent_bad_properties_invalidBinding() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
@@ skipping 136 matching lines @@
 @Component('foo', 42)
 class MyComponent {
 }''';
     resolveMainSource(mainContent);
     assertNoMainErrors();
   }
 
   void test_NgComponent_properties_fieldFromSuper() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    resolveMainSourceNoErrors(
-        _createAngularSource(r'''
+    resolveMainSourceNoErrors(_createAngularSource(r'''
 class MySuper {
   var myPropA;
 }
 
 
 
 @Component(publishAs: 'ctrl', selector: 'myComp',
              templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
              map: const {
                'prop-a' : '@myPropA'
@@ skipping 13 matching lines @@
         "prop-a",
         findMainOffset("prop-a' :"),
         AngularPropertyKind.ATTR,
         "myPropA",
         findMainOffset("myPropA'"));
   }
 
   void test_NgComponent_properties_fromFields() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    resolveMainSourceNoErrors(
-        _createAngularSource(r'''
+    resolveMainSourceNoErrors(_createAngularSource(r'''
 @Component(publishAs: 'ctrl', selector: 'myComp',
              templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
 class MyComponent {
   @NgAttr('prop-a')
   var myPropA;
   @NgCallback('prop-b')
   var myPropB;
   @NgOneWay('prop-c')
   var myPropC;
   @NgOneWayOneTime('prop-d')
@@ skipping 42 matching lines @@
         "prop-e",
         findMainOffset("prop-e')"),
         AngularPropertyKind.TWO_WAY,
         "myPropE",
         -1);
   }
 
   void test_NgComponent_properties_fromMap() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    resolveMainSourceNoErrors(
-        _createAngularSource(r'''
+    resolveMainSourceNoErrors(_createAngularSource(r'''
 @Component(publishAs: 'ctrl', selector: 'myComp',
              templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
              map: const {
                'prop-a' : '@myPropA',
                'prop-b' : '&myPropB',
                'prop-c' : '=>myPropC',
                'prop-d' : '=>!myPropD',
                'prop-e' : '<=>myPropE'
              })
 class MyComponent {
@@ skipping 60 matching lines @@
     // prepare AngularComponentElement
     ClassElement classElement = mainUnitElement.getType("MyComponent");
     AngularComponentElement component =
         getAngularElement(classElement, (e) => e is AngularComponentElement);
     expect(component, isNotNull);
     // verify
     expect(component.name, "ctrl");
     expect(component.nameOffset, AngularTest.findOffset(mainContent, "ctrl'"));
     _assertIsTagSelector(component.selector, "myComp");
     expect(component.templateUri, "my_template.html");
-    expect(component.templateUriOffset, AngularTest.findOffset(mainContent, "my_template.html'"));
+    expect(
+        component.templateUriOffset,
+        AngularTest.findOffset(mainContent, "my_template.html'"));
     expect(component.styleUri, "my_styles.css");
-    expect(component.styleUriOffset, AngularTest.findOffset(mainContent, "my_styles.css'"));
+    expect(
+        component.styleUriOffset,
+        AngularTest.findOffset(mainContent, "my_styles.css'"));
     expect(component.properties, hasLength(0));
   }
 
   void test_NgComponent_scopeProperties() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
     String mainContent = _createAngularSource(r'''
 @Component(publishAs: 'ctrl', selector: 'myComp',
              templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
 class MyComponent {
@@ skipping 18 matching lines @@
         getAngularElement(classElement, (e) => e is AngularComponentElement);
     expect(component, isNotNull);
     // verify
     List<AngularScopePropertyElement> scopeProperties =
         component.scopeProperties;
     expect(scopeProperties, hasLength(3));
     {
       AngularScopePropertyElement property = scopeProperties[0];
       expect(findMainElement2("boolProp"), same(property));
       expect(property.name, "boolProp");
-      expect(property.nameOffset, AngularTest.findOffset(mainContent, "boolProp'"));
+      expect(
+          property.nameOffset,
+          AngularTest.findOffset(mainContent, "boolProp'"));
       expect(property.type.name, "bool");
     }
     {
       AngularScopePropertyElement property = scopeProperties[1];
       expect(findMainElement2("intProp"), same(property));
       expect(property.name, "intProp");
-      expect(property.nameOffset, AngularTest.findOffset(mainContent, "intProp'"));
+      expect(
+          property.nameOffset,
+          AngularTest.findOffset(mainContent, "intProp'"));
       expect(property.type.name, "int");
     }
     {
       AngularScopePropertyElement property = scopeProperties[2];
       expect(findMainElement2("stringProp"), same(property));
       expect(property.name, "stringProp");
-      expect(property.nameOffset, AngularTest.findOffset(mainContent, "stringProp'"));
+      expect(
+          property.nameOffset,
+          AngularTest.findOffset(mainContent, "stringProp'"));
       expect(property.type.name, "String");
     }
   }
 
   void test_NgController() {
     String mainContent = _createAngularSource(r'''
 @Controller(publishAs: 'ctrl', selector: '[myApp]')
 class MyController {
 }''');
     resolveMainSourceNoErrors(mainContent);
@@ skipping 32 matching lines @@
     String mainContent = _createAngularSource(r'''
 @Controller(publishAs: 'ctrl')
 class MyController {
 }''');
     resolveMainSource(mainContent);
     // has error
     assertMainErrors([AngularCode.MISSING_SELECTOR]);
   }
 
   void test_NgController_noAnnotationArguments() {
-    String mainContent =
-        _createAngularSource(r'''
+    String mainContent = _createAngularSource(r'''
 @NgController
 class MyController {
 }''');
     resolveMainSource(mainContent);
   }
 
-  void test_bad_notConstructorAnnotation() {
-    String mainContent = r'''
-const MY_ANNOTATION = null;
-@MY_ANNOTATION()
-class MyFilter {
-}''';
-    resolveMainSource(mainContent);
-    // prepare AngularFilterElement
-    ClassElement classElement = mainUnitElement.getType("MyFilter");
-    AngularFormatterElement filter =
-        getAngularElement(classElement, (e) => e is AngularFormatterElement);
-    expect(filter, isNull);
-  }
-
-  void test_getElement_SimpleStringLiteral_withToolkitElement() {
-    SimpleStringLiteral literal = AstFactory.string2("foo");
-    Element element = new AngularScopePropertyElementImpl("foo", 0, null);
-    literal.toolkitElement = element;
-    expect(AngularCompilationUnitBuilder.getElement(literal, -1), same(element));
-  }
-
-  void test_getElement_component_name() {
-    resolveMainSource(
-        _createAngularSource(r'''
-@Component(publishAs: 'ctrl', selector: 'myComp',
-             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
-class MyComponent {}'''));
-    SimpleStringLiteral node =
-        _findMainNode("ctrl'", (n) => n is SimpleStringLiteral);
-    int offset = node.offset;
-    // find AngularComponentElement
-    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is AngularComponentElement,
-        AngularComponentElement,
-        element);
-  }
-
-  void test_getElement_component_property_fromFieldAnnotation() {
-    resolveMainSource(
-        _createAngularSource(r'''
-@Component(publishAs: 'ctrl', selector: 'myComp',
-             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
-class MyComponent {
-  @NgOneWay('prop')
-  var field;
-}'''));
-    // prepare node
-    SimpleStringLiteral node =
-        _findMainNode("prop'", (n) => n is SimpleStringLiteral);
-    int offset = node.offset;
-    // prepare Element
-    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
-    expect(element, isNotNull);
-    // check AngularPropertyElement
-    AngularPropertyElement property = element as AngularPropertyElement;
-    expect(property.name, "prop");
-  }
-
-  void test_getElement_component_property_fromMap() {
-    resolveMainSource(
-        _createAngularSource(r'''
-@Component(publishAs: 'ctrl', selector: 'myComp',
-             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
-             map: const {
-               'prop' : '@field',
-             })
-class MyComponent {
-  var field;
-}'''));
-    // AngularPropertyElement
-    {
-      SimpleStringLiteral node =
-          _findMainNode("prop'", (n) => n is SimpleStringLiteral);
-      int offset = node.offset;
-      // prepare Element
-      Element element = AngularCompilationUnitBuilder.getElement(node, offset);
-      expect(element, isNotNull);
-      // check AngularPropertyElement
-      AngularPropertyElement property = element as AngularPropertyElement;
-      expect(property.name, "prop");
-    }
-    // FieldElement
-    {
-      SimpleStringLiteral node =
-          _findMainNode("@field'", (n) => n is SimpleStringLiteral);
-      int offset = node.offset;
-      // prepare Element
-      Element element = AngularCompilationUnitBuilder.getElement(node, offset);
-      expect(element, isNotNull);
-      // check FieldElement
-      FieldElement field = element as FieldElement;
-      expect(field.name, "field");
-    }
-  }
-
-  void test_getElement_component_selector() {
-    resolveMainSource(
-        _createAngularSource(r'''
-@Component(publishAs: 'ctrl', selector: 'myComp',
-             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
-class MyComponent {}'''));
-    SimpleStringLiteral node =
-        _findMainNode("myComp'", (n) => n is SimpleStringLiteral);
-    int offset = node.offset;
-    // find AngularSelectorElement
-    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is AngularSelectorElement,
-        AngularSelectorElement,
-        element);
-  }
-
-  void test_getElement_controller_name() {
-    resolveMainSource(
-        _createAngularSource(r'''
-@Controller(publishAs: 'ctrl', selector: '[myApp]')
-class MyController {
-}'''));
-    SimpleStringLiteral node =
-        _findMainNode("ctrl'", (n) => n is SimpleStringLiteral);
-    int offset = node.offset;
-    // find AngularControllerElement
-    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is AngularControllerElement,
-        AngularControllerElement,
-        element);
-  }
-
-  void test_getElement_directive_property() {
-    resolveMainSource(
-        _createAngularSource(r'''
-@Decorator(selector: '[my-dir]',
-             map: const {
-               'my-dir' : '=>field'
-             })
-class MyDirective {
-  set field(value) {}
-}'''));
-    // prepare node
-    SimpleStringLiteral node =
-        _findMainNode("my-dir'", (n) => n is SimpleStringLiteral);
-    int offset = node.offset;
-    // prepare Element
-    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
-    expect(element, isNotNull);
-    // check AngularPropertyElement
-    AngularPropertyElement property = element as AngularPropertyElement;
-    expect(property.name, "my-dir");
-  }
-
-  void test_getElement_directive_selector() {
-    resolveMainSource(
-        _createAngularSource(r'''
-@Decorator(selector: '[my-dir]')
-class MyDirective {}'''));
-    SimpleStringLiteral node =
-        _findMainNode("my-dir]'", (n) => n is SimpleStringLiteral);
-    int offset = node.offset;
-    // find AngularSelectorElement
-    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is AngularSelectorElement,
-        AngularSelectorElement,
-        element);
-  }
-
-  void test_getElement_filter_name() {
-    resolveMainSource(
-        _createAngularSource(r'''
-@Formatter(name: 'myFilter')
-class MyFilter {
-  call(p1, p2) {}
-}'''));
-    SimpleStringLiteral node =
-        _findMainNode("myFilter'", (n) => n is SimpleStringLiteral);
-    int offset = node.offset;
-    // find FilterElement
-    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is AngularFormatterElement,
-        AngularFormatterElement,
-        element);
-  }
-
-  void test_getElement_noClassDeclaration() {
-    resolveMainSource("var foo = 'bar';");
-    SimpleStringLiteral node =
-        _findMainNode("bar'", (n) => n is SimpleStringLiteral);
-    Element element = AngularCompilationUnitBuilder.getElement(node, 0);
-    expect(element, isNull);
-  }
-
-  void test_getElement_noClassElement() {
-    resolveMainSource(r'''
-class A {
-  const A(p);
-}
-
-@A('bar')
-class B {}''');
-    SimpleStringLiteral node =
-        _findMainNode("bar'", (n) => n is SimpleStringLiteral);
-    // reset B element
-    ClassDeclaration classDeclaration =
-        node.getAncestor((node) => node is ClassDeclaration);
-    classDeclaration.name.staticElement = null;
-    // class is not resolved - no element
-    Element element = AngularCompilationUnitBuilder.getElement(node, 0);
-    expect(element, isNull);
-  }
-
-  void test_getElement_noNode() {
-    Element element = AngularCompilationUnitBuilder.getElement(null, 0);
-    expect(element, isNull);
-  }
-
-  void test_getElement_notFound() {
-    resolveMainSource(r'''
-class MyComponent {
-  var str = 'some string';
-}''');
-    // prepare node
-    SimpleStringLiteral node =
-        _findMainNode("some string'", (n) => n is SimpleStringLiteral);
-    int offset = node.offset;
-    // no Element
-    Element element = AngularCompilationUnitBuilder.getElement(node, offset);
-    expect(element, isNull);
-  }
-
   void test_parseSelector_hasAttribute() {
     AngularSelectorElement selector =
         AngularCompilationUnitBuilder.parseSelector(42, "[name]");
     _assertHasAttributeSelector(selector, "name");
     expect(selector.nameOffset, 42 + 1);
   }
 
   void test_parseSelector_hasClass() {
     AngularSelectorElement selector =
         AngularCompilationUnitBuilder.parseSelector(42, ".my-class");
@@ skipping 26 matching lines @@
   void test_parseSelector_isTag_hasAttribute() {
     AngularSelectorElement selector =
         AngularCompilationUnitBuilder.parseSelector(42, "tag[attr]");
     EngineTestCase.assertInstanceOf(
         (obj) => obj is IsTagHasAttributeSelectorElementImpl,
         IsTagHasAttributeSelectorElementImpl,
         selector);
     expect(selector.name, "tag[attr]");
     expect(selector.nameOffset, -1);
     expect((selector as IsTagHasAttributeSelectorElementImpl).tagName, "tag");
-    expect((selector as IsTagHasAttributeSelectorElementImpl).attributeName, "attr");
+    expect(
+        (selector as IsTagHasAttributeSelectorElementImpl).attributeName,
+        "attr");
   }
 
   void test_parseSelector_unknown() {
     AngularSelectorElement selector =
         AngularCompilationUnitBuilder.parseSelector(0, "~unknown");
     expect(selector, isNull);
   }
 
   void test_view() {
     contextHelper.addSource("/wrong.html", "");
@@ skipping 13 matching lines @@
 }''');
     resolveMainSourceNoErrors(mainContent);
     // prepare AngularViewElement(s)
     List<AngularViewElement> views = mainUnitElement.angularViews;
     expect(views, hasLength(2));
     {
       AngularViewElement view = views[0];
       expect(view.templateUri, "my_templateA.html");
       expect(view.name, null);
       expect(view.nameOffset, -1);
-      expect(view.templateUriOffset, AngularTest.findOffset(mainContent, "my_templateA.html'"));
+      expect(
+          view.templateUriOffset,
+          AngularTest.findOffset(mainContent, "my_templateA.html'"));
     }
     {
       AngularViewElement view = views[1];
       expect(view.templateUri, "my_templateB.html");
       expect(view.name, null);
       expect(view.nameOffset, -1);
-      expect(view.templateUriOffset, AngularTest.findOffset(mainContent, "my_templateB.html'"));
+      expect(
+          view.templateUriOffset,
+          AngularTest.findOffset(mainContent, "my_templateB.html'"));
     }
   }
 
   void _assertProperty(AngularPropertyElement property, String expectedName,
       int expectedNameOffset, AngularPropertyKind expectedKind,
       String expectedFieldName, int expectedFieldOffset) {
     expect(property.name, expectedName);
     expect(property.nameOffset, expectedNameOffset);
     expect(property.propertyKind, same(expectedKind));
     expect(property.field.name, expectedFieldName);
@@ skipping 46 matching lines @@
     expect((selector as AngularTagSelectorElementImpl).name, name);
   }
 
   static String _createAngularSource(String code) {
     return "import 'angular.dart';\n" + code;
   }
 }
 
 
 class AngularHtmlUnitResolverTest extends AngularTest {
-  void test_NgComponent_resolveTemplateFile() {
+  void fail_analysisContext_changeDart_invalidateApplication() {
     addMainSource(r'''
+
 import 'angular.dart';
 
 @Component(
     templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
     publishAs: 'ctrl',
     selector: 'myComponent')
 class MyComponent {
-  String field;
 }''');
     contextHelper.addSource(
         "/entry-point.html",
         AngularTest.createHtmlWithAngular(''));
-    addIndexSource2(
-        "/my_template.html",
-        r'''
+    addIndexSource2("/my_template.html", r'''
 <div>
-  {{ctrl.field}}
+  {{ctrl.noMethod()}}
 </div>''');
     contextHelper.addSource("/my_styles.css", "");
     contextHelper.runTasks();
-    resolveIndex();
-    assertNoErrors();
-    assertResolvedIdentifier2("ctrl.", "MyComponent");
-    assertResolvedIdentifier2("field}}", "String");
-  }
-
-  void test_NgComponent_updateDartFile() {
-    Source componentSource = contextHelper.addSource(
-        "/my_component.dart",
-        r'''
-library my.component;
+    // there are some errors in my_template.html
+    {
+      List<AnalysisError> errors = context.getErrors(indexSource).errors;
+      expect(errors.length != 0, isTrue);
+    }
+    // change main.dart, there are no MyComponent anymore
+    context.setContents(mainSource, "");
+    // ...errors in my_template.html should be removed
+    {
+      List<AnalysisError> errors = context.getErrors(indexSource).errors;
+      expect(errors, isEmpty);
+      expect(errors.length == 0, isTrue);
+    }
+  }
+
+  void fail_ngRepeat_additionalVariables() {
+    addMyController();
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat='name in ctrl.names'>
+  {{$index}} {{$first}} {{$middle}} {{$last}} {{$even}} {{$odd}}
+</li>'''));
+    assertResolvedIdentifier2("\$index", "int");
+    assertResolvedIdentifier2("\$first", "bool");
+    assertResolvedIdentifier2("\$middle", "bool");
+    assertResolvedIdentifier2("\$last", "bool");
+    assertResolvedIdentifier2("\$even", "bool");
+    assertResolvedIdentifier2("\$odd", "bool");
+  }
+
+  void fail_ngRepeat_bad_expectedIdentifier() {
+    addMyController();
+    resolveIndex2(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat='name + 42 in ctrl.names'>
+</li>'''));
+    assertErrors(indexSource, [AngularCode.INVALID_REPEAT_ITEM_SYNTAX]);
+  }
+
+  void fail_ngRepeat_bad_expectedIn() {
+    addMyController();
+    resolveIndex2(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat='name : ctrl.names'>
+</li>'''));
+    assertErrors(indexSource, [AngularCode.INVALID_REPEAT_SYNTAX]);
+  }
+
+  void fail_ngRepeat_filters_filter_literal() {
+    addMyController();
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat='item in ctrl.items | filter:42:null'/>
+</li>'''));
+    // filter "filter" is resolved
+    Element filterElement = assertResolvedIdentifier("filter");
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is AngularFormatterElement,
+        AngularFormatterElement,
+        filterElement);
+  }
+
+  void fail_ngRepeat_filters_filter_propertyMap() {
+    addMyController();
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat='item in ctrl.items | filter:{name:null, done:false}'/>
+</li>'''));
+    assertResolvedIdentifier2("name:", "String");
+    assertResolvedIdentifier2("done:", "bool");
+  }
+
+  void fail_ngRepeat_filters_missingColon() {
+    addMyController();
+    resolveIndex2(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy:'' true"/>
+</li>'''));
+    assertErrors(indexSource, [AngularCode.MISSING_FORMATTER_COLON]);
+  }
+
+  void fail_ngRepeat_filters_noArgs() {
+    addMyController();
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy"/>
+</li>'''));
+    // filter "orderBy" is resolved
+    Element filterElement = assertResolvedIdentifier("orderBy");
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is AngularFormatterElement,
+        AngularFormatterElement,
+        filterElement);
+  }
+
+  void fail_ngRepeat_filters_orderBy_emptyString() {
+    addMyController();
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy:'':true"/>
+</li>'''));
+    // filter "orderBy" is resolved
+    Element filterElement = assertResolvedIdentifier("orderBy");
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is AngularFormatterElement,
+        AngularFormatterElement,
+        filterElement);
+  }
+
+  void fail_ngRepeat_filters_orderBy_propertyList() {
+    addMyController();
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy:['name', 'done']"/>
+</li>'''));
+    assertResolvedIdentifier2("name'", "String");
+    assertResolvedIdentifier2("done'", "bool");
+  }
+
+  void fail_ngRepeat_filters_orderBy_propertyName() {
+    addMyController();
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy:'name'"/>
+</li>'''));
+    assertResolvedIdentifier2("name'", "String");
+  }
+
+  void fail_ngRepeat_filters_orderBy_propertyName_minus() {
+    addMyController();
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy:'-name'"/>
+</li>'''));
+    assertResolvedIdentifier2("name'", "String");
+  }
+
+  void fail_ngRepeat_filters_orderBy_propertyName_plus() {
+    addMyController();
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy:'+name'"/>
+</li>'''));
+    assertResolvedIdentifier2("name'", "String");
+  }
+
+  void fail_ngRepeat_filters_orderBy_propertyName_untypedItems() {
+    addMyController();
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.untypedItems | orderBy:'name'"/>
+</li>'''));
+    assertResolvedIdentifier2("name'", "dynamic");
+  }
+
+  void fail_ngRepeat_filters_two() {
+    addMyController();
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy:'+' | orderBy:'-'"/>
+</li>'''));
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is AngularFormatterElement,
+        AngularFormatterElement,
+        assertResolvedIdentifier("orderBy:'+'"));
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is AngularFormatterElement,
+        AngularFormatterElement,
+        assertResolvedIdentifier("orderBy:'-'"));
+  }
+
+  void fail_ngRepeat_resolvedExpressions() {
+    addMyController();
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat='name in ctrl.names'>
+  {{name}}
+</li>'''));
+    assertResolvedIdentifier2("name in", "String");
+    assertResolvedIdentifier2("ctrl.", "MyController");
+    assertResolvedIdentifier2("names'", "List<String>");
+    assertResolvedIdentifier2("name}}", "String");
+  }
+
+  void fail_ngRepeat_trackBy() {
+    addMyController();
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat='name in ctrl.names track by name.length'/>
+</li>'''));
+    assertResolvedIdentifier2("length'", "int");
+  }
+
+  void test_analysisContext_changeEntryPoint_clearAngularErrors_inDart() {
+    addMainSource(r'''
+
 import 'angular.dart';
-@Component(selector: 'myComponent')
+
+@Component(
+    templateUrl: 'no-such-template.html', cssUrl: 'my_styles.css',
+    publishAs: 'ctrl',
+    selector: 'myComponent')
 class MyComponent {
 }''');
-    contextHelper.addSource(
-        "/my_module.dart",
-        r'''
-library my.module;
-import 'my_component.dart';''');
+    Source entrySource = contextHelper.addSource(
+        "/entry-point.html",
+        AngularTest.createHtmlWithAngular(''));
+    contextHelper.addSource("/my_styles.css", "");
+    contextHelper.runTasks();
+    // there are some errors in MyComponent
+    {
+      List<AnalysisError> errors = context.getErrors(mainSource).errors;
+      expect(errors.length != 0, isTrue);
+    }
+    // make entry-point.html non-Angular
+    context.setContents(entrySource, "<html/>");
+    // ...errors in MyComponent should be removed
+    {
+      List<AnalysisError> errors = context.getErrors(mainSource).errors;
+      expect(errors.length == 0, isTrue);
+    }
+  }
+
+  void test_analysisContext_changeEntryPoint_clearAngularErrors_inTemplate() {
     addMainSource(r'''
-library main;
-import 'my_module.dart';''');
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController("<myComponent/>"));
-    // "myComponent" tag was resolved
-    {
-      ht.XmlTagNode tagNode =
-          ht.HtmlUnitUtils.getTagNode(indexUnit, findOffset2("myComponent"));
-      AngularSelectorElement tagElement =
-          tagNode.element as AngularSelectorElement;
-      expect(tagElement, isNotNull);
-      expect(tagElement.name, "myComponent");
-    }
-    // replace "myComponent" with "myComponent2"
-    // in my_component.dart and index.html
-    {
-      context.setContents(
-          componentSource,
-          _getSourceContent(componentSource).replaceAll("myComponent", "myComponent2"));
-      indexContent =
-          _getSourceContent(indexSource).replaceAll("myComponent", "myComponent2");
-      context.setContents(indexSource, indexContent);
-    }
-    contextHelper.runTasks();
-    resolveIndex();
-    // "myComponent2" tag should be resolved
-    {
-      ht.XmlTagNode tagNode =
-          ht.HtmlUnitUtils.getTagNode(indexUnit, findOffset2("myComponent2"));
-      AngularSelectorElement tagElement =
-          tagNode.element as AngularSelectorElement;
-      expect(tagElement, isNotNull);
-      expect(tagElement.name, "myComponent2");
-    }
-  }
-
-  void test_NgComponent_use_resolveAttributes() {
-    contextHelper.addSource(
-        "/my_template.html",
-        r'''
-    <div>
-      {{ctrl.field}}
-    </div>''');
-    addMainSource(r'''
 
 import 'angular.dart';
-
-@Component(
-    templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
-    publishAs: 'ctrl',
-    selector: 'myComponent', // selector
-    map: const {'attrA' : '=>setA', 'attrB' : '@setB'})
-class MyComponent {
-  set setA(value) {}
-  set setB(value) {}
-}''');
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<input type='text' ng-model='someModel'/>
-<myComponent attrA='someModel' attrB='bbb'/>'''));
-    // "attrA" attribute expression was resolved
-    expect(findIdentifier("someModel"), isNotNull);
-    // "myComponent" tag was resolved
-    ht.XmlTagNode tagNode =
-        ht.HtmlUnitUtils.getTagNode(indexUnit, findOffset2("myComponent"));
-    AngularSelectorElement tagElement =
-        tagNode.element as AngularSelectorElement;
-    expect(tagElement, isNotNull);
-    expect(tagElement.name, "myComponent");
-    expect(tagElement.nameOffset, findMainOffset("myComponent', // selector"));
-    // "attrA" attribute was resolved
-    {
-      ht.XmlAttributeNode node =
-          ht.HtmlUnitUtils.getAttributeNode(indexUnit, findOffset2("attrA='"));
-      AngularPropertyElement element = node.element as AngularPropertyElement;
-      expect(element, isNotNull);
-      expect(element.name, "attrA");
-      expect(element.field.name, "setA");
-    }
-    // "attrB" attribute was resolved, even if it @binding
-    {
-      ht.XmlAttributeNode node =
-          ht.HtmlUnitUtils.getAttributeNode(indexUnit, findOffset2("attrB='"));
-      AngularPropertyElement element = node.element as AngularPropertyElement;
-      expect(element, isNotNull);
-      expect(element.name, "attrB");
-      expect(element.field.name, "setB");
-    }
-  }
-
-  void test_NgDirective_noAttribute() {
-    addMainSource(r'''
-
-import 'angular.dart';
-
-@NgDirective(selector: '[my-directive]', map: const {'foo': '=>input'})
-class MyDirective {
-  set input(value) {}
-}''');
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<div my-directive>
-</div>'''));
-  }
-
-  void test_NgDirective_noExpression() {
-    addMainSource(r'''
-
-import 'angular.dart';
-
-@NgDirective(selector: '[my-directive]', map: const {'.': '=>input'})
-class MyDirective {
-  set input(value) {}
-}''');
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<div my-directive>
-</div>'''));
-  }
-
-  void test_NgDirective_resolvedExpression() {
-    addMainSource(r'''
-
-import 'angular.dart';
-
-@Decorator(selector: '[my-directive]')
-class MyDirective {
-  @NgOneWay('my-property')
-  String condition;
-}''');
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<input type='text' ng-model='name'>
-<div my-directive my-property='name != null'>
-</div>'''));
-    resolveMainNoErrors();
-    // "my-directive" attribute was resolved
-    {
-      AngularSelectorElement selector =
-          findMainElement(ElementKind.ANGULAR_SELECTOR, "my-directive");
-      ht.XmlAttributeNode attrNodeSelector =
-          ht.HtmlUnitUtils.getAttributeNode(indexUnit, findOffset2("my-directive"));
-      expect(attrNodeSelector, isNotNull);
-      expect(attrNodeSelector.element, same(selector));
-    }
-    // "my-property" attribute was resolved
-    {
-      ht.XmlAttributeNode attrNodeProperty =
-          ht.HtmlUnitUtils.getAttributeNode(indexUnit, findOffset2("my-property='"));
-      AngularPropertyElement propertyElement =
-          attrNodeProperty.element as AngularPropertyElement;
-      expect(propertyElement, isNotNull);
-      expect(propertyElement.propertyKind, same(AngularPropertyKind.ONE_WAY));
-      expect(propertyElement.field.name, "condition");
-    }
-    // "name" expression was resolved
-    expect(findIdentifier("name != null"), isNotNull);
-  }
-
-  void test_NgDirective_resolvedExpression_attrString() {
-    addMainSource(r'''
-
-import 'angular.dart';
-
-@NgDirective(selector: '[my-directive])
-class MyDirective {
-  @NgAttr('my-property')
-  String property;
-}''');
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<input type='text' ng-model='name'>
-<div my-directive my-property='name != null'>
-</div>'''));
-    resolveMain();
-    // @NgAttr means "string attribute", which we don't parse
-    expect(findIdentifierMaybe("name != null"), isNull);
-  }
-
-  void test_NgDirective_resolvedExpression_dotAsName() {
-    addMainSource(r'''
-
-import 'angular.dart';
-
-@Decorator(
-    selector: '[my-directive]',
-    map: const {'.' : '=>condition'})
-class MyDirective {
-  set condition(value) {}
-}''');
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<input type='text' ng-model='name'>
-<div my-directive='name != null'>
-</div>'''));
-    // "name" attribute was resolved
-    expect(findIdentifier("name != null"), isNotNull);
-  }
-
-  void fail_analysisContext_changeDart_invalidateApplication() {
-    addMainSource(r'''
-
-import 'angular.dart';
 
 @Component(
     templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
     publishAs: 'ctrl',
     selector: 'myComponent')
 class MyComponent {
 }''');
-    contextHelper.addSource(
+    Source entrySource = contextHelper.addSource(
         "/entry-point.html",
         AngularTest.createHtmlWithAngular(''));
-    addIndexSource2(
-        "/my_template.html",
-        r'''
+    addIndexSource2("/my_template.html", r'''
 <div>
   {{ctrl.noMethod()}}
 </div>''');
     contextHelper.addSource("/my_styles.css", "");
     contextHelper.runTasks();
     // there are some errors in my_template.html
     {
       List<AnalysisError> errors = context.getErrors(indexSource).errors;
       expect(errors.length != 0, isTrue);
     }
-    // change main.dart, there are no MyComponent anymore
-    context.setContents(mainSource, "");
+    // make entry-point.html non-Angular
+    context.setContents(entrySource, "<html/>");
     // ...errors in my_template.html should be removed
     {
       List<AnalysisError> errors = context.getErrors(indexSource).errors;
-      expect(errors, isEmpty);
       expect(errors.length == 0, isTrue);
     }
   }
 
-  void test_analysisContext_changeEntryPoint_clearAngularErrors_inDart() {
+  void test_analysisContext_removeEntryPoint_clearAngularErrors_inDart() {
     addMainSource(r'''
 
 import 'angular.dart';
 
 @Component(
     templateUrl: 'no-such-template.html', cssUrl: 'my_styles.css',
     publishAs: 'ctrl',
     selector: 'myComponent')
 class MyComponent {
 }''');
     Source entrySource = contextHelper.addSource(
         "/entry-point.html",
         AngularTest.createHtmlWithAngular(''));
     contextHelper.addSource("/my_styles.css", "");
     contextHelper.runTasks();
     // there are some errors in MyComponent
     {
       List<AnalysisError> errors = context.getErrors(mainSource).errors;
       expect(errors.length != 0, isTrue);
     }
-    // make entry-point.html non-Angular
-    context.setContents(entrySource, "<html/>");
+    // remove entry-point.html
+    {
+      ChangeSet changeSet = new ChangeSet();
+      changeSet.removedSource(entrySource);
+      context.applyChanges(changeSet);
+    }
     // ...errors in MyComponent should be removed
     {
       List<AnalysisError> errors = context.getErrors(mainSource).errors;
       expect(errors.length == 0, isTrue);
     }
   }
 
-  void test_analysisContext_changeEntryPoint_clearAngularErrors_inTemplate() {
+  void test_contextProperties() {
+    addMyController();
+    _resolveIndexNoErrors(AngularTest.createHtmlWithAngular(r'''
+<div>
+  {{$id}}
+  {{$parent}}
+  {{$root}}
+</div>'''));
+    assertResolvedIdentifier("\$id");
+    assertResolvedIdentifier("\$parent");
+    assertResolvedIdentifier("\$root");
+  }
+
+  void test_getAngularElement_isAngular() {
+    // prepare local variable "name" in compilation unit
+    CompilationUnitElementImpl unit =
+        ElementFactory.compilationUnit("test.dart");
+    FunctionElementImpl function = ElementFactory.functionElement("main");
+    unit.functions = <FunctionElement>[function];
+    LocalVariableElementImpl local =
+        ElementFactory.localVariableElement2("name");
+    function.localVariables = <LocalVariableElement>[local];
+    // set AngularElement
+    AngularElement angularElement = new AngularControllerElementImpl("ctrl", 0);
+    local.toolkitObjects = <AngularElement>[angularElement];
+    expect(
+        AngularHtmlUnitResolver.getAngularElement(local),
+        same(angularElement));
+  }
+
+  void test_getAngularElement_notAngular() {
+    Element element = ElementFactory.localVariableElement2("name");
+    expect(AngularHtmlUnitResolver.getAngularElement(element), isNull);
+  }
+
+  void test_getAngularElement_notLocal() {
+    Element element = ElementFactory.classElement2("Test");
+    expect(AngularHtmlUnitResolver.getAngularElement(element), isNull);
+  }
+
+  /**
+   * Test that we resolve "ng-click" expression.
+   */
+  void test_ngClick() {
+    addMyController();
+    _resolveIndexNoErrors(
+        AngularTest.createHtmlWithMyController(
+            r"<button ng-click='ctrl.doSomething($event)'/>"));
+    assertResolvedIdentifier("doSomething");
+  }
+
+  void test_NgComponent_resolveTemplateFile() {
     addMainSource(r'''
-
 import 'angular.dart';
 
 @Component(
     templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
     publishAs: 'ctrl',
     selector: 'myComponent')
 class MyComponent {
-}''');
-    Source entrySource = contextHelper.addSource(
+  String field;
+}''');
+    contextHelper.addSource(
         "/entry-point.html",
         AngularTest.createHtmlWithAngular(''));
-    addIndexSource2(
-        "/my_template.html",
-        r'''
+    addIndexSource2("/my_template.html", r'''
 <div>
-  {{ctrl.noMethod()}}
+  {{ctrl.field}}
 </div>''');
     contextHelper.addSource("/my_styles.css", "");
     contextHelper.runTasks();
-    // there are some errors in my_template.html
-    {
-      List<AnalysisError> errors = context.getErrors(indexSource).errors;
-      expect(errors.length != 0, isTrue);
-    }
-    // make entry-point.html non-Angular
-    context.setContents(entrySource, "<html/>");
-    // ...errors in my_template.html should be removed
-    {
-      List<AnalysisError> errors = context.getErrors(indexSource).errors;
-      expect(errors.length == 0, isTrue);
-    }
-  }
-
-  void test_analysisContext_removeEntryPoint_clearAngularErrors_inDart() {
+    resolveIndex();
+    assertNoErrors();
+    assertResolvedIdentifier2("ctrl.", "MyComponent");
+    assertResolvedIdentifier2("field}}", "String");
+  }
+
+  void test_NgComponent_updateDartFile() {
+    Source componentSource = contextHelper.addSource("/my_component.dart", r'''
+library my.component;
+import 'angular.dart';
+@Component(selector: 'myComponent')
+class MyComponent {
+}''');
+    contextHelper.addSource("/my_module.dart", r'''
+library my.module;
+import 'my_component.dart';''');
+    addMainSource(r'''
+library main;
+import 'my_module.dart';''');
+    _resolveIndexNoErrors(
+        AngularTest.createHtmlWithMyController("<myComponent/>"));
+    // "myComponent" tag was resolved
+    {
+      ht.XmlTagNode tagNode =
+          ht.HtmlUnitUtils.getTagNode(indexUnit, findOffset2("myComponent"));
+      AngularSelectorElement tagElement =
+          tagNode.element as AngularSelectorElement;
+      expect(tagElement, isNotNull);
+      expect(tagElement.name, "myComponent");
+    }
+    // replace "myComponent" with "myComponent2"
+    // in my_component.dart and index.html
+    {
+      context.setContents(
+          componentSource,
+          _getSourceContent(componentSource).replaceAll("myComponent", "myComponent2"));
+      indexContent =
+          _getSourceContent(indexSource).replaceAll("myComponent", "myComponent2");
+      context.setContents(indexSource, indexContent);
+    }
+    contextHelper.runTasks();
+    resolveIndex();
+    // "myComponent2" tag should be resolved
+    {
+      ht.XmlTagNode tagNode =
+          ht.HtmlUnitUtils.getTagNode(indexUnit, findOffset2("myComponent2"));
+      AngularSelectorElement tagElement =
+          tagNode.element as AngularSelectorElement;
+      expect(tagElement, isNotNull);
+      expect(tagElement.name, "myComponent2");
+    }
+  }
+
+  void test_NgComponent_use_resolveAttributes() {
+    contextHelper.addSource("/my_template.html", r'''
+    <div>
+      {{ctrl.field}}
+    </div>''');
     addMainSource(r'''
 
 import 'angular.dart';
 
 @Component(
-    templateUrl: 'no-such-template.html', cssUrl: 'my_styles.css',
+    templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
     publishAs: 'ctrl',
-    selector: 'myComponent')
+    selector: 'myComponent', // selector
+    map: const {'attrA' : '=>setA', 'attrB' : '@setB'})
 class MyComponent {
-}''');
-    Source entrySource = contextHelper.addSource(
-        "/entry-point.html",
-        AngularTest.createHtmlWithAngular(''));
-    contextHelper.addSource("/my_styles.css", "");
-    contextHelper.runTasks();
-    // there are some errors in MyComponent
-    {
-      List<AnalysisError> errors = context.getErrors(mainSource).errors;
-      expect(errors.length != 0, isTrue);
-    }
-    // remove entry-point.html
-    {
-      ChangeSet changeSet = new ChangeSet();
-      changeSet.removedSource(entrySource);
-      context.applyChanges(changeSet);
-    }
-    // ...errors in MyComponent should be removed
-    {
-      List<AnalysisError> errors = context.getErrors(mainSource).errors;
-      expect(errors.length == 0, isTrue);
-    }
-  }
-
-  void test_contextProperties() {
-    addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithAngular(r'''
-<div>
-  {{$id}}
-  {{$parent}}
-  {{$root}}
-</div>'''));
-    assertResolvedIdentifier("\$id");
-    assertResolvedIdentifier("\$parent");
-    assertResolvedIdentifier("\$root");
-  }
-
-  void test_getAngularElement_isAngular() {
-    // prepare local variable "name" in compilation unit
-    CompilationUnitElementImpl unit =
-        ElementFactory.compilationUnit("test.dart");
-    FunctionElementImpl function = ElementFactory.functionElement("main");
-    unit.functions = <FunctionElement>[function];
-    LocalVariableElementImpl local =
-        ElementFactory.localVariableElement2("name");
-    function.localVariables = <LocalVariableElement>[local];
-    // set AngularElement
-    AngularElement angularElement = new AngularControllerElementImpl("ctrl", 0);
-    local.toolkitObjects = <AngularElement>[angularElement];
-    expect(AngularHtmlUnitResolver.getAngularElement(local), same(angularElement));
-  }
-
-  void test_getAngularElement_notAngular() {
-    Element element = ElementFactory.localVariableElement2("name");
-    expect(AngularHtmlUnitResolver.getAngularElement(element), isNull);
-  }
-
-  void test_getAngularElement_notLocal() {
-    Element element = ElementFactory.classElement2("Test");
-    expect(AngularHtmlUnitResolver.getAngularElement(element), isNull);
+  set setA(value) {}
+  set setB(value) {}
+}''');
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<input type='text' ng-model='someModel'/>
+<myComponent attrA='someModel' attrB='bbb'/>'''));
+    // "attrA" attribute expression was resolved
+    expect(findIdentifier("someModel"), isNotNull);
+    // "myComponent" tag was resolved
+    ht.XmlTagNode tagNode =
+        ht.HtmlUnitUtils.getTagNode(indexUnit, findOffset2("myComponent"));
+    AngularSelectorElement tagElement =
+        tagNode.element as AngularSelectorElement;
+    expect(tagElement, isNotNull);
+    expect(tagElement.name, "myComponent");
+    expect(tagElement.nameOffset, findMainOffset("myComponent', // selector"));
+    // "attrA" attribute was resolved
+    {
+      ht.XmlAttributeNode node =
+          ht.HtmlUnitUtils.getAttributeNode(indexUnit, findOffset2("attrA='"));
+      AngularPropertyElement element = node.element as AngularPropertyElement;
+      expect(element, isNotNull);
+      expect(element.name, "attrA");
+      expect(element.field.name, "setA");
+    }
+    // "attrB" attribute was resolved, even if it @binding
+    {
+      ht.XmlAttributeNode node =
+          ht.HtmlUnitUtils.getAttributeNode(indexUnit, findOffset2("attrB='"));
+      AngularPropertyElement element = node.element as AngularPropertyElement;
+      expect(element, isNotNull);
+      expect(element.name, "attrB");
+      expect(element.field.name, "setB");
+    }
+  }
+
+  void test_NgDirective_noAttribute() {
+    addMainSource(r'''
+
+import 'angular.dart';
+
+@NgDirective(selector: '[my-directive]', map: const {'foo': '=>input'})
+class MyDirective {
+  set input(value) {}
+}''');
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<div my-directive>
+</div>'''));
+  }
+
+  void test_NgDirective_noExpression() {
+    addMainSource(r'''
+
+import 'angular.dart';
+
+@NgDirective(selector: '[my-directive]', map: const {'.': '=>input'})
+class MyDirective {
+  set input(value) {}
+}''');
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<div my-directive>
+</div>'''));
+  }
+
+  void test_NgDirective_resolvedExpression() {
+    addMainSource(r'''
+
+import 'angular.dart';
+
+@Decorator(selector: '[my-directive]')
+class MyDirective {
+  @NgOneWay('my-property')
+  String condition;
+}''');
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<input type='text' ng-model='name'>
+<div my-directive my-property='name != null'>
+</div>'''));
+    resolveMainNoErrors();
+    // "my-directive" attribute was resolved
+    {
+      AngularSelectorElement selector =
+          findMainElement(ElementKind.ANGULAR_SELECTOR, "my-directive");
+      ht.XmlAttributeNode attrNodeSelector =
+          ht.HtmlUnitUtils.getAttributeNode(indexUnit, findOffset2("my-directive"));
+      expect(attrNodeSelector, isNotNull);
+      expect(attrNodeSelector.element, same(selector));
+    }
+    // "my-property" attribute was resolved
+    {
+      ht.XmlAttributeNode attrNodeProperty =
+          ht.HtmlUnitUtils.getAttributeNode(indexUnit, findOffset2("my-property='"));
+      AngularPropertyElement propertyElement =
+          attrNodeProperty.element as AngularPropertyElement;
+      expect(propertyElement, isNotNull);
+      expect(propertyElement.propertyKind, same(AngularPropertyKind.ONE_WAY));
+      expect(propertyElement.field.name, "condition");
+    }
+    // "name" expression was resolved
+    expect(findIdentifier("name != null"), isNotNull);
+  }
+
+  void test_NgDirective_resolvedExpression_attrString() {
+    addMainSource(r'''
+
+import 'angular.dart';
+
+@NgDirective(selector: '[my-directive])
+class MyDirective {
+  @NgAttr('my-property')
+  String property;
+}''');
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<input type='text' ng-model='name'>
+<div my-directive my-property='name != null'>
+</div>'''));
+    resolveMain();
+    // @NgAttr means "string attribute", which we don't parse
+    expect(findIdentifierMaybe("name != null"), isNull);
+  }
+
+  void test_NgDirective_resolvedExpression_dotAsName() {
+    addMainSource(r'''
+
+import 'angular.dart';
+
+@Decorator(
+    selector: '[my-directive]',
+    map: const {'.' : '=>condition'})
+class MyDirective {
+  set condition(value) {}
+}''');
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
+<input type='text' ng-model='name'>
+<div my-directive='name != null'>
+</div>'''));
+    // "name" attribute was resolved
+    expect(findIdentifier("name != null"), isNotNull);
   }
 
   /**
-   * Test that we resolve "ng-click" expression.
-   */
-  void test_ngClick() {
-    addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r"<button ng-click='ctrl.doSomething($event)'/>"));
-    assertResolvedIdentifier("doSomething");
-  }
-
-  /**
    * Test that we resolve "ng-if" expression.
    */
   void test_ngIf() {
     addMyController();
     _resolveIndexNoErrors(
         AngularTest.createHtmlWithMyController("<div ng-if='ctrl.field != null'/>"));
     assertResolvedIdentifier("field");
   }
 
   void test_ngModel_modelAfterUsage() {
     addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
 <h3>Hello {{name}}!</h3>
 <input type='text' ng-model='name'>'''));
     assertResolvedIdentifier2("name}}!", "String");
     assertResolvedIdentifier2("name'>", "String");
   }
 
   void test_ngModel_modelBeforeUsage() {
     addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
+    _resolveIndexNoErrors(AngularTest.createHtmlWithMyController(r'''
 <input type='text' ng-model='name'>
 <h3>Hello {{name}}!</h3>'''));
     assertResolvedIdentifier2("name}}!", "String");
     Element element = assertResolvedIdentifier2("name'>", "String");
     expect(element.name, "name");
     expect(element.nameOffset, findOffset2("name'>"));
   }
 
   void test_ngModel_notIdentifier() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController("<input type='text' ng-model='ctrl.field'>"));
+        AngularTest.createHtmlWithMyController(
+            "<input type='text' ng-model='ctrl.field'>"));
     assertResolvedIdentifier2("field'>", "String");
   }
 
   /**
    * Test that we resolve "ng-mouseout" expression.
    */
   void test_ngMouseOut() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r"<button ng-mouseout='ctrl.doSomething($event)'/>"));
+        AngularTest.createHtmlWithMyController(
+            r"<button ng-mouseout='ctrl.doSomething($event)'/>"));
     assertResolvedIdentifier("doSomething");
   }
 
-  void fail_ngRepeat_additionalVariables() {
-    addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat='name in ctrl.names'>
-  {{$index}} {{$first}} {{$middle}} {{$last}} {{$even}} {{$odd}}
-</li>'''));
-    assertResolvedIdentifier2("\$index", "int");
-    assertResolvedIdentifier2("\$first", "bool");
-    assertResolvedIdentifier2("\$middle", "bool");
-    assertResolvedIdentifier2("\$last", "bool");
-    assertResolvedIdentifier2("\$even", "bool");
-    assertResolvedIdentifier2("\$odd", "bool");
-  }
-
-  void fail_ngRepeat_bad_expectedIdentifier() {
-    addMyController();
-    resolveIndex2(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat='name + 42 in ctrl.names'>
-</li>'''));
-    assertErrors(indexSource, [AngularCode.INVALID_REPEAT_ITEM_SYNTAX]);
-  }
-
-  void fail_ngRepeat_bad_expectedIn() {
-    addMyController();
-    resolveIndex2(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat='name : ctrl.names'>
-</li>'''));
-    assertErrors(indexSource, [AngularCode.INVALID_REPEAT_SYNTAX]);
-  }
-
-  void fail_ngRepeat_filters_filter_literal() {
-    addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat='item in ctrl.items | filter:42:null'/>
-</li>'''));
-    // filter "filter" is resolved
-    Element filterElement = assertResolvedIdentifier("filter");
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is AngularFormatterElement,
-        AngularFormatterElement,
-        filterElement);
-  }
-
-  void fail_ngRepeat_filters_filter_propertyMap() {
-    addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat='item in ctrl.items | filter:{name:null, done:false}'/>
-</li>'''));
-    assertResolvedIdentifier2("name:", "String");
-    assertResolvedIdentifier2("done:", "bool");
-  }
-
-  void fail_ngRepeat_filters_missingColon() {
-    addMyController();
-    resolveIndex2(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat="item in ctrl.items | orderBy:'' true"/>
-</li>'''));
-    assertErrors(indexSource, [AngularCode.MISSING_FORMATTER_COLON]);
-  }
-
-  void fail_ngRepeat_filters_noArgs() {
-    addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat="item in ctrl.items | orderBy"/>
-</li>'''));
-    // filter "orderBy" is resolved
-    Element filterElement = assertResolvedIdentifier("orderBy");
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is AngularFormatterElement,
-        AngularFormatterElement,
-        filterElement);
-  }
-
-  void fail_ngRepeat_filters_orderBy_emptyString() {
-    addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat="item in ctrl.items | orderBy:'':true"/>
-</li>'''));
-    // filter "orderBy" is resolved
-    Element filterElement = assertResolvedIdentifier("orderBy");
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is AngularFormatterElement,
-        AngularFormatterElement,
-        filterElement);
-  }
-
-  void fail_ngRepeat_filters_orderBy_propertyList() {
-    addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat="item in ctrl.items | orderBy:['name', 'done']"/>
-</li>'''));
-    assertResolvedIdentifier2("name'", "String");
-    assertResolvedIdentifier2("done'", "bool");
-  }
-
-  void fail_ngRepeat_filters_orderBy_propertyName() {
-    addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat="item in ctrl.items | orderBy:'name'"/>
-</li>'''));
-    assertResolvedIdentifier2("name'", "String");
-  }
-
-  void fail_ngRepeat_filters_orderBy_propertyName_minus() {
-    addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat="item in ctrl.items | orderBy:'-name'"/>
-</li>'''));
-    assertResolvedIdentifier2("name'", "String");
-  }
-
-  void fail_ngRepeat_filters_orderBy_propertyName_plus() {
-    addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat="item in ctrl.items | orderBy:'+name'"/>
-</li>'''));
-    assertResolvedIdentifier2("name'", "String");
-  }
-
-  void fail_ngRepeat_filters_orderBy_propertyName_untypedItems() {
-    addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat="item in ctrl.untypedItems | orderBy:'name'"/>
-</li>'''));
-    assertResolvedIdentifier2("name'", "dynamic");
-  }
-
-  void fail_ngRepeat_filters_two() {
-    addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat="item in ctrl.items | orderBy:'+' | orderBy:'-'"/>
-</li>'''));
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is AngularFormatterElement,
-        AngularFormatterElement,
-        assertResolvedIdentifier("orderBy:'+'"));
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is AngularFormatterElement,
-        AngularFormatterElement,
-        assertResolvedIdentifier("orderBy:'-'"));
-  }
-
-  void fail_ngRepeat_resolvedExpressions() {
-    addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat='name in ctrl.names'>
-  {{name}}
-</li>'''));
-    assertResolvedIdentifier2("name in", "String");
-    assertResolvedIdentifier2("ctrl.", "MyController");
-    assertResolvedIdentifier2("names'", "List<String>");
-    assertResolvedIdentifier2("name}}", "String");
-  }
-
-  void fail_ngRepeat_trackBy() {
-    addMyController();
-    _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(r'''
-<li ng-repeat='name in ctrl.names track by name.length'/>
-</li>'''));
-    assertResolvedIdentifier2("length'", "int");
-  }
-
   /**
    * Test that we resolve "ng-show" expression.
    */
   void test_ngShow() {
     addMyController();
     _resolveIndexNoErrors(
         AngularTest.createHtmlWithMyController("<div ng-show='ctrl.field != null'/>"));
     assertResolvedIdentifier("field");
   }
 
@@ skipping 102 matching lines @@
     // ...but not "invisibleScopeProperty"
     {
       SimpleIdentifier identifier = findIdentifier("invisibleScopeProperty");
       expect(identifier.bestElement, isNull);
     }
   }
 
   void test_resolveExpression_inAttribute() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController("<button title='{{ctrl.field}}'></button>"));
+        AngularTest.createHtmlWithMyController(
+            "<button title='{{ctrl.field}}'></button>"));
     assertResolvedIdentifier2("ctrl", "MyController");
   }
 
   void test_resolveExpression_ngApp_onBody() {
     addMyController();
     _resolveIndexNoErrors(r'''
 <html>
   <body ng-app>
     <div my-controller>
       {{ctrl.field}}
     </div>
     <script type='application/dart' src='main.dart'></script>
   </body>
 </html>''');
     assertResolvedIdentifier2("ctrl", "MyController");
   }
 
   void test_resolveExpression_withFormatter() {
     addMyController();
     _resolveIndexNoErrors(
         AngularTest.createHtmlWithMyController("{{ctrl.field | uppercase}}"));
     assertResolvedIdentifier2("ctrl", "MyController");
     assertResolvedIdentifier("uppercase");
   }
 
   void test_resolveExpression_withFormatter_missingColon() {
     addMyController();
     resolveIndex2(
-        AngularTest.createHtmlWithMyController("{{ctrl.field | uppercase, lowercase}}"));
+        AngularTest.createHtmlWithMyController(
+            "{{ctrl.field | uppercase, lowercase}}"));
     assertErrors(indexSource, [AngularCode.MISSING_FORMATTER_COLON]);
   }
 
   void test_resolveExpression_withFormatter_notSimpleIdentifier() {
     addMyController();
     resolveIndex2(
         AngularTest.createHtmlWithMyController("{{ctrl.field | not.supported}}"));
     assertErrors(indexSource, [AngularCode.INVALID_FORMATTER_NAME]);
   }
 
   void test_scopeProperties() {
     addMainSource(r'''
 
 import 'angular.dart';
 
 @Component(
     templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
     publishAs: 'ctrl',
     selector: 'myComponent')
 class MyComponent {
   String field;
   MyComponent(Scope scope) {
     scope.context['scopeProperty'] = 'abc';
   }
 }
 ''');
     contextHelper.addSource(
         "/entry-point.html",
         AngularTest.createHtmlWithAngular(''));
-    addIndexSource2(
-        "/my_template.html",
-        r'''
+    addIndexSource2("/my_template.html", r'''
 <div>
   {{scopeProperty}}
 </div>''');
     contextHelper.addSource("/my_styles.css", "");
     contextHelper.runTasks();
     resolveIndex();
     assertNoErrors();
     // "scopeProperty" is resolved
     Element element = assertResolvedIdentifier2("scopeProperty}}", "String");
     EngineTestCase.assertInstanceOf(
@@ skipping 14 matching lines @@
 class MyComponent {
 }
 
 void setScopeProperties(Scope scope) {
   scope.context['ctrl'] = 1;
 }
 ''');
     contextHelper.addSource(
         "/entry-point.html",
         AngularTest.createHtmlWithAngular(''));
-    addIndexSource2(
-        "/my_template.html",
-        r'''
+    addIndexSource2("/my_template.html", r'''
 <div>
   {{ctrl}}
 </div>''');
     contextHelper.addSource("/my_styles.css", "");
     contextHelper.runTasks();
     resolveIndex();
     assertNoErrors();
     // "ctrl" is resolved
     LocalVariableElement element =
         assertResolvedIdentifier("ctrl}}") as LocalVariableElement;
@@ skipping 17 matching lines @@
 }
 
 class MyRouteInitializer {
   init(ViewFactory view) {
     view('my_template.html');
   }
 }''');
     contextHelper.addSource(
         "/entry-point.html",
         AngularTest.createHtmlWithAngular(''));
-    addIndexSource2(
-        "/my_template.html",
-        r'''
+    addIndexSource2("/my_template.html", r'''
 <div my-controller>
   {{ctrl.field}}
 </div>''');
     contextHelper.addSource("/my_styles.css", "");
     contextHelper.runTasks();
     resolveIndex();
     assertNoErrors();
     assertResolvedIdentifier2("ctrl.", "MyController");
     assertResolvedIdentifier2("field}}", "String");
   }
 
   String _getSourceContent(Source source) {
     return context.getContents(source).data.toString();
   }
 
   void _resolveIndexNoErrors(String content) {
     resolveIndex2(content);
     assertNoErrors();
     verify([indexSource]);
   }
 }
 
 
 /**
  * Tests for [HtmlUnitUtils] for Angular HTMLs.
  */
 class AngularHtmlUnitUtilsTest extends AngularTest {
-  void test_getElementToOpen_controller() {
-    addMyController();
-    _resolveSimpleCtrlFieldHtml();
-    // prepare expression
-    int offset = indexContent.indexOf("ctrl");
-    Expression expression = ht.HtmlUnitUtils.getExpression(indexUnit, offset);
-    // get element
-    Element element = ht.HtmlUnitUtils.getElementToOpen(indexUnit, expression);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is AngularControllerElement,
-        AngularControllerElement,
-        element);
-    expect(element.name, "ctrl");
-  }
-
-  void test_getElementToOpen_field() {
-    addMyController();
-    _resolveSimpleCtrlFieldHtml();
-    // prepare expression
-    int offset = indexContent.indexOf("field");
-    Expression expression = ht.HtmlUnitUtils.getExpression(indexUnit, offset);
-    // get element
-    Element element = ht.HtmlUnitUtils.getElementToOpen(indexUnit, expression);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is PropertyAccessorElement,
-        PropertyAccessorElement,
-        element);
-    expect(element.name, "field");
-  }
-
   void test_getElement_forExpression() {
     addMyController();
     _resolveSimpleCtrlFieldHtml();
     // prepare expression
     int offset = indexContent.indexOf("ctrl");
     Expression expression = ht.HtmlUnitUtils.getExpression(indexUnit, offset);
     // get element
     Element element = ht.HtmlUnitUtils.getElement(expression);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is VariableElement,
@@ skipping 20 matching lines @@
       int offset = indexContent.indexOf("field");
       Element element = ht.HtmlUnitUtils.getElementAtOffset(indexUnit, offset);
       EngineTestCase.assertInstanceOf(
           (obj) => obj is PropertyAccessorElement,
           PropertyAccessorElement,
           element);
       expect(element.name, "field");
     }
   }
 
+  void test_getElementToOpen_controller() {
+    addMyController();
+    _resolveSimpleCtrlFieldHtml();
+    // prepare expression
+    int offset = indexContent.indexOf("ctrl");
+    Expression expression = ht.HtmlUnitUtils.getExpression(indexUnit, offset);
+    // get element
+    Element element = ht.HtmlUnitUtils.getElementToOpen(indexUnit, expression);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is AngularControllerElement,
+        AngularControllerElement,
+        element);
+    expect(element.name, "ctrl");
+  }
+
+  void test_getElementToOpen_field() {
+    addMyController();
+    _resolveSimpleCtrlFieldHtml();
+    // prepare expression
+    int offset = indexContent.indexOf("field");
+    Expression expression = ht.HtmlUnitUtils.getExpression(indexUnit, offset);
+    // get element
+    Element element = ht.HtmlUnitUtils.getElementToOpen(indexUnit, expression);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is PropertyAccessorElement,
+        PropertyAccessorElement,
+        element);
+    expect(element.name, "field");
+  }
+
   void test_getEnclosingTagNode() {
     resolveIndex2(r'''
 <html>
   <body ng-app>
     <badge name='abc'> 123 </badge>
   </body>
 </html>''');
     // no unit
     expect(ht.HtmlUnitUtils.getEnclosingTagNode(null, 0), isNull);
     // wrong offset
@@ skipping 11 matching lines @@
   void test_getExpression() {
     addMyController();
     _resolveSimpleCtrlFieldHtml();
     // try offset without expression
     expect(ht.HtmlUnitUtils.getExpression(indexUnit, 0), isNull);
     // try offset with expression
     int offset = indexContent.indexOf("ctrl");
     expect(ht.HtmlUnitUtils.getExpression(indexUnit, offset), isNotNull);
     expect(ht.HtmlUnitUtils.getExpression(indexUnit, offset + 1), isNotNull);
     expect(ht.HtmlUnitUtils.getExpression(indexUnit, offset + 2), isNotNull);
-    expect(ht.HtmlUnitUtils.getExpression(indexUnit, offset + "ctrl.field".length), isNotNull);
+    expect(
+        ht.HtmlUnitUtils.getExpression(indexUnit, offset + "ctrl.field".length),
+        isNotNull);
     // try without unit
     expect(ht.HtmlUnitUtils.getExpression(null, offset), isNull);
   }
 
   void test_getTagNode() {
     resolveIndex2(r'''
 <html>
   <body ng-app>
     <badge name='abc'> 123 </badge> done
   </body>
@@ skipping 103 matching lines @@
    * Assert that the number of errors reported against the given source matches the number of errors
    * that are given and that they have the expected error codes. The order in which the errors were
    * gathered is ignored.
    *
    * @param source the source against which the errors should have been reported
    * @param expectedErrorCodes the error codes of the errors that should have been reported
    * @throws AnalysisException if the reported errors could not be computed
    * @throws AssertionFailedError if a different number of errors have been reported than were
    *           expected
    */
-  void assertErrors(Source source, [List<ErrorCode> expectedErrorCodes = ErrorCode.EMPTY_LIST]) {
+  void assertErrors(Source source, [List<ErrorCode> expectedErrorCodes =
+      ErrorCode.EMPTY_LIST]) {
     GatheringErrorListener errorListener = new GatheringErrorListener();
     AnalysisErrorInfo errorsInfo = context.getErrors(source);
     for (AnalysisError error in errorsInfo.errors) {
       errorListener.onError(error);
     }
     errorListener.assertErrorsWithCodes(expectedErrorCodes);
   }
 
   void assertMainErrors(List<ErrorCode> expectedErrorCodes) {
     assertErrors(mainSource, expectedErrorCodes);
@@ skipping 185 matching lines @@
   void verify(List<Source> sources) {
     ResolutionVerifier verifier = new ResolutionVerifier();
     for (Source source in sources) {
       ht.HtmlUnit htmlUnit = context.getResolvedHtmlUnit(source);
       htmlUnit.accept(new ExpressionVisitor_AngularTest_verify(verifier));
     }
     verifier.assertResolved();
   }
 
   void _configureForAngular(AnalysisContextHelper contextHelper) {
-    contextHelper.addSource(
-        "/angular.dart",
-        r'''
+    contextHelper.addSource("/angular.dart", r'''
 library angular;
 
 class Scope {
   Map context;
 }
 
 class Formatter {
   final String name;
   const Formatter({this.name});
 }
@@ skipping 346 matching lines @@
 
   void test_equal_invalidRight() {
     EvaluationResult result = _getExpressionValue("2 == a");
     expect(result.isValid, isFalse);
   }
 
   void test_equal_string_string() {
     _assertValue(false, "'a' == 'b'");
   }
 
+  void test_greaterThan_int_int() {
+    _assertValue(false, "2 > 3");
+  }
+
   void test_greaterThanOrEqual_int_int() {
     _assertValue(false, "2 >= 3");
   }
 
-  void test_greaterThan_int_int() {
-    _assertValue(false, "2 > 3");
-  }
-
   void test_leftShift_int_int() {
     _assertValue3(64, "16 << 2");
   }
+  void test_lessThan_int_int() {
+    _assertValue(true, "2 < 3");
+  }
+
   void test_lessThanOrEqual_int_int() {
     _assertValue(true, "2 <= 3");
   }
 
-  void test_lessThan_int_int() {
-    _assertValue(true, "2 < 3");
-  }
-
   void test_literal_boolean_false() {
     _assertValue(false, "false");
   }
 
   void test_literal_boolean_true() {
     _assertValue(true, "true");
   }
 
   void test_literal_list() {
     EvaluationResult result = _getExpressionValue("const ['a', 'b', 'c']");
@@ skipping 335 matching lines @@
     _validate(true, (members[0] as TopLevelVariableDeclaration).variables);
     _validate(true, (members[1] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_empty() {
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.computeValues();
   }
 
   void test_computeValues_multipleSources() {
-    Source librarySource = addNamedSource(
-        "/lib.dart",
-        r'''
+    Source librarySource = addNamedSource("/lib.dart", r'''
 library lib;
 part 'part.dart';
 const int c = b;
 const int a = 0;''');
-    Source partSource = addNamedSource(
-        "/part.dart",
-        r'''
+    Source partSource = addNamedSource("/part.dart", r'''
 part of lib;
 const int b = a;
 const int d = c;''');
     LibraryElement libraryElement = resolve(librarySource);
     CompilationUnit libraryUnit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     expect(libraryUnit, isNotNull);
     CompilationUnit partUnit =
         analysisContext.resolveCompilationUnit(partSource, libraryElement);
     expect(partUnit, isNotNull);
@@ skipping 167 matching lines @@
 }''');
   }
 
   void test_dependencyOnNonFactoryRedirect_toMissing() {
     // a depends on A.foo() which depends on nothing, since A.bar() is
     // missing.
     _assertProperDependencies(r'''
 const A a = const A.foo();
 class A {
   const A.foo() : this.bar();
-}''',
-        [CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_MISSING_CONSTRUCTOR]);
+}''', [CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_MISSING_CONSTRUCTOR]);
   }
 
   void test_dependencyOnNonFactoryRedirect_toNonConst() {
     // a depends on A.foo() which depends on nothing, since A.bar() is
     // non-const.
     _assertProperDependencies(r'''
 const A a = const A.foo();
 class A {
   const A.foo() : this.bar();
   A.bar();
@@ skipping 28 matching lines @@
     _assertProperDependencies(r'''
 const x = y + 1;
 const y = 2;''');
   }
 
   void test_fromEnvironment_bool_default_false() {
     expect(_assertValidBool(_check_fromEnvironment_bool(null, "false")), false);
   }
 
   void test_fromEnvironment_bool_default_overridden() {
-    expect(_assertValidBool(_check_fromEnvironment_bool("false", "true")), false);
+    expect(
+        _assertValidBool(_check_fromEnvironment_bool("false", "true")),
+        false);
   }
 
   void test_fromEnvironment_bool_default_parseError() {
-    expect(_assertValidBool(_check_fromEnvironment_bool("parseError", "true")), true);
+    expect(
+        _assertValidBool(_check_fromEnvironment_bool("parseError", "true")),
+        true);
   }
 
   void test_fromEnvironment_bool_default_true() {
     expect(_assertValidBool(_check_fromEnvironment_bool(null, "true")), true);
   }
 
   void test_fromEnvironment_bool_false() {
     expect(_assertValidBool(_check_fromEnvironment_bool("false", null)), false);
   }
 
   void test_fromEnvironment_bool_parseError() {
-    expect(_assertValidBool(_check_fromEnvironment_bool("parseError", null)), false);
+    expect(
+        _assertValidBool(_check_fromEnvironment_bool("parseError", null)),
+        false);
   }
 
   void test_fromEnvironment_bool_true() {
     expect(_assertValidBool(_check_fromEnvironment_bool("true", null)), true);
   }
 
   void test_fromEnvironment_bool_undeclared() {
     _assertValidUnknown(_check_fromEnvironment_bool(null, null));
   }
 
   void test_fromEnvironment_int_default_overridden() {
     expect(_assertValidInt(_check_fromEnvironment_int("234", "123")), 234);
   }
 
   void test_fromEnvironment_int_default_parseError() {
-    expect(_assertValidInt(_check_fromEnvironment_int("parseError", "123")), 123);
+    expect(
+        _assertValidInt(_check_fromEnvironment_int("parseError", "123")),
+        123);
   }
 
   void test_fromEnvironment_int_default_undeclared() {
     expect(_assertValidInt(_check_fromEnvironment_int(null, "123")), 123);
   }
 
   void test_fromEnvironment_int_ok() {
     expect(_assertValidInt(_check_fromEnvironment_int("234", null)), 234);
   }
 
   void test_fromEnvironment_int_parseError() {
     _assertValidNull(_check_fromEnvironment_int("parseError", null));
   }
 
   void test_fromEnvironment_int_parseError_nullDefault() {
     _assertValidNull(_check_fromEnvironment_int("parseError", "null"));
   }
 
   void test_fromEnvironment_int_undeclared() {
     _assertValidUnknown(_check_fromEnvironment_int(null, null));
   }
 
   void test_fromEnvironment_int_undeclared_nullDefault() {
     _assertValidNull(_check_fromEnvironment_int(null, "null"));
   }
 
   void test_fromEnvironment_string_default_overridden() {
-    expect(_assertValidString(_check_fromEnvironment_string("abc", "'def'")), "abc");
+    expect(
+        _assertValidString(_check_fromEnvironment_string("abc", "'def'")),
+        "abc");
   }
 
   void test_fromEnvironment_string_default_undeclared() {
-    expect(_assertValidString(_check_fromEnvironment_string(null, "'def'")), "def");
+    expect(
+        _assertValidString(_check_fromEnvironment_string(null, "'def'")),
+        "def");
   }
 
   void test_fromEnvironment_string_empty() {
     expect(_assertValidString(_check_fromEnvironment_string("", null)), "");
   }
 
   void test_fromEnvironment_string_ok() {
-    expect(_assertValidString(_check_fromEnvironment_string("abc", null)), "abc");
+    expect(
+        _assertValidString(_check_fromEnvironment_string("abc", null)),
+        "abc");
   }
 
   void test_fromEnvironment_string_undeclared() {
     _assertValidUnknown(_check_fromEnvironment_string(null, null));
   }
 
   void test_fromEnvironment_string_undeclared_nullDefault() {
     _assertValidNull(_check_fromEnvironment_string(null, "null"));
   }
 
@@ skipping 163 matching lines @@
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A.a1();
 class A {
   const A.a1() : this.a2();
   const A.a2() : x = 5;
   final int x;
 }''');
-    Map<String, DartObjectImpl> aFields = _assertType(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"),
-        "A");
+    Map<String, DartObjectImpl> aFields =
+        _assertType(_evaluateInstanceCreationExpression(compilationUnit, "foo"), "A");
     _assertIntField(aFields, 'x', 5);
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_arg() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A.a1(1);
 class A {
   const A.a1(x) : this.a2(x + 100);
   const A.a2(x) : y = x + 10;
   final int y;
 }''');
-    Map<String, DartObjectImpl> aFields = _assertType(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"),
-        "A");
+    Map<String, DartObjectImpl> aFields =
+        _assertType(_evaluateInstanceCreationExpression(compilationUnit, "foo"), "A");
     _assertIntField(aFields, 'y', 111);
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_cycle() {
     // It is an error to have a cycle in non-factory redirects; however, we
     // need to make sure that even if the error occurs, attempting to evaluate
     // the constant will terminate.
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A();
 class A {
   const A() : this.b();
   const A.b() : this();
 }''');
     _assertValidUnknown(
         _evaluateInstanceCreationExpression(compilationUnit, "foo"));
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_defaultArg() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A.a1();
 class A {
   const A.a1() : this.a2();
   const A.a2([x = 100]) : y = x + 10;
   final int y;
 }''');
-    Map<String, DartObjectImpl> aFields = _assertType(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"),
-        "A");
+    Map<String, DartObjectImpl> aFields =
+        _assertType(_evaluateInstanceCreationExpression(compilationUnit, "foo"), "A");
     _assertIntField(aFields, 'y', 110);
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_toMissing() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A.a1();
 class A {
   const A.a1() : this.a2();
 }''');
     // We don't care what value foo evaluates to (since there is a compile
@@ skipping 20 matching lines @@
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_unnamed() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A.a1();
 class A {
   const A.a1() : this();
   const A() : x = 5;
   final int x;
 }''');
-    Map<String, DartObjectImpl> aFields = _assertType(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"),
-        "A");
+    Map<String, DartObjectImpl> aFields =
+        _assertType(_evaluateInstanceCreationExpression(compilationUnit, "foo"), "A");
     _assertIntField(aFields, 'x', 5);
   }
 
   void test_instanceCreationExpression_redirect() {
     CompilationUnit compilationUnit = resolveSource(r'''
 const foo = const A();
 class A {
   const factory A() = B;
 }
 class B implements A {
   const B();
 }''');
     _assertType(
         _evaluateInstanceCreationExpression(compilationUnit, "foo"),
         "B");
   }
 
+  void test_instanceCreationExpression_redirect_cycle() {
+    // It is an error to have a cycle in factory redirects; however, we need
+    // to make sure that even if the error occurs, attempting to evaluate the
+    // constant will terminate.
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A();
+class A {
+  const factory A() = A.b;
+  const factory A.b() = A;
+}''');
+    _assertValidUnknown(
+        _evaluateInstanceCreationExpression(compilationUnit, "foo"));
+  }
+
+  void test_instanceCreationExpression_redirect_extern() {
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A();
+class A {
+  external const factory A();
+}''');
+    _assertValidUnknown(
+        _evaluateInstanceCreationExpression(compilationUnit, "foo"));
+  }
+
+  void test_instanceCreationExpression_redirect_nonConst() {
+    // It is an error for a const factory constructor redirect to a non-const
+    // constructor; however, we need to make sure that even if the error
+    // attempting to evaluate the constant won't cause a crash.
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A();
+class A {
+  const factory A() = A.b;
+  A.b();
+}''');
+    _assertValidUnknown(
+        _evaluateInstanceCreationExpression(compilationUnit, "foo"));
+  }
+
   void test_instanceCreationExpression_redirectWithTypeParams() {
     CompilationUnit compilationUnit = resolveSource(r'''
 class A {
   const factory A(var a) = B<int>;
 }
 
 class B<T> implements A {
   final T x;
   const B(this.x);
 }
@@ skipping 21 matching lines @@
 }
 
 const A<int> a = const A<int>(10);''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "a");
     Map<String, DartObjectImpl> fields = _assertType(result, "B<int>");
     expect(fields, hasLength(1));
     _assertIntField(fields, "x", 10);
   }
 
-  void test_instanceCreationExpression_redirect_cycle() {
-    // It is an error to have a cycle in factory redirects; however, we need
-    // to make sure that even if the error occurs, attempting to evaluate the
-    // constant will terminate.
-    CompilationUnit compilationUnit = resolveSource(r'''
-const foo = const A();
-class A {
-  const factory A() = A.b;
-  const factory A.b() = A;
-}''');
-    _assertValidUnknown(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"));
-  }
-
-  void test_instanceCreationExpression_redirect_extern() {
-    CompilationUnit compilationUnit = resolveSource(r'''
-const foo = const A();
-class A {
-  external const factory A();
-}''');
-    _assertValidUnknown(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"));
-  }
-
-  void test_instanceCreationExpression_redirect_nonConst() {
-    // It is an error for a const factory constructor redirect to a non-const
-    // constructor; however, we need to make sure that even if the error
-    // attempting to evaluate the constant won't cause a crash.
-    CompilationUnit compilationUnit = resolveSource(r'''
-const foo = const A();
-class A {
-  const factory A() = A.b;
-  A.b();
-}''');
-    _assertValidUnknown(
-        _evaluateInstanceCreationExpression(compilationUnit, "foo"));
-  }
-
   void test_instanceCreationExpression_symbol() {
     CompilationUnit compilationUnit =
         resolveSource("const foo = const Symbol('a');");
     EvaluationResultImpl evaluationResult =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     expect(evaluationResult.value, isNotNull);
     DartObjectImpl value = evaluationResult.value;
     expect(value.type, typeProvider.symbolType);
     expect(value.value, "a");
   }
@@ skipping 131 matching lines @@
     expect(value.type, typeProvider.stringType);
     return value.stringValue;
   }
 
   void _assertValidUnknown(EvaluationResultImpl result) {
     expect(result.value, isNotNull);
     DartObjectImpl value = result.value;
     expect(value.isUnknown, isTrue);
   }
 
-  void _checkInstanceCreationOptionalParams(bool isFieldFormal, bool isNamed,
-      bool hasDefault) {
-    String fieldName = "j";
-    String paramName = isFieldFormal ? fieldName : "i";
-    String formalParam =
-        "${isFieldFormal ? "this." : "int "}$paramName${hasDefault ? " = 3" : ""}";
-    CompilationUnit compilationUnit = resolveSource("""
-const x = const A();
-const y = const A(${isNamed ? '$paramName: ' : ''}10);
-class A {
-  const A(${isNamed ? "{$formalParam}" : "[$formalParam]"})${isFieldFormal ? "" : " : $fieldName = $paramName"};
-  final int $fieldName;
-}""");
-    EvaluationResultImpl x =
-        _evaluateInstanceCreationExpression(compilationUnit, "x");
-    Map<String, DartObjectImpl> fieldsOfX = _assertType(x, "A");
-    expect(fieldsOfX, hasLength(1));
-    if (hasDefault) {
-      _assertIntField(fieldsOfX, fieldName, 3);
-    } else {
-      _assertNullField(fieldsOfX, fieldName);
-    }
-    EvaluationResultImpl y =
-        _evaluateInstanceCreationExpression(compilationUnit, "y");
-    Map<String, DartObjectImpl> fieldsOfY = _assertType(y, "A");
-    expect(fieldsOfY, hasLength(1));
-    _assertIntField(fieldsOfY, fieldName, 10);
-  }
-
-  void _checkInstanceCreation_withSupertypeParams(bool isExplicit) {
-    String superCall = isExplicit ? " : super()" : "";
-    CompilationUnit compilationUnit = resolveSource("""
-class A<T> {
-  const A();
-}
-class B<T, U> extends A<T> {
-  const B()$superCall;
-}
-class C<T, U> extends A<U> {
-  const C()$superCall;
-}
-const b_int_num = const B<int, num>();
-const c_int_num = const C<int, num>();""");
-    EvaluationResultImpl b_int_num =
-        _evaluateInstanceCreationExpression(compilationUnit, "b_int_num");
-    Map<String, DartObjectImpl> b_int_num_fields =
-        _assertType(b_int_num, "B<int, num>");
-    _assertFieldType(b_int_num_fields, GenericState.SUPERCLASS_FIELD, "A<int>");
-    EvaluationResultImpl c_int_num =
-        _evaluateInstanceCreationExpression(compilationUnit, "c_int_num");
-    Map<String, DartObjectImpl> c_int_num_fields =
-        _assertType(c_int_num, "C<int, num>");
-    _assertFieldType(c_int_num_fields, GenericState.SUPERCLASS_FIELD, "A<num>");
-  }
-
   EvaluationResultImpl _check_fromEnvironment_bool(String valueInEnvironment,
       String defaultExpr) {
     String envVarName = "x";
     String varName = "foo";
+    if (valueInEnvironment != null) {
+      analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
+    }
+    String defaultArg =
+        defaultExpr == null ? "" : ", defaultValue: $defaultExpr";
+    CompilationUnit compilationUnit = resolveSource(
+        "const $varName = const bool.fromEnvironment('$envVarName'$defaultArg);");
+    return _evaluateInstanceCreationExpression(compilationUnit, varName);
+  }
+
+  EvaluationResultImpl _check_fromEnvironment_int(String valueInEnvironment,
+      String defaultExpr) {
+    String envVarName = "x";
+    String varName = "foo";
     if (valueInEnvironment != null) {
       analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
     }
     String defaultArg =
         defaultExpr == null ? "" : ", defaultValue: $defaultExpr";
     CompilationUnit compilationUnit = resolveSource(
-                "const $varName = const bool.fromEnvironment('$envVarName'$defaultArg);");
+        "const $varName = const int.fromEnvironment('$envVarName'$defaultArg);");
     return _evaluateInstanceCreationExpression(compilationUnit, varName);
   }
 
-  EvaluationResultImpl _check_fromEnvironment_int(String valueInEnvironment,
+  EvaluationResultImpl _check_fromEnvironment_string(String valueInEnvironment,
       String defaultExpr) {
     String envVarName = "x";
     String varName = "foo";
     if (valueInEnvironment != null) {
       analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
     }
     String defaultArg =
         defaultExpr == null ? "" : ", defaultValue: $defaultExpr";
     CompilationUnit compilationUnit = resolveSource(
-                "const $varName = const int.fromEnvironment('$envVarName'$defaultArg);");
+        "const $varName = const String.fromEnvironment('$envVarName'$defaultArg);");
     return _evaluateInstanceCreationExpression(compilationUnit, varName);
   }
 
-  EvaluationResultImpl _check_fromEnvironment_string(String valueInEnvironment,
-      String defaultExpr) {
-    String envVarName = "x";
-    String varName = "foo";
-    if (valueInEnvironment != null) {
-      analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
+  void _checkInstanceCreation_withSupertypeParams(bool isExplicit) {
+    String superCall = isExplicit ? " : super()" : "";
+    CompilationUnit compilationUnit = resolveSource("""
+class A<T> {
+  const A();
+}
+class B<T, U> extends A<T> {
+  const B()$superCall;
+}
+class C<T, U> extends A<U> {
+  const C()$superCall;
+}
+const b_int_num = const B<int, num>();
+const c_int_num = const C<int, num>();""");
+    EvaluationResultImpl b_int_num =
+        _evaluateInstanceCreationExpression(compilationUnit, "b_int_num");
+    Map<String, DartObjectImpl> b_int_num_fields =
+        _assertType(b_int_num, "B<int, num>");
+    _assertFieldType(b_int_num_fields, GenericState.SUPERCLASS_FIELD, "A<int>");
+    EvaluationResultImpl c_int_num =
+        _evaluateInstanceCreationExpression(compilationUnit, "c_int_num");
+    Map<String, DartObjectImpl> c_int_num_fields =
+        _assertType(c_int_num, "C<int, num>");
+    _assertFieldType(c_int_num_fields, GenericState.SUPERCLASS_FIELD, "A<num>");
+  }
+
+  void _checkInstanceCreationOptionalParams(bool isFieldFormal, bool isNamed,
+      bool hasDefault) {
+    String fieldName = "j";
+    String paramName = isFieldFormal ? fieldName : "i";
+    String formalParam =
+        "${isFieldFormal ? "this." : "int "}$paramName${hasDefault ? " = 3" : ""}";
+    CompilationUnit compilationUnit = resolveSource("""
+const x = const A();
+const y = const A(${isNamed ? '$paramName: ' : ''}10);
+class A {
+  const A(${isNamed ? "{$formalParam}" : "[$formalParam]"})${isFieldFormal ? "" : " : $fieldName = $paramName"};
+  final int $fieldName;
+}""");
+    EvaluationResultImpl x =
+        _evaluateInstanceCreationExpression(compilationUnit, "x");
+    Map<String, DartObjectImpl> fieldsOfX = _assertType(x, "A");
+    expect(fieldsOfX, hasLength(1));
+    if (hasDefault) {
+      _assertIntField(fieldsOfX, fieldName, 3);
+    } else {
+      _assertNullField(fieldsOfX, fieldName);
     }
-    String defaultArg =
-        defaultExpr == null ? "" : ", defaultValue: $defaultExpr";
-    CompilationUnit compilationUnit = resolveSource(
-                "const $varName = const String.fromEnvironment('$envVarName'$defaultArg);");
-    return _evaluateInstanceCreationExpression(compilationUnit, varName);
+    EvaluationResultImpl y =
+        _evaluateInstanceCreationExpression(compilationUnit, "y");
+    Map<String, DartObjectImpl> fieldsOfY = _assertType(y, "A");
+    expect(fieldsOfY, hasLength(1));
+    _assertIntField(fieldsOfY, fieldName, 10);
   }
 
   EvaluationResultImpl
       _evaluateInstanceCreationExpression(CompilationUnit compilationUnit,
       String name) {
     Expression expression =
         findTopLevelConstantExpression(compilationUnit, name);
     return (expression as InstanceCreationExpression).evaluationResult;
   }
 
@@ skipping 50 matching lines @@
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
     _assertValue(
         0,
         expression.accept(
             new ConstantVisitor.con1(new TestTypeProvider(), errorReporter)));
     errorListener.assertNoErrors();
   }
 
-  void test_visitConditionalExpression_instanceCreation_invalidFieldInitializer() {
+  void
+      test_visitConditionalExpression_instanceCreation_invalidFieldInitializer() {
     TestTypeProvider typeProvider = new TestTypeProvider();
     LibraryElementImpl libraryElement = ElementFactory.library(null, "lib");
     String className = "C";
     ClassElementImpl classElement = ElementFactory.classElement2(className);
     (libraryElement.definingCompilationUnit as CompilationUnitElementImpl).types =
         <ClassElement>[classElement];
     ConstructorElementImpl constructorElement =
         ElementFactory.constructorElement(
             classElement,
             null,
@@ skipping 78 matching lines @@
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
     _assertValue(
         1,
         expression.accept(
             new ConstantVisitor.con1(new TestTypeProvider(), errorReporter)));
     errorListener.assertNoErrors();
   }
 
   void test_visitSimpleIdentifier_inEnvironment() {
-    CompilationUnit compilationUnit =
-        resolveSource(r'''
+    CompilationUnit compilationUnit = resolveSource(r'''
 const a = b;
 const b = 3;''');
     Map<String, DartObjectImpl> environment = new Map<String, DartObjectImpl>();
     DartObjectImpl six =
         new DartObjectImpl(typeProvider.intType, new IntState(6));
     environment["b"] = six;
     _assertValue(6, _evaluateConstant(compilationUnit, "a", environment));
   }
 
   void test_visitSimpleIdentifier_notInEnvironment() {
-    CompilationUnit compilationUnit =
-        resolveSource(r'''
+    CompilationUnit compilationUnit = resolveSource(r'''
 const a = b;
 const b = 3;''');
     Map<String, DartObjectImpl> environment = new Map<String, DartObjectImpl>();
     DartObjectImpl six =
         new DartObjectImpl(typeProvider.intType, new IntState(6));
     environment["c"] = six;
     _assertValue(3, _evaluateConstant(compilationUnit, "a", environment));
   }
 
   void test_visitSimpleIdentifier_withoutEnvironment() {
-    CompilationUnit compilationUnit =
-        resolveSource(r'''
+    CompilationUnit compilationUnit = resolveSource(r'''
 const a = b;
 const b = 3;''');
     _assertValue(3, _evaluateConstant(compilationUnit, "a", null));
   }
 
   void _assertValue(int expectedValue, DartObjectImpl result) {
     expect(result, isNotNull);
     expect(result.type.name, "int");
     expect(result.intValue, expectedValue);
   }
@@ skipping 345 matching lines @@
   }
 
   void test_equalEqual_string_unknown() {
     _assertEqualEqual(
         _boolValue(null),
         _stringValue(null),
         _stringValue("def"));
   }
 
   void test_equals_list_false_differentSizes() {
-    expect(_listValue([_boolValue(true)]) ==
-            _listValue([_boolValue(true), _boolValue(false)]), isFalse);
+    expect(
+        _listValue([_boolValue(true)]) ==
+            _listValue([_boolValue(true), _boolValue(false)]),
+        isFalse);
   }
 
   void test_equals_list_false_sameSize() {
-    expect(_listValue([_boolValue(true)]) == _listValue([_boolValue(false)]), isFalse);
+    expect(
+        _listValue([_boolValue(true)]) == _listValue([_boolValue(false)]),
+        isFalse);
   }
 
   void test_equals_list_true_empty() {
     expect(_listValue(), _listValue());
   }
 
   void test_equals_list_true_nonEmpty() {
     expect(_listValue([_boolValue(true)]), _listValue([_boolValue(true)]));
   }
 
@@ skipping 74 matching lines @@
 
   void test_getValue_string_known() {
     String value = "twenty-three";
     expect(_stringValue(value).value, value);
   }
 
   void test_getValue_string_unknown() {
     expect(_stringValue(null).value, isNull);
   }
 
+  void test_greaterThan_knownDouble_knownDouble_false() {
+    _assertGreaterThan(_boolValue(false), _doubleValue(1.0), _doubleValue(2.0));
+  }
+
+  void test_greaterThan_knownDouble_knownDouble_true() {
+    _assertGreaterThan(_boolValue(true), _doubleValue(2.0), _doubleValue(1.0));
+  }
+
+  void test_greaterThan_knownDouble_knownInt_false() {
+    _assertGreaterThan(_boolValue(false), _doubleValue(1.0), _intValue(2));
+  }
+
+  void test_greaterThan_knownDouble_knownInt_true() {
+    _assertGreaterThan(_boolValue(true), _doubleValue(2.0), _intValue(1));
+  }
+
+  void test_greaterThan_knownDouble_unknownDouble() {
+    _assertGreaterThan(_boolValue(null), _doubleValue(1.0), _doubleValue(null));
+  }
+
+  void test_greaterThan_knownDouble_unknownInt() {
+    _assertGreaterThan(_boolValue(null), _doubleValue(1.0), _intValue(null));
+  }
+
+  void test_greaterThan_knownInt_knownInt_false() {
+    _assertGreaterThan(_boolValue(false), _intValue(1), _intValue(2));
+  }
+
+  void test_greaterThan_knownInt_knownInt_true() {
+    _assertGreaterThan(_boolValue(true), _intValue(2), _intValue(1));
+  }
+
+  void test_greaterThan_knownInt_knownString() {
+    _assertGreaterThan(null, _intValue(1), _stringValue("2"));
+  }
+
+  void test_greaterThan_knownInt_unknownDouble() {
+    _assertGreaterThan(_boolValue(null), _intValue(1), _doubleValue(null));
+  }
+
+  void test_greaterThan_knownInt_unknownInt() {
+    _assertGreaterThan(_boolValue(null), _intValue(1), _intValue(null));
+  }
+
+  void test_greaterThan_knownString_knownInt() {
+    _assertGreaterThan(null, _stringValue("1"), _intValue(2));
+  }
+
+  void test_greaterThan_unknownDouble_knownDouble() {
+    _assertGreaterThan(_boolValue(null), _doubleValue(null), _doubleValue(2.0));
+  }
+
+  void test_greaterThan_unknownDouble_knownInt() {
+    _assertGreaterThan(_boolValue(null), _doubleValue(null), _intValue(2));
+  }
+
+  void test_greaterThan_unknownInt_knownDouble() {
+    _assertGreaterThan(_boolValue(null), _intValue(null), _doubleValue(2.0));
+  }
+
+  void test_greaterThan_unknownInt_knownInt() {
+    _assertGreaterThan(_boolValue(null), _intValue(null), _intValue(2));
+  }
+
   void test_greaterThanOrEqual_knownDouble_knownDouble_false() {
     _assertGreaterThanOrEqual(
         _boolValue(false),
         _doubleValue(1.0),
         _doubleValue(2.0));
   }
 
   void test_greaterThanOrEqual_knownDouble_knownDouble_true() {
     _assertGreaterThanOrEqual(
         _boolValue(true),
@@ skipping 74 matching lines @@
     _assertGreaterThanOrEqual(
         _boolValue(null),
         _intValue(null),
         _doubleValue(2.0));
   }
 
   void test_greaterThanOrEqual_unknownInt_knownInt() {
     _assertGreaterThanOrEqual(_boolValue(null), _intValue(null), _intValue(2));
   }
 
-  void test_greaterThan_knownDouble_knownDouble_false() {
-    _assertGreaterThan(_boolValue(false), _doubleValue(1.0), _doubleValue(2.0));
-  }
-
-  void test_greaterThan_knownDouble_knownDouble_true() {
-    _assertGreaterThan(_boolValue(true), _doubleValue(2.0), _doubleValue(1.0));
-  }
-
-  void test_greaterThan_knownDouble_knownInt_false() {
-    _assertGreaterThan(_boolValue(false), _doubleValue(1.0), _intValue(2));
-  }
-
-  void test_greaterThan_knownDouble_knownInt_true() {
-    _assertGreaterThan(_boolValue(true), _doubleValue(2.0), _intValue(1));
-  }
-
-  void test_greaterThan_knownDouble_unknownDouble() {
-    _assertGreaterThan(_boolValue(null), _doubleValue(1.0), _doubleValue(null));
-  }
-
-  void test_greaterThan_knownDouble_unknownInt() {
-    _assertGreaterThan(_boolValue(null), _doubleValue(1.0), _intValue(null));
-  }
-
-  void test_greaterThan_knownInt_knownInt_false() {
-    _assertGreaterThan(_boolValue(false), _intValue(1), _intValue(2));
-  }
-
-  void test_greaterThan_knownInt_knownInt_true() {
-    _assertGreaterThan(_boolValue(true), _intValue(2), _intValue(1));
-  }
-
-  void test_greaterThan_knownInt_knownString() {
-    _assertGreaterThan(null, _intValue(1), _stringValue("2"));
-  }
-
-  void test_greaterThan_knownInt_unknownDouble() {
-    _assertGreaterThan(_boolValue(null), _intValue(1), _doubleValue(null));
-  }
-
-  void test_greaterThan_knownInt_unknownInt() {
-    _assertGreaterThan(_boolValue(null), _intValue(1), _intValue(null));
-  }
-
-  void test_greaterThan_knownString_knownInt() {
-    _assertGreaterThan(null, _stringValue("1"), _intValue(2));
-  }
-
-  void test_greaterThan_unknownDouble_knownDouble() {
-    _assertGreaterThan(_boolValue(null), _doubleValue(null), _doubleValue(2.0));
-  }
-
-  void test_greaterThan_unknownDouble_knownInt() {
-    _assertGreaterThan(_boolValue(null), _doubleValue(null), _intValue(2));
-  }
-
-  void test_greaterThan_unknownInt_knownDouble() {
-    _assertGreaterThan(_boolValue(null), _intValue(null), _doubleValue(2.0));
-  }
-
-  void test_greaterThan_unknownInt_knownInt() {
-    _assertGreaterThan(_boolValue(null), _intValue(null), _intValue(2));
-  }
-
   void test_hasExactValue_bool_false() {
     expect(_boolValue(false).hasExactValue, isTrue);
   }
 
   void test_hasExactValue_bool_true() {
     expect(_boolValue(true).hasExactValue, isTrue);
   }
 
   void test_hasExactValue_bool_unknown() {
     expect(_boolValue(null).hasExactValue, isTrue);
@@ skipping 29 matching lines @@
 
   void test_hasExactValue_list_valid() {
     expect(_listValue([_intValue(23)]).hasExactValue, isTrue);
   }
 
   void test_hasExactValue_map_empty() {
     expect(_mapValue().hasExactValue, isTrue);
   }
 
   void test_hasExactValue_map_invalidKey() {
-    expect(_mapValue([_dynamicValue(), _stringValue("value")]).hasExactValue, isFalse);
+    expect(
+        _mapValue([_dynamicValue(), _stringValue("value")]).hasExactValue,
+        isFalse);
   }
 
   void test_hasExactValue_map_invalidValue() {
-    expect(_mapValue([_stringValue("key"), _dynamicValue()]).hasExactValue, isFalse);
+    expect(
+        _mapValue([_stringValue("key"), _dynamicValue()]).hasExactValue,
+        isFalse);
   }
 
   void test_hasExactValue_map_valid() {
-    expect(_mapValue([_stringValue("key"), _stringValue("value")]).hasExactValue, isTrue);
+    expect(
+        _mapValue([_stringValue("key"), _stringValue("value")]).hasExactValue,
+        isTrue);
   }
 
   void test_hasExactValue_null() {
     expect(_nullValue().hasExactValue, isTrue);
   }
 
   void test_hasExactValue_num() {
     expect(_numValue().hasExactValue, isFalse);
   }
 
@@ skipping 39 matching lines @@
 
   void test_identical_int_unknown() {
     _assertIdentical(_boolValue(null), _intValue(null), _intValue(3));
   }
 
   void test_identical_list_empty() {
     _assertIdentical(_boolValue(true), _listValue(), _listValue());
   }
 
   void test_identical_list_false() {
-    _assertIdentical(_boolValue(false), _listValue(),
+    _assertIdentical(
+        _boolValue(false),
+        _listValue(),
         _listValue([_intValue(3)]));
   }
 
   void test_identical_map_empty() {
     _assertIdentical(_boolValue(true), _mapValue(), _mapValue());
   }
 
   void test_identical_map_false() {
-    _assertIdentical(_boolValue(false), _mapValue(),
+    _assertIdentical(
+        _boolValue(false),
+        _mapValue(),
         _mapValue([_intValue(1), _intValue(2)]));
   }
 
   void test_identical_null() {
     _assertIdentical(_boolValue(true), _nullValue(), _nullValue());
   }
 
   void test_identical_string_false() {
     _assertIdentical(
         _boolValue(false),
         _stringValue("abc"),
         _stringValue("def"));
   }
 
   void test_identical_string_true() {
     _assertIdentical(
         _boolValue(true),
         _stringValue("abc"),
         _stringValue("abc"));
   }
 
   void test_identical_string_unknown() {
-    _assertIdentical(
-        _boolValue(null),
-        _stringValue(null),
-        _stringValue("def"));
+    _assertIdentical(_boolValue(null), _stringValue(null), _stringValue("def"));
   }
 
   void test_integerDivide_knownDouble_knownDouble() {
     _assertIntegerDivide(_intValue(3), _doubleValue(6.0), _doubleValue(2.0));
   }
 
   void test_integerDivide_knownDouble_knownInt() {
     _assertIntegerDivide(_intValue(3), _doubleValue(6.0), _intValue(2));
   }
 
@@ skipping 92 matching lines @@
   }
 
   void test_isBoolNumStringOrNull_string_known() {
     expect(_stringValue("twenty-three").isBoolNumStringOrNull, isTrue);
   }
 
   void test_isBoolNumStringOrNull_string_unknown() {
     expect(_stringValue(null).isBoolNumStringOrNull, isTrue);
   }
 
+  void test_lessThan_knownDouble_knownDouble_false() {
+    _assertLessThan(_boolValue(false), _doubleValue(2.0), _doubleValue(1.0));
+  }
+
+  void test_lessThan_knownDouble_knownDouble_true() {
+    _assertLessThan(_boolValue(true), _doubleValue(1.0), _doubleValue(2.0));
+  }
+
+  void test_lessThan_knownDouble_knownInt_false() {
+    _assertLessThan(_boolValue(false), _doubleValue(2.0), _intValue(1));
+  }
+
+  void test_lessThan_knownDouble_knownInt_true() {
+    _assertLessThan(_boolValue(true), _doubleValue(1.0), _intValue(2));
+  }
+
+  void test_lessThan_knownDouble_unknownDouble() {
+    _assertLessThan(_boolValue(null), _doubleValue(1.0), _doubleValue(null));
+  }
+
+  void test_lessThan_knownDouble_unknownInt() {
+    _assertLessThan(_boolValue(null), _doubleValue(1.0), _intValue(null));
+  }
+
+  void test_lessThan_knownInt_knownInt_false() {
+    _assertLessThan(_boolValue(false), _intValue(2), _intValue(1));
+  }
+
+  void test_lessThan_knownInt_knownInt_true() {
+    _assertLessThan(_boolValue(true), _intValue(1), _intValue(2));
+  }
+
+  void test_lessThan_knownInt_knownString() {
+    _assertLessThan(null, _intValue(1), _stringValue("2"));
+  }
+
+  void test_lessThan_knownInt_unknownDouble() {
+    _assertLessThan(_boolValue(null), _intValue(1), _doubleValue(null));
+  }
+
+  void test_lessThan_knownInt_unknownInt() {
+    _assertLessThan(_boolValue(null), _intValue(1), _intValue(null));
+  }
+
+  void test_lessThan_knownString_knownInt() {
+    _assertLessThan(null, _stringValue("1"), _intValue(2));
+  }
+
+  void test_lessThan_unknownDouble_knownDouble() {
+    _assertLessThan(_boolValue(null), _doubleValue(null), _doubleValue(2.0));
+  }
+
+  void test_lessThan_unknownDouble_knownInt() {
+    _assertLessThan(_boolValue(null), _doubleValue(null), _intValue(2));
+  }
+
+  void test_lessThan_unknownInt_knownDouble() {
+    _assertLessThan(_boolValue(null), _intValue(null), _doubleValue(2.0));
+  }
+
+  void test_lessThan_unknownInt_knownInt() {
+    _assertLessThan(_boolValue(null), _intValue(null), _intValue(2));
+  }
+
   void test_lessThanOrEqual_knownDouble_knownDouble_false() {
     _assertLessThanOrEqual(
         _boolValue(false),
         _doubleValue(2.0),
         _doubleValue(1.0));
   }
 
   void test_lessThanOrEqual_knownDouble_knownDouble_true() {
     _assertLessThanOrEqual(
         _boolValue(true),
@@ skipping 62 matching lines @@
     _assertLessThanOrEqual(
         _boolValue(null),
         _intValue(null),
         _doubleValue(2.0));
   }
 
   void test_lessThanOrEqual_unknownInt_knownInt() {
     _assertLessThanOrEqual(_boolValue(null), _intValue(null), _intValue(2));
   }
 
-  void test_lessThan_knownDouble_knownDouble_false() {
-    _assertLessThan(_boolValue(false), _doubleValue(2.0), _doubleValue(1.0));
-  }
-
-  void test_lessThan_knownDouble_knownDouble_true() {
-    _assertLessThan(_boolValue(true), _doubleValue(1.0), _doubleValue(2.0));
-  }
-
-  void test_lessThan_knownDouble_knownInt_false() {
-    _assertLessThan(_boolValue(false), _doubleValue(2.0), _intValue(1));
-  }
-
-  void test_lessThan_knownDouble_knownInt_true() {
-    _assertLessThan(_boolValue(true), _doubleValue(1.0), _intValue(2));
-  }
-
-  void test_lessThan_knownDouble_unknownDouble() {
-    _assertLessThan(_boolValue(null), _doubleValue(1.0), _doubleValue(null));
-  }
-
-  void test_lessThan_knownDouble_unknownInt() {
-    _assertLessThan(_boolValue(null), _doubleValue(1.0), _intValue(null));
-  }
-
-  void test_lessThan_knownInt_knownInt_false() {
-    _assertLessThan(_boolValue(false), _intValue(2), _intValue(1));
-  }
-
-  void test_lessThan_knownInt_knownInt_true() {
-    _assertLessThan(_boolValue(true), _intValue(1), _intValue(2));
-  }
-
-  void test_lessThan_knownInt_knownString() {
-    _assertLessThan(null, _intValue(1), _stringValue("2"));
-  }
-
-  void test_lessThan_knownInt_unknownDouble() {
-    _assertLessThan(_boolValue(null), _intValue(1), _doubleValue(null));
-  }
-
-  void test_lessThan_knownInt_unknownInt() {
-    _assertLessThan(_boolValue(null), _intValue(1), _intValue(null));
-  }
-
-  void test_lessThan_knownString_knownInt() {
-    _assertLessThan(null, _stringValue("1"), _intValue(2));
-  }
-
-  void test_lessThan_unknownDouble_knownDouble() {
-    _assertLessThan(_boolValue(null), _doubleValue(null), _doubleValue(2.0));
-  }
-
-  void test_lessThan_unknownDouble_knownInt() {
-    _assertLessThan(_boolValue(null), _doubleValue(null), _intValue(2));
-  }
-
-  void test_lessThan_unknownInt_knownDouble() {
-    _assertLessThan(_boolValue(null), _intValue(null), _doubleValue(2.0));
-  }
-
-  void test_lessThan_unknownInt_knownInt() {
-    _assertLessThan(_boolValue(null), _intValue(null), _intValue(2));
-  }
-
   void test_logicalAnd_false_false() {
     _assertLogicalAnd(_boolValue(false), _boolValue(false), _boolValue(false));
   }
 
   void test_logicalAnd_false_null() {
     try {
       _assertLogicalAnd(_boolValue(false), _boolValue(false), _nullValue());
       fail("Expected EvaluationException");
     } on EvaluationException catch (exception) {
     }
@@ skipping 1190 matching lines @@
   }
 
   DartObjectImpl _intValue(int value) {
     if (value == null) {
       return new DartObjectImpl(_typeProvider.intType, IntState.UNKNOWN_VALUE);
     } else {
       return new DartObjectImpl(_typeProvider.intType, new IntState(value));
     }
   }
 
-  DartObjectImpl _listValue([List<DartObjectImpl> elements = DartObjectImpl.EMPTY_LIST]) {
+  DartObjectImpl _listValue([List<DartObjectImpl> elements =
+      DartObjectImpl.EMPTY_LIST]) {
     return new DartObjectImpl(_typeProvider.listType, new ListState(elements));
   }
 
-  DartObjectImpl _mapValue([List<DartObjectImpl> keyElementPairs = DartObjectImpl.EMPTY_LIST]) {
+  DartObjectImpl _mapValue([List<DartObjectImpl> keyElementPairs =
+      DartObjectImpl.EMPTY_LIST]) {
     Map<DartObjectImpl, DartObjectImpl> map =
         new Map<DartObjectImpl, DartObjectImpl>();
     int count = keyElementPairs.length;
     for (int i = 0; i < count; ) {
       map[keyElementPairs[i++]] = keyElementPairs[i++];
     }
     return new DartObjectImpl(_typeProvider.mapType, new MapState(map));
   }
 
   DartObjectImpl _nullValue() {
@@ skipping 95 matching lines @@
     variables.define(variableName, "true");
     DartObject object = variables.getBool(typeProvider, variableName);
     expect(object, isNotNull);
     expect(object.boolValue, true);
   }
 
   void test_getBool_undefined() {
     TestTypeProvider typeProvider = new TestTypeProvider();
     String variableName = "var";
     DeclaredVariables variables = new DeclaredVariables();
-    _assertUnknownDartObject(typeProvider.boolType,
+    _assertUnknownDartObject(
+        typeProvider.boolType,
         variables.getBool(typeProvider, variableName));
   }
 
   void test_getInt_invalid() {
     TestTypeProvider typeProvider = new TestTypeProvider();
     String variableName = "var";
     DeclaredVariables variables = new DeclaredVariables();
     variables.define(variableName, "four score and seven years");
     _assertNullDartObject(
         typeProvider,
         variables.getInt(typeProvider, variableName));
   }
 
   void test_getInt_undefined() {
     TestTypeProvider typeProvider = new TestTypeProvider();
     String variableName = "var";
     DeclaredVariables variables = new DeclaredVariables();
-    _assertUnknownDartObject(typeProvider.intType,
+    _assertUnknownDartObject(
+        typeProvider.intType,
         variables.getInt(typeProvider, variableName));
   }
 
   void test_getInt_valid() {
     TestTypeProvider typeProvider = new TestTypeProvider();
     String variableName = "var";
     DeclaredVariables variables = new DeclaredVariables();
     variables.define(variableName, "23");
     DartObject object = variables.getInt(typeProvider, variableName);
     expect(object, isNotNull);
     expect(object.intValue, 23);
   }
 
   void test_getString_defined() {
     TestTypeProvider typeProvider = new TestTypeProvider();
     String variableName = "var";
     String value = "value";
     DeclaredVariables variables = new DeclaredVariables();
     variables.define(variableName, value);
     DartObject object = variables.getString(typeProvider, variableName);
     expect(object, isNotNull);
     expect(object.stringValue, value);
   }
 
   void test_getString_undefined() {
     TestTypeProvider typeProvider = new TestTypeProvider();
     String variableName = "var";
     DeclaredVariables variables = new DeclaredVariables();
-    _assertUnknownDartObject(typeProvider.stringType,
+    _assertUnknownDartObject(
+        typeProvider.stringType,
         variables.getString(typeProvider, variableName));
   }
 
   void _assertNullDartObject(TestTypeProvider typeProvider, DartObject result) {
     expect(result.type, typeProvider.nullType);
   }
 
   void _assertUnknownDartObject(ParameterizedType expectedType,
-                                DartObject result) {
+      DartObject result) {
     expect((result as DartObjectImpl).isUnknown, isTrue);
     expect(result.type, expectedType);
   }
 }
 
 
 class DirectoryBasedDartSdkTest {
   void fail_getDocFileFor() {
     DirectoryBasedDartSdk sdk = _createDartSdk();
     JavaFile docFile = sdk.getDocFileFor("html");
     expect(docFile, isNotNull);
   }
 
   void test_creation() {
     DirectoryBasedDartSdk sdk = _createDartSdk();
     expect(sdk, isNotNull);
   }
 
   void test_fromFile_invalid() {
     DirectoryBasedDartSdk sdk = _createDartSdk();
-    expect(sdk.fromFileUri(new JavaFile("/not/in/the/sdk.dart").toURI()), isNull);
+    expect(
+        sdk.fromFileUri(new JavaFile("/not/in/the/sdk.dart").toURI()),
+        isNull);
   }
 
   void test_fromFile_library() {
     DirectoryBasedDartSdk sdk = _createDartSdk();
     Source source = sdk.fromFileUri(
         new JavaFile.relative(
             new JavaFile.relative(sdk.libraryDirectory, "core"),
             "core.dart").toURI());
     expect(source, isNotNull);
     expect(source.isInSystemLibrary, isTrue);
@@ skipping 65 matching lines @@
   void test_getVmExecutable() {
     DirectoryBasedDartSdk sdk = _createDartSdk();
     JavaFile executable = sdk.vmExecutable;
     expect(executable, isNotNull);
     expect(executable.exists(), isTrue);
     expect(executable.isExecutable(), isTrue);
   }
 
   DirectoryBasedDartSdk _createDartSdk() {
     JavaFile sdkDirectory = DirectoryBasedDartSdk.defaultSdkDirectory;
-    expect(sdkDirectory, isNotNull, reason: "No SDK configured; set the property 'com.google.dart.sdk' on the command line");
+    expect(
+        sdkDirectory,
+        isNotNull,
+        reason:
+            "No SDK configured; set the property 'com.google.dart.sdk' on the command line");
     return new DirectoryBasedDartSdk(sdkDirectory);
   }
 }
 
 
 class DirectoryBasedSourceContainerTest {
   void test_contains() {
     JavaFile dir = FileUtilities2.createFile("/does/not/exist");
     JavaFile file1 = FileUtilities2.createFile("/does/not/exist/some.dart");
     JavaFile file2 =
@@ skipping 165 matching lines @@
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     ClassElementImpl classB = ElementFactory.classElement2('B', []);
     ConstructorElementImpl constructorB =
         ElementFactory.constructorElement2(classB, '', []);
     constructorB.setModifier(Modifier.SYNTHETIC, true);
     classB.constructors = [constructorB];
     ClassElement classM = ElementFactory.classElement2('M', []);
     WithClause withClause =
         AstFactory.withClause([AstFactory.typeName(classM, [])]);
-    ClassTypeAlias alias = AstFactory.classTypeAlias('C', null, null,
-        AstFactory.typeName(classB, []), withClause, null);
+    ClassTypeAlias alias = AstFactory.classTypeAlias(
+        'C',
+        null,
+        null,
+        AstFactory.typeName(classB, []),
+        withClause,
+        null);
     alias.accept(builder);
     List<ClassElement> types = holder.types;
     expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(alias.element, same(type));
     expect(type.name, equals('C'));
     expect(type.isAbstract, isFalse);
     expect(type.isSynthetic, isFalse);
     expect(type.typeParameters, isEmpty);
     expect(type.fields, isEmpty);
     expect(type.methods, isEmpty);
   }
 
   void test_visitClassTypeAlias_abstract() {
     // class B {}
     // class M {}
     // abstract class C = B with M
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     ClassElementImpl classB = ElementFactory.classElement2('B', []);
     ConstructorElementImpl constructorB =
         ElementFactory.constructorElement2(classB, '', []);
     constructorB.setModifier(Modifier.SYNTHETIC, true);
     classB.constructors = [constructorB];
     ClassElement classM = ElementFactory.classElement2('M', []);
     WithClause withClause =
         AstFactory.withClause([AstFactory.typeName(classM, [])]);
-    ClassTypeAlias classCAst = AstFactory.classTypeAlias('C', null,
-        Keyword.ABSTRACT, AstFactory.typeName(classB, []), withClause, null);
+    ClassTypeAlias classCAst = AstFactory.classTypeAlias(
+        'C',
+        null,
+        Keyword.ABSTRACT,
+        AstFactory.typeName(classB, []),
+        withClause,
+        null);
     classCAst.accept(builder);
     List<ClassElement> types = holder.types;
     expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type.isAbstract, isTrue);
   }
 
   void test_visitClassTypeAlias_typeParams() {
     // class B {}
     // class M {}
     // class C<T> = B with M
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     ClassElementImpl classB = ElementFactory.classElement2('B', []);
     ConstructorElementImpl constructorB =
         ElementFactory.constructorElement2(classB, '', []);
     constructorB.setModifier(Modifier.SYNTHETIC, true);
     classB.constructors = [constructorB];
     ClassElementImpl classM = ElementFactory.classElement2('M', []);
     WithClause withClause =
         AstFactory.withClause([AstFactory.typeName(classM, [])]);
-    ClassTypeAlias classCAst = AstFactory.classTypeAlias('C',
-        AstFactory.typeParameterList(['T']), null,
-        AstFactory.typeName(classB, []), withClause, null);
+    ClassTypeAlias classCAst = AstFactory.classTypeAlias(
+        'C',
+        AstFactory.typeParameterList(['T']),
+        null,
+        AstFactory.typeName(classB, []),
+        withClause,
+        null);
     classCAst.accept(builder);
     List<ClassElement> types = holder.types;
     expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type.typeParameters, hasLength(1));
     expect(type.typeParameters[0].name, equals('T'));
   }
 
   void test_visitConstructorDeclaration_factory() {
     ElementHolder holder = new ElementHolder();
@@ skipping 684 matching lines @@
     String labelName = "l";
     String exceptionParameterName = "e";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
         AstFactory.identifier3(methodName),
         AstFactory.formalParameterList(
             [AstFactory.simpleFormalParameter3(parameterName)]),
-        AstFactory.blockFunctionBody2([
-            AstFactory.variableDeclarationStatement2(
-                Keyword.VAR,
-                [AstFactory.variableDeclaration(localVariableName)]),
-            AstFactory.tryStatement2(
-                AstFactory.block([AstFactory.labeledStatement(
-                    [AstFactory.label2(labelName)],
-                    AstFactory.returnStatement())]),
-                [AstFactory.catchClause(exceptionParameterName)])]));
+        AstFactory.blockFunctionBody2(
+            [
+                AstFactory.variableDeclarationStatement2(
+                    Keyword.VAR,
+                    [AstFactory.variableDeclaration(localVariableName)]),
+                AstFactory.tryStatement2(
+                    AstFactory.block(
+                        [
+                            AstFactory.labeledStatement(
+                                [AstFactory.label2(labelName)],
+                                AstFactory.returnStatement())]),
+                    [AstFactory.catchClause(exceptionParameterName)])]));
     methodDeclaration.accept(builder);
     List<MethodElement> methods = holder.methods;
     expect(methods, hasLength(1));
     MethodElement method = methods[0];
     expect(method, isNotNull);
     expect(method.name, methodName);
     expect(method.isAbstract, isFalse);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
     List<VariableElement> parameters = method.parameters;
     expect(parameters, hasLength(1));
     VariableElement parameter = parameters[0];
     expect(parameter, isNotNull);
     expect(parameter.name, parameterName);
     List<VariableElement> localVariables = method.localVariables;
     expect(localVariables, hasLength(2));
     VariableElement firstVariable = localVariables[0];
     VariableElement secondVariable = localVariables[1];
     expect(firstVariable, isNotNull);
     expect(secondVariable, isNotNull);
-    expect((firstVariable.name == localVariableName &&
+    expect(
+        (firstVariable.name == localVariableName &&
             secondVariable.name == exceptionParameterName) ||
             (firstVariable.name == exceptionParameterName &&
-                secondVariable.name == localVariableName), isTrue);
+                secondVariable.name == localVariableName),
+        isTrue);
     List<LabelElement> labels = method.labels;
     expect(labels, hasLength(1));
     LabelElement label = labels[0];
     expect(label, isNotNull);
     expect(label.name, labelName);
   }
 
   void test_visitNamedFormalParameter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
@@ skipping 298 matching lines @@
     fail("Test this case");
   }
 
   @override
   void reset() {
     AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
     analysisOptions.hint = false;
     resetWithOptions(analysisOptions);
   }
 
-  void test_locateWithOffset_BinaryExpression() {
-    AstNode id = _findNodeIn("+", "var x = 3 + 4;");
-    Element element = ElementLocator.locateWithOffset(id, 0);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodElement,
-        MethodElement,
-        element);
-  }
-
-  void test_locateWithOffset_StringLiteral() {
-    AstNode id = _findNodeIn("abc", "var x = 'abc';");
-    Element element = ElementLocator.locateWithOffset(id, 1);
-    expect(element, isNull);
-  }
-
   void test_locate_AssignmentExpression() {
-    AstNode id =
-        _findNodeIn("+=", r'''
+    AstNode id = _findNodeIn("+=", r'''
 int x = 0;
 void main() {
   x += 1;
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement,
         MethodElement,
         element);
   }
@@ skipping 17 matching lines @@
   }
 
   void test_locate_CompilationUnit() {
     CompilationUnit cu = _resolveContents("// only comment");
     expect(cu.element, isNotNull);
     Element element = ElementLocator.locate(cu);
     expect(element, same(cu.element));
   }
 
   void test_locate_ConstructorDeclaration() {
-    AstNode id =
-        _findNodeIndexedIn("bar", 0, r'''
+    AstNode id = _findNodeIndexedIn("bar", 0, r'''
 class A {
   A.bar() {}
 }''');
     ConstructorDeclaration declaration =
         id.getAncestor((node) => node is ConstructorDeclaration);
     Element element = ElementLocator.locate(declaration);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement,
         ConstructorElement,
         element);
   }
 
   void test_locate_FunctionDeclaration() {
     AstNode id = _findNodeIn("f", "int f() => 3;");
     FunctionDeclaration declaration =
         id.getAncestor((node) => node is FunctionDeclaration);
     Element element = ElementLocator.locate(declaration);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionElement,
         FunctionElement,
         element);
   }
 
   void
       test_locate_Identifier_annotationClass_namedConstructor_forSimpleFormalParameter() {
-    AstNode id = _findNodeIndexedIn(
-        "Class",
-        2,
-        r'''
+    AstNode id = _findNodeIndexedIn("Class", 2, r'''
 class Class {
   const Class.name();
 }
 void main(@Class.name() parameter) {
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassElement,
         ClassElement,
         element);
   }
 
   void
       test_locate_Identifier_annotationClass_unnamedConstructor_forSimpleFormalParameter() {
-    AstNode id = _findNodeIndexedIn(
-        "Class",
-        2,
-        r'''
+    AstNode id = _findNodeIndexedIn("Class", 2, r'''
 class Class {
   const Class();
 }
 void main(@Class() parameter) {
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement,
         ConstructorElement,
         element);
   }
 
   void test_locate_Identifier_className() {
     AstNode id = _findNodeIn("A", "class A { }");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassElement,
         ClassElement,
         element);
   }
 
   void test_locate_Identifier_constructor_named() {
-    AstNode id =
-        _findNodeIndexedIn("bar", 0, r'''
+    AstNode id = _findNodeIndexedIn("bar", 0, r'''
 class A {
   A.bar() {}
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement,
         ConstructorElement,
         element);
   }
 
@@ skipping 12 matching lines @@
   void test_locate_Identifier_fieldName() {
     AstNode id = _findNodeIn("x", "class A { var x; }");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FieldElement,
         FieldElement,
         element);
   }
 
   void test_locate_Identifier_propertAccess() {
-    AstNode id =
-        _findNodeIn("length", r'''
+    AstNode id = _findNodeIn("length", r'''
 void main() {
  int x = 'foo'.length;
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is PropertyAccessorElement,
         PropertyAccessorElement,
         element);
   }
 
   void test_locate_ImportDirective() {
     AstNode id = _findNodeIn("import", "import 'dart:core';");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ImportElement,
         ImportElement,
         element);
   }
 
   void test_locate_IndexExpression() {
-    AstNode id = _findNodeIndexedIn(
-        "\\[",
-        1,
-        r'''
+    AstNode id = _findNodeIndexedIn("\\[", 1, r'''
 void main() {
   List x = [1, 2];
   var y = x[0];
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement,
         MethodElement,
         element);
   }
 
   void test_locate_InstanceCreationExpression() {
-    AstNode node =
-        _findNodeIndexedIn("A(", 0, r'''
+    AstNode node = _findNodeIndexedIn("A(", 0, r'''
 class A {}
 void main() {
  new A();
 }''');
     Element element = ElementLocator.locate(node);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement,
         ConstructorElement,
         element);
   }
@@ skipping 55 matching lines @@
     MethodDeclaration declaration =
         id.getAncestor((node) => node is MethodDeclaration);
     Element element = ElementLocator.locate(declaration);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement,
         MethodElement,
         element);
   }
 
   void test_locate_MethodInvocation_method() {
-    AstNode id = _findNodeIndexedIn(
-        "bar",
-        1,
-        r'''
+    AstNode id = _findNodeIndexedIn("bar", 1, r'''
 class A {
   int bar() => 42;
 }
 void main() {
  var f = new A().bar();
 }''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement,
         MethodElement,
         element);
   }
 
   void test_locate_MethodInvocation_topLevel() {
-    String code =
-        r'''
+    String code = r'''
 foo(x) {}
 void main() {
  foo(0);
 }''';
     CompilationUnit cu = _resolveContents(code);
     int offset = code.indexOf('foo(0)');
     AstNode node = new NodeLocator.con1(offset).searchWithin(cu);
     MethodInvocation invocation =
         node.getAncestor((n) => n is MethodInvocation);
     Element element = ElementLocator.locate(invocation);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionElement,
         FunctionElement,
         element);
   }
 
   void test_locate_PostfixExpression() {
     AstNode id = _findNodeIn("++", "int addOne(int x) => x++;");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement,
         MethodElement,
         element);
   }
 
-  void test_locate_PrefixExpression() {
-    AstNode id = _findNodeIn("++", "int addOne(int x) => ++x;");
-    Element element = ElementLocator.locate(id);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodElement,
-        MethodElement,
-        element);
-  }
-
   void test_locate_PrefixedIdentifier() {
-    AstNode id =
-        _findNodeIn("int", r'''
+    AstNode id = _findNodeIn("int", r'''
 import 'dart:core' as core;
 core.int value;''');
     PrefixedIdentifier identifier =
         id.getAncestor((node) => node is PrefixedIdentifier);
     Element element = ElementLocator.locate(identifier);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassElement,
         ClassElement,
         element);
   }
 
+  void test_locate_PrefixExpression() {
+    AstNode id = _findNodeIn("++", "int addOne(int x) => ++x;");
+    Element element = ElementLocator.locate(id);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is MethodElement,
+        MethodElement,
+        element);
+  }
+
   void test_locate_StringLiteral_exportUri() {
     addNamedSource("/foo.dart", "library foo;");
     AstNode id = _findNodeIn("'foo.dart'", "export 'foo.dart';");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is LibraryElement,
         LibraryElement,
         element);
   }
 
@@ skipping 28 matching lines @@
     AstNode id = _findNodeIn("x", "var x = 'abc';");
     VariableDeclaration declaration =
         id.getAncestor((node) => node is VariableDeclaration);
     Element element = ElementLocator.locate(declaration);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is TopLevelVariableElement,
         TopLevelVariableElement,
         element);
   }
 
+  void test_locateWithOffset_BinaryExpression() {
+    AstNode id = _findNodeIn("+", "var x = 3 + 4;");
+    Element element = ElementLocator.locateWithOffset(id, 0);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is MethodElement,
+        MethodElement,
+        element);
+  }
+
+  void test_locateWithOffset_StringLiteral() {
+    AstNode id = _findNodeIn("abc", "var x = 'abc';");
+    Element element = ElementLocator.locateWithOffset(id, 1);
+    expect(element, isNull);
+  }
+
   /**
    * Find the first AST node matching a pattern in the resolved AST for the given source.
    *
    * [nodePattern] the (unique) pattern used to identify the node of interest.
    * [code] the code to resolve.
    * Returns the matched node in the resolved AST for the given source lines.
    */
   AstNode _findNodeIn(String nodePattern, String code) {
     return _findNodeIndexedIn(nodePattern, 0, code);
   }
 
   /**
    * Find the AST node matching the given indexed occurrence of a pattern in the resolved AST for
    * the given source.
    *
    * [nodePattern] the pattern used to identify the node of interest.
    * [index] the index of the pattern match of interest.
    * [code] the code to resolve.
    * Returns the matched node in the resolved AST for the given source lines
    */
-  AstNode _findNodeIndexedIn(String nodePattern, int index,
-                             String code) {
+  AstNode _findNodeIndexedIn(String nodePattern, int index, String code) {
     CompilationUnit cu = _resolveContents(code);
     int start = _getOffsetOfMatch(code, nodePattern, index);
     int end = start + nodePattern.length;
     return new NodeLocator.con2(start, end).searchWithin(cu);
   }
 
   int _getOffsetOfMatch(String contents, String pattern, int matchIndex) {
     if (matchIndex == 0) {
       return contents.indexOf(pattern);
     }
@@ skipping 159 matching lines @@
         AstFactory.identifier3("x"),
         [firstType, secondType]);
     AnalysisError error = listener.errors[0];
     expect(error.message.indexOf("(") >= 0, isTrue);
   }
 }
 
 
 class ErrorSeverityTest extends EngineTestCase {
   void test_max_error_error() {
-    expect(ErrorSeverity.ERROR.max(ErrorSeverity.ERROR), same(ErrorSeverity.ERROR));
+    expect(
+        ErrorSeverity.ERROR.max(ErrorSeverity.ERROR),
+        same(ErrorSeverity.ERROR));
   }
 
   void test_max_error_none() {
-    expect(ErrorSeverity.ERROR.max(ErrorSeverity.NONE), same(ErrorSeverity.ERROR));
+    expect(
+        ErrorSeverity.ERROR.max(ErrorSeverity.NONE),
+        same(ErrorSeverity.ERROR));
   }
 
   void test_max_error_warning() {
-    expect(ErrorSeverity.ERROR.max(ErrorSeverity.WARNING), same(ErrorSeverity.ERROR));
+    expect(
+        ErrorSeverity.ERROR.max(ErrorSeverity.WARNING),
+        same(ErrorSeverity.ERROR));
   }
 
   void test_max_none_error() {
-    expect(ErrorSeverity.NONE.max(ErrorSeverity.ERROR), same(ErrorSeverity.ERROR));
+    expect(
+        ErrorSeverity.NONE.max(ErrorSeverity.ERROR),
+        same(ErrorSeverity.ERROR));
   }
 
   void test_max_none_none() {
-    expect(ErrorSeverity.NONE.max(ErrorSeverity.NONE), same(ErrorSeverity.NONE));
+    expect(
+        ErrorSeverity.NONE.max(ErrorSeverity.NONE),
+        same(ErrorSeverity.NONE));
   }
 
   void test_max_none_warning() {
-    expect(ErrorSeverity.NONE.max(ErrorSeverity.WARNING), same(ErrorSeverity.WARNING));
+    expect(
+        ErrorSeverity.NONE.max(ErrorSeverity.WARNING),
+        same(ErrorSeverity.WARNING));
   }
 
   void test_max_warning_error() {
-    expect(ErrorSeverity.WARNING.max(ErrorSeverity.ERROR), same(ErrorSeverity.ERROR));
+    expect(
+        ErrorSeverity.WARNING.max(ErrorSeverity.ERROR),
+        same(ErrorSeverity.ERROR));
   }
 
   void test_max_warning_none() {
-    expect(ErrorSeverity.WARNING.max(ErrorSeverity.NONE), same(ErrorSeverity.WARNING));
+    expect(
+        ErrorSeverity.WARNING.max(ErrorSeverity.NONE),
+        same(ErrorSeverity.WARNING));
   }
 
   void test_max_warning_warning() {
-    expect(ErrorSeverity.WARNING.max(ErrorSeverity.WARNING), same(ErrorSeverity.WARNING));
+    expect(
+        ErrorSeverity.WARNING.max(ErrorSeverity.WARNING),
+        same(ErrorSeverity.WARNING));
   }
 }
 
 
 class ExitDetectorTest extends ParserTestCase {
   void fail_doStatement_continue_with_label() {
     _assertFalse("{ x: do { continue x; } while(true); }");
   }
 
   void fail_whileStatement_continue_with_label() {
@@ skipping 201 matching lines @@
   }
 
   void test_forStatement_variableDeclaration() {
     _assertTrue("for (int i = throw 0;;) {}");
   }
 
   void test_functionExpression() {
     _assertFalse("(){};");
   }
 
+  void test_functionExpression_bodyThrows() {
+    _assertFalse("(int i) => throw '';");
+  }
+
   void test_functionExpressionInvocation() {
     _assertFalse("f(g);");
   }
 
   void test_functionExpressionInvocation_argumentThrows() {
     _assertTrue("f(throw '');");
   }
 
   void test_functionExpressionInvocation_targetThrows() {
     _assertTrue("throw ''(g);");
   }
 
-  void test_functionExpression_bodyThrows() {
-    _assertFalse("(int i) => throw '';");
-  }
-
   void test_identifier_prefixedIdentifier() {
     _assertFalse("a.b;");
   }
 
   void test_identifier_simpleIdentifier() {
     _assertFalse("a;");
   }
 
-  void test_ifElse_bothReturn() {
-    _assertTrue("if (c) return 0; else return 1;");
-  }
-
-  void test_ifElse_elseReturn() {
-    _assertFalse("if (c) i++; else return 1;");
-  }
-
-  void test_ifElse_noReturn() {
-    _assertFalse("if (c) i++; else j++;");
-  }
-
-  void test_ifElse_thenReturn() {
-    _assertFalse("if (c) return 0; else j++;");
-  }
-
   void test_if_false_else_return() {
     _assertTrue("if (false) {} else { return 0; }");
   }
 
   void test_if_false_noReturn() {
     _assertFalse("if (false) {}");
   }
 
   void test_if_false_return() {
     _assertFalse("if (false) { return 0; }");
   }
 
   void test_if_noReturn() {
     _assertFalse("if (c) i++;");
   }
 
   void test_if_return() {
     _assertFalse("if (c) return 0;");
   }
 
   void test_if_true_noReturn() {
     _assertFalse("if (true) {}");
   }
 
   void test_if_true_return() {
     _assertTrue("if (true) { return 0; }");
   }
 
+  void test_ifElse_bothReturn() {
+    _assertTrue("if (c) return 0; else return 1;");
+  }
+
+  void test_ifElse_elseReturn() {
+    _assertFalse("if (c) i++; else return 1;");
+  }
+
+  void test_ifElse_noReturn() {
+    _assertFalse("if (c) i++; else j++;");
+  }
+
+  void test_ifElse_thenReturn() {
+    _assertFalse("if (c) return 0; else j++;");
+  }
+
   void test_indexExpression() {
     _assertFalse("a[b];");
   }
 
   void test_indexExpression_index() {
     _assertTrue("a[throw ''];");
   }
 
   void test_indexExpression_target() {
     _assertTrue("throw ''[b];");
@@ skipping 16 matching lines @@
   }
 
   void test_labeledStatement() {
     _assertFalse("label: a;");
   }
 
   void test_labeledStatement_throws() {
     _assertTrue("label: throw '';");
   }
 
-  void test_literal_String() {
-    _assertFalse("'str';");
-  }
-
   void test_literal_boolean() {
     _assertFalse("true;");
   }
 
   void test_literal_double() {
     _assertFalse("1.1;");
   }
 
   void test_literal_integer() {
     _assertFalse("1;");
   }
 
   void test_literal_null() {
     _assertFalse("null;");
   }
 
+  void test_literal_String() {
+    _assertFalse("'str';");
+  }
+
   void test_methodInvocation() {
     _assertFalse("a.b(c);");
   }
 
   void test_methodInvocation_argument() {
     _assertTrue("a.b(throw '');");
   }
 
   void test_methodInvocation_target() {
     _assertTrue("throw ''.b(c);");
@@ skipping 366 matching lines @@
 class FileUriResolverTest {
   void test_creation() {
     expect(new FileUriResolver(), isNotNull);
   }
 
   void test_resolve_file() {
     UriResolver resolver = new FileUriResolver();
     Source result =
         resolver.resolveAbsolute(parseUriWithException("file:/does/not/exist.dart"));
     expect(result, isNotNull);
-    expect(result.fullName, FileUtilities2.createFile("/does/not/exist.dart").getAbsolutePath());
+    expect(
+        result.fullName,
+        FileUtilities2.createFile("/does/not/exist.dart").getAbsolutePath());
   }
 
   void test_resolve_nonFile() {
     UriResolver resolver = new FileUriResolver();
     Source result =
         resolver.resolveAbsolute(parseUriWithException("dart:core"));
     expect(result, isNull);
   }
 }
 
@@ skipping 17 matching lines @@
 $scriptBody
     </script>
   </body>
 </html>""");
     _validate(
         htmlUnit,
         [
             _t4(
                 "html",
                 [
-                    _t4(
-                        "body",
-                        [_t("script", _a(["type", "'application/dart'"]), scriptBody)])])]);
+                    _t4("body", [_t("script", _a(["type", "'application/dart'"]), scriptBody)])])]);
   }
   ht.HtmlUnit parse(String contents) {
 //    TestSource source =
 //        new TestSource.con1(FileUtilities2.createFile("/test.dart"), contents);
     ht.AbstractScanner scanner = new ht.StringScanner(null, contents);
     scanner.passThroughElements = <String>[_TAG_SCRIPT];
     ht.Token token = scanner.tokenize();
     LineInfo lineInfo = new LineInfo(scanner.lineStarts);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ht.HtmlUnit unit =
@@ skipping 118 matching lines @@
     ht.HtmlUnit htmlUnit = parse("<html>foo<br>bar</html>");
     _validate(htmlUnit, [_t3("html", "foo<br>bar", [_t3("br", "")])]);
   }
   void test_parse_self_closing_declaration() {
     ht.HtmlUnit htmlUnit = parse("<!DOCTYPE html><html>foo</html>");
     _validate(htmlUnit, [_t3("html", "foo")]);
   }
   XmlValidator_Attributes _a(List<String> keyValuePairs) =>
       new XmlValidator_Attributes(keyValuePairs);
   XmlValidator_Tag _t(String tag, XmlValidator_Attributes attributes,
-      String content, [List<XmlValidator_Tag> children = XmlValidator_Tag.EMPTY_LIST]) =>
+      String content, [List<XmlValidator_Tag> children =
+      XmlValidator_Tag.EMPTY_LIST]) =>
       new XmlValidator_Tag(tag, attributes, content, children);
   XmlValidator_Tag _t3(String tag, String content,
       [List<XmlValidator_Tag> children = XmlValidator_Tag.EMPTY_LIST]) =>
       new XmlValidator_Tag(tag, new XmlValidator_Attributes(), content, children);
-  XmlValidator_Tag _t4(String tag, [List<XmlValidator_Tag> children = XmlValidator_Tag.EMPTY_LIST]) =>
+  XmlValidator_Tag _t4(String tag, [List<XmlValidator_Tag> children =
+      XmlValidator_Tag.EMPTY_LIST]) =>
       new XmlValidator_Tag(tag, new XmlValidator_Attributes(), null, children);
   void _validate(ht.HtmlUnit htmlUnit, List<XmlValidator_Tag> expectedTags) {
     XmlValidator validator = new XmlValidator();
     validator.expectTags(expectedTags);
     htmlUnit.accept(validator);
     validator.assertValid();
   }
 }
 
 
@@ skipping 85 matching lines @@
     TestSource source = new TestSource(
         FileUtilities2.createFile("/test.html").getAbsolutePath(),
         contents);
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(source);
     _context.applyChanges(changeSet);
     HtmlUnitBuilder builder = new HtmlUnitBuilder(_context);
     return builder.buildHtmlElement(source, _context.parseHtmlUnit(source));
   }
   HtmlUnitBuilderTest_ExpectedLibrary
-      _l([List<HtmlUnitBuilderTest_ExpectedVariable> expectedVariables = HtmlUnitBuilderTest_ExpectedVariable.EMPTY_LIST]) =>
+      _l([List<HtmlUnitBuilderTest_ExpectedVariable> expectedVariables =
+      HtmlUnitBuilderTest_ExpectedVariable.EMPTY_LIST]) =>
       new HtmlUnitBuilderTest_ExpectedLibrary(this, expectedVariables);
   _ExpectedScript _s(HtmlUnitBuilderTest_ExpectedLibrary expectedLibrary) =>
       new _ExpectedScript.con1(expectedLibrary);
   _ExpectedScript _s2(String scriptSourcePath) =>
       new _ExpectedScript.con2(scriptSourcePath);
   HtmlUnitBuilderTest_ExpectedVariable _v(String varName) =>
       new HtmlUnitBuilderTest_ExpectedVariable(varName);
   void _validate(HtmlElementImpl element,
       List<_ExpectedScript> expectedScripts) {
     expect(element.context, same(_context));
     List<HtmlScriptElement> scripts = element.scripts;
     expect(scripts, isNotNull);
     expect(scripts, hasLength(expectedScripts.length));
     for (int scriptIndex = 0; scriptIndex < scripts.length; scriptIndex++) {
       expectedScripts[scriptIndex]._validate(scriptIndex, scripts[scriptIndex]);
     }
   }
 }
 
 
 class HtmlUnitBuilderTest_ExpectedLibrary {
   final HtmlUnitBuilderTest HtmlUnitBuilderTest_this;
   final List<HtmlUnitBuilderTest_ExpectedVariable> _expectedVariables;
   HtmlUnitBuilderTest_ExpectedLibrary(this.HtmlUnitBuilderTest_this,
       [this._expectedVariables = HtmlUnitBuilderTest_ExpectedVariable.EMPTY_LIST]);
   void _validate(int scriptIndex, EmbeddedHtmlScriptElementImpl script) {
     LibraryElement library = script.scriptLibrary;
     expect(library, isNotNull, reason: "script $scriptIndex");
-    expect(script.context, same(HtmlUnitBuilderTest_this._context), reason: "script $scriptIndex");
+    expect(
+        script.context,
+        same(HtmlUnitBuilderTest_this._context),
+        reason: "script $scriptIndex");
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull, reason: "script $scriptIndex");
     List<TopLevelVariableElement> variables = unit.topLevelVariables;
     expect(variables, hasLength(_expectedVariables.length));
     for (int index = 0; index < variables.length; index++) {
       _expectedVariables[index].validate(scriptIndex, variables[index]);
     }
-    expect(library.enclosingElement, same(script), reason: "script $scriptIndex");
+    expect(
+        library.enclosingElement,
+        same(script),
+        reason: "script $scriptIndex");
   }
 }
 
 
 class HtmlUnitBuilderTest_ExpectedVariable {
+  static const List<HtmlUnitBuilderTest_ExpectedVariable> EMPTY_LIST = const
+      <HtmlUnitBuilderTest_ExpectedVariable>[
+      ];
   final String _expectedName;
-  static const List<HtmlUnitBuilderTest_ExpectedVariable> EMPTY_LIST
-      = const <HtmlUnitBuilderTest_ExpectedVariable>[];
   HtmlUnitBuilderTest_ExpectedVariable(this._expectedName);
   void validate(int scriptIndex, TopLevelVariableElement variable) {
     expect(variable, isNotNull, reason: "script $scriptIndex");
     expect(variable.name, _expectedName, reason: "script $scriptIndex");
   }
 }
 
 
 /**
  * Instances of the class `HtmlWarningCodeTest` test the generation of HTML warning codes.
@@ skipping 31 matching lines @@
     _context = null;
     _contents = null;
     _errors = null;
     super.tearDown();
   }
 
   void test_invalidUri() {
     _verify(r'''
 <html>
 <script type='application/dart' src='ht:'/>
-</html>''',
-        [HtmlWarningCode.INVALID_URI]);
+</html>''', [HtmlWarningCode.INVALID_URI]);
     _assertErrorLocation2(_errors[0], "ht:");
   }
 
   void test_uriDoesNotExist() {
     _verify(r'''
 <html>
 <script type='application/dart' src='other.dart'/>
-</html>''',
-        [HtmlWarningCode.URI_DOES_NOT_EXIST]);
+</html>''', [HtmlWarningCode.URI_DOES_NOT_EXIST]);
     _assertErrorLocation2(_errors[0], "other.dart");
   }
 
   void _assertErrorLocation(AnalysisError error, int expectedOffset,
       int expectedLength) {
     expect(error.offset, expectedOffset, reason: error.toString());
     expect(error.length, expectedLength, reason: error.toString());
   }
 
   void _assertErrorLocation2(AnalysisError error, String expectedString) {
@@ skipping 206 matching lines @@
   }
   void _visitNode(AstNode node) {
     node.accept(_createReferenceFinder(_head));
   }
 }
 
 
 class SDKLibrariesReaderTest extends EngineTestCase {
   void test_readFrom_dart2js() {
     LibraryMap libraryMap = new SdkLibrariesReader(
-        true).readFromFile(
-            FileUtilities2.createFile("/libs.dart"),
-            r'''
+        true).readFromFile(FileUtilities2.createFile("/libs.dart"), r'''
 final Map<String, LibraryInfo> LIBRARIES = const <String, LibraryInfo> {
   'first' : const LibraryInfo(
     'first/first.dart',
     category: 'First',
     documented: true,
     platforms: VM_PLATFORM,
     dart2jsPath: 'first/first_dart2js.dart'),
 };''');
     expect(libraryMap, isNotNull);
     expect(libraryMap.size(), 1);
     SdkLibrary first = libraryMap.getLibrary("dart:first");
     expect(first, isNotNull);
     expect(first.category, "First");
     expect(first.path, "first/first_dart2js.dart");
     expect(first.shortName, "dart:first");
     expect(first.isDart2JsLibrary, false);
     expect(first.isDocumented, true);
     expect(first.isImplementation, false);
     expect(first.isVmLibrary, true);
   }
   void test_readFrom_empty() {
     LibraryMap libraryMap = new SdkLibrariesReader(
         false).readFromFile(FileUtilities2.createFile("/libs.dart"), "");
     expect(libraryMap, isNotNull);
     expect(libraryMap.size(), 0);
   }
   void test_readFrom_normal() {
     LibraryMap libraryMap = new SdkLibrariesReader(
-        false).readFromFile(
-            FileUtilities2.createFile("/libs.dart"),
-            r'''
+        false).readFromFile(FileUtilities2.createFile("/libs.dart"), r'''
 final Map<String, LibraryInfo> LIBRARIES = const <String, LibraryInfo> {
   'first' : const LibraryInfo(
     'first/first.dart',
     category: 'First',
     documented: true,
     platforms: VM_PLATFORM),
 
   'second' : const LibraryInfo(
     'second/second.dart',
     category: 'Second',
@@ skipping 46 matching lines @@
     }
   }
   void test_fromEncoding_valid() {
     String encoding = "file:///does/not/exist.dart";
     SourceFactory factory = new SourceFactory(
         [new UriResolver_SourceFactoryTest_test_fromEncoding_valid(encoding)]);
     expect(factory.fromEncoding(encoding), isNotNull);
   }
   void test_resolveUri_absolute() {
     UriResolver_absolute resolver = new UriResolver_absolute();
-    SourceFactory factory =
-        new SourceFactory([resolver]);
+    SourceFactory factory = new SourceFactory([resolver]);
     factory.resolveUri(null, "dart:core");
     expect(resolver.invoked, isTrue);
   }
   void test_resolveUri_nonAbsolute_absolute() {
     SourceFactory factory =
         new SourceFactory([new UriResolver_nonAbsolute_absolute()]);
     String absolutePath = "/does/not/matter.dart";
     Source containingSource =
         new FileBasedSource.con1(FileUtilities2.createFile("/does/not/exist.dart"));
     Source result = factory.resolveUri(containingSource, absolutePath);
-    expect(result.fullName, FileUtilities2.createFile(absolutePath).getAbsolutePath());
+    expect(
+        result.fullName,
+        FileUtilities2.createFile(absolutePath).getAbsolutePath());
   }
   void test_resolveUri_nonAbsolute_relative() {
     SourceFactory factory =
         new SourceFactory([new UriResolver_nonAbsolute_relative()]);
     Source containingSource =
         new FileBasedSource.con1(FileUtilities2.createFile("/does/not/have.dart"));
     Source result = factory.resolveUri(containingSource, "exist.dart");
-    expect(result.fullName, FileUtilities2.createFile("/does/not/exist.dart").getAbsolutePath());
+    expect(
+        result.fullName,
+        FileUtilities2.createFile("/does/not/exist.dart").getAbsolutePath());
   }
   void test_restoreUri() {
     JavaFile file1 = FileUtilities2.createFile("/some/file1.dart");
     JavaFile file2 = FileUtilities2.createFile("/some/file2.dart");
     Source source1 = new FileBasedSource.con1(file1);
     Source source2 = new FileBasedSource.con1(file2);
     Uri expected1 = parseUriWithException("file:///my_file.dart");
     SourceFactory factory =
         new SourceFactory([new UriResolver_restoreUri(source1, expected1)]);
     expect(factory.restoreUri(source1), same(expected1));
@@ skipping 76 matching lines @@
   }
 
   void test_getEncoding() {
     expect(UriKind.DART_URI.encoding, 0x64);
     expect(UriKind.FILE_URI.encoding, 0x66);
     expect(UriKind.PACKAGE_URI.encoding, 0x70);
   }
 }
 
 
-class UriResolver_SourceFactoryTest_test_fromEncoding_valid extends UriResolver
-    {
-  String encoding;
-
-  UriResolver_SourceFactoryTest_test_fromEncoding_valid(this.encoding);
-
-  @override
-  Source resolveAbsolute(Uri uri) {
-    if (uri.toString() == encoding) {
-      return new TestSource();
-    }
-    return null;
-  }
-}
-
-
 class UriResolver_absolute extends UriResolver {
   bool invoked = false;
 
   UriResolver_absolute();
 
   @override
   Source resolveAbsolute(Uri uri) {
     invoked = true;
     return null;
   }
@@ skipping 29 matching lines @@
   @override
   Uri restoreAbsolute(Source source) {
     if (identical(source, source1)) {
       return expected1;
     }
     return null;
   }
 }
 
 
+class UriResolver_SourceFactoryTest_test_fromEncoding_valid extends UriResolver
+    {
+  String encoding;
+
+  UriResolver_SourceFactoryTest_test_fromEncoding_valid(this.encoding);
+
+  @override
+  Source resolveAbsolute(Uri uri) {
+    if (uri.toString() == encoding) {
+      return new TestSource();
+    }
+    return null;
+  }
+}
+
+
 class ValidatingConstantValueComputer extends ConstantValueComputer {
   AstNode _nodeBeingEvaluated;
   ValidatingConstantValueComputer(TypeProvider typeProvider,
       DeclaredVariables declaredVariables)
       : super(typeProvider, declaredVariables);
 
   @override
   void beforeComputeValue(AstNode constNode) {
     super.beforeComputeValue(constNode);
     _nodeBeingEvaluated = constNode;
@@ skipping 27 matching lines @@
     }
     expect(parameterIndex < numParameters, isTrue);
     // If we are getting the default parameter for a constructor in the graph,
     // make sure we properly recorded the dependency on the parameter.
     ConstructorDeclaration constructorNode =
         constructorDeclarationMap[constructor];
     if (constructorNode != null) {
       FormalParameter parameterNode =
           constructorNode.parameters.parameters[parameterIndex];
       expect(referenceGraph.nodes.contains(parameterNode), isTrue);
-      expect(referenceGraph.containsPath(_nodeBeingEvaluated, parameterNode), isTrue);
+      expect(
+          referenceGraph.containsPath(_nodeBeingEvaluated, parameterNode),
+          isTrue);
     }
   }
 
   @override
   ConstantVisitor createConstantVisitor(ErrorReporter errorReporter) {
     return new ConstantValueComputerTest_ValidatingConstantVisitor(
         typeProvider,
         referenceGraph,
         _nodeBeingEvaluated,
         errorReporter);
@@ skipping 126 matching lines @@
         _expectedAttributeIndex = 0;
         _expectedTagsIndex++;
         expect(actual.attributeEnd, isNotNull);
         expect(actual.contentEnd, isNotNull);
         int count = 0;
         ht.Token token = actual.attributeEnd.next;
         ht.Token lastToken = actual.contentEnd;
         while (!identical(token, lastToken)) {
           token = token.next;
           if (++count > 1000) {
-            fail("Expected $_expectedTagsIndex tag: ${expected._tag} to have a sequence of tokens from getAttributeEnd() to getContentEnd()");
+            fail(
+                "Expected $_expectedTagsIndex tag: ${expected._tag} to have a sequence of tokens from getAttributeEnd() to getContentEnd()");
             break;
           }
         }
         if (actual.attributeEnd.type == ht.TokenType.GT) {
           if (ht.HtmlParser.SELF_CLOSING.contains(actual.tag)) {
             expect(actual.closingTag, isNull);
           } else {
             expect(actual.closingTag, isNotNull);
           }
         } else if (actual.attributeEnd.type == ht.TokenType.SLASH_GT) {
@@ skipping 68 matching lines @@
 }
 
 
 class XmlValidator_Attributes {
   final List<String> _keyValuePairs;
   XmlValidator_Attributes([this._keyValuePairs = StringUtilities.EMPTY_ARRAY]);
 }
 
 
 class XmlValidator_Tag {
+  static const List<XmlValidator_Tag> EMPTY_LIST = const <XmlValidator_Tag>[];
   final String _tag;
   final XmlValidator_Attributes _attributes;
   final String _content;
   final List<XmlValidator_Tag> _children;
-  static const List<XmlValidator_Tag> EMPTY_LIST = const <XmlValidator_Tag>[];
-  XmlValidator_Tag(this._tag, this._attributes, this._content, [this._children = EMPTY_LIST]);
+  XmlValidator_Tag(this._tag, this._attributes, this._content, [this._children =
+      EMPTY_LIST]);
 }
 
 
 class _AngularTest_findElement extends GeneralizingElementVisitor<Object> {
   final ElementKind kind;
 
   final String name;
 
   Element result;
 
@@ skipping 22 matching lines @@
   }
   void _validate(int scriptIndex, HtmlScriptElement script) {
     if (_expectedLibrary != null) {
       _validateEmbedded(scriptIndex, script);
     } else {
       _validateExternal(scriptIndex, script);
     }
   }
   void _validateEmbedded(int scriptIndex, HtmlScriptElement script) {
     if (script is! EmbeddedHtmlScriptElementImpl) {
-      fail("Expected script $scriptIndex to be embedded, but found ${script != null ? script.runtimeType : "null"}");
+      fail(
+          "Expected script $scriptIndex to be embedded, but found ${script != null ? script.runtimeType : "null"}");
     }
     EmbeddedHtmlScriptElementImpl embeddedScript =
         script as EmbeddedHtmlScriptElementImpl;
     _expectedLibrary._validate(scriptIndex, embeddedScript);
   }
   void _validateExternal(int scriptIndex, HtmlScriptElement script) {
     if (script is! ExternalHtmlScriptElementImpl) {
-      fail("Expected script $scriptIndex to be external with src=$_expectedExternalScriptName but found ${script != null ? script.runtimeType : "null"}");
+      fail(
+          "Expected script $scriptIndex to be external with src=$_expectedExternalScriptName but found ${script != null ? script.runtimeType : "null"}");
     }
     ExternalHtmlScriptElementImpl externalScript =
         script as ExternalHtmlScriptElementImpl;
     Source scriptSource = externalScript.scriptSource;
     if (_expectedExternalScriptName == null) {
       expect(scriptSource, isNull, reason: "script $scriptIndex");
     } else {
       expect(scriptSource, isNotNull, reason: "script $scriptIndex");
       String actualExternalScriptName = scriptSource.shortName;
-      expect(actualExternalScriptName, _expectedExternalScriptName, reason: "script $scriptIndex");
+      expect(
+          actualExternalScriptName,
+          _expectedExternalScriptName,
+          reason: "script $scriptIndex");
     }
   }
 }