New analyzer snapshot.

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

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
+
 library engine.resolver;
+
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
 import 'error.dart';
 import 'scanner.dart' as sc;
 import 'utilities_dart.dart';
 import 'utilities_general.dart';
 import 'ast.dart';
 import 'parser.dart' show Parser, ParserErrorCode;
 import 'sdk.dart' show DartSdk, SdkLibrary;
 import 'element.dart';
 import 'html.dart' as ht;
 import 'engine.dart';
 import 'constant.dart';
+
 /**
  * Instances of the class `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 source, CompilationUnit unit) {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
@@ skipping 11 matching lines @@
       element.typeAliases = holder.typeAliases;
       element.types = holder.types;
       element.topLevelVariables = holder.topLevelVariables;
       unit.element = element;
       return element;
     } finally {
       timeCounter.stop();
     }
   }
 }
+
 /**
  * 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> {
-
   /**
    * The element holder associated with the element that is currently being built.
    */
   ElementHolder _currentHolder;
 
   /**
    * A flag indicating whether a variable declaration is in the context of a field declaration.
    */
   bool _inFieldContext = false;
 
@@ skipping 15 matching lines @@
   List<FunctionTypeImpl> _functionTypesToFix = null;
 
   /**
    * Initialize a newly created element builder to build the elements for a compilation unit.
    *
    * @param initialHolder the element holder associated with the compilation unit being built
    */
   ElementBuilder(ElementHolder initialHolder) {
     _currentHolder = initialHolder;
   }
+
   Object visitBlock(Block node) {
     bool wasInField = _inFieldContext;
     _inFieldContext = false;
     try {
       node.visitChildren(this);
     } finally {
       _inFieldContext = wasInField;
     }
     return null;
   }
+
   Object visitCatchClause(CatchClause node) {
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
     if (exceptionParameter != null) {
       LocalVariableElementImpl exception = new LocalVariableElementImpl(exceptionParameter);
       _currentHolder.addLocalVariable(exception);
       exceptionParameter.staticElement = exception;
       SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
       if (stackTraceParameter != null) {
         LocalVariableElementImpl stackTrace = new LocalVariableElementImpl(stackTraceParameter);
         _currentHolder.addLocalVariable(stackTrace);
         stackTraceParameter.staticElement = stackTrace;
       }
     }
     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<TypeParameterElement> typeParameters = holder.typeParameters;
     List<Type2> typeArguments = createTypeParameterTypes(typeParameters);
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl.con1(element);
@@ skipping 12 matching lines @@
     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<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;
     holder.validate();
     return null;
   }
+
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     _isValidMixin = false;
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
       visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
@@ skipping 13 matching lines @@
       Identifier returnType = node.returnType;
       if (returnType != null) {
         element.nameOffset = returnType.offset;
       }
     } else {
       constructorName.staticElement = element;
     }
     holder.validate();
     return null;
   }
+
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
     sc.Token keyword = node.keyword;
     LocalVariableElementImpl element = new LocalVariableElementImpl(variableName);
     ForEachStatement statement = node.parent as ForEachStatement;
     int declarationEnd = node.offset + node.length;
     int statementEnd = statement.offset + statement.length;
     element.setVisibleRange(declarationEnd, statementEnd - declarationEnd - 1);
     element.const3 = matches(keyword, sc.Keyword.CONST);
     element.final2 = matches(keyword, sc.Keyword.FINAL);
     _currentHolder.addLocalVariable(element);
     variableName.staticElement = element;
     return super.visitDeclaredIdentifier(node);
   }
+
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     ElementHolder holder = new ElementHolder();
     visit(holder, node.defaultValue);
     FunctionElementImpl initializer = new FunctionElementImpl();
     initializer.functions = holder.functions;
     initializer.labels = holder.labels;
     initializer.localVariables = holder.localVariables;
     initializer.parameters = holder.parameters;
     SimpleIdentifier parameterName = node.parameter.identifier;
     ParameterElementImpl parameter;
@@ skipping 10 matching lines @@
     if (defaultValue != null) {
       parameter.setDefaultValueRange(defaultValue.offset, defaultValue.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 {
       node.visitChildren(this);
     } finally {
       _inFieldContext = wasInField;
     }
     return null;
   }
+
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       FieldFormalParameterElementImpl parameter = new FieldFormalParameterElementImpl(parameterName);
       parameter.const3 = node.isConst;
       parameter.final2 = node.isFinal;
       parameter.parameterKind = node.kind;
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
     ElementHolder holder = new ElementHolder();
     visitChildren(holder, node);
-    ((node.element as ParameterElementImpl)).parameters = holder.parameters;
+    (node.element as ParameterElementImpl).parameters = holder.parameters;
     holder.validate();
     return null;
   }
+
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     FunctionExpression expression = node.functionExpression;
     if (expression != null) {
       ElementHolder holder = new ElementHolder();
       bool wasInFunction = _inFunction;
       _inFunction = true;
       try {
         visitChildren(holder, expression);
       } finally {
         _inFunction = wasInFunction;
@@ skipping 55 matching lines @@
           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;
     _inFunction = true;
     try {
       visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
     FunctionElementImpl element = new FunctionElementImpl.con2(node.beginToken.offset);
@@ skipping 12 matching lines @@
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
     if (_functionTypesToFix != null) {
       _functionTypesToFix.add(type);
     }
     element.type = type;
     _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<TypeParameterElement> typeParameters = holder.typeParameters;
     FunctionTypeAliasElementImpl element = new FunctionTypeAliasElementImpl(aliasName);
     element.parameters = parameters;
     element.typeParameters = typeParameters;
     FunctionTypeImpl type = new FunctionTypeImpl.con2(element);
     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;
+    (node.element as ParameterElementImpl).parameters = holder.parameters;
     holder.validate();
     return null;
   }
+
   Object visitLabeledStatement(LabeledStatement node) {
     bool onSwitchStatement = node.statement is SwitchStatement;
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElementImpl element = new LabelElementImpl(labelName, onSwitchStatement, false);
       _currentHolder.addLabel(element);
       labelName.staticElement = element;
     }
     return super.visitLabeledStatement(node);
   }
+
   Object visitMethodDeclaration(MethodDeclaration node) {
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
       visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
     bool isStatic = node.isStatic;
@@ skipping 48 matching lines @@
         setter.static = isStatic;
         field.setter = setter;
         field.final2 = false;
         _currentHolder.addAccessor(setter);
         propertyNameNode.staticElement = setter;
       }
     }
     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;
     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;
+    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;
       FieldElementImpl field;
       if (isConst && hasInitializer) {
         field = new ConstFieldElementImpl(fieldName);
       } else {
@@ skipping 44 matching lines @@
       initializer.functions = holder.functions;
       initializer.labels = holder.labels;
       initializer.localVariables = holder.localVariables;
       initializer.synthetic = true;
       element.initializer = initializer;
       holder.validate();
     }
     if (element is PropertyInducingElementImpl) {
       PropertyInducingElementImpl variable = element as PropertyInducingElementImpl;
       if (_inFieldContext) {
-        ((variable as FieldElementImpl)).static = matches(((node.parent.parent as FieldDeclaration)).staticKeyword, sc.Keyword.STATIC);
+        (variable as FieldElementImpl).static = matches((node.parent.parent as FieldDeclaration).staticKeyword, sc.Keyword.STATIC);
       }
       PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con2(variable);
       getter.getter = true;
       getter.static = variable.isStatic;
       _currentHolder.addAccessor(getter);
       variable.getter = getter;
       if (!isFinal) {
         PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con2(variable);
         setter.setter = true;
         setter.static = variable.isStatic;
@@ skipping 47 matching lines @@
    * 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 ConstructorDeclaration) {
-        return ((parent as ConstructorDeclaration)).body;
+        return (parent as ConstructorDeclaration).body;
       } else if (parent is FunctionExpression) {
-        return ((parent as FunctionExpression)).body;
+        return (parent as FunctionExpression).body;
       } else if (parent is MethodDeclaration) {
-        return ((parent as MethodDeclaration)).body;
+        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 keyword) => token != null && identical(token.type, sc.TokenType.KEYWORD) && identical(((token as sc.KeywordToken)).keyword, keyword);
+  bool matches(sc.Token token, sc.Keyword keyword) => token != null && identical(token.type, sc.TokenType.KEYWORD) && identical((token as sc.KeywordToken).keyword, keyword);
 
   /**
    * 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);
     }
   }
@@ skipping 27 matching lines @@
       ElementHolder previousHolder = _currentHolder;
       _currentHolder = holder;
       try {
         node.visitChildren(this);
       } finally {
         _currentHolder = previousHolder;
       }
     }
   }
 }
+
 /**
  * Instances of the class `ElementHolder` hold on to elements created while traversing an AST
  * structure so that they can be accessed when creating their enclosing element.
  *
  * @coverage dart.engine.resolver
  */
 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<TopLevelVariableElement> _topLevelVariables;
+
   List<ClassElement> _types;
+
   List<FunctionTypeAliasElement> _typeAliases;
+
   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>();
     }
     _constructors.add(element);
   }
+
   void addField(FieldElement element) {
     if (_fields == null) {
       _fields = new List<FieldElement>();
     }
     _fields.add(element);
   }
+
   void addFunction(FunctionElement element) {
     if (_functions == null) {
       _functions = new List<FunctionElement>();
     }
     _functions.add(element);
   }
+
   void addLabel(LabelElement element) {
     if (_labels == null) {
       _labels = new List<LabelElement>();
     }
     _labels.add(element);
   }
+
   void addLocalVariable(LocalVariableElement element) {
     if (_localVariables == null) {
       _localVariables = new List<VariableElement>();
     }
     _localVariables.add(element);
   }
+
   void addMethod(MethodElement element) {
     if (_methods == null) {
       _methods = new List<MethodElement>();
     }
     _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<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 addTypeParameter(TypeParameterElement element) {
     if (_typeParameters == null) {
       _typeParameters = new List<TypeParameterElement>();
     }
     _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 {
     if (_constructors == null) {
       return ConstructorElementImpl.EMPTY_ARRAY;
     }
     List<ConstructorElement> result = new List.from(_constructors);
     _constructors = null;
     return result;
   }
+
   FieldElement getField(String fieldName) {
     if (_fields == null) {
       return null;
     }
     for (FieldElement field in _fields) {
       if (field.name == fieldName) {
         return field;
       }
     }
     return null;
   }
+
   List<FieldElement> get fields {
     if (_fields == null) {
       return FieldElementImpl.EMPTY_ARRAY;
     }
     List<FieldElement> result = new List.from(_fields);
     _fields = null;
     return result;
   }
+
   List<FunctionElement> get functions {
     if (_functions == null) {
       return FunctionElementImpl.EMPTY_ARRAY;
     }
     List<FunctionElement> result = new List.from(_functions);
     _functions = null;
     return result;
   }
+
   List<LabelElement> get labels {
     if (_labels == null) {
       return LabelElementImpl.EMPTY_ARRAY;
     }
     List<LabelElement> result = new List.from(_labels);
     _labels = null;
     return result;
   }
+
   List<LocalVariableElement> get localVariables {
     if (_localVariables == null) {
       return LocalVariableElementImpl.EMPTY_ARRAY;
     }
     List<LocalVariableElement> result = new List.from(_localVariables);
     _localVariables = null;
     return result;
   }
+
   List<MethodElement> get methods {
     if (_methods == null) {
       return MethodElementImpl.EMPTY_ARRAY;
     }
     List<MethodElement> result = new List.from(_methods);
     _methods = null;
     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;
   }
+
   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 68 matching lines @@
         builder.append("; ");
       }
       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> {
   static String _APPLICATION_DART_IN_DOUBLE_QUOTES = "\"application/dart\"";
+
   static String _APPLICATION_DART_IN_SINGLE_QUOTES = "'application/dart'";
+
   static String _SCRIPT = "script";
+
   static String _SRC = "src";
+
   static String _TYPE = "type";
 
   /**
    * The analysis context in which the element model will be built.
    */
   InternalAnalysisContext _context;
 
   /**
    * The error listener to which errors will be reported.
    */
@@ skipping 62 matching lines @@
     this._modificationStamp = modificationStamp;
     _lineInfo = _context.computeLineInfo(source);
     HtmlElementImpl result = new HtmlElementImpl(_context, source.shortName);
     result.source = source;
     _htmlElement = result;
     unit.accept(this);
     _htmlElement = null;
     unit.element = result;
     return result;
   }
+
   Object visitHtmlUnit(ht.HtmlUnit node) {
     _parentNodes = new List<ht.XmlTagNode>();
     _scripts = new List<HtmlScriptElement>();
     try {
       node.visitChildren(this);
       _htmlElement.scripts = new List.from(_scripts);
     } finally {
       _scripts = null;
       _parentNodes = null;
     }
     return null;
   }
+
   Object visitXmlAttributeNode(ht.XmlAttributeNode node) => null;
+
   Object visitXmlTagNode(ht.XmlTagNode node) {
     if (_parentNodes.contains(node)) {
       JavaStringBuilder builder = new JavaStringBuilder();
       builder.append("Found circularity in XML nodes: ");
       bool first = true;
       for (ht.XmlTagNode pathNode in _parentNodes) {
         if (first) {
           first = false;
         } else {
           builder.append(", ");
@@ skipping 123 matching lines @@
    * @param offset the offset of the first character to be highlighted
    * @param length the number of characters to be highlighted
    * @param arguments the arguments used to compose the error message
    */
   void reportValueError(ErrorCode errorCode, ht.XmlAttributeNode attribute, List<Object> arguments) {
     int offset = attribute.value.offset + 1;
     int length = attribute.value.length - 2;
     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 _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
@@ skipping 19 matching lines @@
   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 visitAssignmentExpression(AssignmentExpression node) {
+    sc.TokenType operatorType = node.operator.type;
+    if (operatorType != sc.TokenType.EQ) {
+      checkForDeprecatedMemberUse(node.bestElement, node);
+    }
+    return super.visitAssignmentExpression(node);
+  }
+
   Object visitBinaryExpression(BinaryExpression node) {
     checkForDivisionOptimizationHint(node);
+    checkForDeprecatedMemberUse(node.bestElement, node);
     return super.visitBinaryExpression(node);
   }
+
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       _enclosingClass = node.element;
       return super.visitClassDeclaration(node);
     } finally {
       _enclosingClass = outerClass;
     }
   }
+
+  Object visitExportDirective(ExportDirective node) {
+    checkForDeprecatedMemberUse(node.uriElement, node);
+    return super.visitExportDirective(node);
+  }
+
+  Object visitImportDirective(ImportDirective node) {
+    checkForDeprecatedMemberUse(node.uriElement, node);
+    return super.visitImportDirective(node);
+  }
+
+  Object visitIndexExpression(IndexExpression node) {
+    checkForDeprecatedMemberUse(node.bestElement, node);
+    return super.visitIndexExpression(node);
+  }
+
+  Object visitInstanceCreationExpression(InstanceCreationExpression node) {
+    checkForDeprecatedMemberUse(node.staticElement, node);
+    return super.visitInstanceCreationExpression(node);
+  }
+
   Object visitIsExpression(IsExpression node) {
     checkAllTypeChecks(node);
     return super.visitIsExpression(node);
   }
+
   Object visitMethodDeclaration(MethodDeclaration node) {
     checkForOverridingPrivateMember(node);
     return super.visitMethodDeclaration(node);
   }
 
+  Object visitPostfixExpression(PostfixExpression node) {
+    checkForDeprecatedMemberUse(node.bestElement, node);
+    return super.visitPostfixExpression(node);
+  }
+
+  Object visitPrefixExpression(PrefixExpression node) {
+    checkForDeprecatedMemberUse(node.bestElement, node);
+    return super.visitPrefixExpression(node);
+  }
+
+  Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+    checkForDeprecatedMemberUse(node.staticElement, node);
+    return super.visitRedirectingConstructorInvocation(node);
+  }
+
+  Object visitSimpleIdentifier(SimpleIdentifier node) {
+    checkForDeprecatedMemberUse2(node);
+    return super.visitSimpleIdentifier(node);
+  }
+
+  Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
+    checkForDeprecatedMemberUse(node.staticElement, node);
+    return super.visitSuperConstructorInvocation(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
@@ skipping 31 matching lines @@
         } else {
           _errorReporter.reportError2(HintCode.TYPE_CHECK_IS_NOT_NULL, node, []);
         }
         return true;
       }
     }
     return false;
   }
 
   /**
+   * Given some [Element], look at the associated metadata and report the use of the member if
+   * it is declared as deprecated.
+   *
+   * @param element some element to check for deprecated use of
+   * @param node the node use for the location of the error
+   * @return `true` if and only if a hint code is generated on the passed node
+   * @see HintCode#DEPRECATED_MEMBER_USE
+   */
+  bool checkForDeprecatedMemberUse(Element element, ASTNode node) {
+    if (element != null && element.isDeprecated) {
+      String displayName = element.displayName;
+      if (element is ConstructorElement) {
+        ConstructorElement constructorElement = element as ConstructorElement;
+        displayName = constructorElement.enclosingElement.displayName;
+        if (!constructorElement.displayName.isEmpty) {
+          displayName = "${displayName}.${constructorElement.displayName}";
+        }
+      }
+      _errorReporter.reportError2(HintCode.DEPRECATED_MEMBER_USE, node, [displayName]);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * For [SimpleIdentifier]s, only call [checkForDeprecatedMemberUse]
+   * if the node is not in a declaration context.
+   *
+   * Also, if the identifier is a constructor name in a constructor invocation, then calls to the
+   * deprecated constructor will be caught by
+   * [visitInstanceCreationExpression] and
+   * [visitSuperConstructorInvocation], and can be ignored by
+   * this visit method.
+   *
+   * @param identifier some simple identifier to check for deprecated use of
+   * @return `true` if and only if a hint code is generated on the passed node
+   * @see HintCode#DEPRECATED_MEMBER_USE
+   */
+  bool checkForDeprecatedMemberUse2(SimpleIdentifier identifier) {
+    if (identifier.inDeclarationContext() || (identifier.parent is ConstructorName && identical(identifier, (identifier.parent as ConstructorName).name)) || (identifier.parent is SuperConstructorInvocation && identical(identifier, (identifier.parent as SuperConstructorInvocation).constructorName))) {
+      return false;
+    }
+    return checkForDeprecatedMemberUse(identifier.bestElement, identifier);
+  }
+
+  /**
    * 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;
     }
@@ skipping 73 matching lines @@
         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;
+            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, [
@@ skipping 22 matching lines @@
     TypeName typeName = node.type;
     Type2 lhsType = expression.staticType;
     Type2 rhsType = typeName.type;
     if (lhsType != null && rhsType != null && !lhsType.isDynamic && !rhsType.isDynamic && lhsType is! TypeParameterType && rhsType is! TypeParameterType && 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
@@ skipping 15 matching lines @@
           _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;
       if (!isDebugConstant(lhsCondition)) {
         ValidResult lhsResult = getConstantBooleanValue(lhsCondition);
         if (lhsResult != null) {
           if (identical(lhsResult, ValidResult.RESULT_TRUE) && isBarBar) {
@@ skipping 21 matching lines @@
     NodeList<Statement> statements = node.statements;
     int size = statements.length;
     for (int i = 0; i < size; i++) {
       Statement currentStatement = statements[i];
       safelyVisit(currentStatement);
       if (currentStatement is ReturnStatement && i != size - 1) {
         Statement nextStatement = statements[i + 1];
         Statement lastStatement = statements[size - 1];
         int offset = nextStatement.offset;
         int length = lastStatement.end - offset;
-        _errorReporter.reportError3(HintCode.DEAD_CODE, offset, length, []);
+        _errorReporter.reportError4(HintCode.DEAD_CODE, offset, length, []);
         return null;
       }
     }
     return null;
   }
+
   Object visitConditionalExpression(ConditionalExpression node) {
     Expression conditionExpression = node.condition;
     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;
     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;
         }
       }
     }
     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>();
     for (int i = 0; i < numOfCatchClauses; i++) {
       CatchClause catchClause = catchClauses[i];
       if (catchClause.onKeyword != null) {
         TypeName typeName = catchClause.exceptionType;
         if (typeName != null && typeName.type != null) {
           Type2 currentType = typeName.type;
           if (currentType.isObject) {
             safelyVisit(catchClause);
             if (i + 1 != numOfCatchClauses) {
               CatchClause nextCatchClause = catchClauses[i + 1];
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = nextCatchClause.offset;
               int length = lastCatchClause.end - offset;
-              _errorReporter.reportError3(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
+              _errorReporter.reportError4(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
               return null;
             }
           }
           for (Type2 type in visitedTypes) {
             if (currentType.isSubtypeOf(type)) {
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = catchClause.offset;
               int length = lastCatchClause.end - offset;
-              _errorReporter.reportError3(HintCode.DEAD_CODE_ON_CATCH_SUBTYPE, offset, length, [currentType.displayName, type.displayName]);
+              _errorReporter.reportError4(HintCode.DEAD_CODE_ON_CATCH_SUBTYPE, offset, length, [currentType.displayName, type.displayName]);
               return null;
             }
           }
           visitedTypes.add(currentType);
         }
         safelyVisit(catchClause);
       } else {
         safelyVisit(catchClause);
         if (i + 1 != numOfCatchClauses) {
           CatchClause nextCatchClause = catchClauses[i + 1];
           CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
           int offset = nextCatchClause.offset;
           int length = lastCatchClause.end - offset;
-          _errorReporter.reportError3(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
+          _errorReporter.reportError4(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
           return null;
         }
       }
     }
     return null;
   }
+
   Object visitWhileStatement(WhileStatement node) {
     Expression conditionExpression = node.condition;
     safelyVisit(conditionExpression);
     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) {
+      if ((expression as BooleanLiteral).value) {
         return ValidResult.RESULT_TRUE;
       } else {
         return ValidResult.RESULT_FALSE;
       }
     }
     return null;
   }
 
   /**
    * Return `true` if and only if the passed expression is resolved to a constant variable.
@@ skipping 22 matching lines @@
    * 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;
+
   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();
     try {
       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);
           }
         }
       }
       ErrorReporter definingCompilationUnitErrorReporter = new ErrorReporter(_errorListener, _compilationUnits[0].element.source);
       _importsVerifier.generateDuplicateImportHints(definingCompilationUnitErrorReporter);
       _importsVerifier.generateUnusedImportHints(definingCompilationUnitErrorReporter);
     } finally {
       timeCounter.stop();
     }
   }
+
   void generateForCompilationUnit(CompilationUnit unit, Source source) {
     ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
     _importsVerifier.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.
  *
  * @coverage dart.engine.resolver
  */
 class ImportsVerifier extends RecursiveASTVisitor<Object> {
-
   /**
    * This is set to `true` if the current compilation unit which is being visited is the
    * defining compilation unit for the library, its value can be set with
    * [setInDefiningCompilationUnit].
    */
   bool _inDefiningCompilationUnit = false;
 
   /**
    * The current library.
    */
@@ skipping 85 matching lines @@
       ImportElement importElement = unusedImport.element;
       if (importElement != null) {
         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;
           if (libraryElement != null) {
             _unusedImports.add(importDirective);
             if (importDirective.asToken != null) {
@@ skipping 26 matching lines @@
             _duplicateImports.add(nextDirective);
           } else {
             _duplicateImports.add(currentDirective);
           }
         }
         currentDirective = nextDirective;
       }
     }
     return super.visitCompilationUnit(node);
   }
+
   Object visitExportDirective(ExportDirective node) {
     visitMetadata(node.metadata);
     return null;
   }
+
   Object visitImportDirective(ImportDirective node) {
     visitMetadata(node.metadata);
     return null;
   }
+
   Object visitLibraryDirective(LibraryDirective node) {
     visitMetadata(node.metadata);
     return null;
   }
+
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefixIdentifier = node.prefix;
     Element element = prefixIdentifier.staticElement;
     if (element is PrefixElement) {
       _unusedImports.remove(_prefixElementMap[element]);
       return null;
     }
     return visitIdentifier(element, prefixIdentifier.name);
   }
+
   Object visitSimpleIdentifier(SimpleIdentifier node) => visitIdentifier(node.staticElement, node.name);
+
   void set inDefiningCompilationUnit(bool inDefiningCompilationUnit) {
     this._inDefiningCompilationUnit = inDefiningCompilationUnit;
   }
 
   /**
    * Recursively add any exported library elements into the [libraryMap].
    */
   void addAdditionalLibrariesForExports(LibraryElement library, ImportDirective importDirective, List<LibraryElement> exportPath) {
     if (exportPath.contains(library)) {
       return;
@@ skipping 33 matching lines @@
    * needing to check to see if a list needs to be created.
    */
   void putIntoLibraryMap(LibraryElement libraryElement, ImportDirective importDirective) {
     List<ImportDirective> importList = _libraryMap[libraryElement];
     if (importList == null) {
       importList = new List<ImportDirective>();
       _libraryMap[libraryElement] = importList;
     }
     importList.add(importDirective);
   }
+
   Object visitIdentifier(Element element, String name) {
     if (element == null) {
       return null;
     }
     if (element is MultiplyDefinedElement) {
       MultiplyDefinedElement multiplyDefinedElement = element as MultiplyDefinedElement;
       for (Element elt in multiplyDefinedElement.conflictingElements) {
         visitIdentifier(elt, name);
       }
       return null;
@@ skipping 33 matching lines @@
    *
    * @param annotations the list of annotations to visit
    */
   void visitMetadata(NodeList<Annotation> annotations) {
     for (Annotation annotation in annotations) {
       Identifier name = annotation.name;
       visitIdentifier(name.staticElement, name.name);
     }
   }
 }
+
 /**
  * Instances of the class `PubVerifier` traverse an AST structure looking for deviations from
  * pub best practices.
  */
 class PubVerifier extends RecursiveASTVisitor<Object> {
   static String _PUBSPEC_YAML = "pubspec.yaml";
 
   /**
    * The analysis context containing the sources to be analyzed
    */
   AnalysisContext _context;
 
   /**
    * The error reporter by which errors will be reported.
    */
   ErrorReporter _errorReporter;
+
   PubVerifier(AnalysisContext context, ErrorReporter errorReporter) {
     this._context = context;
     this._errorReporter = errorReporter;
   }
+
   Object visitImportDirective(ImportDirective directive) {
     return null;
   }
 
   /**
    * This verifies that the passed file import directive is not contained in a source inside a
    * package "lib" directory hierarchy referencing a source outside that package "lib" directory
    * hierarchy.
    *
    * @param uriLiteral the import URL (not `null`)
@@ skipping 44 matching lines @@
     }
     int pathIndex = path.indexOf("/lib/");
     while (pathIndex != -1) {
       if (checkForFileImportOutsideLibReferencesFileInside2(uriLiteral, path, pathIndex + 1)) {
         return true;
       }
       pathIndex = JavaString.indexOf(path, "/lib/", pathIndex + 4);
     }
     return false;
   }
+
   bool checkForFileImportOutsideLibReferencesFileInside2(StringLiteral uriLiteral, String path, int pathIndex) {
     Source source = getSource(uriLiteral);
     String relativePubspecPath = path.substring(0, pathIndex) + _PUBSPEC_YAML;
     Source pubspecSource = _context.sourceFactory.resolveUri(source, relativePubspecPath);
     if (pubspecSource == null || !pubspecSource.exists()) {
       return false;
     }
     String fullName = getSourceFullName(source);
     if (fullName != null) {
       if (!fullName.contains("/lib/")) {
@@ skipping 48 matching lines @@
   String getSourceFullName(Source source) {
     if (source != null) {
       String fullName = source.fullName;
       if (fullName != null) {
         return fullName.replaceAll(r'\', '/');
       }
     }
     return null;
   }
 }
+
+/**
+ * Instances of the class `DeclarationMatcher` determine whether the element model defined by
+ * a given AST structure matches an existing element model.
+ */
+class DeclarationMatcher extends RecursiveASTVisitor<Object> {
+  /**
+   * The compilation unit containing the AST nodes being visited.
+   */
+  CompilationUnitElement _enclosingUnit;
+
+  /**
+   * The function type alias containing the AST nodes being visited, or `null` if we are not
+   * in the scope of a function type alias.
+   */
+  FunctionTypeAliasElement _enclosingAlias;
+
+  /**
+   * The class containing the AST nodes being visited, or `null` if we are not in the scope of
+   * a class.
+   */
+  ClassElement _enclosingClass;
+
+  /**
+   * The method or function containing the AST nodes being visited, or `null` if we are not in
+   * the scope of a method or function.
+   */
+  ExecutableElement _enclosingExecutable;
+
+  /**
+   * The parameter containing the AST nodes being visited, or `null` if we are not in the
+   * scope of a parameter.
+   */
+  ParameterElement _enclosingParameter;
+
+  /**
+   * A set containing all of the elements in the element model that were defined by the old AST node
+   * corresponding to the AST node being visited.
+   */
+  Set<Element> _allElements = new Set<Element>();
+
+  /**
+   * A set containing all of the elements in the element model that were defined by the old AST node
+   * corresponding to the AST node being visited that have not already been matched to nodes in the
+   * AST structure being visited.
+   */
+  Set<Element> _unmatchedElements = new Set<Element>();
+
+  /**
+   * Return `true` if the declarations within the given AST structure define an element model
+   * that is equivalent to the corresponding elements rooted at the given element.
+   *
+   * @param node the AST structure being compared to the element model
+   * @param element the root of the element model being compared to the AST structure
+   * @return `true` if the AST structure defines the same elements as those in the given
+   *         element model
+   */
+  bool matches(ASTNode node, Element element) {
+    captureEnclosingElements(element);
+    gatherElements(element);
+    try {
+      node.accept(this);
+    } on DeclarationMatcher_DeclarationMismatchException catch (exception) {
+      return false;
+    }
+    return _unmatchedElements.isEmpty;
+  }
+
+  Object visitCatchClause(CatchClause node) {
+    SimpleIdentifier exceptionParameter = node.exceptionParameter;
+    if (exceptionParameter != null) {
+      List<LocalVariableElement> localVariables = _enclosingExecutable.localVariables;
+      LocalVariableElement exceptionElement = find3(localVariables, exceptionParameter);
+      processElement(exceptionElement);
+      SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
+      if (stackTraceParameter != null) {
+        LocalVariableElement stackTraceElement = find3(localVariables, stackTraceParameter);
+        processElement(stackTraceElement);
+      }
+    }
+    return super.visitCatchClause(node);
+  }
+
+  Object visitClassDeclaration(ClassDeclaration node) {
+    ClassElement outerClass = _enclosingClass;
+    try {
+      SimpleIdentifier className = node.name;
+      _enclosingClass = find3(_enclosingUnit.types, className);
+      processElement(_enclosingClass);
+      if (!hasConstructor(node)) {
+        ConstructorElement constructor = _enclosingClass.unnamedConstructor;
+        if (constructor.isSynthetic) {
+          processElement(constructor);
+        }
+      }
+      return super.visitClassDeclaration(node);
+    } finally {
+      _enclosingClass = outerClass;
+    }
+  }
+
+  Object visitClassTypeAlias(ClassTypeAlias node) {
+    ClassElement outerClass = _enclosingClass;
+    try {
+      SimpleIdentifier className = node.name;
+      _enclosingClass = find3(_enclosingUnit.types, className);
+      processElement(_enclosingClass);
+      return super.visitClassTypeAlias(node);
+    } finally {
+      _enclosingClass = outerClass;
+    }
+  }
+
+  Object visitCompilationUnit(CompilationUnit node) {
+    processElement(_enclosingUnit);
+    return super.visitCompilationUnit(node);
+  }
+
+  Object visitConstructorDeclaration(ConstructorDeclaration node) {
+    ExecutableElement outerExecutable = _enclosingExecutable;
+    try {
+      SimpleIdentifier constructorName = node.name;
+      if (constructorName == null) {
+        _enclosingExecutable = _enclosingClass.unnamedConstructor;
+      } else {
+        _enclosingExecutable = _enclosingClass.getNamedConstructor(constructorName.name);
+      }
+      processElement(_enclosingExecutable);
+      return super.visitConstructorDeclaration(node);
+    } finally {
+      _enclosingExecutable = outerExecutable;
+    }
+  }
+
+  Object visitDeclaredIdentifier(DeclaredIdentifier node) {
+    SimpleIdentifier variableName = node.identifier;
+    LocalVariableElement element = find3(_enclosingExecutable.localVariables, variableName);
+    processElement(element);
+    return super.visitDeclaredIdentifier(node);
+  }
+
+  Object visitDefaultFormalParameter(DefaultFormalParameter node) {
+    SimpleIdentifier parameterName = node.parameter.identifier;
+    ParameterElement element = getElementForParameter(node, parameterName);
+    Expression defaultValue = node.defaultValue;
+    if (defaultValue != null) {
+      ExecutableElement outerExecutable = _enclosingExecutable;
+      try {
+        if (element == null) {
+        } else {
+          _enclosingExecutable = element.initializer;
+        }
+        defaultValue.accept(this);
+      } finally {
+        _enclosingExecutable = outerExecutable;
+      }
+      processElement(_enclosingExecutable);
+    }
+    ParameterElement outerParameter = _enclosingParameter;
+    try {
+      _enclosingParameter = element;
+      processElement(_enclosingParameter);
+      return super.visitDefaultFormalParameter(node);
+    } finally {
+      _enclosingParameter = outerParameter;
+    }
+  }
+
+  Object visitExportDirective(ExportDirective node) {
+    String uri = getStringValue(node.uri);
+    if (uri != null) {
+      LibraryElement library = _enclosingUnit.library;
+      ExportElement exportElement = find5(library.exports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri));
+      processElement(exportElement);
+    }
+    return super.visitExportDirective(node);
+  }
+
+  Object visitFieldFormalParameter(FieldFormalParameter node) {
+    if (node.parent is! DefaultFormalParameter) {
+      SimpleIdentifier parameterName = node.identifier;
+      ParameterElement element = getElementForParameter(node, parameterName);
+      ParameterElement outerParameter = _enclosingParameter;
+      try {
+        _enclosingParameter = element;
+        processElement(_enclosingParameter);
+        return super.visitFieldFormalParameter(node);
+      } finally {
+        _enclosingParameter = outerParameter;
+      }
+    } else {
+      return super.visitFieldFormalParameter(node);
+    }
+  }
+
+  Object visitFunctionDeclaration(FunctionDeclaration node) {
+    ExecutableElement outerExecutable = _enclosingExecutable;
+    try {
+      SimpleIdentifier functionName = node.name;
+      sc.Token property = node.propertyKeyword;
+      if (property == null) {
+        if (_enclosingExecutable != null) {
+          _enclosingExecutable = find3(_enclosingExecutable.functions, functionName);
+        } else {
+          _enclosingExecutable = find3(_enclosingUnit.functions, functionName);
+        }
+      } else {
+        PropertyAccessorElement accessor = find3(_enclosingUnit.accessors, functionName);
+        if (identical((property as sc.KeywordToken).keyword, sc.Keyword.SET)) {
+          accessor = accessor.variable.setter;
+        }
+        _enclosingExecutable = accessor;
+      }
+      processElement(_enclosingExecutable);
+      return super.visitFunctionDeclaration(node);
+    } finally {
+      _enclosingExecutable = outerExecutable;
+    }
+  }
+
+  Object visitFunctionExpression(FunctionExpression node) {
+    if (node.parent is! FunctionDeclaration) {
+      FunctionElement element = find2(_enclosingExecutable.functions, node.beginToken.offset);
+      processElement(element);
+    }
+    ExecutableElement outerExecutable = _enclosingExecutable;
+    try {
+      _enclosingExecutable = node.element;
+      processElement(_enclosingExecutable);
+      return super.visitFunctionExpression(node);
+    } finally {
+      _enclosingExecutable = outerExecutable;
+    }
+  }
+
+  Object visitFunctionTypeAlias(FunctionTypeAlias node) {
+    FunctionTypeAliasElement outerAlias = _enclosingAlias;
+    try {
+      SimpleIdentifier aliasName = node.name;
+      _enclosingAlias = find3(_enclosingUnit.functionTypeAliases, aliasName);
+      processElement(_enclosingAlias);
+      return super.visitFunctionTypeAlias(node);
+    } finally {
+      _enclosingAlias = outerAlias;
+    }
+  }
+
+  Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
+    if (node.parent is! DefaultFormalParameter) {
+      SimpleIdentifier parameterName = node.identifier;
+      ParameterElement element = getElementForParameter(node, parameterName);
+      ParameterElement outerParameter = _enclosingParameter;
+      try {
+        _enclosingParameter = element;
+        processElement(_enclosingParameter);
+        return super.visitFunctionTypedFormalParameter(node);
+      } finally {
+        _enclosingParameter = outerParameter;
+      }
+    } else {
+      return super.visitFunctionTypedFormalParameter(node);
+    }
+  }
+
+  Object visitImportDirective(ImportDirective node) {
+    String uri = getStringValue(node.uri);
+    if (uri != null) {
+      LibraryElement library = _enclosingUnit.library;
+      ImportElement importElement = find6(library.imports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri), node.prefix);
+      processElement(importElement);
+    }
+    return super.visitImportDirective(node);
+  }
+
+  Object visitLabeledStatement(LabeledStatement node) {
+    for (Label label in node.labels) {
+      SimpleIdentifier labelName = label.label;
+      LabelElement element = find3(_enclosingExecutable.labels, labelName);
+      processElement(element);
+    }
+    return super.visitLabeledStatement(node);
+  }
+
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    ExecutableElement outerExecutable = _enclosingExecutable;
+    try {
+      sc.Token property = node.propertyKeyword;
+      SimpleIdentifier methodName = node.name;
+      String nameOfMethod = methodName.name;
+      if (nameOfMethod == sc.TokenType.MINUS.lexeme && node.parameters.parameters.length == 0) {
+        nameOfMethod = "unary-";
+      }
+      if (property == null) {
+        _enclosingExecutable = find4(_enclosingClass.methods, nameOfMethod, methodName.offset);
+        methodName.staticElement = _enclosingExecutable;
+      } else {
+        PropertyAccessorElement accessor = find3(_enclosingClass.accessors, methodName);
+        if (identical((property as sc.KeywordToken).keyword, sc.Keyword.SET)) {
+          accessor = accessor.variable.setter;
+          methodName.staticElement = accessor;
+        }
+        _enclosingExecutable = accessor;
+      }
+      processElement(_enclosingExecutable);
+      return super.visitMethodDeclaration(node);
+    } finally {
+      _enclosingExecutable = outerExecutable;
+    }
+  }
+
+  Object visitPartDirective(PartDirective node) {
+    String uri = getStringValue(node.uri);
+    if (uri != null) {
+      Source partSource = _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri);
+      CompilationUnitElement element = find(_enclosingUnit.library.parts, partSource);
+      processElement(element);
+    }
+    return super.visitPartDirective(node);
+  }
+
+  Object visitSimpleFormalParameter(SimpleFormalParameter node) {
+    if (node.parent is! DefaultFormalParameter) {
+      SimpleIdentifier parameterName = node.identifier;
+      ParameterElement element = getElementForParameter(node, parameterName);
+      ParameterElement outerParameter = _enclosingParameter;
+      try {
+        _enclosingParameter = element;
+        processElement(_enclosingParameter);
+        return super.visitSimpleFormalParameter(node);
+      } finally {
+        _enclosingParameter = outerParameter;
+      }
+    } else {
+    }
+    return super.visitSimpleFormalParameter(node);
+  }
+
+  Object visitSwitchCase(SwitchCase node) {
+    for (Label label in node.labels) {
+      SimpleIdentifier labelName = label.label;
+      LabelElement element = find3(_enclosingExecutable.labels, labelName);
+      processElement(element);
+    }
+    return super.visitSwitchCase(node);
+  }
+
+  Object visitSwitchDefault(SwitchDefault node) {
+    for (Label label in node.labels) {
+      SimpleIdentifier labelName = label.label;
+      LabelElement element = find3(_enclosingExecutable.labels, labelName);
+      processElement(element);
+    }
+    return super.visitSwitchDefault(node);
+  }
+
+  Object visitTypeParameter(TypeParameter node) {
+    SimpleIdentifier parameterName = node.name;
+    TypeParameterElement element = null;
+    if (_enclosingClass != null) {
+      element = find3(_enclosingClass.typeParameters, parameterName);
+    } else if (_enclosingAlias != null) {
+      element = find3(_enclosingAlias.typeParameters, parameterName);
+    }
+    processElement(element);
+    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) {
+      element = find3(_enclosingClass.fields, variableName);
+    }
+    if (element == null && _enclosingUnit != null) {
+      element = find3(_enclosingUnit.topLevelVariables, variableName);
+    }
+    Expression initializer = node.initializer;
+    if (initializer != null) {
+      ExecutableElement outerExecutable = _enclosingExecutable;
+      try {
+        if (element == null) {
+        } else {
+          _enclosingExecutable = element.initializer;
+        }
+        processElement(element);
+        processElement(_enclosingExecutable);
+        return super.visitVariableDeclaration(node);
+      } finally {
+        _enclosingExecutable = outerExecutable;
+      }
+    }
+    return super.visitVariableDeclaration(node);
+  }
+
+  void processElement(Element element) {
+    if (element == null) {
+      throw new DeclarationMatcher_DeclarationMismatchException();
+    }
+    if (!_allElements.contains(element)) {
+      throw new DeclarationMatcher_DeclarationMismatchException();
+    }
+    _unmatchedElements.remove(element);
+  }
+
+  /**
+   * Given that the comparison is to begin with the given element, capture the enclosing elements
+   * that might be used while performing the comparison.
+   *
+   * @param element the element corresponding to the AST structure to be compared
+   */
+  void captureEnclosingElements(Element element) {
+    Element parent = element is CompilationUnitElement ? element : element.enclosingElement;
+    while (parent != null) {
+      if (parent is CompilationUnitElement) {
+        _enclosingUnit = parent as CompilationUnitElement;
+      } else if (parent is ClassElement) {
+        if (_enclosingClass == null) {
+          _enclosingClass = parent as ClassElement;
+        }
+      } else if (parent is FunctionTypeAliasElement) {
+        if (_enclosingAlias == null) {
+          _enclosingAlias = parent as FunctionTypeAliasElement;
+        }
+      } else if (parent is ExecutableElement) {
+        if (_enclosingExecutable == null) {
+          _enclosingExecutable = parent as ExecutableElement;
+        }
+      } else if (parent is ParameterElement) {
+        if (_enclosingParameter == null) {
+          _enclosingParameter = parent as ParameterElement;
+        }
+      }
+      parent = parent.enclosingElement;
+    }
+  }
+
+  /**
+   * 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) {
+        return part;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return the element in the given array of elements that was created for the declaration at the
+   * given offset. This method should only be used when there is no name
+   *
+   * @param elements the elements of the appropriate kind that exist in the current context
+   * @param offset the offset of the name of the element to be returned
+   * @return the element at the given offset
+   */
+  Element find2(List<Element> elements, int offset) => find4(elements, "", offset);
+
+  /**
+   * Return the element in the given array of elements that was created for the declaration with the
+   * given name.
+   *
+   * @param elements the elements of the appropriate kind that exist in the current context
+   * @param identifier the name node in the declaration of the element to be returned
+   * @return the element created for the declaration with the given name
+   */
+  Element find3(List<Element> elements, SimpleIdentifier identifier) => find4(elements, identifier.name, identifier.offset);
+
+  /**
+   * Return the element in the given array of elements that was created for the declaration with the
+   * given name at the given offset.
+   *
+   * @param elements the elements of the appropriate kind that exist in the current context
+   * @param name the name of the element to be returned
+   * @param offset the offset of the name of the element to be returned
+   * @return the element with the given name and offset
+   */
+  Element find4(List<Element> elements, String name, int offset) {
+    for (Element element in elements) {
+      if (element.displayName == name && element.nameOffset == offset) {
+        return element;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return the export element from the given array whose library has the given source, or
+   * `null` if there is no such export.
+   *
+   * @param exports the export elements being searched
+   * @param source the source of the library associated with the export element to being searched
+   *          for
+   * @return the export element whose library has the given source
+   */
+  ExportElement find5(List<ExportElement> exports, Source source) {
+    for (ExportElement export in exports) {
+      if (export.exportedLibrary.source == source) {
+        return export;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return the import element from the given array whose library has the given source and that has
+   * the given prefix, or `null` if there is no such import.
+   *
+   * @param imports the import elements being searched
+   * @param source the source of the library associated with the import element to being searched
+   *          for
+   * @param prefix the prefix with which the library was imported
+   * @return the import element whose library has the given source and prefix
+   */
+  ImportElement find6(List<ImportElement> imports, Source source, SimpleIdentifier prefix) {
+    for (ImportElement element in imports) {
+      if (element.importedLibrary.source == source) {
+        PrefixElement prefixElement = element.prefix;
+        if (prefix == null) {
+          if (prefixElement == null) {
+            return element;
+          }
+        } else {
+          if (prefixElement != null && prefix.name == prefixElement.displayName) {
+            return element;
+          }
+        }
+      }
+    }
+    return null;
+  }
+
+  void gatherElements(Element element) {
+    element.accept(new GeneralizingElementVisitor_7(this));
+  }
+
+  /**
+   * Search the most closely enclosing list of parameters for a parameter with the given name.
+   *
+   * @param node the node defining the parameter with the given name
+   * @param parameterName the name of the parameter being searched for
+   * @return the element representing the parameter with that name
+   */
+  ParameterElement getElementForParameter(FormalParameter node, SimpleIdentifier parameterName) {
+    List<ParameterElement> parameters = null;
+    if (_enclosingParameter != null) {
+      parameters = _enclosingParameter.parameters;
+    }
+    if (parameters == null && _enclosingExecutable != null) {
+      parameters = _enclosingExecutable.parameters;
+    }
+    if (parameters == null && _enclosingAlias != null) {
+      parameters = _enclosingAlias.parameters;
+    }
+    return parameters == null ? null : find3(parameters, parameterName);
+  }
+
+  /**
+   * 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;
+    }
+    return literal.stringValue;
+  }
+
+  /**
+   * Return `true` if the given class defines at least one constructor.
+   *
+   * @param node the class being tested
+   * @return `true` if the class defines at least one constructor
+   */
+  bool hasConstructor(ClassDeclaration node) {
+    for (ClassMember member in node.members) {
+      if (member is ConstructorDeclaration) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+/**
+ * Instances of the class `DeclarationMismatchException` represent an exception that is
+ * thrown when the element model defined by a given AST structure does not match an existing
+ * element model.
+ */
+class DeclarationMatcher_DeclarationMismatchException extends RuntimeException {
+}
+
+class GeneralizingElementVisitor_7 extends GeneralizingElementVisitor<Object> {
+  final DeclarationMatcher DeclarationMatcher_this;
+
+  GeneralizingElementVisitor_7(this.DeclarationMatcher_this) : super();
+
+  Object visitElement(Element element) {
+    javaSetAdd(DeclarationMatcher_this._allElements, element);
+    javaSetAdd(DeclarationMatcher_this._unmatchedElements, element);
+    return super.visitElement(element);
+  }
+}
+
 /**
  * Instances of the class `DeclarationResolver` are used to resolve declarations in an AST
  * structure to already built elements.
  */
 class DeclarationResolver extends RecursiveASTVisitor<Object> {
-
   /**
    * The compilation unit containing the AST nodes being visited.
    */
   CompilationUnitElement _enclosingUnit;
 
   /**
    * The function type alias containing the AST nodes being visited, or `null` if we are not
    * in the scope of a function type alias.
    */
   FunctionTypeAliasElement _enclosingAlias;
@@ skipping 21 matching lines @@
    * element.
    *
    * @param unit the compilation unit to be resolved
    * @param element the root of the element model used to resolve the AST nodes
    */
   void resolve(CompilationUnit unit, CompilationUnitElement element) {
     _enclosingUnit = element;
     unit.element = element;
     unit.accept(this);
   }
+
   Object visitCatchClause(CatchClause node) {
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
     if (exceptionParameter != null) {
       List<LocalVariableElement> localVariables = _enclosingExecutable.localVariables;
-      find3(localVariables, exceptionParameter);
+      find8(localVariables, exceptionParameter);
       SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
       if (stackTraceParameter != null) {
-        find3(localVariables, stackTraceParameter);
+        find8(localVariables, stackTraceParameter);
       }
     }
     return super.visitCatchClause(node);
   }
+
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       SimpleIdentifier className = node.name;
-      _enclosingClass = find3(_enclosingUnit.types, className);
+      _enclosingClass = find8(_enclosingUnit.types, className);
       return super.visitClassDeclaration(node);
     } finally {
       _enclosingClass = outerClass;
     }
   }
+
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement outerClass = _enclosingClass;
     try {
       SimpleIdentifier className = node.name;
-      _enclosingClass = find3(_enclosingUnit.types, className);
+      _enclosingClass = find8(_enclosingUnit.types, className);
       return super.visitClassTypeAlias(node);
     } finally {
       _enclosingClass = outerClass;
     }
   }
+
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       SimpleIdentifier constructorName = node.name;
       if (constructorName == null) {
         _enclosingExecutable = _enclosingClass.unnamedConstructor;
       } else {
         _enclosingExecutable = _enclosingClass.getNamedConstructor(constructorName.name);
         constructorName.staticElement = _enclosingExecutable;
       }
       node.element = _enclosingExecutable as ConstructorElement;
       return super.visitConstructorDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
+
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
-    find3(_enclosingExecutable.localVariables, variableName);
+    find8(_enclosingExecutable.localVariables, variableName);
     return super.visitDeclaredIdentifier(node);
   }
+
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     SimpleIdentifier parameterName = node.parameter.identifier;
     ParameterElement element = getElementForParameter(node, parameterName);
     Expression defaultValue = node.defaultValue;
     if (defaultValue != null) {
       ExecutableElement outerExecutable = _enclosingExecutable;
       try {
         if (element == null) {
         } else {
           _enclosingExecutable = element.initializer;
         }
         defaultValue.accept(this);
       } finally {
         _enclosingExecutable = outerExecutable;
       }
     }
     ParameterElement outerParameter = _enclosingParameter;
     try {
       _enclosingParameter = element;
       return super.visitDefaultFormalParameter(node);
     } finally {
       _enclosingParameter = outerParameter;
     }
   }
+
   Object visitExportDirective(ExportDirective node) {
     String uri = getStringValue(node.uri);
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
-      ExportElement exportElement = find5(library.exports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri));
+      ExportElement exportElement = find10(library.exports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri));
       node.element = exportElement;
     }
     return super.visitExportDirective(node);
   }
+
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElement element = getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
         return super.visitFieldFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
       return super.visitFieldFormalParameter(node);
     }
   }
