Add widget to display errors, and report dependency_graph errors correctly

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;
 
 import 'package:analyzer/analyzer.dart' show parseDirectives;
 import 'package:analyzer/src/generated/ast.dart'
     show
         LibraryDirective,
         ImportDirective,
         ExportDirective,
         PartDirective,
         PartOfDirective,
         CompilationUnit,
         Identifier;
 import 'package:analyzer/src/generated/engine.dart'
     show ParseDartTask, AnalysisContext;
 import 'package:analyzer/src/generated/source.dart' show Source, SourceKind;
 import 'package:html5lib/dom.dart' show Document;
 import 'package:html5lib/parser.dart' as html;
-import 'package:logging/logging.dart' show Logger;
+import 'package:logging/logging.dart' show Level;
 import 'package:path/path.dart' as path;
+import 'package:source_span/source_span.dart' show SourceSpan;
 
 import 'info.dart';
-import 'options.dart';
+import 'report.dart';
 import 'utils.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 = {};
 
   /// Analyzer used to resolve source files.
   final AnalysisContext _context;
-  final CompilerOptions _options;
+  final CheckerReporter _reporter;
 
-  SourceGraph(this._context, this._options);
+  SourceGraph(this._context, this._reporter);
 
   /// Node associated with a resolved [uri].
   SourceNode nodeFromUri(Uri uri) {
     var uriString = Uri.encodeFull('$uri');
     return nodes.putIfAbsent(uri, () {
       var source = _context.sourceFactory.forUri(uriString);
       var extension = path.extension(uriString);
       if (extension == '.html') {
         return new HtmlSourceNode(uri, source, this);
       } else if (extension == '.dart' || uriString.startsWith('dart:')) {
         return new DartSourceNode(uri, source);
-      } else if (extension == '.js') {
-        return new JavaScriptSourceNode(uri, source);
+      } else if (extension == '.js' || extension == '.css') {
+        return new ResourceSourceNode(uri, source);
       } else {
         assert(false); // unreachable
       }
     });
   }
 }
 
 /// A node in the import graph representing a source file.
 abstract class SourceNode {
   /// Resolved URI for this node.
@@ skipping 35 matching lines @@
   }
 
   String toString() {
     var simpleUri = uri.scheme == 'file' ? path.relative(uri.path) : "$uri";
     return '[$runtimeType: $simpleUri]';
   }
 }
 
 /// A node representing an entry HTML source file.
 class HtmlSourceNode extends SourceNode {
-  /// Javascript dependencies, included by default on any application.
-  Set<JavaScriptSourceNode> runtimeDeps = new Set<JavaScriptSourceNode>();
+  /// Resources included by default on any application.
+  Set<ResourceSourceNode> runtimeDeps = new Set<ResourceSourceNode>();
 
   /// Libraries referred to via script tags.
   Set<DartSourceNode> scripts = new Set<DartSourceNode>();
 
   @override
   Iterable<SourceNode> get allDeps => [scripts, runtimeDeps].expand((e) => e);
 
   @override
   Iterable<SourceNode> get depsWithoutParts => allDeps;
 
   /// Parsed document, updated whenever [update] is invoked.
   Document document;
 
   HtmlSourceNode(uri, source, graph) : super(uri, source) {
     var prefix = 'package:dev_compiler/runtime';
     runtimeDeps
       ..add(graph.nodeFromUri(Uri.parse('$prefix/dart_runtime.js')))
-      ..add(graph.nodeFromUri(Uri.parse('$prefix/harmony_feature_check.js')));
+      ..add(graph.nodeFromUri(Uri.parse('$prefix/harmony_feature_check.js')))
+      ..add(graph.nodeFromUri(Uri.parse('$prefix/messages_widget.js')))
+      ..add(graph.nodeFromUri(Uri.parse('$prefix/messages.css')));
   }
 
   void update(SourceGraph graph) {
     super.update(graph);
     if (needsRebuild) {
+      graph._reporter.clearHtml(uri);
       document = html.parse(source.contents.data, 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) {
-          // TODO(sigmund): expose these as compile-time failures
-          _log.severe(script.sourceSpan.message(
+          graph._reporter.enterHtml(source.uri);
+          graph._reporter.log(new DependencyGraphError(
               'inlined script tags not supported at this time '
               '(see https://github.com/dart-lang/dart-dev-compiler/issues/54).',
-              color: graph._options.useColors ? colorOf('error') : false));
+              script.sourceSpan));
+          graph._reporter.leaveHtml();
           continue;
         }
         var node = graph.nodeFromUri(uri.resolve(src));
-        if (!node.source.exists()) {
-          _log.severe(script.sourceSpan.message('Script file $src not found',
-              color: graph._options.useColors ? colorOf('error') : false));
+        if (node == null || !node.source.exists()) {
+          graph._reporter.enterHtml(source.uri);
+          graph._reporter.log(new DependencyGraphError(
+              'Script file $src not found', script.sourceSpan));
+          graph._reporter.leaveHtml();
         }
-        newScripts.add(node);
+        if (node != null) newScripts.add(node);
       }
 
       if (!_same(newScripts, scripts)) {
         structureChanged = true;
         scripts = newScripts;
       }
     }
   }
 }
 
