implement generic method runtime behavior, fixes #301

tool/input_sdk/private/ddc_runtime/operations.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.
 
 /// This library defines runtime operations on objects used by the code
 /// generator.
 part of dart._runtime;
 
 _canonicalFieldName(obj, name, args, displayName) => JS('', '''(() => {
   $name = $canonicalMember($obj, $name);
@@ skipping 21 matching lines @@
 dput(obj, field, value) => JS('', '''(() => {
   $field = $_canonicalFieldName($obj, $field, [$value], $field);
   // TODO(vsm): Implement NSM and type checks.
   // See: https://github.com/dart-lang/dev_compiler/issues/170
   $obj[$field] = $value;
   return $value;
 })()''');
 
 /// Check that a function of a given type can be applied to
 /// actuals.
-checkApply(type, actuals) => JS('', '''(() => {
+_checkApply(type, actuals) => JS('', '''(() => {
   if ($actuals.length < $type.args.length) return false;
   let index = 0;
   for(let i = 0; i < $type.args.length; ++i) {
     if (!$instanceOfOrNull($actuals[i], $type.args[i])) return false;
     ++index;
   }
   if ($actuals.length == $type.args.length) return true;
   let extras = $actuals.length - $type.args.length;
   if ($type.optionals.length > 0) {
     if (extras > $type.optionals.length) return false;
@@ skipping 27 matching lines @@
 
 throwNoSuchMethod(obj, name, pArgs, nArgs, extras) => JS('', '''(() => {
   $throw_(new $NoSuchMethodError($obj, $_dartSymbol($name), $pArgs, $nArgs, $extras));
 })()''');
 
 throwNoSuchMethodFunc(obj, name, pArgs, opt_func) => JS('', '''(() => {
   if ($obj === void 0) $obj = $opt_func;
   $throwNoSuchMethod($obj, $name, $pArgs);
 })()''');
 
-checkAndCall(f, ftype, obj, args, name) => JS('', '''(() => {
+_checkAndCall(f, ftype, obj, typeArgs, args, name) => JS('', '''(() => {
   let originalFunction = $f;
   if (!($f instanceof Function)) {
     // We're not a function (and hence not a method either)
     // Grab the `call` method if it's not a function.
     if ($f != null) {
       $ftype = $getMethodType($f, 'call');
       $f = $f.call;
     }
     if (!($f instanceof Function)) {
       $throwNoSuchMethodFunc($obj, $name, $args, originalFunction);
     }
   }
   // If f is a function, but not a method (no method type)
   // then it should have been a function valued field, so
   // get the type from the function.
   if ($ftype === void 0) {
     $ftype = $read($f);
   }
 
   if (!$ftype) {
     // TODO(leafp): Allow JS objects to go through?
-    // This includes the DOM.
+    if ($typeArgs != null) {
+      // TODO(jmesserly): is there a sensible way to handle these?
+      $throwStrongModeError('call to JS object `' + $obj +
+          '` with type arguments <' + $typeArgs + '> is not supported.');
+    }
     return $f.apply($obj, $args);
   }
 
-  if ($checkApply($ftype, $args)) {
+  // Apply type arguments
+  let formalCount = $ftype[$_typeFormalCount];
+  if (formalCount != null) {
+    if ($typeArgs == null) {
+      $typeArgs = Array(formalCount).fill($dynamicR);

[Jennifer Messerly, 2016/04/28 23:28:54]

This should be instantiating to bounds.
Related to: https://github.com/dart-lang/dev_compiler/issues/532

Let me know, I try and fix it in this version or split off into its own bug.

Perhaps something like:

    dart.genericBounds((T) => [T, [T, T]], [core.num])

(e.g. for `min` in dart:math)

+    } else if ($typeArgs.length != formalCount) {
+      // TODO(jmesserly): is this the right error?
+      $throwStrongModeError(
+          'incorrect number of arguments to generic function ' +
+          $typeName($ftype) + ', got <' + $typeArgs + '> expected ' +
+          formalCount + '.');
+    }
+    // Instantiate the function.
+    $ftype = $ftype(...$typeArgs);
+  } else if ($typeArgs != null) {
+    $throwStrongModeError(
+        'got type arguments to non-generic function ' + $typeName($ftype) +
+        ', got <' + $typeArgs + '> expected none.');
+  }
+
+  if ($_checkApply($ftype, $args)) {
+    if ($typeArgs != null) {
+      return $f.apply($obj, $typeArgs).apply($obj, $args);
+    }
     return $f.apply($obj, $args);
   }
 
   // TODO(leafp): throw a type error (rather than NSM)
   // if the arity matches but the types are wrong.
+  // TODO(jmesserly): nSM should include type args?
   $throwNoSuchMethodFunc($obj, $name, $args, originalFunction);
 })()''');
 
-dcall(f, @rest args) => JS('', '''(() => {
-  let ftype = $read($f);
-  return $checkAndCall($f, ftype, void 0, $args, 'call');
-})()''');
+dcall(f, @rest args) =>
+    _checkAndCall(f, read(f), JS('', 'void 0'), null, args, 'call');
 
-/// Shared code for dsend, dindex, and dsetindex. */
-callMethod(obj, name, args, displayName) => JS('', '''(() => {
-  let symbol = $_canonicalFieldName($obj, $name, $args, $displayName);
-  let f = $obj != null ? $obj[symbol] : null;
-  let ftype = $getMethodType($obj, $name);
-  return $checkAndCall(f, ftype, $obj, $args, $displayName);
-})()''');
 
-dsend(obj, method, @rest args) => JS('', '''(() => {
-  return $callMethod($obj, $method, $args, $method);
-})()''');
+dgcall(f, typeArgs, @rest args) =>
+    _checkAndCall(f, read(f), JS('', 'void 0'), typeArgs, args, 'call');
 
-dindex(obj, index) => JS('', '''(() => {
-  return $callMethod($obj, 'get', [$index], '[]');
-})()''');
 
-dsetindex(obj, index, value) => JS('', '''(() => {
-  $callMethod($obj, 'set', [$index, $value], '[]=');
-  return $value;
-})()''');
+/// Shared code for dsend, dindex, and dsetindex.
+_callMethod(obj, name, typeArgs, args, displayName) {
+  var symbol = _canonicalFieldName(obj, name, args, displayName);
+  var f = obj != null ? JS('', '#[#]', obj, symbol) : null;
+  var ftype = getMethodType(obj, symbol);
+  return _checkAndCall(f, ftype, obj, typeArgs, args, displayName);
+}
+
+dsend(obj, method, @rest args) => _callMethod(obj, method, null, args, method);
+
+dgsend(obj, typeArgs, method, @rest args) =>
+    _callMethod(obj, method, typeArgs, args, method);
+
+dindex(obj, index) => _callMethod(obj, 'get', null, JS('', '[#]', index), '[]');
+
+dsetindex(obj, index, value) =>
+    _callMethod(obj, 'set', null, JS('', '[#, #]', index, value), '[]=');
 
 _ignoreTypeFailure(actual, type) => JS('', '''(() => {
   // TODO(vsm): Remove this hack ...
   // This is primarily due to the lack of generic methods,
   // but we need to triage all the types.
   if ($isSubtype($type, $Iterable) && $isSubtype($actual, $Iterable) ||
       $isSubtype($type, $Future) && $isSubtype($actual, $Future) ||
       $isSubtype($type, $Map) && $isSubtype($actual, $Map) ||
       $isSubtype($type, $Function) && $isSubtype($actual, $Function) ||
       $isSubtype($type, $Stream) && $isSubtype($actual, $Stream) ||
@@ skipping 267 matching lines @@
     constructor(dartIterator) {
       this.dartIterator = dartIterator;
     }
     next() {
       let i = this.dartIterator;
       let done = !i.moveNext();
       return { done: done, value: done ? void 0 : i.current };
     }
   }
 ''');