Inference casts to dynamic, fuzzy types handled

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';
 
 import 'package:dev_compiler/src/info.dart';
 import 'package:dev_compiler/src/options.dart';
 import 'package:dev_compiler/src/report.dart' show CheckerReporter;
 
 abstract class TypeRules {
   final TypeProvider provider;
   LibraryInfo currentLibraryInfo = null;
 
   TypeRules(TypeProvider this.provider);
 
   bool isSubTypeOf(DartType t1, DartType t2);
   bool isAssignable(DartType t1, DartType t2);
 
   bool isGroundType(DartType t) => true;
   // TODO(vsm): The default implementation is not ignoring the return type,
   // only the restricted override is.
   bool isFunctionSubTypeOf(FunctionType f1, FunctionType f2,
-      {bool ignoreReturn: false}) => isSubTypeOf(f1, f2);
+          {bool fuzzyArrows: true, bool ignoreReturn: false}) =>
+      isSubTypeOf(f1, f2);
 
   bool isBoolType(DartType t) => t == provider.boolType;
   bool isDoubleType(DartType t) => t == provider.doubleType;
   bool isIntType(DartType t) => t == provider.intType;
   bool isNumType(DartType t) => t == provider.intType.superclass;
   bool isStringType(DartType t) => t == provider.stringType;
   bool isNonNullableType(DartType t) => false;
   bool maybeNonNullableType(DartType t) => false;
 
   StaticInfo checkAssignment(Expression expr, DartType t, bool constContext);
@@ skipping 147 matching lines @@
       InheritanceManager manager = new InheritanceManager(element.library);
       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.
