New analyzer snapshot.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // 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';
@@ skipping 1566 matching lines @@
     } else if (type == _typeProvider.doubleType) {
       return true;
     }
     // prepare ClassElement
     Element element = type.element;
     if (element is! ClassElement) {
       return false;
     }
     ClassElement classElement = element as ClassElement;
     // lookup for ==
-    MethodElement method = classElement.lookUpMethod("==", _currentLibrary);
-    while (method != null && method.isAbstract) {
-      ClassElement definingClass = method.enclosingElement;
-      if (definingClass == null) {
-        return false;
-      }
-      method = definingClass.lookUpInheritedMethod("==", _currentLibrary);
-    }
+    MethodElement method = classElement.lookUpConcreteMethod("==", _currentLibrary);
     if (method == null || method.enclosingElement.type.isObject) {
       return false;
     }
     // there is == that we don't like
     return true;
   }
 
   /**
    * Given some computed [Expression], this method generates the passed [ErrorCode] on
    * the node if its' value consists of information from a deferred library.
@@ skipping 3892 matching lines @@
       // TODO(brianwilkerson) Consider the possibility of re-writing the AST.
       FunctionType getterType = element.type;
       if (getterType != null) {
         DartType returnType = getterType.returnType;
         if (!_isExecutableType(returnType)) {
           return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
         }
       }
     } else if (element is ExecutableElement) {
       return null;
+    } else if (element is MultiplyDefinedElement) {
+      // The error has already been reported
+      return null;
     } else if (element == null && target is SuperExpression) {
       // TODO(jwren) We should split the UNDEFINED_METHOD into two error codes, this one, and
       // a code that describes the situation where the method was found, but it was not
       // accessible from the current library.
       return StaticTypeWarningCode.UNDEFINED_SUPER_METHOD;
     } else {
       //
       // This is really a function expression invocation.
       //
       // TODO(brianwilkerson) Consider the possibility of re-writing the AST.
@@ skipping 1204 matching lines @@
           }
         } else if (propertyName.inGetterContext()) {
           if (isStaticProperty) {
             ErrorCode errorCode = (shouldReportMissingMember_static ? StaticWarningCode.UNDEFINED_GETTER : HintCode.UNDEFINED_GETTER);
             if (_doesClassElementHaveProxy(staticOrPropagatedEnclosingElt)) {
               _resolver.reportErrorForNode(errorCode, propertyName, [
                   propertyName.name,
                   staticOrPropagatedEnclosingElt.displayName]);
             }
           } else {
+            if (staticOrPropagatedEnclosingElt is ClassElement) {
+              InterfaceType targetType = staticOrPropagatedEnclosingElt.type;
+              if (targetType != null && targetType.isDartCoreFunction && propertyName.name == FunctionElement.CALL_METHOD_NAME) {
+                // TODO(brianwilkerson) Can we ever resolve the function being invoked?
+                //resolveArgumentsToParameters(node.getArgumentList(), invokedFunction);
+                return;
+              }
+            }
             ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_GETTER : HintCode.UNDEFINED_GETTER);
             if (_doesClassElementHaveProxy(staticOrPropagatedEnclosingElt)) {
               _resolver.reportErrorForNode(errorCode, propertyName, [
                   propertyName.name,
                   staticOrPropagatedEnclosingElt.displayName]);
             }
           }
         } else {
           if (_doesClassElementHaveProxy(staticOrPropagatedEnclosingElt)) {
             _resolver.reportErrorForNode(StaticWarningCode.UNDEFINED_IDENTIFIER, propertyName, [propertyName.name]);
@@ skipping 664 matching lines @@
     ClassElement outerClassElement = _enclosingClass;
     try {
       _enclosingClass = node.element;
       ImplementsClause implementsClause = node.implementsClause;
       // Only check for all of the inheritance logic around clauses if there isn't an error code
       // such as "Cannot extend double" already on the class.
       if (!_checkForExtendsDisallowedClassInTypeAlias(node) && !_checkForImplementsDisallowedClass(implementsClause) && !_checkForAllMixinErrorCodes(node.withClause)) {
         _checkForExtendsDeferredClassInTypeAlias(node);
         _checkForImplementsDeferredClass(implementsClause);
         _checkForRecursiveInterfaceInheritance(_enclosingClass);
-        _checkForTypeAliasCannotReferenceItself_mixin(node);
         _checkForNonAbstractClassInheritsAbstractMember(node.name);
       }
     } finally {
       _enclosingClass = outerClassElement;
     }
     return super.visitClassTypeAlias(node);
   }
 
   @override
   Object visitComment(Comment node) {
@@ skipping 1454 matching lines @@
   /**
    * This verifies that the passed method declaration is abstract only if the enclosing class is
    * also abstract.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONCRETE_CLASS_WITH_ABSTRACT_MEMBER
    */
   bool _checkForConcreteClassWithAbstractMember(MethodDeclaration node) {
     if (node.isAbstract && _enclosingClass != null && !_enclosingClass.isAbstract) {
-      SimpleIdentifier methodName = node.name;
-      _errorReporter.reportErrorForNode(StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER, methodName, [methodName.name, _enclosingClass.displayName]);
-      return true;
+      SimpleIdentifier nameNode = node.name;
+      String memberName = nameNode.name;
+      ExecutableElement overriddenMember;
+      if (node.isGetter) {
+        overriddenMember = _enclosingClass.lookUpInheritedConcreteGetter(memberName, _currentLibrary);
+      } else if (node.isSetter) {
+        overriddenMember = _enclosingClass.lookUpInheritedConcreteSetter(memberName, _currentLibrary);
+      } else {
+        overriddenMember = _enclosingClass.lookUpInheritedConcreteMethod(memberName, _currentLibrary);
+      }
+      if (overriddenMember == null) {
+        _errorReporter.reportErrorForNode(StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER, nameNode, [memberName, _enclosingClass.displayName]);
+        return true;
+      }
     }
     return false;
   }
 
   /**
    * This verifies all possible conflicts of the constructor name with other constructors and
    * members of the same class.
    *
    * @param node the constructor declaration to evaluate
    * @param constructorElement the constructor element
@@ skipping 2462 matching lines @@
   bool _checkForTypeAliasCannotReferenceItself_function(FunctionTypeAlias node) {
     FunctionTypeAliasElement element = node.element;
     if (!_hasTypedefSelfReference(element)) {
       return false;
     }
     _errorReporter.reportErrorForNode(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, node, []);
     return true;
   }
 
   /**
-   * This verifies that the given class type alias does not reference itself.
-   *
-   * @return `true` if and only if an error code is generated on the passed node
-   * @see CompileTimeErrorCode#TYPE_ALIAS_CANNOT_REFERENCE_ITSELF
-   */
-  bool _checkForTypeAliasCannotReferenceItself_mixin(ClassTypeAlias node) {
-    ClassElement element = node.element;
-    if (!_hasTypedefSelfReference(element)) {
-      return false;
-    }
-    _errorReporter.reportErrorForNode(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, node, []);
-    return true;
-  }
-
-  /**
    * This verifies that the passed type name is not a deferred type.
    *
    * @param expression the expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#TYPE_ANNOTATION_DEFERRED_CLASS
    */
   bool _checkForTypeAnnotationDeferredClass(TypeName node) {
     if (node != null && node.isDeferred) {
       _errorReporter.reportErrorForNode(StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, node, [node.name]);
     }
@@ skipping 353 matching lines @@
       if (interfaceNode.type == superType) {
         hasProblem = true;
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS, interfaceNode, [superType.displayName]);
       }
     }
     // done
     return hasProblem;
   }
 
   /**
+   * Return the error code that should be used when the given class references itself directly.
+   *
+   * @param classElt the class that references itself
+   * @return the error code that should be used
+   */
+  ErrorCode _getBaseCaseErrorCode(ClassElement classElt) {
+    InterfaceType supertype = classElt.supertype;
+    if (supertype != null && _enclosingClass == supertype.element) {
+      return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS;
+    }
+    List<InterfaceType> mixins = classElt.mixins;
+    for (int i = 0; i < mixins.length; i++) {
+      if (_enclosingClass == mixins[i].element) {
+        return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH;
+      }
+    }
+    return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS;
+  }
+
+  /**
    * Returns the Type (return type) for a given getter.
    *
    * @param propertyAccessorElement
    * @return The type of the given getter.
    */
   DartType _getGetterType(PropertyAccessorElement propertyAccessorElement) {
     FunctionType functionType = propertyAccessorElement.type;
     if (functionType != null) {
       return functionType.returnType;
     } else {
@@ skipping 220 matching lines @@
 
   /**
    * This checks the class declaration is not a superinterface to itself.
    *
    * @param classElt the class element to test
    * @param path a list containing the potentially cyclic implements path
    * @return `true` if and only if an error code is generated on the passed element
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS
+   * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH
    */
   bool _safeCheckForRecursiveInterfaceInheritance(ClassElement classElt, List<ClassElement> path) {
     // Detect error condition.
     int size = path.length;
     // If this is not the base case (size > 0), and the enclosing class is the passed class
     // element then an error an error.
     if (size > 0 && _enclosingClass == classElt) {
       String enclosingClassName = _enclosingClass.displayName;
       if (size > 1) {
         // Construct a string showing the cyclic implements path: "A, B, C, D, A"
         String separator = ", ";
         JavaStringBuilder builder = new JavaStringBuilder();
         for (int i = 0; i < size; i++) {
           builder.append(path[i].displayName);
           builder.append(separator);
         }
         builder.append(classElt.displayName);
         _errorReporter.reportErrorForOffset(CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, _enclosingClass.nameOffset, enclosingClassName.length, [enclosingClassName, builder.toString()]);
         return true;
       } else {
-        // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS or RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS
-        InterfaceType supertype = classElt.supertype;
-        ErrorCode errorCode = (supertype != null && _enclosingClass == supertype.element ? CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS : CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS);
-        _errorReporter.reportErrorForOffset(errorCode, _enclosingClass.nameOffset, enclosingClassName.length, [enclosingClassName]);
+        // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS or
+        // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS or
+        // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH
+        _errorReporter.reportErrorForOffset(_getBaseCaseErrorCode(classElt), _enclosingClass.nameOffset, enclosingClassName.length, [enclosingClassName]);
         return true;
       }
     }
     if (path.indexOf(classElt) > 0) {
       return false;
     }
     path.add(classElt);
     // n-case
     InterfaceType supertype = classElt.supertype;
     if (supertype != null && _safeCheckForRecursiveInterfaceInheritance(supertype.element, path)) {
       return true;
     }
     List<InterfaceType> interfaceTypes = classElt.interfaces;
     for (InterfaceType interfaceType in interfaceTypes) {
       if (_safeCheckForRecursiveInterfaceInheritance(interfaceType.element, path)) {
         return true;
       }
     }
+    List<InterfaceType> mixinTypes = classElt.mixins;
+    for (InterfaceType mixinType in mixinTypes) {
+      if (_safeCheckForRecursiveInterfaceInheritance(mixinType.element, path)) {
+        return true;
+      }
+    }
     path.removeAt(path.length - 1);
     return false;
   }
 }
 
 /**
  * Instances of the class `ExitDetector` determine whether the visited AST node is guaranteed
  * to terminate by executing a `return` statement, `throw` expression, `rethrow`
  * expression, or simple infinite loop such as `while(true)`.
  */
@@ skipping 999 matching lines @@
 
   /**
    * In cases where there is more than one import directive per library element, this mapping is
    * used to determine which of the multiple import directives are used by generating a
    * [Namespace] for each of the imports to do lookups in the same way that they are done from
    * the [ElementResolver].
    */
   Map<ImportDirective, Namespace> _namespaceMap;
 
   /**
-   * This is a map between prefix elements and the import directive from which they are derived. In
+   * This is a map between prefix elements and the import directives from which they are derived. In
    * cases where a type is referenced via a prefix element, the import directive can be marked as
    * used (removed from the unusedImports) by looking at the resolved `lib` in `lib.X`,
    * instead of looking at which library the `lib.X` resolves.
+   *
+   * TODO (jwren) Since multiple [ImportDirective]s can share the same [PrefixElement],
+   * it is possible to have an unreported unused import in situations where two imports use the same
+   * prefix and at least one import directive is used.
    */
-  Map<PrefixElement, ImportDirective> _prefixElementMap;
+  Map<PrefixElement, List<ImportDirective>> _prefixElementMap;
 
   /**
    * Create a new instance of the [ImportsVerifier].
    *
    * @param errorReporter the error reporter
    */
   ImportsVerifier(LibraryElement library) {
     this._currentLibrary = library;
     this._unusedImports = new List<ImportDirective>();
     this._duplicateImports = new List<ImportDirective>();
     this._libraryMap = new Map<LibraryElement, List<ImportDirective>>();
     this._namespaceMap = new Map<ImportDirective, Namespace>();
-    this._prefixElementMap = new Map<PrefixElement, ImportDirective>();
+    this._prefixElementMap = new Map<PrefixElement, List<ImportDirective>>();
   }
 
   /**
    * Any time after the defining compilation unit has been visited by this visitor, this method can
    * be called to report an [HintCode#DUPLICATE_IMPORT] hint for each of the import directives
    * in the [duplicateImports] list.
    *
    * @param errorReporter the error reporter to report the set of [HintCode#DUPLICATE_IMPORT]
    *          hints to
    */
@@ skipping 37 matching lines @@
             _unusedImports.add(importDirective);
             //
             // Initialize prefixElementMap
             //
             if (importDirective.asToken != null) {
               SimpleIdentifier prefixIdentifier = importDirective.prefix;
               if (prefixIdentifier != null) {
                 Element element = prefixIdentifier.staticElement;
                 if (element is PrefixElement) {
                   PrefixElement prefixElementKey = element;
-                  _prefixElementMap[prefixElementKey] = importDirective;
+                  List<ImportDirective> list = _prefixElementMap[prefixElementKey];
+                  if (list == null) {
+                    list = new List<ImportDirective>();
+                    _prefixElementMap[prefixElementKey] = list;
+                  }
+                  list.add(importDirective);
                 }
               }
             }
             //
             // Initialize libraryMap: libraryElement -> importDirective
             //
             _putIntoLibraryMap(libraryElement, importDirective);
             //
             // For this new addition to the libraryMap, also recursively add any exports from the
             // libraryElement
@@ skipping 52 matching lines @@
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (_unusedImports.isEmpty) {
       return null;
     }
     // If the prefixed identifier references some A.B, where A is a library prefix, then we can
     // lookup the associated ImportDirective in prefixElementMap and remove it from the
     // unusedImports list.
     SimpleIdentifier prefixIdentifier = node.prefix;
     Element element = prefixIdentifier.staticElement;
     if (element is PrefixElement) {
-      _unusedImports.remove(_prefixElementMap[element]);
+      List<ImportDirective> importDirectives = _prefixElementMap[element];
+      for (ImportDirective importDirective in importDirectives) {
+        _unusedImports.remove(importDirective);
+      }
       return null;
     }
     // Otherwise, pass the prefixed identifier element and name onto visitIdentifier.
     return _visitIdentifier(element, prefixIdentifier.name);
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (_unusedImports.isEmpty) {
       return null;
@@ skipping 61 matching lines @@
       return null;
     }
     // If the element is multiply defined then call this method recursively for each of the conflicting elements.
     if (element is MultiplyDefinedElement) {
       MultiplyDefinedElement multiplyDefinedElement = element;
       for (Element elt in multiplyDefinedElement.conflictingElements) {
         _visitIdentifier(elt, name);
       }
       return null;
     } else if (element is PrefixElement) {
-      _unusedImports.remove(_prefixElementMap[element]);
+      List<ImportDirective> importDirectives = _prefixElementMap[element];
+      for (ImportDirective importDirective in importDirectives) {
+        _unusedImports.remove(importDirective);
+      }
       return null;
     } else if (element.enclosingElement is! CompilationUnitElement) {
       // Identifiers that aren't a prefix element and whose enclosing element isn't a
       // CompilationUnit are ignored- this covers the case the identifier is a relative-reference,
       // a reference to an identifier not imported by this library.
       return null;
     }
     LibraryElement containingLibrary = element.library;
     if (containingLibrary == null) {
       return null;
@@ skipping 1763 matching lines @@
           foundElement = MultiplyDefinedElementImpl.fromElements(_definingLibrary.context, foundElement, element);
         }
       }
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       foundElement = _removeSdkElements(identifier, name, foundElement as MultiplyDefinedElementImpl);
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       String foundEltName = foundElement.displayName;
       List<Element> conflictingMembers = (foundElement as MultiplyDefinedElementImpl).conflictingElements;
