simple fix: loosen type annotations for ShadowRoot

pkg/polymer/lib/src/instance.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;
 
 /**
  * Use this annotation to publish a field as an attribute. For example:
  *
  *     class MyPlaybackElement extends PolymerElement {
@@ skipping 165 matching lines @@
       parseDeclaration(declaration);
     }
   }
 
   /**
    * Parse input `<polymer-element>` as needed, override for custom behavior.
    */
   void parseDeclaration(Element elementElement) {
     var root = shadowFromTemplate(fetchTemplate(elementElement));
 
-    // Dart note: this is extra code compared to Polymer to support
-    // the getShadowRoot method.
-    if (root == null) return;
+    // Dart note: the following code is to support the getShadowRoot method.
+    if (root is! ShadowRoot) return;
 
     var name = elementElement.attributes['name'];
     if (name == null) return;
     _shadowRoots[name] = root;
   }
 
   /**
    * Return a shadow-root template (if desired), override for custom behavior.
    */
   Element fetchTemplate(Element elementElement) =>
       elementElement.query('template');
 
-  /** Utility function that creates a shadow root from a `<template>`. */
+  /**
+   * Utility function that creates a shadow root from a `<template>`.
+   *
+   * The base implementation will return a [ShadowRoot], but you can replace it
+   * with your own code and skip ShadowRoot creation. In that case, you should
+   * return `null`.
+   *
+   * In your overridden method, you can use [instanceTemplate] to stamp the
+   * template and initialize data binding, and [shadowRootReady] to intialize
+   * other Polymer features like event handlers. It is fine to call
+   * shadowRootReady with a node something other than a ShadowRoot; for example,
+   * with this Node.
+   */
   ShadowRoot shadowFromTemplate(Element template) {
     if (template == null) return null;
     // cache elder shadow root (if any)
     var elderRoot = this.shadowRoot;
     // make a shadow root
     var root = createShadowRoot();
 
     // Provides ability to traverse from ShadowRoot to the host.
     // TODO(jmessery): remove once we have this ability on the DOM.
     _shadowHost[root] = this;
 
     // migrate flag(s)(
     root.applyAuthorStyles = applyAuthorStyles;
     root.resetStyleInheritance = resetStyleInheritance;
     // stamp template
     // which includes parsing and applying MDV bindings before being
     // inserted (to avoid {{}} in attribute values)
     // e.g. to prevent <img src="images/{{icon}}"> from generating a 404.
     var dom = instanceTemplate(template);
     // append to shadow dom
     root.append(dom);
     // perform post-construction initialization tasks on shadow root
     shadowRootReady(root, template);
     // return the created shadow root
     return root;
   }
 
-  void shadowRootReady(ShadowRoot root, Element template) {
+  void shadowRootReady(Node root, Element template) {

[Siggi Cherem (dart-lang), 2013/10/21 20:51:58]

just wondering if this should be renamed (maybe a polymer.js q). 'rootReady'?
(since it may not be a shadowRoot)?

[Jennifer Messerly, 2013/10/21 20:56:00]

yeah it's a polymer.js question
https://github.com/Polymer/polymer/blob/7d26453ea4926134d29d9040e18e310f4e902...

+sjmiles in case he has a comment :)

     // locate nodes with id and store references to them in this.$ hash
     marshalNodeReferences(root);
     // add local events of interest...
     addInstanceListeners(root, template);
     // TODO(jmesserly): port this
     // set up pointer gestures
     // PointerGestures.register(root);
   }
 
   /** Locate nodes with id and store references to them in [$] hash. */
-  void marshalNodeReferences(ShadowRoot root) {
+  void marshalNodeReferences(Node root) {
     if (root == null) return;
     for (var n in root.queryAll('[id]')) {
       $[n.id] = n;
     }
   }
 
   void attributeChanged(String name, String oldValue, String newValue) {
     if (name != 'class' && name != 'style') {
       attributeToProperty(name, newValue);
     }
@@ skipping 330 matching lines @@
     var events = _declaration._eventDelegates;
     if (events.isEmpty) return;
 
     if (_eventsLog.isLoggable(Level.FINE)) {
       _eventsLog.fine('[$localName] addHostListeners: $events');
     }
     addNodeListeners(this, events.keys, hostEventListener);
   }
 
   /** Attach event listeners inside a shadow [root]. */
-  void addInstanceListeners(ShadowRoot root, Element template) {
+  void addInstanceListeners(Node root, Element template) {
     var templateDelegates = _declaration._templateDelegates;
     if (templateDelegates == null) return;
     var events = templateDelegates[template];
     if (events == null) return;
 
     if (_eventsLog.isLoggable(Level.FINE)) {
       _eventsLog.fine('[$localName] addInstanceListeners: $events');
     }
     addNodeListeners(root, events, instanceEventListener);
   }
@@ skipping 339 matching lines @@
 /**
  * Base class for PolymerElements deriving from HtmlElement.
  *
  * See [Polymer].
  */
 class PolymerElement extends HtmlElement with Polymer, Observable {
   PolymerElement.created() : super.created() {
     polymerCreated();
   }
 }