+
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       SimpleIdentifier functionName = node.name;
       sc.Token property = node.propertyKeyword;
       if (property == null) {
         if (_enclosingExecutable != null) {
-          _enclosingExecutable = find3(_enclosingExecutable.functions, functionName);
+          _enclosingExecutable = find8(_enclosingExecutable.functions, functionName);
         } else {
-          _enclosingExecutable = find3(_enclosingUnit.functions, functionName);
+          _enclosingExecutable = find8(_enclosingUnit.functions, functionName);
         }
       } else {
-        PropertyAccessorElement accessor = find3(_enclosingUnit.accessors, functionName);
-        if (identical(((property as sc.KeywordToken)).keyword, sc.Keyword.SET)) {
+        PropertyAccessorElement accessor = find8(_enclosingUnit.accessors, functionName);
+        if (identical((property as sc.KeywordToken).keyword, sc.Keyword.SET)) {
           accessor = accessor.variable.setter;
           functionName.staticElement = accessor;
         }
         _enclosingExecutable = accessor;
       }
       node.functionExpression.element = _enclosingExecutable;
       return super.visitFunctionDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
+
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is! FunctionDeclaration) {
-      FunctionElement element = find2(_enclosingExecutable.functions, node.beginToken.offset);
+      FunctionElement element = find7(_enclosingExecutable.functions, node.beginToken.offset);
       node.element = element;
     }
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       _enclosingExecutable = node.element;
       return super.visitFunctionExpression(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
+
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     FunctionTypeAliasElement outerAlias = _enclosingAlias;
     try {
       SimpleIdentifier aliasName = node.name;
-      _enclosingAlias = find3(_enclosingUnit.functionTypeAliases, aliasName);
+      _enclosingAlias = find8(_enclosingUnit.functionTypeAliases, aliasName);
       return super.visitFunctionTypeAlias(node);
     } finally {
       _enclosingAlias = outerAlias;
     }
   }
+
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElement element = getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
         return super.visitFunctionTypedFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
       return super.visitFunctionTypedFormalParameter(node);
     }
   }
+
   Object visitImportDirective(ImportDirective node) {
     String uri = getStringValue(node.uri);
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
-      ImportElement importElement = find6(library.imports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri), node.prefix);
+      ImportElement importElement = find11(library.imports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri), node.prefix);
       node.element = importElement;
     }
     return super.visitImportDirective(node);
   }
+
   Object visitLabeledStatement(LabeledStatement node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
-      find3(_enclosingExecutable.labels, labelName);
+      find8(_enclosingExecutable.labels, labelName);
     }
     return super.visitLabeledStatement(node);
   }
+
   Object visitLibraryDirective(LibraryDirective node) {
     node.element = _enclosingUnit.library;
     return super.visitLibraryDirective(node);
   }
+
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       sc.Token property = node.propertyKeyword;
       SimpleIdentifier methodName = node.name;
       String nameOfMethod = methodName.name;
       if (nameOfMethod == sc.TokenType.MINUS.lexeme && node.parameters.parameters.length == 0) {
         nameOfMethod = "unary-";
       }
       if (property == null) {
-        _enclosingExecutable = find4(_enclosingClass.methods, nameOfMethod, methodName.offset);
+        _enclosingExecutable = find9(_enclosingClass.methods, nameOfMethod, methodName.offset);
         methodName.staticElement = _enclosingExecutable;
       } else {
-        PropertyAccessorElement accessor = find3(_enclosingClass.accessors, methodName);
-        if (identical(((property as sc.KeywordToken)).keyword, sc.Keyword.SET)) {
+        PropertyAccessorElement accessor = find8(_enclosingClass.accessors, methodName);
+        if (identical((property as sc.KeywordToken).keyword, sc.Keyword.SET)) {
           accessor = accessor.variable.setter;
           methodName.staticElement = accessor;
         }
         _enclosingExecutable = accessor;
       }
       return super.visitMethodDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
+
   Object visitPartDirective(PartDirective node) {
     String uri = getStringValue(node.uri);
     if (uri != null) {
       Source partSource = _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri);
       node.element = find(_enclosingUnit.library.parts, partSource);
     }
     return super.visitPartDirective(node);
   }
+
   Object visitPartOfDirective(PartOfDirective node) {
     node.element = _enclosingUnit.library;
     return super.visitPartOfDirective(node);
   }
+
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElement element = getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
         return super.visitSimpleFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
     }
     return super.visitSimpleFormalParameter(node);
   }
+
   Object visitSwitchCase(SwitchCase node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
-      find3(_enclosingExecutable.labels, labelName);
+      find8(_enclosingExecutable.labels, labelName);
     }
     return super.visitSwitchCase(node);
   }
+
   Object visitSwitchDefault(SwitchDefault node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
-      find3(_enclosingExecutable.labels, labelName);
+      find8(_enclosingExecutable.labels, labelName);
     }
     return super.visitSwitchDefault(node);
   }
