MalformedType used for all invalid type annotations.

sdk/lib/_internal/compiler/implementation/elements/elements.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.
 
 library elements;
 
 import 'dart:uri';
 
 // TODO(ahe): Rename prefix to 'api' when VM bug is fixed.
 import '../../compiler.dart' as api_e;
@@ skipping 184 matching lines @@
   bool isLibrary() => identical(kind, ElementKind.LIBRARY);
   bool impliesType() => (kind.category & ElementCategory.IMPLIES_TYPE) != 0;
   bool isExtendable() => (kind.category & ElementCategory.IS_EXTENDABLE) != 0;
 
   /** See [ErroneousElement] for documentation. */
   bool isErroneous() => false;
 
   /** See [AmbiguousElement] for documentation. */
   bool isAmbiguous() => false;
 
-  bool isMalformed() => false;
-
   /**
    * Is [:true:] if this element has a corresponding patch.
    *
    * If [:true:] this element has a non-null [patch] field.
    *
    * See [:patch_parser.dart:] for a description of the terminology.
    */
   bool get isPatched => false;
 
   /**
@@ skipping 1122 matching lines @@
 class VoidElement extends Element {
   VoidElement(Element enclosing)
       : super(const SourceString('void'), ElementKind.VOID, enclosing);
   DartType computeType(compiler) => compiler.types.voidType;
   Node parseNode(_) {
     throw 'internal error: parseNode on void';
   }
   bool impliesType() => true;
 }
 
-class MalformedTypeElement extends Element {
-  final TypeAnnotation typeNode;
-
-  MalformedTypeElement(this.typeNode, Element enclosing)
-      : super(const SourceString('malformed'),
-              ElementKind.MALFORMED_TYPE,
-              enclosing);
-
-  DartType computeType(compiler) => compiler.types.malformedType;
-
-  Node parseNode(_) => typeNode;
-
-  bool impliesType() => true;
-
-  bool isMalformed() => true;
-}
-
 /**
  * [TypeDeclarationElement] defines the common interface for class/interface
  * declarations and typedefs.
  */
 abstract class TypeDeclarationElement implements Element {
   // TODO(johnniwinther): This class should eventually be a mixin.
 
   /**
    * The type variables declared on this declaration. The type variables are not
    * available until the type of the element has been computed through
@@ skipping 422 matching lines @@
     } else if (patch != null) {
       return 'origin ${super.toString()}';
     } else {
       return super.toString();
     }
   }
 }
 
 class Elements {
   static bool isUnresolved(Element e) {
-    return e == null || e.isErroneous() || e.isMalformed();
+    return e == null || e.isErroneous();
   }
   static bool isErroneousElement(Element e) => e != null && e.isErroneous();
-  static bool isMalformedElement(Element e) => e != null && e.isMalformed();
 
   static bool isClass(Element e) => e != null && e.kind == ElementKind.CLASS;
   static bool isTypedef(Element e) {
     return e != null && e.kind == ElementKind.TYPEDEF;
   }
 
   static bool isLocal(Element element) {
     return !Elements.isUnresolved(element)
             && !element.isInstanceMember()
             && !isStaticOrTopLevelField(element)
@@ skipping 325 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }