New analyzer snapshot.

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

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.resolver;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
@@ skipping 134 matching lines @@
     if (constructors.length == 0) {
       constructors = createDefaultConstructors(interfaceType);
     }
     element.abstract = node.abstractKeyword != null;
     element.accessors = holder.accessors;
     element.constructors = constructors;
     element.fields = holder.fields;
     element.methods = holder.methods;
     element.typeParameters = typeParameters;
     element.validMixin = _isValidMixin;
-    for (FunctionTypeImpl functionType in _functionTypesToFix) {
-      functionType.typeArguments = typeArguments;
+    int functionTypeCount = _functionTypesToFix.length;
+    for (int i = 0; i < functionTypeCount; i++) {
+      _functionTypesToFix[i].typeArguments = typeArguments;
     }
     _functionTypesToFix = null;
     _currentHolder.addType(element);
     className.staticElement = element;
     holder.validate();
     return null;
   }
 
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ElementHolder holder = new ElementHolder();
@@ skipping 934 matching lines @@
     if (builder.length > 0) {
       AnalysisEngine.instance.logger.logError("Failed to capture elements: ${builder.toString()}");
     }
   }
 }
 
 /**
  * Instances of the class `HtmlUnitBuilder` build an element model for a single HTML unit.
  */
 class HtmlUnitBuilder implements ht.XmlVisitor<Object> {
-  static String _APPLICATION_DART_IN_DOUBLE_QUOTES = "\"application/dart\"";
-
-  static String _APPLICATION_DART_IN_SINGLE_QUOTES = "'application/dart'";
-
-  static String _SCRIPT = "script";
-
   static String _SRC = "src";
 
-  static String _TYPE = "type";
-
   /**
    * The analysis context in which the element model will be built.
    */
   InternalAnalysisContext _context;
 
   /**
    * The error listener to which errors will be reported.
    */
   RecordingErrorListener errorListener;
 
@@ skipping 61 matching lines @@
     _lineInfo = _context.computeLineInfo(source);
     HtmlElementImpl result = new HtmlElementImpl(_context, source.shortName);
     result.source = source;
     _htmlElement = result;
     unit.accept(this);
     _htmlElement = null;
     unit.element = result;
     return result;
   }
 
+  Object visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) {
+    if (_parentNodes.contains(node)) {
+      return reportCircularity(node);
+    }
+    _parentNodes.add(node);
+    try {
+      Source htmlSource = _htmlElement.source;
+      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);
+        try {
+          LibraryResolver resolver = new LibraryResolver(_context);
+          LibraryElementImpl library = resolver.resolveEmbeddedLibrary(htmlSource, _modificationStamp, node.script, true) as LibraryElementImpl;
+          script.scriptLibrary = library;
+          resolvedLibraries.addAll(resolver.resolvedLibraries);
+          errorListener.addAll(resolver.errorListener);
+        } on AnalysisException catch (exception) {
+          AnalysisEngine.instance.logger.logError3(exception);
+        }
+        node.scriptElement = script;
+        _scripts.add(script);
+      } else {
+        ExternalHtmlScriptElementImpl script = new ExternalHtmlScriptElementImpl(node);
+        if (scriptSourcePath != null) {
+          try {
+            scriptSourcePath = Uri.encodeFull(scriptSourcePath);
+            parseUriWithException(scriptSourcePath);
+            Source scriptSource = _context.sourceFactory.resolveUri(htmlSource, scriptSourcePath);
+            script.scriptSource = scriptSource;
+            if (scriptSource == null || !scriptSource.exists()) {
+              reportValueError(HtmlWarningCode.URI_DOES_NOT_EXIST, scriptAttribute, [scriptSourcePath]);
+            }
+          } on URISyntaxException catch (exception) {
+            reportValueError(HtmlWarningCode.INVALID_URI, scriptAttribute, [scriptSourcePath]);
+          }
+        }
+        node.scriptElement = script;
+        _scripts.add(script);
+      }
+    } finally {
+      _parentNodes.remove(node);
+    }
+    return null;
+  }
+
   Object visitHtmlUnit(ht.HtmlUnit node) {
     _parentNodes = new List<ht.XmlTagNode>();
     _scripts = new List<HtmlScriptElement>();
     try {
       node.visitChildren(this);
       _htmlElement.scripts = new List.from(_scripts);
     } finally {
       _scripts = null;
       _parentNodes = null;
     }
     return null;
   }
 
-  Object visitXmlAttributeNode(ht.XmlAttributeNode node) => null;
+  Object visitXmlAttributeNode(ht.XmlAttributeNode node) {
+    for (ht.EmbeddedExpression expression in node.expressions) {
+      resolveExpression(expression.expression);
+    }
+    return null;
+  }
 
   Object visitXmlTagNode(ht.XmlTagNode node) {
     if (_parentNodes.contains(node)) {
-      JavaStringBuilder builder = new JavaStringBuilder();
-      builder.append("Found circularity in XML nodes: ");
-      bool first = true;
-      for (ht.XmlTagNode pathNode in _parentNodes) {
-        if (first) {
-          first = false;
-        } else {
-          builder.append(", ");
-        }
-        String tagName = pathNode.tag.lexeme;
-        if (identical(pathNode, node)) {
-          builder.append("*");
-          builder.append(tagName);
-          builder.append("*");
-        } else {
-          builder.append(tagName);
-        }
-      }
-      AnalysisEngine.instance.logger.logError(builder.toString());
-      return null;
+      return reportCircularity(node);
     }
     _parentNodes.add(node);
     try {
-      if (isScriptNode(node)) {
-        Source htmlSource = _htmlElement.source;
-        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;
-          int attributeEnd = node.attributeEnd.end;
-          LineInfo_Location location = _lineInfo.getLocation(attributeEnd);
-          sc.Scanner scanner = new sc.Scanner(htmlSource, new sc.SubSequenceReader(new CharSequence(contents), attributeEnd), errorListener);
-          scanner.setSourceStart(location.lineNumber, location.columnNumber);
-          sc.Token firstToken = scanner.tokenize();
-          List<int> lineStarts = scanner.lineStarts;
-          Parser parser = new Parser(htmlSource, errorListener);
-          CompilationUnit unit = parser.parseCompilationUnit(firstToken);
-          try {
-            LibraryResolver resolver = new LibraryResolver(_context);
-            LibraryElementImpl library = resolver.resolveEmbeddedLibrary(htmlSource, _modificationStamp, unit, true) as LibraryElementImpl;
-            script.scriptLibrary = library;
-            resolvedLibraries.addAll(resolver.resolvedLibraries);
-            errorListener.addAll(resolver.errorListener);
-          } on AnalysisException catch (exception) {
-            AnalysisEngine.instance.logger.logError3(exception);
-          }
-          _scripts.add(script);
-        } else {
-          ExternalHtmlScriptElementImpl script = new ExternalHtmlScriptElementImpl(node);
-          if (scriptSourcePath != null) {
-            try {
-              scriptSourcePath = Uri.encodeFull(scriptSourcePath);
-              parseUriWithException(scriptSourcePath);
-              Source scriptSource = _context.sourceFactory.resolveUri(htmlSource, scriptSourcePath);
-              script.scriptSource = scriptSource;
-              if (scriptSource == null || !scriptSource.exists()) {
-                reportValueError(HtmlWarningCode.URI_DOES_NOT_EXIST, scriptAttribute, [scriptSourcePath]);
-              }
-            } on URISyntaxException catch (exception) {
-              reportValueError(HtmlWarningCode.INVALID_URI, scriptAttribute, [scriptSourcePath]);
-            }
-          }
-          _scripts.add(script);
-        }
-      } else {
-        node.visitChildren(this);
+      for (ht.EmbeddedExpression expression in node.expressions) {
+        resolveExpression(expression.expression);
       }
+      node.visitChildren(this);
     } finally {
       _parentNodes.remove(node);
     }
     return null;
   }
 
   /**
    * Return the first source attribute for the given tag node, or `null` if it does not exist.
    *
    * @param node the node containing attributes
    * @return the source attribute contained in the given tag
    */
   ht.XmlAttributeNode getScriptSourcePath(ht.XmlTagNode node) {
     for (ht.XmlAttributeNode attribute in node.attributes) {
       if (attribute.name.lexeme == _SRC) {
         return attribute;
       }
     }
     return null;
   }
 
