Updating Polymer to derive from custom elements.

pkg/polymer/lib/src/declaration.dart

 // Copyright (c) 2013, 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.
 
 part of polymer;
 
 /**
- * **Deprecated**: use [Polymer.register] instead.
- *
- * Registers a [PolymerElement]. This is similar to [registerCustomElement]
- * but it is designed to work with the `<element>` element and adds additional
- * features.
- */
-@deprecated
-void registerPolymerElement(String localName, PolymerElement create()) {
-  Polymer._registerClassMirror(localName, reflect(create()).type);
-}
-
-/**
  * **Warning**: this class is experiental and subject to change.
  *
  * The implementation for the `polymer-element` element.
  *
  * Normally you do not need to use this class directly, see [PolymerElement].
  */
-class PolymerDeclaration extends CustomElement {
+class PolymerDeclaration extends HtmlElement {
+  static const _TAG = 'polymer-element';
+
+  factory PolymerDeclaration() => new Element.tag(_TAG);
   // Fully ported from revision:
   // https://github.com/Polymer/polymer/blob/4dc481c11505991a7c43228d3797d28f21267779
   //
   //   src/declaration/attributes.js
   //   src/declaration/events.js
   //   src/declaration/polymer-element.js
   //   src/declaration/properties.js
   //   src/declaration/prototype.js (note: most code not needed in Dart)
   //   src/declaration/styles.js
   //
   // Not yet ported:
   //   src/declaration/path.js - blocked on HTMLImports.getDocumentUrl
 
-  // TODO(jmesserly): these should be Type not ClassMirror. But we can't get
-  // from ClassMirror to Type yet in dart2js, so we use ClassMirror for now.
-  // See https://code.google.com/p/dart/issues/detail?id=12607
-  ClassMirror _type;
-  ClassMirror get type => _type;
+  Type _type;
+  Type get type => _type;
 
   // TODO(jmesserly): this is a cache, because it's tricky in Dart to get from
-  // ClassMirror -> Supertype.
-  ClassMirror _supertype;
-  ClassMirror get supertype => _supertype;
+  // Type -> Supertype.
+  Type _supertype;
+  Type get supertype => _supertype;
 
   // TODO(jmesserly): this is also a cache, since we can't store .element on
   // each level of the __proto__ like JS does.
   PolymerDeclaration _super;
   PolymerDeclaration get superDeclaration => _super;
 
   String _name;
   String get name => _name;
 
   /**
@@ skipping 13 matching lines @@
 
   Map<String, Object> _instanceAttributes;
 
   List<Element> _sheets;
   List<Element> get sheets => _sheets;
 
   List<Element> _styles;
   List<Element> get styles => _styles;
 
   DocumentFragment get templateContent {
-    final template = query('template');
+    final template = this.query('template');
     return template != null ? template.content : null;
   }
 
   /** Maps event names and their associated method in the element class. */
   final Map<String, String> _eventDelegates = {};
 
   /** Expected events per element node. */
   // TODO(sigmund): investigate whether we need more than 1 set of local events
   // per element (why does the js implementation stores 1 per template node?)
   Expando<Set<String>> _templateDelegates;
 
-  void created() {
-    super.created();
-
+  PolymerDeclaration.created() : super.created() {
     // fetch the element name
     _name = attributes['name'];
     // install element definition, if ready
     registerWhenReady();
   }
 
   void registerWhenReady() {
     // if we have no prototype, wait
     if (waitingForType(name)) {
       return;
@@ skipping 71 matching lines @@
     // setting resource paths. e.g.
     // this.$.image.src = this.resolvePath('images/foo.png')
     // Potentially remove when spec bug is addressed.
     // https://www.w3.org/Bugs/Public/show_bug.cgi?id=21407
     // TODO(jmesserly): resolvePath not ported, see first comment in this class.
 
     // under ShadowDOMPolyfill, transforms to approximate missing CSS features
     _shimShadowDomStyling(templateContent, name);
 
     // register our custom element
-    registerType(name);
+    registerType(name, extendsTag: extendee);
 
     // NOTE: skip in Dart because we don't have mutable global scope.
     // reference constructor in a global named by 'constructor' attribute
     // publishConstructor();
   }
 
   /**
    * Gets the Dart type registered for this name, and sets up declarative
    * features. Fills in the [type] and [supertype] fields.
    *
    * *Note*: unlike the JavaScript version, we do not have to metaprogram the
    * prototype, which simplifies this method.
    */
   void buildType(String name, String extendee) {
     // get our custom type
     _type = _getRegisteredType(name);
 
     // get basal prototype
     _supertype = _getRegisteredType(extendee);
     if (supertype != null) _super = _getDeclaration(supertype);
 
+    var cls = reflectClass(_type);
+
     // transcribe `attributes` declarations onto own prototype's `publish`
-    publishAttributes(type, _super);
+    publishAttributes(cls, _super);
 
     publishProperties(type);
 
-    inferObservers(type);
+    inferObservers(cls);
 
     // Skip the rest in Dart:
     // chain various meta-data objects to inherited versions
     // chain custom api to inherited
     // build side-chained lists to optimize iterations
     // inherit publishing meta-data
     //this.inheritAttributesObjects(prototype);
     //this.inheritDelegates(prototype);
     // x-platform fixups
   }
 
   /** Implement various declarative features. */
   void desugar() {
     // compile list of attributes to copy to instances
     accumulateInstanceAttributes();
     // parse on-* delegates declared on `this` element
     parseHostEvents();
     // parse on-* delegates declared in templates
     parseLocalEvents();
     // install external stylesheets as if they are inline
     installSheets();
+    var cls = reflectClass(type);
     // TODO(jmesserly): this feels unnatrual in Dart. Since we have convenient
     // lazy static initialization, can we get by without it?
-    var registered = type.methods[#registerCallback];
+    var registered = cls.methods[#registerCallback];
     if (registered != null && registered.isStatic &&
         registered.isRegularMethod) {
-      type.invoke(#registerCallback, [this]);
+      cls.invoke(#registerCallback, [this]);
     }
 
   }
 
-  void registerType(String name) {
-    // TODO(jmesserly): document.register
-    registerCustomElement(name, () =>
-        type.newInstance(const Symbol(''), const []).reflectee);
+  void registerType(String name, {String extendsTag}) {
+    // native element must be specified in extends
+    var nativeExtends = (extendsTag != null && !extendsTag.contains('-')) ?
+        extendsTag : null;
+    document.register(name, type, extendsTag: nativeExtends);
   }
 
-  void publishAttributes(ClassMirror type, PolymerDeclaration superDecl) {
+  void publishAttributes(ClassMirror cls, PolymerDeclaration superDecl) {
     // get properties to publish
     if (superDecl != null && superDecl._publish != null) {
       _publish = new Map.from(superDecl._publish);
     }
-    _publish = _getProperties(type, _publish, (x) => x is PublishedProperty);
+    _publish = _getProperties(cls, _publish, (x) => x is PublishedProperty);
 
     // merge names from 'attributes' attribute
     var attrs = attributes['attributes'];
     if (attrs != null) {
       // names='a b c' or names='a,b,c'
       // record each name for publishing
       for (var attr in attrs.split(attrs.contains(',') ? ',' : ' ')) {
         // remove excess ws
         attr = attr.trim();
 
         // do not override explicit entries
         if (_publish != null && _publish.containsKey(attr)) continue;
 
         var property = new Symbol(attr);
-        var mirror = type.variables[property];
+        var mirror = cls.variables[property];
         if (mirror == null) {
-          mirror = type.getters[property];
-          if (mirror != null && !_hasSetter(type, mirror)) mirror = null;
+          mirror = cls.getters[property];
+          if (mirror != null && !_hasSetter(cls, mirror)) mirror = null;
         }
         if (mirror == null) {
           window.console.warn('property for attribute $attr of polymer-element '
               'name=$name not found.');
           continue;
         }
         if (_publish == null) _publish = {};
         _publish[attr] = mirror;
       }
     }
@@ skipping 33 matching lines @@
   void addAttributeDelegates(Map<String, String> delegates) {
     attributes.forEach((name, value) {
       if (_hasEventPrefix(name)) {
         delegates[_removeEventPrefix(name)] = value;
       }
     });
   }
 
   /** Extracts events under the element's <template>. */
   void parseLocalEvents() {
-    for (var t in queryAll('template')) {
+    for (var t in this.queryAll('template')) {
       final events = new Set<String>();
       // acquire delegates from entire subtree at t
       accumulateTemplatedEvents(t, events);
       if (events.isNotEmpty) {
         // store delegate information directly on template
         if (_templateDelegates == null) {
           _templateDelegates = new Expando<Set<String>>();
         }
         _templateDelegates[t] = events;
       }
@@ skipping 135 matching lines @@
         ..attributes[_STYLE_SCOPE_ATTRIBUTE] = '$name-$scopeDescriptor';
   }
 
   /**
    * fetch a list of all observable properties names in our inheritance chain
    * above Polymer.
    */
   // TODO(sjmiles): perf: reflection is slow, relatively speaking
   // If an element may take 6us to create, getCustomPropertyNames might
   // cost 1.6us more.
-  void inferObservers(ClassMirror type) {
-    for (var method in type.methods.values) {
+  void inferObservers(ClassMirror cls) {
+    for (var method in cls.methods.values) {
       if (method.isStatic || !method.isRegularMethod) continue;
 
       String name = MirrorSystem.getName(method.simpleName);
       if (name.endsWith('Changed')) {
         if (_observe == null) _observe = {};
         name = name.substring(0, name.length - 7);
         _observe[name] = method.simpleName;
       }
     }
   }
 
-  void publishProperties(ClassMirror type) {
+  void publishProperties(Type type) {
     // Dart note: _publish was already populated by publishAttributes
     if (_publish != null) _publishLC = _lowerCaseMap(_publish);
   }
 
   Map<String, dynamic> _lowerCaseMap(Map<String, dynamic> properties) {
     final map = new Map<String, dynamic>();
     properties.forEach((name, value) {
       map[name.toLowerCase()] = value;
     });
     return map;
   }
 }
 
 /// maps tag names to prototypes
-final Map _typesByName = new Map<String, ClassMirror>();
+final Map _typesByName = new Map<String, Type>();
 
-ClassMirror _getRegisteredType(String name) => _typesByName[name];
+Type _getRegisteredType(String name) => _typesByName[name];
 
 /// elements waiting for prototype, by name
 final Map _waitType = new Map<String, PolymerDeclaration>();
 
 void _notifyType(String name) {
   var waiting = _waitType.remove(name);
   if (waiting != null) waiting.registerWhenReady();
 }
 
 /// elements waiting for super, by name
 final Map _waitSuper = new Map<String, List<PolymerDeclaration>>();
 
 void _notifySuper(String name) {
   _registered.add(name);
   var waiting = _waitSuper.remove(name);
   if (waiting != null) {
     for (var w in waiting) {
       w.registerWhenReady();
     }
   }
 }
 
 /// track document.register'ed tag names
 final Set _registered = new Set<String>();
 
 bool _isRegistered(name) => _registered.contains(name);
 
-final Map _declarations = new Map<ClassMirror, PolymerDeclaration>();
+final Map _declarations = new Map<Type, PolymerDeclaration>();
 
-PolymerDeclaration _getDeclaration(ClassMirror type) => _declarations[type];
+PolymerDeclaration _getDeclaration(Type type) => _declarations[type];
 
 final _objectType = reflectClass(Object);
 
-Map _getProperties(ClassMirror type, Map props, bool matches(metadata)) {
-  for (var field in type.variables.values) {
+Map _getProperties(ClassMirror cls, Map props, bool matches(metadata)) {
+  for (var field in cls.variables.values) {
     if (field.isFinal || field.isStatic || field.isPrivate) continue;
 
     for (var meta in field.metadata) {
       if (matches(meta.reflectee)) {
         if (props == null) props = {};
         props[MirrorSystem.getName(field.simpleName)] = field;
         break;
       }
     }
   }
 
-  for (var getter in type.getters.values) {
+  for (var getter in cls.getters.values) {
     if (getter.isStatic || getter.isPrivate) continue;
 
     for (var meta in getter.metadata) {
       if (matches(meta.reflectee)) {
-        if (_hasSetter(type, getter)) {
+        if (_hasSetter(cls, getter)) {
           if (props == null) props = {};
           props[MirrorSystem.getName(getter.simpleName)] = getter;
         }
         break;
       }
     }
   }
 
   return props;
 }
 
-bool _hasSetter(ClassMirror type, MethodMirror getter) {
+bool _hasSetter(ClassMirror cls, MethodMirror getter) {
   var setterName = new Symbol('${MirrorSystem.getName(getter.simpleName)}=');
-  return type.setters.containsKey(setterName);
+  return cls.setters.containsKey(setterName);
 }
 
-bool _inDartHtml(ClassMirror type) => type.owner.simpleName == #dart.dom.html;
-
 
 /** Attribute prefix used for declarative event handlers. */
 const _EVENT_PREFIX = 'on-';
 
 /** Whether an attribute declares an event. */
 bool _hasEventPrefix(String attr) => attr.startsWith(_EVENT_PREFIX);
 
 String _removeEventPrefix(String name) => name.substring(_EVENT_PREFIX.length);
 
 /**
@@ skipping 105 matching lines @@
   return map;
 }();
 
 // Dart note: we need this function because we have additional renames JS does
 // not have. The JS renames are simply case differences, whereas we have ones
 // like doubleclick -> dblclick and stripping the webkit prefix.
 String _eventNameFromType(String eventType) {
   final result = _reverseEventTranslations[eventType];
   return result != null ? result : eventType;
 }