+
   Object visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
     if (_enclosingClass != null) {
-      find3(_enclosingClass.typeParameters, parameterName);
+      find8(_enclosingClass.typeParameters, parameterName);
     } else if (_enclosingAlias != null) {
-      find3(_enclosingAlias.typeParameters, parameterName);
+      find8(_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);
+      element = find8(_enclosingExecutable.localVariables, variableName);
     }
     if (element == null && _enclosingClass != null) {
-      element = find3(_enclosingClass.fields, variableName);
+      element = find8(_enclosingClass.fields, variableName);
     }
     if (element == null && _enclosingUnit != null) {
-      element = find3(_enclosingUnit.topLevelVariables, variableName);
+      element = find8(_enclosingUnit.topLevelVariables, variableName);
     }
     Expression initializer = node.initializer;
     if (initializer != null) {
       ExecutableElement outerExecutable = _enclosingExecutable;
       try {
         if (element == null) {
         } else {
           _enclosingExecutable = element.initializer;
         }
         return super.visitVariableDeclaration(node);
@@ skipping 22 matching lines @@
   }
 
   /**
    * Return the element in the given array of elements that was created for the declaration at the
    * given offset. This method should only be used when there is no name
    *
    * @param elements the elements of the appropriate kind that exist in the current context
    * @param offset the offset of the name of the element to be returned
    * @return the element at the given offset
    */
-  Element find2(List<Element> elements, int offset) => find4(elements, "", offset);
+  Element find7(List<Element> elements, int offset) => find9(elements, "", offset);
 
   /**
    * Return the element in the given array of elements that was created for the declaration with the
    * given name.
    *
    * @param elements the elements of the appropriate kind that exist in the current context
    * @param identifier the name node in the declaration of the element to be returned
    * @return the element created for the declaration with the given name
    */
-  Element find3(List<Element> elements, SimpleIdentifier identifier) {
-    Element element = find4(elements, identifier.name, identifier.offset);
+  Element find8(List<Element> elements, SimpleIdentifier identifier) {
+    Element element = find9(elements, identifier.name, identifier.offset);
     identifier.staticElement = element;
     return element;
   }
 
   /**
    * Return the element in the given array of elements that was created for the declaration with the
    * given name at the given offset.
    *
    * @param elements the elements of the appropriate kind that exist in the current context
    * @param name the name of the element to be returned
    * @param offset the offset of the name of the element to be returned
    * @return the element with the given name and offset
    */
-  Element find4(List<Element> elements, String name, int offset) {
+  Element find9(List<Element> elements, String name, int offset) {
     for (Element element in elements) {
       if (element.displayName == name && element.nameOffset == offset) {
         return element;
       }
     }
     return null;
   }
 
   /**
    * Return the export element from the given array whose library has the given source, or
    * `null` if there is no such export.
    *
    * @param exports the export elements being searched
    * @param source the source of the library associated with the export element to being searched
    *          for
    * @return the export element whose library has the given source
    */
-  ExportElement find5(List<ExportElement> exports, Source source) {
+  ExportElement find10(List<ExportElement> exports, Source source) {
     for (ExportElement export in exports) {
       if (export.exportedLibrary.source == source) {
         return export;
       }
     }
     return null;
   }
 
   /**
    * Return the import element from the given array whose library has the given source and that has
    * the given prefix, or `null` if there is no such import.
    *
    * @param imports the import elements being searched
    * @param source the source of the library associated with the import element to being searched
    *          for
    * @param prefix the prefix with which the library was imported
    * @return the import element whose library has the given source and prefix
    */
-  ImportElement find6(List<ImportElement> imports, Source source, SimpleIdentifier prefix) {
+  ImportElement find11(List<ImportElement> imports, Source source, SimpleIdentifier prefix) {
     for (ImportElement element in imports) {
       if (element.importedLibrary.source == source) {
         PrefixElement prefixElement = element.prefix;
         if (prefix == null) {
           if (prefixElement == null) {
             return element;
           }
         } else {
           if (prefixElement != null && prefix.name == prefixElement.displayName) {
             return element;
@@ skipping 15 matching lines @@
     List<ParameterElement> parameters = null;
     if (_enclosingParameter != null) {
       parameters = _enclosingParameter.parameters;
     }
     if (parameters == null && _enclosingExecutable != null) {
       parameters = _enclosingExecutable.parameters;
     }
     if (parameters == null && _enclosingAlias != null) {
       parameters = _enclosingAlias.parameters;
     }
-    ParameterElement element = parameters == null ? null : find3(parameters, parameterName);
+    ParameterElement element = parameters == null ? null : find8(parameters, parameterName);
     if (element == null) {
       PrintStringWriter writer = new PrintStringWriter();
       writer.println("Invalid state found in the Analysis Engine:");
       writer.println("DeclarationResolver.getElementForParameter() is visiting a parameter that does not appear to be in a method or function.");
       writer.println("Ancestors:");
       ASTNode parent = node.parent;
       while (parent != null) {
         writer.println(parent.runtimeType.toString());
         writer.println("---------");
         parent = parent.parent;
@@ skipping 10 matching lines @@
    * @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;
     }
     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:
  *
  * * An identifier within the declaration of that name should resolve to the element being
  * declared.
@@ skipping 35 matching lines @@
  * [CompilationUnitElement]).
  * </ol>
  * Note that AST nodes that would represent elements that are not defined are not resolved to
  * anything. This includes such things as references to undeclared variables (which is an error) and
  * names in hide and show combinators that are not defined in the imported library (which is not an
  * error).
  *
  * @coverage dart.engine.resolver
  */
 class ElementResolver extends SimpleASTVisitor<Object> {
+  /**
+   * Checks if the given expression is the reference to the type, if it is then the
+   * [ClassElement] is returned, otherwise `null` is returned.
+   *
+   * @param expr the expression to evaluate
+   * @return the [ClassElement] if the given expression is the reference to the type, and
+   *         `null` otherwise
+   */
+  static ClassElementImpl getTypeReference(Expression expr) {
+    if (expr is Identifier) {
+      Identifier identifier = expr as Identifier;
+      if (identifier.staticElement is ClassElementImpl) {
+        return identifier.staticElement as ClassElementImpl;
+      }
+    }
+    return null;
+  }
 
   /**
    * @return `true` if the given identifier is the return type of a constructor declaration.
    */
   static bool isConstructorReturnType(SimpleIdentifier node) {
     ASTNode parent = node.parent;
     if (parent is ConstructorDeclaration) {
       ConstructorDeclaration constructor = parent as ConstructorDeclaration;
       return identical(constructor.returnType, node);
     }
@@ skipping 101 matching lines @@
     this._resolver = resolver;
     this._definingLibrary = resolver.definingLibrary;
     AnalysisOptions options = _definingLibrary.context.analysisOptions;
     _strictMode = options.strictMode;
     _enableHints = options.hint;
     _dynamicType = resolver.typeProvider.dynamicType;
     _typeType = resolver.typeProvider.typeType;
     _subtypeManager = new SubtypeManager();
     _promoteManager = resolver.promoteManager;
   }
+
   Object visitAssignmentExpression(AssignmentExpression node) {
     sc.Token operator = node.operator;
     sc.TokenType operatorType = operator.type;
     if (operatorType != sc.TokenType.EQ) {
       operatorType = operatorFromCompoundAssignment(operatorType);
       Expression leftHandSide = node.leftHandSide;
       if (leftHandSide != null) {
         String methodName = operatorType.lexeme;
         Type2 staticType = getStaticType(leftHandSide);
         MethodElement staticMethod = lookUpMethod(leftHandSide, staticType, methodName);
@@ skipping 11 matching lines @@
         if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
           ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_METHOD : HintCode.UNDEFINED_METHOD) as ErrorCode;
           _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, operator, [
               methodName,
               shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
         }
       }
     }
     return null;
   }
+
   Object visitBinaryExpression(BinaryExpression node) {
     sc.Token operator = node.operator;
     if (operator.isUserDefinableOperator) {
       Expression leftOperand = node.leftOperand;
       if (leftOperand != null) {
         String methodName = operator.lexeme;
         Type2 staticType = getStaticType(leftOperand);
         MethodElement staticMethod = lookUpMethod(leftOperand, staticType, methodName);
         node.staticElement = staticMethod;
         Type2 propagatedType = getPropagatedType(leftOperand);
         MethodElement propagatedMethod = lookUpMethod(leftOperand, propagatedType, methodName);
         node.propagatedElement = propagatedMethod;
         bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod) && (_strictMode || shouldReportMissingMember(propagatedType, propagatedMethod));
         bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
         if (shouldReportMissingMember_propagated) {
           if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
             shouldReportMissingMember_propagated = false;
           }
         }
         if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
           ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
           _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, operator, [
               methodName,
               shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
         }
       }
     }
     return null;
   }
+
   Object visitBreakStatement(BreakStatement node) {
     SimpleIdentifier labelNode = node.label;
     LabelElementImpl labelElement = lookupLabel(node, labelNode);
     if (labelElement != null && labelElement.isOnSwitchMember) {
-      _resolver.reportError5(ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER, labelNode, []);
+      _resolver.reportError6(ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER, labelNode, []);
     }
     return null;
   }
+
   Object visitClassDeclaration(ClassDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
+
   Object visitClassTypeAlias(ClassTypeAlias node) {
     setMetadata(node.element, node);
     return null;
   }
+
   Object visitCommentReference(CommentReference node) {
     Identifier identifier = node.identifier;
     if (identifier is SimpleIdentifier) {
       SimpleIdentifier simpleIdentifier = identifier as SimpleIdentifier;
       Element element = resolveSimpleIdentifier(simpleIdentifier);
       if (element == null) {
         element = findImportWithoutPrefix(simpleIdentifier);
         if (element is MultiplyDefinedElement) {
           element = null;
         }
       }
       if (element == null) {
       } else {
         if (element.library == null || element.library != _definingLibrary) {
         }
         simpleIdentifier.staticElement = element;
         if (node.newKeyword != null) {
           if (element is ClassElement) {
-            ConstructorElement constructor = ((element as ClassElement)).unnamedConstructor;
+            ConstructorElement constructor = (element as ClassElement).unnamedConstructor;
             if (constructor == null) {
             } else {
               simpleIdentifier.staticElement = constructor;
             }
           } else {
           }
         }
       }
     } else if (identifier is PrefixedIdentifier) {
       PrefixedIdentifier prefixedIdentifier = identifier as PrefixedIdentifier;
       SimpleIdentifier prefix = prefixedIdentifier.prefix;
       SimpleIdentifier name = prefixedIdentifier.identifier;
       Element element = resolveSimpleIdentifier(prefix);
       if (element == null) {
       } else {
         if (element is PrefixElement) {
           prefix.staticElement = element;
           element = _resolver.nameScope.lookup(identifier, _definingLibrary);
           name.staticElement = element;
           return null;
         }
         LibraryElement library = element.library;
         if (library == null) {
           AnalysisEngine.instance.logger.logError("Found element with null library: ${element.name}");
         } else if (library != _definingLibrary) {
         }
         name.staticElement = element;
         if (node.newKeyword == null) {
           if (element is ClassElement) {
-            Element memberElement = lookupGetterOrMethod(((element as ClassElement)).type, name.name);
+            Element memberElement = lookupGetterOrMethod((element as ClassElement).type, name.name);
             if (memberElement == null) {
-              memberElement = ((element as ClassElement)).getNamedConstructor(name.name);
+              memberElement = (element as ClassElement).getNamedConstructor(name.name);
               if (memberElement == null) {
-                memberElement = lookUpSetter(prefix, ((element as ClassElement)).type, name.name);
+                memberElement = lookUpSetter(prefix, (element as ClassElement).type, name.name);
               }
             }
             if (memberElement == null) {
             } else {
               name.staticElement = memberElement;
             }
           } else {
           }
         } else {
           if (element is ClassElement) {
-            ConstructorElement constructor = ((element as ClassElement)).getNamedConstructor(name.name);
+            ConstructorElement constructor = (element as ClassElement).getNamedConstructor(name.name);
             if (constructor == null) {
             } else {
               name.staticElement = constructor;
             }
           } else {
           }
         }
       }
     }
     return null;
   }
+
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     super.visitConstructorDeclaration(node);
     ConstructorElement element = node.element;
     if (element is ConstructorElementImpl) {
       ConstructorElementImpl constructorElement = element as ConstructorElementImpl;
       ConstructorName redirectedNode = node.redirectedConstructor;
       if (redirectedNode != null) {
         ConstructorElement redirectedElement = redirectedNode.staticElement;
         constructorElement.redirectedConstructor = redirectedElement;
       }
       for (ConstructorInitializer initializer in node.initializers) {
         if (initializer is RedirectingConstructorInvocation) {
-          ConstructorElement redirectedElement = ((initializer as RedirectingConstructorInvocation)).staticElement;
+          ConstructorElement redirectedElement = (initializer as RedirectingConstructorInvocation).staticElement;
           constructorElement.redirectedConstructor = redirectedElement;
         }
       }
       setMetadata(constructorElement, node);
     }
     return null;
   }
+
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     SimpleIdentifier fieldName = node.fieldName;
     ClassElement enclosingClass = _resolver.enclosingClass;
-    FieldElement fieldElement = ((enclosingClass as ClassElementImpl)).getField(fieldName.name);
+    FieldElement fieldElement = (enclosingClass as ClassElementImpl).getField(fieldName.name);
     fieldName.staticElement = fieldElement;
     if (fieldElement == null || fieldElement.isSynthetic) {
-      _resolver.reportError5(CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
+      _resolver.reportError6(CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
     } else if (fieldElement.isStatic) {
-      _resolver.reportError5(CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node, [fieldName]);
+      _resolver.reportError6(CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node, [fieldName]);
     }
     return null;
   }
+
   Object visitConstructorName(ConstructorName node) {
     Type2 type = node.type.type;
     if (type != null && type.isDynamic) {
       return null;
     } else if (type is! InterfaceType) {
       ASTNode parent = node.parent;
       if (parent is InstanceCreationExpression) {
-        if (((parent as InstanceCreationExpression)).isConst) {
+        if ((parent as InstanceCreationExpression).isConst) {
         } else {
         }
       } else {
       }
       return null;
     }
     ConstructorElement constructor;
     SimpleIdentifier name = node.name;
     InterfaceType interfaceType = type as InterfaceType;
     if (name == null) {
       constructor = interfaceType.lookUpConstructor(null, _definingLibrary);
     } else {
       constructor = interfaceType.lookUpConstructor(name.name, _definingLibrary);
       name.staticElement = constructor;
     }
     node.staticElement = constructor;
     return null;
   }
+
   Object visitContinueStatement(ContinueStatement node) {
     SimpleIdentifier labelNode = node.label;
     LabelElementImpl labelElement = lookupLabel(node, labelNode);
     if (labelElement != null && labelElement.isOnSwitchStatement) {
-      _resolver.reportError5(ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH, labelNode, []);
+      _resolver.reportError6(ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH, labelNode, []);
     }
     return null;
   }
+
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     setMetadata(node.element, node);
     return null;
   }
+
   Object visitExportDirective(ExportDirective node) {
     Element element = node.element;
     if (element is ExportElement) {
-      resolveCombinators(((element as ExportElement)).exportedLibrary, node.combinators);
+      resolveCombinators((element as ExportElement).exportedLibrary, node.combinators);
       setMetadata(element, node);
     }
     return null;
   }
+
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     String fieldName = node.identifier.name;
     ClassElement classElement = _resolver.enclosingClass;
     if (classElement != null) {
-      FieldElement fieldElement = ((classElement as ClassElementImpl)).getField(fieldName);
+      FieldElement fieldElement = (classElement as ClassElementImpl).getField(fieldName);
       if (fieldElement == null) {
-        _resolver.reportError5(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
+        _resolver.reportError6(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
       } else {
         ParameterElement parameterElement = node.element;
         if (parameterElement is FieldFormalParameterElementImpl) {
           FieldFormalParameterElementImpl fieldFormal = parameterElement as FieldFormalParameterElementImpl;
           fieldFormal.field = fieldElement;
           Type2 declaredType = fieldFormal.type;
           Type2 fieldType = fieldElement.type;
           if (node.type == null) {
             fieldFormal.type = fieldType;
           }
           if (fieldElement.isSynthetic) {
-            _resolver.reportError5(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
+            _resolver.reportError6(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
           } else if (fieldElement.isStatic) {
-            _resolver.reportError5(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [fieldName]);
+            _resolver.reportError6(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [fieldName]);
           } else if (declaredType != null && fieldType != null && !declaredType.isAssignableTo(fieldType)) {
-            _resolver.reportError5(StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE, node, [declaredType.displayName, fieldType.displayName]);
+            _resolver.reportError6(StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE, node, [declaredType.displayName, fieldType.displayName]);
           }
         } else {
           if (fieldElement.isSynthetic) {
-            _resolver.reportError5(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
+            _resolver.reportError6(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
           } else if (fieldElement.isStatic) {
-            _resolver.reportError5(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [fieldName]);
+            _resolver.reportError6(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [fieldName]);
           }
         }
       }
     }
     return super.visitFieldFormalParameter(node);
   }
+
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
+
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     Expression expression = node.function;
     if (expression is FunctionExpression) {
       FunctionExpression functionExpression = expression as FunctionExpression;
       ExecutableElement functionElement = functionExpression.element;
       ArgumentList argumentList = node.argumentList;
       List<ParameterElement> parameters = resolveArgumentsToParameters(false, argumentList, functionElement);
       if (parameters != null) {
         argumentList.correspondingStaticParameters = parameters;
       }
     }
     return null;
   }
+
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     setMetadata(node.element, node);
     return null;
   }
+
   Object visitImportDirective(ImportDirective node) {
     SimpleIdentifier prefixNode = node.prefix;
     if (prefixNode != null) {
       String prefixName = prefixNode.name;
       for (PrefixElement prefixElement in _definingLibrary.prefixes) {
         if (prefixElement.displayName == prefixName) {
           prefixNode.staticElement = prefixElement;
           break;
         }
       }
     }
     ImportElement importElement = node.element;
     if (importElement != null) {
       LibraryElement library = importElement.importedLibrary;
       if (library != null) {
         resolveCombinators(library, node.combinators);
       }
       setMetadata(importElement, node);
     }
     return null;
   }
+
   Object visitIndexExpression(IndexExpression node) {
     Expression target = node.realTarget;
     Type2 staticType = getStaticType(target);
     Type2 propagatedType = getPropagatedType(target);
     String getterMethodName = sc.TokenType.INDEX.lexeme;
     String setterMethodName = sc.TokenType.INDEX_EQ.lexeme;
     bool isInGetterContext = node.inGetterContext();
     bool isInSetterContext = node.inSetterContext();
     if (isInGetterContext && isInSetterContext) {
       MethodElement setterStaticMethod = lookUpMethod(target, staticType, setterMethodName);
@@ skipping 14 matching lines @@
       checkForUndefinedIndexOperator(node, target, getterMethodName, staticMethod, propagatedMethod, staticType, propagatedType);
     } else if (isInSetterContext) {
       MethodElement staticMethod = lookUpMethod(target, staticType, setterMethodName);
       MethodElement propagatedMethod = lookUpMethod(target, propagatedType, setterMethodName);
       node.staticElement = staticMethod;
       node.propagatedElement = propagatedMethod;
       checkForUndefinedIndexOperator(node, target, setterMethodName, staticMethod, propagatedMethod, staticType, propagatedType);
     }
     return null;
   }
+
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     ConstructorElement invokedConstructor = node.constructorName.staticElement;
     node.staticElement = invokedConstructor;
     ArgumentList argumentList = node.argumentList;
     List<ParameterElement> parameters = resolveArgumentsToParameters(node.isConst, argumentList, invokedConstructor);
     if (parameters != null) {
       argumentList.correspondingStaticParameters = parameters;
     }
     return null;
   }
+
   Object visitLibraryDirective(LibraryDirective node) {
     setMetadata(node.element, node);
     return null;
   }
+
   Object visitMethodDeclaration(MethodDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
+
   Object visitMethodInvocation(MethodInvocation node) {
     SimpleIdentifier methodName = node.methodName;
     Expression target = node.realTarget;
     if (target is SuperExpression && !isSuperInValidContext(target as SuperExpression)) {
       return null;
     }
     Element staticElement;
     Element propagatedElement;
     if (target == null) {
       staticElement = resolveInvokedElement2(methodName);
       propagatedElement = null;
     } else {
       Type2 staticType = getStaticType(target);
-      staticElement = resolveInvokedElement(target, staticType, methodName);
-      propagatedElement = resolveInvokedElement(target, getPropagatedType(target), methodName);
+      ClassElementImpl typeReference = getTypeReference(target);
+      if (typeReference != null) {
+        staticElement = propagatedElement = resolveElement(typeReference, methodName.name);
+      } else {
+        staticElement = resolveInvokedElement(target, staticType, methodName);
+        propagatedElement = resolveInvokedElement(target, getPropagatedType(target), methodName);
+      }
     }
     staticElement = convertSetterToGetter(staticElement);
     propagatedElement = convertSetterToGetter(propagatedElement);
     methodName.staticElement = staticElement;
     methodName.propagatedElement = propagatedElement;
     ArgumentList argumentList = node.argumentList;
     if (staticElement != null) {
       List<ParameterElement> parameters = computeCorrespondingParameters(argumentList, staticElement);
       if (parameters != null) {
         argumentList.correspondingStaticParameters = parameters;
@@ skipping 30 matching lines @@
             }
           }
         }
       }
       generatedWithTypePropagation = true;
     }
     if (errorCode == null) {
       return null;
     }
     if (identical(errorCode, StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION)) {
-      _resolver.reportError5(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName, [methodName.name]);
+      _resolver.reportError6(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName, [methodName.name]);
     } else if (identical(errorCode, CompileTimeErrorCode.UNDEFINED_FUNCTION)) {
-      _resolver.reportError5(CompileTimeErrorCode.UNDEFINED_FUNCTION, methodName, [methodName.name]);
+      _resolver.reportError6(CompileTimeErrorCode.UNDEFINED_FUNCTION, methodName, [methodName.name]);
     } else if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_METHOD)) {
       String targetTypeName;
       if (target == null) {
         ClassElement enclosingClass = _resolver.enclosingClass;
         targetTypeName = enclosingClass.displayName;
         ErrorCode proxyErrorCode = (generatedWithTypePropagation ? HintCode.UNDEFINED_METHOD : StaticTypeWarningCode.UNDEFINED_METHOD) as ErrorCode;
         _resolver.reportErrorProxyConditionalAnalysisError(_resolver.enclosingClass, proxyErrorCode, methodName, [methodName.name, targetTypeName]);
       } else {
         Type2 targetType = null;
         if (!generatedWithTypePropagation) {
           targetType = getStaticType(target);
         } else {
           targetType = getPropagatedType(target);
           if (targetType == null) {
             targetType = getStaticType(target);
           }
         }
         if (targetType != null && targetType.isDartCoreFunction && methodName.name == CALL_METHOD_NAME) {
           return null;
         }
         targetTypeName = targetType == null ? null : targetType.displayName;
         ErrorCode proxyErrorCode = (generatedWithTypePropagation ? HintCode.UNDEFINED_METHOD : StaticTypeWarningCode.UNDEFINED_METHOD) as ErrorCode;
         _resolver.reportErrorProxyConditionalAnalysisError(targetType.element, proxyErrorCode, methodName, [methodName.name, targetTypeName]);
       }
     } else if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_SUPER_METHOD)) {
       Type2 targetType = getStaticType(target);
       String targetTypeName = targetType == null ? null : targetType.name;
-      _resolver.reportError5(StaticTypeWarningCode.UNDEFINED_SUPER_METHOD, methodName, [methodName.name, targetTypeName]);
+      _resolver.reportError6(StaticTypeWarningCode.UNDEFINED_SUPER_METHOD, methodName, [methodName.name, targetTypeName]);
     }
     return null;
   }
+
   Object visitPartDirective(PartDirective node) {
     setMetadata(node.element, node);
     return null;
   }
+
   Object visitPartOfDirective(PartOfDirective node) {
     setMetadata(node.element, node);
     return null;
   }
+
   Object visitPostfixExpression(PostfixExpression node) {
     Expression operand = node.operand;
     String methodName = getPostfixOperator(node);
     Type2 staticType = getStaticType(operand);
     MethodElement staticMethod = lookUpMethod(operand, staticType, methodName);
     node.staticElement = staticMethod;
     Type2 propagatedType = getPropagatedType(operand);
     MethodElement propagatedMethod = lookUpMethod(operand, propagatedType, methodName);
     node.propagatedElement = propagatedMethod;
     bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod) && (_strictMode || shouldReportMissingMember(propagatedType, propagatedMethod));
     bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
     if (shouldReportMissingMember_propagated) {
       if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
         shouldReportMissingMember_propagated = false;
       }
     }
     if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
       ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
       _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, node.operator, [
           methodName,
           shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
     }
     return null;
   }
+
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefix = node.prefix;
     SimpleIdentifier identifier = node.identifier;
     Element prefixElement = prefix.staticElement;
     if (prefixElement is PrefixElement) {
       Element element = _resolver.nameScope.lookup(node, _definingLibrary);
       if (element == null && identifier.inSetterContext()) {
         element = _resolver.nameScope.lookup(new ElementResolver_SyntheticIdentifier("${node.name}="), _definingLibrary);
       }
       if (element == null) {
         if (identifier.inSetterContext()) {
-          _resolver.reportError5(StaticWarningCode.UNDEFINED_SETTER, identifier, [identifier.name, prefixElement.name]);
+          _resolver.reportError6(StaticWarningCode.UNDEFINED_SETTER, identifier, [identifier.name, prefixElement.name]);
         } else if (node.parent is Annotation) {
           Annotation annotation = node.parent as Annotation;
-          _resolver.reportError5(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
+          _resolver.reportError6(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
           return null;
         } else {
-          _resolver.reportError5(StaticWarningCode.UNDEFINED_GETTER, identifier, [identifier.name, prefixElement.name]);
+          _resolver.reportError6(StaticWarningCode.UNDEFINED_GETTER, identifier, [identifier.name, prefixElement.name]);
         }
         return null;
       }
       if (element is PropertyAccessorElement && identifier.inSetterContext()) {
-        PropertyInducingElement variable = ((element as PropertyAccessorElement)).variable;
+        PropertyInducingElement variable = (element as PropertyAccessorElement).variable;
         if (variable != null) {
           PropertyAccessorElement setter = variable.setter;
           if (setter != null) {
             element = setter;
           }
         }
       }
       identifier.staticElement = element;
       if (node.parent is Annotation) {
         Annotation annotation = node.parent as Annotation;
-        resolveAnnotationElement(annotation, element, null);
+        resolveAnnotationElement(annotation);
         return null;
       }
       return null;
     }
     if (node.parent is Annotation) {
       Annotation annotation = node.parent as Annotation;
-      resolveAnnotationElement(annotation, prefixElement, identifier);
+      resolveAnnotationElement(annotation);
     }
     resolvePropertyAccess(prefix, identifier);
     return null;
   }
+
   Object visitPrefixExpression(PrefixExpression node) {
     sc.Token operator = node.operator;
     sc.TokenType operatorType = operator.type;
     if (operatorType.isUserDefinableOperator || identical(operatorType, sc.TokenType.PLUS_PLUS) || identical(operatorType, sc.TokenType.MINUS_MINUS)) {
       Expression operand = node.operand;
       String methodName = getPrefixOperator(node);
       Type2 staticType = getStaticType(operand);
       MethodElement staticMethod = lookUpMethod(operand, staticType, methodName);
       node.staticElement = staticMethod;
       Type2 propagatedType = getPropagatedType(operand);
       MethodElement propagatedMethod = lookUpMethod(operand, propagatedType, methodName);
       node.propagatedElement = propagatedMethod;
       bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod) && (_strictMode || shouldReportMissingMember(propagatedType, propagatedMethod));
       bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
       if (shouldReportMissingMember_propagated) {
         if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
           shouldReportMissingMember_propagated = false;
         }
       }
       if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
         ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
         _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, operator, [
             methodName,
             shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
       }
     }
     return null;
   }
+
   Object visitPropertyAccess(PropertyAccess node) {
     Expression target = node.realTarget;
     if (target is SuperExpression && !isSuperInValidContext(target as SuperExpression)) {
       return null;
     }
     SimpleIdentifier propertyName = node.propertyName;
     resolvePropertyAccess(target, propertyName);
     return null;
   }
+
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (enclosingClass == null) {
       return null;
     }
     SimpleIdentifier name = node.constructorName;
     ConstructorElement element;
     if (name == null) {
       element = enclosingClass.unnamedConstructor;
     } else {
       element = enclosingClass.getNamedConstructor(name.name);
     }
     if (element == null) {
       return null;
     }
     if (name != null) {
       name.staticElement = element;
     }
     node.staticElement = 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;
     }
     if (node.name == _dynamicType.name) {
       node.staticElement = _dynamicType.element;
       node.staticType = _typeType;
       return null;
     }
     Element element = resolveSimpleIdentifier(node);
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (isFactoryConstructorReturnType(node) && element != enclosingClass) {
-      _resolver.reportError5(CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS, node, []);
+      _resolver.reportError6(CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS, node, []);
     } else if (isConstructorReturnType(node) && element != enclosingClass) {
-      _resolver.reportError5(CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node, []);
+      _resolver.reportError6(CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node, []);
       element = null;
     } else if (element == null || (element is PrefixElement && !isValidAsPrefix(node))) {
       if (isConstructorReturnType(node)) {
-        _resolver.reportError5(CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node, []);
+        _resolver.reportError6(CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node, []);
       } else if (node.parent is Annotation) {
         Annotation annotation = node.parent as Annotation;
-        _resolver.reportError5(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
+        _resolver.reportError6(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
       } else {
         _resolver.reportErrorProxyConditionalAnalysisError(_resolver.enclosingClass, StaticWarningCode.UNDEFINED_IDENTIFIER, node, [node.name]);
       }
     }
     node.staticElement = element;
     if (node.inSetterContext() && node.inGetterContext() && enclosingClass != null) {
       InterfaceType enclosingType = enclosingClass.type;
       AuxiliaryElements auxiliaryElements = new AuxiliaryElements(lookUpGetter(null, enclosingType, node.name), null);
       node.auxiliaryElements = auxiliaryElements;
     }
     if (node.parent is Annotation) {
       Annotation annotation = node.parent as Annotation;
-      resolveAnnotationElement(annotation, element, null);
+      resolveAnnotationElement(annotation);
     }
     return null;
   }
+
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (enclosingClass == null) {
       return null;
     }
     InterfaceType superType = enclosingClass.supertype;
     if (superType == null) {
       return null;
     }
     SimpleIdentifier name = node.constructorName;
     String superName = name != null ? name.name : null;
     ConstructorElement element = superType.lookUpConstructor(superName, _definingLibrary);
     if (element == null) {
       if (name != null) {
-        _resolver.reportError5(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER, node, [superType.displayName, name]);
+        _resolver.reportError6(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER, node, [superType.displayName, name]);
       } else {
-        _resolver.reportError5(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT, node, [superType.displayName]);
+        _resolver.reportError6(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT, node, [superType.displayName]);
       }
       return null;
     } else {
       if (element.isFactory) {
-        _resolver.reportError5(CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node, [element]);
+        _resolver.reportError6(CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node, [element]);
       }
     }
     if (name != null) {
       name.staticElement = element;
     }
     node.staticElement = element;
     ArgumentList argumentList = node.argumentList;
     List<ParameterElement> parameters = resolveArgumentsToParameters(isInConstConstructor, argumentList, element);
     if (parameters != null) {
       argumentList.correspondingStaticParameters = parameters;
     }
     return null;
   }
+
   Object visitSuperExpression(SuperExpression node) {
     if (!isSuperInValidContext(node)) {
-      _resolver.reportError5(CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT, node, []);
+      _resolver.reportError6(CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT, node, []);
     }
     return super.visitSuperExpression(node);
   }
+
   Object visitTypeParameter(TypeParameter node) {
     TypeName bound = node.bound;
     if (bound != null) {
       TypeParameterElementImpl typeParameter = node.name.staticElement as TypeParameterElementImpl;
       if (typeParameter != null) {
         typeParameter.bound = bound.type;
       }
     }
     setMetadata(node.element, node);
     return null;
   }
+
   Object visitVariableDeclaration(VariableDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
 
   /**
    * Generate annotation elements for each of the annotations in the given node list and add them to
    * the given list of elements.
    *
    * @param annotationList the list of elements to which new elements are to be added
@@ skipping 15 matching lines @@
    * @param target the target of the invocation, or `null` if there was no target
    * @param useStaticContext
    * @param element the element to be invoked
    * @return the error code that should be reported
    */
   ErrorCode checkForInvocationError(Expression target, bool useStaticContext, Element element) {
     if (element is PrefixElement) {
       element = null;
     }
     if (element is PropertyAccessorElement) {
-      FunctionType getterType = ((element as PropertyAccessorElement)).type;
+      FunctionType getterType = (element as PropertyAccessorElement).type;
       if (getterType != null) {
         Type2 returnType = getterType.returnType;
         if (!isExecutableType(returnType)) {
           return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
         }
       }
     } else if (element is ExecutableElement) {
       return null;
     } else if (element == null && target is SuperExpression) {
       return StaticTypeWarningCode.UNDEFINED_SUPER_METHOD;
     } else {
       if (element is PropertyInducingElement) {
-        PropertyAccessorElement getter = ((element as PropertyInducingElement)).getter;
+        PropertyAccessorElement getter = (element as PropertyInducingElement).getter;
         FunctionType getterType = getter.type;
         if (getterType != null) {
           Type2 returnType = getterType.returnType;
           if (!isExecutableType(returnType)) {
             return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
           }
         }
       } else if (element is VariableElement) {
-        Type2 variableType = ((element as VariableElement)).type;
+        Type2 variableType = (element as VariableElement).type;
         if (!isExecutableType(variableType)) {
           return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
         }
       } else {
         if (target == null) {
           ClassElement enclosingClass = _resolver.enclosingClass;
           if (enclosingClass == null) {
             return CompileTimeErrorCode.UNDEFINED_FUNCTION;
           } else if (element == null) {
             return StaticTypeWarningCode.UNDEFINED_METHOD;
@@ skipping 60 matching lines @@
    * Given a list of arguments and the element that will be invoked using those argument, compute
    * the list of parameters that correspond to the list of arguments. Return the parameters that
    * correspond to the arguments, or `null` if no correspondence could be computed.
    *
    * @param argumentList the list of arguments being passed to the element
    * @param executableElement the element that will be invoked with the arguments
    * @return the parameters that correspond to the arguments
    */
   List<ParameterElement> computeCorrespondingParameters(ArgumentList argumentList, Element element) {
     if (element is PropertyAccessorElement) {
-      FunctionType getterType = ((element as PropertyAccessorElement)).type;
+      FunctionType getterType = (element as PropertyAccessorElement).type;
       if (getterType != null) {
         Type2 getterReturnType = getterType.returnType;
         if (getterReturnType is InterfaceType) {
-          MethodElement callMethod = ((getterReturnType as InterfaceType)).lookUpMethod(CALL_METHOD_NAME, _definingLibrary);
+          MethodElement callMethod = (getterReturnType as InterfaceType).lookUpMethod(CALL_METHOD_NAME, _definingLibrary);
           if (callMethod != null) {
             return resolveArgumentsToParameters(false, argumentList, callMethod);
           }
         } else if (getterReturnType is FunctionType) {
-          Element functionElement = ((getterReturnType as FunctionType)).element;
+          Element functionElement = (getterReturnType as FunctionType).element;
           if (functionElement is ExecutableElement) {
             return resolveArgumentsToParameters(false, argumentList, functionElement as ExecutableElement);
           }
         }
       }
     } else if (element is ExecutableElement) {
       return resolveArgumentsToParameters(false, argumentList, element as ExecutableElement);
     } else if (element is VariableElement) {
       VariableElement variable = element as VariableElement;
       Type2 type = _promoteManager.getStaticType(variable);
       if (type is FunctionType) {
         FunctionType functionType = type as FunctionType;
         List<ParameterElement> parameters = functionType.parameters;
         return resolveArgumentsToParameters2(false, argumentList, parameters);
       } else if (type is InterfaceType) {
-        MethodElement callMethod = ((type as InterfaceType)).lookUpMethod(CALL_METHOD_NAME, _definingLibrary);
+        MethodElement callMethod = (type as InterfaceType).lookUpMethod(CALL_METHOD_NAME, _definingLibrary);
         if (callMethod != null) {
           List<ParameterElement> parameters = callMethod.parameters;
           return resolveArgumentsToParameters2(false, argumentList, parameters);
         }
       }
     }
     return null;
   }
 
   /**
    * If the given element is a setter, return the getter associated with it. Otherwise, return the
    * element unchanged.
    *
    * @param element the element to be normalized
    * @return a non-setter element derived from the given element
    */
   Element convertSetterToGetter(Element element) {
     if (element is PropertyAccessorElement) {
-      return ((element as PropertyAccessorElement)).variable.getter;
+      return (element as PropertyAccessorElement).variable.getter;
     }
     return element;
   }
 
   /**
    * Look for any declarations of the given identifier that are imported using a prefix. Return the
    * element that was found, or `null` if the name is not imported using a prefix.
    *
    * @param identifier the identifier that might have been imported using a prefix
    * @return the element that was found
@@ skipping 81 matching lines @@
    * Return `true` if the given type represents an object that could be invoked using the call
    * operator '()'.
    *
    * @param type the type being tested
    * @return `true` if the given type represents an object that could be invoked
    */
   bool isExecutableType(Type2 type) {
     if (type.isDynamic || (type is FunctionType) || type.isDartCoreFunction || type.isObject) {
       return true;
     } else if (type is InterfaceType) {
-      ClassElement classElement = ((type as InterfaceType)).element;
+      ClassElement classElement = (type as InterfaceType).element;
       MethodElement methodElement = classElement.lookUpMethod(CALL_METHOD_NAME, _definingLibrary);
       return methodElement != null;
     }
     return false;
   }
 
   /**
    * @return `true` iff current enclosing function is constant constructor declaration.
    */
   bool get isInConstConstructor {
     ExecutableElement function = _resolver.enclosingFunction;
     if (function is ConstructorElement) {
-      return ((function as ConstructorElement)).isConst;
+      return (function as ConstructorElement).isConst;
     }
     return false;
   }
 
   /**
    * Return `true` if the given element is a static element.
    *
    * @param element the element being tested
    * @return `true` if the given element is a static element
    */
   bool isStatic(Element element) {
     if (element is ExecutableElement) {
-      return ((element as ExecutableElement)).isStatic;
+      return (element as ExecutableElement).isStatic;
     } else if (element is PropertyInducingElement) {
-      return ((element as PropertyInducingElement)).isStatic;
+      return (element as PropertyInducingElement).isStatic;
     }
     return false;
   }
 
   /**
    * Return `true` if the given node can validly be resolved to a prefix:
    *
    * * it is the prefix in an import directive, or
    * * it is the prefix in a prefixed identifier.
    *
    *
    * @param node the node being tested
    * @return `true` if the given node is the prefix in an import directive
    */
   bool isValidAsPrefix(SimpleIdentifier node) {
     ASTNode parent = node.parent;
     if (parent is ImportDirective) {
-      return identical(((parent as ImportDirective)).prefix, node);
+      return identical((parent as ImportDirective).prefix, node);
     } else if (parent is PrefixedIdentifier) {
       return true;
     } else if (parent is MethodInvocation) {
-      return identical(((parent as MethodInvocation)).target, node);
+      return identical((parent as MethodInvocation).target, node);
     }
     return false;
   }
 
   /**
    * 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
@@ skipping 147 matching lines @@
     if (labelNode == null) {
       if (labelScope == null) {
       } else {
         labelElement = labelScope.lookup2(LabelScope.EMPTY_LABEL) as LabelElementImpl;
         if (labelElement == null) {
         }
         labelElement = null;
       }
     } else {
       if (labelScope == null) {
-        _resolver.reportError5(CompileTimeErrorCode.LABEL_UNDEFINED, labelNode, [labelNode.name]);
+        _resolver.reportError6(CompileTimeErrorCode.LABEL_UNDEFINED, labelNode, [labelNode.name]);
       } else {
         labelElement = labelScope.lookup(labelNode) as LabelElementImpl;
         if (labelElement == null) {
-          _resolver.reportError5(CompileTimeErrorCode.LABEL_UNDEFINED, labelNode, [labelNode.name]);
+          _resolver.reportError6(CompileTimeErrorCode.LABEL_UNDEFINED, labelNode, [labelNode.name]);
         } else {
           labelNode.staticElement = labelElement;
         }
       }
     }
     if (labelElement != null) {
       ExecutableElement labelContainer = labelElement.getAncestor(ExecutableElement);
       if (labelContainer != _resolver.enclosingFunction) {
-        _resolver.reportError5(CompileTimeErrorCode.LABEL_IN_OUTER_SCOPE, labelNode, [labelNode.name]);
+        _resolver.reportError6(CompileTimeErrorCode.LABEL_IN_OUTER_SCOPE, labelNode, [labelNode.name]);
         labelElement = null;
       }
     }
     return labelElement;
   }
 
   /**
    * Look up the method with the given name in the given type. Return the element representing the
    * method that was found, or `null` if there is no method with the given name.
    *
@@ skipping 190 matching lines @@
       } else if (operator == sc.TokenType.STAR_EQ) {
         return sc.TokenType.STAR;
       } else if (operator == sc.TokenType.TILDE_SLASH_EQ) {
         return sc.TokenType.TILDE_SLASH;
       }
       break;
     }
     AnalysisEngine.instance.logger.logError("Failed to map ${operator.lexeme} to it's corresponding operator");
     return operator;
   }
+
   void resolveAnnotationConstructorInvocationArguments(Annotation annotation, ConstructorElement constructor) {
     ArgumentList argumentList = annotation.arguments;
     if (argumentList == null) {
       return;
     }
     List<ParameterElement> parameters = resolveArgumentsToParameters(true, argumentList, constructor);
     if (parameters != null) {
       argumentList.correspondingStaticParameters = parameters;
     }
   }
 
   /**
-   * Validates that the given [Element] is the constant variable; or resolves it as a
-   * constructor invocation.
+   * Continues resolution of the given [Annotation].
    *
    * @param annotation the [Annotation] to resolve
-   * @param element the current known [Element] of the annotation, or [ClassElement]
-   * @param nameNode the name of the invoked constructor, may be `null` if unnamed constructor
-   *          or not a constructor invocation
    */
-  void resolveAnnotationElement(Annotation annotation, Element element, SimpleIdentifier nameNode) {
-    if (element is PropertyAccessorElement) {
-      PropertyAccessorElement accessorElement = element as PropertyAccessorElement;
-      if (!accessorElement.isSynthetic) {
-        _resolver.reportError5(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
+  void resolveAnnotationElement(Annotation annotation) {
+    SimpleIdentifier nameNode1;
+    SimpleIdentifier nameNode2;
+    {
+      Identifier annName = annotation.name;
+      if (annName is PrefixedIdentifier) {
+        PrefixedIdentifier prefixed = annName as PrefixedIdentifier;
+        nameNode1 = prefixed.prefix;
+        nameNode2 = prefixed.identifier;
+      } else {
+        nameNode1 = annName as SimpleIdentifier;
+        nameNode2 = null;
+      }
+    }
+    SimpleIdentifier nameNode3 = annotation.constructorName;
+    ConstructorElement constructor = null;
+    if (nameNode1 != null && nameNode2 == null && nameNode3 == null) {
+      Element element1 = nameNode1.staticElement;
+      if (element1 is PropertyAccessorElement) {
+        resolveAnnotationElementGetter(annotation, element1 as PropertyAccessorElement);
         return;
       }
-      VariableElement variableElement = accessorElement.variable;
-      if (!variableElement.isConst) {
-        _resolver.reportError5(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
+      if (element1 is ClassElement) {
+        ClassElement classElement = element1 as ClassElement;
+        constructor = new InterfaceTypeImpl.con1(classElement).lookUpConstructor(null, _definingLibrary);
       }
+    }
+    if (nameNode1 != null && nameNode2 != null && nameNode3 == null) {
+      Element element1 = nameNode1.staticElement;
+      Element element2 = nameNode2.staticElement;
+      if (element1 is ClassElement) {
+        ClassElement classElement = element1 as ClassElement;
+        element2 = classElement.lookUpGetter(nameNode2.name, _definingLibrary);
+      }
+      if (element2 is PropertyAccessorElement) {
+        nameNode2.staticElement = element2;
+        annotation.element = element2;
+        resolveAnnotationElementGetter(annotation, element2 as PropertyAccessorElement);
+        return;
+      }
+      if (element2 is ClassElement) {
+        ClassElement classElement = element2 as ClassElement;
+        constructor = classElement.unnamedConstructor;
+      }
+      if (element1 is ClassElement) {
+        ClassElement classElement = element1 as ClassElement;
+        constructor = new InterfaceTypeImpl.con1(classElement).lookUpConstructor(nameNode2.name, _definingLibrary);
+        nameNode2.staticElement = constructor;
+      }
+    }
+    if (nameNode1 != null && nameNode2 != null && nameNode3 != null) {
+      Element element2 = nameNode2.staticElement;
+      if (element2 is ClassElement) {
+        ClassElement classElement = element2 as ClassElement;
+        String name3 = nameNode3.name;
+        PropertyAccessorElement getter = classElement.lookUpGetter(name3, _definingLibrary);
+        if (getter != null) {
+          nameNode3.staticElement = getter;
+          annotation.element = element2;
+          resolveAnnotationElementGetter(annotation, getter);
+          return;
+        }
+        constructor = new InterfaceTypeImpl.con1(classElement).lookUpConstructor(name3, _definingLibrary);
+        nameNode3.staticElement = constructor;
+      }
+    }
+    if (constructor == null) {
+      _resolver.reportError6(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
       return;
     }
-    if (element is ClassElement) {
-      if (nameNode == null) {
-        nameNode = annotation.constructorName;
-      }
-      String name = nameNode != null ? nameNode.name : null;
-      ConstructorElement constructor;
-      {
-        InterfaceType interfaceType = new InterfaceTypeImpl.con1(element as ClassElement);
-        constructor = interfaceType.lookUpConstructor(name, _definingLibrary);
-      }
-      if (constructor == null) {
-        _resolver.reportError5(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
-        return;
-      }
-      annotation.element = constructor;
-      if (nameNode != null) {
-        nameNode.staticElement = constructor;
-      }
-      resolveAnnotationConstructorInvocationArguments(annotation, constructor);
+    annotation.element = constructor;
+    resolveAnnotationConstructorInvocationArguments(annotation, constructor);
+  }
+
+  void resolveAnnotationElementGetter(Annotation annotation, PropertyAccessorElement accessorElement) {
+    if (!accessorElement.isSynthetic) {
+      _resolver.reportError6(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
       return;
     }
-    if (element != null) {
-      _resolver.reportError5(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
+    VariableElement variableElement = accessorElement.variable;
+    if (!variableElement.isConst) {
+      _resolver.reportError6(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
     }
+    return;
   }
 
   /**
    * Given a list of arguments and the element that will be invoked using those argument, compute
    * the list of parameters that correspond to the list of arguments. Return the parameters that
    * correspond to the arguments, or `null` if no correspondence could be computed.
    *
    * @param reportError if `true` then compile-time error should be reported; if `false`
    *          then compile-time warning
    * @param argumentList the list of arguments being passed to the element
@@ skipping 38 matching lines @@
     int unnamedParameterCount = unnamedParameters.length;
     int unnamedIndex = 0;
     NodeList<Expression> arguments = argumentList.arguments;
     int argumentCount = arguments.length;
     List<ParameterElement> resolvedParameters = new List<ParameterElement>(argumentCount);
     int positionalArgumentCount = 0;
     Set<String> usedNames = new Set<String>();
     for (int i = 0; i < argumentCount; i++) {
       Expression argument = arguments[i];
       if (argument is NamedExpression) {
-        SimpleIdentifier nameNode = ((argument as NamedExpression)).name.label;
+        SimpleIdentifier nameNode = (argument as NamedExpression).name.label;
         String name = nameNode.name;
         ParameterElement element = namedParameters[name];
         if (element == null) {
           ErrorCode errorCode = (reportError ? CompileTimeErrorCode.UNDEFINED_NAMED_PARAMETER : StaticWarningCode.UNDEFINED_NAMED_PARAMETER) as ErrorCode;
-          _resolver.reportError5(errorCode, nameNode, [name]);
+          _resolver.reportError6(errorCode, nameNode, [name]);
         } else {
           resolvedParameters[i] = element;
           nameNode.staticElement = element;
         }
         if (!javaSetAdd(usedNames, name)) {
-          _resolver.reportError5(CompileTimeErrorCode.DUPLICATE_NAMED_ARGUMENT, nameNode, [name]);
+          _resolver.reportError6(CompileTimeErrorCode.DUPLICATE_NAMED_ARGUMENT, nameNode, [name]);
         }
       } else {
         positionalArgumentCount++;
         if (unnamedIndex < unnamedParameterCount) {
           resolvedParameters[i] = unnamedParameters[unnamedIndex++];
         }
       }
     }
     if (positionalArgumentCount < requiredParameters.length) {
       ErrorCode errorCode = (reportError ? CompileTimeErrorCode.NOT_ENOUGH_REQUIRED_ARGUMENTS : StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS) as ErrorCode;
-      _resolver.reportError5(errorCode, argumentList, [requiredParameters.length, positionalArgumentCount]);
+      _resolver.reportError6(errorCode, argumentList, [requiredParameters.length, positionalArgumentCount]);
     } else if (positionalArgumentCount > unnamedParameterCount) {
       ErrorCode errorCode = (reportError ? CompileTimeErrorCode.EXTRA_POSITIONAL_ARGUMENTS : StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS) as ErrorCode;
-      _resolver.reportError5(errorCode, argumentList, [unnamedParameterCount, positionalArgumentCount]);
+      _resolver.reportError6(errorCode, argumentList, [unnamedParameterCount, positionalArgumentCount]);
     }
     return resolvedParameters;
   }
 
   /**
    * Resolve the names in the given combinators in the scope of the given library.
    *
    * @param library the library that defines the names
    * @param combinators the combinators containing the names to be resolved
    */
   void resolveCombinators(LibraryElement library, NodeList<Combinator> combinators) {
     if (library == null) {
       return;
     }
     Namespace namespace = new NamespaceBuilder().createExportNamespace2(library);
     for (Combinator combinator in combinators) {
       NodeList<SimpleIdentifier> names;
       if (combinator is HideCombinator) {
-        names = ((combinator as HideCombinator)).hiddenNames;
+        names = (combinator as HideCombinator).hiddenNames;
       } else {
-        names = ((combinator as ShowCombinator)).shownNames;
+        names = (combinator as ShowCombinator).shownNames;
       }
       for (SimpleIdentifier name in names) {
         Element element = namespace.get(name.name);
         if (element != null) {
           name.staticElement = element;
         }
       }
     }
   }
 
   /**
+   * Given an invocation of the form 'C.x()' where 'C' is a class, find and return the element 'x'
+   * in 'C'.
+   *
+   * @param classElement the class element
+   * @param memberName the member name
+   */
+  Element resolveElement(ClassElementImpl classElement, String memberName) {
+    Element element = null;
+    String methodNameStr = memberName;
+    element = classElement.getMethod(methodNameStr);
+    if (element == null) {
+      element = classElement.getSetter(memberName);
+      if (element == null) {
+        element = classElement.getGetter(memberName);
+      }
+    }
+    if (element != null && element.isAccessibleIn(_definingLibrary)) {
+      return element;
+    }
+    return null;
+  }
+
+  /**
    * Given an invocation of the form 'e.m(a1, ..., an)', resolve 'e.m' to the element being invoked.
    * If the returned element is a method, then the method will be invoked. If the returned element
    * is a getter, the getter will be invoked without arguments and the result of that invocation
    * will then be invoked with the arguments.
    *
    * @param target the target of the invocation ('e')
    * @param targetType the type of the target
    * @param methodName the name of the method being invoked ('m')
    * @return the element being invoked
    */
   Element resolveInvokedElement(Expression target, Type2 targetType, SimpleIdentifier methodName) {
     if (targetType is InterfaceType) {
       InterfaceType classType = targetType as InterfaceType;
       Element element = lookUpMethod(target, classType, methodName.name);
       if (element == null) {
         element = lookUpGetter(target, classType, methodName.name);
       }
       return element;
     } else if (target is SimpleIdentifier) {
-      Element targetElement = ((target as SimpleIdentifier)).staticElement;
+      Element targetElement = (target as SimpleIdentifier).staticElement;
       if (targetElement is PrefixElement) {
-        String name = "${((target as SimpleIdentifier)).name}.${methodName}";
+        String name = "${(target as SimpleIdentifier).name}.${methodName}";
         Identifier functionName = new ElementResolver_SyntheticIdentifier(name);
         Element element = _resolver.nameScope.lookup(functionName, _definingLibrary);
         if (element != null) {
           return element;
         }
       }
     }
     return null;
   }
 
@@ skipping 36 matching lines @@
       memberElement = lookUpSetter(target, targetType, propertyName.name);
     }
     if (memberElement == null) {
       memberElement = lookUpGetter(target, targetType, propertyName.name);
     }
     if (memberElement == null) {
       memberElement = lookUpMethod(target, targetType, propertyName.name);
     }
     return memberElement;
   }
+
   void resolvePropertyAccess(Expression target, SimpleIdentifier propertyName) {
     Type2 staticType = getStaticType(target);
-    ExecutableElement staticElement = resolveProperty(target, staticType, propertyName);
+    Type2 propagatedType = getPropagatedType(target);
+    Element staticElement = null;
+    Element propagatedElement = null;
+    ClassElementImpl typeReference = getTypeReference(target);
+    if (typeReference != null) {
+      staticElement = propagatedElement = resolveElement(typeReference, propertyName.name);
+    } else {
+      staticElement = resolveProperty(target, staticType, propertyName);
+      propagatedElement = resolveProperty(target, propagatedType, propertyName);
+    }
     if (target.parent.parent is Annotation) {
       if (staticElement != null) {
         propertyName.staticElement = staticElement;
       }
       return;
     }
     propertyName.staticElement = staticElement;
-    Type2 propagatedType = getPropagatedType(target);
-    ExecutableElement propagatedElement = resolveProperty(target, propagatedType, propertyName);
     propertyName.propagatedElement = propagatedElement;
     bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticElement) && (_strictMode || shouldReportMissingMember(propagatedType, propagatedElement));
     bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedElement) : false;
     if (shouldReportMissingMember_propagated) {
       if (memberFoundInSubclass(propagatedType.element, propertyName.name, false, true)) {
         shouldReportMissingMember_propagated = false;
       }
     }
     if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
       Element staticOrPropagatedEnclosingElt = shouldReportMissingMember_static ? staticType.element : propagatedType.element;
@@ skipping 32 matching lines @@
    * Resolve the given simple identifier if possible. Return the element to which it could be
    * resolved, or `null` if it could not be resolved. This does not record the results of the
    * resolution.
    *
    * @param node the identifier to be resolved
    * @return the element to which the identifier could be resolved
    */
   Element resolveSimpleIdentifier(SimpleIdentifier node) {
     Element element = _resolver.nameScope.lookup(node, _definingLibrary);
     if (element is PropertyAccessorElement && node.inSetterContext()) {
-      PropertyInducingElement variable = ((element as PropertyAccessorElement)).variable;
+      PropertyInducingElement variable = (element as PropertyAccessorElement).variable;
       if (variable != null) {
         PropertyAccessorElement setter = variable.setter;
         if (setter == null) {
           ClassElement enclosingClass = _resolver.enclosingClass;
           if (enclosingClass != null) {
             setter = lookUpSetter(null, enclosingClass.type, node.name);
           }
         }
         if (setter != null) {
           element = setter;
@@ skipping 21 matching lines @@
   /**
    * 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 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 resolveTypeParameter(Type2 type) {
     if (type is TypeParameterType) {
-      Type2 bound = ((type as TypeParameterType)).element.bound;
+      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 23 matching lines @@
       addAnnotations(annotationList, list.metadata);
       if (list.parent is FieldDeclaration) {
         FieldDeclaration fieldDeclaration = list.parent as FieldDeclaration;
         addAnnotations(annotationList, fieldDeclaration.metadata);
       } else if (list.parent is TopLevelVariableDeclaration) {
         TopLevelVariableDeclaration variableDeclaration = list.parent as TopLevelVariableDeclaration;
         addAnnotations(annotationList, variableDeclaration.metadata);
       }
     }
     if (!annotationList.isEmpty) {
-      ((element as ElementImpl)).metadata = new List.from(annotationList);
+      (element as ElementImpl).metadata = new List.from(annotationList);
     }
   }
 
   /**
    * Return `true` if we should report an error as a result of looking up a member in the
    * given type and not finding any member.
    *
    * @param type the type in which we attempted to perform the look-up
    * @param member the result of the look-up
    * @return `true` if we should report an error
    */
-  bool shouldReportMissingMember(Type2 type, ExecutableElement member) {
+  bool shouldReportMissingMember(Type2 type, Element member) {
     if (member != null || type == null || type.isDynamic || type.isBottom) {
       return false;
     }
     return true;
   }
 }
+
 /**
  * Instances of the class `SyntheticIdentifier` implement an identifier that can be used to
  * look up names in the lexical scope when there is no identifier in the AST structure. There is
  * no identifier in the AST when the parser could not distinguish between a method invocation and
  * an invocation of a top-level function imported with a prefix.
  */
 class ElementResolver_SyntheticIdentifier extends Identifier {
-
   /**
    * The name of the synthetic identifier.
    */
   String _name;
 
   /**
    * Initialize a newly created synthetic identifier to have the given name.
    *
    * @param name the name of the synthetic identifier
    */
   ElementResolver_SyntheticIdentifier(String name) {
     this._name = name;
   }
+
   accept(ASTVisitor visitor) => null;
+
   sc.Token get beginToken => null;
+
   Element get bestElement => null;
+
   sc.Token get endToken => null;
+
   String get name => _name;
+
   Element get propagatedElement => null;
+
   Element get staticElement => null;
+
   void visitChildren(ASTVisitor visitor) {
   }
 }
+
+/**
+ * Instances of the class `IncrementalResolver` resolve the smallest portion of an AST
+ * structure that we currently know how to resolve.
+ */
+class IncrementalResolver {
+  /**
+   * The element for the library containing the compilation unit being visited.
+   */
+  LibraryElement _definingLibrary;
+
+  /**
+   * The source representing the compilation unit being visited.
+   */
+  Source _source;
+
+  /**
+   * The object used to access the types from the core library.
+   */
+  TypeProvider _typeProvider;
+
+  /**
+   * The error listener that will be informed of any errors that are found during resolution.
+   */
+  AnalysisErrorListener _errorListener;
+
+  /**
+   * Initialize a newly created incremental resolver to resolve a node in the given source in the
+   * given library, reporting errors to the given error listener.
+   *
+   * @param definingLibrary the element for the library containing the compilation unit being
+   *          visited
+   * @param source the source representing the compilation unit being visited
+   * @param typeProvider the object used to access the types from the core library
+   * @param errorListener the error listener that will be informed of any errors that are found
+   *          during resolution
+   */
+  IncrementalResolver(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
+    this._definingLibrary = definingLibrary;
+    this._source = source;
+    this._typeProvider = typeProvider;
+    this._errorListener = errorListener;
+  }
+
+  /**
+   * Resolve the given node, reporting any errors or warnings to the given listener.
+   *
+   * @param node the root of the AST structure to be resolved
+   * @throws AnalysisException if the node could not be resolved
+   */
+  void resolve(ASTNode node) {
+    ASTNode rootNode = findResolutionRoot(node);
+    Scope scope = ScopeBuilder.scopeFor(rootNode, _errorListener);
+    if (elementModelChanged(rootNode.parent)) {
+      throw new AnalysisException.con1("Cannot resolve node: element model changed");
+    }
+    resolveTypes(node, scope);
+    resolveVariables(node, scope);
+    resolveReferences(node, scope);
+  }
+
+  /**
+   * Return `true` if the given node can be resolved independently of any other nodes.
+   *
+   * <b>Note:</b> This method needs to be kept in sync with [ScopeBuilder#scopeForAstNode].
+   *
+   * @param node the node being tested
+   * @return `true` if the given node can be resolved independently of any other nodes
+   */
+  bool canBeResolved(ASTNode node) => node is ClassDeclaration || node is ClassTypeAlias || node is CompilationUnit || node is ConstructorDeclaration || node is FunctionDeclaration || node is FunctionTypeAlias || node is MethodDeclaration;
+
+  /**
+   * Return `true` if the portion of the element model defined by the given node has changed.
+   *
+   * @param node the node defining the portion of the element model being tested
+   * @return `true` if the element model defined by the given node has changed
+   * @throws AnalysisException if the correctness of the element model cannot be determined
+   */
+  bool elementModelChanged(ASTNode node) {
+    Element element = getElement(node);
+    if (element == null) {
+      throw new AnalysisException.con1("Cannot resolve node: a ${node.runtimeType.toString()} does not define an element");
+    }
+    DeclarationMatcher matcher = new DeclarationMatcher();
+    return !matcher.matches(node, element);
+  }
+
+  /**
+   * Starting at the given node, find the smallest AST node that can be resolved independently of
+   * any other nodes. Return the node that was found.
+   *
+   * @param node the node at which the search is to begin
+   * @return the smallest AST node that can be resolved independently of any other nodes
+   * @throws AnalysisException if there is no such node
+   */
+  ASTNode findResolutionRoot(ASTNode node) {
+    ASTNode result = node;
+    ASTNode parent = result.parent;
+    while (parent != null && !canBeResolved(parent)) {
+      result = parent;
+      parent = result.parent;
+    }
+    if (parent == null) {
+      throw new AnalysisException.con1("Cannot resolve node: no resolvable node");
+    }
+    return result;
+  }
+
+  /**
+   * Return the element defined by the given node, or `null` if the node does not define an
+   * element.
+   *
+   * @param node the node defining the element to be returned
+   * @return the element defined by the given node
+   */
+  Element getElement(ASTNode node) {
+    if (node is Declaration) {
+      return (node as Declaration).element;
+    } else if (node is CompilationUnit) {
+      return (node as CompilationUnit).element;
+    }
+    return null;
+  }
+
+  void resolveReferences(ASTNode node, Scope scope) {
+    ResolverVisitor visitor = new ResolverVisitor.con3(_definingLibrary, _source, _typeProvider, scope, _errorListener);
+    node.accept(visitor);
+    for (ProxyConditionalAnalysisError conditionalCode in visitor.proxyConditionalAnalysisErrors) {
+      if (conditionalCode.shouldIncludeErrorCode()) {
+        visitor.reportError(conditionalCode.analysisError);
+      }
+    }
+  }
+
+  void resolveTypes(ASTNode node, Scope scope) {
+    TypeResolverVisitor visitor = new TypeResolverVisitor.con3(_definingLibrary, _source, _typeProvider, scope, _errorListener);
+    node.accept(visitor);
+  }
+
+  void resolveVariables(ASTNode node, Scope scope) {
+    VariableResolverVisitor visitor = new VariableResolverVisitor.con2(_definingLibrary, _source, _typeProvider, scope, _errorListener);
+    node.accept(visitor);
+  }
+}
+
 /**
  * Instances of the class `InheritanceManager` manage the knowledge of where class members
  * (methods, getters & setters) are inherited from.
  *
  * @coverage dart.engine.resolver
  */
 class InheritanceManager {
-
   /**
    * The [LibraryElement] that is managed by this manager.
    */
   LibraryElement _library;
 
   /**
    * This is a mapping between each [ClassElement] and a map between the [String] member
    * names and the associated [ExecutableElement] in the mixin and superclass chain.
    */
   Map<ClassElement, MemberMap> _classLookup;
@@ skipping 340 matching lines @@
       int numOfEltsWithMatchingNames = set.length;
       if (numOfEltsWithMatchingNames == 1) {
         resultMap.put(key, new JavaIterator(set).next());
       } else {
         bool allMethods = true;
         bool allSetters = true;
         bool allGetters = true;
         for (ExecutableElement executableElement in set) {
           if (executableElement is PropertyAccessorElement) {
             allMethods = false;
-            if (((executableElement as PropertyAccessorElement)).isSetter) {
+            if ((executableElement as PropertyAccessorElement).isSetter) {
               allGetters = false;
             } else {
               allSetters = false;
             }
           } else {
             allGetters = false;
             allSetters = false;
           }
         }
         if (allMethods || allGetters || allSetters) {
@@ skipping 119 matching lines @@
       if (executableElement is MethodMember) {
         executableElement = MethodMember.from(executableElement as MethodMember, superType);
         map.setValue(i, executableElement);
       } else if (executableElement is PropertyAccessorMember) {
         executableElement = PropertyAccessorMember.from(executableElement as PropertyAccessorMember, superType);
         map.setValue(i, executableElement);
       }
     }
   }
 }
+
 /**
  * Instances of the class `Library` represent the data about a single library during the
  * resolution of some (possibly different) library. They are not intended to be used except during
  * the resolution process.
  *
  * @coverage dart.engine.resolver
  */
 class Library {
-
   /**
    * The analysis context in which this library is being analyzed.
    */
   InternalAnalysisContext _analysisContext;
 
   /**
    * The inheritance manager which is used for this member lookups in this library.
    */
   InheritanceManager _inheritanceManager;
 
@@ skipping 255 matching lines @@
    * Set the library element representing this library to the given library element.
    *
    * @param libraryElement the library element representing this library
    */
   void set libraryElement(LibraryElementImpl libraryElement) {
     this._libraryElement = libraryElement;
     if (_inheritanceManager != null) {
       _inheritanceManager.libraryElement = libraryElement;
     }
   }
+
   String toString() => librarySource.shortName;
 }
+
 /**
  * Instances of the class `LibraryElementBuilder` build an element model for a single library.
  *
  * @coverage dart.engine.resolver
  */
 class LibraryElementBuilder {
-
   /**
    * The analysis context in which the element model will be built.
    */
   InternalAnalysisContext _analysisContext;
 
   /**
    * The listener to which errors will be reported.
    */
   AnalysisErrorListener _errorListener;
 
@@ skipping 26 matching lines @@
     CompilationUnitElementImpl definingCompilationUnitElement = builder.buildCompilationUnit(librarySource, definingCompilationUnit);
     NodeList<Directive> directives = definingCompilationUnit.directives;
     LibraryIdentifier libraryNameNode = null;
     bool hasPartDirective = false;
     FunctionElement entryPoint = findEntryPoint(definingCompilationUnitElement);
     List<Directive> directivesToResolve = new List<Directive>();
     List<CompilationUnitElementImpl> sourcedCompilationUnits = new List<CompilationUnitElementImpl>();
     for (Directive directive in directives) {
       if (directive is LibraryDirective) {
         if (libraryNameNode == null) {
-          libraryNameNode = ((directive as LibraryDirective)).name;
+          libraryNameNode = (directive as LibraryDirective).name;
           directivesToResolve.add(directive);
         }
       } else if (directive is PartDirective) {
         PartDirective partDirective = directive as PartDirective;
         StringLiteral partUri = partDirective.uri;
         Source partSource = library.getSource(partDirective);
         if (partSource != null && partSource.exists()) {
           hasPartDirective = true;
           CompilationUnitElementImpl part = builder.buildCompilationUnit(partSource, library.getAST(partSource));
           part.uri = library.getUri(partDirective);
@@ skipping 79 matching lines @@
    * @param directivesToResolve a list of directives that should be resolved to the library being
    *          built
    * @return the name of the library that the given part is declared to be a part of
    */
   String getPartLibraryName(Library library, Source partSource, List<Directive> directivesToResolve) {
     try {
       CompilationUnit partUnit = library.getAST(partSource);
       for (Directive directive in partUnit.directives) {
         if (directive is PartOfDirective) {
           directivesToResolve.add(directive);
-          LibraryIdentifier libraryName = ((directive as PartOfDirective)).libraryName;
+          LibraryIdentifier libraryName = (directive as PartOfDirective).libraryName;
           if (libraryName != null) {
             return libraryName.name;
           }
         }
       }
     } on AnalysisException catch (exception) {
     }
     return null;
   }
 
   /**
    * Look through all of the compilation units defined for the given library, looking for getters
    * and setters that are defined in different compilation units but that have the same names. If
    * any are found, make sure that they have the same variable element.
    *
    * @param libraryElement the library defining the compilation units to be processed
    */
   void patchTopLevelAccessors(LibraryElementImpl libraryElement) {
     Map<String, PropertyAccessorElement> getters = new Map<String, PropertyAccessorElement>();
     List<PropertyAccessorElement> setters = new List<PropertyAccessorElement>();
     collectAccessors(getters, setters, libraryElement.definingCompilationUnit);
     for (CompilationUnitElement unit in libraryElement.parts) {
       collectAccessors(getters, setters, unit);
     }
     for (PropertyAccessorElement setter in setters) {
       PropertyAccessorElement getter = getters[setter.displayName];
       if (getter != null) {
         PropertyInducingElementImpl variable = getter.variable as PropertyInducingElementImpl;
         variable.setter = setter;
-        ((setter as PropertyAccessorElementImpl)).variable = variable;
+        (setter as PropertyAccessorElementImpl).variable = variable;
       }
     }
   }
 }
+
 /**
  * Instances of the class `LibraryResolver` are used to resolve one or more mutually dependent
  * libraries within a single context.
  *
  * @coverage dart.engine.resolver
  */
 class LibraryResolver {
-
   /**
    * The analysis context in which the libraries are being analyzed.
    */
   InternalAnalysisContext analysisContext;
 
   /**
    * 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].
    */
@@ skipping 195 matching lines @@
    * Build the element model representing the combinators declared by the given directive.
    *
    * @param directive the directive that declares the combinators
    * @return an array containing the import combinators that were built
    */
   List<NamespaceCombinator> buildCombinators(NamespaceDirective directive) {
     List<NamespaceCombinator> combinators = new List<NamespaceCombinator>();
     for (Combinator combinator in directive.combinators) {
       if (combinator is HideCombinator) {
         HideElementCombinatorImpl hide = new HideElementCombinatorImpl();
-        hide.hiddenNames = getIdentifiers(((combinator as HideCombinator)).hiddenNames);
+        hide.hiddenNames = getIdentifiers((combinator as HideCombinator).hiddenNames);
         combinators.add(hide);
       } else {
         ShowElementCombinatorImpl show = new ShowElementCombinatorImpl();
         show.offset = combinator.offset;
         show.end = combinator.end;
-        show.shownNames = getIdentifiers(((combinator as ShowCombinator)).shownNames);
+        show.shownNames = getIdentifiers((combinator as ShowCombinator).shownNames);
         combinators.add(show);
       }
     }
     return new List.from(combinators);
   }
 
   /**
    * Every library now has a corresponding [LibraryElement], so it is now possible to resolve
    * the import and export directives.
    *
@@ skipping 17 matching lines @@
               StringLiteral uriLiteral = importDirective.uri;
               if (uriLiteral != null) {
                 importElement.uriEnd = uriLiteral.end;
               }
               importElement.uri = library.getUri(importDirective);
               importElement.combinators = buildCombinators(importDirective);
               LibraryElement importedLibraryElement = importedLibrary.libraryElement;
               if (importedLibraryElement != null) {
                 importElement.importedLibrary = importedLibraryElement;
               }
-              SimpleIdentifier prefixNode = ((directive as ImportDirective)).prefix;
+              SimpleIdentifier prefixNode = (directive as ImportDirective).prefix;
               if (prefixNode != null) {
                 importElement.prefixOffset = prefixNode.offset;
                 String prefixName = prefixNode.name;
                 PrefixElementImpl prefix = nameToPrefixMap[prefixName];
                 if (prefix == null) {
                   prefix = new PrefixElementImpl(prefixNode);
                   nameToPrefixMap[prefixName] = prefix;
                 }
                 importElement.prefix = prefix;
                 prefixNode.staticElement = prefix;
@@ skipping 322 matching lines @@
    *
    * @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();
     try {
       for (Source source in library.compilationUnitSources) {
         CompilationUnit ast = library.getAST(source);
-        ast.accept(new VariableResolverVisitor(library, source, _typeProvider));
+        ast.accept(new VariableResolverVisitor.con1(library, source, _typeProvider));
         ResolverVisitor visitor = new ResolverVisitor.con1(library, source, _typeProvider);
         ast.accept(visitor);
         for (ProxyConditionalAnalysisError conditionalCode in visitor.proxyConditionalAnalysisErrors) {
           if (conditionalCode.shouldIncludeErrorCode()) {
             visitor.reportError(conditionalCode.analysisError);
           }
         }
       }
     } finally {
       timeCounter.stop();
@@ skipping 14 matching lines @@
       return null;
     }
     String uriContent = uriLiteral.stringValue.trim();
     if (uriContent == null || uriContent.isEmpty) {
       return null;
     }
     uriContent = Uri.encodeFull(uriContent);
     return analysisContext.sourceFactory.resolveUri(librarySource, uriContent);
   }
 }
+
 /**
  * This class is used to replace uses of `HashMap<String, ExecutableElement>` which are not as
  * performant as this class.
  */
 class MemberMap {
-
   /**
    * The current size of this map.
    */
   int size = 0;
 
   /**
    * The array of keys.
    */
   List<String> _keys;
 
@@ skipping 127 matching lines @@
   }
 
   /**
    * Initializes [keys] and [values].
    */
   void initArrays(int initialCapacity) {
     _keys = new List<String>(initialCapacity);
     _values = new List<ExecutableElement>(initialCapacity);
   }
 }
+
 /**
  * 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.
  */
 class ProxyConditionalAnalysisError {
-
   /**
-   * The name of the proxy annotation, from the meta pub package.
+   * The name of the proxy annotation, from dart:core.
    */
   static String _PROXY_ANNOTATION_NAME = "proxy";
 
   /**
-   * The name of the meta library name, from the meta pub package.
-   */
-  static String _META_LIBRARY_NAME = "meta";
-
-  /**
    * Return `true` if the given element represents a class that has the proxy annotation.
    *
    * @param element the class being tested
    * @return `true` if the given element represents a class that has the proxy annotation
    */
   static bool classHasProxyAnnotation(Element element) {
     if (element is ClassElement) {
       ClassElement classElement = element as ClassElement;
       List<ElementAnnotation> annotations = classElement.metadata;
       for (ElementAnnotation annotation in annotations) {
         Element elementAnnotation = annotation.element;
         if (elementAnnotation != null) {
           LibraryElement lib = elementAnnotation.library;
-          if (elementAnnotation.name == _PROXY_ANNOTATION_NAME && lib != null && lib.name == _META_LIBRARY_NAME) {
+          if (lib != null && lib.isDartCore && elementAnnotation.name == _PROXY_ANNOTATION_NAME) {
             return true;
           }
         }
       }
     }
     return false;
   }
 
   /**
    * The enclosing [ClassElement], this is what will determine if the error code should, or
@@ skipping 18 matching lines @@
     this.analysisError = analysisError;
   }
 
   /**
    * Return `true` iff the enclosing class has the proxy annotation.
    *
    * @return `true` iff the enclosing class has the proxy annotation
    */
   bool shouldIncludeErrorCode() => !classHasProxyAnnotation(_enclosingElement);
 }
+
 /**
  * Instances of the class `ResolverVisitor` are used to resolve the nodes within a single
  * compilation unit.
  *
  * @coverage dart.engine.resolver
  */
 class ResolverVisitor extends ScopedVisitor {
-
   /**
    * The manager for the inheritance mappings.
    */
   InheritanceManager _inheritanceManager;
 
   /**
    * The object used to resolve the element associated with the current node.
    */
   ElementResolver _elementResolver;
 
@@ skipping 50 matching lines @@
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
   ResolverVisitor.con2(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, InheritanceManager inheritanceManager, AnalysisErrorListener errorListener) : super.con2(definingLibrary, source, typeProvider, errorListener) {
     this._inheritanceManager = inheritanceManager;
     this._elementResolver = new ElementResolver(this);
     this._typeAnalyzer = new StaticTypeAnalyzer(this);
   }
+
+  /**
+   * Initialize a newly created visitor to resolve the nodes in an AST node.
+   *
+   * @param definingLibrary the element for the library containing the node being visited
+   * @param source the source representing the compilation unit containing the node being visited
+   * @param typeProvider the object used to access the types from the core library
+   * @param nameScope the scope used to resolve identifiers in the node that will first be visited
+   * @param errorListener the error listener that will be informed of any errors that are found
+   *          during resolution
+   */
+  ResolverVisitor.con3(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, Scope nameScope, AnalysisErrorListener errorListener) : super.con3(definingLibrary, source, typeProvider, nameScope, errorListener) {
+    this._inheritanceManager = new InheritanceManager(definingLibrary);
+    this._elementResolver = new ElementResolver(this);
+    this._typeAnalyzer = new StaticTypeAnalyzer(this);
+  }
+
   Object visitAsExpression(AsExpression node) {
     super.visitAsExpression(node);
     override(node.expression, node.type.type);
     return null;
   }
+
   Object visitAssertStatement(AssertStatement node) {
     super.visitAssertStatement(node);
     propagateTrueState(node.condition);
     return null;
   }
+
   Object visitBinaryExpression(BinaryExpression node) {
     sc.TokenType operatorType = node.operator.type;
     Expression leftOperand = node.leftOperand;
     Expression rightOperand = node.rightOperand;
     if (identical(operatorType, sc.TokenType.AMPERSAND_AMPERSAND)) {
       safelyVisit(leftOperand);
       if (rightOperand != null) {
         try {
           overrideManager.enterScope();
           promoteManager.enterScope();
           propagateTrueState(leftOperand);
           promoteTypes(leftOperand);
           clearTypePromotionsIfPotentiallyMutatedIn(leftOperand);
           clearTypePromotionsIfPotentiallyMutatedIn(rightOperand);
-          clearTypePromotionsIfAccessedInScopeAndProtentiallyMutated(rightOperand);
+          clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(rightOperand);
           rightOperand.accept(this);
         } finally {
           overrideManager.exitScope();
           promoteManager.exitScope();
         }
       }
     } else if (identical(operatorType, sc.TokenType.BAR_BAR)) {
       safelyVisit(leftOperand);
       if (rightOperand != null) {
         try {
           overrideManager.enterScope();
           propagateFalseState(leftOperand);
           rightOperand.accept(this);
         } finally {
           overrideManager.exitScope();
         }
       }
     } else {
       safelyVisit(leftOperand);
       safelyVisit(rightOperand);
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
+
   Object visitBlockFunctionBody(BlockFunctionBody node) {
     try {
       overrideManager.enterScope();
       super.visitBlockFunctionBody(node);
     } finally {
       overrideManager.exitScope();
     }
     return null;
   }
+
   Object visitBreakStatement(BreakStatement node) {
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
+
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerType = enclosingClass;
     try {
       enclosingClass = node.element;
       _typeAnalyzer.thisType = enclosingClass == null ? null : enclosingClass.type;
       super.visitClassDeclaration(node);
     } finally {
       _typeAnalyzer.thisType = outerType == null ? null : outerType.type;
       enclosingClass = outerType;
     }
     return null;
   }
+
   Object visitCommentReference(CommentReference node) {
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
+
   Object visitCompilationUnit(CompilationUnit node) {
     try {
       overrideManager.enterScope();
       for (Directive directive in node.directives) {
         directive.accept(this);
       }
       List<CompilationUnitMember> classes = new List<CompilationUnitMember>();
       for (CompilationUnitMember declaration in node.declarations) {
         if (declaration is ClassDeclaration) {
           classes.add(declaration);
         } else {
           declaration.accept(this);
         }
       }
       for (CompilationUnitMember declaration in classes) {
         declaration.accept(this);
       }
     } finally {
       overrideManager.exitScope();
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
+
   Object visitConditionalExpression(ConditionalExpression node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Expression thenExpression = node.thenExpression;
     if (thenExpression != null) {
       try {
         overrideManager.enterScope();
         promoteManager.enterScope();
         propagateTrueState(condition);
         promoteTypes(condition);
         clearTypePromotionsIfPotentiallyMutatedIn(thenExpression);
-        clearTypePromotionsIfAccessedInScopeAndProtentiallyMutated(thenExpression);
+        clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(thenExpression);
         thenExpression.accept(this);
       } finally {
         overrideManager.exitScope();
         promoteManager.exitScope();
       }
     }
     Expression elseExpression = node.elseExpression;
     if (elseExpression != null) {
       try {
         overrideManager.enterScope();
         propagateFalseState(condition);
         elseExpression.accept(this);
       } finally {
         overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     bool thenIsAbrupt = isAbruptTermination(thenExpression);
     bool elseIsAbrupt = isAbruptTermination(elseExpression);
     if (elseIsAbrupt && !thenIsAbrupt) {
       propagateTrueState(condition);
       propagateState(thenExpression);
     } else if (thenIsAbrupt && !elseIsAbrupt) {
       propagateFalseState(condition);
       propagateState(elseExpression);
     }
     return null;
   }
+
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerFunction = enclosingFunction;
     try {
       enclosingFunction = node.element;
       super.visitConstructorDeclaration(node);
     } finally {
       enclosingFunction = outerFunction;
     }
     return null;
   }
+
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     safelyVisit(node.expression);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
+
   Object visitConstructorName(ConstructorName node) {
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
+
   Object visitContinueStatement(ContinueStatement node) {
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
+
   Object visitDoStatement(DoStatement node) {
     try {
       overrideManager.enterScope();
       super.visitDoStatement(node);
     } finally {
       overrideManager.exitScope();
     }
     return null;
   }
+
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
     try {
       overrideManager.enterScope();
       super.visitExpressionFunctionBody(node);
     } finally {
       overrideManager.exitScope();
     }
     return null;
   }
+
   Object visitFieldDeclaration(FieldDeclaration node) {
     try {
       overrideManager.enterScope();
       super.visitFieldDeclaration(node);
     } finally {
       Map<Element, Type2> overrides = overrideManager.captureOverrides(node.fields);
       overrideManager.exitScope();
       overrideManager.applyOverrides(overrides);
     }
     return null;
   }
+
   Object visitForEachStatement(ForEachStatement node) {
     try {
       overrideManager.enterScope();
       super.visitForEachStatement(node);
     } finally {
       overrideManager.exitScope();
     }
     return null;
   }
+
   Object visitForStatement(ForStatement node) {
     try {
       overrideManager.enterScope();
       super.visitForStatement(node);
     } finally {
       overrideManager.exitScope();
     }
     return null;
   }
+
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerFunction = enclosingFunction;
     try {
       SimpleIdentifier functionName = node.name;
       enclosingFunction = functionName.staticElement as ExecutableElement;
       super.visitFunctionDeclaration(node);
     } finally {
       enclosingFunction = outerFunction;
     }
     return null;
   }
+
   Object visitFunctionExpression(FunctionExpression node) {
     ExecutableElement outerFunction = enclosingFunction;
     try {
       enclosingFunction = node.element;
       overrideManager.enterScope();
       super.visitFunctionExpression(node);
     } finally {
       overrideManager.exitScope();
       enclosingFunction = outerFunction;
     }
     return null;
   }
+
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     safelyVisit(node.function);
     node.accept(_elementResolver);
     inferFunctionExpressionsParametersTypes(node.argumentList);
     safelyVisit(node.argumentList);
     node.accept(_typeAnalyzer);
     return null;
   }
+
   Object visitHideCombinator(HideCombinator node) => null;
+
   Object visitIfStatement(IfStatement node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Map<Element, Type2> thenOverrides = null;
     Statement thenStatement = node.thenStatement;
     if (thenStatement != null) {
       try {
         overrideManager.enterScope();
         promoteManager.enterScope();
         propagateTrueState(condition);
         promoteTypes(condition);
         clearTypePromotionsIfPotentiallyMutatedIn(thenStatement);
-        clearTypePromotionsIfAccessedInScopeAndProtentiallyMutated(thenStatement);
+        clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(thenStatement);
         visitStatementInScope(thenStatement);
       } finally {
         thenOverrides = overrideManager.captureLocalOverrides();
         overrideManager.exitScope();
         promoteManager.exitScope();
       }
     }
     Map<Element, Type2> elseOverrides = null;
     Statement elseStatement = node.elseStatement;
     if (elseStatement != null) {
@@ skipping 16 matching lines @@
         overrideManager.applyOverrides(thenOverrides);
       }
     } else if (thenIsAbrupt && !elseIsAbrupt) {
       propagateFalseState(condition);
       if (elseOverrides != null) {
         overrideManager.applyOverrides(elseOverrides);
       }
     }
     return null;
   }
+
   Object visitLabel(Label node) => null;
+
   Object visitLibraryIdentifier(LibraryIdentifier node) => null;
+
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerFunction = enclosingFunction;
     try {
       enclosingFunction = node.element;
       super.visitMethodDeclaration(node);
     } finally {
       enclosingFunction = outerFunction;
     }
     return null;
   }
+
   Object visitMethodInvocation(MethodInvocation node) {
     safelyVisit(node.target);
     node.accept(_elementResolver);
     inferFunctionExpressionsParametersTypes(node.argumentList);
     safelyVisit(node.argumentList);
     node.accept(_typeAnalyzer);
     return null;
   }
+
   Object visitNode(ASTNode node) {
     node.visitChildren(this);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
+
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     safelyVisit(node.prefix);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
+
   Object visitPropertyAccess(PropertyAccess node) {
     safelyVisit(node.target);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
+
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     safelyVisit(node.argumentList);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
+
   Object visitShowCombinator(ShowCombinator node) => null;
+
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     safelyVisit(node.argumentList);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
+
   Object visitSwitchCase(SwitchCase node) {
     try {
       overrideManager.enterScope();
       super.visitSwitchCase(node);
     } finally {
       overrideManager.exitScope();
     }
     return null;
   }
+
   Object visitSwitchDefault(SwitchDefault node) {
     try {
       overrideManager.enterScope();
       super.visitSwitchDefault(node);
     } finally {
       overrideManager.exitScope();
     }
     return null;
   }
+
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     try {
       overrideManager.enterScope();
       super.visitTopLevelVariableDeclaration(node);
     } finally {
       Map<Element, Type2> overrides = overrideManager.captureOverrides(node.variables);
       overrideManager.exitScope();
       overrideManager.applyOverrides(overrides);
     }
     return null;
   }
+
   Object visitTypeName(TypeName node) => null;
+
   Object visitWhileStatement(WhileStatement node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Statement body = node.body;
     if (body != null) {
       try {
         overrideManager.enterScope();
         propagateTrueState(condition);
         visitStatementInScope(body);
       } finally {
         overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   /**
    * Return the propagated element associated with the given expression whose type can be
    * overridden, or `null` if there is no element whose type can be overridden.
    *
    * @param expression the expression with which the element is associated
    * @return the element associated with the given expression
    */
   VariableElement getOverridablePropagatedElement(Expression expression) {
     Element element = null;
     if (expression is SimpleIdentifier) {
-      element = ((expression as SimpleIdentifier)).propagatedElement;
+      element = (expression as SimpleIdentifier).propagatedElement;
     } else if (expression is PrefixedIdentifier) {
-      element = ((expression as PrefixedIdentifier)).propagatedElement;
+      element = (expression as PrefixedIdentifier).propagatedElement;
     } else if (expression is PropertyAccess) {
-      element = ((expression as PropertyAccess)).propertyName.propagatedElement;
+      element = (expression as PropertyAccess).propertyName.propagatedElement;
     }
     if (element is VariableElement) {
       return element as VariableElement;
     }
     return null;
   }
 
   /**
    * Return the static element associated with the given expression whose type can be overridden, or
    * `null` if there is no element whose type can be overridden.
    *
    * @param expression the expression with which the element is associated
    * @return the element associated with the given expression
    */
   VariableElement getOverridableStaticElement(Expression expression) {
     Element element = null;
     if (expression is SimpleIdentifier) {
-      element = ((expression as SimpleIdentifier)).staticElement;
+      element = (expression as SimpleIdentifier).staticElement;
     } else if (expression is PrefixedIdentifier) {
-      element = ((expression as PrefixedIdentifier)).staticElement;
+      element = (expression as PrefixedIdentifier).staticElement;
     } else if (expression is PropertyAccess) {
-      element = ((expression as PropertyAccess)).propertyName.staticElement;
+      element = (expression as PropertyAccess).propertyName.staticElement;
     }
     if (element is VariableElement) {
       return element as VariableElement;
     }
     return null;
   }
 
   /**
    * Return the static element associated with the given expression whose type can be promoted, or
    * `null` if there is no element whose type can be promoted.
    *
    * @param expression the expression with which the element is associated
    * @return the element associated with the given expression
    */
   VariableElement getPromotionStaticElement(Expression expression) {
+    while (expression is ParenthesizedExpression) {
+      expression = (expression as ParenthesizedExpression).expression;
+    }
     if (expression is! SimpleIdentifier) {
       return null;
     }
     SimpleIdentifier identifier = expression as SimpleIdentifier;
     Element element = identifier.staticElement;
     if (element is! VariableElement) {
       return null;
     }
     ElementKind kind = element.kind;
     if (identical(kind, ElementKind.LOCAL_VARIABLE)) {
@@ skipping 43 matching lines @@
         return;
       }
     }
     Type2 currentType = getBestType(element);
     if (currentType == null || !currentType.isMoreSpecificThan(potentialType)) {
       overrideManager.setType(element, potentialType);
     }
   }
 
   /**
-   * If it is appropriate to do so, promotes the current type of the static element associated with
-   * the given expression with the given type. Generally speaking, it is appropriate if the given
-   * type is more specific than the current type.
-   *
-   * @param expression the expression used to access the static element whose types might be
-   *          promoted
-   * @param potentialType the potential type of the elements
-   */
-  void promote(Expression expression, Type2 potentialType) {
-    VariableElement element = getPromotionStaticElement(expression);
-    if (element != null) {
-      if (((element as VariableElementImpl)).isPotentiallyMutatedInClosure) {
-        return;
-      }
-      Type2 type = expression.staticType;
-      if (type == null || type.isDynamic) {
-        return;
-      }
-      if (potentialType == null || potentialType.isDynamic) {
-        return;
-      }
-      if (!potentialType.isMoreSpecificThan(type)) {
-        return;
-      }
-      promoteManager.setType(element, potentialType);
-    }
-  }
-
-  /**
    * Report a conditional analysis error with the given error code and arguments.
    *
    * @param enclosingElement the enclosing element
    * @param errorCode the error code of the error to be reported
    * @param node the node specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportErrorProxyConditionalAnalysisError(Element enclosingElement, ErrorCode errorCode, ASTNode node, List<Object> arguments) {
     proxyConditionalAnalysisErrors.add(new ProxyConditionalAnalysisError(enclosingElement, new AnalysisError.con2(source, node.offset, node.length, errorCode, arguments)));
   }
@@ skipping 15 matching lines @@
    * Report a conditional analysis error with the given error code and arguments.
    *
    * @param enclosingElement the enclosing element
    * @param errorCode the error code of the error to be reported
    * @param token the token specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void 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 {
@@ skipping 14 matching lines @@
           }
         }
         visitStatementInScope(body);
       } finally {
         overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
   }
+
   void visitForStatementInScope(ForStatement node) {
     safelyVisit(node.variables);
     safelyVisit(node.initialization);
     safelyVisit(node.condition);
     overrideManager.enterScope();
     try {
       propagateTrueState(node.condition);
       visitStatementInScope(node.body);
       node.updaters.accept(this);
     } finally {
       overrideManager.exitScope();
     }
   }
 
   /**
    * Checks each promoted variable in the current scope for compliance with the following
    * specification statement:
    *
    * If the variable <i>v</i> is accessed by a closure in <i>s<sub>1</sub></i> then the variable
    * <i>v</i> is not potentially mutated anywhere in the scope of <i>v</i>.
    */
-  void clearTypePromotionsIfAccessedInScopeAndProtentiallyMutated(ASTNode target) {
+  void clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(ASTNode target) {
     for (Element element in promoteManager.promotedElements) {
-      if (((element as VariableElementImpl)).isPotentiallyMutatedInScope) {
+      if ((element as VariableElementImpl).isPotentiallyMutatedInScope) {
         if (isVariableAccessedInClosure(element, target)) {
           promoteManager.setType(element, null);
         }
       }
     }
   }
 
   /**
    * Checks each promoted variable in the current scope for compliance with the following
    * specification statement:
@@ skipping 12 matching lines @@
    * Return the best type information available for the given element. If the type of the element
    * has been overridden, then return the overriding type. Otherwise, return the static type.
    *
    * @param element the element for which type information is to be returned
    * @return the best type information available for the given element
    */
   Type2 getBestType(Element element) {
     Type2 bestType = overrideManager.getType(element);
     if (bestType == null) {
       if (element is LocalVariableElement) {
-        bestType = ((element as LocalVariableElement)).type;
+        bestType = (element as LocalVariableElement).type;
       } else if (element is ParameterElement) {
-        bestType = ((element as ParameterElement)).type;
+        bestType = (element as ParameterElement).type;
       }
     }
     return bestType;
   }
 
   /**
    * The given expression is the expression used to compute the iterator for a for-each statement.
    * Attempt to compute the type of objects that will be assigned to the loop variable and return
    * that type. Return `null` if the type could not be determined.
    *
@@ skipping 65 matching lines @@
 
   /**
    * Return `true` if the given expression terminates abruptly (that is, if any expression
    * following the given expression will not be reached).
    *
    * @param expression the expression being tested
    * @return `true` if the given expression terminates abruptly
    */
   bool isAbruptTermination(Expression expression) {
     while (expression is ParenthesizedExpression) {
-      expression = ((expression as ParenthesizedExpression)).expression;
+      expression = (expression as ParenthesizedExpression).expression;
     }
     return expression is ThrowExpression || expression is RethrowExpression;
   }
 
   /**
    * Return `true` if the given statement terminates abruptly (that is, if any statement
    * following the given statement will not be reached).
    *
    * @param statement the statement being tested
    * @return `true` if the given statement terminates abruptly
    */
   bool isAbruptTermination2(Statement statement) {
     if (statement is ReturnStatement || statement is BreakStatement || statement is ContinueStatement) {
       return true;
     } else if (statement is ExpressionStatement) {
-      return isAbruptTermination(((statement as ExpressionStatement)).expression);
+      return isAbruptTermination((statement as ExpressionStatement).expression);
     } else if (statement is Block) {
-      NodeList<Statement> statements = ((statement as Block)).statements;
+      NodeList<Statement> statements = (statement as Block).statements;
       int size = statements.length;
       if (size == 0) {
         return false;
       }
       return isAbruptTermination2(statements[size - 1]);
     }
     return false;
   }
 
   /**
    * Return `true` if the given variable is accessed within a closure in the given
    * [ASTNode] and also mutated somewhere in variable scope. This information is only
    * available for local variables (including parameters).
    *
    * @param variable the variable to check
    * @param target the [ASTNode] to check within
    * @return `true` if this variable is potentially mutated somewhere in the given ASTNode
    */
   bool isVariableAccessedInClosure(Element variable, ASTNode target) {
     List<bool> result = [false];
-    target.accept(new RecursiveASTVisitor_7(result, variable));
+    target.accept(new RecursiveASTVisitor_8(result, variable));
     return result[0];
   }
 
   /**
    * Return `true` if the given variable is potentially mutated somewhere in the given
    * [ASTNode]. This information is only available for local variables (including parameters).
    *
    * @param variable the variable to check
    * @param target the [ASTNode] to check within
    * @return `true` if this variable is potentially mutated somewhere in the given ASTNode
    */
   bool isVariablePotentiallyMutatedIn(Element variable, ASTNode target) {
     List<bool> result = [false];
-    target.accept(new RecursiveASTVisitor_8(result, variable));
+    target.accept(new RecursiveASTVisitor_9(result, variable));
     return result[0];
   }
 
   /**
+   * If it is appropriate to do so, promotes the current type of the static element associated with
+   * the given expression with the given type. Generally speaking, it is appropriate if the given
+   * type is more specific than the current type.
+   *
+   * @param expression the expression used to access the static element whose types might be
+   *          promoted
+   * @param potentialType the potential type of the elements
+   */
+  void promote(Expression expression, Type2 potentialType) {
+    VariableElement element = getPromotionStaticElement(expression);
+    if (element != null) {
+      if ((element as VariableElementImpl).isPotentiallyMutatedInClosure) {
+        return;
+      }
+      Type2 type = promoteManager.getType(element);
+      if (type == null) {
+        type = expression.staticType;
+      }
+      if (type == null || type.isDynamic) {
+        return;
+      }
+      if (potentialType == null || potentialType.isDynamic) {
+        return;
+      }
+      if (!potentialType.isMoreSpecificThan(type)) {
+        return;
+      }
+      promoteManager.setType(element, potentialType);
+    }
+  }
+
+  /**
    * Promotes type information using given condition.
    */
   void promoteTypes(Expression condition) {
     if (condition is BinaryExpression) {
       BinaryExpression binary = condition as BinaryExpression;
       if (identical(binary.operator.type, sc.TokenType.AMPERSAND_AMPERSAND)) {
         Expression left = binary.leftOperand;
         Expression right = binary.rightOperand;
         promoteTypes(left);
         promoteTypes(right);
         clearTypePromotionsIfPotentiallyMutatedIn(right);
       }
     } else if (condition is IsExpression) {
       IsExpression is2 = condition as IsExpression;
       if (is2.notOperator == null) {
         promote(is2.expression, is2.type.type);
       }
     } else if (condition is ParenthesizedExpression) {
-      promoteTypes(((condition as ParenthesizedExpression)).expression);
+      promoteTypes((condition as ParenthesizedExpression).expression);
     }
   }
 
   /**
    * Propagate any type information that results from knowing that the given condition will have
    * been evaluated to 'false'.
    *
    * @param condition the condition that will have evaluated to 'false'
    */
   void propagateFalseState(Expression condition) {
     if (condition is BinaryExpression) {
       BinaryExpression binary = condition as BinaryExpression;
       if (identical(binary.operator.type, sc.TokenType.BAR_BAR)) {
         propagateFalseState(binary.leftOperand);
         propagateFalseState(binary.rightOperand);
       }
     } else if (condition is IsExpression) {
       IsExpression is2 = condition as IsExpression;
       if (is2.notOperator != null) {
         override(is2.expression, is2.type.type);
       }
     } else if (condition is PrefixExpression) {
       PrefixExpression prefix = condition as PrefixExpression;
       if (identical(prefix.operator.type, sc.TokenType.BANG)) {
         propagateTrueState(prefix.operand);
       }
     } else if (condition is ParenthesizedExpression) {
-      propagateFalseState(((condition as ParenthesizedExpression)).expression);
+      propagateFalseState((condition as ParenthesizedExpression).expression);
     }
   }
 
   /**
    * Propagate any type information that results from knowing that the given expression will have
    * been evaluated without altering the flow of execution.
    *
    * @param expression the expression that will have been evaluated
    */
   void propagateState(Expression expression) {
@@ skipping 16 matching lines @@
       IsExpression is2 = condition as IsExpression;
       if (is2.notOperator == null) {
         override(is2.expression, is2.type.type);
       }
     } else if (condition is PrefixExpression) {
       PrefixExpression prefix = condition as PrefixExpression;
       if (identical(prefix.operator.type, sc.TokenType.BANG)) {
         propagateFalseState(prefix.operand);
       }
     } else if (condition is ParenthesizedExpression) {
-      propagateTrueState(((condition as ParenthesizedExpression)).expression);
+      propagateTrueState((condition as ParenthesizedExpression).expression);
     }
   }
 
   /**
    * Record that the propagated type of the given node is the given type.
    *
    * @param expression the node whose type is to be recorded
    * @param type the propagated type of the node
    */
   void recordPropagatedType(Expression expression, Type2 type) {
     if (type != null && !type.isDynamic) {
       expression.propagatedType = type;
     }
   }
+
   get elementResolver_J2DAccessor => _elementResolver;
+
   set elementResolver_J2DAccessor(__v) => _elementResolver = __v;
+
   get labelScope_J2DAccessor => labelScope;
+
   set labelScope_J2DAccessor(__v) => labelScope = __v;
+
   get nameScope_J2DAccessor => nameScope;
+
   set nameScope_J2DAccessor(__v) => nameScope = __v;
+
   get typeAnalyzer_J2DAccessor => _typeAnalyzer;
+
   set typeAnalyzer_J2DAccessor(__v) => _typeAnalyzer = __v;
+
   get enclosingClass_J2DAccessor => enclosingClass;
+
   set enclosingClass_J2DAccessor(__v) => enclosingClass = __v;
 }
-class RecursiveASTVisitor_7 extends RecursiveASTVisitor<Object> {
+
+class RecursiveASTVisitor_8 extends RecursiveASTVisitor<Object> {
   List<bool> result;
+
   Element variable;
-  RecursiveASTVisitor_7(this.result, this.variable) : super();
+
+  RecursiveASTVisitor_8(this.result, this.variable) : super();
+
   bool _inClosure = false;
+
   Object visitFunctionExpression(FunctionExpression node) {
     bool inClosure = this._inClosure;
     try {
       this._inClosure = true;
       return super.visitFunctionExpression(node);
     } finally {
       this._inClosure = inClosure;
     }
   }
+
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (result[0]) {
       return null;
     }
     if (_inClosure && identical(node.staticElement, variable)) {
       result[0] = javaBooleanOr(result[0], true);
     }
     return null;
   }
 }
-class RecursiveASTVisitor_8 extends RecursiveASTVisitor<Object> {
+
+class RecursiveASTVisitor_9 extends RecursiveASTVisitor<Object> {
   List<bool> result;
+
   Element variable;
-  RecursiveASTVisitor_8(this.result, this.variable) : super();
+
+  RecursiveASTVisitor_9(this.result, this.variable) : super();
+
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (result[0]) {
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result[0] = javaBooleanOr(result[0], true);
       }
     }
     return null;
   }
 }
+
 /**
  * The abstract class `ScopedVisitor` maintains name and label scopes as an AST structure is
  * being visited.
  *
  * @coverage dart.engine.resolver
  */
 abstract class ScopedVisitor extends UnifyingASTVisitor<Object> {
-
   /**
    * The element for the library containing the compilation unit being visited.
    */
   LibraryElement definingLibrary;
 
   /**
    * The source representing the compilation unit being visited.
    */
   Source source;
 
@@ skipping 46 matching lines @@
    */
   ScopedVisitor.con2(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
     this.definingLibrary = definingLibrary;
     this.source = source;
     this._errorListener = errorListener;
     this.nameScope = new LibraryScope(definingLibrary, errorListener);
     this.typeProvider = typeProvider;
   }
 
   /**
+   * Initialize a newly created visitor to resolve the nodes in a compilation unit.
+   *
+   * @param definingLibrary the element for the library containing the compilation unit being
+   *          visited
+   * @param source the source representing the compilation unit being visited
+   * @param typeProvider the object used to access the types from the core library
+   * @param nameScope the scope used to resolve identifiers in the node that will first be visited
+   * @param errorListener the error listener that will be informed of any errors that are found
+   *          during resolution
+   */
+  ScopedVisitor.con3(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, Scope nameScope, AnalysisErrorListener errorListener) {
+    this.definingLibrary = definingLibrary;
+    this.source = source;
+    this._errorListener = errorListener;
+    this.nameScope = nameScope;
+    this.typeProvider = typeProvider;
+  }
+
+  /**
    * Report an error with the given analysis error.
    *
    * @param errorCode analysis error
    */
   void reportError(AnalysisError analysisError) {
     _errorListener.onError(analysisError);
   }
+
   Object visitBlock(Block node) {
     Scope outerScope = nameScope;
     try {
       EnclosedScope enclosedScope = new EnclosedScope(nameScope);
       hideNamesDefinedInBlock(enclosedScope, node);
       nameScope = enclosedScope;
       super.visitBlock(node);
     } finally {
       nameScope = outerScope;
     }
     return null;
   }
+
   Object visitCatchClause(CatchClause node) {
     SimpleIdentifier exception = node.exceptionParameter;
     if (exception != null) {
       Scope outerScope = nameScope;
       try {
         nameScope = new EnclosedScope(nameScope);
         nameScope.define(exception.staticElement);
         SimpleIdentifier stackTrace = node.stackTraceParameter;
         if (stackTrace != null) {
           nameScope.define(stackTrace.staticElement);
         }
         super.visitCatchClause(node);
       } finally {
         nameScope = outerScope;
       }
     } else {
       super.visitCatchClause(node);
     }
     return null;
   }
+
   Object visitClassDeclaration(ClassDeclaration node) {
     Scope outerScope = nameScope;
     try {
       nameScope = new ClassScope(nameScope, node.element);
       super.visitClassDeclaration(node);
     } finally {
       nameScope = outerScope;
     }
     return null;
   }
+
   Object visitClassTypeAlias(ClassTypeAlias node) {
     Scope outerScope = nameScope;
     try {
       nameScope = new ClassScope(nameScope, node.element);
       super.visitClassTypeAlias(node);
     } finally {
       nameScope = outerScope;
     }
     return null;
   }
+
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     Scope outerScope = nameScope;
     try {
       nameScope = new FunctionScope(nameScope, node.element);
       super.visitConstructorDeclaration(node);
     } finally {
       nameScope = outerScope;
     }
     return null;
   }
+
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     VariableElement element = node.element;
     if (element != null) {
       nameScope.define(element);
     }
     super.visitDeclaredIdentifier(node);
     return null;
   }
+
   Object visitDoStatement(DoStatement node) {
     LabelScope outerLabelScope = labelScope;
     try {
       labelScope = new LabelScope.con1(labelScope, false, false);
       visitStatementInScope(node.body);
       safelyVisit(node.condition);
     } finally {
       labelScope = outerLabelScope;
     }
     return null;
   }
+
   Object visitForEachStatement(ForEachStatement node) {
     Scope outerNameScope = nameScope;
     LabelScope outerLabelScope = labelScope;
     try {
       nameScope = new EnclosedScope(nameScope);
       labelScope = new LabelScope.con1(outerLabelScope, false, false);
       visitForEachStatementInScope(node);
     } finally {
       labelScope = outerLabelScope;
       nameScope = outerNameScope;
     }
     return null;
   }
+
   Object visitFormalParameterList(FormalParameterList node) {
     super.visitFormalParameterList(node);
     if (nameScope is FunctionScope) {
-      ((nameScope as FunctionScope)).defineParameters();
+      (nameScope as FunctionScope).defineParameters();
     }
     if (nameScope is FunctionTypeScope) {
-      ((nameScope as FunctionTypeScope)).defineParameters();
+      (nameScope as FunctionTypeScope).defineParameters();
     }
     return null;
   }
+
   Object visitForStatement(ForStatement node) {
     Scope outerNameScope = nameScope;
     LabelScope outerLabelScope = labelScope;
     try {
       nameScope = new EnclosedScope(nameScope);
       labelScope = new LabelScope.con1(outerLabelScope, false, false);
       visitForStatementInScope(node);
     } finally {
       labelScope = outerLabelScope;
       nameScope = outerNameScope;
     }
     return null;
   }
+
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement function = node.element;
     Scope outerScope = nameScope;
     try {
       nameScope = new FunctionScope(nameScope, function);
       super.visitFunctionDeclaration(node);
     } finally {
       nameScope = outerScope;
     }
     if (function.enclosingElement is! CompilationUnitElement) {
       nameScope.define(function);
     }
     return null;
   }
+
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is FunctionDeclaration) {
       super.visitFunctionExpression(node);
     } else {
       Scope outerScope = nameScope;
       try {
         ExecutableElement functionElement = node.element;
         if (functionElement == null) {
         } else {
           nameScope = new FunctionScope(nameScope, functionElement);
         }
         super.visitFunctionExpression(node);
       } finally {
         nameScope = outerScope;
       }
     }
     return null;
   }
+
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     Scope outerScope = nameScope;
     try {
       nameScope = new FunctionTypeScope(nameScope, node.element);
       super.visitFunctionTypeAlias(node);
     } finally {
       nameScope = outerScope;
     }
     return null;
   }
+
   Object visitIfStatement(IfStatement node) {
     safelyVisit(node.condition);
     visitStatementInScope(node.thenStatement);
     visitStatementInScope(node.elseStatement);
     return null;
   }
+
   Object visitLabeledStatement(LabeledStatement node) {
     LabelScope outerScope = addScopesFor(node.labels);
     try {
       super.visitLabeledStatement(node);
     } finally {
       labelScope = outerScope;
     }
     return null;
   }
+
   Object visitMethodDeclaration(MethodDeclaration node) {
     Scope outerScope = nameScope;
     try {
       nameScope = new FunctionScope(nameScope, node.element);
       super.visitMethodDeclaration(node);
     } finally {
       nameScope = outerScope;
     }
     return null;
   }
+
   Object visitSwitchCase(SwitchCase node) {
     node.expression.accept(this);
     Scope outerNameScope = nameScope;
     try {
       nameScope = new EnclosedScope(nameScope);
       node.statements.accept(this);
     } finally {
       nameScope = outerNameScope;
     }
     return null;
   }
+
   Object visitSwitchDefault(SwitchDefault node) {
     Scope outerNameScope = nameScope;
     try {
       nameScope = new EnclosedScope(nameScope);
       node.statements.accept(this);
     } finally {
       nameScope = outerNameScope;
     }
     return null;
   }
+
   Object visitSwitchStatement(SwitchStatement node) {
     LabelScope outerScope = labelScope;
     try {
       labelScope = new LabelScope.con1(outerScope, true, false);
       for (SwitchMember member in node.members) {
         for (Label label in member.labels) {
           SimpleIdentifier labelName = label.label;
           LabelElement labelElement = labelName.staticElement as LabelElement;
           labelScope = new LabelScope.con2(labelScope, labelName.name, labelElement);
         }
       }
       super.visitSwitchStatement(node);
     } finally {
       labelScope = outerScope;
     }
     return null;
   }
+
   Object visitVariableDeclaration(VariableDeclaration node) {
+    super.visitVariableDeclaration(node);
     if (node.parent.parent is! TopLevelVariableDeclaration && node.parent.parent is! FieldDeclaration) {
       VariableElement element = node.element;
       if (element != null) {
         nameScope.define(element);
       }
     }
-    super.visitVariableDeclaration(node);
     return null;
   }
+
   Object visitWhileStatement(WhileStatement node) {
     LabelScope outerScope = labelScope;
     try {
       labelScope = new LabelScope.con1(outerScope, false, false);
       safelyVisit(node.condition);
       visitStatementInScope(node.body);
     } finally {
       labelScope = outerScope;
     }
     return null;
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param node the node specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
-  void reportError5(ErrorCode errorCode, ASTNode node, List<Object> arguments) {
+  void reportError6(ErrorCode errorCode, ASTNode node, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(source, node.offset, node.length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param offset the offset of the location of the error
    * @param length the length of the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
-  void reportError6(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
+  void reportError7(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(source, offset, length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param token the token specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
-  void reportError7(ErrorCode errorCode, sc.Token token, List<Object> arguments) {
+  void reportError8(ErrorCode errorCode, sc.Token token, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(source, token.offset, token.length, errorCode, arguments));
   }
 
   /**
    * Visit the given AST node if it is not null.
    *
    * @param node the node to be visited
    */
   void safelyVisit(ASTNode node) {
     if (node != null) {
@@ skipping 82 matching lines @@
         }
       }
       if (statement is FunctionDeclarationStatement) {
         FunctionDeclarationStatement fds = statement as FunctionDeclarationStatement;
         Element element = fds.functionDeclaration.element;
         scope.hide(element);
       }
     }
   }
 }
+
 /**
  * Instances of the class `StaticTypeAnalyzer` perform two type-related tasks. First, they
  * compute the static type of every expression. Second, they look for any static type errors or
  * warnings that might need to be generated. The requirements for the type analyzer are:
  * <ol>
  * * Every element that refers to types should be fully populated.
  * * Every node representing an expression should be resolved to the Type of the expression.
  * </ol>
  *
  * @coverage dart.engine.resolver
  */
 class StaticTypeAnalyzer extends SimpleASTVisitor<Object> {
-
   /**
    * Create a table mapping HTML tag names to the names of the classes (in 'dart:html') that
    * implement those tags.
    *
    * @return the table that was created
    */
   static Map<String, String> createHtmlTagToClassMap() {
     Map<String, String> map = new Map<String, String>();
     map["a"] = "AnchorElement";
     map["area"] = "AreaElement";
@@ skipping 333 matching lines @@
   }
 
   /**
    * The Dart Language Specification, 12.3: <blockquote>The static type of a literal double is
    * double.</blockquote>
    */
   Object visitDoubleLiteral(DoubleLiteral node) {
     recordStaticType(node, _typeProvider.doubleType);
     return null;
   }
+
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     FunctionExpression function = node.functionExpression;
     ExecutableElementImpl functionElement = node.element as ExecutableElementImpl;
     functionElement.returnType = computeStaticReturnType2(node);
     recordPropagatedType(functionElement, function.body);
     recordStaticType(function, functionElement.type);
     return null;
   }
 
   /**
@@ skipping 409 matching lines @@
           recordPropagatedType2(node, propagatedStaticType);
         }
         Type2 propagatedPropagatedType = computePropagatedReturnType(propagatedElement);
         if (propagatedPropagatedType != null && (staticStaticType == null || propagatedPropagatedType.isMoreSpecificThan(staticStaticType)) && (staticPropagatedType == null || propagatedPropagatedType.isMoreSpecificThan(staticPropagatedType)) && (propagatedStaticType == null || propagatedPropagatedType.isMoreSpecificThan(propagatedStaticType))) {
           recordPropagatedType2(node, propagatedPropagatedType);
         }
       }
     }
     return null;
   }
+
   Object visitNamedExpression(NamedExpression node) {
     Expression expression = node.expression;
     recordStaticType(node, getStaticType(expression));
     recordPropagatedType2(node, expression.propagatedType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.2: <blockquote>The static type of `null` is bottom.
    * </blockquote>
    */
   Object visitNullLiteral(NullLiteral node) {
     recordStaticType(node, _typeProvider.bottomType);
     return null;
   }
+
   Object visitParenthesizedExpression(ParenthesizedExpression node) {
     Expression expression = node.expression;
     recordStaticType(node, getStaticType(expression));
     recordPropagatedType2(node, expression.propagatedType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.28: <blockquote>A postfix expression of the form
    * <i>v++</i>, where <i>v</i> is an identifier, is equivalent to <i>(){var r = v; v = r + 1;
@@ skipping 37 matching lines @@
 
   /**
    * See [visitSimpleIdentifier].
    */
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefixedIdentifier = node.identifier;
     Element staticElement = prefixedIdentifier.staticElement;
     Type2 staticType = _dynamicType;
     if (staticElement is ClassElement) {
       if (isNotTypeLiteral(node)) {
-        staticType = ((staticElement as ClassElement)).type;
+        staticType = (staticElement as ClassElement).type;
       } else {
         staticType = _typeProvider.typeType;
       }
     } else if (staticElement is FunctionTypeAliasElement) {
       if (isNotTypeLiteral(node)) {
-        staticType = ((staticElement as FunctionTypeAliasElement)).type;
+        staticType = (staticElement as FunctionTypeAliasElement).type;
       } else {
         staticType = _typeProvider.typeType;
       }
     } else if (staticElement is MethodElement) {
-      staticType = ((staticElement as MethodElement)).type;
+      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;
+      staticType = (staticElement as ExecutableElement).type;
     } else if (staticElement is TypeParameterElement) {
-      staticType = ((staticElement as TypeParameterElement)).type;
+      staticType = (staticElement as TypeParameterElement).type;
     } else if (staticElement is VariableElement) {
-      staticType = ((staticElement as VariableElement)).type;
+      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;
+        propagatedType = (propagatedElement as ClassElement).type;
       } else {
         propagatedType = _typeProvider.typeType;
       }
     } else if (propagatedElement is FunctionTypeAliasElement) {
-      propagatedType = ((propagatedElement as FunctionTypeAliasElement)).type;
+      propagatedType = (propagatedElement as FunctionTypeAliasElement).type;
     } else if (propagatedElement is MethodElement) {
-      propagatedType = ((propagatedElement as MethodElement)).type;
+      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;
+      propagatedType = (propagatedElement as ExecutableElement).type;
     } else if (propagatedElement is TypeParameterElement) {
-      propagatedType = ((propagatedElement as TypeParameterElement)).type;
+      propagatedType = (propagatedElement as TypeParameterElement).type;
     } else if (propagatedElement is VariableElement) {
-      propagatedType = ((propagatedElement as VariableElement)).type;
+      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);
     }
     return null;
@@ skipping 70 matching lines @@
    * ... a top-level getter invocation <i>i</i> of the form <i>m</i>, where <i>m</i> is an
    * identifier ...
    *
    * The static type of <i>i</i> is the declared return type of <i>m</i>.</blockquote>
    */
   Object visitPropertyAccess(PropertyAccess node) {
     SimpleIdentifier propertyName = node.propertyName;
     Element element = propertyName.staticElement;
     Type2 staticType = _dynamicType;
     if (element is MethodElement) {
-      staticType = ((element as MethodElement)).type;
+      staticType = (element as MethodElement).type;
     } else if (element is PropertyAccessorElement) {
       staticType = getType(element as PropertyAccessorElement, node.target != null ? getStaticType(node.target) : null);
     } else {
     }
     recordStaticType(propertyName, staticType);
     recordStaticType(node, staticType);
     Type2 propagatedType = _overrideManager.getType(element);
     if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
       recordPropagatedType2(node, propagatedType);
     }
@@ skipping 49 matching lines @@
    * to be thrown.
    * * Otherwise <i>e</i> is equivalent to the property extraction <i>this.id</i>.
    *
    * </blockquote>
    */
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     Type2 staticType = _dynamicType;
     if (element is ClassElement) {
       if (isNotTypeLiteral(node)) {
-        staticType = ((element as ClassElement)).type;
+        staticType = (element as ClassElement).type;
       } else {
         staticType = _typeProvider.typeType;
       }
     } else if (element is FunctionTypeAliasElement) {
       if (isNotTypeLiteral(node)) {
-        staticType = ((element as FunctionTypeAliasElement)).type;
+        staticType = (element as FunctionTypeAliasElement).type;
       } else {
         staticType = _typeProvider.typeType;
       }
     } else if (element is MethodElement) {
-      staticType = ((element as MethodElement)).type;
+      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;
+      staticType = (element as ExecutableElement).type;
     } else if (element is TypeParameterElement) {
-      staticType = ((element as TypeParameterElement)).type;
+      staticType = (element as TypeParameterElement).type;
     } else if (element is VariableElement) {
       VariableElement variable = element as VariableElement;
       staticType = _promoteManager.getStaticType(variable);
     } else if (element is PrefixElement) {
       return null;
     } else {
       staticType = _dynamicType;
     }
     recordStaticType(node, staticType);
     Type2 propagatedType = _overrideManager.getType(element);
@@ skipping 13 matching lines @@
   }
 
   /**
    * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is
    * `String`.</blockquote>
    */
   Object visitStringInterpolation(StringInterpolation node) {
     recordStaticType(node, _typeProvider.stringType);
     return null;
   }
+
   Object visitSuperExpression(SuperExpression node) {
     if (_thisType == null) {
       recordStaticType(node, _dynamicType);
     } else {
       recordStaticType(node, _thisType);
     }
     return null;
   }
+
   Object visitSymbolLiteral(SymbolLiteral node) {
     recordStaticType(node, _typeProvider.symbolType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.10: <blockquote>The static type of `this` is the
    * interface of the immediately enclosing class.</blockquote>
    */
   Object visitThisExpression(ThisExpression node) {
     if (_thisType == null) {
       recordStaticType(node, _dynamicType);
     } else {
       recordStaticType(node, _thisType);
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.8: <blockquote>The static type of a throw expression is
    * bottom.</blockquote>
    */
   Object visitThrowExpression(ThrowExpression node) {
     recordStaticType(node, _typeProvider.bottomType);
     return null;
   }
+
   Object visitVariableDeclaration(VariableDeclaration node) {
     Expression initializer = node.initializer;
     if (initializer != null) {
       Type2 rightType = initializer.bestType;
       SimpleIdentifier name = node.name;
       recordPropagatedType2(name, rightType);
       VariableElement element = name.staticElement as VariableElement;
       if (element != null) {
         _resolver.override2(element, rightType);
       }
@@ skipping 38 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_9(result));
+      body.accept(new GeneralizingASTVisitor_10(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
    */
   Type2 computeStaticReturnType(Element element) {
     if (element is PropertyAccessorElement) {
-      FunctionType propertyType = ((element as PropertyAccessorElement)).type;
+      FunctionType propertyType = (element as PropertyAccessorElement).type;
       if (propertyType != null) {
         Type2 returnType = propertyType.returnType;
         if (returnType.isDartCoreFunction) {
           return _dynamicType;
         } else if (returnType is InterfaceType) {
-          MethodElement callMethod = ((returnType as InterfaceType)).lookUpMethod(ElementResolver.CALL_METHOD_NAME, _resolver.definingLibrary);
+          MethodElement callMethod = (returnType as InterfaceType).lookUpMethod(ElementResolver.CALL_METHOD_NAME, _resolver.definingLibrary);
           if (callMethod != null) {
             return callMethod.type.returnType;
           }
         } else if (returnType is FunctionType) {
-          Type2 innerReturnType = ((returnType as FunctionType)).returnType;
+          Type2 innerReturnType = (returnType as FunctionType).returnType;
           if (innerReturnType != null) {
             return innerReturnType;
           }
         }
         if (returnType != null) {
           return returnType;
         }
       }
     } else if (element is ExecutableElement) {
-      FunctionType type = ((element as ExecutableElement)).type;
+      FunctionType type = (element as ExecutableElement).type;
       if (type != null) {
         return type.returnType;
       }
     } else if (element is VariableElement) {
       VariableElement variable = element as VariableElement;
       Type2 variableType = _promoteManager.getStaticType(variable);
       if (variableType is FunctionType) {
-        return ((variableType as FunctionType)).returnType;
+        return (variableType as FunctionType).returnType;
       }
     }
     return _dynamicType;
   }
 
   /**
    * Given a function declaration, compute the return static type of the function. The return type
    * of functions with a block body is `dynamicType`, with an expression body it is the type
    * of the expression.
    *
@@ skipping 12 matching lines @@
    * Given a function expression, compute the return type of the function. The return type of
    * functions with a block body is `dynamicType`, with an expression body it is the type of
    * the expression.
    *
    * @param node the function expression whose return type is to be computed
    * @return the return type that was computed
    */
   Type2 computeStaticReturnType3(FunctionExpression node) {
     FunctionBody body = node.body;
     if (body is ExpressionFunctionBody) {
-      return getStaticType(((body as ExpressionFunctionBody)).expression);
+      return getStaticType((body as ExpressionFunctionBody).expression);
     }
     return _dynamicType;
   }
 
   /**
    * If the given element name can be mapped to the name of a class defined within the given
    * library, return the type specified by the argument.
    *
    * @param library the library in which the specified type would be defined
    * @param elementName the name of the element for which a type is being sought
@@ skipping 47 matching lines @@
    * string literal, return the String value of the argument.
    *
    * @param argumentList the list of arguments from which a string value is to be extracted
    * @return the string specified by the first argument in the argument list
    */
   String getFirstArgumentAsString(ArgumentList argumentList) {
     NodeList<Expression> arguments = argumentList.arguments;
     if (arguments.length > 0) {
       Expression argument = arguments[0];
       if (argument is SimpleStringLiteral) {
-        return ((argument as SimpleStringLiteral)).value;
+        return (argument as SimpleStringLiteral).value;
       }
     }
     return null;
   }
 
   /**
    * If the given argument list contains at least one argument, and if the argument is a simple
    * string literal, and if the value of the argument is the name of a class defined within the
    * given library, return the type specified by the argument.
    *
@@ skipping 111 matching lines @@
   bool isHtmlLibrary(LibraryElement library) => library != null && "dart.dom.html" == library.name;
 
   /**
    * Return `true` if the given node is not a type literal.
    *
    * @param node the node being tested
    * @return `true` if the given node is not a type literal
    */
   bool isNotTypeLiteral(Identifier node) {
     ASTNode parent = node.parent;
-    return parent is TypeName || (parent is PrefixedIdentifier && (parent.parent is TypeName || identical(((parent as PrefixedIdentifier)).prefix, node))) || (parent is PropertyAccess && identical(((parent as PropertyAccess)).target, node)) || (parent is MethodInvocation && identical(node, ((parent as MethodInvocation)).target));
+    return parent is TypeName || (parent is PrefixedIdentifier && (parent.parent is TypeName || identical((parent as PrefixedIdentifier).prefix, node))) || (parent is PropertyAccess && identical((parent as PropertyAccess).target, node)) || (parent is MethodInvocation && identical(node, (parent as MethodInvocation).target));
   }
 
   /**
    * Given a function element and its body, compute and record the propagated return type of the
    * function.
    *
    * @param functionElement the function element to record propagated return type for
    * @param body the boy of the function whose propagated return type is to be computed
    * @return the propagated return type that was computed, may be `null` if it is not more
    *         specific than the static return type.
@@ skipping 60 matching lines @@
         }
       }
       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_9 extends GeneralizingASTVisitor<Object> {
+
+class GeneralizingASTVisitor_10 extends GeneralizingASTVisitor<Object> {
   List<Type2> result;
-  GeneralizingASTVisitor_9(this.result) : super();
+
+  GeneralizingASTVisitor_10(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) {
       result[0] = type;
     } else {
       result[0] = result[0].getLeastUpperBound(type);
     }
     return null;
   }
 }
+
 /**
  * Instances of this class manage the knowledge of what the set of subtypes are for a given type.
  */
 class SubtypeManager {
-
   /**
    * A map between [ClassElement]s and a set of [ClassElement]s that are subtypes of the
    * key.
    */
   Map<ClassElement, Set<ClassElement>> _subtypeMap = new Map<ClassElement, Set<ClassElement>>();
 
   /**
    * The set of all [LibraryElement]s that have been visited by the manager. This is used both
    * to prevent infinite loops in the recursive methods, and also as a marker for the scope of the
    * libraries visited by this manager.
@@ skipping 124 matching lines @@
    */
   void putInSubtypeMap(ClassElement supertypeElement, ClassElement subtypeElement) {
     Set<ClassElement> subtypes = _subtypeMap[supertypeElement];
     if (subtypes == null) {
       subtypes = new Set<ClassElement>();
       _subtypeMap[supertypeElement] = subtypes;
     }
     javaSetAdd(subtypes, subtypeElement);
   }
 }
+
 /**
  * Instances of the class `TypeOverrideManager` manage the ability to override the type of an
  * element within a given context.
  */
 class TypeOverrideManager {
-
   /**
    * The current override scope, or `null` if no scope has been entered.
    */
   TypeOverrideManager_TypeOverrideScope _currentScope;
 
   /**
    * Apply a set of overrides that were previously captured.
    *
    * @param overrides the overrides to be applied
    */
@@ skipping 68 matching lines @@
    * @param element the element whose type might have been overridden
    * @param type the overridden type of the given element
    */
   void setType(Element element, Type2 type) {
     if (_currentScope == null) {
       throw new IllegalStateException("Cannot override without a scope");
     }
     _currentScope.setType(element, type);
   }
 }
+
 /**
  * Instances of the class `TypeOverrideScope` represent a scope in which the types of
  * elements can be overridden.
  */
 class TypeOverrideManager_TypeOverrideScope {
-
   /**
    * The outer scope in which types might be overridden.
    */
   TypeOverrideManager_TypeOverrideScope _outerScope;
 
   /**
    * A table mapping elements to the overridden type of that element.
    */
   Map<Element, Type2> _overridenTypes = new Map<Element, Type2>();
 
@@ skipping 51 matching lines @@
   /**
    * Return the overridden type of the given element, or `null` if the type of the element
    * has not been overridden.
    *
    * @param element the element whose type might have been overridden
    * @return the overridden type of the given element
    */
   Type2 getType(Element element) {
     Type2 type = _overridenTypes[element];
     if (type == null && element is PropertyAccessorElement) {
-      type = _overridenTypes[((element as PropertyAccessorElement)).variable];
+      type = _overridenTypes[(element as PropertyAccessorElement).variable];
     }
     if (type != null) {
       return type;
     } else if (_outerScope != null) {
       return _outerScope.getType(element);
     }
     return null;
   }
 
   /**
    * Set the overridden type of the given element to the given type
    *
    * @param element the element whose type might have been overridden
    * @param type the overridden type of the given element
    */
   void setType(Element element, Type2 type) {
     _overridenTypes[element] = type;
   }
 }
+
 /**
  * Instances of the class `TypePromotionManager` manage the ability to promote types of local
  * variables and formal parameters from their declared types based on control flow.
  */
 class TypePromotionManager {
-
   /**
    * The current promotion scope, or `null` if no scope has been entered.
    */
   TypePromotionManager_TypePromoteScope _currentScope;
 
   /**
    * Enter a new promotions scope.
    */
   void enterScope() {
     _currentScope = new TypePromotionManager_TypePromoteScope(_currentScope);
@@ skipping 47 matching lines @@
    * @param element the element whose type might have been promoted
    * @param type the promoted type of the given element
    */
   void setType(Element element, Type2 type) {
     if (_currentScope == null) {
       throw new IllegalStateException("Cannot promote without a scope");
     }
     _currentScope.setType(element, type);
   }
 }
+
 /**
  * Instances of the class `TypePromoteScope` represent a scope in which the types of
  * elements can be promoted.
  */
 class TypePromotionManager_TypePromoteScope {
-
   /**
    * The outer scope in which types might be promoter.
    */
   TypePromotionManager_TypePromoteScope _outerScope;
 
   /**
    * A table mapping elements to the promoted type of that element.
    */
   Map<Element, Type2> _promotedTypes = new Map<Element, Type2>();
 
@@ skipping 14 matching lines @@
   /**
    * Return the promoted type of the given element, or `null` if the type of the element has
    * not been promoted.
    *
    * @param element the element whose type might have been promoted
    * @return the promoted type of the given element
    */
   Type2 getType(Element element) {
     Type2 type = _promotedTypes[element];
     if (type == null && element is PropertyAccessorElement) {
-      type = _promotedTypes[((element as PropertyAccessorElement)).variable];
+      type = _promotedTypes[(element as PropertyAccessorElement).variable];
     }
     if (type != null) {
       return type;
     } else if (_outerScope != null) {
       return _outerScope.getType(element);
     }
     return null;
   }
 
   /**
    * Set the promoted type of the given element to the given type.
    *
    * @param element the element whose type might have been promoted
    * @param type the promoted type of the given element
    */
   void setType(Element element, Type2 type) {
     _promotedTypes[element] = type;
   }
 }
+
 /**
  * The interface `TypeProvider` defines the behavior of objects that provide access to types
  * defined by the language.
  *
  * @coverage dart.engine.resolver
  */
 abstract class TypeProvider {
-
-  /**
-   * Return the type representing the built-in type 'Null'.
-   *
-   * @return the type representing the built-in type 'null'
-   */
-  InterfaceType get nullType;
-
   /**
    * Return the type representing the built-in type 'bool'.
    *
    * @return the type representing the built-in type 'bool'
    */
   InterfaceType get boolType;
 
   /**
    * Return the type representing the type 'bottom'.
    *
    * @return the type representing the type 'bottom'
    */
   Type2 get bottomType;
 
   /**
+   * Return the type representing the built-in type 'Deprecated'.
+   *
+   * @return the type representing the built-in type 'Deprecated'
+   */
+  InterfaceType get deprecatedType;
+
+  /**
    * Return the type representing the built-in type 'double'.
    *
    * @return the type representing the built-in type 'double'
    */
   InterfaceType get doubleType;
 
   /**
    * Return the type representing the built-in type 'dynamic'.
    *
    * @return the type representing the built-in type 'dynamic'
@@ skipping 22 matching lines @@
   InterfaceType get listType;
 
   /**
    * Return the type representing the built-in type 'Map'.
    *
    * @return the type representing the built-in type 'Map'
    */
   InterfaceType get mapType;
 
   /**
+   * Return the type representing the built-in type 'Null'.
+   *
+   * @return the type representing the built-in type 'null'
+   */
+  InterfaceType get nullType;
+
+  /**
    * Return the type representing the built-in type 'num'.
    *
    * @return the type representing the built-in type 'num'
    */
   InterfaceType get numType;
 
   /**
    * Return the type representing the built-in type 'Object'.
    *
    * @return the type representing the built-in type 'Object'
@@ skipping 21 matching lines @@
    */
   InterfaceType get symbolType;
 
   /**
    * Return the type representing the built-in type 'Type'.
    *
    * @return the type representing the built-in type 'Type'
    */
   InterfaceType get typeType;
 }
+
 /**
  * Instances of the class `TypeProviderImpl` provide access to types defined by the language
  * by looking for those types in the element model for the core library.
  *
  * @coverage dart.engine.resolver
  */
 class TypeProviderImpl implements TypeProvider {
-
   /**
    * The type representing the built-in type 'bool'.
    */
   InterfaceType _boolType;
 
   /**
    * The type representing the type 'bottom'.
    */
   Type2 _bottomType;
 
   /**
    * The type representing the built-in type 'double'.
    */
   InterfaceType _doubleType;
 
   /**
+   * The type representing the built-in type 'Deprecated'.
+   */
+  InterfaceType _deprecatedType;
+
+  /**
    * The type representing the built-in type 'dynamic'.
    */
   Type2 _dynamicType;
 
   /**
    * The type representing the built-in type 'Function'.
    */
   InterfaceType _functionType;
 
   /**
@@ skipping 47 matching lines @@
   InterfaceType _typeType;
 
   /**
    * Initialize a newly created type provider to provide the types defined in the given library.
    *
    * @param coreLibrary the element representing the core library (dart:core).
    */
   TypeProviderImpl(LibraryElement coreLibrary) {
     initializeFrom(coreLibrary);
   }
+
   InterfaceType get boolType => _boolType;
+
   Type2 get bottomType => _bottomType;
+
+  InterfaceType get deprecatedType => _deprecatedType;
+
   InterfaceType get doubleType => _doubleType;
+
   Type2 get dynamicType => _dynamicType;
+
   InterfaceType get functionType => _functionType;
+
   InterfaceType get intType => _intType;
+
   InterfaceType get listType => _listType;
+
   InterfaceType get mapType => _mapType;
+
   InterfaceType get nullType => _nullType;
+
   InterfaceType get numType => _numType;
+
   InterfaceType get objectType => _objectType;
+
   InterfaceType get stackTraceType => _stackTraceType;
+
   InterfaceType get stringType => _stringType;
+
   InterfaceType get symbolType => _symbolType;
+
   InterfaceType get typeType => _typeType;
 
   /**
    * Return the type with the given name from the given namespace, or `null` if there is no
    * class with the given name.
    *
    * @param namespace the namespace in which to search for the given name
    * @param typeName the name of the type being searched for
    * @return the type that was found
    */
   InterfaceType getType(Namespace namespace, String typeName) {
     Element element = namespace.get(typeName);
     if (element == null) {
       AnalysisEngine.instance.logger.logInformation("No definition of type ${typeName}");
       return null;
     }
-    return ((element as ClassElement)).type;
+    return (element as ClassElement).type;
   }
 
   /**
    * Initialize the types provided by this type provider from the given library.
    *
    * @param library the library containing the definitions of the core types
    */
   void initializeFrom(LibraryElement library) {
     Namespace namespace = new NamespaceBuilder().createPublicNamespace(library);
     _boolType = getType(namespace, "bool");
     _bottomType = BottomTypeImpl.instance;
+    _deprecatedType = getType(namespace, "Deprecated");
     _doubleType = getType(namespace, "double");
     _dynamicType = DynamicTypeImpl.instance;
     _functionType = getType(namespace, "Function");
     _intType = getType(namespace, "int");
     _listType = getType(namespace, "List");
     _mapType = getType(namespace, "Map");
     _nullType = getType(namespace, "Null");
     _numType = getType(namespace, "num");
     _objectType = getType(namespace, "Object");
     _stackTraceType = getType(namespace, "StackTrace");
     _stringType = getType(namespace, "String");
     _symbolType = getType(namespace, "Symbol");
     _typeType = getType(namespace, "Type");
   }
 }
+
 /**
  * Instances of the class `TypeResolverVisitor` are used to resolve the types associated with
  * the elements in the element model. This includes the types of superclasses, mixins, interfaces,
  * fields, methods, parameters, and local variables. As a side-effect, this also finishes building
  * the type hierarchy.
  *
  * @coverage dart.engine.resolver
  */
 class TypeResolverVisitor extends ScopedVisitor {
-
   /**
    * @return `true` if the name of the given [TypeName] is an built-in identifier.
    */
   static bool isBuiltInIdentifier(TypeName node) {
     sc.Token token = node.name.beginToken;
     return identical(token.type, sc.TokenType.KEYWORD);
   }
 
   /**
    * @return `true` if given [TypeName] is used as a type annotation.
    */
   static bool isTypeAnnotation(TypeName node) {
     ASTNode parent = node.parent;
     if (parent is VariableDeclarationList) {
-      return identical(((parent as VariableDeclarationList)).type, node);
+      return identical((parent as VariableDeclarationList).type, node);
     }
     if (parent is FieldFormalParameter) {
-      return identical(((parent as FieldFormalParameter)).type, node);
+      return identical((parent as FieldFormalParameter).type, node);
     }
     if (parent is SimpleFormalParameter) {
-      return identical(((parent as SimpleFormalParameter)).type, node);
+      return identical((parent as SimpleFormalParameter).type, node);
     }
     return false;
   }
 
   /**
    * The type representing the type 'dynamic'.
    */
   Type2 _dynamicType;
 
   /**
@@ skipping 18 matching lines @@
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
   TypeResolverVisitor.con2(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) : super.con2(definingLibrary, source, typeProvider, errorListener) {
     _dynamicType = typeProvider.dynamicType;
   }
+
+  /**
+   * Initialize a newly created visitor to resolve the nodes in an AST node.
+   *
+   * @param definingLibrary the element for the library containing the node being visited
+   * @param source the source representing the compilation unit containing the node being visited
+   * @param typeProvider the object used to access the types from the core library
+   * @param nameScope the scope used to resolve identifiers in the node that will first be visited
+   * @param errorListener the error listener that will be informed of any errors that are found
+   *          during resolution
+   */
+  TypeResolverVisitor.con3(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, Scope nameScope, AnalysisErrorListener errorListener) : super.con3(definingLibrary, source, typeProvider, nameScope, errorListener) {
+    _dynamicType = typeProvider.dynamicType;
+  }
+
   Object visitCatchClause(CatchClause node) {
     super.visitCatchClause(node);
     SimpleIdentifier exception = node.exceptionParameter;
     if (exception != null) {
       TypeName exceptionTypeName = node.exceptionType;
       Type2 exceptionType;
       if (exceptionTypeName == null) {
         exceptionType = typeProvider.dynamicType;
       } else {
         exceptionType = getType3(exceptionTypeName);
       }
       recordType(exception, exceptionType);
       Element element = exception.staticElement;
       if (element is VariableElementImpl) {
-        ((element as VariableElementImpl)).type = exceptionType;
+        (element as VariableElementImpl).type = exceptionType;
       } else {
       }
     }
     SimpleIdentifier stackTrace = node.stackTraceParameter;
     if (stackTrace != null) {
       recordType(stackTrace, typeProvider.stackTraceType);
     }
     return null;
   }
+
   Object visitClassDeclaration(ClassDeclaration node) {
     _hasReferenceToSuper = false;
     super.visitClassDeclaration(node);
     ClassElementImpl classElement = getClassElement(node.name);
     InterfaceType superclassType = null;
     ExtendsClause extendsClause = node.extendsClause;
     if (extendsClause != null) {
       ErrorCode errorCode = (node.withClause == null ? CompileTimeErrorCode.EXTENDS_NON_CLASS : CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS) as ErrorCode;
       superclassType = resolveType(extendsClause.superclass, errorCode, errorCode);
       if (superclassType != typeProvider.objectType) {
         classElement.validMixin = false;
       }
     }
     if (classElement != null) {
       if (superclassType == null) {
         InterfaceType objectType = typeProvider.objectType;
         if (classElement.type != objectType) {
           superclassType = objectType;
         }
       }
       classElement.supertype = superclassType;
       classElement.hasReferenceToSuper2 = _hasReferenceToSuper;
     }
     resolve(classElement, node.withClause, node.implementsClause);
     return null;
   }
+
   Object visitClassTypeAlias(ClassTypeAlias node) {
     super.visitClassTypeAlias(node);
     ClassElementImpl classElement = getClassElement(node.name);
     ErrorCode errorCode = CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS;
     InterfaceType superclassType = resolveType(node.superclass, errorCode, errorCode);
     if (superclassType == null) {
       superclassType = typeProvider.objectType;
     }
     if (classElement != null && superclassType != null) {
       classElement.supertype = superclassType;
     }
     resolve(classElement, node.withClause, node.implementsClause);
     return null;
   }
+
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     super.visitConstructorDeclaration(node);
     ExecutableElementImpl element = node.element as ExecutableElementImpl;
     ClassElement definingClass = element.enclosingElement as ClassElement;
     element.returnType = definingClass.type;
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
     type.typeArguments = definingClass.type.typeArguments;
     element.type = type;
     return null;
   }
+
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     super.visitDeclaredIdentifier(node);
     Type2 declaredType;
     TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = getType3(typeName);
     }
     LocalVariableElementImpl element = node.element as LocalVariableElementImpl;
     element.type = declaredType;
     return null;
   }
+
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     super.visitDefaultFormalParameter(node);
     return null;
   }
+
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     super.visitFieldFormalParameter(node);
     Element element = node.identifier.staticElement;
     if (element is ParameterElementImpl) {
       ParameterElementImpl parameter = element as ParameterElementImpl;
       FormalParameterList parameterList = node.parameters;
       if (parameterList == null) {
         Type2 type;
         TypeName typeName = node.type;
         if (typeName == null) {
           type = _dynamicType;
         } else {
           type = getType3(typeName);
         }
         parameter.type = type;
       } else {
         setFunctionTypedParameterType(parameter, node.type, node.parameters);
       }
     } else {
     }
     return null;
   }
+
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     super.visitFunctionDeclaration(node);
     ExecutableElementImpl element = node.element as ExecutableElementImpl;
     element.returnType = computeReturnType(node.returnType);
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
     ClassElement definingClass = element.getAncestor(ClassElement);
     if (definingClass != null) {
       type.typeArguments = definingClass.type.typeArguments;
     }
     element.type = type;
     return null;
   }
+
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     super.visitFunctionTypeAlias(node);
     FunctionTypeAliasElementImpl element = node.element as FunctionTypeAliasElementImpl;
     element.returnType = computeReturnType(node.returnType);
     return null;
   }
+
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     super.visitFunctionTypedFormalParameter(node);
     Element element = node.identifier.staticElement;
     if (element is ParameterElementImpl) {
       setFunctionTypedParameterType(element as ParameterElementImpl, node.returnType, node.parameters);
     } else {
     }
     return null;
   }
+
   Object visitMethodDeclaration(MethodDeclaration node) {
     super.visitMethodDeclaration(node);
     ExecutableElementImpl element = node.element as ExecutableElementImpl;
     element.returnType = computeReturnType(node.returnType);
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
     ClassElement definingClass = element.getAncestor(ClassElement);
     if (definingClass != null) {
       type.typeArguments = definingClass.type.typeArguments;
     }
     element.type = type;
     if (element is PropertyAccessorElement) {
       PropertyAccessorElement accessor = element as PropertyAccessorElement;
       PropertyInducingElementImpl variable = accessor.variable as PropertyInducingElementImpl;
       if (accessor.isGetter) {
         variable.type = type.returnType;
       } else if (variable.type == null) {
         List<Type2> parameterTypes = type.normalParameterTypes;
         if (parameterTypes != null && parameterTypes.length > 0) {
           variable.type = parameterTypes[0];
         }
       }
     }
     return null;
   }
+
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     super.visitSimpleFormalParameter(node);
     Type2 declaredType;
     TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = getType3(typeName);
     }
     Element element = node.identifier.staticElement;
     if (element is ParameterElement) {
-      ((element as ParameterElementImpl)).type = declaredType;
+      (element as ParameterElementImpl).type = declaredType;
     } else {
     }
     return null;
   }
+
   Object visitSuperExpression(SuperExpression node) {
     _hasReferenceToSuper = true;
     return super.visitSuperExpression(node);
   }
+
   Object visitTypeName(TypeName node) {
     super.visitTypeName(node);
     Identifier typeName = node.name;
     TypeArgumentList argumentList = node.typeArguments;
     Element element = nameScope.lookup(typeName, definingLibrary);
     if (element == null) {
       if (typeName.name == this._dynamicType.name) {
         setElement(typeName, this._dynamicType.element);
         if (argumentList != null) {
         }
@@ skipping 10 matching lines @@
         return null;
       }
       ASTNode parent = node.parent;
       if (typeName is PrefixedIdentifier && parent is ConstructorName && argumentList == null) {
         ConstructorName name = parent as ConstructorName;
         if (name.name == null) {
           PrefixedIdentifier prefixedIdentifier = typeName as PrefixedIdentifier;
           SimpleIdentifier prefix = prefixedIdentifier.prefix;
           element = nameScope.lookup(prefix, definingLibrary);
           if (element is PrefixElement) {
-            if (parent.parent is InstanceCreationExpression && ((parent.parent as InstanceCreationExpression)).isConst) {
-              reportError5(CompileTimeErrorCode.CONST_WITH_NON_TYPE, prefixedIdentifier.identifier, [prefixedIdentifier.identifier.name]);
+            if (parent.parent is InstanceCreationExpression && (parent.parent as InstanceCreationExpression).isConst) {
+              reportError6(CompileTimeErrorCode.CONST_WITH_NON_TYPE, prefixedIdentifier.identifier, [prefixedIdentifier.identifier.name]);
             } else {
-              reportError5(StaticWarningCode.NEW_WITH_NON_TYPE, prefixedIdentifier.identifier, [prefixedIdentifier.identifier.name]);
+              reportError6(StaticWarningCode.NEW_WITH_NON_TYPE, prefixedIdentifier.identifier, [prefixedIdentifier.identifier.name]);
             }
             setElement(prefix, element);
             return null;
           } else if (element != null) {
             name.name = prefixedIdentifier.identifier;
             name.period = prefixedIdentifier.period;
             node.name = prefix;
             typeName = prefix;
           }
         }
       }
     }
     bool elementValid = element is! MultiplyDefinedElement;
     if (elementValid && element is! ClassElement && isTypeNameInInstanceCreationExpression(node)) {
       SimpleIdentifier typeNameSimple = getTypeSimpleIdentifier(typeName);
       InstanceCreationExpression creation = node.parent.parent as InstanceCreationExpression;
       if (creation.isConst) {
         if (element == null) {
-          reportError5(CompileTimeErrorCode.UNDEFINED_CLASS, typeNameSimple, [typeName]);
+          reportError6(CompileTimeErrorCode.UNDEFINED_CLASS, typeNameSimple, [typeName]);
         } else {
-          reportError5(CompileTimeErrorCode.CONST_WITH_NON_TYPE, typeNameSimple, [typeName]);
+          reportError6(CompileTimeErrorCode.CONST_WITH_NON_TYPE, typeNameSimple, [typeName]);
         }
         elementValid = false;
       } else {
         if (element != null) {
-          reportError5(StaticWarningCode.NEW_WITH_NON_TYPE, typeNameSimple, [typeName]);
+          reportError6(StaticWarningCode.NEW_WITH_NON_TYPE, typeNameSimple, [typeName]);
           elementValid = false;
         }
       }
     }
     if (elementValid && element == null) {
       SimpleIdentifier typeNameSimple = getTypeSimpleIdentifier(typeName);
       RedirectingConstructorKind redirectingConstructorKind;
       if (isBuiltInIdentifier(node) && isTypeAnnotation(node)) {
-        reportError5(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, typeName, [typeName.name]);
+        reportError6(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, typeName, [typeName.name]);
       } else if (typeNameSimple.name == "boolean") {
-        reportError5(StaticWarningCode.UNDEFINED_CLASS_BOOLEAN, typeNameSimple, []);
+        reportError6(StaticWarningCode.UNDEFINED_CLASS_BOOLEAN, typeNameSimple, []);
       } else if (isTypeNameInCatchClause(node)) {
-        reportError5(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName, [typeName.name]);
+        reportError6(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName, [typeName.name]);
       } else if (isTypeNameInAsExpression(node)) {
-        reportError5(StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
+        reportError6(StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
       } else if (isTypeNameInIsExpression(node)) {
-        reportError5(StaticWarningCode.TYPE_TEST_NON_TYPE, typeName, [typeName.name]);
+        reportError6(StaticWarningCode.TYPE_TEST_NON_TYPE, typeName, [typeName.name]);
       } else if ((redirectingConstructorKind = getRedirectingConstructorKind(node)) != null) {
         ErrorCode errorCode = (identical(redirectingConstructorKind, RedirectingConstructorKind.CONST) ? CompileTimeErrorCode.REDIRECT_TO_NON_CLASS : StaticWarningCode.REDIRECT_TO_NON_CLASS) as ErrorCode;
-        reportError5(errorCode, typeName, [typeName.name]);
+        reportError6(errorCode, typeName, [typeName.name]);
       } else if (isTypeNameInTypeArgumentList(node)) {
-        reportError5(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT, typeName, [typeName.name]);
+        reportError6(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT, typeName, [typeName.name]);
       } else {
-        reportError5(StaticWarningCode.UNDEFINED_CLASS, typeName, [typeName.name]);
+        reportError6(StaticWarningCode.UNDEFINED_CLASS, typeName, [typeName.name]);
       }
       elementValid = false;
     }
     if (!elementValid) {
       if (element is MultiplyDefinedElement) {
         setElement(typeName, element);
       } else {
         setElement(typeName, this._dynamicType.element);
       }
       typeName.staticType = this._dynamicType;
       node.type = this._dynamicType;
       return null;
     }
     Type2 type = null;
     if (element is ClassElement) {
       setElement(typeName, element);
-      type = ((element as ClassElement)).type;
+      type = (element as ClassElement).type;
     } else if (element is FunctionTypeAliasElement) {
       setElement(typeName, element);
-      type = ((element as FunctionTypeAliasElement)).type;
+      type = (element as FunctionTypeAliasElement).type;
     } else if (element is TypeParameterElement) {
       setElement(typeName, element);
-      type = ((element as TypeParameterElement)).type;
+      type = (element as TypeParameterElement).type;
       if (argumentList != null) {
       }
     } else if (element is MultiplyDefinedElement) {
-      List<Element> elements = ((element as MultiplyDefinedElement)).conflictingElements;
+      List<Element> elements = (element as MultiplyDefinedElement).conflictingElements;
       type = getType(elements);
       if (type != null) {
         node.type = type;
       }
     } else {
       RedirectingConstructorKind redirectingConstructorKind;
       if (isTypeNameInCatchClause(node)) {
-        reportError5(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName, [typeName.name]);
+        reportError6(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName, [typeName.name]);
       } else if (isTypeNameInAsExpression(node)) {
-        reportError5(StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
+        reportError6(StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
       } else if (isTypeNameInIsExpression(node)) {
-        reportError5(StaticWarningCode.TYPE_TEST_NON_TYPE, typeName, [typeName.name]);
+        reportError6(StaticWarningCode.TYPE_TEST_NON_TYPE, typeName, [typeName.name]);
       } else if ((redirectingConstructorKind = getRedirectingConstructorKind(node)) != null) {
         ErrorCode errorCode = (identical(redirectingConstructorKind, RedirectingConstructorKind.CONST) ? CompileTimeErrorCode.REDIRECT_TO_NON_CLASS : StaticWarningCode.REDIRECT_TO_NON_CLASS) as ErrorCode;
-        reportError5(errorCode, typeName, [typeName.name]);
+        reportError6(errorCode, typeName, [typeName.name]);
       } else if (isTypeNameInTypeArgumentList(node)) {
-        reportError5(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT, typeName, [typeName.name]);
+        reportError6(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT, typeName, [typeName.name]);
       } else {
         ASTNode parent = typeName.parent;
         while (parent is TypeName) {
           parent = parent.parent;
         }
         if (parent is ExtendsClause || parent is ImplementsClause || parent is WithClause || parent is ClassTypeAlias) {
         } else {
-          reportError5(StaticWarningCode.NOT_A_TYPE, typeName, [typeName.name]);
+          reportError6(StaticWarningCode.NOT_A_TYPE, typeName, [typeName.name]);
         }
       }
       setElement(typeName, this._dynamicType.element);
       typeName.staticType = this._dynamicType;
       node.type = this._dynamicType;
       return null;
     }
     if (argumentList != null) {
       NodeList<TypeName> arguments = argumentList.arguments;
       int argumentCount = arguments.length;
       List<Type2> parameters = getTypeArguments(type);
       int parameterCount = parameters.length;
       int count = Math.min(argumentCount, parameterCount);
       List<Type2> typeArguments = new List<Type2>();
       for (int i = 0; i < count; i++) {
         Type2 argumentType = getType3(arguments[i]);
         if (argumentType != null) {
           typeArguments.add(argumentType);
         }
       }
       if (argumentCount != parameterCount) {
-        reportError5(getInvalidTypeParametersErrorCode(node), node, [typeName.name, parameterCount, argumentCount]);
+        reportError6(getInvalidTypeParametersErrorCode(node), node, [typeName.name, parameterCount, argumentCount]);
       }
       argumentCount = typeArguments.length;
       if (argumentCount < parameterCount) {
         for (int i = argumentCount; i < parameterCount; i++) {
           typeArguments.add(this._dynamicType);
         }
       }
       if (type is InterfaceTypeImpl) {
         InterfaceTypeImpl interfaceType = type as InterfaceTypeImpl;
         type = interfaceType.substitute4(new List.from(typeArguments));
@@ skipping 11 matching lines @@
         for (int i = 0; i < parameterCount; i++) {
           arguments[i] = dynamicType;
         }
         type = type.substitute2(arguments, parameters);
       }
     }
     typeName.staticType = type;
     node.type = type;
     return null;
   }
+
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     Type2 declaredType;
-    TypeName typeName = ((node.parent as VariableDeclarationList)).type;
+    TypeName typeName = (node.parent as VariableDeclarationList).type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = getType3(typeName);
     }
     Element element = node.name.staticElement;
     if (element is VariableElement) {
-      ((element as VariableElementImpl)).type = declaredType;
+      (element as VariableElementImpl).type = declaredType;
       if (element is PropertyInducingElement) {
         PropertyInducingElement variableElement = element as PropertyInducingElement;
         PropertyAccessorElementImpl getter = variableElement.getter as PropertyAccessorElementImpl;
         getter.returnType = declaredType;
         FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter);
         ClassElement definingClass = element.getAncestor(ClassElement);
         if (definingClass != null) {
           getterType.typeArguments = definingClass.type.typeArguments;
         }
         getter.type = getterType;
         PropertyAccessorElementImpl setter = variableElement.setter as PropertyAccessorElementImpl;
         if (setter != null) {
           List<ParameterElement> parameters = setter.parameters;
           if (parameters.length > 0) {
-            ((parameters[0] as ParameterElementImpl)).type = declaredType;
+            (parameters[0] as ParameterElementImpl).type = declaredType;
           }
           setter.returnType = VoidTypeImpl.instance;
           FunctionTypeImpl setterType = new FunctionTypeImpl.con1(setter);
           if (definingClass != null) {
             setterType.typeArguments = definingClass.type.typeArguments;
           }
           setter.type = setterType;
         }
       }
     } else {
@@ skipping 58 matching lines @@
    *
    * @param node the type name with the wrong number of type arguments
    * @return the error code that should be used to report that the wrong number of type arguments
    *         were provided
    */
   ErrorCode getInvalidTypeParametersErrorCode(TypeName node) {
     ASTNode parent = node.parent;
     if (parent is ConstructorName) {
       parent = parent.parent;
       if (parent is InstanceCreationExpression) {
-        if (((parent as InstanceCreationExpression)).isConst) {
+        if ((parent as InstanceCreationExpression).isConst) {
           return CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS;
         } else {
           return StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS;
         }
       }
     }
     return StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS;
   }
 
   /**
@@ skipping 28 matching lines @@
    * @param elements the elements to which a single name could potentially be resolved
    * @return the single interface type that should be used for the type name
    */
   InterfaceType getType(List<Element> elements) {
     InterfaceType type = null;
     for (Element element in elements) {
       if (element is ClassElement) {
         if (type != null) {
           return null;
         }
-        type = ((element as ClassElement)).type;
+        type = (element as ClassElement).type;
       }
     }
     return type;
   }
 
   /**
    * Return the type represented by the given type name.
    *
    * @param typeName the type name representing the type to be returned
    * @return the type represented by the type name
    */
   Type2 getType3(TypeName typeName) {
     Type2 type = typeName.type;
     if (type == null) {
       return _dynamicType;
     }
     return type;
   }
 
   /**
    * Return the type arguments associated with the given type.
    *
    * @param type the type whole type arguments are to be returned
    * @return the type arguments associated with the given type
    */
   List<Type2> getTypeArguments(Type2 type) {
     if (type is InterfaceType) {
-      return ((type as InterfaceType)).typeArguments;
+      return (type as InterfaceType).typeArguments;
     } else if (type is FunctionType) {
-      return ((type as FunctionType)).typeArguments;
+      return (type as FunctionType).typeArguments;
     }
     return TypeImpl.EMPTY_ARRAY;
   }
 
   /**
    * Returns the simple identifier of the given (may be qualified) type name.
    *
    * @param typeName the (may be qualified) qualified type name
    * @return the simple identifier of the given (may be qualified) type name.
    */
   SimpleIdentifier getTypeSimpleIdentifier(Identifier typeName) {
     if (typeName is SimpleIdentifier) {
       return typeName as SimpleIdentifier;
     } else {
-      return ((typeName as PrefixedIdentifier)).identifier;
+      return (typeName as PrefixedIdentifier).identifier;
     }
   }
 
   /**
    * Checks if the given type name is used as the type in an as expression.
    *
    * @param typeName the type name to analyzer
    * @return `true` if the given type name is used as the type in an as expression
    */
   bool isTypeNameInAsExpression(TypeName typeName) {
@@ skipping 105 matching lines @@
         TypeName typeName = typeNames[i];
         if (!detectedRepeatOnIndex[i]) {
           Element element = typeName.name.staticElement;
           for (int j = i + 1; j < typeNames.length; j++) {
             TypeName typeName2 = typeNames[j];
             Identifier identifier2 = typeName2.name;
             String name2 = identifier2.name;
             Element element2 = identifier2.staticElement;
             if (element != null && element == element2) {
               detectedRepeatOnIndex[j] = true;
-              reportError5(CompileTimeErrorCode.IMPLEMENTS_REPEATED, typeName2, [name2]);
+              reportError6(CompileTimeErrorCode.IMPLEMENTS_REPEATED, typeName2, [name2]);
             }
           }
         }
       }
     }
   }
 
   /**
    * Return the type specified by the given name.
    *
    * @param typeName the type name specifying the type to be returned
    * @param nonTypeError the error to produce if the type name is defined to be something other than
    *          a type
    * @param dynamicTypeError the error to produce if the type name is "dynamic"
    * @return the type specified by the type name
    */
   InterfaceType resolveType(TypeName typeName, ErrorCode nonTypeError, ErrorCode dynamicTypeError) {
     Type2 type = typeName.type;
     if (type is InterfaceType) {
       return type as InterfaceType;
     }
     Identifier name = typeName.name;
     if (name.name == sc.Keyword.DYNAMIC.syntax) {
-      reportError5(dynamicTypeError, name, [name.name]);
+      reportError6(dynamicTypeError, name, [name.name]);
     } else {
-      reportError5(nonTypeError, name, [name.name]);
+      reportError6(nonTypeError, name, [name.name]);
     }
     return null;
   }
 
   /**
    * Resolve the types in the given list of type names.
    *
    * @param typeNames the type names to be resolved
    * @param nonTypeError the error to produce if the type name is defined to be something other than
    *          a type
    * @param dynamicTypeError the error to produce if the type name is "dynamic"
    * @return an array containing all of the types that were resolved.
    */
   List<InterfaceType> resolveTypes(NodeList<TypeName> typeNames, ErrorCode nonTypeError, ErrorCode dynamicTypeError) {
     List<InterfaceType> types = new List<InterfaceType>();
     for (TypeName typeName in typeNames) {
       InterfaceType type = resolveType(typeName, nonTypeError, dynamicTypeError);
       if (type != null) {
         types.add(type);
       }
     }
     return new List.from(types);
   }
+
   void setElement(Identifier typeName, Element element) {
     if (element != null) {
       if (typeName is SimpleIdentifier) {
-        ((typeName as SimpleIdentifier)).staticElement = element;
+        (typeName as SimpleIdentifier).staticElement = element;
       } else if (typeName is PrefixedIdentifier) {
         PrefixedIdentifier identifier = typeName as PrefixedIdentifier;
         identifier.identifier.staticElement = element;
         SimpleIdentifier prefix = identifier.prefix;
         Element prefixElement = nameScope.lookup(prefix, definingLibrary);
         if (prefixElement != null) {
           prefix.staticElement = prefixElement;
         }
       }
     }
@@ skipping 26 matching lines @@
       if (alias != null) {
         aliasElement.typeParameters = alias.typeParameters;
         type.typeArguments = alias.type.typeArguments;
       } else {
         type.typeArguments = TypeImpl.EMPTY_ARRAY;
       }
     }
     element.type = type;
   }
 }
+
 /**
  * Kind of the redirecting constructor.
  */
 class RedirectingConstructorKind extends Enum<RedirectingConstructorKind> {
   static final RedirectingConstructorKind CONST = new RedirectingConstructorKind('CONST', 0);
+
   static final RedirectingConstructorKind NORMAL = new RedirectingConstructorKind('NORMAL', 1);
+
   static final List<RedirectingConstructorKind> values = [CONST, NORMAL];
+
   RedirectingConstructorKind(String name, int ordinal) : super(name, ordinal);
 }
+
 /**
  * Instances of the class `VariableResolverVisitor` are used to resolve
  * [SimpleIdentifier]s to local variables and formal parameters.
  *
  * @coverage dart.engine.resolver
  */
 class VariableResolverVisitor extends ScopedVisitor {
-
   /**
    * The method or function that we are currently visiting, or `null` if we are not inside a
    * method or function.
    */
   ExecutableElement _enclosingFunction;
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
-  VariableResolverVisitor(Library library, Source source, TypeProvider typeProvider) : super.con1(library, source, typeProvider);
+  VariableResolverVisitor.con1(Library library, Source source, TypeProvider typeProvider) : super.con1(library, source, typeProvider);
+
+  /**
+   * Initialize a newly created visitor to resolve the nodes in an AST node.
+   *
+   * @param definingLibrary the element for the library containing the node being visited
+   * @param source the source representing the compilation unit containing the node being visited
+   * @param typeProvider the object used to access the types from the core library
+   * @param nameScope the scope used to resolve identifiers in the node that will first be visited
+   * @param errorListener the error listener that will be informed of any errors that are found
+   *          during resolution
+   */
+  VariableResolverVisitor.con2(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, Scope nameScope, AnalysisErrorListener errorListener) : super.con3(definingLibrary, source, typeProvider, nameScope, errorListener);
+
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       return super.visitFunctionDeclaration(node);
     } finally {
       _enclosingFunction = outerFunction;
     }
   }
+
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is! FunctionDeclaration) {
       ExecutableElement outerFunction = _enclosingFunction;
       try {
         _enclosingFunction = node.element;
         return super.visitFunctionExpression(node);
       } finally {
         _enclosingFunction = outerFunction;
       }
     } else {
       return super.visitFunctionExpression(node);
     }
   }
+
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (node.staticElement != null) {
       return null;
     }
     ASTNode parent = node.parent;
-    if (parent is PrefixedIdentifier && identical(((parent as PrefixedIdentifier)).identifier, node)) {
+    if (parent is PrefixedIdentifier && identical((parent as PrefixedIdentifier).identifier, node)) {
       return null;
     }
-    if (parent is PropertyAccess && identical(((parent as PropertyAccess)).propertyName, node)) {
+    if (parent is PropertyAccess && identical((parent as PropertyAccess).propertyName, node)) {
       return null;
     }
-    if (parent is MethodInvocation && identical(((parent as MethodInvocation)).methodName, node)) {
+    if (parent is MethodInvocation && identical((parent as MethodInvocation).methodName, node)) {
       return null;
     }
     if (parent is ConstructorName) {
       return null;
     }
     if (parent is Label) {
       return null;
     }
     Element element = nameScope.lookup(node, definingLibrary);
     if (element is! VariableElement) {
@@ skipping 15 matching lines @@
         ParameterElementImpl parameterImpl = element as ParameterElementImpl;
         parameterImpl.markPotentiallyMutatedInScope();
         if (_enclosingFunction != null && (element.enclosingElement != _enclosingFunction)) {
           parameterImpl.markPotentiallyMutatedInClosure();
         }
       }
     }
     return null;
   }
 }
+
 /**
  * Instances of the class `ClassScope` implement the scope defined by a class.
  *
  * @coverage dart.engine.resolver
  */
 class ClassScope 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 represented by this scope
    */
   ClassScope(Scope enclosingScope, ClassElement typeElement) : super(new EnclosedScope(enclosingScope)) {
     defineTypeParameters(typeElement);
     defineMembers(typeElement);
   }
+
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     if (existing is PropertyAccessorElement && duplicate is MethodElement) {
       if (existing.nameOffset < duplicate.nameOffset) {
         return new AnalysisError.con2(duplicate.source, duplicate.nameOffset, duplicate.displayName.length, CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME, [existing.displayName]);
       } else {
         return new AnalysisError.con2(existing.source, existing.nameOffset, existing.displayName.length, CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME, [existing.displayName]);
       }
     }
     return super.getErrorForDuplicate(existing, duplicate);
   }
@@ skipping 17 matching lines @@
    *
    * @param typeElement the element representing the type represented by this scope
    */
   void defineTypeParameters(ClassElement typeElement) {
     Scope parameterScope = enclosingScope;
     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 {
-
   /**
    * The scope in which this scope is lexically enclosed.
    */
-  Scope enclosingScope;
+  Scope _enclosingScope;
 
   /**
-   * A set of names that will be defined in this scope, but right now are not defined. However
-   * according to the scoping rules these names are hidden, even if they were defined in an outer
+   * A table mapping names that will be defined in this scope, but right now are not initialized.
+   * According to the scoping rules these names are hidden, even if they were defined in an outer
    * scope.
    */
-  Set<String> _hiddenNames = new Set<String>();
+  Map<String, Element> _hiddenElements = new Map<String, Element>();
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
    */
   EnclosedScope(Scope enclosingScope) {
-    this.enclosingScope = enclosingScope;
+    this._enclosingScope = enclosingScope;
   }
-  AnalysisErrorListener get errorListener => enclosingScope.errorListener;
+
+  Scope get enclosingScope => _enclosingScope;
+
+  AnalysisErrorListener get errorListener => _enclosingScope.errorListener;
 
   /**
-   * Hides the name of the given element in this scope. If there is already an element with the
-   * given name defined in an outer scope, then it will become unavailable.
+   * Record that given element is declared in this scope, but hasn't been initialized yet, so it is
+   * error to use. If there is already an element with the given name defined in an outer scope,
+   * then it will become unavailable.
    *
-   * @param element the element to be hidden in this scope
+   * @param element the element declared, but not initialized in this scope
    */
   void hide(Element element) {
     if (element != null) {
       String name = element.name;
       if (name != null && !name.isEmpty) {
-        javaSetAdd(_hiddenNames, name);
+        _hiddenElements[name] = element;
       }
     }
   }
+
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) {
     Element element = localLookup(name, referencingLibrary);
     if (element != null) {
       return element;
     }
-    if (_hiddenNames.contains(name)) {
+    Element hiddenElement = _hiddenElements[name];
+    if (hiddenElement != null) {
       errorListener.onError(new AnalysisError.con2(getSource(identifier), identifier.offset, identifier.length, CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION, []));
+      return hiddenElement;
     }
-    return enclosingScope.lookup3(identifier, name, referencingLibrary);
+    return _enclosingScope.lookup3(identifier, name, referencingLibrary);
   }
 }
+
 /**
  * Instances of the class `FunctionScope` implement the scope defined by a function.
  *
  * @coverage dart.engine.resolver
  */
 class FunctionScope extends EnclosedScope {
   ExecutableElement _functionElement;
+
   bool _parametersDefined = false;
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
    * @param functionElement the element representing the type represented by this scope
    */
   FunctionScope(Scope enclosingScope, ExecutableElement functionElement) : super(new EnclosedScope(enclosingScope)) {
     this._functionElement = functionElement;
@@ skipping 14 matching lines @@
         parameterScope.define(_functionElement);
       }
     }
     for (ParameterElement parameter in _functionElement.parameters) {
       if (!parameter.isInitializingFormal) {
         parameterScope.define(parameter);
       }
     }
   }
 }
+
 /**
  * Instances of the class `FunctionTypeScope` implement the scope defined by a function type
  * alias.
  *
  * @coverage dart.engine.resolver
  */
 class FunctionTypeScope extends EnclosedScope {
   FunctionTypeAliasElement _typeElement;
+
   bool _parametersDefined = false;
 
   /**
    * 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)) {
     this._typeElement = typeElement;
@@ skipping 20 matching lines @@
    *
    * @param typeElement the element representing the type represented by this scope
    */
   void defineTypeParameters() {
     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 {
-
   /**
    * The label scope enclosing this label scope.
    */
   LabelScope _outerScope;
 
   /**
    * The label defined in this scope.
    */
   String _label;
 
@@ skipping 56 matching lines @@
   LabelElement lookup2(String targetLabel) {
     if (_label == targetLabel) {
       return _element;
     } else if (_outerScope != null) {
       return _outerScope.lookup2(targetLabel);
     } else {
       return null;
     }
   }
 }
+
 /**
  * Instances of the class `LibraryImportScope` represent the scope containing all of the names
  * available from imported libraries.
  *
  * @coverage dart.engine.resolver
  */
 class LibraryImportScope extends Scope {
-
   /**
    * The element representing the library in which this scope is enclosed.
    */
   LibraryElement _definingLibrary;
 
   /**
    * The listener that is to be informed when an error is encountered.
    */
   AnalysisErrorListener _errorListener;
 
   /**
    * A list of the namespaces representing the names that are available in this scope from imported
    * libraries.
    */
   List<Namespace> _importedNamespaces = new List<Namespace>();
 
   /**
    * Initialize a newly created scope representing the names imported into the given library.
    *
    * @param definingLibrary the element representing the library that imports the names defined in
    *          this scope
    * @param errorListener the listener that is to be informed when an error is encountered
    */
   LibraryImportScope(LibraryElement definingLibrary, AnalysisErrorListener errorListener) {
     this._definingLibrary = definingLibrary;
     this._errorListener = errorListener;
     createImportedNamespaces(definingLibrary);
   }
+
   void define(Element element) {
     if (!Scope.isPrivateName(element.displayName)) {
       super.define(element);
     }
   }
+
   AnalysisErrorListener get errorListener => _errorListener;
+
   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 if (foundElement != element) {
           foundElement = MultiplyDefinedElementImpl.fromElements(_definingLibrary.context, foundElement, element);
         }
       }
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       foundElement = removeSdkElements(identifier, name, foundElement as MultiplyDefinedElementImpl);
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       String foundEltName = foundElement.displayName;
-      List<Element> conflictingMembers = ((foundElement as MultiplyDefinedElementImpl)).conflictingElements;
+      List<Element> conflictingMembers = (foundElement as MultiplyDefinedElementImpl).conflictingElements;
       String libName1 = getLibraryName(conflictingMembers[0], "");
       String libName2 = getLibraryName(conflictingMembers[1], "");
       _errorListener.onError(new AnalysisError.con2(getSource(identifier), identifier.offset, identifier.length, StaticWarningCode.AMBIGUOUS_IMPORT, [foundEltName, libName1, libName2]));
       return foundElement;
     }
     if (foundElement != null) {
       defineWithoutChecking2(name, foundElement);
     }
     return foundElement;
   }
@@ skipping 63 matching lines @@
       return conflictingMembers[0];
     } else if (to == 0) {
       AnalysisEngine.instance.logger.logInformation("Multiply defined SDK element: ${foundElement}");
       return foundElement;
     }
     List<Element> remaining = new List<Element>(to);
     JavaSystem.arraycopy(conflictingMembers, 0, remaining, 0, to);
     return new MultiplyDefinedElementImpl(_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 {
-
   /**
    * Initialize a newly created scope representing the names defined in the given library.
    *
    * @param definingLibrary the element representing the library represented by this scope
    * @param errorListener the listener that is to be informed when an error is encountered
    */
   LibraryScope(LibraryElement definingLibrary, AnalysisErrorListener errorListener) : super(new LibraryImportScope(definingLibrary, errorListener)) {
     defineTopLevelNames(definingLibrary);
   }
+
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     if (existing is PrefixElement) {
       int offset = duplicate.nameOffset;
       if (duplicate is PropertyAccessorElement) {
         PropertyAccessorElement accessor = duplicate as PropertyAccessorElement;
         if (accessor.isSynthetic) {
           offset = accessor.variable.nameOffset;
         }
       }
       return new AnalysisError.con2(duplicate.source, offset, duplicate.displayName.length, CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER, [existing.displayName]);
@@ skipping 32 matching lines @@
   void defineTopLevelNames(LibraryElement definingLibrary) {
     for (PrefixElement prefix in definingLibrary.prefixes) {
       define(prefix);
     }
     defineLocalNames(definingLibrary.definingCompilationUnit);
     for (CompilationUnitElement compilationUnit in definingLibrary.parts) {
       defineLocalNames(compilationUnit);
     }
   }
 }
+
 /**
  * Instances of the class `Namespace` implement a mapping of identifiers to the elements
  * represented by those identifiers. Namespaces are the building blocks for scopes.
  *
  * @coverage dart.engine.resolver
  */
 class Namespace {
-
   /**
    * A table mapping names that are defined in this namespace to the element representing the thing
    * declared with that name.
    */
   Map<String, Element> _definedNames;
 
   /**
    * An empty namespace.
    */
   static Namespace EMPTY = new Namespace(new Map<String, Element>());
@@ skipping 17 matching lines @@
    */
   Element get(String name) => _definedNames[name];
 
   /**
    * Return a table containing the same mappings as those defined by this namespace.
    *
    * @return a table containing the same mappings as those defined by this namespace
    */
   Map<String, Element> get definedNames => new Map<String, Element>.from(_definedNames);
 }
+
 /**
  * Instances of the class `NamespaceBuilder` are used to build a `Namespace`. Namespace
  * builders are thread-safe and re-usable.
  *
  * @coverage dart.engine.resolver
  */
 class NamespaceBuilder {
-
   /**
    * Create a namespace representing the export namespace of the given [ExportElement].
    *
    * @param element the export element whose export namespace is to be created
    * @return the export namespace that was created
    */
   Namespace createExportNamespace(ExportElement element) {
     LibraryElement exportedLibrary = element.exportedLibrary;
     if (exportedLibrary == null) {
       return Namespace.EMPTY;
@@ skipping 105 matching lines @@
 
   /**
    * Apply the given combinators to all of the names in the given mapping table.
    *
    * @param definedNames the mapping table to which the namespace operations are to be applied
    * @param combinators the combinators to be applied
    */
   Map<String, Element> apply(Map<String, Element> definedNames, List<NamespaceCombinator> combinators) {
     for (NamespaceCombinator combinator in combinators) {
       if (combinator is HideElementCombinator) {
-        hide(definedNames, ((combinator as HideElementCombinator)).hiddenNames);
+        hide(definedNames, (combinator as HideElementCombinator).hiddenNames);
       } else if (combinator is ShowElementCombinator) {
-        definedNames = show(definedNames, ((combinator as ShowElementCombinator)).shownNames);
+        definedNames = show(definedNames, (combinator as ShowElementCombinator).shownNames);
       } else {
         AnalysisEngine.instance.logger.logError("Unknown type of combinator: ${combinator.runtimeType.toString()}");
       }
     }
     return definedNames;
   }
 
   /**
    * Apply the given prefix to all of the names in the table of defined names.
    *
@@ skipping 27 matching lines @@
     try {
       Map<String, Element> definedNames = new Map<String, Element>();
       for (ExportElement element in library.exports) {
         LibraryElement exportedLibrary = element.exportedLibrary;
         if (exportedLibrary != null && !visitedElements.contains(exportedLibrary)) {
           Map<String, Element> exportedNames = createExportMapping(exportedLibrary, visitedElements);
           exportedNames = apply(exportedNames, element.combinators);
           addAll(definedNames, exportedNames);
         }
       }
-      addAll2(definedNames, ((library.context as InternalAnalysisContext)).getPublicNamespace(library));
+      addAll2(definedNames, (library.context as InternalAnalysisContext).getPublicNamespace(library));
       return definedNames;
     } finally {
       visitedElements.remove(library);
     }
   }
 
   /**
    * Hide all of the given names by removing them from the given collection of defined names.
    *
    * @param definedNames the names that were defined before this operation
@@ skipping 22 matching lines @@
       }
       String setterName = "${name}=";
       element = definedNames[setterName];
       if (element != null) {
         newNames[setterName] = element;
       }
     }
     return newNames;
   }
 }
+
 /**
  * The abstract class `Scope` defines the behavior common to name scopes used by the resolver
  * to determine which names are visible at any given point in the code.
  *
  * @coverage dart.engine.resolver
  */
 abstract class Scope {
-
   /**
    * The prefix used to mark an identifier as being private to its library.
    */
   static String PRIVATE_NAME_PREFIX = "_";
 
   /**
    * The suffix added to the declared name of a setter when looking up the setter. Used to
    * disambiguate between a getter and a setter that have the same name.
    */
   static String SETTER_SUFFIX = "=";
@@ skipping 31 matching lines @@
     if (name != null && !name.isEmpty) {
       if (_definedNames.containsKey(name)) {
         errorListener.onError(getErrorForDuplicate(_definedNames[name], element));
       } else {
         _definedNames[name] = element;
       }
     }
   }
 
   /**
+   * Return the scope in which this scope is lexically enclosed.
+   *
+   * @return the scope in which this scope is lexically enclosed
+   */
+  Scope get enclosingScope => null;
+
+  /**
    * Return the element with which the given identifier is associated, or `null` if the name
    * is not defined within this scope.
    *
    * @param identifier the identifier associated with the element to be returned
    * @param referencingLibrary the library that contains the reference to the name, used to
    *          implement library-level privacy
    * @return the element with which the given identifier is associated
    */
   Element lookup(Identifier identifier, LibraryElement referencingLibrary) => lookup3(identifier, identifier.name, referencingLibrary);
 
@@ skipping 88 matching lines @@
   String getName(Element element) {
     if (element is MethodElement) {
       MethodElement method = element as MethodElement;
       if (method.name == "-" && method.parameters.length == 0) {
         return UNARY_MINUS;
       }
     }
     return element.name;
   }
 }
+
+/**
+ * Instances of the class `ScopeBuilder` build the scope for a given node in an AST structure.
+ * At the moment, this class only handles top-level and class-level declarations.
+ */
+class ScopeBuilder {
+  /**
+   * Return the scope in which the given AST structure should be resolved.
+   *
+   * @param node the root of the AST structure to be resolved
+   * @param errorListener the listener to which analysis errors will be reported
+   * @return the scope in which the given AST structure should be resolved
+   * @throws AnalysisException if the AST structure has not been resolved or is not part of a
+   *           [CompilationUnit]
+   */
+  static Scope scopeFor(ASTNode node, AnalysisErrorListener errorListener) {
+    if (node == null) {
+      throw new AnalysisException.con1("Cannot create scope: node is null");
+    } else if (node is CompilationUnit) {
+      ScopeBuilder builder = new ScopeBuilder(errorListener);
+      return builder.scopeForAstNode(node);
+    }
+    ASTNode parent = node.parent;
+    if (parent == null) {
+      throw new AnalysisException.con1("Cannot create scope: node is not part of a CompilationUnit");
+    }
+    ScopeBuilder builder = new ScopeBuilder(errorListener);
+    return builder.scopeForAstNode(parent);
+  }
+
+  /**
+   * The listener to which analysis errors will be reported.
+   */
+  AnalysisErrorListener _errorListener;
+
+  /**
+   * Initialize a newly created scope builder to generate a scope that will report errors to the
+   * given listener.
+   *
+   * @param errorListener the listener to which analysis errors will be reported
+   */
+  ScopeBuilder(AnalysisErrorListener errorListener) {
+    this._errorListener = errorListener;
+  }
+
+  /**
+   * Return the scope in which the given AST structure should be resolved.
+   *
+   * <b>Note:</b> This method needs to be kept in sync with
+   * [IncrementalResolver#canBeResolved].
+   *
+   * @param node the root of the AST structure to be resolved
+   * @return the scope in which the given AST structure should be resolved
+   * @throws AnalysisException if the AST structure has not been resolved or is not part of a
+   *           [CompilationUnit]
+   */
+  Scope scopeForAstNode(ASTNode node) {
+    if (node is CompilationUnit) {
+      return scopeForCompilationUnit(node as CompilationUnit);
+    }
+    ASTNode parent = node.parent;
+    if (parent == null) {
+      throw new AnalysisException.con1("Cannot create scope: node is not part of a CompilationUnit");
+    }
+    Scope scope = scopeForAstNode(parent);
+    if (node is ClassDeclaration) {
+      scope = new ClassScope(scope, (node as ClassDeclaration).element);
+    } else if (node is ClassTypeAlias) {
+      scope = new ClassScope(scope, (node as ClassTypeAlias).element);
+    } else if (node is ConstructorDeclaration) {
+      FunctionScope functionScope = new FunctionScope(scope, (node as ConstructorDeclaration).element);
+      functionScope.defineParameters();
+      scope = functionScope;
+    } else if (node is FunctionDeclaration) {
+      FunctionScope functionScope = new FunctionScope(scope, (node as FunctionDeclaration).element);
+      functionScope.defineParameters();
+      scope = functionScope;
+    } else if (node is FunctionTypeAlias) {
+      scope = new FunctionTypeScope(scope, (node as FunctionTypeAlias).element);
+    } else if (node is MethodDeclaration) {
+      FunctionScope functionScope = new FunctionScope(scope, (node as MethodDeclaration).element);
+      functionScope.defineParameters();
+      scope = functionScope;
+    }
+    return scope;
+  }
+
+  Scope scopeForCompilationUnit(CompilationUnit node) {
+    CompilationUnitElement unitElement = node.element;
+    if (unitElement == null) {
+      throw new AnalysisException.con1("Cannot create scope: compilation unit is not resolved");
+    }
+    LibraryElement libraryElement = unitElement.library;
+    if (libraryElement == null) {
+      throw new AnalysisException.con1("Cannot create scope: compilation unit is not part of a library");
+    }
+    return new LibraryScope(libraryElement, _errorListener);
+  }
+}
+
 /**
  * Instances of the class `ConstantVerifier` traverse an AST structure looking for additional
  * errors and warnings not covered by the parser and resolver. In particular, it looks for errors
  * and warnings related to constant expressions.
  *
  * @coverage dart.engine.resolver
  */
 class ConstantVerifier extends RecursiveASTVisitor<Object> {
-
   /**
    * The error reporter by which errors will be reported.
    */
   ErrorReporter _errorReporter;
 
   /**
    * The type representing the type 'bool'.
    */
   InterfaceType _boolType;
 
@@ skipping 17 matching lines @@
    *
    * @param errorReporter the error reporter by which errors will be reported
    */
   ConstantVerifier(ErrorReporter errorReporter, TypeProvider typeProvider) {
     this._errorReporter = errorReporter;
     this._boolType = typeProvider.boolType;
     this._intType = typeProvider.intType;
     this._numType = typeProvider.numType;
     this._stringType = typeProvider.stringType;
   }
+
   Object visitAnnotation(Annotation node) {
     super.visitAnnotation(node);
     Element element = node.element;
     if (element is ConstructorElement) {
       ConstructorElement constructorElement = element as ConstructorElement;
       if (!constructorElement.isConst) {
         _errorReporter.reportError2(CompileTimeErrorCode.NON_CONSTANT_ANNOTATION_CONSTRUCTOR, node, []);
         return null;
       }
       ArgumentList argumentList = node.arguments;
       if (argumentList == null) {
         _errorReporter.reportError2(CompileTimeErrorCode.NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS, node, []);
         return null;
       }
       validateConstantArguments(argumentList);
     }
     return null;
   }
+
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     if (node.constKeyword != null) {
       validateInitializers(node);
     }
     validateDefaultValues(node.parameters);
     return super.visitConstructorDeclaration(node);
   }
+
   Object visitFunctionExpression(FunctionExpression node) {
     super.visitFunctionExpression(node);
     validateDefaultValues(node.parameters);
     return null;
   }
+
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     validateConstantArguments2(node);
     return super.visitInstanceCreationExpression(node);
   }
+
   Object visitListLiteral(ListLiteral node) {
     super.visitListLiteral(node);
     if (node.constKeyword != null) {
       for (Expression element in node.elements) {
         validate(element, CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT);
       }
     }
     return null;
   }
+
   Object visitMapLiteral(MapLiteral node) {
     super.visitMapLiteral(node);
     bool isConst = node.constKeyword != null;
     bool reportEqualKeys = true;
     Set<Object> keys = new Set<Object>();
     List<Expression> invalidKeys = new List<Expression>();
     for (MapLiteralEntry entry in node.entries) {
       Expression key = entry.key;
       if (isConst) {
         EvaluationResultImpl result = validate(key, CompileTimeErrorCode.NON_CONSTANT_MAP_KEY);
         validate(entry.value, CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE);
         if (result is ValidResult) {
-          Object value = ((result as ValidResult)).value;
+          Object value = (result as ValidResult).value;
           if (keys.contains(value)) {
             invalidKeys.add(key);
           } else {
             javaSetAdd(keys, value);
           }
         }
       } else {
         EvaluationResultImpl result = key.accept(new ConstantVisitor());
         if (result is ValidResult) {
-          Object value = ((result as ValidResult)).value;
+          Object value = (result as ValidResult).value;
           if (keys.contains(value)) {
             invalidKeys.add(key);
           } else {
             javaSetAdd(keys, value);
           }
         } else {
           reportEqualKeys = false;
         }
       }
     }
     if (reportEqualKeys) {
       for (Expression key in invalidKeys) {
         _errorReporter.reportError2(StaticWarningCode.EQUAL_KEYS_IN_MAP, key, []);
       }
     }
     return null;
   }
+
   Object visitMethodDeclaration(MethodDeclaration node) {
     super.visitMethodDeclaration(node);
     validateDefaultValues(node.parameters);
     return null;
   }
+
   Object visitSwitchCase(SwitchCase node) {
     super.visitSwitchCase(node);
     validate(node.expression, CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION);
     return null;
   }
+
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     Expression initializer = node.initializer;
     if (initializer != null && node.isConst) {
       VariableElementImpl element = node.element as VariableElementImpl;
       EvaluationResultImpl result = element.evaluationResult;
       if (result == null) {
         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;
   }
 
   /**
    * 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 errorCode) {
     if (result is ErrorResult) {
-      for (ErrorResult_ErrorData data in ((result as ErrorResult)).errorData) {
+      for (ErrorResult_ErrorData data in (result as ErrorResult).errorData) {
         ErrorCode dataErrorCode = data.errorCode;
         if (identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_INT) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM)) {
           _errorReporter.reportError2(dataErrorCode, data.node, []);
         } else {
           _errorReporter.reportError2(errorCode, data.node, []);
         }
       }
     }
   }
 
@@ skipping 12 matching lines @@
   }
 
   /**
    * Validate that if the passed arguments are constant expressions.
    *
    * @param argumentList the argument list to evaluate
    */
   void validateConstantArguments(ArgumentList argumentList) {
     for (Expression argument in argumentList.arguments) {
       if (argument is NamedExpression) {
-        argument = ((argument as NamedExpression)).expression;
+        argument = (argument as NamedExpression).expression;
       }
       validate(argument, CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT);
     }
   }
 
   /**
    * Validate that if the passed instance creation is 'const' then all its arguments are constant
    * expressions.
    *
    * @param node the instance creation evaluate
@@ skipping 33 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_13(this, parameterElements));
+    EvaluationResultImpl result = expression.accept(new ConstantVisitor_14(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_13 extends ConstantVisitor {
+
+class ConstantVisitor_14 extends ConstantVisitor {
   final ConstantVerifier ConstantVerifier_this;
+
   List<ParameterElement> parameterElements;
-  ConstantVisitor_13(this.ConstantVerifier_this, this.parameterElements) : super();
+
+  ConstantVisitor_14(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)) {
             return ValidResult.RESULT_BOOL;
           }
           if (type.isSubtypeOf(ConstantVerifier_this._intType)) {
             return ValidResult.RESULT_INT;
           }
           if (type.isSubtypeOf(ConstantVerifier_this._numType)) {
             return ValidResult.RESULT_NUM;
           }
           if (type.isSubtypeOf(ConstantVerifier_this._stringType)) {
             return ValidResult.RESULT_STRING;
           }
         }
         return ValidResult.RESULT_OBJECT;
       }
     }
     return super.visitSimpleIdentifier(node);
   }
 }
+
 /**
  * Instances of the class `ErrorVerifier` traverse an AST structure looking for additional
  * errors and warnings not covered by the parser and resolver.
  *
  * @coverage dart.engine.resolver
  */
 class ErrorVerifier extends RecursiveASTVisitor<Object> {
-
-  /**
-   * Checks if the given expression is the reference to the type.
-   *
-   * @param expr the expression to evaluate
-   * @return `true` if the given expression is the reference to the type
-   */
-  static bool isTypeReference(Expression expr) {
-    if (expr is Identifier) {
-      Identifier identifier = expr as Identifier;
-      return identifier.staticElement is ClassElement;
-    }
-    return false;
-  }
-
   /**
    * The error reporter by which errors will be reported.
    */
   ErrorReporter _errorReporter;
 
   /**
    * The current library that is being analyzed.
    */
   LibraryElement _currentLibrary;
 
@@ skipping 143 matching lines @@
    * A table mapping name of the library to the export directive which export this library.
    */
   Map<String, LibraryElement> _nameToExportElement = new Map<String, LibraryElement>();
 
   /**
    * A table mapping name of the library to the import directive which import this library.
    */
   Map<String, LibraryElement> _nameToImportElement = new Map<String, LibraryElement>();
 
   /**
-   * A table mapping names to the export elements exported them.
+   * A table mapping names to the exported elements.
    */
-  Map<String, ExportElement> _exportedNames = new Map<String, ExportElement>();
+  Map<String, Element> _exportedElements = new Map<String, Element>();
 
   /**
    * A set of the names of the variable initializers we are visiting now.
    */
   Set<String> _namesForReferenceToDeclaredVariableInInitializer = new Set<String>();
 
   /**
    * A list of types used by the [CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS] and
    * [CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS] error codes.
    */
   List<InterfaceType> _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT;
+
   ErrorVerifier(ErrorReporter errorReporter, LibraryElement currentLibrary, TypeProvider typeProvider, InheritanceManager inheritanceManager) {
     this._errorReporter = errorReporter;
     this._currentLibrary = currentLibrary;
     this._isInSystemLibrary = currentLibrary.source.isInSystemLibrary;
     this._typeProvider = typeProvider;
     this._inheritanceManager = inheritanceManager;
     _strictMode = currentLibrary.context.analysisOptions.strictMode;
     _isEnclosingConstructorConst = false;
     _isInCatchClause = false;
     _isInStaticVariableDeclaration = false;
     _isInInstanceVariableDeclaration = false;
     _isInInstanceVariableInitializer = false;
     _isInConstructorInitializer = false;
     _isInStaticMethod = false;
     _boolType = typeProvider.boolType;
     _dynamicType = typeProvider.dynamicType;
     _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT = <InterfaceType> [
         typeProvider.nullType,
         typeProvider.numType,
         typeProvider.intType,
         typeProvider.doubleType,
         _boolType,
         typeProvider.stringType];
   }
+
   Object visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
     checkForArgumentDefinitionTestNonParameter(node);
     return super.visitArgumentDefinitionTest(node);
   }
+
   Object visitArgumentList(ArgumentList node) {
     checkForArgumentTypeNotAssignable(node);
     return super.visitArgumentList(node);
   }
+
   Object visitAssertStatement(AssertStatement node) {
     checkForNonBoolExpression(node);
     return super.visitAssertStatement(node);
   }
+
   Object visitAssignmentExpression(AssignmentExpression node) {
     sc.Token operator = node.operator;
     sc.TokenType operatorType = operator.type;
     if (identical(operatorType, sc.TokenType.EQ)) {
       checkForInvalidAssignment2(node.leftHandSide, node.rightHandSide);
     } else {
       checkForInvalidAssignment(node);
     }
     checkForAssignmentToFinal(node);
     checkForArgumentTypeNotAssignable2(node.rightHandSide);
     return super.visitAssignmentExpression(node);
   }
+
   Object visitBinaryExpression(BinaryExpression node) {
     checkForArgumentTypeNotAssignable2(node.rightOperand);
     return super.visitBinaryExpression(node);
   }
+
   Object visitBlockFunctionBody(BlockFunctionBody node) {
     int previousReturnWithCount = _returnWithCount;
     int previousReturnWithoutCount = _returnWithoutCount;
     try {
       _returnWithCount = 0;
       _returnWithoutCount = 0;
       super.visitBlockFunctionBody(node);
       checkForMixedReturns(node);
     } finally {
       _returnWithCount = previousReturnWithCount;
       _returnWithoutCount = previousReturnWithoutCount;
     }
     return null;
   }
+
   Object visitCatchClause(CatchClause node) {
     bool previousIsInCatchClause = _isInCatchClause;
     try {
       _isInCatchClause = true;
       return super.visitCatchClause(node);
     } finally {
       _isInCatchClause = previousIsInCatchClause;
     }
   }
+
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       _isInNativeClass = node.nativeClause != null;
       _enclosingClass = node.element;
       WithClause withClause = node.withClause;
       ImplementsClause implementsClause = node.implementsClause;
       ExtendsClause extendsClause = node.extendsClause;
       checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME);
       checkForMemberWithClassName();
@@ skipping 13 matching lines @@
         _initialFieldElementsMap = new Map<FieldElement, INIT_STATE>();
         for (FieldElement fieldElement in fieldElements) {
           if (!fieldElement.isSynthetic) {
             _initialFieldElementsMap[fieldElement] = fieldElement.initializer == null ? INIT_STATE.NOT_INIT : INIT_STATE.INIT_IN_DECLARATION;
           }
         }
       }
       checkForFinalNotInitialized(node);
       checkForDuplicateDefinitionInheritance();
       checkForConflictingGetterAndMethod();
+      checkForConflictingInstanceGetterAndSuperclassMember();
       checkImplementsSuperClass(node);
       checkImplementsFunctionWithoutCall(node);
       return super.visitClassDeclaration(node);
     } finally {
       _isInNativeClass = false;
       _initialFieldElementsMap = null;
       _enclosingClass = outerClass;
     }
   }
+
   Object visitClassTypeAlias(ClassTypeAlias node) {
     checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
     checkForAllMixinErrorCodes(node.withClause);
     ClassElement outerClassElement = _enclosingClass;
     try {
       _enclosingClass = node.element;
       checkForRecursiveInterfaceInheritance(node.element);
       checkForTypeAliasCannotReferenceItself_mixin(node);
     } finally {
       _enclosingClass = outerClassElement;
     }
     return super.visitClassTypeAlias(node);
   }
+
   Object visitComment(Comment node) {
     _isInComment = true;
     try {
       return super.visitComment(node);
     } finally {
       _isInComment = false;
     }
   }
+
   Object visitConditionalExpression(ConditionalExpression node) {
     checkForNonBoolCondition(node.condition);
     return super.visitConditionalExpression(node);
   }
+
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       _isEnclosingConstructorConst = node.constKeyword != null;
       checkForConstConstructorWithNonFinalField(node);
       checkForConstConstructorWithNonConstSuper(node);
       checkForConflictingConstructorNameAndMember(node);
       checkForAllFinalInitializedErrorCodes(node);
       checkForRedirectingConstructorErrorCodes(node);
       checkForMultipleSuperInitializers(node);
       checkForRecursiveConstructorRedirect(node);
       if (!checkForRecursiveFactoryRedirect(node)) {
         checkForAllRedirectConstructorErrorCodes(node);
       }
       checkForUndefinedConstructorInInitializerImplicit(node);
       checkForRedirectToNonConstConstructor(node);
       checkForReturnInGenerativeConstructor(node);
       return super.visitConstructorDeclaration(node);
     } finally {
       _isEnclosingConstructorConst = false;
       _enclosingFunction = outerFunction;
     }
   }
+
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     _isInConstructorInitializer = true;
     try {
       checkForFieldInitializerNotAssignable(node);
       return super.visitConstructorFieldInitializer(node);
     } finally {
       _isInConstructorInitializer = false;
     }
   }
+
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     checkForInvalidAssignment2(node.identifier, node.defaultValue);
     checkForDefaultValueInFunctionTypedParameter(node);
     return super.visitDefaultFormalParameter(node);
   }
+
   Object visitDoStatement(DoStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitDoStatement(node);
   }
+
   Object visitExportDirective(ExportDirective node) {
     checkForAmbiguousExport(node);
     checkForExportDuplicateLibraryName(node);
     checkForExportInternalLibrary(node);
     return super.visitExportDirective(node);
   }
+
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
     FunctionType functionType = _enclosingFunction == null ? null : _enclosingFunction.type;
     Type2 expectedReturnType = functionType == null ? DynamicTypeImpl.instance : functionType.returnType;
     checkForReturnOfInvalidType(node.expression, expectedReturnType);
     return super.visitExpressionFunctionBody(node);
   }
+
   Object visitFieldDeclaration(FieldDeclaration node) {
     if (!node.isStatic) {
       VariableDeclarationList variables = node.fields;
       if (variables.isConst) {
-        _errorReporter.reportError4(CompileTimeErrorCode.CONST_INSTANCE_FIELD, variables.keyword, []);
+        _errorReporter.reportError5(CompileTimeErrorCode.CONST_INSTANCE_FIELD, variables.keyword, []);
       }
     }
     _isInStaticVariableDeclaration = node.isStatic;
     _isInInstanceVariableDeclaration = !_isInStaticVariableDeclaration;
     try {
       checkForAllInvalidOverrideErrorCodes2(node);
       return super.visitFieldDeclaration(node);
     } finally {
       _isInStaticVariableDeclaration = false;
       _isInInstanceVariableDeclaration = false;
     }
   }
+
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     checkForConstFormalParameter(node);
     checkForPrivateOptionalParameter(node);
     checkForFieldInitializingFormalRedirectingConstructor(node);
     return super.visitFieldFormalParameter(node);
   }
+
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       SimpleIdentifier identifier = node.name;
       String methodName = "";
       if (identifier != null) {
         methodName = identifier.name;
       }
       _enclosingFunction = node.element;
       if (node.isSetter || node.isGetter) {
         checkForMismatchedAccessorTypes(node, methodName);
         if (node.isSetter) {
           FunctionExpression functionExpression = node.functionExpression;
           if (functionExpression != null) {
             checkForWrongNumberOfParametersForSetter(node.name, functionExpression.parameters);
           }
           TypeName returnType = node.returnType;
           checkForNonVoidReturnTypeForSetter(returnType);
         }
       }
       return super.visitFunctionDeclaration(node);
     } finally {
       _enclosingFunction = outerFunction;
     }
   }
+
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is! FunctionDeclaration) {
       ExecutableElement outerFunction = _enclosingFunction;
       try {
         _enclosingFunction = node.element;
         return super.visitFunctionExpression(node);
       } finally {
         _enclosingFunction = outerFunction;
       }
     } else {
       return super.visitFunctionExpression(node);
     }
   }
+
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     Expression functionExpression = node.function;
     Type2 expressionType = functionExpression.staticType;
     if (!isFunctionType(expressionType)) {
       _errorReporter.reportError2(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION_EXPRESSION, functionExpression, []);
     }
     return super.visitFunctionExpressionInvocation(node);
   }
+
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
     checkForDefaultValueInFunctionTypeAlias(node);
     checkForTypeAliasCannotReferenceItself_function(node);
     return super.visitFunctionTypeAlias(node);
   }
+
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     bool old = _isInFunctionTypedFormalParameter;
     _isInFunctionTypedFormalParameter = true;
     try {
       return super.visitFunctionTypedFormalParameter(node);
     } finally {
       _isInFunctionTypedFormalParameter = old;
     }
   }
+
   Object visitIfStatement(IfStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitIfStatement(node);
   }
+
   Object visitImportDirective(ImportDirective node) {
     checkForImportDuplicateLibraryName(node);
     checkForImportInternalLibrary(node);
     return super.visitImportDirective(node);
   }
+
   Object visitIndexExpression(IndexExpression node) {
     checkForArgumentTypeNotAssignable2(node.index);
     return super.visitIndexExpression(node);
   }
+
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     _isInConstInstanceCreation = node.isConst;
     try {
       ConstructorName constructorName = node.constructorName;
       TypeName typeName = constructorName.type;
       Type2 type = typeName.type;
       if (type is InterfaceType) {
         InterfaceType interfaceType = type as InterfaceType;
         checkForConstOrNewWithAbstractClass(node, typeName, interfaceType);
         if (_isInConstInstanceCreation) {
           checkForConstWithNonConst(node);
           checkForConstWithUndefinedConstructor(node);
           checkForConstWithTypeParameters(node);
         } else {
           checkForNewWithUndefinedConstructor(node);
         }
       }
       return super.visitInstanceCreationExpression(node);
     } finally {
       _isInConstInstanceCreation = false;
     }
   }
+
   Object visitListLiteral(ListLiteral node) {
     if (node.constKeyword != null) {
       TypeArgumentList typeArguments = node.typeArguments;
       if (typeArguments != null) {
         NodeList<TypeName> arguments = typeArguments.arguments;
         if (arguments.length != 0) {
           checkForInvalidTypeArgumentInConstTypedLiteral(arguments, CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST);
         }
       }
     }
     checkForExpectedOneListTypeArgument(node);
     checkForListElementTypeNotAssignable(node);
     return super.visitListLiteral(node);
   }
+
   Object visitMapLiteral(MapLiteral node) {
     TypeArgumentList typeArguments = node.typeArguments;
     if (typeArguments != null) {
       NodeList<TypeName> arguments = typeArguments.arguments;
       if (arguments.length != 0) {
         if (node.constKeyword != null) {
           checkForInvalidTypeArgumentInConstTypedLiteral(arguments, CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP);
         }
       }
     }
     checkExpectedTwoMapTypeArguments(typeArguments);
     checkForNonConstMapAsExpressionStatement(node);
     checkForMapTypeNotAssignable(node);
     checkForConstMapKeyExpressionTypeImplementsEquals2(node);
     return super.visitMapLiteral(node);
   }
+
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement previousFunction = _enclosingFunction;
     try {
       _isInStaticMethod = node.isStatic;
       _enclosingFunction = node.element;
       SimpleIdentifier identifier = node.name;
       String methodName = "";
       if (identifier != null) {
         methodName = identifier.name;
       }
       if (node.isSetter || node.isGetter) {
         checkForMismatchedAccessorTypes(node, methodName);
-        checkForConflictingInstanceGetterAndSuperclassMember(node);
       }
       if (node.isGetter) {
         checkForConflictingStaticGetterAndInstanceSetter(node);
       } else if (node.isSetter) {
         checkForWrongNumberOfParametersForSetter(node.name, node.parameters);
         checkForNonVoidReturnTypeForSetter(node.returnType);
         checkForConflictingStaticSetterAndInstanceMember(node);
       } else if (node.isOperator) {
         checkForOptionalParameterInOperator(node);
         checkForWrongNumberOfParametersForOperator(node);
         checkForNonVoidReturnTypeForOperator(node);
+      } else {
+        checkForConflictingInstanceMethodSetter(node);
       }
       checkForConcreteClassWithAbstractMember(node);
       checkForAllInvalidOverrideErrorCodes3(node);
       return super.visitMethodDeclaration(node);
     } finally {
       _enclosingFunction = previousFunction;
       _isInStaticMethod = false;
     }
   }
+
   Object visitMethodInvocation(MethodInvocation node) {
     Expression target = node.realTarget;
     SimpleIdentifier methodName = node.methodName;
-    checkForStaticAccessToInstanceMember(target, methodName);
-    checkForInstanceAccessToStaticMember(target, methodName);
-    if (target == null) {
+    if (target != null) {
+      ClassElement typeReference = ElementResolver.getTypeReference(target);
+      checkForStaticAccessToInstanceMember(typeReference, methodName);
+      checkForInstanceAccessToStaticMember(typeReference, methodName);
+    } else {
       checkForUnqualifiedReferenceToNonLocalStaticMember(methodName);
     }
     return super.visitMethodInvocation(node);
   }
+
   Object visitNativeClause(NativeClause node) {
     if (!_isInSystemLibrary) {
       _errorReporter.reportError2(ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE, node, []);
     }
     return super.visitNativeClause(node);
   }
+
   Object visitNativeFunctionBody(NativeFunctionBody node) {
     checkForNativeFunctionBodyInNonSDKCode(node);
     return super.visitNativeFunctionBody(node);
   }
+
   Object visitPostfixExpression(PostfixExpression node) {
     checkForAssignmentToFinal2(node.operand);
     checkForIntNotAssignable(node.operand);
     return super.visitPostfixExpression(node);
   }
+
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (node.parent is! Annotation) {
-      checkForStaticAccessToInstanceMember(node.prefix, node.identifier);
-      checkForInstanceAccessToStaticMember(node.prefix, node.identifier);
+      ClassElement typeReference = ElementResolver.getTypeReference(node.prefix);
+      SimpleIdentifier name = node.identifier;
+      checkForStaticAccessToInstanceMember(typeReference, name);
+      checkForInstanceAccessToStaticMember(typeReference, name);
     }
     return super.visitPrefixedIdentifier(node);
   }
+
   Object visitPrefixExpression(PrefixExpression node) {
     sc.TokenType operatorType = node.operator.type;
     Expression operand = node.operand;
     if (identical(operatorType, sc.TokenType.BANG)) {
       checkForNonBoolNegationExpression(operand);
     } else if (operatorType.isIncrementOperator) {
       checkForAssignmentToFinal2(operand);
     }
     checkForIntNotAssignable(operand);
     return super.visitPrefixExpression(node);
   }
+
   Object visitPropertyAccess(PropertyAccess node) {
-    Expression target = node.realTarget;
+    ClassElement typeReference = ElementResolver.getTypeReference(node.realTarget);
     SimpleIdentifier propertyName = node.propertyName;
-    checkForStaticAccessToInstanceMember(target, propertyName);
-    checkForInstanceAccessToStaticMember(target, propertyName);
+    checkForStaticAccessToInstanceMember(typeReference, propertyName);
+    checkForInstanceAccessToStaticMember(typeReference, propertyName);
     return super.visitPropertyAccess(node);
   }
+
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     _isInConstructorInitializer = true;
     try {
       return super.visitRedirectingConstructorInvocation(node);
     } finally {
       _isInConstructorInitializer = false;
     }
   }
+
   Object visitRethrowExpression(RethrowExpression node) {
     checkForRethrowOutsideCatch(node);
     return super.visitRethrowExpression(node);
   }
+
   Object visitReturnStatement(ReturnStatement node) {
     if (node.expression == null) {
       _returnWithoutCount++;
     } else {
       _returnWithCount++;
     }
     checkForAllReturnStatementErrorCodes(node);
     return super.visitReturnStatement(node);
   }
+
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     checkForConstFormalParameter(node);
     checkForPrivateOptionalParameter(node);
     return super.visitSimpleFormalParameter(node);
   }
+
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     checkForImplicitThisReferenceInInitializer(node);
     if (!isUnqualifiedReferenceToNonLocalStaticMemberAllowed(node)) {
       checkForUnqualifiedReferenceToNonLocalStaticMember(node);
     }
     return super.visitSimpleIdentifier(node);
   }
+
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     _isInConstructorInitializer = true;
     try {
       return super.visitSuperConstructorInvocation(node);
     } finally {
       _isInConstructorInitializer = false;
     }
   }
+
   Object visitSwitchStatement(SwitchStatement node) {
     checkForInconsistentCaseExpressionTypes(node);
     checkForSwitchExpressionNotAssignable(node);
     checkForCaseBlocksNotTerminated(node);
     return super.visitSwitchStatement(node);
   }
+
   Object visitThisExpression(ThisExpression node) {
     checkForInvalidReferenceToThis(node);
     return super.visitThisExpression(node);
   }
+
   Object visitThrowExpression(ThrowExpression node) {
     checkForConstEvalThrowsException(node);
     return super.visitThrowExpression(node);
   }
+
   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_PARAMETER_NAME);
     checkForTypeParameterSupertypeOfItsBound(node);
     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;
     try {
       if (initializerNode != null) {
         initializerNode.accept(this);
       }
     } finally {
       _isInInstanceVariableInitializer = false;
       _namesForReferenceToDeclaredVariableInInitializer.remove(name);
     }
     return null;
   }
+
   Object visitVariableDeclarationList(VariableDeclarationList node) => super.visitVariableDeclarationList(node);
+
   Object visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     checkForFinalNotInitialized2(node.variables);
     return super.visitVariableDeclarationStatement(node);
   }
+
   Object visitWhileStatement(WhileStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitWhileStatement(node);
   }
 
   /**
    * This verifies if the passed map literal has type arguments then there is exactly two.
    *
    * @param node the map literal to evaluate
    * @return `true` if and only if an error code is generated on the passed node
@@ skipping 27 matching lines @@
     }
     if (_isInNativeClass) {
       return false;
     }
     bool foundError = false;
     Map<FieldElement, INIT_STATE> fieldElementsMap = new Map<FieldElement, INIT_STATE>.from(_initialFieldElementsMap);
     NodeList<FormalParameter> formalParameters = node.parameters.parameters;
     for (FormalParameter formalParameter in formalParameters) {
       FormalParameter parameter = formalParameter;
       if (parameter is DefaultFormalParameter) {
-        parameter = ((parameter as DefaultFormalParameter)).parameter;
+        parameter = (parameter as DefaultFormalParameter).parameter;
       }
       if (parameter is FieldFormalParameter) {
-        FieldElement fieldElement = ((parameter.element as FieldFormalParameterElementImpl)).field;
+        FieldElement fieldElement = (parameter.element as FieldFormalParameterElementImpl).field;
         INIT_STATE state = fieldElementsMap[fieldElement];
         if (identical(state, INIT_STATE.NOT_INIT)) {
           fieldElementsMap[fieldElement] = INIT_STATE.INIT_IN_FIELD_FORMAL;
         } else if (identical(state, INIT_STATE.INIT_IN_DECLARATION)) {
           if (fieldElement.isFinal || fieldElement.isConst) {
             _errorReporter.reportError2(StaticWarningCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR, formalParameter.identifier, [fieldElement.displayName]);
             foundError = true;
           }
         } else if (identical(state, INIT_STATE.INIT_IN_FIELD_FORMAL)) {
           if (fieldElement.isFinal || fieldElement.isConst) {
@@ skipping 358 matching lines @@
     }
     bool problemReported = false;
     for (TypeName mixinName in withClause.mixinTypes) {
       Type2 mixinType = mixinName.type;
       if (mixinType is! InterfaceType) {
         continue;
       }
       if (checkForExtendsOrImplementsDisallowedClass(mixinName, CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS)) {
         problemReported = true;
       } else {
-        ClassElement mixinElement = ((mixinType as InterfaceType)).element;
+        ClassElement mixinElement = (mixinType as InterfaceType).element;
         problemReported = javaBooleanOr(problemReported, checkForMixinDeclaresConstructor(mixinName, mixinElement));
         problemReported = javaBooleanOr(problemReported, checkForMixinInheritsNotFromObject(mixinName, mixinElement));
         problemReported = javaBooleanOr(problemReported, checkForMixinReferencesSuper(mixinName, mixinElement));
       }
     }
     return problemReported;
   }
 
   /**
    * This checks error related to the redirected constructors.
@@ skipping 53 matching lines @@
    * @param node the return statement to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#RETURN_IN_GENERATIVE_CONSTRUCTOR
    * @see StaticWarningCode#RETURN_WITHOUT_VALUE
    * @see StaticTypeWarningCode#RETURN_OF_INVALID_TYPE
    */
   bool checkForAllReturnStatementErrorCodes(ReturnStatement node) {
     FunctionType functionType = _enclosingFunction == null ? null : _enclosingFunction.type;
     Type2 expectedReturnType = functionType == null ? DynamicTypeImpl.instance : functionType.returnType;
     Expression returnExpression = node.expression;
-    bool isGenerativeConstructor = _enclosingFunction is ConstructorElement && !((_enclosingFunction as ConstructorElement)).isFactory;
+    bool isGenerativeConstructor = _enclosingFunction is ConstructorElement && !(_enclosingFunction as ConstructorElement).isFactory;
     if (isGenerativeConstructor) {
       if (returnExpression == null) {
         return false;
       }
       _errorReporter.reportError2(CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR, returnExpression, []);
       return true;
     }
     if (returnExpression == null) {
       if (VoidTypeImpl.instance.isAssignableTo(expectedReturnType)) {
         return false;
@@ skipping 15 matching lines @@
   bool checkForAmbiguousExport(ExportDirective node) {
     if (node.element is! ExportElement) {
       return false;
     }
     ExportElement exportElement = node.element as ExportElement;
     LibraryElement exportedLibrary = exportElement.exportedLibrary;
     if (exportedLibrary == null) {
       return false;
     }
     Namespace namespace = new NamespaceBuilder().createExportNamespace(exportElement);
-    Set<String> newNames = namespace.definedNames.keys.toSet();
-    for (String name in newNames) {
-      ExportElement prevElement = _exportedNames[name];
-      if (prevElement != null && prevElement != exportElement) {
+    Map<String, Element> definedNames = namespace.definedNames;
+    for (MapEntry<String, Element> definedEntry in getMapEntrySet(definedNames)) {
+      String name = definedEntry.getKey();
+      Element element = definedEntry.getValue();
+      Element prevElement = _exportedElements[name];
+      if (element != null && prevElement != null && prevElement != element) {
         _errorReporter.reportError2(CompileTimeErrorCode.AMBIGUOUS_EXPORT, node, [
             name,
-            prevElement.exportedLibrary.definingCompilationUnit.displayName,
-            exportedLibrary.definingCompilationUnit.displayName]);
+            prevElement.library.definingCompilationUnit.displayName,
+            element.library.definingCompilationUnit.displayName]);
         return true;
       } else {
-        _exportedNames[name] = exportElement;
+        _exportedElements[name] = element;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed argument definition test identifier is a parameter.
    *
    * @param node the [ArgumentDefinitionTest] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
@@ skipping 116 matching lines @@
    *
    * @param node the expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ASSIGNMENT_TO_CONST
    * @see StaticWarningCode#ASSIGNMENT_TO_FINAL
    * @see StaticWarningCode#ASSIGNMENT_TO_METHOD
    */
   bool checkForAssignmentToFinal2(Expression expression) {
     Element element = null;
     if (expression is Identifier) {
-      element = ((expression as Identifier)).staticElement;
+      element = (expression as Identifier).staticElement;
     }
     if (expression is PropertyAccess) {
-      element = ((expression as PropertyAccess)).propertyName.staticElement;
+      element = (expression as PropertyAccess).propertyName.staticElement;
     }
     if (element is PropertyAccessorElement) {
       PropertyAccessorElement accessor = element as PropertyAccessorElement;
       element = accessor.variable;
     }
     if (element is VariableElement) {
       VariableElement variable = element as VariableElement;
       if (variable.isConst) {
         _errorReporter.reportError2(StaticWarningCode.ASSIGNMENT_TO_CONST, expression, []);
         return true;
@@ skipping 54 matching lines @@
         if (index != -1 && index < members.length - 1) {
           return false;
         }
       }
     } else {
       Statement statement = statements[statements.length - 1];
       if (statement is BreakStatement || statement is ContinueStatement || statement is ReturnStatement) {
         return false;
       }
       if (statement is ExpressionStatement) {
-        Expression expression = ((statement as ExpressionStatement)).expression;
+        Expression expression = (statement as ExpressionStatement).expression;
         if (expression is ThrowExpression) {
           return false;
         }
       }
     }
-    _errorReporter.reportError4(StaticWarningCode.CASE_BLOCK_NOT_TERMINATED, node.keyword, []);
+    _errorReporter.reportError5(StaticWarningCode.CASE_BLOCK_NOT_TERMINATED, node.keyword, []);
     return true;
   }
 
   /**
    * This verifies that the switch cases in the given switch statement is terminated with 'break',
    * 'continue', 'return' or 'throw'.
    *
    * @param node the switch statement containing the cases to be checked
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CASE_BLOCK_NOT_TERMINATED
@@ skipping 17 matching lines @@
    *
    * @param node the switch statement to evaluate
    * @param type the common type of all 'case' expressions
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
    */
   bool checkForCaseExpressionTypeImplementsEquals(SwitchStatement node, Type2 type) {
     if (!implementsEqualsWhenNotAllowed(type)) {
       return false;
     }
-    _errorReporter.reportError4(CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, node.keyword, [type.displayName]);
+    _errorReporter.reportError5(CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, node.keyword, [type.displayName]);
     return true;
   }
 
   /**
    * This verifies that the passed method declaration is abstract only if the enclosing class is
    * also abstract.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONCRETE_CLASS_WITH_ABSTRACT_MEMBER
@@ skipping 69 matching lines @@
       return false;
     }
     bool hasProblem = false;
     for (MethodElement method in _enclosingClass.methods) {
       String name = method.name;
       ExecutableElement inherited = _inheritanceManager.lookupInheritance(_enclosingClass, name);
       if (inherited is! PropertyAccessorElement) {
         continue;
       }
       hasProblem = true;
-      _errorReporter.reportError3(CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD, method.nameOffset, name.length, [
+      _errorReporter.reportError4(CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD, method.nameOffset, name.length, [
           _enclosingClass.displayName,
           inherited.enclosingElement.displayName,
           name]);
     }
     for (PropertyAccessorElement accessor in _enclosingClass.accessors) {
       if (!accessor.isGetter) {
         continue;
       }
       String name = accessor.name;
       ExecutableElement inherited = _inheritanceManager.lookupInheritance(_enclosingClass, name);
       if (inherited is! MethodElement) {
         continue;
       }
       hasProblem = true;
-      _errorReporter.reportError3(CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER, accessor.nameOffset, name.length, [
+      _errorReporter.reportError4(CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER, accessor.nameOffset, name.length, [
           _enclosingClass.displayName,
           inherited.enclosingElement.displayName,
           name]);
     }
     return hasProblem;
   }
 
   /**
-   * This verifies that the superclass of the enclosing class does not declare accessible static
-   * member with the same name as the passed instance getter/setter method declaration.
+   * This verifies that the superclass of the [enclosingClass] does not declare accessible
+   * static members with the same name as the instance getters/setters declared in
+   * [enclosingClass].
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER
    * @see StaticWarningCode#CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER
    */
-  bool checkForConflictingInstanceGetterAndSuperclassMember(MethodDeclaration node) {
+  bool checkForConflictingInstanceGetterAndSuperclassMember() {
+    if (_enclosingClass == null) {
+      return false;
+    }
+    InterfaceType enclosingType = _enclosingClass.type;
+    bool hasProblem = false;
+    for (PropertyAccessorElement accessor in _enclosingClass.accessors) {
+      if (accessor.isStatic) {
+        continue;
+      }
+      String name = accessor.displayName;
+      bool getter = accessor.isGetter;
+      if (accessor.isSetter && accessor.isSynthetic) {
+        continue;
+      }
+      ExecutableElement superElement;
+      superElement = enclosingType.lookUpGetterInSuperclass(name, _currentLibrary);
+      if (superElement == null) {
+        superElement = enclosingType.lookUpSetterInSuperclass(name, _currentLibrary);
+      }
+      if (superElement == null) {
+        superElement = enclosingType.lookUpMethodInSuperclass(name, _currentLibrary);
+      }
+      if (superElement == null) {
+        continue;
+      }
+      if (!superElement.isStatic) {
+        continue;
+      }
+      ClassElement superElementClass = superElement.enclosingElement as ClassElement;
+      InterfaceType superElementType = superElementClass.type;
+      hasProblem = true;
+      if (getter) {
+        _errorReporter.reportError3(StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER, accessor, [superElementType.displayName]);
+      } else {
+        _errorReporter.reportError3(StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER, accessor, [superElementType.displayName]);
+      }
+    }
+    return hasProblem;
+  }
+
+  /**
+   * This verifies that the enclosing class does not have a setter with the same name as the passed
+   * instance method declaration.
+   *
+   * @param node the method declaration to evaluate
+   * @return `true` if and only if an error code is generated on the passed node
+   * @see StaticWarningCode#CONFLICTING_INSTANCE_METHOD_SETTER
+   */
+  bool checkForConflictingInstanceMethodSetter(MethodDeclaration node) {
     if (node.isStatic) {
       return false;
     }
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
     }
     String name = nameNode.name;
     if (_enclosingClass == null) {
       return false;
     }
-    InterfaceType enclosingType = _enclosingClass.type;
-    ExecutableElement superElement;
-    superElement = enclosingType.lookUpGetterInSuperclass(name, _currentLibrary);
-    if (superElement == null) {
-      superElement = enclosingType.lookUpSetterInSuperclass(name, _currentLibrary);
-    }
-    if (superElement == null) {
-      superElement = enclosingType.lookUpMethodInSuperclass(name, _currentLibrary);
-    }
-    if (superElement == null) {
+    ExecutableElement setter = _inheritanceManager.lookupMember(_enclosingClass, "${name}=");
+    if (setter == null) {
       return false;
     }
-    if (!superElement.isStatic) {
-      return false;
-    }
-    ClassElement superElementClass = superElement.enclosingElement as ClassElement;
-    InterfaceType superElementType = superElementClass.type;
-    if (node.isGetter) {
-      _errorReporter.reportError2(StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER, nameNode, [superElementType.displayName]);
-    } else {
-      _errorReporter.reportError2(StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER, nameNode, [superElementType.displayName]);
-    }
+    _errorReporter.reportError2(StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER, nameNode, [
+        _enclosingClass.displayName,
+        name,
+        setter.enclosingElement.displayName]);
     return true;
   }
 
   /**
    * This verifies that the enclosing class does not have an instance member with the same name as
    * the passed static getter method declaration.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER
@@ skipping 71 matching lines @@
    * @param node the class declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONFLICTING_TYPE_VARIABLE_AND_CLASS
    * @see CompileTimeErrorCode#CONFLICTING_TYPE_VARIABLE_AND_MEMBER
    */
   bool checkForConflictingTypeVariableErrorCodes(ClassDeclaration node) {
     bool problemReported = false;
     for (TypeParameterElement typeParameter in _enclosingClass.typeParameters) {
       String name = typeParameter.name;
       if (_enclosingClass.name == name) {
-        _errorReporter.reportError3(CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_CLASS, typeParameter.nameOffset, name.length, [name]);
+        _errorReporter.reportError4(CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_CLASS, typeParameter.nameOffset, name.length, [name]);
         problemReported = true;
       }
       if (_enclosingClass.getMethod(name) != null || _enclosingClass.getGetter(name) != null || _enclosingClass.getSetter(name) != null) {
-        _errorReporter.reportError3(CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER, typeParameter.nameOffset, name.length, [name]);
+        _errorReporter.reportError4(CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER, typeParameter.nameOffset, name.length, [name]);
         problemReported = true;
       }
     }
     return problemReported;
   }
 
   /**
    * This verifies that if the passed constructor declaration is 'const' then there are no
    * invocations of non-'const' super constructors.
    *
@@ skipping 135 matching lines @@
    *          [InstanceCreationExpression], this is the AST node that the error is attached to
    * @param type the type being constructed with this [InstanceCreationExpression]
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONST_WITH_ABSTRACT_CLASS
    * @see StaticWarningCode#NEW_WITH_ABSTRACT_CLASS
    */
   bool checkForConstOrNewWithAbstractClass(InstanceCreationExpression node, TypeName typeName, InterfaceType type) {
     if (type.element.isAbstract) {
       ConstructorElement element = node.staticElement;
       if (element != null && !element.isFactory) {
-        if (identical(((node.keyword as sc.KeywordToken)).keyword, sc.Keyword.CONST)) {
+        if (identical((node.keyword as sc.KeywordToken).keyword, sc.Keyword.CONST)) {
           _errorReporter.reportError2(StaticWarningCode.CONST_WITH_ABSTRACT_CLASS, typeName, []);
         } else {
           _errorReporter.reportError2(StaticWarningCode.NEW_WITH_ABSTRACT_CLASS, typeName, []);
         }
         return true;
       }
     }
     return false;
   }
 
@@ skipping 179 matching lines @@
     if (name == null) {
       return false;
     }
     ExecutableElement inheritedMember = _inheritanceManager.lookupInheritance(_enclosingClass, name);
     if (inheritedMember == null) {
       return false;
     }
     if (inheritedMember.isStatic) {
       return false;
     }
-    _errorReporter.reportError3(CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE, staticMember.nameOffset, name.length, [name, inheritedMember.enclosingElement.displayName]);
+    _errorReporter.reportError4(CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE, staticMember.nameOffset, name.length, [name, inheritedMember.enclosingElement.displayName]);
     return true;
   }
 
   /**
    * This verifies if the passed list literal has type arguments then there is exactly one.
    *
    * @param node the list literal to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#EXPECTED_ONE_LIST_TYPE_ARGUMENTS
    */
@@ skipping 101 matching lines @@
   bool checkForExtendsOrImplementsDisallowedClass(TypeName typeName, ErrorCode errorCode) {
     if (typeName.isSynthetic) {
       return false;
     }
     Type2 superType = typeName.type;
     for (InterfaceType disallowedType in _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT) {
       if (superType != null && superType == disallowedType) {
         if (superType == _typeProvider.numType) {
           ASTNode grandParent = typeName.parent.parent;
           if (grandParent is ClassDeclaration) {
-            ClassElement classElement = ((grandParent as ClassDeclaration)).element;
+            ClassElement classElement = (grandParent as ClassDeclaration).element;
             Type2 classType = classElement.type;
             if (classType != null && (classType == _typeProvider.intType || classType == _typeProvider.doubleType)) {
               return false;
             }
           }
         }
         _errorReporter.reportError2(errorCode, typeName, [disallowedType.displayName]);
         return true;
       }
     }
@@ skipping 316 matching lines @@
     if (errors == null || errors.isEmpty) {
       return false;
     }
     for (AnalysisError error in errors) {
       _errorReporter.reportError(error);
     }
     return true;
   }
 
   /**
-   * This checks that if the given "target" is not a type reference then the "name" is reference to
-   * an instance member.
+   * This checks the given "typeReference" is not a type reference and that then the "name" is
+   * reference to an instance member.
    *
-   * @param target the target of the name access to evaluate
+   * @param typeReference the resolved [ClassElement] of the left hand side of the expression,
+   *          or `null`, aka, the class element of 'C' in 'C.x', see
+   *          [getTypeReference]
    * @param name the accessed name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INSTANCE_ACCESS_TO_STATIC_MEMBER
    */
-  bool checkForInstanceAccessToStaticMember(Expression target, SimpleIdentifier name) {
-    if (target == null) {
-      return false;
-    }
+  bool checkForInstanceAccessToStaticMember(ClassElement typeReference, SimpleIdentifier name) {
     if (_isInComment) {
       return false;
     }
+    if (typeReference != null) {
+      return false;
+    }
     Element element = name.staticElement;
     if (element is! ExecutableElement) {
       return false;
     }
     ExecutableElement executableElement = element as ExecutableElement;
     if (executableElement.enclosingElement is! ClassElement) {
       return false;
     }
     if (!executableElement.isStatic) {
       return false;
     }
-    if (isTypeReference(target)) {
-      return false;
-    }
     _errorReporter.reportError2(StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER, name, [name.name]);
     return true;
   }
 
   /**
    * This verifies that an 'int' can be assigned to the parameter corresponding to the given
    * expression. This is used for prefix and postfix expressions where the argument value is
    * implicit.
    *
    * @param argument the expression to which the operator is being applied
@@ skipping 194 matching lines @@
     if (_enclosingClass == null) {
       return false;
     }
     String className = _enclosingClass.name;
     if (className == null) {
       return false;
     }
     bool problemReported = false;
     for (PropertyAccessorElement accessor in _enclosingClass.accessors) {
       if (className == accessor.name) {
-        _errorReporter.reportError3(CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME, accessor.nameOffset, className.length, []);
+        _errorReporter.reportError4(CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME, accessor.nameOffset, className.length, []);
         problemReported = true;
       }
     }
     return problemReported;
   }
 
   /**
    * Check to make sure that all similarly typed accessors are of the same type (including inherited
    * accessors).
    *
@@ skipping 263 matching lines @@
     MemberMap membersInheritedFromInterfaces = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(_enclosingClass);
     MemberMap membersInheritedFromSuperclasses = _inheritanceManager.getMapOfMembersInheritedFromClasses(_enclosingClass);
     for (int i = 0; i < membersInheritedFromInterfaces.size; i++) {
       String memberName = membersInheritedFromInterfaces.getKey(i);
       ExecutableElement executableElt = membersInheritedFromInterfaces.getValue(i);
       if (memberName == null) {
         break;
       }
       ExecutableElement elt = membersInheritedFromSuperclasses.get(executableElt.name);
       if (elt != null) {
-        if (elt is MethodElement && !((elt as MethodElement)).isAbstract) {
+        if (elt is MethodElement && !(elt as MethodElement).isAbstract) {
           continue;
-        } else if (elt is PropertyAccessorElement && !((elt as PropertyAccessorElement)).isAbstract) {
+        } else if (elt is PropertyAccessorElement && !(elt as PropertyAccessorElement).isAbstract) {
           continue;
         }
       }
       if (executableElt is MethodElement) {
         if (!methodsInEnclosingClass.contains(memberName) && !memberHasConcreteMethodImplementationInSuperclassChain(_enclosingClass, memberName, new List<ClassElement>())) {
           javaSetAdd(missingOverrides, executableElt);
         }
       } else if (executableElt is PropertyAccessorElement) {
         if (!accessorsInEnclosingClass.contains(memberName) && !memberHasConcreteAccessorImplementationInSuperclassChain(_enclosingClass, memberName, new List<ClassElement>())) {
           javaSetAdd(missingOverrides, executableElt);
@@ skipping 292 matching lines @@
     if (size > 0 && _enclosingClass == classElt) {
       String enclosingClassName = _enclosingClass.displayName;
       if (size > 1) {
         String separator = ", ";
         JavaStringBuilder builder = new JavaStringBuilder();
         for (int i = 0; i < size; i++) {
           builder.append(path[i].displayName);
           builder.append(separator);
         }
         builder.append(classElt.displayName);
-        _errorReporter.reportError3(CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, _enclosingClass.nameOffset, enclosingClassName.length, [enclosingClassName, builder.toString()]);
+        _errorReporter.reportError4(CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, _enclosingClass.nameOffset, enclosingClassName.length, [enclosingClassName, builder.toString()]);
         return true;
       } else {
         InterfaceType supertype = classElt.supertype;
         ErrorCode errorCode = (supertype != null && _enclosingClass == supertype.element ? CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS : CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS) as ErrorCode;
-        _errorReporter.reportError3(errorCode, _enclosingClass.nameOffset, enclosingClassName.length, [enclosingClassName]);
+        _errorReporter.reportError4(errorCode, _enclosingClass.nameOffset, enclosingClassName.length, [enclosingClassName]);
         return true;
       }
     }
     if (path.indexOf(classElt) > 0) {
       return false;
     }
     path.add(classElt);
     InterfaceType supertype = classElt.supertype;
     if (supertype != null && checkForRecursiveInterfaceInheritance2(supertype.element, path)) {
       return true;
@@ skipping 17 matching lines @@
    * @see CompileTimeErrorCode#DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR
    * @see CompileTimeErrorCode#FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR
    * @see CompileTimeErrorCode#MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS
    * @see CompileTimeErrorCode#SUPER_IN_REDIRECTING_CONSTRUCTOR
    */
   bool checkForRedirectingConstructorErrorCodes(ConstructorDeclaration node) {
     bool errorReported = false;
     ConstructorName redirectedConstructor = node.redirectedConstructor;
     if (redirectedConstructor != null) {
       for (FormalParameter parameter in node.parameters.parameters) {
-        if (parameter is DefaultFormalParameter && ((parameter as DefaultFormalParameter)).defaultValue != null) {
+        if (parameter is DefaultFormalParameter && (parameter as DefaultFormalParameter).defaultValue != null) {
           _errorReporter.reportError2(CompileTimeErrorCode.DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR, parameter.identifier, []);
           errorReported = true;
         }
       }
     }
     int numRedirections = 0;
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is RedirectingConstructorInvocation) {
         if (numRedirections > 0) {
           _errorReporter.reportError2(CompileTimeErrorCode.MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS, initializer, []);
@@ skipping 125 matching lines @@
       }
       _errorReporter.reportError2(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
           staticReturnType.displayName,
           expectedReturnType.displayName,
           _enclosingFunction.displayName]);
       return true;
     }
   }
 
   /**
-   * This checks that if the given "target" is the type reference then the "name" is not the
-   * reference to a instance member.
+   * This checks the given "typeReference" and that the "name" is not the reference to an instance
+   * member.
    *
-   * @param target the target of the name access to evaluate
+   * @param typeReference the resolved [ClassElement] of the left hand side of the expression,
+   *          or `null`, aka, the class element of 'C' in 'C.x', see
+   *          [getTypeReference]
    * @param name the accessed name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#STATIC_ACCESS_TO_INSTANCE_MEMBER
    */
-  bool checkForStaticAccessToInstanceMember(Expression target, SimpleIdentifier name) {
+  bool checkForStaticAccessToInstanceMember(ClassElement typeReference, SimpleIdentifier name) {
+    if (typeReference == null) {
+      return false;
+    }
     Element element = name.staticElement;
     if (element is! ExecutableElement) {
       return false;
     }
     ExecutableElement memberElement = element as ExecutableElement;
     if (memberElement.isStatic) {
       return false;
     }
-    if (!isTypeReference(target)) {
-      return false;
-    }
     _errorReporter.reportError2(StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER, name, [name.name]);
     return true;
   }
 
   /**
    * This checks that the type of the passed 'switch' expression is assignable to the type of the
    * 'case' members.
    *
    * @param node the 'switch' statement to evaluate
    * @return `true` if and only if an error code is generated on the passed node
@@ skipping 69 matching lines @@
       return false;
     }
     Element element = type.element;
     if (element is! ClassElement) {
       return false;
     }
     ClassElement classElement = element as ClassElement;
     List<Type2> typeParameters = classElement.type.typeArguments;
     List<TypeParameterElement> boundingElts = classElement.typeParameters;
     NodeList<TypeName> typeNameArgList = node.typeArguments.arguments;
-    List<Type2> typeArguments = ((type as InterfaceType)).typeArguments;
+    List<Type2> typeArguments = (type as InterfaceType).typeArguments;
     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;
       if (argType != null && boundType != null) {
         boundType = boundType.substitute2(typeArguments, typeParameters);
         if (!argType.isSubtypeOf(boundType)) {
           ErrorCode errorCode;
@@ skipping 85 matching lines @@
       }
       if (!superUnnamedConstructor.isDefaultConstructor) {
         int offset;
         int length;
         {
           Identifier returnType = node.returnType;
           SimpleIdentifier name = node.name;
           offset = returnType.offset;
           length = (name != null ? name.end : returnType.end) - offset;
         }
-        _errorReporter.reportError3(CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT, offset, length, [superType.displayName]);
+        _errorReporter.reportError4(CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT, offset, length, [superType.displayName]);
       }
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT, node.returnType, [superElement.name]);
     return true;
   }
 
   /**
    * 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 name) {
     Element element = name.staticElement;
     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)) {
+    if ((element is MethodElement && !(element as MethodElement).isStatic) || (element is PropertyAccessorElement && !(element as PropertyAccessorElement).isStatic)) {
       return false;
     }
     if (identical(enclosingElement, _enclosingClass)) {
       return false;
     }
     _errorReporter.reportError2(StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER, name, [name.name]);
     return true;
   }
 
   /**
@@ skipping 73 matching lines @@
       return false;
     }
     ClassElement classElement = node.element;
     if (classElement == null) {
       return false;
     }
     if (!classElement.type.isSubtypeOf(_typeProvider.functionType)) {
       return false;
     }
     ExecutableElement callMethod = _inheritanceManager.lookupMember(classElement, "call");
-    if (callMethod == null || callMethod is! MethodElement || ((callMethod as MethodElement)).isAbstract) {
+    if (callMethod == null || callMethod is! MethodElement || (callMethod as MethodElement).isAbstract) {
       _errorReporter.reportError2(StaticWarningCode.FUNCTION_WITHOUT_CALL, node.name, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the given class declaration does not have the same class in the 'extends'
    * and 'implements' clauses.
    *
@@ skipping 64 matching lines @@
 
   /**
    * Return the variable element represented by the given expression, or `null` if there is no
    * such element.
    *
    * @param expression the expression whose element is to be returned
    * @return the variable element represented by the expression
    */
   VariableElement getVariableElement(Expression expression) {
     if (expression is Identifier) {
-      Element element = ((expression as Identifier)).staticElement;
+      Element element = (expression as Identifier).staticElement;
       if (element is VariableElement) {
         return element as VariableElement;
       }
     }
     return null;
   }
 
   /**
    * @return `true` if the given constructor redirects to itself, directly or indirectly
    */
   bool hasRedirectingFactoryConstructorCycle(ConstructorElement element) {
     Set<ConstructorElement> constructors = new Set<ConstructorElement>();
     ConstructorElement current = element;
     while (current != null) {
       if (constructors.contains(current)) {
         return identical(current, element);
       }
       javaSetAdd(constructors, current);
       current = current.redirectedConstructor;
       if (current is ConstructorMember) {
-        current = ((current as ConstructorMember)).baseElement;
+        current = (current as ConstructorMember).baseElement;
       }
     }
     return false;
   }
 
   /**
    * @return <code>true</code> if given [Element] has direct or indirect reference to itself
    *         from anywhere except [ClassElement] or type parameter bounds.
    */
   bool hasTypedefSelfReference(Element target) {
@@ skipping 13 matching lines @@
             firstIteration = false;
             break;
           } else {
             return true;
           }
         }
         if (current != null && !checked.contains(current)) {
           break;
         }
       }
-      current.accept(new GeneralizingElementVisitor_14(target, toCheck));
+      current.accept(new GeneralizingElementVisitor_15(target, toCheck));
       javaSetAdd(checked, current);
     }
   }
 
   /**
    * @return `true` if given [Type] implements operator <i>==</i>, and it is not
    *         <i>int</i> or <i>String</i>.
    */
   bool implementsEqualsWhenNotAllowed(Type2 type) {
     if (type == null || type == _typeProvider.intType || type == _typeProvider.stringType) {
       return false;
     }
     Element element = type.element;
     if (element is! ClassElement) {
       return false;
     }
     ClassElement classElement = element as ClassElement;
     MethodElement method = classElement.lookUpMethod("==", _currentLibrary);
     if (method == null || method.enclosingElement.type.isObject) {
       return false;
     }
     return true;
   }
+
   bool isFunctionType(Type2 type) {
     if (type.isDynamic || type.isBottom) {
       return true;
     } else if (type is FunctionType || type.isDartCoreFunction) {
       return true;
     } else if (type is InterfaceType) {
-      MethodElement callMethod = ((type as InterfaceType)).lookUpMethod(ElementResolver.CALL_METHOD_NAME, _currentLibrary);
+      MethodElement callMethod = (type as InterfaceType).lookUpMethod(ElementResolver.CALL_METHOD_NAME, _currentLibrary);
       return callMethod != null;
     }
     return false;
   }
 
   /**
    * @return `true` if the given [ASTNode] is the part of constant constructor
    *         invocation.
    */
   bool isInConstConstructorInvocation(ASTNode node) {
@@ skipping 37 matching lines @@
    *         a static member of a supertype
    */
   bool isUnqualifiedReferenceToNonLocalStaticMemberAllowed(SimpleIdentifier node) {
     if (node.inDeclarationContext()) {
       return true;
     }
     ASTNode parent = node.parent;
     if (parent is ConstructorName || parent is MethodInvocation || parent is PropertyAccess || parent is SuperConstructorInvocation) {
       return true;
     }
-    if (parent is PrefixedIdentifier && identical(((parent as PrefixedIdentifier)).identifier, node)) {
+    if (parent is PrefixedIdentifier && identical((parent as PrefixedIdentifier).identifier, node)) {
       return true;
     }
-    if (parent is Annotation && identical(((parent as Annotation)).constructorName, node)) {
+    if (parent is Annotation && identical((parent as Annotation).constructorName, node)) {
       return true;
     }
     if (parent is CommentReference) {
       CommentReference commentReference = parent as CommentReference;
       if (commentReference.newKeyword != null) {
         return true;
       }
     }
     return false;
   }
@@ skipping 73 matching lines @@
     InterfaceType superType = classElement.supertype;
     if (superType != null) {
       ClassElement superClassElt = superType.element;
       if (superClassElt != null) {
         return memberHasConcreteMethodImplementationInSuperclassChain(superClassElt, methodName, superclassChain);
       }
     }
     return false;
   }
 }
+
 /**
  * This enum holds one of four states of a field initialization state through a constructor
  * signature, not initialized, initialized in the field declaration, initialized in the field
  * formal, and finally, initialized in the initializers list.
  */
 class INIT_STATE extends Enum<INIT_STATE> {
   static final INIT_STATE NOT_INIT = new INIT_STATE('NOT_INIT', 0);
+
   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_14 extends GeneralizingElementVisitor<Object> {
+
+class GeneralizingElementVisitor_15 extends GeneralizingElementVisitor<Object> {
   Element target;
+
   List<Element> toCheck;
-  GeneralizingElementVisitor_14(this.target, this.toCheck) : super();
+
+  GeneralizingElementVisitor_15(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 visitTypeParameterElement(TypeParameterElement element) {
     addTypeToCheck(element.bound);
     return super.visitTypeParameterElement(element);
   }
+
   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) {
       return;
     }
     toCheck.add(element);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type as InterfaceType;
       for (Type2 typeArgument in interfaceType.typeArguments) {
         addTypeToCheck(typeArgument);
       }
     }
   }
 }
+
 /**
  * The enumeration `ResolverErrorCode` defines the error codes used for errors detected by the
  * resolver. The convention for this class is for the name of the error code to indicate the problem
  * that caused the error to be generated and for the error message to explain what is wrong and,
  * when appropriate, how the problem can be corrected.
  *
  * @coverage dart.engine.resolver
  */
 class ResolverErrorCode extends Enum<ResolverErrorCode> implements ErrorCode {
   static final ResolverErrorCode BREAK_LABEL_ON_SWITCH_MEMBER = new ResolverErrorCode.con1('BREAK_LABEL_ON_SWITCH_MEMBER', 0, ErrorType.COMPILE_TIME_ERROR, "Break label resolves to case or default statement");
+
   static final ResolverErrorCode CONTINUE_LABEL_ON_SWITCH = new ResolverErrorCode.con1('CONTINUE_LABEL_ON_SWITCH', 1, ErrorType.COMPILE_TIME_ERROR, "A continue label resolves to switch, must be loop or switch member");
+
   static final ResolverErrorCode MISSING_LIBRARY_DIRECTIVE_WITH_PART = new ResolverErrorCode.con1('MISSING_LIBRARY_DIRECTIVE_WITH_PART', 2, ErrorType.COMPILE_TIME_ERROR, "Libraries that have parts must have a library directive");
+
   static final List<ResolverErrorCode> values = [
       BREAK_LABEL_ON_SWITCH_MEMBER,
       CONTINUE_LABEL_ON_SWITCH,
       MISSING_LIBRARY_DIRECTIVE_WITH_PART];
 
   /**
    * The type of this error.
    */
   ErrorType _type;
 
@@ skipping 24 matching lines @@
    *
    * @param type the type of this error
    * @param message the template used to create the message to be displayed for the error
    * @param correction the template used to create the correction to be displayed for the error
    */
   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;
 }