Move DDC to analyzer-based checker

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:convert' show JSON;
 import 'dart:math' as math;
 import 'dart:io';
 
 import 'package:analyzer/src/generated/ast.dart' show CompilationUnit;
 import 'package:analyzer/src/generated/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 'checker/checker.dart';
-import 'checker/rules.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';
 
 /// Sets up the type checker logger to print a span that highlights error
 /// messages.
 StreamSubscription setupLogger(Level level, printFn) {
@@ skipping 66 matching lines @@
             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;
+  ErrorCollector get reporter => super.reporter;
 
   /// 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 ${_compilationRecord.length} libraries in ${time} s\n');
 
@@ skipping 90 matching lines @@
     }
 
     // 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;
+      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
@@ skipping 110 matching lines @@
     for (var l in lib.exports) _collectLibraries(l.exportedLibrary, loaded);
     // Move the item to the end of the list.
     loaded.remove(uri);
     loaded.add(uri);
   }
 }
 
 abstract class AbstractCompiler {
   final CompilerOptions options;
   final AnalysisContext context;
-  final CodeChecker checker;
+  final AnalysisErrorListener reporter;
 
-  AbstractCompiler(AnalysisContext context, CompilerOptions options,
-      [AnalysisErrorListener reporter])
-      : context = context,
-        options = options,
-        checker = new CodeChecker(
-            new TypeRules(context.typeProvider, options: options.strongOptions),
-            reporter ?? AnalysisErrorListener.NULL_LISTENER);
+  AbstractCompiler(this.context, this.options, [this.reporter]);
 
   String get outputDir => options.codegenOptions.outputDir;
-  TypeRules get rules => checker.rules;
-  AnalysisErrorListener get reporter => checker.reporter;
 
   Uri stringToUri(String uriString) {
     var uri = uriString.startsWith('dart:') || uriString.startsWith('package:')
         ? Uri.parse(uriString)
         : new Uri.file(path.absolute(uriString));
     return uri;
   }
 
   /// Directory presumed to be the common prefix for all input file:// URIs.
   /// Used when computing output paths.
@@ skipping 62 matching lines @@
     } else {
       assert(uri.scheme == 'package');
       // filepath is good here, we want the output to start with a directory
       // matching the package name.
       return filepath;
     }
   }
 
   /// Log any errors encountered when resolving [source] and return whether any
   /// errors were found.
-  bool logErrors(Source source) {
-    List<AnalysisError> errors = context.computeErrors(source);
+  bool computeErrors(Source source) {
+    AnalysisContext errorContext = context;
+    // TODO(jmesserly): should this be a fix somewhere in analyzer?
+    // otherwise we fail to find the parts.
+    if (source.uri.scheme == 'dart') {
+      errorContext = context.sourceFactory.dartSdk.context;
+    }
+    List<AnalysisError> errors = errorContext.computeErrors(source);
     bool failure = false;
-    if (errors.isNotEmpty) {
-      for (var error in errors) {
-        // Always skip TODOs.
-        if (error.errorCode.type == ErrorType.TODO) continue;
+    for (var error in errors) {
+      // Always skip TODOs.
+      if (error.errorCode.type == ErrorType.TODO) continue;
 
-        // Skip hints for now. In the future these could be turned on via flags.
-        if (error.errorCode.errorSeverity.ordinal <
-            ErrorSeverity.WARNING.ordinal) {
-          continue;
+      // TODO(jmesserly): for now, treat DDC errors as having a different
+      // error level from Analayzer ones.
+      if (error.errorCode.name.startsWith('dev_compiler')) {
+        reporter.onError(error);
+        if (error.errorCode.errorSeverity == ErrorSeverity.ERROR) {
+          failure = true;
         }
-
+      } else if (error.errorCode.errorSeverity.ordinal >=
+          ErrorSeverity.WARNING.ordinal) {
         // All analyzer warnings or errors are errors for DDC.
         failure = true;
         reporter.onError(error);
+      } else {
+        // Skip hints for now.
       }
     }
     return failure;
   }
 }
 
 AnalysisErrorListener createErrorReporter(
     AnalysisContext context, CompilerOptions options) {
   return options.dumpInfo
       ? new SummaryReporter(context, options.logLevel)
@@ skipping 42 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');