-      String libName1 = _getLibraryName(conflictingMembers[0], "");
-      String libName2 = _getLibraryName(conflictingMembers[1], "");
-      // TODO (jwren) Change the error message to include a list of all library names instead of
-      // just the first two
-      errorListener.onError(new AnalysisError.con2(getSource(identifier), identifier.offset, identifier.length, StaticWarningCode.AMBIGUOUS_IMPORT, [foundEltName, libName1, libName2]));
+      int count = conflictingMembers.length;
+      List<String> libraryNames = new List<String>(count);
+      for (int i = 0; i < count; i++) {
+        libraryNames[i] = _getLibraryName(conflictingMembers[i], "");
+      }
+      libraryNames.sort();
+      errorListener.onError(new AnalysisError.con2(getSource(identifier), identifier.offset, identifier.length, StaticWarningCode.AMBIGUOUS_IMPORT, [
+          foundEltName,
+          StringUtilities.printListOfQuotedNames(libraryNames)]));
       return foundElement;
     }
     if (foundElement != null) {
       defineNameWithoutChecking(name, foundElement);
     }
     return foundElement;
   }
 
   /**
    * Create all of the namespaces associated with the libraries imported into this library. The
@@ skipping 2613 matching lines @@
    */
   ClassElement _enclosingClass = null;
 
   /**
    * The class declaration representing the class containing the current node, or `null` if
    * the current node is not contained in a class.
    */
   ClassDeclaration _enclosingClassDeclaration = null;
 
   /**
+   * The function type alias representing the function type containing the current node, or
+   * `null` if the current node is not contained in a function type alias.
+   */
+  FunctionTypeAlias _enclosingFunctionTypeAlias = null;
+
+  /**
    * The element representing the function containing the current node, or `null` if the
    * current node is not contained in a function.
    */
   ExecutableElement _enclosingFunction = null;
 
   /**
    * The [Comment] before a [FunctionDeclaration] or a [MethodDeclaration] that
    * cannot be resolved where we visited it, because it should be resolved in the scope of the body.
    */
   Comment _commentBeforeFunction = null;