+  Object reportCircularity(ht.XmlTagNode node) {
+    JavaStringBuilder builder = new JavaStringBuilder();
+    builder.append("Found circularity in XML nodes: ");
+    bool first = true;
+    for (ht.XmlTagNode pathNode in _parentNodes) {
+      if (first) {
+        first = false;
+      } else {
+        builder.append(", ");
+      }
+      String tagName = pathNode.tag.lexeme;
+      if (identical(pathNode, node)) {
+        builder.append("*");
+        builder.append(tagName);
+        builder.append("*");
+      } else {
+        builder.append(tagName);
+      }
+    }
+    AnalysisEngine.instance.logger.logError(builder.toString());
+    return null;
+  }
+
   /**
-   * Determine if the specified node is a Dart script.
-   *
-   * @param node the node to be tested (not `null`)
-   * @return `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;
-  }
-
-  /**
    * 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));
   }
 
   /**
    * Report an error with the given error code at the location of the value of the given attribute.
    * 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 reportValueError(ErrorCode errorCode, ht.XmlAttributeNode attribute, List<Object> arguments) {
     int offset = attribute.value.offset + 1;
     int length = attribute.value.length - 2;
     reportError(errorCode, offset, length, arguments);
   }
+
+  void resolveExpression(Expression expression) {
+  }
 }
 
 /**
  * Instances of the class `BestPracticesVerifier` traverse an AST structure looking for
  * violations of Dart best practices.
  *
  * @coverage dart.engine.resolver
  */
 class BestPracticesVerifier extends RecursiveASTVisitor<Object> {
   static String _GETTER = "getter";
@@ skipping 213 matching lines @@
    * deprecated constructor will be caught by
    * [visitInstanceCreationExpression] and
    * [visitSuperConstructorInvocation], and can be ignored by
    * this visit method.
    *
    * @param identifier some simple identifier to check for deprecated use of
    * @return `true` if and only if a hint code is generated on the passed node
    * @see HintCode#DEPRECATED_MEMBER_USE
    */
   bool checkForDeprecatedMemberUse2(SimpleIdentifier identifier) {
-    if (identifier.inDeclarationContext() || (identifier.parent is ConstructorName && identical(identifier, (identifier.parent as ConstructorName).name)) || (identifier.parent is SuperConstructorInvocation && identical(identifier, (identifier.parent as SuperConstructorInvocation).constructorName))) {
+    if (identifier.inDeclarationContext()) {
+      return false;
+    }
+    ASTNode parent = identifier.parent;
+    if ((parent is ConstructorName && identical(identifier, (parent as ConstructorName).name)) || (parent is SuperConstructorInvocation && identical(identifier, (parent as SuperConstructorInvocation).constructorName)) || parent is HideCombinator) {
       return false;
     }
     return checkForDeprecatedMemberUse(identifier.bestElement, identifier);
   }
 
   /**
    * Check for the passed binary expression for the [HintCode#DIVISION_OPTIMIZATION].
    *
    * @param node the binary expression to check
    * @return `true` if and only if a hint code is generated on the passed node
@@ skipping 477 matching lines @@
   }
 
   void generateForCompilationUnit(CompilationUnit unit, Source source) {
     ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
     _importsVerifier.visitCompilationUnit(unit);
     new DeadCodeVerifier(errorReporter).visitCompilationUnit(unit);
     if (_enableDart2JSHints) {
       new Dart2JSVerifier(errorReporter).visitCompilationUnit(unit);
     }
     new BestPracticesVerifier(errorReporter).visitCompilationUnit(unit);
+    new ToDoFinder(errorReporter).findIn(unit);
   }
 }
 
 /**
  * Instances of the class `ImportsVerifier` visit all of the referenced libraries in the
  * source code verifying that all of the imports are used, otherwise a
  * [HintCode#UNUSED_IMPORT] is generated with
  * [generateUnusedImportHints].
  *
  * While this class does not yet have support for an "Organize Imports" action, this logic built up
@@ skipping 440 matching lines @@
       String fullName = source.fullName;
       if (fullName != null) {
         return fullName.replaceAll(r'\', '/');
       }
     }
     return null;
   }
 }
 
 /**
+ * Instances of the class `ToDoFinder` find to-do comments in Dart code.
+ */
+class ToDoFinder {
+  /**
+   * The error reporter by which to-do comments will be reported.
+   */
+  ErrorReporter _errorReporter;
+
+  /**
+   * Initialize a newly created to-do finder to report to-do comments to the given reporter.
+   *
+   * @param errorReporter the error reporter by which to-do comments will be reported
+   */
+  ToDoFinder(ErrorReporter errorReporter) {
+    this._errorReporter = errorReporter;
+  }
+
+  /**
+   * Search the comments in the given compilation unit for to-do comments and report an error for
+   * each.
+   *
+   * @param unit the compilation unit containing the to-do comments
+   */
+  void findIn(CompilationUnit unit) {
+    gatherTodoComments(unit.beginToken);
+  }
+
+  /**
+   * Search the comment tokens reachable from the given token and create errors for each to-do
+   * comment.
+   *
+   * @param token the head of the list of tokens being searched
+   */
+  void gatherTodoComments(sc.Token token) {
+    while (token != null && token.type != sc.TokenType.EOF) {
+      sc.Token commentToken = token.precedingComments;
+      while (commentToken != null) {
+        if (identical(commentToken.type, sc.TokenType.SINGLE_LINE_COMMENT) || identical(commentToken.type, sc.TokenType.MULTI_LINE_COMMENT)) {
+          scrapeTodoComment(commentToken);
+        }
+        commentToken = commentToken.next;
+      }
+      token = token.next;
+    }
+  }
+
+  /**
+   * Look for user defined tasks in comments and convert them into info level analysis issues.
+   *
+   * @param commentToken the comment token to analyze
+   */
+  void scrapeTodoComment(sc.Token commentToken) {
+    JavaPatternMatcher matcher = new JavaPatternMatcher(TodoCode.TODO_REGEX, commentToken.lexeme);
+    if (matcher.find()) {
+      int offset = commentToken.offset + matcher.start() + matcher.group(1).length;
+      int length = matcher.group(2).length;
+      _errorReporter.reportError4(TodoCode.TODO, offset, length, [matcher.group(2)]);
+    }
+  }
+}
+
+/**
  * Instances of the class `DeclarationMatcher` determine whether the element model defined by
  * a given AST structure matches an existing element model.
  */
 class DeclarationMatcher extends RecursiveASTVisitor<Object> {
   /**
    * The compilation unit containing the AST nodes being visited.
    */
   CompilationUnitElement _enclosingUnit;
 
   /**
@@ skipping 587 matching lines @@
  */
 class DeclarationMatcher_DeclarationMismatchException extends RuntimeException {
 }
 
 class GeneralizingElementVisitor_7 extends GeneralizingElementVisitor<Object> {
   final DeclarationMatcher DeclarationMatcher_this;
 
   GeneralizingElementVisitor_7(this.DeclarationMatcher_this) : super();
 
   Object visitElement(Element element) {
-    javaSetAdd(DeclarationMatcher_this._allElements, element);
-    javaSetAdd(DeclarationMatcher_this._unmatchedElements, element);
+    DeclarationMatcher_this._allElements.add(element);
+    DeclarationMatcher_this._unmatchedElements.add(element);
     return super.visitElement(element);
   }
 }
 
 /**
  * Instances of the class `DeclarationResolver` are used to resolve declarations in an AST
  * structure to already built elements.
  */
 class DeclarationResolver extends RecursiveASTVisitor<Object> {
   /**
@@ skipping 630 matching lines @@
    * The resolver driving this participant.
    */
   ResolverVisitor _resolver;
 
   /**
    * The element for the library containing the compilation unit being visited.
    */
   LibraryElement _definingLibrary;
 
   /**
-   * A flag indicating whether we are running in strict mode. In strict mode, error reporting is
-   * based exclusively on the static type information.
-   */
-  bool _strictMode = false;
-
-  /**
    * A flag indicating whether we should generate hints.
    */
   bool _enableHints = false;
 
   /**
    * The type representing the type 'dynamic'.
    */
   Type2 _dynamicType;
 
   /**
@@ skipping 25 matching lines @@
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param resolver the resolver driving this participant
    */
   ElementResolver(ResolverVisitor resolver) {
     this._resolver = resolver;
     this._definingLibrary = resolver.definingLibrary;
     AnalysisOptions options = _definingLibrary.context.analysisOptions;
-    _strictMode = options.strictMode;
     _enableHints = options.hint;
     _dynamicType = resolver.typeProvider.dynamicType;
     _typeType = resolver.typeProvider.typeType;
     _subtypeManager = new SubtypeManager();
     _promoteManager = resolver.promoteManager;
   }
 
   Object visitAssignmentExpression(AssignmentExpression node) {
     sc.Token operator = node.operator;
     sc.TokenType operatorType = operator.type;
     if (operatorType != sc.TokenType.EQ) {
       operatorType = operatorFromCompoundAssignment(operatorType);
       Expression leftHandSide = node.leftHandSide;
       if (leftHandSide != null) {
         String methodName = operatorType.lexeme;
         Type2 staticType = getStaticType(leftHandSide);
         MethodElement staticMethod = lookUpMethod(leftHandSide, staticType, methodName);
         node.staticElement = staticMethod;
         Type2 propagatedType = getPropagatedType(leftHandSide);
         MethodElement propagatedMethod = lookUpMethod(leftHandSide, propagatedType, methodName);
         node.propagatedElement = propagatedMethod;
-        bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod) && (_strictMode || shouldReportMissingMember(propagatedType, propagatedMethod));
+        bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod);
         bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
         if (shouldReportMissingMember_propagated) {
           if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
             shouldReportMissingMember_propagated = false;
           }
         }
         if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
           ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_METHOD : HintCode.UNDEFINED_METHOD) as ErrorCode;
           _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, operator, [
               methodName,
               shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
         }
       }
     }
     return null;
   }
 
   Object visitBinaryExpression(BinaryExpression node) {
     sc.Token operator = node.operator;
     if (operator.isUserDefinableOperator) {
       Expression leftOperand = node.leftOperand;
       if (leftOperand != null) {
         String methodName = operator.lexeme;
         Type2 staticType = getStaticType(leftOperand);
         MethodElement staticMethod = lookUpMethod(leftOperand, staticType, methodName);
         node.staticElement = staticMethod;
         Type2 propagatedType = getPropagatedType(leftOperand);
         MethodElement propagatedMethod = lookUpMethod(leftOperand, propagatedType, methodName);
         node.propagatedElement = propagatedMethod;
-        bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod) && (_strictMode || shouldReportMissingMember(propagatedType, propagatedMethod));
+        bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod);
         bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
         if (shouldReportMissingMember_propagated) {
           if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
             shouldReportMissingMember_propagated = false;
           }
         }
         if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
           ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
           _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, operator, [
               methodName,
@@ skipping 316 matching lines @@
     return null;
   }
 
   Object visitMethodDeclaration(MethodDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
 
   Object visitMethodInvocation(MethodInvocation node) {
     SimpleIdentifier methodName = node.methodName;
+    if (methodName.isSynthetic) {
+      return null;
+    }
     Expression target = node.realTarget;
     if (target is SuperExpression && !isSuperInValidContext(target as SuperExpression)) {
       return null;
     }
     Element staticElement;
     Element propagatedElement;
     if (target == null) {
       staticElement = resolveInvokedElement2(methodName);
       propagatedElement = null;
     } else {
@@ skipping 102 matching lines @@
 
   Object visitPostfixExpression(PostfixExpression node) {
     Expression operand = node.operand;
     String methodName = getPostfixOperator(node);
     Type2 staticType = getStaticType(operand);
     MethodElement staticMethod = lookUpMethod(operand, staticType, methodName);
     node.staticElement = staticMethod;
     Type2 propagatedType = getPropagatedType(operand);
     MethodElement propagatedMethod = lookUpMethod(operand, propagatedType, methodName);
     node.propagatedElement = propagatedMethod;
-    bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod) && (_strictMode || shouldReportMissingMember(propagatedType, propagatedMethod));
+    bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod);
     bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
     if (shouldReportMissingMember_propagated) {
       if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
         shouldReportMissingMember_propagated = false;
       }
     }
     if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
       ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
       _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, node.operator, [
           methodName,
@@ skipping 53 matching lines @@
     sc.TokenType operatorType = operator.type;
     if (operatorType.isUserDefinableOperator || identical(operatorType, sc.TokenType.PLUS_PLUS) || identical(operatorType, sc.TokenType.MINUS_MINUS)) {
       Expression operand = node.operand;
       String methodName = getPrefixOperator(node);
       Type2 staticType = getStaticType(operand);
       MethodElement staticMethod = lookUpMethod(operand, staticType, methodName);
       node.staticElement = staticMethod;
       Type2 propagatedType = getPropagatedType(operand);
       MethodElement propagatedMethod = lookUpMethod(operand, propagatedType, methodName);
       node.propagatedElement = propagatedMethod;
-      bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod) && (_strictMode || shouldReportMissingMember(propagatedType, propagatedMethod));
+      bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod);
       bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
       if (shouldReportMissingMember_propagated) {
         if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
           shouldReportMissingMember_propagated = false;
         }
       }
       if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
         ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
         _resolver.reportErrorProxyConditionalAnalysisError3(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, operator, [
             methodName,
@@ skipping 34 matching lines @@
     node.staticElement = element;
     ArgumentList argumentList = node.argumentList;
     List<ParameterElement> parameters = resolveArgumentsToParameters(false, argumentList, element);
     if (parameters != null) {
       argumentList.correspondingStaticParameters = parameters;
     }
     return null;
   }
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
+    if (node.isSynthetic) {
+      return null;
+    }
     if (node.staticElement != null) {
       return null;
     }
     if (node.name == _dynamicType.name) {
       node.staticElement = _dynamicType.element;
       node.staticType = _typeType;
       return null;
     }
     Element element = resolveSimpleIdentifier(node);
     ClassElement enclosingClass = _resolver.enclosingClass;
@@ skipping 86 matching lines @@
   }
 
   /**
    * Generate annotation elements for each of the annotations in the given node list and add them to
    * the given list of elements.
    *
    * @param annotationList the list of elements to which new elements are to be added
    * @param annotations the AST nodes used to generate new elements
    */
   void addAnnotations(List<ElementAnnotationImpl> annotationList, NodeList<Annotation> annotations) {
-    for (Annotation annotationNode in annotations) {
-      Element resolvedElement = annotationNode.element;
+    int annotationCount = annotations.length;
+    for (int i = 0; i < annotationCount; i++) {
+      Element resolvedElement = annotations[i].element;
       if (resolvedElement != null) {
         annotationList.add(new ElementAnnotationImpl(resolvedElement));
       }
     }
   }
 
   /**
    * Given that we have found code to invoke the given element, return the error code that should be
    * reported, or `null` if no error should be reported.
    *
@@ skipping 65 matching lines @@
    * Check that the for some index expression that the method element was resolved, otherwise a
    * [StaticWarningCode#UNDEFINED_OPERATOR] is generated.
    *
    * @param node the index expression to resolve
    * @param target the target of the expression
    * @param methodName the name of the operator associated with the context of using of the given
    *          index expression
    * @return `true` if and only if an error code is generated on the passed node
    */
   bool checkForUndefinedIndexOperator(IndexExpression node, Expression target, String methodName, MethodElement staticMethod, MethodElement propagatedMethod, Type2 staticType, Type2 propagatedType) {
-    bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod) && (_strictMode || shouldReportMissingMember(propagatedType, propagatedMethod));
+    bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod);
     bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedMethod) : false;
     if (shouldReportMissingMember_propagated) {
       if (memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
         shouldReportMissingMember_propagated = false;
       }
     }
     if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
       sc.Token leftBracket = node.leftBracket;
       sc.Token rightBracket = node.rightBracket;
       ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
