Downwards closure inference

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 552 matching lines @@
   void annotateMapLiteral(MapLiteral e, List<DartType> targs) {}
 
   /// Called for each new/const which gets inferred
   void annotateInstanceCreationExpression(
       InstanceCreationExpression e, List<DartType> targs) {}
 
   /// Downward inference
   bool inferExpression(Expression e, DartType t) {
     if (e is Conversion) return inferExpression(e.node, t);
     if (rules.isSubTypeOf(rules.getStaticType(e), t)) return true;
+    if (e is FunctionExpression) return _inferFunctionExpression(e, t);
     if (e is ListLiteral) return _inferListLiteral(e, t);
     if (e is MapLiteral) return _inferMapLiteral(e, t);
     if (e is NamedExpression) return _inferNamedExpression(e, t);
     if (e is InstanceCreationExpression) return _inferInstanceCreationExpression(
         e, t);
     return false;
   }
 
   /// If t1 = I<dynamic, ..., dynamic>, then look for a supertype
   /// of t1 of the form K<S0, ..., Sm> where t2 = K<S0', ..., Sm'>
@@ skipping 133 matching lines @@
       }
     }
     annotateInstanceCreationExpression(e, targs);
     return true;
   }
 
   bool _inferNamedExpression(NamedExpression e, DartType t) {
     return inferExpression(e.expression, t);
   }
 
+  bool _inferFunctionExpression(FunctionExpression e, DartType t) {
+    if (t is! FunctionType) return false;
+    var returnT = (t as FunctionType).returnType;
+    if (returnT.isDynamic) return false;

[vsm, 2015/04/01 00:14:19]

Why do we disallow this?

In this case,

typedef Foo(int x);

Foo f = (x) => x;

should we infer the closure as int->int?

[Leaf, 2015/04/03 00:51:55]

Eventually, yes.  As it stands, no.  I don't improve on the argument types of
the closures, since doing so requires fully re-checking the body.  

So if returnT is dynamic, inference (in this limited implementation) cannot
improve the type.

+    var eType = e.staticType;
+    if (eType is! FunctionType) return false;
+    if (e.body is! ExpressionFunctionBody) return false;
+    var body = (e.body as ExpressionFunctionBody).expression;
+    if (!inferExpression(body, returnT)) 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.
+    (e.element as ExecutableElementImpl).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;
+    }
+    return rules.isSubTypeOf(e.staticType, t);

[vsm, 2015/04/01 00:14:19]

Should we have changed e.element.returnType if the inference failed?

[Leaf, 2015/04/03 00:51:55]

Probably not.  Probably doesn't matter, but still not a good idea.  Fixed.

+  }
+
   bool _inferListLiteral(ListLiteral e, DartType t) {
     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;
@@ skipping 23 matching lines @@
     var entries = e.entries;
     bool inferEntry(MapLiteralEntry entry) {
       return inferExpression(entry.key, kType) &&
           inferExpression(entry.value, vType);
     }
     var b = entries.every(inferEntry);
     if (b) annotateMapLiteral(e, targs);
     return b;
   }
 }