New analyzer_experimental snapshot.

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

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.resolver;
 
 import 'dart:collection';
+import 'dart:uri' show Uri;
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
 import 'error.dart';
 import 'scanner.dart' as sc;
 import 'utilities_dart.dart';
 import 'ast.dart';
 import 'parser.dart' show Parser, ParserErrorCode;
 import 'sdk.dart' show DartSdk;
@@ skipping 544 matching lines @@
       if (!isFinal) {
         PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con2(variable);
         setter.setter = true;
         _currentHolder.addAccessor(setter);
         variable.setter = setter;
       }
       if (_inFieldContext) {
         ((variable as FieldElementImpl)).static = matches(((node.parent.parent as FieldDeclaration)).keyword, sc.Keyword.STATIC);
       }
     }
-    return super.visitVariableDeclaration(node);
+    return null;
   }
   List<Type2> createTypeVariableTypes(List<TypeVariableElement> typeVariables) {
     int typeVariableCount = typeVariables.length;
     List<Type2> typeArguments = new List<Type2>(typeVariableCount);
     for (int i = 0; i < typeVariableCount; i++) {
       TypeVariableElementImpl typeVariable = typeVariables[i] as TypeVariableElementImpl;
       TypeVariableTypeImpl typeArgument = new TypeVariableTypeImpl(typeVariable);
       typeVariable.type = typeArgument;
       typeArguments[i] = typeArgument;
     }
@@ skipping 204 matching lines @@
   static String _APPLICATION_DART_IN_DOUBLE_QUOTES = "\"application/dart\"";
   static String _APPLICATION_DART_IN_SINGLE_QUOTES = "'application/dart'";
   static String _SCRIPT = "script";
   static String _SRC = "src";
   static String _TYPE = "type";
   /**
    * The analysis context in which the element model will be built.
    */
   InternalAnalysisContext _context;
   /**
+   * The error listener to which errors will be reported.
+   */
+  AnalysisErrorListener _errorListener;
+  /**
+   * The line information associated with the source for which an element is being built, or{@code null} if we are not building an element.
+   */
+  LineInfo _lineInfo;
+  /**
    * The HTML element being built.
    */
   HtmlElementImpl _htmlElement;
   /**
    * The script elements being built.
    */
   List<HtmlScriptElement> _scripts;
   /**
    * Initialize a newly created HTML unit builder.
    * @param context the analysis context in which the element model will be built
+   * @param errorListener the error listener to which errors will be reported
    */
-  HtmlUnitBuilder(InternalAnalysisContext context) {
+  HtmlUnitBuilder(InternalAnalysisContext context, AnalysisErrorListener errorListener) {
     this._context = context;
+    this._errorListener = errorListener;
   }
   /**
    * Build the HTML element for the given source.
    * @param source the source describing the compilation unit
    * @return the HTML element that was built
    * @throws AnalysisException if the analysis could not be performed
    */
   HtmlElementImpl buildHtmlElement(Source source) => buildHtmlElement2(source, _context.parseHtmlUnit(source));
   /**
    * 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 source2, ht.HtmlUnit unit) {
+    _lineInfo = _context.computeLineInfo(source2);
     HtmlElementImpl result = new HtmlElementImpl(_context, source2.shortName);
     result.source = source2;
     _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);
     _scripts = null;
     return null;
   }
   Object visitXmlAttributeNode(ht.XmlAttributeNode node) => null;
   Object visitXmlTagNode(ht.XmlTagNode node) {
     if (isScriptNode(node)) {
       Source htmlSource = _htmlElement.source;
-      String scriptSourcePath = getScriptSourcePath(node);
+      ht.XmlAttributeNode scriptAttribute = getScriptSourcePath(node);
+      String scriptSourcePath = scriptAttribute == null ? null : scriptAttribute.text;
       if (identical(node.attributeEnd.type, ht.TokenType.GT) && scriptSourcePath == null) {
         EmbeddedHtmlScriptElementImpl script = new EmbeddedHtmlScriptElementImpl(node);
         String contents = node.content;
-        AnalysisErrorListener errorListener = new AnalysisErrorListener_5();
-        sc.StringScanner scanner = new sc.StringScanner(null, contents, errorListener);
+        int attributeEnd2 = node.attributeEnd.end;
+        LineInfo_Location location = _lineInfo.getLocation(attributeEnd2);
+        sc.StringScanner scanner = new sc.StringScanner(htmlSource, contents, _errorListener);
+        scanner.setSourceStart(location.lineNumber, location.columnNumber, attributeEnd2);
         sc.Token firstToken = scanner.tokenize();
         List<int> lineStarts2 = scanner.lineStarts;
-        Parser parser = new Parser(null, errorListener);
+        Parser parser = new Parser(null, _errorListener);
         CompilationUnit unit = parser.parseCompilationUnit(firstToken);
+        unit.lineInfo = new LineInfo(lineStarts2);
         try {
           CompilationUnitBuilder builder = new CompilationUnitBuilder();
           CompilationUnitElementImpl elem = builder.buildCompilationUnit(htmlSource, unit);
           LibraryElementImpl library = new LibraryElementImpl(_context, null);
           library.definingCompilationUnit = elem;
           script.scriptLibrary = library;
-        } on AnalysisException catch (e) {
-          print(e);
+        } on AnalysisException catch (exception) {
+          print(exception);
         }
         _scripts.add(script);
       } else {
         ExternalHtmlScriptElementImpl script = new ExternalHtmlScriptElementImpl(node);
         if (scriptSourcePath != null) {
-          script.scriptSource = _context.sourceFactory.resolveUri(htmlSource, scriptSourcePath);
+          try {
+            new Uri(scriptSourcePath);
+            Source scriptSource = _context.sourceFactory.resolveUri(htmlSource, scriptSourcePath);
+            script.scriptSource = scriptSource;
+            if (!scriptSource.exists()) {
+              reportError(HtmlWarningCode.URI_DOES_NOT_EXIST, scriptAttribute.offset + 1, scriptSourcePath.length, []);
+            }
+          } on URISyntaxException catch (exception) {
+            reportError(HtmlWarningCode.INVALID_URI, scriptAttribute.offset + 1, scriptSourcePath.length, []);
+          }
         }
         _scripts.add(script);
       }
     } else {
       node.visitChildren(this);
     }
     return null;
   }
   /**
-   * Return the value of the source attribute if it exists.
+   * Return the first source attribute for the given tag node, or {@code null} if it does not exist.
    * @param node the node containing attributes
-   * @return the source path or {@code null} if not defined
+   * @return the source attribute contained in the given tag
    */
-  String getScriptSourcePath(ht.XmlTagNode node) {
+  ht.XmlAttributeNode getScriptSourcePath(ht.XmlTagNode node) {
     for (ht.XmlAttributeNode attribute in node.attributes) {
       if (attribute.name.lexeme == _SRC) {
-        String text2 = attribute.text;
-        return text2 != null && text2.length > 0 ? text2 : null;
+        return attribute;
       }
     }
     return null;
   }
   /**
    * Determine if the specified node is a Dart script.
    * @param node the node to be tested (not {@code null})
    * @return {@code true} if the node is a Dart script
    */
   bool isScriptNode(ht.XmlTagNode node) {
     if (node.tagNodes.length != 0 || node.tag.lexeme != _SCRIPT) {
       return false;
     }
     for (ht.XmlAttributeNode attribute in node.attributes) {
       if (attribute.name.lexeme == _TYPE) {
         ht.Token valueToken = attribute.value;
         if (valueToken != null) {
           String value = valueToken.lexeme;
           if (value == _APPLICATION_DART_IN_DOUBLE_QUOTES || value == _APPLICATION_DART_IN_SINGLE_QUOTES) {
             return true;
           }
         }
       }
     }
     return false;
   }
-}
-class AnalysisErrorListener_5 implements AnalysisErrorListener {
-  void onError(AnalysisError error) {
+  /**
+   * Report an error with the given error code at the given location. Use the given arguments to
+   * compose the error message.
+   * @param errorCode the error code of the error to be reported
+   * @param offset the offset of the first character to be highlighted
+   * @param length the number of characters to be highlighted
+   * @param arguments the arguments used to compose the error message
+   */
+  void reportError(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
+    _errorListener.onError(new AnalysisError.con2(_htmlElement.source, offset, length, errorCode, arguments));
   }
 }
 /**
  * Instances of the class {@code DeclarationResolver} are used to resolve declarations in an AST
  * structure to already built elements.
  */
 class DeclarationResolver extends RecursiveASTVisitor<Object> {
   /**
    * The compilation unit containing the AST nodes being visited.
    */
@@ skipping 569 matching lines @@
     return null;
   }
   Object visitBreakStatement(BreakStatement node) {
     SimpleIdentifier labelNode = node.label;
     LabelElementImpl labelElement = lookupLabel(node, labelNode);
     if (labelElement != null && labelElement.isOnSwitchMember()) {
       _resolver.reportError(ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER, labelNode, []);
     }
     return null;
   }
+  Object visitCommentReference(CommentReference node) {
+    Identifier identifier2 = node.identifier;
+    if (identifier2 is SimpleIdentifier) {
+      SimpleIdentifier simpleIdentifier = identifier2 as SimpleIdentifier;
+      visitSimpleIdentifier(simpleIdentifier);
+      Element element2 = simpleIdentifier.element;
+      if (element2 != null) {
+        if (element2.library != _resolver.definingLibrary) {
+        }
+        if (node.newKeyword != null) {
+          if (element2 is ClassElement) {
+            ConstructorElement constructor = ((element2 as ClassElement)).unnamedConstructor;
+            recordResolution(simpleIdentifier, constructor);
+          } else {
+          }
+        }
+      }
+    } else if (identifier2 is PrefixedIdentifier) {
+      PrefixedIdentifier prefixedIdentifier = identifier2 as PrefixedIdentifier;
+      SimpleIdentifier prefix2 = prefixedIdentifier.prefix;
+      SimpleIdentifier name = prefixedIdentifier.identifier;
+      visitSimpleIdentifier(prefix2);
+      Element element3 = prefix2.element;
+      if (element3 != null) {
+        if (element3 is PrefixElement) {
+          element3 = _resolver.nameScope.lookup(identifier2, _resolver.definingLibrary);
+          recordResolution(name, element3);
+          return null;
+        }
+        if (element3.library != _resolver.definingLibrary) {
+        }
+        if (node.newKeyword == null) {
+          if (element3 is ClassElement) {
+            Element memberElement = lookupGetterOrMethod(((element3 as ClassElement)).type, name.name);
+            if (memberElement == null) {
+              memberElement = ((element3 as ClassElement)).getNamedConstructor(name.name);
+            }
+            if (memberElement == null) {
+              reportGetterOrSetterNotFound(prefixedIdentifier, name, element3.name);
+            } else {
+              recordResolution(name, memberElement);
+            }
+          } else {
+          }
+        } else {
+          if (element3 is ClassElement) {
+            ConstructorElement constructor = ((element3 as ClassElement)).getNamedConstructor(name.name);
+            if (constructor != null) {
+              recordResolution(name, constructor);
+            }
+          } else {
+          }
+        }
+      }
+    }
+    return null;
+  }
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     FieldElement fieldElement = null;
     SimpleIdentifier fieldName2 = node.fieldName;
     ClassElement enclosingClass2 = _resolver.enclosingClass;
     fieldElement = ((enclosingClass2 as ClassElementImpl)).getField(fieldName2.name);
     if (fieldElement == null) {
       _resolver.reportError(CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD, node, [fieldName2]);
     } else if (!fieldElement.isSynthetic()) {
       recordResolution(fieldName2, fieldElement);
       if (fieldElement.isStatic()) {
@@ skipping 45 matching lines @@
   }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     String fieldName = node.identifier.name;
     ClassElement classElement = _resolver.enclosingClass;
     if (classElement != null) {
       FieldElement fieldElement = ((classElement as ClassElementImpl)).getField(fieldName);
       if (fieldElement != null) {
         if (!fieldElement.isSynthetic()) {
           ParameterElement parameterElement = node.element;
           if (parameterElement is FieldFormalParameterElementImpl) {
-            ((parameterElement as FieldFormalParameterElementImpl)).field = fieldElement;
+            FieldFormalParameterElementImpl fieldFormal = parameterElement as FieldFormalParameterElementImpl;
+            fieldFormal.field = fieldElement;
+            Type2 declaredType = fieldFormal.type;
+            Type2 fieldType = fieldElement.type;
+            if (node.type == null) {
+              fieldFormal.type = fieldType;
+            }
             if (fieldElement.isStatic()) {
               _resolver.reportError(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [fieldName]);
+            } else if (declaredType != null && fieldType != null && !declaredType.isAssignableTo(fieldType)) {
+              _resolver.reportError(StaticWarningCode.FIELD_INITIALIZER_WITH_INVALID_TYPE, node, [declaredType.name, fieldType.name]);
             }
           }
         }
       } else {
         _resolver.reportError(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
       }
     }
     return super.visitFieldFormalParameter(node);
   }
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => null;
@@ skipping 144 matching lines @@
             _resolver.reportError(StaticTypeWarningCode.UNDEFINED_METHOD, methodName2, [methodName2.name, enclosingClass3.name]);
           } else {
             _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
           }
         } else {
           Type2 targetType = getType(target);
           String targetTypeName = targetType == null ? null : targetType.name;
           if (targetTypeName == null) {
             _resolver.reportError(StaticTypeWarningCode.UNDEFINED_FUNCTION, methodName2, [methodName2.name]);
           } else {
-            _resolver.reportError(StaticTypeWarningCode.UNDEFINED_METHOD, methodName2, [methodName2.name, targetTypeName]);
+            if (!doesClassDeclareNoSuchMethod(targetType.element)) {
+              _resolver.reportError(StaticTypeWarningCode.UNDEFINED_METHOD, methodName2, [methodName2.name, targetTypeName]);
+            }
           }
         }
         return null;
       }
     }
     recordResolution(methodName2, invokedMethod);
     resolveNamedArguments(node.argumentList, invokedMethod);
     return null;
   }
   Object visitPostfixExpression(PostfixExpression node) {
@@ skipping 137 matching lines @@
       memberElement = lookUpGetter(targetType, identifier.name);
     }
     if (memberElement == null) {
       MethodElement methodElement = lookUpMethod(targetType, identifier.name);
       if (methodElement != null) {
         recordResolution(identifier, methodElement);
         return null;
       }
     }
     if (memberElement == null) {
-      if (identifier.inSetterContext()) {
-        _resolver.reportError(StaticWarningCode.UNDEFINED_SETTER, identifier, [identifier.name, targetType.name]);
-      } else if (identifier.inGetterContext()) {
-        _resolver.reportError(StaticWarningCode.UNDEFINED_GETTER, identifier, [identifier.name, targetType.name]);
-      } else {
-        _resolver.reportError(StaticWarningCode.UNDEFINED_IDENTIFIER, identifier, [identifier.name]);
+      if (!doesClassDeclareNoSuchMethod(targetType.element)) {
+        if (identifier.inSetterContext()) {
+          _resolver.reportError(StaticWarningCode.UNDEFINED_SETTER, identifier, [identifier.name, targetType.name]);
+        } else if (identifier.inGetterContext()) {
+          _resolver.reportError(StaticWarningCode.UNDEFINED_GETTER, identifier, [identifier.name, targetType.name]);
+        } else {
+          System.out.println("two ${identifier.name}");
+          _resolver.reportError(StaticWarningCode.UNDEFINED_IDENTIFIER, identifier, [identifier.name]);
+        }
       }
     } else {
       recordResolution(identifier, memberElement);
     }
     return null;
   }
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     ClassElement enclosingClass2 = _resolver.enclosingClass;
     if (enclosingClass2 == null) {
       return null;
@@ skipping 36 matching lines @@
         element = lookUpSetter(enclosingType, node.name);
       }
       if (element == null && node.inGetterContext()) {
         element = lookUpGetter(enclosingType, node.name);
       }
       if (element == null) {
         element = lookUpMethod(enclosingType, node.name);
       }
     }
     if (element == null) {
-      _resolver.reportError(StaticWarningCode.UNDEFINED_IDENTIFIER, node, [node.name]);
+      if (!doesClassDeclareNoSuchMethod(enclosingClass2)) {
+        _resolver.reportError(StaticWarningCode.UNDEFINED_IDENTIFIER, node, [node.name]);
+      }
     }
     recordResolution(node, element);
     return null;
   }
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     ClassElement enclosingClass2 = _resolver.enclosingClass;
     if (enclosingClass2 == null) {
       return null;
     }
     ClassElement superclass = getSuperclass(enclosingClass2);
