remove most of the StrongOptions

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 386 matching lines @@
 
     // Downcast if toT <: fromT
     if (isSubTypeOf(toT, fromT)) return Coercion.cast(fromT, toT);
 
     // Downcast if toT <===> fromT
     // The intention here is to allow casts that are sideways in the restricted
     // type system, but allowed in the regular dart type system, since these
     // are likely to succeed.  The canonical example is List<dynamic> and
     // Iterable<T> for some concrete T (e.g. Object).  These are unrelated
     // in the restricted system, but List<dynamic> <: Iterable<T> in dart.
-    if (options.relaxedCasts && fromT.isAssignableTo(toT)) {
+    if (fromT.isAssignableTo(toT)) {
       return Coercion.cast(fromT, toT);
     }
     return Coercion.error();
   }
 
   StaticInfo checkAssignment(Expression expr, DartType toT) {
     final fromT = getStaticType(expr);
     final Coercion c = _coerceTo(fromT, toT);
     if (c is Identity) return null;
     if (c is CoercionError) return new StaticTypeError(this, expr, toT);
     var reason = null;
-    if (options.inferDownwards) {
-      var errors = <String>[];
-      var ok = inferrer.inferExpression(expr, toT, errors);
-      if (ok) return InferredType.create(this, expr, toT);
-      reason = (errors.isNotEmpty) ? errors.first : null;
-    }
+
+    var errors = <String>[];
+    var ok = inferrer.inferExpression(expr, toT, errors);
+    if (ok) return InferredType.create(this, expr, toT);
+    reason = (errors.isNotEmpty) ? errors.first : null;
+
     if (c is Cast) return DownCast.create(this, expr, c, reason: reason);
     assert(false);
     return null;
   }
 
   DartType elementType(Element e) {
     if (e == null) {
       // Malformed code - just return dynamic.
       return provider.dynamicType;
     }
@@ skipping 313 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;
   }
 }