implement `Invocation.typeArguments` in DDC

pkg/dev_compiler/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;
 
 class InvocationImpl extends Invocation {
   final Symbol memberName;
   final List positionalArguments;
   final Map<Symbol, dynamic> namedArguments;
+  final List<Type> typeArguments;
   final bool isMethod;
   final bool isGetter;
   final bool isSetter;
 
   InvocationImpl(memberName, this.positionalArguments,
       {namedArguments,
+      List typeArguments,
       this.isMethod: false,
       this.isGetter: false,
       this.isSetter: false})
-      : memberName = _dartSymbol(memberName),
-        namedArguments = _namedArgsToSymbols(namedArguments);
+      : memberName =
+            isSetter ? _setterSymbol(memberName) : _dartSymbol(memberName),
+        namedArguments = _namedArgsToSymbols(namedArguments),
+        typeArguments = typeArguments == null
+            ? const []
+            : typeArguments.map(wrapType).toList();
 
   static Map<Symbol, dynamic> _namedArgsToSymbols(namedArgs) {
     if (namedArgs == null) return {};
     return new Map.fromIterable(getOwnPropertyNames(namedArgs),
         key: _dartSymbol, value: (k) => JS('', '#[#]', namedArgs, k));
   }
 }
 
 /// Given an object and a method name, tear off the method.
 /// Sets the runtime type of the torn off method appropriately,
@@ skipping 133 matching lines @@
     if (isJsInterop(obj)) {
       return JS('', '#[#] = #', obj, f, value);
     }
   }
   return noSuchMethod(
       obj, new InvocationImpl(field, JS('', '[#]', value), isSetter: true));
 }
 
 /// Check that a function of a given type can be applied to
 /// actuals.
