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

lib/src/dependency_graph.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.
 
 /// Tracks the shape of the import/export graph and dependencies between files.
 library dev_compiler.src.dependency_graph;
 
 import 'dart:collection' show HashSet, HashMap;
 
 import 'package:analyzer/analyzer.dart' show parseDirectives;
 import 'package:analyzer/src/generated/ast.dart'
     show
         AstNode,
         CompilationUnit,
         ExportDirective,
         Identifier,
         ImportDirective,
         LibraryDirective,
         PartDirective,
         PartOfDirective,
         UriBasedDirective;
 import 'package:analyzer/src/generated/engine.dart'
     show ParseDartTask, AnalysisContext;
+import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/source.dart' show Source, SourceKind;
 import 'package:html/dom.dart' show Document, Node, Element;
 import 'package:html/parser.dart' as html;
 import 'package:logging/logging.dart' show Logger, Level;
 import 'package:path/path.dart' as path;
 
 import 'info.dart';
 import 'options.dart';
 import 'report.dart';
 
 /// Holds references to all source nodes in the import graph. This is mainly
 /// used as a level of indirection to ensure that each source has a canonical
 /// representation.
 class SourceGraph {
   /// All nodes in the source graph. Used to get a canonical representation for
   /// any node.
   final Map<Uri, SourceNode> nodes = {};
 
   /// Resources included by default on any application.
   final runtimeDeps = new Set<ResourceSourceNode>();
 
   /// Analyzer used to resolve source files.
   final AnalysisContext _context;
-  final CompilerReporter _reporter;
+  final AnalysisErrorListener _reporter;
   final CompilerOptions _options;
 
   SourceGraph(this._context, this._reporter, this._options) {
     var dir = _options.runtimeDir;
     if (dir == null) {
       _log.severe('Runtime dir could not be determined automatically, '
           'please specify the --runtime-dir flag on the command line.');
       return;
     }
     var prefix = path.absolute(dir);
@@ skipping 116 matching lines @@
   final htmlResourceNodes = new HashMap<Element, ResourceSourceNode>();
 
   HtmlSourceNode(SourceGraph graph, Uri uri, Source source)
       : runtimeDeps = graph.runtimeDeps,
         super(graph, uri, source);
 
   @override
   void update() {
     super.update();
     if (needsRebuild) {
-      graph._reporter.clearHtml(uri);
+      var reporter = graph._reporter;
+      if (reporter is SummaryReporter) {
+        reporter.clearHtml(uri);
+      }
       document = html.parse(contents, generateSpans: true);
       var newScripts = new Set<DartSourceNode>();
       var tags = document.querySelectorAll('script[type="application/dart"]');
       for (var script in tags) {
         var src = script.attributes['src'];
         if (src == null) {
           _reportError(graph, 'inlined script tags not supported at this time '
               '(see https://github.com/dart-lang/dart-dev-compiler/issues/54).',
               script);
           continue;
@@ skipping 30 matching lines @@
         newResources.add(res);
       }
       if (!_same(newResources, resources)) {
         structureChanged = true;
         resources = newResources;
       }
     }
   }
 
   void _reportError(SourceGraph graph, String message, Node node) {
-    graph._reporter.enterHtml(_source.uri);
     var span = node.sourceSpan;
-    graph._reporter.log(
-        new Message(message, Level.SEVERE, span.start.offset, span.end.offset));
-    graph._reporter.leaveHtml();
+
+    // TODO(jmesserly): should these be errors or warnings?
+    var errorCode = new HtmlWarningCode('dev_compiler.$runtimeType', message);
+    graph._reporter.onError(new AnalysisError(
+        _source, span.start.offset, span.length, errorCode));
   }
 }
 
 /// A node representing a Dart library or part.
 class DartSourceNode extends SourceNode {
   /// Set of imported libraries (empty for part files).
   Set<DartSourceNode> imports = new Set<DartSourceNode>();
 
   /// Set of exported libraries (empty for part files).
   Set<DartSourceNode> exports = new Set<DartSourceNode>();
@@ skipping 24 matching lines @@
   // But we could discard it after that point.
   void saveUpdatedContents() {
     graph._context.setContents(_source, _source.contents.data);
   }
 
   @override
   void update() {
     super.update();
 
     if (needsRebuild) {
-      graph._reporter.clearLibrary(uri);
+      var reporter = graph._reporter;
+      if (reporter is SummaryReporter) {
+        reporter.clearLibrary(uri);
+      }
+
       // If the defining compilation-unit changed, the structure might have
       // changed.
       var unit = parseDirectives(contents, name: _source.fullName);
       var newImports = new Set<DartSourceNode>();
       var newExports = new Set<DartSourceNode>();
       var newParts = new Set<DartSourceNode>();
       for (var d in unit.directives) {
         // Nothing to do for parts.
         if (d is PartOfDirective) return;
         if (d is LibraryDirective) continue;
 
         var directiveUri = (d as UriBasedDirective).uri;
 
         // `dart:core` and other similar URLs only contain a name, but it is
         // meant to be a folder when resolving relative paths from it.
         var targetUri = uri.scheme == 'dart' && uri.pathSegments.length == 1
             ? Uri.parse('$uri/').resolve(directiveUri.stringValue)
             : uri.resolve(directiveUri.stringValue);
         var target =
             ParseDartTask.resolveDirective(graph._context, _source, d, null);
         var node = graph.nodes.putIfAbsent(
             targetUri, () => new DartSourceNode(graph, targetUri, target));
         //var node = graph.nodeFromUri(targetUri);
         if (node._source == null || !node._source.exists()) {
-          _reportError(graph, 'File $targetUri not found', unit, d);
+          _reportError(graph, 'File $targetUri not found', d);
         }
 
         if (d is ImportDirective) {
           newImports.add(node);
         } else if (d is ExportDirective) {
           newExports.add(node);
         } else if (d is PartDirective) {
           newParts.add(node);
         }
       }
@@ skipping 33 matching lines @@
     for (var p in parts) {
       // Technically for parts we don't need to look at the contents. If they
       // contain imports, exports, or parts, we'll ignore them in our crawling.
       // However we do a full update to make it easier to adjust when users
       // switch a file from a part to a library.
       p.update();
       if (p.needsRebuild) needsRebuild = true;
     }
   }
 
-  void _reportError(
-      SourceGraph graph, String message, CompilationUnit unit, AstNode node) {
-    graph._reporter
-      ..enterLibrary(_source.uri)
-      ..enterCompilationUnit(unit, _source)
-      ..log(new Message(message, Level.SEVERE, node.offset, node.end))
-      ..leaveCompilationUnit()
-      ..leaveLibrary();
+  void _reportError(SourceGraph graph, String message, AstNode node) {
+    graph._reporter.onError(new AnalysisError(_source, node.offset,
+        node.length, new CompileTimeErrorCode('dev_compiler.$runtimeType', message)));
   }
 }
 
 /// Represents a runtime resource from our compiler that is needed to run an
 /// application.
 class ResourceSourceNode extends SourceNode {
   ResourceSourceNode(graph, uri, source) : super(graph, uri, source);
 }
 
 /// Updates the structure and `needsRebuild` marks in nodes of [graph] reachable
@@ skipping 158 matching lines @@
   // _foreign_helper is not included, as it only defines the JS builtin that
   // the compiler handles at compile time.
 ];
 
 /// Runtime files added to applications when running in server mode.
 List<String> runtimeFilesForServerMode([bool includeWidget = true]) =>
     new List<String>.from(defaultRuntimeFiles)
   ..addAll(includeWidget ? const ['messages_widget.js', 'messages.css'] : []);
 
 final _log = new Logger('dev_compiler.dependency_graph');