Remove Compiler.reportFatalError.

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 1314 matching lines @@
       // TODO(johnniwinther): Register the relation between the annotation
       // and the annotated element instead. This will allow the backend to
       // retrieve the backend constant and only register metadata on the
       // elements for which it is needed. (Issue 17732).
       registry.registerMetadataConstant(annotation, annotatedElement);
       annotation.resolutionState = STATE_DONE;
     }));
   }
 
   error(Spannable node, MessageKind kind, [arguments = const {}]) {
-    // TODO(ahe): Make non-fatal.
-    compiler.reportFatalError(node, kind, arguments);
+    compiler.reportError(node, kind, arguments);
   }
 
   Link<MetadataAnnotation> resolveMetadata(Element element,
                                            VariableDefinitions node) {
     LinkBuilder<MetadataAnnotation> metadata =
         new LinkBuilder<MetadataAnnotation>();
     for (Metadata annotation in node.metadata.nodes) {
       ParameterMetadataAnnotation metadataAnnotation =
           new ParameterMetadataAnnotation(annotation);
       metadataAnnotation.annotatedElement = element;
@@ skipping 59 matching lines @@
     final Node selector = init.selector;
     final String name = selector.asIdentifier().source;
     // Lookup target field.
     Element target;
     if (isFieldInitializer(init)) {
       target = constructor.enclosingClass.lookupLocalMember(name);
       if (target == null) {
         error(selector, MessageKind.CANNOT_RESOLVE, {'name': name});
       } else if (target.kind != ElementKind.FIELD) {
         error(selector, MessageKind.NOT_A_FIELD, {'fieldName': name});
+        // TODO(ahe): Don't throw, recover from error.
+        throw new CompilerCancelledException(null);
       } else if (!target.isInstanceMember) {
         error(selector, MessageKind.INIT_STATIC_FIELD, {'fieldName': name});
       }
     } else {
       error(init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
     }
     registry.useElement(init, target);
     registry.registerStaticUse(target);
     checkForDuplicateInitializers(target, init);
     // Resolve initializing value.
@@ skipping 206 matching lines @@
         'internal error: Unhandled node: ${node.getObjectDescription()}');
     return null;
   }
 
   R visitEmptyStatement(Node node) => null;
 
   /** Convenience method for visiting nodes that may be null. */
   R visit(Node node) => (node == null) ? null : node.accept(this);
 
   void error(Spannable node, MessageKind kind, [Map arguments = const {}]) {
-    compiler.reportFatalError(node, kind, arguments);
+    compiler.reportError(node, kind, arguments);
   }
 
   void warning(Spannable node, MessageKind kind, [Map arguments = const {}]) {
     compiler.reportWarning(node, kind, arguments);
   }
 
   void internalError(Spannable node, message) {
     compiler.internalError(node, message);
   }
 
@@ skipping 577 matching lines @@
                                                  MessageKind kind,
                                                  [Map arguments = const {}]) {
     compiler.reportWarning(node, kind, arguments);
     return new ErroneousElementX(kind, arguments, name, enclosingElement);
   }
 
   ResolutionResult visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) {
         error(node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': node});
+        // TODO(ahe): Don't throw, recover from error.
+        throw new CompilerCancelledException(null);
       }
       return null;
     } else if (node.isSuper()) {
-      if (!inInstanceContext) error(node, MessageKind.NO_SUPER_IN_STATIC);
+      if (!inInstanceContext) {
+        error(node, MessageKind.NO_SUPER_IN_STATIC);
+        // TODO(ahe): Don't throw, recover from error.
+        throw new CompilerCancelledException(null);
+      }
       if ((ElementCategory.SUPER & allowedCategory) == 0) {
         error(node, MessageKind.INVALID_USE_OF_SUPER);
       }
       return null;
     } else {
       String name = node.source;
       Element element = lookupInScope(compiler, node, scope, name);
       if (Elements.isUnresolved(element) && name == 'dynamic') {
         // TODO(johnniwinther): Remove this hack when we can return more complex
         // 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, node.source);
       if (element == null) {
         if (!inInstanceContext) {
           element = warnAndCreateErroneousElement(
               node, node.source, MessageKind.CANNOT_RESOLVE,
               {'name': node});
           registry.registerThrowNoSuchMethod();
         }
       } else if (element.isErroneous) {
         // Use the erroneous element.
       } else {
         if ((element.kind.category & allowedCategory) == 0) {
           // TODO(ahe): Improve error message. Need UX input.
           error(node, MessageKind.GENERIC,
                 {'text': "is not an expression $element"});
+        // TODO(ahe): Don't throw, recover from error.
+          throw new CompilerCancelledException(null);
         }
       }
       if (!Elements.isUnresolved(element) && element.isClass) {
         ClassElement classElement = element;
         classElement.ensureResolved(compiler);
       }
       return new ElementResult(registry.useElement(node, element));
     }
   }
 
