Analyzer snapshot.

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

 // 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';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
 import 'error.dart';
 import 'scanner.dart' as sc;
 import 'utilities_dart.dart';
 import 'utilities_general.dart';
 import 'ast.dart';
 import 'parser.dart' show Parser, ParserErrorCode;
 import 'sdk.dart' show DartSdk, SdkLibrary;
 import 'element.dart';
 import 'html.dart' as ht;
 import 'engine.dart';
 import 'constant.dart';
 
 /**
+ * Instances of the class `AngularCompilationUnitBuilder` build an Angular specific element
+ * model for a single compilation unit.
+ *
+ * @coverage dart.engine.resolver
+ */
+class AngularCompilationUnitBuilder {
+  static String _NG_COMPONENT = "NgComponent";
+
+  static String _NG_CONTROLLER = "NgController";
+
+  static String _NG_FILTER = "NgFilter";
+
+  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";
+
+  /**
+   * 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;
+    Set<Type2> seenTypes = new Set();
+    while (interfaceType != null) {
+      if (!seenTypes.add(interfaceType)) {
+        return false;
+      }
+      if (interfaceType.element.name == "Module") {
+        return true;
+      }
+      interfaceType = interfaceType.superclass;
+    }
+    return false;
+  }
+
+  static bool isTagName(String s) {
+    if (s == null || s.length == 0) {
+      return false;
+    }
+    int sz = s.length;
+    for (int i = 0; i < sz; i++) {
+      int c = s.codeUnitAt(i);
+      if (!Character.isLetter(c)) {
+        if (i == 0) {
+          return false;
+        }
+        if (!Character.isDigit(c) && c != 0x2D) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Parses given selector text and returns [AngularSelector]. May be `null` if cannot
+   * parse.
+   */
+  static AngularSelector parseSelector(String text) {
+    if (text.startsWith("[") && text.endsWith("]")) {
+      return new HasAttributeSelector(text.substring(1, text.length - 1));
+    }
+    if (StringUtilities.isTagName(text)) {
+      return new IsTagSelector(text);
+    }
+    return null;
+  }
+
+  /**
+   * 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 as SimpleStringLiteral;
+        }
+      }
+    }
+    return nameLiteral;
+  }
+
+  /**
+   * Checks if given [LocalVariableElement] is an Angular <code>Module</code>.
+   */
+  static bool isModule2(VariableDeclaration node) {
+    Type2 type = node.name.bestType;
+    return isModule(type);
+  }
+
+  /**
+   * The source containing the unit that will be analyzed.
+   */
+  Source _source;
+
+  /**
+   * The listener to which errors will be reported.
+   */
+  AnalysisErrorListener _errorListener;
+
+  /**
+   * 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) {
+    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) {
+    for (CompilationUnitMember unitMember in unit.declarations) {
+      if (unitMember is ClassDeclaration) {
+        this._classDeclaration = unitMember as ClassDeclaration;
+        this._classElement = _classDeclaration.element as ClassElementImpl;
+        this._classToolkitObjects.clear();
+        parseModuleClass();
+        NodeList<Annotation> annotations = _classDeclaration.metadata;
+        for (Annotation annotation in annotations) {
+          this._annotation = annotation;
+          if (isAngularAnnotation2(_NG_FILTER)) {
+            parseNgFilter();
+            continue;
+          }
+          if (isAngularAnnotation2(_NG_COMPONENT)) {
+            parseNgComponent();
+            continue;
+          }
+          if (isAngularAnnotation2(_NG_CONTROLLER)) {
+            parseNgController();
+            continue;
+          }
+        }
+        if (!_classToolkitObjects.isEmpty) {
+          List<ToolkitObjectElement> objects = _classToolkitObjects;
+          _classElement.toolkitObjects = new List.from(objects);
+        }
+      }
+    }
+    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 as NamedExpression;
+        String argumentName = namedExpression.name.label.name;
+        if (name == argumentName) {
+          return namedExpression.expression;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * @return the [String] value of the named argument.
+   */
+  String getStringArgument(String name) {
+    Expression argument = getArgument(name);
+    return (argument as SimpleStringLiteral).value;
+  }
+
+  /**
+   * @return the offset of the value of the named argument.
+   */
+  int getStringArgumentOffset(String name) {
+    Expression argument = getArgument(name);
+    return (argument as SimpleStringLiteral).valueOffset;
+  }
+
+  /**
+   * Checks if [namedArguments] has string value for the argument with the given name.
+   */
+  bool hasStringArgument(String name) {
+    Expression argument = getArgument(name);
+    return argument is SimpleStringLiteral;
+  }
+
+  /**
+   * Checks if given [Annotation] is an annotation with required name.
+   */
+  bool isAngularAnnotation(Annotation annotation, String name) {
+    Element element = annotation.element;
+    if (element is ConstructorElement) {
+      ConstructorElement constructorElement = element as ConstructorElement;
+      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;
+    }
+    List<AngularModuleElement> childModules = [];
+    List<ClassElement> keyTypes = [];
+    _classDeclaration.accept(new RecursiveASTVisitor_8(this, childModules, keyTypes));
+    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;
+    if (arguments.length == 1 && methodName == "install") {
+      Type2 argType = arguments[0].bestType;
+      if (argType is InterfaceType) {
+        ClassElement argElement = (argType as InterfaceType).element;
+        List<ToolkitObjectElement> toolkitObjects = argElement.toolkitObjects;
+        for (ToolkitObjectElement toolkitObject in toolkitObjects) {
+          if (toolkitObject is AngularModuleElement) {
+            childModules.add(toolkitObject as AngularModuleElement);
+          }
+        }
+      }
+      return;
+    }
+    if (arguments.length >= 1 && (methodName == "type" || methodName == "value")) {
+      Expression arg = arguments[0];
+      if (arg is Identifier) {
+        Element argElement = (arg as Identifier).staticElement;
+        if (argElement is ClassElement) {
+          keyTypes.add(argElement as ClassElement);
+        }
+      }
+      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_9(this));
+  }
+
+  void parseNgComponent() {
+    bool isValid = true;
+    if (!hasStringArgument(_PUBLISH_AS)) {
+      reportErrorForAnnotation(AngularCode.MISSING_PUBLISH_AS, []);
+      isValid = false;
+    }
+    AngularSelector selector = null;
+    if (!hasStringArgument(_SELECTOR)) {
+      reportErrorForAnnotation(AngularCode.MISSING_SELECTOR, []);
+      isValid = false;
+    } else {
+      String selectorText = getStringArgument(_SELECTOR);
+      selector = parseSelector(selectorText);
+      if (selector == null) {
+        reportErrorForArgument(_SELECTOR, AngularCode.CANNOT_PARSE_SELECTOR, [selectorText]);
+        isValid = false;
+      }
+    }
+    if (!hasStringArgument(_TEMPLATE_URL)) {
+      reportErrorForAnnotation(AngularCode.MISSING_TEMPLATE_URL, []);
+      isValid = false;
+    }
+    if (!hasStringArgument(_CSS_URL)) {
+      reportErrorForAnnotation(AngularCode.MISSING_CSS_URL, []);
+      isValid = false;
+    }
+    if (isValid) {
+      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;
+      element.styleUri = styleUri;
+      element.styleUriOffset = styleUriOffset;
+      element.properties = parseNgComponentProperties();
+      _classToolkitObjects.add(element);
+    }
+  }
+
+  /**
+   * Parses [AngularPropertyElement]s from [annotation] and [classDeclaration].
+   */
+  List<AngularPropertyElement> parseNgComponentProperties() {
+    List<AngularPropertyElement> properties = [];
+    parseNgComponentProperties_fromMap(properties);
+    parseNgComponentProperties_fromFields(properties);
+    return new List.from(properties);
+  }
+
+  /**
+   * Parses [AngularPropertyElement]s from [annotation].
+   */
+  void parseNgComponentProperties_fromFields(List<AngularPropertyElement> properties) {
+    NodeList<ClassMember> members = _classDeclaration.members;
+    for (ClassMember member in members) {
+      if (member is FieldDeclaration) {
+        FieldDeclaration fieldDeclaration = member as FieldDeclaration;
+        for (Annotation annotation in fieldDeclaration.metadata) {
+          AngularPropertyKind kind = null;
+          if (isAngularAnnotation(annotation, _NG_ATTR)) {
+            kind = AngularPropertyKind.ATTR;
+          } else if (isAngularAnnotation(annotation, _NG_CALLBACK)) {
+            kind = AngularPropertyKind.CALLBACK;
+          } else if (isAngularAnnotation(annotation, _NG_ONE_WAY)) {
+            kind = AngularPropertyKind.ONE_WAY;
+          } else if (isAngularAnnotation(annotation, _NG_ONE_WAY_ONE_TIME)) {
+            kind = AngularPropertyKind.ONE_WAY_ONE_TIME;
+          } else if (isAngularAnnotation(annotation, _NG_TWO_WAY)) {
+            kind = AngularPropertyKind.TWO_WAY;
+          }
+          if (kind != null) {
+            SimpleStringLiteral nameLiteral = getOnlySimpleStringLiteralArgument(annotation);
+            FieldElement field = getOnlyFieldElement(fieldDeclaration);
+            if (nameLiteral != null && field != null) {
+              AngularPropertyElementImpl property = new AngularPropertyElementImpl(nameLiteral.value, nameLiteral.valueOffset);
+              property.field = field;
+              property.propertyKind = kind;
+              properties.add(property);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Parses [AngularPropertyElement]s from [annotation].
+   */
+  void parseNgComponentProperties_fromMap(List<AngularPropertyElement> properties) {
+    Expression mapExpression = getArgument("map");
+    if (mapExpression == null) {
+      return;
+    }
+    if (mapExpression is! MapLiteral) {
+      reportError(mapExpression, AngularCode.INVALID_PROPERTY_MAP, []);
+      return;
+    }
+    MapLiteral mapLiteral = mapExpression as MapLiteral;
+    for (MapLiteralEntry entry in mapLiteral.entries) {
+      Expression nameExpression = entry.key;
+      if (nameExpression is! SimpleStringLiteral) {
+        reportError(nameExpression, AngularCode.INVALID_PROPERTY_NAME, []);
+        continue;
+      }
+      SimpleStringLiteral nameLiteral = nameExpression as SimpleStringLiteral;
+      String name = nameLiteral.value;
+      int nameOffset = nameLiteral.valueOffset;
+      Expression specExpression = entry.value;
+      if (specExpression is! SimpleStringLiteral) {
+        reportError(specExpression, AngularCode.INVALID_PROPERTY_SPEC, []);
+        continue;
+      }
+      SimpleStringLiteral specLiteral = specExpression as SimpleStringLiteral;
+      String spec = specLiteral.value;
+      AngularPropertyKind kind;
+      int fieldNameOffset;
+      if (spec.startsWith(_PREFIX_ATTR)) {
+        kind = AngularPropertyKind.ATTR;
+        fieldNameOffset = 1;
+      } else if (spec.startsWith(_PREFIX_CALLBACK)) {
+        kind = AngularPropertyKind.CALLBACK;
+        fieldNameOffset = 1;
+      } else if (spec.startsWith(_PREFIX_ONE_WAY_ONE_TIME)) {
+        kind = AngularPropertyKind.ONE_WAY_ONE_TIME;
+        fieldNameOffset = 3;
+      } else if (spec.startsWith(_PREFIX_ONE_WAY)) {
+        kind = AngularPropertyKind.ONE_WAY;
+        fieldNameOffset = 2;
+      } else if (spec.startsWith(_PREFIX_TWO_WAY)) {
+        kind = AngularPropertyKind.TWO_WAY;
+        fieldNameOffset = 3;
+      } else {
+        reportError(specLiteral, AngularCode.INVALID_PROPERTY_KIND, [spec]);
+        continue;
+      }
+      String fieldName = spec.substring(fieldNameOffset);
+      fieldNameOffset += specLiteral.valueOffset;
+      FieldElement field = _classElement.getField(fieldName);
+      if (field == null) {
+        reportError(specLiteral, AngularCode.INVALID_PROPERTY_FIELD, [fieldName]);
+        continue;
+      }
+      AngularPropertyElementImpl property = new AngularPropertyElementImpl(name, nameOffset);
+      property.field = field;
+      property.propertyKind = kind;
+      property.fieldNameOffset = fieldNameOffset;
+      properties.add(property);
+    }
+  }
+
+  void parseNgController() {
+    bool isValid = true;
+    if (!hasStringArgument(_PUBLISH_AS)) {
+      reportErrorForAnnotation(AngularCode.MISSING_PUBLISH_AS, []);
+      isValid = false;
+    }
+    AngularSelector selector = null;
+    if (!hasStringArgument(_SELECTOR)) {
+      reportErrorForAnnotation(AngularCode.MISSING_SELECTOR, []);
+      isValid = false;
+    } else {
+      String selectorText = getStringArgument(_SELECTOR);
+      selector = parseSelector(selectorText);
+      if (selector == null) {
+        reportErrorForArgument(_SELECTOR, AngularCode.CANNOT_PARSE_SELECTOR, [selectorText]);
+        isValid = false;
+      }
+    }
+    if (isValid) {
+      String name = getStringArgument(_PUBLISH_AS);
+      int nameOffset = getStringArgumentOffset(_PUBLISH_AS);
+      AngularControllerElementImpl element = new AngularControllerElementImpl(name, nameOffset);
+      element.selector = selector;
+      _classToolkitObjects.add(element);
+    }
+  }
+
+  void parseNgFilter() {
+    bool isValid = true;
+    if (!hasStringArgument(_NAME)) {
+      reportErrorForAnnotation(AngularCode.MISSING_NAME, []);
+      isValid = false;
+    }
+    if (isValid) {
+      String name = getStringArgument(_NAME);
+      int nameOffset = getStringArgumentOffset(_NAME);
+      _classToolkitObjects.add(new AngularFilterElementImpl(name, nameOffset));
+    }
+  }
+
+  void reportError(ASTNode node, ErrorCode errorCode, List<Object> arguments) {
+    _errorListener.onError(new AnalysisError.con2(_source, node.offset, node.length, errorCode, arguments));
+  }
+
+  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_8 extends RecursiveASTVisitor<Object> {
+  final AngularCompilationUnitBuilder AngularCompilationUnitBuilder_this;
+
+  List<AngularModuleElement> childModules;
+
+  List<ClassElement> keyTypes;
+
+  RecursiveASTVisitor_8(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_9 extends RecursiveASTVisitor<Object> {
+  final AngularCompilationUnitBuilder AngularCompilationUnitBuilder_this;
+
+  RecursiveASTVisitor_9(this.AngularCompilationUnitBuilder_this) : super();
+
+  LocalVariableElementImpl _variable = null;
+
+  Expression _variableInit = null;
+
+  List<AngularModuleElement> _childModules = [];
+
+  List<ClassElement> _keyTypes = [];
+
+  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 as LocalVariableElementImpl;
+      _variableInit = node.initializer;
+    }
+    return super.visitVariableDeclaration(node);
+  }
+
+  bool isVariableInvocation(MethodInvocation node) {
+    Expression target = node.realTarget;
+    if (_variableInit is CascadeExpression && target != null && identical(target.parent, _variableInit)) {
+      return true;
+    }
+    if (target is Identifier) {
+      Element targetElement = (target as Identifier).staticElement;
+      return identical(targetElement, _variable);
+    }
+    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.
    *
    * @param source the source describing the compilation unit
@@ skipping 1256 matching lines @@
   }
 
   /**
    * Return the first source attribute for the given tag node, or `null` if it does not exist.
    *
    * @param node the node containing attributes
    * @return the source attribute contained in the given tag
    */
   ht.XmlAttributeNode getScriptSourcePath(ht.XmlTagNode node) {
     for (ht.XmlAttributeNode attribute in node.attributes) {
-      if (attribute.name.lexeme == _SRC) {
+      if (attribute.name == _SRC) {
         return attribute;
       }
     }
     return null;
   }
 
   Object reportCircularity(ht.XmlTagNode node) {
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append("Found circularity in XML nodes: ");
     bool first = true;
     for (ht.XmlTagNode pathNode in _parentNodes) {
       if (first) {
         first = false;
       } else {
         builder.append(", ");
       }
-      String tagName = pathNode.tag.lexeme;
+      String tagName = pathNode.tag;
       if (identical(pathNode, node)) {
         builder.append("*");
         builder.append(tagName);
         builder.append("*");
       } else {
         builder.append(tagName);
       }
     }
     AnalysisEngine.instance.logger.logError(builder.toString());
     return null;
@@ skipping 15 matching lines @@
   /**
    * Report an error with the given error code at the location of the value of the given attribute.
    * Use the given arguments to compose the error message.
    *
    * @param errorCode the error code of the error to be reported
    * @param offset the offset of the first character to be highlighted
    * @param length the number of characters to be highlighted
    * @param arguments the arguments used to compose the error message
    */
   void reportValueError(ErrorCode errorCode, ht.XmlAttributeNode attribute, List<Object> arguments) {
-    int offset = attribute.value.offset + 1;
-    int length = attribute.value.length - 2;
+    int offset = attribute.valueToken.offset + 1;
+    int length = attribute.valueToken.length - 2;
     reportError(errorCode, offset, length, arguments);
   }
 
   void resolveExpression(Expression expression) {
   }
 }
 
 /**
  * Instances of the class `BestPracticesVerifier` traverse an AST structure looking for
  * violations of Dart best practices.
@@ skipping 1849 matching lines @@
           if (prefixElement != null && prefix.name == prefixElement.displayName) {
             return element;
           }
         }
       }
     }
     return null;
   }
 
   void gatherElements(Element element) {
-    element.accept(new GeneralizingElementVisitor_8(this));
+    element.accept(new GeneralizingElementVisitor_10(this));
   }
 
   /**
    * Search the most closely enclosing list of parameters for a parameter with the given name.
    *
    * @param node the node defining the parameter with the given name
    * @param parameterName the name of the parameter being searched for
    * @return the element representing the parameter with that name
    */
   ParameterElement getElementForParameter(FormalParameter node, SimpleIdentifier parameterName) {
@@ skipping 41 matching lines @@
 }
 
 /**
  * Instances of the class `DeclarationMismatchException` represent an exception that is
  * thrown when the element model defined by a given AST structure does not match an existing
  * element model.
  */
 class DeclarationMatcher_DeclarationMismatchException extends RuntimeException {
 }
 
-class GeneralizingElementVisitor_8 extends GeneralizingElementVisitor<Object> {
+class GeneralizingElementVisitor_10 extends GeneralizingElementVisitor<Object> {
   final DeclarationMatcher DeclarationMatcher_this;
 
-  GeneralizingElementVisitor_8(this.DeclarationMatcher_this) : super();
+  GeneralizingElementVisitor_10(this.DeclarationMatcher_this) : super();
 
   Object visitElement(Element element) {
     DeclarationMatcher_this._allElements.add(element);
     DeclarationMatcher_this._unmatchedElements.add(element);
     return super.visitElement(element);
   }
 }
 
 /**
  * Instances of the class `DeclarationResolver` are used to resolve declarations in an AST
@@ skipping 867 matching lines @@
         }
       }
       setMetadata(constructorElement, node);
     }
     return null;
   }
 
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     SimpleIdentifier fieldName = node.fieldName;
     ClassElement enclosingClass = _resolver.enclosingClass;
-    FieldElement fieldElement = (enclosingClass as ClassElementImpl).getField(fieldName.name);
+    FieldElement fieldElement = enclosingClass.getField(fieldName.name);
     fieldName.staticElement = fieldElement;
     if (fieldElement == null || fieldElement.isSynthetic) {
       _resolver.reportError6(CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
     } else if (fieldElement.isStatic) {
       _resolver.reportError6(CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node, [fieldName]);
     }
     return null;
   }
 
   Object visitConstructorName(ConstructorName node) {
@@ skipping 43 matching lines @@
       resolveCombinators((element as ExportElement).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 as ClassElementImpl).getField(fieldName);
+      FieldElement fieldElement = classElement.getField(fieldName);
       if (fieldElement == null) {
         _resolver.reportError6(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
       } else {
         ParameterElement parameterElement = node.element;
         if (parameterElement is FieldFormalParameterElementImpl) {
           FieldFormalParameterElementImpl fieldFormal = parameterElement as FieldFormalParameterElementImpl;
           fieldFormal.field = fieldElement;
           Type2 declaredType = fieldFormal.type;
           Type2 fieldType = fieldElement.type;
           if (node.type == null) {
@@ skipping 3495 matching lines @@
         ast.accept(visitor);
         for (ProxyConditionalAnalysisError conditionalCode in visitor.proxyConditionalAnalysisErrors) {
           if (conditionalCode.shouldIncludeErrorCode()) {
             visitor.reportError(conditionalCode.analysisError);
           }
         }
       }
     } finally {
       timeCounter.stop();
     }
+    timeCounter = PerformanceStatistics.angular.start();
+    try {
+      for (Source source in library.compilationUnitSources) {
+        CompilationUnit ast = library.getAST(source);
+        new AngularCompilationUnitBuilder(_errorListener, source).build(ast);
+      }
+    } 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
    * @param directive the directive which URI should be resolved
    * @return the result of resolving the URI against the URI of the library
    */
@@ skipping 412 matching lines @@
       _typeAnalyzer.thisType = _enclosingClass == null ? null : _enclosingClass.type;
       super.visitClassDeclaration(node);
     } finally {
       _typeAnalyzer.thisType = outerType == null ? null : outerType.type;
       _enclosingClass = outerType;
     }
     return null;
   }
 
   Object visitComment(Comment node) {
-    if (node.parent is FunctionDeclaration || node.parent is MethodDeclaration) {
+    if (node.parent is FunctionDeclaration || node.parent is ConstructorDeclaration || node.parent is MethodDeclaration) {
       if (node != _commentBeforeFunction) {
         _commentBeforeFunction = node;
         return null;
       }
     }
     super.visitComment(node);
     _commentBeforeFunction = null;
     return null;
   }
 
@@ skipping 743 matching lines @@
    * Return `true` if the given variable is accessed within a closure in the given
    * [ASTNode] and also mutated somewhere in variable scope. This information is only
    * available for local variables (including parameters).
    *
    * @param variable the variable to check
    * @param target the [ASTNode] to check within
    * @return `true` if this variable is potentially mutated somewhere in the given ASTNode
    */
   bool isVariableAccessedInClosure(Element variable, ASTNode target) {
     List<bool> result = [false];
-    target.accept(new RecursiveASTVisitor_9(result, variable));
+    target.accept(new RecursiveASTVisitor_11(result, variable));
     return result[0];
   }
 
   /**
    * Return `true` if the given variable is potentially mutated somewhere in the given
    * [ASTNode]. This information is only available for local variables (including parameters).
    *
    * @param variable the variable to check
    * @param target the [ASTNode] to check within
    * @return `true` if this variable is potentially mutated somewhere in the given ASTNode
    */
   bool isVariablePotentiallyMutatedIn(Element variable, ASTNode target) {
     List<bool> result = [false];
-    target.accept(new RecursiveASTVisitor_10(result, variable));
+    target.accept(new RecursiveASTVisitor_12(result, variable));
     return result[0];
   }
 
   /**
    * If it is appropriate to do so, promotes the current type of the static element associated with
    * the given expression with the given type. Generally speaking, it is appropriate if the given
    * type is more specific than the current type.
    *
    * @param expression the expression used to access the static element whose types might be
    *          promoted
@@ skipping 136 matching lines @@
 
   get typeAnalyzer_J2DAccessor => _typeAnalyzer;
 
   set typeAnalyzer_J2DAccessor(__v) => _typeAnalyzer = __v;
 
   get enclosingClass_J2DAccessor => _enclosingClass;
 
   set enclosingClass_J2DAccessor(__v) => _enclosingClass = __v;
 }
 
-class RecursiveASTVisitor_9 extends RecursiveASTVisitor<Object> {
+class RecursiveASTVisitor_11 extends RecursiveASTVisitor<Object> {
   List<bool> result;
 
   Element variable;
 
-  RecursiveASTVisitor_9(this.result, this.variable) : super();
+  RecursiveASTVisitor_11(this.result, this.variable) : super();
 
   bool _inClosure = false;
 
   Object visitFunctionExpression(FunctionExpression node) {
     bool inClosure = this._inClosure;
     try {
       this._inClosure = true;
       return super.visitFunctionExpression(node);
     } finally {
       this._inClosure = inClosure;
     }
   }
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (result[0]) {
       return null;
     }
     if (_inClosure && identical(node.staticElement, variable)) {
       result[0] = javaBooleanOr(result[0], true);
     }
     return null;
   }
 }
 
-class RecursiveASTVisitor_10 extends RecursiveASTVisitor<Object> {
+class RecursiveASTVisitor_12 extends RecursiveASTVisitor<Object> {
   List<bool> result;
 
   Element variable;
 
-  RecursiveASTVisitor_10(this.result, this.variable) : super();
+  RecursiveASTVisitor_12(this.result, this.variable) : super();
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (result[0]) {
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result[0] = javaBooleanOr(result[0], true);
       }
     }
@@ skipping 1754 matching lines @@
    * @param body the boy of the function whose propagated return type is to be computed
    * @return the propagated return type that was computed
    */
   Type2 computePropagatedReturnType2(FunctionBody body) {
     if (body is ExpressionFunctionBody) {
       ExpressionFunctionBody expressionBody = body as ExpressionFunctionBody;
       return expressionBody.expression.bestType;
     }
     if (body is BlockFunctionBody) {
       List<Type2> result = [null];
-      body.accept(new GeneralizingASTVisitor_11(result));
+      body.accept(new GeneralizingASTVisitor_13(result));
       return result[0];
     }
     return null;
   }
 
   /**
    * Compute the static return type of the method or function represented by the given element.
    *
    * @param element the element representing the method or function invoked by the given node
    * @return the static return type that was computed
@@ skipping 342 matching lines @@
       }
     }
     return staticType;
   }
 
   get thisType_J2DAccessor => _thisType;
 
   set thisType_J2DAccessor(__v) => _thisType = __v;
 }
 
-class GeneralizingASTVisitor_11 extends GeneralizingASTVisitor<Object> {
+class GeneralizingASTVisitor_13 extends GeneralizingASTVisitor<Object> {
   List<Type2> result;
 
-  GeneralizingASTVisitor_11(this.result) : super();
+  GeneralizingASTVisitor_13(this.result) : super();
 
   Object visitExpression(Expression node) => null;
 
   Object visitReturnStatement(ReturnStatement node) {
     Type2 type;
     Expression expression = node.expression;
     if (expression != null) {
       type = expression.bestType;
     } else {
       type = BottomTypeImpl.instance;
@@ skipping 3120 matching lines @@
   }
 
   /**
    * Validates that the given expression is a compile time constant.
    *
    * @param parameterElements the elements of parameters of constant constructor, they are
    *          considered as a valid potentially constant expressions
    * @param expression the expression to validate
    */
   void validateInitializerExpression(List<ParameterElement> parameterElements, Expression expression) {
-    EvaluationResultImpl result = expression.accept(new ConstantVisitor_14(_typeProvider, this, parameterElements));
+    EvaluationResultImpl result = expression.accept(new ConstantVisitor_16(_typeProvider, this, parameterElements));
     reportErrors(result, CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER);
   }
 
   /**
    * Validates that all of the arguments of a constructor initializer are compile time constants.
    *
    * @param parameterElements the elements of parameters of constant constructor, they are
    *          considered as a valid potentially constant expressions
    * @param argumentList the argument list to validate
    */
@@ skipping 25 matching lines @@
         validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
       }
       if (initializer is SuperConstructorInvocation) {
         SuperConstructorInvocation invocation = initializer as SuperConstructorInvocation;
         validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
       }
     }
   }
 }
 
-class ConstantVisitor_14 extends ConstantVisitor {
+class ConstantVisitor_16 extends ConstantVisitor {
   final ConstantVerifier ConstantVerifier_this;
 
   List<ParameterElement> parameterElements;
 
-  ConstantVisitor_14(TypeProvider arg0, this.ConstantVerifier_this, this.parameterElements) : super(arg0);
+  ConstantVisitor_16(TypeProvider arg0, this.ConstantVerifier_this, this.parameterElements) : super(arg0);
 
   EvaluationResultImpl visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     for (ParameterElement parameterElement in parameterElements) {
       if (identical(parameterElement, element) && parameterElement != null) {
         Type2 type = parameterElement.type;
         if (type != null) {
           if (type.isDynamic) {
             return ConstantVerifier_this.valid(ConstantVerifier_this._typeProvider.objectType, DynamicState.DYNAMIC_STATE);
           } else if (type.isSubtypeOf(ConstantVerifier_this._boolType)) {
@@ skipping 1610 matching lines @@
       if (name == otherConstructor.name) {
         if (name == null || name.length == 0) {
           _errorReporter.reportError2(CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT, node, []);
         } else {
           _errorReporter.reportError2(CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME, node, [name]);
         }
         return true;
       }
     }
     if (constructorName != null && constructorElement != null && !constructorName.isSynthetic) {
-      List<FieldElement> fields = classElement.fields;
-      for (FieldElement field in fields) {
-        if (field.name == name) {
-          _errorReporter.reportError2(CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD, node, [name]);
-          return true;
-        }
+      FieldElement field = classElement.getField(name);
+      if (field != null) {
+        _errorReporter.reportError2(CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD, node, [name]);
+        return true;
       }
-      List<MethodElement> methods = classElement.methods;
-      for (MethodElement method in methods) {
-        if (method.name == name) {
-          _errorReporter.reportError2(CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD, node, [name]);
-          return true;
-        }
+      MethodElement method = classElement.getMethod(name);
+      if (method != null) {
+        _errorReporter.reportError2(CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD, node, [name]);
+        return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the [enclosingClass] does not have method and getter with the same
    * names.
    *
    * @return `true` if and only if an error code is generated on the passed node
@@ skipping 2487 matching lines @@
             firstIteration = false;
             break;
           } else {
             return true;
           }
         }
         if (current != null && !checked.contains(current)) {
           break;
         }
       }
-      current.accept(new GeneralizingElementVisitor_15(target, toCheck));
+      current.accept(new GeneralizingElementVisitor_17(target, toCheck));
       checked.add(current);
     }
   }
 
   /**
    * @return `true` if given [Type] implements operator <i>==</i>, and it is not
    *         <i>int</i> or <i>String</i>.
    */
   bool implementsEqualsWhenNotAllowed(Type2 type) {
     if (type == null || type == _typeProvider.intType || type == _typeProvider.stringType) {
@@ skipping 241 matching lines @@
 
   static final List<INIT_STATE> values = [
       NOT_INIT,
       INIT_IN_DECLARATION,
       INIT_IN_FIELD_FORMAL,
       INIT_IN_INITIALIZERS];
 
   INIT_STATE(String name, int ordinal) : super(name, ordinal);
 }
 
-class GeneralizingElementVisitor_15 extends GeneralizingElementVisitor<Object> {
+class GeneralizingElementVisitor_17 extends GeneralizingElementVisitor<Object> {
   Element target;
 
   List<Element> toCheck;
 
-  GeneralizingElementVisitor_15(this.target, this.toCheck) : super();
+  GeneralizingElementVisitor_17(this.target, this.toCheck) : super();
 
   bool _inClass = false;
 
   Object visitClassElement(ClassElement element) {
     addTypeToCheck(element.supertype);
     for (InterfaceType mixin in element.mixins) {
       addTypeToCheck(mixin);
     }
     _inClass = !element.isTypedef;
     try {
@@ skipping 76 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 correction9;
+  String correction10;
 
   /**
    * 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.correction9 = correction;
+    this.correction10 = correction;
   }
 
-  String get correction => correction9;
+  String get correction => correction10;
 
   ErrorSeverity get errorSeverity => type.severity;
 }