Wrapperless dart:html and friends

tool/input_sdk/private/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 168 matching lines @@
 _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('', '''(() => {
   for (let name of $names) {
+    // TODO(vsm): Need to generate static methods.
+    if (!$f[name]) continue;
     $tagMemoized($f[name], function() {
       let parts = $f[$_staticSig][name];
       return $definiteFunctionType.apply(null, parts);
     })
   }
 })()''');
 
 /// Set up the type signature of a class (constructor object)
 /// f is a constructor object
 /// signature is an object containing optional properties as follows:
@@ skipping 30 matching lines @@
 /// This is important because otherwise, trying to read or write the field
 /// would end up calling the getter or setter, and one of those might not even
 /// exist, resulting in a runtime error. Even if they did exist, that's the
 /// wrong behavior if a new field was declared.
 ///
 virtualField(subclass, fieldName) => JS('', '''(() => {
   // If the field is already overridden, do nothing.
   let prop = $getOwnPropertyDescriptor($subclass.prototype, $fieldName);
   if (prop) return;
 
-  let symbol = Symbol($subclass.name + '.' + $fieldName);
+  let symbol = Symbol($subclass.name + '.' + $fieldName.toString());
   $defineProperty($subclass.prototype, $fieldName, {
     get: function() { return this[symbol]; },
     set: function(x) { this[symbol] = x; }
   });
 })()''');
 
 ///
 /// Given a class and an initializer method name, creates a constructor
 /// function with the same name. For example `new SomeClass.name(args)`.
 ///
 defineNamedConstructor(clazz, name) => JS('', '''(() => {
   let proto = $clazz.prototype;
   let initMethod = proto[$name];
   let ctor = function() { return initMethod.apply(this, arguments); };
   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('', '{}');
 
 getExtensionSymbol(name) => JS('', '''(() => {
   let sym = $dartx[$name];
-  if (!sym) $dartx[$name] = sym = Symbol('dartx.' + $name);
+  if (!sym) $dartx[$name] = sym = Symbol('dartx.' + $name.toString());
   return sym;
 })()''');
 
 defineExtensionNames(names) => JS('', '$names.forEach($getExtensionSymbol)');
 
 // Install properties in prototype order.  Properties / descriptors from
 // more specific types should overwrite ones from less specific types.
 _installProperties(jsProto, extProto) => JS('', '''(() => {
   if (extProto !== $Object.prototype && extProto !== jsProto) {
     $_installProperties(jsProto, extProto.__proto__);
   }
   $copyTheseProperties(jsProto, extProto, $getOwnPropertySymbols(extProto));
 })()''');
 
 ///
 /// 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;
 
   // Mark the JS type's instances so we can easily check for extensions.
-  $assert_(jsProto[$_extensionType] === void 0);
   jsProto[$_extensionType] = $dartExtType;
   $_installProperties(jsProto, extProto);
   let originalSigFn = $getOwnPropertyDescriptor($dartExtType, $_methodSig).get;
   $assert_(originalSigFn);
   $defineMemoizedGetter($jsType, $_methodSig, originalSigFn);
 })()''');
 
 ///
 /// Mark a concrete type as implementing extension methods.
 /// For example: `class MyIter implements Iterable`.
@@ skipping 10 matching lines @@
 ///     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('', '''(() => {
   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);
   }
   // 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
   // on the function.
   let originalSigFn = $getOwnPropertyDescriptor($type, $_methodSig).get;
   $defineMemoizedGetter(type, $_methodSig, function() {
@@ skipping 24 matching lines @@
 })()''');
 
 /// Sets the element type of a list literal.
 list(obj, elementType) =>
     JS('', '$setType($obj, ${getGenericClass(JSArray)}($elementType))');
 
 setBaseClass(derived, base) => JS('', '''(() => {
   // Link the extension to the type it's extending as a base class.
   $derived.prototype.__proto__ = $base.prototype;
 })()''');