analyzer_experimental checkpoint and AnalysisContext example.

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';
@@ skipping 37 matching lines @@
    * @throws AnalysisException if the analysis could not be performed
    */
   CompilationUnitElementImpl buildCompilationUnit(Source source) => buildCompilationUnit2(source, _analysisContext.parse3(source, _errorListener));
   /**
    * 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 buildCompilationUnit2(Source source13, CompilationUnit unit) {
+  CompilationUnitElementImpl buildCompilationUnit2(Source source15, CompilationUnit unit) {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     unit.accept(builder);
-    CompilationUnitElementImpl element = new CompilationUnitElementImpl(source13.shortName);
+    CompilationUnitElementImpl element = new CompilationUnitElementImpl(source15.shortName);
     element.accessors = holder.accessors;
     element.functions = holder.functions;
-    element.source = source13;
+    element.source = source15;
     element.typeAliases = holder.typeAliases;
     element.types = holder.types;
     element.topLevelVariables = holder.topLevelVariables;
     unit.element = element;
     return element;
   }
 }
 /**
  * Instances of the class {@code ElementBuilder} traverse an AST structure and build the element
  * model representing the AST structure.
@@ skipping 93 matching lines @@
     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) {
+    if (constructorName == null) {
+      Identifier returnType4 = node.returnType;
+      if (returnType4 != null) {
+        element.nameOffset = returnType4.offset;
+      }
+    } else {
       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;
@@ skipping 195 matching lines @@
       _inFunction = wasInFunction;
     }
     sc.Token property = node.propertyKeyword;
     if (property == null) {
       SimpleIdentifier methodName = node.name;
       String nameOfMethod = methodName.name;
       if (nameOfMethod == sc.TokenType.MINUS.lexeme && node.parameters.parameters.length == 0) {
         nameOfMethod = "unary-";
       }
       MethodElementImpl element = new MethodElementImpl.con2(nameOfMethod, methodName.offset);
-      sc.Token keyword = node.modifierKeyword;
-      element.abstract = matches(keyword, sc.Keyword.ABSTRACT);
+      element.abstract = node.isAbstract();
       element.functions = holder.functions;
       element.labels = holder.labels;
       element.localVariables = holder.localVariables;
       element.parameters = holder.parameters;
-      element.static = matches(keyword, sc.Keyword.STATIC);
+      element.static = node.isStatic();
       _currentHolder.addMethod(element);
       methodName.element = element;
     } else {
       SimpleIdentifier propertyNameNode = node.name;
       String propertyName = propertyNameNode.name;
       FieldElementImpl field = _currentHolder.getField(propertyName) as FieldElementImpl;
       if (field == null) {
         field = new FieldElementImpl.con2(node.name.name);
         field.final2 = true;
         field.static = matches(node.modifierKeyword, sc.Keyword.STATIC);
@@ skipping 331 matching lines @@
    * @return the HTML element that was built
    * @throws AnalysisException if the analysis could not be performed
    */
   HtmlElementImpl buildHtmlElement(Source source) => buildHtmlElement2(source, _context.parseHtml(source).htmlUnit);
   /**
    * Build the HTML element for the given source.
    * @param source the source describing the compilation unit
    * @param unit the AST structure representing the HTML
    * @throws AnalysisException if the analysis could not be performed
    */
