New analyzer_experimental snapshot.

pkg/analyzer_experimental/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_general.dart';
 import 'utilities_dart.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 `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
    * @param unit the AST structure representing the compilation unit
    * @return the compilation unit element that was built
    * @throws AnalysisException if the analysis could not be performed
    */
   CompilationUnitElementImpl buildCompilationUnit(Source source2, CompilationUnit unit) {
+    TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
     if (unit == null) {
       return null;
     }
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     unit.accept(builder);
     CompilationUnitElementImpl element = new CompilationUnitElementImpl(source2.shortName);
     element.accessors = holder.accessors;
     element.functions = holder.functions;
     element.source = source2;
     element.typeAliases = holder.typeAliases;
     element.types = holder.types;
     element.topLevelVariables = holder.topLevelVariables;
     unit.element = element;
+    timeCounter.stop();
     return element;
   }
 }
 /**
  * Instances of the class `ElementBuilder` traverse an AST structure and build the element
  * model representing the AST structure.
  *
  * @coverage dart.engine.resolver
  */
 class ElementBuilder extends RecursiveASTVisitor<Object> {
@@ skipping 58 matching lines @@
     }
     return super.visitCatchClause(node);
   }
   Object visitClassDeclaration(ClassDeclaration node) {
     ElementHolder holder = new ElementHolder();
     _isValidMixin = true;
     _functionTypesToFix = new List<FunctionTypeImpl>();
     visitChildren(holder, node);
     SimpleIdentifier className = node.name;
     ClassElementImpl element = new ClassElementImpl(className);
-    List<TypeVariableElement> typeVariables = holder.typeVariables;
-    List<Type2> typeArguments = createTypeVariableTypes(typeVariables);
+    List<TypeParameterElement> typeParameters = holder.typeParameters;
+    List<Type2> typeArguments = createTypeParameterTypes(typeParameters);
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl.con1(element);
     interfaceType.typeArguments = typeArguments;
     element.type = interfaceType;
     List<ConstructorElement> constructors = holder.constructors;
     if (constructors.length == 0) {
       constructors = createDefaultConstructors(interfaceType);
     }
     element.abstract = node.abstractKeyword != null;
     element.accessors = holder.accessors;
     element.constructors = constructors;
     element.fields = holder.fields;
     element.methods = holder.methods;
-    element.typeVariables = typeVariables;
+    element.typeParameters = typeParameters;
     element.validMixin = _isValidMixin;
     for (FunctionTypeImpl functionType in _functionTypesToFix) {
       functionType.typeArguments = typeArguments;
     }
     _functionTypesToFix = null;
     _currentHolder.addType(element);
     className.staticElement = element;
     holder.validate();
     return null;
   }
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ElementHolder holder = new ElementHolder();
     _functionTypesToFix = new List<FunctionTypeImpl>();
     visitChildren(holder, node);
     SimpleIdentifier className = node.name;
     ClassElementImpl element = new ClassElementImpl(className);
     element.abstract = node.abstractKeyword != null;
     element.typedef = true;
-    List<TypeVariableElement> typeVariables = holder.typeVariables;
-    element.typeVariables = typeVariables;
-    List<Type2> typeArguments = createTypeVariableTypes(typeVariables);
+    List<TypeParameterElement> typeParameters = holder.typeParameters;
+    element.typeParameters = typeParameters;
+    List<Type2> typeArguments = createTypeParameterTypes(typeParameters);
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl.con1(element);
     interfaceType.typeArguments = typeArguments;
     element.type = interfaceType;
     element.constructors = createDefaultConstructors(interfaceType);
     for (FunctionTypeImpl functionType in _functionTypesToFix) {
       functionType.typeArguments = typeArguments;
     }
     _functionTypesToFix = null;
     _currentHolder.addType(element);
     className.staticElement = element;
@@ skipping 63 matching lines @@
       parameter = new DefaultParameterElementImpl(parameterName);
     }
     parameter.const3 = node.isConst;
     parameter.final2 = node.isFinal;
     parameter.initializer = initializer;
     parameter.parameterKind = node.kind;
     Expression defaultValue = node.defaultValue;
     if (defaultValue != null) {
       parameter.setDefaultValueRange(defaultValue.offset, defaultValue.length);
     }
-    FunctionBody body = getFunctionBody(node);
-    if (body != null) {
-      parameter.setVisibleRange(body.offset, body.length);
-    }
+    setParameterVisibleRange(node, parameter);
     _currentHolder.addParameter(parameter);
     parameterName.staticElement = parameter;
     node.parameter.accept(this);
     holder.validate();
     return null;
   }
   Object visitFieldDeclaration(FieldDeclaration node) {
     bool wasInField = _inFieldContext;
     _inFieldContext = true;
     try {
@@ skipping 48 matching lines @@
         }
         _currentHolder.addFunction(element);
         expression.element = element;
         functionName.staticElement = element;
       } else {
         SimpleIdentifier propertyNameNode = node.name;
         if (propertyNameNode == null) {
           return null;
         }
         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 = true;
-          _currentHolder.addField(field);
+        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);
           getter.functions = holder.functions;
           getter.labels = holder.labels;
           getter.localVariables = holder.localVariables;
-          getter.variable = field;
+          getter.variable = variable;
           getter.getter = true;
           getter.static = true;
-          field.getter = getter;
+          variable.getter = getter;
           _currentHolder.addAccessor(getter);
+          expression.element = getter;
           propertyNameNode.staticElement = getter;
         } else {
           PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con1(propertyNameNode);
           setter.functions = holder.functions;
           setter.labels = holder.labels;
           setter.localVariables = holder.localVariables;
           setter.parameters = holder.parameters;
-          setter.variable = field;
+          setter.variable = variable;
           setter.setter = true;
           setter.static = true;
-          field.setter = setter;
-          field.final2 = false;
+          variable.setter = setter;
+          variable.final2 = false;
           _currentHolder.addAccessor(setter);
+          expression.element = setter;
           propertyNameNode.staticElement = setter;
         }
       }
       holder.validate();
     }
     return null;
   }
   Object visitFunctionExpression(FunctionExpression node) {
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
@@ skipping 24 matching lines @@
     _currentHolder.addFunction(element);
     node.element = element;
     holder.validate();
     return null;
   }
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     ElementHolder holder = new ElementHolder();
     visitChildren(holder, node);
     SimpleIdentifier aliasName = node.name;
     List<ParameterElement> parameters = holder.parameters;
-    List<TypeVariableElement> typeVariables = holder.typeVariables;
+    List<TypeParameterElement> typeParameters = holder.typeParameters;
     FunctionTypeAliasElementImpl element = new FunctionTypeAliasElementImpl(aliasName);
     element.parameters = parameters;
-    element.typeVariables = typeVariables;
+    element.typeParameters = typeParameters;
     FunctionTypeImpl type = new FunctionTypeImpl.con2(element);
-    type.typeArguments = createTypeVariableTypes(typeVariables);
+    type.typeArguments = createTypeParameterTypes(typeParameters);
     element.type = type;
     _currentHolder.addTypeAlias(element);
     aliasName.staticElement = element;
     holder.validate();
     return null;
   }
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter = new ParameterElementImpl.con1(parameterName);
       parameter.parameterKind = node.kind;
+      setParameterVisibleRange(node, parameter);
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
     ElementHolder holder = new ElementHolder();
     visitChildren(holder, node);
     ((node.element as ParameterElementImpl)).parameters = holder.parameters;
     holder.validate();
     return null;
   }
   Object visitLabeledStatement(LabeledStatement node) {
@@ skipping 33 matching lines @@
       _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);
         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;
@@ skipping 20 matching lines @@
     holder.validate();
     return null;
   }
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter = new ParameterElementImpl.con1(parameterName);
       parameter.const3 = node.isConst;
       parameter.final2 = node.isFinal;
       parameter.parameterKind = node.kind;
+      setParameterVisibleRange(node, parameter);
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
     return super.visitSimpleFormalParameter(node);
   }
   Object visitSuperExpression(SuperExpression node) {
     _isValidMixin = false;
     return super.visitSuperExpression(node);
   }
   Object visitSwitchCase(SwitchCase node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElementImpl element = new LabelElementImpl(labelName, false, true);
       _currentHolder.addLabel(element);
       labelName.staticElement = element;
     }
     return super.visitSwitchCase(node);
   }
   Object visitSwitchDefault(SwitchDefault node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElementImpl element = new LabelElementImpl(labelName, false, true);
       _currentHolder.addLabel(element);
       labelName.staticElement = element;
     }
     return super.visitSwitchDefault(node);
   }
   Object visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
