Introduce .isMalformed

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

 // Copyright (c) 2015, 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 dart2js.resolution.constructors;
 
 import '../common.dart';
 import '../compiler.dart' show
     Compiler;
 import '../constants/constructors.dart' show
@@ skipping 528 matching lines @@
       return result;
     }
 
     // Find the unnamed constructor if the reference resolved to a
     // class.
     if (result.type != null) {
       // The unnamed constructor may not exist, so [e] may become unresolved.
       result = resolveConstructor(result.type, diagnosticNode, '');
     } else {
       Element element = result.element;
-      if (element.isErroneous) {
+      if (element.isMalformed) {
         result = constructorResultForErroneous(diagnosticNode, element);
       } else {
         result = reportAndCreateErroneousConstructorElement(
             diagnosticNode,
             ConstructorResultKind.INVALID_TYPE, null,
             element, element.name,
             MessageKind.NOT_A_TYPE, {'node': diagnosticNode});
       }
     }
     resolver.registry.setType(expression, result.type);
     return result;
   }
 
   ConstructorResult visitTypeAnnotation(TypeAnnotation node) {
     // This is not really resolving a type-annotation, but the name of the
     // constructor. Therefore we allow deferred types.
     DartType type = resolver.resolveTypeAnnotation(
         node,
         malformedIsError: inConstContext,
         deferredIsMalformed: false);
     registry.registerRequiredType(type, resolver.enclosingElement);
     return constructorResultForType(node, type);
   }
 
   ConstructorResult visitSend(Send node) {
     ConstructorResult receiver = visit(node.receiver);
     assert(invariant(node.receiver, receiver != null,
         message: 'No result returned for $node.receiver.'));
     if (receiver.kind != null) {
-      assert(invariant(node, receiver.element.isErroneous,
+      assert(invariant(node, receiver.element.isMalformed,
           message: "Unexpected prefix result: $receiver."));
       // We have already found an error.
       return receiver;
     }
 
     Identifier name = node.selector.asIdentifier();
     if (name == null) {
       reporter.internalError(node.selector, 'unexpected node');
     }
 
@@ skipping 37 matching lines @@
   ConstructorResult constructorResultForElement(
       Node node, String name, Element element) {
     element = Elements.unwrap(element, reporter, node);
     if (element == null) {
       return reportAndCreateErroneousConstructorElement(
           node,
           ConstructorResultKind.INVALID_TYPE, null,
           resolver.enclosingElement, name,
           MessageKind.CANNOT_RESOLVE,
           {'name': name});
-    } else if (element.isErroneous) {
+    } else if (element.isMalformed) {
       return constructorResultForErroneous(node, element);
     } else if (element.isClass) {
       ClassElement cls = element;
       cls.computeType(resolution);
       return constructorResultForType(node, cls.rawType);
     } else if (element.isPrefix) {
       return new ConstructorResult.forElement(element);
     } else if (element.isTypedef) {
       TypedefElement typdef = element;
       typdef.ensureResolved(resolution);
@@ skipping 106 matching lines @@
     // constructors.
     return null;
   }
   // TODO(johnniwinther): Use [Name] for lookup.
   ConstructorElement constructor = cls.lookupConstructor(constructorName);
   if (constructor != null) {
     constructor = constructor.declaration;
   }
   return constructor;
 }