-  HtmlElementImpl buildHtmlElement2(Source source14, ht.HtmlUnit unit) {
-    HtmlElementImpl result = new HtmlElementImpl(_context, source14.shortName);
-    result.source = source14;
+  HtmlElementImpl buildHtmlElement2(Source source16, ht.HtmlUnit unit) {
+    HtmlElementImpl result = new HtmlElementImpl(_context, source16.shortName);
+    result.source = source16;
     _htmlElement = result;
     unit.accept(this);
     _htmlElement = null;
     unit.element = result;
     return result;
   }
   Object visitHtmlUnit(ht.HtmlUnit node) {
     _scripts = new List<HtmlScriptElement>();
     node.visitChildren(this);
     _htmlElement.scripts = new List.from(_scripts);
@@ skipping 278 matching lines @@
     Element element;
     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 (!isExecutableType(returnType4)) {
+              Type2 returnType5 = getterType.returnType;
+              if (!isExecutableType(returnType5)) {
                 _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) {
           ClassElement targetClass = targetType.element as ClassElement;
           PropertyAccessorElement accessor = lookUpGetterInType(targetClass, methodName2.name);
           if (accessor != null) {
-            Type2 returnType5 = accessor.type.returnType.substitute2(((targetType as InterfaceType)).typeArguments, TypeVariableTypeImpl.getTypes(targetClass.typeVariables));
-            if (!isExecutableType(returnType5)) {
+            Type2 returnType6 = accessor.type.returnType.substitute2(((targetType as InterfaceType)).typeArguments, TypeVariableTypeImpl.getTypes(targetClass.typeVariables));
+            if (!isExecutableType(returnType6)) {
               _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 11 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 (!isExecutableType(returnType6)) {
+          Type2 returnType7 = getterType.returnType;
+          if (!isExecutableType(returnType7)) {
             _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 (!isExecutableType(variableType)) {
           _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
         }
@@ skipping 1082 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_237_impl(analysisContext);
+    _jtd_constructor_239_impl(analysisContext);
   }
-  _jtd_constructor_237_impl(AnalysisContextImpl analysisContext) {
-    _jtd_constructor_238_impl(analysisContext, null);
+  _jtd_constructor_239_impl(AnalysisContextImpl analysisContext) {
+    _jtd_constructor_240_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_238_impl(analysisContext2, additionalAnalysisErrorListener);
+    _jtd_constructor_240_impl(analysisContext2, additionalAnalysisErrorListener);
   }
-  _jtd_constructor_238_impl(AnalysisContextImpl analysisContext2, AnalysisErrorListener additionalAnalysisErrorListener) {
+  _jtd_constructor_240_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 944 matching lines @@
    * assignment of the form <i>e<sub>1</sub>.v op= e<sub>2</sub></i> is equivalent to <i>((x) => x.v
    * = x.v op e<sub>2</sub>)(e<sub>1</sub>)</i> where <i>x</i> is a variable that is not used in
    * <i>e<sub>2</sub></i>. A compound assignment of the form <i>e<sub>1</sub>[e<sub>2</sub>] op=
    * e<sub>3</sub></i> is equivalent to <i>((a, i) => a[i] = a[i] op e<sub>3</sub>)(e<sub>1</sub>,
    * e<sub>2</sub>)</i> where <i>a</i> and <i>i</i> are a variables that are not used in
    * <i>e<sub>3</sub></i>. </blockquote>
    */
   Object visitAssignmentExpression(AssignmentExpression node) {
     sc.TokenType operator11 = node.operator.type;
     if (operator11 != sc.TokenType.EQ) {
-      return recordReturnType(node, node.element);
+      return recordReturnType(node, node.element, null);
     }
     return recordType(node, getType(node.rightHandSide));
   }
   /**
    * The Dart Language Specification, 12.20: <blockquote>The static type of a logical boolean
    * expression is {@code bool}.</blockquote>
    * <p>
    * The Dart Language Specification, 12.21:<blockquote>A bitwise expression of the form
    * <i>e<sub>1</sub> op e<sub>2</sub></i> is equivalent to the method invocation
    * <i>e<sub>1</sub>.op(e<sub>2</sub>)</i>. A bitwise expression of the form <i>super op
@@ skipping 28 matching lines @@
    * <i>super.op(e<sub>2</sub>)</i>.</blockquote>
    */
   Object visitBinaryExpression(BinaryExpression node) {
     sc.TokenType operator12 = node.operator.type;
     while (true) {
       if (operator12 == sc.TokenType.AMPERSAND_AMPERSAND || operator12 == sc.TokenType.BAR_BAR || operator12 == sc.TokenType.EQ_EQ || operator12 == sc.TokenType.BANG_EQ) {
         return recordType(node, _typeProvider.boolType);
       }
       break;
     }
-    return recordReturnType(node, node.element);
+    return recordReturnType(node, node.element, null);
   }
   /**
    * The Dart Language Specification, 12.4: <blockquote>The static type of a boolean literal is{@code bool}.</blockquote>
    */
   Object visitBooleanLiteral(BooleanLiteral node) => recordType(node, _typeProvider.boolType);
   /**
    * The Dart Language Specification, 12.15.2: <blockquote>A cascaded method invocation expression
    * of the form <i>e..suffix</i> is equivalent to the expression <i>(t) {t.suffix; return
    * t;}(e)</i>.</blockquote>
    */
@@ skipping 69 matching lines @@
    * has the form <i>e<sub>f</sub>(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>, where <i>e<sub>f</sub></i> is
    * an expression.
    * <p>
    * It is a static type warning if the static type <i>F</i> of <i>e<sub>f</sub></i> may not be
    * assigned to a function type.
    * <p>
    * If <i>F</i> is not a function type, the static type of <i>i</i> is dynamic. Otherwise the
    * static type of <i>i</i> is the declared return type of <i>F</i>.</blockquote>
    */
-  Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => recordReturnType(node, node.element);
+  Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => recordReturnType(node, node.element, null);
   /**
    * The Dart Language Specification, 12.29: <blockquote>An assignable expression of the form
    * <i>e<sub>1</sub>[e<sub>2</sub>]</i> is evaluated as a method invocation of the operator method
    * <i>[]</i> on <i>e<sub>1</sub></i> with argument <i>e<sub>2</sub></i>.</blockquote>
    */
   Object visitIndexExpression(IndexExpression node) {
+    Type2 type = getType(node.realTarget);
+    List<Type2> typeArgs = null;
+    if (type is InterfaceType) {
+      typeArgs = ((type as InterfaceType)).typeArguments;
+    }
     if (node.inSetterContext()) {
-      return recordArgumentType(node, node.element);
+      return recordArgumentType(node, node.element, typeArgs);
     }
-    return recordReturnType(node, node.element);
+    return recordReturnType(node, node.element, typeArgs);
   }
   /**
    * The Dart Language Specification, 12.11.1: <blockquote>The static type of a new expression of
    * either the form <i>new T.id(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> or the form <i>new
    * T(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> is <i>T</i>.</blockquote>
    * <p>
    * The Dart Language Specification, 12.11.2: <blockquote>The static type of a constant object
    * expression of either the form <i>const T.id(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> or the
    * form <i>const T(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> is <i>T</i>. </blockquote>
    */
@@ skipping 82 matching lines @@
    * &hellip;, x<sub>n+k</sub>: a<sub>n+k</sub>)</i>.
    * <p>
    * It is a static type warning if <i>S</i> does not have an accessible instance member named m. If
    * <i>S.m</i> exists, it is a static warning if the type <i>F</i> of <i>S.m</i> may not be
    * assigned to a function type.
    * <p>
    * If <i>S.m</i> does not exist, or if <i>F</i> is not a function type, the static type of
    * <i>i</i> is dynamic. Otherwise the static type of <i>i</i> is the declared return type of
    * <i>F</i>.</blockquote>
    */
-  Object visitMethodInvocation(MethodInvocation node) => recordReturnType(node, node.methodName.element);
+  Object visitMethodInvocation(MethodInvocation node) => recordReturnType(node, node.methodName.element, null);
   Object visitNamedExpression(NamedExpression node) => recordType(node, getType(node.expression));
   /**
    * The Dart Language Specification, 12.2: <blockquote>The static type of {@code null} is bottom.
    * </blockquote>
    */
   Object visitNullLiteral(NullLiteral node) => recordType(node, _typeProvider.bottomType);
   Object visitParenthesizedExpression(ParenthesizedExpression node) => recordType(node, getType(node.expression));
   /**
    * 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 47 matching lines @@
   /**
    * 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
    * form <i>op super</i> is equivalent to the method invocation <i>super.op()<i>.</blockquote>
    */
   Object visitPrefixExpression(PrefixExpression node) {
     sc.TokenType operator13 = node.operator.type;
     if (identical(operator13, sc.TokenType.BANG)) {
       return recordType(node, _typeProvider.boolType);
     }
-    return recordReturnType(node, node.element);
+    return recordReturnType(node, node.element, null);
   }
   /**
    * The Dart Language Specification, 12.13: <blockquote> Property extraction allows for a member of
    * an object to be concisely extracted from the object. If <i>o</i> is an object, and if <i>m</i>
    * is the name of a method member of <i>o</i>, then
    * <ul>
    * <li><i>o.m</i> is defined to be equivalent to: <i>(r<sub>1</sub>, &hellip;, r<sub>n</sub>,
    * {p<sub>1</sub> : d<sub>1</sub>, &hellip;, p<sub>k</sub> : d<sub>k</sub>}){return
    * o.m(r<sub>1</sub>, &hellip;, r<sub>n</sub>, p<sub>1</sub>: p<sub>1</sub>, &hellip;,
    * p<sub>k</sub>: p<sub>k</sub>);}</i> if <i>m</i> has required parameters <i>r<sub>1</sub>,
@@ skipping 148 matching lines @@
    */
   Object visitThrowExpression(ThrowExpression node) => recordType(node, _typeProvider.bottomType);
   /**
    * Given a function declaration, compute the return type of the function. The return type of
    * functions with a block body is {@code 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 computeReturnType(FunctionDeclaration node) {
-    TypeName returnType7 = node.returnType;
-    if (returnType7 == null) {
+    TypeName returnType8 = node.returnType;
+    if (returnType8 == null) {
       return computeReturnType2(node.functionExpression);
     }
-    return returnType7.type;
+    return returnType8.type;
   }
   /**
    * Given a function expression, compute the return type of the function. The return type of
    * functions with a block body is {@code 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 computeReturnType2(FunctionExpression node) {
     FunctionBody body4 = node.body;
@@ skipping 59 matching lines @@
    */
   bool isNotTypeLiteral(SimpleIdentifier node) {
     ASTNode parent15 = node.parent;
     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
+   * @param typeArguments the array of {@link Type}s to perform a substitution on the parameter
+   * types from the type in the passed {@link Element}, or <code>null</code>
    */
-  Object recordArgumentType(IndexExpression expression, MethodElement element) {
+  Object recordArgumentType(IndexExpression expression, MethodElement element, List<Type2> typeArguments10) {
     if (element != null) {
       List<ParameterElement> parameters12 = element.parameters;
       if (parameters12 != null && parameters12.length == 2) {
-        return recordType(expression, parameters12[1].type);
+        ClassElement classElement = parameters12[1].getAncestor(ClassElement);
+        List<Type2> typeParameters = classElement == null ? null : classElement.type.typeArguments;
+        if (typeArguments10 == null || typeParameters == null || typeArguments10.length != typeParameters.length) {
+          return recordType(expression, parameters12[1].type);
+        } else {
+          return recordType(expression, parameters12[1].type.substitute2(typeArguments10, typeParameters));
+        }
       }
     }
     return recordType(expression, _dynamicType);
   }
   /**
    * Record that the static type of the given node is the return type of the method or function
    * represented by the given element.
    * @param expression the node whose type is to be recorded
    * @param element the element representing the method or function invoked by the given node
+   * @param typeArguments the array of {@link Type}s to perform a substitution on the parameter
+   * types from the type in the passed {@link Element}, or <code>null</code>
    */
-  Object recordReturnType(Expression expression, Element element) {
+  Object recordReturnType(Expression expression, Element element, List<Type2> typeArguments11) {
     if (element is PropertyAccessorElement) {
       FunctionType propertyType = ((element as PropertyAccessorElement)).type;
       if (propertyType != null) {
-        Type2 returnType8 = propertyType.returnType;
-        if (returnType8 is FunctionType) {
-          Type2 innerReturnType = ((returnType8 as FunctionType)).returnType;
+        Type2 returnType9 = propertyType.returnType;
+        if (returnType9 is FunctionType) {
+          Type2 innerReturnType = ((returnType9 as FunctionType)).returnType;
           if (innerReturnType != null) {
             return recordType(expression, innerReturnType);
           }
         }
-        if (returnType8 != null) {
-          return recordType(expression, returnType8);
+        if (returnType9 != null) {
+          return recordType(expression, returnType9);
         }
       }
     } else if (element is ExecutableElement) {
       FunctionType type17 = ((element as ExecutableElement)).type;
       if (type17 != null) {
-        return recordType(expression, type17.returnType);
+        ClassElement classElement = element.getAncestor(ClassElement);
+        List<Type2> typeParameters = classElement == null ? null : classElement.type.typeArguments;
+        if (typeArguments11 == null || typeParameters == null || typeArguments11.length != typeParameters.length) {
+          return recordType(expression, type17.returnType);
+        } else {
+          return recordType(expression, type17.returnType.substitute2(typeArguments11, typeParameters));
+        }
       }
     } else if (element is VariableElement) {
       Type2 variableType = ((element as VariableElement)).type;
       if (variableType is FunctionType) {
         return recordType(expression, ((variableType as FunctionType)).returnType);
       }
     }
     return recordType(expression, _dynamicType);
   }
   /**
    * Record that the static type of the given node is the given type.
    * @param expression the node whose type is to be recorded
    * @param type the static type of the node
    */
   Object recordType(Expression expression, Type2 type) {
     if (type == null) {
       expression.staticType = _dynamicType;
     } else {
       expression.staticType = type;
     }
     return null;
   }
   /**
    * Set the return type and parameter type information for the given function type based on the
    * given return type and parameter elements.
    * @param functionType the function type to be filled in
    * @param returnType the return type of the function, or {@code null} if no type was declared
    * @param parameters the elements representing the parameters to the function
    */
-  void setTypeInformation(FunctionTypeImpl functionType, Type2 returnType11, FormalParameterList parameterList) {
+  void setTypeInformation(FunctionTypeImpl functionType, Type2 returnType12, FormalParameterList parameterList) {
     List<Type2> normalParameterTypes = new List<Type2>();
     List<Type2> optionalParameterTypes = new List<Type2>();
     LinkedHashMap<String, Type2> namedParameterTypes = new LinkedHashMap<String, Type2>();
     if (parameterList != null) {
       for (ParameterElement parameter in parameterList.elements) {
         while (true) {
           if (parameter.parameterKind == ParameterKind.REQUIRED) {
             normalParameterTypes.add(parameter.type);
           } else if (parameter.parameterKind == ParameterKind.POSITIONAL) {
             optionalParameterTypes.add(parameter.type);
           } else if (parameter.parameterKind == ParameterKind.NAMED) {
             namedParameterTypes[parameter.name] = parameter.type;
           }
           break;
         }
       }
     }
     functionType.normalParameterTypes = new List.from(normalParameterTypes);
     functionType.optionalParameterTypes = new List.from(optionalParameterTypes);
     functionType.namedParameterTypes = namedParameterTypes;
-    functionType.returnType = returnType11;
+    functionType.returnType = returnType12;
   }
   get thisType_J2DAccessor => _thisType;
   set thisType_J2DAccessor(__v) => _thisType = __v;
 }
 /**
  * The interface {@code TypeProvider} defines the behavior of objects that provide access to types
  * defined by the language.
  * @coverage dart.engine.resolver
  */
 abstract class TypeProvider {
@@ skipping 31 matching lines @@
    * Return the type representing the built-in type 'List'.
    * @return the type representing the built-in type 'List'
    */
   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 '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'
    */
   InterfaceType get objectType;
   /**
    * Return the type representing the built-in type 'StackTrace'.
    * @return the type representing the built-in type 'StackTrace'
    */
   InterfaceType get stackTraceType;
   /**
@@ skipping 39 matching lines @@
   InterfaceType _intType;
   /**
    * The type representing the built-in type 'List'.
    */
   InterfaceType _listType;
   /**
    * The type representing the built-in type 'Map'.
    */
   InterfaceType _mapType;
   /**
+   * The type representing the built-in type 'num'.
+   */
+  InterfaceType _numType;
+  /**
    * The type representing the built-in type 'Object'.
    */
   InterfaceType _objectType;
   /**
    * The type representing the built-in type 'StackTrace'.
    */
   InterfaceType _stackTraceType;
   /**
    * The type representing the built-in type 'String'.
    */
@@ skipping 10 matching lines @@
     initializeFrom(coreLibrary);
   }
   InterfaceType get boolType => _boolType;
   Type2 get bottomType => _bottomType;
   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 numType => _numType;
   InterfaceType get objectType => _objectType;
   InterfaceType get stackTraceType => _stackTraceType;
   InterfaceType get stringType => _stringType;
   InterfaceType get typeType => _typeType;
   /**
    * Return the type with the given name from the given namespace, or {@code 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
@@ skipping 13 matching lines @@
   void initializeFrom(LibraryElement library) {
     Namespace namespace = new NamespaceBuilder().createPublicNamespace(library);
     _boolType = getType(namespace, "bool");
     _bottomType = BottomTypeImpl.instance;
     _doubleType = getType(namespace, "double");
     _dynamicType = DynamicTypeImpl.instance;
     _functionType = getType(namespace, "Function");
     _intType = getType(namespace, "int");
     _listType = getType(namespace, "List");
     _mapType = getType(namespace, "Map");
+    _numType = getType(namespace, "num");
     _objectType = getType(namespace, "Object");
     _stackTraceType = getType(namespace, "StackTrace");
     _stringType = getType(namespace, "String");
     _typeType = getType(namespace, "Type");
   }
 }
 /**
  * Instances of the class {@code 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
@@ skipping 512 matching lines @@
       }
     }
   }
   /**
    * Set the return type and parameter type information for the given function type based on the
    * given return type and parameter elements.
    * @param functionType the function type to be filled in
    * @param returnType the return type of the function, or {@code null} if no type was declared
    * @param parameters the elements representing the parameters to the function
    */
-  void setTypeInformation(FunctionTypeImpl functionType, TypeName returnType12, List<ParameterElement> parameters) {
+  void setTypeInformation(FunctionTypeImpl functionType, TypeName returnType13, List<ParameterElement> parameters) {
     List<Type2> normalParameterTypes = new List<Type2>();
     List<Type2> optionalParameterTypes = new List<Type2>();
     LinkedHashMap<String, Type2> namedParameterTypes = new LinkedHashMap<String, Type2>();
     for (ParameterElement parameter in parameters) {
       while (true) {
         if (parameter.parameterKind == ParameterKind.REQUIRED) {
           normalParameterTypes.add(parameter.type);
         } else if (parameter.parameterKind == ParameterKind.POSITIONAL) {
           optionalParameterTypes.add(parameter.type);
         } else if (parameter.parameterKind == ParameterKind.NAMED) {
           namedParameterTypes[parameter.name] = parameter.type;
         }
         break;
       }
     }
     if (!normalParameterTypes.isEmpty) {
       functionType.normalParameterTypes = new List.from(normalParameterTypes);
     }
     if (!optionalParameterTypes.isEmpty) {
       functionType.optionalParameterTypes = new List.from(optionalParameterTypes);
     }
     if (!namedParameterTypes.isEmpty) {
       functionType.namedParameterTypes = namedParameterTypes;
     }
-    if (returnType12 == null) {
+    if (returnType13 == null) {
       functionType.returnType = _dynamicType;
     } else {
-      functionType.returnType = returnType12.type;
+      functionType.returnType = returnType13.type;
     }
   }
 }
 /**
  * Instances of the class {@code 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.
@@ skipping 141 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_248_impl(outerScope, onSwitchStatement, onSwitchMember);
+    _jtd_constructor_250_impl(outerScope, 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));
+  _jtd_constructor_250_impl(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) {
+    _jtd_constructor_251_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_249_impl(outerScope2, label4, element19);
+    _jtd_constructor_251_impl(outerScope2, label4, element19);
   }
-  _jtd_constructor_249_impl(LabelScope outerScope2, String label4, LabelElement element19) {
+  _jtd_constructor_251_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 580 matching lines @@
         }
       }
     }
     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) {
+  void validateDefaultValues(FormalParameterList parameters15) {
+    if (parameters15 == null) {
       return;
     }
-    for (FormalParameter parameter in parameters14.parameters) {
+    for (FormalParameter parameter in parameters15.parameters) {
       if (parameter is DefaultFormalParameter) {
         DefaultFormalParameter defaultParameter = parameter as DefaultFormalParameter;
         Expression defaultValue2 = defaultParameter.defaultValue;
         if (defaultValue2 != null) {
           EvaluationResultImpl result = validate(defaultValue2, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
           if (defaultParameter.isConst()) {
             VariableElementImpl element46 = parameter.element as VariableElementImpl;
             element46.evaluationResult = result;
           }
         }
@@ skipping 17 matching lines @@
   LibraryElement _currentLibrary;
   /**
    * The type representing the type 'dynamic'.
    */
   Type2 _dynamicType;
   /**
    * The object providing access to the types defined by the language.
    */
   TypeProvider _typeProvider;
   /**
+   * This is set to <code>true</code> iff the visitor is currently visiting children nodes of a{@link ConstructorDeclaration} and the constructor is 'const'.
+   * @see #visitConstructorDeclaration(ConstructorDeclaration)
+   */
+  bool _isEnclosingConstructorConst = false;
+  /**
    * The method or function that we are currently visiting, or {@code null} if we are not inside a
    * method or function.
    */
   ExecutableElement _currentFunction;
+  /**
+   * A list of types used by the {@link CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS} and{@link CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS} error codes.
+   */
+  List<InterfaceType> _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT;
   ErrorVerifier(ErrorReporter errorReporter, LibraryElement currentLibrary, TypeProvider typeProvider) {
     this._errorReporter = errorReporter;
     this._currentLibrary = currentLibrary;
     this._typeProvider = typeProvider;
+    _isEnclosingConstructorConst = false;
     _dynamicType = typeProvider.dynamicType;
+    _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT = <InterfaceType> [typeProvider.numType, typeProvider.intType, typeProvider.doubleType, typeProvider.boolType, typeProvider.stringType];
   }
   Object visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
     checkForArgumentDefinitionTestNonParameter(node);
     return super.visitArgumentDefinitionTest(node);
   }
   Object visitAssertStatement(AssertStatement node) {
     checkForNonBoolExpression(node);
     return super.visitAssertStatement(node);
   }
   Object visitAssignmentExpression(AssignmentExpression node) {
     checkForInvalidAssignment(node);
     return super.visitAssignmentExpression(node);
   }
   Object visitClassDeclaration(ClassDeclaration node) {
     checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME);
     return super.visitClassDeclaration(node);
   }
   Object visitClassTypeAlias(ClassTypeAlias node) {
     checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
     return super.visitClassTypeAlias(node);
   }
   Object visitConditionalExpression(ConditionalExpression node) {
     checkForNonBoolCondition(node.condition);
     return super.visitConditionalExpression(node);
   }
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement previousFunction = _currentFunction;
     try {
       _currentFunction = node.element;
+      _isEnclosingConstructorConst = node.constKeyword != null;
       checkForConstConstructorWithNonFinalField(node);
       checkForConflictingConstructorNameAndMember(node);
       return super.visitConstructorDeclaration(node);
     } finally {
+      _isEnclosingConstructorConst = false;
       _currentFunction = previousFunction;
     }
   }
   Object visitDoStatement(DoStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitDoStatement(node);
   }
+  Object visitExtendsClause(ExtendsClause node) {
+    checkForExtendsDisallowedClass(node);
+    return super.visitExtendsClause(node);
+  }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     checkForConstFormalParameter(node);
     return super.visitFieldFormalParameter(node);
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement previousFunction = _currentFunction;
     try {
       _currentFunction = node.element;
       return super.visitFunctionDeclaration(node);
     } finally {
       _currentFunction = previousFunction;
     }
   }
   Object visitFunctionExpression(FunctionExpression node) {
     ExecutableElement previousFunction = _currentFunction;
     try {
       _currentFunction = node.element;
       return super.visitFunctionExpression(node);
     } finally {
       _currentFunction = previousFunction;
     }
   }
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
+    checkForDefaultValueInFunctionTypeAlias(node);
     return super.visitFunctionTypeAlias(node);
   }
   Object visitIfStatement(IfStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitIfStatement(node);
   }
+  Object visitImplementsClause(ImplementsClause node) {
+    checkForImplementsDisallowedClass(node);
+    return super.visitImplementsClause(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);
     }
@@ skipping 13 matching lines @@
     return super.visitReturnStatement(node);
   }
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     checkForConstFormalParameter(node);
     return super.visitSimpleFormalParameter(node);
   }
   Object visitSwitchStatement(SwitchStatement node) {
     checkForCaseExpressionTypeImplementsEquals(node);
     return super.visitSwitchStatement(node);
   }
+  Object visitThrowExpression(ThrowExpression node) {
+    checkForConstEvalThrowsException(node);
+    return super.visitThrowExpression(node);
+  }
   Object visitTypeParameter(TypeParameter node) {
     checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME);
     return super.visitTypeParameter(node);
   }
   Object visitVariableDeclarationList(VariableDeclarationList node) {
     checkForBuiltInIdentifierAsName2(node);
     return super.visitVariableDeclarationList(node);
   }
   Object visitWhileStatement(WhileStatement node) {
     checkForNonBoolCondition(node.condition);
@@ skipping 103 matching lines @@
     return false;
   }
   /**
    * This verifies that the passed constructor declaration is not 'const' if it has a non-final
    * instance variable.
    * @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_CONSTRUCTOR_WITH_NON_FINAL_FIELD
    */
   bool checkForConstConstructorWithNonFinalField(ConstructorDeclaration node) {
-    if (node.constKeyword == null) {
+    if (!_isEnclosingConstructorConst) {
       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() && !field.isSynthetic()) {
           _errorReporter.reportError(CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD, node, []);
           return true;
         }
       }
     }
     return false;
   }
   /**
+   * This verifies that the passed throw expression is not enclosed in a 'const' constructor
+   * declaration.
+   * @param node the throw expression expression to evaluate
+   * @return return <code>true</code> if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#CONST_EVAL_THROWS_EXCEPTION
+   */
+  bool checkForConstEvalThrowsException(ThrowExpression node) {
+    if (_isEnclosingConstructorConst) {
+      _errorReporter.reportError(CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, node, []);
+      return true;
+    }
+    return false;
+  }
+  /**
    * This verifies that the passed normal formal parameter is not 'const'.
    * @param node the normal formal parameter to evaluate
    * @return return <code>true</code> if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_FORMAL_PARAMETER
    */
   bool checkForConstFormalParameter(NormalFormalParameter node) {
     if (node.isConst()) {
       _errorReporter.reportError(CompileTimeErrorCode.CONST_FORMAL_PARAMETER, node, []);
       return true;
     }
@@ skipping 24 matching lines @@
     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()) {
+    ConstructorElement constructorElement = node.element;
+    if (node.isConst() && constructorElement != null && !constructorElement.isConst()) {
       _errorReporter.reportError(CompileTimeErrorCode.CONST_WITH_NON_CONST, node, []);
       return true;
     }
     return false;
   }
   /**
+   * This verifies that there are no default parameters in the passed function type alias.
+   * @param node the function type alias to evaluate
+   * @return return <code>true</code> if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS
+   */
+  bool checkForDefaultValueInFunctionTypeAlias(FunctionTypeAlias node) {
+    bool result = false;
+    FormalParameterList formalParameterList = node.parameters;
+    NodeList<FormalParameter> parameters13 = formalParameterList.parameters;
+    for (FormalParameter formalParameter in parameters13) {
+      if (formalParameter is DefaultFormalParameter) {
+        DefaultFormalParameter defaultFormalParameter = formalParameter as DefaultFormalParameter;
+        if (defaultFormalParameter.defaultValue != null) {
+          _errorReporter.reportError(CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS, node, []);
+          result = true;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * This verifies that the passed extends clause does not extend classes such as num or String.
+   * @param node the extends clause to test
+   * @return return <code>true</code> if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS
+   */
+  bool checkForExtendsDisallowedClass(ExtendsClause extendsClause) => checkForExtendsOrImplementsDisallowedClass(extendsClause.superclass, CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
+  /**
+   * This verifies that the passed type name does not extend or implement classes such as 'num' or
+   * 'String'.
+   * @param node the type name to test
+   * @return return <code>true</code> if and only if an error code is generated on the passed node
+   * @see #checkForExtendsDisallowedClass(ExtendsClause)
+   * @see #checkForImplementsDisallowedClass(ImplementsClause)
+   * @see CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS
+   * @see CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS
+   */
+  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 == disallowedType) {
+        if (superType == _typeProvider.numType) {
+          ASTNode grandParent = typeName.parent.parent;
+          if (grandParent is ClassDeclaration) {
+            ClassElement classElement = ((grandParent as ClassDeclaration)).element;
+            Type2 classType = classElement.type;
+            if (classType != null && (classType == _typeProvider.intType || classType == _typeProvider.doubleType)) {
+              return false;
+            }
+          }
+        }
+        _errorReporter.reportError(errorCode, typeName, [disallowedType.name]);
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * This verifies that the passed implements clause does not implement classes such as 'num' or
+   * 'String'.
+   * @param node the implements clause to test
+   * @return return <code>true</code> if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS
+   */
+  bool checkForImplementsDisallowedClass(ImplementsClause implementsClause) {
+    bool result = false;
+    for (TypeName type in implementsClause.interfaces) {
+      result = javaBooleanOr(result, checkForExtendsOrImplementsDisallowedClass(type, CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS));
+      ;
+    }
+    return result;
+  }
+  /**
    * 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;
 }