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

lib/strong_mode.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.
 
 /// Types needed to implement "strong" checking in the Dart analyzer.
 /// This is intended to be used by analyzer_cli and analysis_server packages.
 library dev_compiler.strong_mode;
 
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContextImpl, AnalysisErrorInfo, AnalysisErrorInfoImpl;
 import 'package:analyzer/src/generated/error.dart'
     show
         AnalysisError,
+        AnalysisErrorListener,
+        CompileTimeErrorCode,
         ErrorCode,
-        CompileTimeErrorCode,
-        StaticTypeWarningCode,
-        HintCode;
+        ErrorSeverity,
+        HintCode,
+        StaticTypeWarningCode;
 import 'package:analyzer/src/generated/source.dart' show Source;
 import 'package:args/args.dart';
-import 'package:logging/logging.dart' show Level;
 
 import 'src/checker/checker.dart' show CodeChecker;
 import 'src/checker/resolver.dart' show LibraryResolverWithInference;
 import 'src/checker/rules.dart' show RestrictedRules;
-import 'src/report.dart' show CheckerReporter, Message;
 
 /// A type checker for Dart code that operates under stronger rules, and has
 /// the ability to do local type inference in some situations.
 class StrongChecker {
   final AnalysisContextImpl _context;
   final CodeChecker _checker;
-  final _ErrorReporter _reporter;
-  final StrongModeOptions _options;
+  final _ErrorCollector _reporter;
 
-  StrongChecker._(this._context, this._options, this._checker, this._reporter);
+  StrongChecker._(this._context, this._checker, this._reporter);
 
   factory StrongChecker(
       AnalysisContextImpl context, StrongModeOptions options) {
     // TODO(jmesserly): is there a cleaner way to plug this in?
     if (context.libraryResolverFactory != null) {
       throw new ArgumentError.value(context, 'context',
           'Analysis context must not have libraryResolverFactory already set.');
     }
     context.libraryResolverFactory =
         (c) => new LibraryResolverWithInference(c, options);
 
     var rules = new RestrictedRules(context.typeProvider, options: options);
-    var reporter = new _ErrorReporter();
+    var reporter = new _ErrorCollector(options.hints);
     var checker = new CodeChecker(rules, reporter, options);
-    return new StrongChecker._(context, options, checker, reporter);
+    return new StrongChecker._(context, checker, reporter);
   }
 
   /// Computes and returns DDC errors for the [source].
   AnalysisErrorInfo computeErrors(Source source) {
     var errors = new List<AnalysisError>();
-
-    // TODO(jmesserly): change DDC to emit ErrorCodes directly.
-    _reporter._log = (Message msg) {
-      // Skip hints unless requested.
-      if (msg.level < Level.WARNING && !_options.hints) return;
-
-      var errorCodeFactory = _levelToErrorCode[msg.level];
-      var category = '${msg.runtimeType}';
-      var errorCode = errorCodeFactory(category, msg.message);
-      var len = msg.end - msg.begin;
-      errors.add(new AnalysisError(source, msg.begin, len, errorCode));
-    };
+    _reporter.errors = errors;
 
     for (Source librarySource in _context.getLibrariesContaining(source)) {
       var resolved = _context.resolveCompilationUnit2(source, librarySource);
       _checker.visitCompilationUnit(resolved);
     }
-    _reporter._log = null;
+    _reporter.errors = null;
+
     return new AnalysisErrorInfoImpl(errors, _context.getLineInfo(source));
   }
 }
 
-/// Maps a DDC log level to an analyzer ErrorCode subclass.
-final _levelToErrorCode = <Level, _ErrorCodeFactory>{
-  Level.SEVERE: (n, m) => new CompileTimeErrorCode(n, m),
-  Level.WARNING: (n, m) => new StaticTypeWarningCode(n, m),
-  Level.INFO: (n, m) => new HintCode(n, m)
-};
+class _ErrorCollector implements AnalysisErrorListener {
+  List<AnalysisError> errors;
+  final bool hints;
+  _ErrorCollector(this.hints);
 
-class _ErrorReporter implements CheckerReporter {
-  _CheckerReporterLog _log;
-  void log(Message message) => _log(message);
+  void onError(AnalysisError error) {
+    // Unless DDC hints are requested, filter them out.
+    var HINT = ErrorSeverity.INFO.ordinal;
+    if (hints || error.errorCode.errorSeverity.ordinal > HINT) {
+      errors.add(error);
+    }
+  }
 }
 
 class StrongModeOptions {
 
   /// Whether to infer return types and field types from overridden members.
   final bool inferFromOverrides;
   static const inferFromOverridesDefault = true;
 
   /// Whether to infer types for consts and fields by looking at initializers on
   /// the RHS. For example, in a constant declaration like:
@@ skipping 91 matching lines @@
     return inferFromOverrides == s.inferFromOverrides &&
         inferTransitively == s.inferTransitively &&
         onlyInferConstsAndFinalFields == s.onlyInferConstsAndFinalFields &&
         inferDownwards == s.inferDownwards &&
         relaxedCasts == s.relaxedCasts &&
         nonnullableTypes.length == s.nonnullableTypes.length &&
         new Set.from(nonnullableTypes).containsAll(s.nonnullableTypes);
   }
 }
 
-typedef void _CheckerReporterLog(Message message);
-typedef ErrorCode _ErrorCodeFactory(String name, String message);
-
 List<String> _optionsToList(String option,
     {List<String> defaultValue: const <String>[]}) {
   if (option == null) {
     return defaultValue;
   } else if (option.isEmpty) {
     return <String>[];
   } else {
     return option.split(',');
   }
 }