Refactor Meta and object destruction tracking.

* Moves the `isDestroying` and `isDestroyed` flags into meta
* Prevents recreating meta _while_ destroying the object (was happening
  during chain node removal)
* Allows reading values/caches after object destruction, but triggers an
  assertion if non-readable meta methods are called after the object is
  destroyed
* Avoids doing extra work when unwatching keys/paths for an object that
  is also destroyed
* Use bitwise flagging instead of many boolean properties for meta, and
  expose helpful methods to interact with them
* Move chains cleanup to `Meta#destroy`.

Author: Robert Jackson

packages/ember-metal/lib/chains.js

@@ -116,23 +116,23 @@ function addChainWatcher(obj, keyName, node) {
   watchKey(obj, keyName, m);
 }
 
-function removeChainWatcher(obj, keyName, node) {
+function removeChainWatcher(obj, keyName, node, _meta) {
   if (!isObject(obj)) {
     return;
   }
 
-  let m = peekMeta(obj);
+  let meta = _meta || peekMeta(obj);
 
-  if (!m || !m.readableChainWatchers()) {
+  if (!meta || !meta.readableChainWatchers()) {
     return;
   }
 
   // make meta writable
-  m = metaFor(obj);
+  meta = metaFor(obj);
 
-  m.readableChainWatchers().remove(keyName, node);
+  meta.readableChainWatchers().remove(keyName, node);
 
-  unwatchKey(obj, keyName, m);
+  unwatchKey(obj, keyName, meta);
 }
 
 // A ChainNode watches a single key on an object. If you provide a starting

packages/ember-metal/lib/meta.js

@@ -5,7 +5,10 @@
 import { EmptyObject, lookupDescriptor, symbol } from 'ember-utils';
 import isEnabled from './features';
 import { protoMethods as listenerMethods } from './meta_listeners';
-import { runInDebug } from './debug';
+import { runInDebug, assert } from './debug';
+import {
+  removeChainWatcher
+} from './chains';
 
 let counters = {
   peekCalls: 0,
@@ -55,6 +58,12 @@ let members = {
   tag: ownCustomObject
 };
 
+const FLAGS = {
+  sourceDestroying: 1 << 1,
+  sourceDestroyed: 1 << 2,
+  metaDestroyed: 1 << 3
+};
+
 if (isEnabled('ember-glimmer-detect-backtracking-rerender') ||
     isEnabled('ember-glimmer-allow-backtracking-rerender')) {
   members.lastRendered = ownMap;
@@ -78,6 +87,10 @@ export function Meta(obj, parentMeta) {
   this._chains = undefined;
   this._tag = undefined;
 
+  // initial value for all flags right now is false
+  // see FLAGS const for detailed list of flags used
+  this._flags = 0;
+
   // used only internally
   this.source = obj;
 
@@ -104,11 +117,70 @@ Meta.prototype.isInitialized = function(obj) {
   return this.proto !== obj;
 };
 
+const NODE_STACK = [];
+
+Meta.prototype.destroy = function() {
+  // remove chainWatchers to remove circular references that would prevent GC
+
+  let node, nodes, key, nodeObject;
+  node = this.readableChains();
+  if (node) {
+    NODE_STACK.push(node);
+    // process tree
+    while (NODE_STACK.length > 0) {
+      node = NODE_STACK.pop();
+      // push children
+      nodes = node._chains;
+      if (nodes) {
+        for (key in nodes) {
+          if (nodes[key] !== undefined) {
+            NODE_STACK.push(nodes[key]);
+          }
+        }
+      }
+
+      // remove chainWatcher in node object
+      if (node._watching) {
+        nodeObject = node._object;
+        if (nodeObject) {
+          let foreignMeta = peekMeta(nodeObject);
+          // avoid cleaning up chain watchers when both current and
+          // foreign objects are being destroyed
+          if (foreignMeta && !foreignMeta.isSourceDestroying()) {
+            removeChainWatcher(nodeObject, node._key, node, foreignMeta);
+          }
+        }
+      }
+    }
+  }
+
+  this.setMetaDestroyed();
+};
+
 for (let name in listenerMethods) {
   Meta.prototype[name] = listenerMethods[name];
 }
 memberNames.forEach(name => members[name](name, Meta));
 
+for (let name in FLAGS) {
+  buildFlagAccessors(name, FLAGS[name], Meta);
+}
+
+function buildFlagAccessors(name, flag, Meta) {
+  let capitalized = capitalize(name);
+  Meta.prototype['is' + capitalized] = function() {
+    return (this._flags & flag) !== 0;
+  };
+
+  Meta.prototype['set' + capitalized] = function() {
+    this._flags |= flag;
+  };
+
+  Meta.prototype['unset' + capitalized] = function() {
+    this._flags &= ~flag;
+  };
+}
+
 // Implements a member that is a lazily created, non-inheritable
 // POJO.
 function ownMap(name, Meta) {
@@ -135,6 +207,8 @@ function inheritedMap(name, Meta) {
   let capitalized = capitalize(name);
 
   Meta.prototype['write' + capitalized] = function(subkey, value) {
+    assert(`Cannot call write${capitalized} after the object is destroyed.`, !this.isMetaDestroyed());
+
     let map = this._getOrCreateOwnMap(key);
     map[subkey] = value;
   };
@@ -161,6 +235,8 @@ function inheritedMap(name, Meta) {
   };
 
   Meta.prototype['clear' + capitalized] = function() {
+    assert(`Cannot call clear${capitalized} after the object is destroyed.`, !this.isMetaDestroyed());
+
     this[key] = undefined;
   };
 
@@ -206,6 +282,8 @@ function inheritedMapOfMaps(name, Meta) {
   let capitalized = capitalize(name);
 
   Meta.prototype['write' + capitalized] = function(subkey, itemkey, value) {
+    assert(`Cannot call write${capitalized} after the object is destroyed.`, !this.isMetaDestroyed());
+
     let outerMap = this._getOrCreateOwnMap(key);
     let innerMap = outerMap[subkey];
     if (!innerMap) {
@@ -277,6 +355,8 @@ function ownCustomObject(name, Meta) {
   let key = memberProperty(name);
   let capitalized = capitalize(name);
   Meta.prototype['writable' + capitalized] = function(create) {
+    assert(`Cannot call writable${capitalized} after the object is destroyed.`, !this.isMetaDestroyed());
+
     let ret = this[key];
     if (!ret) {
       ret = this[key] = create(this.source);
@@ -295,6 +375,8 @@ function inheritedCustomObject(name, Meta) {
   let key = memberProperty(name);
   let capitalized = capitalize(name);
   Meta.prototype['writable' + capitalized] = function(create) {
+    assert(`Cannot call writable${capitalized} after the object is destroyed.`, !this.isMetaDestroyed());
+
     let ret = this[key];
     if (!ret) {
       if (this.parent) {
@@ -376,7 +458,7 @@ const HAS_NATIVE_WEAKMAP = (function() {
   return Object.prototype.toString.call(instance) === '[object WeakMap]';
 })();
 
-let setMeta, peekMeta, deleteMeta;
+let setMeta, peekMeta;
 
 // choose the one appropriate for given platform
 if (HAS_NATIVE_WEAKMAP) {
@@ -412,14 +494,6 @@ if (HAS_NATIVE_WEAKMAP) {
       runInDebug(() => counters.peakPrototypeWalks++);
     }
   };
-
-  deleteMeta = function WeakMap_deleteMeta(obj) {
-    runInDebug(() => counters.deleteCalls++);
-
-    // set value to `null` so that we can detect
-    // a deleted meta in peekMeta later
-    metaStore.set(obj, null);
-  };
 } else {
   setMeta = function Fallback_setMeta(obj, meta) {
     // if `null` already, just set it to the new value
@@ -438,13 +512,15 @@ if (HAS_NATIVE_WEAKMAP) {
   peekMeta = function Fallback_peekMeta(obj) {
     return obj[META_FIELD];
   };
+}
 
-  deleteMeta = function Fallback_deleteMeta(obj) {
-    if (typeof obj[META_FIELD] !== 'object') {
-      return;
-    }
-    obj[META_FIELD] = null;
-  };
+export function deleteMeta(obj) {
+  runInDebug(() => counters.deleteCalls++);
+
+  let meta = peekMeta(obj);
+  if (meta) {
+    meta.destroy();
+  }
 }
 
 /**
@@ -487,6 +563,5 @@ export function meta(obj) {
 export {
   peekMeta,
   setMeta,
-  deleteMeta,
   counters
 };