more housecleaning: remove DartRules and reportMissingType

lib/src/checker/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.
 
 library dev_compiler.src.checker.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;
@@ skipping 322 matching lines @@
     _failure = false;
     _overrideChecker._failure = false;
   }
 
   CodeChecker(TypeRules rules, AnalysisErrorListener reporter)
       : rules = rules,
         reporter = reporter,
         _overrideChecker = new _OverrideChecker(rules, reporter);
 
   @override
-  void visitCompilationUnit(CompilationUnit unit) {
-    void report(Expression expr) {
-      reporter.onError(new MissingTypeError(expr).toAnalysisError());
-    }
-    var callback = rules.reportMissingType;
-    rules.reportMissingType = report;
-    unit.visitChildren(this);
-    rules.reportMissingType = callback;
-  }
-
-  @override
   void visitComment(Comment node) {
     // skip, no need to do typechecking inside comments (they may contain
     // comment references which would require resolution).
   }
 
   @override
   void visitClassDeclaration(ClassDeclaration node) {
     _overrideChecker.check(node);
     super.visitClassDeclaration(node);
   }
 
   @override
   void visitAssignmentExpression(AssignmentExpression node) {
     var token = node.operator;
     if (token.type != TokenType.EQ) {
       _checkCompoundAssignment(node);
     } else {
-      DartType staticType = rules.getStaticType(node.leftHandSide);
+      DartType staticType = _getStaticType(node.leftHandSide);
       checkAssignment(node.rightHandSide, staticType);
     }
     node.visitChildren(this);
   }
 
   /// Check constructor declaration to ensure correct super call placement.
   @override
   void visitConstructorDeclaration(ConstructorDeclaration node) {
     node.visitChildren(this);
 
@@ skipping 505 matching lines @@
       // Sanity check the operator
       assert(methodElement.isOperator);
       var functionType = methodElement.type;
       var paramTypes = functionType.normalParameterTypes;
       assert(paramTypes.length == 1);
       assert(functionType.namedParameterTypes.isEmpty);
       assert(functionType.optionalParameterTypes.isEmpty);
 
       // Check the lhs type
       var staticInfo;
-      var rhsType = rules.getStaticType(expr.rightHandSide);
-      var lhsType = rules.getStaticType(expr.leftHandSide);
+      var rhsType = _getStaticType(expr.rightHandSide);
+      var lhsType = _getStaticType(expr.leftHandSide);
       var returnType = _specializedBinaryReturnType(
           op, lhsType, rhsType, functionType.returnType);
 
       if (!rules.isSubTypeOf(returnType, lhsType)) {
         final numType = rules.provider.numType;
         // Try to fix up the numerical case if possible.
         if (rules.isSubTypeOf(lhsType, numType) &&
             rules.isSubTypeOf(lhsType, rhsType)) {
           // This is also slightly different from spec, but allows us to keep
           // compound operators in the int += num and num += dynamic cases.
@@ skipping 25 matching lines @@
   bool _isObjectMethod(Expression target, SimpleIdentifier id) {
     MethodElement element =
         rules.provider.objectType.element.getMethod(id.name);
     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.onError(new MissingTypeError(expr).toAnalysisError());
+    }
+    return type ?? rules.provider.dynamicType;
+  }
+
   void _recordDynamicInvoke(AstNode node, AstNode target) {
     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.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);
     }
   }
 }