From 9ec1fbe8f0d2969aa55ece35326882f729ff5629 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Wed, 14 Sep 2016 18:52:47 -0700
Subject: [PATCH 01/20] WIP eliminate collection

---
 src/elements/element.html            |   2 +-
 src/properties/batched-effects.html  |  16 +-
 src/properties/property-effects.html |  54 +---
 src/templatizer/dom-repeat.html      | 445 ++++-----------------------
 src/utils/path.html                  |  53 +---
 test/smoke/data-table.html           | 379 +++++++++++++++++++++++
 test/smoke/issue-34.html             |  62 ++++
 test/smoke/issue-3947-test.html      |  66 ++++
 test/smoke/issue-3947.html           |  33 ++
 test/smoke/test.html                 |  10 +
 test/unit/dom-repeat.html            |  10 +-
 11 files changed, 649 insertions(+), 481 deletions(-)
 create mode 100644 test/smoke/data-table.html
 create mode 100644 test/smoke/issue-34.html
 create mode 100644 test/smoke/issue-3947-test.html
 create mode 100644 test/smoke/issue-3947.html
 create mode 100644 test/smoke/test.html

diff --git a/src/elements/element.html b/src/elements/element.html
index bb011eb6b8..80924b356a 100644
--- a/src/elements/element.html
+++ b/src/elements/element.html
@@ -179,7 +179,7 @@
       // reserved for canonical behavior
       connectedCallback() {
         if (hostStack.isEmpty()) {
-          this._flushProperties();
+          this._flushProperties(true);
           this.updateStyles();
         }
       }
diff --git a/src/properties/batched-effects.html b/src/properties/batched-effects.html
index 198dbe6d52..30a4470caa 100644
--- a/src/properties/batched-effects.html
+++ b/src/properties/batched-effects.html
@@ -123,11 +123,11 @@
       // -- set properties machinery
 
       _propertiesChanged(currentProps, changedProps, oldProps) {
-        // if (window.debug) {
-        //   var c = Object.getOwnPropertyNames(changedProps);
-        //   console.group(inst.localName + '#' + inst.id + ': ' + c);
-        //   debugger;
-        // }
+        // ----------------------------
+        var c = Object.getOwnPropertyNames(changedProps || {});
+        console.group(this.localName + '#' + this.id + ': ' + c);
+        debugger;
+        // ----------------------------
         // Compute
         var computedProps = runComputedEffects(this, changedProps, oldProps);
         // Compute linked paths
@@ -148,9 +148,9 @@
           runEffects(this, this.PROPERTY_EFFECT_TYPES.OBSERVE,
             changedProps, oldProps);
         }
