Library custom formatters

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 {}
   // Copy each mixin's methods, with later ones overwriting earlier entries.
   for (let m of $mixins) {
     $copyProperties(Mixin.prototype, m.prototype);
   }
   // Initializer method: run mixin initializers, then the base.
@@ skipping 17 matching lines @@
       }
       return s;
     }
   });
 
   // Save mixins for reflection
   Mixin[$_mixins] = $mixins;
   return Mixin;
 })()''');
 
-
 /// The Symbol for storing type arguments on a specialized generic type.
 final _mixins = JS('', 'Symbol("mixins")');
 
 getMixins(clazz) => JS('', '$clazz[$_mixins]');
 
 @JSExportName('implements')
 final _implements = JS('', 'Symbol("implements")');
 
 getImplements(clazz) => JS('', '#[#]', clazz, _implements);
 
 /// The Symbol for storing type arguments on a specialized generic type.
 final _typeArguments = JS('', 'Symbol("typeArguments")');
 
 final _originalDeclaration = JS('', 'Symbol("originalDeclaration")');
 
 /// 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) => JS('', '''(() => {
+generic(typeConstructor) => 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 16 matching lines @@
             value[$_originalDeclaration] = makeGenericType;
           }
         } else {
           value = new Map();
         }
         map.set(arg, value);
       }
     }
     return value;
   }
