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 11 matching lines @@
 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.
  */
 class AngularCompilationUnitBuilder {
-  static String _NG_COMPONENT = "NgComponent";
+  static String _NG_COMPONENT = "Component";
 
-  static String _NG_CONTROLLER = "NgController";
+  static String _NG_CONTROLLER = "Controller";
 
-  static String _NG_DIRECTIVE = "NgDirective";
+  static String _NG_DECORATOR = "Decorator";
 
-  static String _NG_FILTER = "NgFilter";
+  static String _NG_FORMATTER = "Formatter";
 
   static String _NAME = "name";
 
   static String _SELECTOR = "selector";
 
   static String _PUBLISH_AS = "publishAs";
 
   static String _TEMPLATE_URL = "templateUrl";
 
   static String _CSS_URL = "cssUrl";
@@ skipping 47 matching lines @@
         if (_isNameCoveredByLiteral(selector, node)) {
           return selector;
         }
       }
       // try properties of AngularComponentElement
       if (toolkitObject is AngularComponentElement) {
         AngularComponentElement component = toolkitObject;
         properties = component.properties;
       }
       // try properties of AngularDirectiveElement
-      if (toolkitObject is AngularDirectiveElement) {
-        AngularDirectiveElement directive = toolkitObject;
+      if (toolkitObject is AngularDecoratorElement) {
+        AngularDecoratorElement directive = toolkitObject;
         properties = directive.properties;
       }
       // check properties
       for (AngularPropertyElement property in properties) {
         // property name (use complete node range)
         if (_isNameCoveredByLiteral(property, node)) {
           return property;
         }
         // field name (use complete node range, including @, => and <=>)
         FieldElement field = property.field;
@@ skipping 148 matching lines @@
         this._classDeclaration = unitMember;
         this._classElement = _classDeclaration.element as ClassElementImpl;
         // process annotations
         NodeList<Annotation> annotations = _classDeclaration.metadata;
         for (Annotation annotation in annotations) {
           // verify annotation
           if (annotation.arguments == null) {
             continue;
           }
           this._annotation = annotation;
-          // @NgFilter
-          if (_isAngularAnnotation(annotation, _NG_FILTER)) {
-            _parseNgFilter();
+          // @Formatter
+          if (_isAngularAnnotation(annotation, _NG_FORMATTER)) {
+            _parseFormatter();
             continue;
           }
-          // @NgComponent
+          // @Component
           if (_isAngularAnnotation(annotation, _NG_COMPONENT)) {
-            _parseNgComponent();
+            _parseComponent();
             continue;
           }
-          // @NgController
+          // @Controller
           if (_isAngularAnnotation(annotation, _NG_CONTROLLER)) {
-            _parseNgController();
+            _parseController();
             continue;
           }
-          // @NgDirective
-          if (_isAngularAnnotation(annotation, _NG_DIRECTIVE)) {
-            _parseNgDirective();
+          // @Decorator
+          if (_isAngularAnnotation(annotation, _NG_DECORATOR)) {
+            _parseDecorator();
             continue;
           }
         }
       }
     }
   }
 
   /**
    * @return the argument [Expression] with given name form [annotation], may be
    *         `null` if not found.
@@ skipping 46 matching lines @@
    */
   bool _isAngularAnnotation(Annotation annotation, String name) {
     Element element = annotation.element;
     if (element is ConstructorElement) {
       ConstructorElement constructorElement = element;
       return constructorElement.returnType.displayName == name;
     }
     return false;
   }
 
-  void _parseNgComponent() {
+  void _parseComponent() {
     bool isValid = true;
     // publishAs
     String name = null;
     int nameOffset = -1;
     if (_hasStringArgument(_PUBLISH_AS)) {
       name = _getStringArgument(_PUBLISH_AS);
       nameOffset = _getStringArgumentOffset(_PUBLISH_AS);
     }
     // selector
     AngularSelectorElement selector = null;
@@ skipping 23 matching lines @@
       styleUriOffset = _getStringArgumentOffset(_CSS_URL);
     }
     // create
     if (isValid) {
       AngularComponentElementImpl element = new AngularComponentElementImpl(name, nameOffset, _annotation.offset);
       element.selector = selector;
       element.templateUri = templateUri;
       element.templateUriOffset = templateUriOffset;
       element.styleUri = styleUri;
       element.styleUriOffset = styleUriOffset;
-      element.properties = _parseNgComponentProperties();
+      element.properties = _parseComponentProperties();
       element.scopeProperties = _parseScopeProperties();
       _classElement.addToolkitObjects(element);
     }
   }
 
   /**
    * Parses [AngularPropertyElement]s from [annotation] and [classDeclaration].
    */
-  List<AngularPropertyElement> _parseNgComponentProperties() {
+  List<AngularPropertyElement> _parseComponentProperties() {
     List<AngularPropertyElement> properties = [];
-    _parseNgComponentProperties_fromMap(properties);
-    _parseNgComponentProperties_fromFields(properties);
+    _parseComponentProperties_fromMap(properties);
+    _parseComponentProperties_fromFields(properties);
     return new List.from(properties);
   }
 
   /**
    * Parses [AngularPropertyElement]s from [annotation].
    */
-  void _parseNgComponentProperties_fromFields(List<AngularPropertyElement> properties) {
+  void _parseComponentProperties_fromFields(List<AngularPropertyElement> properties) {
     NodeList<ClassMember> members = _classDeclaration.members;
     for (ClassMember member in members) {
       if (member is FieldDeclaration) {
         FieldDeclaration fieldDeclaration = member;
         for (Annotation annotation in fieldDeclaration.metadata) {
           // prepare property kind (if property annotation at all)
           AngularPropertyKind kind = null;
           if (_isAngularAnnotation(annotation, _NG_ATTR)) {
             kind = AngularPropertyKind.ATTR;
           } else if (_isAngularAnnotation(annotation, _NG_CALLBACK)) {
@@ skipping 17 matching lines @@
             }
           }
         }
       }
     }
   }
 
   /**
    * Parses [AngularPropertyElement]s from [annotation].
    */
-  void _parseNgComponentProperties_fromMap(List<AngularPropertyElement> properties) {
+  void _parseComponentProperties_fromMap(List<AngularPropertyElement> properties) {
     Expression mapExpression = _getArgument("map");
     // may be not properties
     if (mapExpression == null) {
       return;
     }
     // prepare map literal
     if (mapExpression is! MapLiteral) {
       _reportErrorForNode(AngularCode.INVALID_PROPERTY_MAP, mapExpression, []);
       return;
     }
@@ skipping 50 matching lines @@
       FieldElement field = setter.variable as FieldElement;
       // add property
       AngularPropertyElementImpl property = new AngularPropertyElementImpl(name, nameOffset);
       property.field = field;
       property.propertyKind = kind;
       property.fieldNameOffset = fieldNameOffset;
       properties.add(property);
     }
   }
 
-  void _parseNgController() {
+  void _parseController() {
     bool isValid = true;
     // publishAs
     if (!_hasStringArgument(_PUBLISH_AS)) {
       _reportErrorForAnnotation(AngularCode.MISSING_PUBLISH_AS, []);
       isValid = false;
     }
     // selector
     AngularSelectorElement selector = null;
     if (!_hasStringArgument(_SELECTOR)) {
       _reportErrorForAnnotation(AngularCode.MISSING_SELECTOR, []);
       isValid = false;
     } else {
       SimpleStringLiteral selectorLiteral = _getStringLiteral(_SELECTOR);
       selector = _parseSelectorFromString(selectorLiteral);
       if (selector == null) {
         _reportErrorForArgument(_SELECTOR, AngularCode.CANNOT_PARSE_SELECTOR, [selectorLiteral]);
         isValid = false;
       }
     }
     // create
     if (isValid) {
       String name = _getStringArgument(_PUBLISH_AS);
       int nameOffset = _getStringArgumentOffset(_PUBLISH_AS);
       AngularControllerElementImpl element = new AngularControllerElementImpl(name, nameOffset);
       element.selector = selector;
       _classElement.addToolkitObjects(element);
     }
   }
 
-  void _parseNgDirective() {
+  void _parseDecorator() {
     bool isValid = true;
     // selector
     AngularSelectorElement selector = null;
     if (!_hasStringArgument(_SELECTOR)) {
       _reportErrorForAnnotation(AngularCode.MISSING_SELECTOR, []);
       isValid = false;
     } else {
       SimpleStringLiteral selectorLiteral = _getStringLiteral(_SELECTOR);
       selector = _parseSelectorFromString(selectorLiteral);
       if (selector == null) {
         _reportErrorForArgument(_SELECTOR, AngularCode.CANNOT_PARSE_SELECTOR, [selectorLiteral]);
         isValid = false;
       }
     }
     // create
     if (isValid) {
       int offset = _annotation.offset;
-      AngularDirectiveElementImpl element = new AngularDirectiveElementImpl(offset);
+      AngularDecoratorElementImpl element = new AngularDecoratorElementImpl(offset);
       element.selector = selector;
-      element.properties = _parseNgComponentProperties();
+      element.properties = _parseComponentProperties();
       _classElement.addToolkitObjects(element);
     }
   }
 
-  void _parseNgFilter() {
+  void _parseFormatter() {
     bool isValid = true;
     // name
     if (!_hasStringArgument(_NAME)) {
       _reportErrorForAnnotation(AngularCode.MISSING_NAME, []);
       isValid = false;
     }
     // create
     if (isValid) {
       String name = _getStringArgument(_NAME);
       int nameOffset = _getStringArgumentOffset(_NAME);
-      _classElement.addToolkitObjects(new AngularFilterElementImpl(name, nameOffset));
+      _classElement.addToolkitObjects(new AngularFormatterElementImpl(name, nameOffset));
     }
   }
 
   List<AngularScopePropertyElement> _parseScopeProperties() {
     List<AngularScopePropertyElement> properties = [];
     _classDeclaration.accept(new RecursiveAstVisitor_AngularCompilationUnitBuilder_parseScopeProperties(properties));
     return new List.from(properties);
   }
 
   /**
@@ skipping 297 matching lines @@
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl.con1(element);
     interfaceType.typeArguments = typeArguments;
     element.type = interfaceType;
     List<ConstructorElement> constructors = holder.constructors;
     if (constructors.length == 0) {
       //
       // Create the default constructor.
       //
       constructors = _createDefaultConstructors(interfaceType);
     }
-    element.abstract = node.abstractKeyword != null;
+    element.abstract = node.isAbstract;
     element.accessors = holder.accessors;
     element.constructors = constructors;
     element.fields = holder.fields;
     element.methods = holder.methods;
     element.typeParameters = typeParameters;
     element.validMixin = _isValidMixin;
     int functionTypeCount = _functionTypesToFix.length;
     for (int i = 0; i < functionTypeCount; i++) {
       _functionTypesToFix[i].typeArguments = typeArguments;
     }
@@ skipping 37 matching lines @@
     _isValidMixin = false;
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
       _visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
     SimpleIdentifier constructorName = node.name;
-    ConstructorElementImpl element = new ConstructorElementImpl.con1(constructorName);
+    ConstructorElementImpl element = new ConstructorElementImpl.forNode(constructorName);
     if (node.factoryKeyword != null) {
       element.factory = true;
     }
     element.functions = holder.functions;
     element.labels = holder.labels;
     element.localVariables = holder.localVariables;
     element.parameters = holder.parameters;
     element.const2 = node.constKeyword != null;
     _currentHolder.addConstructor(element);
     node.element = element;
@@ skipping 40 matching lines @@
     } else {
       parameter = new DefaultParameterElementImpl(parameterName);
     }
     parameter.const3 = node.isConst;
     parameter.final2 = node.isFinal;
     parameter.parameterKind = node.kind;
     // set initializer, default value range
     Expression defaultValue = node.defaultValue;
     if (defaultValue != null) {
       _visit(holder, defaultValue);
-      FunctionElementImpl initializer = new FunctionElementImpl.con2(defaultValue.beginToken.offset);
+      FunctionElementImpl initializer = new FunctionElementImpl.forOffset(defaultValue.beginToken.offset);
       initializer.functions = holder.functions;
       initializer.labels = holder.labels;
       initializer.localVariables = holder.localVariables;
       initializer.parameters = holder.parameters;
       initializer.synthetic = true;
       parameter.initializer = initializer;
       parameter.setDefaultValueRange(defaultValue.offset, defaultValue.length);
     }
     // visible range
     _setParameterVisibleRange(node, parameter);
@@ skipping 49 matching lines @@
       bool wasInFunction = _inFunction;
       _inFunction = true;
       try {
         _visitChildren(holder, expression);
       } finally {
         _inFunction = wasInFunction;
       }
       sc.Token property = node.propertyKeyword;
       if (property == null) {
         SimpleIdentifier functionName = node.name;
-        FunctionElementImpl element = new FunctionElementImpl.con1(functionName);
+        FunctionElementImpl element = new FunctionElementImpl.forNode(functionName);
         element.functions = holder.functions;
         element.labels = holder.labels;
         element.localVariables = holder.localVariables;
         element.parameters = holder.parameters;
         if (_inFunction) {
           Block enclosingBlock = node.getAncestor((node) => node is Block);
           if (enclosingBlock != null) {
             int functionEnd = node.offset + node.length;
             int blockEnd = enclosingBlock.offset + enclosingBlock.length;
             element.setVisibleRange(functionEnd, blockEnd - functionEnd - 1);
@@ skipping 10 matching lines @@
         }
         String propertyName = propertyNameNode.name;
         TopLevelVariableElementImpl variable = _currentHolder.getTopLevelVariable(propertyName) as TopLevelVariableElementImpl;
         if (variable == null) {
           variable = new TopLevelVariableElementImpl.con2(node.name.name);
           variable.final2 = true;
           variable.synthetic = true;
           _currentHolder.addTopLevelVariable(variable);
         }
         if (_matches(property, sc.Keyword.GET)) {
-          PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con1(propertyNameNode);
+          PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.forNode(propertyNameNode);
           getter.functions = holder.functions;
           getter.labels = holder.labels;
           getter.localVariables = holder.localVariables;
           getter.variable = variable;
           getter.getter = true;
           getter.static = true;
           variable.getter = getter;
           _currentHolder.addAccessor(getter);
           expression.element = getter;
           propertyNameNode.staticElement = getter;
         } else {
-          PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con1(propertyNameNode);
+          PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.forNode(propertyNameNode);
           setter.functions = holder.functions;
           setter.labels = holder.labels;
           setter.localVariables = holder.localVariables;
           setter.parameters = holder.parameters;
           setter.variable = variable;
           setter.setter = true;
           setter.static = true;
           variable.setter = setter;
           variable.final2 = false;
           _currentHolder.addAccessor(setter);
           expression.element = setter;
           propertyNameNode.staticElement = setter;
         }
       }
       holder.validate();
     }
     return null;
   }
 
   @override
   Object visitFunctionExpression(FunctionExpression node) {
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
       _visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
-    FunctionElementImpl element = new FunctionElementImpl.con2(node.beginToken.offset);
+    FunctionElementImpl element = new FunctionElementImpl.forOffset(node.beginToken.offset);
     element.functions = holder.functions;
     element.labels = holder.labels;
     element.localVariables = holder.localVariables;
     element.parameters = holder.parameters;
     if (_inFunction) {
       Block enclosingBlock = node.getAncestor((node) => node is Block);
       if (enclosingBlock != null) {
         int functionEnd = node.offset + node.length;
         int blockEnd = enclosingBlock.offset + enclosingBlock.length;
         element.setVisibleRange(functionEnd, blockEnd - functionEnd - 1);
@@ skipping 72 matching lines @@
       _inFunction = wasInFunction;
     }
     bool isStatic = node.isStatic;
     sc.Token property = node.propertyKeyword;
     if (property == null) {
       SimpleIdentifier methodName = node.name;
       String nameOfMethod = methodName.name;
       if (nameOfMethod == sc.TokenType.MINUS.lexeme && node.parameters.parameters.length == 0) {
         nameOfMethod = "unary-";
       }
-      MethodElementImpl element = new MethodElementImpl.con2(nameOfMethod, methodName.offset);
+      MethodElementImpl element = new MethodElementImpl(nameOfMethod, methodName.offset);
       element.abstract = node.isAbstract;
       element.functions = holder.functions;
       element.labels = holder.labels;
       element.localVariables = holder.localVariables;
       element.parameters = holder.parameters;
       element.static = isStatic;
       _currentHolder.addMethod(element);
       methodName.staticElement = element;
     } else {
       SimpleIdentifier propertyNameNode = node.name;
       String propertyName = propertyNameNode.name;
       FieldElementImpl field = _currentHolder.getField(propertyName) as FieldElementImpl;
       if (field == null) {
         field = new FieldElementImpl.con2(node.name.name);
         field.final2 = true;
         field.static = isStatic;
         field.synthetic = true;
         _currentHolder.addField(field);
       }
       if (_matches(property, sc.Keyword.GET)) {
-        PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con1(propertyNameNode);
+        PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.forNode(propertyNameNode);
         getter.functions = holder.functions;
         getter.labels = holder.labels;
         getter.localVariables = holder.localVariables;
         getter.variable = field;
         getter.abstract = node.body is EmptyFunctionBody && node.externalKeyword == null;
         getter.getter = true;
         getter.static = isStatic;
         field.getter = getter;
         _currentHolder.addAccessor(getter);
         propertyNameNode.staticElement = getter;
       } else {
-        PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con1(propertyNameNode);
+        PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.forNode(propertyNameNode);
         setter.functions = holder.functions;
         setter.labels = holder.labels;
         setter.localVariables = holder.localVariables;
         setter.parameters = holder.parameters;
         setter.variable = field;
         setter.abstract = node.body is EmptyFunctionBody && !_matches(node.externalKeyword, sc.Keyword.EXTERNAL);
         setter.setter = true;
         setter.static = isStatic;
         field.setter = setter;
         field.final2 = false;
@@ skipping 109 matching lines @@
     element.final2 = isFinal;
     if (hasInitializer) {
       ElementHolder holder = new ElementHolder();
       bool wasInFieldContext = _inFieldContext;
       _inFieldContext = false;
       try {
         _visit(holder, node.initializer);
       } finally {
         _inFieldContext = wasInFieldContext;
       }
-      FunctionElementImpl initializer = new FunctionElementImpl.con2(node.initializer.beginToken.offset);
+      FunctionElementImpl initializer = new FunctionElementImpl.forOffset(node.initializer.beginToken.offset);
       initializer.functions = holder.functions;
       initializer.labels = holder.labels;
       initializer.localVariables = holder.localVariables;
       initializer.synthetic = true;
       element.initializer = initializer;
       holder.validate();
     }
     if (element is PropertyInducingElementImpl) {
       PropertyInducingElementImpl variable = element as PropertyInducingElementImpl;
       if (_inFieldContext) {
         (variable as FieldElementImpl).static = _matches((node.parent.parent as FieldDeclaration).staticKeyword, sc.Keyword.STATIC);
       }
-      PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con2(variable);
+      PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl(variable);
       getter.getter = true;
       getter.static = variable.isStatic;
       _currentHolder.addAccessor(getter);
       variable.getter = getter;
       if (!isFinal) {
-        PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con2(variable);
+        PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl(variable);
         setter.setter = true;
         setter.static = variable.isStatic;
         ParameterElementImpl parameter = new ParameterElementImpl.con2("_${variable.name}", variable.nameOffset);
         parameter.synthetic = true;
         parameter.parameterKind = ParameterKind.REQUIRED;
         setter.parameters = <ParameterElement> [parameter];
         _currentHolder.addAccessor(setter);
         variable.setter = setter;
       }
     }
@@ skipping 15 matching lines @@
     }
   }
 
   /**
    * Creates the [ConstructorElement]s array with the single default constructor element.
    *
    * @param interfaceType the interface type for which to create a default constructor
    * @return the [ConstructorElement]s array with the single default constructor element
    */
   List<ConstructorElement> _createDefaultConstructors(InterfaceTypeImpl interfaceType) {
-    ConstructorElementImpl constructor = new ConstructorElementImpl.con1(null);
+    ConstructorElementImpl constructor = new ConstructorElementImpl.forNode(null);
     constructor.synthetic = true;
     constructor.returnType = interfaceType;
     FunctionTypeImpl type = new FunctionTypeImpl.con1(constructor);
     _functionTypesToFix.add(type);
     constructor.type = type;
     return <ConstructorElement> [constructor];
   }
 
   /**
    * Create the types associated with the given type parameters, setting the type of each type
@@ skipping 4555 matching lines @@
     //
     Expression target = node.realTarget;
     if (target is SuperExpression && !_isSuperInValidContext(target)) {
       return null;
     }
     Element staticElement;
     Element propagatedElement;
     if (target == null) {
       staticElement = _resolveInvokedElement(methodName);
       propagatedElement = null;
+    } else if (_isDeferredPrefix(target) && methodName.name == FunctionElement.LOAD_LIBRARY_NAME) {
+      LibraryElement importedLibrary = _getImportedLibrary(target);
+      methodName.staticElement = importedLibrary.loadLibraryFunction;
+      return null;
     } else {
       DartType staticType = _getStaticType(target);
       //
       // If this method invocation is of the form 'C.m' where 'C' is a class, then we don't call
       // resolveInvokedElement(..) which walks up the class hierarchy, instead we just look for the
       // member in the type only.
       //
       ClassElementImpl typeReference = getTypeReference(target);
       if (typeReference != null) {
         staticElement = propagatedElement = _resolveElement(typeReference, methodName);
@@ skipping 633 matching lines @@
           } else {
             element = MultiplyDefinedElementImpl.fromElements(_definingLibrary.context, element, importedElement);
           }
         }
       }
     }
     return element;
   }
 
   /**
+   * Assuming that the given expression is a prefix for a deferred import, return the library that
+   * is being imported.
+   *
+   * @param expression the expression representing the deferred import's prefix
+   * @return the library that is being imported by the import associated with the prefix
+   */
+  LibraryElement _getImportedLibrary(Expression expression) {
+    PrefixElement prefixElement = (expression as SimpleIdentifier).staticElement as PrefixElement;
+    List<ImportElement> imports = prefixElement.enclosingElement.getImportsWithPrefix(prefixElement);
+    return imports[0].importedLibrary;
+  }
+
+  /**
    * Return the name of the method invoked by the given postfix expression.
    *
    * @param node the postfix expression being invoked
    * @return the name of the method invoked by the expression
    */
   String _getPostfixOperator(PostfixExpression node) => (node.operator.type == sc.TokenType.PLUS_PLUS) ? sc.TokenType.PLUS.lexeme : sc.TokenType.MINUS.lexeme;
 
   /**
    * Return the name of the method invoked by the given postfix expression.
    *
@@ skipping 45 matching lines @@
     if (staticType is FunctionType) {
       //
       // All function types are subtypes of 'Function', which is itself a subclass of 'Object'.
       //
       staticType = _resolver.typeProvider.functionType;
     }
     return staticType;
   }
 
   /**
+   * Return `true` if the given expression is a prefix for a deferred import.
+   *
+   * @param expression the expression being tested
+   * @return `true` if the given expression is a prefix for a deferred import
+   */
+  bool _isDeferredPrefix(Expression expression) {
+    if (expression is! SimpleIdentifier) {
+      return false;
+    }
+    Element element = (expression as SimpleIdentifier).staticElement;
+    if (element is! PrefixElement) {
+      return false;
+    }
+    PrefixElement prefixElement = element as PrefixElement;
+    List<ImportElement> imports = prefixElement.enclosingElement.getImportsWithPrefix(prefixElement);
+    if (imports.length != 1) {
+      return false;
+    }
+    return imports[0].isDeferred;
+  }
+
+  /**
    * Return `true` if the given type represents an object that could be invoked using the call
    * operator '()'.
    *
    * @param type the type being tested
    * @return `true` if the given type represents an object that could be invoked
    */
   bool _isExecutableType(DartType type) {
     if (type.isDynamic || (type is FunctionType) || type.isDartCoreFunction || type.isObject) {
       return true;
     } else if (type is InterfaceType) {
@@ skipping 2564 matching lines @@
           libraryNameNode = directive.name;
           directivesToResolve.add(directive);
         }
       } else if (directive is PartDirective) {
         PartDirective partDirective = directive;
         StringLiteral partUri = partDirective.uri;
         Source partSource = partDirective.source;
         if (_analysisContext.exists(partSource)) {
           hasPartDirective = true;
           CompilationUnit partUnit = library.getAST(partSource);
-          CompilationUnitElementImpl part = builder.buildCompilationUnit(partSource, partUnit);
-          part.uriOffset = partUri.offset;
-          part.uriEnd = partUri.end;
-          part.uri = partDirective.uriContent;
-          //
-          // Validate that the part contains a part-of directive with the same name as the library.
-          //
-          String partLibraryName = _getPartLibraryName(partSource, partUnit, directivesToResolve);
-          if (partLibraryName == null) {
-            _errorListener.onError(new AnalysisError.con2(librarySource, partUri.offset, partUri.length, CompileTimeErrorCode.PART_OF_NON_PART, [partUri.toSource()]));
-          } else if (libraryNameNode == null) {
-          } else if (libraryNameNode.name != partLibraryName) {
-            _errorListener.onError(new AnalysisError.con2(librarySource, partUri.offset, partUri.length, StaticWarningCode.PART_OF_DIFFERENT_LIBRARY, [libraryNameNode.name, partLibraryName]));
+          if (partUnit != null) {
+            CompilationUnitElementImpl part = builder.buildCompilationUnit(partSource, partUnit);
+            part.uriOffset = partUri.offset;
+            part.uriEnd = partUri.end;
+            part.uri = partDirective.uriContent;
+            //
+            // Validate that the part contains a part-of directive with the same name as the library.
+            //
+            String partLibraryName = _getPartLibraryName(partSource, partUnit, directivesToResolve);
+            if (partLibraryName == null) {
+              _errorListener.onError(new AnalysisError.con2(librarySource, partUri.offset, partUri.length, CompileTimeErrorCode.PART_OF_NON_PART, [partUri.toSource()]));
+            } else if (libraryNameNode == null) {
+            } else if (libraryNameNode.name != partLibraryName) {
+              _errorListener.onError(new AnalysisError.con2(librarySource, partUri.offset, partUri.length, StaticWarningCode.PART_OF_DIFFERENT_LIBRARY, [libraryNameNode.name, partLibraryName]));
+            }
+            if (entryPoint == null) {
+              entryPoint = _findEntryPoint(part);
+            }
+            directive.element = part;
+            sourcedCompilationUnits.add(part);
           }
-          if (entryPoint == null) {
-            entryPoint = _findEntryPoint(part);
-          }
-          directive.element = part;
-          sourcedCompilationUnits.add(part);
         }
       }
     }
     if (hasPartDirective && libraryNameNode == null) {
       _errorListener.onError(new AnalysisError.con1(librarySource, ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART, []));
     }
     //
     // Create and populate the library element.
     //
     LibraryElementImpl libraryElement = new LibraryElementImpl(_analysisContext, libraryNameNode);
@@ skipping 184 matching lines @@
       instrumentation.metric("fullAnalysis", fullAnalysis);
       instrumentation.data3("fullName", librarySource.fullName);
       //
       // Create the objects representing the library being resolved and the core library.
       //
       Library targetLibrary = _createLibraryWithUnit(librarySource, modificationStamp, unit);
       _coreLibrary = _libraryMap[_coreLibrarySource];
       if (_coreLibrary == null) {
         // This will be true unless the library being analyzed is the core library.
         _coreLibrary = createLibrary(_coreLibrarySource);
+        if (_coreLibrary == null) {
+          throw new AnalysisException.con1("Core library does not exist");
+        }
       }
       instrumentation.metric3("createLibrary", "complete");
       //
       // Compute the set of libraries that need to be resolved together.
       //
       _computeEmbeddedLibraryDependencies(targetLibrary, unit);
       _librariesInCycles = _computeLibrariesInCycles(targetLibrary);
       //
       // Build the element models representing the libraries being resolved. This is done in three
       // steps:
@@ skipping 6448 matching lines @@
    * Create an implicit constructor that is copied from the given constructor, but that is in the
    * given class.
    *
    * @param classType the class in which the implicit constructor is defined
    * @param explicitConstructor the constructor on which the implicit constructor is modeled
    * @param parameterTypes the types to be replaced when creating parameters
    * @param argumentTypes the types with which the parameters are to be replaced
    * @return the implicit constructor that was created
    */
   ConstructorElement _createImplicitContructor(InterfaceType classType, ConstructorElement explicitConstructor, List<DartType> parameterTypes, List<DartType> argumentTypes) {
-    ConstructorElementImpl implicitConstructor = new ConstructorElementImpl.con2(explicitConstructor.name, -1);
+    ConstructorElementImpl implicitConstructor = new ConstructorElementImpl(explicitConstructor.name, -1);
     implicitConstructor.synthetic = true;
     implicitConstructor.redirectedConstructor = explicitConstructor;
     implicitConstructor.const2 = explicitConstructor.isConst;
     implicitConstructor.returnType = classType;
     List<ParameterElement> explicitParameters = explicitConstructor.parameters;
     int count = explicitParameters.length;
     if (count > 0) {
       List<ParameterElement> implicitParameters = new List<ParameterElement>(count);
       for (int i = 0; i < count; i++) {
         ParameterElement explicitParameter = explicitParameters[i];
@@ skipping 6654 matching lines @@
   }
 
   /**
    * This verifies that if the given class declaration implements the class Function that it has a
    * concrete implementation of the call method.
    *
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#FUNCTION_WITHOUT_CALL
    */
   bool _checkImplementsFunctionWithoutCall(ClassDeclaration node) {
-    if (node.abstractKeyword != null) {
+    if (node.isAbstract) {
       return false;
     }
     ClassElement classElement = node.element;
     if (classElement == null) {
       return false;
     }
     if (!classElement.type.isSubtypeOf(_typeProvider.functionType)) {
       return false;
     }
     // If there is a noSuchMethod method, then don't report the warning, see dartbug.com/16078
@@ skipping 497 matching lines @@
    *
    * @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
    */
   const ResolverErrorCode.con2(String name, int ordinal, this.type, this.message, this.correction) : super(name, ordinal);
 
   @override
   ErrorSeverity get errorSeverity => type.severity;
 }