Recover from crash in xcodebuild/ReleaseIA32/generated_tests/language/async_test_constructor4.dart.

dart/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 602 matching lines @@
           // Ensure the signature of the synthesized element is
           // resolved. This is the only place where the resolver is
           // seeing this element.
           element.computeSignature(compiler);
           if (!target.isErroneous) {
             registry.registerStaticUse(target);
             registry.registerImplicitSuperCall(target);
           }
           return registry.mapping;
         } else {
-          assert(element.isDeferredLoaderGetter);
+          assert(element.isDeferredLoaderGetter || element.isErroneous);
           return _ensureTreeElements(element);
         }
       } else {
         element.parseNode(compiler);
         element.computeType(compiler);
         processAsyncMarker(compiler, element);
         FunctionElementX implementation = element;
         if (element.isExternal) {
           implementation = compiler.backend.resolveExternalFunction(element);
         }
@@ skipping 130 matching lines @@
 
       // [factory] must already be analyzed but the [TreeElements] might not
       // have been stored in the enqueuer cache yet.
       // TODO(johnniwinther): Store [TreeElements] in the cache before
       // resolution of the element.
       TreeElements treeElements = factory.treeElements;
       assert(invariant(node, treeElements != null,
           message: 'No TreeElements cached for $factory.'));
       FunctionExpression functionNode = factory.parseNode(compiler);
       RedirectingFactoryBody redirectionNode = functionNode.body;
-      InterfaceType factoryType = treeElements.getType(redirectionNode);
-
-      targetType = targetType.substByContext(factoryType);
+      DartType factoryType = treeElements.getType(redirectionNode);
+      if (!factoryType.isDynamic) {
+        targetType = targetType.substByContext(factoryType);
+      }
       factory.effectiveTarget = target;
       factory.effectiveTargetType = targetType;
     }
   }
 
   /**
    * Load and resolve the supertypes of [cls].
    *
    * Warning: do not call this method directly. It should only be
    * called by [resolveClass] and [ClassSupertypeResolver].
@@ skipping 4066 matching lines @@
       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, 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);
     }
+
     if (type == null) {
       if (Elements.isUnresolved(element)) {
         type = const DynamicType();
       } else {
         type = element.enclosingClass.rawType;
       }
     }
     resolver.registry.setType(expression, type);
     return element;
   }
@@ skipping 81 matching lines @@
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }
 
 TreeElements _ensureTreeElements(AnalyzableElementX element) {
+  if (element.isErroneous) return new TreeElementMapping(element);
   if (element._treeElements == null) {
     element._treeElements = new TreeElementMapping(element);
   }
   return element._treeElements;
 }
 
 abstract class AnalyzableElementX implements AnalyzableElement {
   TreeElements _treeElements;
 
   bool get hasTreeElements => _treeElements != null;
@@ skipping 43 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }