Name and hoist types

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 136 matching lines @@
 /// 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;
-  let parts = sigObj[$name];
-  if (parts === void 0) return void 0;
-  return $definiteFunctionType.apply(null, parts);
+  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 ($cls === void 0) return void 0;
   if ($cls == null) return void 0;
   let sigCtor = $cls[$_constructorSig];
   if (sigCtor === void 0) return void 0;
-  let parts = sigCtor[$name];
-  if (parts === void 0) return void 0;
-  return $definiteFunctionType.apply(null, parts);
+  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?
@@ skipping 35 matching lines @@
 // 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('', '''(() => {
   for (let name of $names) {
     // TODO(vsm): Need to generate static methods.
     if (!$f[name]) continue;
     $tagLazy($f[name], function() {
-      let parts = $f[$_staticSig][name];
-      return $definiteFunctionType.apply(null, parts);
+      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
@@ skipping 192 matching lines @@
 setBaseClass(derived, base) {
   JS('', '#.prototype.__proto__ = #.prototype', derived, base);
 }
 
 /// Like [setBaseClass] but for generic extension types, e.g. `JSArray<E>`
 setExtensionBaseClass(derived, base) {
   // Mark the generic type as an extension type.
   JS('', '#.prototype[#] = #', derived, _extensionType, derived);
   setBaseClass(derived, base);
 }