Add widget to display errors, and report dependency_graph errors correctly

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';
@@ skipping 47 matching lines @@
       resolver = options.useMockSdk
           ? new TypeResolver.fromMock(mockSdkSources, options)
           : new TypeResolver.fromDir(options.dartSdkPath, options);
     }
 
     if (reporter == null) {
       reporter = options.dumpInfo
           ? new SummaryReporter()
           : new LogReporter(options.useColors);
     }
-    var graph = new SourceGraph(resolver.context, options);
+    var graph = new SourceGraph(resolver.context, reporter);
     var rules = new RestrictedRules(resolver.context.typeProvider, reporter,
         options: options);
     var checker = new CodeChecker(rules, reporter, options);
     var inputFile = options.entryPointFile;
     var uri = inputFile.startsWith('dart:') || inputFile.startsWith('package:')
         ? Uri.parse(inputFile)
         : new Uri.file(path.absolute(inputFile));
     var entryNode = graph.nodeFromUri(uri);
 
     var outputDir = options.outputDir;
@@ skipping 12 matching lines @@
   }
 
   Compiler._(this._options, this._resolver, this._reporter, this._rules,
       this._checker, this._graph, this._entryNode, this._generators);
 
   bool _buildSource(SourceNode node) {
     if (node is HtmlSourceNode) {
       _buildHtmlFile(node);
     } else if (node is DartSourceNode) {
       _buildDartLibrary(node);
-    } else if (node is JavaScriptSourceNode) {
-      _buildJavaScriptFile(node);
+    } else if (node is ResourceSourceNode) {
+      _buildResourceFile(node);
     } else {
       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 (_options.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(_options.outputDir, filename);
     new File(outputFile).writeAsStringSync(output);
 
     if (_options.outputDart) return;
   }
 
-  void _buildJavaScriptFile(JavaScriptSourceNode node) {
-    // JavaScriptSourceNodes are pieces of the dev_compiler runtime which are
+  void _buildResourceFile(ResourceSourceNode node) {
+    // ResourceSourceNodes are pieces of the dev_compiler runtime which are
     // dependencies added for js codegen.
     if (_options.outputDir == null || _options.outputDart) return;
     assert(node.uri.scheme == 'package');
     var filepath = path.join(_options.outputDir, node.uri.path);
     var dir = path.dirname(filepath);
     new Directory(dir).createSync(recursive: true);
     new File(filepath).writeAsStringSync(node.source.contents.data);
   }
 
   bool _isEntry(DartSourceNode node) {
     if (_entryNode is DartSourceNode) return _entryNode == node;
     return (_entryNode as HtmlSourceNode).scripts.contains(node);
   }
 
   void _buildDartLibrary(DartSourceNode node) {
     var source = node.source;
     // TODO(sigmund): find out from analyzer team if there is a better way
     _resolver.context.applyChanges(new ChangeSet()..changedSource(source));
     var entryUnit = _resolver.context.resolveCompilationUnit2(source, source);
     var lib = entryUnit.element.enclosingElement;
     if (!_options.checkSdk && lib.isInSdk) return;
     var current = node.info;
     if (current != null) {
       assert(current.library == lib);
     } else {
       node.info = current = new LibraryInfo(lib, _isEntry(node));
     }
-    _reporter.enterLibrary(current);
+    _reporter.enterLibrary(source.uri);
     _libraries.add(current);
     _rules.currentLibraryInfo = current;
 
     var units = [entryUnit]
       ..addAll(node.parts.map(
           (p) => _resolver.context.resolveCompilationUnit2(p.source, source)));
     bool failureInLib = false;
     for (var unit in units) {
       var unitSource = unit.element.source;
       _reporter.enterSource(unitSource);
@@ skipping 15 matching lines @@
 
   CheckerResults run() {
     var clock = new Stopwatch()..start();
 
     // TODO(sigmund): we are missing a couple failures here. The
     // dependendency_graph now detects broken imports or unsupported features
     // like more than one script tag (see .severe messages in
     // dependency_graph.dart). Such failures should be reported back
     // here so we can mark failure=true in the CheckerResutls.
     rebuild(_entryNode, _graph, _buildSource);
-    if (_options.dumpInfo && _reporter is SummaryReporter) {
-      var result = (_reporter as SummaryReporter).result;
-      print(summaryToString(result));
-      if (_options.dumpInfoFile != null) {
-        new File(_options.dumpInfoFile)
-            .writeAsStringSync(JSON.encode(result.toJsonMap()));
-      }
-    }
+    _dumpInfoIfRequested();
     clock.stop();
     if (_options.serverMode) {
       var time = (clock.elapsedMilliseconds / 1000).toStringAsFixed(2);
       print('Compiled ${_libraries.length} libraries in ${time} s\n');
     }
     return new CheckerResults(
         _libraries, _rules, _failure || _options.forceCompile);
   }
 
   void _runAgain() {
     var clock = new Stopwatch()..start();
-    if (_reporter is SummaryReporter) (_reporter as SummaryReporter).clear();
     _libraries = <LibraryInfo>[];
     int changed = 0;
 
     // TODO(sigmund): propagate failures here (see TODO in run).
     rebuild(_entryNode, _graph, (n) {
       changed++;
       return _buildSource(n);
     });
-    if (_reporter is SummaryReporter) {
-      print(summaryToString((_reporter as SummaryReporter).result));
-    }
     clock.stop();
+    if (changed > 0) _dumpInfoIfRequested();
     var time = (clock.elapsedMilliseconds / 1000).toStringAsFixed(2);
     print("Compiled ${changed} libraries in ${time} s\n");
   }
+
+  _dumpInfoIfRequested() {
+    if (!_options.dumpInfo || _reporter is! SummaryReporter) return;
+    var result = (_reporter as SummaryReporter).result;
+    if (!_options.serverMode) print(summaryToString(result));
+    var filepath = _options.serverMode
+        ? path.join(_options.outputDir, 'messages.json')
+        : _options.dumpInfoFile;
+    if (filepath == null) return;
+    new File(filepath).writeAsStringSync(JSON.encode(result.toJsonMap()));
+  }
 }
 
 class CompilerServer {
   final Compiler compiler;
   final String outDir;
   final int port;
   final String _entryPath;
 
   factory CompilerServer(CompilerOptions options) {
     var entryPath = path.basename(options.entryPointFile);
@@ skipping 27 matching lines @@
   }
 
   rebuildIfNeeded(shelf.Request request) {
     var filepath = request.url.path;
     if (filepath == '/$_entryPath' || filepath == '/') compiler._runAgain();
   }
 }
 
 final _log = new Logger('dev_compiler');
 final _earlyErrorResult = new CheckerResults(const [], null, true);