Don’t exit prematurely if compilation failed.

dart/pkg/compiler/lib/src/compiler.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 dart2js;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 811 matching lines @@
 
   /// Document class from dart:mirrors.
   ClassElement documentClass;
   Element identicalFunction;
   Element loadLibraryFunction;
   Element functionApplyMethod;
   Element intEnvironment;
   Element boolEnvironment;
   Element stringEnvironment;
 
+  /// Tracks elements with compile-time errors.
+  final Set<Element> elementsWithCompileTimeErrors = new Set<Element>();
+
   fromEnvironment(String name) => null;
 
   Element get currentElement => _currentElement;
 
   String tryToString(object) {
     try {
       return object.toString();
     } catch (_) {
       return '<exception in toString()>';
     }
@@ skipping 97 matching lines @@
   bool get shouldPrintProgress {
     return verbose && progress.elapsedMilliseconds > 500;
   }
 
   static const int PHASE_SCANNING = 0;
   static const int PHASE_RESOLVING = 1;
   static const int PHASE_DONE_RESOLVING = 2;
   static const int PHASE_COMPILING = 3;
   int phase;
 
-  bool compilationFailed = false;
+  bool compilationFailedInternal = false;
+
+  bool get compilationFailed => compilationFailedInternal;
+
+  void set compilationFailed(bool value) {
+    if (value) {
+      elementsWithCompileTimeErrors.add(currentElement);
+    }
+    compilationFailedInternal = value;
+  }
 
   bool hasCrashed = false;
 
   /// Set by the backend if real reflection is detected in use of dart:mirrors.
   bool disableTypeInferenceForMirrors = false;
 
   Compiler({this.enableTypeAssertions: false,
             this.enableUserAssertions: false,
             this.trustTypeAnnotations: false,
             this.trustPrimitives: false,
@@ skipping 96 matching lines @@
 
   Universe get resolverWorld => enqueuer.resolution.universe;
   Universe get codegenWorld => enqueuer.codegen.universe;
 
   bool get hasBuildId => buildId != UNDETERMINED_BUILD_ID;
 
   bool get analyzeAll => analyzeAllFlag || compileAll;
 
   bool get compileAll => false;
 
-  bool get disableTypeInference => disableTypeInferenceFlag;
+  bool get disableTypeInference {
+    return disableTypeInferenceFlag || compilationFailed;
+  }
 
   int getNextFreeClassId() => nextFreeClassId++;
 
   void unimplemented(Spannable spannable, String methodName) {
     internalError(spannable, "$methodName not implemented.");
   }
 
   void internalError(Spannable node, reason) {
     String message = tryToString(reason);
     reportDiagnosticInternal(
@@ skipping 451 matching lines @@
       fullyEnqueueLibrary(mainApp, enqueuer.resolution);
     }
     // Elements required by enqueueHelpers are global dependencies
     // that are not pulled in by a particular element.
     backend.enqueueHelpers(enqueuer.resolution, globalDependencies);
     resolveLibraryMetadata();
     log('Resolving...');
     processQueue(enqueuer.resolution, mainFunction);
     enqueuer.resolution.logSummary(log);
 
-    if (compilationFailed) return;
     if (!showPackageWarnings && !suppressWarnings) {
       suppressedWarnings.forEach((Uri uri, SuppressionInfo info) {
         MessageKind kind = MessageKind.HIDDEN_WARNINGS_HINTS;
         if (info.warnings == 0) {
           kind = MessageKind.HIDDEN_HINTS;
         } else if (info.hints == 0) {
           kind = MessageKind.HIDDEN_WARNINGS;
         }
         reportDiagnostic(null,
             kind.message({'warnings': info.warnings,
                           'hints': info.hints,
                           'uri': uri},
                          terseDiagnostics),
             api.Diagnostic.HINT);
       });
     }
     if (analyzeOnly) {
-      if (!analyzeAll) {
+      if (!analyzeAll && !compilationFailed) {
         // No point in reporting unused code when [analyzeAll] is true: all
         // code is artificially used.
+        // If compilation failed, it is possible that the error prevents the
+        // compiler from analyzing all the code.
         reportUnusedCode();
       }
       return;
     }
     assert(mainFunction != null);
     phase = PHASE_DONE_RESOLVING;
 
     world.populate();
     // Compute whole-program-knowledge that the backend needs. (This might
     // require the information computed in [world.populate].)
@@ skipping 21 matching lines @@
       backend.enableNoSuchMethod(null, enqueuer.codegen);
     }
     if (compileAll) {
       libraryLoader.libraries.forEach((LibraryElement library) {
         fullyEnqueueLibrary(library, enqueuer.codegen);
       });
     }
     processQueue(enqueuer.codegen, mainFunction);
     enqueuer.codegen.logSummary(log);
 
-    if (compilationFailed) return;
-
     int programSize = backend.assembleProgram();
 
     if (dumpInfo) {
       dumpInfoTask.reportSize(programSize);
       dumpInfoTask.dumpInfo();
     }
 
     checkQueues();
   }
 
@@ skipping 43 matching lines @@
       }
       world.addToWorkList(main);
     }
     if (verbose) {
       progress.reset();
     }
     world.forEach((WorkItem work) {
       withCurrentElement(work.element, () => work.run(this, world));
     });
     world.queueIsClosed = true;
-    if (compilationFailed) return;
-    assert(world.checkNoEnqueuedInvokedInstanceMethods());
+    assert(compilationFailed || world.checkNoEnqueuedInvokedInstanceMethods());
   }
 
   /**
    * Perform various checks of the queues. This includes checking that
    * the queues are empty (nothing was added after we stopped
    * processing the queues). Also compute the number of methods that
    * were resolved, but not compiled (aka excess resolution).
    */
   checkQueues() {
     for (Enqueuer world in [enqueuer.resolution, enqueuer.codegen]) {
@@ skipping 390 matching lines @@
   void forgetElement(Element element) {
     enqueuer.forgetElement(element);
     if (element is MemberElement) {
       for (Element closure in element.nestedClosures) {
         // TODO(ahe): It would be nice to reuse names of nested closures.
         closureToClassMapper.forgetElement(closure);
       }
     }
     backend.forgetElement(element);
   }
+
+  bool elementHasCompileTimeError(Element element) {
+    return elementsWithCompileTimeErrors.contains(element);
+  }
 }
 
 class CompilerTask {
   final Compiler compiler;
   final Stopwatch watch;
   UserTag profilerTag;
 
   CompilerTask(Compiler compiler)
       : this.compiler = compiler,
         watch = (compiler.verbose) ? new Stopwatch() : null;
@@ skipping 271 matching lines @@
   InterfaceType get nullType => nullClass.computeType(compiler);
 
   @override
   InterfaceType get numType => numClass.computeType(compiler);
 
   @override
   InterfaceType get stringType =>  stringClass.computeType(compiler);
 }
 
 typedef void InternalErrorFunction(Spannable location, String message);