-    TypeVariableElementImpl element = new TypeVariableElementImpl(parameterName);
-    TypeVariableTypeImpl type = new TypeVariableTypeImpl(element);
-    element.type = type;
-    _currentHolder.addTypeVariable(element);
-    parameterName.staticElement = element;
+    TypeParameterElementImpl typeParameter = new TypeParameterElementImpl(parameterName);
+    TypeParameterTypeImpl typeParameterType = new TypeParameterTypeImpl(typeParameter);
+    typeParameter.type = typeParameterType;
+    _currentHolder.addTypeParameter(typeParameter);
+    parameterName.staticElement = typeParameter;
     return super.visitTypeParameter(node);
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
     sc.Token keyword = ((node.parent as VariableDeclarationList)).keyword;
     bool isConst = matches(keyword, sc.Keyword.CONST);
     bool isFinal = matches(keyword, sc.Keyword.FINAL);
     bool hasInitializer = node.initializer != null;
     VariableElementImpl element;
     if (_inFieldContext) {
       SimpleIdentifier fieldName = node.name;
@@ skipping 87 matching lines @@
     ConstructorElementImpl constructor = new ConstructorElementImpl(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 variables, setting the type of each type
-   * variable, and return an array of types corresponding to the given variables.
+   * Create the types associated with the given type parameters, setting the type of each type
+   * parameter, and return an array of types corresponding to the given parameters.
    *
-   * @param typeVariables the type variables for which types are to be created
-   * @return
+   * @param typeParameters the type parameters for which types are to be created
+   * @return an array of types corresponding to the given parameters
    */
-  List<Type2> createTypeVariableTypes(List<TypeVariableElement> typeVariables) {
-    int typeVariableCount = typeVariables.length;
-    List<Type2> typeArguments = new List<Type2>(typeVariableCount);
-    for (int i = 0; i < typeVariableCount; i++) {
-      TypeVariableElementImpl typeVariable = typeVariables[i] as TypeVariableElementImpl;
-      TypeVariableTypeImpl typeArgument = new TypeVariableTypeImpl(typeVariable);
-      typeVariable.type = typeArgument;
-      typeArguments[i] = typeArgument;
+  List<Type2> createTypeParameterTypes(List<TypeParameterElement> typeParameters) {
+    int typeParameterCount = typeParameters.length;
+    List<Type2> typeArguments = new List<Type2>(typeParameterCount);
+    for (int i = 0; i < typeParameterCount; i++) {
+      TypeParameterElementImpl typeParameter = typeParameters[i] as TypeParameterElementImpl;
+      TypeParameterTypeImpl typeParameterType = new TypeParameterTypeImpl(typeParameter);
+      typeParameter.type = typeParameterType;
+      typeArguments[i] = typeParameterType;
     }
     return typeArguments;
   }
 
   /**
    * Return the body of the function that contains the given parameter, or `null` if no
    * function body could be found.
    *
    * @param node the parameter contained in the function whose body is to be returned
    * @return the body of the function that contains the given parameter
    */
   FunctionBody getFunctionBody(FormalParameter node) {
     ASTNode parent = node.parent;
     while (parent != null) {
-      if (parent is FunctionExpression) {
+      if (parent is ConstructorDeclaration) {
+        return ((parent as ConstructorDeclaration)).body;
+      } else if (parent is FunctionExpression) {
         return ((parent as FunctionExpression)).body;
       } else if (parent is MethodDeclaration) {
         return ((parent as MethodDeclaration)).body;
       }
       parent = parent.parent;
     }
     return null;
   }
 
   /**
    * Return `true` if the given token is a token for the given keyword.
    *
    * @param token the token being tested
    * @param keyword the keyword being tested for
    * @return `true` if the given token is a token for the given keyword
    */
   bool matches(sc.Token token, sc.Keyword keyword2) => token != null && identical(token.type, sc.TokenType.KEYWORD) && identical(((token as sc.KeywordToken)).keyword, keyword2);
 
   /**
+   * Sets the visible source range for formal parameter.
+   */
+  void setParameterVisibleRange(FormalParameter node, ParameterElementImpl element) {
+    FunctionBody body = getFunctionBody(node);
+    if (body != null) {
+      element.setVisibleRange(body.offset, body.length);
+    }
+  }
+
+  /**
    * Make the given holder be the current holder while visiting the given node.
    *
    * @param holder the holder that will gather elements that are built while visiting the children
    * @param node the node to be visited
    */
   void visit(ElementHolder holder, ASTNode node) {
     if (node != null) {
       ElementHolder previousHolder = _currentHolder;
       _currentHolder = holder;
       try {
@@ skipping 30 matching lines @@
  */
 class ElementHolder {
   List<PropertyAccessorElement> _accessors;
   List<ConstructorElement> _constructors;
   List<FieldElement> _fields;
   List<FunctionElement> _functions;
   List<LabelElement> _labels;
   List<VariableElement> _localVariables;
   List<MethodElement> _methods;
   List<ParameterElement> _parameters;
-  List<VariableElement> _topLevelVariables;
+  List<TopLevelVariableElement> _topLevelVariables;
   List<ClassElement> _types;
   List<FunctionTypeAliasElement> _typeAliases;
-  List<TypeVariableElement> _typeVariables;
+  List<TypeParameterElement> _typeParameters;
   void addAccessor(PropertyAccessorElement element) {
     if (_accessors == null) {
       _accessors = new List<PropertyAccessorElement>();
     }
     _accessors.add(element);
   }
   void addConstructor(ConstructorElement element) {
     if (_constructors == null) {
       _constructors = new List<ConstructorElement>();
     }
@@ skipping 30 matching lines @@
     _methods.add(element);
   }
   void addParameter(ParameterElement element) {
     if (_parameters == null) {
       _parameters = new List<ParameterElement>();
     }
     _parameters.add(element);
   }
   void addTopLevelVariable(TopLevelVariableElement element) {
     if (_topLevelVariables == null) {
-      _topLevelVariables = new List<VariableElement>();
+      _topLevelVariables = new List<TopLevelVariableElement>();
     }
     _topLevelVariables.add(element);
   }
   void addType(ClassElement element) {
     if (_types == null) {
       _types = new List<ClassElement>();
     }
     _types.add(element);
   }
   void addTypeAlias(FunctionTypeAliasElement element) {
     if (_typeAliases == null) {
       _typeAliases = new List<FunctionTypeAliasElement>();
     }
     _typeAliases.add(element);
   }
-  void addTypeVariable(TypeVariableElement element) {
-    if (_typeVariables == null) {
-      _typeVariables = new List<TypeVariableElement>();
+  void addTypeParameter(TypeParameterElement element) {
+    if (_typeParameters == null) {
+      _typeParameters = new List<TypeParameterElement>();
     }
-    _typeVariables.add(element);
+    _typeParameters.add(element);
   }
   List<PropertyAccessorElement> get accessors {
     if (_accessors == null) {
       return PropertyAccessorElementImpl.EMPTY_ARRAY;
     }
     List<PropertyAccessorElement> result = new List.from(_accessors);
     _accessors = null;
     return result;
   }
   List<ConstructorElement> get constructors {
@@ skipping 56 matching lines @@
     return result;
   }
   List<ParameterElement> get parameters {
     if (_parameters == null) {
       return ParameterElementImpl.EMPTY_ARRAY;
     }
     List<ParameterElement> result = new List.from(_parameters);
     _parameters = null;
     return result;
   }
+  TopLevelVariableElement getTopLevelVariable(String variableName) {
+    if (_topLevelVariables == null) {
+      return null;
+    }
+    for (TopLevelVariableElement variable in _topLevelVariables) {
+      if (variable.name == variableName) {
+        return variable;
+      }
+    }
+    return null;
+  }
   List<TopLevelVariableElement> get topLevelVariables {
     if (_topLevelVariables == null) {
       return TopLevelVariableElementImpl.EMPTY_ARRAY;
     }
     List<TopLevelVariableElement> result = new List.from(_topLevelVariables);
     _topLevelVariables = null;
     return result;
   }
   List<FunctionTypeAliasElement> get typeAliases {
     if (_typeAliases == null) {
       return FunctionTypeAliasElementImpl.EMPTY_ARRAY;
     }
     List<FunctionTypeAliasElement> result = new List.from(_typeAliases);
     _typeAliases = null;
     return result;
   }
+  List<TypeParameterElement> get typeParameters {
+    if (_typeParameters == null) {
+      return TypeParameterElementImpl.EMPTY_ARRAY;
+    }
+    List<TypeParameterElement> result = new List.from(_typeParameters);
+    _typeParameters = null;
+    return result;
+  }
   List<ClassElement> get types {
     if (_types == null) {
       return ClassElementImpl.EMPTY_ARRAY;
     }
     List<ClassElement> result = new List.from(_types);
     _types = null;
     return result;
   }
-  List<TypeVariableElement> get typeVariables {
-    if (_typeVariables == null) {
-      return TypeVariableElementImpl.EMPTY_ARRAY;
-    }
-    List<TypeVariableElement> result = new List.from(_typeVariables);
-    _typeVariables = null;
-    return result;
-  }
   void validate() {
     JavaStringBuilder builder = new JavaStringBuilder();
     if (_accessors != null) {
       builder.append(_accessors.length);
       builder.append(" accessors");
     }
     if (_constructors != null) {
       if (builder.length > 0) {
         builder.append("; ");
       }
@@ skipping 56 matching lines @@
       builder.append(_types.length);
       builder.append(" types");
     }
     if (_typeAliases != null) {
       if (builder.length > 0) {
         builder.append("; ");
       }
       builder.append(_typeAliases.length);
       builder.append(" type aliases");
     }
-    if (_typeVariables != null) {
+    if (_typeParameters != null) {
       if (builder.length > 0) {
         builder.append("; ");
       }
-      builder.append(_typeVariables.length);
-      builder.append(" type variables");
+      builder.append(_typeParameters.length);
+      builder.append(" type parameters");
     }
     if (builder.length > 0) {
       AnalysisEngine.instance.logger.logError("Failed to capture elements: ${builder.toString()}");
     }
   }
 }
 /**
  * Instances of the class `HtmlUnitBuilder` build an element model for a single HTML unit.
  */
 class HtmlUnitBuilder implements ht.XmlVisitor<Object> {
@@ skipping 234 matching lines @@
    * @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;
     reportError(errorCode, offset, length, arguments);
   }
 }
 /**
+ * Instances of the class `BestPracticesVerifier` traverse an AST structure looking for
+ * violations of Dart best practices.
+ *
+ * @coverage dart.engine.resolver
+ */
+class BestPracticesVerifier extends RecursiveASTVisitor<Object> {
+  static String _GETTER = "getter";
+  static String _HASHCODE_GETTER_NAME = "hashCode";
+  static String _METHOD = "method";
+  static String _NULL_TYPE_NAME = "Null";
+  static String _OBJECT_TYPE_NAME = "Object";
+  static String _SETTER = "setter";
+  static String _TO_INT_METHOD_NAME = "toInt";
+
+  /**
+   * Given a parenthesized expression, this returns the parent (or recursively grand-parent) of the
+   * expression that is a parenthesized expression, but whose parent is not a parenthesized
+   * expression.
+   *
+   * For example given the code `(((e)))`: `(e) -> (((e)))`.
+   *
+   * @param parenthesizedExpression some expression whose parent is a parenthesized expression
+   * @return the first parent or grand-parent that is a parenthesized expression, that does not have
+   *         a parenthesized expression parent
+   */
+  static ParenthesizedExpression wrapParenthesizedExpression(ParenthesizedExpression parenthesizedExpression) {
+    if (parenthesizedExpression.parent is ParenthesizedExpression) {
+      return wrapParenthesizedExpression(parenthesizedExpression.parent as ParenthesizedExpression);
+    }
+    return parenthesizedExpression;
+  }
+
+  /**
+   * The class containing the AST nodes being visited, or `null` if we are not in the scope of
+   * a class.
+   */
+  ClassElement _enclosingClass;
+
+  /**
+   * The error reporter by which errors will be reported.
+   */
+  ErrorReporter _errorReporter;
+
+  /**
+   * Create a new instance of the [BestPracticesVerifier].
+   *
+   * @param errorReporter the error reporter
+   */
+  BestPracticesVerifier(ErrorReporter errorReporter) {
+    this._errorReporter = errorReporter;
+  }
+  Object visitAsExpression(AsExpression node) {
+    checkForUnnecessaryCast(node);
+    return super.visitAsExpression(node);
+  }
+  Object visitBinaryExpression(BinaryExpression node) {
+    checkForDivisionOptimizationHint(node);
+    return super.visitBinaryExpression(node);
+  }
+  Object visitClassDeclaration(ClassDeclaration node) {
+    ClassElement outerClass = _enclosingClass;
+    try {
+      _enclosingClass = node.element;
+      return super.visitClassDeclaration(node);
+    } finally {
+      _enclosingClass = outerClass;
+    }
+  }
+  Object visitIsExpression(IsExpression node) {
+    checkAllTypeChecks(node);
+    return super.visitIsExpression(node);
+  }
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    checkForOverridingPrivateMember(node);
+    return super.visitMethodDeclaration(node);
+  }
+
+  /**
+   * Check for the passed is expression for the unnecessary type check hint codes as well as null
+   * checks expressed using an is expression.
+   *
+   * @param node the is expression to check
+   * @return `true` if and only if a hint code is generated on the passed node
+   * @see HintCode#TYPE_CHECK_IS_NOT_NULL
+   * @see HintCode#TYPE_CHECK_IS_NULL
+   * @see HintCode#UNNECESSARY_TYPE_CHECK_TRUE
+   * @see HintCode#UNNECESSARY_TYPE_CHECK_FALSE
+   */
+  bool checkAllTypeChecks(IsExpression node) {
+    Expression expression = node.expression;
+    TypeName typeName = node.type;
+    Type2 lhsType = expression.staticType;
+    Type2 rhsType = typeName.type;
+    if (lhsType == null || rhsType == null) {
+      return false;
+    }
+    String rhsNameStr = typeName.name.name;
+    if ((rhsType.isDynamic && rhsNameStr == sc.Keyword.DYNAMIC.syntax)) {
+      if (node.notOperator == null) {
+        _errorReporter.reportError2(HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node, []);
+      } else {
+        _errorReporter.reportError2(HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node, []);
+      }
+      return true;
+    }
+    Element rhsElement = rhsType.element;
+    LibraryElement libraryElement = rhsElement != null ? rhsElement.library : null;
+    if (libraryElement != null && libraryElement.isDartCore) {
+      if ((rhsType.isObject && rhsNameStr == _OBJECT_TYPE_NAME) || (expression is NullLiteral && rhsNameStr == _NULL_TYPE_NAME)) {
+        if (node.notOperator == null) {
+          _errorReporter.reportError2(HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node, []);
+        } else {
+          _errorReporter.reportError2(HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node, []);
+        }
+        return true;
+      } else if (rhsNameStr == _NULL_TYPE_NAME) {
+        if (node.notOperator == null) {
+          _errorReporter.reportError2(HintCode.TYPE_CHECK_IS_NULL, node, []);
+        } else {
+          _errorReporter.reportError2(HintCode.TYPE_CHECK_IS_NOT_NULL, node, []);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Check for the passed binary expression for the [HintCode#DIVISION_OPTIMIZATION].
+   *
+   * @param node the binary expression to check
+   * @return `true` if and only if a hint code is generated on the passed node
+   * @see HintCode#DIVISION_OPTIMIZATION
+   */
+  bool checkForDivisionOptimizationHint(BinaryExpression node) {
+    if (node.operator.type != sc.TokenType.SLASH) {
+      return false;
+    }
+    MethodElement methodElement = node.bestElement;
+    if (methodElement == null) {
+      return false;
+    }
+    LibraryElement libraryElement = methodElement.library;
+    if (libraryElement != null && !libraryElement.isDartCore) {
+      return false;
+    }
+    if (node.parent is ParenthesizedExpression) {
+      ParenthesizedExpression parenthesizedExpression = wrapParenthesizedExpression(node.parent as ParenthesizedExpression);
+      if (parenthesizedExpression.parent is MethodInvocation) {
+        MethodInvocation methodInvocation = parenthesizedExpression.parent as MethodInvocation;
+        if (_TO_INT_METHOD_NAME == methodInvocation.methodName.name && methodInvocation.argumentList.arguments.isEmpty) {
+          _errorReporter.reportError2(HintCode.DIVISION_OPTIMIZATION, methodInvocation, []);
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Check for the passed class declaration for the
+   * [HintCode#OVERRIDE_EQUALS_BUT_NOT_HASH_CODE] hint code.
+   *
+   * @param node the class declaration to check
+   * @return `true` if and only if a hint code is generated on the passed node
+   * @see HintCode#OVERRIDE_EQUALS_BUT_NOT_HASH_CODE
+   */
+  bool checkForOverrideEqualsButNotHashCode(ClassDeclaration node) {
+    ClassElement classElement = node.element;
+    if (classElement == null) {
+      return false;
+    }
+    MethodElement equalsOperatorMethodElement = classElement.getMethod(sc.TokenType.EQ_EQ.lexeme);
+    if (equalsOperatorMethodElement != null) {
+      PropertyAccessorElement hashCodeElement = classElement.getGetter(_HASHCODE_GETTER_NAME);
+      if (hashCodeElement == null) {
+        _errorReporter.reportError2(HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE, node.name, [classElement.displayName]);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Check for the passed class declaration for the
+   * [HintCode#OVERRIDE_EQUALS_BUT_NOT_HASH_CODE] hint code.
+   *
+   * @param node the class declaration to check
+   * @return `true` if and only if a hint code is generated on the passed node
+   * @see HintCode#OVERRIDDING_PRIVATE_MEMBER
+   */
+  bool checkForOverridingPrivateMember(MethodDeclaration node) {
+    if (_enclosingClass == null) {
+      return false;
+    }
+    if (!Identifier.isPrivateName(node.name.name)) {
+      return false;
+    }
+    ExecutableElement executableElement = node.element;
+    if (executableElement == null) {
+      return false;
+    }
+    String elementName = executableElement.name;
+    bool isGetterOrSetter = executableElement is PropertyAccessorElement;
+    InterfaceType superType = _enclosingClass.supertype;
+    if (superType == null) {
+      return false;
+    }
+    ClassElement classElement = superType.element;
+    while (classElement != null) {
+      if (_enclosingClass.library != classElement.library) {
+        if (isGetterOrSetter) {
+          PropertyAccessorElement overriddenAccessor = null;
+          List<PropertyAccessorElement> accessors = classElement.accessors;
+          for (PropertyAccessorElement propertyAccessorElement in accessors) {
+            if (elementName == propertyAccessorElement.name) {
+              overriddenAccessor = propertyAccessorElement;
+              break;
+            }
+          }
+          if (overriddenAccessor != null) {
+            String memberType = ((executableElement as PropertyAccessorElement)).isGetter ? _GETTER : _SETTER;
+            _errorReporter.reportError2(HintCode.OVERRIDDING_PRIVATE_MEMBER, node.name, [
+                memberType,
+                executableElement.displayName,
+                classElement.displayName]);
+            return true;
+          }
+        } else {
+          MethodElement overriddenMethod = classElement.getMethod(elementName);
+          if (overriddenMethod != null) {
+            _errorReporter.reportError2(HintCode.OVERRIDDING_PRIVATE_MEMBER, node.name, [
+                _METHOD,
+                executableElement.displayName,
+                classElement.displayName]);
+            return true;
+          }
+        }
+      }
+      superType = classElement.supertype;
+      classElement = superType != null ? superType.element : null;
+    }
+    return false;
+  }
+
+  /**
+   * Check for the passed as expression for the [HintCode#UNNECESSARY_CAST] hint code.
+   *
+   * @param node the as expression to check
+   * @return `true` if and only if a hint code is generated on the passed node
+   * @see HintCode#UNNECESSARY_CAST
+   */
+  bool checkForUnnecessaryCast(AsExpression node) {
+    Expression expression = node.expression;
+    TypeName typeName = node.type;
+    Type2 lhsType = expression.staticType;
+    Type2 rhsType = typeName.type;
+    if (lhsType != null && rhsType != null && !lhsType.isDynamic && !rhsType.isDynamic && lhsType.isSubtypeOf(rhsType)) {
+      _errorReporter.reportError2(HintCode.UNNECESSARY_CAST, node, []);
+      return true;
+    }
+    return false;
+  }
+}
+/**
+ * Instances of the class `Dart2JSVerifier` traverse an AST structure looking for hints for
+ * code that will be compiled to JS, such as [HintCode#IS_DOUBLE].
+ *
+ * @coverage dart.engine.resolver
+ */
+class Dart2JSVerifier extends RecursiveASTVisitor<Object> {
+
+  /**
+   * The error reporter by which errors will be reported.
+   */
+  ErrorReporter _errorReporter;
+
+  /**
+   * The name of the `double` type.
+   */
+  static String _DOUBLE_TYPE_NAME = "double";
+
+  /**
+   * Create a new instance of the [Dart2JSVerifier].
+   *
+   * @param errorReporter the error reporter
+   */
+  Dart2JSVerifier(ErrorReporter errorReporter) {
+    this._errorReporter = errorReporter;
+  }
+  Object visitIsExpression(IsExpression node) {
+    checkForIsDoubleHints(node);
+    return super.visitIsExpression(node);
+  }
+
+  /**
+   * Check for instances of `x is double`, `x is int`, `x is! double` and
+   * `x is! int`.
+   *
+   * @param node the is expression to check
+   * @return `true` if and only if a hint code is generated on the passed node
+   * @see HintCode#IS_DOUBLE
+   * @see HintCode#IS_INT
+   * @see HintCode#IS_NOT_DOUBLE
+   * @see HintCode#IS_NOT_INT
+   */
+  bool checkForIsDoubleHints(IsExpression node) {
+    TypeName typeName = node.type;
+    Type2 type = typeName.type;
+    if (type != null && type.element != null) {
+      Element element = type.element;
+      String typeNameStr = element.name;
+      LibraryElement libraryElement = element.library;
+      if (typeNameStr == _DOUBLE_TYPE_NAME && libraryElement != null && libraryElement.isDartCore) {
+        if (node.notOperator == null) {
+          _errorReporter.reportError2(HintCode.IS_DOUBLE, node, []);
+        } else {
+          _errorReporter.reportError2(HintCode.IS_NOT_DOUBLE, node, []);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+}
+/**
  * Instances of the class `DeadCodeVerifier` traverse an AST structure looking for cases of
  * [HintCode#DEAD_CODE].
  *
  * @coverage dart.engine.resolver
  */
 class DeadCodeVerifier extends RecursiveASTVisitor<Object> {
 
   /**
    * The error reporter by which errors will be reported.
    */
   ErrorReporter _errorReporter;
 
   /**
    * Create a new instance of the [DeadCodeVerifier].
    *
    * @param errorReporter the error reporter
    */
   DeadCodeVerifier(ErrorReporter errorReporter) {
     this._errorReporter = errorReporter;
   }
   Object visitBinaryExpression(BinaryExpression node) {
     sc.Token operator = node.operator;
     bool isAmpAmp = identical(operator.type, sc.TokenType.AMPERSAND_AMPERSAND);
     bool isBarBar = identical(operator.type, sc.TokenType.BAR_BAR);
     if (isAmpAmp || isBarBar) {
       Expression lhsCondition = node.leftOperand;
-      ValidResult lhsResult = getConstantBooleanValue(lhsCondition);
-      if (lhsResult != null) {
-        if (identical(lhsResult, ValidResult.RESULT_TRUE) && isBarBar) {
-          _errorReporter.reportError2(HintCode.DEAD_CODE, node.rightOperand, []);
-          safelyVisit(lhsCondition);
-          return null;
-        } else if (identical(lhsResult, ValidResult.RESULT_FALSE) && isAmpAmp) {
-          _errorReporter.reportError2(HintCode.DEAD_CODE, node.rightOperand, []);
-          safelyVisit(lhsCondition);
-          return null;
+      if (!isDebugConstant(lhsCondition)) {
+        ValidResult lhsResult = getConstantBooleanValue(lhsCondition);
+        if (lhsResult != null) {
+          if (identical(lhsResult, ValidResult.RESULT_TRUE) && isBarBar) {
+            _errorReporter.reportError2(HintCode.DEAD_CODE, node.rightOperand, []);
+            safelyVisit(lhsCondition);
+            return null;
+          } else if (identical(lhsResult, ValidResult.RESULT_FALSE) && isAmpAmp) {
+            _errorReporter.reportError2(HintCode.DEAD_CODE, node.rightOperand, []);
+            safelyVisit(lhsCondition);
+            return null;
+          }
         }
       }
     }
     return super.visitBinaryExpression(node);
   }
 
   /**
    * For each [Block], this method reports and error on all statements between the end of the
    * block and the first return statement (assuming there it is not at the end of the block.)
    *
@@ skipping 11 matching lines @@
         int offset = nextStatement.offset;
         int length = lastStatement.end - offset;
         _errorReporter.reportError3(HintCode.DEAD_CODE, offset, length, []);
         return null;
       }
     }
     return null;
   }
   Object visitConditionalExpression(ConditionalExpression node) {
     Expression conditionExpression = node.condition;
-    ValidResult result = getConstantBooleanValue(conditionExpression);
-    if (result != null) {
-      if (identical(result, ValidResult.RESULT_TRUE)) {
-        _errorReporter.reportError2(HintCode.DEAD_CODE, node.elseExpression, []);
-        safelyVisit(node.thenExpression);
-        return null;
-      } else {
-        _errorReporter.reportError2(HintCode.DEAD_CODE, node.thenExpression, []);
-        safelyVisit(node.elseExpression);
-        return null;
+    safelyVisit(conditionExpression);
+    if (!isDebugConstant(conditionExpression)) {
+      ValidResult result = getConstantBooleanValue(conditionExpression);
+      if (result != null) {
+        if (identical(result, ValidResult.RESULT_TRUE)) {
+          _errorReporter.reportError2(HintCode.DEAD_CODE, node.elseExpression, []);
+          safelyVisit(node.thenExpression);
+          return null;
+        } else {
+          _errorReporter.reportError2(HintCode.DEAD_CODE, node.thenExpression, []);
+          safelyVisit(node.elseExpression);
+          return null;
+        }
       }
     }
     return super.visitConditionalExpression(node);
   }
   Object visitIfStatement(IfStatement node) {
     Expression conditionExpression = node.condition;
-    ValidResult result = getConstantBooleanValue(conditionExpression);
-    if (result != null) {
-      if (identical(result, ValidResult.RESULT_TRUE)) {
-        Statement elseStatement = node.elseStatement;
-        if (elseStatement != null) {
-          _errorReporter.reportError2(HintCode.DEAD_CODE, elseStatement, []);
-          safelyVisit(node.thenStatement);
+    safelyVisit(conditionExpression);
+    if (!isDebugConstant(conditionExpression)) {
+      ValidResult result = getConstantBooleanValue(conditionExpression);
+      if (result != null) {
+        if (identical(result, ValidResult.RESULT_TRUE)) {
+          Statement elseStatement = node.elseStatement;
+          if (elseStatement != null) {
+            _errorReporter.reportError2(HintCode.DEAD_CODE, elseStatement, []);
+            safelyVisit(node.thenStatement);
+            return null;
+          }
+        } else {
+          _errorReporter.reportError2(HintCode.DEAD_CODE, node.thenStatement, []);
+          safelyVisit(node.elseStatement);
           return null;
         }
-      } else {
-        _errorReporter.reportError2(HintCode.DEAD_CODE, node.thenStatement, []);
-        safelyVisit(node.elseStatement);
-        return null;
       }
     }
     return super.visitIfStatement(node);
   }
   Object visitTryStatement(TryStatement node) {
     safelyVisit(node.body);
     safelyVisit(node.finallyBlock);
     NodeList<CatchClause> catchClauses = node.catchClauses;
     int numOfCatchClauses = catchClauses.length;
     List<Type2> visitedTypes = new List<Type2>();
@@ skipping 36 matching lines @@
           _errorReporter.reportError3(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
           return null;
         }
       }
     }
     return null;
   }
   Object visitWhileStatement(WhileStatement node) {
     Expression conditionExpression = node.condition;
     safelyVisit(conditionExpression);
-    ValidResult result = getConstantBooleanValue(conditionExpression);
-    if (result != null) {
-      if (identical(result, ValidResult.RESULT_FALSE)) {
-        _errorReporter.reportError2(HintCode.DEAD_CODE, node.body, []);
-        return null;
+    if (!isDebugConstant(conditionExpression)) {
+      ValidResult result = getConstantBooleanValue(conditionExpression);
+      if (result != null) {
+        if (identical(result, ValidResult.RESULT_FALSE)) {
+          _errorReporter.reportError2(HintCode.DEAD_CODE, node.body, []);
+          return null;
+        }
       }
     }
     safelyVisit(node.body);
     return null;
   }
 
   /**
    * Given some [Expression], this method returns [ValidResult#RESULT_TRUE] if it is
    * `true`, [ValidResult#RESULT_FALSE] if it is `false`, or `null` if the
    * expression is not a constant boolean value.
    *
    * @param expression the expression to evaluate
    * @return [ValidResult#RESULT_TRUE] if it is `true`, [ValidResult#RESULT_FALSE]
    *         if it is `false`, or `null` if the expression is not a constant boolean
    *         value
    */
   ValidResult getConstantBooleanValue(Expression expression) {
     if (expression is BooleanLiteral) {
       if (((expression as BooleanLiteral)).value) {
         return ValidResult.RESULT_TRUE;
       } else {
         return ValidResult.RESULT_FALSE;
       }
-    } else {
-      EvaluationResultImpl result = expression.accept(new ConstantVisitor());
-      if (identical(result, ValidResult.RESULT_TRUE)) {
-        return ValidResult.RESULT_TRUE;
-      } else if (identical(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) {
+    Element element = null;
+    if (expression is Identifier) {
+      Identifier identifier = expression as Identifier;
+      element = identifier.staticElement;
+    } else if (expression is PropertyAccess) {
+      PropertyAccess propertyAccess = expression as PropertyAccess;
+      element = propertyAccess.propertyName.staticElement;
+    }
+    if (element is PropertyAccessorElement) {
+      PropertyAccessorElement pae = element as PropertyAccessorElement;
+      PropertyInducingElement variable = pae.variable;
+      return variable != null && variable.isConst;
+    }
+    return false;
+  }
+
+  /**
    * If the given node is not `null`, visit this instance of the dead code verifier.
    *
    * @param node the node to be visited
    */
   void safelyVisit(ASTNode node) {
     if (node != null) {
       node.accept(this);
     }
   }
 }
 /**
  * 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;
   AnalysisErrorListener _errorListener;
   ImportsVerifier _importsVerifier;
-  DeadCodeVerifier _deadCodeVerifier;
+  bool _enableDart2JSHints = false;
   HintGenerator(List<CompilationUnit> compilationUnits, AnalysisContext context, AnalysisErrorListener errorListener) {
     this._compilationUnits = compilationUnits;
     this._context = context;
     this._errorListener = errorListener;
     LibraryElement library = compilationUnits[0].element.library;
     _importsVerifier = new ImportsVerifier(library);
+    _enableDart2JSHints = context.analysisOptions.dart2jsHint;
   }
   void generateForLibrary() {
+    TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.hints.start();
     for (int i = 0; i < _compilationUnits.length; i++) {
       CompilationUnitElement element = _compilationUnits[i].element;
       if (element != null) {
         if (i == 0) {
           _importsVerifier.inDefiningCompilationUnit = true;
           generateForCompilationUnit(_compilationUnits[i], element.source);
           _importsVerifier.inDefiningCompilationUnit = false;
         } else {
           generateForCompilationUnit(_compilationUnits[i], element.source);
         }
       }
     }
-    _importsVerifier.generateUnusedImportHints(new ErrorReporter(_errorListener, _compilationUnits[0].element.source));
+    ErrorReporter definingCompilationUnitErrorReporter = new ErrorReporter(_errorListener, _compilationUnits[0].element.source);
+    _importsVerifier.generateDuplicateImportHints(definingCompilationUnitErrorReporter);
+    _importsVerifier.generateUnusedImportHints(definingCompilationUnitErrorReporter);
+    timeCounter.stop();
   }
   void generateForCompilationUnit(CompilationUnit unit, Source source) {
     ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
     _importsVerifier.visitCompilationUnit(unit);
-    _deadCodeVerifier = new DeadCodeVerifier(errorReporter);
-    _deadCodeVerifier.visitCompilationUnit(unit);
+    new DeadCodeVerifier(errorReporter).visitCompilationUnit(unit);
+    if (_enableDart2JSHints) {
+      new Dart2JSVerifier(errorReporter).visitCompilationUnit(unit);
+    }
+    new BestPracticesVerifier(errorReporter).visitCompilationUnit(unit);
   }
 }
 /**
  * Instances of the class `ImportsVerifier` visit all of the referenced libraries in the
  * source code verifying that all of the imports are used, otherwise a
  * [HintCode#UNUSED_IMPORT] is generated with
  * [generateUnusedImportHints].
  *
  * While this class does not yet have support for an "Organize Imports" action, this logic built up
  * in this class could be used for such an action in the future.
@@ skipping 18 matching lines @@
    * A list of [ImportDirective]s that the current library imports, as identifiers are visited
    * by this visitor and an import has been identified as being used by the library, the
    * [ImportDirective] is removed from this list. After all the sources in the library have
    * been evaluated, this list represents the set of unused imports.
    *
    * @see ImportsVerifier#generateUnusedImportErrors(ErrorReporter)
    */
   List<ImportDirective> _unusedImports;
 
   /**
+   * After the list of [unusedImports] has been computed, this list is a proper subset of the
+   * unused imports that are listed more than once.
+   */
+  List<ImportDirective> _duplicateImports;
+
+  /**
    * This is a map between the set of [LibraryElement]s that the current library imports, and
    * a list of [ImportDirective]s that imports the library. In cases where the current library
    * imports a library with a single directive (such as `import lib1.dart;`), the library
    * element will map to a list of one [ImportDirective], which will then be removed from the
    * [unusedImports] list. In cases where the current library imports a library with multiple
    * directives (such as `import lib1.dart; import lib1.dart show C;`), the
    * [LibraryElement] will be mapped to a list of the import directives, and the namespace
    * will need to be used to compute the correct [ImportDirective] being used, see
    * [namespaceMap].
    */
@@ skipping 16 matching lines @@
   Map<PrefixElement, ImportDirective> _prefixElementMap;
 
   /**
    * Create a new instance of the [ImportsVerifier].
    *
    * @param errorReporter the error reporter
    */
   ImportsVerifier(LibraryElement library) {
     this._currentLibrary = library;
     this._unusedImports = new List<ImportDirective>();
+    this._duplicateImports = new List<ImportDirective>();
     this._libraryMap = new Map<LibraryElement, List<ImportDirective>>();
     this._namespaceMap = new Map<ImportDirective, Namespace>();
     this._prefixElementMap = new Map<PrefixElement, ImportDirective>();
   }
 
   /**
+   * Any time after the defining compilation unit has been visited by this visitor, this method can
+   * be called to report an [HintCode#DUPLICATE_IMPORT] hint for each of the import directives
+   * in the [duplicateImports] list.
+   *
+   * @param errorReporter the error reporter to report the set of [HintCode#DUPLICATE_IMPORT]
+   *          hints to
+   */
+  void generateDuplicateImportHints(ErrorReporter errorReporter) {
+    for (ImportDirective duplicateImport in _duplicateImports) {
+      errorReporter.reportError2(HintCode.DUPLICATE_IMPORT, duplicateImport.uri, []);
+    }
+  }
+
+  /**
    * After all of the compilation units have been visited by this visitor, this method can be called
    * to report an [HintCode#UNUSED_IMPORT] hint for each of the import directives in the
    * [unusedImports] list.
    *
    * @param errorReporter the error reporter to report the set of [HintCode#UNUSED_IMPORT]
    *          hints to
    */
   void generateUnusedImportHints(ErrorReporter errorReporter) {
     for (ImportDirective unusedImport in _unusedImports) {
+      Element element = unusedImport.element;
+      if (element is ImportElement) {
+        ImportElement importElement = element as ImportElement;
+        LibraryElement libraryElement = importElement.importedLibrary;
+        if (libraryElement != null && libraryElement.isDartCore) {
+          continue;
+        }
+      }
       errorReporter.reportError2(HintCode.UNUSED_IMPORT, unusedImport.uri, []);
     }
   }
   Object visitCompilationUnit(CompilationUnit node) {
     if (_inDefiningCompilationUnit) {
       NodeList<Directive> directives = node.directives;
       for (Directive directive in directives) {
         if (directive is ImportDirective) {
           ImportDirective importDirective = directive as ImportDirective;
           LibraryElement libraryElement = importDirective.uriElement;
@@ skipping 11 matching lines @@
             }
             putIntoLibraryMap(libraryElement, importDirective);
             addAdditionalLibrariesForExports(libraryElement, importDirective, new List<LibraryElement>());
           }
         }
       }
     }
     if (_unusedImports.isEmpty) {
       return null;
     }
+    if (_unusedImports.length > 1) {
+      List<ImportDirective> importDirectiveArray = new List.from(_unusedImports);
+      importDirectiveArray.sort(ImportDirective.COMPARATOR);
+      ImportDirective currentDirective = importDirectiveArray[0];
+      for (int i = 1; i < importDirectiveArray.length; i++) {
+        ImportDirective nextDirective = importDirectiveArray[i];
+        if (ImportDirective.COMPARATOR(currentDirective, nextDirective) == 0) {
+          if (currentDirective.offset < nextDirective.offset) {
+            _duplicateImports.add(nextDirective);
+          } else {
+            _duplicateImports.add(currentDirective);
+          }
+        }
+        currentDirective = nextDirective;
+      }
+    }
     return super.visitCompilationUnit(node);
   }
   Object visitExportDirective(ExportDirective node) => null;
   Object visitImportDirective(ImportDirective node) => null;
   Object visitLibraryDirective(LibraryDirective node) => null;
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefixIdentifier = node.prefix;
     Element element = prefixIdentifier.staticElement;
     if (element is PrefixElement) {
       _unusedImports.remove(_prefixElementMap[element]);
@@ skipping 539 matching lines @@
   Object visitSwitchDefault(SwitchDefault node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       find3(_enclosingExecutable.labels, labelName);
     }
     return super.visitSwitchDefault(node);
   }
   Object visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
     if (_enclosingClass != null) {
-      find3(_enclosingClass.typeVariables, parameterName);
+      find3(_enclosingClass.typeParameters, parameterName);
     } else if (_enclosingAlias != null) {
-      find3(_enclosingAlias.typeVariables, parameterName);
+      find3(_enclosingAlias.typeParameters, parameterName);
     }
     return super.visitTypeParameter(node);
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
     VariableElement element = null;
     SimpleIdentifier variableName = node.name;
     if (_enclosingExecutable != null) {
       element = find3(_enclosingExecutable.localVariables, variableName);
     }
     if (element == null && _enclosingClass != null) {
@@ skipping 12 matching lines @@
         }
         return super.visitVariableDeclaration(node);
       } finally {
         _enclosingExecutable = outerExecutable;
       }
     }
     return super.visitVariableDeclaration(node);
   }
 
   /**
-   * Append the value of the given string literal to the given string builder.
-   *
-   * @param builder the builder to which the string's value is to be appended
-   * @param literal the string literal whose value is to be appended to the builder
-   * @throws IllegalArgumentException if the string is not a constant string without any string
-   *           interpolation
-   */
-  void appendStringValue(JavaStringBuilder builder, StringLiteral literal) {
-    if (literal is SimpleStringLiteral) {
-      builder.append(((literal as SimpleStringLiteral)).value);
-    } else if (literal is AdjacentStrings) {
-      for (StringLiteral stringLiteral in ((literal as AdjacentStrings)).strings) {
-        appendStringValue(builder, stringLiteral);
-      }
-    } else {
-      throw new IllegalArgumentException();
-    }
-  }
-
-  /**
    * Return the element for the part with the given source, or `null` if there is no element
    * for the given source.
    *
    * @param parts the elements for the parts
    * @param partSource the source for the part whose element is to be returned
    * @return the element for the part with the given source
    */
   CompilationUnitElement find(List<CompilationUnitElement> parts, Source partSource) {
     for (CompilationUnitElement part in parts) {
       if (part.source == partSource) {
@@ skipping 130 matching lines @@
    * Return the value of the given string literal, or `null` if the string is not a constant
    * string without any string interpolation.
    *
    * @param literal the string literal whose value is to be returned
    * @return the value of the given string literal
    */
   String getStringValue(StringLiteral literal) {
     if (literal is StringInterpolation) {
       return null;
     }
-    JavaStringBuilder builder = new JavaStringBuilder();
-    try {
-      appendStringValue(builder, literal);
-    } on IllegalArgumentException catch (exception) {
-      return null;
-    }
-    return builder.toString().trim();
+    return literal.stringValue;
   }
 }
 /**
  * Instances of the class `ElementResolver` are used by instances of [ResolverVisitor]
  * to resolve references within the AST structure to the elements being referenced. The requirements
  * for the element resolver are:
  * <ol>
  * * Every [SimpleIdentifier] should be resolved to the element to which it refers.
  * Specifically:
  *
@@ skipping 631 matching lines @@
     } else {
       element = enclosingClass.getNamedConstructor(name.name);
     }
     if (element == null) {
       return null;
     }
     if (name != null) {
       name.staticElement = element;
     }
     node.staticElement = element;
-    node.element = element;
     ArgumentList argumentList = node.argumentList;
     List<ParameterElement> parameters = resolveArgumentsToParameters(false, argumentList, element);
     if (parameters != null) {
       argumentList.correspondingStaticParameters = parameters;
     }
     return null;
   }
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (node.staticElement != null) {
       return null;
@@ skipping 54 matching lines @@
       return null;
     } else {
       if (element.isFactory) {
         _resolver.reportError5(CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node, [element]);
       }
     }
     if (name != null) {
       name.staticElement = element;
     }
     node.staticElement = element;
-    node.element = 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.reportError5(CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT, node, []);
     }
     return super.visitSuperExpression(node);
   }
   Object visitTypeParameter(TypeParameter node) {
     TypeName bound = node.bound;
     if (bound != null) {
-      TypeVariableElementImpl variable = node.name.staticElement as TypeVariableElementImpl;
-      if (variable != null) {
-        variable.bound = bound.type;
+      TypeParameterElementImpl typeParameter = node.name.staticElement as TypeParameterElementImpl;
+      if (typeParameter != null) {
+        typeParameter.bound = bound.type;
       }
     }
     setMetadata(node.element, node);
     return null;
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
 
@@ skipping 174 matching lines @@
     LibraryElement definingLibrary = _resolver.definingLibrary;
     for (ImportElement importElement in definingLibrary.imports) {
       PrefixElement prefixElement = importElement.prefix;
       if (prefixElement != null) {
         Identifier prefixedIdentifier = new ElementResolver_SyntheticIdentifier("${prefixElement.name}.${identifier.name}");
         Element importedElement = nameScope.lookup(prefixedIdentifier, definingLibrary);
         if (importedElement != null) {
           if (element == null) {
             element = importedElement;
           } else {
-            element = new MultiplyDefinedElementImpl(definingLibrary.context, element, importedElement);
+            element = new MultiplyDefinedElementImpl.con1(definingLibrary.context, element, importedElement);
           }
         }
       }
     }
     return element;
   }
 
   /**
    * Return the name of the method invoked by the given postfix expression.
    *
@@ skipping 22 matching lines @@
     }
   }
 
   /**
    * Return the propagated type of the given expression that is to be used for type analysis.
    *
    * @param expression the expression whose type is to be returned
    * @return the type of the given expression
    */
   Type2 getPropagatedType(Expression expression) {
-    Type2 propagatedType = resolveTypeVariable(expression.propagatedType);
+    Type2 propagatedType = resolveTypeParameter(expression.propagatedType);
     if (propagatedType is FunctionType) {
       propagatedType = _resolver.typeProvider.functionType;
     }
     return propagatedType;
   }
 
   /**
    * Return the static type of the given expression that is to be used for type analysis.
    *
    * @param expression the expression whose type is to be returned
    * @return the type of the given expression
    */
   Type2 getStaticType(Expression expression) {
     if (expression is NullLiteral) {
       return _resolver.typeProvider.objectType;
     }
-    Type2 staticType = resolveTypeVariable(expression.staticType);
+    Type2 staticType = resolveTypeParameter(expression.staticType);
     if (staticType is FunctionType) {
       staticType = _resolver.typeProvider.functionType;
     }
     return staticType;
   }
 
   /**
    * Return the element representing the superclass of the given class.
    *
    * @param targetClass the class whose superclass is to be returned
@@ skipping 76 matching lines @@
   /**
    * Look up the getter with the given name in the given type. Return the element representing the
    * getter that was found, or `null` if there is no getter with the given name.
    *
    * @param target the target of the invocation, or `null` if there is no target
    * @param type the type in which the getter is defined
    * @param getterName the name of the getter being looked up
    * @return the element representing the getter that was found
    */
   PropertyAccessorElement lookUpGetter(Expression target, Type2 type, String getterName) {
-    type = resolveTypeVariable(type);
+    type = resolveTypeParameter(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type as InterfaceType;
       PropertyAccessorElement accessor;
       if (target is SuperExpression) {
         accessor = interfaceType.lookUpGetterInSuperclass(getterName, _resolver.definingLibrary);
       } else {
         accessor = interfaceType.lookUpGetter(getterName, _resolver.definingLibrary);
       }
       if (accessor != null) {
         return accessor;
@@ skipping 49 matching lines @@
   /**
    * Look up the method or getter with the given name in the given type. Return the element
    * representing the method or getter that was found, or `null` if there is no method or
    * getter with the given name.
    *
    * @param type the type in which the method or getter is defined
    * @param memberName the name of the method or getter being looked up
    * @return the element representing the method or getter that was found
    */
   ExecutableElement lookupGetterOrMethod(Type2 type, String memberName) {
-    type = resolveTypeVariable(type);
+    type = resolveTypeParameter(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type as InterfaceType;
       ExecutableElement member = interfaceType.lookUpMethod(memberName, _resolver.definingLibrary);
       if (member != null) {
         return member;
       }
       member = interfaceType.lookUpGetter(memberName, _resolver.definingLibrary);
       if (member != null) {
         return member;
       }
@@ skipping 92 matching lines @@
   /**
    * 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.
    *
    * @param target the target of the invocation, or `null` if there is no target
    * @param type the type in which the method is defined
    * @param methodName the name of the method being looked up
    * @return the element representing the method that was found
    */
   MethodElement lookUpMethod(Expression target, Type2 type, String methodName) {
-    type = resolveTypeVariable(type);
+    type = resolveTypeParameter(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type as InterfaceType;
       MethodElement method;
       if (target is SuperExpression) {
         method = interfaceType.lookUpMethodInSuperclass(methodName, _resolver.definingLibrary);
       } else {
         method = interfaceType.lookUpMethod(methodName, _resolver.definingLibrary);
       }
       if (method != null) {
         return method;
@@ skipping 49 matching lines @@
   /**
    * Look up the setter with the given name in the given type. Return the element representing the
    * setter that was found, or `null` if there is no setter with the given name.
    *
    * @param target the target of the invocation, or `null` if there is no target
    * @param type the type in which the setter is defined
    * @param setterName the name of the setter being looked up
    * @return the element representing the setter that was found
    */
   PropertyAccessorElement lookUpSetter(Expression target, Type2 type, String setterName) {
-    type = resolveTypeVariable(type);
+    type = resolveTypeParameter(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type as InterfaceType;
       PropertyAccessorElement accessor;
       if (target is SuperExpression) {
         accessor = interfaceType.lookUpSetterInSuperclass(setterName, _resolver.definingLibrary);
       } else {
         accessor = interfaceType.lookUpSetter(setterName, _resolver.definingLibrary);
       }
       if (accessor != null) {
         return accessor;
@@ skipping 405 matching lines @@
         element = lookUpGetter(null, enclosingType, node.name);
       }
       if (element == null) {
         element = lookUpMethod(null, enclosingType, node.name);
       }
     }
     return element;
   }
 
   /**
-   * If the given type is a type variable, resolve it to the type that should be used when looking
+   * If the given type is a type parameter, resolve it to the type that should be used when looking
    * up members. Otherwise, return the original type.
    *
-   * @param type the type that is to be resolved if it is a type variable
-   * @return the type that should be used in place of the argument if it is a type variable, or the
-   *         original argument if it isn't a type variable
+   * @param type the type that is to be resolved if it is a type parameter
+   * @return the type that should be used in place of the argument if it is a type parameter, or the
+   *         original argument if it isn't a type parameter
    */
-  Type2 resolveTypeVariable(Type2 type) {
-    if (type is TypeVariableType) {
-      Type2 bound = ((type as TypeVariableType)).element.bound;
+  Type2 resolveTypeParameter(Type2 type) {
+    if (type is TypeParameterType) {
+      Type2 bound = ((type as TypeParameterType)).element.bound;
       if (bound == null) {
         return _resolver.typeProvider.objectType;
       }
       return bound;
     }
     return type;
   }
 
   /**
    * Return the propagated element if it is not `null`, or the static element if it is.
@@ skipping 1065 matching lines @@
  * @coverage dart.engine.resolver
  */
 class LibraryResolver {
 
   /**
    * The analysis context in which the libraries are being analyzed.
    */
   InternalAnalysisContext analysisContext;
 
   /**
-   * A flag indicating whether analysis is to generate hint results (e.g. type inference based
-   * information and pub best practices).
-   */
-  bool _enableHints = false;
-
-  /**
    * The listener to which analysis errors will be reported, this error listener is either
    * references [recordingErrorListener], or it unions the passed
    * [AnalysisErrorListener] with the [recordingErrorListener].
    */
   RecordingErrorListener errorListener;
 
   /**
    * A source object representing the core library (dart:core).
    */
   Source _coreLibrarySource;
@@ skipping 20 matching lines @@
 
   /**
    * Initialize a newly created library resolver to resolve libraries within the given context.
    *
    * @param analysisContext the analysis context in which the library is being analyzed
    */
   LibraryResolver(InternalAnalysisContext analysisContext) {
     this.analysisContext = analysisContext;
     this.errorListener = new RecordingErrorListener();
     _coreLibrarySource = analysisContext.sourceFactory.forUri(DartSdk.DART_CORE);
-    _enableHints = analysisContext.analysisOptions.hint;
   }
 
   /**
    * Resolve the library specified by the given source in the given context. The library is assumed
    * to be embedded in the given source.
    *
    * @param librarySource the source specifying the defining compilation unit of the library to be
    *          resolved
    * @param modificationStamp the time stamp of the source from which the compilation unit was
    *          created
@@ skipping 269 matching lines @@
     }
   }
 
   /**
    * Resolve the type hierarchy across all of the types declared in the libraries in the current
    * cycle.
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void buildTypeHierarchies() {
+    TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
     for (Library library in resolvedLibraries) {
       for (Source source in library.compilationUnitSources) {
         TypeResolverVisitor visitor = new TypeResolverVisitor.con1(library, source, _typeProvider);
         library.getAST(source).accept(visitor);
       }
     }
+    timeCounter.stop();
   }
 
   /**
    * Compute a dependency map of libraries reachable from the given library. A dependency map is a
    * table that maps individual libraries to a list of the libraries that either import or export
    * those libraries.
    *
    * This map is used to compute all of the libraries involved in a cycle that include the root
    * library. Given that we only add libraries that are reachable from the root library, when we
    * work backward we are guaranteed to only get libraries in the cycle.
@@ skipping 192 matching lines @@
     for (int i = 0; i < count; i++) {
       identifiers[i] = names[i].name;
     }
     return identifiers;
   }
 
   /**
    * Compute a value for all of the constants in the libraries being analyzed.
    */
   void performConstantEvaluation() {
+    TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
     ConstantValueComputer computer = new ConstantValueComputer();
     for (Library library in resolvedLibraries) {
       for (Source source in library.compilationUnitSources) {
         try {
           CompilationUnit unit = library.getAST(source);
           if (unit != null) {
             computer.add(unit);
           }
         } on AnalysisException catch (exception) {
           AnalysisEngine.instance.logger.logError2("Internal Error: Could not access AST for ${source.fullName} during constant evaluation", exception);
         }
       }
     }
     computer.computeValues();
+    timeCounter.stop();
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the libraries in the current cycle.
    *
    * @throws AnalysisException if any of the identifiers could not be resolved or if any of the
    *           libraries could not have their types analyzed
    */
   void resolveReferencesAndTypes() {
     for (Library library in resolvedLibraries) {
       resolveReferencesAndTypes2(library);
     }
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the given library.
    *
    * @param library the library to be resolved
    * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
    *           the library cannot be analyzed
    */
   void resolveReferencesAndTypes2(Library library) {
+    TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
     for (Source source in library.compilationUnitSources) {
       ResolverVisitor visitor = new ResolverVisitor.con1(library, source, _typeProvider);
       library.getAST(source).accept(visitor);
       for (ProxyConditionalAnalysisError conditionalCode in visitor.proxyConditionalAnalysisErrors) {
         if (conditionalCode.shouldIncludeErrorCode()) {
           visitor.reportError(conditionalCode.analysisError);
         }
       }
     }
+    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 25 matching lines @@
 
   /**
    * Run additional analyses, such as the [ConstantVerifier] and [ErrorVerifier]
    * analysis in the given library.
    *
    * @param library the library to have the extra analyses processes run
    * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
    *           the library cannot be analyzed
    */
   void runAdditionalAnalyses2(Library library) {
+    TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.errors.start();
     for (Source source in library.compilationUnitSources) {
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       CompilationUnit unit = library.getAST(source);
       ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, _typeProvider);
       unit.accept(constantVerifier);
       ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter, library.libraryElement, _typeProvider, library.inheritanceManager);
       unit.accept(errorVerifier);
     }
-    if (_enableHints) {
-      HintGenerator hintGenerator = new HintGenerator(library.compilationUnits, analysisContext, errorListener);
-      hintGenerator.generateForLibrary();
-    }
+    timeCounter.stop();
   }
 }
 /**
  * This class is a wrapper for an [AnalysisError] which can also be queried after resolution
  * to find out if the error should actually be reported. In this case, these errors are conditional
  * on the non-existence of an `@proxy` annotation.
  *
  * If we have other conditional error codes in the future, we should have this class implement some
  * ConditionalErrorCode so that after resolution, a list of ConditionalErrorCode can be visited
  * instead of multiple lists of *ConditionalErrorCodes.
@@ skipping 631 matching lines @@
    * @param token the token specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportErrorProxyConditionalAnalysisError3(Element enclosingElement, ErrorCode errorCode, sc.Token token, List<Object> arguments) {
     proxyConditionalAnalysisErrors.add(new ProxyConditionalAnalysisError(enclosingElement, new AnalysisError.con2(source, token.offset, token.length, errorCode, arguments)));
   }
   void visitForEachStatementInScope(ForEachStatement node) {
     Expression iterator = node.iterator;
     safelyVisit(iterator);
     DeclaredIdentifier loopVariable = node.loopVariable;
+    SimpleIdentifier identifier = node.identifier;
     safelyVisit(loopVariable);
+    safelyVisit(identifier);
     Statement body = node.body;
     if (body != null) {
       try {
         overrideManager.enterScope();
         if (loopVariable != null && iterator != null) {
           LocalVariableElement loopElement = loopVariable.element;
           if (loopElement != null) {
             Type2 iteratorElementType = getIteratorElementType(iterator);
             override2(loopElement, iteratorElementType);
             recordPropagatedType(loopVariable.identifier, iteratorElementType);
           }
+        } else if (identifier != null && iterator != null) {
+          Element identifierElement = identifier.staticElement;
+          if (identifierElement is VariableElement) {
+            Type2 iteratorElementType = getIteratorElementType(iterator);
+            override2(identifierElement as VariableElement, iteratorElementType);
+            recordPropagatedType(identifier, iteratorElementType);
+          }
         }
         visitStatementInScope(body);
       } finally {
         overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
   }
   void visitForStatementInScope(ForStatement node) {
@@ skipping 585 matching lines @@
   }
 
   /**
    * Visit the given statement after it's scope has been created. This replaces the normal call to
    * the inherited visit method so that ResolverVisitor can intervene when type propagation is
    * enabled.
    *
    * @param node the statement to be visited
    */
   void visitForEachStatementInScope(ForEachStatement node) {
+    safelyVisit(node.identifier);
     safelyVisit(node.iterator);
     safelyVisit(node.loopVariable);
     visitStatementInScope(node.body);
   }
 
   /**
    * Visit the given statement after it's scope has been created. This replaces the normal call to
    * the inherited visit method so that ResolverVisitor can intervene when type propagation is
    * enabled.
    *
@@ skipping 546 matching lines @@
    * The Dart Language Specification, 12.11.1: <blockquote>The static type of a new expression of
    * either the form <i>new T.id(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> or the form <i>new
    * T(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> is <i>T</i>.</blockquote>
    *
    * The Dart Language Specification, 12.11.2: <blockquote>The static type of a constant object
    * expression of either the form <i>const T.id(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> or the
    * form <i>const T(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> is <i>T</i>. </blockquote>
    */
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     recordStaticType(node, node.constructorName.type.type);
-    ConstructorElement element = node.element;
+    ConstructorElement element = node.staticElement;
     if (element != null && "Element" == element.enclosingElement.name) {
-      String constructorName = element.name;
-      if ("tag" == constructorName) {
-        LibraryElement library = element.library;
-        if (isHtmlLibrary(library)) {
+      LibraryElement library = element.library;
+      if (isHtmlLibrary(library)) {
+        String constructorName = element.name;
+        if ("tag" == constructorName) {
           Type2 returnType = getFirstArgumentAsType2(library, node.argumentList, _HTML_ELEMENT_TO_CLASS_MAP);
           if (returnType != null) {
             recordPropagatedType2(node, returnType);
           }
-        }
-      } else {
-        LibraryElement library = element.library;
-        if (isHtmlLibrary(library)) {
+        } else {
           Type2 returnType = getElementNameAsType(library, constructorName, _HTML_ELEMENT_TO_CLASS_MAP);
           if (returnType != null) {
             recordPropagatedType2(node, returnType);
           }
         }
       }
     }
     return null;
   }
 
@@ skipping 355 matching lines @@
         staticType = _typeProvider.typeType;
       }
     } else if (staticElement is FunctionTypeAliasElement) {
       staticType = ((staticElement as FunctionTypeAliasElement)).type;
     } else if (staticElement is MethodElement) {
       staticType = ((staticElement as MethodElement)).type;
     } else if (staticElement is PropertyAccessorElement) {
       staticType = getType(staticElement as PropertyAccessorElement, node.prefix.staticType);
     } else if (staticElement is ExecutableElement) {
       staticType = ((staticElement as ExecutableElement)).type;
-    } else if (staticElement is TypeVariableElement) {
-      staticType = ((staticElement as TypeVariableElement)).type;
+    } else if (staticElement is TypeParameterElement) {
+      staticType = ((staticElement as TypeParameterElement)).type;
     } else if (staticElement is VariableElement) {
       staticType = ((staticElement as VariableElement)).type;
     }
     recordStaticType(prefixedIdentifier, staticType);
     recordStaticType(node, staticType);
     Element propagatedElement = prefixedIdentifier.propagatedElement;
     Type2 propagatedType = null;
     if (propagatedElement is ClassElement) {
       if (isNotTypeLiteral(node)) {
         propagatedType = ((propagatedElement as ClassElement)).type;
       } else {
         propagatedType = _typeProvider.typeType;
       }
     } else if (propagatedElement is FunctionTypeAliasElement) {
       propagatedType = ((propagatedElement as FunctionTypeAliasElement)).type;
     } else if (propagatedElement is MethodElement) {
       propagatedType = ((propagatedElement as MethodElement)).type;
     } else if (propagatedElement is PropertyAccessorElement) {
       propagatedType = getType(propagatedElement as PropertyAccessorElement, node.prefix.staticType);
     } else if (propagatedElement is ExecutableElement) {
       propagatedType = ((propagatedElement as ExecutableElement)).type;
-    } else if (propagatedElement is TypeVariableElement) {
-      propagatedType = ((propagatedElement as TypeVariableElement)).type;
+    } else if (propagatedElement is TypeParameterElement) {
+      propagatedType = ((propagatedElement as TypeParameterElement)).type;
     } else if (propagatedElement is VariableElement) {
       propagatedType = ((propagatedElement as VariableElement)).type;
     }
     Type2 overriddenType = _overrideManager.getType(propagatedElement);
     if (propagatedType == null || (overriddenType != null && overriddenType.isMoreSpecificThan(propagatedType))) {
       propagatedType = overriddenType;
     }
     if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
       recordPropagatedType2(prefixedIdentifier, propagatedType);
       recordPropagatedType2(node, propagatedType);
@@ skipping 154 matching lines @@
         staticType = _typeProvider.typeType;
       }
     } else if (element is FunctionTypeAliasElement) {
       staticType = ((element as FunctionTypeAliasElement)).type;
     } else if (element is MethodElement) {
       staticType = ((element as MethodElement)).type;
     } else if (element is PropertyAccessorElement) {
       staticType = getType(element as PropertyAccessorElement, null);
     } else if (element is ExecutableElement) {
       staticType = ((element as ExecutableElement)).type;
-    } else if (element is TypeVariableElement) {
-      staticType = ((element as TypeVariableElement)).type;
+    } else if (element is TypeParameterElement) {
+      staticType = ((element as TypeParameterElement)).type;
     } else if (element is VariableElement) {
       staticType = ((element as VariableElement)).type;
     } else if (element is PrefixElement) {
       return null;
     } else {
       staticType = _dynamicType;
     }
     recordStaticType(node, staticType);
     Type2 propagatedType = _overrideManager.getType(element);
     if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
@@ skipping 104 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_8(result));
+      body.accept(new GeneralizingASTVisitor_7(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 198 matching lines @@
       PropertyAccessorElement getter = accessor.variable.getter;
       if (getter != null) {
         functionType = getter.type;
         if (functionType != null) {
           return functionType.returnType;
         }
       }
       return _dynamicType;
     }
     Type2 returnType = functionType.returnType;
-    if (returnType is TypeVariableType && context is InterfaceType) {
+    if (returnType is TypeParameterType && context is InterfaceType) {
       InterfaceType interfaceTypeContext = context as InterfaceType;
-      List<TypeVariableElement> parameterElements = interfaceTypeContext.element != null ? interfaceTypeContext.element.typeVariables : null;
-      if (parameterElements != null) {
-        for (int i = 0; i < parameterElements.length; i++) {
-          TypeVariableElement varElt = parameterElements[i];
-          if (returnType.name == varElt.name) {
+      List<TypeParameterElement> typeParameterElements = interfaceTypeContext.element != null ? interfaceTypeContext.element.typeParameters : null;
+      if (typeParameterElements != null) {
+        for (int i = 0; i < typeParameterElements.length; i++) {
+          TypeParameterElement typeParameterElement = typeParameterElements[i];
+          if (returnType.name == typeParameterElement.name) {
             return interfaceTypeContext.typeArguments[i];
           }
         }
       }
     }
     return returnType;
   }
 
   /**
    * Return the type represented by the given type name.
@@ skipping 97 matching lines @@
    *
    * @param node the binary expression to analyze
    * @param staticType the static type of the expression as resolved
    * @return the better type guess, or the same static type as given
    */
   Type2 refineBinaryExpressionType(BinaryExpression node, Type2 staticType) {
     sc.TokenType operator = node.operator.type;
     if (identical(operator, sc.TokenType.AMPERSAND_AMPERSAND) || identical(operator, sc.TokenType.BAR_BAR) || identical(operator, sc.TokenType.EQ_EQ) || identical(operator, sc.TokenType.BANG_EQ)) {
       return _typeProvider.boolType;
     }
-    if (identical(operator, sc.TokenType.MINUS) || identical(operator, sc.TokenType.PERCENT) || identical(operator, sc.TokenType.PLUS) || identical(operator, sc.TokenType.STAR)) {
-      Type2 doubleType = _typeProvider.doubleType;
-      if (identical(getStaticType(node.leftOperand), _typeProvider.intType) && identical(getStaticType(node.rightOperand), doubleType)) {
-        return doubleType;
+    Type2 intType = _typeProvider.intType;
+    if (getStaticType(node.leftOperand) == intType) {
+      if (identical(operator, sc.TokenType.MINUS) || identical(operator, sc.TokenType.PERCENT) || identical(operator, sc.TokenType.PLUS) || identical(operator, sc.TokenType.STAR)) {
+        Type2 doubleType = _typeProvider.doubleType;
+        if (getStaticType(node.rightOperand) == doubleType) {
+          return doubleType;
+        }
       }
-    }
-    if (identical(operator, sc.TokenType.MINUS) || identical(operator, sc.TokenType.PERCENT) || identical(operator, sc.TokenType.PLUS) || identical(operator, sc.TokenType.STAR) || identical(operator, sc.TokenType.TILDE_SLASH)) {
-      Type2 intType = _typeProvider.intType;
-      if (identical(getStaticType(node.leftOperand), intType) && identical(getStaticType(node.rightOperand), intType)) {
-        staticType = intType;
+      if (identical(operator, sc.TokenType.MINUS) || identical(operator, sc.TokenType.PERCENT) || identical(operator, sc.TokenType.PLUS) || identical(operator, sc.TokenType.STAR) || identical(operator, sc.TokenType.TILDE_SLASH)) {
+        if (getStaticType(node.rightOperand) == intType) {
+          staticType = intType;
+        }
       }
     }
     return staticType;
   }
   get thisType_J2DAccessor => _thisType;
   set thisType_J2DAccessor(__v) => _thisType = __v;
 }
-class GeneralizingASTVisitor_8 extends GeneralizingASTVisitor<Object> {
+class GeneralizingASTVisitor_7 extends GeneralizingASTVisitor<Object> {
   List<Type2> result;
-  GeneralizingASTVisitor_8(this.result) : super();
+  GeneralizingASTVisitor_7(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;
     }
     if (result[0] == null) {
@@ skipping 777 matching lines @@
       node.type = _dynamicType;
       return null;
     }
     Type2 type = null;
     if (element is ClassElement) {
       setElement(typeName, element);
       type = ((element as ClassElement)).type;
     } else if (element is FunctionTypeAliasElement) {
       setElement(typeName, element);
       type = ((element as FunctionTypeAliasElement)).type;
-    } else if (element is TypeVariableElement) {
+    } else if (element is TypeParameterElement) {
       setElement(typeName, element);
-      type = ((element as TypeVariableElement)).type;
+      type = ((element as TypeParameterElement)).type;
       if (argumentList != null) {
       }
     } else if (element is MultiplyDefinedElement) {
       List<Element> elements = ((element as MultiplyDefinedElement)).conflictingElements;
       type = getType(elements);
       if (type != null) {
         node.type = type;
       }
     } else {
       if (isTypeNameInCatchClause(node)) {
@@ skipping 462 matching lines @@
    */
   void setFunctionTypedParameterType(ParameterElementImpl element, TypeName returnType2, FormalParameterList parameterList) {
     List<ParameterElement> parameters = getElements(parameterList);
     FunctionTypeAliasElementImpl aliasElement = new FunctionTypeAliasElementImpl(null);
     aliasElement.synthetic = true;
     aliasElement.shareParameters(parameters);
     aliasElement.returnType = computeReturnType(returnType2);
     FunctionTypeImpl type = new FunctionTypeImpl.con2(aliasElement);
     ClassElement definingClass = element.getAncestor(ClassElement);
     if (definingClass != null) {
-      aliasElement.shareTypeVariables(definingClass.typeVariables);
+      aliasElement.shareTypeParameters(definingClass.typeParameters);
       type.typeArguments = definingClass.type.typeArguments;
     } else {
       FunctionTypeAliasElement alias = element.getAncestor(FunctionTypeAliasElement);
       while (alias != null && alias.isSynthetic) {
         alias = alias.getAncestor(FunctionTypeAliasElement);
       }
       if (alias != null) {
-        aliasElement.typeVariables = alias.typeVariables;
+        aliasElement.typeParameters = alias.typeParameters;
         type.typeArguments = alias.type.typeArguments;
       } else {
-        type.typeArguments = TypeVariableTypeImpl.EMPTY_ARRAY;
+        type.typeArguments = TypeImpl.EMPTY_ARRAY;
       }
     }
     element.type = type;
   }
 }
 /**
  * Instances of the class `ClassScope` implement the scope defined by a class.
  *
  * @coverage dart.engine.resolver
  */
@@ skipping 34 matching lines @@
     }
   }
 
   /**
    * Define the type parameters for the class.
    *
    * @param typeElement the element representing the type represented by this scope
    */
   void defineTypeParameters(ClassElement typeElement) {
     Scope parameterScope = enclosingScope;
-    for (TypeVariableElement parameter in typeElement.typeVariables) {
-      parameterScope.define(parameter);
+    for (TypeParameterElement typeParameter in typeElement.typeParameters) {
+      parameterScope.define(typeParameter);
     }
   }
 }
 /**
  * Instances of the class `EnclosedScope` implement a scope that is lexically enclosed in
  * another scope.
  *
  * @coverage dart.engine.resolver
  */
 class EnclosedScope extends Scope {
@@ skipping 91 matching lines @@
  */
 class FunctionTypeScope extends EnclosedScope {
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
    * @param typeElement the element representing the type alias represented by this scope
    */
   FunctionTypeScope(Scope enclosingScope, FunctionTypeAliasElement typeElement) : super(new EnclosedScope(enclosingScope)) {
-    defineTypeVariables(typeElement);
+    defineTypeParameters(typeElement);
     defineParameters(typeElement);
   }
 
   /**
    * Define the parameters for the function type alias.
    *
    * @param typeElement the element representing the type represented by this scope
    */
   void defineParameters(FunctionTypeAliasElement typeElement) {
     for (ParameterElement parameter in typeElement.parameters) {
       define(parameter);
     }
   }
 
   /**
-   * Define the type variables for the function type alias.
+   * Define the type parameters for the function type alias.
    *
    * @param typeElement the element representing the type represented by this scope
    */
-  void defineTypeVariables(FunctionTypeAliasElement typeElement) {
-    Scope typeVariableScope = enclosingScope;
-    for (TypeVariableElement typeVariable in typeElement.typeVariables) {
-      typeVariableScope.define(typeVariable);
+  void defineTypeParameters(FunctionTypeAliasElement typeElement) {
+    Scope typeParameterScope = enclosingScope;
+    for (TypeParameterElement typeParameter in typeElement.typeParameters) {
+      typeParameterScope.define(typeParameter);
     }
   }
 }
 /**
  * Instances of the class `LabelScope` represent a scope in which a single label is defined.
  *
  * @coverage dart.engine.resolver
  */
 class LabelScope {
 
@@ skipping 119 matching lines @@
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) {
     Element foundElement = localLookup(name, referencingLibrary);
     if (foundElement != null) {
       return foundElement;
     }
     for (Namespace nameSpace in _importedNamespaces) {
       Element element = nameSpace.get(name);
       if (element != null) {
         if (foundElement == null) {
           foundElement = element;
-        } else {
-          foundElement = new MultiplyDefinedElementImpl(_definingLibrary.context, foundElement, element);
+        } else if (foundElement != element) {
+          foundElement = new MultiplyDefinedElementImpl.con1(_definingLibrary.context, foundElement, element);
         }
       }
     }
     if (foundElement is MultiplyDefinedElementImpl) {
+      foundElement = removeSdkElements(foundElement as MultiplyDefinedElementImpl);
+    }
+    if (foundElement is MultiplyDefinedElementImpl) {
       String foundEltName = foundElement.displayName;
       String libName1 = "", libName2 = "";
       List<Element> conflictingMembers = ((foundElement as MultiplyDefinedElementImpl)).conflictingElements;
       LibraryElement enclosingLibrary = conflictingMembers[0].getAncestor(LibraryElement);
       if (enclosingLibrary != null) {
         libName1 = enclosingLibrary.definingCompilationUnit.displayName;
       }
       enclosingLibrary = conflictingMembers[1].getAncestor(LibraryElement);
       if (enclosingLibrary != null) {
         libName2 = enclosingLibrary.definingCompilationUnit.displayName;
@@ skipping 13 matching lines @@
    *
    * @param definingLibrary the element representing the library that imports the libraries for
    *          which namespaces will be created
    */
   void createImportedNamespaces(LibraryElement definingLibrary) {
     NamespaceBuilder builder = new NamespaceBuilder();
     for (ImportElement element in definingLibrary.imports) {
       _importedNamespaces.add(builder.createImportNamespace(element));
     }
   }
+
+  /**
+   * Given a collection of elements that a single name could all be mapped to, remove from the list
+   * all of the names defined in the SDK. Return the element(s) that remain.
+   *
+   * @param foundElement the element encapsulating the collection of elements
+   * @return all of the elements that are not defined in the SDK
+   */
+  Element removeSdkElements(MultiplyDefinedElementImpl foundElement) {
+    List<Element> conflictingMembers = foundElement.conflictingElements;
+    int length = conflictingMembers.length;
+    int to = 0;
+    for (Element member in conflictingMembers) {
+      if (!member.library.isInSdk) {
+        conflictingMembers[to++] = member;
+      }
+    }
+    if (to == length) {
+      return foundElement;
+    } else if (to == 1) {
+      return conflictingMembers[0];
+    }
+    List<Element> remaining = new List<Element>(to);
+    JavaSystem.arraycopy(conflictingMembers, 0, remaining, 0, to);
+    return new MultiplyDefinedElementImpl.con2(_definingLibrary.context, remaining);
+  }
 }
 /**
  * Instances of the class `LibraryScope` implement a scope containing all of the names defined
  * in a given library.
  *
  * @coverage dart.engine.resolver
  */
 class LibraryScope extends EnclosedScope {
 
   /**
@@ skipping 644 matching lines @@
         result = validate(initializer, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
         element.evaluationResult = result;
       } else if (result is ErrorResult) {
         reportErrors(result, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
       }
     }
     return null;
   }
 
   /**
-   * Return `true` if the given value is the result of evaluating an expression whose value is
-   * a valid key in a const map literal. Keys in const map literals must be either a string, number,
-   * boolean, list, map, or null.
-   *
-   * @param value
-   * @return `true` if the given value is a valid key in a const map literal
-   */
-  bool isValidConstMapKey(Object value) => true;
-
-  /**
    * If the given result represents one or more errors, report those errors. Except for special
    * cases, use the given error code rather than the one reported in the error.
    *
    * @param result the result containing any errors that need to be reported
    * @param errorCode the error code to be used if the result represents an error
    */
   void reportErrors(EvaluationResultImpl result, ErrorCode errorCode2) {
     if (result is ErrorResult) {
       for (ErrorResult_ErrorData data in ((result as ErrorResult)).errorData) {
         ErrorCode dataErrorCode = data.errorCode;
@@ skipping 75 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_12(this, parameterElements));
+    EvaluationResultImpl result = expression.accept(new ConstantVisitor_11(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 24 matching lines @@
         RedirectingConstructorInvocation invocation = initializer as RedirectingConstructorInvocation;
         validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
       }
       if (initializer is SuperConstructorInvocation) {
         SuperConstructorInvocation invocation = initializer as SuperConstructorInvocation;
         validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
       }
     }
   }
 }
-class ConstantVisitor_12 extends ConstantVisitor {
+class ConstantVisitor_11 extends ConstantVisitor {
   final ConstantVerifier ConstantVerifier_this;
   List<ParameterElement> parameterElements;
-  ConstantVisitor_12(this.ConstantVerifier_this, this.parameterElements) : super();
+  ConstantVisitor_11(this.ConstantVerifier_this, this.parameterElements) : super();
   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 ValidResult.RESULT_DYNAMIC;
           }
           if (type.isSubtypeOf(ConstantVerifier_this._boolType)) {
@@ skipping 655 matching lines @@
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     checkForFinalNotInitialized2(node.variables);
     return super.visitTopLevelVariableDeclaration(node);
   }
   Object visitTypeName(TypeName node) {
     checkForTypeArgumentNotMatchingBounds(node);
     checkForTypeParameterReferencedByStatic(node);
     return super.visitTypeName(node);
   }
   Object visitTypeParameter(TypeParameter node) {
-    checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME);
+    checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME);
     return super.visitTypeParameter(node);
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
     SimpleIdentifier nameNode = node.name;
     Expression initializerNode = node.initializer;
     checkForInvalidAssignment2(nameNode, initializerNode);
     nameNode.accept(this);
     String name = nameNode.name;
     javaSetAdd(_namesForReferenceToDeclaredVariableInInitializer, name);
     _isInInstanceVariableInitializer = _isInInstanceVariableDeclaration;
@@ skipping 88 matching lines @@
           } else if (identical(state, INIT_STATE.INIT_IN_INITIALIZERS)) {
             _errorReporter.reportError2(CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS, fieldName, [fieldElement.displayName]);
             foundError = true;
           }
         }
       }
     }
     for (MapEntry<FieldElement, INIT_STATE> entry in getMapEntrySet(fieldElementsMap)) {
       if (identical(entry.getValue(), INIT_STATE.NOT_INIT)) {
         FieldElement fieldElement = entry.getKey();
-        if (fieldElement.isFinal || fieldElement.isConst) {
+        if (fieldElement.isConst) {
+          _errorReporter.reportError2(CompileTimeErrorCode.CONST_NOT_INITIALIZED, node.returnType, [fieldElement.name]);
+          foundError = true;
+        } else if (fieldElement.isFinal) {
           _errorReporter.reportError2(StaticWarningCode.FINAL_NOT_INITIALIZED, node.returnType, [fieldElement.name]);
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
    * This checks the passed executable element against override-error codes.
@@ skipping 63 matching lines @@
       return false;
     }
     Type2 overridingFTReturnType = overridingFT.returnType;
     Type2 overriddenFTReturnType = overriddenFT.returnType;
     List<Type2> overridingNormalPT = overridingFT.normalParameterTypes;
     List<Type2> overriddenNormalPT = overriddenFT.normalParameterTypes;
     List<Type2> overridingPositionalPT = overridingFT.optionalParameterTypes;
     List<Type2> overriddenPositionalPT = overriddenFT.optionalParameterTypes;
     Map<String, Type2> overridingNamedPT = overridingFT.namedParameterTypes;
     Map<String, Type2> overriddenNamedPT = overriddenFT.namedParameterTypes;
-    if (overridingNormalPT.length != overriddenNormalPT.length) {
+    if (overridingNormalPT.length > overriddenNormalPT.length) {
       _errorReporter.reportError2(StaticWarningCode.INVALID_OVERRIDE_REQUIRED, errorNameTarget, [
           overriddenNormalPT.length,
           overriddenExecutable.enclosingElement.displayName]);
       return true;
     }
     if (overridingPositionalPT.length < overriddenPositionalPT.length) {
       _errorReporter.reportError2(StaticWarningCode.INVALID_OVERRIDE_POSITIONAL, errorNameTarget, [
           overriddenPositionalPT.length,
           overriddenExecutable.enclosingElement.displayName]);
       return true;
@@ skipping 511 matching lines @@
   }
 
   /**
    * This verifies that the passed identifier is not a keyword, and generates the passed error code
    * on the identifier if it is a keyword.
    *
    * @param identifier the identifier to check to ensure that it is not a keyword
    * @param errorCode if the passed identifier is a keyword then this error code is created on the
    *          identifier, the error code will be one of
    *          [CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_NAME],
-   *          [CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME] or
+   *          [CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME] or
    *          [CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_NAME
-   * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME
+   * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME
    * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME
    */
   bool checkForBuiltInIdentifierAsName(SimpleIdentifier identifier, ErrorCode errorCode) {
     sc.Token token = identifier.token;
     if (identical(token.type, sc.TokenType.KEYWORD)) {
       _errorReporter.reportError2(errorCode, identifier, [identifier.name]);
       return true;
     }
     return false;
   }
@@ skipping 505 matching lines @@
    * @see CompileTimeErrorCode#CONST_WITH_TYPE_PARAMETERS
    */
   bool checkForConstWithTypeParameters2(TypeName typeName) {
     if (typeName == null) {
       return false;
     }
     Identifier name = typeName.name;
     if (name == null) {
       return false;
     }
-    if (name.staticElement is TypeVariableElement) {
+    if (name.staticElement is TypeParameterElement) {
       _errorReporter.reportError2(CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS, name, []);
     }
     TypeArgumentList typeArguments = typeName.typeArguments;
     if (typeArguments != null) {
       bool hasError = false;
       for (TypeName argument in typeArguments.arguments) {
         hasError = javaBooleanOr(hasError, checkForConstWithTypeParameters2(argument));
       }
       return hasError;
     }
@@ skipping 314 matching lines @@
     return false;
   }
 
   /**
    * This verifies that final fields that are declared, without any constructors in the enclosing
    * class, are initialized. Cases in which there is at least one constructor are handled at the end
    * of [checkForAllFinalInitializedErrorCodes].
    *
    * @param node the class declaration to test
    * @return `true` if and only if an error code is generated on the passed node
-   * @see CompileTimeErrorCode#FINAL_NOT_INITIALIZED
+   * @see CompileTimeErrorCode#CONST_NOT_INITIALIZED
+   * @see StaticWarningCode#FINAL_NOT_INITIALIZED
    */
   bool checkForFinalNotInitialized(ClassDeclaration node) {
     NodeList<ClassMember> classMembers = node.members;
     for (ClassMember classMember in classMembers) {
       if (classMember is ConstructorDeclaration) {
         return false;
       }
     }
     bool foundError = false;
     for (ClassMember classMember in classMembers) {
       if (classMember is FieldDeclaration) {
         FieldDeclaration field = classMember as FieldDeclaration;
         foundError = javaBooleanOr(foundError, checkForFinalNotInitialized2(field.fields));
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that the passed variable declaration list has only initialized variables if the
    * list is final or const. This method is called by
    * [checkForFinalNotInitialized],
    * [visitTopLevelVariableDeclaration] and
    * [visitVariableDeclarationStatement].
    *
    * @param node the class declaration to test
    * @return `true` if and only if an error code is generated on the passed node
-   * @see CompileTimeErrorCode#FINAL_NOT_INITIALIZED
+   * @see CompileTimeErrorCode#CONST_NOT_INITIALIZED
+   * @see StaticWarningCode#FINAL_NOT_INITIALIZED
    */
   bool checkForFinalNotInitialized2(VariableDeclarationList node) {
     if (_isInNativeClass) {
       return false;
     }
     bool foundError = false;
-    if (!node.isSynthetic && (node.isConst || node.isFinal)) {
+    if (!node.isSynthetic) {
       NodeList<VariableDeclaration> variables = node.variables;
       for (VariableDeclaration variable in variables) {
         if (variable.initializer == null) {
-          _errorReporter.reportError2(StaticWarningCode.FINAL_NOT_INITIALIZED, variable.name, [variable.name.name]);
+          if (node.isConst) {
+            _errorReporter.reportError2(CompileTimeErrorCode.CONST_NOT_INITIALIZED, variable.name, [variable.name.name]);
+          } else if (node.isFinal) {
+            _errorReporter.reportError2(StaticWarningCode.FINAL_NOT_INITIALIZED, variable.name, [variable.name.name]);
+          }
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that the passed implements clause does not implement classes such as 'num' or
    * 'String'.
@@ skipping 326 matching lines @@
    *
    * @param arguments a non-`null`, non-empty [TypeName] node list from the respective
    *          [ListLiteral] or [MapLiteral]
    * @param errorCode either [CompileTimeErrorCode#INVALID_TYPE_ARGUMENT_IN_CONST_LIST] or
    *          [CompileTimeErrorCode#INVALID_TYPE_ARGUMENT_IN_CONST_MAP]
    * @return `true` if and only if an error code is generated on the passed node
    */
   bool checkForInvalidTypeArgumentInConstTypedLiteral(NodeList<TypeName> arguments, ErrorCode errorCode) {
     bool foundError = false;
     for (TypeName typeName in arguments) {
-      if (typeName.type is TypeVariableType) {
+      if (typeName.type is TypeParameterType) {
         _errorReporter.reportError2(errorCode, typeName, [typeName.name]);
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that the elements given [ListLiteral] are subtypes of the specified element
    * type.
@@ skipping 942 matching lines @@
    * This verifies that the type arguments in the passed type name are all within their bounds.
    *
    * @param node the [TypeName] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
    */
   bool checkForTypeArgumentNotMatchingBounds(TypeName node) {
     if (node.typeArguments == null) {
       return false;
     }
-    List<TypeVariableElement> boundingElts = null;
+    List<TypeParameterElement> boundingElts = null;
     Type2 type = node.type;
     if (type == null) {
       return false;
     }
     Element element = type.element;
     if (element is ClassElement) {
-      boundingElts = ((element as ClassElement)).typeVariables;
+      boundingElts = ((element as ClassElement)).typeParameters;
     } else {
       return false;
     }
     NodeList<TypeName> typeNameArgList = node.typeArguments.arguments;
     int loopThroughIndex = Math.min(typeNameArgList.length, boundingElts.length);
     bool foundError = false;
     for (int i = 0; i < loopThroughIndex; i++) {
       TypeName argTypeName = typeNameArgList[i];
       Type2 argType = argTypeName.type;
       Type2 boundType = boundingElts[i].bound;
@@ skipping 17 matching lines @@
    * This checks that if the passed type name is a type parameter being used to define a static
    * member.
    *
    * @param node the type name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#TYPE_PARAMETER_REFERENCED_BY_STATIC
    */
   bool checkForTypeParameterReferencedByStatic(TypeName node) {
     if (_isInStaticMethod || _isInStaticVariableDeclaration) {
       Type2 type = node.type;
-      if (type is TypeVariableType) {
+      if (type is TypeParameterType) {
         _errorReporter.reportError2(StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC, node, []);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This checks that if the passed generative constructor has neither an explicit super constructor
    * invocation nor a redirecting constructor invocation, that the superclass has a default
@@ skipping 48 matching lines @@
   /**
    * This checks that if the given name is a reference to a static member it is defined in the
    * enclosing class rather than in a superclass.
    *
    * @param name the name to be evaluated
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER
    */
   bool checkForUnqualifiedReferenceToNonLocalStaticMember(SimpleIdentifier name2) {
     Element element = name2.staticElement;
-    if (element == null || element is TypeVariableElement) {
+    if (element == null || element is TypeParameterElement) {
       return false;
     }
     Element enclosingElement = element.enclosingElement;
     if (enclosingElement is! ClassElement) {
       return false;
     }
     if ((element is MethodElement && !((element as MethodElement)).isStatic) || (element is PropertyAccessorElement && !((element as PropertyAccessorElement)).isStatic)) {
       return false;
     }
     if (identical(enclosingElement, _enclosingClass)) {
@@ skipping 168 matching lines @@
       current = current.redirectedConstructor;
       if (current is ConstructorMember) {
         current = ((current as ConstructorMember)).baseElement;
       }
     }
     return false;
   }
 
   /**
    * @return <code>true</code> if given [Element] has direct or indirect reference to itself
-   *         form anywhere except [ClassElement] or type variable bounds.
+   *         from anywhere except [ClassElement] or type parameter bounds.
    */
   bool hasTypedefSelfReference(Element target) {
     Set<Element> checked = new Set<Element>();
     List<Element> toCheck = new List<Element>();
     toCheck.add(target);
     bool firstIteration = true;
     while (true) {
       Element current;
       while (true) {
         if (toCheck.isEmpty) {
           return false;
         }
         current = toCheck.removeAt(toCheck.length - 1);
         if (target == current) {
           if (firstIteration) {
             firstIteration = false;
             break;
           } else {
             return true;
           }
         }
         if (current != null && !checked.contains(current)) {
           break;
         }
       }
-      current.accept(new GeneralizingElementVisitor_13(target, toCheck));
+      current.accept(new GeneralizingElementVisitor_12(target, toCheck));
       javaSetAdd(checked, current);
     }
   }
   bool isFunctionType(Type2 type) {
     if (type.isDynamic || identical(type, BottomTypeImpl.instance)) {
       return true;
     } else if (type is InterfaceType) {
       if (identical(type, _typeProvider.functionType)) {
         return true;
       }
@@ skipping 158 matching lines @@
   static final INIT_STATE INIT_IN_DECLARATION = new INIT_STATE('INIT_IN_DECLARATION', 1);
   static final INIT_STATE INIT_IN_FIELD_FORMAL = new INIT_STATE('INIT_IN_FIELD_FORMAL', 2);
   static final INIT_STATE INIT_IN_INITIALIZERS = new INIT_STATE('INIT_IN_INITIALIZERS', 3);
   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_13 extends GeneralizingElementVisitor<Object> {
+class GeneralizingElementVisitor_12 extends GeneralizingElementVisitor<Object> {
   Element target;
   List<Element> toCheck;
-  GeneralizingElementVisitor_13(this.target, this.toCheck) : super();
+  GeneralizingElementVisitor_12(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 {
       return super.visitClassElement(element);
     } finally {
       _inClass = false;
     }
   }
   Object visitExecutableElement(ExecutableElement element) {
     if (element.isSynthetic) {
       return null;
     }
     addTypeToCheck(element.returnType);
     return super.visitExecutableElement(element);
   }
   Object visitFunctionTypeAliasElement(FunctionTypeAliasElement element) {
     addTypeToCheck(element.returnType);
     return super.visitFunctionTypeAliasElement(element);
   }
   Object visitParameterElement(ParameterElement element) {
     addTypeToCheck(element.type);
     return super.visitParameterElement(element);
   }
-  Object visitTypeVariableElement(TypeVariableElement element) => null;
+  Object visitTypeParameterElement(TypeParameterElement element) => null;
   Object visitVariableElement(VariableElement element) {
     addTypeToCheck(element.type);
     return super.visitVariableElement(element);
   }
   void addTypeToCheck(Type2 type) {
     if (type == null) {
       return;
     }
     Element element = type.element;
     if (_inClass && target == element) {
@@ skipping 62 matching lines @@
   ResolverErrorCode.con2(String name, int ordinal, ErrorType type, String message, String correction) : super(name, ordinal) {
     this._type = type;
     this._message = message;
     this.correction9 = correction;
   }
   String get correction => correction9;
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
 }