implement `Invocation.typeArguments` in DDC

pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/classes.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 the operations that define and manipulate Dart
 /// classes.  Included in this are:
 ///   - Generics
 ///   - Class metadata
 ///   - Extension methods
 ///
 
 // TODO(leafp): Consider splitting some of this out.
 part of dart._runtime;
 
 ///
 /// Returns a new type that mixes members from base and all mixins.
 ///
 /// Each mixin applies in sequence, with further to the right ones overriding
 /// previous entries.
 ///
 /// For each mixin, we only take its own properties, not anything from its
 /// superclass (prototype).
-mixin(base, @rest mixins) => JS(
-    '',
-    '''(() => {
+mixin(base, @rest mixins) => JS('', '''(() => {
   // Create an initializer for the mixin, so when derived constructor calls
   // super, we can correctly initialize base and mixins.
 
   // Create a class that will hold all of the mixin methods.
   class Mixin extends $base {}
   // Save the original constructor.  For ClassTypeAlias definitions, this
   // is the concrete type.  We embed metadata (e.g., implemented interfaces)
   // on this constructor and need to access that from runtime instances.
   let constructor = Mixin.prototype.constructor;
   // Copy each mixin's methods, with later ones overwriting earlier entries.
@@ skipping 70 matching lines @@
     clazz, _implements, clazz, _implements);
 
 /// The Symbol for storing type arguments on a specialized generic type.
 final _typeArguments = JS('', 'Symbol("typeArguments")');
 
 final _originalDeclaration = JS('', 'Symbol("originalDeclaration")');
 
 final mixinNew = JS('', 'Symbol("dart.mixinNew")');
 
 /// Wrap a generic class builder function with future flattening.
-flattenFutures(builder) => JS(
-    '',
-    '''(() => {
+flattenFutures(builder) => JS('', '''(() => {
   function flatten(T) {
     if (!T) return $builder($dynamic);
     let futureClass = $getGenericClass($Future);
     //TODO(leafp): This only handles the direct flattening case.
     // It would probably be good to at least search up the class
     // hierarchy.  If we keep doing flattening long term, we may
     // want to implement the full future flattening per spec.
     if ($getGenericClass(T) == futureClass) {
       let args = $getGenericArgs(T);
       if (args) return $builder(args[0]);
     }
     return $builder(T);
   }
   return flatten;
 })()''');
 
 /// Memoize a generic type constructor function.
-generic(typeConstructor, [setBaseClass]) => JS(
-    '',
-    '''(() => {
+generic(typeConstructor, [setBaseClass]) => JS('', '''(() => {
   let length = $typeConstructor.length;
   if (length < 1) {
     $throwInternalError('must have at least one generic type argument');
   }
   let resultMap = new Map();
   function makeGenericType(...args) {
     if (args.length != length && args.length != 0) {
       $throwInternalError('requires ' + length + ' or 0 type arguments');
     }
     while (args.length < length) args.push($dynamic);
@@ skipping 109 matching lines @@
 
 finalFieldType(type, metadata) =>
     JS('', '{ type: #, isFinal: true, metadata: # }', type, metadata);
 
 fieldType(type, metadata) =>
     JS('', '{ type: #, isFinal: false, metadata: # }', type, metadata);
 
 /// Get the type of a constructor from a class using the stored signature
 /// If name is undefined, returns the type of the default constructor
 /// Returns undefined if the constructor is not found.
-classGetConstructorType(cls, name) => JS(
-    '',
-    '''(() => {
+classGetConstructorType(cls, name) => JS('', '''(() => {
   if(!$name) $name = 'new';
   if ($cls === void 0) return void 0;
   if ($cls == null) return void 0;
   let sigCtor = $cls[$_constructorSig];
   if (sigCtor === void 0) return void 0;
   return sigCtor[$name];
 })()''');
 
 // Set up the method signature field on the constructor
 _setInstanceSignature(f, sigF, kind) => defineMemoizedGetter(
@@ skipping 29 matching lines @@
 _setStaticFieldSignature(f, sigF) =>
     JS('', '$defineMemoizedGetter($f, $_staticFieldSig, $sigF)');
 
 _setStaticGetterSignature(f, sigF) =>
     JS('', '$defineMemoizedGetter($f, $_staticGetterSig, $sigF)');
 
 _setStaticSetterSignature(f, sigF) =>
     JS('', '$defineMemoizedGetter($f, $_staticSetterSig, $sigF)');
 
 // Set the lazily computed runtime type field on static methods
-_setStaticTypes(f, names) => JS(
-    '',
-    '''(() => {
+_setStaticTypes(f, names) => JS('', '''(() => {
   for (let name of $names) {
     // TODO(vsm): Need to generate static methods.
     if (!$f[name]) continue;
     $tagLazy($f[name], function() {
       return $f[$_staticSig][name];
     })
   }
 })()''');
 
 /// Set up the type signature of a class (constructor object)
 /// f is a constructor object
 /// signature is an object containing optional properties as follows:
 ///  methods: A function returning an object mapping method names
 ///   to method types.  The function is evaluated lazily and cached.
 ///  statics: A function returning an object mapping static method
 ///   names to types.  The function is evaluated lazily and cached.
 ///  names: An array of the names of the static methods.  Used to
 ///   permit eagerly setting the runtimeType field on the methods
 ///   while still lazily computing the type descriptor object.
 ///  fields: A function returning an object mapping instance field
 ///    names to types.
-setSignature(f, signature) => JS(
-    '',
-    '''(() => {
+setSignature(f, signature) => JS('', '''(() => {
   // TODO(ochafik): Deconstruct these when supported by Chrome.
   let constructors =
     ('constructors' in signature) ? signature.constructors : () => ({});
   let methods =
     ('methods' in signature) ? signature.methods : () => ({});
   let fields =
     ('fields' in signature) ? signature.fields : () => ({});
   let getters =
     ('getters' in signature) ? signature.getters : () => ({});
   let setters =
@@ skipping 13 matching lines @@
   $_setFieldSignature($f, fields);
   $_setGetterSignature($f, getters);
   $_setSetterSignature($f, setters);
   $_setStaticSignature($f, statics);
   $_setStaticFieldSignature($f, staticFields);
   $_setStaticGetterSignature($f, staticGetters);
   $_setStaticSetterSignature($f, staticSetters);
   $_setStaticTypes($f, names);
 })()''');
 
-bool _hasSigEntry(type, sigF, name) => JS(
-    'bool',
-    '''(() => {
+bool _hasSigEntry(type, sigF, name) => JS('bool', '''(() => {
   let sigObj = $type[$sigF];
   if (sigObj === void 0) return false;
   return $name in sigObj;
 })()''');
 
 bool hasMethod(type, name) => _hasSigEntry(type, _methodSig, name);
 bool hasGetter(type, name) => _hasSigEntry(type, _getterSig, name);
 bool hasSetter(type, name) => _hasSigEntry(type, _setterSig, name);
 bool hasField(type, name) => _hasSigEntry(type, _fieldSig, name);
 
@@ skipping 41 matching lines @@
   var names = getOwnPropertyNames(coreObjProto);
   for (int i = 0; i < JS('int', '#.length', names); ++i) {
     var name = JS('', '#[#]', names, i);
     var desc = getOwnPropertyDescriptor(coreObjProto, name);
     defineProperty(jsProto, getExtensionSymbol(name), desc);
   }
 }
 
 final _extensionMap = JS('', 'new Map()');
 
-_applyExtension(jsType, dartExtType) => JS(
-    '',
-    '''(() => {
+_applyExtension(jsType, dartExtType) => JS('', '''(() => {
   // TODO(vsm): Not all registered js types are real.
   if (!$jsType) return;
 
   let jsProto = $jsType.prototype;
 
   // TODO(vsm): This sometimes doesn't exist on FF.  These types will be
   // broken.
   if (!jsProto) return;
 
   $_installProperties(jsProto, $dartExtType, jsProto[$_extensionType]);
@@ skipping 41 matching lines @@
 ///
 /// Results in:
 ///
 ///     MyType.prototype[dartx.add] = MyType.prototype.add;
 ///     MyType.prototype[dartx.remove] = MyType.prototype.remove;
 ///
 // TODO(jmesserly): essentially this gives two names to the same method.
 // This benefit is roughly equivalent call performance either way, but the
 // cost is we need to call defineExtensionMembers any time a subclass
 // overrides one of these methods.
-defineExtensionMembers(type, methodNames) => JS(
-    '',
-    '''(() => {
+defineExtensionMembers(type, methodNames) => JS('', '''(() => {
   let proto = $type.prototype;
   for (let name of $methodNames) {
     let method = $getOwnPropertyDescriptor(proto, name);
     $defineProperty(proto, $getExtensionSymbol(name), method);
   }
   // Ensure the signature is available too.
   // TODO(jmesserly): not sure if we can do this in a cleaner way. Essentially
   // we need to copy the signature (and in the future, other data like
   // annotations) any time we copy a method as part of our metaprogramming.
   // It might be more friendly to JS metaprogramming if we include this info
@@ skipping 19 matching lines @@
   upgradeSig($_getterSig);
   upgradeSig($_setterSig);
 })()''');
 
 /// Sets the type of `obj` to be `type`
 setType(obj, type) {
   JS('', '#.__proto__ = #.prototype', obj, type);
   return obj;
 }
 
-/// Sets the element type of a list literal.
-list(obj, elementType) =>
-    setType(obj, JS('', '#(#)', getGenericClass(JSArray), elementType));
-
 /// Link the extension to the type it's extending as a base class.
 setBaseClass(derived, base) {
   JS('', '#.prototype.__proto__ = #.prototype', derived, base);
   // We use __proto__ to track the superclass hierarchy (see isSubtype).
   JS('', '#.__proto__ = #', derived, base);
 }
 
 /// Like [setBaseClass], but for generic extension types such as `JSArray<E>`.
 setExtensionBaseClass(dartType, jsType) {
   // Mark the generic type as an extension type and link the prototype objects.
   var dartProto = JS('', '#.prototype', dartType);
   JS('', '#[#] = #', dartProto, _extensionType, dartType);
   JS('', '#.__proto__ = #.prototype', dartProto, jsType);
 }
 
 defineEnumValues(enumClass, names) {
   var values = [];
   for (var i = 0; i < JS('int', '#.length', names); i++) {
     var value = const_(JS('', 'new #.new(#)', enumClass, i));
     JS('', '#.push(#)', values, value);
     defineValue(enumClass, JS('', '#[#]', names, i), value);
   }
   JS('', '#.values = #', enumClass, constList(values, enumClass));
 }