-        // if (window.debug) {
-        //   console.groupEnd(inst.localName + '#' + inst.id + ': ' + c);
-        // }
+        // ----------------------------
+        console.groupEnd(this.localName + '#' + this.id + ': ' + c);
+        // ----------------------------
       }
 
       _setPropertyToNodeFromAnnotation(node, prop, value) {
diff --git a/src/properties/property-effects.html b/src/properties/property-effects.html
index efa869ac74..95b7b07968 100644
--- a/src/properties/property-effects.html
+++ b/src/properties/property-effects.html
@@ -557,27 +557,8 @@
   // data api
 
   // Note: this implemetation only accepts key-based array paths
-  function notifySplices(inst, array, path, splices) {
-    let change = {
-      keySplices: Polymer.Collection.applySplices(array, splices),
-      indexSplices: splices
-    };
-    let splicesPath = path + '.splices';
-    inst._setProperty(splicesPath, change);
-    inst._setProperty(path + '.length', array.length);
-    // All path notification values are cached on `this.__data__`.
-    // Null here to allow potentially large splice records to be GC'ed.
-    inst.__data[splicesPath] = {keySplices: null, indexSplices: null};
-  }
-
-  function notifySplice(inst, array, path, index, added, removed) {
-    notifySplices(inst, array, path, [{
-      index: index,
-      addedCount: added,
-      removed: removed,
-      object: array,
-      type: 'splice'
-    }]);
+  function notifySplices(inst, array, path) {
+    inst._setProperty(path, array);
   }
 
   function upper(name) {
@@ -688,12 +669,12 @@
       // `path` can be a user-facing path string or array of path parts.
       _setPathOrUnmanagedProperty(path, value) {
         let rootProperty = Polymer.Path.root(Array.isArray(path) ? path[0] : path);
-        let _hasEffect = this._hasPropertyEffect(rootProperty);
+        let hasEffect = this._hasPropertyEffect(rootProperty);
         let isPath = (rootProperty !== path);
-        if (!_hasEffect || isPath) {
+        if (!hasEffect || isPath) {
           path = Polymer.Path.set(this, path, value);
         }
-        if (_hasEffect) {
+        if (hasEffect) {
           return path;
         }
       }
@@ -801,7 +782,7 @@
         let info = {};
         let array = Polymer.Path.get(this, path, info);
         // Notify change to key-based path
-        notifySplices(this, array, info.path, splices);
+        notifySplices(this, array, info.path);
       }
 
       /**
@@ -885,10 +866,9 @@
       push(path, ...items) {
         let info = {};
         let array = Polymer.Path.get(this, path, info);
-        let len = array.length;
         let ret = array.push(...items);
         if (items.length) {
-          notifySplice(this, array, info.path, len, items.length, []);
+          notifySplices(this, array, info.path);
         }
         return ret;
       }
@@ -912,7 +892,7 @@
         let hadLength = Boolean(array.length);
         let ret = array.pop();
         if (hadLength) {
-          notifySplice(this, array, info.path, array.length, 0, [ret]);
+          notifySplices(this, array, info.path);
         }
         return ret;
       }
@@ -937,18 +917,9 @@
       splice(path, start, deleteCount, ...items) {
         let info = {};
         let array = Polymer.Path.get(this, path, info);
-        // Normalize fancy native splice handling of crazy start values
-        if (start < 0) {
-          start = array.length - Math.floor(-start);
-        } else {
-          start = Math.floor(start);
-        }
-        if (!start) {
-          start = 0;
-        }
         let ret = array.splice(start, deleteCount, ...items);
         if (items.length || ret.length) {
-          notifySplice(this, array, info.path, start, items.length, ret);
+          notifySplices(this, array, info.path);
         }
         return ret;
       }
@@ -972,7 +943,7 @@
         let hadLength = Boolean(array.length);
         let ret = array.shift();
         if (hadLength) {
-          notifySplice(this, array, info.path, 0, 0, [ret]);
+          notifySplices(this, array, info.path);
         }
         return ret;
       }
@@ -996,12 +967,15 @@
         let array = Polymer.Path.get(this, path, info);
         let ret = array.unshift(...items);
         if (items.length) {
-          notifySplice(this, array, info.path, 0, items.length, []);
+          notifySplices(this, array, info.path);
         }
         return ret;
       }
 
       notifyPath(path, value) {
+        if (arguments.length == 1) {
+          value = this.get(path);
+        }
         this._setProperty(path, value);
       }
 
diff --git a/src/templatizer/dom-repeat.html b/src/templatizer/dom-repeat.html
index 0e529acce9..308884cdd9 100644
--- a/src/templatizer/dom-repeat.html
+++ b/src/templatizer/dom-repeat.html
@@ -74,33 +74,10 @@
 the host, or a function may be assigned to the property directly.  The functions
 should implemented following the standard `Array` filter/sort API.
 
-In order to re-run the filter or sort functions based on changes to sub-fields
-of `items`, the `observe` property may be set as a space-separated list of
-`item` sub-fields that should cause a re-filter/sort when modified.  If
-the filter or sort function depends on properties not contained in `items`,
-the user should observe changes to those properties and call `render` to update
-the view based on the dependency change.
-
-For example, for an `dom-repeat` with a filter of the following:
-
-```js
-isEngineer: function(item) {
-    return item.type == 'engineer' || item.manager.type == 'engineer';
-}
-```
-
-Then the `observe` property should be configured as follows:
-
-```html
-<template is="dom-repeat" items="{{employees}}"
-          filter="isEngineer" observe="type manager.type">
-```
-
 -->
 
 <link rel="import" href="../../polymer-legacy.html">
 <link rel="import" href="templatizer.html">
-<link rel="import" href="collection.html">
 <link rel="import" href="../utils/debounce.html">
 
 <script>
@@ -153,6 +130,16 @@
         value: 'index'
       },
 
+      /**
+       * The name of the variable to add to the binding scope with the index
+       * for the inst.  If `sort` is provided, the index will reflect the
+       * sorted order (rather than the original array order).
+       */
+      origIndexAs: {
+        type: String,
+        value: 'origIndex'
+      },
+
       /**
        * A function that should determine the sort order of the items.  This
        * property should either be provided as a string, indicating a method
@@ -177,18 +164,6 @@
         observer: '_filterChanged'
       },
 
-      /**
-       * When using a `filter` or `sort` function, the `observe` property
-       * should be set to a space-separated list of the names of item
-       * sub-fields that should trigger a re-sort or re-filter when changed.
-       * These should generally be fields of `item` that the sort or filter
-       * function depends on.
-       */
-      observe: {
-        type: String,
-        observer: '_observeChanged'
-      },
-
       /**
        * When using a `filter` or `sort` function, the `delay` property
        * determines a debounce time after a change to observed item
@@ -284,11 +259,10 @@
           throw new Error('dom-repeat requires a <template> child');
         }
         // Template instance props that should be excluded from forwarding
-        var instanceProps = {
-          __key__: true
-        };
+        var instanceProps = {};
         instanceProps[this.as] = true;
         instanceProps[this.indexAs] = true;
+        instanceProps[this.origIndexAs] = true;
         this._ctor = templatizer.templatize(template, {
           instanceProps: instanceProps,
           fwdHostPropToInstance: function(host, prop, value) {
@@ -296,32 +270,17 @@
             var self = this.parentNode;
             var i$ = self._instances;
             for (var i=0, inst; (i<i$.length) && (inst=i$[i]); i++) {
-              if (!inst.isPlaceholder) {
-                inst.forwardProperty(prop, value, host);
-              }
+              inst.forwardProperty(prop, value, host);
             }
           },
           fwdInstancePropToHost: function(inst, prop, value) {
             //TODO(kschaaf): fallout from separating template from dom-repeat
             var self = this.__dataHost.parentNode;
             if (prop == self.as) {
-              var idx;
-              if (self._sortFn || self._filterFn) {
-                // Known slow lookup: when sorted/filtered, there is no way to
-                // efficiently memoize the array index and keep it in sync with array
-                // mutations, so we need to look the item up in the array
-                // This can happen e.g. when array of strings is repeated into inputs
-                idx = self.items.indexOf(self.collection.getItem(inst.__key__));
-              } else {
-                // When there is no sort/filter, the view index is the array index
-                idx = inst[self.indexAs];
-              }
-              // TODO(kschaaf): The upward flow of the instance prop here does
-              // not take advantage of the normal batched effects batching
-              self.set('items.' + idx, value);
+              self.items[inst[self.origIndexAs]] = value;
+              self.notifyPath('items', self.items);
             } else if (prop.indexOf(self.as + '.') === 0) {
-              self.set('items.' + inst.__key__ + '.' +
-                prop.slice(self.as.length + 1), value);
+              self.notifyPath('items', self.items);
             }
           }
         });
@@ -388,55 +347,14 @@
       this._debounceRender();
     },
 
-    _observeChanged: function() {
-      this._observePaths = this.observe &&
-        this.observe.replace('.*', '.').split(' ');
-    },
-
     _itemsChanged: function(change) {
-      if (change.path == 'items') {
-        if (Array.isArray(this.items)) {
-          this.collection = Polymer.Collection.from(this.items);
-        } else if (!this.items) {
-          this.collection = null;
-        } else {
-          console.warn('dom-repeat expected array for `items`, found', this.items);
-        }
-        this._keySplices = [];
-        this._indexSplices = [];
-        this._needFullRefresh = true;
-        this._initializeChunking();
-        this._debounceRender();
-      } else if (change.path == 'items.splices') {
-        this._keySplices = this._keySplices.concat(change.value.keySplices);
-        this._indexSplices = this._indexSplices.concat(change.value.indexSplices);
-        this._debounceRender();
-      } else { // items.*
-        // slice off 'items.' ('items.'.length == 6)
-        var subpath = change.path.slice(6);
-        this._forwardItemPath(subpath, change.value);
-        this._checkObservedPaths(subpath);
-      }
-    },
-
-    _checkObservedPaths: function(path) {
-      if (this._observePaths) {
-        path = path.substring(path.indexOf('.') + 1);
-        var paths = this._observePaths;
-        for (var i=0; i<paths.length; i++) {
-          if (path.indexOf(paths[i]) === 0) {
-            // TODO(kschaaf): interim solution: ideally this is just an incremental
-            // insertion sort of the changed item
-            this._needFullRefresh = true;
-            if (this.delay) {
-              this.debounce('render', this._render, this.delay);
-            } else {
-              this._debounceRender();
-            }
-            return;
-          }
-        }
+      if (this.items && !Array.isArray(this.items)) {
+        console.warn('dom-repeat expected array for `items`, found', this.items);
       }
+      this._needFullRefresh = true;
+      this._initializeChunking();
+      // this._debounceRender();
+      this._render();
     },
 
     _debounceRender: function() {
@@ -459,45 +377,7 @@
 
     _render: function() {
       this.ensureTemplatized();
-      // Choose rendering path: full vs. incremental using splices
-      if (this._needFullRefresh) {
-        // Full refresh when items, sort, or filter change, or when render() called
-        this._applyFullRefresh();
-        this._needFullRefresh = false;
-      } else if (this._keySplices.length) {
-        // Incremental refresh when splices were queued
-        if (this._sortFn) {
-          this._applySplicesUserSort(this._keySplices);
-        } else {
-          if (this._filterFn) {
-            // TODK(kschaaf): Filtering using array sort takes slow path
-            this._applyFullRefresh();
-          } else {
-            this._applySplicesArrayOrder(this._indexSplices);
-          }
-        }
-      } else {
-        // Otherwise only limit changed; no change to instances, just need to
-        // upgrade more placeholders to instances
-      }
-      this._keySplices = [];
-      this._indexSplices = [];
-      // Update final _keyToInstIdx and instance indices, and
-      // upgrade/downgrade placeholders
-      var keyToIdx = this._keyToInstIdx = {};
-      for (var i=this._instances.length-1; i>=0; i--) {
-        var inst = this._instances[i];
-        if (inst.isPlaceholder && i<this._limit) {
-          inst = this._insertInstance(i, inst.__key__);
-        } else if (!inst.isPlaceholder && i>=this._limit) {
-          inst = this._downgradeInstance(i, inst.__key__);
-        }
-        keyToIdx[inst.__key__] = i;
-        if (!inst.isPlaceholder) {
-          inst.forwardProperty(this.indexAs, i);
-          inst.flushProperties();
-        }
-      }
+      this._applyFullRefresh();
       // Reset the pool
       // TODO(kschaaf): Reuse pool across turns and nested templates
       // Requires updating hostProps and dealing with the fact that path
@@ -514,197 +394,57 @@
       this._tryRenderChunk();
     },
 
-    // Render method 1: full refesh
-    // ----
-    // Full list of keys is pulled from the collection, then sorted, filtered,
-    // and iterated to create (or reuse) existing instances
     _applyFullRefresh: function() {
-      var c = this.collection;
-      // Start with unordered keys for user sort,
-      // or get them in array order for array order
-      var keys;
-      if (this._sortFn) {
-        keys = c ? c.getKeys() : [];
-      } else {
-        keys = [];
-        if (c) {
-          var items = this.items;
-          if (items) {
-            for (var i=0; i<items.length; i++) {
-              keys.push(c.getKey(items[i]));
-            }
-          }
-        }
+      const items = this.items || [];
+      let viewOrder = this._viewOrder = new Array(items.length);
+      for (let i=0; i<items.length; i++) {
+        viewOrder[i] = i;
       }
-      // capture reference for use in filter/sort fn's
-      var self = this;
-      // Apply user filter to keys
+      // Apply user filter
       if (this._filterFn) {
-        keys = keys.filter(function(a) {
-          return self._filterFn(c.getItem(a));
-        });
+        viewOrder = viewOrder.filter((i) => this._filterFn(items[i]));
       }
-      // Apply user sort to keys
+      // Apply user sort
       if (this._sortFn) {
-        keys.sort(function(a, b) {
-          return self._sortFn(c.getItem(a), c.getItem(b));
-        });
-      }
-      // Generate instances and assign items and keys
-      // TODO(kschaaf): Key handling is not yet implemented!
-      for (i=0; i<keys.length; i++) {
-        var key = keys[i];
-        var inst = this._instances[i];
-        if (inst) {
-          inst.__key__ = key;
-          if (!inst.isPlaceholder && i < this._limit) {
-            inst.forwardProperty(this.as, c.getItem(key));
-          }
-        } else if (i < this._limit) {
-          this._insertInstance(i, key);
+        viewOrder.sort((a, b) => this._sortFn(items[a], items[b]));
+      }
+      // Generate instances and assign items
+      let instIdx = 0;
+      let limit = Math.min(viewOrder.length, this._limit);
+      for (; instIdx<limit; instIdx++) {
+        let inst = this._instances[instIdx];
+        let itemIdx = viewOrder[instIdx];
+        let item = items[itemIdx];
+        if (inst && instIdx < this._limit) {
+          inst.forwardProperty(this.as, item);
+          inst.forwardProperty(this.indexAs, instIdx);
+          inst.forwardProperty(this.origIndexAs, itemIdx);
+          inst.flushProperties();
         } else {
-          this._insertPlaceholder(i, key);
+          this._insertInstance(item, instIdx, itemIdx);
         }
       }
       // Remove any extra instances from previous state
-      for (var j=this._instances.length-1; j>=i; j--) {
-        this._detachAndRemoveInstance(j);
-      }
-    },
-
-    _numericSort: function(a, b) {
-      return a - b;
-    },
-
-    // Render method 2: incremental update using splices with user sort applied
-    // ----
-    // Removed/added keys are deduped, all removed rows are detached and pooled
-    // first, and added rows are insertion-sorted into place using user sort
-    _applySplicesUserSort: function(splices) {
-      var c = this.collection;
-      var keyMap = {};
-      var key;
-      // Dedupe added and removed keys to a final added/removed map
-      for (var i=0, s; (i<splices.length) && (s=splices[i]); i++) {
-        for (var j=0; j<s.removed.length; j++) {
-          key = s.removed[j];
-          keyMap[key] = keyMap[key] ? null : -1;
-        }
-        for (j=0; j<s.added.length; j++) {
-          key = s.added[j];
-          keyMap[key] = keyMap[key] ? null : 1;
-        }
-      }
-      // Convert added/removed key map to added/removed arrays
-      var removedIdxs = [];
-      var addedKeys = [];
-      for (key in keyMap) {
-        if (keyMap[key] === -1) {
-          removedIdxs.push(this._keyToInstIdx[key]);
-        }
-        if (keyMap[key] === 1) {
-          addedKeys.push(key);
-        }
-      }
-      // Remove & pool removed instances
-      if (removedIdxs.length) {
-        // Sort removed instances idx's then remove backwards,
-        // so we don't invalidate instance index
-        // use numeric sort, default .sort is alphabetic
-        removedIdxs.sort(this._numericSort);
-        for (i=removedIdxs.length-1; i>=0 ; i--) {
-          var idx = removedIdxs[i];
-          // Removed idx may be undefined if item was previously filtered out
-          if (idx !== undefined) {
-            this._detachAndRemoveInstance(idx);
-          }
-        }
-      }
-      // capture reference for use in filter/sort fn's
-      var self = this;
-      // Add instances for added keys
-      if (addedKeys.length) {
-        // Filter added keys
-        if (this._filterFn) {
-          addedKeys = addedKeys.filter(function(a) {
-            return self._filterFn(c.getItem(a));
-          });
-        }
-        // Sort added keys
-        addedKeys.sort(function(a, b) {
-          return self._sortFn(c.getItem(a), c.getItem(b));
-        });
-        // Insertion-sort new instances into place (from pool or newly created)
-        var start = 0;
-        for (i=0; i<addedKeys.length; i++) {
-          start = this._insertRowUserSort(start, addedKeys[i]);
-        }
-      }
-    },
-
-    _insertRowUserSort: function(start, key) {
-      var c = this.collection;
-      var item = c.getItem(key);
-      var end = this._instances.length - 1;
-      var idx = -1;
-      // Binary search for insertion point
-      while (start <= end) {
-        var mid = (start + end) >> 1;
-        var midKey = this._instances[mid].__key__;
-        var cmp = this._sortFn(c.getItem(midKey), item);
-        if (cmp < 0) {
-          start = mid + 1;
-        } else if (cmp > 0) {
-          end = mid - 1;
-        } else {
-          idx = mid;
-          break;
-        }
-      }
-      if (idx < 0) {
-        idx = end + 1;
-      }
-      // Insert instance at insertion point
-      this._insertPlaceholder(idx, key);
-      return idx;
-    },
-
-    // Render method 3: incremental update using splices with array order
-    // ----
-    // Splices are processed in order; removed rows are pooled, and added
-    // rows are as placeholders, and placeholders are updated to
-    // actual rows at the end to take full advantage of removed rows
-    _applySplicesArrayOrder: function(splices) {
-      for (var i=0, s; (i<splices.length) && (s=splices[i]); i++) {
-        // Detach & pool removed instances
-        for (var j=0; j<s.removed.length; j++) {
-          this._detachAndRemoveInstance(s.index);
-        }
-        for (j=0; j<s.addedKeys.length; j++) {
-          this._insertPlaceholder(s.index+j, s.addedKeys[j]);
-        }
+      for (let i=this._instances.length-1; i>=instIdx; i--) {
+        this._detachAndRemoveInstance(i);
       }
     },
 
     _detachInstance: function(idx) {
       var inst = this._instances[idx];
-      if (!inst.isPlaceholder) {
-        //TODO(sorvell): why is this necessary?
-        if (inst.children) {
-          for (var i=0; i<inst.children.length; i++) {
-            var el = inst.children[i];
-            inst.root.appendChild(el);
-          }
+      //TODO(sorvell): why is this necessary?
+      if (inst.children) {
+        for (var i=0; i<inst.children.length; i++) {
+          var el = inst.children[i];
+          inst.root.appendChild(el);
         }
-        return inst;
       }
+      return inst;
     },
 
     _attachInstance: function(idx, parent) {
       var inst = this._instances[idx];
-      if (!inst.isPlaceholder) {
-        parent.insertBefore(inst.root, this);
-      }
+      parent.insertBefore(inst.root, this);
     },
 
     _detachAndRemoveInstance: function(idx) {
@@ -715,53 +455,33 @@
       this._instances.splice(idx, 1);
     },
 
-    _insertPlaceholder: function(idx, key) {
-      this._instances.splice(idx, 0, {
-        isPlaceholder: true,
-        __key__: key
-      });
-    },
-
-    _stampInstance: function(idx, key) {
-      var model = {
-        __key__: key
-      };
-      model[this.as] = this.collection.getItem(key);
-      model[this.indexAs] = idx;
+    _stampInstance: function(item, instIdx, itemIdx) {
+      var model = {};
+      model[this.as] = item;
+      model[this.indexAs] = instIdx;
+      model[this.origIndexAs] = itemIdx;
       return new this._ctor(this, model);
     },
 
-    _insertInstance: function(idx, key) {
+    _insertInstance: function(item, instIdx, itemIdx) {
       var inst = this._pool.pop();
       if (inst) {
         // TODO(kschaaf): If the pool is shared across turns, hostProps
-        // need to be re-set to reused instances in addition to item/key
-        inst.forwardProperty(this.as, this.collection.getItem(key));
-        inst.forwardProperty('__key__', key);
+        // need to be re-set to reused instances in addition to item
+        inst.forwardProperty(this.as, item);
+        inst.forwardProperty(this.indexAs, instIdx);
+        inst.forwardProperty(this.origIndexAs, itemIdx);
       } else {
-        inst = this._stampInstance(idx, key);
+        inst = this._stampInstance(item, instIdx, itemIdx);
       }
-      var beforeRow = this._instances[idx + 1];
-      var beforeNode = beforeRow && !beforeRow.isPlaceholder ? beforeRow.children[0] : this;
+      var beforeRow = this._instances[instIdx + 1];
+      var beforeNode = beforeRow ? beforeRow.children[0] : this;
       // TODO(sorvell): remove when fragment patching is auto-magic.
       if (window.ShadyDOM) {
         ShadyDOM.patch(inst.root);
       }
       this.parentNode.insertBefore(inst.root, beforeNode);
-      this._instances[idx] = inst;
-      return inst;
-    },
-
-    _downgradeInstance: function(idx, key) {
-      var inst = this._detachInstance(idx);
-      if (inst) {
-        this._pool.push(inst);
-      }
-      inst = {
-        isPlaceholder: true,
-        __key__: key
-      };
-      this._instances[idx] = inst;
+      this._instances[instIdx] = inst;
       return inst;
     },
 
@@ -772,22 +492,6 @@
       }
     },
 
-    // Called as a side effect of a host items.<key>.<path> path change,
-    // responsible for notifying item.<path> changes to inst for key
-    _forwardItemPath: function(path, value) {
-      if (this._keyToInstIdx) {
-        var dot = path.indexOf('.');
-        var key = path.substring(0, dot < 0 ? path.length : dot);
-        var idx = this._keyToInstIdx[key];
-        var inst = this._instances[idx];
-        if (inst && !inst.isPlaceholder) {
-          path = this.as + ((dot >= 0) ? ('.' + path.substring(dot+1)) : '');
-          inst.forwardProperty(path, value);
-          inst.flushProperties();
-        }
-      }
-    },
-
     /**
      * Returns the item associated with a given element stamped by
      * this `dom-repeat`.
@@ -805,19 +509,6 @@
       return instance && instance[this.as];
     },
 
-    /**
-     * Returns the `Polymer.Collection` key associated with a given
-     * element stamped by this `dom-repeat`.
-     *
-     * @method keyForElement
-     * @param {HTMLElement} el Element for which to return the key.
-     * @return {any} Key associated with the element.
-     */
-    keyForElement: function(el) {
-      var instance = this.modelForElement(el);
-      return instance && instance.__key__;
-    },
-
     /**
      * Returns the inst index for a given element stamped by this `dom-repeat`.
      * If `sort` is provided, the index will reflect the sorted order (rather
diff --git a/src/utils/path.html b/src/utils/path.html
index c1f325ca2a..3ff2f029da 100644
--- a/src/utils/path.html
+++ b/src/utils/path.html
@@ -69,26 +69,13 @@
     get: function(root, path, info) {
       var prop = root;
       var parts = this.getParts(path);
-      var array;
       // Loop over path parts[0..n-1] and dereference
       for (var i=0; i<parts.length; i++) {
         if (!prop) {
           return;
         }
         var part = parts[i];
-        if (array && part[0] == '#') {
-          // Part was key; lookup item in collection
-          prop = Polymer.Collection.from(array).getItem(part);
-        } else {
-          // Get item from simple property dereference
-          prop = prop[part];
-          if (info && array && (parseInt(part, 10) == part)) {
-            // Translate array indices to collection keys for path notificaiton
-            parts[i] = Polymer.Collection.from(array).getKey(prop);
-          }
-        }
-        // Cache previous part if it is an array
-        array = Array.isArray(prop) ? prop : null;
+        prop = prop[part];
       }
       if (info) {
         info.path = parts.join('.');
@@ -99,51 +86,15 @@
     set: function(root, path, value) {
       var prop = root;
       var parts = this.getParts(path);
-      var array;
       var last = parts[parts.length-1];
       if (parts.length > 1) {
         // Loop over path parts[0..n-2] and dereference
         for (var i=0; i<parts.length-1; i++) {
           var part = parts[i];
-          if (array && part[0] == '#') {
-            // Part was key; lookup item in collection
-            prop = Polymer.Collection.from(array).getItem(part);
-          } else {
-            // Get item from simple property dereference
-            prop = prop[part];
-            if (array && (parseInt(part, 10) == part)) {
-              // Translate array indices to collection keys for path notificaiton
-              parts[i] = Polymer.Collection.from(array).getKey(prop);
-            }
-          }
+          prop = prop[part];
           if (!prop) {
             return;
           }
-          // Cache previous part if it is an array
-          array = Array.isArray(prop) ? prop : null;
-        }
-        // Special handling when last part is a array item: need to replace
-        // item in collection associated with key for that item
-        if (array) {
-          var coll = Polymer.Collection.from(array);
-          var old, key;
-          if (last[0] == '#') {
-            // Part was key; lookup item in collection
-            key = last;
-            old = coll.getItem(key);
-            // Update last part from key to index: O(n) lookup unavoidable
-            last = array.indexOf(old);
-            // Replace item associated with key in collection
-            coll.setItem(key, value);
-          } else if (parseInt(last, 10) == last) {
-            // Dereference index & lookup collection key
-            old = prop[last];
-            key = coll.getKey(old);
-            // Translate array indices to collection keys for path notificaiton
-            parts[i] = key;
-            // Replace item associated with key in collection
-            coll.setItem(key, value);
-          }
         }
         // Set value to object at end of path
         prop[last] = value;
diff --git a/test/smoke/data-table.html b/test/smoke/data-table.html
new file mode 100644
index 0000000000..e98fbe94f3
--- /dev/null
+++ b/test/smoke/data-table.html
@@ -0,0 +1,379 @@
+<!doctype html>
+<!--
+@license
+Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+<html>
+<head>
+  <title>data-table</title>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <script src="../../../webcomponentsjs/webcomponents-lite.js"></script>
+  <link rel="import" href="../../polymer.html">
+</head>
+<body>
+
+  <script>
+    window.emojiByType = {
+      a: '😎',
+      b: '💰',
+      c: '🚔',
+      d: '💕',
+      e: '👍',
+      f: '🍌'
+    };
+  </script>
+
+  <dom-module id="data-popup">
+    <template strip-whitespace>
+      <style>
+        :host {
+          display: inline-block;
+          background: lightblue;
+          border-radius: 10px;
+          border-bottom-left-radius: 0;
+          border: 1px solid #aaa;
+          box-shadow: 3px 3px 5px #535353;
+          padding: 5px;
+          z-index: 1;
+        }
+      </style>
+      <slot></slot>
+      </template>
+    </template>
+    <script>
+      HTMLImports.whenReady(function() {
+        Polymer({
+          is: 'data-popup'
+        });
+      });
+    </script>
+  </dom-module>
+
+  <dom-module id="data-cell">
+    <template strip-whitespace>
+      <style>
+        :host {
+          flex: 1;
+          border: 2px solid #aaa;
+          padding: 5px;
+          position: relative;
+          background: #eee;
+        }
+        data-popup {
+          display: none;
+          position: absolute;
+          bottom: calc(100% - 15px);
+          left: calc(100% - 15px);
+        }
+        :host(:hover) data-popup {
+          display: inline-block;
+        }
+        :host([change=up]) {
+          background: #afa;
+        }
+        :host([change=down]) {
+          background: #faa;
+        }
+        .type {
+          display: inline-block;
+          border-radius: 100%;
+          box-sizing: border-box;
+          padding: 3px 0;
+          background: #aaa;
+          margin-right: 5px;
+          height: 30px;
+          width: 30px;
+          text-align: center;
+        }
+      </style>
+      <div class="type">{{computeTypeIcon(type)}}</div>
+      {{toFixed(value)}}
+      <data-popup>{{value}}</data-popup>
+    </template>
+    <script>
+      HTMLImports.whenReady(function() {
+        Polymer({
+          is: 'data-cell',
+          properties: {
+            type: {
+              type: String,
+              notify: true
+            },
+            value: {
+              type: Number,
+              notify: true
+            },
+            change: {
+              reflectToAttribute: true,
+              computed: 'computeChange(value)'
+            }
+          },
+          attached: function() {
+            this.fire('register-cell');
+          },
+          computeChange: function(value) {
+            var prev = this._prev;
+            this._prev = value;
+            return value > prev ? 'up' : (value < prev ? 'down' : 'none');
+          },
+          computeTypeIcon: function(type) {
+            return emojiByType[type];
+          },
+          toFixed: function(value) {
+            return Number(value).toFixed(2);
+          }
+        });
+      });
+    </script>
+  </dom-module>
+
+  <dom-module id="data-row">
+    <template strip-whitespace>
+      <style>
+        :host {
+          display: flex;
+          flex-direction: row;
+        }
+        .title-cell {
+          flex: 1;
+        }
+        .title {
+          font-weight: bold;
+        }
+        .dominant {
+          font-size: 0.7em;
+        }
+      </style>
+      <div class="title-cell">
+        <div class="title">{{title}}</div>
+        <div class="dominant">Dominant: {{computeDominant(cells.*)}}</div>
+      </div>
+      <template is="dom-repeat" items="{{cells}}" as="cell">
+        <data-cell type="{{cell.type}}" value="{{cell.value}}"></data-cell>
+      </template>
+    </template>
+    <script>
+      HTMLImports.whenReady(function() {
+        Polymer({
+          is: 'data-row',
+          properties: {
+            title: {
+              type: String,
+              notify: true
+            },
+            cells: {
+              type: Array,
+              notify: true
+            }
+          },
+          computeDominant: function(info) {
+            var types = this.types = info.base.reduce(function(map, i) {
+              return map[i.type] = (map[i.type] || 0) + 1, map;
+            }, {})
+            return emojiByType[Object.keys(types).sort(function(a, b) {
+              return types[b] - types[a];
+            })[0]];
+          }
+        });
+      });
+    </script>
+  </dom-module>
+
+  <dom-module id="data-table">
+    <template strip-whitespace>
+      <style>
+        :host {
+          display: block;
+        }
+      </style>
+      Polymer: {{version}}<br>
+      <button on-tap="toggleRunning">{{computeRunning(running)}}</button>
+      <input value-as-number="{{tables::input}}" type="number" style="width:35px;" placeholder="tables">
+      <input value-as-number="{{rows::input}}" type="number" style="width:35px;" placeholder="rows">
+      <input value-as-number="{{columns::input}}" type="number" style="width:35px;" placeholder="columns">
+      <br><br>
+      <select value="{{strategy::change}}">
+        <option value="reset">(Mutate in place x n), reset</option>
+        <option value="reset-each">(Mutate in place, reset) x n</option>
+        <option value="path">(Set path from top) x n</option>
+        <option value="path-leaf">(Set path from leaf) x n</option>
+      </select>
+      n = <input value-as-number="{{mutations::input}}" type="number" style="width:35px;">
+      <br><br>
+      <h3>FPS: {{fps}}</h3>
+      <h3>Op time: {{toFixed(optime, 2)}}</h3>
+      <div xhidden>
+        <template is="dom-repeat" items="{{tableData}}">
+          <h3>Table {{index}}:</h3>
+          <template is="dom-repeat" items="{{data}}" as="row">
+            <data-row title="{{row.title}}" cells="{{row.cells}}"></data-row>
+          </template>
+        </template>
+      </div>
+    </template>
+    <script>
+      HTMLImports.whenReady(function() {
+        var params = document.location.search.substring(1).split('&').map(p=>p.split('='))
+          .reduce((m, p)=>{return m[p[0]] = p[1], m;}, {});
+        Polymer({
+          is: 'data-table',
+          properties: {
+            rows: {
+              type: Number,
+              value: Number(params.rows) || 6
+            },
+            columns: {
+              type: Number,
+              value: Number(params.columns) || 10
+            },
+            tables: {
+              type: Number,
+              value: Number(params.tables) || 2
+            },
+            mutations: {
+              type: Number,
+              value: Number(params.mutations) || 30
+            },
+            strategy: {
+              type: String,
+              value: params.strategy || 'reset'
+            },
+            running: {
+              type: Number,
+              value: params.running === 'false' ? false : true
+            },
+            tableData: {
+              computed: 'computeTableData(tables)'
+            },
+            optime: {
+              value: 0
+            }
+          },
+          observers: ['computeData(rows, columns)'],
+          created: function() {
+            this._fps = 0;
+            this.end = performance.now() + 1000;
+            var cells = this.cells = [];
+            this.addEventListener('register-cell', function(e) {
+              var cell = e.composedPath()[0];
+              cell.id = 'cell-' + cells.length;
+              cells.push(cell);
+            });
+          },
+          toggleRunning: function() {
+            this.running = !this.running;
+            if (this.running) {
+              this.go();
+            }
+          },
+          computeRunning: function(running) {
+            return running ? 'Pause' : 'Run';
+          },
+          computeData: function(rows, columns) {
+            var r = [];
+            for (var i=0; i<rows; i++) {
+              var c = [];
+              for (var j=0; j<columns; j++) {
+                c.push({
+                  value: Math.random() * 10,
+                  type: ['a','b','c','d','e','f'][Math.floor(Math.random()*6)]
+                });
+              }
+              r.push({
+                cells: c,
+                title: 'Row ' + i
+              })
+            }
+            this.data = r;
+          },
+          computeTableData: function(tables) {
+            return new Array(Number(tables));
+          },
+          toFixed: function(value, decimals) {
+            return value.toFixed(decimals);
+          },
+          ready: function() {
+            this.version = Polymer.version || 'alacarte';
+            if (!this.setProperties) {
+              this.setProperties = function(props) {
+                for (var p in props) {
+                  this.set(p, props[p]);
+                }
+              }
+            }
+            this.go();
+          },
+          go: function() {
+            var optime = 0;
+            for (var i=0; i<this.mutations; i++) {
+              var type = ['a','b','c','d','e','f'][Math.floor(Math.random()*6)];
+              var delta = (Math.random() > 0.5 ? -1 : 1) * (Math.random() * 5);
+              var row = Math.floor(Math.random() * this.rows);
+              var column = Math.floor(Math.random() * this.columns);
+              var d = this.data[row].cells[column];
+              if (this.strategy == 'reset' || this.strategy == 'reset-each') {
+                d.type = type;
+                d.value += delta;
+                if (this.strategy == 'reset-each') {
+                  var start = performance.now();
+                  this.set('data', this.data);
+                  optime += (performance.now() - start);
+                }
+              } else if (this.strategy == 'path') {
+                var path = ['data', row, 'cells', column].join('.');
+                var props = {};
+                props[path + '.type'] = type;
+                props[path + '.value'] = d.value + delta;
+                var start = performance.now();
+                this.setProperties(props);
+                optime += (performance.now() - start);
+              } else if (this.strategy == 'path-leaf') {
+                var c = this.cells[Math.floor(this.cells.length * Math.random())];
+                var props = {
+                  type: type,
+                  value: c.value + delta
+                };
+                var start = performance.now();
+                c.setProperties(props);
+                optime += (performance.now() - start);
+              }
+            }
+            if (optime) {
+              this.optime = (this.optime * 9 + (optime / this.mutations)) / 10;
+              // this.optime = optime / this.mutations;
+            }
+            if (this.strategy == 'reset') {
+              var start = performance.now();
+              this.set('data', this.data);
+              this.optime = (this.optime * 9 + (performance.now() - start)) / 10;
+              // this.optime = performance.now() - start;
+            }
+            this._fps++;
+            if (performance.now() > this.end) {
+              this.fps = this._fps;
+              this._fps = 0;
+              this.end = performance.now() + 1000;
+            }
+            var self = this;
+            if (this.running) {
+              requestAnimationFrame(function() {
+                self.go();
+              });
+            }
+          }
+        });
+      });
+    </script>
+  </dom-module>
+
+  <data-table id="table"></data-table>
+
+
+</body>
+</html>
diff --git a/test/smoke/issue-34.html b/test/smoke/issue-34.html
new file mode 100644
index 0000000000..af4fb03c36
--- /dev/null
+++ b/test/smoke/issue-34.html
@@ -0,0 +1,62 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="../../../webcomponentsjs/webcomponents-lite.js"></script>
+  <link rel="import" href="../../polymer.html">
+</head>
+<body>
+
+<dom-module id="x-parent">
+  <template>
+    <h1>1 + [[foo]] = [[bar]]</h1>
+    <x-child id="child" foo="[[foo]]" bar="{{bar}}"></x-child>
+  </template>
+
+  <script>
+    Polymer({
+      is: 'x-parent',
+
+      properties: {
+        foo: {
+          type: Number,
+          value: 1
+        }
+      },
+
+      attached() {
+        window.setInterval(function() {
+          ++this.foo;
+        }.bind(this), 2000);
+      }
+    });
+  </script>
+</dom-module>
+
+<dom-module id="x-child">
+  <script>
+    Polymer({
+      is: 'x-child',
+
+      properties: {
+        foo: {
+          type: Number,
+          observer: 'fooChanged'
+        },
+
+        bar: {
+          type: Number,
+          notify: true
+        }
+      },
+
+      fooChanged() {
+        this.bar = 1 + this.foo;
+      }
+    });
+  </script>
+</dom-module>
+
+<x-parent></x-parent>
+
+</body>
+</html>
diff --git a/test/smoke/issue-3947-test.html b/test/smoke/issue-3947-test.html
new file mode 100644
index 0000000000..03ab60b177
--- /dev/null
+++ b/test/smoke/issue-3947-test.html
@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="../../../webcomponentsjs/webcomponents-lite.js"></script>
+  <link rel="import" href="../../polymer.html">
+</head>
+<body>
+
+<!--   <dom-module id="x-host">
+    <template>
+      <button on-click="reset">Reset</button>
+      <button on-click="mutate">Mutate</button>
+      <hr>
+      <template is="dom-repeat" items="{{items}}">
+        <input value="{{item.value::input}}"><br>
+      </template>
+      <hr>
+      <template is="dom-repeat" items="{{items}}">
+        <input value="{{item.value::input}}"><br>
+      </template>
+    </template>
+  </dom-module>
+ -->
+  <dom-module id="x-host">
+    <template>
+      <button on-click="reset">Reset</button>
+      <button on-click="mutate">Mutate</button>
+      <hr>
+      <dom-repeat is="dom-repeat" id="outside" items="{{items}}">
+        <template id="outside">
+          <input value="{{item.value::input}}"><br>
+          <dom-repeat is="dom-repeat" id="inside" items="{{item.items}}">
+            <template id="inside">
+              *** <input value="{{item.value::input}}"><br>
+            </template>
+          </dom-repeat>
+        </template>
+      </dom-repeat>
+    </template>
+  </dom-module>
+
+  <script>
+    Polymer({
+      is: 'x-host',
+      ready: function() {
+        this.reset();
+      },
+      reset: function() {
+        this.items = [
+          {value: 'a', items: [
+            {value: 1}
+          ]}
+        ];
+      },
+      mutate: function() {
+        this.items.shift();
+        this.items.push({value: Math.random().toString().slice(-1)});
+        this.items = this.items;
+      }
+    })
+  </script>
+
+  <x-host id="host"></x-host>
+
+</body>
+</html>
diff --git a/test/smoke/issue-3947.html b/test/smoke/issue-3947.html
new file mode 100644
index 0000000000..5ae21c26c8
--- /dev/null
+++ b/test/smoke/issue-3947.html
@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="../../../webcomponentsjs/webcomponents-lite.js"></script>
+  <link rel="import" href="../../polymer.html">
+</head>
+<body>
+
+  <dom-repeat id="repeater">
+    <template>
+      <p>{{item.name}}</p>
+    </template>
+  </dom-repeat>
+
+  <button onclick="addData()">add</button>
+
+  <script>
+    var t = document.getElementById('repeater');
+    // t.items = [];
+
+    function addData() {
+      let items = [];
+      items.push({
+        name: 'item ' + items.length
+      });
+      t.items = items;
+      console.log(t.items);
+    }
+
+  </script>
+
+</body>
+</html>
diff --git a/test/smoke/test.html b/test/smoke/test.html
new file mode 100644
index 0000000000..7af2d666a4
--- /dev/null
+++ b/test/smoke/test.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="../../../webcomponentsjs/webcomponents-lite.js"></script>
+  <link rel="import" href="../../polymer-element.html">
+</head>
+<body>
+
+</body>
+</html>
diff --git a/test/unit/dom-repeat.html b/test/unit/dom-repeat.html
index 97264b56dc..494309280c 100644
--- a/test/unit/dom-repeat.html
+++ b/test/unit/dom-repeat.html
@@ -3227,14 +3227,16 @@ <h4>x-repeat-chunked</h4>
         unconfigured1.$.repeater.render();
         var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
         var stamped2 = unconfigured2.root.querySelectorAll('*:not(template):not(dom-repeat)');
+        assert.equal(stamped1[26].itemaProp, 'prop-1');
+        assert.equal(stamped2[26].itemaProp, 'prop-3');
         var old = unconfigured.items[2];
-        // Change last item (first rendered in #1, last rendered in #2)
+        // Change last item (last item rendered in both, due to sort in #1)
         unconfigured1.$.repeater._instances[0].itema = {prop: 'change!'};
-        assert.equal(stamped1[0].itemaProp, 'change!');
+        assert.equal(stamped1[26].itemaProp, 'change!');
         assert.equal(stamped2[26].itemaProp, 'change!');
         // Revert
         unconfigured2.$.repeater._instances[2].itema = old;
-        assert.equal(stamped1[0].itemaProp, 'prop-3');
+        assert.equal(stamped1[26].itemaProp, 'prop-1');
         assert.equal(stamped2[26].itemaProp, 'prop-3');
         unconfigured1.$.repeater.sort = null;
         unconfigured1.$.repeater.render();
@@ -3321,7 +3323,7 @@ <h4>x-repeat-chunked</h4>
         assert.equal(repeater3.itemForElement(stamped1[4]).prop, 'prop-1-1-3');
       });
 
-      test('keyForElement', function() {
+      test.skip('keyForElement', function() {
         var dom = unconfigured1.root;
         var stamped1 = dom.querySelectorAll('*:not(template):not(dom-repeat)');
         var repeater1 = dom.querySelector('dom-repeat[as=itema]');

From b5420e73998e402feb0a3dc1686253f195c6984b Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Mon, 19 Sep 2016 15:19:22 -0700
Subject: [PATCH 02/20] Keep async render, sync index path update, indexSplices
 notification.

---
 src/properties/batched-effects.html  |  30 +++--
 src/properties/meta-effects.html     |   2 +-
 src/properties/property-effects.html |  44 +++++--
 src/templatizer/dom-repeat.html      | 109 +++++++++++++--
 test/runner.html                     |   2 +-
 test/unit/dom-repeat-elements.html   |   2 +-
 test/unit/dom-repeat.html            |  15 ++-
 test/unit/notify-path.html           | 190 +++++++++++++--------------
 8 files changed, 260 insertions(+), 134 deletions(-)

diff --git a/src/properties/batched-effects.html b/src/properties/batched-effects.html
index 30a4470caa..45b76bfd64 100644
--- a/src/properties/batched-effects.html
+++ b/src/properties/batched-effects.html
@@ -39,10 +39,11 @@
   }
 
   function computeLinkedPaths(inst, changedProps, computedProps) {
-    if (inst.__dataLinkedPaths) {
+    const links = inst.__dataLinkedPaths;
+    if (links) {
       var link;
-      for (var a in inst.__dataLinkedPaths) {
-        var b = inst.__dataLinkedPaths[a];
+      for (var a in links) {
+        var b = links[a];
         for (var path in changedProps) {
           if (Polymer.Path.isDescendant(a, path)) {
             link = Polymer.Path.translate(a, b, path);
@@ -69,7 +70,7 @@
       utils.mixin(inst.__dataInterimOld, oldProps) : oldProps;
     // Notify
     var host = inst.__dataHost;
-    runEffects(inst, inst.PROPERTY_EFFECT_TYPES.NOTIFY, props);
+    runEffects(inst, inst.PROPERTY_EFFECT_TYPES.NOTIFY, props, oldProps, notifyPaths);
     // Flush host
     // TODO(kschaaf): fix this check (__dataLib is gone)
     if (host /*&& host.__dataLib instanceof BatchedEffects*/ && host.__dataPending) {
@@ -85,7 +86,16 @@
     }
   }
 
-  function runEffects(inst, type, props, oldProps) {
+  function notifyPaths(inst, prop, value) {
+    let rootProperty = Polymer.Path.root(prop);
+    if (rootProperty !== prop) {
+      let name = Polymer.CaseMap.camelToDashCase(rootProperty) + '-changed';
+      inst.dispatchEvent(new CustomEvent(name, { detail: {value, path: prop }}));
+    }
+  }
+
+
+  function runEffects(inst, type, props, oldProps, fallback) {
     var ran;
     var effects = inst[type];
     if (effects) {
@@ -105,6 +115,9 @@
               ran = true;
             }
           }
+        } else if (fallback) {
+          fallback(inst, prop, inst.__data[prop],
+            oldProps && oldProps[prop], inst.__dataFromAbove);
         }
       }
     }
@@ -124,9 +137,8 @@
 
       _propertiesChanged(currentProps, changedProps, oldProps) {
         // ----------------------------
-        var c = Object.getOwnPropertyNames(changedProps || {});
-        console.group(this.localName + '#' + this.id + ': ' + c);
-        debugger;
+        // var c = Object.getOwnPropertyNames(changedProps || {});
+        // console.group(this.localName + '#' + this.id + ': ' + c);
         // ----------------------------
         // Compute
         var computedProps = runComputedEffects(this, changedProps, oldProps);
@@ -149,7 +161,7 @@
             changedProps, oldProps);
         }
         // ----------------------------
-        console.groupEnd(this.localName + '#' + this.id + ': ' + c);
+        // console.groupEnd(this.localName + '#' + this.id + ': ' + c);
         // ----------------------------
       }
 
diff --git a/src/properties/meta-effects.html b/src/properties/meta-effects.html
index c3038c4d12..f0cca5bea0 100644
--- a/src/properties/meta-effects.html
+++ b/src/properties/meta-effects.html
@@ -61,7 +61,7 @@
               info.value.call(this) :
               info.value;
             if (this._hasReadOnlyEffect(p)) {
-              this._setProperty(p, value)
+              this._setProperty(p, value);
             } else {
               this[p] = value;
             }
diff --git a/src/properties/property-effects.html b/src/properties/property-effects.html
index 95b7b07968..313f86c3a0 100644
--- a/src/properties/property-effects.html
+++ b/src/properties/property-effects.html
@@ -557,8 +557,26 @@
   // data api
 
   // Note: this implemetation only accepts key-based array paths
-  function notifySplices(inst, array, path) {
-    inst._setProperty(path, array);
+  function notifySplices(inst, array, path, splices) {
+    let change = {
+      indexSplices: splices
+    };
+    let splicesPath = path + '.splices';
+    inst._setProperty(splicesPath, change);
+    inst._setProperty(path + '.length', array.length);
+    // All path notification values are cached on `this.__data__`.
+    // Null here to allow potentially large splice records to be GC'ed.
+    inst.__data[splicesPath] = {keySplices: null, indexSplices: null};
+  }
+
+  function notifySplice(inst, array, path, index, added, removed) {
+    notifySplices(inst, array, path, [{
+      index: index,
+      addedCount: added,
+      removed: removed,
+      object: array,
+      type: 'splice'
+    }]);
   }
 
   function upper(name) {
@@ -782,7 +800,7 @@
         let info = {};
         let array = Polymer.Path.get(this, path, info);
         // Notify change to key-based path
-        notifySplices(this, array, info.path);
+        notifySplices(this, array, info.path, splices);
       }
 
       /**
@@ -866,9 +884,10 @@
       push(path, ...items) {
         let info = {};
         let array = Polymer.Path.get(this, path, info);
+        let len = array.length;
         let ret = array.push(...items);
         if (items.length) {
-          notifySplices(this, array, info.path);
+          notifySplice(this, array, info.path, len, items.length, []);
         }
         return ret;
       }
@@ -892,7 +911,7 @@
         let hadLength = Boolean(array.length);
         let ret = array.pop();
         if (hadLength) {
-          notifySplices(this, array, info.path);
+          notifySplice(this, array, info.path, array.length, 0, [ret]);
         }
         return ret;
       }
@@ -917,9 +936,18 @@
       splice(path, start, deleteCount, ...items) {
         let info = {};
         let array = Polymer.Path.get(this, path, info);
+        // Normalize fancy native splice handling of crazy start values
+        if (start < 0) {
+          start = array.length - Math.floor(-start);
+        } else {
+          start = Math.floor(start);
+        }
+        if (!start) {
+          start = 0;
+        }
         let ret = array.splice(start, deleteCount, ...items);
         if (items.length || ret.length) {
-          notifySplices(this, array, info.path);
+          notifySplice(this, array, info.path, start, items.length, ret);
         }
         return ret;
       }
@@ -943,7 +971,7 @@
         let hadLength = Boolean(array.length);
         let ret = array.shift();
         if (hadLength) {
-          notifySplices(this, array, info.path);
+          notifySplice(this, array, info.path, 0, 0, [ret]);
         }
         return ret;
       }
@@ -967,7 +995,7 @@
         let array = Polymer.Path.get(this, path, info);
         let ret = array.unshift(...items);
         if (items.length) {
-          notifySplices(this, array, info.path);
+          notifySplice(this, array, info.path, 0, items.length, []);
         }
         return ret;
       }
diff --git a/src/templatizer/dom-repeat.html b/src/templatizer/dom-repeat.html
index 308884cdd9..b89e93768e 100644
--- a/src/templatizer/dom-repeat.html
+++ b/src/templatizer/dom-repeat.html
@@ -74,6 +74,28 @@
 the host, or a function may be assigned to the property directly.  The functions
 should implemented following the standard `Array` filter/sort API.
 
+In order to re-run the filter or sort functions based on changes to sub-fields
+of `items`, the `observe` property may be set as a space-separated list of
+`item` sub-fields that should cause a re-filter/sort when modified.  If
+the filter or sort function depends on properties not contained in `items`,
+the user should observe changes to those properties and call `render` to update
+the view based on the dependency change.
+
+For example, for an `dom-repeat` with a filter of the following:
+
+```js
+isEngineer: function(item) {
+    return item.type == 'engineer' || item.manager.type == 'engineer';
+}
+```
+
+Then the `observe` property should be configured as follows:
+
+```html
+<template is="dom-repeat" items="{{employees}}"
+          filter="isEngineer" observe="type manager.type">
+```
+
 -->
 
 <link rel="import" href="../../polymer-legacy.html">
@@ -107,8 +129,7 @@
        * to stamp and that that each template instance should bind to.
        */
       items: {
-        type: Array,
-        notify: true
+        type: Array
       },
 
       /**
@@ -164,6 +185,18 @@
         observer: '_filterChanged'
       },
 
+      /**
+       * When using a `filter` or `sort` function, the `observe` property
+       * should be set to a space-separated list of the names of item
+       * sub-fields that should trigger a re-sort or re-filter when changed.
+       * These should generally be fields of `item` that the sort or filter
+       * function depends on.
+       */
+      observe: {
+        type: String,
+        observer: '_observeChanged'
+      },
+
       /**
        * When using a `filter` or `sort` function, the `delay` property
        * determines a debounce time after a change to observed item
@@ -276,11 +309,13 @@
           fwdInstancePropToHost: function(inst, prop, value) {
             //TODO(kschaaf): fallout from separating template from dom-repeat
             var self = this.__dataHost.parentNode;
-            if (prop == self.as) {
-              self.items[inst[self.origIndexAs]] = value;
-              self.notifyPath('items', self.items);
-            } else if (prop.indexOf(self.as + '.') === 0) {
-              self.notifyPath('items', self.items);
+            if (Polymer.Path.matches(self.as, prop)) {
+              let idx = inst[self.origIndexAs];
+              if (prop == self.as) {
+                self.items[idx] = value;
+              }
+              let path = Polymer.Path.translate(self.as, 'items.' + idx, prop);
+              self.notifyPath(path, value);
             }
           }
         });
@@ -347,14 +382,42 @@
       this._debounceRender();
     },
 
+    _observeChanged: function() {
+      this._observePaths = this.observe &&
+        this.observe.replace('.*', '.').split(' ');
+    },
+
     _itemsChanged: function(change) {
       if (this.items && !Array.isArray(this.items)) {
         console.warn('dom-repeat expected array for `items`, found', this.items);
       }
-      this._needFullRefresh = true;
-      this._initializeChunking();
-      // this._debounceRender();
-      this._render();
+      if (this._forwardItemPath(change.path, change.value)) {
+        this._checkObservedPaths(change.path);
+      } else {
+        this._needFullRefresh = true;
+        this._initializeChunking();
+        this._debounceRender();
+      }
+    },
+
+    _checkObservedPaths: function(path) {
+      if (this._observePaths) {
+        path = path.substring(path.indexOf('.', 6) + 1);
+        var paths = this._observePaths;
+        for (var i=0; i<paths.length; i++) {
+          if (path.indexOf(paths[i]) === 0) {
+            // TODO(kschaaf): interim solution: ideally this is just an incremental
+            // insertion sort of the changed item
+            this._needFullRefresh = true;
+            if (this.delay) {
+              this.debounce('render', this._render, this.delay);
+            } else {
+              this._debounceRender();
+            }
+            return;
+          }
+        }
+      }
     },
 
     _debounceRender: function() {
@@ -409,12 +472,15 @@
         viewOrder.sort((a, b) => this._sortFn(items[a], items[b]));
       }
       // Generate instances and assign items
+      const limit = Math.min(viewOrder.length, this._limit);
+      const idxMap = this._origIdxToInstIdx = {};
       let instIdx = 0;
-      let limit = Math.min(viewOrder.length, this._limit);
+      this._origIdxToInstIdx = idxMap;
       for (; instIdx<limit; instIdx++) {
         let inst = this._instances[instIdx];
         let itemIdx = viewOrder[instIdx];
         let item = items[itemIdx];
+        idxMap[itemIdx] = instIdx;
         if (inst && instIdx < this._limit) {
           inst.forwardProperty(this.as, item);
           inst.forwardProperty(this.indexAs, instIdx);
@@ -492,6 +558,25 @@
       }
     },
 
+    // Called as a side effect of a host items.<key>.<path> path change,
+    // responsible for notifying item.<path> changes to inst for key
+    _forwardItemPath: function(path, value) {
+      if (this._origIdxToInstIdx) {
+        // slice off 'items.' ('items.'.length == 6)
+        path = path.slice(6);
+        var dot = path.indexOf('.');
+        var origIdx = path.substring(0, dot < 0 ? path.length : dot);
+        var instIdx = this._origIdxToInstIdx[origIdx];
+        var inst = this._instances[instIdx];
+        if (inst) {
+          path = this.as + ((dot >= 0) ? ('.' + path.substring(dot+1)) : '');
+          inst.forwardProperty(path, value);
+          inst.flushProperties();
+          return true;
+        }
+      }
+    },
+
     /**
      * Returns the item associated with a given element stamped by
      * this `dom-repeat`.
diff --git a/test/runner.html b/test/runner.html
index be2361e149..97574a9f2a 100644
--- a/test/runner.html
+++ b/test/runner.html
@@ -76,7 +76,7 @@
       shady.push('wc-shadydom=true');
     }
 
-    suites = combinations(suites, [ce, shady]);
+    // suites = combinations(suites, [ce, shady]);
     console.log('Testing suites:\n\t' + suites.join('\n\t'));
 
     WCT.loadSuites(suites);
diff --git a/test/unit/dom-repeat-elements.html b/test/unit/dom-repeat-elements.html
index 44a00983ab..85f5f6de0c 100644
--- a/test/unit/dom-repeat-elements.html
+++ b/test/unit/dom-repeat-elements.html
@@ -267,7 +267,7 @@
 
 <dom-module id="x-nested-repeat-configured">
   <template>
-    <template id="repeater" is="dom-repeat" items="{{items}}" as="itema" index-as="indexa"observe="prop">
+    <template id="repeater" is="dom-repeat" items="{{items}}" as="itema" index-as="indexa" observe="prop">
       <x-foo
              innera-prop="{{innera.prop}}"
              itema-prop="{{itema.prop}}"
diff --git a/test/unit/dom-repeat.html b/test/unit/dom-repeat.html
index 494309280c..afa0909acb 100644
--- a/test/unit/dom-repeat.html
+++ b/test/unit/dom-repeat.html
@@ -19,9 +19,9 @@
 </head>
 <body>
 
-
-  <h4>x-simple-repeat</h4>
-  <x-simple-repeat id="simple"></x-simple-repeat>
+  <test-fixture id="simple">
+    <x-simple-repeat></x-simple-repeat>
+  </test-fixture>
 
   <h4>x-primitive-repeat</h4>
   <x-primitive-repeat id="primitive"></x-primitive-repeat>
@@ -1316,6 +1316,7 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('css scoping retained when re-ordering', function(done) {
+        let simple = fixture('simple');
         if (!Polymer.Settings.useShadow) {
           // Confirm initial scoping
           var stamped = simple.root.querySelectorAll('*:not(template):not(dom-repeat)');
@@ -3230,13 +3231,15 @@ <h4>x-repeat-chunked</h4>
         assert.equal(stamped1[26].itemaProp, 'prop-1');
         assert.equal(stamped2[26].itemaProp, 'prop-3');
         var old = unconfigured.items[2];
-        // Change last item (last item rendered in both, due to sort in #1)
+        // Change last item (first rendered in #1, last rendered in #2)
+        // (but only because `observe` doesn't catch this and cause the list to
+        // re-sort; if it was, stamped1[26] should change)
         unconfigured1.$.repeater._instances[0].itema = {prop: 'change!'};
-        assert.equal(stamped1[26].itemaProp, 'change!');
+        assert.equal(stamped1[0].itemaProp, 'change!');
         assert.equal(stamped2[26].itemaProp, 'change!');
         // Revert
         unconfigured2.$.repeater._instances[2].itema = old;
-        assert.equal(stamped1[26].itemaProp, 'prop-1');
+        assert.equal(stamped1[0].itemaProp, 'prop-3');
         assert.equal(stamped2[26].itemaProp, 'prop-3');
         unconfigured1.$.repeater.sort = null;
         unconfigured1.$.repeater.render();
diff --git a/test/unit/notify-path.html b/test/unit/notify-path.html
index baf3b6b0c3..ab0b25747a 100644
--- a/test/unit/notify-path.html
+++ b/test/unit/notify-path.html
@@ -415,18 +415,16 @@
     assert.equal(el.$.boundChild.computedFromPaths, 100);
   });
 
-  test('array.splices notified (no Collection)', function() {
+  test('array.splices notified', function() {
     el.arrayNoColl = [];
     assert.equal(el.arrayNoCollChanged.callCount, 1);
     el.push('arrayNoColl', 1, 2, 3);
     assert.equal(el.arrayNoCollChanged.callCount, 2);
-    assert.equal(Polymer.Collection.from(el.arrayNoColl).getKeys().length, 3);
     el.push('arrayNoColl', 4, 5, 6);
     assert.equal(el.arrayNoCollChanged.callCount, 3);
-    assert.equal(Polymer.Collection.from(el.arrayNoColl).getKeys().length, 6);
   });
 
-  test('array.splices notified', function() {
+  test.skip('array.splices notified', function() {
     el.array = [];
     // Ensure keySplices are generated for test purposes
     Polymer.Collection.from(el.array);
@@ -446,7 +444,7 @@
 
     el.push('array', 1, 2, 3);
     assert.notEqual(el.arraySplices.indexSplices, null);
-    assert.notEqual(el.arraySplices.keySplices, null);
+    // assert.notEqual(el.arraySplices.keySplices, null);
   });
 
   test('array.splices notified, multiple args, prop first', function() {
@@ -571,16 +569,16 @@
     assert.equal(el.get('array.0'), 1);
     assert.equal(el.get('array.1'), 2);
     assert.equal(el.get('array.2'), 3);
-    assert.equal(el.get('array.#0'), 1);
-    assert.equal(el.get('array.#1'), 2);
-    assert.equal(el.get('array.#2'), 3);
+    // assert.equal(el.get('array.#0'), 1);
+    // assert.equal(el.get('array.#1'), 2);
+    // assert.equal(el.get('array.#2'), 3);
     assert.equal(el.get('array.array'), el.array.array);
     assert.equal(el.get('array.array.0'), 5);
     assert.equal(el.get('array.array.1'), 6);
     assert.equal(el.get('array.array.2'), 7);
-    assert.equal(el.get('array.array.#0'), 5);
-    assert.equal(el.get('array.array.#1'), 6);
-    assert.equal(el.get('array.array.#2'), 7);
+    // assert.equal(el.get('array.array.#0'), 5);
+    // assert.equal(el.get('array.array.#1'), 6);
+    // assert.equal(el.get('array.array.#2'), 7);
     assert.equal(el.get('array.prop'), 'prop');
     el.unshift('array', 0);
     el.splice('array', 2, 0, 1.5);
@@ -591,21 +589,21 @@
     assert.equal(el.get('array.2'), 1.5);
     assert.equal(el.get('array.3'), 2);
     assert.equal(el.get('array.4'), 3);
-    assert.equal(el.get('array.#0'), 1);
-    assert.equal(el.get('array.#1'), 2);
-    assert.equal(el.get('array.#2'), 3);
-    assert.equal(el.get('array.#3'), 0);
-    assert.equal(el.get('array.#4'), 1.5);
+    // assert.equal(el.get('array.#0'), 1);
+    // assert.equal(el.get('array.#1'), 2);
+    // assert.equal(el.get('array.#2'), 3);
+    // assert.equal(el.get('array.#3'), 0);
+    // assert.equal(el.get('array.#4'), 1.5);
     assert.equal(el.get('array.array.0'), 4);
     assert.equal(el.get('array.array.1'), 5);
     assert.equal(el.get('array.array.2'), 5.5);
     assert.equal(el.get('array.array.3'), 6);
     assert.equal(el.get('array.array.4'), 7);
-    assert.equal(el.get('array.array.#0'), 5);
-    assert.equal(el.get('array.array.#1'), 6);
-    assert.equal(el.get('array.array.#2'), 7);
-    assert.equal(el.get('array.array.#3'), 4);
-    assert.equal(el.get('array.array.#4'), 5.5);
+    // assert.equal(el.get('array.array.#0'), 5);
+    // assert.equal(el.get('array.array.#1'), 6);
+    // assert.equal(el.get('array.array.#2'), 7);
+    // assert.equal(el.get('array.array.#3'), 4);
+    // assert.equal(el.get('array.array.#4'), 5.5);
   });
 
   test('set array', function() {
@@ -617,16 +615,16 @@
     assert.equal(el.get('array.0'), 1);
     assert.equal(el.get('array.1'), 2);
     assert.equal(el.get('array.2'), 3);
-    assert.equal(el.get('array.#0'), 1);
-    assert.equal(el.get('array.#1'), 2);
-    assert.equal(el.get('array.#2'), 3);
+    // assert.equal(el.get('array.#0'), 1);
+    // assert.equal(el.get('array.#1'), 2);
+    // assert.equal(el.get('array.#2'), 3);
     assert.equal(el.get('array.array'), el.array.array);
     assert.equal(el.get('array.array.0'), 5);
     assert.equal(el.get('array.array.1'), 6);
     assert.equal(el.get('array.array.2'), 7);
-    assert.equal(el.get('array.array.#0'), 5);
-    assert.equal(el.get('array.array.#1'), 6);
-    assert.equal(el.get('array.array.#2'), 7);
+    // assert.equal(el.get('array.array.#0'), 5);
+    // assert.equal(el.get('array.array.#1'), 6);
+    // assert.equal(el.get('array.array.#2'), 7);
     assert.equal(el.get('array.prop'), 'prop');
     el.set(['array', 0], 81);
     el.set(['array', 1], 82);
@@ -638,34 +636,34 @@
     assert.equal(el.get('array.0'), 81);
     assert.equal(el.get('array.1'), 82);
     assert.equal(el.get('array.2'), 83);
-    assert.equal(el.get('array.#0'), 81);
-    assert.equal(el.get('array.#1'), 82);
-    assert.equal(el.get('array.#2'), 83);
+    // assert.equal(el.get('array.#0'), 81);
+    // assert.equal(el.get('array.#1'), 82);
+    // assert.equal(el.get('array.#2'), 83);
     assert.equal(el.get('array.array.0'), 91);
     assert.equal(el.get('array.array.1'), 92);
     assert.equal(el.get('array.array.2'), 93);
-    assert.equal(el.get('array.array.#0'), 91);
-    assert.equal(el.get('array.array.#1'), 92);
-    assert.equal(el.get('array.array.#2'), 93);
+    // assert.equal(el.get('array.array.#0'), 91);
+    // assert.equal(el.get('array.array.#1'), 92);
+    // assert.equal(el.get('array.array.#2'), 93);
     assert.equal(el.get('array.prop'), 'foo');
-    el.set(['array', '#0'], 31);
-    el.set(['array', '#1'], 32);
-    el.set(['array', '#2'], 33);
-    el.set(['array.array', '#0'], 41);
-    el.set(['array.array', '#1'], 42);
-    el.set(['array.array', '#2'], 43);
-    assert.equal(el.get('array.0'), 31);
-    assert.equal(el.get('array.1'), 32);
-    assert.equal(el.get('array.2'), 33);
-    assert.equal(el.get('array.#0'), 31);
-    assert.equal(el.get('array.#1'), 32);
-    assert.equal(el.get('array.#2'), 33);
-    assert.equal(el.get('array.array.0'), 41);
-    assert.equal(el.get('array.array.1'), 42);
-    assert.equal(el.get('array.array.2'), 43);
-    assert.equal(el.get('array.array.#0'), 41);
-    assert.equal(el.get('array.array.#1'), 42);
-    assert.equal(el.get('array.array.#2'), 43);
+    // el.set(['array', '#0'], 31);
+    // el.set(['array', '#1'], 32);
+    // el.set(['array', '#2'], 33);
+    // el.set(['array.array', '#0'], 41);
+    // el.set(['array.array', '#1'], 42);
+    // el.set(['array.array', '#2'], 43);
+    // assert.equal(el.get('array.0'), 31);
+    // assert.equal(el.get('array.1'), 32);
+    // assert.equal(el.get('array.2'), 33);
+    // assert.equal(el.get('array.#0'), 31);
+    // assert.equal(el.get('array.#1'), 32);
+    // assert.equal(el.get('array.#2'), 33);
+    // assert.equal(el.get('array.array.0'), 41);
+    // assert.equal(el.get('array.array.1'), 42);
+    // assert.equal(el.get('array.array.2'), 43);
+    // assert.equal(el.get('array.array.#0'), 41);
+    // assert.equal(el.get('array.array.#1'), 42);
+    // assert.equal(el.get('array.array.#2'), 43);
   });
 
   var nop = function() {};
@@ -673,18 +671,18 @@
   test('push array', function() {
     el.arrayChanged = nop;
     el.array = ['orig1', 'orig2', 'orig3'];
-    Polymer.Collection.from(el.array);
-    var key = el.array.length;
+    // Polymer.Collection.from(el.array);
+    // var key = el.array.length;
     el.arrayChanged = function(change) {
       assert.strictEqual(change.indexSplices.length, 1);
       assert.strictEqual(change.indexSplices[0].index, 3);
       assert.strictEqual(change.indexSplices[0].addedCount, 2);
       assert.strictEqual(change.indexSplices[0].removed.length, 0);
-      assert.strictEqual(change.keySplices.length, 1);
-      assert.strictEqual(change.keySplices[0].added.length, 2);
-      assert.strictEqual(change.keySplices[0].added[0], '#' + key);
-      assert.strictEqual(change.keySplices[0].added[1], '#' + (key+1));
-      assert.strictEqual(change.keySplices[0].removed.length, 0);
+      // assert.strictEqual(change.keySplices.length, 1);
+      // assert.strictEqual(change.keySplices[0].added.length, 2);
+      // assert.strictEqual(change.keySplices[0].added[0], '#' + key);
+      // assert.strictEqual(change.keySplices[0].added[1], '#' + (key+1));
+      // assert.strictEqual(change.keySplices[0].removed.length, 0);
     };
     var ret = el.push('array', 'new1', 'new2');
     assert.strictEqual(ret, 5);
@@ -699,18 +697,18 @@
   test('pop array', function() {
     el.arrayChanged = nop;
     el.array = ['orig1', 'orig2', 'orig3'];
-    Polymer.Collection.from(el.array);
-    var key = el.array.length-1;
+    // Polymer.Collection.from(el.array);
+    // var key = el.array.length-1;
     el.arrayChanged = function(change) {
       assert.strictEqual(change.indexSplices.length, 1);
       assert.strictEqual(change.indexSplices[0].index, 2);
       assert.strictEqual(change.indexSplices[0].addedCount, 0);
       assert.strictEqual(change.indexSplices[0].removed.length, 1);
       assert.strictEqual(change.indexSplices[0].removed[0], 'orig3');
-      assert.strictEqual(change.keySplices.length, 1);
-      assert.strictEqual(change.keySplices[0].added.length, 0);
-      assert.strictEqual(change.keySplices[0].removed.length, 1);
-      assert.strictEqual(change.keySplices[0].removed[0], '#' + key);
+      // assert.strictEqual(change.keySplices.length, 1);
+      // assert.strictEqual(change.keySplices[0].added.length, 0);
+      // assert.strictEqual(change.keySplices[0].removed.length, 1);
+      // assert.strictEqual(change.keySplices[0].removed[0], '#' + key);
     };
     var ret = el.pop('array');
     assert.strictEqual(ret, 'orig3');
@@ -722,18 +720,18 @@
   test('unshift array', function() {
     el.arrayChanged = nop;
     el.array = ['orig1', 'orig2', 'orig3'];
-    Polymer.Collection.from(el.array);
-    var key = el.array.length;
+    // Polymer.Collection.from(el.array);
+    // var key = el.array.length;
     el.arrayChanged = function(change) {
       assert.strictEqual(change.indexSplices.length, 1);
       assert.strictEqual(change.indexSplices[0].index, 0);
       assert.strictEqual(change.indexSplices[0].addedCount, 2);
       assert.strictEqual(change.indexSplices[0].removed.length, 0);
-      assert.strictEqual(change.keySplices.length, 1);
-      assert.strictEqual(change.keySplices[0].added.length, 2);
-      assert.strictEqual(change.keySplices[0].added[0], '#' + key);
-      assert.strictEqual(change.keySplices[0].added[1], '#' + (key+1));
-      assert.strictEqual(change.keySplices[0].removed.length, 0);
+      // assert.strictEqual(change.keySplices.length, 1);
+      // assert.strictEqual(change.keySplices[0].added.length, 2);
+      // assert.strictEqual(change.keySplices[0].added[0], '#' + key);
+      // assert.strictEqual(change.keySplices[0].added[1], '#' + (key+1));
+      // assert.strictEqual(change.keySplices[0].removed.length, 0);
     };
     var ret = el.unshift('array', 'new1', 'new2');
     assert.strictEqual(ret, 5);
@@ -748,17 +746,17 @@
   test('shift array', function() {
     el.arrayChanged = nop;
     el.array = ['orig1', 'orig2', 'orig3'];
-    Polymer.Collection.from(el.array);
+    // Polymer.Collection.from(el.array);
     el.arrayChanged = function(change) {
       assert.strictEqual(change.indexSplices.length, 1);
       assert.strictEqual(change.indexSplices[0].index, 0);
       assert.strictEqual(change.indexSplices[0].addedCount, 0);
       assert.strictEqual(change.indexSplices[0].removed.length, 1);
       assert.strictEqual(change.indexSplices[0].removed[0], 'orig1');
-      assert.strictEqual(change.keySplices.length, 1);
-      assert.strictEqual(change.keySplices[0].added.length, 0);
-      assert.strictEqual(change.keySplices[0].removed.length, 1);
-      assert.strictEqual(change.keySplices[0].removed[0], '#' + 0);
+      // assert.strictEqual(change.keySplices.length, 1);
+      // assert.strictEqual(change.keySplices[0].added.length, 0);
+      // assert.strictEqual(change.keySplices[0].removed.length, 1);
+      // assert.strictEqual(change.keySplices[0].removed[0], '#' + 0);
     };
     var ret = el.shift('array');
     assert.strictEqual(ret, 'orig1');
@@ -770,20 +768,20 @@
   test('splice array', function() {
     el.arrayChanged = nop;
     el.array = ['orig1', 'orig2', 'orig3'];
-    var key = el.array.length;
-    Polymer.Collection.from(el.array);
+    // var key = el.array.length;
+    // Polymer.Collection.from(el.array);
     el.arrayChanged = function(change) {
       assert.strictEqual(change.indexSplices.length, 1);
       assert.strictEqual(change.indexSplices[0].index, 1);
       assert.strictEqual(change.indexSplices[0].addedCount, 2);
       assert.strictEqual(change.indexSplices[0].removed.length, 1);
       assert.strictEqual(change.indexSplices[0].removed[0], 'orig2');
-      assert.strictEqual(change.keySplices.length, 1);
-      assert.strictEqual(change.keySplices[0].added.length, 2);
-      assert.strictEqual(change.keySplices[0].added[0], '#' + key);
-      assert.strictEqual(change.keySplices[0].added[1], '#' + (key+1));
-      assert.strictEqual(change.keySplices[0].removed.length, 1);
-      assert.strictEqual(change.keySplices[0].removed[0], '#' + 1);
+      // assert.strictEqual(change.keySplices.length, 1);
+      // assert.strictEqual(change.keySplices[0].added.length, 2);
+      // assert.strictEqual(change.keySplices[0].added[0], '#' + key);
+      // assert.strictEqual(change.keySplices[0].added[1], '#' + (key+1));
+      // assert.strictEqual(change.keySplices[0].removed.length, 1);
+      // assert.strictEqual(change.keySplices[0].removed[0], '#' + 1);
     };
     var ret = el.splice('array', 1, 1, 'new1', 'new2');
     assert.deepEqual(ret, ['orig2']);
@@ -875,12 +873,12 @@
       assert.strictEqual(change.indexSplices[0].addedCount, 2);
       assert.strictEqual(change.indexSplices[0].removed.length, 1);
       assert.strictEqual(change.indexSplices[0].removed[0], 'orig2');
-      assert.strictEqual(change.keySplices.length, 1);
-      assert.strictEqual(change.keySplices[0].added.length, 2);
-      assert.strictEqual(change.keySplices[0].added[0], '#' + key);
-      assert.strictEqual(change.keySplices[0].added[1], '#' + (key+1));
-      assert.strictEqual(change.keySplices[0].removed.length, 1);
-      assert.strictEqual(change.keySplices[0].removed[0], '#' + 1);
+      // assert.strictEqual(change.keySplices.length, 1);
+      // assert.strictEqual(change.keySplices[0].added.length, 2);
+      // assert.strictEqual(change.keySplices[0].added[0], '#' + key);
+      // assert.strictEqual(change.keySplices[0].added[1], '#' + (key+1));
+      // assert.strictEqual(change.keySplices[0].removed.length, 1);
+      // assert.strictEqual(change.keySplices[0].removed[0], '#' + 1);
     };
     var ret = el.splice('array', '1', '1', 'new1', 'new2');
     assert.deepEqual(ret, ['orig2']);
@@ -902,12 +900,12 @@
       assert.strictEqual(change.indexSplices[0].addedCount, 2);
       assert.strictEqual(change.indexSplices[0].removed.length, 1);
       assert.strictEqual(change.indexSplices[0].removed[0], 'orig2');
-      assert.strictEqual(change.keySplices.length, 1);
-      assert.strictEqual(change.keySplices[0].added.length, 2);
-      assert.strictEqual(change.keySplices[0].added[0], '#' + key);
-      assert.strictEqual(change.keySplices[0].added[1], '#' + (key+1));
-      assert.strictEqual(change.keySplices[0].removed.length, 1);
-      assert.strictEqual(change.keySplices[0].removed[0], '#' + 1);
+      // assert.strictEqual(change.keySplices.length, 1);
+      // assert.strictEqual(change.keySplices[0].added.length, 2);
+      // assert.strictEqual(change.keySplices[0].added[0], '#' + key);
+      // assert.strictEqual(change.keySplices[0].added[1], '#' + (key+1));
+      // assert.strictEqual(change.keySplices[0].removed.length, 1);
+      // assert.strictEqual(change.keySplices[0].removed[0], '#' + 1);
     };
     var ret = el.splice('array', '-2', '1', 'new1', 'new2');
     assert.deepEqual(ret, ['orig2']);

From f1b5e3e82c43bbaaa2feef75b4dd78c771e885d4 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Mon, 19 Sep 2016 19:38:22 -0700
Subject: [PATCH 03/20] Add tests for direct mutation + reset of arrays.

---
 test/unit/dom-repeat.html | 2098 ++++++++++++++++++++++++++++++++++---
 1 file changed, 1965 insertions(+), 133 deletions(-)

diff --git a/test/unit/dom-repeat.html b/test/unit/dom-repeat.html
index afa0909acb..87ca5e810b 100644
--- a/test/unit/dom-repeat.html
+++ b/test/unit/dom-repeat.html
@@ -19,9 +19,8 @@
 </head>
 <body>
 
-  <test-fixture id="simple">
-    <x-simple-repeat></x-simple-repeat>
-  </test-fixture>
+  <h4>x-simple-repeat</h4>
+  <x-simple-repeat id="simple"></x-simple-repeat>
 
   <h4>x-primitive-repeat</h4>
   <x-primitive-repeat id="primitive"></x-primitive-repeat>
@@ -113,6 +112,11 @@ <h4>x-repeat-chunked</h4>
       el.splice(path, idx, 1);
     }
 
+    function arrayDeleteDirect(array, item) {
+      var idx = array.indexOf(item);
+      array.splice(idx, 1);
+    }
+
     suiteSetup(function() {
       // TODO(sorvell): remove when patching logic is improved.
       if (window.ShadyDOM) {
@@ -806,31 +810,1801 @@ <h4>x-repeat-chunked</h4>
         assert.equal(stamped1[38].indexc, 2);
       });
 
-      test('change to non-item scope doesn\'t affect other dom-repeat', function() {
-        var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
-        var stamped2 = unconfigured2.root.querySelectorAll('*:not(template):not(dom-repeat)');
-
-        unconfigured1.prop = 'foo';
-        unconfigured2.prop = 'bar';
-        assert.equal(stamped1[0].outerProp, 'foo');
-        assert.equal(stamped1[1].outerProp, 'foo');
-        assert.equal(stamped1[2].outerProp, 'foo');
-        assert.equal(stamped2[0].outerProp, 'bar');
-        assert.equal(stamped2[1].outerProp, 'bar');
-        assert.equal(stamped2[2].outerProp, 'bar');
+      test('change to non-item scope doesn\'t affect other dom-repeat', function() {
+        var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+        var stamped2 = unconfigured2.root.querySelectorAll('*:not(template):not(dom-repeat)');
+
+        unconfigured1.prop = 'foo';
+        unconfigured2.prop = 'bar';
+        assert.equal(stamped1[0].outerProp, 'foo');
+        assert.equal(stamped1[1].outerProp, 'foo');
+        assert.equal(stamped1[2].outerProp, 'foo');
+        assert.equal(stamped2[0].outerProp, 'bar');
+        assert.equal(stamped2[1].outerProp, 'bar');
+        assert.equal(stamped2[2].outerProp, 'bar');
+
+        stamped1[1].$.bar.inneraProp = 'bar';
+      });
+
+    });
+
+    suite('reacting to changes, array sort', function() {
+
+      var removed;
+
+      test('push', function(done) {
+        unconfigured1.domUpdateHandlerCount = 0;
+        unconfigured.push('items', {prop: 'new-1'}, {prop: 'new-2'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped2.length, 2 + 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[38].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped1[38].indexa, 2);
+          assert.equal(stamped1[38].indexb, 2);
+          assert.equal(stamped1[38].indexc, 2);
+          assert.equal(stamped1[39].itemaProp, 'new-1');
+          assert.equal(stamped1[40].itemaProp, 'new-2');
+          assert.equal(stamped1[41], undefined);
+          assert.equal(stamped2[38].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped2[38].indexa, 2);
+          assert.equal(stamped2[38].indexb, 2);
+          assert.equal(stamped2[38].indexc, 2);
+          assert.equal(stamped2[39].itemaProp, 'new-1');
+          assert.equal(stamped2[40].itemaProp, 'new-2');
+          assert.equal(stamped2[41], undefined);
+          assert.equal(unconfigured1.domUpdateHandlerCount, 1);
+          done();
+        });
+      });
+
+      test('undo: push (using splice)', function(done) {
+        unconfigured1.domUpdateHandlerCount = 0;
+        unconfigured.splice('items', 3, 2);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped2.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[38].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped1[38].indexa, 2);
+          assert.equal(stamped1[38].indexb, 2);
+          assert.equal(stamped1[38].indexc, 2);
+          assert.equal(stamped1[39], undefined);
+          assert.equal(stamped2[38].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped2[38].indexa, 2);
+          assert.equal(stamped2[38].indexb, 2);
+          assert.equal(stamped2[38].indexc, 2);
+          assert.equal(stamped2[39], undefined);
+          assert.equal(unconfigured1.domUpdateHandlerCount, 1);
+          done();
+        });
+      });
+
+      test('pop', function(done) {
+        removed = unconfigured.pop('items');
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped2.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[25].itemcProp, 'prop-2-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          assert.equal(stamped2[25].itemcProp, 'prop-2-3-3');
+          assert.equal(stamped2[25].indexa, 1);
+          assert.equal(stamped2[25].indexb, 2);
+          assert.equal(stamped2[25].indexc, 2);
+          assert.equal(stamped2[26], undefined);
+          done();
+        });
+      });
+
+      test('undo: pop (using splice)', function(done) {
+        unconfigured.splice('items', 2, 0, removed);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped2.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[38].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped1[38].indexa, 2);
+          assert.equal(stamped1[38].indexb, 2);
+          assert.equal(stamped1[38].indexc, 2);
+          assert.equal(stamped1[39], undefined);
+          assert.equal(stamped2[38].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped2[38].indexa, 2);
+          assert.equal(stamped2[38].indexb, 2);
+          assert.equal(stamped2[38].indexc, 2);
+          assert.equal(stamped2[39], undefined);
+          done();
+        });
+      });
+
+      test('unshift', function(done) {
+        unconfigured.unshift('items', {prop: 'new-1'}, {prop: 'new-2'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped2.length, 2 + 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'new-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itemaProp, 'new-2');
+          assert.equal(stamped1[1].indexa, 1);
+          assert.equal(stamped1[2].itemaProp, 'prop-1');
+          assert.equal(stamped1[2].indexa, 2);
+          assert.equal(stamped2[0].itemaProp, 'new-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped2[1].itemaProp, 'new-2');
+          assert.equal(stamped1[1].indexa, 1);
+          assert.equal(stamped2[2].itemaProp, 'prop-1');
+          assert.equal(stamped2[2].indexa, 2);
+          done();
+        });
+      });
+
+      test('undo: unshift (using splice)', function(done) {
+        unconfigured.splice('items', 0, 2);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped2.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped2[0].itemaProp, 'prop-1');
+          assert.equal(stamped2[0].indexa, 0);
+          assert.equal(stamped2[1].itembProp, 'prop-1-1');
+          assert.equal(stamped2[1].indexa, 0);
+          assert.equal(stamped2[1].indexb, 0);
+          done();
+        });
+      });
+
+      test('shift', function(done) {
+        removed = unconfigured.shift('items');
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped2.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-2');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-2-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-2-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped2[0].itemaProp, 'prop-2');
+          assert.equal(stamped2[0].indexa, 0);
+          assert.equal(stamped2[1].itembProp, 'prop-2-1');
+          assert.equal(stamped2[1].indexa, 0);
+          assert.equal(stamped2[1].indexb, 0);
+          assert.equal(stamped2[2].itemcProp, 'prop-2-1-1');
+          assert.equal(stamped2[2].indexa, 0);
+          assert.equal(stamped2[2].indexb, 0);
+          assert.equal(stamped2[2].indexc, 0);
+          done();
+        });
+      });
+
+      test('undo: shift (using splice)', function(done) {
+        unconfigured.splice('items', 0, 0, removed);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped2.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped2[0].itemaProp, 'prop-1');
+          assert.equal(stamped2[0].indexa, 0);
+          assert.equal(stamped2[1].itembProp, 'prop-1-1');
+          assert.equal(stamped2[1].indexa, 0);
+          assert.equal(stamped2[1].indexb, 0);
+          assert.equal(stamped2[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped2[2].indexa, 0);
+          assert.equal(stamped2[2].indexb, 0);
+          assert.equal(stamped2[2].indexc, 0);
+          done();
+        });
+      });
+
+      test('splice - remove from middle', function(done) {
+        removed = unconfigured.splice('items', 1, 1)[0];
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped2.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[13].itemaProp, 'prop-3');
+          assert.equal(stamped1[13].indexa, 1);
+          assert.equal(stamped1[14].itembProp, 'prop-3-1');
+          assert.equal(stamped1[14].indexa, 1);
+          assert.equal(stamped1[14].indexb, 0);
+          assert.equal(stamped1[15].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[15].indexa, 1);
+          assert.equal(stamped1[15].indexb, 0);
+          assert.equal(stamped1[15].indexc, 0);
+          assert.equal(stamped2[0].itemaProp, 'prop-1');
+          assert.equal(stamped2[0].indexa, 0);
+          assert.equal(stamped2[1].itembProp, 'prop-1-1');
+          assert.equal(stamped2[1].indexa, 0);
+          assert.equal(stamped2[1].indexb, 0);
+          assert.equal(stamped2[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped2[2].indexa, 0);
+          assert.equal(stamped2[2].indexb, 0);
+          assert.equal(stamped2[2].indexc, 0);
+          assert.equal(stamped2[13].itemaProp, 'prop-3');
+          assert.equal(stamped2[13].indexa, 1);
+          assert.equal(stamped2[14].itembProp, 'prop-3-1');
+          assert.equal(stamped2[14].indexa, 1);
+          assert.equal(stamped2[14].indexb, 0);
+          assert.equal(stamped2[15].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped2[15].indexa, 1);
+          assert.equal(stamped2[15].indexb, 0);
+          assert.equal(stamped2[15].indexc, 0);
+          done();
+        });
+      });
+
+      test('undo: splice - remove from middle (using splice)', function(done) {
+        unconfigured.splice('items', 1, 0, removed);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped2.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[13].itemaProp, 'prop-2');
+          assert.equal(stamped1[13].indexa, 1);
+          assert.equal(stamped1[14].itembProp, 'prop-2-1');
+          assert.equal(stamped1[14].indexa, 1);
+          assert.equal(stamped1[14].indexb, 0);
+          assert.equal(stamped1[15].itemcProp, 'prop-2-1-1');
+          assert.equal(stamped1[15].indexa, 1);
+          assert.equal(stamped1[15].indexb, 0);
+          assert.equal(stamped1[15].indexc, 0);
+          assert.equal(stamped2[0].itemaProp, 'prop-1');
+          assert.equal(stamped2[0].indexa, 0);
+          assert.equal(stamped2[1].itembProp, 'prop-1-1');
+          assert.equal(stamped2[1].indexa, 0);
+          assert.equal(stamped2[1].indexb, 0);
+          assert.equal(stamped2[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped2[2].indexa, 0);
+          assert.equal(stamped2[2].indexb, 0);
+          assert.equal(stamped2[2].indexc, 0);
+          assert.equal(stamped2[13].itemaProp, 'prop-2');
+          assert.equal(stamped2[13].indexa, 1);
+          assert.equal(stamped2[14].itembProp, 'prop-2-1');
+          assert.equal(stamped2[14].indexa, 1);
+          assert.equal(stamped2[14].indexb, 0);
+          assert.equal(stamped2[15].itemcProp, 'prop-2-1-1');
+          assert.equal(stamped2[15].indexa, 1);
+          assert.equal(stamped2[15].indexb, 0);
+          assert.equal(stamped2[15].indexc, 0);
+          done();
+        });
+      });
+
+      test('splice - add to middle', function(done) {
+        unconfigured.splice('items', 1, 0, {prop: 'new-1'}, {prop: 'new-2'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped2.length, 2 + 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[13].itemaProp, 'new-1');
+          assert.equal(stamped1[13].indexa, 1);
+          assert.equal(stamped1[14].itemaProp, 'new-2');
+          assert.equal(stamped1[14].indexa, 2);
+          assert.equal(stamped1[15].itemaProp, 'prop-2');
+          assert.equal(stamped1[15].indexa, 3);
+          assert.equal(stamped1[16].itembProp, 'prop-2-1');
+          assert.equal(stamped1[16].indexa, 3);
+          assert.equal(stamped1[16].indexb, 0);
+          assert.equal(stamped1[17].itemcProp, 'prop-2-1-1');
+          assert.equal(stamped1[17].indexa, 3);
+          assert.equal(stamped1[17].indexb, 0);
+          assert.equal(stamped1[17].indexc, 0);
+          assert.equal(stamped2[0].itemaProp, 'prop-1');
+          assert.equal(stamped2[0].indexa, 0);
+          assert.equal(stamped2[1].itembProp, 'prop-1-1');
+          assert.equal(stamped2[1].indexa, 0);
+          assert.equal(stamped2[1].indexb, 0);
+          assert.equal(stamped2[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped2[2].indexa, 0);
+          assert.equal(stamped2[2].indexb, 0);
+          assert.equal(stamped2[2].indexc, 0);
+          assert.equal(stamped2[13].itemaProp, 'new-1');
+          assert.equal(stamped2[13].indexa, 1);
+          assert.equal(stamped2[14].itemaProp, 'new-2');
+          assert.equal(stamped2[14].indexa, 2);
+          assert.equal(stamped2[15].itemaProp, 'prop-2');
+          assert.equal(stamped2[15].indexa, 3);
+          assert.equal(stamped2[16].itembProp, 'prop-2-1');
+          assert.equal(stamped2[16].indexa, 3);
+          assert.equal(stamped2[16].indexb, 0);
+          assert.equal(stamped2[17].itemcProp, 'prop-2-1-1');
+          assert.equal(stamped2[17].indexa, 3);
+          assert.equal(stamped2[17].indexb, 0);
+          assert.equal(stamped2[17].indexc, 0);
+          done();
+        });
+      });
+
+      test('undo: splice - add to middle (using splice)', function(done) {
+        unconfigured.splice('items', 1, 2);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped2.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[13].itemaProp, 'prop-2');
+          assert.equal(stamped1[13].indexa, 1);
+          assert.equal(stamped1[14].itembProp, 'prop-2-1');
+          assert.equal(stamped1[14].indexa, 1);
+          assert.equal(stamped1[14].indexb, 0);
+          assert.equal(stamped1[15].itemcProp, 'prop-2-1-1');
+          assert.equal(stamped1[15].indexa, 1);
+          assert.equal(stamped1[15].indexb, 0);
+          assert.equal(stamped1[15].indexc, 0);
+          assert.equal(stamped2[0].itemaProp, 'prop-1');
+          assert.equal(stamped2[0].indexa, 0);
+          assert.equal(stamped2[1].itembProp, 'prop-1-1');
+          assert.equal(stamped2[1].indexa, 0);
+          assert.equal(stamped2[1].indexb, 0);
+          assert.equal(stamped2[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped2[2].indexa, 0);
+          assert.equal(stamped2[2].indexb, 0);
+          assert.equal(stamped2[2].indexc, 0);
+          assert.equal(stamped2[13].itemaProp, 'prop-2');
+          assert.equal(stamped2[13].indexa, 1);
+          assert.equal(stamped2[14].itembProp, 'prop-2-1');
+          assert.equal(stamped2[14].indexa, 1);
+          assert.equal(stamped2[14].indexb, 0);
+          assert.equal(stamped2[15].itemcProp, 'prop-2-1-1');
+          assert.equal(stamped2[15].indexa, 1);
+          assert.equal(stamped2[15].indexb, 0);
+          assert.equal(stamped2[15].indexc, 0);
+          done();
+        });
+      });
+
+      test('splice - replace in middle', function(done) {
+        removed = unconfigured.splice('items', 1, 2, {prop: 'new-1'}, {prop: 'new-2'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
+          assert.equal(stamped2.length, 2 + 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[13].itemaProp, 'new-1');
+          assert.equal(stamped1[13].indexa, 1);
+          assert.equal(stamped1[14].itemaProp, 'new-2');
+          assert.equal(stamped1[14].indexa, 2);
+          assert.equal(stamped1[15], undefined);
+          assert.equal(stamped2[0].itemaProp, 'prop-1');
+          assert.equal(stamped2[0].indexa, 0);
+          assert.equal(stamped2[1].itembProp, 'prop-1-1');
+          assert.equal(stamped2[1].indexa, 0);
+          assert.equal(stamped2[1].indexb, 0);
+          assert.equal(stamped2[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped2[2].indexa, 0);
+          assert.equal(stamped2[2].indexb, 0);
+          assert.equal(stamped2[2].indexc, 0);
+          assert.equal(stamped2[13].itemaProp, 'new-1');
+          assert.equal(stamped2[13].indexa, 1);
+          assert.equal(stamped2[14].itemaProp, 'new-2');
+          assert.equal(stamped2[14].indexa, 2);
+          assert.equal(stamped2[15], undefined);
+          done();
+        });
+      });
+
+      test('undo: splice - replace in middle (using splice)', function(done) {
+        unconfigured.splice('items', 1, 2, removed[0], removed[1]);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped2.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[13].itemaProp, 'prop-2');
+          assert.equal(stamped1[13].indexa, 1);
+          assert.equal(stamped1[14].itembProp, 'prop-2-1');
+          assert.equal(stamped1[14].indexa, 1);
+          assert.equal(stamped1[14].indexb, 0);
+          assert.equal(stamped1[15].itemcProp, 'prop-2-1-1');
+          assert.equal(stamped1[15].indexa, 1);
+          assert.equal(stamped1[15].indexb, 0);
+          assert.equal(stamped1[15].indexc, 0);
+          assert.equal(stamped2[0].itemaProp, 'prop-1');
+          assert.equal(stamped2[0].indexa, 0);
+          assert.equal(stamped2[1].itembProp, 'prop-1-1');
+          assert.equal(stamped2[1].indexa, 0);
+          assert.equal(stamped2[1].indexb, 0);
+          assert.equal(stamped2[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped2[2].indexa, 0);
+          assert.equal(stamped2[2].indexb, 0);
+          assert.equal(stamped2[2].indexc, 0);
+          assert.equal(stamped2[13].itemaProp, 'prop-2');
+          assert.equal(stamped2[13].indexa, 1);
+          assert.equal(stamped2[14].itembProp, 'prop-2-1');
+          assert.equal(stamped2[14].indexa, 1);
+          assert.equal(stamped2[14].indexb, 0);
+          assert.equal(stamped2[15].itemcProp, 'prop-2-1-1');
+          assert.equal(stamped2[15].indexa, 1);
+          assert.equal(stamped2[15].indexb, 0);
+          assert.equal(stamped2[15].indexc, 0);
+          done();
+        });
+      });
+
+    });
+
+    suite('reacting to changes, array sort with filter', function() {
+
+      var removed;
+
+      test('push', function(done) {
+        unconfigured1.$.repeater.filter = function(o) {
+          return o.prop.indexOf('2') < 0;
+        };
+        unconfigured.push('items', {prop: 'new-1'}, {prop: 'new-2'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 1 + 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-3-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-3-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26].itemaProp, 'new-1');
+          assert.equal(stamped1[26].indexa, 2);
+          assert.equal(stamped1[27], undefined);
+          done();
+        });
+      });
+
+      test('undo: push (using splice)', function(done) {
+        unconfigured.splice('items', 3, 2);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-3-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-3-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('pop', function(done) {
+        removed = unconfigured.pop('items');
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[10].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[10].indexa, 0);
+          assert.equal(stamped1[10].indexb, 2);
+          assert.equal(stamped1[10].indexc, 0);
+          assert.equal(stamped1[11].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[11].indexa, 0);
+          assert.equal(stamped1[11].indexb, 2);
+          assert.equal(stamped1[11].indexc, 1);
+          assert.equal(stamped1[12].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[12].indexa, 0);
+          assert.equal(stamped1[12].indexb, 2);
+          assert.equal(stamped1[12].indexc, 2);
+          assert.equal(stamped1[13], undefined);
+          done();
+        });
+      });
+
+      test('undo: pop (using splice)', function(done) {
+        unconfigured.splice('items', 2, 0, removed);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-3-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-3-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('unshift', function(done) {
+        unconfigured.unshift('items', {prop: 'new-1'}, {prop: 'new-2'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 1 + 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'new-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itemaProp, 'prop-1');
+          assert.equal(stamped1[1].indexa, 1);
+          assert.equal(stamped1[2].itembProp, 'prop-1-1');
+          assert.equal(stamped1[2].indexa, 1);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[3].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[3].indexa, 1);
+          assert.equal(stamped1[3].indexb, 0);
+          assert.equal(stamped1[3].indexc, 0);
+          done();
+        });
+      });
+
+      test('undo: unshift (using splice)', function(done) {
+        unconfigured.splice('items', 0, 2);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-3-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-3-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('shift', function(done) {
+        removed = unconfigured.shift('items');
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[10].itemcProp, 'prop-3-3-1');
+          assert.equal(stamped1[10].indexa, 0);
+          assert.equal(stamped1[10].indexb, 2);
+          assert.equal(stamped1[10].indexc, 0);
+          assert.equal(stamped1[11].itemcProp, 'prop-3-3-2');
+          assert.equal(stamped1[11].indexa, 0);
+          assert.equal(stamped1[11].indexb, 2);
+          assert.equal(stamped1[11].indexc, 1);
+          assert.equal(stamped1[12].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped1[12].indexa, 0);
+          assert.equal(stamped1[12].indexb, 2);
+          assert.equal(stamped1[12].indexc, 2);
+          assert.equal(stamped1[13], undefined);
+          done();
+        });
+      });
+
+      test('undo: shift (using splice)', function(done) {
+        unconfigured.splice('items', 0, 0, removed);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-3-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-3-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('splice - remove from middle', function(done) {
+        removed = unconfigured.splice('items', 1, 1)[0];
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-3-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-3-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('undo: splice - remove from middle (using splice)', function(done) {
+        unconfigured.splice('items', 1, 0, removed);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-3-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-3-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('splice - add to middle', function(done) {
+        unconfigured.splice('items', 1, 0, {prop: 'new-1'}, {prop: 'new-2'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 1 + 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[13].itemaProp, 'new-1');
+          assert.equal(stamped1[13].indexa, 1);
+          assert.equal(stamped1[14].itemaProp, 'prop-3');
+          assert.equal(stamped1[14].indexa, 2);
+          assert.equal(stamped1[15].itembProp, 'prop-3-1');
+          assert.equal(stamped1[15].indexa, 2);
+          assert.equal(stamped1[15].indexb, 0);
+          assert.equal(stamped1[16].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[16].indexa, 2);
+          assert.equal(stamped1[16].indexb, 0);
+          assert.equal(stamped1[16].indexc, 0);
+          done();
+        });
+      });
+
+      test('undo: splice - add to middle (using splice)', function(done) {
+        unconfigured.splice('items', 1, 2);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-3-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-3-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('splice - replace in middle', function(done) {
+        removed = unconfigured.splice('items', 1, 2, {prop: 'new-1'}, {prop: 'new-2'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 1 + 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[13].itemaProp, 'new-1');
+          assert.equal(stamped1[14], undefined);
+          done();
+        });
+      });
+
+      test('undo: splice - replace in middle (using splice)', function(done) {
+        unconfigured.splice('items', 1, 2, removed[0], removed[1]);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-3-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-3-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+    });
+
+    suite('reacting to changes, view sort', function() {
+
+      var removed, a, m, z;
+
+      test('push', function(done) {
+        unconfigured1.$.repeater.filter = null;
+        unconfigured1.$.repeater.sort = function(a, b) {
+          return b.prop == a.prop ? 0 : b.prop < a.prop ? -1 : 1;
+        };
+        unconfigured.push('items', a={prop: 'a'}, m={prop: 'prop-1*'}, z={prop: 'z'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'z');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itemaProp, 'prop-3');
+          assert.equal(stamped1[1].indexa, 1);
+          assert.equal(stamped1[2].itembProp, 'prop-3-1');
+          assert.equal(stamped1[2].indexa, 1);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[3].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[3].indexa, 1);
+          assert.equal(stamped1[3].indexb, 0);
+          assert.equal(stamped1[3].indexc, 0);
+          assert.equal(stamped1[27].itemaProp, 'prop-1*');
+          assert.equal(stamped1[27].indexa, 3);
+          assert.equal(stamped1[40].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[40].indexa, 4);
+          assert.equal(stamped1[40].indexb, 2);
+          assert.equal(stamped1[40].indexc, 2);
+          assert.equal(stamped1[41].itemaProp, 'a');
+          assert.equal(stamped1[41].indexa, 5);
+          done();
+        });
+      });
+
+      //BREAKME(kschaar): this used to use arrayDelete; removing that from
+      // dom-bind since it's a wierdo Polymer API and dom-bind is raw
+      test('undo: push (using splice)', function(done) {
+        arrayDelete(unconfigured, 'items',  a);
+        arrayDelete(unconfigured, 'items',  m);
+        arrayDelete(unconfigured, 'items',  z);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[36].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[36].indexa, 2);
+          assert.equal(stamped1[36].indexb, 2);
+          assert.equal(stamped1[36].indexc, 0);
+          assert.equal(stamped1[37].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[37].indexa, 2);
+          assert.equal(stamped1[37].indexb, 2);
+          assert.equal(stamped1[37].indexc, 1);
+          assert.equal(stamped1[38].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[38].indexa, 2);
+          assert.equal(stamped1[38].indexb, 2);
+          assert.equal(stamped1[38].indexc, 2);
+          assert.equal(stamped1[39], undefined);
+          done();
+        });
+      });
+
+      test('pop', function(done) {
+        removed = unconfigured.pop('items');
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[25].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('undo: pop (using splice)', function(done) {
+        unconfigured.splice('items', 2, 0, removed);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[36].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[36].indexa, 2);
+          assert.equal(stamped1[36].indexb, 2);
+          assert.equal(stamped1[36].indexc, 0);
+          assert.equal(stamped1[37].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[37].indexa, 2);
+          assert.equal(stamped1[37].indexb, 2);
+          assert.equal(stamped1[37].indexc, 1);
+          assert.equal(stamped1[38].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[38].indexa, 2);
+          assert.equal(stamped1[38].indexb, 2);
+          assert.equal(stamped1[38].indexc, 2);
+          assert.equal(stamped1[39], undefined);
+          done();
+        });
+      });
+
+      test('unshift', function(done) {
+        unconfigured.unshift('items', a={prop: 'a'}, m={prop: 'prop-1*'}, z={prop: 'z'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'z');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itemaProp, 'prop-3');
+          assert.equal(stamped1[1].indexa, 1);
+          assert.equal(stamped1[2].itembProp, 'prop-3-1');
+          assert.equal(stamped1[2].indexa, 1);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[3].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[3].indexa, 1);
+          assert.equal(stamped1[3].indexb, 0);
+          assert.equal(stamped1[3].indexc, 0);
+          assert.equal(stamped1[27].itemaProp, 'prop-1*');
+          assert.equal(stamped1[27].indexa, 3);
+          assert.equal(stamped1[40].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[40].indexa, 4);
+          assert.equal(stamped1[40].indexb, 2);
+          assert.equal(stamped1[40].indexc, 2);
+          assert.equal(stamped1[41].itemaProp, 'a');
+          assert.equal(stamped1[41].indexa, 5);
+          done();
+        });
+      });
+
+      test('undo: unshift (using arrayDelete)', function(done) {
+        arrayDelete(unconfigured, 'items',  a);
+        arrayDelete(unconfigured, 'items',  m);
+        arrayDelete(unconfigured, 'items',  z);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[36].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[36].indexa, 2);
+          assert.equal(stamped1[36].indexb, 2);
+          assert.equal(stamped1[36].indexc, 0);
+          assert.equal(stamped1[37].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[37].indexa, 2);
+          assert.equal(stamped1[37].indexb, 2);
+          assert.equal(stamped1[37].indexc, 1);
+          assert.equal(stamped1[38].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[38].indexa, 2);
+          assert.equal(stamped1[38].indexb, 2);
+          assert.equal(stamped1[38].indexc, 2);
+          assert.equal(stamped1[39], undefined);
+          done();
+        });
+      });
+
+      test('shift', function(done) {
+        removed = unconfigured.shift('items');
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-2-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-2-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-2-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('undo: shift (using splice)', function(done) {
+        unconfigured.splice('items', 0, 0, removed);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[36].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[36].indexa, 2);
+          assert.equal(stamped1[36].indexb, 2);
+          assert.equal(stamped1[36].indexc, 0);
+          assert.equal(stamped1[37].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[37].indexa, 2);
+          assert.equal(stamped1[37].indexb, 2);
+          assert.equal(stamped1[37].indexc, 1);
+          assert.equal(stamped1[38].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[38].indexa, 2);
+          assert.equal(stamped1[38].indexb, 2);
+          assert.equal(stamped1[38].indexc, 2);
+          assert.equal(stamped1[39], undefined);
+          done();
+        });
+      });
+
+      test('splice - remove from middle', function(done) {
+        removed = unconfigured.splice('items', 1, 1)[0];
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[13].itemaProp, 'prop-1');
+          assert.equal(stamped1[13].indexa, 1);
+          assert.equal(stamped1[14].itembProp, 'prop-1-1');
+          assert.equal(stamped1[14].indexa, 1);
+          assert.equal(stamped1[14].indexb, 0);
+          assert.equal(stamped1[15].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[15].indexa, 1);
+          assert.equal(stamped1[15].indexb, 0);
+          assert.equal(stamped1[15].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('undo: splice - remove from middle (using splice)', function(done) {
+        unconfigured.splice('items', 1, 0, removed);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[13].itemaProp, 'prop-2');
+          assert.equal(stamped1[13].indexa, 1);
+          assert.equal(stamped1[14].itembProp, 'prop-2-1');
+          assert.equal(stamped1[14].indexa, 1);
+          assert.equal(stamped1[14].indexb, 0);
+          assert.equal(stamped1[15].itemcProp, 'prop-2-1-1');
+          assert.equal(stamped1[15].indexa, 1);
+          assert.equal(stamped1[15].indexb, 0);
+          assert.equal(stamped1[15].indexc, 0);
+          assert.equal(stamped1[36].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[36].indexa, 2);
+          assert.equal(stamped1[36].indexb, 2);
+          assert.equal(stamped1[36].indexc, 0);
+          assert.equal(stamped1[37].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[37].indexa, 2);
+          assert.equal(stamped1[37].indexb, 2);
+          assert.equal(stamped1[37].indexc, 1);
+          assert.equal(stamped1[38].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[38].indexa, 2);
+          assert.equal(stamped1[38].indexb, 2);
+          assert.equal(stamped1[38].indexc, 2);
+          done();
+        });
+      });
+
+      test('splice - add to middle', function(done) {
+        unconfigured.splice('items', 1, 0, a={prop: 'a'}, m={prop: 'prop-1*'}, z={prop: 'z'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'z');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itemaProp, 'prop-3');
+          assert.equal(stamped1[1].indexa, 1);
+          assert.equal(stamped1[2].itembProp, 'prop-3-1');
+          assert.equal(stamped1[2].indexa, 1);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[3].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[3].indexa, 1);
+          assert.equal(stamped1[3].indexb, 0);
+          assert.equal(stamped1[3].indexc, 0);
+          assert.equal(stamped1[27].itemaProp, 'prop-1*');
+          assert.equal(stamped1[27].indexa, 3);
+          assert.equal(stamped1[40].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[40].indexa, 4);
+          assert.equal(stamped1[40].indexb, 2);
+          assert.equal(stamped1[40].indexc, 2);
+          assert.equal(stamped1[41].itemaProp, 'a');
+          assert.equal(stamped1[41].indexa, 5);
+          done();
+        });
+      });
+
+      test('undo: splice - add to middle (using arrayDelete)', function(done) {
+        arrayDelete(unconfigured, 'items',  a);
+        arrayDelete(unconfigured, 'items',  m);
+        arrayDelete(unconfigured, 'items',  z);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[36].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[36].indexa, 2);
+          assert.equal(stamped1[36].indexb, 2);
+          assert.equal(stamped1[36].indexc, 0);
+          assert.equal(stamped1[37].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[37].indexa, 2);
+          assert.equal(stamped1[37].indexb, 2);
+          assert.equal(stamped1[37].indexc, 1);
+          assert.equal(stamped1[38].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[38].indexa, 2);
+          assert.equal(stamped1[38].indexb, 2);
+          assert.equal(stamped1[38].indexc, 2);
+          assert.equal(stamped1[39], undefined);
+          done();
+        });
+      });
+
+      test('splice - replace in middle', function(done) {
+        removed = unconfigured.splice('items', 1, 2, a={prop: 'a'}, m={prop: 'prop-1*'}, z={prop: 'z'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'z');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itemaProp, 'prop-1*');
+          assert.equal(stamped1[1].indexa, 1);
+          assert.equal(stamped1[2].itemaProp, 'prop-1');
+          assert.equal(stamped1[2].indexa, 2);
+          assert.equal(stamped1[3].itembProp, 'prop-1-1');
+          assert.equal(stamped1[3].indexa, 2);
+          assert.equal(stamped1[3].indexb, 0);
+          assert.equal(stamped1[4].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[4].indexa, 2);
+          assert.equal(stamped1[4].indexb, 0);
+          assert.equal(stamped1[4].indexc, 0);
+          assert.equal(stamped1[15].itemaProp, 'a');
+          assert.equal(stamped1[15].indexa, 3);
+          assert.equal(stamped1[16], undefined);
+          done();
+        });
+      });
+
+      test('undo: splice - replace in middle (using splice)', function(done) {
+        arrayDelete(unconfigured, 'items',  a);
+        arrayDelete(unconfigured, 'items',  m);
+        arrayDelete(unconfigured, 'items',  z);
+        unconfigured.splice('items', 1, 2, removed[0], removed[1]);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[36].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[36].indexa, 2);
+          assert.equal(stamped1[36].indexb, 2);
+          assert.equal(stamped1[36].indexc, 0);
+          assert.equal(stamped1[37].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[37].indexa, 2);
+          assert.equal(stamped1[37].indexb, 2);
+          assert.equal(stamped1[37].indexc, 1);
+          assert.equal(stamped1[38].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[38].indexa, 2);
+          assert.equal(stamped1[38].indexb, 2);
+          assert.equal(stamped1[38].indexc, 2);
+          assert.equal(stamped1[39], undefined);
+          done();
+        });
+      });
+
+    });
+
+    suite('reacting to changes, view sort with filter', function() {
+
+      var removed, a, m, z;
+
+      suiteSetup(function() {
+        unconfigured1.$.repeater.sort = function(a, b) {
+          return b.prop == a.prop ? 0 : b.prop < a.prop ? -1 : 1;
+        };
+        unconfigured1.$.repeater.filter = function(o) {
+          return o.prop.indexOf('2') < 0;
+        };
+        unconfigured1.$.repeater.render();
+        CustomElements.takeRecords();
+        CustomElements.takeRecords();
+      });
+
+      suiteTeardown(function() {
+        unconfigured1.$.repeater.sort = null;
+        unconfigured1.$.repeater.filter = null;
+        unconfigured1.$.repeater.render();
+        CustomElements.takeRecords();
+        CustomElements.takeRecords();
+      });
+
+      test('push', function(done) {
+        unconfigured.push('items', a={prop: 'a'}, m={prop: 'item*2'}, z={prop: 'z'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'z');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itemaProp, 'prop-3');
+          assert.equal(stamped1[1].indexa, 1);
+          assert.equal(stamped1[2].itembProp, 'prop-3-1');
+          assert.equal(stamped1[2].indexa, 1);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[3].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[3].indexa, 1);
+          assert.equal(stamped1[3].indexb, 0);
+          assert.equal(stamped1[3].indexc, 0);
+          assert.equal(stamped1[26].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[26].indexa, 2);
+          assert.equal(stamped1[26].indexb, 2);
+          assert.equal(stamped1[26].indexc, 2);
+          assert.equal(stamped1[27].itemaProp, 'a');
+          assert.equal(stamped1[27].indexa, 3);
+          assert.equal(stamped1[28], undefined);
+          done();
+        });
+      });
+
+      test('undo: push (using arrayDelete)', function(done) {
+        arrayDelete(unconfigured, 'items',  a);
+        arrayDelete(unconfigured, 'items',  m);
+        arrayDelete(unconfigured, 'items',  z);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('pop', function(done) {
+        removed = unconfigured.pop('items');
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-1');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-1-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[12].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[12].indexa, 0);
+          assert.equal(stamped1[12].indexb, 2);
+          assert.equal(stamped1[12].indexc, 2);
+          assert.equal(stamped1[13], undefined);
+          done();
+        });
+      });
+
+      test('undo: pop (using splice)', function(done) {
+        unconfigured.splice('items', 2, 0, removed);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('unshift', function(done) {
+        unconfigured.unshift('items', a={prop: 'a'}, m={prop: 'item*2'}, z={prop: 'z'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'z');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itemaProp, 'prop-3');
+          assert.equal(stamped1[1].indexa, 1);
+          assert.equal(stamped1[2].itembProp, 'prop-3-1');
+          assert.equal(stamped1[2].indexa, 1);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[3].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[3].indexa, 1);
+          assert.equal(stamped1[3].indexb, 0);
+          assert.equal(stamped1[3].indexc, 0);
+          assert.equal(stamped1[26].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[26].indexa, 2);
+          assert.equal(stamped1[26].indexb, 2);
+          assert.equal(stamped1[26].indexc, 2);
+          assert.equal(stamped1[27].itemaProp, 'a');
+          assert.equal(stamped1[27].indexa, 3);
+          assert.equal(stamped1[28], undefined);
+          done();
+        });
+      });
+
+      test('undo: unshift (using splice)', function(done) {
+        unconfigured.splice('items', 0, 3);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('shift', function(done) {
+        removed = unconfigured.shift('items');
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[12].itemcProp, 'prop-3-3-3');
+          assert.equal(stamped1[12].indexa, 0);
+          assert.equal(stamped1[12].indexb, 2);
+          assert.equal(stamped1[12].indexc, 2);
+          assert.equal(stamped1[13], undefined);
+          done();
+        });
+      });
+
+      test('undo: shift (using splice)', function(done) {
+        unconfigured.splice('items', 0, 0, removed);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('splice - remove from middle', function(done) {
+        removed = unconfigured.splice('items', 1, 1)[0];
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[13].itemaProp, 'prop-1');
+          assert.equal(stamped1[13].indexa, 1);
+          assert.equal(stamped1[14].itembProp, 'prop-1-1');
+          assert.equal(stamped1[14].indexa, 1);
+          assert.equal(stamped1[14].indexb, 0);
+          assert.equal(stamped1[15].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[15].indexa, 1);
+          assert.equal(stamped1[15].indexb, 0);
+          assert.equal(stamped1[15].indexc, 0);
+          done();
+        });
+      });
+
+      test('undo: splice - remove from middle (using splice)', function(done) {
+        unconfigured.splice('items', 1, 0, removed);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('splice - add to middle', function(done) {
+        unconfigured.splice('items', 1, 0, a={prop: 'a'}, m={prop: 'item*2'}, z={prop: 'z'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'z');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itemaProp, 'prop-3');
+          assert.equal(stamped1[1].indexa, 1);
+          assert.equal(stamped1[2].itembProp, 'prop-3-1');
+          assert.equal(stamped1[2].indexa, 1);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[3].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[3].indexa, 1);
+          assert.equal(stamped1[3].indexb, 0);
+          assert.equal(stamped1[3].indexc, 0);
+          assert.equal(stamped1[26].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[26].indexa, 2);
+          assert.equal(stamped1[26].indexb, 2);
+          assert.equal(stamped1[26].indexc, 2);
+          assert.equal(stamped1[27].itemaProp, 'a');
+          assert.equal(stamped1[27].indexa, 3);
+          assert.equal(stamped1[28], undefined);
+          done();
+        });
+      });
+
+      test('undo: splice - add to middle (using splice)', function(done) {
+        unconfigured.splice('items', 1, 3);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
+      });
+
+      test('splice - replace in middle', function(done) {
+        removed = unconfigured.splice('items', 1, 2, a={prop: 'a'}, m={prop: 'item*2'}, z={prop: 'z'});
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'z');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itemaProp, 'prop-1');
+          assert.equal(stamped1[1].indexa, 1);
+          assert.equal(stamped1[2].itembProp, 'prop-1-1');
+          assert.equal(stamped1[2].indexa, 1);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[3].itemcProp, 'prop-1-1-1');
+          assert.equal(stamped1[3].indexa, 1);
+          assert.equal(stamped1[3].indexb, 0);
+          assert.equal(stamped1[3].indexc, 0);
+          assert.equal(stamped1[13].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[13].indexa, 1);
+          assert.equal(stamped1[13].indexb, 2);
+          assert.equal(stamped1[13].indexc, 2);
+          assert.equal(stamped1[14].itemaProp, 'a');
+          assert.equal(stamped1[14].indexa, 2);
+          assert.equal(stamped1[15], undefined);
+          done();
+        });
+      });
 
-        stamped1[1].$.bar.inneraProp = 'bar';
+      test('undo: splice - replace in middle (using splice)', function(done) {
+        unconfigured.splice('items', 1, 3, removed[0], removed[1]);
+        setTimeout(function() {
+          var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
+          assert.equal(stamped1[0].itemaProp, 'prop-3');
+          assert.equal(stamped1[0].indexa, 0);
+          assert.equal(stamped1[1].itembProp, 'prop-3-1');
+          assert.equal(stamped1[1].indexa, 0);
+          assert.equal(stamped1[1].indexb, 0);
+          assert.equal(stamped1[2].itemcProp, 'prop-3-1-1');
+          assert.equal(stamped1[2].indexa, 0);
+          assert.equal(stamped1[2].indexb, 0);
+          assert.equal(stamped1[2].indexc, 0);
+          assert.equal(stamped1[23].itemcProp, 'prop-1-3-1');
+          assert.equal(stamped1[23].indexa, 1);
+          assert.equal(stamped1[23].indexb, 2);
+          assert.equal(stamped1[23].indexc, 0);
+          assert.equal(stamped1[24].itemcProp, 'prop-1-3-2');
+          assert.equal(stamped1[24].indexa, 1);
+          assert.equal(stamped1[24].indexb, 2);
+          assert.equal(stamped1[24].indexc, 1);
+          assert.equal(stamped1[25].itemcProp, 'prop-1-3-3');
+          assert.equal(stamped1[25].indexa, 1);
+          assert.equal(stamped1[25].indexb, 2);
+          assert.equal(stamped1[25].indexc, 2);
+          assert.equal(stamped1[26], undefined);
+          done();
+        });
       });
 
     });
 
-    suite('reacting to changes, array sort', function() {
+    suite('reacting to changes, array sort (direct mutation)', function() {
 
       var removed;
 
       test('push', function(done) {
         unconfigured1.domUpdateHandlerCount = 0;
-        unconfigured.push('items', {prop: 'new-1'}, {prop: 'new-2'});
+        unconfigured.items.push({prop: 'new-1'}, {prop: 'new-2'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
@@ -857,7 +2631,8 @@ <h4>x-repeat-chunked</h4>
 
       test('undo: push (using splice)', function(done) {
         unconfigured1.domUpdateHandlerCount = 0;
-        unconfigured.splice('items', 3, 2);
+        unconfigured.items.splice(3, 2);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
@@ -879,7 +2654,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('pop', function(done) {
-        removed = unconfigured.pop('items');
+        removed = unconfigured.items.pop();
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
@@ -900,7 +2676,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: pop (using splice)', function(done) {
-        unconfigured.splice('items', 2, 0, removed);
+        unconfigured.items.splice(2, 0, removed);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
@@ -921,7 +2698,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('unshift', function(done) {
-        unconfigured.unshift('items', {prop: 'new-1'}, {prop: 'new-2'});
+        unconfigured.items.unshift({prop: 'new-1'}, {prop: 'new-2'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
@@ -944,7 +2722,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: unshift (using splice)', function(done) {
-        unconfigured.splice('items', 0, 2);
+        unconfigured.items.splice(0, 2);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
@@ -965,7 +2744,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('shift', function(done) {
-        removed = unconfigured.shift('items');
+        removed = unconfigured.items.shift();
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
@@ -994,7 +2774,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: shift (using splice)', function(done) {
-        unconfigured.splice('items', 0, 0, removed);
+        unconfigured.items.splice(0, 0, removed);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
@@ -1023,7 +2804,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('splice - remove from middle', function(done) {
-        removed = unconfigured.splice('items', 1, 1)[0];
+        removed = unconfigured.items.splice(1, 1)[0];
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
@@ -1070,7 +2852,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: splice - remove from middle (using splice)', function(done) {
-        unconfigured.splice('items', 1, 0, removed);
+        unconfigured.items.splice(1, 0, removed);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
@@ -1117,7 +2900,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('splice - add to middle', function(done) {
-        unconfigured.splice('items', 1, 0, {prop: 'new-1'}, {prop: 'new-2'});
+        unconfigured.items.splice(1, 0, {prop: 'new-1'}, {prop: 'new-2'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
@@ -1172,7 +2956,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: splice - add to middle (using splice)', function(done) {
-        unconfigured.splice('items', 1, 2);
+        unconfigured.items.splice(1, 2);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
@@ -1219,7 +3004,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('splice - replace in middle', function(done) {
-        removed = unconfigured.splice('items', 1, 2, {prop: 'new-1'}, {prop: 'new-2'});
+        removed = unconfigured.items.splice(1, 2, {prop: 'new-1'}, {prop: 'new-2'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
@@ -1258,7 +3044,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: splice - replace in middle (using splice)', function(done) {
-        unconfigured.splice('items', 1, 2, removed[0], removed[1]);
+        unconfigured.items.splice(1, 2, removed[0], removed[1]);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           var stamped2 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
@@ -1304,55 +3091,9 @@ <h4>x-repeat-chunked</h4>
         });
       });
 
-      test('large splice', function(done) {
-        primitiveLarge.splice('items', 0, 10);
-        setTimeout(function() {
-          var stamped =
-            primitiveLarge.root.querySelectorAll('*:not(template):not(dom-repeat)');
-          assert.equal(stamped.length, 1, 'total stamped count incorrect');
-          assert.equal(stamped[0].textContent, '10');
-          done();
-        });
-      });
-
-      test('css scoping retained when re-ordering', function(done) {
-        let simple = fixture('simple');
-        if (!Polymer.Settings.useShadow) {
-          // Confirm initial scoping
-          var stamped = simple.root.querySelectorAll('*:not(template):not(dom-repeat)');
-          assert.equal(stamped[0].itemaProp, 'prop-1');
-          assert(stamped[0].classList.contains('x-simple-repeat'), 'expected scoping');
-          assert.equal(stamped.length, 3, 'total stamped count incorrect');
-          var row = stamped[0];
-          // Move
-          removed = simple.splice('items', 0, 1);
-          simple.splice('items', 1, 0, removed[0]);
-          setTimeout(function() {
-            stamped = simple.root.querySelectorAll('*:not(template):not(dom-repeat)');
-            assert.equal(stamped.length, 3, 'total stamped count incorrect');
-            assert.equal(row, stamped[1]);
-            assert.equal(stamped[1].itemaProp, 'prop-1');
-            assert(stamped[1].classList.contains('x-simple-repeat'), 'expected scoping');
-            // Revert
-            removed = simple.splice('items', 1, 1);
-            simple.splice('items', 0, 0, removed[0]);
-            setTimeout(function() {
-              stamped = simple.root.querySelectorAll('*:not(template):not(dom-repeat)');
-              assert.equal(stamped.length, 3, 'total stamped count incorrect');
-              assert.equal(row, stamped[0]);
-              assert.equal(stamped[0].itemaProp, 'prop-1');
-              assert(stamped[0].classList.contains('x-simple-repeat'), 'expected scoping');
-              done();
-            });
-          });
-        } else {
-          done();
-        }
-      });
-
     });
 
-    suite('reacting to changes, array sort with filter', function() {
+    suite('reacting to changes, array sort with filter (direct mutation)', function() {
 
       var removed;
 
@@ -1360,7 +3101,8 @@ <h4>x-repeat-chunked</h4>
         unconfigured1.$.repeater.filter = function(o) {
           return o.prop.indexOf('2') < 0;
         };
-        unconfigured.push('items', {prop: 'new-1'}, {prop: 'new-2'});
+        unconfigured.items.push({prop: 'new-1'}, {prop: 'new-2'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 1 + 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -1393,7 +3135,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: push (using splice)', function(done) {
-        unconfigured.splice('items', 3, 2);
+        unconfigured.items.splice(3, 2);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -1424,7 +3167,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('pop', function(done) {
-        removed = unconfigured.pop('items');
+        removed = unconfigured.items.pop();
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
@@ -1455,7 +3199,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: pop (using splice)', function(done) {
-        unconfigured.splice('items', 2, 0, removed);
+        unconfigured.items.splice(2, 0, removed);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -1486,7 +3231,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('unshift', function(done) {
-        unconfigured.unshift('items', {prop: 'new-1'}, {prop: 'new-2'});
+        unconfigured.items.unshift({prop: 'new-1'}, {prop: 'new-2'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 1 + 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -1506,7 +3252,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: unshift (using splice)', function(done) {
-        unconfigured.splice('items', 0, 2);
+        unconfigured.items.splice(0, 2);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -1537,7 +3284,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('shift', function(done) {
-        removed = unconfigured.shift('items');
+        removed = unconfigured.items.shift();
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
@@ -1568,7 +3316,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: shift (using splice)', function(done) {
-        unconfigured.splice('items', 0, 0, removed);
+        unconfigured.items.splice(0, 0, removed);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -1599,7 +3348,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('splice - remove from middle', function(done) {
-        removed = unconfigured.splice('items', 1, 1)[0];
+        removed = unconfigured.items.splice(1, 1)[0];
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -1630,7 +3380,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: splice - remove from middle (using splice)', function(done) {
-        unconfigured.splice('items', 1, 0, removed);
+        unconfigured.items.splice(1, 0, removed);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -1661,7 +3412,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('splice - add to middle', function(done) {
-        unconfigured.splice('items', 1, 0, {prop: 'new-1'}, {prop: 'new-2'});
+        unconfigured.items.splice(1, 0, {prop: 'new-1'}, {prop: 'new-2'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 1 + 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -1690,7 +3442,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: splice - add to middle (using splice)', function(done) {
-        unconfigured.splice('items', 1, 2);
+        unconfigured.items.splice(1, 2);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -1721,7 +3474,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('splice - replace in middle', function(done) {
-        removed = unconfigured.splice('items', 1, 2, {prop: 'new-1'}, {prop: 'new-2'});
+        removed = unconfigured.items.splice(1, 2, {prop: 'new-1'}, {prop: 'new-2'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 1 + 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
@@ -1741,7 +3495,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: splice - replace in middle (using splice)', function(done) {
-        unconfigured.splice('items', 1, 2, removed[0], removed[1]);
+        unconfigured.items.splice(1, 2, removed[0], removed[1]);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -1773,7 +3528,7 @@ <h4>x-repeat-chunked</h4>
 
     });
 
-    suite('reacting to changes, view sort', function() {
+    suite('reacting to changes, view sort (direct mutation)', function() {
 
       var removed, a, m, z;
 
@@ -1782,7 +3537,8 @@ <h4>x-repeat-chunked</h4>
         unconfigured1.$.repeater.sort = function(a, b) {
           return b.prop == a.prop ? 0 : b.prop < a.prop ? -1 : 1;
         };
-        unconfigured.push('items', a={prop: 'a'}, m={prop: 'prop-1*'}, z={prop: 'z'});
+        unconfigured.items.push(a={prop: 'a'}, m={prop: 'prop-1*'}, z={prop: 'z'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 3 + 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
@@ -1812,9 +3568,10 @@ <h4>x-repeat-chunked</h4>
       //BREAKME(kschaar): this used to use arrayDelete; removing that from
       // dom-bind since it's a wierdo Polymer API and dom-bind is raw
       test('undo: push (using splice)', function(done) {
-        arrayDelete(unconfigured, 'items',  a);
-        arrayDelete(unconfigured, 'items',  m);
-        arrayDelete(unconfigured, 'items',  z);
+        arrayDeleteDirect(unconfigured.items, a);
+        arrayDeleteDirect(unconfigured.items, m);
+        arrayDeleteDirect(unconfigured.items, z);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
@@ -1845,7 +3602,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('pop', function(done) {
-        removed = unconfigured.pop('items');
+        removed = unconfigured.items.pop();
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -1859,7 +3617,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: pop (using splice)', function(done) {
-        unconfigured.splice('items', 2, 0, removed);
+        unconfigured.items.splice(2, 0, removed);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
@@ -1890,7 +3649,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('unshift', function(done) {
-        unconfigured.unshift('items', a={prop: 'a'}, m={prop: 'prop-1*'}, z={prop: 'z'});
+        unconfigured.items.unshift(a={prop: 'a'}, m={prop: 'prop-1*'}, z={prop: 'z'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 3 + 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
@@ -1918,9 +3678,10 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: unshift (using arrayDelete)', function(done) {
-        arrayDelete(unconfigured, 'items',  a);
-        arrayDelete(unconfigured, 'items',  m);
-        arrayDelete(unconfigured, 'items',  z);
+        arrayDeleteDirect(unconfigured.items, a);
+        arrayDeleteDirect(unconfigured.items, m);
+        arrayDeleteDirect(unconfigured.items, z);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
@@ -1951,7 +3712,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('shift', function(done) {
-        removed = unconfigured.shift('items');
+        removed = unconfigured.items.shift();
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -1982,7 +3744,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: shift (using splice)', function(done) {
-        unconfigured.splice('items', 0, 0, removed);
+        unconfigured.items.splice(0, 0, removed);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
@@ -2013,7 +3776,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('splice - remove from middle', function(done) {
-        removed = unconfigured.splice('items', 1, 1)[0];
+        removed = unconfigured.items.splice(1, 1)[0];
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -2053,7 +3817,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: splice - remove from middle (using splice)', function(done) {
-        unconfigured.splice('items', 1, 0, removed);
+        unconfigured.items.splice(1, 0, removed);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
@@ -2092,7 +3857,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('splice - add to middle', function(done) {
-        unconfigured.splice('items', 1, 0, a={prop: 'a'}, m={prop: 'prop-1*'}, z={prop: 'z'});
+        unconfigured.items.splice(1, 0, a={prop: 'a'}, m={prop: 'prop-1*'}, z={prop: 'z'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 3 + 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
@@ -2120,9 +3886,10 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: splice - add to middle (using arrayDelete)', function(done) {
-        arrayDelete(unconfigured, 'items',  a);
-        arrayDelete(unconfigured, 'items',  m);
-        arrayDelete(unconfigured, 'items',  z);
+        arrayDeleteDirect(unconfigured.items, a);
+        arrayDeleteDirect(unconfigured.items, m);
+        arrayDeleteDirect(unconfigured.items, z);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
@@ -2153,7 +3920,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('splice - replace in middle', function(done) {
-        removed = unconfigured.splice('items', 1, 2, a={prop: 'a'}, m={prop: 'prop-1*'}, z={prop: 'z'});
+        removed = unconfigured.items.splice(1, 2, a={prop: 'a'}, m={prop: 'prop-1*'}, z={prop: 'z'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 3 + 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
@@ -2178,10 +3946,11 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: splice - replace in middle (using splice)', function(done) {
-        arrayDelete(unconfigured, 'items',  a);
-        arrayDelete(unconfigured, 'items',  m);
-        arrayDelete(unconfigured, 'items',  z);
-        unconfigured.splice('items', 1, 2, removed[0], removed[1]);
+        arrayDeleteDirect(unconfigured.items, a);
+        arrayDeleteDirect(unconfigured.items, m);
+        arrayDeleteDirect(unconfigured.items, z);
+        unconfigured.items.splice(1, 2, removed[0], removed[1]);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 3 + 3*3 + 3*3*3, 'total stamped count incorrect');
@@ -2213,7 +3982,7 @@ <h4>x-repeat-chunked</h4>
 
     });
 
-    suite('reacting to changes, view sort with filter', function() {
+    suite('reacting to changes, view sort with filter (direct mutation)', function() {
 
       var removed, a, m, z;
 
@@ -2238,7 +4007,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('push', function(done) {
-        unconfigured.push('items', a={prop: 'a'}, m={prop: 'item*2'}, z={prop: 'z'});
+        unconfigured.items.push(a={prop: 'a'}, m={prop: 'item*2'}, z={prop: 'z'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -2265,9 +4035,10 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: push (using arrayDelete)', function(done) {
-        arrayDelete(unconfigured, 'items',  a);
-        arrayDelete(unconfigured, 'items',  m);
-        arrayDelete(unconfigured, 'items',  z);
+        arrayDeleteDirect(unconfigured.items, a);
+        arrayDeleteDirect(unconfigured.items, m);
+        arrayDeleteDirect(unconfigured.items, z);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -2298,7 +4069,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('pop', function(done) {
-        removed = unconfigured.pop('items');
+        removed = unconfigured.items.pop();
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
@@ -2321,7 +4093,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: pop (using splice)', function(done) {
-        unconfigured.splice('items', 2, 0, removed);
+        unconfigured.items.splice(2, 0, removed);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -2352,7 +4125,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('unshift', function(done) {
-        unconfigured.unshift('items', a={prop: 'a'}, m={prop: 'item*2'}, z={prop: 'z'});
+        unconfigured.items.unshift(a={prop: 'a'}, m={prop: 'item*2'}, z={prop: 'z'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -2379,7 +4153,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: unshift (using splice)', function(done) {
-        unconfigured.splice('items', 0, 3);
+        unconfigured.items.splice(0, 3);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -2410,7 +4185,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('shift', function(done) {
-        removed = unconfigured.shift('items');
+        removed = unconfigured.items.shift();
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
@@ -2433,7 +4209,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: shift (using splice)', function(done) {
-        unconfigured.splice('items', 0, 0, removed);
+        unconfigured.items.splice(0, 0, removed);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -2464,7 +4241,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('splice - remove from middle', function(done) {
-        removed = unconfigured.splice('items', 1, 1)[0];
+        removed = unconfigured.items.splice(1, 1)[0];
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -2491,7 +4269,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: splice - remove from middle (using splice)', function(done) {
-        unconfigured.splice('items', 1, 0, removed);
+        unconfigured.items.splice(1, 0, removed);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -2522,7 +4301,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('splice - add to middle', function(done) {
-        unconfigured.splice('items', 1, 0, a={prop: 'a'}, m={prop: 'item*2'}, z={prop: 'z'});
+        unconfigured.items.splice(1, 0, a={prop: 'a'}, m={prop: 'item*2'}, z={prop: 'z'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -2549,7 +4329,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: splice - add to middle (using splice)', function(done) {
-        unconfigured.splice('items', 1, 3);
+        unconfigured.items.splice(1, 3);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -2580,7 +4361,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('splice - replace in middle', function(done) {
-        removed = unconfigured.splice('items', 1, 2, a={prop: 'a'}, m={prop: 'item*2'}, z={prop: 'z'});
+        removed = unconfigured.items.splice(1, 2, a={prop: 'a'}, m={prop: 'item*2'}, z={prop: 'z'});
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 1 + 1*3 + 1*3*3, 'total stamped count incorrect');
@@ -2607,7 +4389,8 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('undo: splice - replace in middle (using splice)', function(done) {
-        unconfigured.splice('items', 1, 3, removed[0], removed[1]);
+        unconfigured.items.splice(1, 3, removed[0], removed[1]);
+        unconfigured.items = unconfigured.items;
         setTimeout(function() {
           var stamped1 = unconfigured1.root.querySelectorAll('*:not(template):not(dom-repeat)');
           assert.equal(stamped1.length, 2 + 2*3 + 2*3*3, 'total stamped count incorrect');
@@ -3899,6 +5682,55 @@ <h4>x-repeat-chunked</h4>
 
     }
 
+    suite('misc', function() {
+
+      test('large splice', function(done) {
+        primitiveLarge.splice('items', 0, 10);
+        setTimeout(function() {
+          var stamped =
+            primitiveLarge.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped.length, 1, 'total stamped count incorrect');
+          assert.equal(stamped[0].textContent, '10');
+          done();
+        });
+      });
+
+      test('css scoping retained when re-ordering', function(done) {
+        if (!Polymer.Settings.useShadow) {
+          // Confirm initial scoping
+          var stamped = simple.root.querySelectorAll('*:not(template):not(dom-repeat)');
+          assert.equal(stamped[0].itemaProp, 'prop-1');
+          assert(stamped[0].classList.contains('x-simple-repeat'), 'expected scoping');
+          assert.equal(stamped.length, 3, 'total stamped count incorrect');
+          var row = stamped[0];
+          // Move
+          removed = simple.splice('items', 0, 1);
+          simple.splice('items', 1, 0, removed[0]);
+          setTimeout(function() {
+            stamped = simple.root.querySelectorAll('*:not(template):not(dom-repeat)');
+            assert.equal(stamped.length, 3, 'total stamped count incorrect');
+            assert.equal(row, stamped[1]);
+            assert.equal(stamped[1].itemaProp, 'prop-1');
+            assert(stamped[1].classList.contains('x-simple-repeat'), 'expected scoping');
+            // Revert
+            removed = simple.splice('items', 1, 1);
+            simple.splice('items', 0, 0, removed[0]);
+            setTimeout(function() {
+              stamped = simple.root.querySelectorAll('*:not(template):not(dom-repeat)');
+              assert.equal(stamped.length, 3, 'total stamped count incorrect');
+              assert.equal(row, stamped[0]);
+              assert.equal(stamped[0].itemaProp, 'prop-1');
+              assert(stamped[0].classList.contains('x-simple-repeat'), 'expected scoping');
+              done();
+            });
+          });
+        } else {
+          done();
+        }
+      });
+
+    });
+
   })();
   </script>
 

From 81e83ffbd217ec9d1798380abc13c34fd175db23 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Mon, 19 Sep 2016 19:41:01 -0700
Subject: [PATCH 04/20] Revert inadvertent change to connected flush.

---
 src/elements/element.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/elements/element.html b/src/elements/element.html
index 80924b356a..bb011eb6b8 100644
--- a/src/elements/element.html
+++ b/src/elements/element.html
@@ -179,7 +179,7 @@
       // reserved for canonical behavior
       connectedCallback() {
         if (hostStack.isEmpty()) {
-          this._flushProperties(true);
+          this._flushProperties();
           this.updateStyles();
         }
       }

From bca75796ef18452a064541c8154a00b2285541bd Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Mon, 19 Sep 2016 19:41:43 -0700
Subject: [PATCH 05/20] Re-enable full test suite.

---
 test/runner.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/runner.html b/test/runner.html
index 97574a9f2a..be2361e149 100644
--- a/test/runner.html
+++ b/test/runner.html
@@ -76,7 +76,7 @@
       shady.push('wc-shadydom=true');
     }
 
-    // suites = combinations(suites, [ce, shady]);
+    suites = combinations(suites, [ce, shady]);
     console.log('Testing suites:\n\t' + suites.join('\n\t'));
 
     WCT.loadSuites(suites);

From 85f20b7849195a03ae3119b52e55936ecba932c9 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Mon, 19 Sep 2016 19:44:04 -0700
Subject: [PATCH 06/20] Remove collection.html

---
 src/templatizer/collection.html | 189 --------------------------------
 src/utils/path.html             |   1 -
 2 files changed, 190 deletions(-)
 delete mode 100644 src/templatizer/collection.html

diff --git a/src/templatizer/collection.html b/src/templatizer/collection.html
deleted file mode 100644
index a4bd6130f4..0000000000
--- a/src/templatizer/collection.html
+++ /dev/null
@@ -1,189 +0,0 @@
-<!--
-@license
-Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
-This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
-The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
-The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
-Code distributed by Google as part of the polymer project is also
-subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
--->
-
-<script>
-(function() {
-  'use strict';
-
-  class Collection {
-
-    static from(userArray) {
-      return this._collections.get(userArray) ||
-        new Collection(userArray);
-    }
-
-    static applySplices(userArray, splices) {
-      // Only apply splices & generate keySplices if the array already has a
-      // backing Collection, meaning there is an element monitoring its keys;
-      // Splices that happen before the collection has been created must be
-      // discarded to avoid double-entries
-      var coll = this._collections.get(userArray);
-      return coll ? coll._applySplices(splices) : null;
-    }
-
-    constructor(userArray) {
-      Collection._collections.set(userArray, this);
-      this.userArray = userArray;
-      this.store = userArray.slice();
-      this.initMap();
-    }
-
-    initMap() {
-      var omap = this.omap = new WeakMap();
-      var pmap = this.pmap = {};
-      var s = this.store;
-      for (var i=0; i<s.length; i++) {
-        var item = s[i];
-        if (item && typeof item == 'object') {
-          omap.set(item, i);
-        } else {
-          pmap[item] = i;
-        }
-      }
-    }
-
-    add(item) {
-      var key = this.store.push(item) - 1;
-      if (item && typeof item == 'object') {
-        this.omap.set(item, key);
-      } else {
-        this.pmap[item] = key;
-      }
-      return '#' + key;
-    }
-
-    removeKey(key) {
-      if ((key = this._parseKey(key))) {
-        this._removeFromMap(this.store[key]);
-        delete this.store[key];
-      }
-    }
-
-    _removeFromMap(item) {
-      if (item && typeof item == 'object') {
-        this.omap.delete(item);
-      } else {
-        delete this.pmap[item];
-      }
-    }
-
-    remove(item) {
-      var key = this.getKey(item);
-      this.removeKey(key);
-      return key;
-    }
-
-    getKey(item) {
-      var key;
-      if (item && typeof item == 'object') {
-        key = this.omap.get(item);
-      } else {
-        key = this.pmap[item];
-      }
-      if (key != undefined) {
-        return '#' + key;
-      }
-    }
-
-    getKeys() {
-      return Object.keys(this.store).map(function(key) {
-        return '#' + key;
-      });
-    }
-
-    _parseKey(key) {
-      if (key && key[0] == '#') {
-        return key.slice(1);
-      }
-    }
-
-    setItem(key, item) {
-      if ((key = this._parseKey(key))) {
-        var old = this.store[key];
-        if (old) {
-          this._removeFromMap(old);
-        }
-        if (item && typeof item == 'object') {
-          this.omap.set(item, key);
-        } else {
-          this.pmap[item] = key;
-        }
-        this.store[key] = item;
-      }
-    }
-
-    getItem(key) {
-      if ((key = this._parseKey(key))) {
-        return this.store[key];
-      }
-    }
-
-    getItems() {
-      var items = [], store = this.store;
-      for (var key in store) {
-        items.push(store[key]);
-      }
-      return items;
-    }
-
-    // Accepts an array of standard splice records (index, addedCount, removed
-    // array), and performs two key actions:
-    // 1. Applies the splice to the collection: adds newly added items to the
-    //    store which generates a unique key for it, and removes removed items
-    //    (and their key) from the store
-    // 2. Generates a "keySplices" record (in contrast to the input
-    //    "indexSplices"), which contains an array of added and removed keys
-    //    corresponding to the added/removed items
-    _applySplices(splices) {
-      // Dedupe added and removed keys to a final added/removed map
-      var keyMap = {}, key;
-      for (var i=0, s; (i<splices.length) && (s=splices[i]); i++) {
-        s.addedKeys = [];
-        for (var j=0; j<s.removed.length; j++) {
-          key = this.getKey(s.removed[j]);
-          keyMap[key] = keyMap[key] ? null : -1;
-        }
-        for (j=0; j<s.addedCount; j++) {
-          var item = this.userArray[s.index + j];
-          key = this.getKey(item);
-          key = (key === undefined) ? this.add(item) : key;
-          keyMap[key] = keyMap[key] ? null : 1;
-          // Add an "addedKeys" array to indexSplices to capture keys associated
-          // with added items, since references to added items can be lost by
-          // further changes to the array by the time the splice is consumed
-          s.addedKeys.push(key);
-        }
-      }
-      // Convert added/removed key map to added/removed arrays
-      var removed = [];
-      var added = [];
-      for (key in keyMap) {
-        if (keyMap[key] < 0) {
-          this.removeKey(key);
-          removed.push(key);
-        }
-        if (keyMap[key] > 0) {
-          added.push(key);
-        }
-      }
-      return [{
-        removed: removed,
-        added: added
-      }];
-    }
-
-  }
-
-  Collection._collections = new WeakMap();
-
-  Polymer.Collection = Collection;
-
-})();
-</script>
diff --git a/src/utils/path.html b/src/utils/path.html
index 3ff2f029da..d1a68c11a7 100644
--- a/src/utils/path.html
+++ b/src/utils/path.html
@@ -9,7 +9,6 @@
 -->
 
 <link rel="import" href="boot.html">
-<link rel="import" href="../templatizer/collection.html">
 
 <script>
 

From 37b041d64312db4a94180d78ec2c7cf4813c6781 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Tue, 20 Sep 2016 20:02:50 -0700
Subject: [PATCH 07/20] Add notes to readme.

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index d575a6a6ed..9bb1bc808c 100644
--- a/README.md
+++ b/README.md
@@ -229,7 +229,7 @@ Polymer 2.0 will continue to use a [shim](https://github.com/webcomponents/shady
 * `<style>` inside of a `<dom-module>`, but outside of `<template>` is no longer supported
 * Imperatively created custom-styles (e.g. `document.createElement('style', 'custom-style')`) are no longer supported.
 
-### Data layer
+### Data system
 * An element's template is not stamped & data system not initialized (observers, bindings, etc.) until the element has been connected to the main document.  This is a direct result of the V1 changes that prevent reading attributes in the constructor.
 * Re-setting an object or array no longer dirty checks, meaning you can make deep changes to an object/array and just re-set it, without needing to use `set`/`notifyPath`.  Although the `set` API remains and will often be the more efficient way to make changes, this change removes users of Polymer elements from needing to use this API, making it more compatible with alternate data-binding and state management libraries.
 * Propagation of data through the binding system is now batched, such that multi-property computing functions and observers run once with a set of coherent changes.  Single property accessors still propagate data synchronously, although there is a new `setProperties({...})` API on Polymer elements that can be used to propagate multiple values as a coherent set.
@@ -238,6 +238,7 @@ Polymer 2.0 will continue to use a [shim](https://github.com/webcomponents/shady
 * Setting/changing any function used in inline template annotations will cause the binding to re-compute its value using the new function and current property values
 ‘notify’ events not fired when value changes as result of binding from host
 * In order for a property to be deserialized from its attribute, it must be declared in the `properties` metadata object
+* The `Polymer.Collection` and associated key-based path and splice notification for arrays has been eliminated.  See [explanation here](https://github.com/Polymer/polymer/pull/3970#issue-178203286) for more details.
 
 ### Removed API
 * `Polymer.instanceof` and `Polymer.isInstance`: no longer needed, use

From 26545c138e687ae8af06cf0f5996aed11dd16082 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Thu, 22 Sep 2016 18:05:26 -0700
Subject: [PATCH 08/20] Add legacy root param to set API. Remove test cruft.

---
 src/properties/property-effects.html | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/properties/property-effects.html b/src/properties/property-effects.html
index 313f86c3a0..bbd73eb994 100644
--- a/src/properties/property-effects.html
+++ b/src/properties/property-effects.html
@@ -843,12 +843,18 @@
        *   indices, the index may be used as a dotted part directly
        *   (e.g. `users.12.name` or `['users', 12, 'name']`).
        * @param {*} value Value to set at the specified path.
+       * @param {Object=} root Root object from which the path is evaluated.
+       *   When specified, no notification will occur.
       */
-      set(path, value) {
-        if (!this._hasReadOnlyEffect(path)) {
-          if ((path = this._setPathOrUnmanagedProperty(path, value))) {
-            this._setProperty(path, value);
-          }
+      set(path, value, root) {
+        if (root) {
+          Polymer.Path.set(root, path, value);
+        } else {
+          if (!this._hasReadOnlyEffect(path)) {
+            if ((path = this._setPathOrUnmanagedProperty(path, value))) {
+              this._setProperty(path, value);
+            }
+          }          
         }
       }
 

From 276bf0e01646933658d45a9385d0d13169c083f8 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Thu, 22 Sep 2016 18:06:26 -0700
Subject: [PATCH 09/20] Remove test cruft. Add set+root test.

---
 test/unit/notify-path.html | 114 ++-----------------------------------
 1 file changed, 5 insertions(+), 109 deletions(-)

diff --git a/test/unit/notify-path.html b/test/unit/notify-path.html
index ab0b25747a..5acf74e9b7 100644
--- a/test/unit/notify-path.html
+++ b/test/unit/notify-path.html
@@ -424,33 +424,15 @@
     assert.equal(el.arrayNoCollChanged.callCount, 3);
   });
 
-  test.skip('array.splices notified', function() {
-    el.array = [];
-    // Ensure keySplices are generated for test purposes
-    Polymer.Collection.from(el.array);
-    assert.equal(el.arrayChanged.callCount, 1);
-    el.push('array', 1, 2, 3);
-    assert.equal(el.arrayChanged.callCount, 2);
-    assert.equal(Polymer.Collection.from(el.array).getKeys().length, 3);
-    el.push('array', 4, 5, 6);
-    assert.equal(el.arrayChanged.callCount, 3);
-    assert.equal(Polymer.Collection.from(el.array).getKeys().length, 6);
-  });
-
   test('ensure splices sent into userland dont get nulled', function(){
     el.array = [];
-    // Ensure keySplices are generated for test purposes
-    Polymer.Collection.from(el.array);
-
     el.push('array', 1, 2, 3);
     assert.notEqual(el.arraySplices.indexSplices, null);
-    // assert.notEqual(el.arraySplices.keySplices, null);
   });
 
   test('array.splices notified, multiple args, prop first', function() {
     var array = [];
     // Ensure keySplices are generated for test purposes
-    Polymer.Collection.from(array);
     el.setProperties({
       array: array,
       prop: 'first'
@@ -466,7 +448,6 @@
   test.skip('array.splices notified, multiple args, prop last', function() {
     el.array = [];
     // Ensure keySplices are generated for test purposes
-    Polymer.Collection.from(el.array);
     el.push('array', 1, 2, 3);
     el.prop = 'last';
     assert.equal(el.arrayOrPropChanged.callCount, 1);
@@ -535,6 +516,7 @@
     el.set('nested.again.there', 55);
     el.set('nested.again.again', {});
     el.set(['nested', 'again.again', 'wayOverThere'], 99);
+    el.set(['again.thereToo'], 111, el.nested.again);
     assert.equal(el.simple, 11);
     assert.equal(el.get('simple'), 11);
     assert.equal(el.get('nested'), el.nested);
@@ -546,6 +528,8 @@
     assert.equal(el.get('nested.again.again'), el.nested.again.again);
     assert.equal(el.nested.again.again.wayOverThere, 99);
     assert.equal(el.get('nested.again.again.wayOverThere'), 99);
+    assert.equal(el.nested.again.again.thereToo, 111);
+    assert.equal(el.get('nested.again.again.thereToo'), 111);
   });
 
   test('notifyPath calls observer', function() {
@@ -569,16 +553,10 @@
     assert.equal(el.get('array.0'), 1);
     assert.equal(el.get('array.1'), 2);
     assert.equal(el.get('array.2'), 3);
-    // assert.equal(el.get('array.#0'), 1);
-    // assert.equal(el.get('array.#1'), 2);
-    // assert.equal(el.get('array.#2'), 3);
     assert.equal(el.get('array.array'), el.array.array);
     assert.equal(el.get('array.array.0'), 5);
     assert.equal(el.get('array.array.1'), 6);
     assert.equal(el.get('array.array.2'), 7);
-    // assert.equal(el.get('array.array.#0'), 5);
-    // assert.equal(el.get('array.array.#1'), 6);
-    // assert.equal(el.get('array.array.#2'), 7);
     assert.equal(el.get('array.prop'), 'prop');
     el.unshift('array', 0);
     el.splice('array', 2, 0, 1.5);
@@ -589,21 +567,11 @@
     assert.equal(el.get('array.2'), 1.5);
     assert.equal(el.get('array.3'), 2);
     assert.equal(el.get('array.4'), 3);
-    // assert.equal(el.get('array.#0'), 1);
-    // assert.equal(el.get('array.#1'), 2);
-    // assert.equal(el.get('array.#2'), 3);
-    // assert.equal(el.get('array.#3'), 0);
-    // assert.equal(el.get('array.#4'), 1.5);
     assert.equal(el.get('array.array.0'), 4);
     assert.equal(el.get('array.array.1'), 5);
     assert.equal(el.get('array.array.2'), 5.5);
     assert.equal(el.get('array.array.3'), 6);
     assert.equal(el.get('array.array.4'), 7);
-    // assert.equal(el.get('array.array.#0'), 5);
-    // assert.equal(el.get('array.array.#1'), 6);
-    // assert.equal(el.get('array.array.#2'), 7);
-    // assert.equal(el.get('array.array.#3'), 4);
-    // assert.equal(el.get('array.array.#4'), 5.5);
   });
 
   test('set array', function() {
@@ -615,16 +583,10 @@
     assert.equal(el.get('array.0'), 1);
     assert.equal(el.get('array.1'), 2);
     assert.equal(el.get('array.2'), 3);
-    // assert.equal(el.get('array.#0'), 1);
-    // assert.equal(el.get('array.#1'), 2);
-    // assert.equal(el.get('array.#2'), 3);
     assert.equal(el.get('array.array'), el.array.array);
     assert.equal(el.get('array.array.0'), 5);
     assert.equal(el.get('array.array.1'), 6);
     assert.equal(el.get('array.array.2'), 7);
-    // assert.equal(el.get('array.array.#0'), 5);
-    // assert.equal(el.get('array.array.#1'), 6);
-    // assert.equal(el.get('array.array.#2'), 7);
     assert.equal(el.get('array.prop'), 'prop');
     el.set(['array', 0], 81);
     el.set(['array', 1], 82);
@@ -636,15 +598,9 @@
     assert.equal(el.get('array.0'), 81);
     assert.equal(el.get('array.1'), 82);
     assert.equal(el.get('array.2'), 83);
-    // assert.equal(el.get('array.#0'), 81);
-    // assert.equal(el.get('array.#1'), 82);
-    // assert.equal(el.get('array.#2'), 83);
     assert.equal(el.get('array.array.0'), 91);
     assert.equal(el.get('array.array.1'), 92);
     assert.equal(el.get('array.array.2'), 93);
-    // assert.equal(el.get('array.array.#0'), 91);
-    // assert.equal(el.get('array.array.#1'), 92);
-    // assert.equal(el.get('array.array.#2'), 93);
     assert.equal(el.get('array.prop'), 'foo');
     // el.set(['array', '#0'], 31);
     // el.set(['array', '#1'], 32);
@@ -652,18 +608,6 @@
     // el.set(['array.array', '#0'], 41);
     // el.set(['array.array', '#1'], 42);
     // el.set(['array.array', '#2'], 43);
-    // assert.equal(el.get('array.0'), 31);
-    // assert.equal(el.get('array.1'), 32);
-    // assert.equal(el.get('array.2'), 33);
-    // assert.equal(el.get('array.#0'), 31);
-    // assert.equal(el.get('array.#1'), 32);
-    // assert.equal(el.get('array.#2'), 33);
-    // assert.equal(el.get('array.array.0'), 41);
-    // assert.equal(el.get('array.array.1'), 42);
-    // assert.equal(el.get('array.array.2'), 43);
-    // assert.equal(el.get('array.array.#0'), 41);
-    // assert.equal(el.get('array.array.#1'), 42);
-    // assert.equal(el.get('array.array.#2'), 43);
   });
 
   var nop = function() {};
@@ -671,18 +615,12 @@
   test('push array', function() {
     el.arrayChanged = nop;
     el.array = ['orig1', 'orig2', 'orig3'];
-    // Polymer.Collection.from(el.array);
     // var key = el.array.length;
     el.arrayChanged = function(change) {
       assert.strictEqual(change.indexSplices.length, 1);
       assert.strictEqual(change.indexSplices[0].index, 3);
       assert.strictEqual(change.indexSplices[0].addedCount, 2);
       assert.strictEqual(change.indexSplices[0].removed.length, 0);
-      // assert.strictEqual(change.keySplices.length, 1);
-      // assert.strictEqual(change.keySplices[0].added.length, 2);
-      // assert.strictEqual(change.keySplices[0].added[0], '#' + key);
-      // assert.strictEqual(change.keySplices[0].added[1], '#' + (key+1));
-      // assert.strictEqual(change.keySplices[0].removed.length, 0);
     };
     var ret = el.push('array', 'new1', 'new2');
     assert.strictEqual(ret, 5);
@@ -697,7 +635,6 @@
   test('pop array', function() {
     el.arrayChanged = nop;
     el.array = ['orig1', 'orig2', 'orig3'];
-    // Polymer.Collection.from(el.array);
     // var key = el.array.length-1;
     el.arrayChanged = function(change) {
       assert.strictEqual(change.indexSplices.length, 1);
@@ -705,10 +642,6 @@
       assert.strictEqual(change.indexSplices[0].addedCount, 0);
       assert.strictEqual(change.indexSplices[0].removed.length, 1);
       assert.strictEqual(change.indexSplices[0].removed[0], 'orig3');
-      // assert.strictEqual(change.keySplices.length, 1);
-      // assert.strictEqual(change.keySplices[0].added.length, 0);
-      // assert.strictEqual(change.keySplices[0].removed.length, 1);
-      // assert.strictEqual(change.keySplices[0].removed[0], '#' + key);
     };
     var ret = el.pop('array');
     assert.strictEqual(ret, 'orig3');
@@ -720,18 +653,12 @@
   test('unshift array', function() {
     el.arrayChanged = nop;
     el.array = ['orig1', 'orig2', 'orig3'];
-    // Polymer.Collection.from(el.array);
     // var key = el.array.length;
     el.arrayChanged = function(change) {
       assert.strictEqual(change.indexSplices.length, 1);
       assert.strictEqual(change.indexSplices[0].index, 0);
       assert.strictEqual(change.indexSplices[0].addedCount, 2);
       assert.strictEqual(change.indexSplices[0].removed.length, 0);
-      // assert.strictEqual(change.keySplices.length, 1);
-      // assert.strictEqual(change.keySplices[0].added.length, 2);
-      // assert.strictEqual(change.keySplices[0].added[0], '#' + key);
-      // assert.strictEqual(change.keySplices[0].added[1], '#' + (key+1));
-      // assert.strictEqual(change.keySplices[0].removed.length, 0);
     };
     var ret = el.unshift('array', 'new1', 'new2');
     assert.strictEqual(ret, 5);
@@ -746,17 +673,12 @@
   test('shift array', function() {
     el.arrayChanged = nop;
     el.array = ['orig1', 'orig2', 'orig3'];
-    // Polymer.Collection.from(el.array);
     el.arrayChanged = function(change) {
       assert.strictEqual(change.indexSplices.length, 1);
       assert.strictEqual(change.indexSplices[0].index, 0);
       assert.strictEqual(change.indexSplices[0].addedCount, 0);
       assert.strictEqual(change.indexSplices[0].removed.length, 1);
       assert.strictEqual(change.indexSplices[0].removed[0], 'orig1');
-      // assert.strictEqual(change.keySplices.length, 1);
-      // assert.strictEqual(change.keySplices[0].added.length, 0);
-      // assert.strictEqual(change.keySplices[0].removed.length, 1);
-      // assert.strictEqual(change.keySplices[0].removed[0], '#' + 0);
     };
     var ret = el.shift('array');
     assert.strictEqual(ret, 'orig1');
@@ -769,19 +691,12 @@
     el.arrayChanged = nop;
     el.array = ['orig1', 'orig2', 'orig3'];
     // var key = el.array.length;
-    // Polymer.Collection.from(el.array);
     el.arrayChanged = function(change) {
       assert.strictEqual(change.indexSplices.length, 1);
       assert.strictEqual(change.indexSplices[0].index, 1);
       assert.strictEqual(change.indexSplices[0].addedCount, 2);
       assert.strictEqual(change.indexSplices[0].removed.length, 1);
       assert.strictEqual(change.indexSplices[0].removed[0], 'orig2');
-      // assert.strictEqual(change.keySplices.length, 1);
-      // assert.strictEqual(change.keySplices[0].added.length, 2);
-      // assert.strictEqual(change.keySplices[0].added[0], '#' + key);
-      // assert.strictEqual(change.keySplices[0].added[1], '#' + (key+1));
-      // assert.strictEqual(change.keySplices[0].removed.length, 1);
-      // assert.strictEqual(change.keySplices[0].removed[0], '#' + 1);
     };
     var ret = el.splice('array', 1, 1, 'new1', 'new2');
     assert.deepEqual(ret, ['orig2']);
@@ -795,7 +710,6 @@
   test('corner: no-op push array', function() {
     el.arrayChanged = nop;
     el.array = ['orig1', 'orig2', 'orig3'];
-    Polymer.Collection.from(el.array);
     el.arrayChanged = function() {
       throw new Error("should not notify");
     };
@@ -810,7 +724,6 @@
   test('corner: no-op pop array', function() {
     el.arrayChanged = nop;
     el.array = [];
-    Polymer.Collection.from(el.array);
     el.arrayChanged = function() {
       throw new Error("should not notify");
     };
@@ -822,7 +735,6 @@
   test('corner: no-op unshift array', function() {
     el.arrayChanged = nop;
     el.array = ['orig1', 'orig2', 'orig3'];
-    Polymer.Collection.from(el.array);
     el.arrayChanged = function() {
       throw new Error("should not notify");
     };
@@ -837,7 +749,6 @@
   test('corner: no-op shift array', function() {
     el.arrayChanged = nop;
     el.array = [];
-    Polymer.Collection.from(el.array);
     el.arrayChanged = function() {
       throw new Error("should not notify");
     };
@@ -850,7 +761,6 @@
   test('corner: no-op splice array', function() {
     el.arrayChanged = nop;
     el.array = ['orig1', 'orig2', 'orig3'];
-    Polymer.Collection.from(el.array);
     el.arrayChanged = function() {
       throw new Error("should not notify");
     };
@@ -865,20 +775,13 @@
   test('corner: splice array: string args', function() {
     el.arrayChanged = nop;
     el.array = ['orig1', 'orig2', 'orig3'];
-    var key = el.array.length;
-    Polymer.Collection.from(el.array);
+    // var key = el.array.length;
     el.arrayChanged = function(change) {
       assert.strictEqual(change.indexSplices.length, 1);
       assert.strictEqual(change.indexSplices[0].index, 1);
       assert.strictEqual(change.indexSplices[0].addedCount, 2);
       assert.strictEqual(change.indexSplices[0].removed.length, 1);
       assert.strictEqual(change.indexSplices[0].removed[0], 'orig2');
-      // assert.strictEqual(change.keySplices.length, 1);
-      // assert.strictEqual(change.keySplices[0].added.length, 2);
-      // assert.strictEqual(change.keySplices[0].added[0], '#' + key);
-      // assert.strictEqual(change.keySplices[0].added[1], '#' + (key+1));
-      // assert.strictEqual(change.keySplices[0].removed.length, 1);
-      // assert.strictEqual(change.keySplices[0].removed[0], '#' + 1);
     };
     var ret = el.splice('array', '1', '1', 'new1', 'new2');
     assert.deepEqual(ret, ['orig2']);
@@ -892,20 +795,13 @@
   test('corner: splice array: negative start', function() {
     el.arrayChanged = nop;
     el.array = ['orig1', 'orig2', 'orig3'];
-    var key = el.array.length;
-    Polymer.Collection.from(el.array);
+    // var key = el.array.length;
     el.arrayChanged = function(change) {
       assert.strictEqual(change.indexSplices.length, 1);
       assert.strictEqual(change.indexSplices[0].index, 1);
       assert.strictEqual(change.indexSplices[0].addedCount, 2);
       assert.strictEqual(change.indexSplices[0].removed.length, 1);
       assert.strictEqual(change.indexSplices[0].removed[0], 'orig2');
-      // assert.strictEqual(change.keySplices.length, 1);
-      // assert.strictEqual(change.keySplices[0].added.length, 2);
-      // assert.strictEqual(change.keySplices[0].added[0], '#' + key);
-      // assert.strictEqual(change.keySplices[0].added[1], '#' + (key+1));
-      // assert.strictEqual(change.keySplices[0].removed.length, 1);
-      // assert.strictEqual(change.keySplices[0].removed[0], '#' + 1);
     };
     var ret = el.splice('array', '-2', '1', 'new1', 'new2');
     assert.deepEqual(ret, ['orig2']);

From 05ffc645cd3c5fac392a10cc5bf59c5cfe964b76 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Thu, 22 Sep 2016 18:20:48 -0700
Subject: [PATCH 10/20] Remove reference to Collection.

---
 test/unit/dom-repeat.html | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/unit/dom-repeat.html b/test/unit/dom-repeat.html
index 87ca5e810b..a165b466be 100644
--- a/test/unit/dom-repeat.html
+++ b/test/unit/dom-repeat.html
@@ -5048,7 +5048,6 @@ <h4>x-repeat-chunked</h4>
           items.sort();
           var splices = Polymer.ArraySplice.calculateSplices(items, prev);
           var change = {
-            keySplices: Polymer.Collection.applySplices(items, splices),
             indexSplices: splices
           };
           primitive.set('items.splices', change);

From 0c909016574509add53e981a8bc75d791f0a25eb Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Thu, 22 Sep 2016 18:21:34 -0700
Subject: [PATCH 11/20] var->let

---
 src/properties/batched-effects.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/properties/batched-effects.html b/src/properties/batched-effects.html
index bc107b454e..69bcd1f4d8 100644
--- a/src/properties/batched-effects.html
+++ b/src/properties/batched-effects.html
@@ -43,7 +43,7 @@
     if (links) {
       let link;
       for (let a in inst.__dataLinkedPaths) {
-        var b = links[a];
+        let b = links[a];
         for (let path in changedProps) {
           if (Polymer.Path.isDescendant(a, path)) {
             link = Polymer.Path.translate(a, b, path);

From f7d58e79776d62e8efb5b7778182e4f283a45790 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Thu, 22 Sep 2016 19:12:21 -0700
Subject: [PATCH 12/20] Ensure all path API's normalize user path.

---
 src/properties/property-effects.html | 33 ++++++++++++++++-----
 src/utils/path.html                  | 11 +++----
 test/unit/notify-path.html           | 44 +++++++++++++++++++++++++---
 3 files changed, 72 insertions(+), 16 deletions(-)

diff --git a/src/properties/property-effects.html b/src/properties/property-effects.html
index bebc224f7e..3606c7bb4f 100644
--- a/src/properties/property-effects.html
+++ b/src/properties/property-effects.html
@@ -556,7 +556,7 @@
 
   // data api
 
-  // Note: this implemetation only accepts key-based array paths
+  // Note: this implemetation only accepts normalized paths
   function notifySplices(inst, array, path, splices) {
     let change = {
       indexSplices: splices
@@ -566,7 +566,7 @@
     inst._setProperty(path + '.length', array.length);
     // All path notification values are cached on `this.__data__`.
     // Null here to allow potentially large splice records to be GC'ed.
-    inst.__data[splicesPath] = {keySplices: null, indexSplices: null};
+    inst.__data[splicesPath] = {indexSplices: null};
   }
 
   function notifySplice(inst, array, path, index, added, removed) {
@@ -682,7 +682,7 @@
       // system, and not in every step of the hot path.
       // If `path` is an unmanaged property (property without an accessor)
       // or a path, sets the value at that path.  If the root of the path
-      // is a managed property, returns an index-to-key transformed path
+      // is a managed property, returns a normalized string path
       // sutable for setting into the system via setProperty/setPendingProperty
       // `path` can be a user-facing path string or array of path parts.
       _setPathOrUnmanagedProperty(path, value) {
@@ -745,6 +745,8 @@
        * @param {string} from Source path to link.
        */
       linkPaths(to, from) {
+        to = Polymer.Path.normalize(to);
+        from = Polymer.Path.normalize(from);
         this.__dataLinkedPaths = this.__dataLinkedPaths || {};
         if (from) {
           this.__dataLinkedPaths[to] = from;
@@ -763,6 +765,7 @@
        * @param {string} path Target path to unlink.
        */
       unlinkPaths(path) {
+        path = Polymer.Path.normalize(path);
         if (this.__dataLinkedPaths) {
           delete this.__dataLinkedPaths[path];
         }
@@ -799,7 +802,6 @@
       notifySplices(path, splices) {
         let info = {};
         let array = Polymer.Path.get(this, path, info);
-        // Notify change to key-based path
         notifySplices(this, array, info.path, splices);
       }
 
@@ -836,12 +838,12 @@
        *
        * @method set
        * @param {(string|Array<(string|number)>)} path Path to the value
-       *   to write.  The path may be specified as a string (e.g. `foo.bar.baz`)
+       *   to write.  The path may be specified as a string (e.g. `'foo.bar.baz'`)
        *   or an array of path parts (e.g. `['foo.bar', 'baz']`).  Note that
        *   bracketed expressions are not supported; string-based path parts
        *   *must* be separated by dots.  Note that when dereferencing array
        *   indices, the index may be used as a dotted part directly
-       *   (e.g. `users.12.name` or `['users', 12, 'name']`).
+       *   (e.g. `'users.12.name'` or `['users', 12, 'name']`).
        * @param {*} value Value to set at the specified path.
        * @param {Object=} root Root object from which the path is evaluated.
        *   When specified, no notification will occur.
@@ -1010,9 +1012,26 @@
         return ret;
       }
 
+      /**
+       * Notify that a path has changed.
+       *
+       * Example:
+       *
+       *     this.item.user.name = 'Bob';
+       *     this.notifyPath('item.user.name');
+       *
+       * @param {string} path Path that should be notified.
+       * @param {*=} value Value at the path (optional).
+      */
       notifyPath(path, value) {
         if (arguments.length == 1) {
-          value = this.get(path);
+          // Get value if not supplied
+          let info = {};
+          value = Polymer.Path.get(this, path, info);
+          path = info.path;
+        } else if (Array.isArray(path)) {
+          // Normalize path if needed
+          path = Polymer.Path.normalize(path);
         }
         this._setProperty(path, value);
       }
diff --git a/src/utils/path.html b/src/utils/path.html
index d1a68c11a7..310a067940 100644
--- a/src/utils/path.html
+++ b/src/utils/path.html
@@ -50,7 +50,8 @@
              this.isDescendant(base, path);
     },
 
-    getParts: function(path) {
+    // Converts array-based paths to flattened path, optionally split into array
+    normalize: function(path, split) {
       if (Array.isArray(path)) {
         var parts = [];
         for (var i=0; i<path.length; i++) {
@@ -59,15 +60,15 @@
             parts.push(args[j]);
           }
         }
-        return parts;
+        return split ? parts : parts.join('.');
       } else {
-        return path.toString().split('.');
+        return split ? path.toString().split('.') : path;
       }
     },
 
     get: function(root, path, info) {
       var prop = root;
-      var parts = this.getParts(path);
+      var parts = this.normalize(path, true);
       // Loop over path parts[0..n-1] and dereference
       for (var i=0; i<parts.length; i++) {
         if (!prop) {
@@ -84,7 +85,7 @@
 
     set: function(root, path, value) {
       var prop = root;
-      var parts = this.getParts(path);
+      var parts = this.normalize(path, true);
       var last = parts[parts.length-1];
       if (parts.length > 1) {
         // Loop over path parts[0..n-2] and dereference
diff --git a/test/unit/notify-path.html b/test/unit/notify-path.html
index 5acf74e9b7..f2fc56a6ed 100644
--- a/test/unit/notify-path.html
+++ b/test/unit/notify-path.html
@@ -532,12 +532,48 @@
     assert.equal(el.get('nested.again.again.thereToo'), 111);
   });
 
-  test('notifyPath calls observer', function() {
-    el.a = {b: {c: true}};
+  test('notifyPath basic', function() {
+    el.a = {b: {c: 0}};
     el.resetObservers();
-    el.notifyPath('a.b.c', el.a.b.c);
+    el.a.b.c = 55;
+    el.notifyPath('a.b.c');
     assert.isTrue(el.aChanged.calledOnce);
-    assert.equal(el.get('a.b.c'), true);
+    assert.equal(el.aChanged.firstCall.args[0].path, 'a.b.c');
+    assert.equal(el.aChanged.firstCall.args[0].value, 55);
+    assert.equal(el.get('a.b.c'), 55);
+  });
+
+  test('notifyPath with array path argument', function() {
+    el.a = {b: {c: 0}};
+    el.resetObservers();
+    el.a.b.c = 56;
+    el.notifyPath(['a', 'b.c']);
+    assert.isTrue(el.aChanged.calledOnce);
+    assert.equal(el.aChanged.firstCall.args[0].path, 'a.b.c');
+    assert.equal(el.aChanged.firstCall.args[0].value, 56);
+    assert.equal(el.get('a.b.c'), 56);
+  });
+
+  test('notifyPath with value argument', function() {
+    el.a = {b: {c: 0}};
+    el.resetObservers();
+    el.a.b.c = 57;
+    el.notifyPath('a.b.c', 57);
+    assert.isTrue(el.aChanged.calledOnce);
+    assert.equal(el.aChanged.firstCall.args[0].path, 'a.b.c');
+    assert.equal(el.aChanged.firstCall.args[0].value, 57);
+    assert.equal(el.get('a.b.c'), 57);
+  });
+
+  test('notifyPath with value argument and array path argument', function() {
+    el.a = {b: {c: 0}};
+    el.resetObservers();
+    el.a.b.c = 57;
+    el.notifyPath(['a', 'b.c'], 57);
+    assert.isTrue(el.aChanged.calledOnce);
+    assert.equal(el.aChanged.firstCall.args[0].path, 'a.b.c');
+    assert.equal(el.aChanged.firstCall.args[0].value, 57);
+    assert.equal(el.get('a.b.c'), 57);
   });
 
   test('notifyPath a non-extistant does nothing', function() {

From 8b09552579557a636629d0283d010f05a374a56e Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Thu, 22 Sep 2016 19:32:00 -0700
Subject: [PATCH 13/20] Use links.

---
 src/properties/batched-effects.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/properties/batched-effects.html b/src/properties/batched-effects.html
index 69bcd1f4d8..b50fc4d662 100644
--- a/src/properties/batched-effects.html
+++ b/src/properties/batched-effects.html
@@ -42,7 +42,7 @@
     const links = inst.__dataLinkedPaths;
     if (links) {
       let link;
-      for (let a in inst.__dataLinkedPaths) {
+      for (let a in links) {
         let b = links[a];
         for (let path in changedProps) {
           if (Polymer.Path.isDescendant(a, path)) {

From 8e754b1d88f5c047da922892d53b97c79f827c5d Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Fri, 23 Sep 2016 09:25:11 -0700
Subject: [PATCH 14/20] Call filter fn using all standard args.

---
 src/templatizer/dom-repeat.html | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/templatizer/dom-repeat.html b/src/templatizer/dom-repeat.html
index b89e93768e..3f2dc768e8 100644
--- a/src/templatizer/dom-repeat.html
+++ b/src/templatizer/dom-repeat.html
@@ -465,7 +465,8 @@
       }
       // Apply user filter
       if (this._filterFn) {
-        viewOrder = viewOrder.filter((i) => this._filterFn(items[i]));
+        viewOrder = viewOrder.filter((i, idx, array) =>
+          this._filterFn(items[i], idx, array));
       }
       // Apply user sort
       if (this._sortFn) {

From 66a5a7a47a2536f3ec36dd8cf5f04c731444b2cb Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Fri, 23 Sep 2016 09:26:10 -0700
Subject: [PATCH 15/20] Ensure paths are notified using queueProperty:true

---
 src/properties/batched-effects.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/properties/batched-effects.html b/src/properties/batched-effects.html
index b50fc4d662..f60533a4b1 100644
--- a/src/properties/batched-effects.html
+++ b/src/properties/batched-effects.html
@@ -90,12 +90,12 @@
     let rootProperty = Polymer.Path.root(prop);
     if (rootProperty !== prop) {
       let name = Polymer.CaseMap.camelToDashCase(rootProperty) + '-changed';
-      inst.dispatchEvent(new CustomEvent(name, { detail: {value, path: prop }}));
+      let options = { detail: {value, path: prop }};
+      inst._dispatchNotifyingEvent(new CustomEvent(name, options));
       return true;
     }
   }
 
-
   function runEffects(inst, type, props, oldProps, fallback) {
     let ran;
     let effects = inst[type];

From de9bc5cd5993ea11dbe9e0367656f13a263517ee Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Fri, 23 Sep 2016 15:02:24 -0700
Subject: [PATCH 16/20] origIndex->itemsIndex. Decorate template with d-r
 reference.

---
 src/templatizer/dom-repeat.html | 45 ++++++++++++++++-----------------
 1 file changed, 22 insertions(+), 23 deletions(-)

diff --git a/src/templatizer/dom-repeat.html b/src/templatizer/dom-repeat.html
index 3f2dc768e8..1f27dba012 100644
--- a/src/templatizer/dom-repeat.html
+++ b/src/templatizer/dom-repeat.html
@@ -156,9 +156,9 @@
        * for the inst.  If `sort` is provided, the index will reflect the
        * sorted order (rather than the original array order).
        */
-      origIndexAs: {
+      itemsIndexAs: {
         type: String,
-        value: 'origIndex'
+        value: 'itemsIndex'
       },
 
       /**
@@ -288,6 +288,7 @@
       // it until then
       if (!this._ctor) {
         var template = this.template = this.querySelector('template');
+        template.__domRepeat = this;
         if (!template) {
           throw new Error('dom-repeat requires a <template> child');
         }
@@ -295,27 +296,25 @@
         var instanceProps = {};
         instanceProps[this.as] = true;
         instanceProps[this.indexAs] = true;
-        instanceProps[this.origIndexAs] = true;
+        instanceProps[this.itemsIndexAs] = true;
         this._ctor = templatizer.templatize(template, {
           instanceProps: instanceProps,
           fwdHostPropToInstance: function(host, prop, value) {
-            //TODO(kschaaf): fallout from separating template from dom-repeat
-            var self = this.parentNode;
-            var i$ = self._instances;
+            var repeater = this.__domRepeat;
+            var i$ = repeater._instances;
             for (var i=0, inst; (i<i$.length) && (inst=i$[i]); i++) {
               inst.forwardProperty(prop, value, host);
             }
           },
           fwdInstancePropToHost: function(inst, prop, value) {
-            //TODO(kschaaf): fallout from separating template from dom-repeat
-            var self = this.__dataHost.parentNode;
-            if (Polymer.Path.matches(self.as, prop)) {
-              let idx = inst[self.origIndexAs];
-              if (prop == self.as) {
-                self.items[idx] = value;
+            var repeater = this.__dataHost.__domRepeat;
+            if (Polymer.Path.matches(repeater.as, prop)) {
+              let idx = inst[repeater.itemsIndexAs];
+              if (prop == repeater.as) {
+                repeater.items[idx] = value;
               }
-              let path = Polymer.Path.translate(self.as, 'items.' + idx, prop);
-              self.notifyPath(path, value);
+              let path = Polymer.Path.translate(repeater.as, 'items.' + idx, prop);
+              repeater.notifyPath(path, value);
             }
           }
         });
@@ -459,7 +458,7 @@
 
     _applyFullRefresh: function() {
       const items = this.items || [];
-      let viewOrder = this._viewOrder = new Array(items.length);
+      let viewOrder = new Array(items.length);
       for (let i=0; i<items.length; i++) {
         viewOrder[i] = i;
       }
@@ -474,9 +473,9 @@
       }
       // Generate instances and assign items
       const limit = Math.min(viewOrder.length, this._limit);
-      const idxMap = this._origIdxToInstIdx = {};
+      const idxMap = this._itemsIdxToInstIdx = {};
       let instIdx = 0;
-      this._origIdxToInstIdx = idxMap;
+      this._itemsIdxToInstIdx = idxMap;
       for (; instIdx<limit; instIdx++) {
         let inst = this._instances[instIdx];
         let itemIdx = viewOrder[instIdx];
@@ -485,7 +484,7 @@
         if (inst && instIdx < this._limit) {
           inst.forwardProperty(this.as, item);
           inst.forwardProperty(this.indexAs, instIdx);
-          inst.forwardProperty(this.origIndexAs, itemIdx);
+          inst.forwardProperty(this.itemsIndexAs, itemIdx);
           inst.flushProperties();
         } else {
           this._insertInstance(item, instIdx, itemIdx);
@@ -526,7 +525,7 @@
       var model = {};
       model[this.as] = item;
       model[this.indexAs] = instIdx;
-      model[this.origIndexAs] = itemIdx;
+      model[this.itemsIndexAs] = itemIdx;
       return new this._ctor(this, model);
     },
 
@@ -537,7 +536,7 @@
         // need to be re-set to reused instances in addition to item
         inst.forwardProperty(this.as, item);
         inst.forwardProperty(this.indexAs, instIdx);
-        inst.forwardProperty(this.origIndexAs, itemIdx);
+        inst.forwardProperty(this.itemsIndexAs, itemIdx);
       } else {
         inst = this._stampInstance(item, instIdx, itemIdx);
       }
@@ -562,12 +561,12 @@
     // Called as a side effect of a host items.<key>.<path> path change,
     // responsible for notifying item.<path> changes to inst for key
     _forwardItemPath: function(path, value) {
-      if (this._origIdxToInstIdx) {
+      if (this._itemsIdxToInstIdx) {
         // slice off 'items.' ('items.'.length == 6)
         path = path.slice(6);
         var dot = path.indexOf('.');
-        var origIdx = path.substring(0, dot < 0 ? path.length : dot);
-        var instIdx = this._origIdxToInstIdx[origIdx];
+        var itemsIdx = path.substring(0, dot < 0 ? path.length : dot);
+        var instIdx = this._itemsIdxToInstIdx[itemsIdx];
         var inst = this._instances[instIdx];
         if (inst) {
           path = this.as + ((dot >= 0) ? ('.' + path.substring(dot+1)) : '');

From f6388f5f67af48b77d3a608da492883ab907f158 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Fri, 23 Sep 2016 15:18:34 -0700
Subject: [PATCH 17/20] Add comments.

---
 src/templatizer/dom-repeat.html | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/templatizer/dom-repeat.html b/src/templatizer/dom-repeat.html
index 1f27dba012..9698253fff 100644
--- a/src/templatizer/dom-repeat.html
+++ b/src/templatizer/dom-repeat.html
@@ -390,9 +390,15 @@
       if (this.items && !Array.isArray(this.items)) {
         console.warn('dom-repeat expected array for `items`, found', this.items);
       }
+      // If path was to an item (e.g. 'items.3' or 'items.3.foo'), forward the
+      // path to that instance synchronously (retuns false for non-item paths)
       if (this._forwardItemPath(change.path, change.value)) {
+        // For item paths, check if it was an observed path and if so, do a
+        // full refresh to re-sort/filter
         this._checkObservedPaths(change.path);
       } else {
+        // Otherwise, the array was reset ('items') or spliced ('items.splices'),
+        // so queue a full refresh
         this._needFullRefresh = true;
         this._initializeChunking();
         this._debounceRender();
@@ -405,8 +411,6 @@
         var paths = this._observePaths;
         for (var i=0; i<paths.length; i++) {
           if (path.indexOf(paths[i]) === 0) {
-            // TODO(kschaaf): interim solution: ideally this is just an incremental
-            // insertion sort of the changed item
             this._needFullRefresh = true;
             if (this.delay) {
               this.debounce('render', this._render, this.delay);
@@ -471,11 +475,11 @@
       if (this._sortFn) {
         viewOrder.sort((a, b) => this._sortFn(items[a], items[b]));
       }
-      // Generate instances and assign items
-      const limit = Math.min(viewOrder.length, this._limit);
+      // items->inst map kept for item path forwarding
       const idxMap = this._itemsIdxToInstIdx = {};
       let instIdx = 0;
-      this._itemsIdxToInstIdx = idxMap;
+      // Generate instances and assign items
+      const limit = Math.min(viewOrder.length, this._limit);
       for (; instIdx<limit; instIdx++) {
         let inst = this._instances[instIdx];
         let itemIdx = viewOrder[instIdx];

From 095ca0dc280e595180846bc1947b0c64409a6e18 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Fri, 23 Sep 2016 15:26:19 -0700
Subject: [PATCH 18/20] Slice subpath early.

---
 src/templatizer/dom-repeat.html | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/templatizer/dom-repeat.html b/src/templatizer/dom-repeat.html
index 9698253fff..0c0c7d9b0d 100644
--- a/src/templatizer/dom-repeat.html
+++ b/src/templatizer/dom-repeat.html
@@ -392,10 +392,11 @@
       }
       // If path was to an item (e.g. 'items.3' or 'items.3.foo'), forward the
       // path to that instance synchronously (retuns false for non-item paths)
-      if (this._forwardItemPath(change.path, change.value)) {
+      let subPath = change.path.slice(6); // 'items.'.length == 6
+      if (this._forwardItemPath(subPath, change.value)) {
         // For item paths, check if it was an observed path and if so, do a
         // full refresh to re-sort/filter
-        this._checkObservedPaths(change.path);
+        this._checkObservedPaths(subPath);
       } else {
         // Otherwise, the array was reset ('items') or spliced ('items.splices'),
         // so queue a full refresh
@@ -407,7 +408,7 @@
 
     _checkObservedPaths: function(path) {
       if (this._observePaths) {
-        path = path.substring(path.indexOf('.', 6) + 1);
+        path = path.substring(path.indexOf('.') + 1);
         var paths = this._observePaths;
         for (var i=0; i<paths.length; i++) {
           if (path.indexOf(paths[i]) === 0) {
@@ -566,8 +567,6 @@
     // responsible for notifying item.<path> changes to inst for key
     _forwardItemPath: function(path, value) {
       if (this._itemsIdxToInstIdx) {
-        // slice off 'items.' ('items.'.length == 6)
-        path = path.slice(6);
         var dot = path.indexOf('.');
         var itemsIdx = path.substring(0, dot < 0 ? path.length : dot);
         var instIdx = this._itemsIdxToInstIdx[itemsIdx];

From c67a8aedede1cacf1d7f86bf6d66a5f5b1d0d2b4 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Fri, 23 Sep 2016 16:01:03 -0700
Subject: [PATCH 19/20] Refactoring, renaming.

---
 src/templatizer/dom-repeat.html | 38 ++++++++++++++++-----------------
 1 file changed, 18 insertions(+), 20 deletions(-)

diff --git a/src/templatizer/dom-repeat.html b/src/templatizer/dom-repeat.html
index 0c0c7d9b0d..ddd9fbfd1c 100644
--- a/src/templatizer/dom-repeat.html
+++ b/src/templatizer/dom-repeat.html
@@ -392,12 +392,7 @@
       }
       // If path was to an item (e.g. 'items.3' or 'items.3.foo'), forward the
       // path to that instance synchronously (retuns false for non-item paths)
-      let subPath = change.path.slice(6); // 'items.'.length == 6
-      if (this._forwardItemPath(subPath, change.value)) {
-        // For item paths, check if it was an observed path and if so, do a
-        // full refresh to re-sort/filter
-        this._checkObservedPaths(subPath);
-      } else {
+      if (!this._forwardItemPath(change.path, change.value)) {
         // Otherwise, the array was reset ('items') or spliced ('items.splices'),
         // so queue a full refresh
         this._needFullRefresh = true;
@@ -418,7 +413,7 @@
             } else {
               this._debounceRender();
             }
-            return;
+            return true;
           }
         }
       }
@@ -463,29 +458,29 @@
 
     _applyFullRefresh: function() {
       const items = this.items || [];
-      let viewOrder = new Array(items.length);
+      let isntIdxToItemsIdx = new Array(items.length);
       for (let i=0; i<items.length; i++) {
-        viewOrder[i] = i;
+        isntIdxToItemsIdx[i] = i;
       }
       // Apply user filter
       if (this._filterFn) {
-        viewOrder = viewOrder.filter((i, idx, array) =>
+        isntIdxToItemsIdx = isntIdxToItemsIdx.filter((i, idx, array) =>
           this._filterFn(items[i], idx, array));
       }
       // Apply user sort
       if (this._sortFn) {
-        viewOrder.sort((a, b) => this._sortFn(items[a], items[b]));
+        isntIdxToItemsIdx.sort((a, b) => this._sortFn(items[a], items[b]));
       }
       // items->inst map kept for item path forwarding
-      const idxMap = this._itemsIdxToInstIdx = {};
+      const itemsIdxToInstIdx = this._itemsIdxToInstIdx = {};
       let instIdx = 0;
       // Generate instances and assign items
-      const limit = Math.min(viewOrder.length, this._limit);
+      const limit = Math.min(isntIdxToItemsIdx.length, this._limit);
       for (; instIdx<limit; instIdx++) {
         let inst = this._instances[instIdx];
-        let itemIdx = viewOrder[instIdx];
+        let itemIdx = isntIdxToItemsIdx[instIdx];
         let item = items[itemIdx];
-        idxMap[itemIdx] = instIdx;
+        itemsIdxToInstIdx[itemIdx] = instIdx;
         if (inst && instIdx < this._limit) {
           inst.forwardProperty(this.as, item);
           inst.forwardProperty(this.indexAs, instIdx);
@@ -567,15 +562,18 @@
     // responsible for notifying item.<path> changes to inst for key
     _forwardItemPath: function(path, value) {
       if (this._itemsIdxToInstIdx) {
+        path = path.slice(6); // 'items.'.length == 6
         var dot = path.indexOf('.');
-        var itemsIdx = path.substring(0, dot < 0 ? path.length : dot);
+        var itemsIdx = dot < 0 ? path : path.substring(0, dot);
         var instIdx = this._itemsIdxToInstIdx[itemsIdx];
         var inst = this._instances[instIdx];
         if (inst) {
-          path = this.as + ((dot >= 0) ? ('.' + path.substring(dot+1)) : '');
-          inst.forwardProperty(path, value);
-          inst.flushProperties();
-          return true;
+          path = dot < 0 ? '' : path.substring(dot+1);
+          if (!this._checkObservedPaths(path)) {
+            inst.forwardProperty(this.as + (path ? '.' + path : ''), value);
+            inst.flushProperties();
+            return true;
+          }        
         }
       }
     },

From a2c7c69d2406e099e03b3b3908efe668a26b60d4 Mon Sep 17 00:00:00 2001
From: Kevin Schaaf <kschaaf@google.com>
Date: Fri, 23 Sep 2016 16:25:44 -0700
Subject: [PATCH 20/20] Refactor runEffects fallback for notifyPath. Fix lint.

---
 src/properties/batched-effects.html | 66 ++++++++++++++++++-----------
 test/unit/dom-repeat.html           |  1 +
 2 files changed, 42 insertions(+), 25 deletions(-)

diff --git a/src/properties/batched-effects.html b/src/properties/batched-effects.html
index f60533a4b1..b75127d177 100644
--- a/src/properties/batched-effects.html
+++ b/src/properties/batched-effects.html
@@ -69,12 +69,22 @@
     inst.__dataInterimOld = inst.__dataInterimOld ?
       utils.mixin(inst.__dataInterimOld, oldProps) : oldProps;
     // Notify
-    if (runEffects(inst, inst.PROPERTY_EFFECT_TYPES.NOTIFY, props, oldProps, notifyPaths)) {
-      // Flush host
-      let host = inst.__dataHost;
-      if (host && host.setProperties) {
-        host._flushProperties();
-      }      
+    let notified;
+    let notifyEffects = inst[inst.PROPERTY_EFFECT_TYPES.NOTIFY];
+    let id = effectUid++;
+    // Try normal notify effects; if none, fall back to try path notification
+    for (let prop in props) {
+      if (notifyEffects && runEffectsForProperty(inst, notifyEffects, id,
+        prop, inst.__data[prop], oldProps && oldProps[prop])) {
+        notified = true;
+      } else if (notifyPath(inst, prop, props[prop])) {
+        notified = true;
+      }
+    }
+    // Flush host if we actually notified and host was batching
+    let host;
+    if (notified && (host = inst.__dataHost) && host.setProperties) {
+      host._flushProperties();
     }
     // Combine & return interim data only for last entry
     if (runId == inst._runId) {
@@ -82,11 +92,11 @@
       oldProps = inst.__dataInterimOld;
       inst.__dataInterim = null;
       inst.__dataInterimOld = null;
-      return {changedProps: changedProps, oldProps: oldProps};
+      return { changedProps, oldProps };
     }
   }
 
-  function notifyPaths(inst, prop, value) {
+  function notifyPath(inst, prop, value) {
     let rootProperty = Polymer.Path.root(prop);
     if (rootProperty !== prop) {
       let name = Polymer.CaseMap.camelToDashCase(rootProperty) + '-changed';
@@ -96,29 +106,35 @@
     }
   }
 
-  function runEffects(inst, type, props, oldProps, fallback) {
+  function runEffects(inst, type, props, oldProps) {
     let ran;
     let effects = inst[type];
     if (effects) {
       let id = effectUid++;
       for (let prop in props) {
-        let rootProperty = Polymer.Path.root(prop);
-        let fxs = effects[rootProperty];
-        if (fxs) {
-          for (let i=0, l=fxs.length, fx; (i<l) && (fx=fxs[i]); i++) {
-            if (Polymer.Path.matches(fx.path, prop) &&
-              (!fx.info || fx.info.lastRun !== id)) {
-              fx.fn(inst, prop, inst.__data[prop],
-                  oldProps && oldProps[prop], fx.info, inst.__dataFromAbove);
-              if (fx.info) {
-                fx.info.lastRun = id;
-              }
-              ran = true;
-            }
+        if (runEffectsForProperty(inst, effects, id, prop, inst.__data[prop],
+          oldProps && oldProps[prop])) {
+          ran = true;
+        }
+      }
+    }
+    return ran;
+  }
+
+  function runEffectsForProperty(inst, effects, id, prop, value, old) {
+    let ran;
+    let rootProperty = Polymer.Path.root(prop);
+    let fxs = effects[rootProperty];
+    if (fxs) {
+      let fromAbove = inst.__dataFromAbove;
+      for (let i=0, l=fxs.length, fx; (i<l) && (fx=fxs[i]); i++) {
+        if (Polymer.Path.matches(fx.path, prop) &&
+          (!fx.info || fx.info.lastRun !== id)) {
+          fx.fn(inst, prop, value, old, fx.info, fromAbove);
+          if (fx.info) {
+            fx.info.lastRun = id;
           }
-        } else if (fallback && fallback(inst, prop, inst.__data[prop],
-            oldProps && oldProps[prop], inst.__dataFromAbove)) {
-          ran = true
+          ran = true;
         }
       }
     }
diff --git a/test/unit/dom-repeat.html b/test/unit/dom-repeat.html
index a165b466be..f73d777662 100644
--- a/test/unit/dom-repeat.html
+++ b/test/unit/dom-repeat.html
@@ -5695,6 +5695,7 @@ <h4>x-repeat-chunked</h4>
       });
 
       test('css scoping retained when re-ordering', function(done) {
+        var removed;
         if (!Polymer.Settings.useShadow) {
           // Confirm initial scoping
           var stamped = simple.root.querySelectorAll('*:not(template):not(dom-repeat)');