From e95afeb173d887d154f1cc6a464ba3b7fef943b7 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Mon, 6 Mar 2017 15:04:34 -0800
Subject: [PATCH] Separate binding-specific code from template stamp. Expose
 override points.

---
 lib/mixins/property-effects.html | 305 +++++++++++-------
 lib/mixins/template-stamp.html   | 523 +++++++++++--------------------
 lib/utils/templatize.html        |   6 +-
 3 files changed, 372 insertions(+), 462 deletions(-)

diff --git a/lib/mixins/property-effects.html b/lib/mixins/property-effects.html
index de11cd4df3..259bd86ba3 100644
--- a/lib/mixins/property-effects.html
+++ b/lib/mixins/property-effects.html
@@ -646,106 +646,6 @@
     applyBindingValue(inst, info.methodInfo, val);
   }
 
-  /**
-   * Post-processes template bindings (notes for short) provided by the
-   * Bindings library for use by the effects system:
-   * - Parses bindings for methods into method `signature` objects
-   * - Memoizes the root property for path bindings
-   * - Recurses into nested templates and processes those templates and
-   *   extracts any host properties, which are set to the template's
-   *   `_content._hostProps`
-   * - Adds bindings from the host to <template> elements for any nested
-   *   template's lexically bound "host properties"; template handling
-   *   elements can then add accessors to the template for these properties
-   *   to forward host properties into template instances accordingly.
-   *
-   * @param {Array<Object>} notes List of notes to process; the notes are
-   *   modified in place.
-   * @private
-   */
-  function processAnnotations(notes) {
-    if (!notes._processed) {
-      for (let i=0; i<notes.length; i++) {
-        let note = notes[i];
-        // Parse bindings for methods & path roots (models)
-        for (let j=0; j<note.bindings.length; j++) {
-          let b = note.bindings[j];
-          for (let k=0; k<b.parts.length; k++) {
-            let p = b.parts[k];
-            if (!p.literal) {
-              p.signature = parseMethod(p.value);
-              if (!p.signature) {
-                p.rootProperty = Polymer.Path.root(p.value);
-              }
-            }
-          }
-        }
-        // Recurse into nested templates & bind host props
-        if (note.templateContent) {
-          processAnnotations(note.templateContent._notes);
-          let hostProps = note.templateContent._hostProps =
-            discoverTemplateHostProps(note.templateContent._notes);
-          let bindings = [];
-          for (let prop in hostProps) {
-            bindings.push({
-              index: note.index,
-              kind: 'property',
-              name: '_host_' + prop,
-              parts: [{
-                mode: '{',
-                value: prop
-              }]
-            });
-          }
-          note.bindings = note.bindings.concat(bindings);
-        }
-      }
-      notes._processed = true;
-    }
-  }
-
-  /**
-   * Finds all property usage in templates (property/path bindings and function
-   * arguments) and returns the path roots as keys in a map. Each outer template
-   * merges inner _hostProps to propagate inner host property needs to outer
-   * templates.
-   *
-   * @param {Array<Object>} notes List of notes to process for a given template
-   * @return {Object<string,boolean>} Map of host properties that the template
-   *   (or any nested templates) uses
-   * @private
-   */
-  function discoverTemplateHostProps(notes) {
-    let hostProps = {};
-    for (let i=0, n; (i<notes.length) && (n=notes[i]); i++) {
-      // Find all bindings to parent.* and spread them into _parentPropChain
-      for (let j=0, b$=n.bindings, b; (j<b$.length) && (b=b$[j]); j++) {
-        for (let k=0, p$=b.parts, p; (k<p$.length) && (p=p$[k]); k++) {
-          if (p.signature) {
-            let args = p.signature.args;
-            for (let kk=0; kk<args.length; kk++) {
-              let rootProperty = args[kk].rootProperty;
-              if (rootProperty) {
-                hostProps[rootProperty] = true;
-              }
-            }
-            hostProps[p.signature.methodName] = true;
-          } else {
-            if (p.rootProperty) {
-              hostProps[p.rootProperty] = true;
-            }
-          }
-        }
-      }
-      // Merge child _hostProps into this _hostProps
-      if (n.templateContent) {
-        let templateHostProps = n.templateContent._hostProps;
-        Object.assign(hostProps, templateHostProps);
-      }
-    }
-    return hostProps;
-  }
-
   /**
    * Returns true if a binding's metadata meets all the requirements to allow
    * 2-way binding, and therefore a <property>-changed event listener should be
@@ -905,6 +805,91 @@
 
   const emptyArray = [];
 
+  // Regular expressions used for binding
+  const IDENT  = '(?:' + '[a-zA-Z_$][\\w.:$\\-*]*' + ')';
+  const NUMBER = '(?:' + '[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?' + ')';
+  const SQUOTE_STRING = '(?:' + '\'(?:[^\'\\\\]|\\\\.)*\'' + ')';
+  const DQUOTE_STRING = '(?:' + '"(?:[^"\\\\]|\\\\.)*"' + ')';
+  const STRING = '(?:' + SQUOTE_STRING + '|' + DQUOTE_STRING + ')';
+  const ARGUMENT = '(?:' + IDENT + '|' + NUMBER + '|' +  STRING + '\\s*' + ')';
+  const ARGUMENTS = '(?:' + ARGUMENT + '(?:,\\s*' + ARGUMENT + ')*' + ')';
+  const ARGUMENT_LIST = '(?:' + '\\(\\s*' +
+                                '(?:' + ARGUMENTS + '?' + ')' +
+                              '\\)\\s*' + ')';
+  const BINDING = '(' + IDENT + '\\s*' + ARGUMENT_LIST + '?' + ')'; // Group 3
+  const OPEN_BRACKET = '(\\[\\[|{{)' + '\\s*';
+  const CLOSE_BRACKET = '(?:]]|}})';
+  const NEGATE = '(?:(!)\\s*)?'; // Group 2
+  const EXPRESSION = OPEN_BRACKET + NEGATE + BINDING + CLOSE_BRACKET;
+  const bindingRegex = new RegExp(EXPRESSION, "g");
+
+  function parseBindings(text, hostProps) {
+    let parts = [];
+    let lastIndex = 0;
+    let m;
+    // Example: "literal1{{prop}}literal2[[!compute(foo,bar)]]final"
+    // Regex matches:
+    //        Iteration 1:  Iteration 2:
+    // m[1]: '{{'          '[['
+    // m[2]: ''            '!'
+    // m[3]: 'prop'        'compute(foo,bar)'
+    while ((m = bindingRegex.exec(text)) !== null) {
+      // Add literal part
+      if (m.index > lastIndex) {
+        parts.push({literal: text.slice(lastIndex, m.index)});
+      }
+      // Add binding part
+      // Mode (one-way or two)
+      let mode = m[1][0];
+      let negate = Boolean(m[2]);
+      let value = m[3].trim();
+      let customEvent, notifyEvent, colon;
+      if (mode == '{' && (colon = value.indexOf('::')) > 0) {
+        notifyEvent = value.substring(colon + 2);
+        value = value.substring(0, colon);
+        customEvent = true;
+      }
+      let signature = parseMethod(value, hostProps);
+      let rootProperty;
+      if (!signature) {
+        rootProperty = Polymer.Path.root(value);
+        hostProps[rootProperty] = true;
+      }
+      parts.push({
+        compoundIndex: parts.length,
+        value,
+        mode,
+        negate,
+        event: notifyEvent,
+        customEvent,
+        signature,
+        rootProperty
+      });
+      lastIndex = bindingRegex.lastIndex;
+    }
+    // Add a final literal part
+    if (lastIndex && lastIndex < text.length) {
+      let literal = text.substring(lastIndex);
+      if (literal) {
+        parts.push({
+          literal: literal
+        });
+      }
+    }
+    if (parts.length) {
+      return parts;
+    }
+  }
+
+  function literalFromParts(parts) {
+    let s = '';
+    for (let i=0; i<parts.length; i++) {
+      let literal = parts[i].literal;
+      s += literal || '';
+    }
+    return s;
+  }
+
   /**
    * Parses an expression string for a method signature, and returns a metadata
    * describing the method in terms of `methodName`, `static` (whether all the
@@ -915,15 +900,18 @@
    *   found, otherwise `undefined`
    * @private
    */
