[BUGFIX release] Fixes tag chaining on Proxy mixins

Currently, the Proxy mixin uses the private `UNKNOWN_PROPERTY_TAG` API
to provide the tags for the content property that the mixin is proxying
to. However, previously the chains system would do this _and_ still
entangle changes to the local property. This allowed users to manually
notify in subclasses of Proxy.

This PR adds the tag for the property back to the returned tag, so it
works the same as before. It also refactors `setupMandatorySetter`,
since we now have to do that work in two places (to avoid re-entry).

Author: Chris Garrett

packages/@ember/-internals/metal/lib/tags.ts

@@ -32,7 +32,7 @@ export function createTagForProperty(object: object, propertyKey: string | symbo
   let newTag = createUpdatableTag();
 
   if (DEBUG) {
-    setupMandatorySetter!(object, propertyKey);
+    setupMandatorySetter!(newTag, object, propertyKey);
 
     (newTag as any)._propertyKey = propertyKey;
   }

packages/@ember/-internals/runtime/lib/mixins/-proxy.js

@@ -63,10 +63,12 @@ export default Mixin.create({
   }),
 
   [CUSTOM_TAG_FOR](key) {
+    let tag = createTagForProperty(this, key);
+
     if (key in this) {
-      return createTagForProperty(this, key);
+      return tag;
     } else {
-      return combine(getChainTagsForKey(this, `content.${key}`));
+      return combine([tag, ...getChainTagsForKey(this, `content.${key}`)]);
     }
   },
 

packages/@ember/-internals/runtime/tests/system/object_proxy_test.js

@@ -338,5 +338,33 @@ moduleFor(
         observe: observer('foo', function() {}),
       }).create();
     }
+
+    async '@test custom proxies should be able to notify property changes manually'(assert) {
+      let proxy = ObjectProxy.extend({
+        locals: { foo: 123 },
+
+        unknownProperty(key) {
+          return this.locals[key];
+        },
+
+        setUnknownProperty(key, value) {
+          this.locals[key] = value;
+          this.notifyPropertyChange(key);
+        },
+      }).create();
+
+      let count = 0;
+
+      proxy.addObserver('foo', function() {
+        count++;
+      });
+
+      proxy.set('foo', 456);
+      await runLoopSettled();
+
+      assert.equal(count, 1);
+      assert.equal(proxy.get('foo'), 456);
+      assert.equal(proxy.get('locals.foo'), 456);
+    }
   }
 );

packages/@ember/-internals/utils/lib/mandatory-setter.ts

@@ -1,8 +1,12 @@
 import { assert } from '@ember/debug';
+import { _WeakSet as WeakSet } from '@ember/polyfills';
 import { DEBUG } from '@glimmer/env';
+import { Tag } from '@glimmer/reference';
 import lookupDescriptor from './lookup-descriptor';
 
-export let setupMandatorySetter: ((obj: object, keyName: string | symbol) => void) | undefined;
+export let setupMandatorySetter:
+  | ((tag: Tag, obj: object, keyName: string | symbol) => void)
+  | undefined;
 export let teardownMandatorySetter: ((obj: object, keyName: string | symbol) => void) | undefined;
 export let setWithMandatorySetter:
   | ((obj: object, keyName: string | symbol, value: any) => void)
@@ -11,6 +15,8 @@ export let setWithMandatorySetter:
 type PropertyDescriptorWithMeta = PropertyDescriptor & { hadOwnProperty?: boolean };
 
 if (DEBUG) {
+  let SEEN_TAGS = new WeakSet();
+
   let MANDATORY_SETTERS: WeakMap<
     object,
     // @ts-ignore
@@ -21,7 +27,13 @@ if (DEBUG) {
     return Object.prototype.propertyIsEnumerable.call(obj, key);
   };
 
-  setupMandatorySetter = function(obj: object, keyName: string | symbol) {
+  setupMandatorySetter = function(tag: Tag, obj: object, keyName: string | symbol) {
+    if (SEEN_TAGS.has(tag)) {
+      return;
+    }
+
+    SEEN_TAGS!.add(tag);
+
     let desc = (lookupDescriptor(obj, keyName) as PropertyDescriptorWithMeta) || {};
 
     if (desc.get || desc.set) {