Support async getters.

pkg/compiler/lib/src/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   AnalyzableElement get analyzedElement;
   Iterable<Node> get superUses;
 
@@ skipping 4782 matching lines @@
   ConstructorResolver(Compiler compiler, this.resolver,
                       {bool this.inConstContext: false})
       : super(compiler);
 
   ResolutionRegistry get registry => resolver.registry;
 
   visitNode(Node node) {
     throw 'not supported';
   }
 
-  failOrReturnErroneousElement(Element enclosing, Node diagnosticNode,
-                               String targetName, MessageKind kind,
-                               Map arguments) {
+  failOrReturnErroneousConstructorElement(
+      Element enclosing, Node diagnosticNode,
+      String targetName, MessageKind kind,
+      Map arguments) {
     if (kind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
       registry.registerThrowNoSuchMethod();
     } else {
       registry.registerThrowRuntimeError();
     }
     if (inConstContext) {
       compiler.reportError(diagnosticNode, kind, arguments);
     } else {
       compiler.reportWarning(diagnosticNode, kind, arguments);
     }
-    return new ErroneousElementX(kind, arguments, targetName, enclosing);
+    return new ErroneousConstructorElementX(
+        kind, arguments, targetName, enclosing);
   }
 
   FunctionElement resolveConstructor(ClassElement cls,
                                      Node diagnosticNode,
                                      String constructorName) {
     cls.ensureResolved(compiler);
     Element result = cls.lookupConstructor(constructorName);
     if (result == null) {
       String fullConstructorName = Elements.constructorNameForDiagnostics(
               cls.name,
               constructorName);
-      return failOrReturnErroneousElement(
+      return failOrReturnErroneousConstructorElement(
           cls,
           diagnosticNode,
           fullConstructorName,
           MessageKind.CANNOT_FIND_CONSTRUCTOR,
           {'constructorName': fullConstructorName});
     } else if (inConstContext && !result.isConst) {
       error(diagnosticNode, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
     }
     return result;
   }
@@ skipping 16 matching lines @@
         message: 'No element return for $diagnosticNode.'));
     // Find the unnamed constructor if the reference resolved to a
     // class.
     if (!Elements.isUnresolved(element) && !element.isConstructor) {
       if (element.isClass) {
         ClassElement cls = element;
         cls.ensureResolved(compiler);
         // The unnamed constructor may not exist, so [e] may become unresolved.
         element = resolveConstructor(cls, diagnosticNode, '');
       } else {
-        element = failOrReturnErroneousElement(
+        element = failOrReturnErroneousConstructorElement(
             element, diagnosticNode, element.name, MessageKind.NOT_A_TYPE,
             {'node': diagnosticNode});
       }
     } else if (element.isErroneous && element is! ErroneousElementX) {
       element = new ErroneousConstructorElementX(
           MessageKind.NOT_A_TYPE, {'node': diagnosticNode},
           element.name, element);
       registry.registerThrowRuntimeError();
     }
 
@@ skipping 29 matching lines @@
 
     if (element.isClass) {
       ClassElement cls = element;
       cls.ensureResolved(compiler);
       return resolveConstructor(cls, name, name.source);
     } else if (element.isPrefix) {
       PrefixElement prefix = element;
       element = prefix.lookupLocalMember(name.source);
       element = Elements.unwrap(element, compiler, node);
       if (element == null) {
-        return failOrReturnErroneousElement(
+        return failOrReturnErroneousConstructorElement(
             resolver.enclosingElement, name,
             name.source,
             MessageKind.CANNOT_RESOLVE,
             {'name': name});
       } else if (!element.isClass) {
         error(node, MessageKind.NOT_A_TYPE, {'node': name});
       }
     } else {
       internalError(node.receiver, 'unexpected element $element');
     }
     return element;
   }
 
   Element visitIdentifier(Identifier node) {
     String name = node.source;
     Element element = resolver.reportLookupErrorIfAny(
         lookupInScope(compiler, node, resolver.scope, name), node, name);
     registry.useElement(node, element);
     // TODO(johnniwinther): Change errors to warnings, cf. 11.11.1.
     if (element == null) {
-      return failOrReturnErroneousElement(resolver.enclosingElement, node, name,
-                                          MessageKind.CANNOT_RESOLVE,
-                                          {'name': name});
+      return failOrReturnErroneousConstructorElement(
+          resolver.enclosingElement, node, name,
+          MessageKind.CANNOT_RESOLVE,
+          {'name': name});
     } else if (element.isErroneous) {
       return element;
     } else if (element.isTypedef) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF,
             {'typedefName': name});
       element = new ErroneousConstructorElementX(
           MessageKind.CANNOT_INSTANTIATE_TYPEDEF,
           {'typedefName': name}, name, resolver.enclosingElement);
       registry.registerThrowRuntimeError();
     } else if (element.isTypeVariable) {
@@ skipping 84 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }