Introduce .isMalformed

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.
 
 library dart2js.resolution.members;
 
 import '../common.dart';
 import '../common/names.dart' show
     Selectors;
 import '../compiler.dart' show
@@ skipping 358 matching lines @@
         // objects than [Element] from this method.
         element = compiler.typeClass;
         // Set the type to be `dynamic` to mark that this is a type literal.
         registry.setType(node, const DynamicType());
       }
       element = reportLookupErrorIfAny(element, node, name);
       if (element == null) {
         if (!inInstanceContext) {
           element = reportCannotResolve(node, name);
         }
-      } else if (element.isErroneous) {
-        // Use the erroneous element.
+      } else if (element.isMalformed) {
+        // Use the malformed element.
       } else {
         if ((element.kind.category & allowedCategory) == 0) {
           element = reportAndCreateErroneousElement(
               node, name, MessageKind.GENERIC,
               // TODO(ahe): Improve error message. Need UX input.
               {'text': "is not an expression $element"});
         }
       }
       if (!Elements.isUnresolved(element) && element.isClass) {
         ClassElement classElement = element;
@@ skipping 426 matching lines @@
           MessageKind.NO_THIS_AVAILABLE, const {},
           isError: true);
       registry.registerCompileTimeError(error);
       return new StaticAccess.invalid(error);
     }
     return null;
   }
 
   /// Compute the [AccessSemantics] corresponding to a super access of [target].
   AccessSemantics computeSuperAccessSemantics(Spannable node, Element target) {
-    if (target.isErroneous) {
+    if (target.isMalformed) {
       return new StaticAccess.unresolvedSuper(target);
     } else if (target.isGetter) {
       return new StaticAccess.superGetter(target);
     } else if (target.isSetter) {
       return new StaticAccess.superSetter(target);
     } else if (target.isField) {
       if (target.isFinal) {
         return new StaticAccess.superFinalField(target);
       } else {
         return new StaticAccess.superField(target);
       }
     } else {
       assert(invariant(node, target.isFunction,
           message: "Unexpected super target '$target'."));
       return new StaticAccess.superMethod(target);
     }
   }
 
   /// Compute the [AccessSemantics] corresponding to a compound super access
   /// reading from [getter] and writing to [setter].
   AccessSemantics computeCompoundSuperAccessSemantics(
       Spannable node,
       Element getter,
       Element setter,
       {bool isIndex: false}) {
-    if (getter.isErroneous) {
-      if (setter.isErroneous) {
+    if (getter.isMalformed) {
+      if (setter.isMalformed) {
         return new StaticAccess.unresolvedSuper(getter);
       } else if (setter.isFunction) {
         assert(invariant(node, setter.name == '[]=',
             message: "Unexpected super setter '$setter'."));
         return new CompoundAccessSemantics(
                     CompoundAccessKind.UNRESOLVED_SUPER_GETTER, getter, setter);
       } else {
         assert(invariant(node, setter.isSetter,
             message: "Unexpected super setter '$setter'."));
         return new CompoundAccessSemantics(
             CompoundAccessKind.UNRESOLVED_SUPER_GETTER, getter, setter);
       }
     } else if (getter.isField) {
-      if (setter.isErroneous) {
+      if (setter.isMalformed) {
         assert(invariant(node, getter.isFinal,
             message: "Unexpected super setter '$setter' for getter '$getter."));
         return new StaticAccess.superFinalField(getter);
       } else if (setter.isField) {
         if (getter == setter) {
           return new StaticAccess.superField(getter);
         } else {
           return new CompoundAccessSemantics(
               CompoundAccessKind.SUPER_FIELD_FIELD, getter, setter);
         }
       } else {
         // Either the field is accessible directly, or a setter shadows the
         // setter access. If there was another instance member it would shadow
         // the field.
         assert(invariant(node, setter.isSetter,
             message: "Unexpected super setter '$setter'."));
         return new CompoundAccessSemantics(
             CompoundAccessKind.SUPER_FIELD_SETTER, getter, setter);
       }
     } else if (getter.isGetter) {
-      if (setter.isErroneous) {
+      if (setter.isMalformed) {
         return new CompoundAccessSemantics(
             CompoundAccessKind.UNRESOLVED_SUPER_SETTER, getter, setter);
       } else if (setter.isField) {
         return new CompoundAccessSemantics(
             CompoundAccessKind.SUPER_GETTER_FIELD, getter, setter);
       } else {
         assert(invariant(node, setter.isSetter,
             message: "Unexpected super setter '$setter'."));
         return new CompoundAccessSemantics(
             CompoundAccessKind.SUPER_GETTER_SETTER, getter, setter);
       }
     } else {
       assert(invariant(node, getter.isFunction,
           message: "Unexpected super getter '$getter'."));
-      if (setter.isErroneous) {
+      if (setter.isMalformed) {
         if (isIndex) {
           return new CompoundAccessSemantics(
               CompoundAccessKind.UNRESOLVED_SUPER_SETTER, getter, setter);
         } else {
           return new StaticAccess.superMethod(getter);
         }
       } else if (setter.isFunction) {
         assert(invariant(node, setter.name == '[]=',
             message: "Unexpected super setter '$setter'."));
         assert(invariant(node, getter.name == '[]',
@@ skipping 31 matching lines @@
     }
   }
 
   /// Compute the [AccessSemantics] corresponding to a static or toplevel access
   /// of [target].
   AccessSemantics computeStaticOrTopLevelAccessSemantics(
       Spannable node,
       Element target) {
 
     target = target.declaration;
-    if (target.isErroneous) {
+    if (target.isMalformed) {
       // This handles elements with parser errors.
-      // TODO(johnniwinther): Elements with parse error should not set
-      // [isErroneous] to `true`.
       return new StaticAccess.unresolved(target);
     }
     if (target.isStatic) {
       if (target.isGetter) {
         return new StaticAccess.staticGetter(target);
       } else if (target.isSetter) {
         return new StaticAccess.staticSetter(target);
       } else if (target.isField) {
         if (target.isFinal || target.isConst) {
           return new StaticAccess.finalStaticField(target);
@@ skipping 1914 matching lines @@
             ? new StaticAccess.topLevelSetter(abstractField.setter)
             : new StaticAccess.staticSetter(abstractField.setter);
         registry.registerStaticUse(abstractField.setter);
       }
     } else {
       MemberElement member = element;
       // TODO(johnniwinther): Needed to provoke a parsing and with it discovery
       // of parse errors to make [element] erroneous. Fix this!
       member.computeType(resolution);
       registry.registerStaticUse(member);
-      if (member.isErroneous) {
+      if (member.isMalformed) {
         // [member] has parse errors.
         semantics = new StaticAccess.unresolved(member);
       } else if (member.isFunction) {
         // `a = b`, `a++` or `a += b` where `a` is a function.
         ErroneousElement error = reportAndCreateErroneousElement(
             node.selector, name.text,
             MessageKind.ASSIGNING_METHOD, const {});
         registry.registerThrowNoSuchMethod();
         if (node.isComplex) {
           // `a++` or `a += b` where `a` is a function.
@@ skipping 22 matching lines @@
       }
     }
     return handleUpdate(node, name, semantics);
   }
 
   /// Handle access to resolved [element].
   ResolutionResult handleResolvedSend(Send node, Name name, Element element) {
     if (element.isAmbiguous) {
       return handleAmbiguousSend(node, name, element);
     }
-    if (element.isErroneous) {
+    if (element.isMalformed) {
       // This handles elements with parser errors.
-      // TODO(johnniwinther): Elements with parse error should not set
-      // [isErroneous] to `true`.
       assert(invariant(node, element is! ErroneousElement,
           message: "Unexpected erroneous element $element."));
       return handleErroneousAccess(node, name,
           new StaticAccess.unresolved(element));
     }
     if (element.isInstanceMember) {
       if (inInstanceContext) {
         // TODO(johnniwinther): Maybe use the found [element].
         return handleThisPropertyAccess(node, name);
       } else {
@@ skipping 18 matching lines @@
     }
     return reporter.internalError(node, "Unexpected resolved send: $element");
   }
 
   /// Handle update to resolved [element].
   ResolutionResult handleResolvedSendSet(
       SendSet node, Name name, Element element) {
     if (element.isAmbiguous) {
       return handleAmbiguousUpdate(node, name, element);
     }
-    if (element.isErroneous) {
-      // This handles elements with parser errors.
-      // TODO(johnniwinther): Elements with parse error should not set
-      // [isErroneous] to `true`.
+    if (element.isMalformed) {
+      // This handles elements with parser errors..
       assert(invariant(node, element is! ErroneousElement,
           message: "Unexpected erroneous element $element."));
       return handleUpdate(node, name,new StaticAccess.unresolved(element));
     }
     if (element.isInstanceMember) {
       if (inInstanceContext) {
         return handleThisPropertyUpdate(node, name, element);
       } else {
         return handleUpdate(node, name, reportStaticInstanceAccess(node, name));
       }
@@ skipping 1689 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(DiagnosticReporter reporter, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }