implement generic method runtime behavior, fixes #301

lib/src/compiler/code_generator.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.
 
 import 'dart:collection' show HashMap, HashSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 1098 matching lines @@
         } else {
           tMethods.add(property);
         }
       }
     }
 
     var tCtors = <JS.Property>[];
     for (ConstructorDeclaration node in ctors) {
       var memberName = _constructorName(node.element);
       var element = node.element;
-      var parts = _emitFunctionTypeParts(element.type, node.parameters);
+      var parts = _emitFunctionTypeParts(element.type,
+          parameters: node.parameters.parameters);
       var property =
           new JS.Property(memberName, new JS.ArrayInitializer(parts));
       tCtors.add(property);
     }
 
     JS.Property build(String name, List<JS.Property> elements) {
       var o =
           new JS.ObjectInitializer(elements, multiline: elements.length > 1);
       var e = js.call('() => #', o);
       return new JS.Property(_propertyName(name), e);
@@ skipping 493 matching lines @@
     } else {
       fn = _emitFunctionBody(node.element, node.parameters, node.body);
 
       if (node.operatorKeyword != null &&
           node.name.name == '[]=' &&
           fn.params.isNotEmpty) {
         // []= methods need to return the value. We could also address this at
         // call sites, but it's cleaner to instead transform the operator method.
         fn = _alwaysReturnLastParameter(fn);
       }
+
+      fn = _makeGenericFunction(fn);
     }
 
     return annotate(
         new JS.Method(_elementMemberName(node.element), fn,
             isGetter: node.isGetter,
             isSetter: node.isSetter,
             isStatic: node.isStatic),
         node,
         node.element);
   }
@@ skipping 130 matching lines @@
     }
     return _loader.isLoaded(type.element);
   }
 
   JS.Expression _emitFunctionTagged(JS.Expression fn, DartType type,
       {topLevel: false}) {
     var name = type.name;
     var lazy = topLevel && !_typeIsLoaded(type);
 
     if (type is FunctionType && (name == '' || name == null)) {
-      if (type.returnType.isDynamic &&
+      if (type.typeFormals.isEmpty &&
+          type.returnType.isDynamic &&
           type.optionalParameterTypes.isEmpty &&
           type.namedParameterTypes.isEmpty &&
           type.normalParameterTypes.every((t) => t.isDynamic)) {
         return js.call('dart.fn(#)', [fn]);
       }
 
-      String code = lazy ? '() => dart.definiteFunctionType(#)' : '#';
-      return js.call('dart.fn(#, $code)', [fn, _emitFunctionTypeParts(type)]);
+      var parts = _emitFunctionTypeParts(type);
+      if (lazy) {
+        return js.call(
+            'dart.lazyFn(#, () => #)', [fn, new JS.ArrayInitializer(parts)]);
+      } else {
+        return js.call('dart.fn(#, #)', [fn, parts]);
+      }
     }
     throw 'Function has non function type: $type';
   }
 
   /// Emits an arrow FunctionExpression node.
   ///
   /// This should be used for all places in Dart's AST where FunctionExpression
   /// appears and the function is actually in an Expression context. These
   /// correspond to arrow functions in Dart.
   ///
@@ skipping 14 matching lines @@
     if (body is JS.Block) {
       JS.Block block = body;
       if (block.statements.length == 1) {
         JS.Statement s = block.statements[0];
         if (s is JS.Return) body = s.value;
       }
     }
 
     // Convert `function(...) { ... }` to `(...) => ...`
     // This is for readability, but it also ensures correct `this` binding.
-    return annotate(
-        new JS.ArrowFun(f.params, body,
-            typeParams: f.typeParams, returnType: f.returnType),
-        node);
+    var fn = new JS.ArrowFun(f.params, body,
+        typeParams: f.typeParams, returnType: f.returnType);
+
+    return annotate(_makeGenericFunction(fn), node);
+  }
+
+  JS.FunctionExpression/*=T*/ _makeGenericFunction/*<T extends JS.FunctionExpression>*/(

[vsm, 2016/04/29 14:48:53]

nit len

[Jennifer Messerly, 2016/04/29 17:18:44]

fixed. I guess dartfmt can't help until we have generic methods

+      JS.FunctionExpression/*=T*/ fn) {
+    if (fn.typeParams == null || fn.typeParams.isEmpty) return fn;
+
+    // TODO(jmesserly): we could make these default to `dynamic`.
+    var typeParams = fn.typeParams;
+    if (fn is JS.ArrowFun) {
+      return new JS.ArrowFun(typeParams, fn);
+    }
+    var f = fn as JS.Fun;
+    return new JS.Fun(

[vsm, 2016/04/29 14:48:53]

Could this be an ArrayFun?

[Jennifer Messerly, 2016/04/29 17:18:44]

it preserves the kind of the incoming function:
* if it was an =>, it stays => (see 4 lines above)
* otherwise it stays a Fun.

When building a JS AST we need raw JS.Funs sometimes, such as to fit in a
JS.Method. So changing the type wouldn't be valid. If an => could have been
used, the outside code should've already done that.

+        typeParams,
+        new JS.Block([
+          // Convert the function to an => function, to ensure `this` binding.
+          new JS.Return(new JS.ArrowFun(f.params, f.body,
+              typeParams: f.typeParams, returnType: f.returnType))
+        ]));
   }
 
   /// Emits a non-arrow FunctionExpression node.
   ///
   /// This should be used for all places in Dart's AST where FunctionExpression
   /// appears but the function is not actually in an Expression context, such
   /// as methods, properties, and top-level functions.
   ///
   /// Contrast with [visitFunctionExpression].
   JS.Fun _emitFunction(FunctionExpression node) {
     var fn = _emitFunctionBody(node.element, node.parameters, node.body);
-    return annotate(fn, node);
+    return annotate(_makeGenericFunction(fn), node);
   }
 
   JS.Fun _emitFunctionBody(ExecutableElement element,
       FormalParameterList parameters, FunctionBody body) {
-    var returnType = emitTypeRef(element.returnType);
+    FunctionType type = element.type;
 
     // sync*, async, async*
     if (element.isAsynchronous || element.isGenerator) {
       return new JS.Fun(
           visitFormalParameterList(parameters, destructure: false),
-          js.statement('{ return #; }',
-              [_emitGeneratorFunctionBody(element, parameters, body)]),
-          returnType: returnType);
+          new JS.Block([
+            _emitGeneratorFunctionBody(element, parameters, body).toReturn()
+          ]),
+          returnType: emitTypeRef(type.returnType));
     }