@@ skipping 262 matching lines @@
    * @param getterName the name of the 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 getter that was found
    */
   PropertyAccessorElement lookUpGetterInInterfaces(InterfaceType targetType, bool includeTargetType, String getterName, Set<ClassElement> visitedInterfaces) {
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
-    javaSetAdd(visitedInterfaces, targetClass);
+    visitedInterfaces.add(targetClass);
     if (includeTargetType) {
       PropertyAccessorElement getter = targetType.getGetter(getterName);
       if (getter != null && getter.isAccessibleIn(_definingLibrary)) {
         return getter;
       }
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
       PropertyAccessorElement getter = lookUpGetterInInterfaces(interfaceType, true, getterName, visitedInterfaces);
       if (getter != null) {
         return getter;
@@ skipping 48 matching lines @@
    * @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, bool includeTargetType, String memberName, Set<ClassElement> visitedInterfaces) {
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
-    javaSetAdd(visitedInterfaces, targetClass);
+    visitedInterfaces.add(targetClass);
     if (includeTargetType) {
       ExecutableElement member = targetType.getMethod(memberName);
       if (member != null) {
         return member;
       }
       member = targetType.getGetter(memberName);
       if (member != null) {
         return member;
       }
     }
@@ skipping 93 matching lines @@
    * @param methodName the name of the method 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 that was found
    */
   MethodElement lookUpMethodInInterfaces(InterfaceType targetType, bool includeTargetType, String methodName, Set<ClassElement> visitedInterfaces) {
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
-    javaSetAdd(visitedInterfaces, targetClass);
+    visitedInterfaces.add(targetClass);
     if (includeTargetType) {
       MethodElement method = targetType.getMethod(methodName);
       if (method != null && method.isAccessibleIn(_definingLibrary)) {
         return method;
       }
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
       MethodElement method = lookUpMethodInInterfaces(interfaceType, true, methodName, visitedInterfaces);
       if (method != null) {
         return method;
@@ skipping 49 matching lines @@
    * @param setterName the name of the setter 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 setter that was found
    */
   PropertyAccessorElement lookUpSetterInInterfaces(InterfaceType targetType, bool includeTargetType, String setterName, Set<ClassElement> visitedInterfaces) {
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
-    javaSetAdd(visitedInterfaces, targetClass);
+    visitedInterfaces.add(targetClass);
     if (includeTargetType) {
       PropertyAccessorElement setter = targetType.getSetter(setterName);
       if (setter != null && setter.isAccessibleIn(_definingLibrary)) {
         return setter;
       }
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
       PropertyAccessorElement setter = lookUpSetterInInterfaces(interfaceType, true, setterName, visitedInterfaces);
       if (setter != null) {
         return setter;
@@ skipping 238 matching lines @@
         SimpleIdentifier nameNode = (argument as NamedExpression).name.label;
         String name = nameNode.name;
         ParameterElement element = namedParameters[name];
         if (element == null) {
           ErrorCode errorCode = (reportError ? CompileTimeErrorCode.UNDEFINED_NAMED_PARAMETER : StaticWarningCode.UNDEFINED_NAMED_PARAMETER) as ErrorCode;
           _resolver.reportError6(errorCode, nameNode, [name]);
         } else {
           resolvedParameters[i] = element;
           nameNode.staticElement = element;
         }
-        if (!javaSetAdd(usedNames, name)) {
+        if (!usedNames.add(name)) {
           _resolver.reportError6(CompileTimeErrorCode.DUPLICATE_NAMED_ARGUMENT, nameNode, [name]);
         }
       } else {
         positionalArgumentCount++;
         if (unnamedIndex < unnamedParameterCount) {
           resolvedParameters[i] = unnamedParameters[unnamedIndex++];
         }
       }
     }
     if (positionalArgumentCount < requiredParameters.length) {
@@ skipping 149 matching lines @@
       propagatedElement = resolveProperty(target, propagatedType, propertyName);
     }
     if (target.parent.parent is Annotation) {
       if (staticElement != null) {
         propertyName.staticElement = staticElement;
       }
       return;
     }
     propertyName.staticElement = staticElement;
     propertyName.propagatedElement = propagatedElement;
-    bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticElement) && (_strictMode || shouldReportMissingMember(propagatedType, propagatedElement));
+    bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticElement);
     bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedElement) : false;
     if (shouldReportMissingMember_propagated) {
       if (memberFoundInSubclass(propagatedType.element, propertyName.name, false, true)) {
         shouldReportMissingMember_propagated = false;
       }
     }
     if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
       Element staticOrPropagatedEnclosingElt = shouldReportMissingMember_static ? staticType.element : propagatedType.element;
       bool isStaticProperty = isStatic(staticOrPropagatedEnclosingElt);
       if (propertyName.inSetterContext()) {
@@ skipping 82 matching lines @@
       Type2 bound = (type as TypeParameterType).element.bound;
       if (bound == null) {
         return _resolver.typeProvider.objectType;
       }
       return bound;
     }
     return type;
   }
 
   /**
-   * Return the propagated element if it is not `null`, or the static element if it is.
-   *
-   * @param staticElement the element computed using static type information
-   * @param propagatedElement the element computed using propagated type information
-   * @return the more specific of the two elements
-   */
-  ExecutableElement select(ExecutableElement staticElement, ExecutableElement propagatedElement) => propagatedElement != null ? propagatedElement : staticElement;
-
-  /**
    * Given a node that can have annotations associated with it and the element to which that node
    * has been resolved, create the annotations in the element model representing the annotations on
    * the node.
    *
    * @param element the element to which the node has been resolved
    * @param node the node that can have annotations associated with it
    */
   void setMetadata(Element element, AnnotatedNode node) {
     if (element is! ElementImpl) {
       return;
@@ skipping 56 matching lines @@
   accept(ASTVisitor visitor) => null;
 
   sc.Token get beginToken => null;
 
   Element get bestElement => null;
 
   sc.Token get endToken => null;
 
   String get name => _name;
 
+  int get precedence => 16;
+
   Element get propagatedElement => null;
 
   Element get staticElement => null;
 
   void visitChildren(ASTVisitor visitor) {
   }
 }
 
 /**
  * Instances of the class `IncrementalResolver` resolve the smallest portion of an AST
@@ skipping 328 matching lines @@
     ClassElement superclassElt = null;
     InterfaceType supertype = classElt.supertype;
     if (supertype != null) {
       superclassElt = supertype.element;
     } else {
       _classLookup[classElt] = resultMap;
       return resultMap;
     }
     if (superclassElt != null) {
       if (!visitedClasses.contains(superclassElt)) {
-        javaSetAdd(visitedClasses, classElt);
+        visitedClasses.add(classElt);
         resultMap = new MemberMap.con2(computeClassChainLookupMap(superclassElt, visitedClasses));
       } else {
         _classLookup[superclassElt] = resultMap;
         return resultMap;
       }
       substituteTypeParametersDownHierarchy(supertype, resultMap);
       recordMapWithClassMembers(resultMap, supertype);
     }
     List<InterfaceType> mixins = classElt.mixins;
     for (int i = mixins.length - 1; i >= 0; i--) {
@@ skipping 69 matching lines @@
       resultMap = new MemberMap();
     }
     InterfaceType supertype = classElt.supertype;
     ClassElement superclassElement = supertype != null ? supertype.element : null;
     List<InterfaceType> mixins = classElt.mixins;
     List<InterfaceType> interfaces = classElt.interfaces;
     List<MemberMap> lookupMaps = new List<MemberMap>();
     if (superclassElement != null) {
       if (!visitedInterfaces.contains(superclassElement)) {
         try {
-          javaSetAdd(visitedInterfaces, superclassElement);
+          visitedInterfaces.add(superclassElement);
           MemberMap map = computeInterfaceLookupMap(superclassElement, visitedInterfaces);
           map = new MemberMap.con2(map);
           substituteTypeParametersDownHierarchy(supertype, map);
           recordMapWithClassMembers(map, supertype);
           lookupMaps.add(map);
         } finally {
           visitedInterfaces.remove(superclassElement);
         }
       } else {
         MemberMap map = _interfaceLookup[classElt];
         if (map != null) {
           lookupMaps.add(map);
         } else {
           _interfaceLookup[superclassElement] = resultMap;
           return resultMap;
         }
       }
     }
     for (InterfaceType mixinType in mixins) {
       MemberMap mapWithMixinMembers = new MemberMap();
       recordMapWithClassMembers(mapWithMixinMembers, mixinType);
       lookupMaps.add(mapWithMixinMembers);
     }
     for (InterfaceType interfaceType in interfaces) {
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null) {
         if (!visitedInterfaces.contains(interfaceElement)) {
           try {
-            javaSetAdd(visitedInterfaces, interfaceElement);
+            visitedInterfaces.add(interfaceElement);
             MemberMap map = computeInterfaceLookupMap(interfaceElement, visitedInterfaces);
             map = new MemberMap.con2(map);
             substituteTypeParametersDownHierarchy(interfaceType, map);
             recordMapWithClassMembers(map, interfaceType);
             lookupMaps.add(map);
           } finally {
             visitedInterfaces.remove(interfaceElement);
           }
         } else {
           MemberMap map = _interfaceLookup[classElt];
@@ skipping 15 matching lines @@
       for (int i = 0; i < lookupMap.size; i++) {
         String key = lookupMap.getKey(i);
         if (key == null) {
           break;
         }
         Set<ExecutableElement> set = unionMap[key];
         if (set == null) {
           set = new Set<ExecutableElement>();
           unionMap[key] = set;
         }
-        javaSetAdd(set, lookupMap.getValue(i));
+        set.add(lookupMap.getValue(i));
       }
     }
     for (MapEntry<String, Set<ExecutableElement>> entry in getMapEntrySet(unionMap)) {
       String key = entry.getKey();
       Set<ExecutableElement> set = entry.getValue();
       int numOfEltsWithMatchingNames = set.length;
       if (numOfEltsWithMatchingNames == 1) {
         resultMap.put(key, new JavaIterator(set).next());
       } else {
         bool allMethods = true;
@@ skipping 112 matching lines @@
    * @param length the length of the location of the error
    * @param errorCode the error code to be associated with this error
    * @param arguments the arguments used to build the error message
    */
   void reportError(ClassElement classElt, int offset, int length, ErrorCode errorCode, List<Object> arguments) {
     Set<AnalysisError> errorSet = _errorsInClassElement[classElt];
     if (errorSet == null) {
       errorSet = new Set<AnalysisError>();
       _errorsInClassElement[classElt] = errorSet;
     }
-    javaSetAdd(errorSet, new AnalysisError.con2(classElt.source, offset, length, errorCode, arguments));
+    errorSet.add(new AnalysisError.con2(classElt.source, offset, length, errorCode, arguments));
   }
 
   /**
    * Loop through all of the members in some [MemberMap], performing type parameter
    * substitutions using a passed supertype.
    *
    * @param superType the supertype to substitute into the members of the [MemberMap]
    * @param map the MemberMap to perform the substitutions on
    */
   void substituteTypeParametersDownHierarchy(InterfaceType superType, MemberMap map) {
@@ skipping 146 matching lines @@
 
   /**
    * Return an array containing the libraries that are either imported or exported from this
    * library.
    *
    * @return the libraries that are either imported or exported from this library
    */
   List<Library> get importsAndExports {
     Set<Library> libraries = new Set<Library>();
     for (Library library in imports) {
-      javaSetAdd(libraries, library);
+      libraries.add(library);
     }
     for (Library library in exports) {
-      javaSetAdd(libraries, library);
+      libraries.add(library);
     }
     return new List.from(libraries);
   }
 
   /**
    * Return the inheritance manager for this library.
    *
    * @return the inheritance manager for this library
    */
   InheritanceManager get inheritanceManager {
@@ skipping 431 matching lines @@
    * @throws AnalysisException if the library could not be resolved for some reason
    */
   LibraryElement resolveLibrary(Source librarySource, bool fullAnalysis) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.LibraryResolver.resolveLibrary");
     try {
       instrumentation.metric("fullAnalysis", fullAnalysis);
       instrumentation.data3("fullName", librarySource.fullName);
       Library targetLibrary = createLibrary(librarySource);
       _coreLibrary = _libraryMap[_coreLibrarySource];
       if (_coreLibrary == null) {
-        _coreLibrary = createLibrary(_coreLibrarySource);
+        _coreLibrary = createLibraryOrNull(_coreLibrarySource);
+        if (_coreLibrary == null) {
+          throw new AnalysisException.con1("Core library does not exist");
+        }
       }
       instrumentation.metric3("createLibrary", "complete");
       computeLibraryDependencies(targetLibrary);
       resolvedLibraries = computeLibrariesInCycles(targetLibrary);
       buildElementModels();
       instrumentation.metric3("buildElementModels", "complete");
       LibraryElement coreElement = _coreLibrary.libraryElement;
       if (coreElement == null) {
         throw new AnalysisException.con1("Could not resolve dart:core");
       }
@@ skipping 36 matching lines @@
    * Given a library that is part of a cycle that includes the root library, add to the given set of
    * libraries all of the libraries reachable from the root library that are also included in the
    * cycle.
    *
    * @param library the library to be added to the collection of libraries in cycles
    * @param librariesInCycle a collection of the libraries that are in the cycle
    * @param dependencyMap a table mapping libraries to the collection of libraries from which those
    *          libraries are referenced
    */
   void addLibrariesInCycle(Library library, Set<Library> librariesInCycle, Map<Library, List<Library>> dependencyMap) {
-    if (javaSetAdd(librariesInCycle, library)) {
+    if (librariesInCycle.add(library)) {
       List<Library> dependentLibraries = dependencyMap[library];
       if (dependentLibraries != null) {
         for (Library dependentLibrary in dependentLibraries) {
           addLibrariesInCycle(dependentLibrary, librariesInCycle, dependencyMap);
         }
       }
     }
   }
 
   /**
    * Add the given library, and all libraries reachable from it that have not already been visited,
    * to the given dependency map.
    *
    * @param library the library currently being added to the dependency map
    * @param dependencyMap the dependency map being computed
    * @param visitedLibraries the libraries that have already been visited, used to prevent infinite
    *          recursion
    */
   void addToDependencyMap(Library library, Map<Library, List<Library>> dependencyMap, Set<Library> visitedLibraries) {
-    if (javaSetAdd(visitedLibraries, library)) {
+    if (visitedLibraries.add(library)) {
       for (Library referencedLibrary in library.importsAndExports) {
         addDependencyToMap(dependencyMap, library, referencedLibrary);
         addToDependencyMap(referencedLibrary, dependencyMap, visitedLibraries);
       }
       if (!library.explicitlyImportsCore && library != _coreLibrary) {
         addDependencyToMap(dependencyMap, library, _coreLibrary);
       }
     }
   }
 
@@ skipping 59 matching lines @@
                 PrefixElementImpl prefix = nameToPrefixMap[prefixName];
                 if (prefix == null) {
                   prefix = new PrefixElementImpl(prefixNode);
                   nameToPrefixMap[prefixName] = prefix;
                 }
                 importElement.prefix = prefix;
                 prefixNode.staticElement = prefix;
               }
               directive.element = importElement;
               imports.add(importElement);
-              if (doesCompilationUnitHavePartOfDirective(importedLibrary.getAST(importedSource))) {
+              if (analysisContext.computeKindOf(importedSource) != SourceKind.LIBRARY) {
                 errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY, [uriLiteral.toSource()]));
               }
             }
           }
         } else if (directive is ExportDirective) {
           ExportDirective exportDirective = directive as ExportDirective;
           Source exportedSource = library.getSource(exportDirective);
           if (exportedSource != null) {
             Library exportedLibrary = _libraryMap[exportedSource];
             if (exportedLibrary != null) {
               ExportElementImpl exportElement = new ExportElementImpl();
               exportElement.uri = library.getUri(exportDirective);
               exportElement.combinators = buildCombinators(exportDirective);
               LibraryElement exportedLibraryElement = exportedLibrary.libraryElement;
               if (exportedLibraryElement != null) {
                 exportElement.exportedLibrary = exportedLibraryElement;
               }
               directive.element = exportElement;
               exports.add(exportElement);
-              if (doesCompilationUnitHavePartOfDirective(exportedLibrary.getAST(exportedSource))) {
+              if (analysisContext.computeKindOf(exportedSource) != SourceKind.LIBRARY) {
                 StringLiteral uriLiteral = exportDirective.uri;
                 errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY, [uriLiteral.toSource()]));
               }
             }
           }
         }
       }
       Source librarySource = library.librarySource;
       if (!library.explicitlyImportsCore && _coreLibrarySource != librarySource) {
         ImportElementImpl importElement = new ImportElementImpl();
@@ skipping 92 matching lines @@
    * @throws AnalysisException if some portion of the library graph could not be traversed
    */
   void computeLibraryDependencies2(Library library, CompilationUnit unit) {
     Source librarySource = library.librarySource;
     Set<Source> exportedSources = new Set<Source>();
     Set<Source> importedSources = new Set<Source>();
     for (Directive directive in unit.directives) {
       if (directive is ExportDirective) {
         Source exportSource = resolveSource(librarySource, directive as ExportDirective);
         if (exportSource != null) {
-          javaSetAdd(exportedSources, exportSource);
+          exportedSources.add(exportSource);
         }
       } else if (directive is ImportDirective) {
         Source importSource = resolveSource(librarySource, directive as ImportDirective);
         if (importSource != null) {
-          javaSetAdd(importedSources, importSource);
+          importedSources.add(importSource);
         }
       }
     }
     computeLibraryDependencies3(library, new List.from(importedSources), new List.from(exportedSources));
   }
 
   /**
    * Recursively traverse the libraries reachable from the given library, creating instances of the
    * class [Library] to represent them, and record the references in the library objects.
    *
@@ skipping 91 matching lines @@
   Library createLibraryOrNull(Source librarySource) {
     if (!librarySource.exists()) {
       return null;
     }
     Library library = new Library(analysisContext, errorListener, librarySource);
     _libraryMap[librarySource] = library;
     return library;
   }
 
   /**
-   * Return `true` if and only if the passed [CompilationUnit] has a part-of directive.
-   *
-   * @param node the [CompilationUnit] to test
-   * @return `true` if and only if the passed [CompilationUnit] has a part-of directive
-   */
-  bool doesCompilationUnitHavePartOfDirective(CompilationUnit node) {
-    NodeList<Directive> directives = node.directives;
-    for (Directive directive in directives) {
-      if (directive is PartOfDirective) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
    * Return an array containing the lexical identifiers associated with the nodes in the given list.
    *
    * @param names the AST nodes representing the identifiers
    * @return the lexical identifiers associated with the nodes in the list
    */
   List<String> getIdentifiers(NodeList<SimpleIdentifier> names) {
     int count = names.length;
     List<String> identifiers = new List<String>(count);
     for (int i = 0; i < count; i++) {
       identifiers[i] = names[i].name;
@@ skipping 243 matching lines @@
  * This class is a wrapper for an [AnalysisError] which can also be queried after resolution
  * to find out if the error should actually be reported. In this case, these errors are conditional
  * on the non-existence of an `@proxy` annotation.
  *
  * If we have other conditional error codes in the future, we should have this class implement some
  * ConditionalErrorCode so that after resolution, a list of ConditionalErrorCode can be visited
  * instead of multiple lists of *ConditionalErrorCodes.
  */
 class ProxyConditionalAnalysisError {
   /**
-   * The name of the proxy annotation, from dart:core.
-   */
-  static String _PROXY_ANNOTATION_NAME = "proxy";
-
-  /**
    * Return `true` if the given element represents a class that has the proxy annotation.
    *
    * @param element the class being tested
    * @return `true` if the given element represents a class that has the proxy annotation
    */
-  static bool classHasProxyAnnotation(Element element) {
-    if (element is ClassElement) {
-      ClassElement classElement = element as ClassElement;
-      List<ElementAnnotation> annotations = classElement.metadata;
-      for (ElementAnnotation annotation in annotations) {
-        Element elementAnnotation = annotation.element;
-        if (elementAnnotation != null) {
-          LibraryElement lib = elementAnnotation.library;
-          if (lib != null && lib.isDartCore && elementAnnotation.name == _PROXY_ANNOTATION_NAME) {
-            return true;
-          }
-        }
-      }
-    }
-    return false;
-  }
+  static bool classHasProxyAnnotation(Element element) => (element is ClassElement) && (element as ClassElement).isProxy;
 
   /**
    * The enclosing [ClassElement], this is what will determine if the error code should, or
    * should not, be generated on the source.
    */
   Element _enclosingElement;
 
   /**
    * The conditional analysis error.
    */
@@ skipping 197 matching lines @@
 
   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);
+      NodeList<Directive> directives = node.directives;
+      int directiveCount = directives.length;
+      for (int i = 0; i < directiveCount; i++) {
+        directives[i].accept(this);
       }
-      List<CompilationUnitMember> classes = new List<CompilationUnitMember>();
-      for (CompilationUnitMember declaration in node.declarations) {
-        if (declaration is ClassDeclaration) {
-          classes.add(declaration);
-        } else {
+      NodeList<CompilationUnitMember> declarations = node.declarations;
+      int declarationCount = declarations.length;
+      for (int i = 0; i < declarationCount; i++) {
+        CompilationUnitMember declaration = declarations[i];
+        if (declaration is! ClassDeclaration) {
           declaration.accept(this);
         }
       }
-      for (CompilationUnitMember declaration in classes) {
-        declaration.accept(this);
+      for (int i = 0; i < declarationCount; i++) {
+        CompilationUnitMember declaration = declarations[i];
+        if (declaration is ClassDeclaration) {
+          declaration.accept(this);
+        }
       }
     } finally {
       overrideManager.exitScope();
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   Object visitConditionalExpression(ConditionalExpression node) {
@@ skipping 1386 matching lines @@
     }
     return outerScope;
   }
 
   /**
    * Marks the local declarations of the given [Block] hidden in the enclosing scope.
    * According to the scoping rules name is hidden if block defines it, but name is defined after
    * its declaration statement.
    */
   void hideNamesDefinedInBlock(EnclosedScope scope, Block block) {
-    for (Statement statement in block.statements) {
+    NodeList<Statement> statements = block.statements;
+    int statementCount = statements.length;
+    for (int i = 0; i < statementCount; i++) {
+      Statement statement = statements[i];
       if (statement is VariableDeclarationStatement) {
         VariableDeclarationStatement vds = statement as VariableDeclarationStatement;
-        for (VariableDeclaration variableDeclaration in vds.variables.variables) {
-          Element element = variableDeclaration.element;
-          scope.hide(element);
+        NodeList<VariableDeclaration> variables = vds.variables.variables;
+        int variableCount = variables.length;
+        for (int j = 0; j < variableCount; j++) {
+          scope.hide(variables[j].element);
         }
-      }
-      if (statement is FunctionDeclarationStatement) {
+      } else if (statement is FunctionDeclarationStatement) {
         FunctionDeclarationStatement fds = statement as FunctionDeclarationStatement;
-        Element element = fds.functionDeclaration.element;
-        scope.hide(element);
+        scope.hide(fds.functionDeclaration.element);
       }
     }
   }
 }
 
 /**
  * Instances of the class `StaticTypeAnalyzer` perform two type-related tasks. First, they
  * compute the static type of every expression. Second, they look for any static type errors or
  * warnings that might need to be generated. The requirements for the type analyzer are:
  * <ol>
@@ skipping 676 matching lines @@
    * <i>S.m</i> exists, it is a static warning if the type <i>F</i> of <i>S.m</i> may not be
    * assigned to a function type.
    *
    * If <i>S.m</i> does not exist, or if <i>F</i> is not a function type, the static type of
    * <i>i</i> is dynamic. Otherwise the static type of <i>i</i> is the declared return type of
    * <i>F</i>.</blockquote>
    */
   Object visitMethodInvocation(MethodInvocation node) {
     SimpleIdentifier methodNameNode = node.methodName;
     Element staticMethodElement = methodNameNode.staticElement;
+    if (staticMethodElement is LocalVariableElement) {
+      LocalVariableElement variable = staticMethodElement as LocalVariableElement;
+      Type2 staticType = variable.type;
+      recordStaticType(methodNameNode, staticType);
+      Type2 propagatedType = _overrideManager.getType(variable);
+      if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
+        recordPropagatedType2(methodNameNode, propagatedType);
+      }
+    }
     Type2 staticStaticType = computeStaticReturnType(staticMethodElement);
     recordStaticType(node, staticStaticType);
     Type2 staticPropagatedType = computePropagatedReturnType(staticMethodElement);
     if (staticPropagatedType != null && (staticStaticType == null || staticPropagatedType.isMoreSpecificThan(staticStaticType))) {
       recordPropagatedType2(node, staticPropagatedType);
     }
     String methodName = methodNameNode.name;
     if (methodName == "then") {
       Expression target = node.realTarget;
       Type2 targetType = target == null ? null : target.bestType;
@@ skipping 942 matching lines @@
 
   /**
    * Given some [ClassElement] and a [HashSet<ClassElement>], this method recursively
    * adds all of the subtypes of the [ClassElement] to the passed array.
    *
    * @param classElement the type to compute the set of subtypes of
    * @param visitedClasses the set of class elements that this method has already recursively seen
    * @param allSubtypes the computed set of subtypes of the passed class element
    */
   void computeAllSubtypes2(ClassElement classElement, Set<ClassElement> visitedClasses, Set<ClassElement> allSubtypes) {
-    if (!javaSetAdd(visitedClasses, classElement)) {
+    if (!visitedClasses.add(classElement)) {
       return;
     }
     Set<ClassElement> subtypes = _subtypeMap[classElement];
     if (subtypes == null) {
       return;
     }
     for (ClassElement subtype in subtypes) {
       computeAllSubtypes2(subtype, visitedClasses, allSubtypes);
     }
     allSubtypes.addAll(subtypes);
@@ skipping 48 matching lines @@
    * [computeAllSubtypes] on all of the [ClassElement]s in the
    * compilation unit, and itself for all imported and exported libraries. All visited libraries are
    * added to the [visitedLibraries] set.
    *
    * @param libraryElement the library element
    */
   void computeSubtypesInLibrary(LibraryElement libraryElement) {
     if (libraryElement == null || _visitedLibraries.contains(libraryElement)) {
       return;
     }
-    javaSetAdd(_visitedLibraries, libraryElement);
+    _visitedLibraries.add(libraryElement);
     computeSubtypesInCompilationUnit(libraryElement.definingCompilationUnit);
     List<CompilationUnitElement> parts = libraryElement.parts;
     for (CompilationUnitElement part in parts) {
       computeSubtypesInCompilationUnit(part);
     }
     List<LibraryElement> imports = libraryElement.importedLibraries;
     for (LibraryElement importElt in imports) {
       computeSubtypesInLibrary(importElt.library);
     }
     List<LibraryElement> exports = libraryElement.exportedLibraries;
     for (LibraryElement exportElt in exports) {
       computeSubtypesInLibrary(exportElt.library);
     }
   }
 
   /**
    * Add some key/ value pair into the [subtypeMap] map.
    *
    * @param supertypeElement the key for the [subtypeMap] map
    * @param subtypeElement the value for the [subtypeMap] map
    */
   void putInSubtypeMap(ClassElement supertypeElement, ClassElement subtypeElement) {
     Set<ClassElement> subtypes = _subtypeMap[supertypeElement];
     if (subtypes == null) {
       subtypes = new Set<ClassElement>();
       _subtypeMap[supertypeElement] = subtypes;
     }
-    javaSetAdd(subtypes, subtypeElement);
+    subtypes.add(subtypeElement);
   }
 }
 
 /**
  * Instances of the class `TypeOverrideManager` manage the ability to override the type of an
  * element within a given context.
  */
 class TypeOverrideManager {
   /**
    * The current override scope, or `null` if no scope has been entered.
@@ skipping 1928 matching lines @@
 
   /**
    * The listener that is to be informed when an error is encountered.
    */
   AnalysisErrorListener _errorListener;
 
   /**
    * A list of the namespaces representing the names that are available in this scope from imported
    * libraries.
    */
-  List<Namespace> _importedNamespaces = new List<Namespace>();
+  List<Namespace> _importedNamespaces;
 
   /**
    * Initialize a newly created scope representing the names imported into the given library.
    *
    * @param definingLibrary the element representing the library that imports the names defined in
    *          this scope
    * @param errorListener the listener that is to be informed when an error is encountered
    */
   LibraryImportScope(LibraryElement definingLibrary, AnalysisErrorListener errorListener) {
     this._definingLibrary = definingLibrary;
@@ skipping 43 matching lines @@
 
   /**
    * Create all of the namespaces associated with the libraries imported into this library. The
    * names are not added to this scope, but are stored for later reference.
    *
    * @param definingLibrary the element representing the library that imports the libraries for
    *          which namespaces will be created
    */
   void createImportedNamespaces(LibraryElement definingLibrary) {
     NamespaceBuilder builder = new NamespaceBuilder();
-    for (ImportElement element in definingLibrary.imports) {
-      _importedNamespaces.add(builder.createImportNamespace(element));
+    List<ImportElement> imports = definingLibrary.imports;
+    int count = imports.length;
+    _importedNamespaces = new List<Namespace>(count);
+    for (int i = 0; i < count; i++) {
+      _importedNamespaces[i] = builder.createImportNamespace(imports[i]);
     }
   }
 
   /**
    * Returns the name of the library that defines given element.
    *
    * @param element the element to get library name
    * @param def the default name to use
    * @return the name of the library that defines given element
    */
@@ skipping 328 matching lines @@
   /**
    * Create a mapping table representing the export namespace of the given library.
    *
    * @param library the library whose public namespace is to be created
    * @param visitedElements a set of libraries that do not need to be visited when processing the
    *          export directives of the given library because all of the names defined by them will
    *          be added by another library
    * @return the mapping table that was created
    */
   Map<String, Element> createExportMapping(LibraryElement library, Set<LibraryElement> visitedElements) {
-    javaSetAdd(visitedElements, library);
+    visitedElements.add(library);
     try {
       Map<String, Element> definedNames = new Map<String, Element>();
       for (ExportElement element in library.exports) {
         LibraryElement exportedLibrary = element.exportedLibrary;
         if (exportedLibrary != null && !visitedElements.contains(exportedLibrary)) {
           Map<String, Element> exportedNames = createExportMapping(exportedLibrary, visitedElements);
           exportedNames = apply(exportedNames, element.combinators);
           addAll(definedNames, exportedNames);
         }
       }
@@ skipping 417 matching lines @@
     for (MapLiteralEntry entry in node.entries) {
       Expression key = entry.key;
       if (isConst) {
         EvaluationResultImpl result = validate(key, CompileTimeErrorCode.NON_CONSTANT_MAP_KEY);
         validate(entry.value, CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE);
         if (result is ValidResult) {
           Object value = (result as ValidResult).value;
           if (keys.contains(value)) {
             invalidKeys.add(key);
           } else {
-            javaSetAdd(keys, value);
+            keys.add(value);
           }
         }
       } else {
         EvaluationResultImpl result = key.accept(new ConstantVisitor());
         if (result is ValidResult) {
           Object value = (result as ValidResult).value;
           if (keys.contains(value)) {
             invalidKeys.add(key);
           } else {
-            javaSetAdd(keys, value);
+            keys.add(value);
           }
         } else {
           reportEqualKeys = false;
         }
       }
     }
     if (reportEqualKeys) {
       for (Expression key in invalidKeys) {
         _errorReporter.reportError2(StaticWarningCode.EQUAL_KEYS_IN_MAP, key, []);
       }
@@ skipping 118 matching lines @@
   }
 
   /**
    * Validates that the given expression is a compile time constant.
    *
    * @param parameterElements the elements of parameters of constant constructor, they are
    *          considered as a valid potentially constant expressions
    * @param expression the expression to validate
    */
   void validateInitializerExpression(List<ParameterElement> parameterElements, Expression expression) {
-    EvaluationResultImpl result = expression.accept(new ConstantVisitor_14(this, parameterElements));
+    EvaluationResultImpl result = expression.accept(new ConstantVisitor_13(this, parameterElements));
     reportErrors(result, CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER);
   }
 
   /**
    * Validates that all of the arguments of a constructor initializer are compile time constants.
    *
    * @param parameterElements the elements of parameters of constant constructor, they are
    *          considered as a valid potentially constant expressions
    * @param argumentList the argument list to validate
    */
@@ skipping 25 matching lines @@
         validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
       }
       if (initializer is SuperConstructorInvocation) {
         SuperConstructorInvocation invocation = initializer as SuperConstructorInvocation;
         validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
       }
     }
   }
 }
 
-class ConstantVisitor_14 extends ConstantVisitor {
+class ConstantVisitor_13 extends ConstantVisitor {
   final ConstantVerifier ConstantVerifier_this;
 
   List<ParameterElement> parameterElements;
 
-  ConstantVisitor_14(this.ConstantVerifier_this, this.parameterElements) : super();
+  ConstantVisitor_13(this.ConstantVerifier_this, this.parameterElements) : super();
 
   EvaluationResultImpl visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     for (ParameterElement parameterElement in parameterElements) {
       if (identical(parameterElement, element) && parameterElement != null) {
         Type2 type = parameterElement.type;
         if (type != null) {
           if (type.isDynamic) {
             return ValidResult.RESULT_DYNAMIC;
           }
@@ skipping 48 matching lines @@
    * The object providing access to the types defined by the language.
    */
   TypeProvider _typeProvider;
 
   /**
    * The manager for the inheritance mappings.
    */
   InheritanceManager _inheritanceManager;
 
   /**
-   * A flag indicating whether we are running in strict mode. In strict mode, error reporting is
-   * based exclusively on the static type information.
-   */
-  bool _strictMode = false;
-
-  /**
    * This is set to `true` iff the visitor is currently visiting children nodes of a
    * [ConstructorDeclaration] and the constructor is 'const'.
    *
    * @see #visitConstructorDeclaration(ConstructorDeclaration)
    */
   bool _isEnclosingConstructorConst = false;
 
   /**
    * This is set to `true` iff the visitor is currently visiting children nodes of a
    * [CatchClause].
@@ skipping 127 matching lines @@
    * [CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS] error codes.
    */
   List<InterfaceType> _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT;
 
   ErrorVerifier(ErrorReporter errorReporter, LibraryElement currentLibrary, TypeProvider typeProvider, InheritanceManager inheritanceManager) {
     this._errorReporter = errorReporter;
     this._currentLibrary = currentLibrary;
     this._isInSystemLibrary = currentLibrary.source.isInSystemLibrary;
     this._typeProvider = typeProvider;
     this._inheritanceManager = inheritanceManager;
-    _strictMode = currentLibrary.context.analysisOptions.strictMode;
     _isEnclosingConstructorConst = false;
     _isInCatchClause = false;
     _isInStaticVariableDeclaration = false;
     _isInInstanceVariableDeclaration = false;
     _isInInstanceVariableInitializer = false;
     _isInConstructorInitializer = false;
     _isInStaticMethod = false;
     _boolType = typeProvider.boolType;
     _dynamicType = typeProvider.dynamicType;
     _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT = <InterfaceType> [
@@ skipping 533 matching lines @@
     checkForTypeParameterSupertypeOfItsBound(node);
     return super.visitTypeParameter(node);
   }
 
   Object visitVariableDeclaration(VariableDeclaration node) {
     SimpleIdentifier nameNode = node.name;
     Expression initializerNode = node.initializer;
     checkForInvalidAssignment2(nameNode, initializerNode);
     nameNode.accept(this);
     String name = nameNode.name;
-    javaSetAdd(_namesForReferenceToDeclaredVariableInInitializer, name);
+    _namesForReferenceToDeclaredVariableInInitializer.add(name);
     _isInInstanceVariableInitializer = _isInInstanceVariableDeclaration;
     try {
       if (initializerNode != null) {
         initializerNode.accept(this);
       }
     } finally {
       _isInInstanceVariableInitializer = false;
       _namesForReferenceToDeclaredVariableInInitializer.remove(name);
     }
     return null;
@@ skipping 146 matching lines @@
       PropertyAccessorElement accessorElement = executableElement as PropertyAccessorElement;
       isGetter = accessorElement.isGetter;
       isSetter = accessorElement.isSetter;
     }
     if (overriddenExecutable == null) {
       if (!isGetter && !isSetter && !executableElement.isOperator) {
         Set<ClassElement> visitedClasses = new Set<ClassElement>();
         InterfaceType superclassType = _enclosingClass.supertype;
         ClassElement superclassElement = superclassType == null ? null : superclassType.element;
         while (superclassElement != null && !visitedClasses.contains(superclassElement)) {
-          javaSetAdd(visitedClasses, superclassElement);
+          visitedClasses.add(superclassElement);
           LibraryElement superclassLibrary = superclassElement.library;
           List<FieldElement> fieldElts = superclassElement.fields;
           for (FieldElement fieldElt in fieldElts) {
             if (fieldElt.name != executableElementName) {
               continue;
             }
             if (executableElementPrivate && _currentLibrary != superclassLibrary) {
               continue;
             }
             if (fieldElt.isStatic) {
@@ skipping 469 matching lines @@
    * @param expectedPropagatedType the expected propagated type of the parameter, may be
    *          `null`
    * @param actualPropagatedType the expected propagated type of the parameter, may be `null`
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    */
   bool checkForArgumentTypeNotAssignable4(Expression expression, Type2 expectedStaticType, Type2 actualStaticType, Type2 expectedPropagatedType, Type2 actualPropagatedType, ErrorCode errorCode) {
     if (actualStaticType == null || expectedStaticType == null) {
       return false;
     }
-    if (_strictMode) {
-      if (actualStaticType.isAssignableTo(expectedStaticType)) {
-        return false;
-      }
-      _errorReporter.reportError2(errorCode, expression, [
-          actualStaticType.displayName,
-          expectedStaticType.displayName]);
-      return true;
-    }
-    if (actualPropagatedType == null || expectedPropagatedType == null) {
-      if (actualStaticType.isAssignableTo(expectedStaticType)) {
-        return false;
-      }
-      _errorReporter.reportError2(errorCode, expression, [
-          actualStaticType.displayName,
-          expectedStaticType.displayName]);
-      return true;
-    }
-    if (actualStaticType.isAssignableTo(expectedStaticType) || actualStaticType.isAssignableTo(expectedPropagatedType) || actualPropagatedType.isAssignableTo(expectedStaticType) || actualPropagatedType.isAssignableTo(expectedPropagatedType)) {
+    if (actualStaticType.isAssignableTo(expectedStaticType)) {
       return false;
     }
     _errorReporter.reportError2(errorCode, expression, [
-        (actualPropagatedType == null ? actualStaticType : actualPropagatedType).displayName,
-        (expectedPropagatedType == null ? expectedStaticType : expectedPropagatedType).displayName]);
+        actualStaticType.displayName,
+        expectedStaticType.displayName]);
     return true;
   }
 
   /**
    * This verifies that left hand side of the passed assignment expression is not final.
    *
    * @param node the assignment expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ASSIGNMENT_TO_FINAL
    */
@@ skipping 934 matching lines @@
     Expression expression = node.expression;
     if (expression == null) {
       return false;
     }
     Type2 staticType = getStaticType(expression);
     if (staticType == null) {
       return false;
     }
     if (staticType.isAssignableTo(fieldType)) {
       return false;
-    } else if (_strictMode) {
-      if (_isEnclosingConstructorConst) {
-        _errorReporter.reportError2(CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [staticType.displayName, fieldType.displayName]);
-      } else {
-        _errorReporter.reportError2(StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [staticType.displayName, fieldType.displayName]);
-      }
-      return true;
-    }
-    Type2 propagatedType = expression.propagatedType;
-    if (propagatedType != null && propagatedType.isAssignableTo(fieldType)) {
-      return false;
     }
     if (_isEnclosingConstructorConst) {
-      _errorReporter.reportError2(CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [
-          (propagatedType == null ? staticType : propagatedType).displayName,
-          fieldType.displayName]);
+      _errorReporter.reportError2(CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [staticType.displayName, fieldType.displayName]);
     } else {
-      _errorReporter.reportError2(StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [
-          (propagatedType == null ? staticType : propagatedType).displayName,
-          fieldType.displayName]);
+      _errorReporter.reportError2(StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [staticType.displayName, fieldType.displayName]);
     }
     return true;
   }
 
   /**
    * This verifies that the passed field formal parameter is in a constructor declaration.
    *
    * @param node the field formal parameter to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR
@@ skipping 355 matching lines @@
    * @see StaticTypeWarningCode#INVALID_ASSIGNMENT
    */
   bool checkForInvalidAssignment2(Expression lhs, Expression rhs) {
     if (lhs == null || rhs == null) {
       return false;
     }
     VariableElement leftElement = getVariableElement(lhs);
     Type2 leftType = (leftElement == null) ? getStaticType(lhs) : leftElement.type;
     Type2 staticRightType = getStaticType(rhs);
     bool isStaticAssignable = staticRightType.isAssignableTo(leftType);
-    Type2 propagatedRightType = rhs.propagatedType;
-    if (_strictMode || propagatedRightType == null) {
-      if (!isStaticAssignable) {
-        _errorReporter.reportError2(StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [staticRightType.displayName, leftType.displayName]);
-        return true;
-      }
-    } else {
-      bool isPropagatedAssignable = propagatedRightType.isAssignableTo(leftType);
-      if (!isStaticAssignable && !isPropagatedAssignable) {
-        _errorReporter.reportError2(StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [staticRightType.displayName, leftType.displayName]);
-        return true;
-      }
+    if (!isStaticAssignable) {
+      _errorReporter.reportError2(StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [staticRightType.displayName, leftType.displayName]);
+      return true;
     }
     return false;
   }
 
   /**
    * This verifies that the usage of the passed 'this' is valid.
    *
    * @param node the 'this' expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#INVALID_REFERENCE_TO_THIS
@@ skipping 379 matching lines @@
       return false;
     }
     List<MethodElement> methods = _enclosingClass.methods;
     List<PropertyAccessorElement> accessors = _enclosingClass.accessors;
     Set<String> methodsInEnclosingClass = new Set<String>();
     for (MethodElement method in methods) {
       String methodName = method.name;
       if (methodName == ElementResolver.NO_SUCH_METHOD_METHOD_NAME) {
         return false;
       }
-      javaSetAdd(methodsInEnclosingClass, methodName);
+      methodsInEnclosingClass.add(methodName);
     }
     Set<String> accessorsInEnclosingClass = new Set<String>();
     for (PropertyAccessorElement accessor in accessors) {
-      javaSetAdd(accessorsInEnclosingClass, accessor.name);
+      accessorsInEnclosingClass.add(accessor.name);
     }
     Set<ExecutableElement> missingOverrides = new Set<ExecutableElement>();
     MemberMap membersInheritedFromInterfaces = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(_enclosingClass);
     MemberMap membersInheritedFromSuperclasses = _inheritanceManager.getMapOfMembersInheritedFromClasses(_enclosingClass);
     for (int i = 0; i < membersInheritedFromInterfaces.size; i++) {
       String memberName = membersInheritedFromInterfaces.getKey(i);
       ExecutableElement executableElt = membersInheritedFromInterfaces.getValue(i);
       if (memberName == null) {
         break;
       }
       ExecutableElement elt = membersInheritedFromSuperclasses.get(executableElt.name);
       if (elt != null) {
         if (elt is MethodElement && !(elt as MethodElement).isAbstract) {
           continue;
         } else if (elt is PropertyAccessorElement && !(elt as PropertyAccessorElement).isAbstract) {
           continue;
         }
       }
       if (executableElt is MethodElement) {
         if (!methodsInEnclosingClass.contains(memberName) && !memberHasConcreteMethodImplementationInSuperclassChain(_enclosingClass, memberName, new List<ClassElement>())) {
-          javaSetAdd(missingOverrides, executableElt);
+          missingOverrides.add(executableElt);
         }
       } else if (executableElt is PropertyAccessorElement) {
         if (!accessorsInEnclosingClass.contains(memberName) && !memberHasConcreteAccessorImplementationInSuperclassChain(_enclosingClass, memberName, new List<ClassElement>())) {
-          javaSetAdd(missingOverrides, executableElt);
+          missingOverrides.add(executableElt);
         }
       }
     }
     int missingOverridesSize = missingOverrides.length;
     if (missingOverridesSize == 0) {
       return false;
     }
     List<ExecutableElement> missingOverridesArray = new List.from(missingOverrides);
     List<String> stringMembersArrayListSet = new List<String>();
     for (int i = 0; i < missingOverridesArray.length; i++) {
@@ skipping 447 matching lines @@
       if (staticReturnType.isVoid || staticReturnType.isDynamic || staticReturnType.isBottom) {
         return false;
       }
       _errorReporter.reportError2(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
           staticReturnType.displayName,
           expectedReturnType.displayName,
           _enclosingFunction.displayName]);
       return true;
     }
     bool isStaticAssignable = staticReturnType.isAssignableTo(expectedReturnType);
-    Type2 propagatedReturnType = returnExpression.propagatedType;
-    if (_strictMode || propagatedReturnType == null) {
-      if (isStaticAssignable) {
-        return false;
-      }
-      _errorReporter.reportError2(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
-          staticReturnType.displayName,
-          expectedReturnType.displayName,
-          _enclosingFunction.displayName]);
-      return true;
-    } else {
-      bool isPropagatedAssignable = propagatedReturnType.isAssignableTo(expectedReturnType);
-      if (isStaticAssignable || isPropagatedAssignable) {
-        return false;
-      }
-      _errorReporter.reportError2(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
-          staticReturnType.displayName,
-          expectedReturnType.displayName,
-          _enclosingFunction.displayName]);
-      return true;
+    if (isStaticAssignable) {
+      return false;
     }
+    _errorReporter.reportError2(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
+        staticReturnType.displayName,
+        expectedReturnType.displayName,
+        _enclosingFunction.displayName]);
+    return true;
   }
 
   /**
    * This checks the given "typeReference" and that the "name" is not the reference to an instance
    * member.
    *
    * @param typeReference the resolved [ClassElement] of the left hand side of the expression,
    *          or `null`, aka, the class element of 'C' in 'C.x', see
    *          [getTypeReference]
    * @param name the accessed name to evaluate
@@ skipping 422 matching lines @@
   /**
    * @return `true` if the given constructor redirects to itself, directly or indirectly
    */
   bool hasRedirectingFactoryConstructorCycle(ConstructorElement element) {
     Set<ConstructorElement> constructors = new Set<ConstructorElement>();
     ConstructorElement current = element;
     while (current != null) {
       if (constructors.contains(current)) {
         return identical(current, element);
       }
-      javaSetAdd(constructors, current);
+      constructors.add(current);
       current = current.redirectedConstructor;
       if (current is ConstructorMember) {
         current = (current as ConstructorMember).baseElement;
       }
     }
     return false;
   }
 
   /**
    * @return <code>true</code> if given [Element] has direct or indirect reference to itself
@@ skipping 16 matching lines @@
             firstIteration = false;
             break;
           } else {
             return true;
           }
         }
         if (current != null && !checked.contains(current)) {
           break;
         }
       }
-      current.accept(new GeneralizingElementVisitor_15(target, toCheck));
-      javaSetAdd(checked, current);
+      current.accept(new GeneralizingElementVisitor_14(target, toCheck));
+      checked.add(current);
     }
   }
 
   /**
    * @return `true` if given [Type] implements operator <i>==</i>, and it is not
    *         <i>int</i> or <i>String</i>.
    */
   bool implementsEqualsWhenNotAllowed(Type2 type) {
     if (type == null || type == _typeProvider.intType || type == _typeProvider.stringType) {
       return false;
@@ skipping 188 matching lines @@
 
   static final List<INIT_STATE> values = [
       NOT_INIT,
       INIT_IN_DECLARATION,
       INIT_IN_FIELD_FORMAL,
       INIT_IN_INITIALIZERS];
 
   INIT_STATE(String name, int ordinal) : super(name, ordinal);
 }
 
-class GeneralizingElementVisitor_15 extends GeneralizingElementVisitor<Object> {
+class GeneralizingElementVisitor_14 extends GeneralizingElementVisitor<Object> {
   Element target;
 
   List<Element> toCheck;
 
-  GeneralizingElementVisitor_15(this.target, this.toCheck) : super();
+  GeneralizingElementVisitor_14(this.target, this.toCheck) : super();
 
   bool _inClass = false;
 
   Object visitClassElement(ClassElement element) {
     addTypeToCheck(element.supertype);
     for (InterfaceType mixin in element.mixins) {
       addTypeToCheck(mixin);
     }
     _inClass = !element.isTypedef;
     try {
@@ skipping 110 matching lines @@
   }
 
   String get correction => correction9;
 
   ErrorSeverity get errorSeverity => _type.severity;
 
   String get message => _message;
 
   ErrorType get type => _type;
 }