Add widget to display errors, and report dependency_graph errors correctly

lib/src/checker/resolver.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.
 
 /// Encapsulates how to invoke the analyzer resolver and overrides how it
 /// computes types on expressions to use our restricted set of types.
 library dev_compiler.src.checker.resolver;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
-import 'package:analyzer/src/generated/error.dart';
+import 'package:analyzer/src/generated/error.dart' as analyzer;
 import 'package:analyzer/src/generated/java_io.dart' show JavaFile;
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
 import 'package:analyzer/src/generated/sdk_io.dart' show DirectoryBasedDartSdk;
 import 'package:analyzer/src/generated/source.dart' show DartUriResolver;
 import 'package:analyzer/src/generated/source.dart' show Source;
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:logging/logging.dart' as logger;
 
 import 'package:dev_compiler/src/options.dart';
@@ skipping 43 matching lines @@
   /// Find the corresponding [Source] for [uri].
   Source findSource(Uri uri) {
     var source = _sources[uri];
     if (source != null) return source;
     return _sources[uri] = context.sourceFactory.forUri('$uri');
   }
 
   /// Log any errors encountered when resolving [source] and return whether any
   /// errors were found.
   bool logErrors(Source source, CheckerReporter reporter) {
-    List<AnalysisError> errors = context.getErrors(source).errors;
+    List<analyzer.AnalysisError> errors = context.getErrors(source).errors;
     bool failure = false;
     if (errors.isNotEmpty) {
       for (var error in errors) {
-        var severity = error.errorCode.errorSeverity;
-        var isError = severity == ErrorSeverity.ERROR;
-        if (isError) failure = true;
-        var level = isError ? logger.Level.SEVERE : logger.Level.WARNING;
-        reporter.logAnalyzerError(
-            error.message, level, error.offset, error.offset + error.length);
+        var message = new AnalyzerError.from(error);
+        if (message.level == logger.Level.SEVERE) failure = true;
+        reporter.log(message);

[Siggi Cherem (dart-lang), 2015/03/07 02:43:01]

I am unifying the error reporting using the new [Message] class

[vsm, 2015/03/09 15:14:36]

Nice!

       }
     }
     return failure;
   }
 }
 
+class AnalyzerError extends Message {
+  factory AnalyzerError.from(analyzer.AnalysisError error) {
+    var severity = error.errorCode.errorSeverity;
+    var isError = severity == analyzer.ErrorSeverity.ERROR;
+    var level = isError ? logger.Level.SEVERE : logger.Level.WARNING;
+    int begin = error.offset;
+    int end = begin + error.length;
+    return new AnalyzerError(error.message, level, begin, end);
+  }
+
+  const AnalyzerError(String message, logger.Level level, int begin, int end)
+      : super('[from analyzer]: $message', level, begin, end);
+}
+
 /// Creates an analysis context that contains our restricted typing rules.
 InternalAnalysisContext _initContext(ResolverOptions options) {
   var analysisOptions = new AnalysisOptionsImpl()..cacheSize = 512;
   AnalysisContextImpl res = AnalysisEngine.instance.createAnalysisContext();
   res.analysisOptions = analysisOptions;
   res.resolverVisitorFactory = RestrictedResolverVisitor.constructor(options);
   if (options.inferFromOverrides) {
     res.typeResolverVisitorFactory = RestrictedTypeResolverVisitor.constructor;
   }
   return res;
@@ skipping 335 matching lines @@
         element.returnType.isDynamic &&
         node.returnType == null) {
       var type = searchTypeFor(element.enclosingElement.type, element);
       if (type != null && !type.returnType.isDynamic) {
         element.returnType = type.returnType;
       }
     }
     return res;
   }
 }