+  makeGenericType[$_genericTypeCtor] = $typeConstructor;
   return makeGenericType;
 })()''');
 
 getGenericClass(type) =>
     JS('', '$safeGetOwnProperty($type, $_originalDeclaration)');
 
-getGenericArgs(type) =>
-    JS('', '$safeGetOwnProperty($type, $_typeArguments)');
+getGenericArgs(type) => JS('', '$safeGetOwnProperty($type, $_typeArguments)');
 
 final _constructorSig = JS('', 'Symbol("sigCtor")');
 final _methodSig = JS('', 'Symbol("sig")');
 final _staticSig = JS('', 'Symbol("sigStatic")');
+final _genericTypeCtor = JS('', 'Symbol("genericType")');
+
+getMethodSig(value) => JS('', '#[#]', value, _methodSig);
+getGenericTypeCtor(value) => JS('', '#[#]', value, _genericTypeCtor);
 
 /// Get the type of a method from an object using the stored signature
-getMethodType(obj, name) => JS('', '''(() => {
+getMethodType(obj, name) => JS(
+    '',
+    '''(() => {
   let type = $obj == null ? $Object : $obj.__proto__.constructor;
   return $getMethodTypeFromType(type, $name);
 })()''');
 
 /// Get the type of a method from a type using the stored signature
-getMethodTypeFromType(type, name) => JS('', '''(() => {
+getMethodTypeFromType(type, name) => JS(
+    '',
+    '''(() => {
   let sigObj = $type[$_methodSig];
   if (sigObj === void 0) return void 0;
   return sigObj[$name];
 })()''');
 
 /// 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 = $cls.name;
   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];
 })()''');
 
 /// Given an object and a method name, tear off the method.
 /// Sets the runtime type of the torn off method appropriately,
 /// and also binds the object.
 ///
 /// If the optional `f` argument is passed in, it will be used as the method.
 /// This supports cases like `super.foo` where we need to tear off the method
 /// from the superclass, not from the `obj` directly.
 /// TODO(leafp): Consider caching the tearoff on the object?
-bind(obj, name, f) => JS('', '''(() => {
+bind(obj, name, f) => JS(
+    '',
+    '''(() => {
   if ($f === void 0) $f = $obj[$name];
   $f = $f.bind($obj);
   // TODO(jmesserly): track the function's signature on the function, instead
   // of having to go back to the class?
   let sig = $getMethodType($obj, $name);
   $assert_(sig);
   $tag($f, sig);
   return $f;
 })()''');
 
 /// Instantiate a generic method.
 ///
 /// We need to apply the type arguments both to the function, as well as its
 /// associated function type.
 gbind(f, @rest typeArgs) {
   var result = JS('', '#.apply(null, #)', f, typeArgs);
   var sig = JS('', '#.apply(null, #)', _getRuntimeType(f), typeArgs);
   tag(result, sig);
   return result;
 }
 
 // Set up the method signature field on the constructor
-_setMethodSignature(f, sigF) => JS('', '''(() => {
+_setMethodSignature(f, sigF) => JS(
+    '',
+    '''(() => {
   $defineMemoizedGetter($f, $_methodSig, () => {
     let sigObj = $sigF();
     sigObj.__proto__ = $f.__proto__[$_methodSig];
     return sigObj;
   });
 })()''');
 
 // Set up the constructor signature field on the constructor
 _setConstructorSignature(f, sigF) =>
     JS('', '$defineMemoizedGetter($f, $_constructorSig, $sigF)');
 
 // Set up the static signature field on the constructor
 _setStaticSignature(f, sigF) =>
     JS('', '$defineMemoizedGetter($f, $_staticSig, $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 evalutated 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.
-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 statics =
     ('statics' in signature) ? signature.statics : () => ({});
   let names =
     ('names' in signature) ? signature.names : [];
   $_setConstructorSignature($f, constructors);
   $_setMethodSignature($f, methods);
   $_setStaticSignature($f, statics);
   $_setStaticTypes($f, names);
 })()''');
 
 hasMethod(obj, name) => JS('', '$getMethodType($obj, $name) !== void 0');
 
 /// Given a class and an initializer method name, creates a constructor
 /// function with the same name.
 ///
 /// After we define the named constructor, the class can be constructed with
 /// `new SomeClass.name(args)`.
-defineNamedConstructor(clazz, name) => JS('', '''(() => {
+defineNamedConstructor(clazz, name) => JS(
+    '',
+    '''(() => {
   let proto = $clazz.prototype;
   let initMethod = proto[$name];
   let ctor = function(...args) { initMethod.apply(this, args); };
+  ctor[$isNamedConstructor] = true;
   ctor.prototype = proto;
   // Use defineProperty so we don't hit a property defined on Function,
   // like `caller` and `arguments`.
   $defineProperty($clazz, $name, { value: ctor, configurable: true });
 })()''');
 
-
 final _extensionType = JS('', 'Symbol("extensionType")');
 
 getExtensionType(obj) => JS('', '#[#]', obj, _extensionType);
 
 final dartx = JS('', 'dartx');
 
 getExtensionSymbol(name) {
   var sym = JS('', 'dartx[#]', name);
   if (sym == null) {
     sym = JS('', 'Symbol("dartx." + #.toString())', name);
     JS('', 'dartx[#] = #', name, sym);
   }
   return sym;
 }
 
 defineExtensionNames(names) =>
     JS('', '#.forEach(#)', names, getExtensionSymbol);
 
-
 /// Install properties in prototype-first order.  Properties / descriptors from
 /// more specific types should overwrite ones from less specific types.
 void _installProperties(jsProto, extProto) {
-
   // This relies on the Dart type literal evaluating to the JavaScript
   // constructor.
   var coreObjProto = JS('', '#.prototype', Object);
 
-  var parentsExtension =
-      JS('', '(#.__proto__)[#]', jsProto, _extensionType);
+  var parentsExtension = JS('', '(#.__proto__)[#]', jsProto, _extensionType);
   var installedParent =
       JS('', '# && #.prototype', parentsExtension, parentsExtension);
 
   _installProperties2(jsProto, extProto, coreObjProto, installedParent);
 }
 
 void _installProperties2(jsProto, extProto, coreObjProto, installedParent) {
   if (JS('bool', '# === #', extProto, coreObjProto)) {
     _installPropertiesForObject(jsProto, coreObjProto);
     return;
   }
   if (JS('bool', '# !== #', jsProto, extProto)) {
     var extParent = JS('', '#.__proto__', extProto);
 
     // If the extension methods of the parent have been installed on the parent
     // of [jsProto], the methods will be available via prototype inheritance.
 
-    if(JS('bool', '# !== #', installedParent, extParent)) {
+    if (JS('bool', '# !== #', installedParent, extParent)) {
       _installProperties2(jsProto, extParent, coreObjProto, installedParent);
     }
   }
   copyTheseProperties(jsProto, extProto, getOwnPropertySymbols(extProto));
 }
 
 void _installPropertiesForObject(jsProto, coreObjProto) {
   // core.Object members need to be copied from the non-symbol name to the
   // symbol name.
   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);
   }
   return;
 }
 
 /// Copy symbols from the prototype of the source to destination.
 /// These are the only properties safe to copy onto an existing public
 /// JavaScript class.
-registerExtension(jsType, dartExtType) => JS('', '''(() => {
+registerExtension(jsType, dartExtType) => JS(
+    '',
+    '''(() => {
   // TODO(vsm): Not all registered js types are real.
   if (!jsType) return;
 
   let extProto = $dartExtType.prototype;
   let jsProto = $jsType.prototype;
 
   // Mark the JS type's instances so we can easily check for extensions.
   jsProto[$_extensionType] = $dartExtType;
   $_installProperties(jsProto, extProto);
   let originalSigFn = $getOwnPropertyDescriptor($dartExtType, $_methodSig).get;
@@ skipping 13 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);
     // TODO(vsm): We should be able to generate code to avoid this case.
     // The method may be null if this type implements a potentially native
     // interface but isn't native itself.  For a field on this type, we're not
     // generating a corresponding getter/setter method - it's just a field.
     if (!method) continue;
     $defineProperty(proto, $getExtensionSymbol(name), method);
   }
@@ skipping 58 matching lines @@
   JS('', '#.__proto__ = #.__proto__', callableCtor, classExpr);
   return callableCtor;
 }
 
 /// Given a class and an initializer method name and a call method, creates a
 /// constructor function with the same name.
 ///
 /// For example it can be called with `new SomeClass.name(args)`.
 ///
 /// The constructor
-defineNamedConstructorCallable(clazz, name, ctor) => JS('', '''(() => {
+defineNamedConstructorCallable(clazz, name, ctor) => JS(
+    '',
+    '''(() => {
   ctor.prototype = $clazz.prototype;
   // Use defineProperty so we don't hit a property defined on Function,
   // like `caller` and `arguments`.
   $defineProperty($clazz, $name, { value: ctor, configurable: true });
 })()''');