fixes #6, refactor to use AnalysisError/Listener throughout dev_compiler

lib/devc.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.devc;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
-import 'package:analyzer/src/generated/error.dart'
-    show AnalysisError, ErrorSeverity, ErrorType;
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, ChangeSet;
+import 'package:analyzer/src/generated/error.dart'
+    show AnalysisError, AnalysisErrorListener, ErrorSeverity, ErrorType;
 import 'package:analyzer/src/generated/source.dart' show Source;
 import 'package:logging/logging.dart' show Level, Logger, LogRecord;
 import 'package:path/path.dart' as path;
 import 'package:shelf/shelf.dart' as shelf;
 import 'package:shelf/shelf_io.dart' as shelf;
 import 'package:shelf_static/shelf_static.dart' as shelf_static;
 
 import 'src/analysis_context.dart';
 import 'src/checker/checker.dart';
 import 'src/checker/rules.dart';
@@ skipping 21 matching lines @@
   AnalysisContext get context;
   TypeRules get rules;
   Uri get entryPointUri;
 }
 
 /// Encapsulates the logic to do a one-off compilation or a partial compilation
 /// when the compiler is run as a development server.
 class Compiler implements AbstractCompiler {
   final CompilerOptions options;
   final AnalysisContext context;
-  final CompilerReporter _reporter;
+  final AnalysisErrorListener _reporter;
   final TypeRules rules;
   final CodeChecker _checker;
   final SourceNode _entryNode;
   List<LibraryInfo> _libraries = <LibraryInfo>[];
   final _generators = <CodeGenerator>[];
   bool _hashing;
   bool _failure = false;
 
   factory Compiler(CompilerOptions options,
-      {AnalysisContext context, CompilerReporter reporter}) {
+      {AnalysisContext context, AnalysisErrorListener reporter}) {
     var strongOpts = options.strongOptions;
     var sourceOpts = options.sourceOptions;
     if (context == null) {
       context = createAnalysisContextWithSources(strongOpts, sourceOpts);
     }
 
     if (reporter == null) {
       reporter = options.dumpInfo
           ? new SummaryReporter(context, options.logLevel)
           : new LogReporter(context, useColors: options.useColors);
@@ skipping 39 matching lines @@
       assert(false); // should not get a build request on PartSourceNode
     }
 
     // TODO(sigmund): don't always return true. Use summarization to better
     // determine when rebuilding is needed.
     return true;
   }
 
   void _buildHtmlFile(HtmlSourceNode node) {
     if (outputDir == null) return;
-    var uri = node.source.uri;
-    _reporter.enterHtml(uri);
     var output = generateEntryHtml(node, options);
     if (output == null) {
       _failure = true;
       return;
     }
-    _reporter.leaveHtml();
     var filename = path.basename(node.uri.path);
     String outputFile = path.join(outputDir, filename);
     new File(outputFile).writeAsStringSync(output);
   }
 
   void _buildResourceFile(ResourceSourceNode node) {
     // ResourceSourceNodes files that just need to be copied over to the output
     // location. These can be external dependencies or pieces of the
     // dev_compiler runtime.
     if (outputDir == null) return;
@@ skipping 17 matching lines @@
     context.applyChanges(new ChangeSet()..changedSource(source));
     var entryUnit = context.resolveCompilationUnit2(source, source);
     var lib = entryUnit.element.enclosingElement;
     if (!options.checkSdk && lib.source.uri.scheme == 'dart') return;
     var current = node.info;
     if (current != null) {
       assert(current.library == lib);
     } else {
       node.info = current = new LibraryInfo(lib, _isEntry(node));
     }
-    _reporter.enterLibrary(source.uri);
     _libraries.add(current);
     rules.currentLibraryInfo = current;
 
     var resolvedParts = node.parts
         .map((p) => context.resolveCompilationUnit2(p.source, source))
         .toList(growable: false);
     var libraryUnit = new LibraryUnit(entryUnit, resolvedParts);
     bool failureInLib = false;
     for (var unit in libraryUnit.libraryThenParts) {
       var unitSource = unit.element.source;
-      _reporter.enterCompilationUnit(unit);
-      // TODO(sigmund): integrate analyzer errors with static-info (issue #6).
       failureInLib = logErrors(unitSource) || failureInLib;
       _checker.visitCompilationUnit(unit);
       if (_checker.failure) failureInLib = true;
-      _reporter.leaveCompilationUnit();
     }
     if (failureInLib) {
       _failure = true;
       if (!options.codegenOptions.forceCompile) return;
     }
 
     for (var cg in _generators) {
       var hash = cg.generateLibrary(libraryUnit, current);
       if (_hashing) node.cachingHash = hash;
     }
-    _reporter.leaveLibrary();
   }
 
   /// Log any errors encountered when resolving [source] and return whether any
   /// errors were found.
   bool logErrors(Source source) {
     context.computeErrors(source);
     List<AnalysisError> errors = context.getErrors(source).errors;
     bool failure = false;
     if (errors.isNotEmpty) {
       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;
         }
 
-        var message = new AnalyzerMessage.from(error);
-        if (message.level == Level.SEVERE) failure = true;
-        _reporter.log(message);
+        // All analyzer warnings or errors are errors for DDC.
+        failure = true;
+        _reporter.onError(error);
       }
     }
     return failure;
   }
 
   CheckerResults run() {
     var clock = new Stopwatch()..start();
 
     // TODO(sigmund): we are missing a couple failures here. The
     // dependency_graph now detects broken imports or unsupported features
@@ skipping 105 matching lines @@
       // Note: the cache-control header should be enough, but this doesn't hurt
       // and can help renew the policy after it expires.
       headers['ETag'] = hash;
     }
     return response.change(headers: headers);
   };
 }
 
 final _log = new Logger('dev_compiler');
 final _earlyErrorResult = new CheckerResults(const [], null, true);