Refactor strong mode to use standard Analyzer errors

pkg/analyzer/lib/src/generated/type_system.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 analyzer.src.generated.type_system;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/dart/ast/token.dart' show TokenType;
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
-import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
+import 'package:analyzer/src/generated/engine.dart'
+    show AnalysisContext, AnalysisOptionsImpl;
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 typedef bool _GuardedSubtypeChecker<T>(T t1, T t2, Set<Element> visited);
 
 /**
  * Implementation of [TypeSystem] using the strong mode rules.
  * https://github.com/dart-lang/dev_compiler/blob/master/STRONG_MODE.md
  */
 class StrongTypeSystemImpl extends TypeSystem {
+  /**
+   * True if implicit casts should be allowed, otherwise false.
+   *
+   * This affects the behavior of [isAssignableTo].
+   */
+  final bool implicitCasts;
+
+  StrongTypeSystemImpl({this.implicitCasts: true});
+
   bool anyParameterType(FunctionType ft, bool predicate(DartType t)) {
     return ft.parameters.any((p) => predicate(p.type));
   }
 
   @override
   bool canPromoteToType(DartType to, DartType from) => isSubtypeOf(to, from);
 
   @override
   FunctionType functionTypeToConcreteType(
       TypeProvider typeProvider, FunctionType t) {
@@ skipping 252 matching lines @@
     // An actual subtype
     if (isSubtypeOf(fromType, toType)) {
       return true;
     }
 
     // Don't allow implicit downcasts between function types
     // and call method objects, as these will almost always fail.
     if ((fromType is FunctionType && getCallMethodType(toType) != null) ||
         (toType is FunctionType && getCallMethodType(fromType) != null)) {
       return false;
     }

[Leaf, 2016/06/11 00:24:39]

I think this (and the next check) can be moved under the implicitCasts flag. 
Probably doesn't make much difference but doesn't hurt to skip some is checks
when possible.

[Jennifer Messerly, 2016/06/11 00:40:38]

Ah yes, great idea!

 
     // Don't allow a non-generic function where a generic one is expected. The
     // former wouldn't know how to handle type arguments being passed to it.
     // TODO(rnystrom): This same check also exists in FunctionTypeImpl.relate()
     // but we don't always reliably go through that code path. This should be
     // cleaned up to avoid the redundancy.
     if (fromType is FunctionType &&
         toType is FunctionType &&
         fromType.typeFormals.isEmpty &&
         toType.typeFormals.isNotEmpty) {
       return false;
     }
 
-    // If the subtype relation goes the other way, allow the implicit downcast.
-    // TODO(leafp): Emit warnings and hints for these in some way.
-    // TODO(leafp): Consider adding a flag to disable these?  Or just rely on
-    //   --warnings-as-errors?
-    if (isSubtypeOf(toType, fromType) || toType.isAssignableTo(fromType)) {
-      // TODO(leafp): error if type is known to be exact (literal,
-      //  instance creation).
-      // TODO(leafp): Warn on composite downcast.
-      // TODO(leafp): hint on object/dynamic downcast.
-      // TODO(leafp): Consider allowing assignment casts.
-      return true;
+    if (implicitCasts) {
+      // If the subtype relation goes the other way, allow the implicit
+      // downcast.
+      if (isSubtypeOf(toType, fromType) || toType.isAssignableTo(fromType)) {
+        // TODO(leafp,jmesserly): we emit warnings/hints for these in
+        // src/task/strong/checker.dart, which is a bit inconsistent. That
+        // code should be handled into places that use isAssignableTo, such as
+        // ErrorVerifier.
+        return true;
+      }
     }
 
     return false;
   }
 
   bool isGroundType(DartType t) {
     // TODO(leafp): Revisit this.
     if (t is TypeParameterType) {
       return false;
     }
@@ skipping 840 matching lines @@
    * [TypeParameterType], return their least upper bound in a type system
    * specific manner.
    */
   DartType _typeParameterLeastUpperBound(
       TypeProvider provider, DartType type1, DartType type2);
 
   /**
    * Create either a strong mode or regular type system based on context.
    */
   static TypeSystem create(AnalysisContext context) {
-    return (context.analysisOptions.strongMode)
-        ? new StrongTypeSystemImpl()
+    var options = context.analysisOptions as AnalysisOptionsImpl;
+    return options.strongMode
+        ? new StrongTypeSystemImpl(implicitCasts: options.implicitCasts)
         : new TypeSystemImpl();
   }
 }
 
 /**
  * Implementation of [TypeSystem] using the rules in the Dart specification.
  */
 class TypeSystemImpl extends TypeSystem {
   TypeSystemImpl();
 
@@ skipping 283 matching lines @@
       } else {
         passedOut = true;
       }
     } else if (type is FunctionType) {
       _visitFunctionType(typeParam, type, paramIn);
     } else if (type is InterfaceType) {
       _visitInterfaceType(typeParam, type, paramIn);
     }
   }
 }