@@ skipping 236 matching lines @@
     allowedCategory |= ElementCategory.PREFIX | ElementCategory.SUPER;
     ResolutionResult resolvedReceiver = visit(node.receiver);
     allowedCategory = oldCategory;
 
     Element target;
     String name = node.selector.asIdentifier().source;
     if (identical(name, 'this')) {
       // TODO(ahe): Why is this using GENERIC?
       error(node.selector, MessageKind.GENERIC,
             {'text': "expected an identifier"});
+      return null;
     } else if (node.isSuperCall) {
       if (node.isOperator) {
         if (isUserDefinableOperator(name)) {
           name = selector.name;
         } else {
           error(node.selector, MessageKind.ILLEGAL_SUPER_SEND, {'name': name});
+          return null;
         }
       }
       if (!inInstanceContext) {
         error(node.receiver, MessageKind.NO_INSTANCE_AVAILABLE, {'name': name});
         return null;
       }
       if (currentClass.supertype == null) {
         // This is just to guard against internal errors, so no need
         // for a real error message.
         error(node.receiver, MessageKind.GENERIC,
               {'text': "Object has no superclass"});
+        return null;
       }
       // TODO(johnniwinther): Ensure correct behavior if currentClass is a
       // patch.
       target = currentClass.lookupSuperSelector(selector);
       // [target] may be null which means invoking noSuchMethod on
       // super.
       if (target == null) {
         target = warnAndCreateErroneousElement(
             node, name, MessageKind.NO_SUCH_SUPER_MEMBER,
             {'className': currentClass, 'memberName': name});
@@ skipping 779 matching lines @@
                              {'type': keyType});
       }
     }
   }
 
   void analyzeConstant(Node node) {
     ConstantExpression constant =
         compiler.resolver.constantCompiler.compileNode(
             node, registry.mapping);
 
+    if (constant == null) {
+      assert(invariant(node, compiler.compilationFailed));
+      return;
+    }
+
     ConstantValue value = constant.value;
     if (value.isMap) {
       checkConstMapKeysDontOverrideEquals(node, value);
     }
 
     // The type constant that is an argument to JS_INTERCEPTOR_CONSTANT names
     // a class that will be instantiated outside the program by attaching a
     // native class dispatch record referencing the interceptor.
     if (argumentsToJsInterceptorConstant != null &&
         argumentsToJsInterceptorConstant.contains(node)) {
@@ skipping 1548 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});
     } else if (element.isTypeVariable) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
             {'typeVariableName': name});
+      // TODO(ahe): Don't throw, recover from error.
+      throw new CompilerCancelledException(null);
     } else if (!element.isClass && !element.isPrefix) {
       error(node, MessageKind.NOT_A_TYPE, {'node': name});
+      // TODO(ahe): Don't throw, recover from error.
+      throw new CompilerCancelledException(null);
     }
     return element;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     Node constructorReference = node.constructorReference;
     return finishConstructorReference(visit(constructorReference),
         constructorReference, node);
   }
@@ skipping 62 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }