fix #30030, fix #27327 - fix tearoffs and various Object member bugs

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 391 matching lines @@
     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);
+void _installProperties(jsProto, dartType, installedParent) {
+  if (JS('bool', '# === #', dartType, Object)) {
+    _installPropertiesForObject(jsProto);
+    return;
+  }
+  var dartProto = JS('', '#.prototype', dartType);
+  if (JS('bool', '# === #', jsProto, dartProto)) return;

[vsm, 2017/06/30 18:08:47]

This was there before, but I'm not sure I understand why/when this line above
kicks in.

[Jennifer Messerly, 2017/07/05 21:17:16]

Yeah, I'm not sure! It might've been a guard against Array.prototype (tho we
still had useless copy properties) or it might've been to stop at JS
Object.prototype. In the new code, neither of those should be a problem so I'll
see if I can clean it up :)

 
-  var parentsExtension = JS('', '(#.__proto__)[#]', jsProto, _extensionType);
-  var installedParent =
-      JS('', '# && #.prototype', parentsExtension, parentsExtension);
+  // If the extension methods of the parent have been installed on the parent
+  // of [jsProto], the methods will be available via prototype inheritance.
+  var dartSupertype = JS('', '#.__proto__', dartType);
+  if (JS('bool', '# !== #', dartSupertype, installedParent)) {
+    _installProperties(jsProto, dartSupertype, installedParent);
+  }
 
-  _installProperties2(jsProto, extProto, coreObjProto, installedParent);
+  copyTheseProperties(jsProto, dartProto, getOwnPropertySymbols(dartProto));
 }
 
-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)) {
-      _installProperties2(jsProto, extParent, coreObjProto, installedParent);
-    }
-  }
-  copyTheseProperties(jsProto, extProto, getOwnPropertySymbols(extProto));
-}
-
-void _installPropertiesForObject(jsProto, coreObjProto) {
+void _installPropertiesForObject(jsProto) {
   // core.Object members need to be copied from the non-symbol name to the
   // symbol name.
+  var coreObjProto = JS('', '#.prototype', Object);
   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(
     '',
     '''(() => {
   // TODO(vsm): Not all registered js types are real.
   if (!jsType) return;
 
-  let extProto = $dartExtType.prototype;
   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]);
+
   // Mark the JS type's instances so we can easily check for extensions.
   jsProto[$_extensionType] = $dartExtType;
-  $_installProperties(jsProto, extProto);
+
   function updateSig(sigF) {
     let originalDesc = $getOwnPropertyDescriptor($dartExtType, sigF);
     if (originalDesc === void 0) return;
     let originalSigFn = originalDesc.get;
     $assert_(originalSigFn);
     $defineMemoizedGetter($jsType, sigF, originalSigFn);
   }
   updateSig($_methodSig);
   updateSig($_fieldSig);
   updateSig($_getterSig);
@@ skipping 56 matching lines @@
 })()''');
 
 /// 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) =>
-    JS('', '$setType($obj, ${getGenericClass(JSArray)}($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, e.g. `JSArray<E>`
-setExtensionBaseClass(derived, base) {
-  // Mark the generic type as an extension type and link the prototype objects
-  return JS(
-      '',
-      '''(() => {
-    if ($base) {
-      $derived.prototype[$_extensionType] = $derived;
-      $derived.prototype.__proto__ = $base.prototype
-    }
-})()''');
+/// 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));
 }