Add a reporter, remove caching of source files and recording of info (in progress)

[email protected], [email protected]

Review URL: https://chromereviews.googleplex.com/132767014

Author: sigmundch

bin/devc.dart

@@ -61,7 +61,7 @@ void main(List<String> argv) {
   Level level = Level.LEVELS.firstWhere((Level l) => l.name == levelName,
       orElse: () => Level.SEVERE);
   var useColors = stdioType(stdout) == StdioType.TERMINAL;
-  if (!args['dump-info']) setupLogger(level, print, useColors: useColors);
+  if (!args['dump-info']) setupLogger(level, print);
 
   var typeResolver = new TypeResolver(shouldMockSdk ?
       TypeResolver.sdkResolverFromMock(mockSdkSources) :

lib/devc.dart

@@ -3,32 +3,21 @@ library ddc.devc;
 
 import 'dart:async';
 
-import 'package:path/path.dart' as path;
-import 'package:analyzer/analyzer.dart';
-import 'package:analyzer/src/generated/ast.dart';
 import 'package:logging/logging.dart' show Level, Logger, LogRecord;
+import 'package:path/path.dart' as path;
 
 import 'package:ddc/src/checker/checker.dart';
 import 'package:ddc/src/checker/resolver.dart' show TypeResolver;
 import 'package:ddc/src/codegen/dart_codegen.dart';
 import 'package:ddc/src/codegen/js_codegen.dart';
 import 'package:ddc/src/report.dart';
-import 'package:ddc/src/utils.dart';
 
 /// Sets up the type checker logger to print a span that highlights error
 /// messages.
-StreamSubscription setupLogger(Level level, printFn, {bool useColors: true}) {
+StreamSubscription setupLogger(Level level, printFn) {
   Logger.root.level = level;
   return Logger.root.onRecord.listen((LogRecord rec) {
-    AstNode node = rec.error;
-    if (node == null) {
-      printFn('${rec.level.name.toLowerCase()}: ${rec.message}');
-      return;
-    }
-
-    final span = spanForNode(node);
-    final color = useColors ? colorOf(rec.level.name) : null;
-    printFn('${span.message(rec.message, color: color)}');
+    printFn('${rec.level.name.toLowerCase()}: ${rec.message}');
   });
 }
 
@@ -37,15 +26,13 @@ Future<bool> compile(String inputFile, TypeResolver resolver,
     String outputDir, bool dumpInfo: false, bool useColors: true}) {
 
   // Run checker
+  var reporter = dumpInfo ? new SummaryReporter() : new LogReporter(useColors);
   var uri = new Uri.file(path.absolute(inputFile));
-  var results =
-      checkProgram(uri, resolver, checkSdk: checkSdk, useColors: useColors);
+  var results = checkProgram(uri, resolver, reporter,
+      checkSdk: checkSdk, useColors: useColors);
 
-  if (dumpInfo) {
-    // TODO(sigmund): return right after?
-    var summary = checkerResultsToSummary(results);
-    print(summaryToString(summary));
-  }
+  // TODO(sigmund): return right after?
+  if (dumpInfo) print(summaryToString(reporter.result));
 
   if (results.failure) return new Future.value(false);
 

lib/src/checker/checker.dart

@@ -7,18 +7,20 @@ import 'package:analyzer/src/generated/resolver.dart';
 import 'package:logging/logging.dart' as logger;
 
 import 'package:ddc/src/info.dart';
+import 'package:ddc/src/report.dart' show CheckerReporter;
 import 'package:ddc/src/utils.dart';
 import 'resolver.dart';
 import 'rules.dart';
 
 /// Runs the program checker using the restricted type rules on [fileUri].
 CheckerResults checkProgram(Uri fileUri, TypeResolver resolver,
-    {bool checkSdk: false, bool useColors: true}) {
+    CheckerReporter reporter, {bool checkSdk: false, bool useColors: true}) {
 
   // Invoke the checker on the entry point.
   TypeProvider provider = resolver.context.typeProvider;
-  var rules = new RestrictedRules(provider);
-  final visitor = new ProgramChecker(resolver, rules, fileUri, checkSdk);
+  var rules = new RestrictedRules(provider, reporter);
+  final visitor = new ProgramChecker(
+      resolver, rules, fileUri, checkSdk, reporter);
   visitor.check();
   return new CheckerResults(visitor.libraries, rules, visitor.failure);
 }
@@ -28,26 +30,32 @@ class ProgramChecker extends RecursiveAstVisitor {
   final TypeRules _rules;
   final Uri _root;
   final bool _checkSdk;
+  final CheckerReporter _reporter;
   final List<LibraryInfo> libraries = <LibraryInfo>[];
 
   LibraryInfo _current;
   bool failure = false;
 
-  ProgramChecker(this._resolver, this._rules, this._root, this._checkSdk);
+  ProgramChecker(
+      this._resolver, this._rules, this._root, this._checkSdk, this._reporter);
 
   void check() {
     var startLibrary = _resolver.context
         .computeLibraryElement(_resolver.findSource(_root));
     for (var lib in reachableLibraries(startLibrary)) {
       if (!_checkSdk && lib.isInSdk) continue;
       _current = new LibraryInfo(lib);
+      _reporter.enterLibrary(_current);
       libraries.add(_current);
       _rules.currentLibraryInfo = _current;
       for (var unit in lib.units) {
+        _reporter.enterSource(unit.source);
         // TODO(sigmund): integrate analyzer errors with static-info (issue #6).
-        failure = _resolver.logErrors(unit.source) || failure;
+        failure = _resolver.logErrors(unit.source, _reporter) || failure;
         unit.node.visitChildren(this);
+        _reporter.leaveSource();
       }
+      _reporter.leaveLibrary();
     }
   }
 
@@ -361,15 +369,12 @@ class ProgramChecker extends RecursiveAstVisitor {
     final semanticNode = _getSemanticNode(node);
     assert(semanticNode.dynamicInvoke == null);
     semanticNode.dynamicInvoke = info;
-    semanticNode.messages.add(info);
-    logCheckerMessage(info);
+    _reporter.log(info);
   }
 
   void _recordMessage(StaticInfo info) {
     if (info == null) return;
-
     if (info.level >= logger.Level.SEVERE) failure = true;
-    _getSemanticNode(info.node).messages.add(info);
-    logCheckerMessage(info);
+    _reporter.log(info);
   }
 }

lib/src/checker/resolver.dart

@@ -16,6 +16,7 @@ import 'package:analyzer/src/generated/source_io.dart';
 import 'package:logging/logging.dart' as logger;
 
 import 'package:ddc/src/utils.dart';
+import 'package:ddc/src/report.dart';
 import 'dart_sdk.dart';
 import 'multi_package_resolver.dart';
 
@@ -52,19 +53,17 @@ class TypeResolver {
 
   /// Log any errors encountered when resolving [source] and return whether any
   /// errors were found.
-  bool logErrors(Source source) {
+  bool logErrors(Source source, CheckerReporter reporter) {
     List<AnalysisError> errors = context.getErrors(source).errors;
     bool failure = false;
     if (errors.isNotEmpty) {
       for (var error in errors) {
-        var offset = error.offset;
-        var span = spanFor(error.source, offset, offset + error.length);
         var severity = error.errorCode.errorSeverity;
         var isError = severity == ErrorSeverity.ERROR;
         if (isError) failure = true;
         var level = isError ? logger.Level.SEVERE : logger.Level.WARNING;
-        _log.log(level, span.message('[from analyzer]: ${error.message}',
-            color: colorOf(severity.name)));
+        reporter.logAnalyzerError(error.message,
+            level, error.offset, error.offset + error.length);
       }
     }
     return failure;

lib/src/checker/rules.dart

@@ -6,7 +6,7 @@ import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 import 'package:ddc/src/info.dart';
-import 'package:ddc/src/utils.dart' show logCheckerMessage;
+import 'package:ddc/src/report.dart' show CheckerReporter;
 
 abstract class TypeRules {
   final TypeProvider provider;
@@ -56,18 +56,17 @@ class DartRules extends TypeRules {
 }
 
 class RestrictedRules extends TypeRules {
+  final CheckerReporter _reporter;
 
-  RestrictedRules(TypeProvider provider) : super(provider);
+  RestrictedRules(TypeProvider provider, this._reporter) : super(provider);
 
   DartType getStaticType(Expression expr) {
     var type = expr.staticType;
     if (type != null) return type;
 
     var node = currentLibraryInfo.nodeInfo
         .putIfAbsent(expr, () => new SemanticNode(expr));
-    var info = new MissingTypeError(expr);
-    node.messages.add(info);
-    logCheckerMessage(info);
+    _reporter.log(new MissingTypeError(expr));
     return provider.dynamicType;
   }
 

lib/src/info.dart

@@ -54,11 +54,6 @@ class SemanticNode {
   /// If this operation is dynamically dispatched, this will be set.
   DynamicInvoke dynamicInvoke;
 
-  /// All error or warning messages about this node, including [dynamicInvoke].
-  /// Except for [dynamicInvoke] all other messages here are not used when
-  /// generating code.
-  final messages = <StaticInfo>[];
-
   SemanticNode(this.node);
 }