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

dart/pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, 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.
 
 library elements.modelx;
 
 import 'elements.dart';
 import '../constants/expressions.dart';
 import '../helpers/helpers.dart';  // Included for debug helpers.
 import '../tree/tree.dart';
@@ skipping 311 matching lines @@
   FunctionElement asFunctionElement() => this;
 
   String get message => '${messageKind.message(messageArguments)}';
 
   String toString() => '<$name: $message>';
 
   accept(ElementVisitor visitor) => visitor.visitErroneousElement(this);
 }
 
 /// A constructor that was synthesized to recover from a compile-time error.
-class ErroneousConstructorElementX extends ErroneousElementX {
+class ErroneousConstructorElementX extends ErroneousElementX
+    with PatchMixin<FunctionElement>
+    implements ConstructorElementX {
   // TODO(ahe): Instead of subclassing [ErroneousElementX], this class should
   // be more like [ErroneousFieldElementX]. In particular, its kind should be
   // [ElementKind.GENERATIVE_CONSTRUCTOR], and it shouldn't throw as much.
 
   ErroneousConstructorElementX(
       MessageKind messageKind,
       Map messageArguments,
       String name,
       Element enclosing)
       : super(messageKind, messageArguments, name, enclosing);
+
+  bool get isRedirectingFactory => false;
+
+  get definingElement {
+    throw new UnsupportedError("definingElement");
+  }
+
+  get asyncMarker {
+    throw new UnsupportedError("asyncMarker");
+  }
+
+  set asyncMarker(_) {
+    throw new UnsupportedError("asyncMarker=");
+  }
+
+  get internalEffectiveTarget {
+    throw new UnsupportedError("internalEffectiveTarget");
+  }
+
+  set internalEffectiveTarget(_) {
+    throw new UnsupportedError("internalEffectiveTarget=");
+  }
+
+  get effectiveTargetType {
+    throw new UnsupportedError("effectiveTargetType");
+  }
+
+  set effectiveTargetType(_) {
+    throw new UnsupportedError("effectiveTargetType=");
+  }
+
+  get typeCache {
+    throw new UnsupportedError("typeCache");
+  }
+
+  set typeCache(_) {
+    throw new UnsupportedError("typeCache=");
+  }
+
+  get immediateRedirectionTarget {
+    throw new UnsupportedError("immediateRedirectionTarget");
+  }
+
+  set immediateRedirectionTarget(_) {
+    throw new UnsupportedError("immediateRedirectionTarget=");
+  }
+
+  get functionSignatureCache {
+    throw new UnsupportedError("functionSignatureCache");
+  }
+
+  set functionSignatureCache(_) {
+    throw new UnsupportedError("functionSignatureCache=");
+  }
+
+  get nestedClosures {
+    throw new UnsupportedError("nestedClosures");
+  }
+
+  set nestedClosures(_) {
+    throw new UnsupportedError("nestedClosures=");
+  }
+
+  bool get hasNoBody => false;
+
+  bool get _hasNoBody => false;
+
+  void set effectiveTarget(_) {
+    throw new UnsupportedError("effectiveTarget=");
+  }
 }
 
 /// A message attached to a [WarnOnUseElementX].
 class WrappedMessage {
   /// The message position. If [:null:] the position of the reference to the
   /// [WarnOnUseElementX] is used.
   final Spannable spannable;
 
   /**
    * The message to report on resolving a wrapped element.
@@ skipping 2615 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }