Factor out reporting from rules

lib/src/checker/rules.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.
 
 library dev_compiler.src.checker.rules;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/options.dart';
-import 'package:dev_compiler/src/report.dart' show CheckerReporter;
 
 abstract class TypeRules {
   final TypeProvider provider;
   LibraryInfo currentLibraryInfo = null;
 
   TypeRules(TypeProvider this.provider);
 
+  set reportMissingType(MissingTypeReporter callback);
+  MissingTypeReporter get reportMissingType;
+
   bool isSubTypeOf(DartType t1, DartType t2);
   bool isAssignable(DartType t1, DartType t2);
 
   bool isGroundType(DartType t) => true;
   // TODO(vsm): The default implementation is not ignoring the return type,
   // only the restricted override is.
   bool isFunctionSubTypeOf(FunctionType f1, FunctionType f2,
           {bool fuzzyArrows: true, bool ignoreReturn: false}) =>
       isSubTypeOf(f1, f2);
 
@@ skipping 13 matching lines @@
 
   bool isDynamic(DartType t);
   bool isDynamicTarget(Expression expr);
   bool isDynamicGet(Expression expr);
   bool isDynamicCall(Expression call);
 }
 
 class DartRules extends TypeRules {
   DartRules(TypeProvider provider) : super(provider);
 
+  set reportMissingType(MissingTypeReporter callback) {}
+  MissingTypeReporter get reportMissingType => null;
+
   bool isSubTypeOf(DartType t1, DartType t2) {
     return t1.isSubtypeOf(t2);
   }
 
   bool isAssignable(DartType t1, DartType t2) {
     return t1.isAssignableTo(t2);
   }
 
   StaticInfo checkAssignment(
       Expression expr, DartType toType, bool constContext) {
     final fromType = getStaticType(expr);
     if (!isAssignable(fromType, toType)) {
       return new StaticTypeError(this, expr, toType);
     }
     return null;
   }
 
   DartType elementType(Element e) {
     return (e as dynamic).type;
   }
 
   /// By default, all invocations are dynamic in Dart.
   bool isDynamic(DartType t) => true;
   bool isDynamicTarget(Expression expr) => true;
   bool isDynamicGet(Expression expr) => true;
   bool isDynamicCall(Expression call) => true;
 }
 
+typedef void MissingTypeReporter(Expression expr);
+
 class RestrictedRules extends TypeRules {
-  final CheckerReporter _reporter;
+  MissingTypeReporter _reporter;
   final RulesOptions options;
   final List<DartType> _nonnullableTypes;
   DownwardsInference inferrer;
 
+  set reportMissingType(MissingTypeReporter callback) => _reporter = callback;

[Jennifer Messerly, 2015/04/07 14:52:22]

this should just be a field?

MissingTypeReporter reportMissingType;

it will induce the getter/setter pair

[Leaf, 2015/04/07 16:56:25]

Done.

+  MissingTypeReporter get reportMissingType => _reporter;
+
   DartType _typeFromName(String name) {
     switch (name) {
       case 'int':
         return provider.intType;
       case 'double':
         return provider.doubleType;
       case 'num':
         return provider.numType;
       case 'bool':
         return provider.boolType;
       case 'String':
         return provider.stringType;
       default:
         throw new UnsupportedError('Unsupported non-nullable type $name');
     }
   }
 
-  RestrictedRules(TypeProvider provider, this._reporter, {this.options})
+  RestrictedRules(TypeProvider provider, {this.options})
       : _nonnullableTypes = <DartType>[],
         super(provider) {
     var types = options.nonnullableTypes;
     _nonnullableTypes.addAll(types.map(_typeFromName));
     inferrer = new DownwardsInference(this);
   }
 
   DartType getStaticType(Expression expr) {
     var type = expr.staticType;
     if (type != null) return type;
-    _reporter.log(new MissingTypeError(expr));
+    if (_reporter != null) _reporter(expr);
     return provider.dynamicType;
   }
 
   bool _isBottom(DartType t, {bool dynamicIsBottom: false}) {
     if (t.isDynamic && dynamicIsBottom) return true;
     // TODO(vsm): We need direct support for non-nullability in DartType.
     // This should check on "true/nonnullable" Bottom
     if (t.isBottom && _nonnullableTypes.isEmpty) return true;
     return false;
   }
@@ skipping 701 matching lines @@
     var entries = e.entries;
     bool inferEntry(MapLiteralEntry entry) {
       return _inferExpression(entry.key, kType, errors) &&
           _inferExpression(entry.value, vType, errors);
     }
     var b = entries.every(inferEntry);
     if (b) annotateMapLiteral(e, targs);
     return b;
   }
 }