remove ignoreTypes flag, to reimplement later, see #134

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';
 
@@ skipping 57 matching lines @@
     var t = getStaticType(applicand);
     if (t is InterfaceType) {
       return getCallMethodType(t);
     }
     if (t is FunctionType) return t;
     return null;
   }
 
   DartType elementType(Element e);
 
-  bool isDynamic(DartType t);
   bool isDynamicTarget(Expression expr);
   bool isDynamicCall(Expression call);
 }
 
+// TODO(jmesserly): this is unused.
 class DartRules extends TypeRules {
   DartRules(TypeProvider provider) : super(provider);
 
   MissingTypeReporter reportMissingType = null;
 
   bool isSubTypeOf(DartType t1, DartType t2) {
     return t1.isSubtypeOf(t2);
   }
 
   bool isAssignable(DartType t1, DartType t2) {
@@ skipping 365 matching lines @@
     }
     if (c is Cast) return DownCast.create(this, expr, c, reason: reason);
     assert(false);
     return null;
   }
 
   DartType elementType(Element e) {
     return (e as dynamic).type;
   }
 
-  bool isDynamic(DartType t) => options.ignoreTypes || t.isDynamic;
-
   /// Returns `true` if the target expression is dynamic.
-  bool isDynamicTarget(Expression target) =>
-      options.ignoreTypes || utils.isDynamicTarget(target);
+  // TODO(jmesserly): remove this in favor of utils? Or a static method here?
+  bool isDynamicTarget(Expression target) => utils.isDynamicTarget(target);
 
   /// Returns `true` if the expression is a dynamic function call or method
   /// invocation.
   bool isDynamicCall(Expression call) {
-    if (options.ignoreTypes) return true;
     var t = getTypeAsCaller(call);
     // TODO(leafp): This will currently return true if t is Function
     // This is probably the most correct thing to do for now, since
     // this code is also used by the back end.  Maybe revisit at some
     // point?
     if (t == null) return true;
     // Dynamic as the parameter type is treated as bottom.  A function with
     // a dynamic parameter type requires a dynamic call in general.
     // However, as an optimization, if we have an original definition, we know
     // dynamic is reified as Object - in this case a regular call is fine.
@@ skipping 293 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;
   }
 }