-_checkApply(type, actuals) => JS(
-    '',
-    '''(() => {
+_checkApply(type, actuals) => JS('', '''(() => {
   // TODO(vsm): Remove when we no longer need mirrors metadata.
   // An array is used to encode annotations attached to the type.
   if ($type instanceof Array) {
     $type = type[0];
   }
   if ($actuals.length < $type.args.length) return false;
   let index = 0;
   for(let i = 0; i < $type.args.length; ++i) {
     $check($actuals[i], $type.args[i]);
     ++index;
@@ skipping 19 matching lines @@
   if (names.length == 0) return false;
   for (var name of names) {
     if (!($hasOwnProperty.call($type.named, name))) {
       return false;
     }
     $check(opts[name], $type.named[name]);
   }
   return true;
 })()''');
 
-_toSymbolName(symbol) => JS(
-    '',
-    '''(() => {
+_toSymbolName(symbol) => JS('', '''(() => {
         let str = $symbol.toString();
         // Strip leading 'Symbol(' and trailing ')'
         return str.substring(7, str.length-1);
     })()''');
 
-_toDisplayName(name) => JS(
-    '',
-    '''(() => {
+_toDisplayName(name) => JS('', '''(() => {
       // Names starting with _ are escaped names used to disambiguate Dart and
       // JS names.
       if ($name[0] === '_') {
         // Inverse of 
         switch($name) {
           case '_get':
             return '[]';
           case '_set':
             return '[]=';
           case '_negate':
             return 'unary-';
           case '_constructor':
           case '_prototype':
             return $name.substring(1);
         }
       }
       return $name;
   })()''');
 
 Symbol _dartSymbol(name) {
   return (JS('bool', 'typeof # === "symbol"', name))
       ? JS('Symbol', '#(new #.new(#, #))', const_, _internal.PrivateSymbol,
           _toSymbolName(name), name)
       : JS('Symbol', '#(#.new(#))', const_, Symbol, _toDisplayName(name));
 }
 
+Symbol _setterSymbol(name) {
+  return (JS('bool', 'typeof # === "symbol"', name))
+      ? JS('Symbol', '#(new #.new(# + "=", #))', const_,
+          _internal.PrivateSymbol, _toSymbolName(name), name)
+      : JS('Symbol', '#(#.new(# + "="))', const_, Symbol, _toDisplayName(name));
+}
+
 /// Extracts the named argument array from a list of arguments, and returns it.
 // TODO(jmesserly): we need to handle named arguments better.
 extractNamedArgs(args) {
   if (JS('bool', '#.length > 0', args)) {
     var last = JS('', '#[#.length - 1]', args, args);
     if (JS(
         'bool', '# != null && #.__proto__ === Object.prototype', last, last)) {
       return JS('', '#.pop()', args);
     }
   }
   return null;
 }
 
-_checkAndCall(f, ftype, obj, typeArgs, args, name) => JS(
-    '',
-    '''(() => {
+_checkAndCall(f, ftype, obj, typeArgs, args, name) => JS('', '''(() => {
   $_trackCall($obj);
 
   let originalTarget = obj === void 0 ? f : obj;
 
   function callNSM() {
     return $noSuchMethod(originalTarget, new $InvocationImpl.new(
-        $name, $args,
-        {namedArguments: $extractNamedArgs($args), isMethod: true}));
+        $name, $args, {
+          namedArguments: $extractNamedArgs($args),
+          typeArguments: $typeArgs,
+          isMethod: true
+        }));
   }
   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($getType($f), 'call');
       $f = f.call ? $bind($f, 'call') : void 0;
     }
     if (!($f instanceof Function)) {
       return callNSM();
@@ skipping 52 matching lines @@
 })()''');
 
 dcall(f, @rest args) =>
     _checkAndCall(f, _getRuntimeType(f), JS('', 'void 0'), null, args, 'call');
 
 dgcall(f, typeArgs, @rest args) => _checkAndCall(
     f, _getRuntimeType(f), JS('', 'void 0'), typeArgs, args, 'call');
 
 /// Helper for REPL dynamic invocation variants that make a best effort to
 /// enable accessing private members across library boundaries.
-_dhelperRepl(object, field, callback) => JS(
-    '',
-    '''(() => {
+_dhelperRepl(object, field, callback) => JS('', '''(() => {
   let rawField = $field;
   if (typeof(field) == 'symbol') {
     // test if the specified field exists in which case it is safe to use it.
     if ($field in $object) return $callback($field);
 
     // Symbol is from a different library. Make a best effort to
     $field = $field.toString();
     $field = $field.substring('Symbol('.length, field.length - 1);
 
   } else if ($field.charAt(0) != '_') {
@@ skipping 59 matching lines @@
 
 dindex(obj, index) =>
     _callMethod(obj, '_get', null, JS('', '[#]', index), '[]');
 
 dsetindex(obj, index, value) =>
     _callMethod(obj, '_set', null, JS('', '[#, #]', index, value), '[]=');
 
 /// TODO(leafp): This duplicates code in types.dart.
 /// I haven't found a way to factor it out that makes the
 /// code generator happy though.
-_ignoreMemo(f) => JS(
-    '',
-    '''(() => {
+_ignoreMemo(f) => JS('', '''(() => {
   let memo = new Map();
   return (t1, t2) => {
     let map = memo.get(t1);
     let result;
     if (map) {
       result = map.get(t2);
       if (result !== void 0) return result;
     } else {
       memo.set(t1, map = new Map());
     }
     result = $f(t1, t2);
     map.set(t2, result);
     return result;
   };
 })()''');
 
-final _ignoreTypeFailure = JS(
-    '',
-    '''(() => {
+final _ignoreTypeFailure = JS('', '''(() => {
   return $_ignoreMemo((actual, type) => {
       // TODO(vsm): Remove this hack ...
       // This is primarily due to the lack of generic methods,
       // but we need to triage all the types.
     if ($_isFutureOr(type)) {
       // Ignore if we would ignore either side of union.
       let typeArg = $getGenericArgs(type)[0];
       let typeFuture = ${getGenericClass(Future)}(typeArg);
       return $_ignoreTypeFailure(actual, typeFuture) ||
         $_ignoreTypeFailure(actual, typeArg);
@@ skipping 13 matching lines @@
     return false;
   });
 })()''');
 
 /// Returns true if [obj] is an instance of [type]
 /// Returns true if [obj] is a JS function and [type] is a function type
 /// Returns false if [obj] is not an instance of [type] in both spec
 ///  and strong mode
 /// Returns null if [obj] is not an instance of [type] in strong mode
 ///  but might be in spec mode
-bool strongInstanceOf(obj, type, ignoreFromWhiteList) => JS(
-    '',
-    '''(() => {
+bool strongInstanceOf(obj, type, ignoreFromWhiteList) => JS('', '''(() => {
   let actual = $getReifiedType($obj);
   let result = $isSubtype(actual, $type);
   if (result || (actual == $int && $isSubtype($double, $type))) return true;
   if (actual == $jsobject && $_isFunctionType(type) &&
       typeof(obj) === 'function') {
     return true;
   }
   if (result === false) return false;
   if (!dart.__ignoreWhitelistedErrors ||
       ($ignoreFromWhiteList == void 0)) {
     return result;
   }
   if ($_ignoreTypeFailure(actual, $type)) return true;
   return result;
 })()''');
 
 /// Returns true if [obj] is null or an instance of [type]
 /// Returns false if [obj] is non-null and not an instance of [type]
 /// in strong mode
-instanceOfOrNull(obj, type) => JS(
-    '',
-    '''(() => {
+instanceOfOrNull(obj, type) => JS('', '''(() => {
   // If strongInstanceOf returns null, convert to false here.
   if (($obj == null) || $strongInstanceOf($obj, $type, true)) return true;
   return false;
 })()''');
 
 @JSExportName('is')
-bool instanceOf(obj, type) => JS(
-    '',
-    '''(() => {
+bool instanceOf(obj, type) => JS('', '''(() => {
   if ($obj == null) {
     return $type == $Null || $_isTop($type);
   }
   let result = $strongInstanceOf($obj, $type);
   if (result !== null) return result;
   if (!dart.__failForWeakModeIsChecks) return false;
   let actual = $getReifiedType($obj);
   let message = 'Strong mode is-check failure: ' +
       $typeName(actual) + ' does not soundly subtype ' +
       $typeName($type);
@@ skipping 72 matching lines @@
 
   if (JS('bool', 'Math.floor(#) != #', obj, obj)) {
     throwCastError(obj, getReifiedType(obj), JS('', '#', int));
   }
   return obj;
 }
 
 /// Adds type type test predicates to a constructor for a non-parameterized
 /// type. Non-parameterized types can use `instanceof` for subclass checks and
 /// fall through to a helper for subtype tests.
-addSimpleTypeTests(ctor) => JS(
-    '',
-    '''(() => {
+addSimpleTypeTests(ctor) => JS('', '''(() => {
   $ctor.is = function is_C(object) {
     // This is incorrect for classes [Null] and [Object], so we do not use
     // [addSimpleTypeTests] for these classes.
     if (object instanceof this) return true;
     return dart.is(object, this);
   };
   $ctor.as = function as_C(object) {
     if (object instanceof this) return object;
     return dart.as(object, this);
   };
   $ctor._check = function check_C(object) {
     if (object instanceof this) return object;
     return dart.check(object, this);
   };
 })()''');
 
 /// Adds type type test predicates to a constructor. Used for parmeterized
 /// types. We avoid `instanceof` for, e.g. `x is ListQueue` since there is
 /// no common class for `ListQueue<int>` and `ListQueue<String>`.
-addTypeTests(ctor) => JS(
-    '',
-    '''(() => {
+addTypeTests(ctor) => JS('', '''(() => {
   $ctor.as = function as_G(object) {
     return dart.as(object, this);
   };
   $ctor.is = function is_G(object) {
     return dart.is(object, this);
   };
   $ctor._check = function check_G(object) {
     return dart.check(object, this);
   };
 })()''');
 
 // TODO(vsm): Consider optimizing this.  We may be able to statically
 // determine which == operation to invoke given the static types.
-equals(x, y) => JS(
-    '',
-    '''(() => {
+equals(x, y) => JS('', '''(() => {
   if ($x == null || $y == null) return $x == $y;
   let eq = $x[dartx['==']] || $x['=='];
   return eq ? eq.call($x, $y) : $x === $y;
 })()''');
 
 /// Checks that `x` is not null or undefined. */
 notNull(x) {
   if (x == null) throwNullValueError();
   return x;
 }
 
 ///
 /// Creates a dart:collection LinkedHashMap.
 ///
 /// For a map with string keys an object literal can be used, for example
 /// `map({'hi': 1, 'there': 2})`.
 ///
 /// Otherwise an array should be used, for example `map([1, 2, 3, 4])` will
 /// create a map with keys [1, 3] and values [2, 4]. Each key-value pair
 /// should be adjacent entries in the array.
 ///
 /// For a map with no keys the function can be called with no arguments, for
 /// example `map()`.
 ///
 // TODO(jmesserly): this could be faster
 // TODO(jmesserly): we can use default values `= dynamic` once #417 is fixed.
 // TODO(jmesserly): move this to classes for consistency with list literals?
-map(values, [K, V]) => JS(
-    '',
-    '''(() => {
+map(values, [K, V]) => JS('', '''(() => {
   if ($K == null) $K = $dynamic;
   if ($V == null) $V = $dynamic;
   let map = ${getGenericClass(LinkedHashMap)}($K, $V).new();
   if (Array.isArray($values)) {
     for (let i = 0, end = $values.length - 1; i < end; i += 2) {
       let key = $values[i];
       let value = $values[i + 1];
       map._set(key, value);
     }
   } else if (typeof $values === 'object') {
@@ skipping 92 matching lines @@
 /// returns the result. If the value is not found, [valueFn] will be called to
 /// add it. For example:
 ///
 ///     let map = new Map();
 ///     putIfAbsent(map, [1, 2, 'hi ', 'there '], () => 'world');
 ///
 /// ... will create a Map with a structure like:
 ///
 ///     { 1: { 2: { 'hi ': { 'there ': 'world' } } } }
 ///
-multiKeyPutIfAbsent(map, keys, valueFn) => JS(
-    '',
-    '''(() => {
+multiKeyPutIfAbsent(map, keys, valueFn) => JS('', '''(() => {
   for (let k of $keys) {
     let value = $map.get(k);
     if (!value) {
       // TODO(jmesserly): most of these maps are very small (e.g. 1 item),
       // so it may be worth optimizing for that.
       $map.set(k, value = new Map());
     }
     $map = value;
   }
   if ($map.has($_value)) return $map.get($_value);
@@ skipping 11 matching lines @@
 final constants = JS('', 'new Map()');
 
 ///
 /// Canonicalize a constant object.
 ///
 /// Preconditions:
 /// - `obj` is an objects or array, not a primitive.
 /// - nested values of the object are themselves already canonicalized.
 ///
 @JSExportName('const')
-const_(obj) => JS(
-    '',
-    '''(() => {
+const_(obj) => JS('', '''(() => {
   // TODO(leafp): This table gets quite large in apps.
   // Keeping the paths is probably expensive.  It would probably
   // be more space efficient to just use a direct hash table with
   // an appropriately defined structural equality function.
   function lookupNonTerminal(map, key) {
     let result = map.get(key);
     if (result !== void 0) return result;
     map.set(key, result = new Map());
     return result;
   };
@@ skipping 26 matching lines @@
   return $obj;
 })()''');
 
 /// The global constant list table.
 /// This maps the number of elements in the list (n)
 /// to a path of length n of maps indexed by the value
 /// of the field.  The final map is indexed by the element
 /// type and contains the canonical version of the list.
 final constantLists = JS('', 'new Map()');
 
-///
 /// Canonicalize a constant list
-///
-constList(elements, elementType) => JS(
-    '',
-    '''(() => {
+constList(elements, elementType) => JS('', '''(() => {
   function lookupNonTerminal(map, key) {
     let result = map.get(key);
     if (result !== void 0) return result;
     map.set(key, result = new Map());
     return result;
   };
   let count = $elements.length;
   let map = lookupNonTerminal($constantLists, count);
   for (let i = 0; i < count; i++) {
     map = lookupNonTerminal(map, elements[i]);
   }
   let value = map.get($elementType);
   if (value) return value;
-  value = $list($elements, $elementType);
+
+  value = $setType($elements, ${getGenericClass(JSArray)}($elementType));
   map.set($elementType, value);
   return value;
 })()''');
 
 // The following are helpers for Object methods when the receiver
 // may be null or primitive.  These should only be generated by
 // the compiler.
 hashCode(obj) {
   if (obj == null) return 0;
 
   switch (JS('String', 'typeof #', obj)) {
     case "number":
       return JS('', '# & 0x1FFFFFFF', obj);
     case "boolean":
       // From JSBool.hashCode, see comment there.
       return JS('', '# ? (2 * 3 * 23 * 3761) : (269 * 811)', obj);
     case "function":
-      var hashFn = JS('', '#[#]', obj, _tearoffHashcode);
-      if (hashFn != null) return JS('int', '#()', hashFn);
-      return Primitives.objectHashCode(obj);
+      if (JS('bool', '# instanceof Function', obj)) {
+        var hashFn = JS('', '#[#]', obj, _tearoffHashcode);
+        if (hashFn != null) return JS('int', '#()', hashFn);
+        return Primitives.objectHashCode(obj);
+      }
   }
 
   var extension = getExtensionType(obj);
   if (extension != null) {
     return JS('', '#[dartx.hashCode]', obj);
   }
   return JS('', '#.hashCode', obj);
 }
 
 @JSExportName('toString')
 String _toString(obj) {
   if (obj == null) return "null";
 
   var extension = getExtensionType(obj);
   if (extension != null) {
     return JS('String', '#[dartx.toString]()', obj);
   }
-  if (JS('bool', 'typeof # == "function"', obj)) {
+  if (JS('bool', 'typeof # == "function" && # instanceof Function', obj, obj)) {
     // If the function is a Type object, we should just display the type name.
     // Regular Dart code should typically get wrapped type objects instead of
     // raw type (aka JS constructor) objects however raw type objects can be
     // exposed to Dart code via JS interop or debugging tools.
     if (isType(obj)) return typeName(obj);
 
     return JS(
         'String', r'"Closure: " + # + " from: " + #', getReifiedType(obj), obj);
   }
   // TODO(jmesserly): restore this faster path once ES Symbol is treated as
   // an extension type (and thus hits the above code path).
   // See https://github.com/dart-lang/sdk/issues/28323
   // return JS('', '"" + #', obj);
   return JS('String', '#.toString()', obj);
 }
 
 // TODO(jmesserly): is the argument type verified statically?
 noSuchMethod(obj, Invocation invocation) {
-  if (obj == null || JS('bool', 'typeof # == "function"', obj)) {
+  if (obj == null ||
+      JS('bool', 'typeof # == "function" && # instanceof Function', obj, obj)) {
     throwNoSuchMethodError(obj, invocation.memberName,
         invocation.positionalArguments, invocation.namedArguments);
   }
   // Delegate to the (possibly user-defined) method on the object.
   var extension = getExtensionType(obj);
   if (extension != null) {
     return JS('', '#[dartx.noSuchMethod](#)', obj, invocation);
   }
   return JS('', '#.noSuchMethod(#)', obj, invocation);
 }
 
 constFn(x) => JS('', '() => x');
 
 runtimeType(obj) {
   // Handle primitives where the method isn't on the object.
   var result = _checkPrimitiveType(obj);
   if (result != null) return wrapType(result);
 
   // Delegate to the (possibly user-defined) method on the object.
   var extension = getExtensionType(obj);
   if (extension != null) {
     result = JS('', '#[dartx.runtimeType]', obj);
     // If extension doesn't override runtimeType, return the extension type.
     return result ?? wrapType(extension);
   }
-  if (JS('bool', 'typeof # == "function"', obj)) {
+  if (JS('bool', 'typeof # == "function" && # instanceof Function', obj, obj)) {
     return wrapType(getReifiedType(obj));
   }
   return JS('', '#.runtimeType', obj);
 }
 
 /// Implements Dart's interpolated strings as ES2015 tagged template literals.
 ///
 /// For example: dart.str`hello ${name}`
-String str(strings, @rest values) => JS(
-    '',
-    '''(() => {
+String str(strings, @rest values) => JS('', '''(() => {
   let s = $strings[0];
   for (let i = 0, len = $values.length; i < len; ) {
     s += $notNull($_toString($values[i])) + $strings[++i];
   }
   return s;
 })()''');
 
-final JsIterator = JS(
-    '',
-    '''
+final JsIterator = JS('', '''
   class JsIterator {
     constructor(dartIterator) {
       this.dartIterator = dartIterator;
     }
     next() {
       let i = this.dartIterator;
       let done = !i.moveNext();
       return { done: done, value: done ? void 0 : i.current };
     }
   }
@@ skipping 19 matching lines @@
 /// Libraries are not actually deferred in DDC, so this just returns a future
 /// that completes immediately.
 Future loadLibrary() => new Future.value();
 
 /// Defines lazy statics.
 void defineLazy(to, from) {
   for (var name in getOwnNamesAndSymbols(from)) {
     defineLazyProperty(to, name, getOwnPropertyDescriptor(from, name));
   }
 }