Allow S->T <: dynamic->T

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 144 matching lines @@
       FunctionType callType = manager.lookupMemberType(t, "call");
       return callType;
     }
     return null;
   }
 
   /// Check that f1 is a subtype of f2. [ignoreReturn] is used in the DDC
   /// checker to determine whether f1 would be a subtype of f2 if the return
   /// type of f1 is set to match f2's return type.
   bool isFunctionSubTypeOf(FunctionType f1, FunctionType f2,
-      {bool ignoreReturn: false}) {
+      {bool dynamicIsBottom: false, bool ignoreReturn: false}) {
     final r1s = f1.normalParameterTypes;
     final o1s = f1.optionalParameterTypes;
     final n1s = f1.namedParameterTypes;
     final r2s = f2.normalParameterTypes;
     final o2s = f2.optionalParameterTypes;
     final n2s = f2.namedParameterTypes;
     final ret1 = ignoreReturn ? f2.returnType : f1.returnType;
     final ret2 = f2.returnType;
 
     // A -> B <: C -> D if C <: A and
     // either D is void or B <: D
     if (!ret2.isVoid && !isSubTypeOf(ret1, ret2)) return false;
 
     // Reject if one has named and the other has optional
     if (n1s.length > 0 && o2s.length > 0) return false;
     if (n2s.length > 0 && o1s.length > 0) return false;
 
     // f2 has named parameters
     if (n2s.length > 0) {
       // Check that every named parameter in f2 has a match in f1
       for (String k2 in n2s.keys) {
         if (!n1s.containsKey(k2)) return false;
-        if (!isSubTypeOf(n2s[k2], n1s[k2])) return false;
+        if (!isSubTypeOf(n2s[k2], n1s[k2], dynamicIsBottom: true)) return false;
       }
     }
     // If we get here, we either have no named parameters,
     // or else the named parameters match and we have no optional
     // parameters
 
     // If f1 has more required parameters, reject
     if (r1s.length > r2s.length) return false;
 
     // If f2 has more required + optional parameters, reject
     if (r2s.length + o2s.length > r1s.length + o1s.length) return false;
 
     // The parameter lists must look like the following at this point
     // where rrr is a region of required, and ooo is a region of optionals.
     // f1: rrr ooo ooo ooo
     // f2: rrr rrr ooo
     int rr = r1s.length; // required in both
     int or = r2s.length - r1s.length; // optional in f1, required in f2
     int oo = o2s.length; // optional in both
 
     for (int i = 0; i < rr; ++i) {
-      if (!isSubTypeOf(r2s[i], r1s[i])) return false;
+      if (!isSubTypeOf(r2s[i], r1s[i], dynamicIsBottom: true)) return false;
     }
     for (int i = 0, j = rr; i < or; ++i, ++j) {
-      if (!isSubTypeOf(r2s[j], o1s[i])) return false;
+      if (!isSubTypeOf(r2s[j], o1s[i], dynamicIsBottom: true)) return false;
     }
     for (int i = or, j = 0; i < oo; ++i, ++j) {
-      if (!isSubTypeOf(o2s[j], o1s[i])) return false;
+      if (!isSubTypeOf(o2s[j], o1s[i], dynamicIsBottom: true)) return false;
     }
     return true;
   }
 
   bool _isInterfaceSubTypeOf(InterfaceType i1, InterfaceType i2) {
     if (i1 == i2) return true;
 
     if (i1.element == i2.element) {
       List<DartType> tArgs1 = i1.typeArguments;
       List<DartType> tArgs2 = i2.typeArguments;
@@ skipping 26 matching lines @@
       if (_isInterfaceSubTypeOf(parent, i2)) return true;
     }
 
     for (final parent in i1.mixins) {
       if (_isInterfaceSubTypeOf(parent, i2)) return true;
     }
 
     return false;
   }
 
-  bool isSubTypeOf(DartType t1, DartType t2) {
+  bool isSubTypeOf(DartType t1, DartType t2, {bool dynamicIsBottom: false}) {
     if (t1 == t2) return true;
 
+    if (t2.isDynamic) return !dynamicIsBottom;
+    // In negative state, dynamic acts as bottom as well as top, but in a

[Leaf, 2015/03/18 22:57:25]

This comment I think is left over from the polarity version?

[vsm, 2015/03/18 23:40:32]

Done.

+    // positive (normal) state, we disallow this subtyping.
+    if (t1.isDynamic) return dynamicIsBottom;
+
     // Null can be assigned to anything non-primitive.
     // FIXME: Can this be anything besides null?
     if (t1.isBottom) {
       // Return false iff t2 *may* be a primitive type.
       return !maybeNonNullableType(t2);
     }
     if (t2.isBottom) return false;
 
-    if (t2.isDynamic) return true;
-    if (t1.isDynamic) return false;
-
     // Trivially true for non-primitives.
     if (t2 == provider.objectType) return true;
     if (t1 == provider.objectType) return false;
 
     // S <: T where S is a type variable
     //  T is not dynamic or object (handled above)
     //  S != T (handled above)
     //  So only true if bound of S is S' and
     //  S' <: T
     if (t1 is TypeParameterType) {
@@ skipping 202 matching lines @@
     return t.isDynamic || t.isDartCoreFunction;
   }
 
   /// Returns `true` if the expression is a dynamic function call or method
   /// invocation.
   bool isDynamicCall(Expression call) {
     if (options.ignoreTypes) return true;
     var t = getStaticType(call);
     // TODO(jmesserly): fix handling of types with `call` methods. These are not
     // FunctionType, but they also aren't dynamic calls.
-    return t.isDynamic || t.isDartCoreFunction || t is! FunctionType;
+    if (t.isDynamic || t.isDartCoreFunction || t is! FunctionType) {
+      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.
+    if (call is SimpleIdentifier) {

[Leaf, 2015/03/18 22:57:25]

This could probably be done for at least some prefixed identifiers as well.

[vsm, 2015/03/18 23:40:32]

The "call" expression is the method name (not the actual call expression) the
way this is currently used.

+      var element = call.staticElement;
+      if (element is FunctionElement || element is MethodElement) {
+        // An original declaration.
+        return false;
+      }
+    }
+    var ft = t as FunctionType;
+    for (var parameterType in ft.normalParameterTypes) {
+      if (parameterType.isDynamic) return true;
+    }
+    for (var parameterType in ft.optionalParameterTypes) {
+      if (parameterType.isDynamic) return true;
+    }
+    for (var parameterType in ft.namedParameterTypes.values) {
+      if (parameterType.isDynamic) return true;
+    }
+    return false;
   }
 }