+
     // normal function (sync)
     return new JS.Fun(visitFormalParameterList(parameters), _visit(body),
-        typeParams: _emitTypeFormals(element.typeParameters),
-        returnType: returnType);
+        typeParams: _emitTypeFormals(type.typeFormals),
+        returnType: emitTypeRef(type.returnType));
   }
 
   JS.Expression _emitGeneratorFunctionBody(ExecutableElement element,
       FormalParameterList parameters, FunctionBody body) {
     var kind = element.isSynchronous ? 'sync' : 'async';
     if (element.isGenerator) kind += 'Star';
 
     // Transforms `sync*` `async` and `async*` function bodies
     // using ES6 generators.
     //
@@ skipping 184 matching lines @@
       var key = _propertyName(name);
       var value = _emitTypeName(type);
       properties.add(new JS.Property(key, value));
     });
     return new JS.ObjectInitializer(properties);
   }
 
   /// Emit the pieces of a function type, as an array of return type,
   /// regular args, and optional/named args.
   List<JS.Expression> _emitFunctionTypeParts(FunctionType type,
-      [FormalParameterList parameterList]) {
-    var parameters = parameterList?.parameters;
-    var returnType = type.returnType;
+      {List<FormalParameter> parameters, bool lowerTypedef: false}) {
     var parameterTypes = type.normalParameterTypes;
     var optionalTypes = type.optionalParameterTypes;
     var namedTypes = type.namedParameterTypes;
-    var rt = _emitTypeName(returnType);
+    var rt = _emitTypeName(type.returnType);
     var ra = _emitTypeNames(parameterTypes, parameters);
-    if (!namedTypes.isEmpty) {
+
+    List<JS.Expression> typeParts;
+    if (namedTypes.isNotEmpty) {
       assert(optionalTypes.isEmpty);
       // TODO(vsm): Pass in annotations here as well.
       var na = _emitTypeProperties(namedTypes);
-      return [rt, ra, na];
-    }
-    if (!optionalTypes.isEmpty) {
+      typeParts = [rt, ra, na];
+    } else if (optionalTypes.isNotEmpty) {
       assert(namedTypes.isEmpty);
       var oa = _emitTypeNames(
           optionalTypes, parameters?.sublist(parameterTypes.length));
-      return [rt, ra, oa];
+      typeParts = [rt, ra, oa];
+    } else {
+      typeParts = [rt, ra];
     }
-    return [rt, ra];
+
+    var typeFormals = type.typeFormals;
+    if (typeFormals.isNotEmpty && !lowerTypedef) {
+      // TODO(jmesserly): this is a suboptimal representation for universal
+      // function types (as callable functions). See discussion at:
+      // https://github.com/dart-lang/dev_compiler/issues/526
+      var tf = _emitTypeFormals(typeFormals);
+      typeParts = [new JS.ArrowFun(tf, new JS.ArrayInitializer(typeParts))];
+    }
+    return typeParts;
   }
 
   /// Emits a Dart [type] into code.
   ///
   /// If [lowerTypedef] is set, a typedef will be expanded as if it were a
   /// function type. Similarly if [lowerGeneric] is set, the `List$()` form
   /// will be used instead of `List`. These flags are used when generating
   /// the definitions for typedefs and generic types, respectively.
   JS.Expression _emitTypeName(DartType type,
       {bool lowerTypedef: false, bool lowerGeneric: false}) {
     // The void and dynamic types are not defined in core.
     if (type.isVoid) {
       return js.call('dart.void');
     } else if (type.isDynamic) {
       return js.call('dart.dynamic');
     } else if (type.isBottom) {
       return js.call('dart.bottom');
     }
 
     _loader.declareBeforeUse(type.element);
 
     // TODO(jmesserly): like constants, should we hoist function types out of
     // methods? Similar issue with generic types. For all of these, we may want
     // to canonicalize them too, at least when inside the same library.
     var name = type.name;
     var element = type.element;
     if (name == '' || name == null || lowerTypedef) {
-      var parts = _emitFunctionTypeParts(type as FunctionType);
+      // TODO(jmesserly): should we change how typedefs work? They currently
+      // go through use similar logic as generic classes. This makes them
+      // different from universal function types.

[vsm, 2016/04/29 14:48:53]

do you want to file a bug?  is there a language open here?

[Leaf, 2016/04/29 15:55:03]

There's active language discussion about how to sort out the universal function
type syntax.

[Jennifer Messerly, 2016/04/29 17:18:44]

Haha, yeah. Funny when theory and implementation collide like that. :)

We could implement these more like the universal types, then just treat the use
of the typedef with no type args as instantiated w/ dynamic.

Not sure it's worth changing though.

+      var ft = type as FunctionType;
+      var parts = _emitFunctionTypeParts(ft, lowerTypedef: lowerTypedef);
       return js.call('dart.functionType(#)', [parts]);
     }
-    // For now, reify generic method parameters as dynamic
-    bool _isGenericTypeParameter(DartType type) =>
-        type is TypeParameterType &&
-        type.element.enclosingElement is! TypeDefiningElement;
-
-    if (_isGenericTypeParameter(type)) {
-      return js.call('dart.dynamic');
-    }
 
     if (type is TypeParameterType) {
       return new JS.Identifier(name);
     }
 
     if (type is ParameterizedType) {
       var args = type.typeArguments;
       Iterable jsArgs = null;
-      if (args.any((a) => !a.isDynamic && !_isGenericTypeParameter(a))) {
+      if (args.any((a) => !a.isDynamic)) {
         jsArgs = args.map(_emitTypeName);
       } else if (lowerGeneric) {
         jsArgs = [];
       }
       if (jsArgs != null) {
         var genericName = _emitTopLevelName(element, suffix: '\$');
         return js.call('#(#)', [genericName, jsArgs]);
       }
     }
 
@@ skipping 119 matching lines @@
     return new JS.Block(stmts);
   }
 
   @override
   JS.Block visitBlock(Block node) =>
       new JS.Block(_visitList(node.statements) as List<JS.Statement>,
           isScope: true);
 
   @override
   visitMethodInvocation(MethodInvocation node) {
-    if (node.operator != null && node.operator.lexeme == '?.') {
+    if (node.operator?.lexeme == '?.') {
       return _emitNullSafe(node);
     }
 
-    var target = _getTarget(node);
     var result = _emitForeignJS(node);
     if (result != null) return result;
 
-    String code;
+    var target = _getTarget(node);
     if (target == null || isLibraryPrefix(target)) {
-      if (DynamicInvoke.get(node.methodName)) {
-        code = 'dart.dcall(#, #)';
-      } else {
-        code = '#(#)';
-      }
-      return js
-          .call(code, [_visit(node.methodName), _visit(node.argumentList)]);
+      return _emitFunctionCall(node);
     }
 
+    return _emitMethodCall(target, node);
+  }
+
+  /// Emits a (possibly generic) instance method call.
+  JS.Expression _emitMethodCall(Expression target, MethodInvocation node) {
     var type = getStaticType(target);
     var name = node.methodName.name;
     var element = node.methodName.staticElement;
     bool isStatic = element is ExecutableElement && element.isStatic;
     var memberName = _emitMemberName(name, type: type, isStatic: isStatic);
 
+    JS.Expression jsTarget = _visit(target);
+    var typeArgs = _emitInvokeTypeArguments(node);
+    List<JS.Expression> args = _visit(node.argumentList);
     if (DynamicInvoke.get(target)) {
-      code = 'dart.dsend(#, #, #)';
-    } else if (DynamicInvoke.get(node.methodName)) {
+      if (typeArgs != null) {
+        return js.call('dart.dgsend(#, [#], #, #)',
+            [jsTarget, typeArgs, memberName, args]);
+      } else {
+        return js.call('dart.dsend(#, #, #)', [jsTarget, memberName, args]);
+      }
+    }
+    if (_isObjectMemberCall(target, name)) {
+      // Object methods require a helper for null checks & native types.
+      assert(typeArgs == null); // Object methods don't take type args.
+      return js.call('dart.#(#, #)', [memberName, jsTarget, args]);
+    }
+
+    jsTarget = new JS.PropertyAccess(jsTarget, memberName);
+    if (typeArgs != null) jsTarget = new JS.Call(jsTarget, typeArgs);
+
+    if (DynamicInvoke.get(node.methodName)) {
       // This is a dynamic call to a statically known target. For example:
       //     class Foo { Function bar; }
       //     new Foo().bar(); // dynamic call
-      code = 'dart.dcall(#.#, #)';
-    } else if (_isObjectMemberCall(target, name)) {
-      // Object methods require a helper for null checks.
-      return js.call('dart.#(#, #)',
-          [memberName, _visit(target), _visit(node.argumentList)]);
-    } else {
-      code = '#.#(#)';
+      return js.call('dart.dcall(#, #)', [jsTarget, args]);
     }
 
-    return js
-        .call(code, [_visit(target), memberName, _visit(node.argumentList)]);
+    return new JS.Call(jsTarget, args);
   }
 
-  /// Emits code for the `JS(...)` builtin.
+  /// Emits a function call, to a top-level function, local function, or
+  /// an expression.
+  JS.Expression _emitFunctionCall(InvocationExpression node) {
+    var fn = _visit(node.function);
+    var args = _visit(node.argumentList);
+    if (DynamicInvoke.get(node.function)) {
+      var typeArgs = _emitInvokeTypeArguments(node);
+      if (typeArgs != null) {
+        return js.call('dart.dgcall(#, [#], #)', [fn, typeArgs, args]);
+      } else {
+        return js.call('dart.dcall(#, #)', [fn, args]);
+      }
+    } else {
+      return new JS.Call(_applyInvokeTypeArguments(fn, node), args);
+    }
+  }
+
+  JS.Expression _applyInvokeTypeArguments(
+      JS.Expression target, InvocationExpression node) {
+    var typeArgs = _emitInvokeTypeArguments(node);
+    if (typeArgs == null) return target;
+    return new JS.Call(target, typeArgs);
+  }
+
+  List<JS.Expression> _emitInvokeTypeArguments(InvocationExpression node) {
+    return _emitFunctionTypeArguments(
+        node.function.staticType, node.staticInvokeType);
+  }
+
+  /// If `g` is a generic function type, and `f` is an instantiation of it,
+  /// then this will return the type arguments to apply, otherwise null.
+  List<JS.Expression> _emitFunctionTypeArguments(DartType g, DartType f) {
+    if (g is FunctionType &&
+        g.typeFormals.isNotEmpty &&
+        f is FunctionType &&
+        f.typeFormals.isEmpty) {
+      return _recoverTypeArguments(g, f)
+          .map(_emitTypeName)
+          .toList(growable: false);
+    }
+    return null;
+  }
+
+  /// Given a generic function type [g] and an instantiated function type [f],
+  /// find a list of type arguments TArgs such that `g<TArgs> == f`,
+  /// and return TArgs.
+  ///
+  /// This function must be called with type [f] that was instantiated from [g].
+  Iterable<DartType> _recoverTypeArguments(FunctionType g, FunctionType f) {
+    // TODO(jmesserly): this design is a bit unfortunate. It would be nice if
+    // resolution could simply create a synthetic type argument list.
+    assert(identical(g.element, f.element));
+    assert(g.typeFormals.isNotEmpty && f.typeFormals.isEmpty);
+    assert(g.typeFormals.length + g.typeArguments.length ==
+        f.typeArguments.length);
+
+    // Instantiation in Analyzer works like this:
+    // Given:
+    //     {U/T} <S> T -> S
+    // Where {U/T} represents the typeArguments (U) and typeParameters (T) list,
+    // and <S> represents the typeFormals.
+    //
+    // Now instantiate([V]), and the result should be:
+    //     {U/T, V/S} T -> S.
+    //
+    // Therefore, we can recover the typeArguments from our instantiated
+    // function.
+    return f.typeArguments.skip(g.typeArguments.length);
+  }
+
+  /// Emits code for the `JS(...)` macro.
   _emitForeignJS(MethodInvocation node) {
     var e = node.methodName.staticElement;
     if (isInlineJS(e)) {
       var args = node.argumentList.arguments;
       // arg[0] is static return type, used in `RestrictedStaticTypeAnalyzer`
       var code = args[1];
       var templateArgs;
       var source;
       if (code is StringInterpolation) {
         if (args.length > 2) {
@@ skipping 18 matching lines @@
       var result = template.instantiate(_visitList(templateArgs));
       // `throw` is emitted as a statement by `parseForeignJS`.
       assert(result is JS.Expression || node.parent is ExpressionStatement);
       return result;
     }
     return null;
   }
 
   @override
   JS.Expression visitFunctionExpressionInvocation(
-      FunctionExpressionInvocation node) {
-    var code;
-    if (DynamicInvoke.get(node.function)) {
-      code = 'dart.dcall(#, #)';
-    } else {
-      code = '#(#)';
-    }
-    return js.call(code, [_visit(node.function), _visit(node.argumentList)]);
-  }
+          FunctionExpressionInvocation node) =>
+      _emitFunctionCall(node);
 
   @override
   List<JS.Expression> visitArgumentList(ArgumentList node) {
     var args = <JS.Expression>[];
     var named = <JS.Property>[];
     for (var arg in node.arguments) {
       if (arg is NamedExpression) {
         named.add(_visit(arg));
       } else if (arg is MethodInvocation && isJsSpreadInvocation(arg)) {
         args.add(
@@ skipping 1309 matching lines @@
     throw 'Unimplemented ${node.runtimeType}: $node';
   }
 
   _visit(AstNode node) {
     if (node == null) return null;
     var result = node.accept(this);
     if (result is JS.Node) result = annotate(result, node);
     return result;
   }
 
-  // TODO(jmesserly): this will need to be a generic method, if we ever want to
-  // self-host strong mode.
-  List/*<T>*/ _visitList/*<T>*/(Iterable<AstNode> nodes) {
+  List/*<T>*/ _visitList/*<T extends AstNode>*/(Iterable/*<T>*/ nodes) {
     if (nodes == null) return null;
     var result = /*<T>*/ [];
     for (var node in nodes) result.add(_visit(node));
     return result;
   }
 
   /// Visits a list of expressions, creating a comma expression if needed in JS.
   JS.Expression _visitListToBinary(List<Expression> nodes, String operator) {
     if (nodes == null || nodes.isEmpty) return null;
     return new JS.Expression.binary(
@@ skipping 117 matching lines @@
       node is FunctionDeclaration ? node.functionExpression.body : node.body;
 
   /// Returns the canonical name to refer to the Dart library.
   JS.Identifier emitLibraryName(LibraryElement library) {
     // It's either one of the libraries in this module, or it's an import.
     return _libraries[library] ??
         _imports.putIfAbsent(library,
             () => new JS.TemporaryId(jsLibraryName(_buildRoot, library)));
   }
 
-  JS.Node annotate(JS.Node node, AstNode original, [Element element]) {
+  JS.Node/*=T*/ annotate/*<T extends JS.Node>*/(
+      JS.Node/*=T*/ node, AstNode original,
+      [Element element]) {
     if (options.closure && element != null) {
       node = node.withClosureAnnotation(closureAnnotationFor(
           node, original, element, namedArgumentTemp.name));
     }
     return node..sourceInformation = original;
   }
 
   /// Returns true if this is any kind of object represented by `Number` in JS.
   ///
   /// In practice, this is 4 types: num, int, double, and JSNumber.
@@ skipping 106 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';