Register throwRuntimeError when creating an ErroneousConstructorElementX

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 1837 matching lines @@
                                         Map messageArguments,
                                         {DartType userProvidedBadType,
                                          Element erroneousElement}) {
       if (malformedIsError) {
         visitor.error(node, messageKind, messageArguments);
       } else {
         registry.registerThrowRuntimeError();
         visitor.warning(node, messageKind, messageArguments);
       }
       if (erroneousElement == null) {
-         erroneousElement = new ErroneousElementX(
+        registry.registerThrowRuntimeError();
+        erroneousElement = new ErroneousElementX(
             messageKind, messageArguments, typeName.source,
             visitor.enclosingElement);
       }
       List<DartType> arguments = <DartType>[];
       resolveTypeArguments(visitor, node, const <DartType>[], arguments);
       return new MalformedType(erroneousElement,
               userProvidedBadType, arguments);
     }
 
     // Try to construct the type from the element.
@@ skipping 3003 matching lines @@
         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);
+      registry.registerThrowRuntimeError();
     }
 
     if (type == null) {
       if (Elements.isUnresolved(element)) {
         type = const DynamicType();
       } else {
         type = element.enclosingClass.rawType;
       }
     }
     resolver.registry.setType(expression, type);
@@ skipping 53 matching lines @@
                                           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) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
             {'typeVariableName': name});
       element = new ErroneousConstructorElementX(
           MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
           {'typeVariableName': name}, name, resolver.enclosingElement);
+      registry.registerThrowRuntimeError();
     } else if (!element.isClass && !element.isPrefix) {
       error(node, MessageKind.NOT_A_TYPE, {'node': name});
       element = new ErroneousConstructorElementX(
           MessageKind.NOT_A_TYPE, {'node': name}, name,
           resolver.enclosingElement);
+      registry.registerThrowRuntimeError();
     }
     return element;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     Node constructorReference = node.constructorReference;
     return finishConstructorReference(visit(constructorReference),
         constructorReference, node);
   }
@@ skipping 63 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }