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?

[vsm, 2015/07/09 23:54:07]

Mostly look like real errors (e.g., inline scripts not supported, file not
found).

[Jennifer Messerly, 2015/07/10 16:12:05]

yeah, maybe ... on the other hand, HTML doesn't really have a notion of
"errors", at least not in the sense that blocks rendering. HTML parse errors
aren't even usually displayed normally, except by linters. (which is kind of a
shame, because there's a lot of useful parse errors in the spec!)

similarly, html errors don't really affect soundness (at least I hope so ;-) )
... so if we treat them as warnings, worst case, your app won't load, best cast,
maybe you can still develop some other parts (like the CSS). if we don't
generate the HTML file ... your app totally won't load. e.g. for inline scripts,
maybe you have one inline script and one src= script, you could still debug the
src= app even if the inline one doesn't work.

it also depends on --force-compile ... if we have that on always for --server,
then we have less incentive to lower the error level.

anyway, not saying I'm in favor of warnings, just don't know that it's clear
cut. Seemed worth adding a TODO at least :)

+    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');