New analyzer snapshot.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // 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.resolver;
 
 import 'dart:collection';
@@ skipping 31 matching lines @@
   static String _NAME = "name";
 
   static String _SELECTOR = "selector";
 
   static String _PUBLISH_AS = "publishAs";
 
   static String _TEMPLATE_URL = "templateUrl";
 
   static String _CSS_URL = "cssUrl";
 
-  static String _PREFIX_ATTR = "@";
-
-  static String _PREFIX_CALLBACK = "&";
-
-  static String _PREFIX_ONE_WAY = "=>";
-
-  static String _PREFIX_ONE_WAY_ONE_TIME = "=>!";
-
-  static String _PREFIX_TWO_WAY = "<=>";
-
   static String _NG_ATTR = "NgAttr";
 
   static String _NG_CALLBACK = "NgCallback";
 
   static String _NG_ONE_WAY = "NgOneWay";
 
   static String _NG_ONE_WAY_ONE_TIME = "NgOneWayOneTime";
 
   static String _NG_TWO_WAY = "NgTwoWay";
 
+  /**
+   * Returns the array of all top-level Angular elements that could be used in this library.
+   *
+   * @param libraryElement the [LibraryElement] to analyze
+   * @return the array of all top-level Angular elements that could be used in this library
+   */
+  static List<AngularElement> getAngularElements(LibraryElement libraryElement) {
+    List<AngularElement> angularElements = [];
+    // add Angular elements from current library
+    for (CompilationUnitElement unit in libraryElement.units) {
+      for (ClassElement type in unit.types) {
+        addAngularElements(angularElements, type);
+      }
+    }
+    // handle imports
+    for (ImportElement importElement in libraryElement.imports) {
+      Namespace namespace = new NamespaceBuilder().createImportNamespace(importElement);
+      for (Element importedElement in namespace.definedNames.values) {
+        addAngularElements(angularElements, importedElement);
+      }
+    }
+    // done
+    return new List.from(angularElements);
+  }
+
   static Element getElement(ASTNode node, int offset) {
-    // maybe no node
-    if (node == null) {
+    // maybe node is not SimpleStringLiteral
+    if (node is! SimpleStringLiteral) {
       return null;
     }
     // prepare enclosing ClassDeclaration
     ClassDeclaration classDeclaration = node.getAncestor(ClassDeclaration);
     if (classDeclaration == null) {
       return null;
     }
     // prepare ClassElement
     ClassElement classElement = classDeclaration.element;
     if (classElement == null) {
       return null;
     }
     // check toolkit objects
     for (ToolkitObjectElement toolkitObject in classElement.toolkitObjects) {
       List<AngularPropertyElement> properties = AngularPropertyElement.EMPTY_ARRAY;
+      // maybe name
+      if (toolkitObject is AngularElement) {
+        if (isNameCoveredByLiteral(toolkitObject, node)) {
+          return toolkitObject;
+        }
+      }
       // try properties of AngularComponentElement
       if (toolkitObject is AngularComponentElement) {
         AngularComponentElement component = toolkitObject;
+        // try selector
+        {
+          AngularSelectorElement selector = component.selector;
+          if (isNameCoveredByLiteral(selector, node)) {
+            return selector;
+          }
+        }
+        // try properties
         properties = component.properties;
       }
       // try properties of AngularDirectiveElement
       if (toolkitObject is AngularDirectiveElement) {
         AngularDirectiveElement directive = toolkitObject;
         properties = directive.properties;
       }
       // check properties
       for (AngularPropertyElement property in properties) {
         // property name (use complete node range)
-        int propertyOffset = property.nameOffset;
-        int propertyEnd = propertyOffset + property.name.length;
-        if (node.offset <= propertyOffset && propertyEnd < node.end) {
+        if (isNameCoveredByLiteral(property, node)) {
           return property;
         }
         // field name (use complete node range, including @, => and <=>)
         FieldElement field = property.field;
         if (field != null) {
           int fieldOffset = property.fieldNameOffset;
           int fieldEnd = fieldOffset + field.name.length;
           if (node.offset <= fieldOffset && fieldEnd < node.end) {
             return field;
           }
         }
       }
     }
     // no Element
     return null;
   }
 
   /**
-   * Checks if given [Type] is an Angular <code>Module</code> or its subclass.
-   */
-  static bool isModule(Type2 type) {
-    if (type is! InterfaceType) {
-      return false;
-    }
-    InterfaceType interfaceType = type as InterfaceType;
-    // check hierarchy
-    Set<Type2> seenTypes = new Set();
-    while (interfaceType != null) {
-      // check for recursion
-      if (!seenTypes.add(interfaceType)) {
-        return false;
-      }
-      // check for "Module"
-      if (interfaceType.element.name == "Module") {
-        return true;
-      }
-      // try supertype
-      interfaceType = interfaceType.superclass;
-    }
-    // no
-    return false;
-  }
-
-  /**
    * Parses given selector text and returns [AngularSelectorElement]. May be `null` if
    * cannot parse.
    */
   static AngularSelectorElement parseSelector(int offset, String text) {
-    if (text.startsWith("[") && text.endsWith("]")) {
+    if (StringUtilities.startsWithChar(text, 0x5B) && StringUtilities.endsWithChar(text, 0x5D)) {
       int nameOffset = offset + "[".length;
       String attributeName = text.substring(1, text.length - 1);
       // TODO(scheglov) report warning if there are spaces between [ and identifier
       return new HasAttributeSelectorElementImpl(attributeName, nameOffset);
     }
     if (StringUtilities.isTagName(text)) {
       return new IsTagSelectorElementImpl(text, offset);
     }
     return null;
   }
 
   /**
+   * Adds [AngularElement] declared by the given top-level [Element].
+   *
+   * @param angularElements the list to fill with top-level [AngularElement]s
+   * @param unitMember the top-level member of unit, such as [ClassElement], to get
+   *          [AngularElement]s from
+   */
+  static void addAngularElements(List<AngularElement> angularElements, Element unitMember) {
+    if (unitMember is ClassElement) {
+      ClassElement type = unitMember;
+      for (ToolkitObjectElement toolkitObject in type.toolkitObjects) {
+        if (toolkitObject is AngularElement) {
+          angularElements.add(toolkitObject);
+        }
+      }
+    }
+  }
+
+  /**
    * Returns the [FieldElement] of the first field in the given [FieldDeclaration].
    */
   static FieldElement getOnlyFieldElement(FieldDeclaration fieldDeclaration) {
     NodeList<VariableDeclaration> fields = fieldDeclaration.fields.variables;
     return fields[0].element as FieldElement;
   }
 
   /**
    * If given [Annotation] has one argument and it is [SimpleStringLiteral], returns it,
    * otherwise returns `null`.
    */
   static SimpleStringLiteral getOnlySimpleStringLiteralArgument(Annotation annotation) {
     SimpleStringLiteral nameLiteral = null;
     ArgumentList argsNode = annotation.arguments;
     if (argsNode != null) {
       NodeList<Expression> args = argsNode.arguments;
       if (args.length == 1) {
         Expression arg = args[0];
         if (arg is SimpleStringLiteral) {
           nameLiteral = arg;
         }
       }
     }
     return nameLiteral;
   }
 
   /**
-   * Checks if given [LocalVariableElement] is an Angular <code>Module</code>.
+   * Checks if the name range of the given [Element] is completely covered by the given
+   * [SimpleStringLiteral].
    */
-  static bool isModule2(VariableDeclaration node) {
-    Type2 type = node.name.bestType;
-    return isModule(type);
+  static bool isNameCoveredByLiteral(Element element, ASTNode node) {
+    if (element != null) {
+      String name = element.name;
+      if (name != null) {
+        int nameOffset = element.nameOffset;
+        int nameEnd = nameOffset + name.length;
+        return node.offset <= nameOffset && nameEnd < node.end;
+      }
+    }
+    return false;
   }
 
   /**
    * Parses given [SimpleStringLiteral] using [parseSelector].
    */
   static AngularSelectorElement parseSelector2(SimpleStringLiteral literal) {
     int offset = literal.valueOffset;
     String text = literal.stringValue;
     return parseSelector(offset, text);
   }
 
   /**
-   * The source containing the unit that will be analyzed.
+   * The [AnalysisContext] that performs analysis.
    */
-  Source _source;
+  AnalysisContext _context;
 
   /**
    * The listener to which errors will be reported.
    */
   AnalysisErrorListener _errorListener;
 
   /**
+   * The source containing the unit that will be analyzed.
+   */
+  Source _source;
+
+  /**
    * The [ClassDeclaration] that is currently being analyzed.
    */
   ClassDeclaration _classDeclaration;
 
   /**
    * The [ClassElementImpl] that is currently being analyzed.
    */
   ClassElementImpl _classElement;
 
   /**
    * The [ToolkitObjectElement]s to set for [classElement].
    */
   List<ToolkitObjectElement> _classToolkitObjects = [];
 
   /**
    * The [Annotation] that is currently being analyzed.
    */
   Annotation _annotation;
 
   /**
    * Initialize a newly created compilation unit element builder.
    *
    * @param errorListener the listener to which errors will be reported.
    * @param source the source containing the unit that will be analyzed
    */
-  AngularCompilationUnitBuilder(AnalysisErrorListener errorListener, Source source) {
+  AngularCompilationUnitBuilder(AnalysisContext context, AnalysisErrorListener errorListener, Source source) {
+    this._context = context;
     this._errorListener = errorListener;
     this._source = source;
   }
 
   /**
    * Builds Angular specific element models and adds them to the existing Dart elements.
    *
    * @param unit the compilation unit with built Dart element models
    */
   void build(CompilationUnit unit) {
     // process classes
     for (CompilationUnitMember unitMember in unit.declarations) {
       if (unitMember is ClassDeclaration) {
         this._classDeclaration = unitMember;
         this._classElement = _classDeclaration.element as ClassElementImpl;
         this._classToolkitObjects.clear();
-        parseModuleClass();
         // process annotations
         NodeList<Annotation> annotations = _classDeclaration.metadata;
         for (Annotation annotation in annotations) {
           // verify annotation
           if (annotation.arguments == null) {
             continue;
           }
           this._annotation = annotation;
           // @NgFilter
           if (isAngularAnnotation2(_NG_FILTER)) {
@@ skipping 16 matching lines @@
             continue;
           }
         }
         // set toolkit objects
         if (!_classToolkitObjects.isEmpty) {
           List<ToolkitObjectElement> objects = _classToolkitObjects;
           _classElement.toolkitObjects = new List.from(objects);
         }
       }
     }
-    // process modules in variables
-    parseModuleVariables(unit);
   }
 
   /**
-   * Creates [AngularModuleElementImpl] for given information.
-   */
-  AngularModuleElementImpl createModuleElement(List<AngularModuleElement> childModules, List<ClassElement> keyTypes) {
-    AngularModuleElementImpl module = new AngularModuleElementImpl();
-    module.childModules = new List.from(childModules);
-    module.keyTypes = new List.from(keyTypes);
-    return module;
-  }
-
-  /**
    * @return the argument [Expression] with given name form [annotation], may be
    *         `null` if not found.
    */
   Expression getArgument(String name) {
     List<Expression> arguments = _annotation.arguments.arguments;
     for (Expression argument in arguments) {
       if (argument is NamedExpression) {
         NamedExpression namedExpression = argument;
         String argumentName = namedExpression.name.label.name;
         if (name == argumentName) {
@@ skipping 43 matching lines @@
       return constructorElement.returnType.displayName == name;
     }
     return false;
   }
 
   /**
    * Checks if [annotation] is an annotation with required name.
    */
   bool isAngularAnnotation2(String name) => isAngularAnnotation(_annotation, name);
 
-  /**
-   * Checks if [classElement] is an Angular <code>Module</code>.
-   */
-  bool get isModule4 {
-    InterfaceType supertype = _classElement.supertype;
-    return isModule(supertype);
-  }
-
-  /**
-   * Analyzes [classDeclaration] and if it is a module, creates [AngularModuleElement]
-   * model for it.
-   */
-  void parseModuleClass() {
-    if (!isModule4) {
-      return;
-    }
-    // check install(), type() and value() invocations
-    List<AngularModuleElement> childModules = [];
-    List<ClassElement> keyTypes = [];
-    _classDeclaration.accept(new RecursiveASTVisitor_AngularCompilationUnitBuilder_parseModuleClass(this, childModules, keyTypes));
-    // set module element
-    AngularModuleElementImpl module = createModuleElement(childModules, keyTypes);
-    _classToolkitObjects.add(module);
-  }
-
-  /**
-   * Checks if given [MethodInvocation] is an interesting <code>Module</code> method
-   * invocation and remembers corresponding elements into lists.
-   */
-  void parseModuleInvocation(MethodInvocation node, List<AngularModuleElement> childModules, List<ClassElement> keyTypes) {
-    String methodName = node.methodName.name;
-    NodeList<Expression> arguments = node.argumentList.arguments;
-    // install()
-    if (arguments.length == 1 && methodName == "install") {
-      Type2 argType = arguments[0].bestType;
-      if (argType is InterfaceType) {
-        ClassElement argElement = argType.element;
-        List<ToolkitObjectElement> toolkitObjects = argElement.toolkitObjects;
-        for (ToolkitObjectElement toolkitObject in toolkitObjects) {
-          if (toolkitObject is AngularModuleElement) {
-            childModules.add(toolkitObject);
-          }
-        }
-      }
-      return;
-    }
-    // type() and value()
-    if (arguments.length >= 1 && (methodName == "type" || methodName == "value")) {
-      Expression arg = arguments[0];
-      if (arg is Identifier) {
-        Element argElement = arg.staticElement;
-        if (argElement is ClassElement) {
-          keyTypes.add(argElement);
-        }
-      }
-      return;
-    }
-  }
-
-  /**
-   * Checks every local variable in the given unit to see if it is a <code>Module</code> and creates
-   * [AngularModuleElement] for it.
-   */
-  void parseModuleVariables(CompilationUnit unit) {
-    unit.accept(new RecursiveASTVisitor_AngularCompilationUnitBuilder_parseModuleVariables(this));
-  }
-
   void parseNgComponent() {
     bool isValid = true;
     // publishAs
     if (!hasStringArgument(_PUBLISH_AS)) {
       reportErrorForAnnotation(AngularCode.MISSING_PUBLISH_AS, []);
       isValid = false;
     }
     // selector
     AngularSelectorElement selector = null;
     if (!hasStringArgument(_SELECTOR)) {
@@ skipping 22 matching lines @@
       String name = getStringArgument(_PUBLISH_AS);
       int nameOffset = getStringArgumentOffset(_PUBLISH_AS);
       String templateUri = getStringArgument(_TEMPLATE_URL);
       int templateUriOffset = getStringArgumentOffset(_TEMPLATE_URL);
       String styleUri = getStringArgument(_CSS_URL);
       int styleUriOffset = getStringArgumentOffset(_CSS_URL);
       AngularComponentElementImpl element = new AngularComponentElementImpl(name, nameOffset);
       element.selector = selector;
       element.templateUri = templateUri;
       element.templateUriOffset = templateUriOffset;
+      // resolve template URI
+      // TODO(scheglov) resolve to HtmlElement to allow F3 ?
+      {
+        try {
+          parseUriWithException(templateUri);
+          // TODO(scheglov) think if there is better solution
+          if (templateUri.startsWith("packages/")) {
+            templateUri = "package:${templateUri.substring("packages/".length)}";
+          }
+          Source templateSource = _context.sourceFactory.resolveUri(_source, templateUri);
+          if (templateSource == null || !templateSource.exists()) {
+            reportErrorForArgument(_TEMPLATE_URL, AngularCode.URI_DOES_NOT_EXIST, [templateUri]);
+          }
+          element.templateSource = templateSource;
+        } on URISyntaxException catch (exception) {
+          reportErrorForArgument(_TEMPLATE_URL, AngularCode.INVALID_URI, [templateUri]);
+        }
+      }
       element.styleUri = styleUri;
       element.styleUriOffset = styleUriOffset;
       element.properties = parseNgComponentProperties(true);
       _classToolkitObjects.add(element);
     }
   }
 
   /**
    * Parses [AngularPropertyElement]s from [annotation] and [classDeclaration].
    */
@@ skipping 74 matching lines @@
       Expression specExpression = entry.value;
       if (specExpression is! SimpleStringLiteral) {
         reportError(specExpression, AngularCode.INVALID_PROPERTY_SPEC, []);
         continue;
       }
       SimpleStringLiteral specLiteral = specExpression as SimpleStringLiteral;
       String spec = specLiteral.value;
       // parse binding kind and field name
       AngularPropertyKind kind;
       int fieldNameOffset;
-      if (spec.startsWith(_PREFIX_ATTR)) {
+      if (StringUtilities.startsWithChar(spec, 0x40)) {
         kind = AngularPropertyKind.ATTR;
         fieldNameOffset = 1;
-      } else if (spec.startsWith(_PREFIX_CALLBACK)) {
+      } else if (StringUtilities.startsWithChar(spec, 0x26)) {
         kind = AngularPropertyKind.CALLBACK;
         fieldNameOffset = 1;
-      } else if (spec.startsWith(_PREFIX_ONE_WAY_ONE_TIME)) {
+      } else if (StringUtilities.startsWith3(spec, 0, 0x3D, 0x3E, 0x21)) {
         kind = AngularPropertyKind.ONE_WAY_ONE_TIME;
         fieldNameOffset = 3;
-      } else if (spec.startsWith(_PREFIX_ONE_WAY)) {
+      } else if (StringUtilities.startsWith2(spec, 0, 0x3D, 0x3E)) {
         kind = AngularPropertyKind.ONE_WAY;
         fieldNameOffset = 2;
-      } else if (spec.startsWith(_PREFIX_TWO_WAY)) {
+      } else if (StringUtilities.startsWith3(spec, 0, 0x3C, 0x3D, 0x3E)) {
         kind = AngularPropertyKind.TWO_WAY;
         fieldNameOffset = 3;
       } else {
         reportError(specLiteral, AngularCode.INVALID_PROPERTY_KIND, [spec]);
         continue;
       }
       String fieldName = spec.substring(fieldNameOffset);
       fieldNameOffset += specLiteral.valueOffset;
       // prepare field
       FieldElement field = _classElement.getField(fieldName);
@@ skipping 93 matching lines @@
   void reportErrorForAnnotation(ErrorCode errorCode, List<Object> arguments) {
     reportError(_annotation, errorCode, arguments);
   }
 
   void reportErrorForArgument(String argumentName, ErrorCode errorCode, List<Object> arguments) {
     Expression argument = getArgument(argumentName);
     reportError(argument, errorCode, arguments);
   }
 }
 
-class RecursiveASTVisitor_AngularCompilationUnitBuilder_parseModuleClass extends RecursiveASTVisitor<Object> {
-  final AngularCompilationUnitBuilder AngularCompilationUnitBuilder_this;
-
-  List<AngularModuleElement> childModules;
-
-  List<ClassElement> keyTypes;
-
-  RecursiveASTVisitor_AngularCompilationUnitBuilder_parseModuleClass(this.AngularCompilationUnitBuilder_this, this.childModules, this.keyTypes) : super();
-
-  Object visitMethodInvocation(MethodInvocation node) {
-    if (node.target == null) {
-      AngularCompilationUnitBuilder_this.parseModuleInvocation(node, childModules, keyTypes);
-    }
-    return null;
-  }
-}
-
-class RecursiveASTVisitor_AngularCompilationUnitBuilder_parseModuleVariables extends RecursiveASTVisitor<Object> {
-  final AngularCompilationUnitBuilder AngularCompilationUnitBuilder_this;
-
-  RecursiveASTVisitor_AngularCompilationUnitBuilder_parseModuleVariables(this.AngularCompilationUnitBuilder_this) : super();
-
-  LocalVariableElementImpl _variable = null;
-
-  Expression _variableInit = null;
-
-  List<AngularModuleElement> _childModules = [];
-
-  List<ClassElement> _keyTypes = [];
-
-  Object visitClassDeclaration(ClassDeclaration node) => null;
-
-  Object visitFunctionDeclaration(FunctionDeclaration node) {
-    _childModules.clear();
-    _keyTypes.clear();
-    super.visitFunctionDeclaration(node);
-    if (_variable != null) {
-      AngularModuleElementImpl module = AngularCompilationUnitBuilder_this.createModuleElement(_childModules, _keyTypes);
-      _variable.toolkitObjects = <ToolkitObjectElement> [module];
-    }
-    return null;
-  }
-
-  Object visitMethodInvocation(MethodInvocation node) {
-    if (_variable != null) {
-      if (isVariableInvocation(node)) {
-        AngularCompilationUnitBuilder_this.parseModuleInvocation(node, _childModules, _keyTypes);
-      }
-    }
-    return null;
-  }
-
-  Object visitVariableDeclaration(VariableDeclaration node) {
-    VariableElement element = node.element;
-    if (element is LocalVariableElementImpl && AngularCompilationUnitBuilder.isModule2(node)) {
-      _variable = element;
-      _variableInit = node.initializer;
-    }
-    return super.visitVariableDeclaration(node);
-  }
-
-  bool isVariableInvocation(MethodInvocation node) {
-    Expression target = node.realTarget;
-    // var module = new Module()..type(t1)..type(t2);
-    if (_variableInit is CascadeExpression && target != null && identical(target.parent, _variableInit)) {
-      return true;
-    }
-    // var module = new Module();
-    // module.type(t);
-    if (target is Identifier) {
-      Element targetElement = target.staticElement;
-      return identical(targetElement, _variable);
-    }
-    // no
-    return false;
-  }
-}
-
 /**
  * Instances of the class `CompilationUnitBuilder` build an element model for a single
  * compilation unit.
  *
  * @coverage dart.engine.resolver
  */
 class CompilationUnitBuilder {
   /**
    * Build the compilation unit element for the given source.
    *
@@ skipping 1971 matching lines @@
       CatchClause catchClause = catchClauses[i];
       if (catchClause.onKeyword != null) {
         // on-catch clause found, verify that the exception type is not a subtype of a previous
         // on-catch exception type
         TypeName typeName = catchClause.exceptionType;
         if (typeName != null && typeName.type != null) {
           Type2 currentType = typeName.type;
           if (currentType.isObject) {
             // Found catch clause clause that has Object as an exception type, this is equivalent to
             // having a catch clause that doesn't have an exception type, visit the block, but
-            // generate an error on any following catch clauses (and don't visit them).
+             // generate an error on any following catch clauses (and don't visit them).
             safelyVisit(catchClause);
             if (i + 1 != numOfCatchClauses) {
-              // this catch clause is not the last in the try statement
+               // this catch clause is not the last in the try statement
               CatchClause nextCatchClause = catchClauses[i + 1];
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = nextCatchClause.offset;
               int length = lastCatchClause.end - offset;
               _errorReporter.reportError5(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
               return null;
             }
           }
           for (Type2 type in visitedTypes) {
             if (currentType.isSubtypeOf(type)) {
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = catchClause.offset;
               int length = lastCatchClause.end - offset;
               _errorReporter.reportError5(HintCode.DEAD_CODE_ON_CATCH_SUBTYPE, offset, length, [currentType.displayName, type.displayName]);
               return null;
             }
           }
           visitedTypes.add(currentType);
         }
         safelyVisit(catchClause);
       } else {
-        // Found catch clause clause that doesn't have an exception type, visit the block, but
+         // Found catch clause clause that doesn't have an exception type, visit the block, but
         // generate an error on any following catch clauses (and don't visit them).
         safelyVisit(catchClause);
         if (i + 1 != numOfCatchClauses) {
           // this catch clause is not the last in the try statement
           CatchClause nextCatchClause = catchClauses[i + 1];
           CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
           int offset = nextCatchClause.offset;
           int length = lastCatchClause.end - offset;
           _errorReporter.reportError5(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
           return null;
@@ skipping 33 matching lines @@
   ValidResult getConstantBooleanValue(Expression expression) {
     if (expression is BooleanLiteral) {
       if (expression.value) {
         return new ValidResult(new DartObjectImpl(null, BoolState.from(true)));
       } else {
         return new ValidResult(new DartObjectImpl(null, BoolState.from(false)));
       }
     }
     // Don't consider situations where we could evaluate to a constant boolean expression with the
     // ConstantVisitor
-    //    else {
-    //      EvaluationResultImpl result = expression.accept(new ConstantVisitor());
-    //      if (result == ValidResult.RESULT_TRUE) {
-    //        return ValidResult.RESULT_TRUE;
-    //      } else if (result == ValidResult.RESULT_FALSE) {
-    //        return ValidResult.RESULT_FALSE;
-    //      }
-    //      return null;
-    //    }
+//
+       // else {
+//
+         // EvaluationResultImpl result = expression.accept(new ConstantVisitor());
+//
+         // if (result == ValidResult.RESULT_TRUE) {
+//
+           // return ValidResult.RESULT_TRUE;
+//
+         // } else if (result == ValidResult.RESULT_FALSE) {
+//
+           // return ValidResult.RESULT_FALSE;
+//
+         // }
+//
+         // return null;
+//
+       // }
     return null;
   }
 
   /**
    * Return `true` if and only if the passed expression is resolved to a constant variable.
    *
    * @param expression some conditional expression
    * @return `true` if and only if the passed expression is resolved to a constant variable
    */
   bool isDebugConstant(Expression expression) {
@@ skipping 19 matching lines @@
    * @param node the node to be visited
    */
   void safelyVisit(ASTNode node) {
     if (node != null) {
       node.accept(this);
     }
   }
 }
 
 /**
+ * Instances of the class `ExitDetector` determine whether the visited AST node is guaranteed
+ * to terminate by executing a `return` statement, `throw` expression, `rethrow`
+ * expression, or simple infinite loop such as `while(true)`.
+ */
+class ExitDetector extends GeneralizingASTVisitor<bool> {
+  bool visitArgumentList(ArgumentList node) => visitExpressions(node.arguments);
+
+  bool visitAsExpression(AsExpression node) => node.expression.accept(this);
+
+  bool visitAssertStatement(AssertStatement node) => node.condition.accept(this);
+
+  bool visitAssignmentExpression(AssignmentExpression node) => node.leftHandSide.accept(this) || node.rightHandSide.accept(this);
+
+  bool visitBinaryExpression(BinaryExpression node) {
+    Expression lhsExpression = node.leftOperand;
+    sc.TokenType operatorType = node.operator.type;
+    // If the operator is || and the left hand side is false literal, don't consider the RHS of the
+    // binary expression.
+    // TODO(jwren) Do we want to take constant expressions into account, evaluate if(false) {}
+    // differently than if(<condition>), when <condition> evaluates to a constant false value?
+    if (identical(operatorType, sc.TokenType.BAR_BAR)) {
+      if (lhsExpression is BooleanLiteral) {
+        BooleanLiteral booleanLiteral = lhsExpression;
+        if (!booleanLiteral.value) {
+          return false;
+        }
+      }
+    }
+    // If the operator is && and the left hand side is true literal, don't consider the RHS of the
+    // binary expression.
+    if (identical(operatorType, sc.TokenType.AMPERSAND_AMPERSAND)) {
+      if (lhsExpression is BooleanLiteral) {
+        BooleanLiteral booleanLiteral = lhsExpression;
+        if (booleanLiteral.value) {
+          return false;
+        }
+      }
+    }
+    return lhsExpression.accept(this) || node.rightOperand.accept(this);
+  }
+
+  bool visitBlock(Block node) => visitStatements(node.statements);
+
+  bool visitBlockFunctionBody(BlockFunctionBody node) => node.block.accept(this);
+
+  bool visitBreakStatement(BreakStatement node) => false;
+
+  bool visitCascadeExpression(CascadeExpression node) {
+    Expression target = node.target;
+    if (target.accept(this)) {
+      return true;
+    }
+    return visitExpressions(node.cascadeSections);
+  }
+
+  bool visitConditionalExpression(ConditionalExpression node) {
+    Expression conditionExpression = node.condition;
+    Expression thenStatement = node.thenExpression;
+    Expression elseStatement = node.elseExpression;
+    // TODO(jwren) Do we want to take constant expressions into account, evaluate if(false) {}
+    // differently than if(<condition>), when <condition> evaluates to a constant false value?
+    if (conditionExpression.accept(this)) {
+      return true;
+    }
+    if (thenStatement == null || elseStatement == null) {
+      return false;
+    }
+    return thenStatement.accept(this) && elseStatement.accept(this);
+  }
+
+  bool visitContinueStatement(ContinueStatement node) => false;
+
+  bool visitDoStatement(DoStatement node) {
+    Expression conditionExpression = node.condition;
+    if (conditionExpression.accept(this)) {
+      return true;
+    }
+    // TODO(jwren) Do we want to take all constant expressions into account?
+    if (conditionExpression is BooleanLiteral) {
+      BooleanLiteral booleanLiteral = conditionExpression;
+      if (booleanLiteral.value) {
+        return node.body.accept(this);
+      }
+    }
+    return false;
+  }
+
+  bool visitEmptyStatement(EmptyStatement node) => false;
+
+  bool visitExpressionStatement(ExpressionStatement node) => node.expression.accept(this);
+
+  bool visitForEachStatement(ForEachStatement node) => node.iterator.accept(this);
+
+  bool visitForStatement(ForStatement node) {
+    if (node.variables != null && visitVariableDeclarations(node.variables.variables)) {
+      return true;
+    }
+    if (node.initialization != null && node.initialization.accept(this)) {
+      return true;
+    }
+    if (node.condition != null && node.condition.accept(this)) {
+      return true;
+    }
+    return visitExpressions(node.updaters);
+  }
+
+  bool visitFunctionDeclarationStatement(FunctionDeclarationStatement node) => false;
+
+  bool visitFunctionExpression(FunctionExpression node) => false;
+
+  bool visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
+    if (node.function.accept(this)) {
+      return true;
+    }
+    return node.argumentList.accept(this);
+  }
+
+  bool visitIdentifier(Identifier node) => false;
+
+  bool visitIfStatement(IfStatement node) {
+    Expression conditionExpression = node.condition;
+    Statement thenStatement = node.thenStatement;
+    Statement elseStatement = node.elseStatement;
+    // TODO(jwren) Do we want to take constant expressions into account, evaluate if(false) {}
+    // differently than if(<condition>), when <condition> evaluates to a constant false value?
+    if (conditionExpression.accept(this)) {
+      return true;
+    }
+    if (thenStatement == null || elseStatement == null) {
+      return false;
+    }
+    return thenStatement.accept(this) && elseStatement.accept(this);
+  }
+
+  bool visitIndexExpression(IndexExpression node) {
+    Expression target = node.target;
+    if (target != null && target.accept(this)) {
+      return true;
+    }
+    if (node.index.accept(this)) {
+      return true;
+    }
+    return false;
+  }
+
+  bool visitInstanceCreationExpression(InstanceCreationExpression node) => node.argumentList.accept(this);
+
+  bool visitIsExpression(IsExpression node) => node.expression.accept(this);
+
+  bool visitLabel(Label node) => false;
+
+  bool visitLabeledStatement(LabeledStatement node) => node.statement.accept(this);
+
+  bool visitLiteral(Literal node) => false;
+
+  bool visitMethodInvocation(MethodInvocation node) {
+    Expression target = node.target;
+    if (target != null && target.accept(this)) {
+      return true;
+    }
+    return node.argumentList.accept(this);
+  }
+
+  bool visitNamedExpression(NamedExpression node) => node.expression.accept(this);
+
+  bool visitParenthesizedExpression(ParenthesizedExpression node) => node.expression.accept(this);
+
+  bool visitPostfixExpression(PostfixExpression node) => false;
+
+  bool visitPrefixExpression(PrefixExpression node) => false;
+
+  bool visitPropertyAccess(PropertyAccess node) => node.target.accept(this);
+
+  bool visitRethrowExpression(RethrowExpression node) => true;
+
+  bool visitReturnStatement(ReturnStatement node) => true;
+
+  bool visitSuperExpression(SuperExpression node) => false;
+
+  bool visitSwitchCase(SwitchCase node) => visitStatements(node.statements);
+
+  bool visitSwitchDefault(SwitchDefault node) => visitStatements(node.statements);
+
+  bool visitSwitchStatement(SwitchStatement node) {
+    bool hasDefault = false;
+    for (SwitchMember member in node.members) {
+      if (!member.accept(this)) {
+        return false;
+      }
+      if (member is SwitchDefault) {
+        hasDefault = true;
+      }
+    }
+    return hasDefault;
+  }
+
+  bool visitThisExpression(ThisExpression node) => false;
+
+  bool visitThrowExpression(ThrowExpression node) => true;
+
+  bool visitTryStatement(TryStatement node) {
+    if (node.body.accept(this)) {
+      return true;
+    }
+    Block finallyBlock = node.finallyBlock;
+    if (finallyBlock != null && finallyBlock.accept(this)) {
+      return true;
+    }
+    return false;
+  }
+
+  bool visitTypeName(TypeName node) => false;
+
+  bool visitVariableDeclaration(VariableDeclaration node) {
+    Expression initializer = node.initializer;
+    if (initializer != null) {
+      return initializer.accept(this);
+    }
+    return false;
+  }
+
+  bool visitVariableDeclarationList(VariableDeclarationList node) => visitVariableDeclarations(node.variables);
+
+  bool visitVariableDeclarationStatement(VariableDeclarationStatement node) {
+    NodeList<VariableDeclaration> variables = node.variables.variables;
+    for (int i = 0; i < variables.length; i++) {
+      if (variables[i].accept(this)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool visitWhileStatement(WhileStatement node) {
+    Expression conditionExpression = node.condition;
+    if (conditionExpression.accept(this)) {
+      return true;
+    }
+    // TODO(jwren) Do we want to take all constant expressions into account?
+    if (conditionExpression is BooleanLiteral) {
+      BooleanLiteral booleanLiteral = conditionExpression;
+      if (booleanLiteral.value) {
+        return node.body.accept(this);
+      }
+    }
+    return false;
+  }
+
+  bool visitExpressions(NodeList<Expression> expressions) {
+    for (int i = expressions.length - 1; i >= 0; i--) {
+      if (expressions[i].accept(this)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool visitStatements(NodeList<Statement> statements) {
+    for (int i = statements.length - 1; i >= 0; i--) {
+      if (statements[i].accept(this)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool visitVariableDeclarations(NodeList<VariableDeclaration> variableDeclarations) {
+    for (int i = variableDeclarations.length - 1; i >= 0; i--) {
+      if (variableDeclarations[i].accept(this)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+/**
  * Instances of the class `HintGenerator` traverse a library's worth of dart code at a time to
  * generate hints over the set of sources.
  *
  * @see HintCode
  * @coverage dart.engine.resolver
  */
 class HintGenerator {
   List<CompilationUnit> _compilationUnits;
 
   AnalysisContext _context;
@@ skipping 414 matching lines @@
    * @param path the file path being verified (not `null`)
    * @return `true` if and only if an error code is generated on the passed node
    * @see PubSuggestionCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE
    */
   bool checkForFileImportInsideLibReferencesFileOutside(StringLiteral uriLiteral, String path) {
     Source source = getSource(uriLiteral);
     String fullName = getSourceFullName(source);
     if (fullName != null) {
       int pathIndex = 0;
       int fullNameIndex = fullName.length;
-      while (pathIndex < path.length && JavaString.startsWithBefore(path, "../", pathIndex)) {
+      while (pathIndex < path.length && StringUtilities.startsWith3(path, pathIndex, 0x2E, 0x2E, 0x2F)) {
         fullNameIndex = JavaString.lastIndexOf(fullName, '/', fullNameIndex);
         if (fullNameIndex < 4) {
           return false;
         }
         // Check for "/lib" at a specified place in the fullName
-        if (JavaString.startsWithBefore(fullName, "/lib", fullNameIndex - 4)) {
+        if (StringUtilities.startsWith4(fullName, fullNameIndex - 4, 0x2F, 0x6C, 0x69, 0x62)) {
           String relativePubspecPath = path.substring(0, pathIndex + 3) + _PUBSPEC_YAML;
           Source pubspecSource = _context.sourceFactory.resolveUri(source, relativePubspecPath);
           if (pubspecSource != null && pubspecSource.exists()) {
             // Files inside the lib directory hierarchy should not reference files outside
             _errorReporter.reportError3(PubSuggestionCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE, uriLiteral, []);
           }
           return true;
         }
         pathIndex += 3;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed file import directive is not contained in a source outside a
    * package "lib" directory hierarchy referencing a source inside that package "lib" directory
    * hierarchy.
    *
    * @param uriLiteral the import URL (not `null`)
    * @param path the file path being verified (not `null`)
    * @return `true` if and only if an error code is generated on the passed node
    * @see PubSuggestionCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE
    */
   bool checkForFileImportOutsideLibReferencesFileInside(StringLiteral uriLiteral, String path) {
-    if (path.startsWith("lib/")) {
+    if (StringUtilities.startsWith4(path, 0, 0x6C, 0x69, 0x62, 0x2F)) {
       if (checkForFileImportOutsideLibReferencesFileInside2(uriLiteral, path, 0)) {
         return true;
       }
     }
-    int pathIndex = path.indexOf("/lib/");
+    int pathIndex = StringUtilities.indexOf5(path, 0, 0x2F, 0x6C, 0x69, 0x62, 0x2F);
     while (pathIndex != -1) {
       if (checkForFileImportOutsideLibReferencesFileInside2(uriLiteral, path, pathIndex + 1)) {
         return true;
       }
-      pathIndex = JavaString.indexOf(path, "/lib/", pathIndex + 4);
+      pathIndex = StringUtilities.indexOf5(path, pathIndex + 4, 0x2F, 0x6C, 0x69, 0x62, 0x2F);
     }
     return false;
   }
 
   bool checkForFileImportOutsideLibReferencesFileInside2(StringLiteral uriLiteral, String path, int pathIndex) {
     Source source = getSource(uriLiteral);
     String relativePubspecPath = path.substring(0, pathIndex) + _PUBSPEC_YAML;
     Source pubspecSource = _context.sourceFactory.resolveUri(source, relativePubspecPath);
     if (pubspecSource == null || !pubspecSource.exists()) {
       return false;
     }
     String fullName = getSourceFullName(source);
     if (fullName != null) {
-      if (!fullName.contains("/lib/")) {
+      if (StringUtilities.indexOf5(fullName, 0, 0x2F, 0x6C, 0x69, 0x62, 0x2F) < 0) {
         // Files outside the lib directory hierarchy should not reference files inside
         // ... use package: url instead
         _errorReporter.reportError3(PubSuggestionCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE, uriLiteral, []);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed package import directive does not contain ".."
    *
    * @param uriLiteral the import URL (not `null`)
    * @param path the path to be validated (not `null`)
    * @return `true` if and only if an error code is generated on the passed node
    * @see PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT
    */
   bool checkForPackageImportContainsDotDot(StringLiteral uriLiteral, String path) {
-    if (path.startsWith("../") || path.contains("/../")) {
+    if (StringUtilities.startsWith3(path, 0, 0x2E, 0x2E, 0x2F) || StringUtilities.indexOf4(path, 0, 0x2F, 0x2E, 0x2E, 0x2F) >= 0) {
       // Package import should not to contain ".."
       _errorReporter.reportError3(PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT, uriLiteral, []);
       return true;
     }
     return false;
   }
 
   /**
    * Answer the source associated with the compilation unit containing the given AST node.
    *
@@ skipping 24 matching lines @@
       String fullName = source.fullName;
       if (fullName != null) {
         return fullName.replaceAll(r'\', '/');
       }
     }
     return null;
   }
 }
 
 /**
- * Instances of the class `ReturnDetector` determine whether the visited AST node is
- * guaranteed (modulo exceptions) to terminate by executing a return statement.
- */
-class ReturnDetector extends UnifyingASTVisitor<bool> {
-  bool visitBlock(Block node) => visitStatements(node.statements);
-
-  bool visitBlockFunctionBody(BlockFunctionBody node) => node.block.accept(this);
-
-  bool visitIfStatement(IfStatement node) {
-    Statement thenStatement = node.thenStatement;
-    Statement elseStatement = node.elseStatement;
-    if (thenStatement == null || elseStatement == null) {
-      return false;
-    }
-    return thenStatement.accept(this) && elseStatement.accept(this);
-  }
-
-  bool visitNode(ASTNode node) => false;
-
-  bool visitReturnStatement(ReturnStatement node) => true;
-
-  bool visitSwitchCase(SwitchCase node) => visitStatements(node.statements);
-
-  bool visitSwitchDefault(SwitchDefault node) => visitStatements(node.statements);
-
-  bool visitSwitchStatement(SwitchStatement node) {
-    bool hasDefault = false;
-    for (SwitchMember member in node.members) {
-      if (!member.accept(this)) {
-        return false;
-      }
-      if (member is SwitchDefault) {
-        hasDefault = true;
-      }
-    }
-    return hasDefault;
-  }
-
-  bool visitStatements(NodeList<Statement> statements) {
-    for (int i = statements.length - 1; i >= 0; i--) {
-      if (statements[i].accept(this)) {
-        return true;
-      }
-    }
-    return false;
-  }
-}
-
-/**
  * Instances of the class `ToDoFinder` find to-do comments in Dart code.
  */
 class ToDoFinder {
   /**
    * The error reporter by which to-do comments will be reported.
    */
   ErrorReporter _errorReporter;
 
   /**
    * Initialize a newly created to-do finder to report to-do comments to the given reporter.
@@ skipping 1427 matching lines @@
         }
       }
     }
     return null;
   }
 
   Object visitBreakStatement(BreakStatement node) {
     SimpleIdentifier labelNode = node.label;
     LabelElementImpl labelElement = lookupLabel(node, labelNode);
     if (labelElement != null && labelElement.isOnSwitchMember) {
-      _resolver.reportError7(ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER, labelNode, []);
+      _resolver.reportError8(ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER, labelNode, []);
     }
     return null;
   }
 
   Object visitClassDeclaration(ClassDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
 
   Object visitClassTypeAlias(ClassTypeAlias node) {
@@ skipping 105 matching lines @@
     }
     return null;
   }
 
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     SimpleIdentifier fieldName = node.fieldName;
     ClassElement enclosingClass = _resolver.enclosingClass;
     FieldElement fieldElement = enclosingClass.getField(fieldName.name);
     fieldName.staticElement = fieldElement;
     if (fieldElement == null || fieldElement.isSynthetic) {
-      _resolver.reportError7(CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
+      _resolver.reportError8(CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
     } else if (fieldElement.isStatic) {
-      _resolver.reportError7(CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node, [fieldName]);
+      _resolver.reportError8(CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node, [fieldName]);
     }
     return null;
   }
 
   Object visitConstructorName(ConstructorName node) {
     Type2 type = node.type.type;
     if (type != null && type.isDynamic) {
       return null;
     } else if (type is! InterfaceType) {
       // TODO(brianwilkerson) Report these errors.
@@ skipping 17 matching lines @@
       name.staticElement = constructor;
     }
     node.staticElement = constructor;
     return null;
   }
 
   Object visitContinueStatement(ContinueStatement node) {
     SimpleIdentifier labelNode = node.label;
     LabelElementImpl labelElement = lookupLabel(node, labelNode);
     if (labelElement != null && labelElement.isOnSwitchStatement) {
-      _resolver.reportError7(ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH, labelNode, []);
+      _resolver.reportError8(ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH, labelNode, []);
     }
     return null;
   }
 
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     setMetadata(node.element, node);
     return null;
   }
 
   Object visitExportDirective(ExportDirective node) {
     Element element = node.element;
     if (element is ExportElement) {
       // The element is null when the URI is invalid
       // TODO(brianwilkerson) Figure out whether the element can ever be something other than an
       // ExportElement
       resolveCombinators(element.exportedLibrary, node.combinators);
       setMetadata(element, node);
     }
     return null;
   }
 
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     String fieldName = node.identifier.name;
     ClassElement classElement = _resolver.enclosingClass;
     if (classElement != null) {
       FieldElement fieldElement = classElement.getField(fieldName);
       if (fieldElement == null) {
-        _resolver.reportError7(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
+        _resolver.reportError8(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
       } else {
         ParameterElement parameterElement = node.element;
         if (parameterElement is FieldFormalParameterElementImpl) {
           FieldFormalParameterElementImpl fieldFormal = parameterElement;
           fieldFormal.field = fieldElement;
           Type2 declaredType = fieldFormal.type;
           Type2 fieldType = fieldElement.type;
           if (node.type == null) {
             fieldFormal.type = fieldType;
           }
           if (fieldElement.isSynthetic) {
-            _resolver.reportError7(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
+            _resolver.reportError8(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
           } else if (fieldElement.isStatic) {
-            _resolver.reportError7(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [fieldName]);
+            _resolver.reportError8(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [fieldName]);
           } else if (declaredType != null && fieldType != null && !declaredType.isAssignableTo(fieldType)) {
             // TODO(brianwilkerson) We should implement a displayName() method for types that will
             // work nicely with function types and then use that below.
-            _resolver.reportError7(StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE, node, [declaredType.displayName, fieldType.displayName]);
+            _resolver.reportError8(StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE, node, [declaredType.displayName, fieldType.displayName]);
           }
         } else {
           if (fieldElement.isSynthetic) {
-            _resolver.reportError7(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
+            _resolver.reportError8(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
           } else if (fieldElement.isStatic) {
-            _resolver.reportError7(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [fieldName]);
+            _resolver.reportError8(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [fieldName]);
           }
         }
       }
     }
     //    else {
     //    // TODO(jwren) Report error, constructor initializer variable is a top level element
     //    // (Either here or in ErrorVerifier#checkForAllFinalInitializedErrorCodes)
     //    }
+    setMetadata2(node.element, node);
     return super.visitFieldFormalParameter(node);
   }
 
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
 
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     // TODO(brianwilkerson) Can we ever resolve the function being invoked?
     Expression expression = node.function;
     if (expression is FunctionExpression) {
       FunctionExpression functionExpression = expression;
       ExecutableElement functionElement = functionExpression.element;
       ArgumentList argumentList = node.argumentList;
       List<ParameterElement> parameters = resolveArgumentsToParameters(false, argumentList, functionElement);
       if (parameters != null) {
         argumentList.correspondingStaticParameters = parameters;
       }
     }
     return null;
   }
 
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     setMetadata(node.element, node);
     return null;
   }
 
+  Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
+    setMetadata2(node.element, node);
+    return null;
+  }
+
   Object visitImportDirective(ImportDirective node) {
     SimpleIdentifier prefixNode = node.prefix;
     if (prefixNode != null) {
       String prefixName = prefixNode.name;
       for (PrefixElement prefixElement in _definingLibrary.prefixes) {
         if (prefixElement.displayName == prefixName) {
           prefixNode.staticElement = prefixElement;
           break;
         }
       }
@@ skipping 163 matching lines @@
             }
           }
         }
       }
       generatedWithTypePropagation = true;
     }
     if (errorCode == null) {
       return null;
     }
     if (identical(errorCode, StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION)) {
-      _resolver.reportError7(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName, [methodName.name]);
+      _resolver.reportError8(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName, [methodName.name]);
     } else if (identical(errorCode, CompileTimeErrorCode.UNDEFINED_FUNCTION)) {
-      _resolver.reportError7(CompileTimeErrorCode.UNDEFINED_FUNCTION, methodName, [methodName.name]);
+      _resolver.reportError8(CompileTimeErrorCode.UNDEFINED_FUNCTION, methodName, [methodName.name]);
     } else if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_METHOD)) {
       String targetTypeName;
       if (target == null) {
         ClassElement enclosingClass = _resolver.enclosingClass;
         targetTypeName = enclosingClass.displayName;
         ErrorCode proxyErrorCode = (generatedWithTypePropagation ? HintCode.UNDEFINED_METHOD : StaticTypeWarningCode.UNDEFINED_METHOD) as ErrorCode;
         _resolver.reportErrorProxyConditionalAnalysisError(_resolver.enclosingClass, proxyErrorCode, methodName, [methodName.name, targetTypeName]);
       } else {
         // ignore Function "call"
         // (if we are about to create a hint using type propagation, then we can use type
@@ skipping 15 matching lines @@
         }
         targetTypeName = targetType == null ? null : targetType.displayName;
         ErrorCode proxyErrorCode = (generatedWithTypePropagation ? HintCode.UNDEFINED_METHOD : StaticTypeWarningCode.UNDEFINED_METHOD) as ErrorCode;
         _resolver.reportErrorProxyConditionalAnalysisError(targetType.element, proxyErrorCode, methodName, [methodName.name, targetTypeName]);
       }
     } else if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_SUPER_METHOD)) {
       // Generate the type name.
       // The error code will never be generated via type propagation
       Type2 targetType = getStaticType(target);
       String targetTypeName = targetType == null ? null : targetType.name;
-      _resolver.reportError7(StaticTypeWarningCode.UNDEFINED_SUPER_METHOD, methodName, [methodName.name, targetTypeName]);
+      _resolver.reportError8(StaticTypeWarningCode.UNDEFINED_SUPER_METHOD, methodName, [methodName.name, targetTypeName]);
     }
     return null;
   }
 
   Object visitPartDirective(PartDirective node) {
     setMetadata(node.element, node);
     return null;
   }
 
   Object visitPartOfDirective(PartOfDirective node) {
@@ skipping 37 matching lines @@
     // First, check to see whether the prefix is really a prefix.
     //
     Element prefixElement = prefix.staticElement;
     if (prefixElement is PrefixElement) {
       Element element = _resolver.nameScope.lookup(node, _definingLibrary);
       if (element == null && identifier.inSetterContext()) {
         element = _resolver.nameScope.lookup(new ElementResolver_SyntheticIdentifier("${node.name}="), _definingLibrary);
       }
       if (element == null) {
         if (identifier.inSetterContext()) {
-          _resolver.reportError7(StaticWarningCode.UNDEFINED_SETTER, identifier, [identifier.name, prefixElement.name]);
+          _resolver.reportError8(StaticWarningCode.UNDEFINED_SETTER, identifier, [identifier.name, prefixElement.name]);
         } else if (node.parent is Annotation) {
           Annotation annotation = node.parent as Annotation;
-          _resolver.reportError7(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
+          _resolver.reportError8(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
           return null;
         } else {
-          _resolver.reportError7(StaticWarningCode.UNDEFINED_GETTER, identifier, [identifier.name, prefixElement.name]);
+          _resolver.reportError8(StaticWarningCode.UNDEFINED_GETTER, identifier, [identifier.name, prefixElement.name]);
         }
         return null;
       }
       if (element is PropertyAccessorElement && identifier.inSetterContext()) {
         PropertyInducingElement variable = (element as PropertyAccessorElement).variable;
         if (variable != null) {
           PropertyAccessorElement setter = variable.setter;
           if (setter != null) {
             element = setter;
           }
@@ skipping 88 matching lines @@
     }
     node.staticElement = element;
     ArgumentList argumentList = node.argumentList;
     List<ParameterElement> parameters = resolveArgumentsToParameters(false, argumentList, element);
     if (parameters != null) {
       argumentList.correspondingStaticParameters = parameters;
     }
     return null;
   }
 
+  Object visitSimpleFormalParameter(SimpleFormalParameter node) {
+    setMetadata2(node.element, node);
+    return null;
+  }
+
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     //
     // Synthetic identifiers have been already reported during parsing.
     //
     if (node.isSynthetic) {
       return null;
     }
     //
     // We ignore identifiers that have already been resolved, such as identifiers representing the
     // name in a declaration.
     //
     if (node.staticElement != null) {
       return null;
     }
     //
     // The name dynamic denotes a Type object even though dynamic is not a class.
     //
     if (node.name == _dynamicType.name) {
       node.staticElement = _dynamicType.element;
       node.staticType = _typeType;
       return null;
     }
     //
     // Otherwise, the node should be resolved.
     //
     Element element = resolveSimpleIdentifier(node);
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (isFactoryConstructorReturnType(node) && element != enclosingClass) {
-      _resolver.reportError7(CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS, node, []);
+      _resolver.reportError8(CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS, node, []);
     } else if (isConstructorReturnType(node) && element != enclosingClass) {
-      _resolver.reportError7(CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node, []);
+      _resolver.reportError8(CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node, []);
       element = null;
     } else if (element == null || (element is PrefixElement && !isValidAsPrefix(node))) {
       // TODO(brianwilkerson) Recover from this error.
       if (isConstructorReturnType(node)) {
-        _resolver.reportError7(CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node, []);
+        _resolver.reportError8(CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node, []);
       } else if (node.parent is Annotation) {
         Annotation annotation = node.parent as Annotation;
-        _resolver.reportError7(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
+        _resolver.reportError8(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
       } else {
         _resolver.reportErrorProxyConditionalAnalysisError(_resolver.enclosingClass, StaticWarningCode.UNDEFINED_IDENTIFIER, node, [node.name]);
       }
     }
     node.staticElement = element;
     if (node.inSetterContext() && node.inGetterContext() && enclosingClass != null) {
       InterfaceType enclosingType = enclosingClass.type;
       AuxiliaryElements auxiliaryElements = new AuxiliaryElements(lookUpGetter(null, enclosingType, node.name), null);
       node.auxiliaryElements = auxiliaryElements;
     }
@@ skipping 16 matching lines @@
     InterfaceType superType = enclosingClass.supertype;
     if (superType == null) {
       // TODO(brianwilkerson) Report this error.
       return null;
     }
     SimpleIdentifier name = node.constructorName;
     String superName = name != null ? name.name : null;
     ConstructorElement element = superType.lookUpConstructor(superName, _definingLibrary);
     if (element == null) {
       if (name != null) {
-        _resolver.reportError7(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER, node, [superType.displayName, name]);
+        _resolver.reportError8(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER, node, [superType.displayName, name]);
       } else {
-        _resolver.reportError7(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT, node, [superType.displayName]);
+        _resolver.reportError8(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT, node, [superType.displayName]);
       }
       return null;
     } else {
       if (element.isFactory) {
-        _resolver.reportError7(CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node, [element]);
+        _resolver.reportError8(CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node, [element]);
       }
     }
     if (name != null) {
       name.staticElement = element;
     }
     node.staticElement = element;
     ArgumentList argumentList = node.argumentList;
     List<ParameterElement> parameters = resolveArgumentsToParameters(isInConstConstructor, argumentList, element);
     if (parameters != null) {
       argumentList.correspondingStaticParameters = parameters;
     }
     return null;
   }
 
   Object visitSuperExpression(SuperExpression node) {
     if (!isSuperInValidContext(node)) {
-      _resolver.reportError7(CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT, node, []);
+      _resolver.reportError8(CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT, node, []);
     }
     return super.visitSuperExpression(node);
   }
 
   Object visitTypeParameter(TypeParameter node) {
     TypeName bound = node.bound;
     if (bound != null) {
       TypeParameterElementImpl typeParameter = node.name.staticElement as TypeParameterElementImpl;
       if (typeParameter != null) {
         typeParameter.bound = bound.type;
@@ skipping 542 matching lines @@
         if (labelElement == null) {
         }
         //
         // The label element that was returned was a marker for look-up and isn't stored in the
         // element model.
         //
         labelElement = null;
       }
     } else {
       if (labelScope == null) {
-        _resolver.reportError7(CompileTimeErrorCode.LABEL_UNDEFINED, labelNode, [labelNode.name]);
+        _resolver.reportError8(CompileTimeErrorCode.LABEL_UNDEFINED, labelNode, [labelNode.name]);
       } else {
         labelElement = labelScope.lookup(labelNode) as LabelElementImpl;
         if (labelElement == null) {
-          _resolver.reportError7(CompileTimeErrorCode.LABEL_UNDEFINED, labelNode, [labelNode.name]);
+          _resolver.reportError8(CompileTimeErrorCode.LABEL_UNDEFINED, labelNode, [labelNode.name]);
         } else {
           labelNode.staticElement = labelElement;
         }
       }
     }
     if (labelElement != null) {
       ExecutableElement labelContainer = labelElement.getAncestor(ExecutableElement);
       if (labelContainer != _resolver.enclosingFunction) {
-        _resolver.reportError7(CompileTimeErrorCode.LABEL_IN_OUTER_SCOPE, labelNode, [labelNode.name]);
+        _resolver.reportError8(CompileTimeErrorCode.LABEL_IN_OUTER_SCOPE, labelNode, [labelNode.name]);
         labelElement = null;
       }
     }
     return labelElement;
   }
 
   /**
    * Look up the method with the given name in the given type. Return the element representing the
    * method that was found, or `null` if there is no method with the given name.
    *
@@ skipping 304 matching lines @@
           resolveAnnotationElementGetter(annotation, getter);
           return;
         }
         // prefix.Class.constructor(args)
         constructor = new InterfaceTypeImpl.con1(classElement).lookUpConstructor(name3, _definingLibrary);
         nameNode3.staticElement = constructor;
       }
     }
     // we need constructor
     if (constructor == null) {
-      _resolver.reportError7(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
+      _resolver.reportError8(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
       return;
     }
     // record element
     annotation.element = constructor;
     // resolve arguments
     resolveAnnotationConstructorInvocationArguments(annotation, constructor);
   }
 
   void resolveAnnotationElementGetter(Annotation annotation, PropertyAccessorElement accessorElement) {
     // accessor should be synthetic
     if (!accessorElement.isSynthetic) {
-      _resolver.reportError7(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
+      _resolver.reportError8(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
       return;
     }
     // variable should be constant
     VariableElement variableElement = accessorElement.variable;
     if (!variableElement.isConst) {
-      _resolver.reportError7(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
+      _resolver.reportError8(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
     }
     // OK
     return;
   }
 
   /**
    * Given a list of arguments and the element that will be invoked using those argument, compute
    * the list of parameters that correspond to the list of arguments. Return the parameters that
    * correspond to the arguments, or `null` if no correspondence could be computed.
    *
@@ skipping 46 matching lines @@
     int positionalArgumentCount = 0;
     Set<String> usedNames = new Set<String>();
     for (int i = 0; i < argumentCount; i++) {
       Expression argument = arguments[i];
       if (argument is NamedExpression) {
         SimpleIdentifier nameNode = argument.name.label;
         String name = nameNode.name;
         ParameterElement element = namedParameters[name];
         if (element == null) {
           ErrorCode errorCode = (reportError ? CompileTimeErrorCode.UNDEFINED_NAMED_PARAMETER : StaticWarningCode.UNDEFINED_NAMED_PARAMETER) as ErrorCode;
-          _resolver.reportError7(errorCode, nameNode, [name]);
+          _resolver.reportError8(errorCode, nameNode, [name]);
         } else {
           resolvedParameters[i] = element;
           nameNode.staticElement = element;
         }
         if (!usedNames.add(name)) {
-          _resolver.reportError7(CompileTimeErrorCode.DUPLICATE_NAMED_ARGUMENT, nameNode, [name]);
+          _resolver.reportError8(CompileTimeErrorCode.DUPLICATE_NAMED_ARGUMENT, nameNode, [name]);
         }
       } else {
         positionalArgumentCount++;
         if (unnamedIndex < unnamedParameterCount) {
           resolvedParameters[i] = unnamedParameters[unnamedIndex++];
         }
       }
     }
     if (positionalArgumentCount < requiredParameters.length) {
       ErrorCode errorCode = (reportError ? CompileTimeErrorCode.NOT_ENOUGH_REQUIRED_ARGUMENTS : StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS) as ErrorCode;
-      _resolver.reportError7(errorCode, argumentList, [requiredParameters.length, positionalArgumentCount]);
+      _resolver.reportError8(errorCode, argumentList, [requiredParameters.length, positionalArgumentCount]);
     } else if (positionalArgumentCount > unnamedParameterCount) {
       ErrorCode errorCode = (reportError ? CompileTimeErrorCode.EXTRA_POSITIONAL_ARGUMENTS : StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS) as ErrorCode;
-      _resolver.reportError7(errorCode, argumentList, [unnamedParameterCount, positionalArgumentCount]);
+      _resolver.reportError8(errorCode, argumentList, [unnamedParameterCount, positionalArgumentCount]);
     }
     return resolvedParameters;
   }
 
   /**
    * Resolve the names in the given combinators in the scope of the given library.
    *
    * @param library the library that defines the names
    * @param combinators the combinators containing the names to be resolved
    */
@@ skipping 306 matching lines @@
         TopLevelVariableDeclaration variableDeclaration = list.parent as TopLevelVariableDeclaration;
         addAnnotations(annotationList, variableDeclaration.metadata);
       }
     }
     if (!annotationList.isEmpty) {
       (element as ElementImpl).metadata = new List.from(annotationList);
     }
   }
 
   /**
+   * Given a node that can have annotations associated with it and the element to which that node
+   * has been resolved, create the annotations in the element model representing the annotations on
+   * the node.
+   *
+   * @param element the element to which the node has been resolved
+   * @param node the node that can have annotations associated with it
+   */
+  void setMetadata2(Element element, NormalFormalParameter node) {
+    if (element is! ElementImpl) {
+      return;
+    }
+    List<ElementAnnotationImpl> annotationList = new List<ElementAnnotationImpl>();
+    addAnnotations(annotationList, node.metadata);
+    if (!annotationList.isEmpty) {
+      (element as ElementImpl).metadata = new List.from(annotationList);
+    }
+  }
+
+  /**
    * Return `true` if we should report an error as a result of looking up a member in the
    * given type and not finding any member.
    *
    * @param type the type in which we attempted to perform the look-up
    * @param member the result of the look-up
    * @return `true` if we should report an error
    */
   bool shouldReportMissingMember(Type2 type, Element member) {
     if (member != null || type == null || type.isDynamic || type.isBottom) {
       return false;
@@ skipping 806 matching lines @@
    * AST structures.
    */
   Map<Source, ResolvableCompilationUnit> _astMap = new Map<Source, ResolvableCompilationUnit>();
 
   /**
    * The library scope used when resolving elements within this library's compilation units.
    */
   LibraryScope _libraryScope;
 
   /**
+   * An array of all top-level Angular elements that could be used in this library.
+   */
+  List<AngularElement> angularElements;
+
+  /**
    * An empty array that can be used to initialize lists of libraries.
    */
   static List<Library> _EMPTY_ARRAY = new List<Library>(0);
 
   /**
    * The prefix of a URI using the dart-ext scheme to reference a native code library.
    */
   static String _DART_EXT_SCHEME = "dart-ext:";
 
   /**
@@ skipping 169 matching lines @@
       Source source = _analysisContext.sourceFactory.resolveUri(librarySource, "${uriBase}.dll");
       if (source == null || !source.exists()) {
         source = _analysisContext.sourceFactory.resolveUri(librarySource, "${uriBase}.so");
         if (source == null || !source.exists()) {
           source = _analysisContext.sourceFactory.resolveUri(librarySource, "${uriBase}.dylib");
           if (source == null || !source.exists()) {
             _errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST, [uriContent]));
           }
         }
       }
+      _libraryElement.hasExtUri2 = true;
       return null;
     }
     try {
       parseUriWithException(uriContent);
       Source source = _analysisContext.sourceFactory.resolveUri(librarySource, uriContent);
       if (source == null || !source.exists()) {
         _errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST, [uriContent]));
       }
       return source;
     } on URISyntaxException catch (exception) {
@@ skipping 940 matching lines @@
         }
       }
     } finally {
       timeCounter.stop();
     }
     // Angular
     timeCounter = PerformanceStatistics.angular.start();
     try {
       for (Source source in library.compilationUnitSources) {
         CompilationUnit ast = library.getAST(source);
-        new AngularCompilationUnitBuilder(_errorListener, source).build(ast);
+        new AngularCompilationUnitBuilder(analysisContext, _errorListener, source).build(ast);
       }
+      // remember accessible Angular elements
+      LibraryElementImpl libraryElement = library.libraryElement;
+      library.angularElements = AngularCompilationUnitBuilder.getAngularElements(libraryElement);
     } finally {
       timeCounter.stop();
     }
   }
 
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * given library, or `null` if the URI is not valid.
    *
    * @param librarySource the source representing the library containing the directive
@@ skipping 1887 matching lines @@
    */
   Scope get nameScope => _nameScope;
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param node the node specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
-  void reportError7(ErrorCode errorCode, ASTNode node, List<Object> arguments) {
+  void reportError8(ErrorCode errorCode, ASTNode node, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(source, node.offset, node.length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param offset the offset of the location of the error
    * @param length the length of the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
-  void reportError8(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
+  void reportError9(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(source, offset, length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param token the token specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
-  void reportError9(ErrorCode errorCode, sc.Token token, List<Object> arguments) {
+  void reportError10(ErrorCode errorCode, sc.Token token, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(source, token.offset, token.length, errorCode, arguments));
   }
 
   /**
    * Visit the given AST node if it is not null.
    *
    * @param node the node to be visited
    */
   void safelyVisit(ASTNode node) {
     if (node != null) {
@@ skipping 1467 matching lines @@
    * @param argumentList the list of arguments from which a type is to be extracted
    * @return the type specified by the first argument in the argument list
    */
   Type2 getFirstArgumentAsQuery(LibraryElement library, ArgumentList argumentList) {
     String argumentValue = getFirstArgumentAsString(argumentList);
     if (argumentValue != null) {
       //
       // If the query has spaces, full parsing is required because it might be:
       //   E[text='warning text']
       //
-      if (argumentValue.contains(" ")) {
+      if (StringUtilities.indexOf1(argumentValue, 0, 0x20) >= 0) {
         return null;
       }
       //
       // Otherwise, try to extract the tag based on http://www.w3.org/TR/CSS2/selector.html.
       //
       String tag = argumentValue;
-      tag = StringUtilities.substringBefore(tag, ":");
-      tag = StringUtilities.substringBefore(tag, "[");
-      tag = StringUtilities.substringBefore(tag, ".");
-      tag = StringUtilities.substringBefore(tag, "#");
+      tag = StringUtilities.substringBeforeChar(tag, 0x3A);
+      tag = StringUtilities.substringBeforeChar(tag, 0x5B);
+      tag = StringUtilities.substringBeforeChar(tag, 0x2E);
+      tag = StringUtilities.substringBeforeChar(tag, 0x23);
       tag = _HTML_ELEMENT_TO_CLASS_MAP[tag.toLowerCase()];
       ClassElement returnType = library.getType(tag);
       if (returnType != null) {
         return returnType.type;
       }
     }
     return null;
   }
 
   /**
@@ skipping 1364 matching lines @@
       if (typeName is PrefixedIdentifier && parent is ConstructorName && argumentList == null) {
         ConstructorName name = parent;
         if (name.name == null) {
           PrefixedIdentifier prefixedIdentifier = typeName as PrefixedIdentifier;
           SimpleIdentifier prefix = prefixedIdentifier.prefix;
           element = nameScope.lookup(prefix, definingLibrary);
           if (element is PrefixElement) {
             if (parent.parent is InstanceCreationExpression && (parent.parent as InstanceCreationExpression).isConst) {
               // If, if this is a const expression, then generate a
               // CompileTimeErrorCode.CONST_WITH_NON_TYPE error.
-              reportError7(CompileTimeErrorCode.CONST_WITH_NON_TYPE, prefixedIdentifier.identifier, [prefixedIdentifier.identifier.name]);
+              reportError8(CompileTimeErrorCode.CONST_WITH_NON_TYPE, prefixedIdentifier.identifier, [prefixedIdentifier.identifier.name]);
             } else {
               // Else, if this expression is a new expression, report a NEW_WITH_NON_TYPE warning.
-              reportError7(StaticWarningCode.NEW_WITH_NON_TYPE, prefixedIdentifier.identifier, [prefixedIdentifier.identifier.name]);
+              reportError8(StaticWarningCode.NEW_WITH_NON_TYPE, prefixedIdentifier.identifier, [prefixedIdentifier.identifier.name]);
             }
             setElement(prefix, element);
             return null;
           } else if (element != null) {
             //
             // Rewrite the constructor name. The parser, when it sees a constructor named "a.b",
             // cannot tell whether "a" is a prefix and "b" is a class name, or whether "a" is a
             // class name and "b" is a constructor name. It arbitrarily chooses the former, but
             // in this case was wrong.
             //
             name.name = prefixedIdentifier.identifier;
             name.period = prefixedIdentifier.period;
             node.name = prefix;
             typeName = prefix;
           }
         }
       }
     }
     // check element
     bool elementValid = element is! MultiplyDefinedElement;
     if (elementValid && element is! ClassElement && isTypeNameInInstanceCreationExpression(node)) {
       SimpleIdentifier typeNameSimple = getTypeSimpleIdentifier(typeName);
       InstanceCreationExpression creation = node.parent.parent as InstanceCreationExpression;
       if (creation.isConst) {
         if (element == null) {
-          reportError7(CompileTimeErrorCode.UNDEFINED_CLASS, typeNameSimple, [typeName]);
+          reportError8(CompileTimeErrorCode.UNDEFINED_CLASS, typeNameSimple, [typeName]);
         } else {
-          reportError7(CompileTimeErrorCode.CONST_WITH_NON_TYPE, typeNameSimple, [typeName]);
+          reportError8(CompileTimeErrorCode.CONST_WITH_NON_TYPE, typeNameSimple, [typeName]);
         }
         elementValid = false;
       } else {
         if (element != null) {
-          reportError7(StaticWarningCode.NEW_WITH_NON_TYPE, typeNameSimple, [typeName]);
+          reportError8(StaticWarningCode.NEW_WITH_NON_TYPE, typeNameSimple, [typeName]);
           elementValid = false;
         }
       }
     }
     if (elementValid && element == null) {
       // We couldn't resolve the type name.
       // TODO(jwren) Consider moving the check for CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE
       // from the ErrorVerifier, so that we don't have two errors on a built in identifier being
       // used as a class name. See CompileTimeErrorCodeTest.test_builtInIdentifierAsType().
       SimpleIdentifier typeNameSimple = getTypeSimpleIdentifier(typeName);
       RedirectingConstructorKind redirectingConstructorKind;
       if (isBuiltInIdentifier(node) && isTypeAnnotation(node)) {
-        reportError7(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, typeName, [typeName.name]);
+        reportError8(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, typeName, [typeName.name]);
       } else if (typeNameSimple.name == "boolean") {
-        reportError7(StaticWarningCode.UNDEFINED_CLASS_BOOLEAN, typeNameSimple, []);
+        reportError8(StaticWarningCode.UNDEFINED_CLASS_BOOLEAN, typeNameSimple, []);
       } else if (isTypeNameInCatchClause(node)) {
-        reportError7(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName, [typeName.name]);
+        reportError8(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName, [typeName.name]);
       } else if (isTypeNameInAsExpression(node)) {
-        reportError7(StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
+        reportError8(StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
       } else if (isTypeNameInIsExpression(node)) {
-        reportError7(StaticWarningCode.TYPE_TEST_NON_TYPE, typeName, [typeName.name]);
+        reportError8(StaticWarningCode.TYPE_TEST_NON_TYPE, typeName, [typeName.name]);
       } else if ((redirectingConstructorKind = getRedirectingConstructorKind(node)) != null) {
         ErrorCode errorCode = (identical(redirectingConstructorKind, RedirectingConstructorKind.CONST) ? CompileTimeErrorCode.REDIRECT_TO_NON_CLASS : StaticWarningCode.REDIRECT_TO_NON_CLASS) as ErrorCode;
-        reportError7(errorCode, typeName, [typeName.name]);
+        reportError8(errorCode, typeName, [typeName.name]);
       } else if (isTypeNameInTypeArgumentList(node)) {
-        reportError7(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT, typeName, [typeName.name]);
+        reportError8(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT, typeName, [typeName.name]);
       } else {
-        reportError7(StaticWarningCode.UNDEFINED_CLASS, typeName, [typeName.name]);
+        reportError8(StaticWarningCode.UNDEFINED_CLASS, typeName, [typeName.name]);
       }
       elementValid = false;
     }
     if (!elementValid) {
       if (element is MultiplyDefinedElement) {
         setElement(typeName, element);
       } else {
         setElement(typeName, this._dynamicType.element);
       }
       typeName.staticType = this._dynamicType;
@@ skipping 15 matching lines @@
     } else if (element is MultiplyDefinedElement) {
       List<Element> elements = (element as MultiplyDefinedElement).conflictingElements;
       type = getType(elements);
       if (type != null) {
         node.type = type;
       }
     } else {
       // The name does not represent a type.
       RedirectingConstructorKind redirectingConstructorKind;
       if (isTypeNameInCatchClause(node)) {
-        reportError7(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName, [typeName.name]);
+        reportError8(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName, [typeName.name]);
       } else if (isTypeNameInAsExpression(node)) {
-        reportError7(StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
+        reportError8(StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
       } else if (isTypeNameInIsExpression(node)) {
-        reportError7(StaticWarningCode.TYPE_TEST_NON_TYPE, typeName, [typeName.name]);
+        reportError8(StaticWarningCode.TYPE_TEST_NON_TYPE, typeName, [typeName.name]);
       } else if ((redirectingConstructorKind = getRedirectingConstructorKind(node)) != null) {
         ErrorCode errorCode = (identical(redirectingConstructorKind, RedirectingConstructorKind.CONST) ? CompileTimeErrorCode.REDIRECT_TO_NON_CLASS : StaticWarningCode.REDIRECT_TO_NON_CLASS) as ErrorCode;
-        reportError7(errorCode, typeName, [typeName.name]);
+        reportError8(errorCode, typeName, [typeName.name]);
       } else if (isTypeNameInTypeArgumentList(node)) {
-        reportError7(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT, typeName, [typeName.name]);
+        reportError8(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT, typeName, [typeName.name]);
       } else {
         ASTNode parent = typeName.parent;
         while (parent is TypeName) {
           parent = parent.parent;
         }
         if (parent is ExtendsClause || parent is ImplementsClause || parent is WithClause || parent is ClassTypeAlias) {
         } else {
-          reportError7(StaticWarningCode.NOT_A_TYPE, typeName, [typeName.name]);
+          reportError8(StaticWarningCode.NOT_A_TYPE, typeName, [typeName.name]);
         }
       }
       setElement(typeName, this._dynamicType.element);
       typeName.staticType = this._dynamicType;
       node.type = this._dynamicType;
       return null;
     }
     if (argumentList != null) {
       NodeList<TypeName> arguments = argumentList.arguments;
       int argumentCount = arguments.length;
       List<Type2> parameters = getTypeArguments(type);
       int parameterCount = parameters.length;
       int count = Math.min(argumentCount, parameterCount);
       List<Type2> typeArguments = new List<Type2>();
       for (int i = 0; i < count; i++) {
         Type2 argumentType = getType3(arguments[i]);
         if (argumentType != null) {
           typeArguments.add(argumentType);
         }
       }
       if (argumentCount != parameterCount) {
-        reportError7(getInvalidTypeParametersErrorCode(node), node, [typeName.name, parameterCount, argumentCount]);
+        reportError8(getInvalidTypeParametersErrorCode(node), node, [typeName.name, parameterCount, argumentCount]);
       }
       argumentCount = typeArguments.length;
       if (argumentCount < parameterCount) {
         //
         // If there were too many arguments, we already handled it by not adding the values of the
         // extra arguments to the list. If there are too few, we handle it by adding 'dynamic'
         // enough times to make the count equal.
         //
         for (int i = argumentCount; i < parameterCount; i++) {
           typeArguments.add(this._dynamicType);
@@ skipping 352 matching lines @@
         TypeName typeName = typeNames[i];
         if (!detectedRepeatOnIndex[i]) {
           Element element = typeName.name.staticElement;
           for (int j = i + 1; j < typeNames.length; j++) {
             TypeName typeName2 = typeNames[j];
             Identifier identifier2 = typeName2.name;
             String name2 = identifier2.name;
             Element element2 = identifier2.staticElement;
             if (element != null && element == element2) {
               detectedRepeatOnIndex[j] = true;
-              reportError7(CompileTimeErrorCode.IMPLEMENTS_REPEATED, typeName2, [name2]);
+              reportError8(CompileTimeErrorCode.IMPLEMENTS_REPEATED, typeName2, [name2]);
             }
           }
         }
       }
     }
   }
 
   /**
    * Return the type specified by the given name.
    *
    * @param typeName the type name specifying the type to be returned
    * @param nonTypeError the error to produce if the type name is defined to be something other than
    *          a type
    * @param dynamicTypeError the error to produce if the type name is "dynamic"
    * @return the type specified by the type name
    */
   InterfaceType resolveType(TypeName typeName, ErrorCode nonTypeError, ErrorCode dynamicTypeError) {
     Type2 type = typeName.type;
     if (type is InterfaceType) {
       return type;
     }
     // If the type is not an InterfaceType, then visitTypeName() sets the type to be a DynamicTypeImpl
     Identifier name = typeName.name;
     if (name.name == sc.Keyword.DYNAMIC.syntax) {
-      reportError7(dynamicTypeError, name, [name.name]);
+      reportError8(dynamicTypeError, name, [name.name]);
     } else {
-      reportError7(nonTypeError, name, [name.name]);
+      reportError8(nonTypeError, name, [name.name]);
     }
     return null;
   }
 
   /**
    * Resolve the types in the given list of type names.
    *
    * @param typeNames the type names to be resolved
    * @param nonTypeError the error to produce if the type name is defined to be something other than
    *          a type
@@ skipping 994 matching lines @@
 /**
  * The abstract class `Scope` defines the behavior common to name scopes used by the resolver
  * to determine which names are visible at any given point in the code.
  *
  * @coverage dart.engine.resolver
  */
 abstract class Scope {
   /**
    * The prefix used to mark an identifier as being private to its library.
    */
-  static String PRIVATE_NAME_PREFIX = "_";
+  static int PRIVATE_NAME_PREFIX = 0x5F;
 
   /**
    * The suffix added to the declared name of a setter when looking up the setter. Used to
    * disambiguate between a getter and a setter that have the same name.
    */
   static String SETTER_SUFFIX = "=";
 
   /**
    * The name used to look up the method used to implement the unary minus operator. Used to
    * disambiguate between the unary and binary operators.
    */
   static String UNARY_MINUS = "unary-";
 
   /**
    * Return `true` if the given name is a library-private name.
    *
    * @param name the name being tested
    * @return `true` if the given name is a library-private name
    */
-  static bool isPrivateName(String name) => name != null && name.startsWith(PRIVATE_NAME_PREFIX);
+  static bool isPrivateName(String name) => name != null && StringUtilities.startsWithChar(name, PRIVATE_NAME_PREFIX);
 
   /**
    * A table mapping names that are defined in this scope to the element representing the thing
    * declared with that name.
    */
   Map<String, Element> _definedNames = new Map<String, Element>();
 
   /**
    * A flag indicating whether there are any names defined in this scope.
    */
@@ skipping 708 matching lines @@
    * with a [MethodDeclaration] in the AST structure.
    */
   bool _isInStaticMethod = false;
 
   /**
    * This is set to `true` iff the visitor is currently visiting code in the SDK.
    */
   bool _isInSystemLibrary = false;
 
   /**
+   * A flag indicating whether the current library contains at least one import directive with a URI
+   * that uses the "dart-ext" scheme.
+   */
+  bool _hasExtUri = false;
+
+  /**
    * The class containing the AST nodes being visited, or `null` if we are not in the scope of
    * a class.
    */
   ClassElement _enclosingClass;
 
   /**
    * The method or function that we are currently visiting, or `null` if we are not inside a
    * method or function.
    */
   ExecutableElement _enclosingFunction;
@@ skipping 49 matching lines @@
   /**
    * A list of types used by the [CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS] and
    * [CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS] error codes.
    */
   List<InterfaceType> _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT;
 
   ErrorVerifier(ErrorReporter errorReporter, LibraryElement currentLibrary, TypeProvider typeProvider, InheritanceManager inheritanceManager) {
     this._errorReporter = errorReporter;
     this._currentLibrary = currentLibrary;
     this._isInSystemLibrary = currentLibrary.source.isInSystemLibrary;
+    this._hasExtUri = currentLibrary.hasExtUri();
     this._typeProvider = typeProvider;
     this._inheritanceManager = inheritanceManager;
     _isEnclosingConstructorConst = false;
     _isInCatchClause = false;
     _isInStaticVariableDeclaration = false;
     _isInInstanceVariableDeclaration = false;
     _isInInstanceVariableInitializer = false;
     _isInConstructorInitializer = false;
     _isInStaticMethod = false;
     _boolType = typeProvider.boolType;
@@ skipping 2921 matching lines @@
       if (counterpartAccessor != null && identical(counterpartAccessor.enclosingElement, propertyAccessorElement.enclosingElement)) {
         return false;
       }
     }
     if (counterpartAccessor == null) {
       // If the accessor is declared in a class, check the superclasses.
       if (_enclosingClass != null) {
         // Figure out the correct identifier to lookup in the inheritance graph, if 'x', then 'x=',
         // or if 'x=', then 'x'.
         String lookupIdentifier = propertyAccessorElement.name;
-        if (lookupIdentifier.endsWith("=")) {
+        if (StringUtilities.endsWithChar(lookupIdentifier, 0x3D)) {
           lookupIdentifier = lookupIdentifier.substring(0, lookupIdentifier.length - 1);
         } else {
           lookupIdentifier += "=";
         }
         // lookup with the identifier.
         ExecutableElement elementFromInheritance = _inheritanceManager.lookupInheritance(_enclosingClass, lookupIdentifier);
         // Verify that we found something, and that it is an accessor
         if (elementFromInheritance != null && elementFromInheritance is PropertyAccessorElement) {
           enclosingClassForCounterpart = elementFromInheritance.enclosingElement as ClassElement;
           counterpartAccessor = elementFromInheritance;
@@ skipping 123 matching lines @@
   }
 
   /**
    * Checks to ensure that native function bodies can only in SDK code.
    *
    * @param node the native function body to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see ParserErrorCode#NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE
    */
   bool checkForNativeFunctionBodyInNonSDKCode(NativeFunctionBody node) {
-    // TODO(brianwilkerson) Figure out the right rule for when 'native' is allowed.
-    if (!_isInSystemLibrary) {
+    if (!_isInSystemLibrary && !_hasExtUri) {
       _errorReporter.reportError3(ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed 'new' instance creation expression invokes existing constructor.
    *
    * This method assumes that the instance creation was tested to be 'new' before being called.
@@ skipping 362 matching lines @@
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#PRIVATE_OPTIONAL_PARAMETER
    */
   bool checkForPrivateOptionalParameter(FormalParameter node) {
     // should be named parameter
     if (node.kind != ParameterKind.NAMED) {
       return false;
     }
     // name should start with '_'
     SimpleIdentifier name = node.identifier;
-    if (name.isSynthetic || !name.name.startsWith("_")) {
+    if (name.isSynthetic || !StringUtilities.startsWithChar(name.name, 0x5F)) {
       return false;
     }
     // report problem
     _errorReporter.reportError3(CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER, node, []);
     return true;
   }
 
   /**
    * This checks if the passed constructor declaration is the redirecting generative constructor and
    * references itself directly or indirectly.
@@ skipping 1165 matching lines @@
 
   /**
    * The template used to create the message to be displayed for this error.
    */
   final String message;
 
   /**
    * The template used to create the correction to be displayed for this error, or `null` if
    * there is no correction information for this error.
    */
-  String correction10;
+  String correction9;
 
   /**
    * Initialize a newly created error code to have the given type and message.
    *
    * @param type the type of this error
    * @param message the message template used to create the message to be displayed for the error
    */
   ResolverErrorCode.con1(String name, int ordinal, this.type, this.message) : super(name, ordinal);
 
   /**
    * Initialize a newly created error code to have the given type, message and correction.
    *
    * @param type the type of this error
    * @param message the template used to create the message to be displayed for the error
    * @param correction the template used to create the correction to be displayed for the error
    */
   ResolverErrorCode.con2(String name, int ordinal, this.type, this.message, String correction) : super(name, ordinal) {
-    this.correction10 = correction;
+    this.correction9 = correction;
   }
 
-  String get correction => correction10;
+  String get correction => correction9;
 
   ErrorSeverity get errorSeverity => type.severity;
 }