FYI: add strong mode checking to error verifier's task

pkg/analyzer/lib/src/task/strong/checker.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.
 
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/scanner.dart' show Token, TokenType;
 
 import 'info.dart';
 import 'rules.dart';
 
 /// Checks for overriding declarations of fields and methods. This is used to
 /// check overrides between classes and superclasses, interfaces, and mixin
 /// applications.
 class _OverrideChecker {
   bool _failure = false;
   final TypeRules _rules;
-  final ErrorReporter _reporter;
+  final AnalysisErrorListener _reporter;
 
   _OverrideChecker(this._rules, this._reporter);
 
   void check(ClassDeclaration node) {
     if (node.element.type.isObject) return;
     _checkSuperOverrides(node);
     _checkMixinApplicationOverrides(node);
     _checkAllInterfaceOverrides(node);
   }
 
@@ skipping 277 matching lines @@
       _recordMessage(new InvalidMethodOverride(
           errorLocation, element, type, subType, baseType));
     }
     return true;
   }
 
   void _recordMessage(StaticInfo info) {
     if (info == null) return;
     var error = info.toAnalysisError();
     if (error.errorCode.errorSeverity == ErrorSeverity.ERROR) _failure = true;
-    _reporter.reportError(error);
+    _reporter.onError(error);
   }
 }
 
 /// Checks the body of functions and properties.
 class CodeChecker extends RecursiveAstVisitor {
   final TypeRules rules;
-  final ErrorReporter reporter;
+  final AnalysisErrorListener reporter;
   final _OverrideChecker _overrideChecker;
   bool _failure = false;
   bool get failure => _failure || _overrideChecker._failure;
 
   void reset() {
     _failure = false;
     _overrideChecker._failure = false;
   }
 
-  CodeChecker(TypeRules rules, ErrorReporter reporter)
+  CodeChecker(TypeRules rules, AnalysisErrorListener reporter)
       : rules = rules,
         reporter = reporter,
         _overrideChecker = new _OverrideChecker(rules, reporter);
 
   @override
   void visitComment(Comment node) {
     // skip, no need to do typechecking inside comments (they may contain
     // comment references which would require resolution).
   }
 
@@ skipping 562 matching lines @@
     return (element != null && !element.isStatic);
   }
 
   bool _isObjectProperty(Expression target, SimpleIdentifier id) {
     return _isObjectGetter(target, id) || _isObjectMethod(target, id);
   }
 
   DartType _getStaticType(Expression expr) {
     var type = expr.staticType;
     if (type == null) {
-      reporter.reportError(new MissingTypeError(expr).toAnalysisError());
+      reporter.onError(new MissingTypeError(expr).toAnalysisError());
     }
     return type ?? rules.provider.dynamicType;
   }
 
   void _recordDynamicInvoke(AstNode node, AstNode target) {
-    reporter.reportError(new DynamicInvoke(rules, node).toAnalysisError());
+    reporter.onError(new DynamicInvoke(rules, node).toAnalysisError());
     // TODO(jmesserly): we may eventually want to record if the whole operation
     // (node) was dynamic, rather than the target, but this is an easier fit
     // with what we used to do.
     DynamicInvoke.set(target, true);
   }
 
   void _recordMessage(StaticInfo info) {
     if (info == null) return;
     var error = info.toAnalysisError();
     if (error.errorCode.errorSeverity == ErrorSeverity.ERROR) _failure = true;
-    reporter.reportError(error);
+    reporter.onError(error);
 
     if (info is CoercionInfo) {
       // TODO(jmesserly): if we're run again on the same AST, we'll produce the
       // same annotations. This should be harmless. This might go away once
       // CodeChecker is integrated better with analyzer, as it will know that
       // checking has already been performed.
       // assert(CoercionInfo.get(info.node) == null);
       CoercionInfo.set(info.node, info);
     }
   }
@@ skipping 26 matching lines @@
       }
     } catch (e) {
       // TODO(sigmund): remove this try-catch block (see issue #48).
     }
     if (baseMethod == null || baseMethod.isStatic) return null;
     return baseMethod.type;
   }
   ;
   return f;
 }