Remove code that requires whole-program compile

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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math' as math;
 import 'dart:io';
 
 import 'package:analyzer/dart/ast/ast.dart' show CompilationUnit;
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisEngine, AnalysisContext, ChangeSet, ParseDartTask;
 import 'package:analyzer/src/generated/error.dart'
     show AnalysisError, ErrorSeverity, ErrorType;
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/source.dart' show Source;
 import 'package:analyzer/src/task/html.dart';
 import 'package:html/dom.dart' as html;
 import 'package:html/parser.dart' as html;
 import 'package:logging/logging.dart' show Level, Logger, LogRecord;
 import 'package:path/path.dart' as path;
 
 import 'analysis_context.dart';
 import 'codegen/html_codegen.dart' as html_codegen;
 import 'codegen/js_codegen.dart';
-import 'info.dart'
-    show AnalyzerMessage, CheckerResults, LibraryInfo, LibraryUnit;
 import 'options.dart';
 import 'report.dart';
-import 'report/html_reporter.dart';
 import 'utils.dart' show FileSystem, isStrongModeError;
 
 /// Sets up the type checker logger to print a span that highlights error
 /// messages.
 StreamSubscription setupLogger(Level level, printFn) {
   Logger.root.level = level;
   return Logger.root.onRecord.listen((LogRecord rec) {
     printFn('${rec.level.name.toLowerCase()}: ${rec.message}');
   });
 }
@@ skipping 10 matching lines @@
     if (options.inputs.length == 0) {
       print('Expected filename.');
       return null;
     }
   }
   return options;
 }
 
 /// Compile with the given options and return success or failure.
 bool compile(CompilerOptions options) {
-  assert(!options.serverMode);
-
   var context = createAnalysisContextWithSources(options.sourceOptions);
-  var reporter = createErrorReporter(context, options);
-  bool status = new BatchCompiler(context, options, reporter: reporter).run();
-
-  if (reporter is HtmlReporter) {
-    reporter.finish(options);
-  } else if (reporter is SummaryReporter) {
-    var result = reporter.result;
-    print(summaryToString(result));
-  }
-
-  return status;
+  var reporter = new LogReporter(context, useColors: options.useColors);
+  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 check or compile them again.
   final _compilationRecord = <LibraryElement, bool>{};
   bool _sdkCopied = false;
 
   bool _failure = false;
   bool get failure => _failure;
 
-  final _pendingLibraries = <LibraryUnit>[];
+  final _pendingLibraries = <List<CompilationUnit>>[];
 
   BatchCompiler(AnalysisContext context, CompilerOptions options,
       {AnalysisErrorListener reporter,
       FileSystem fileSystem: const FileSystem()})
       : super(
             context,
             options,
             new ErrorCollector(reporter ?? AnalysisErrorListener.NULL_LISTENER),
             fileSystem) {
     _inputBaseDir = options.inputBaseDir;
@@ skipping 44 matching lines @@
     reporter.flush();
   }
 
   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;
+      var library = unit.first.element.library;
       assert(_compilationRecord[library] == true ||
           options.codegenOptions.forceCompile);
 
       // Process dependencies 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) {
@@ skipping 36 matching lines @@
         _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 unitElements = new List.from(library.parts)
+      ..add(library.definingCompilationUnit);
     var units = <CompilationUnit>[];
 
     bool failureInLib = false;
     for (var element in unitElements) {
       var unit = context.resolveCompilationUnit(element.source, library);
       units.add(unit);
       failureInLib = computeErrors(element.source) || failureInLib;
     }
     if (failureInLib) _compilationRecord[library] = false;
 
     // Notifier framework if requested
     if (notifier != null) {
       reporter.flush();
       notifier(getOutputPath(library.source.uri));
     }
 
     // Record valid libraries for further dependence checking (cycles) and
     // codegen.
 
     // TODO(vsm): Restructure this to not delay code generation more than
     // necessary.  We'd like to process the AST before there is any chance
     // it's cached out.  We should refactor common logic in
     // server/dependency_graph and perhaps the analyzer itself.
     success = _compilationRecord[library];
     if (success || options.codegenOptions.forceCompile) {
-      var unit = units.first;
-      var parts = units.skip(1).toList();
-      _pendingLibraries.add(new LibraryUnit(unit, parts));
+      _pendingLibraries.add(units);
     }
 
     // Return tentative success status.
     if (!success) _failure = true;
     return success;
   }
 
   void _copyDartRuntime() {
     if (_sdkCopied) return;
     _sdkCopied = true;
@@ skipping 216 matching lines @@
         failure = true;
         reporter.onError(error);
       } else {
         // Skip hints for now.
       }
     }
     return failure;
   }
 }
 
-AnalysisErrorListener createErrorReporter(
-    AnalysisContext context, CompilerOptions options) {
-  return options.htmlReport
-      ? new HtmlReporter(context)
-      : options.serverMode
-          ? new SummaryReporter(context, options.logLevel)
-          : new LogReporter(context, useColors: options.useColors);
-}
-
 // TODO(jmesserly): find a better home for these.
 /// Curated order to minimize lazy classes needed by dart:core and its
 /// transitive SDK imports.
 final corelibOrder = [
   'dart:core',
   'dart:collection',
   'dart:_internal',
   'dart:math',
   'dart:_interceptors',
   'dart:async',
@@ skipping 34 matching lines @@
   var files = [
     'harmony_feature_check.js',
     'dart_library.js',
     'dart/_runtime.js',
   ];
   files.addAll(corelibOrder.map(coreToFile));
   return files;
 }();
 
 final _log = new Logger('dev_compiler.src.compiler');