@@ skipping 21 matching lines @@
     TypeName bound2 = node.bound;
     if (bound2 != null) {
       TypeVariableElementImpl variable = node.name.element as TypeVariableElementImpl;
       if (variable != null) {
         variable.bound = bound2.type;
       }
     }
     return null;
   }
   /**
+   * Return {@code true} if the passed {@link Element} is a {@link ClassElement} that declares a
+   * method "noSuchMethod".
+   * @param element the {@link Element} to evaluate
+   * @return {@code true} if the passed {@link Element} is a {@link ClassElement} that declares a
+   * method "noSuchMethod"
+   */
+  bool doesClassDeclareNoSuchMethod(Element element) {
+    if (element == null) {
+      return false;
+    }
+    if (element is! ClassElementImpl) {
+      return false;
+    }
+    ClassElementImpl classElement = element as ClassElementImpl;
+    MethodElement method = classElement.lookUpMethod("noSuchMethod", _resolver.definingLibrary);
+    if (method == null) {
+      return false;
+    }
+    return true;
+  }
+  /**
    * Search through the array of parameters for a parameter whose name matches the given name.
    * Return the parameter with the given name, or {@code null} if there is no such parameter.
    * @param parameters the parameters being searched
    * @param name the name being searched for
    * @return the parameter with the given name
    */
   ParameterElement findNamedParameter(List<ParameterElement> parameters, String name2) {
     for (ParameterElement parameter in parameters) {
       if (identical(parameter.parameterKind, ParameterKind.NAMED)) {
         String parameteName = parameter.name;
@@ skipping 87 matching lines @@
         return getter;
       }
     }
     InterfaceType superclass2 = targetType.superclass;
     if (superclass2 == null) {
       return null;
     }
     return lookUpGetterInInterfaces(superclass2, getterName, visitedInterfaces);
   }
   /**
+   * Look up the method or getter with the given name in the given type. Return the element
+   * representing the method or getter that was found, or {@code null} if there is no method or
+   * getter with the given name.
+   * @param type the type in which the method or getter is defined
+   * @param memberName the name of the method or getter being looked up
+   * @return the element representing the method or getter that was found
+   */
+  ExecutableElement lookupGetterOrMethod(Type2 type, String memberName) {
+    type = resolveTypeVariable(type);
+    if (type is InterfaceType) {
+      InterfaceType interfaceType = type as InterfaceType;
+      ExecutableElement member = interfaceType.lookUpMethod(memberName, _resolver.definingLibrary);
+      if (member != null) {
+        return member;
+      }
+      member = interfaceType.lookUpGetter(memberName, _resolver.definingLibrary);
+      if (member != null) {
+        return member;
+      }
+      return lookUpGetterOrMethodInInterfaces(interfaceType, memberName, new Set<ClassElement>());
+    }
+    return null;
+  }
+  /**
+   * Look up the method or getter with the given name in the interfaces implemented by the given
+   * type, either directly or indirectly. Return the element representing the method or getter that
+   * was found, or {@code null} if there is no method or getter with the given name.
+   * @param targetType the type in which the method or getter might be defined
+   * @param memberName the name of the method or getter being looked up
+   * @param visitedInterfaces a set containing all of the interfaces that have been examined, used
+   * to prevent infinite recursion and to optimize the search
+   * @return the element representing the method or getter that was found
+   */
+  ExecutableElement lookUpGetterOrMethodInInterfaces(InterfaceType targetType, String memberName, Set<ClassElement> visitedInterfaces) {
+    ClassElement targetClass = targetType.element;
+    if (visitedInterfaces.contains(targetClass)) {
+      return null;
+    }
+    javaSetAdd(visitedInterfaces, targetClass);
+    ExecutableElement member = targetType.getMethod(memberName);
+    if (member != null) {
+      return member;
+    }
+    member = targetType.getGetter(memberName);
+    if (member != null) {
+      return member;
+    }
+    for (InterfaceType interfaceType in targetType.interfaces) {
+      member = lookUpGetterOrMethodInInterfaces(interfaceType, memberName, visitedInterfaces);
+      if (member != null) {
+        return member;
+      }
+    }
+    InterfaceType superclass2 = targetType.superclass;
+    if (superclass2 == null) {
+      return null;
+    }
+    return lookUpGetterInInterfaces(superclass2, memberName, visitedInterfaces);
+  }
+  /**
    * Find the element corresponding to the given label node in the current label scope.
    * @param parentNode the node containing the given label
    * @param labelNode the node representing the label being looked up
    * @return the element corresponding to the given label node in the current scope
    */
   LabelElementImpl lookupLabel(ASTNode parentNode, SimpleIdentifier labelNode) {
     LabelScope labelScope2 = _resolver.labelScope;
     LabelElementImpl labelElement = null;
     if (labelNode == null) {
       if (labelScope2 == null) {
@@ skipping 163 matching lines @@
    * 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 element2) {
     if (element2 != null) {
       node.element = element2;
     }
   }
   /**
-   * Report the {@link StaticTypeWarningCode}s <code>UNDEFINED_SETTER</code> and
-   * <code>UNDEFINED_GETTER</code>.
+   * 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
    */
   void reportGetterOrSetterNotFound(PrefixedIdentifier node, SimpleIdentifier identifier2, String typeName) {
+    Type2 targetType = getType(node);
+    if (targetType != null && doesClassDeclareNoSuchMethod(targetType.element)) {
+      return;
+    }
     bool isSetterContext = node.identifier.inSetterContext();
     ErrorCode errorCode = isSetterContext ? StaticTypeWarningCode.UNDEFINED_SETTER : StaticTypeWarningCode.UNDEFINED_GETTER;
     _resolver.reportError(errorCode, identifier2, [identifier2.name, typeName]);
   }
   /**
    * Resolve the names in the given combinators in the scope of the given library.
    * @param library the library that defines the names
    * @param combinators the combinators containing the names to be resolved
    */
   void resolveCombinators(LibraryElement library, NodeList<Combinator> combinators) {
@@ skipping 479 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(InternalAnalysisContext analysisContext) {
-    _jtd_constructor_263_impl(analysisContext);
+    _jtd_constructor_264_impl(analysisContext);
   }
-  _jtd_constructor_263_impl(InternalAnalysisContext analysisContext) {
-    _jtd_constructor_264_impl(analysisContext, null);
+  _jtd_constructor_264_impl(InternalAnalysisContext analysisContext) {
+    _jtd_constructor_265_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(InternalAnalysisContext analysisContext2, AnalysisErrorListener additionalAnalysisErrorListener) {
-    _jtd_constructor_264_impl(analysisContext2, additionalAnalysisErrorListener);
+    _jtd_constructor_265_impl(analysisContext2, additionalAnalysisErrorListener);
   }
-  _jtd_constructor_264_impl(InternalAnalysisContext analysisContext2, AnalysisErrorListener additionalAnalysisErrorListener) {
+  _jtd_constructor_265_impl(InternalAnalysisContext analysisContext2, AnalysisErrorListener additionalAnalysisErrorListener) {
     this._analysisContext = analysisContext2;
     this._recordingErrorListener = new RecordingErrorListener();
     if (additionalAnalysisErrorListener == null) {
       this._errorListener = _recordingErrorListener;
     } else {
       this._errorListener = new AnalysisErrorListener_9(this, additionalAnalysisErrorListener);
     }
     _coreLibrarySource = analysisContext2.sourceFactory.forUri(DartSdk.DART_CORE);
   }
   /**
@@ skipping 394 matching lines @@
    * Record the results of resolution with the analysis context. This includes recording
    * <ul>
    * <li>the resolved AST associated with each compilation unit,</li>
    * <li>the set of resolution errors produced for each compilation unit, and</li>
    * <li>the element models produced for each library.</li>
    * </ul>
    */
   void recordResults() {
     Map<Source, LibraryElement> elementMap = new Map<Source, LibraryElement>();
     for (Library library in _librariesInCycles) {
-      recordResults2(library.librarySource, library.definingCompilationUnit);
+      Source librarySource2 = library.librarySource;
+      recordResults2(librarySource2, librarySource2, library.definingCompilationUnit);
       for (Source source in library.compilationUnitSources) {
-        recordResults2(source, library.getAST(source));
+        recordResults2(source, librarySource2, library.getAST(source));
       }
       elementMap[library.librarySource] = library.libraryElement;
     }
     _analysisContext.recordLibraryElements(elementMap);
   }
-  void recordResults2(Source source, CompilationUnit unit) {
+  void recordResults2(Source source, Source librarySource, CompilationUnit unit) {
     List<AnalysisError> errors = _recordingErrorListener.getErrors2(source);
     unit.resolutionErrors = errors;
-    _analysisContext.recordResolvedCompilationUnit(source, unit);
-    _analysisContext.recordResolutionErrors(source, errors, unit.lineInfo);
+    _analysisContext.recordResolvedCompilationUnit(source, librarySource, unit);
+    _analysisContext.recordResolutionErrors(source, librarySource, errors, unit.lineInfo);
   }
   /**
    * Resolve the identifiers and perform type analysis in the libraries in the current cycle.
    * @throws AnalysisException if any of the identifiers could not be resolved or if any of the
    * libraries could not have their types analyzed
    */
   void resolveReferencesAndTypes() {
     for (Library library in _librariesInCycles) {
       resolveReferencesAndTypes2(library);
     }
@@ skipping 74 matching lines @@
    * The object keeping track of which elements have had their types overridden.
    */
   TypeOverrideManager _overrideManager = new TypeOverrideManager();
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   ResolverVisitor.con1(Library library, Source source, TypeProvider typeProvider) : super.con1(library, source, typeProvider) {
-    _jtd_constructor_265_impl(library, source, typeProvider);
+    _jtd_constructor_266_impl(library, source, typeProvider);
   }
-  _jtd_constructor_265_impl(Library library, Source source, TypeProvider typeProvider) {
+  _jtd_constructor_266_impl(Library library, Source source, TypeProvider typeProvider) {
     this._elementResolver = new ElementResolver(this);
     this._typeAnalyzer = new StaticTypeAnalyzer(this);
   }
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    * @param definingLibrary the element for the library containing the compilation unit being
    * visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    * during resolution
    */
   ResolverVisitor.con2(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) : super.con2(definingLibrary, source, typeProvider, errorListener) {
-    _jtd_constructor_266_impl(definingLibrary, source, typeProvider, errorListener);
+    _jtd_constructor_267_impl(definingLibrary, source, typeProvider, errorListener);
   }
-  _jtd_constructor_266_impl(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
+  _jtd_constructor_267_impl(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
     this._elementResolver = new ElementResolver(this);
     this._typeAnalyzer = new StaticTypeAnalyzer(this);
   }
   /**
    * Return the object keeping track of which elements have had their types overridden.
    * @return the object keeping track of which elements have had their types overridden
    */
   TypeOverrideManager get overrideManager => _overrideManager;
   Object visitAsExpression(AsExpression node) {
     super.visitAsExpression(node);
     if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
       VariableElement element = getOverridableElement(node.expression);
       if (element != null) {
         Type2 type2 = node.type.type;
         if (type2 != null) {
-          _overrideManager.setType(element, type2);
+          override(element, getType(element), type2);
         }
       }
     }
     return null;
   }
   Object visitAssertStatement(AssertStatement node) {
-    Expression condition2 = node.condition;
-    condition2.accept(this);
-    propagateTrueState(condition2);
+    super.visitAssertStatement(node);
+    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      propagateTrueState(node.condition);
+    }
+    return null;
+  }
+  Object visitBinaryExpression(BinaryExpression node) {
+    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      sc.TokenType operatorType = node.operator.type;
+      if (identical(operatorType, sc.TokenType.AMPERSAND_AMPERSAND)) {
+        Expression leftOperand2 = node.leftOperand;
+        leftOperand2.accept(this);
+        Expression rightOperand2 = node.rightOperand;
+        if (rightOperand2 != null) {
+          try {
+            _overrideManager.enterScope();
+            propagateTrueState(leftOperand2);
+            rightOperand2.accept(this);
+          } finally {
+            _overrideManager.exitScope();
+          }
+        }
+      } else if (identical(operatorType, sc.TokenType.BAR_BAR)) {
+        Expression leftOperand3 = node.leftOperand;
+        leftOperand3.accept(this);
+        Expression rightOperand3 = node.rightOperand;
+        if (rightOperand3 != null) {
+          try {
+            _overrideManager.enterScope();
+            propagateFalseState(leftOperand3);
+            rightOperand3.accept(this);
+          } finally {
+            _overrideManager.exitScope();
+          }
+        }
+      } else {
+        node.leftOperand.accept(this);
+        node.rightOperand.accept(this);
+      }
+      node.accept(_elementResolver);
+      node.accept(_typeAnalyzer);
+    } else {
+      super.visitBinaryExpression(node);
+    }
     return null;
   }
   Object visitBreakStatement(BreakStatement node) {
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerType = _enclosingClass;
     try {
       _enclosingClass = node.element;
       _typeAnalyzer.thisType = _enclosingClass == null ? null : _enclosingClass.type;
       super.visitClassDeclaration(node);
     } finally {
       _typeAnalyzer.thisType = outerType == null ? null : outerType.type;
       _enclosingClass = outerType;
     }
     return null;
   }
-  Object visitComment(Comment node) => null;
+  Object visitCommentReference(CommentReference node) {
+    node.accept(_elementResolver);
+    node.accept(_typeAnalyzer);
+    return null;
+  }
   Object visitCompilationUnit(CompilationUnit node) {
-    try {
-      _overrideManager.enterScope();
-      for (Directive directive in node.directives) {
-        directive.accept(this);
-      }
-      List<CompilationUnitMember> classes = new List<CompilationUnitMember>();
-      for (CompilationUnitMember declaration in node.declarations) {
-        if (declaration is ClassDeclaration) {
-          classes.add(declaration);
-        } else {
+    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      try {
+        _overrideManager.enterScope();
+        for (Directive directive in node.directives) {
+          directive.accept(this);
+        }
+        List<CompilationUnitMember> classes = new List<CompilationUnitMember>();
+        for (CompilationUnitMember declaration in node.declarations) {
+          if (declaration is ClassDeclaration) {
+            classes.add(declaration);
+          } else {
+            declaration.accept(this);
+          }
+        }
+        for (CompilationUnitMember declaration in classes) {
           declaration.accept(this);
         }
+      } finally {
+        _overrideManager.exitScope();
       }
-      for (CompilationUnitMember declaration in classes) {
-        declaration.accept(this);
-      }
-    } finally {
-      _overrideManager.exitScope();
+      node.accept(_elementResolver);
+      node.accept(_typeAnalyzer);
+    } else {
+      super.visitCompilationUnit(node);
     }
     return null;
   }
   Object visitConditionalExpression(ConditionalExpression node) {
-    Expression condition2 = node.condition;
-    condition2.accept(this);
-    Expression thenExpression2 = node.thenExpression;
-    if (thenExpression2 != null) {
-      try {
-        _overrideManager.enterScope();
-        propagateTrueState(condition2);
-        thenExpression2.accept(this);
-      } finally {
-        _overrideManager.exitScope();
+    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      Expression condition2 = node.condition;
+      condition2.accept(this);
+      Expression thenExpression2 = node.thenExpression;
+      if (thenExpression2 != null) {
+        try {
+          _overrideManager.enterScope();
+          propagateTrueState(condition2);
+          thenExpression2.accept(this);
+        } finally {
+          _overrideManager.exitScope();
+        }
       }
-    }
-    Expression elseExpression2 = node.elseExpression;
-    if (elseExpression2 != null) {
-      try {
-        _overrideManager.enterScope();
-        propagateFalseState(condition2);
-        elseExpression2.accept(this);
-      } finally {
-        _overrideManager.exitScope();
+      Expression elseExpression2 = node.elseExpression;
+      if (elseExpression2 != null) {
+        try {
+          _overrideManager.enterScope();
+          propagateFalseState(condition2);
+          elseExpression2.accept(this);
+        } finally {
+          _overrideManager.exitScope();
+        }
       }
-    }
-    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      node.accept(_elementResolver);
+      node.accept(_typeAnalyzer);
       bool thenIsAbrupt = thenExpression2 != null && isAbruptTermination(thenExpression2);
       bool elseIsAbrupt = elseExpression2 != null && isAbruptTermination(elseExpression2);
       if (elseIsAbrupt && !thenIsAbrupt) {
         propagateTrueState(condition2);
       } else if (thenIsAbrupt && !elseIsAbrupt) {
         propagateFalseState(condition2);
       }
+    } else {
+      super.visitConditionalExpression(node);
     }
     return null;
   }
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       super.visitConstructorDeclaration(node);
     } finally {
       _enclosingFunction = outerFunction;
@@ skipping 10 matching lines @@
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitContinueStatement(ContinueStatement node) {
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitFieldDeclaration(FieldDeclaration node) {
-    try {
-      _overrideManager.enterScope();
+    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      try {
+        _overrideManager.enterScope();
+        super.visitFieldDeclaration(node);
+      } finally {
+        Map<Element, Type2> overrides = captureOverrides(node.fields);
+        _overrideManager.exitScope();
+        applyOverrides(overrides);
+      }
+    } else {
       super.visitFieldDeclaration(node);
-    } finally {
-      Map<Element, Type2> overrides = captureOverrides(node.fields);
-      _overrideManager.exitScope();
-      for (MapEntry<Element, Type2> entry in getMapEntrySet(overrides)) {
-        _overrideManager.setType(entry.getKey(), entry.getValue());
+    }
+    return null;
+  }
+  Object visitForEachStatement(ForEachStatement node) {
+    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      try {
+        _overrideManager.enterScope();
+        super.visitForEachStatement(node);
+      } finally {
+        _overrideManager.exitScope();
       }
+    } else {
+      super.visitForEachStatement(node);
     }
     return null;
   }
   Object visitForStatement(ForStatement node) {
-    try {
-      _overrideManager.enterScope();
+    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      try {
+        _overrideManager.enterScope();
+        super.visitForStatement(node);
+      } finally {
+        _overrideManager.exitScope();
+      }
+    } else {
       super.visitForStatement(node);
-    } finally {
-      _overrideManager.exitScope();
     }
     return null;
   }
   Object visitFunctionBody(FunctionBody node) {
-    try {
-      _overrideManager.enterScope();
+    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      try {
+        _overrideManager.enterScope();
+        super.visitFunctionBody(node);
+      } finally {
+        _overrideManager.exitScope();
+      }
+    } else {
       super.visitFunctionBody(node);
-    } finally {
-      _overrideManager.exitScope();
     }
     return null;
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       SimpleIdentifier functionName = node.name;
       _enclosingFunction = functionName.element as ExecutableElement;
       super.visitFunctionDeclaration(node);
     } finally {
       _enclosingFunction = outerFunction;
     }
     return null;
   }
   Object visitFunctionExpression(FunctionExpression node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
-      _overrideManager.enterScope();
+      if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+        _overrideManager.enterScope();
+      }
       super.visitFunctionExpression(node);
     } finally {
-      _overrideManager.exitScope();
+      if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+        _overrideManager.exitScope();
+      }
       _enclosingFunction = outerFunction;
     }
     return null;
   }
   Object visitHideCombinator(HideCombinator node) => null;
   Object visitIfStatement(IfStatement node) {
-    Expression condition2 = node.condition;
-    condition2.accept(this);
-    Statement thenStatement2 = node.thenStatement;
-    if (thenStatement2 != null) {
-      try {
-        _overrideManager.enterScope();
-        propagateTrueState(condition2);
-        thenStatement2.accept(this);
-      } finally {
-        _overrideManager.exitScope();
+    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      Expression condition2 = node.condition;
+      condition2.accept(this);
+      Statement thenStatement2 = node.thenStatement;
+      if (thenStatement2 != null) {
+        try {
+          _overrideManager.enterScope();
+          propagateTrueState(condition2);
+          thenStatement2.accept(this);
+        } finally {
+          _overrideManager.exitScope();
+        }
       }
-    }
-    Statement elseStatement2 = node.elseStatement;
-    if (elseStatement2 != null) {
-      try {
-        _overrideManager.enterScope();
-        propagateFalseState(condition2);
-        elseStatement2.accept(this);
-      } finally {
-        _overrideManager.exitScope();
+      Statement elseStatement2 = node.elseStatement;
+      if (elseStatement2 != null) {
+        try {
+          _overrideManager.enterScope();
+          propagateFalseState(condition2);
+          elseStatement2.accept(this);
+        } finally {
+          _overrideManager.exitScope();
+        }
       }
-    }
-    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      node.accept(_elementResolver);
+      node.accept(_typeAnalyzer);
       bool thenIsAbrupt = thenStatement2 != null && isAbruptTermination2(thenStatement2);
       bool elseIsAbrupt = elseStatement2 != null && isAbruptTermination2(elseStatement2);
       if (elseIsAbrupt && !thenIsAbrupt) {
         propagateTrueState(condition2);
       } else if (thenIsAbrupt && !elseIsAbrupt) {
         propagateFalseState(condition2);
       }
+    } else {
+      super.visitIfStatement(node);
     }
     return null;
   }
   Object visitLabel(Label node) => null;
   Object visitLibraryIdentifier(LibraryIdentifier node) => null;
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       super.visitMethodDeclaration(node);
@@ skipping 34 matching lines @@
     return null;
   }
   Object visitShowCombinator(ShowCombinator node) => null;
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     safelyVisit(node.argumentList);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitSwitchCase(SwitchCase node) {
-    try {
-      _overrideManager.enterScope();
+    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      try {
+        _overrideManager.enterScope();
+        super.visitSwitchCase(node);
+      } finally {
+        _overrideManager.exitScope();
+      }
+    } else {
       super.visitSwitchCase(node);
-    } finally {
-      _overrideManager.exitScope();
     }
     return null;
   }
   Object visitSwitchDefault(SwitchDefault node) {
-    try {
-      _overrideManager.enterScope();
+    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      try {
+        _overrideManager.enterScope();
+        super.visitSwitchDefault(node);
+      } finally {
+        _overrideManager.exitScope();
+      }
+    } else {
       super.visitSwitchDefault(node);
-    } finally {
-      _overrideManager.exitScope();
     }
     return null;
   }
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
-    try {
-      _overrideManager.enterScope();
+    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      try {
+        _overrideManager.enterScope();
+        super.visitTopLevelVariableDeclaration(node);
+      } finally {
+        Map<Element, Type2> overrides = captureOverrides(node.variables);
+        _overrideManager.exitScope();
+        applyOverrides(overrides);
+      }
+    } else {
       super.visitTopLevelVariableDeclaration(node);
-    } finally {
-      Map<Element, Type2> overrides = captureOverrides(node.variables);
-      _overrideManager.exitScope();
-      for (MapEntry<Element, Type2> entry in getMapEntrySet(overrides)) {
-        _overrideManager.setType(entry.getKey(), entry.getValue());
-      }
     }
     return null;
   }
   Object visitTypeName(TypeName node) => null;
+  Object visitWhileStatement(WhileStatement node) {
+    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      Expression condition2 = node.condition;
+      condition2.accept(this);
+      Statement body2 = node.body;
+      if (body2 != null) {
+        try {
+          _overrideManager.enterScope();
+          propagateTrueState(condition2);
+          body2.accept(this);
+        } finally {
+          _overrideManager.exitScope();
+        }
+      }
+      node.accept(_elementResolver);
+      node.accept(_typeAnalyzer);
+    } else {
+      super.visitWhileStatement(node);
+    }
+    return null;
+  }
   /**
    * Return the class element representing the class containing the current node, or {@code null} if
    * the current node is not contained in a class.
    * @return the class element representing the class containing the current node
    */
   ClassElement get enclosingClass => _enclosingClass;
   /**
    * Return the element representing the function containing the current node, or {@code null} if
    * the current node is not contained in a function.
    * @return the element representing the function containing the current node
    */
   ExecutableElement get enclosingFunction => _enclosingFunction;
   /**
    * Return the element associated with the given expression whose type can be overridden, or{@code null} if there is no element whose type can be overridden.
    * @param expression the expression with which the element is associated
    * @return the element associated with the given expression
    */
   VariableElement getOverridableElement(Expression expression) {
     if (expression is SimpleIdentifier) {
       Element element2 = ((expression as SimpleIdentifier)).element;
       if (element2 is VariableElement) {
         return element2 as VariableElement;
       }
     }
     return null;
   }
+  void visitForEachStatementInScope(ForEachStatement node) {
+    if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
+      DeclaredIdentifier loopVariable2 = node.loopVariable;
+      safelyVisit(loopVariable2);
+      Expression iterator2 = node.iterator;
+      if (iterator2 != null) {
+        iterator2.accept(this);
+        if (loopVariable2 != null) {
+          LocalVariableElement loopElement = loopVariable2.element;
+          override(loopElement, loopElement.type, getIteratorElementType(iterator2));
+        }
+      }
+      safelyVisit(node.body);
+      node.accept(_elementResolver);
+      node.accept(_typeAnalyzer);
+    } else {
+      super.visitForEachStatementInScope(node);
+    }
+  }
+  /**
+   * Apply a set of overrides that were previously captured.
+   * @param overrides the overrides to be applied
+   */
+  void applyOverrides(Map<Element, Type2> overrides) {
+    for (MapEntry<Element, Type2> entry in getMapEntrySet(overrides)) {
+      _overrideManager.setType(entry.getKey(), entry.getValue());
+    }
+  }
   /**
    * Return a map from the elements for the variables in the given list that have their types
    * overridden to the overriding type.
    * @param variableList the list of variables whose overriding types are to be captured
    * @return a table mapping elements to their overriding types
    */
   Map<Element, Type2> captureOverrides(VariableDeclarationList variableList) {
     Map<Element, Type2> overrides = new Map<Element, Type2>();
     if (StaticTypeAnalyzer.USE_TYPE_PROPAGATION) {
       if (variableList.isConst() || variableList.isFinal()) {
         for (VariableDeclaration variable in variableList.variables) {
           Element element2 = variable.element;
           if (element2 != null) {
             Type2 type = _overrideManager.getType(element2);
             if (type != null) {
               overrides[element2] = type;
             }
           }
         }
       }
     }
     return overrides;
   }
   /**
+   * The given expression is the expression used to compute the iterator for a for-each statement.
+   * Attempt to compute the type of objects that will be assigned to the loop variable and return
+   * that type. Return {@code null} if the type could not be determined.
+   * @param iterator the iterator for a for-each statement
+   * @return the type of objects that will be assigned to the loop variable
+   */
+  Type2 getIteratorElementType(Expression iteratorExpression) {
+    Type2 expressionType = iteratorExpression.staticType;
+    if (expressionType is InterfaceType) {
+      PropertyAccessorElement iterator = ((expressionType as InterfaceType)).lookUpGetter("iterator", definingLibrary);
+      if (iterator == null) {
+        return null;
+      }
+      Type2 iteratorType = iterator.type.returnType;
+      if (iteratorType is InterfaceType) {
+        PropertyAccessorElement current = ((iteratorType as InterfaceType)).lookUpGetter("current", definingLibrary);
+        if (current == null) {
+          return null;
+        }
+        return current.type.returnType;
+      }
+    }
+    return null;
+  }
+  /**
+   * Return the type of the given (overridable) element.
+   * @param element the element whose type is to be returned
+   * @return the type of the given element
+   */
+  Type2 getType(Element element) {
+    if (element is LocalVariableElement) {
+      return ((element as LocalVariableElement)).type;
+    } else if (element is ParameterElement) {
+      return ((element as ParameterElement)).type;
+    }
+    return null;
+  }
+  /**
    * Return {@code true} if the given expression terminates abruptly (that is, if any expression
    * following the given expression will not be reached).
    * @param expression the expression being tested
    * @return {@code true} if the given expression terminates abruptly
    */
   bool isAbruptTermination(Expression expression2) {
     while (expression2 is ParenthesizedExpression) {
       expression2 = ((expression2 as ParenthesizedExpression)).expression;
     }
     return expression2 is ThrowExpression || expression2 is RethrowExpression;
@@ skipping 13 matching lines @@
       NodeList<Statement> statements2 = ((statement as Block)).statements;
       int size2 = statements2.length;
       if (size2 == 0) {
         return false;
       }
       return isAbruptTermination2(statements2[size2 - 1]);
     }
     return false;
   }
   /**
+   * If it is appropriate to do so, override the type of the given element. Use the static type and
+   * inferred type of the element to determine whether or not it is appropriate.
+   * @param element the element whose type might be overridden
+   * @param staticType the static type of the element
+   * @param inferredType the inferred type of the element
+   */
+  void override(VariableElement element, Type2 staticType, Type2 inferredType) {
+    if (identical(inferredType, BottomTypeImpl.instance)) {
+      return;
+    }
+    if (element is PropertyInducingElement) {
+      PropertyInducingElement variable = element as PropertyInducingElement;
+      if (!variable.isConst() && !variable.isFinal()) {
+        return;
+      }
+    }
+    if (staticType == null || (inferredType != null && inferredType.isMoreSpecificThan(staticType))) {
+      _overrideManager.setType(element, inferredType);
+    }
+  }
+  /**
    * Propagate any type information that results from knowing that the given condition will have
    * evaluated to 'false'.
    * @param condition the condition that will have evaluated to 'false'
    */
   void propagateFalseState(Expression condition) {
     while (condition is ParenthesizedExpression) {
       condition = ((condition as ParenthesizedExpression)).expression;
     }
     if (condition is IsExpression) {
       IsExpression is2 = condition as IsExpression;
       if (is2.notOperator != null) {
-        Element element = getOverridableElement(is2.expression);
+        VariableElement element = getOverridableElement(is2.expression);
         if (element != null) {
           Type2 type2 = is2.type.type;
           if (type2 != null) {
-            _overrideManager.setType(element, type2);
+            override(element, getType(element), type2);
           }
         }
       }
     } else if (condition is BinaryExpression) {
       BinaryExpression binary = condition as BinaryExpression;
       if (identical(binary.operator.type, sc.TokenType.BAR_BAR)) {
         propagateFalseState(binary.leftOperand);
         propagateFalseState(binary.rightOperand);
       }
     }
   }
   /**
    * Propagate any type information that results from knowing that the given condition will have
    * evaluated to 'true'.
    * @param condition the condition that will have evaluated to 'true'
    */
   void propagateTrueState(Expression condition) {
     while (condition is ParenthesizedExpression) {
       condition = ((condition as ParenthesizedExpression)).expression;
     }
     if (condition is IsExpression) {
       IsExpression is2 = condition as IsExpression;
       if (is2.notOperator == null) {
-        Element element = getOverridableElement(is2.expression);
+        VariableElement element = getOverridableElement(is2.expression);
         if (element != null) {
           Type2 type2 = is2.type.type;
           if (type2 != null) {
-            _overrideManager.setType(element, type2);
+            override(element, getType(element), type2);
           }
         }
       }
     } else if (condition is BinaryExpression) {
       BinaryExpression binary = condition as BinaryExpression;
       if (identical(binary.operator.type, sc.TokenType.AMPERSAND_AMPERSAND)) {
         propagateTrueState(binary.leftOperand);
         propagateTrueState(binary.rightOperand);
       }
     }
@@ skipping 48 matching lines @@
    * The scope used to resolve labels for {@code break} and {@code continue} statements, or{@code null} if no labels have been defined in the current context.
    */
   LabelScope _labelScope;
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   ScopedVisitor.con1(Library library, Source source2, TypeProvider typeProvider2) {
-    _jtd_constructor_267_impl(library, source2, typeProvider2);
+    _jtd_constructor_268_impl(library, source2, typeProvider2);
   }
-  _jtd_constructor_267_impl(Library library, Source source2, TypeProvider typeProvider2) {
+  _jtd_constructor_268_impl(Library library, Source source2, TypeProvider typeProvider2) {
     this._definingLibrary = library.libraryElement;
     this._source = source2;
     LibraryScope libraryScope2 = library.libraryScope;
     this._errorListener = libraryScope2.errorListener;
     this._nameScope = libraryScope2;
     this._typeProvider = typeProvider2;
   }
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    * @param definingLibrary the element for the library containing the compilation unit being
    * visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    * during resolution
    */
   ScopedVisitor.con2(LibraryElement definingLibrary2, Source source2, TypeProvider typeProvider2, AnalysisErrorListener errorListener2) {
-    _jtd_constructor_268_impl(definingLibrary2, source2, typeProvider2, errorListener2);
+    _jtd_constructor_269_impl(definingLibrary2, source2, typeProvider2, errorListener2);
   }
-  _jtd_constructor_268_impl(LibraryElement definingLibrary2, Source source2, TypeProvider typeProvider2, AnalysisErrorListener errorListener2) {
+  _jtd_constructor_269_impl(LibraryElement definingLibrary2, Source source2, TypeProvider typeProvider2, AnalysisErrorListener errorListener2) {
     this._definingLibrary = definingLibrary2;
     this._source = source2;
     this._errorListener = errorListener2;
     this._nameScope = new LibraryScope(definingLibrary2, errorListener2);
     this._typeProvider = typeProvider2;
   }
   /**
    * Return the library element for the library containing the compilation unit being resolved.
    * @return the library element for the library containing the compilation unit being resolved
    */
@@ skipping 78 matching lines @@
       _labelScope = outerScope;
     }
     return null;
   }
   Object visitForEachStatement(ForEachStatement node) {
     LabelScope outerLabelScope = _labelScope;
     _labelScope = new LabelScope.con1(outerLabelScope, false, false);
     Scope outerNameScope = _nameScope;
     _nameScope = new EnclosedScope(_nameScope);
     try {
-      super.visitForEachStatement(node);
+      visitForEachStatementInScope(node);
     } finally {
       _nameScope = outerNameScope;
       _labelScope = outerLabelScope;
     }
     return null;
   }
   Object visitForStatement(ForStatement node) {
     LabelScope outerLabelScope = _labelScope;
     _labelScope = new LabelScope.con1(outerLabelScope, false, false);
     Scope outerNameScope = _nameScope;
@@ skipping 135 matching lines @@
    * @return the name scope in which the current node is being resolved
    */
   Scope get nameScope => _nameScope;
   /**
    * Report an error with the given error code and arguments.
    * @param errorCode the error code of the error to be reported
    * @param node the node specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportError(ErrorCode errorCode, ASTNode node, List<Object> arguments) {
-    _errorListener.onError(new AnalysisError.con2(_source, node.offset, node.length, errorCode, [arguments]));
+    _errorListener.onError(new AnalysisError.con2(_source, node.offset, node.length, errorCode, arguments));
   }
   /**
    * Report an error with the given error code and arguments.
    * @param errorCode the error code of the error to be reported
    * @param token the token specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportError3(ErrorCode errorCode, sc.Token token, List<Object> arguments) {
-    _errorListener.onError(new AnalysisError.con2(_source, token.offset, token.length, errorCode, [arguments]));
+    _errorListener.onError(new AnalysisError.con2(_source, token.offset, token.length, errorCode, arguments));
+  }
+  /**
+   * Visit the given statement after it's scope has been created. This replaces the normal call to
+   * the inherited visit method so that ResolverVisitor can intervene when type propagation is
+   * enabled.
+   * @param node the statement to be visited
+   */
+  void visitForEachStatementInScope(ForEachStatement node) {
+    super.visitForEachStatement(node);
   }
   /**
    * Add scopes for each of the given labels.
    * @param labels the labels for which new scopes are to be added
    * @return the scope that was in effect before the new scopes were added
    */
   LabelScope addScopesFor(NodeList<Label> labels) {
     LabelScope outerScope = _labelScope;
     for (Label label in labels) {
       SimpleIdentifier labelNameNode = label.label;
@@ skipping 165 matching lines @@
    * <p>
    * ... an assignment of the form <i>e<sub>1</sub>.v = e<sub>2</sub></i> ...
    * <p>
    * Let <i>T</i> be the static type of <i>e<sub>1</sub></i>. It is a static type warning if
    * <i>T</i> does not have an accessible instance setter named <i>v=</i>. It is a static type
    * warning if the static type of <i>e<sub>2</sub></i> may not be assigned to <i>T</i>.
    * <p>
    * The static type of the expression <i>e<sub>1</sub>.v = e<sub>2</sub></i> is the static type of
    * <i>e<sub>2</sub></i>.
    * <p>
-   * ... an assignment of the form <i>e<sub>1</sub>[e<sub>2</sub>] = e<sub>3</sub></i> ...
+   * ... an assignment of the form <i>e<sub>1</sub>[[e<sub>2</sub>]] = e<sub>3</sub></i> ...
    * <p>
-   * The static type of the expression <i>e<sub>1</sub>[e<sub>2</sub>] = e<sub>3</sub></i> is the
+   * The static type of the expression <i>e<sub>1</sub>[[e<sub>2</sub>]] = e<sub>3</sub></i> is the
    * static type of <i>e<sub>3</sub></i>.
    * <p>
    * A compound assignment of the form <i>v op= e</i> is equivalent to <i>v = v op e</i>. A compound
    * assignment of the form <i>C.v op= e</i> is equivalent to <i>C.v = C.v op e</i>. A compound
    * 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>,
+   * <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 operator2 = node.operator.type;
     if (operator2 != sc.TokenType.EQ) {
       return recordReturnType(node, node.element);
     }
     Type2 rightType = getType2(node.rightHandSide);
     if (USE_TYPE_PROPAGATION) {
@@ skipping 94 matching lines @@
    */
   Object visitDoubleLiteral(DoubleLiteral node) => recordType(node, _typeProvider.doubleType);
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     FunctionExpression function = node.functionExpression;
     FunctionTypeImpl functionType = node.element.type as FunctionTypeImpl;
     setTypeInformation(functionType, computeReturnType(node), function.parameters);
     return recordType(function, functionType);
   }
   /**
    * The Dart Language Specification, 12.9: <blockquote>The static type of a function literal of the
-   * form <i>(T<sub>1</sub> a<sub>1</sub>, &hellip;, T<sub>n</sub> a<sub>n</sub>, [T<sub>n+1</sub>
-   * x<sub>n+1</sub> = d1, &hellip;, T<sub>n+k</sub> x<sub>n+k</sub> = dk]) => e</i> is
-   * <i>(T<sub>1</sub>, &hellip;, Tn, [T<sub>n+1</sub> x<sub>n+1</sub>, &hellip;, T<sub>n+k</sub>
-   * x<sub>n+k</sub>]) &rarr; T<sub>0</sub></i>, where <i>T<sub>0</sub></i> is the static type of
+   * form <i>(T<sub>1</sub> a<sub>1</sub>, &hellip;, T<sub>n</sub> a<sub>n</sub>, [[T<sub>n+1</sub>
+   * x<sub>n+1</sub> = d1, &hellip;, T<sub>n+k</sub> x<sub>n+k</sub> = dk]]) => e</i> is
+   * <i>(T<sub>1</sub>, &hellip;, Tn, [[T<sub>n+1</sub> x<sub>n+1</sub>, &hellip;, T<sub>n+k</sub>
+   * x<sub>n+k</sub>]]) &rarr; T<sub>0</sub></i>, where <i>T<sub>0</sub></i> is the static type of
    * <i>e</i>. In any case where <i>T<sub>i</sub>, 1 &lt;= i &lt;= n</i>, is not specified, it is
    * considered to have been specified as dynamic.
    * <p>
    * The static type of a function literal of the form <i>(T<sub>1</sub> a<sub>1</sub>, &hellip;,
    * T<sub>n</sub> a<sub>n</sub>, {T<sub>n+1</sub> x<sub>n+1</sub> : d1, &hellip;, T<sub>n+k</sub>
    * x<sub>n+k</sub> : dk}) => e</i> is <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, {T<sub>n+1</sub>
    * x<sub>n+1</sub>, &hellip;, T<sub>n+k</sub> x<sub>n+k</sub>}) &rarr; T<sub>0</sub></i>, where
    * <i>T<sub>0</sub></i> is the static type of <i>e</i>. In any case where <i>T<sub>i</sub>, 1
    * &lt;= i &lt;= n</i>, is not specified, it is considered to have been specified as dynamic.
    * <p>
    * The static type of a function literal of the form <i>(T<sub>1</sub> a<sub>1</sub>, &hellip;,
-   * T<sub>n</sub> a<sub>n</sub>, [T<sub>n+1</sub> x<sub>n+1</sub> = d1, &hellip;, T<sub>n+k</sub>
-   * x<sub>n+k</sub> = dk]) {s}</i> is <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, [T<sub>n+1</sub>
-   * x<sub>n+1</sub>, &hellip;, T<sub>n+k</sub> x<sub>n+k</sub>]) &rarr; dynamic</i>. In any case
+   * T<sub>n</sub> a<sub>n</sub>, [[T<sub>n+1</sub> x<sub>n+1</sub> = d1, &hellip;, T<sub>n+k</sub>
+   * x<sub>n+k</sub> = dk]]) {s}</i> is <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, [[T<sub>n+1</sub>
+   * x<sub>n+1</sub>, &hellip;, T<sub>n+k</sub> x<sub>n+k</sub>]]) &rarr; dynamic</i>. In any case
    * where <i>T<sub>i</sub>, 1 &lt;= i &lt;= n</i>, is not specified, it is considered to have been
    * specified as dynamic.
    * <p>
    * The static type of a function literal of the form <i>(T<sub>1</sub> a<sub>1</sub>, &hellip;,
    * T<sub>n</sub> a<sub>n</sub>, {T<sub>n+1</sub> x<sub>n+1</sub> : d1, &hellip;, T<sub>n+k</sub>
    * x<sub>n+k</sub> : dk}) {s}</i> is <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, {T<sub>n+1</sub>
    * x<sub>n+1</sub>, &hellip;, T<sub>n+k</sub> x<sub>n+k</sub>}) &rarr; dynamic</i>. In any case
    * where <i>T<sub>i</sub>, 1 &lt;= i &lt;= n</i>, is not specified, it is considered to have been
    * specified as dynamic.</blockquote>
    */
@@ skipping 13 matching lines @@
    * <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);
   /**
    * 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>
+   * <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) {
     if (node.inSetterContext()) {
       return recordArgumentType(node, node.element);
     }
     return recordReturnType(node, node.element);
   }
   /**
    * 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
@@ skipping 24 matching lines @@
   Object visitIntegerLiteral(IntegerLiteral node) => recordType(node, _typeProvider.intType);
   /**
    * The Dart Language Specification, 12.31: <blockquote>It is a static warning if <i>T</i> does not
    * denote a type available in the current lexical scope.
    * <p>
    * The static type of an is-expression is {@code bool}.</blockquote>
    */
   Object visitIsExpression(IsExpression node) => recordType(node, _typeProvider.boolType);
   /**
    * 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>
+   * 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 typeArguments2 = node.typeArguments;
     if (typeArguments2 != null) {
       NodeList<TypeName> arguments2 = typeArguments2.arguments;
       if (arguments2 != null && arguments2.length == 1) {
         TypeName argumentType = arguments2[0];
         return recordType(node, _typeProvider.listType.substitute5(<Type2> [getType4(argumentType)]));
       }
     }
@@ skipping 123 matching lines @@
    * 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;
    * return r}()</i>.
    * <p>
    * A postfix expression of the form <i>C.v++</i> is equivalent to <i>(){var r = C.v; C.v = r + 1;
    * return r}()</i>.
    * <p>
    * A postfix expression of the form <i>e1.v++</i> is equivalent to <i>(x){var r = x.v; x.v = r +
    * 1; return r}(e1)</i>.
    * <p>
-   * A postfix expression of the form <i>e1[e2]++</i> is equivalent to <i>(a, i){var r = a[i]; a[i]
+   * 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>
    * <p>
    * 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; return r}()</i>.
    * <p>
    * A postfix expression of the form <i>C.v--</i> is equivalent to <i>(){var r = C.v; C.v = r - 1;
    * return r}()</i>.
    * <p>
    * A postfix expression of the form <i>e1.v--</i> is equivalent to <i>(x){var r = x.v; x.v = r -
    * 1; return r}(e1)</i>.
    * <p>
-   * A postfix expression of the form <i>e1[e2]--</i> is equivalent to <i>(a, i){var r = a[i]; a[i]
+   * 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, getType2(node.operand));
   /**
    * See {@link #visitSimpleIdentifier(SimpleIdentifier)}.
    */
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefixedIdentifier = node.identifier;
     Element element2 = prefixedIdentifier.element;
     if (element2 == null) {
@@ skipping 46 matching lines @@
    * 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>,
    * &hellip;, r<sub>n</sub></i>, and named parameters <i>p<sub>1</sub> &hellip; p<sub>k</sub></i>
    * with defaults <i>d<sub>1</sub>, &hellip;, d<sub>k</sub></i>.</li>
-   * <li><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>,
+   * <li><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>, &hellip;, p<sub>k</sub>);}</i> if <i>m</i> has required parameters
    * <i>r<sub>1</sub>, &hellip;, r<sub>n</sub></i>, and optional positional parameters
    * <i>p<sub>1</sub> &hellip; p<sub>k</sub></i> with defaults <i>d<sub>1</sub>, &hellip;,
    * d<sub>k</sub></i>.</li>
    * </ul>
    * Otherwise, if <i>m</i> is the name of a getter member of <i>o</i> (declared implicitly or
    * explicitly) then <i>o.m</i> evaluates to the result of invoking the getter. </blockquote>
    * <p>
    * The Dart Language Specification, 12.17: <blockquote> ... a getter invocation <i>i</i> of the
    * form <i>e.m</i> ...
@@ skipping 261 matching lines @@
       if (nameMap != null) {
         argumentValue = nameMap[argumentValue.toLowerCase()];
       }
       ClassElement returnType = library.getType(argumentValue);
       if (returnType != null) {
         return returnType.type;
       }
     }
     return null;
   }
+  /**
+   * Return the type of the given (overridable) element.
+   * @param element the element whose type is to be returned
+   * @return the type of the given element
+   */
   Type2 getType(Element element) {
     if (element is LocalVariableElement) {
       return ((element as LocalVariableElement)).type;
     } else if (element is ParameterElement) {
       return ((element as ParameterElement)).type;
     }
     return null;
   }
   /**
    * Return the type of the given expression that is to be used for type analysis.
    * @param expression the expression whose type is to be returned
    * @return the type of the given expression
    */
   Type2 getType2(Expression expression) {
     Type2 type = expression.staticType;
     if (type == null) {
       return _dynamicType;
     }
     return type;
   }
   /**
    * Return the type that should be recorded for a node that resolved to the given accessor.
    * @param accessor the accessor that the node resolved to
-   * @param context if the accessor element has context [by being the RHS of a{@link PrefixedIdentifier} or {@link PropertyAccess}], and the return type of the
+   * @param context if the accessor element has context [[by being the RHS of a{@link PrefixedIdentifier} or {@link PropertyAccess}]], and the return type of the
    * accessor is a parameter type, then the type of the LHS can be used to get more
    * specific type information
    * @return the type that should be recorded for a node that resolved to the given accessor
    */
   Type2 getType3(PropertyAccessorElement accessor, Type2 context) {
     FunctionType functionType = accessor.type;
     if (functionType == null) {
       return _dynamicType;
     }
     if (accessor.isSetter()) {
@@ skipping 53 matching lines @@
     return parent2 is TypeName || (parent2 is PrefixedIdentifier && (parent2.parent is TypeName || identical(((parent2 as PrefixedIdentifier)).prefix, node))) || (parent2 is PropertyAccess && identical(((parent2 as PropertyAccess)).target, node)) || (parent2 is MethodInvocation && identical(node, ((parent2 as MethodInvocation)).target));
   }
   /**
    * If it is appropriate to do so, override the type of the given element. Use the static type and
    * inferred type of the element to determine whether or not it is appropriate.
    * @param element the element whose type might be overridden
    * @param staticType the static type of the element
    * @param inferredType the inferred type of the element
    */
   void override(VariableElement element, Type2 staticType, Type2 inferredType) {
-    if (identical(inferredType, BottomTypeImpl.instance) || element is! VariableElement) {
+    if (identical(inferredType, BottomTypeImpl.instance)) {
       return;
     }
     if (element is PropertyInducingElement) {
       PropertyInducingElement variable = element as PropertyInducingElement;
       if (!variable.isConst() && !variable.isFinal()) {
         return;
       }
     }
     if (staticType == null || (inferredType != null && inferredType.isMoreSpecificThan(staticType))) {
       _overrideManager.setType(element, inferredType);
@@ skipping 394 matching lines @@
    * The type representing the type 'dynamic'.
    */
   Type2 _dynamicType;
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   TypeResolverVisitor.con1(Library library, Source source, TypeProvider typeProvider) : super.con1(library, source, typeProvider) {
-    _jtd_constructor_273_impl(library, source, typeProvider);
+    _jtd_constructor_274_impl(library, source, typeProvider);
   }
-  _jtd_constructor_273_impl(Library library, Source source, TypeProvider typeProvider) {
+  _jtd_constructor_274_impl(Library library, Source source, TypeProvider typeProvider) {
     _dynamicType = typeProvider.dynamicType;
   }
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    * @param definingLibrary the element for the library containing the compilation unit being
    * visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    * during resolution
    */
   TypeResolverVisitor.con2(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) : super.con2(definingLibrary, source, typeProvider, errorListener) {
-    _jtd_constructor_274_impl(definingLibrary, source, typeProvider, errorListener);
+    _jtd_constructor_275_impl(definingLibrary, source, typeProvider, errorListener);
   }
-  _jtd_constructor_274_impl(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
+  _jtd_constructor_275_impl(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
     _dynamicType = typeProvider.dynamicType;
   }
   Object visitCatchClause(CatchClause node) {
     super.visitCatchClause(node);
     SimpleIdentifier exception = node.exceptionParameter;
     if (exception != null) {
       TypeName exceptionTypeName = node.exceptionType;
       Type2 exceptionType;
       if (exceptionTypeName == null) {
         exceptionType = typeProvider.objectType;
@@ skipping 190 matching lines @@
         }
       }
     }
     if (element == null) {
       Identifier simpleIdentifier;
       if (typeName is SimpleIdentifier) {
         simpleIdentifier = typeName;
       } else {
         simpleIdentifier = ((typeName as PrefixedIdentifier)).prefix;
       }
-      reportError(StaticWarningCode.UNDEFINED_CLASS, simpleIdentifier, [simpleIdentifier.name]);
+      if (simpleIdentifier.name == "boolean") {
+        reportError(StaticWarningCode.UNDEFINED_CLASS_BOOLEAN, simpleIdentifier, []);
+      } else {
+        reportError(StaticWarningCode.UNDEFINED_CLASS, simpleIdentifier, [simpleIdentifier.name]);
+      }
       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 FunctionTypeAliasElement) {
@@ skipping 450 matching lines @@
  * 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, FunctionTypeAliasElement typeElement) : super(new EnclosedScope(enclosingScope)) {
-    defineTypeParameters(typeElement);
+    defineTypeVariables(typeElement);
+    defineParameters(typeElement);
   }
   /**
-   * Define the type parameters for the function type alias.
+   * Define the parameters for the function type alias.
    * @param typeElement the element representing the type represented by this scope
    */
-  void defineTypeParameters(FunctionTypeAliasElement typeElement) {
-    Scope parameterScope = enclosingScope;
-    for (TypeVariableElement parameter in typeElement.typeVariables) {
-      parameterScope.define(parameter);
+  void defineParameters(FunctionTypeAliasElement typeElement) {
+    for (ParameterElement parameter in typeElement.parameters) {
+      define(parameter);
+    }
+  }
+  /**
+   * Define the type variables for the function type alias.
+   * @param typeElement the element representing the type represented by this scope
+   */
+  void defineTypeVariables(FunctionTypeAliasElement typeElement) {
+    Scope typeVariableScope = enclosingScope;
+    for (TypeVariableElement typeVariable in typeElement.typeVariables) {
+      typeVariableScope.define(typeVariable);
     }
   }
 }
 /**
  * Instances of the class {@code LabelScope} represent a scope in which a single label is defined.
  * @coverage dart.engine.resolver
  */
 class LabelScope {
   /**
    * The label scope enclosing this label scope.
@@ skipping 15 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_279_impl(outerScope, onSwitchStatement, onSwitchMember);
+    _jtd_constructor_280_impl(outerScope, onSwitchStatement, onSwitchMember);
   }
-  _jtd_constructor_279_impl(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) {
-    _jtd_constructor_280_impl(outerScope, EMPTY_LABEL, new LabelElementImpl(_EMPTY_LABEL_IDENTIFIER, onSwitchStatement, onSwitchMember));
+  _jtd_constructor_280_impl(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) {
+    _jtd_constructor_281_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 label2, LabelElement element2) {
-    _jtd_constructor_280_impl(outerScope2, label2, element2);
+    _jtd_constructor_281_impl(outerScope2, label2, element2);
   }
-  _jtd_constructor_280_impl(LabelScope outerScope2, String label2, LabelElement element2) {
+  _jtd_constructor_281_impl(LabelScope outerScope2, String label2, LabelElement element2) {
     this._outerScope = outerScope2;
     this._label = label2;
     this._element = element2;
   }
   /**
    * 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 653 matching lines @@
   /**
    * This is set to {@code true} iff the visitor is currently visiting children nodes of a{@link CatchClause}.
    * @see #visitCatchClause(CatchClause)
    */
   bool _isInCatchClause = false;
   /**
    * This is set to {@code true} iff the visitor is currently visiting code in the SDK.
    */
   bool _isInSystemLibrary = false;
   /**
+   * The class containing the AST nodes being visited, or {@code null} if we are not in the scope of
+   * a class.
+   */
+  ClassElement _enclosingClass;
+  /**
    * The method or function that we are currently visiting, or {@code null} if we are not inside a
    * method or function.
    */
   ExecutableElement _enclosingFunction;
   /**
    * This map is initialized when visiting the contents of a class declaration. If the visitor is
    * not in an enclosing class declaration, then the map is set to {@code null}.
    * <p>
    * When set the map maps the set of {@link FieldElement}s in the class to an{@link INIT_STATE#NOT_INIT} or {@link INIT_STATE#INIT_IN_DECLARATION}. <code>checkFor*</code>
    * methods, specifically {@link #checkForAllFinalInitializedErrorCodes(ConstructorDeclaration)},
@@ skipping 32 matching lines @@
   Object visitCatchClause(CatchClause node) {
     bool previousIsInCatchClause = _isInCatchClause;
     try {
       _isInCatchClause = true;
       return super.visitCatchClause(node);
     } finally {
       _isInCatchClause = previousIsInCatchClause;
     }
   }
   Object visitClassDeclaration(ClassDeclaration node) {
+    ClassElement outerClass = _enclosingClass;
     try {
+      _enclosingClass = node.element;
       checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME);
       ClassElement classElement = node.element;
       if (classElement != null) {
         List<FieldElement> fieldElements = classElement.fields;
         _initialFieldElementsMap = new Map<FieldElement, INIT_STATE>();
         for (FieldElement fieldElement in fieldElements) {
           if (!fieldElement.isSynthetic()) {
             _initialFieldElementsMap[fieldElement] = fieldElement.initializer == null ? INIT_STATE.NOT_INIT : INIT_STATE.INIT_IN_DECLARATION;
           }
         }
       }
       checkForFinalNotInitialized(node);
       return super.visitClassDeclaration(node);
     } finally {
       _initialFieldElementsMap = null;
+      _enclosingClass = outerClass;
     }
   }
   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 outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       _isEnclosingConstructorConst = node.constKeyword != null;
       checkForConstConstructorWithNonFinalField(node);
       checkForConflictingConstructorNameAndMember(node);
       checkForAllFinalInitializedErrorCodes(node);
       return super.visitConstructorDeclaration(node);
     } finally {
       _isEnclosingConstructorConst = false;
       _enclosingFunction = outerFunction;
     }
   }
+  Object visitDefaultFormalParameter(DefaultFormalParameter node) {
+    checkForPrivateOptionalParameter(node);
+    return super.visitDefaultFormalParameter(node);
+  }
   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);
@@ skipping 36 matching lines @@
     TypeName typeName = constructorName2.type;
     Type2 type2 = typeName.type;
     if (type2 is InterfaceType) {
       InterfaceType interfaceType = type2 as InterfaceType;
       checkForConstWithNonConst(node);
       checkForConstOrNewWithAbstractClass(node, typeName, interfaceType);
       checkForTypeArgumentNotMatchingBounds(node, constructorName2.element, typeName);
     }
     return super.visitInstanceCreationExpression(node);
   }
+  Object visitListLiteral(ListLiteral node) {
+    if (node.modifier != null) {
+      TypeArgumentList typeArguments2 = node.typeArguments;
+      if (typeArguments2 != null) {
+        NodeList<TypeName> arguments2 = typeArguments2.arguments;
+        if (arguments2.length != 0) {
+          checkForInvalidTypeArgumentInConstTypedLiteral(arguments2, CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST);
+        }
+      }
+    }
+    return super.visitListLiteral(node);
+  }
   Object visitMapLiteral(MapLiteral node) {
-    checkForInvalidTypeArgumentForKey(node);
+    TypeArgumentList typeArguments2 = node.typeArguments;
+    if (typeArguments2 != null) {
+      NodeList<TypeName> arguments2 = typeArguments2.arguments;
+      if (arguments2.length != 0) {
+        checkForInvalidTypeArgumentForKey(arguments2);
+        if (node.modifier != null) {
+          checkForInvalidTypeArgumentInConstTypedLiteral(arguments2, CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP);
+        }
+      }
+    }
     return super.visitMapLiteral(node);
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement previousFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
+      if (node.isSetter()) {
+        checkForWrongNumberOfParametersForSetter(node);
+      } else if (node.isOperator()) {
+        checkForOptionalParameterInOperator(node);
+      }
+      checkForConcreteClassWithAbstractMember(node);
       return super.visitMethodDeclaration(node);
     } finally {
       _enclosingFunction = previousFunction;
     }
   }
   Object visitNativeFunctionBody(NativeFunctionBody node) {
     checkForNativeFunctionBodyInNonSDKCode(node);
     return super.visitNativeFunctionBody(node);
   }
   Object visitRethrowExpression(RethrowExpression node) {
     checkForRethrowOutsideCatch(node);
     return super.visitRethrowExpression(node);
   }
   Object visitReturnStatement(ReturnStatement node) {
-    checkForReturnOfInvalidType(node);
+    checkForAllReturnStatementErrorCodes(node);
     return super.visitReturnStatement(node);
   }
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     checkForConstFormalParameter(node);
     return super.visitSimpleFormalParameter(node);
   }
   Object visitSwitchStatement(SwitchStatement node) {
     checkForCaseExpressionTypeImplementsEquals(node);
     checkForInconsistentCaseExpressionTypes(node);
     return super.visitSwitchStatement(node);
@@ skipping 83 matching lines @@
           } else if (identical(state, INIT_STATE.INIT_IN_INITIALIZERS)) {
             _errorReporter.reportError(CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS, fieldName2, [fieldElement.name]);
             foundError = true;
           }
         }
       }
     }
     return foundError;
   }
   /**
+   * This checks that the return statement of the form <i>return e;</i> is not in a generative
+   * constructor.
+   * <p>
+   * This checks that return statements without expressions are not in a generative constructor and
+   * the return type is not assignable to {@code null}; that is, we don't have {@code return;} if
+   * the enclosing method has a return type.
+   * <p>
+   * This checks that the return type matches the type of the declared return type in the enclosing
+   * method or function.
+   * @param node the return statement to evaluate
+   * @return {@code true} if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#RETURN_IN_GENERATIVE_CONSTRUCTOR
+   * @see StaticWarningCode#RETURN_WITHOUT_VALUE
+   * @see StaticTypeWarningCode#RETURN_OF_INVALID_TYPE
+   */
+  bool checkForAllReturnStatementErrorCodes(ReturnStatement node) {
+    FunctionType functionType = _enclosingFunction == null ? null : _enclosingFunction.type;
+    Type2 expectedReturnType = functionType == null ? DynamicTypeImpl.instance : functionType.returnType;
+    Expression returnExpression = node.expression;
+    bool isGenerativeConstructor = _enclosingFunction is ConstructorElement && !((_enclosingFunction as ConstructorElement)).isFactory();
+    if (returnExpression != null) {
+      if (isGenerativeConstructor) {
+        _errorReporter.reportError(CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR, returnExpression, []);
+        return true;
+      }
+      if (!expectedReturnType.isVoid()) {
+        Type2 actualReturnType = getType(returnExpression);
+        if (!actualReturnType.isAssignableTo(expectedReturnType)) {
+          _errorReporter.reportError(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [actualReturnType.name, expectedReturnType.name, _enclosingFunction.name]);
+          return true;
+        }
+      }
+    } else {
+      if (!isGenerativeConstructor && !VoidTypeImpl.instance.isAssignableTo(expectedReturnType)) {
+        _errorReporter.reportError(StaticWarningCode.RETURN_WITHOUT_VALUE, node, []);
+      }
+    }
+    return false;
+  }
+  /**
    * This verifies that the passed argument definition test identifier is a parameter.
    * @param node the {@link ArgumentDefinitionTest} to evaluate
    * @return return {@code true} 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 identifier2 = node.identifier;
     Element element2 = identifier2.element;
     if (element2 != null && element2 is! ParameterElement) {
       _errorReporter.reportError(CompileTimeErrorCode.ARGUMENT_DEFINITION_TEST_NON_PARAMETER, identifier2, [identifier2.name]);
@@ skipping 59 matching lines @@
         ClassElement classElement = element2 as ClassElement;
         MethodElement method = classElement.lookUpMethod("==", _currentLibrary);
         if (method != null && method.enclosingElement.type != _typeProvider.objectType) {
           _errorReporter.reportError(CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, expression2, [element2.name]);
           return true;
         }
       }
     }
     return false;
   }
+  /**
+   * This verifies that the passed method declaration is abstract only if the enclosing class is
+   * also abstract.
+   * @param node the method declaration to evaluate
+   * @return {@code true} if and only if an error code is generated on the passed node
+   * @see StaticWarningCode#CONCRETE_CLASS_WITH_ABSTRACT_MEMBER
+   */
+  bool checkForConcreteClassWithAbstractMember(MethodDeclaration node) {
+    if (node.isAbstract() && _enclosingClass != null && !_enclosingClass.isAbstract()) {
+      SimpleIdentifier methodName = node.name;
+      _errorReporter.reportError(StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER, methodName, [methodName.name, _enclosingClass.name]);
+      return true;
+    }
+    return false;
+  }
   bool checkForConflictingConstructorNameAndMember(ConstructorDeclaration node) {
     ConstructorElement constructorElement = node.element;
     SimpleIdentifier constructorName = node.name;
     if (constructorName != null && constructorElement != null && !constructorName.isSynthetic()) {
       String name2 = constructorName.name;
       ClassElement classElement = constructorElement.enclosingElement;
       List<FieldElement> fields2 = classElement.fields;
       for (FieldElement field in fields2) {
         if (field.name == name2) {
           _errorReporter.reportError(CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD, node, [name2]);
@@ skipping 275 matching lines @@
     VariableElement leftElement = getVariableElement(lhs);
     Type2 leftType = (leftElement == null) ? getType(lhs) : leftElement.type;
     Type2 rightType = getType(rhs);
     if (!rightType.isAssignableTo(leftType)) {
       _errorReporter.reportError(StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [rightType.name, leftType.name]);
       return true;
     }
     return false;
   }
   /**
-   * Checks to ensure that native function bodies can only in SDK code.
-   * @param node the map literal to test
+   * Checks to ensure that first type argument to a map literal must be the 'String' type.
+   * @param arguments a non-{@code null}, non-empty {@link TypeName} node list from the respective{@link MapLiteral}
    * @return return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#INVALID_TYPE_ARGUMENT_FOR_KEY
    */
-  bool checkForInvalidTypeArgumentForKey(MapLiteral node) {
-    TypeArgumentList typeArgumentList = node.typeArguments;
-    if (typeArgumentList == null) {
-      return false;
-    }
-    NodeList<TypeName> arguments2 = typeArgumentList.arguments;
-    if (arguments2.length == 0) {
-      return false;
-    }
-    TypeName firstArgument = arguments2[0];
+  bool checkForInvalidTypeArgumentForKey(NodeList<TypeName> arguments) {
+    TypeName firstArgument = arguments[0];
     Type2 firstArgumentType = firstArgument.type;
     if (firstArgumentType != null && firstArgumentType != _typeProvider.stringType) {
       _errorReporter.reportError(CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_FOR_KEY, firstArgument, []);
       return true;
     }
     return false;
   }
   /**
+   * Checks to ensure that the passed {@link ListLiteral} or {@link MapLiteral} does not have a type
+   * parameter as a type argument.
+   * @param arguments a non-{@code null}, non-empty {@link TypeName} node list from the respective{@link ListLiteral} or {@link MapLiteral}
+   * @param errorCode either {@link CompileTimeErrorCode#INVALID_TYPE_ARGUMENT_IN_CONST_LIST} or{@link CompileTimeErrorCode#INVALID_TYPE_ARGUMENT_IN_CONST_MAP}
+   * @return {@code true} if and only if an error code is generated on the passed node
+   */
+  bool checkForInvalidTypeArgumentInConstTypedLiteral(NodeList<TypeName> arguments, ErrorCode errorCode) {
+    bool foundError = false;
+    for (TypeName typeName in arguments) {
+      if (typeName.type is TypeVariableType) {
+        _errorReporter.reportError(errorCode, typeName, [typeName.name]);
+        foundError = true;
+      }
+    }
+    return foundError;
+  }
+  /**
    * Checks to ensure that native function bodies can only in SDK code.
    * @param node the native function body to test
    * @return return {@code true} if and only if an error code is generated on the passed node
    * @see ParserErrorCode#NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE
    */
   bool checkForNativeFunctionBodyInNonSDKCode(NativeFunctionBody node) {
     if (!_isInSystemLibrary) {
       _errorReporter.reportError(ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE, node, []);
       return true;
     }
@@ skipping 31 matching lines @@
     } else if (type is FunctionType) {
       FunctionType functionType = type as FunctionType;
       if (functionType.typeArguments.length == 0 && !functionType.returnType.isAssignableTo(_typeProvider.boolType)) {
         _errorReporter.reportError(StaticTypeWarningCode.NON_BOOL_EXPRESSION, expression, []);
         return true;
       }
     }
     return false;
   }
   /**
+   * This verifies the passed operator-method declaration, does not have an optional parameter.
+   * <p>
+   * This method assumes that the method declaration was tested to be an operator declaration before
+   * being called.
+   * @param node the method declaration to evaluate
+   * @return {@code true} if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#OPTIONAL_PARAMETER_IN_OPERATOR
+   */
+  bool checkForOptionalParameterInOperator(MethodDeclaration node) {
+    FormalParameterList parameterList = node.parameters;
+    if (parameterList == null) {
+      return false;
+    }
+    bool foundError = false;
+    NodeList<FormalParameter> formalParameters = parameterList.parameters;
+    for (FormalParameter formalParameter in formalParameters) {
+      if (formalParameter.kind.isOptional()) {
+        _errorReporter.reportError(CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR, formalParameter, []);
+        foundError = true;
+      }
+    }
+    return foundError;
+  }
+  /**
+   * This checks for named optional parameters that begin with '_'.
+   * @param node the default formal parameter to evaluate
+   * @return {@code true} if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#PRIVATE_OPTIONAL_PARAMETER
+   */
+  bool checkForPrivateOptionalParameter(DefaultFormalParameter node) {
+    sc.Token separator2 = node.separator;
+    if (separator2 != null && separator2.lexeme == ":") {
+      NormalFormalParameter parameter2 = node.parameter;
+      SimpleIdentifier name = parameter2.identifier;
+      if (!name.isSynthetic() && name.name.startsWith("_")) {
+        _errorReporter.reportError(CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER, node, []);
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
    * This checks that the rethrow is inside of a catch clause.
    * @param node the rethrow expression to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#RETHROW_OUTSIDE_CATCH
    */
   bool checkForRethrowOutsideCatch(RethrowExpression node) {
     if (!_isInCatchClause) {
       _errorReporter.reportError(CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH, node, []);
       return true;
     }
     return false;
   }
   /**
-   * This checks that the return type matches the type of the declared return type in the enclosing
-   * method or function.
-   * @param node the return statement to evaluate
-   * @return return {@code true} if and only if an error code is generated on the passed node
-   * @see StaticTypeWarningCode#RETURN_OF_INVALID_TYPE
-   */
-  bool checkForReturnOfInvalidType(ReturnStatement node) {
-    FunctionType functionType = _enclosingFunction == null ? null : _enclosingFunction.type;
-    Type2 expectedReturnType = functionType == null ? null : functionType.returnType;
-    Expression returnExpression = node.expression;
-    if (expectedReturnType != null && !expectedReturnType.isVoid() && returnExpression != null) {
-      Type2 actualReturnType = getType(returnExpression);
-      if (!actualReturnType.isAssignableTo(expectedReturnType)) {
-        _errorReporter.reportError(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [actualReturnType.name, expectedReturnType.name, _enclosingFunction.name]);
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
    * This verifies that the type arguments in the passed instance creation expression are all within
-   * their bounds as specified by the class element where the constructor [that is being invoked] is
+   * their bounds as specified by the class element where the constructor [[that is being invoked]] is
    * declared.
    * @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 constructorElement the {@link ConstructorElement} from the instance creation expression
    * @return return {@code true} if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
    */
   bool checkForTypeArgumentNotMatchingBounds(InstanceCreationExpression node, ConstructorElement constructorElement, TypeName typeName) {
     if (typeName.typeArguments != null && constructorElement != null) {
       NodeList<TypeName> typeNameArgList = typeName.typeArguments.arguments;
       List<TypeVariableElement> boundingElts = constructorElement.enclosingElement.typeVariables;
       int loopThroughIndex = Math.min(typeNameArgList.length, boundingElts.length);
       for (int i = 0; i < loopThroughIndex; i++) {
         TypeName argTypeName = typeNameArgList[i];
         Type2 argType = argTypeName.type;
         Type2 boundType = boundingElts[i].bound;
         if (argType != null && boundType != null) {
           if (!argType.isSubtypeOf(boundType)) {
             _errorReporter.reportError(StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS, argTypeName, [argTypeName.name, boundingElts[i].name]);
             return true;
           }
         }
       }
     }
     return false;
   }
   /**
+   * This verifies if the passed setter method declaration, has only one parameter.
+   * <p>
+   * This method assumes that the method declaration was tested to be a setter before being called.
+   * @param node the method declaration to evaluate
+   * @return return {@code true} if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER
+   */
+  bool checkForWrongNumberOfParametersForSetter(MethodDeclaration node) {
+    FormalParameterList parameterList = node.parameters;
+    if (parameterList == null) {
+      return false;
+    }
+    NodeList<FormalParameter> formalParameters = parameterList.parameters;
+    int numberOfParameters = formalParameters.length;
+    if (numberOfParameters != 1) {
+      _errorReporter.reportError(CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER, node.name, [numberOfParameters]);
+      return true;
+    }
+    return false;
+  }
+  /**
    * Return the type of the given expression that is to be used for type analysis.
    * @param expression the expression whose type is to be returned
    * @return the type of the given expression
    */
   Type2 getType(Expression expression) {
     Type2 type = expression.staticType;
     return type == null ? _dynamicType : type;
   }
   /**
    * Return the variable element represented by the given expression, or {@code null} if there is no
@@ skipping 63 matching lines @@
     this._type = type;
     this._message = message;
   }
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
   bool needsRecompilation() => true;
   int compareTo(ResolverErrorCode other) => __ordinal - other.__ordinal;
   String toString() => __name;
 }