instantiate generic tear-offs, fixes #525

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 456 matching lines @@
     var typeFormals = element.typeParameters;
     if (typeFormals.isNotEmpty) {
       return _defineClassTypeArguments(element, typeFormals,
           js.statement('const # = #;', [element.name, body]));
     } else {
       return js.statement('# = #;', [_emitTopLevelName(element), body]);
     }
   }
 
   @override
-  JS.Expression visitTypeName(TypeName node) => _emitTypeName(node.type);
+  JS.Expression visitTypeName(TypeName node) {
+    // TODO(jmesserly): should only happen for erroneous code.
+    if (node.type == null) return js.call('dart.dynamic');
+    return _emitTypeName(node.type);
+  }
 
   @override
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement element = node.element;
 
     // Forward all generative constructors from the base class.
     var methods = <JS.Method>[];
 
     var supertype = element.supertype;
     if (!supertype.isObject) {
@@ skipping 983 matching lines @@
           fields[element as FieldElement] = _visitInitializer(fieldNode);
         }
       }
     }
 
     // Initialize fields from `this.fieldName` parameters.
     if (ctor != null) {
       for (var p in ctor.parameters.parameters) {
         var element = p.element;
         if (element is FieldFormalParameterElement) {
-          fields[element.field] = visitSimpleIdentifier(p.identifier);
+          fields[element.field] = _emitSimpleIdentifier(p.identifier);
         }
       }
 
       // Run constructor field initializers such as `: foo = bar.baz`
       for (var init in ctor.initializers) {
         if (init is ConstructorFieldInitializer) {
           fields[init.fieldName.staticElement as FieldElement] =
               _visit(init.expression);
         }
       }
@@ skipping 42 matching lines @@
   JS.Statement _emitArgumentInitializers(node, {bool constructor: false}) {
     // Constructor argument initializers are emitted earlier in the code, rather
     // than always when we visit the function body, so we control it explicitly.
     if (node is ConstructorDeclaration != constructor) return null;
 
     var parameters = _parametersOf(node);
     if (parameters == null) return null;
 
     var body = <JS.Statement>[];
     for (var param in parameters.parameters) {
-      var jsParam = visitSimpleIdentifier(param.identifier);
+      var jsParam = _emitSimpleIdentifier(param.identifier);
 
       if (!options.destructureNamedParams) {
         if (param.kind == ParameterKind.NAMED) {
           // Parameters will be passed using their real names, not the (possibly
           // renamed) local variable.
           var paramName = js.string(param.identifier.name, "'");
 
           // TODO(ochafik): Fix `'prop' in obj` to please Closure's renaming.
           body.add(js.statement('let # = # && # in # ? #.# : #;', [
             jsParam,
@@ skipping 414 matching lines @@
       declareFn = new JS.FunctionDeclaration(name, fn);
     }
     declareFn = annotate(declareFn, node, node.functionDeclaration.element);
 
     return new JS.Block([
       declareFn,
       _emitFunctionTagged(name, func.element.type).toStatement()
     ]);
   }
 
-  /// Writes a simple identifier. This can handle implicit `this` as well as
-  /// going through the qualified library name if necessary.
+  /// Emits a simple identifier, including handling an inferred generic
+  /// function instantiation.
   @override
   JS.Expression visitSimpleIdentifier(SimpleIdentifier node) {
+    return _applyFunctionTypeArguments(
+        _emitSimpleIdentifier(node), node.staticElement, node.staticType);
+  }
+
+  /// Emits a simple identifier, handling implicit `this` as well as
+  /// going through the qualified library name if necessary, but *not* handling
+  /// inferred generic function instantiation.
+  JS.Expression _emitSimpleIdentifier(SimpleIdentifier node) {
     var accessor = node.staticElement;
     if (accessor == null) {
       return js.commentExpression(
           'Unimplemented unknown name', new JS.Identifier(node.name));
     }
 
     // Get the original declaring element. If we had a property accessor, this
     // indirects back to a (possibly synthetic) field.
     var element = accessor;
     if (accessor is PropertyAccessorElement) element = accessor.variable;
@@ skipping 332 matching lines @@
     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)) {
       if (typeArgs != null) {
-        return js.call('dart.dgsend(#, [#], #, #)',
-            [jsTarget, typeArgs, memberName, args]);
+        return js.call('dart.dgsend(#, #, #, #)',
+            [jsTarget, new JS.ArrayInitializer(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]);
     }
 
@@ skipping 11 matching lines @@
   }
 
   /// 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]);
+        return js.call('dart.dgcall(#, #, #)',
+            [fn, new JS.ArrayInitializer(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);
+        node.function.staticType, node.staticInvokeType, node.typeArguments);
   }
 
   /// 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) {
+  List<JS.Expression> _emitFunctionTypeArguments(DartType g, DartType f,
+      [TypeArgumentList typeArgs]) {
     if (g is FunctionType &&
         g.typeFormals.isNotEmpty &&
         f is FunctionType &&
         f.typeFormals.isEmpty) {
       return _recoverTypeArguments(g, f)
           .map(_emitTypeName)
           .toList(growable: false);
+    } else if (typeArgs != null) {
+      // Dynamic calls may have type arguments, even though the function types
+      // are not known.
+      // TODO(jmesserly): seems to be mostly broken in Analyzer at the moment:
+      // https://github.com/dart-lang/sdk/issues/26368
+      return typeArgs.arguments.map(visitTypeName).toList(growable: false);

[Harry Terkelsen, 2016/04/29 23:04:11]

why visitTypeName here and _emitTypeName above? Is it just to guard in case
typeArgs contains a null?

[Jennifer Messerly, 2016/04/29 23:08:14]

_emitTypeName ... probably should be renamed _emitType. It takes a DartType.
visitTypeName takes the AST node.

     }
     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) {
@@ skipping 821 matching lines @@
   JS.This visitThisExpression(ThisExpression node) => new JS.This();
 
   @override
   JS.Super visitSuperExpression(SuperExpression node) => new JS.Super();
 
   @override
   visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (isLibraryPrefix(node.prefix)) {
       return _visit(node.identifier);
     } else {
-      return _emitAccess(node.prefix, node.identifier);
+      return _emitAccess(node.prefix, node.identifier, node.staticType);
     }
   }
 
   @override
   visitPropertyAccess(PropertyAccess node) {
     if (node.operator.lexeme == '?.') {
       return _emitNullSafe(node);
     }
-    return _emitAccess(_getTarget(node), node.propertyName);
+    return _emitAccess(_getTarget(node), node.propertyName, node.staticType);
   }
 
   JS.Expression _emitNullSafe(Expression node) {
     // Desugar ?. sequence by passing a sequence of callbacks that applies
     // each operation in sequence:
     //
     //     obj?.foo()?.bar
     // -->
     //     nullSafe(obj, _ => _.foo(), _ => _.bar);
     //
@@ skipping 56 matching lines @@
 
     // Check if the target could be `null`, is dynamic, or may be an extension
     // native type. In all of those cases we need defensive code generation.
     var type = getStaticType(target);
     return isNullable(target) ||
         type.isDynamic ||
         (_extensionTypes.contains(type.element) && target is! SuperExpression);
   }
 
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
-  JS.Expression _emitAccess(Expression target, SimpleIdentifier memberId) {
-    var member = memberId.staticElement;
+  JS.Expression _emitAccess(Expression target, SimpleIdentifier memberId, DartType resultType) {

[Harry Terkelsen, 2016/04/29 23:04:11]

long line

[Jennifer Messerly, 2016/04/29 23:08:14]

huh, format must've not run, I'll see about that. I think it fixes the blank
line issue too

+    Element member = memberId.staticElement;
     if (member is PropertyAccessorElement) {
       member = (member as PropertyAccessorElement).variable;
     }
     bool isStatic = member is ClassMemberElement && member.isStatic;
     var name = _emitMemberName(memberId.name,
         type: getStaticType(target), isStatic: isStatic);
     if (DynamicInvoke.get(target)) {
       return js.call('dart.dload(#, #)', [_visit(target), name]);
     }
 
-    if (target is SuperExpression &&
-        member is FieldElement &&
-        !member.isSynthetic) {
+    var jsTarget = _visit(target);
+    bool isSuper = jsTarget is JS.Super;
+
+    if (isSuper && member is FieldElement && !member.isSynthetic) {
       // If super.x is actually a field, then x is an instance property since
       // subclasses cannot override x.
-      return js.call('this.#', [name]);
+      jsTarget = new JS.This();
     }
 
-    String code;
+    JS.Expression result;
     if (member != null && member is MethodElement && !isStatic) {
       // Tear-off methods: explicitly bind it.
-      if (target is SuperExpression) {
-        return js.call('dart.bind(this, #, #.#)', [name, _visit(target), name]);
+      if (isSuper) {
+        result = js.call('dart.bind(this, #, #.#)', [name, jsTarget, name]);
       } else if (_isObjectMemberCall(target, memberId.name)) {
-        return js.call('dart.bind(#, #, dart.#)', [_visit(target), name, name]);
+        result = js.call('dart.bind(#, #, dart.#)', [jsTarget, name, name]);
+      } else {
+        result = js.call('dart.bind(#, #)', [jsTarget, name]);
       }
-      code = 'dart.bind(#, #)';
     } else if (_isObjectMemberCall(target, memberId.name)) {
-      return js.call('dart.#(#)', [name, _visit(target)]);
+      result = js.call('dart.#(#)', [name, jsTarget]);
     } else {
-      code = '#.#';
+      result = js.call('#.#', [jsTarget, name]);
+    }
+    return _applyFunctionTypeArguments(result, member, resultType);
+  }
+
+  /// If this is an inferred instantiation of a generic function/method, this
+  /// will add the inferred type arguments.
+  JS.Expression _applyFunctionTypeArguments(
+      JS.Expression result, Element member, DartType instantiated) {
+

[Harry Terkelsen, 2016/04/29 23:04:11]

unnecessary blank lines

+
+    DartType type;
+    if (member is ExecutableElement) {
+      type = member.type;
+    } else if (member is VariableElement) {
+      type = member.type;
     }
 
-    return js.call(code, [_visit(target), name]);
+    // TODO(jmesserly): handle explicitly passed type args.
+    if (type == null) return result;
+    var typeArgs = _emitFunctionTypeArguments(type, instantiated);
+    if (typeArgs == null) return result;
+    return js.call('dart.gbind(#, #)', [result, typeArgs]);
   }
 
   /// Emits a generic send, like an operator method.
   ///
   /// **Please note** this function does not support method invocation syntax
   /// `obj.name(args)` because that could be a getter followed by a call.
   /// See [visitMethodInvocation].
   JS.Expression _emitSend(
       Expression target, String name, List<Expression> args) {
     var type = getStaticType(target);
@@ skipping 685 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';