-  function parseMethod(expression) {
+  function parseMethod(expression, hostProps) {
     // tries to match valid javascript property names
     let m = expression.match(/([^\s]+?)\(([\s\S]*)\)/);
     if (m) {
       let sig = { methodName: m[1], static: true };
+      if (hostProps) {
+        hostProps[sig.methodName] = true;
+      }
       if (m[2].trim()) {
         // replace escaped commas with comma entity, split on un-escaped commas
         let args = m[2].replace(/\\,/g, '&comma;').split(',');
-        return parseArgs(args, sig);
+        return parseArgs(args, sig, hostProps);
       } else {
         sig.args = emptyArray;
         return sig;
@@ -942,11 +930,13 @@
    * @return {Object} The updated signature metadata object
    * @private
    */
-  function parseArgs(argList, sig) {
+  function parseArgs(argList, sig, hostProps) {
     sig.args = argList.map(function(rawArg) {
       let arg = parseArg(rawArg);
       if (!arg.literal) {
         sig.static = false;
+      } else if (hostProps) {
+        hostProps[arg.rootProperty] = true;
       }
       return arg;
     }, this);
@@ -2178,23 +2168,114 @@
         // Clear any existing propagation effects inherited from superClass
         this.__propagateEffects = {};
         this.__notifyListeners = [];
-        let notes = this._parseTemplateAnnotations(template);
-        processAnnotations(notes);
+        let notes = this.constructor._prepareTemplate(template);
         for (let i=0, note; (i<notes.length) && (note=notes[i]); i++)  {
           // where to find the node in the concretized list
           let b$ = note.bindings;
-          for (let j=0, binding; (j<b$.length) && (binding=b$[j]); j++) {
-            if (shouldAddListener(binding)) {
-              addAnnotatedListener(this, i, binding.name,
-                binding.parts[0].value,
-                binding.parts[0].event,
-                binding.parts[0].negate);
+          if (b$){
+            for (let j=0, binding; (j<b$.length) && (binding=b$[j]); j++) {
+              if (shouldAddListener(binding)) {
+                addAnnotatedListener(this, i, binding.name,
+                  binding.parts[0].value,
+                  binding.parts[0].event,
+                  binding.parts[0].negate);
+              }
+              addBindingEffect(this, binding, i, dynamicFns);
             }
-            addBindingEffect(this, binding, i, dynamicFns);
           }
         }
       }
 
+      static _parseTemplateNode(node, note) {
+        let hostProps = note.notes.hostProps = note.notes.hostProps || {};
+        let noted = super._parseTemplateNode(node, note);
+        if (node.nodeType === Node.TEXT_NODE) {
+          let parts = parseBindings(node.textContent, hostProps);
+          if (parts) {
+            // Initialize the textContent with any literal parts
+            // NOTE: default to a space here so the textNode remains; some browsers
+            // (IE) evacipate an empty textNode following cloneNode/importNode.
+            node.textContent = literalFromParts(parts) || ' ';
+            note.bindings = note.bindings || [];
+            note.bindings.push({
+              kind: 'text',
+              name: 'textContent',
+              parts: parts,
+              isCompound: parts.length !== 1
+            });
+            noted = true;
+          }
+        }
+        return noted;
+      }
+
+      static _parseTemplateNodeAttribute(node, note, name, value) {
+        let parts = parseBindings(value, note.notes.hostProps);
+        if (parts) {
+          // Attribute or property
+          let origName = name;
+          let kind = 'property';
+          if (name[name.length-1] == '$') {
+            name = name.slice(0, -1);
+            kind = 'attribute';
+          }
+          // Initialize attribute bindings with any literal parts
+          let literal = literalFromParts(parts);
+          if (literal && kind == 'attribute') {
+            node.setAttribute(name, literal);
+          }
+          // Clear attribute before removing, since IE won't allow removing
+          // `value` attribute if it previously had a value (can't
+          // unconditionally set '' before removing since attributes with `$`
+          // can't be set using setAttribute)
+          if (node.localName === 'input' && origName === 'value') {
+            node.setAttribute(origName, '');
+          }
+          // Remove annotation
+          node.removeAttribute(origName);
+          // Case hackery: attributes are lower-case, but bind targets
+          // (properties) are case sensitive. Gambit is to map dash-case to
+          // camel-case: `foo-bar` becomes `fooBar`.
+          // Attribute bindings are excepted.
+          let propertyName = Polymer.CaseMap.dashToCamelCase(name);
+          if (kind === 'property') {
+            name = propertyName;
+          }
+          note.bindings = note.bindings || [];
+          note.bindings.push({
+            kind: kind,
+            name: name,
+            propertyName: propertyName,
+            parts: parts,
+            literal: literal,
+            isCompound: parts.length !== 1
+          });
+          return true;
+        } else {
+          return super._parseTemplateNodeAttribute(node, note, name, value);
+        }
+      }
+
+      static _parseTemplate(node, note) {
+        super._parseTemplate(node, note);
+        // Merge host props into outer template and add bindings
+        let hostProps = Object.assign(note.notes.hostProps,
+          note.templateContent._notes.hostProps);
+        for (let prop in hostProps) {
+          note.bindings = note.bindings || [];
+          note.bindings.push({
+            index: note.index,
+            kind: 'property',
+            name: '_host_' + prop,
+            parts: [{
+              mode: '{',
+              value: prop
+            }]
+          });
+        }
+        return true;
+      }
+
     }
 
     return PropertyEffects;
diff --git a/lib/mixins/template-stamp.html b/lib/mixins/template-stamp.html
index ac10e38fdd..fbb9aa9d00 100644
--- a/lib/mixins/template-stamp.html
+++ b/lib/mixins/template-stamp.html
@@ -16,198 +16,6 @@
 
   'use strict';
 
-  // null-array (shared empty array to avoid null-checks)
-  const emptyArray = [];
-
-  let bindingRegex = (function() {
-    let IDENT  = '(?:' + '[a-zA-Z_$][\\w.:$\\-*]*' + ')';
-    let NUMBER = '(?:' + '[-+]?[0-9]*\\.?[0-9]+(?:[eE][-+]?[0-9]+)?' + ')';
-    let SQUOTE_STRING = '(?:' + '\'(?:[^\'\\\\]|\\\\.)*\'' + ')';
-    let DQUOTE_STRING = '(?:' + '"(?:[^"\\\\]|\\\\.)*"' + ')';
-    let STRING = '(?:' + SQUOTE_STRING + '|' + DQUOTE_STRING + ')';
-    let ARGUMENT = '(?:' + IDENT + '|' + NUMBER + '|' +  STRING + '\\s*' + ')';
-    let ARGUMENTS = '(?:' + ARGUMENT + '(?:,\\s*' + ARGUMENT + ')*' + ')';
-    let ARGUMENT_LIST = '(?:' + '\\(\\s*' +
-                                  '(?:' + ARGUMENTS + '?' + ')' +
-                                '\\)\\s*' + ')';
-    let BINDING = '(' + IDENT + '\\s*' + ARGUMENT_LIST + '?' + ')'; // Group 3
-    let OPEN_BRACKET = '(\\[\\[|{{)' + '\\s*';
-    let CLOSE_BRACKET = '(?:]]|}})';
-    let NEGATE = '(?:(!)\\s*)?'; // Group 2
-    let EXPRESSION = OPEN_BRACKET + NEGATE + BINDING + CLOSE_BRACKET;
-    return new RegExp(EXPRESSION, "g");
-  })();
-
-  let insertionPointTag = 'slot';
-
-  /**
-   * Scans a template to produce an annotation map that stores expression metadata
-   * and information that associates the metadata to nodes in a template instance.
-   *
-   * Supported annotations are:
-   *   * id attributes
-   *   * binding annotations in text nodes
-   *     * double-mustache expressions: {{expression}}
-   *     * double-bracket expressions: [[expression]]
-   *   * binding annotations in attributes
-   *     * attribute-bind expressions: name="{{expression}} || [[expression]]"
-   *     * property-bind expressions: name*="{{expression}} || [[expression]]"
-   *     * property-bind expressions: name:="expression"
-   *   * event annotations
-   *     * event delegation directives: on-<eventName>="expression"
-   *
-   * Generated data-structure:
-   *   [
-   *     {
-   *       id: '<id>',
-   *       events: [
-   *         {
-   *           mode: ['auto'|''],
-   *           name: '<name>'
-   *           value: '<expression>'
-   *         }, ...
-   *       ],
-   *       bindings: [
-   *         {
-   *           kind: ['text'|'attribute'|'property'],
-   *           mode: ['auto'|''],
-   *           name: '<name>'
-   *           value: '<expression>'
-   *         }, ...
-   *       ],
-   *       parent: <reference to parent annotation>,
-   *       index: <integer index in parent's childNodes collection>
-   *     },
-   *     ...
-   *   ]
-   *
-   * @param {HTMLTemplateElement} template
-   * @param {boolean=} stripWhiteSpace
-   * @return {Array<Object>}
-   */
-  function parseTemplateAnnotations(template, stripWhiteSpace, ownerDocument) {
-    // TODO(kschaaf): File issue and/or remove when fixed
-    // hold a reference to content as _content to prevent odd Chrome gc issue
-    // nested templates also may receive their content as _content
-    let content = (template._content = template._content || template.content);
-    // since a template may be re-used, memo-ize notes.
-    if (!content._notes) {
-      content._notes = [];
-      // TODO(sorvell): whitespace and processAnnotations need to be factored
-      // into plugins
-      ownerDocument = ownerDocument || template.ownerDocument;
-      parseNodeAnnotations(content, content._notes,
-        stripWhiteSpace || template.hasAttribute('strip-whitespace'), ownerDocument);
-    }
-    return content._notes;
-  }
-
-  // add annotations gleaned from subtree at `node` to `list`
-  function parseNodeAnnotations(node, list, stripWhiteSpace, ownerDocument) {
-    return node.nodeType === Node.TEXT_NODE ?
-      parseTextNodeAnnotation(node, list) :
-        parseElementAnnotations(node, list, stripWhiteSpace, ownerDocument);
-  }
-
-  function parseBindings(text) {
-    let parts = [];
-    let lastIndex = 0;
-    let m;
-    // Example: "literal1{{prop}}literal2[[!compute(foo,bar)]]final"
-    // Regex matches:
-    //        Iteration 1:  Iteration 2:
-    // m[1]: '{{'          '[['
-    // m[2]: ''            '!'
-    // m[3]: 'prop'        'compute(foo,bar)'
-    while ((m = bindingRegex.exec(text)) !== null) {
-      // Add literal part
-      if (m.index > lastIndex) {
-        parts.push({literal: text.slice(lastIndex, m.index)});
-      }
-      // Add binding part
-      // Mode (one-way or two)
-      let mode = m[1][0];
-      let negate = Boolean(m[2]);
-      let value = m[3].trim();
-      let customEvent, notifyEvent, colon;
-      if (mode == '{' && (colon = value.indexOf('::')) > 0) {
-        notifyEvent = value.substring(colon + 2);
-        value = value.substring(0, colon);
-        customEvent = true;
-      }
-      parts.push({
-        compoundIndex: parts.length,
-        value: value,
-        mode: mode,
-        negate: negate,
-        event: notifyEvent,
-        customEvent: customEvent
-      });
-      lastIndex = bindingRegex.lastIndex;
-    }
-    // Add a final literal part
-    if (lastIndex && lastIndex < text.length) {
-      let literal = text.substring(lastIndex);
-      if (literal) {
-        parts.push({
-          literal: literal
-        });
-      }
-    }
-    if (parts.length) {
-      return parts;
-    }
-  }
-
-  function literalFromParts(parts) {
-    let s = '';
-    for (let i=0; i<parts.length; i++) {
-      let literal = parts[i].literal;
-      s += literal || '';
-    }
-    return s;
-  }
-
-  // add annotations gleaned from TextNode `node` to `list`
-  function parseTextNodeAnnotation(node, list) {
-    let parts = parseBindings(node.textContent);
-    if (parts) {
-      // Initialize the textContent with any literal parts
-      // NOTE: default to a space here so the textNode remains; some browsers
-      // (IE) evacipate an empty textNode following cloneNode/importNode.
-      node.textContent = literalFromParts(parts) || ' ';
-      let note = {
-        bindings: [{
-          kind: 'text',
-          name: 'textContent',
-          parts: parts,
-          isCompound: parts.length !== 1
-        }]
-      };
-      list.push(note);
-      return note;
-    }
-  }
-
-  // add annotations gleaned from Element `node` to `list`
-  function parseElementAnnotations(element, list, stripWhiteSpace, ownerDocument) {
-    let note = {
-      bindings: [],
-      events: []
-    };
-    if (element.localName === insertionPointTag) {
-      list._hasInsertionPoint = true;
-    }
-    parseChildNodesAnnotations(element, note, list, stripWhiteSpace, ownerDocument);
-    if (element.attributes) {
-      parseNodeAttributeAnnotations(element, note);
-    }
-    if (note.bindings.length || note.events.length || note.id) {
-      list.push(note);
-    }
-    return note;
-  }
-
   // 1.x backwards-compatible auto-wrapper for template type extensions
   // This is a clear layering violation and gives favored-nation status to
   // dom-if and dom-repeat templates.  This is a conceit we're choosing to keep
@@ -235,149 +43,6 @@
     return node;
   }
 
-  // add annotations gleaned from children of `root` to `list`, `root`'s
-  // `note` is supplied as it is the note.parent of added annotations
-  function parseChildNodesAnnotations(root, note, list, stripWhiteSpace, ownerDocument) {
-    if (root.firstChild) {
-      let node = root.firstChild;
-      let i = 0;
-      while (node) {
-        // Wrap templates
-        if (node.localName == 'template') {
-          node = wrapTemplateExtension(node);
-        }
-        // Recurse
-        if (node.localName == 'template' &&
-          !node.hasAttribute('preserve-content')) {
-          parseTemplate(node, i, list, note, stripWhiteSpace, ownerDocument);
-        }
-        // collapse adjacent textNodes: fixes an IE issue that can cause
-        // text nodes to be inexplicably split =(
-        // note that root.normalize() should work but does not so we do this
-        // manually.
-        let next = node.nextSibling;
-        if (node.nodeType === Node.TEXT_NODE) {
-          let n = next;
-          while (n && (n.nodeType === Node.TEXT_NODE)) {
-            node.textContent += n.textContent;
-            next = n.nextSibling;
-            root.removeChild(n);
-            n = next;
-          }
-          // optionally strip whitespace
-          if (stripWhiteSpace && !node.textContent.trim()) {
-            root.removeChild(node);
-            // decrement index since node is removed
-            i--;
-          }
-        }
-        // if this node didn't get evacipated, parse it.
-        if (node.parentNode) {
-          let childAnnotation = parseNodeAnnotations(node, list,
-            stripWhiteSpace, ownerDocument);
-          if (childAnnotation) {
-            childAnnotation.parent = note;
-            childAnnotation.index = i;
-          }
-        }
-        node = next;
-        i++;
-      }
-    }
-  }
-
-  // 1. Parse annotations from the template and memoize them on
-  //    content._notes (recurses into nested templates)
-  // 2. Remove template.content and store it in annotation list, where it
-  //    will be the responsibility of the host to set it back to the template
-  //    (this is both an optimization to avoid re-stamping nested template
-  //    children and avoids a bug in Chrome where nested template children
-  //    upgrade)
-  function parseTemplate(node, index, list, parent, stripWhiteSpace, ownerDocument) {
-    let content = node.content.ownerDocument.createDocumentFragment();
-    content._notes = parseTemplateAnnotations(node, stripWhiteSpace, ownerDocument);
-    content.appendChild(node.content);
-    list.push({
-      bindings: emptyArray,
-      events: emptyArray,
-      templateContent: content,
-      parent: parent,
-      index: index
-    });
-  }
-
-  // add annotation data from attributes to the `annotation` for node `node`
-  function parseNodeAttributeAnnotations(node, annotation) {
-    // Make copy of original attribute list, since the order may change
-    // as attributes are added and removed
-    let attrs = Array.prototype.slice.call(node.attributes);
-    for (let i=attrs.length-1, a; (a=attrs[i]); i--) {
-      let n = a.name;
-      let v = a.value;
-      let b;
-      // events (on-*)
-      if (n.slice(0, 3) === 'on-') {
-        node.removeAttribute(n);
-        annotation.events.push({
-          name: n.slice(3),
-          value: v
-        });
-      }
-      // bindings (other attributes)
-      else if ((b = parseNodeAttributeAnnotation(node, n, v))) {
-        annotation.bindings.push(b);
-      }
-      // static id
-      else if (n === 'id') {
-        annotation.id = v;
-      }
-    }
-  }
-
-  // construct annotation data from a generic attribute, or undefined
-  function parseNodeAttributeAnnotation(node, name, value) {
-    let parts = parseBindings(value);
-    if (parts) {
-      // Attribute or property
-      let origName = name;
-      let kind = 'property';
-      if (name[name.length-1] == '$') {
-        name = name.slice(0, -1);
-        kind = 'attribute';
-      }
-      // Initialize attribute bindings with any literal parts
-      let literal = literalFromParts(parts);
-      if (literal && kind == 'attribute') {
-        node.setAttribute(name, literal);
-      }
-      // Clear attribute before removing, since IE won't allow removing
-      // `value` attribute if it previously had a value (can't
-      // unconditionally set '' before removing since attributes with `$`
-      // can't be set using setAttribute)
-      if (node.localName === 'input' && origName === 'value') {
-        node.setAttribute(origName, '');
-      }
-      // Remove annotation
-      node.removeAttribute(origName);
-      // Case hackery: attributes are lower-case, but bind targets
-      // (properties) are case sensitive. Gambit is to map dash-case to
-      // camel-case: `foo-bar` becomes `fooBar`.
-      // Attribute bindings are excepted.
-      let propertyName = Polymer.CaseMap.dashToCamelCase(name);
-      if (kind === 'property') {
-        name = propertyName;
-      }
-      return {
-        kind: kind,
-        name: name,
-        propertyName: propertyName,
-        parts: parts,
-        literal: literal,
-        isCompound: parts.length !== 1
-      };
-    }
-  }
-
   function findTemplateAnnotatedNode(root, note) {
     // recursively ascend tree until we hit root
     let parent = note.parent && findTemplateAnnotatedNode(root,
@@ -461,6 +126,181 @@
         this.__templateNotes = null;
       }
 
+      /**
+       * Scans a template to produce an annotation map that stores expression metadata
+       * and information that associates the metadata to nodes in a template instance.
+       *
+       * Supported annotations are:
+       *   * id attributes
+       *   * binding annotations in text nodes
+       *     * double-mustache expressions: {{expression}}
+       *     * double-bracket expressions: [[expression]]
+       *   * binding annotations in attributes
+       *     * attribute-bind expressions: name="{{expression}} || [[expression]]"
+       *     * property-bind expressions: name*="{{expression}} || [[expression]]"
+       *     * property-bind expressions: name:="expression"
+       *   * event annotations
+       *     * event delegation directives: on-<eventName>="expression"
+       *
+       * Generated data-structure:
+       *   [
+       *     {
+       *       id: '<id>',
+       *       events: [
+       *         {
+       *           mode: ['auto'|''],
+       *           name: '<name>'
+       *           value: '<expression>'
+       *         }, ...
+       *       ],
+       *       bindings: [
+       *         {
+       *           kind: ['text'|'attribute'|'property'],
+       *           mode: ['auto'|''],
+       *           name: '<name>'
+       *           value: '<expression>'
+       *         }, ...
+       *       ],
+       *       parent: <reference to parent annotation>,
+       *       index: <integer index in parent's childNodes collection>
+       *     },
+       *     ...
+       *   ]
+       *
+       * @param {HTMLTemplateElement} template
+       * @param {boolean=} stripWhiteSpace
+       * @param {Document=} ownerDocument
+       * @return {Array<Object>}
+       */
+      static _prepareTemplate(template, stripWhiteSpace, ownerDocument) {
+        // TODO(kschaaf): File issue and/or remove when fixed
+        // hold a reference to content as _content to prevent odd Chrome gc issue
+        // nested templates also may receive their content as _content
+        let content = (template._content = template._content || template.content);
+        // since a template may be re-used, memo-ize notes.
+        if (!content._notes) {
+          let notes = content._notes = [];
+          notes.ownerDocument = ownerDocument || template.ownerDocument;
+          notes.stripWhiteSpace = stripWhiteSpace || template.hasAttribute('strip-whitespace');
+          this._parseTemplateNode(content, {notes});
+        }
+        return content._notes;
+      }
+
+      // add annotations gleaned from subtree at `node` to `notes`
+      static _parseTemplateNode(node, note) {
+        let noted;
+        if (node.localName == 'template' &&
+          !node.hasAttribute('preserve-content')) {
+          noted |= this._parseTemplate(node, note);
+        } else if (node.localName === 'slot') {
+          node._hasInsertionPoint = true;
+        }
+        if (node.firstChild) {
+          noted |= this._parseTemplateChildNodes(node, note);
+        }
+        if (node.attributes) {
+          noted |= this._parseTemplateNodeAttributes(node, note);
+        }
+        return noted;
+      }
+
+      // add annotations gleaned from children of `root` to `list`, `root`'s
+      // `note` is supplied as it is the note.parent of added annotations
+      static _parseTemplateChildNodes(root, note) {
+        let node = root.firstChild;
+        if (node) {
+          let i = 0;
+          while (node) {
+            // Wrap templates
+            if (node.localName == 'template') {
+              node = wrapTemplateExtension(node);
+            }
+            // collapse adjacent textNodes: fixes an IE issue that can cause
+            // text nodes to be inexplicably split =(
+            // note that root.normalize() should work but does not so we do this
+            // manually.
+            let next = node.nextSibling;
+            if (node.nodeType === Node.TEXT_NODE) {
+              let n = next;
+              while (n && (n.nodeType === Node.TEXT_NODE)) {
+                node.textContent += n.textContent;
+                next = n.nextSibling;
+                root.removeChild(n);
+                n = next;
+              }
+              // optionally strip whitespace
+              if (note.notes.stripWhiteSpace && !node.textContent.trim()) {
+                root.removeChild(node);
+                // decrement index since node is removed
+                i--;
+              }
+            }
+            // if this node didn't get evacipated, parse it.
+            if (node.parentNode) {
+              let childNote = {
+                notes: note.notes,
+                parent: note,
+                index: i
+              }
+              if (this._parseTemplateNode(node, childNote)) {
+                note.notes.push(childNote);
+              }
+            }
+            node = next;
+            i++;
+          }
+        }
+      }
+
+      // Recurse into nested templates
+      // 1. Parse annotations from the template and memoize them on
+      //    content._notes (recurses into nested templates)
+      // 2. Remove template.content and store it in annotation list, where it
+      //    will be the responsibility of the host to set it back to the template
+      //    (this is both an optimization to avoid re-stamping nested template
+      //    children and avoids a bug in Chrome where nested template children
+      //    upgrade)
+      static _parseTemplate(node, note) {
+        let content = node.content.ownerDocument.createDocumentFragment();
+        content._notes = this._prepareTemplate(node,
+          note.notes.stripWhiteSpace, note.notes.ownerDocument);
+        content.appendChild(node.content);
+        note.templateContent = content;
+        return true;
+      }
+
+      // add annotation data from attributes to the `annotation` for node `node`
+      static _parseTemplateNodeAttributes(node, note) {
+        // Make copy of original attribute list, since the order may change
+        // as attributes are added and removed
+        let attrs = Array.prototype.slice.call(node.attributes);
+        let noted;
+        for (let i=attrs.length-1, a; (a=attrs[i]); i--) {
+          noted |= this._parseTemplateNodeAttribute(node, note, a.name, a.value)
+        }
+        return noted;
+      }
+
+      // construct annotation data from a generic attribute, or undefined
+      static _parseTemplateNodeAttribute(node, note, name, value) {
+        // events (on-*)
+        if (name.slice(0, 3) === 'on-') {
+          node.removeAttribute(name);
+          note.events = note.events || [];
+          note.events.push({
+            name: name.slice(3),
+            value
+          });
+          return true;
+        }
+        // static id
+        else if (name === 'id') {
+          note.id = value;
+          return true;
+        }
+      }
+
       /**
        * Clones the provided template content and returns a document fragment
        * containing the cloned dom.
@@ -494,7 +334,7 @@
             window.HTMLTemplateElement && HTMLTemplateElement.decorate) {
           HTMLTemplateElement.decorate(template);
         }
-        let notes = this.__templateNotes = this._parseTemplateAnnotations(template);
+        let notes = this.__templateNotes = this.constructor._prepareTemplate(template);
         let dom = document.importNode(template._content || template.content, true);
         // NOTE: ShadyDom optimization indicating there is an insertion point
         dom.__noInsertionPoint = !notes._hasInsertionPoint;
@@ -509,17 +349,6 @@
         return dom;
       }
 
-      // preprocess-time
-
-      // construct and return a list of annotation records
-      // by scanning `template`'s content
-      //
-      // TODO(sorvell): This should just crawl over a template and call
-      // a supplied list of callbacks.
-      _parseTemplateAnnotations(template) {
-        return parseTemplateAnnotations(template);
-      }
-
       _addMethodEventListenerToNode(node, eventName, methodName, context) {
         context = context || node;
         let handler = createNodeEventHandler(context, eventName, methodName);
diff --git a/lib/utils/templatize.html b/lib/utils/templatize.html
index ad1008aee3..adc3febe4b 100644
--- a/lib/utils/templatize.html
+++ b/lib/utils/templatize.html
@@ -218,7 +218,7 @@
             class TemplatizedTemplate extends base {}
           // Add template - >instances effects
           // and host <- template effects
-          let hostProps = template._content._hostProps;
+          let hostProps = template._content._notes.hostProps;
           for (let prop in hostProps) {
             klass.prototype._addPropertyEffect('_host_' + prop,
               klass.prototype.PROPERTY_EFFECT_TYPES.PROPAGATE,
@@ -250,7 +250,7 @@
     }
 
     function addNotifyEffects(klass, template, options) {
-      let hostProps = template._content._hostProps || {};
+      let hostProps = template._content._notes.hostProps || {};
       for (let iprop in options.instanceProps) {
         delete hostProps[iprop];
         let userNotifyInstanceProp = options.notifyInstanceProp;
@@ -404,7 +404,7 @@
         klass.prototype._methodHost = findMethodHost(template);
         klass.prototype.__dataHost = template;
         klass.prototype.__templatizeOwner = owner;
-        klass.prototype.__hostProps = template._content._hostProps;
+        klass.prototype.__hostProps = template._content._notes.hostProps;
         return klass;
       },