Batch the batch compiler for tests

lib/src/compiler.dart

 // Copyright (c) 2015, 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.
 
 /// Command line tool to run the checker on a Dart program.
 library dev_compiler.src.compiler;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math' as math;
@@ skipping 53 matching lines @@
 }
 
 bool compile(CompilerOptions options) {
   assert(!options.serverMode);
   var context = createAnalysisContextWithSources(
       options.strongOptions, options.sourceOptions);
   var reporter = createErrorReporter(context, options);
   return new BatchCompiler(context, options, reporter: reporter).run();
 }
 
+// Callback on each individual compiled library
+typedef void CompilationNotifier(String path);
+
 class BatchCompiler extends AbstractCompiler {
   JSGenerator _jsGen;
   LibraryElement _dartCore;
   String _runtimeOutputDir;
 
-  /// Already compiled sources, so we don't compile them again.
-  final _compiled = new HashSet<LibraryElement>();
+  /// Already compiled sources, so we don't check or compile them again.
+  final _compilationRecord = <LibraryElement, bool>{};
   bool _sdkCopied = false;
 
   bool _failure = false;
   bool get failure => _failure;
 
+  final _pendingLibraries = <LibraryUnit>[];
+
   BatchCompiler(AnalysisContext context, CompilerOptions options,
       {AnalysisErrorListener reporter})
       : super(
             context,
             options,
             new ErrorCollector(
                 reporter ?? AnalysisErrorListener.NULL_LISTENER)) {
     _inputBaseDir = options.inputBaseDir;
     if (outputDir != null) {
       _jsGen = new JSGenerator(this);
       _runtimeOutputDir = path.join(outputDir, 'dev_compiler', 'runtime');
     }
     _dartCore = context.typeProvider.objectType.element.library;
   }
 
   ErrorCollector get reporter => checker.reporter;
 
-  void reset() {
-    _compiled.clear();
-    _sdkCopied = false;
-  }
-
   /// Compiles every file in [options.inputs].
   /// Returns true on successful compile.
   bool run() {
     var clock = new Stopwatch()..start();
     options.inputs.forEach(compileFromUriString);
     clock.stop();
     var time = (clock.elapsedMilliseconds / 1000).toStringAsFixed(2);
-    _log.fine('Compiled ${_compiled.length} libraries in ${time} s\n');
+    _log.fine('Compiled ${_compilationRecord.length} libraries in ${time} s\n');
 
     return !_failure;
   }
 
-  void compileFromUriString(String uriString) {
-    _compileFromUri(stringToUri(uriString));
+  void compileFromUriString(String uriString, [CompilationNotifier notifier]) {
+    _compileFromUri(stringToUri(uriString), notifier);
   }
 
-  void _compileFromUri(Uri uri) {
+  void _compileFromUri(Uri uri, CompilationNotifier notifier) {
+    _failure = false;
     if (!uri.isAbsolute) {
       throw new ArgumentError.value('$uri', 'uri', 'must be absolute');
     }
     var source = context.sourceFactory.forUri(Uri.encodeFull('$uri'));
     if (source == null) {
       throw new ArgumentError.value('$uri', 'uri', 'could not find source for');
     }
-    compileSource(source);
+    _compileSource(source, notifier);
   }
 
-  void compileSource(Source source) {
+  void _compileSource(Source source, CompilationNotifier notifier) {
     if (AnalysisEngine.isHtmlFileName(source.uri.path)) {
-      _compileHtml(source);
+      _compileHtml(source, notifier);
     } else {
-      _compileLibrary(context.computeLibraryElement(source));
+      _compileLibrary(context.computeLibraryElement(source), notifier);
     }
+    _processPending();
     reporter.flush();
   }
 
-  void _compileLibrary(LibraryElement library) {
-    if (!_compiled.add(library)) return;
+  void _processPending() {
+    // _pendingLibraries was recorded in post-order.  Process from the end
+    // to ensure reverse post-order.  This will ensure that we handle back
+    // edges from the original depth-first search correctly.
+
+    while (_pendingLibraries.isNotEmpty) {
+      var unit = _pendingLibraries.removeLast();
+      var library = unit.library.element.enclosingElement;
+      assert(_compilationRecord.containsKey(library) &&
+          _compilationRecord[library]);
+
+      // Process dependences one more time to propagate failure from cycles
+      for (var import in library.imports) {
+        if (!_compilationRecord[import.importedLibrary]) {
+          _compilationRecord[library] = false;
+        }
+      }
+      for (var export in library.exports) {
+        if (!_compilationRecord[export.exportedLibrary]) {
+          _compilationRecord[library] = false;
+        }
+      }
+
+      // Generate code if still valid
+      if (_jsGen != null &&
+          (_compilationRecord[library] ||
+              options.codegenOptions.forceCompile)) {
+        _jsGen.generateLibrary(unit);
+      }
+    }
+  }
+
+  bool _compileLibrary(LibraryElement library, CompilationNotifier notifier) {
+    if (_compilationRecord.containsKey(library)) {
+      if (!_compilationRecord[library]) _failure = true;
+      return _compilationRecord[library];
+    }
+    // Optimistically mark a library valid until proven otherwise
+    _compilationRecord[library] = true;
 
     if (!options.checkSdk && library.source.uri.scheme == 'dart') {
+      // We assume the Dart SDK is always valid
       if (_jsGen != null) _copyDartRuntime();
-      return;
+      return true;
     }
 
+    // Check dependences to determine if this library type checks
     // TODO(jmesserly): in incremental mode, we can skip the transitive
     // compile of imports/exports.
-    _compileLibrary(_dartCore); // implicit dart:core dependency
-    for (var import in library.imports) _compileLibrary(import.importedLibrary);
-    for (var export in library.exports) _compileLibrary(export.exportedLibrary);
+    _compileLibrary(_dartCore, notifier); // implicit dart:core dependency
+    for (var import in library.imports) {
+      if (!_compileLibrary(import.importedLibrary, notifier)) {
+        _compilationRecord[library] = false;
+      }
+    }
+    for (var export in library.exports) {
+      if (!_compileLibrary(export.exportedLibrary, notifier)) {
+        _compilationRecord[library] = false;
+      }
+    }
 
+    // Check this library's own code
     var unitElements = [library.definingCompilationUnit]..addAll(library.parts);
     var units = <CompilationUnit>[];
 
     bool failureInLib = false;
     for (var element in unitElements) {
       var unit = context.resolveCompilationUnit(element.source, library);
       units.add(unit);
       failureInLib = logErrors(element.source) || failureInLib;
+      checker.reset();
       checker.visitCompilationUnit(unit);
       if (checker.failure) failureInLib = true;
     }
+    if (failureInLib) _compilationRecord[library] = false;
 
-    if (failureInLib) {
-      _failure = true;
-      if (!options.codegenOptions.forceCompile) return;
+    // Notifier framework if requested
+    if (notifier != null) {
+      reporter.flush();
+      notifier(getOutputPath(library.source.uri));
     }
 
-    if (_jsGen != null) {
+    // Record valid libraries for further dependence checking (cycles) and
+    // codegen.
+    if (_compilationRecord[library] || options.codegenOptions.forceCompile) {
       var unit = units.first;
       var parts = units.skip(1).toList();
-      _jsGen.generateLibrary(new LibraryUnit(unit, parts));
+      _pendingLibraries.add(new LibraryUnit(unit, parts));
     }
+
+    // Return tentative success status.
+    if (!_compilationRecord[library]) _failure = true;
+    return _compilationRecord[library];
   }
 
   void _copyDartRuntime() {
     if (_sdkCopied) return;
     _sdkCopied = true;
     for (var file in defaultRuntimeFiles) {
       var input = new File(path.join(options.runtimeDir, file));
       var output = new File(path.join(_runtimeOutputDir, file));
       if (output.existsSync() &&
           output.lastModifiedSync() == input.lastModifiedSync()) {
         continue;
       }
       new Directory(path.dirname(output.path)).createSync(recursive: true);
       input.copySync(output.path);
     }
   }
 
-  void _compileHtml(Source source) {
+  void _compileHtml(Source source, CompilationNotifier notifier) {
     // TODO(jmesserly): reuse DartScriptsTask instead of copy/paste.
     var contents = context.getContents(source);
     var document = html.parse(contents.data, generateSpans: true);
     var scripts = document.querySelectorAll('script[type="application/dart"]');
 
     var loadedLibs = new LinkedHashSet<Uri>();
 
     var htmlOutDir = path.dirname(getOutputPath(source.uri));
     for (var script in scripts) {
       Source scriptSource = null;
       var srcAttr = script.attributes['src'];
       if (srcAttr == null) {
         if (script.hasContent()) {
           var fragments = <ScriptFragment>[];
           for (var node in script.nodes) {
             if (node is html.Text) {
               var start = node.sourceSpan.start;
               fragments.add(new ScriptFragment(
                   start.offset, start.line, start.column, node.data));
             }
           }
           scriptSource = new DartScript(source, fragments);
         }
       } else if (AnalysisEngine.isDartFileName(srcAttr)) {
         scriptSource = context.sourceFactory.resolveUri(source, srcAttr);
       }
 
       if (scriptSource != null) {
         var lib = context.computeLibraryElement(scriptSource);
-        _compileLibrary(lib);
+        _compileLibrary(lib, notifier);
         script.replaceWith(_linkLibraries(lib, loadedLibs, from: htmlOutDir));
       }
     }
 
     new File(getOutputPath(source.uri)).openSync(mode: FileMode.WRITE)
       ..writeStringSync(document.outerHtml)
       ..writeStringSync('\n')
       ..closeSync();
   }
 
@@ skipping 215 matching lines @@
     '_rtti.js',
     '_classes.js',
     '_operations.js',
     'dart_runtime.js',
   ];
   files.addAll(corelibOrder.map((l) => l.replaceAll('.', '/') + '.js'));
   return files;
 }();
 
 final _log = new Logger('dev_compiler.src.compiler');