More DDC mirrors support

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
 ///
@@ skipping 127 matching lines @@
   }
   makeGenericType[$_genericTypeCtor] = $typeConstructor;
   return makeGenericType;
 })()''');
 
 getGenericClass(type) =>
     JS('', '$safeGetOwnProperty($type, $_originalDeclaration)');
 
 getGenericArgs(type) => JS('', '$safeGetOwnProperty($type, $_typeArguments)');
 
+// TODO(vsm): Collapse into one expando.
 final _constructorSig = JS('', 'Symbol("sigCtor")');
-final _methodSig = JS('', 'Symbol("sig")');
-final _staticSig = JS('', 'Symbol("sigStatic")');
+final _methodSig = JS('', 'Symbol("sigMethod")');
+final _fieldSig = JS('', 'Symbol("sigField")');
+final _getterSig= JS('', 'Symbol("sigGetter")');
+final _setterSig= JS('', 'Symbol("sigSetter")');
+final _staticSig = JS('', 'Symbol("sigStaticMethod")');
+final _staticFieldSig = JS('', 'Symbol("sigStaticField")');
+final _staticGetterSig= JS('', 'Symbol("sigStaticGetter")');
+final _staticSetterSig= JS('', 'Symbol("sigStaticSetter")');
 final _genericTypeCtor = JS('', 'Symbol("genericType")');
 
+// TODO(vsm): Collapse this as well - just provide a dart map to mirrors code.
+// These are queried by mirrors code.
+getConstructorSig(value) => JS('', '#[#]', value, _constructorSig);
 getMethodSig(value) => JS('', '#[#]', value, _methodSig);
+getFieldSig(value) => JS('', '#[#]', value, _fieldSig);
+getGetterSig(value) => JS('', '#[#]', value, _getterSig);
+getSetterSig(value) => JS('', '#[#]', value, _setterSig);
+getStaticSig(value) => JS('', '#[#]', value, _staticSig);
+getStaticFieldSig(value) => JS('', '#[#]', value, _staticFieldSig);
+getStaticGetterSig(value) => JS('', '#[#]', value, _staticGetterSig);
+getStaticSetterSig(value) => JS('', '#[#]', value, _staticSetterSig);
+
 getGenericTypeCtor(value) => JS('', '#[#]', value, _genericTypeCtor);
 
 /// Get the type of a method from an object using the stored signature
 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(
     '',
     '''(() => {
   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(
     '',
     '''(() => {
-  if(!$name) $name = $cls.name;
+  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];
 })()''');
 
 /// 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.
@@ skipping 20 matching lines @@
 /// 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(
+_setInstanceSignature(f, sigF, kind) => JS(
     '',
     '''(() => {
-  $defineMemoizedGetter($f, $_methodSig, () => {
+  $defineMemoizedGetter($f, $kind, () => {
     let sigObj = $sigF();
-    sigObj.__proto__ = $f.__proto__[$_methodSig];
+    sigObj.__proto__ = $f.__proto__[$kind];
     return sigObj;
   });
 })()''');
 
+_setMethodSignature(f, sigF) => _setInstanceSignature(f, sigF, _methodSig);
+_setFieldSignature(f, sigF) => _setInstanceSignature(f, sigF, _fieldSig);
+_setGetterSignature(f, sigF) => _setInstanceSignature(f, sigF, _getterSig);
+_setSetterSignature(f, sigF) => _setInstanceSignature(f, sigF, _setterSig);
+
 // 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)');
 
+_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(
     '',
     '''(() => {
   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.
+///  fields: A function returning an object mapping instance field
+///    names to types.
 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 =
+    ('setters' in signature) ? signature.setters : () => ({});
   let statics =
     ('statics' in signature) ? signature.statics : () => ({});
+  let staticFields =
+    ('sfields' in signature) ? signature.sfields : () => ({});
+  let staticGetters =
+    ('sgetters' in signature) ? signature.sgetters : () => ({});
+  let staticSetters =
+    ('ssetters' in signature) ? signature.ssetters : () => ({});
   let names =
     ('names' in signature) ? signature.names : [];
   $_setConstructorSignature($f, constructors);
   $_setMethodSignature($f, methods);
+  $_setFieldSignature($f, fields);
+  $_setGetterSignature($f, getters);
+  $_setSetterSignature($f, setters);
   $_setStaticSignature($f, statics);
+  $_setStaticFieldSignature($f, staticFields);
+  $_setStaticGetterSignature($f, staticGetters);
+  $_setStaticSetterSignature($f, staticSetters);
   $_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)`.
@@ skipping 193 matching lines @@
 ///
 /// The constructor
 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 });
 })()''');