@@ skipping 75 matching lines @@
 
   /**
    * Return the object keeping track of which elements have had their types promoted.
    *
    * @return the object keeping track of which elements have had their types promoted
    */
   TypePromotionManager get promoteManager => _promoteManager;
 
   @override
   Object visitAnnotation(Annotation node) {
-    if (identical(node.parent, _enclosingClassDeclaration)) {
+    AstNode parent = node.parent;
+    if (identical(parent, _enclosingClassDeclaration) || identical(parent, _enclosingFunctionTypeAlias)) {
       return null;
     }
     return super.visitAnnotation(node);
   }
 
   @override
   Object visitAsExpression(AsExpression node) {
     super.visitAsExpression(node);
     overrideExpression(node.expression, node.type.type);
     return null;
@@ skipping 351 matching lines @@
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     safelyVisit(node.function);
     node.accept(_elementResolver);
     _inferFunctionExpressionsParametersTypes(node.argumentList);
     safelyVisit(node.argumentList);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   @override
+  Object visitFunctionTypeAlias(FunctionTypeAlias node) {
+    // Resolve the metadata in the library scope.
+    if (node.metadata != null) {
+      node.metadata.accept(this);
+    }
+    FunctionTypeAlias outerAlias = _enclosingFunctionTypeAlias;
+    _enclosingFunctionTypeAlias = node;
+    try {
+      super.visitFunctionTypeAlias(node);
+    } finally {
+      _enclosingFunctionTypeAlias = outerAlias;
+    }
+    return null;
+  }
+
+  @override
   Object visitHideCombinator(HideCombinator node) => null;
 
   @override
   Object visitIfStatement(IfStatement node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Map<Element, DartType> thenOverrides = null;
     Statement thenStatement = node.thenStatement;
     if (thenStatement != null) {
       _overrideManager.enterScope();
@@ skipping 2321 matching lines @@
       }
     }
     // Record static return type of the static element.
     DartType staticStaticType = _computeStaticReturnType(staticMethodElement);
     _recordStaticType(node, staticStaticType);
     // Record propagated return type of the static element.
     DartType staticPropagatedType = _computePropagatedReturnType(staticMethodElement);
     if (staticPropagatedType != null && (staticStaticType == null || staticPropagatedType.isMoreSpecificThan(staticStaticType))) {
       _recordPropagatedType(node, staticPropagatedType);
     }
+    bool needPropagatedType = true;
     String methodName = methodNameNode.name;
-    // Future.then(closure) return type is:
-    // 1) the returned Future type, if the closure returns a Future;
-    // 2) Future<valueType>, if the closure returns a value.
     if (methodName == "then") {
       Expression target = node.realTarget;
-      DartType targetType = target == null ? null : target.bestType;
-      if (_isAsyncFutureType(targetType)) {
-        NodeList<Expression> arguments = node.argumentList.arguments;
-        if (arguments.length == 1) {
-          // TODO(brianwilkerson) Handle the case where both arguments are provided.
-          Expression closureArg = arguments[0];
-          if (closureArg is FunctionExpression) {
-            FunctionExpression closureExpr = closureArg;
-            DartType returnType = _computePropagatedReturnType(closureExpr.element);
-            if (returnType != null) {
-              // prepare the type of the returned Future
-              InterfaceTypeImpl newFutureType;
-              if (_isAsyncFutureType(returnType)) {
-                newFutureType = returnType as InterfaceTypeImpl;
-              } else {
-                InterfaceType futureType = targetType as InterfaceType;
-                newFutureType = new InterfaceTypeImpl.con1(futureType.element);
-                newFutureType.typeArguments = <DartType> [returnType];
+      if (target != null) {
+        DartType targetType = target.bestType;
+        if (_isAsyncFutureType(targetType)) {
+          // Future.then(closure) return type is:
+          // 1) the returned Future type, if the closure returns a Future;
+          // 2) Future<valueType>, if the closure returns a value.
+          NodeList<Expression> arguments = node.argumentList.arguments;
+          if (arguments.length == 1) {
+            // TODO(brianwilkerson) Handle the case where both arguments are provided.
+            Expression closureArg = arguments[0];
+            if (closureArg is FunctionExpression) {
+              FunctionExpression closureExpr = closureArg;
+              DartType returnType = _computePropagatedReturnType(closureExpr.element);
+              if (returnType != null) {
+                // prepare the type of the returned Future
+                InterfaceTypeImpl newFutureType;
+                if (_isAsyncFutureType(returnType)) {
+                  newFutureType = returnType as InterfaceTypeImpl;
+                } else {
+                  InterfaceType futureType = targetType as InterfaceType;
+                  newFutureType = new InterfaceTypeImpl.con1(futureType.element);
+                  newFutureType.typeArguments = <DartType> [returnType];
+                }
+                // set the 'then' invocation type
+                _recordPropagatedType(node, newFutureType);
+                needPropagatedType = false;
+                return null;
               }
-              // set the 'then' invocation type
-              _recordPropagatedType(node, newFutureType);
-              return null;
             }
           }
         }
       }
-    }
-    if (methodName == "\$dom_createEvent") {
+    } else if (methodName == "\$dom_createEvent") {
       Expression target = node.realTarget;
       if (target != null) {
         DartType targetType = target.bestType;
         if (targetType is InterfaceType && (targetType.name == "HtmlDocument" || targetType.name == "Document")) {
           LibraryElement library = targetType.element.library;
           if (_isHtmlLibrary(library)) {
             DartType returnType = _getFirstArgumentAsType(library, node.argumentList);
             if (returnType != null) {
               _recordPropagatedType(node, returnType);
+              needPropagatedType = false;
             }
           }
         }
       }
     } else if (methodName == "query") {
       Expression target = node.realTarget;
       if (target == null) {
         Element methodElement = methodNameNode.bestElement;
         if (methodElement != null) {
           LibraryElement library = methodElement.library;
           if (_isHtmlLibrary(library)) {
             DartType returnType = _getFirstArgumentAsQuery(library, node.argumentList);
             if (returnType != null) {
               _recordPropagatedType(node, returnType);
+              needPropagatedType = false;
             }
           }
         }
       } else {
         DartType targetType = target.bestType;
         if (targetType is InterfaceType && (targetType.name == "HtmlDocument" || targetType.name == "Document")) {
           LibraryElement library = targetType.element.library;
           if (_isHtmlLibrary(library)) {
             DartType returnType = _getFirstArgumentAsQuery(library, node.argumentList);
             if (returnType != null) {
               _recordPropagatedType(node, returnType);
+              needPropagatedType = false;
             }
           }
         }
       }
     } else if (methodName == "\$dom_createElement") {
       Expression target = node.realTarget;
-      DartType targetType = target.bestType;
-      if (targetType is InterfaceType && (targetType.name == "HtmlDocument" || targetType.name == "Document")) {
-        LibraryElement library = targetType.element.library;
-        if (_isHtmlLibrary(library)) {
-          DartType returnType = _getFirstArgumentAsQuery(library, node.argumentList);
-          if (returnType != null) {
-            _recordPropagatedType(node, returnType);
+      if (target != null) {
+        DartType targetType = target.bestType;
+        if (targetType is InterfaceType && (targetType.name == "HtmlDocument" || targetType.name == "Document")) {
+          LibraryElement library = targetType.element.library;
+          if (_isHtmlLibrary(library)) {
+            DartType returnType = _getFirstArgumentAsQuery(library, node.argumentList);
+            if (returnType != null) {
+              _recordPropagatedType(node, returnType);
+              needPropagatedType = false;
+            }
           }
         }
       }
     } else if (methodName == "JS") {
       DartType returnType = _getFirstArgumentAsType(_typeProvider.objectType.element.library, node.argumentList);
       if (returnType != null) {
         _recordPropagatedType(node, returnType);
+        needPropagatedType = false;
       }
-    } else {
+    } else if (methodName == "getContext") {
+      Expression target = node.realTarget;
+      if (target != null) {
+        DartType targetType = target.bestType;
+        if (targetType is InterfaceType && (targetType.name == "CanvasElement")) {
+          NodeList<Expression> arguments = node.argumentList.arguments;
+          if (arguments.length == 1) {
+            Expression argument = arguments[0];
+            if (argument is StringLiteral) {
+              String value = argument.stringValue;
+              if ("2d" == value) {
+                PropertyAccessorElement getter = targetType.element.getGetter("context2D");
+                if (getter != null) {
+                  DartType returnType = getter.returnType;
+                  if (returnType != null) {
+                    _recordPropagatedType(node, returnType);
+                    needPropagatedType = false;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (needPropagatedType) {
       Element propagatedElement = methodNameNode.propagatedElement;
       if (!identical(propagatedElement, staticMethodElement)) {
         // Record static return type of the propagated element.
         DartType propagatedStaticType = _computeStaticReturnType(propagatedElement);
         if (propagatedStaticType != null && (staticStaticType == null || propagatedStaticType.isMoreSpecificThan(staticStaticType)) && (staticPropagatedType == null || propagatedStaticType.isMoreSpecificThan(staticPropagatedType))) {
           _recordPropagatedType(node, propagatedStaticType);
         }
         // Record propagated return type of the propagated element.
         DartType propagatedPropagatedType = _computePropagatedReturnType(propagatedElement);
         if (propagatedPropagatedType != null && (staticStaticType == null || propagatedPropagatedType.isMoreSpecificThan(staticStaticType)) && (staticPropagatedType == null || propagatedPropagatedType.isMoreSpecificThan(staticPropagatedType)) && (propagatedStaticType == null || propagatedPropagatedType.isMoreSpecificThan(propagatedStaticType))) {
@@ skipping 2935 matching lines @@
         parameterImpl.markPotentiallyMutatedInScope();
         // If we are in some closure, check if it is not the same as where variable is declared.
         if (_enclosingFunction != null && (element.enclosingElement != _enclosingFunction)) {
           parameterImpl.markPotentiallyMutatedInClosure();
         }
       }
     }
     return null;
   }
 }