Don’t exit prematurely if compilation failed.

dart/pkg/compiler/lib/src/ssa/builder.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 ssa;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 1200 matching lines @@
                        Selector selector,
                        List<HInstruction> providedArguments,
                        ast.Node currentNode) {
     // TODO(johnniwinther): Register this on the [registry]. Currently the
     // [CodegenRegistry] calls the enqueuer, but [element] should _not_ be
     // enqueued.
     backend.registerStaticUse(element, compiler.enqueuer.codegen);
 
     // Ensure that [element] is an implementation element.
     element = element.implementation;
+
+    if (compiler.elementHasCompileTimeError(element)) return false;
+
     FunctionElement function = element;
     bool insideLoop = loopNesting > 0 || graph.calledInLoop;
 
     // Bail out early if the inlining decision is in the cache and we can't
     // inline (no need to check the hard constraints).
     bool cachedCanBeInlined =
         backend.inlineCache.canInline(function, insideLoop: insideLoop);
     if (cachedCanBeInlined == false) return false;
 
     bool meetsHardConstraints() {
@@ skipping 602 matching lines @@
 
       Element target = constructor.definingConstructor.implementation;
       bool match = Selector.addForwardingElementArgumentsToList(
           constructor,
           arguments,
           target,
           compileArgument,
           handleConstantForOptionalParameter,
           compiler.world);
       if (!match) {
+        if (compiler.elementHasCompileTimeError(constructor)) {
+          return;
+        }
         // If this fails, the selector we constructed for the call to a
         // forwarding constructor in a mixin application did not match the
         // constructor (which, for example, may happen when the libraries are
         // not compatible for private names, see issue 20394).
         compiler.internalError(constructor,
                                'forwarding constructor call does not match');
       }
       inlineSuperOrRedirect(
           target,
           arguments,
@@ skipping 75 matching lines @@
    * Run through the fields of [cls] and add their potential
    * initializers.
    *
    * Invariant: [classElement] must be an implementation element.
    */
   void buildFieldInitializers(ClassElement classElement,
                               Map<Element, HInstruction> fieldValues) {
     assert(invariant(classElement, classElement.isImplementation));
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, VariableElement member) {
+          if (compiler.elementHasCompileTimeError(member)) return;
           compiler.withCurrentElement(member, () {
             TreeElements definitions = member.treeElements;
             ast.Node node = member.node;
             ast.Expression initializer = member.initializer;
             if (initializer == null) {
               // Unassigned fields of native classes are not initialized to
               // prevent overwriting pre-initialized native properties.
               if (!Elements.isNativeOrExtendsNative(classElement)) {
                 fieldValues[member] = graph.addConstantNull(compiler);
               }
@@ skipping 1254 matching lines @@
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceGetterWithCompiledReceiver(
           send, elements.getSelector(send), receiver);
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
       // TODO(5346): Try to avoid the need for calling [declaration] before
       // creating an [HStatic].
       push(new HStatic(element.declaration, backend.nonNullType));
       // TODO(ahe): This should be registered in codegen.
       registry.registerGetOfStaticFunction(element.declaration);
     } else if (Elements.isErroneousElement(element)) {
-      // An erroneous element indicates an unresolved static getter.
-      generateThrowNoSuchMethod(send,
-                                noSuchMethodTargetSymbolString(element, 'get'),
-                                argumentNodes: const Link<ast.Node>());
+      if (element is ErroneousElement) {
+        // An erroneous element indicates an unresolved static getter.
+        generateThrowNoSuchMethod(
+            send,
+            noSuchMethodTargetSymbolString(element, 'get'),
+            argumentNodes: const Link<ast.Node>());
+      } else {
+        // TODO(ahe): Do something like the above, that is, emit a runtime
+        // error.
+        stack.add(graph.addConstantNull(compiler));
+      }
     } else {
       LocalElement local = element;
       stack.add(localsHandler.readLocal(local));
     }
   }
 
   void generateInstanceSetterWithCompiledReceiver(ast.Send send,
                                                   HInstruction receiver,
                                                   HInstruction value,
                                                   {Selector selector,
@@ skipping 1054 matching lines @@
       assert(invariant(send, selector != null,
                        message: 'Constructor Symbol.validated is missing'));
     }
 
     bool isRedirected = constructorDeclaration.isRedirectingFactory;
     InterfaceType type = elements.getType(node);
     InterfaceType expectedType =
         constructorDeclaration.computeEffectiveTargetType(type);
     expectedType = localsHandler.substInContext(expectedType);
 
+    if (compiler.elementHasCompileTimeError(constructor)) {
+      // TODO(ahe): Do something like [generateWrongArgumentCountError].
+      stack.add(graph.addConstantNull(compiler));
+      return;
+    }
     if (checkTypeVariableBounds(node, type)) return;
 
     var inputs = <HInstruction>[];
     if (constructor.isGenerativeConstructor &&
         Elements.isNativeOrExtendsNative(constructor.enclosingClass)) {
       // Native class generative constructors take a pre-constructed object.
       inputs.add(graph.addConstantNull(compiler));
     }
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [makeStaticArgumentList].
@@ skipping 347 matching lines @@
   }
 
   visitNewExpression(ast.NewExpression node) {
     Element element = elements[node.send];
     final bool isSymbolConstructor = element == compiler.symbolConstructor;
     if (!Elements.isErroneousElement(element)) {
       ConstructorElement function = element;
       element = function.effectiveTarget;
     }
     if (Elements.isErroneousElement(element)) {
+      if (element is !ErroneousElement) {
+        // TODO(ahe): Do something like [generateWrongArgumentCountError].
+        stack.add(graph.addConstantNull(compiler));
+        return;
+      }
       ErroneousElement error = element;
       if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
         generateThrowNoSuchMethod(
             node.send,
             noSuchMethodTargetSymbolString(error, 'constructor'),
             argumentNodes: node.send.arguments);
       } else {
         Message message = error.messageKind.message(error.messageArguments);
         generateRuntimeError(node.send, message.toString());
       }
@@ skipping 1968 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }