Reducing the amount of code we generate in the compiler: We still continue

lib/polymer_element.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.
 
 library polymer.polymer_element;
 
 import 'dart:async';
 import 'dart:html';
 import 'dart:mirrors';
 
+import 'package:mdv/mdv.dart' as mdv;
 import 'package:observe/observe.dart';
 
 import 'custom_element.dart';
 import 'observe.dart';
 import 'src/utils_observe.dart' show toCamelCase, toHyphenedName;
 
 /**
  * Registers a [PolymerElement]. This is similar to [registerCustomElement]
  * but it is designed to work with the `<element>` element and adds additional
  * features.
  */
-// TODO(sigmund): change this to take the 'localName' (recent polymer change)
-void registerPolymerElement(Element elementElement, CustomElement create()) {
-  // Creates the CustomElement and then publish attributes.
-  createElement() {
-    final CustomElement element = create();
-    // TODO(jmesserly): to simplify the DWC compiler, we always emit calls to
-    // registerPolymerElement, regardless of the base class type.
-    if (element is PolymerElement) {
-      PolymerElement pElement = element;
-      pElement._parseHostEvents(elementElement);
-      pElement._parseLocalEvents(elementElement);
-      pElement._publishAttributes(elementElement);
-    }
-    return element;
-  }
-
-  registerCustomElement(elementElement.attributes['name'], createElement);
+void registerPolymerElement(String localName, PolymerElement create()) {
+  registerCustomElement(localName, () => create().._initialize(localName));
 }
 
 /**
  * *Warning*: many features of this class are not fully implemented.
  *
  * The base class for Polymer elements. It provides convience features on top
  * of the custom elements web standard.
  *
  * Currently it supports publishing attributes via:
  *
@@ skipping 11 matching lines @@
   // This is a partial port of:
   // https://github.com/Polymer/polymer/blob/stable/src/attrs.js
   // https://github.com/Polymer/polymer/blob/stable/src/bindProperties.js
   // https://github.com/Polymer/polymer/blob/7936ff8/src/declaration/events.js
   // https://github.com/Polymer/polymer/blob/7936ff8/src/instance/events.js
   // TODO(jmesserly): we still need to port more of the functionality
 
   // TODO(sigmund): delete. The next line is only added to avoid warnings from
   // the analyzer (see http://dartbug.com/11672)
   Element get host => super.host;
+
+  bool get applyAuthorStyles => false;
+  bool get resetStyleInheritance => false;
+
+  /**
+   * The declaration of this polymer-element, used to extract template contents
+   * and other information.
+   */
+  static Map<String, Element> _declarations = {};
+  static Element getDeclaration(String localName) {
+    if (localName == null) return null;
+    var element = _declarations[localName];
+    if (element == null) {
+      element = document.query('polymer-element[name="$localName"]');
+      _declarations[localName] = element;
+    }
+    return element;
+  }
+
   Map<String, PathObserver> _publishedAttrs;
   Map<String, StreamSubscription> _bindings;
+  final List<String> _localNames = [];
 
-  void _publishAttributes(Element elementElement) {
+  void _initialize(String localName) {
+    if (localName == null) return;
+
+    var declaration = getDeclaration(localName);
+    if (declaration == null) return;
+
+    if (declaration.attributes['extends'] != null) {
+      var base = declaration.attributes['extends'];
+      // Skip normal tags, only initialize parent custom elements.
+      if (base.contains('-')) _initialize(base);
+    }
+
+    _parseHostEvents(declaration);
+    _parseLocalEvents(declaration);
+    _publishAttributes(declaration);
+    _localNames.add(localName);
+  }
+
+  void _publishAttributes(elementElement) {
     _bindings = {};
     _publishedAttrs = {};
 
     var attrs = elementElement.attributes['attributes'];
     if (attrs != null) {
       // attributes='a b c' or attributes='a,b,c'
       for (var name in attrs.split(attrs.contains(',') ? ',' : ' ')) {
         name = name.trim();
 
         // TODO(jmesserly): PathObserver is overkill here; it helps avoid
         // "new Symbol" and other mirrors-related warnings.
         _publishedAttrs[name] = new PathObserver(this, toCamelCase(name));
       }
     }
   }
 
   void created() {
     // TODO(jmesserly): this breaks until we get some kind of type conversion.
     // _publishedAttrs.forEach((name, propObserver) {
     // var value = attributes[name];
     //   if (value != null) propObserver.value = value;
     // });
-
+    _initShadowRoot();
     _addHostListeners();
   }
 
-  // TODO(sigmund): make this private once we create the shadow root directly
-  // here in polymer element.
-  void shadowRootReady(ShadowRoot root, String elementName) {
-    _addInstanceListeners(root, elementName);
+  void _initShadowRoot() {
+    for (var localName in _localNames) {
+      var declaration = getDeclaration(localName);
+      var root = createShadowRoot(localName);
+      _addInstanceListeners(root, localName);
+
+      root.applyAuthorStyles = applyAuthorStyles;
+      root.resetStyleInheritance = resetStyleInheritance;
+
+      var templateNode = declaration.children.firstWhere(
+          (n) => n.localName == 'template', orElse: () => null);
+      if (templateNode == null) return;
+
+      root.nodes.add(cloneTemplate(templateNode.content));
+      // TODO(sigmund): use fancy-syntax as the default.
+      var syntax = templateNode.attributes['syntax'];
+
+      // TODO(sigmund,jmesserly): mdv.bindModel should be async internally
+      Timer.run(() => mdv.bindModel(root, this,

[Siggi Cherem (dart-lang), 2013/07/19 22:52:52]

so this was the fix after all. Seems to work ok for most cases, but there are 2
tests that still puzzle me: doing a Timer.run to observe the changes is not
enough, sometimes is necessary to do a longer delay (for instance, 200ms).

Any ideas? I'm ok submitting as it is anyways, but let me know what you think.

[Jennifer Messerly, 2013/07/19 23:16:24]

not sure... it depends on how Timer.run is implemented (is it equivalent to
setTimeout 0?) ... what could be happening is that this delay changes the order
that MutationObservers are noticing the changes, and whether they're noticing it
before or after observers fire. Alas, async makes it hard to write predictable
code :|

+          syntax != null ? TemplateElement.syntax[syntax] : null));
+    }
   }
 
   void bind(String name, model, String path) {
     var propObserver = _publishedAttrs[name];
     if (propObserver != null) {
       unbind(name);
 
       _bindings[name] = new PathObserver(model, path).bindSync((value) {
         propObserver.value = value;
       });
@@ skipping 356 matching lines @@
   'onKeyMessage': MediaElement.keyMessageEvent,
   'onNeedKey': MediaElement.needKeyEvent,
   'onWebGlContextLost': CanvasElement.webGlContextLostEvent,
   'onWebGlContextRestored': CanvasElement.webGlContextRestoredEvent,
   'onPointerLockChange': Document.pointerLockChangeEvent,
   'onPointerLockError': Document.pointerLockErrorEvent,
   'onReadyStateChange': Document.readyStateChangeEvent,
   'onSelectionChange': Document.selectionChangeEvent,
   'onSecurityPolicyViolation': Document.securityPolicyViolationEvent,
 };