Rename analyzer-experimental to analyzer_experimental.

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

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.resolver;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart';
 import 'error.dart';
 import 'scanner.dart' as sc;
 import 'utilities_dart.dart';
 import 'ast.dart';
 import 'parser.dart' show Parser;
 import 'element.dart' hide HideCombinator, ShowCombinator;
 import 'html.dart' as ht;
 import 'engine.dart';
+import 'constant.dart';
 import 'element.dart' as __imp_combi show HideCombinator, ShowCombinator;
 
 /**
  * Instances of the class {@code CompilationUnitBuilder} build an element model for a single
  * compilation unit.
  * @coverage dart.engine.resolver
  */
 class CompilationUnitBuilder {
   /**
    * The analysis context in which the element model will be built.
@@ skipping 137 matching lines @@
     visitChildren(holder, node);
     SimpleIdentifier constructorName = node.name;
     ConstructorElementImpl element = new ConstructorElementImpl(constructorName);
     if (node.factoryKeyword != null) {
       element.factory = true;
     }
     element.functions = holder.functions;
     element.labels = holder.labels;
     element.localVariables = holder.localVariables;
     element.parameters = holder.parameters;
+    element.const2 = node.constKeyword != null;
     _currentHolder.addConstructor(element);
     node.element = element;
     if (constructorName != null) {
       constructorName.element = element;
     }
     return null;
   }
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
     sc.Token keyword27 = 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.const2 = matches(keyword27, sc.Keyword.CONST);
+    element.const3 = matches(keyword27, sc.Keyword.CONST);
     element.final2 = matches(keyword27, sc.Keyword.FINAL);
     _currentHolder.addLocalVariable(element);
     variableName.element = 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 = new ParameterElementImpl(parameterName);
-    parameter.const2 = node.isConst();
+    ParameterElementImpl parameter;
+    if (node.isConst()) {
+      parameter = new ConstParameterElementImpl(parameterName);
+      parameter.const3 = true;
+    } else {
+      parameter = new ParameterElementImpl(parameterName);
+    }
     parameter.final2 = node.isFinal();
     parameter.initializer = initializer;
     parameter.parameterKind = node.kind;
     FunctionBody body = getFunctionBody(node);
     if (body != null) {
       parameter.setVisibleRange(body.offset, body.length);
     }
     _currentHolder.addParameter(parameter);
     parameterName.element = parameter;
     node.parameter.accept(this);
     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;
       ParameterElementImpl parameter = new ParameterElementImpl(parameterName);
-      parameter.const2 = node.isConst();
+      parameter.const3 = node.isConst();
       parameter.initializingFormal = true;
       parameter.final2 = node.isFinal();
       parameter.parameterKind = node.kind;
       _currentHolder.addParameter(parameter);
       parameterName.element = parameter;
     }
     return super.visitFieldFormalParameter(node);
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     FunctionExpression expression = node.functionExpression;
@@ skipping 86 matching lines @@
     _currentHolder.addFunction(element);
     node.element = element;
     return null;
   }
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     ElementHolder holder = new ElementHolder();
     visitChildren(holder, node);
     SimpleIdentifier aliasName = node.name;
     List<ParameterElement> parameters10 = holder.parameters;
     List<TypeVariableElement> typeVariables6 = holder.typeVariables;
-    TypeAliasElementImpl element = new TypeAliasElementImpl(aliasName);
+    FunctionTypeAliasElementImpl element = new FunctionTypeAliasElementImpl(aliasName);
     element.parameters = parameters10;
     element.typeVariables = typeVariables6;
     FunctionTypeImpl type = new FunctionTypeImpl.con2(element);
     type.typeArguments = createTypeVariableTypes(typeVariables6);
     element.type = type;
     _currentHolder.addTypeAlias(element);
     aliasName.element = element;
     return null;
   }
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
@@ skipping 76 matching lines @@
         _currentHolder.addAccessor(setter);
         propertyNameNode.element = setter;
       }
     }
     return null;
   }
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter = new ParameterElementImpl(parameterName);
-      parameter.const2 = node.isConst();
+      parameter.const3 = node.isConst();
       parameter.final2 = node.isFinal();
       parameter.parameterKind = node.kind;
       _currentHolder.addParameter(parameter);
       parameterName.element = parameter;
     }
     return super.visitSimpleFormalParameter(node);
   }
   Object visitSuperExpression(SuperExpression node) {
     _isValidMixin = false;
     return super.visitSuperExpression(node);
@@ skipping 19 matching lines @@
   Object visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
     TypeVariableElementImpl element = new TypeVariableElementImpl(parameterName);
     TypeVariableTypeImpl type = new TypeVariableTypeImpl(element);
     element.type = type;
     _currentHolder.addTypeVariable(element);
     parameterName.element = element;
     return super.visitTypeParameter(node);
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
+    sc.Token keyword28 = ((node.parent as VariableDeclarationList)).keyword;
+    bool isConst = matches(keyword28, sc.Keyword.CONST);
+    bool isFinal = matches(keyword28, sc.Keyword.FINAL);
+    bool hasInitializer = node.initializer != null;
     VariableElementImpl element;
     if (_inFieldContext) {
       SimpleIdentifier fieldName = node.name;
-      FieldElementImpl field = new FieldElementImpl.con1(fieldName);
+      FieldElementImpl field;
+      if (isConst && hasInitializer) {
+        field = new ConstFieldElementImpl(fieldName);
+      } else {
+        field = new FieldElementImpl.con1(fieldName);
+      }
       element = field;
       _currentHolder.addField(field);
       fieldName.element = field;
     } else if (_inFunction) {
       SimpleIdentifier variableName = node.name;
-      element = new LocalVariableElementImpl(variableName);
+      LocalVariableElementImpl variable;
+      if (isConst && hasInitializer) {
+        variable = new ConstLocalVariableElementImpl(variableName);
+      } else {
+        variable = new LocalVariableElementImpl(variableName);
+      }
+      element = variable;
       Block enclosingBlock = node.getAncestor(Block);
       int functionEnd = node.offset + node.length;
       int blockEnd = enclosingBlock.offset + enclosingBlock.length;
-      ((element as LocalVariableElementImpl)).setVisibleRange(functionEnd, blockEnd - functionEnd - 1);
-      _currentHolder.addLocalVariable((element as LocalVariableElementImpl));
+      variable.setVisibleRange(functionEnd, blockEnd - functionEnd - 1);
+      _currentHolder.addLocalVariable(variable);
       variableName.element = element;
     } else {
       SimpleIdentifier variableName = node.name;
-      element = new TopLevelVariableElementImpl.con1(variableName);
-      _currentHolder.addTopLevelVariable((element as TopLevelVariableElementImpl));
+      TopLevelVariableElementImpl variable;
+      if (isConst && hasInitializer) {
+        variable = new ConstTopLevelVariableElementImpl(variableName);
+      } else {
+        variable = new TopLevelVariableElementImpl.con1(variableName);
+      }
+      element = variable;
+      _currentHolder.addTopLevelVariable(variable);
       variableName.element = element;
     }
-    sc.Token keyword28 = ((node.parent as VariableDeclarationList)).keyword;
-    bool isFinal = matches(keyword28, sc.Keyword.FINAL);
-    element.const2 = matches(keyword28, sc.Keyword.CONST);
+    element.const3 = isConst;
     element.final2 = isFinal;
-    if (node.initializer != null) {
+    if (hasInitializer) {
       ElementHolder holder = new ElementHolder();
       bool wasInFieldContext = _inFieldContext;
       _inFieldContext = false;
       try {
         visit(holder, node.initializer);
       } finally {
         _inFieldContext = wasInFieldContext;
       }
       FunctionElementImpl initializer = new FunctionElementImpl();
       initializer.functions = holder.functions;
@@ skipping 95 matching lines @@
  * @coverage dart.engine.resolver
  */
 class ElementHolder {
   List<PropertyAccessorElement> _accessors = new List<PropertyAccessorElement>();
   List<ConstructorElement> _constructors = new List<ConstructorElement>();
   List<FieldElement> _fields = new List<FieldElement>();
   List<FunctionElement> _functions = new List<FunctionElement>();
   List<LabelElement> _labels = new List<LabelElement>();
   List<VariableElement> _localVariables = new List<VariableElement>();
   List<MethodElement> _methods = new List<MethodElement>();
-  List<TypeAliasElement> _typeAliases = new List<TypeAliasElement>();
+  List<FunctionTypeAliasElement> _typeAliases = new List<FunctionTypeAliasElement>();
   List<ParameterElement> _parameters = new List<ParameterElement>();
   List<VariableElement> _topLevelVariables = new List<VariableElement>();
   List<ClassElement> _types = new List<ClassElement>();
   List<TypeVariableElement> _typeVariables = new List<TypeVariableElement>();
   /**
    * Initialize a newly created element holder.
    */
   ElementHolder() : super() {
   }
   void addAccessor(PropertyAccessorElement element) {
@@ skipping 19 matching lines @@
   }
   void addParameter(ParameterElement element) {
     _parameters.add(element);
   }
   void addTopLevelVariable(TopLevelVariableElement element) {
     _topLevelVariables.add(element);
   }
   void addType(ClassElement element) {
     _types.add(element);
   }
-  void addTypeAlias(TypeAliasElement element) {
+  void addTypeAlias(FunctionTypeAliasElement element) {
     _typeAliases.add(element);
   }
   void addTypeVariable(TypeVariableElement element) {
     _typeVariables.add(element);
   }
   List<PropertyAccessorElement> get accessors => new List.from(_accessors);
   List<ConstructorElement> get constructors => new List.from(_constructors);
   FieldElement getField(String fieldName) {
     for (FieldElement field in _fields) {
       if (field.name == fieldName) {
         return field;
       }
     }
     return null;
   }
   List<FieldElement> get fields => new List.from(_fields);
   List<FunctionElement> get functions => new List.from(_functions);
   List<LabelElement> get labels => new List.from(_labels);
   List<LocalVariableElement> get localVariables => new List.from(_localVariables);
   List<MethodElement> get methods => new List.from(_methods);
   List<ParameterElement> get parameters => new List.from(_parameters);
   List<TopLevelVariableElement> get topLevelVariables => new List.from(_topLevelVariables);
-  List<TypeAliasElement> get typeAliases => new List.from(_typeAliases);
+  List<FunctionTypeAliasElement> get typeAliases => new List.from(_typeAliases);
   List<ClassElement> get types => new List.from(_types);
   List<TypeVariableElement> get typeVariables => new List.from(_typeVariables);
 }
 /**
  * Instances of the class {@code 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";
@@ skipping 182 matching lines @@
    */
   ElementResolver(ResolverVisitor resolver) {
     this._resolver = resolver;
   }
   Object visitAssignmentExpression(AssignmentExpression node) {
     sc.TokenType operator7 = node.operator.type;
     if (operator7 != sc.TokenType.EQ) {
       operator7 = operatorFromCompoundAssignment(operator7);
       Expression leftNode = node.leftHandSide;
       if (leftNode != null) {
-        Type2 leftType = leftNode.staticType;
+        Type2 leftType = getType(leftNode);
         if (leftType != null) {
           Element leftElement = leftType.element;
           if (leftElement != null) {
             MethodElement method = lookUpMethod(leftElement, operator7.lexeme);
             if (method != null) {
               node.element = method;
             } else {
             }
           }
         }
@@ skipping 59 matching lines @@
   }
   Object visitContinueStatement(ContinueStatement node) {
     SimpleIdentifier labelNode = node.label;
     LabelElementImpl labelElement = lookupLabel(node, labelNode);
     if (labelElement != null && labelElement.isOnSwitchStatement()) {
       _resolver.reportError(ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH, labelNode, []);
     }
     return null;
   }
   Object visitExportDirective(ExportDirective node) {
-    Element element21 = node.element;
-    if (element21 is ExportElement) {
-      resolveCombinators(((element21 as ExportElement)).exportedLibrary, node.combinators);
+    Element element22 = node.element;
+    if (element22 is ExportElement) {
+      resolveCombinators(((element22 as ExportElement)).exportedLibrary, node.combinators);
     }
     return null;
   }
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => null;
   Object visitImportDirective(ImportDirective node) {
     SimpleIdentifier prefixNode = node.prefix;
     if (prefixNode != null) {
       String prefixName = prefixNode.name;
       for (PrefixElement prefixElement in _resolver.definingLibrary.prefixes) {
         if (prefixElement.name == prefixName) {
           recordResolution(prefixNode, prefixElement);
           break;
         }
       }
     }
-    Element element22 = node.element;
-    if (element22 is ImportElement) {
-      resolveCombinators(((element22 as ImportElement)).importedLibrary, node.combinators);
+    Element element23 = node.element;
+    if (element23 is ImportElement) {
+      resolveCombinators(((element23 as ImportElement)).importedLibrary, node.combinators);
     }
     return null;
   }
   Object visitIndexExpression(IndexExpression node) {
     Type2 arrayType = getType(node.realTarget);
     if (arrayType == null || arrayType.isDynamic()) {
       return null;
     }
     Element arrayTypeElement = arrayType.element;
     String operator;
@@ skipping 23 matching lines @@
     if (target == null) {
       element = _resolver.nameScope.lookup(methodName2, _resolver.definingLibrary);
       if (element == null) {
         element = lookUpMethod(_resolver.enclosingClass, methodName2.name);
         if (element == null) {
           PropertyAccessorElement getter = lookUpGetter(_resolver.enclosingClass, methodName2.name);
           if (getter != null) {
             FunctionType getterType = getter.type;
             if (getterType != null) {
               Type2 returnType4 = getterType.returnType;
-              if (!returnType4.isDynamic() && returnType4 is! FunctionType && !returnType4.isDartCoreFunction()) {
+              if (!isExecutableType(returnType4)) {
                 _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
               }
             }
             recordResolution(methodName2, getter);
             return null;
           }
         }
       }
     } else {
       Type2 targetType = getType(target);
       if (targetType is InterfaceType) {
         element = lookUpMethod(targetType.element, methodName2.name);
         if (element == null) {
-          PropertyAccessorElement accessor = lookUpGetterInType((targetType.element as ClassElement), methodName2.name);
+          ClassElement targetClass = targetType.element as ClassElement;
+          PropertyAccessorElement accessor = lookUpGetterInType(targetClass, methodName2.name);
           if (accessor != null) {
-            Type2 returnType5 = accessor.type.returnType;
-            if (!returnType5.isDynamic() && returnType5 is! FunctionType && !returnType5.isDartCoreFunction()) {
+            Type2 returnType5 = accessor.type.returnType.substitute2(((targetType as InterfaceType)).typeArguments, TypeVariableTypeImpl.getTypes(targetClass.typeVariables));
+            if (!isExecutableType(returnType5)) {
               _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
               return null;
             }
             element = accessor;
           }
         }
         if (element == null && target is SuperExpression) {
           _resolver.reportError(StaticTypeWarningCode.UNDEFINED_SUPER_METHOD, methodName2, [methodName2.name, targetType.element.name]);
           return null;
         }
@@ skipping 12 matching lines @@
     }
     ExecutableElement invokedMethod = null;
     if (element is ExecutableElement) {
       invokedMethod = element as ExecutableElement;
     } else {
       if (element is PropertyInducingElement) {
         PropertyAccessorElement getter3 = ((element as PropertyInducingElement)).getter;
         FunctionType getterType = getter3.type;
         if (getterType != null) {
           Type2 returnType6 = getterType.returnType;
-          if (!returnType6.isDynamic() && returnType6 is! FunctionType && !returnType6.isDartCoreFunction()) {
+          if (!isExecutableType(returnType6)) {
             _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
           }
         }
         recordResolution(methodName2, element);
         return null;
       } else if (element is VariableElement) {
         Type2 variableType = ((element as VariableElement)).type;
-        if (!variableType.isDynamic() && variableType is! FunctionType && !variableType.isDartCoreFunction()) {
+        if (!isExecutableType(variableType)) {
           _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
         }
         recordResolution(methodName2, element);
         return null;
       } else {
         _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
         return null;
       }
     }
     recordResolution(methodName2, invokedMethod);
@@ skipping 278 matching lines @@
    * @param expression the expression whose type is to be returned
    * @return the type of the given expression
    */
   Type2 getType(Expression expression) {
     if (expression is NullLiteral) {
       return _resolver.typeProvider.objectType;
     }
     return expression.staticType;
   }
   /**
+   * Return {@code true} if the given type represents an object that could be invoked using the call
+   * operator '()'.
+   * @param type the type being tested
+   * @return {@code true} if the given type represents an object that could be invoked
+   */
+  bool isExecutableType(Type2 type) => type.isDynamic() || (type is FunctionType) || type.isDartCoreFunction();
+  /**
    * Look up the getter with the given name in the given type. Return the element representing the
    * getter that was found, or {@code null} if there is no getter with the given name.
    * @param element the element representing the type in which the getter is defined
    * @param getterName the name of the getter being looked up
    * @return the element representing the getter that was found
    */
   PropertyAccessorElement lookUpGetter(Element element, String getterName) {
     if (identical(element, DynamicTypeImpl.instance)) {
       return null;
     }
@@ skipping 261 matching lines @@
       break;
     }
     AnalysisEngine.instance.logger.logError("Failed to map ${operator.lexeme} to it's corresponding operator");
     return operator;
   }
   /**
    * Record the fact that the given AST node was resolved to the given element.
    * @param node the AST node that was resolved
    * @param element the element to which the AST node was resolved
    */
-  void recordResolution(SimpleIdentifier node, Element element49) {
-    if (element49 != null) {
-      node.element = element49;
+  void recordResolution(SimpleIdentifier node, Element element52) {
+    if (element52 != null) {
+      node.element = element52;
     }
   }
   /**
    * Report the {@link StaticTypeWarningCode}s <code>UNDEFINED_SETTER</code> and
    * <code>UNDEFINED_GETTER</code>.
    * @param node the prefixed identifier that gives the context to determine if the error on the
    * undefined identifier is a getter or a setter
    * @param identifier the identifier in the passed prefix identifier
    * @param typeName the name of the type of the left hand side of the passed prefixed identifier
    */
@@ skipping 49 matching lines @@
       }
     }
   }
   /**
    * If the given element is a type variable, resolve it to the class that should be used when
    * looking up members. Otherwise, return the original element.
    * @param element the element that is to be resolved if it is a type variable
    * @return the class that should be used in place of the argument if it is a type variable, or the
    * original argument if it isn't a type variable
    */
-  Element resolveTypeVariable(Element element50) {
-    if (element50 is TypeVariableElement) {
-      Type2 bound4 = ((element50 as TypeVariableElement)).bound;
+  Element resolveTypeVariable(Element element53) {
+    if (element53 is TypeVariableElement) {
+      Type2 bound4 = ((element53 as TypeVariableElement)).bound;
       if (bound4 == null) {
         return _resolver.typeProvider.objectType.element;
       }
       return bound4.element;
     }
-    return element50;
+    return element53;
   }
 }
 class Identifier_4 extends Identifier {
   String name9;
   Identifier_4(this.name9) : super();
   accept(ASTVisitor visitor) => null;
   sc.Token get beginToken => null;
   Element get element => null;
   sc.Token get endToken => null;
   String get name => name9;
@@ skipping 407 matching lines @@
   Map<Source, Library> _libraryMap = new Map<Source, Library>();
   /**
    * A collection containing the libraries that are being resolved together.
    */
   Set<Library> _librariesInCycles;
   /**
    * Initialize a newly created library resolver to resolve libraries within the given context.
    * @param analysisContext the analysis context in which the library is being analyzed
    */
   LibraryResolver.con1(AnalysisContextImpl analysisContext) {
-    _jtd_constructor_226_impl(analysisContext);
+    _jtd_constructor_237_impl(analysisContext);
   }
-  _jtd_constructor_226_impl(AnalysisContextImpl analysisContext) {
-    _jtd_constructor_227_impl(analysisContext, null);
+  _jtd_constructor_237_impl(AnalysisContextImpl analysisContext) {
+    _jtd_constructor_238_impl(analysisContext, null);
   }
   /**
    * Initialize a newly created library resolver to resolve libraries within the given context.
    * @param analysisContext the analysis context in which the library is being analyzed
    * @param errorListener the listener to which analysis errors will be reported
    */
   LibraryResolver.con2(AnalysisContextImpl analysisContext2, AnalysisErrorListener additionalAnalysisErrorListener) {
-    _jtd_constructor_227_impl(analysisContext2, additionalAnalysisErrorListener);
+    _jtd_constructor_238_impl(analysisContext2, additionalAnalysisErrorListener);
   }
-  _jtd_constructor_227_impl(AnalysisContextImpl analysisContext2, AnalysisErrorListener additionalAnalysisErrorListener) {
+  _jtd_constructor_238_impl(AnalysisContextImpl analysisContext2, AnalysisErrorListener additionalAnalysisErrorListener) {
     this._analysisContext = analysisContext2;
     this._recordingErrorListener = new RecordingErrorListener();
     if (additionalAnalysisErrorListener == null) {
       this._errorListener = _recordingErrorListener;
     } else {
       this._errorListener = new AnalysisErrorListener_5(this, additionalAnalysisErrorListener);
     }
     _coreLibrarySource = analysisContext2.sourceFactory.forUri(LibraryElementBuilder.CORE_LIBRARY_URI);
   }
   /**
@@ skipping 783 matching lines @@
     }
     try {
       super.visitSwitchStatement(node);
     } finally {
       _labelScope = outerScope;
     }
     return null;
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
     if (node.parent.parent is! TopLevelVariableDeclaration && node.parent.parent is! FieldDeclaration) {
-      VariableElement element23 = node.element;
-      if (element23 != null) {
-        _nameScope.define(element23);
+      VariableElement element24 = node.element;
+      if (element24 != null) {
+        _nameScope.define(element24);
       }
     }
     super.visitVariableDeclaration(node);
     return null;
   }
   Object visitWhileStatement(WhileStatement node) {
     LabelScope outerScope = _labelScope;
     _labelScope = new LabelScope.con1(outerScope, false, false);
     try {
       super.visitWhileStatement(node);
@@ skipping 320 matching lines @@
   /**
    * The Dart Language Specification, 12.6: <blockquote>The static type of a list literal of the
    * form <i><b>const</b> &lt;E&gt;[e<sub>1</sub>, &hellip;, e<sub>n</sub>]</i> or the form
    * <i>&lt;E&gt;[e<sub>1</sub>, &hellip;, e<sub>n</sub>]</i> is {@code List&lt;E&gt;}. The static
    * type a list literal of the form <i><b>const</b> [e<sub>1</sub>, &hellip;, e<sub>n</sub>]</i> or
    * the form <i>[e<sub>1</sub>, &hellip;, e<sub>n</sub>]</i> is {@code List&lt;dynamic&gt;}.</blockquote>
    */
   Object visitListLiteral(ListLiteral node) {
     TypeArgumentList typeArguments8 = node.typeArguments;
     if (typeArguments8 != null) {
-      NodeList<TypeName> arguments3 = typeArguments8.arguments;
-      if (arguments3 != null && arguments3.length == 1) {
-        TypeName argumentType = arguments3[0];
+      NodeList<TypeName> arguments4 = typeArguments8.arguments;
+      if (arguments4 != null && arguments4.length == 1) {
+        TypeName argumentType = arguments4[0];
         return recordType(node, _typeProvider.listType.substitute5(<Type2> [getType3(argumentType)]));
       }
     }
     return recordType(node, _typeProvider.listType.substitute5(<Type2> [_dynamicType]));
   }
   /**
    * The Dart Language Specification, 12.7: <blockquote>The static type of a map literal of the form
    * <i><b>const</b> &lt;String, V&gt; {k<sub>1</sub>:e<sub>1</sub>, &hellip;,
    * k<sub>n</sub>:e<sub>n</sub>}</i> or the form <i>&lt;String, V&gt; {k<sub>1</sub>:e<sub>1</sub>,
    * &hellip;, k<sub>n</sub>:e<sub>n</sub>}</i> is {@code Map&lt;String, V&gt;}. The static type a
    * map literal of the form <i><b>const</b> {k<sub>1</sub>:e<sub>1</sub>, &hellip;,
    * k<sub>n</sub>:e<sub>n</sub>}</i> or the form <i>{k<sub>1</sub>:e<sub>1</sub>, &hellip;,
    * k<sub>n</sub>:e<sub>n</sub>}</i> is {@code Map&lt;String, dynamic&gt;}.
    * <p>
    * It is a compile-time error if the first type argument to a map literal is not
    * <i>String</i>.</blockquote>
    */
   Object visitMapLiteral(MapLiteral node) {
     TypeArgumentList typeArguments9 = node.typeArguments;
     if (typeArguments9 != null) {
-      NodeList<TypeName> arguments4 = typeArguments9.arguments;
-      if (arguments4 != null && arguments4.length == 2) {
-        TypeName keyType = arguments4[0];
+      NodeList<TypeName> arguments5 = typeArguments9.arguments;
+      if (arguments5 != null && arguments5.length == 2) {
+        TypeName keyType = arguments5[0];
         if (keyType != _typeProvider.stringType) {
         }
-        TypeName valueType = arguments4[1];
+        TypeName valueType = arguments5[1];
         return recordType(node, _typeProvider.mapType.substitute5(<Type2> [_typeProvider.stringType, getType3(valueType)]));
       }
     }
     return recordType(node, _typeProvider.mapType.substitute5(<Type2> [_typeProvider.stringType, _dynamicType]));
   }
   /**
    * The Dart Language Specification, 12.15.1: <blockquote>An ordinary method invocation <i>i</i>
    * has the form <i>o.m(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>: a<sub>n+1</sub>,
    * &hellip;, x<sub>n+k</sub>: a<sub>n+k</sub>)</i>.
    * <p>
@@ skipping 61 matching lines @@
    * <p>
    * A postfix expression of the form <i>e1[e2]--</i> is equivalent to <i>(a, i){var r = a[i]; a[i]
    * = r - 1; return r}(e1, e2)</i></blockquote>
    */
   Object visitPostfixExpression(PostfixExpression node) => recordType(node, getType(node.operand));
   /**
    * See {@link #visitSimpleIdentifier(SimpleIdentifier)}.
    */
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefixedIdentifier = node.identifier;
-    Element element24 = prefixedIdentifier.element;
-    if (element24 is VariableElement) {
-      Type2 variableType = ((element24 as VariableElement)).type;
+    Element element25 = prefixedIdentifier.element;
+    if (element25 is VariableElement) {
+      Type2 variableType = ((element25 as VariableElement)).type;
       recordType(prefixedIdentifier, variableType);
       return recordType(node, variableType);
-    } else if (element24 is PropertyAccessorElement) {
-      Type2 propertyType = getType2((element24 as PropertyAccessorElement));
+    } else if (element25 is PropertyAccessorElement) {
+      Type2 propertyType = getType2((element25 as PropertyAccessorElement));
       recordType(prefixedIdentifier, propertyType);
       return recordType(node, propertyType);
-    } else if (element24 is MethodElement) {
-      Type2 returnType = ((element24 as MethodElement)).type;
+    } else if (element25 is MethodElement) {
+      Type2 returnType = ((element25 as MethodElement)).type;
       recordType(prefixedIdentifier, returnType);
       return recordType(node, returnType);
     } else {
     }
     recordType(prefixedIdentifier, _dynamicType);
     return recordType(node, _dynamicType);
   }
   /**
    * The Dart Language Specification, 12.27: <blockquote>A unary expression <i>u</i> of the form
    * <i>op e</i> is equivalent to a method invocation <i>expression e.op()</i>. An expression of the
@@ skipping 44 matching lines @@
    * The static type of <i>i</i> is the declared return type of <i>C.m</i> if it exists or dynamic
    * otherwise.
    * <p>
    * ... a top-level getter invocation <i>i</i> of the form <i>m</i>, where <i>m</i> is an
    * identifier ...
    * <p>
    * The static type of <i>i</i> is the declared return type of <i>m</i>.</blockquote>
    */
   Object visitPropertyAccess(PropertyAccess node) {
     SimpleIdentifier propertyName2 = node.propertyName;
-    Element element25 = propertyName2.element;
-    if (element25 is MethodElement) {
-      FunctionType type15 = ((element25 as MethodElement)).type;
+    Element element26 = propertyName2.element;
+    if (element26 is MethodElement) {
+      FunctionType type15 = ((element26 as MethodElement)).type;
       recordType(propertyName2, type15);
       return recordType(node, type15);
-    } else if (element25 is PropertyAccessorElement) {
-      Type2 propertyType = getType2((element25 as PropertyAccessorElement));
+    } else if (element26 is PropertyAccessorElement) {
+      Type2 propertyType = getType2((element26 as PropertyAccessorElement));
       recordType(propertyName2, propertyType);
       return recordType(node, propertyType);
     } else {
     }
     recordType(propertyName2, _dynamicType);
     return recordType(node, _dynamicType);
   }
   /**
    * The Dart Language Specification, 12.30: <blockquote>Evaluation of an identifier expression
    * <i>e</i> of the form <i>id</i> proceeds as follows:
@@ skipping 30 matching lines @@
    * <li>If <i>d</i> is the declaration of a top level getter, then <i>e</i> is equivalent to the
    * getter invocation <i>id</i>.
    * <li>Otherwise, if <i>e</i> occurs inside a top level or static function (be it function,
    * method, getter, or setter) or variable initializer, evaluation of e causes a NoSuchMethodError
    * to be thrown.
    * <li>Otherwise <i>e</i> is equivalent to the property extraction <i>this.id</i>.
    * </ul>
    * </blockquote>
    */
   Object visitSimpleIdentifier(SimpleIdentifier node) {
-    Element element26 = node.element;
-    if (element26 == null) {
+    Element element27 = node.element;
+    if (element27 == null) {
       return recordType(node, _dynamicType);
-    } else if (element26 is ClassElement) {
-      if (isTypeName(node)) {
-        return recordType(node, ((element26 as ClassElement)).type);
+    } else if (element27 is ClassElement) {
+      if (isNotTypeLiteral(node)) {
+        return recordType(node, ((element27 as ClassElement)).type);
       }
       return recordType(node, _typeProvider.typeType);
-    } else if (element26 is TypeVariableElement) {
-      return recordType(node, ((element26 as TypeVariableElement)).type);
-    } else if (element26 is TypeAliasElement) {
-      return recordType(node, ((element26 as TypeAliasElement)).type);
-    } else if (element26 is VariableElement) {
-      return recordType(node, ((element26 as VariableElement)).type);
-    } else if (element26 is MethodElement) {
-      return recordType(node, ((element26 as MethodElement)).type);
-    } else if (element26 is PropertyAccessorElement) {
-      return recordType(node, getType2((element26 as PropertyAccessorElement)));
-    } else if (element26 is ExecutableElement) {
-      return recordType(node, ((element26 as ExecutableElement)).type);
-    } else if (element26 is PrefixElement) {
+    } else if (element27 is TypeVariableElement) {
+      return recordType(node, ((element27 as TypeVariableElement)).type);
+    } else if (element27 is FunctionTypeAliasElement) {
+      return recordType(node, ((element27 as FunctionTypeAliasElement)).type);
+    } else if (element27 is VariableElement) {
+      return recordType(node, ((element27 as VariableElement)).type);
+    } else if (element27 is MethodElement) {
+      return recordType(node, ((element27 as MethodElement)).type);
+    } else if (element27 is PropertyAccessorElement) {
+      return recordType(node, getType2((element27 as PropertyAccessorElement)));
+    } else if (element27 is ExecutableElement) {
+      return recordType(node, ((element27 as ExecutableElement)).type);
+    } else if (element27 is PrefixElement) {
       return null;
     } else {
       return recordType(node, _dynamicType);
     }
   }
   /**
    * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is{@code String}.</blockquote>
    */
   Object visitSimpleStringLiteral(SimpleStringLiteral node) => recordType(node, _typeProvider.stringType);
   /**
@@ skipping 95 matching lines @@
    * @return the type represented by the type name
    */
   Type2 getType3(TypeName typeName) {
     Type2 type16 = typeName.type;
     if (type16 == null) {
       return _dynamicType;
     }
     return type16;
   }
   /**
-   * Return {@code true} if the given node is being used as the name of a type.
+   * Return {@code true} if the given node is not a type literal.
    * @param node the node being tested
-   * @return {@code true} if the given node is being used as the name of a type
+   * @return {@code true} if the given node is not a type literal
    */
-  bool isTypeName(SimpleIdentifier node) {
+  bool isNotTypeLiteral(SimpleIdentifier node) {
     ASTNode parent15 = node.parent;
-    return parent15 is TypeName || (parent15 is PrefixedIdentifier && parent15.parent is TypeName) || (parent15 is MethodInvocation && identical(node, ((parent15 as MethodInvocation)).target));
+    return parent15 is TypeName || (parent15 is PrefixedIdentifier && (parent15.parent is TypeName || identical(((parent15 as PrefixedIdentifier)).prefix, node))) || (parent15 is PropertyAccess && identical(((parent15 as PropertyAccess)).target, node)) || (parent15 is MethodInvocation && identical(node, ((parent15 as MethodInvocation)).target));
   }
   /**
    * Record that the static type of the given node is the type of the second argument to the method
    * represented by the given element.
    * @param expression the node whose type is to be recorded
    * @param element the element representing the method invoked by the given node
    */
   Object recordArgumentType(IndexExpression expression, MethodElement element) {
     if (element != null) {
       List<ParameterElement> parameters12 = element.parameters;
@@ skipping 284 matching lines @@
     SimpleIdentifier exception = node.exceptionParameter;
     if (exception != null) {
       TypeName exceptionTypeName = node.exceptionType;
       Type2 exceptionType;
       if (exceptionTypeName == null) {
         exceptionType = typeProvider.objectType;
       } else {
         exceptionType = getType4(exceptionTypeName);
       }
       recordType(exception, exceptionType);
-      Element element27 = exception.element;
-      if (element27 is VariableElementImpl) {
-        ((element27 as VariableElementImpl)).type = exceptionType;
+      Element element28 = exception.element;
+      if (element28 is VariableElementImpl) {
+        ((element28 as VariableElementImpl)).type = exceptionType;
       } else {
       }
     }
     SimpleIdentifier stackTrace = node.stackTraceParameter;
     if (stackTrace != null) {
       recordType(stackTrace, typeProvider.stackTraceType);
     }
     return null;
   }
   Object visitClassDeclaration(ClassDeclaration node) {
@@ skipping 27 matching lines @@
       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 element28 = node.element as ExecutableElementImpl;
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(element28);
-    setTypeInformation(type, null, element28.parameters);
-    type.returnType = ((element28.enclosingElement as ClassElement)).type;
-    element28.type = type;
+    ExecutableElementImpl element29 = node.element as ExecutableElementImpl;
+    FunctionTypeImpl type = new FunctionTypeImpl.con1(element29);
+    setTypeInformation(type, null, element29.parameters);
+    type.returnType = ((element29.enclosingElement as ClassElement)).type;
+    element29.type = type;
     return null;
   }
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     super.visitDeclaredIdentifier(node);
     Type2 declaredType;
     TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = getType4(typeName);
     }
-    LocalVariableElementImpl element29 = node.element as LocalVariableElementImpl;
-    element29.type = declaredType;
+    LocalVariableElementImpl element30 = node.element as LocalVariableElementImpl;
+    element30.type = declaredType;
     return null;
   }
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     super.visitDefaultFormalParameter(node);
     return null;
   }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     super.visitFieldFormalParameter(node);
-    Element element30 = node.identifier.element;
-    if (element30 is ParameterElementImpl) {
-      ParameterElementImpl parameter = element30 as ParameterElementImpl;
+    Element element31 = node.identifier.element;
+    if (element31 is ParameterElementImpl) {
+      ParameterElementImpl parameter = element31 as ParameterElementImpl;
       Type2 type;
       TypeName typeName = node.type;
       if (typeName == null) {
         type = _dynamicType;
       } else {
         type = getType4(typeName);
       }
       parameter.type = type;
     } else {
     }
     return null;
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     super.visitFunctionDeclaration(node);
-    ExecutableElementImpl element31 = node.element as ExecutableElementImpl;
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(element31);
-    setTypeInformation(type, node.returnType, element31.parameters);
-    element31.type = type;
+    ExecutableElementImpl element32 = node.element as ExecutableElementImpl;
+    FunctionTypeImpl type = new FunctionTypeImpl.con1(element32);
+    setTypeInformation(type, node.returnType, element32.parameters);
+    element32.type = type;
     return null;
   }
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     super.visitFunctionTypeAlias(node);
-    TypeAliasElementImpl element32 = node.element as TypeAliasElementImpl;
-    FunctionTypeImpl type18 = element32.type as FunctionTypeImpl;
-    setTypeInformation(type18, node.returnType, element32.parameters);
+    FunctionTypeAliasElementImpl element33 = node.element as FunctionTypeAliasElementImpl;
+    FunctionTypeImpl type18 = element33.type as FunctionTypeImpl;
+    setTypeInformation(type18, node.returnType, element33.parameters);
     return null;
   }
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     super.visitFunctionTypedFormalParameter(node);
-    ParameterElementImpl element33 = node.identifier.element as ParameterElementImpl;
+    ParameterElementImpl element34 = node.identifier.element as ParameterElementImpl;
     FunctionTypeImpl type = new FunctionTypeImpl.con1((null as ExecutableElement));
     setTypeInformation(type, node.returnType, getElements(node.parameters));
-    element33.type = type;
+    element34.type = type;
     return null;
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     super.visitMethodDeclaration(node);
-    ExecutableElementImpl element34 = node.element as ExecutableElementImpl;
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(element34);
-    setTypeInformation(type, node.returnType, element34.parameters);
-    element34.type = type;
-    if (element34 is PropertyAccessorElementImpl) {
-      PropertyAccessorElementImpl accessor = element34 as PropertyAccessorElementImpl;
+    ExecutableElementImpl element35 = node.element as ExecutableElementImpl;
+    FunctionTypeImpl type = new FunctionTypeImpl.con1(element35);
+    setTypeInformation(type, node.returnType, element35.parameters);
+    element35.type = type;
+    if (element35 is PropertyAccessorElementImpl) {
+      PropertyAccessorElementImpl accessor = element35 as PropertyAccessorElementImpl;
       PropertyInducingElementImpl variable5 = accessor.variable as PropertyInducingElementImpl;
       if (accessor.isGetter()) {
         variable5.type = type.returnType;
       } else if (variable5.type == null) {
         List<Type2> parameterTypes = type.normalParameterTypes;
         if (parameterTypes != null && parameterTypes.length > 0) {
           variable5.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 = getType4(typeName);
     }
-    Element element35 = node.identifier.element;
-    if (element35 is ParameterElement) {
-      ((element35 as ParameterElementImpl)).type = declaredType;
+    Element element36 = node.identifier.element;
+    if (element36 is ParameterElement) {
+      ((element36 as ParameterElementImpl)).type = declaredType;
     } else {
     }
     return null;
   }
   Object visitTypeName(TypeName node) {
     super.visitTypeName(node);
     Identifier typeName = node.name;
     TypeArgumentList argumentList = node.typeArguments;
     Element element = nameScope.lookup(typeName, definingLibrary);
     if (element == null) {
@@ skipping 33 matching lines @@
     if (element == null) {
       setElement(typeName, _dynamicType.element);
       typeName.staticType = _dynamicType;
       node.type = _dynamicType;
       return null;
     }
     Type2 type = null;
     if (element is ClassElement) {
       setElement(typeName, element);
       type = ((element as ClassElement)).type;
-    } else if (element is TypeAliasElement) {
+    } else if (element is FunctionTypeAliasElement) {
       setElement(typeName, element);
-      type = ((element as TypeAliasElement)).type;
+      type = ((element as FunctionTypeAliasElement)).type;
     } else if (element is TypeVariableElement) {
       setElement(typeName, element);
       type = ((element as TypeVariableElement)).type;
       if (argumentList != null) {
       }
     } else {
       setElement(typeName, _dynamicType.element);
       typeName.staticType = _dynamicType;
       node.type = _dynamicType;
       return null;
     }
     if (argumentList != null) {
-      NodeList<TypeName> arguments5 = argumentList.arguments;
-      int argumentCount = arguments5.length;
+      NodeList<TypeName> arguments6 = argumentList.arguments;
+      int argumentCount = arguments6.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 = getType4(arguments5[i]);
+        Type2 argumentType = getType4(arguments6[i]);
         if (argumentType != null) {
           typeArguments.add(argumentType);
         }
       }
       if (argumentCount != parameterCount) {
         reportError(getInvalidTypeParametersErrorCode(node), node, [typeName.name, argumentCount, parameterCount]);
       }
       argumentCount = typeArguments.length;
       if (argumentCount < parameterCount) {
         for (int i = argumentCount; i < parameterCount; i++) {
@@ skipping 26 matching lines @@
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     Type2 declaredType;
     TypeName typeName = ((node.parent as VariableDeclarationList)).type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = getType4(typeName);
     }
-    Element element36 = node.name.element;
-    if (element36 is VariableElement) {
-      ((element36 as VariableElementImpl)).type = declaredType;
-      if (element36 is FieldElement) {
-        FieldElement field = element36 as FieldElement;
+    Element element37 = node.name.element;
+    if (element37 is VariableElement) {
+      ((element37 as VariableElementImpl)).type = declaredType;
+      if (element37 is FieldElement) {
+        FieldElement field = element37 as FieldElement;
         PropertyAccessorElementImpl getter5 = field.getter as PropertyAccessorElementImpl;
         FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter5);
         getterType.returnType = declaredType;
         getter5.type = getterType;
         PropertyAccessorElementImpl setter4 = field.setter as PropertyAccessorElementImpl;
         if (setter4 != null) {
           FunctionTypeImpl setterType = new FunctionTypeImpl.con1(setter4);
           setterType.returnType = VoidTypeImpl.instance;
           setterType.normalParameterTypes = <Type2> [declaredType];
           setter4.type = setterType;
         }
       }
     } else {
     }
     return null;
   }
   /**
    * Return the class element that represents the class whose name was provided.
    * @param identifier the name from the declaration of a class
    * @return the class element that represents the class
    */
   ClassElementImpl getClassElement(SimpleIdentifier identifier) {
     if (identifier == null) {
       return null;
     }
-    Element element37 = identifier.element;
-    if (element37 is! ClassElementImpl) {
+    Element element38 = identifier.element;
+    if (element38 is! ClassElementImpl) {
       return null;
     }
-    return element37 as ClassElementImpl;
+    return element38 as ClassElementImpl;
   }
   /**
    * Return an array containing all of the elements associated with the parameters in the given
    * list.
    * @param parameterList the list of parameters whose elements are to be returned
    * @return the elements associated with the parameters
    */
   List<ParameterElement> getElements(FormalParameterList parameterList) {
     List<ParameterElement> elements = new List<ParameterElement>();
     for (FormalParameter parameter in parameterList.parameters) {
-      ParameterElement element38 = parameter.identifier.element as ParameterElement;
-      if (element38 != null) {
-        elements.add(element38);
+      ParameterElement element39 = parameter.identifier.element as ParameterElement;
+      if (element39 != null) {
+        elements.add(element39);
       }
     }
     return new List.from(elements);
   }
   /**
    * The number of type arguments in the given type name does not match the number of parameters in
    * the corresponding class element. Return the error code that should be used to report this
    * error.
    * @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
@@ skipping 97 matching lines @@
    * @param undefinedError the error to produce if the type name is not defined
    * @param nonTypeError the error to produce if the type name is defined to be something other than
    * a type
    * @param nonInterfaceType the error to produce if the type is not an interface type
    * @return the type specified by the type name
    */
   InterfaceType resolveType(TypeName typeName, ErrorCode undefinedError, ErrorCode nonTypeError, ErrorCode nonInterfaceType) {
     Identifier name16 = typeName.name;
     Element element = nameScope.lookup(name16, definingLibrary);
     if (element == null) {
-      reportError(undefinedError, name16, []);
+      reportError(undefinedError, name16, [name16.name]);
     } else if (element is ClassElement) {
       Type2 classType = ((element as ClassElement)).type;
       typeName.type = classType;
       if (classType is InterfaceType) {
         return classType as InterfaceType;
       }
-      reportError(nonInterfaceType, name16, []);
+      reportError(nonInterfaceType, name16, [name16.name]);
     } else if (element is MultiplyDefinedElement) {
       List<Element> elements = ((element as MultiplyDefinedElement)).conflictingElements;
       InterfaceType type = getType(elements);
       if (type != null) {
         typeName.type = type;
       }
     } else {
-      reportError(nonTypeError, name16, []);
+      reportError(nonTypeError, name16, [name16.name]);
     }
     return null;
   }
   /**
    * Resolve the types in the given list of type names.
    * @param typeNames the type names to be resolved
    * @param undefinedError the error to produce if the type name is not defined
    * @param nonTypeError the error to produce if the type name is defined to be something other than
    * a type
    * @param nonInterfaceType the error to produce if the type is not an interface type
    * @return an array containing all of the types that were resolved.
    */
   List<InterfaceType> resolveTypes(NodeList<TypeName> typeNames, ErrorCode undefinedError, ErrorCode nonTypeError, ErrorCode nonInterfaceType) {
     List<InterfaceType> types = new List<InterfaceType>();
     for (TypeName typeName in typeNames) {
       InterfaceType type = resolveType(typeName, undefinedError, nonTypeError, nonInterfaceType);
       if (type != null) {
         types.add(type);
       }
     }
     return new List.from(types);
   }
-  void setElement(Identifier typeName, Element element51) {
-    if (element51 != null) {
+  void setElement(Identifier typeName, Element element54) {
+    if (element54 != null) {
       if (typeName is SimpleIdentifier) {
-        ((typeName as SimpleIdentifier)).element = element51;
+        ((typeName as SimpleIdentifier)).element = element54;
       } else if (typeName is PrefixedIdentifier) {
         PrefixedIdentifier identifier = typeName as PrefixedIdentifier;
-        identifier.identifier.element = element51;
+        identifier.identifier.element = element54;
         SimpleIdentifier prefix9 = identifier.prefix;
         Element prefixElement = nameScope.lookup(prefix9, definingLibrary);
         if (prefixElement != null) {
           prefix9.element = prefixElement;
         }
       }
     }
   }
   /**
    * Set the return type and parameter type information for the given function type based on the
@@ skipping 139 matching lines @@
  * Instances of the class {@code FunctionTypeScope} implement the scope defined by a function type
  * alias.
  * @coverage dart.engine.resolver
  */
 class FunctionTypeScope extends EnclosedScope {
   /**
    * Initialize a newly created scope enclosed within another scope.
    * @param enclosingScope the scope in which this scope is lexically enclosed
    * @param typeElement the element representing the type alias represented by this scope
    */
-  FunctionTypeScope(Scope enclosingScope, TypeAliasElement typeElement) : super(new EnclosedScope(enclosingScope)) {
+  FunctionTypeScope(Scope enclosingScope, FunctionTypeAliasElement typeElement) : super(new EnclosedScope(enclosingScope)) {
     defineTypeParameters(typeElement);
   }
   /**
    * Define the type parameters for the function type alias.
    * @param typeElement the element representing the type represented by this scope
    */
-  void defineTypeParameters(TypeAliasElement typeElement) {
+  void defineTypeParameters(FunctionTypeAliasElement typeElement) {
     Scope parameterScope = enclosingScope;
     for (TypeVariableElement parameter in typeElement.typeVariables) {
       parameterScope.define(parameter);
     }
   }
 }
 /**
  * Instances of the class {@code LabelScope} represent a scope in which a single label is defined.
  * @coverage dart.engine.resolver
  */
@@ skipping 18 matching lines @@
    * The label element returned for scopes that can be the target of an unlabeled {@code break} or{@code continue}.
    */
   static SimpleIdentifier _EMPTY_LABEL_IDENTIFIER = new SimpleIdentifier.full(new sc.StringToken(sc.TokenType.IDENTIFIER, "", 0));
   /**
    * Initialize a newly created scope to represent the potential target of an unlabeled{@code break} or {@code continue}.
    * @param outerScope the label scope enclosing the new label scope
    * @param onSwitchStatement {@code true} if this label is associated with a {@code switch}statement
    * @param onSwitchMember {@code true} if this label is associated with a {@code switch} member
    */
   LabelScope.con1(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) {
-    _jtd_constructor_237_impl(outerScope, onSwitchStatement, onSwitchMember);
+    _jtd_constructor_248_impl(outerScope, onSwitchStatement, onSwitchMember);
   }
-  _jtd_constructor_237_impl(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) {
-    _jtd_constructor_238_impl(outerScope, EMPTY_LABEL, new LabelElementImpl(_EMPTY_LABEL_IDENTIFIER, onSwitchStatement, onSwitchMember));
+  _jtd_constructor_248_impl(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) {
+    _jtd_constructor_249_impl(outerScope, EMPTY_LABEL, new LabelElementImpl(_EMPTY_LABEL_IDENTIFIER, onSwitchStatement, onSwitchMember));
   }
   /**
    * Initialize a newly created scope to represent the given label.
    * @param outerScope the label scope enclosing the new label scope
    * @param label the label defined in this scope
    * @param element the element to which the label resolves
    */
   LabelScope.con2(LabelScope outerScope2, String label4, LabelElement element19) {
-    _jtd_constructor_238_impl(outerScope2, label4, element19);
+    _jtd_constructor_249_impl(outerScope2, label4, element19);
   }
-  _jtd_constructor_238_impl(LabelScope outerScope2, String label4, LabelElement element19) {
+  _jtd_constructor_249_impl(LabelScope outerScope2, String label4, LabelElement element19) {
     this._outerScope = outerScope2;
     this._label = label4;
     this._element = element19;
   }
   /**
    * Return the label element corresponding to the given label, or {@code null} if the given label
    * is not defined in this scope.
    * @param targetLabel the label being looked up
    * @return the label element corresponding to the given label
    */
@@ skipping 109 matching lines @@
    * @param compilationUnit the compilation unit defining the top-level names to be added to this
    * scope
    */
   void defineLocalNames(CompilationUnitElement compilationUnit) {
     for (PropertyAccessorElement element in compilationUnit.accessors) {
       define(element);
     }
     for (FunctionElement element in compilationUnit.functions) {
       define(element);
     }
-    for (TypeAliasElement element in compilationUnit.typeAliases) {
+    for (FunctionTypeAliasElement element in compilationUnit.functionTypeAliases) {
       define(element);
     }
     for (ClassElement element in compilationUnit.types) {
       define(element);
     }
   }
   /**
    * Add to this scope all of the names that are explicitly defined in the given library.
    * @param definingLibrary the element representing the library that defines the names in this
    * scope
@@ skipping 125 matching lines @@
    * @param compilationUnit the compilation unit defining the top-level names to be added to this
    * namespace
    */
   void addPublicNames(Map<String, Element> definedNames, CompilationUnitElement compilationUnit) {
     for (PropertyAccessorElement element in compilationUnit.accessors) {
       addIfPublic(definedNames, element);
     }
     for (FunctionElement element in compilationUnit.functions) {
       addIfPublic(definedNames, element);
     }
-    for (TypeAliasElement element in compilationUnit.typeAliases) {
+    for (FunctionTypeAliasElement element in compilationUnit.functionTypeAliases) {
       addIfPublic(definedNames, element);
     }
     for (ClassElement element in compilationUnit.types) {
       addIfPublic(definedNames, element);
     }
     for (VariableElement element in compilationUnit.topLevelVariables) {
       addIfPublic(definedNames, element);
     }
   }
   /**
@@ skipping 218 matching lines @@
  * 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 constant evaluator used to evaluate constants.
-   */
-  ConstantEvaluator _evaluator;
-  /**
    * Initialize a newly created constant verifier.
    * @param errorReporter the error reporter by which errors will be reported
    */
   ConstantVerifier(ErrorReporter errorReporter) {
     this._errorReporter = errorReporter;
-    _evaluator = new ConstantEvaluator(errorReporter);
   }
   Object visitFunctionExpression(FunctionExpression node) {
     super.visitFunctionExpression(node);
     validateDefaultValues(node.parameters);
     return null;
   }
   Object visitListLiteral(ListLiteral node) {
     super.visitListLiteral(node);
     if (node.modifier != 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.modifier != null;
     Set<String> keys = new Set<String>();
     for (MapLiteralEntry entry in node.entries) {
       StringLiteral key4 = entry.key;
-      Object value = validate(key4, CompileTimeErrorCode.NON_CONSTANT_MAP_KEY);
-      if (value is String) {
-        if (keys.contains(value)) {
+      EvaluationResultImpl result = validate(key4, CompileTimeErrorCode.NON_CONSTANT_MAP_KEY);
+      if (result is ValidResult && ((result as ValidResult)).value is String) {
+        String value10 = ((result as ValidResult)).value as String;
+        if (keys.contains(value10)) {
           _errorReporter.reportError(StaticWarningCode.EQUAL_KEYS_IN_MAP, key4, []);
         } else {
-          javaSetAdd(keys, (value as String));
+          javaSetAdd(keys, value10);
         }
-      } else if (value != null) {
       }
       if (isConst) {
         validate(entry.value, CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE);
       }
     }
     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 initializer4 = node.initializer;
     if (initializer4 != null && node.isConst()) {
-      validate(initializer4, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
+      EvaluationResultImpl result = validate(initializer4, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
+      VariableElementImpl element45 = node.element as VariableElementImpl;
+      element45.evaluationResult = result;
     }
     return null;
   }
   /**
    * Validate that the given expression is a compile time constant. Return the value of the compile
    * time constant, or {@code null} if the expression is not a compile time constant.
    * @param expression the expression to be validated
    * @param errorCode the error code to be used if the expression is not a compile time constant
    * @return the value of the compile time constant
    */
-  Object validate(Expression expression, ErrorCode errorCode) {
-    Object value = expression.accept(_evaluator);
-    if (identical(value, ConstantEvaluator.NOT_A_CONSTANT)) {
-      _errorReporter.reportError(errorCode, expression, []);
-      return null;
+  EvaluationResultImpl validate(Expression expression, ErrorCode errorCode4) {
+    EvaluationResultImpl result = expression.accept(new ConstantVisitor());
+    if (result is ErrorResult) {
+      for (ErrorResult_ErrorData data in ((result as ErrorResult)).errorData) {
+        if (identical(data.errorCode, CompileTimeErrorCode.COMPILE_TIME_CONSTANT_RAISES_EXCEPTION_DIVIDE_BY_ZERO)) {
+          _errorReporter.reportError(data.errorCode, data.node, []);
+        } else {
+          _errorReporter.reportError(errorCode4, data.node, []);
+        }
+      }
     }
-    if (identical(value, errorCode)) {
-      _errorReporter.reportError(CompileTimeErrorCode.COMPILE_TIME_CONSTANT_RAISES_EXCEPTION, expression, []);
-      return null;
-    }
-    if (identical(value, errorCode)) {
-      _errorReporter.reportError(CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT, expression, []);
-      return null;
-    }
-    return value;
+    return result;
   }
   /**
    * Validate that the default value associated with each of the parameters in the given list is a
    * compile time constant.
    * @param parameters the list of parameters to be validated
    */
   void validateDefaultValues(FormalParameterList parameters14) {
     if (parameters14 == null) {
       return;
     }
     for (FormalParameter parameter in parameters14.parameters) {
       if (parameter is DefaultFormalParameter) {
-        Expression defaultValue2 = ((parameter as DefaultFormalParameter)).defaultValue;
+        DefaultFormalParameter defaultParameter = parameter as DefaultFormalParameter;
+        Expression defaultValue2 = defaultParameter.defaultValue;
         if (defaultValue2 != null) {
-          validate(defaultValue2, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
+          EvaluationResultImpl result = validate(defaultValue2, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
+          if (defaultParameter.isConst()) {
+            VariableElementImpl element46 = parameter.element as VariableElementImpl;
+            element46.evaluationResult = result;
+          }
         }
       }
     }
   }
 }
 /**
  * Instances of the class {@code ErrorVerifier} traverse an AST structure looking for additional
  * errors and warnings not covered by the parser and resolver.
  * @coverage dart.engine.resolver
  */
@@ skipping 93 matching lines @@
   Object visitIfStatement(IfStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitIfStatement(node);
   }
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     ConstructorName constructorName4 = node.constructorName;
     TypeName typeName = constructorName4.type;
     Type2 type20 = typeName.type;
     if (type20 is InterfaceType) {
       InterfaceType interfaceType = type20 as InterfaceType;
+      checkForConstWithNonConst(node);
       checkForConstOrNewWithAbstractClass(node, typeName, interfaceType);
       checkForTypeArgumentNotMatchingBounds(node, constructorName4.element, typeName);
-    } else {
-      _errorReporter.reportError(CompileTimeErrorCode.NON_CONSTANT_MAP_KEY, typeName, []);
     }
     return super.visitInstanceCreationExpression(node);
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement previousFunction = _currentFunction;
     try {
       _currentFunction = node.element;
       return super.visitMethodDeclaration(node);
     } finally {
       _currentFunction = previousFunction;
@@ skipping 24 matching lines @@
     return super.visitWhileStatement(node);
   }
   /**
    * This verifies that the passed argument definition test identifier is a parameter.
    * @param node the {@link ArgumentDefinitionTest} to evaluate
    * @return return <code>true</code> if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#ARGUMENT_DEFINITION_TEST_NON_PARAMETER
    */
   bool checkForArgumentDefinitionTestNonParameter(ArgumentDefinitionTest node) {
     SimpleIdentifier identifier14 = node.identifier;
-    Element element44 = identifier14.element;
-    if (element44 != null && element44 is! ParameterElement) {
+    Element element47 = identifier14.element;
+    if (element47 != null && element47 is! ParameterElement) {
       _errorReporter.reportError(CompileTimeErrorCode.ARGUMENT_DEFINITION_TEST_NON_PARAMETER, identifier14, [identifier14.name]);
       return true;
     }
     return false;
   }
   /**
    * This verifies that the passed identifier is not a keyword, and generates the passed error code
    * on the identifier if it is a keyword.
    * @param identifier the identifier to check to ensure that it is not a keyword
    * @param errorCode if the passed identifier is a keyword then this error code is created on the
@@ skipping 38 matching lines @@
    * This verifies that the passed switch statement does not have a case expression with the
    * operator '==' overridden.
    * @param node the switch statement to evaluate
    * @return return <code>true</code> if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
    */
   bool checkForCaseExpressionTypeImplementsEquals(SwitchStatement node) {
     Expression expression16 = node.expression;
     Type2 type = expression16.staticType;
     if (type != null && type != _typeProvider.intType && type != _typeProvider.stringType) {
-      Element element45 = type.element;
-      if (element45 is ClassElement) {
-        ClassElement classElement = element45 as ClassElement;
+      Element element48 = type.element;
+      if (element48 is ClassElement) {
+        ClassElement classElement = element48 as ClassElement;
         MethodElement method = classElement.lookUpMethod("==", _currentLibrary);
         if (method != null && method.enclosingElement.type != _typeProvider.objectType) {
-          _errorReporter.reportError(CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, expression16, [element45.name]);
+          _errorReporter.reportError(CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, expression16, [element48.name]);
           return true;
         }
       }
     }
     return false;
   }
   bool checkForConflictingConstructorNameAndMember(ConstructorDeclaration node) {
     ConstructorElement constructorElement = node.element;
     SimpleIdentifier constructorName = node.name;
     if (constructorName != null && constructorElement != null && !constructorName.isSynthetic()) {
@@ skipping 25 matching lines @@
    */
   bool checkForConstConstructorWithNonFinalField(ConstructorDeclaration node) {
     if (node.constKeyword == null) {
       return false;
     }
     ConstructorElement constructorElement = node.element;
     if (constructorElement != null) {
       ClassElement classElement = constructorElement.enclosingElement;
       List<FieldElement> elements = classElement.fields;
       for (FieldElement field in elements) {
-        if (!field.isFinal() && !field.isConst()) {
+        if (!field.isFinal() && !field.isConst() && !field.isSynthetic()) {
           _errorReporter.reportError(CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD, node, []);
           return true;
         }
       }
     }
     return false;
   }
   /**
    * This verifies that the passed normal formal parameter is not 'const'.
    * @param node the normal formal parameter to evaluate
@@ skipping 12 matching lines @@
    * class.
    * @param node the instance creation expression to evaluate
    * @param typeName the {@link TypeName} of the {@link ConstructorName} from the{@link InstanceCreationExpression}, this is the AST node that the error is attached to
    * @param type the type being constructed with this {@link InstanceCreationExpression}
    * @return return <code>true</code> 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 element46 = node.element;
-      if (element46 != null && !element46.isFactory()) {
+      ConstructorElement element49 = node.element;
+      if (element49 != null && !element49.isFactory()) {
         if (identical(((node.keyword as sc.KeywordToken)).keyword, sc.Keyword.CONST)) {
           _errorReporter.reportError(StaticWarningCode.CONST_WITH_ABSTRACT_CLASS, typeName, []);
         } else {
           _errorReporter.reportError(StaticWarningCode.NEW_WITH_ABSTRACT_CLASS, typeName, []);
         }
         return true;
       }
     }
     return false;
   }
   /**
+   * This verifies that if the passed instance creation expression is 'const', then it is not being
+   * invoked on a constructor that is not 'const'.
+   * @param node the instance creation expression to evaluate
+   * @return return <code>true</code> if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#CONST_WITH_NON_CONST
+   */
+  bool checkForConstWithNonConst(InstanceCreationExpression node) {
+    if (node.isConst() && !node.element.isConst()) {
+      _errorReporter.reportError(CompileTimeErrorCode.CONST_WITH_NON_CONST, node, []);
+      return true;
+    }
+    return false;
+  }
+  /**
    * This verifies that the passed assignment expression represents a valid assignment.
    * @param node the assignment expression to evaluate
    * @return return <code>true</code> if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INVALID_ASSIGNMENT
    */
   bool checkForInvalidAssignment(AssignmentExpression node) {
     Expression lhs = node.leftHandSide;
     Expression rhs = node.rightHandSide;
     Type2 leftType = getType(lhs);
     Type2 rightType = getType(rhs);
@@ skipping 133 matching lines @@
   ResolverErrorCode(this.__name, this.__ordinal, ErrorType type, String message) {
     this._type = type;
     this._message = message;
   }
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
   bool needsRecompilation() => true;
   String toString() => __name;
 }