@@ skipping 20 matching lines @@
   @override
   Iterable<SourceNode> get depsWithoutParts =>
       [imports, exports].expand((e) => e);
 
   LibraryInfo info;
 
   void update(SourceGraph graph) {
     super.update(graph);
 
     if (needsRebuild && source.contents.data != null) {
+      graph._reporter.clearLibrary(uri);
       // If the defining compilation-unit changed, the structure might have
       // changed.
       var unit = parseDirectives(source.contents.data, 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 target =
             ParseDartTask.resolveDirective(graph._context, source, d, null);
         var uri = target.uri;
         var node =
             graph.nodes.putIfAbsent(uri, () => new DartSourceNode(uri, target));
         if (!node.source.exists()) {
-          _log.severe(spanForNode(unit, source, d).message(
-              'File $uri not found',
-              color: graph._options.useColors ? colorOf('error') : false));
+          graph._reporter.enterLibrary(source.uri);
+          graph._reporter.log(new DependencyGraphError(
+              'File $uri not found', spanForNode(unit, source, d)));
+          graph._reporter.leaveLibrary();
         }
 
         if (d is ImportDirective) {
           newImports.add(node);
         } else if (d is ExportDirective) {
           newExports.add(node);
         } else if (d is PartDirective) {
           newParts.add(node);
         }
       }
@@ skipping 34 matching lines @@
       // 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(graph);
       if (p.needsRebuild) needsRebuild = true;
     }
   }
 }
 
-/// Represents a Javascript runtime resource from our compiler that is needed to
-/// run an application.
-class JavaScriptSourceNode extends SourceNode {
-  JavaScriptSourceNode(uri, source) : super(uri, source);
+/// Represents a runtime resource from our compiler that is needed to run an
+/// application.
+class ResourceSourceNode extends SourceNode {
+  ResourceSourceNode(uri, source) : super(uri, source);
 }
 
 /// Updates the structure and `needsRebuild` marks in nodes of [graph] reachable
 /// from [start].
 ///
 /// That is, staring from [start], we update the graph by detecting file changes
 /// and rebuilding the structure of the graph wherever it changed (an import was
 /// added or removed, etc).
 ///
 /// After calling this function a node is marked with `needsRebuild` only if it
@@ skipping 45 matching lines @@
   // cases anways require using summaries to understand what parts of the public
   // API may be affected by transitive changes. The re-export case is just one
   // of those transitive cases, but is not sufficient. See
   // https://github.com/dart-lang/dev_compiler/issues/76
   var apiChangeDetected = new HashSet<SourceNode>();
   bool structureHasChanged = false;
 
   bool shouldBuildNode(SourceNode n) {
     if (n.needsRebuild) return true;
     if (n is HtmlSourceNode) return structureHasChanged;
-    if (n is JavaScriptSourceNode) return false;
+    if (n is ResourceSourceNode) return false;
     return (n as DartSourceNode).imports
         .any((i) => apiChangeDetected.contains(i));
   }
 
   visitInPostOrder(start, (n) {
     if (n.structureChanged) structureHasChanged = true;
     if (shouldBuildNode(n)) {
       if (build(n)) apiChangeDetected.add(n);
     } else if (n is DartSourceNode &&
         n.exports.any((e) => apiChangeDetected.contains(e))) {
@@ skipping 33 matching lines @@
   helper(SourceNode node) {
     if (!seen.add(node)) return;
     var deps = includeParts ? node.allDeps : node.depsWithoutParts;
     deps.forEach(helper);
     action(node);
   }
   helper(start);
 }
 
 bool _same(Set a, Set b) => a.length == b.length && a.containsAll(b);
-final _log = new Logger('dev_compiler.graph');
+
+/// An error message discovered while parsing the dependencies between files.
+class DependencyGraphError extends MessageWithSpan {
+  const DependencyGraphError(String message, SourceSpan span)
+      : super(message, Level.SEVERE, span);
+}