+  // [fuzzyArrows] indicates whether or not the f1 and f2 should be
+  // treated as fuzzy arrow types (and hence dynamic parameters to f2 treated as
+  // bottom).
   bool isFunctionSubTypeOf(FunctionType f1, FunctionType f2,
-      {bool dynamicIsBottom: false, bool ignoreReturn: false}) {
+      {bool fuzzyArrows: true, 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], dynamicIsBottom: true)) return false;
+        if (!isSubTypeOf(n2s[k2], n1s[k2],
+            dynamicIsBottom: fuzzyArrows)) 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], dynamicIsBottom: true)) return false;
+      if (!isSubTypeOf(r2s[i], r1s[i],
+          dynamicIsBottom: fuzzyArrows)) return false;
     }
     for (int i = 0, j = rr; i < or; ++i, ++j) {
-      if (!isSubTypeOf(r2s[j], o1s[i], dynamicIsBottom: true)) return false;
+      if (!isSubTypeOf(r2s[j], o1s[i],
+          dynamicIsBottom: fuzzyArrows)) return false;
     }
     for (int i = or, j = 0; i < oo; ++i, ++j) {
-      if (!isSubTypeOf(o2s[j], o1s[i], dynamicIsBottom: true)) return false;
+      if (!isSubTypeOf(o2s[j], o1s[i],
+          dynamicIsBottom: fuzzyArrows)) 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 305 matching lines @@
   /// Called for each list literal which gets inferred
   void annotateListLiteral(ListLiteral e, List<DartType> targs) {}
 
   /// Called for each map literal which gets inferred
   void annotateMapLiteral(MapLiteral e, List<DartType> targs) {}
 
   /// Called for each new/const which gets inferred
   void annotateInstanceCreationExpression(
       InstanceCreationExpression e, List<DartType> targs) {}
 
+  /// Called for cast from dynamic required for inference to succeed
+  void annotateCastFromDynamic(Expression e, DartType t) {}
+
+  /// Called for each function expression return type inferred
+  void annotateFunctionExpression(FunctionExpression e, DartType returnType) {}
+
   /// Downward inference
   bool inferExpression(Expression e, DartType t, List<String> errors) {
-    if (e is Conversion) return inferExpression(e.node, t, errors);
+    // Don't cast top level expressions, only sub-expressions
+    return _inferExpression(e, t, errors, cast: false);
+  }
+
+  /// Downward inference
+  bool _inferExpression(Expression e, DartType t, List<String> errors,
+      {cast: true}) {
+    if (e is Conversion) return _inferExpression(e.node, t, errors);
     if (rules.isSubTypeOf(rules.getStaticType(e), t)) return true;
+    if (cast && rules.getStaticType(e).isDynamic) {
+      annotateCastFromDynamic(e, t);
+      return true;
+    }
     if (e is FunctionExpression) return _inferFunctionExpression(e, t, errors);
     if (e is ListLiteral) return _inferListLiteral(e, t, errors);
     if (e is MapLiteral) return _inferMapLiteral(e, t, errors);
     if (e is NamedExpression) return _inferNamedExpression(e, t, errors);
     if (e is InstanceCreationExpression) return _inferInstanceCreationExpression(
         e, t, errors);
     errors.add("$e cannot be typed as $t");
     return false;
   }
 
@@ skipping 113 matching lines @@
     var fType = baseType.substitute2(targs, tparams);
     {
       var rTypes = fType.normalParameterTypes;
       var oTypes = fType.optionalParameterTypes;
       var pTypes = new List.from(rTypes)..addAll(oTypes);
       var pArgs = arguments.where((x) => x is! NamedExpression);
       var pi = 0;
       for (var arg in pArgs) {
         if (pi >= pTypes.length) return false;
         var argType = pTypes[pi];
-        if (!inferExpression(arg, argType, errors)) return false;
+        if (!_inferExpression(arg, argType, errors)) return false;
         pi++;
       }
       var nTypes = fType.namedParameterTypes;
       for (var arg0 in arguments) {
         if (arg0 is! NamedExpression) continue;
         var arg = arg0 as NamedExpression;
         SimpleIdentifier nameNode = arg.name.label;
         String name = nameNode.name;
         var argType = nTypes[name];
         if (argType == null) return false;
-        if (!inferExpression(arg, argType, errors)) return false;
+        if (!_inferExpression(arg, argType, errors)) return false;
       }
     }
     annotateInstanceCreationExpression(e, targs);
     return true;
   }
 
   bool _inferNamedExpression(NamedExpression e, DartType t, errors) {
-    return inferExpression(e.expression, t, errors);
+    return _inferExpression(e.expression, t, errors);
   }
 
   bool _inferFunctionExpression(FunctionExpression e, DartType t, errors) {
     if (t is! FunctionType) return false;
-    var returnT = (t as FunctionType).returnType;
-    if (returnT.isDynamic) return false;
+    var fType = (t as FunctionType);
     var eType = e.staticType;
     if (eType is! FunctionType) return false;
+
+    // We have a function literal, so we can treat the arrow type
+    // as non-fuzzy.  Since we're not improving on parameter types
+    // currently, if this check fails then we cannot succeed, so
+    // bail out.  Otherwise, we never need to check the parameter types
+    // again.
+    if (!rules.isFunctionSubTypeOf(eType, fType,
+        fuzzyArrows: false, ignoreReturn: true)) return false;
+
+    // This only entered inference because of fuzzy typing.
+    // The function type is already specific enough, we can just
+    // succeed and treat it as a succesful inference

[vsm, 2015/04/03 22:32:59]

s/succesful/successful/

+    if (rules.isSubTypeOf(eType.returnType, fType.returnType)) return true;
+
+    // Fuzzy typing again, handle the void case (not caught by the previous)
+    if (fType.returnType.isVoid) return true;
+
     if (e.body is! ExpressionFunctionBody) return false;
     var body = (e.body as ExpressionFunctionBody).expression;
-    if (!inferExpression(body, returnT, errors)) return false;
+    if (!_inferExpression(body, fType.returnType, errors)) return false;
+
     // TODO(leafp): Try narrowing the argument types if possible
     // to get better code in the function body.  This requires checking
     // that the body is well-typed at the more specific type.
-    var element = (e.element as ExecutableElementImpl);
-    var oldReturnT = element.returnType;
-    element.returnType = returnT;
-    // Work around dynamic as bottom for now by handling function literals
-    // with dynamic arguments specially.  We already know the body is typable
-    // at the chosen type, and if all args are dynamic, then function must be
-    // typeable.
-    if ((eType as FunctionType).parameters.every((x) => x.type.isDynamic)) {
-      return true;
-    }
-    if (rules.isSubTypeOf(e.staticType, t)) return true;
-    element.returnType = oldReturnT;
-    return false;
+
+    // At this point, we know that the parameter types are in the appropriate subtype
+    // relation, and we have checked that we can type the body at the appropriate return
+    // type, so we can are done.
+    annotateFunctionExpression(e, fType.returnType);
+    return true;
   }
 
   bool _inferListLiteral(ListLiteral e, DartType t, errors) {
     var dyn = rules.provider.dynamicType;
     var listT = rules.provider.listType.substitute4([dyn]);
     // List <: t (using dart rules) must be true
     if (!listT.isSubtypeOf(t)) return false;
     // The list literal must have no type arguments
     if (e.typeArguments != null) return false;
     if (t is! InterfaceType) return false;
     var targs = _matchTypes(listT, t);
     if (targs == null) return false;
     assert(targs.length == 1);
     var etype = targs[0];
     assert(!etype.isDynamic);
     var elements = e.elements;
-    var b = elements.every((e) => inferExpression(e, etype, errors));
+    var b = elements.every((e) => _inferExpression(e, etype, errors));
     if (b) annotateListLiteral(e, targs);
     return b;
   }
 
   bool _inferMapLiteral(MapLiteral e, DartType t, errors) {
     var dyn = rules.provider.dynamicType;
     var mapT = rules.provider.mapType.substitute4([dyn, dyn]);
     // Map <: t (using dart rules) must be true
     if (!mapT.isSubtypeOf(t)) return false;
     // The map literal must have no type arguments
     if (e.typeArguments != null) return false;
     if (t is! InterfaceType) return false;
     var targs = _matchTypes(mapT, t);
     if (targs == null) return false;
     assert(targs.length == 2);
     var kType = targs[0];
     var vType = targs[1];
     assert(!(kType.isDynamic && vType.isDynamic));
     var entries = e.entries;
     bool inferEntry(MapLiteralEntry entry) {
-      return inferExpression(entry.key, kType, errors) &&
-          inferExpression(entry.value, vType, errors);
+      return _inferExpression(entry.key, kType, errors) &&
+          _inferExpression(entry.value, vType, errors);
     }
     var b = entries.every(inferEntry);
     if (b) annotateMapLiteral(e, targs);
     return b;
   }
 }