Consolidate references and tags

benchmark/lib/build.js

@@ -26,16 +26,16 @@ async function build(dist, out) {
       strip({
         functions: ['assert', 'deprecate'],
       }),
-      terser({
-        compress: {
-          // eslint-disable-next-line @typescript-eslint/naming-convention
-          negate_iife: false,
-          sequences: 0,
-        },
-        output: {
-          semicolons: false,
-        },
-      }),
+      // terser({
+      //   compress: {
+      //     // eslint-disable-next-line @typescript-eslint/naming-convention
+      //     negate_iife: false,
+      //     sequences: 0,
+      //   },
+      //   output: {
+      //     semicolons: false,
+      //   },
+      // }),
     ],
     onwarn(warning) {
       let { code } = warning;

packages/@glimmer/benchmark-env/index.ts

@@ -1,4 +1,4 @@
 export { default as createCell } from './src/create-cell';
 export { default as createBenchmark } from './src/create-benchmark';
 
-export { Benchmark, Cell, ComponentArgs, UpdateBenchmark } from './src/interfaces';
+export { Benchmark, ComponentArgs, UpdateBenchmark, Cell } from './src/interfaces';

packages/@glimmer/benchmark-env/src/benchmark/args-proxy.ts

@@ -1,5 +1,5 @@
 import { CapturedNamedArguments, CapturedArguments } from '@glimmer/interfaces';
-import { valueForRef } from '@glimmer/reference';
+import { getValue } from '@glimmer/validator';
 import { ComponentArgs } from '../interfaces';
 
 class ArgsProxy implements ProxyHandler<CapturedNamedArguments> {
@@ -17,7 +17,7 @@ class ArgsProxy implements ProxyHandler<CapturedNamedArguments> {
   ): PropertyDescriptor | undefined {
     let desc: PropertyDescriptor | undefined;
     if (typeof p === 'string' && p in target) {
-      const value = valueForRef(target[p]);
+      const value = getValue(target[p]);
       desc = {
         enumerable: true,
         configurable: false,
@@ -34,7 +34,7 @@ class ArgsProxy implements ProxyHandler<CapturedNamedArguments> {
 
   get(target: CapturedNamedArguments, p: PropertyKey): any {
     if (typeof p === 'string' && p in target) {
-      return valueForRef(target[p]);
+      return getValue(target[p]);
     }
   }
 

packages/@glimmer/benchmark-env/src/benchmark/basic-component-manager.ts

@@ -1,5 +1,13 @@
-import { WithCreateInstance, Dict, VMArguments, Template, Owner } from '@glimmer/interfaces';
-import { createConstRef, Reference } from '@glimmer/reference';
+import {
+  WithCreateInstance,
+  Dict,
+  VMArguments,
+  Template,
+  Owner,
+  Source,
+  StorageSource,
+} from '@glimmer/interfaces';
+import { createConstStorage } from '@glimmer/validator';
 import { EMPTY_ARGS } from '@glimmer/runtime';
 import { getComponentTemplate } from '@glimmer/manager';
 import { ComponentArgs } from '../interfaces';
@@ -22,7 +30,7 @@ const BASIC_COMPONENT_CAPABILITIES = {
 };
 
 interface BasicState {
-  self: Reference<unknown>;
+  self: Source<unknown>;
   instance: object;
 }
 
@@ -32,9 +40,9 @@ class BasicComponentManager
     _owner: Owner,
     Component: { new (args: ComponentArgs): object },
     args: VMArguments | null
-  ) {
+  ): { instance: object; self: StorageSource } {
     const instance = new Component(argsProxy(args === null ? EMPTY_ARGS : args.capture()));
-    const self = createConstRef(instance, 'this');
+    const self = createConstStorage(instance, 'this');
     return { instance, self };
   }
 

packages/@glimmer/benchmark-env/src/benchmark/create-env-delegate.ts

@@ -104,12 +104,21 @@ setGlobalContext({
       console.warn(msg);
     }
   },
+
+  createClassicTrackedDecorator() {
+    throw new Error('Classic tracked decorators are not supported');
+  },
+
+  extendTrackedPropertyDesc() {},
 });
 
 export default function createEnvDelegate(isInteractive: boolean): EnvironmentDelegate {
   return {
     isInteractive,
     enableDebugTooling: false,
+    scheduleEffects(_phase, callback) {
+      callback();
+    },
     onTransactionCommit() {
       flush(scheduledDestructors);
       flush(scheduledFinalizers);

packages/@glimmer/benchmark-env/src/benchmark/on-modifier.ts

@@ -1,13 +1,12 @@
-import { CapturedArguments, InternalModifierManager, Owner } from '@glimmer/interfaces';
-import { Reference, valueForRef } from '@glimmer/reference';
+import { CapturedArguments, InternalModifierManager, Owner, Source } from '@glimmer/interfaces';
+import { getValue } from '@glimmer/validator';
 import { castToBrowser } from '@glimmer/util';
-import { createUpdatableTag } from '@glimmer/validator';
 import { SimpleElement } from '@simple-dom/interface';
 
 interface OnModifierState {
   element: SimpleElement;
-  nameRef: Reference<string>;
-  listenerRef: Reference<EventListener>;
+  nameRef: Source<string>;
+  listenerRef: Source<EventListener>;
   name: string | null;
   listener: EventListener | null;
 }
@@ -16,8 +15,8 @@ class OnModifierManager implements InternalModifierManager<OnModifierState, obje
   create(_owner: Owner, element: SimpleElement, _: {}, args: CapturedArguments) {
     return {
       element,
-      nameRef: args.positional[0] as Reference<string>,
-      listenerRef: args.positional[1] as Reference<EventListener>,
+      nameRef: args.positional[0] as Source<string>,
+      listenerRef: args.positional[1] as Source<EventListener>,
       name: null,
       listener: null,
     };
@@ -28,17 +27,17 @@ class OnModifierManager implements InternalModifierManager<OnModifierState, obje
   }
 
   install(state: OnModifierState) {
-    const name = valueForRef(state.nameRef);
-    const listener = valueForRef(state.listenerRef);
+    const name = getValue(state.nameRef);
+    const listener = getValue(state.listenerRef);
     castToBrowser(state.element, 'ELEMENT').addEventListener(name, listener);
     state.listener = listener;
     state.name = name;
   }
 
   update(state: OnModifierState) {
     const element = castToBrowser(state.element, 'ELEMENT');
-    const name = valueForRef(state.nameRef);
-    const listener = valueForRef(state.listenerRef);
+    const name = getValue(state.nameRef);
+    const listener = getValue(state.listenerRef);
     if (name !== state.name || listener !== state.listener) {
       element.removeEventListener(state.name!, state.listener!);
       element.addEventListener(name, listener);
@@ -50,10 +49,6 @@ class OnModifierManager implements InternalModifierManager<OnModifierState, obje
   getDestroyable(state: OnModifierState) {
     return state;
   }
-
-  getTag() {
-    return createUpdatableTag();
-  }
 }
 
 const onModifier: InternalModifierManager<unknown, object> = new OnModifierManager();

packages/@glimmer/benchmark-env/src/create-cell.ts

@@ -1,37 +1,20 @@
-import {
-  tagMetaFor,
-  consumeTag,
-  dirtyTagFor,
-  TagMeta,
-  tagFor,
-  UpdatableTag,
-} from '@glimmer/validator';
+import { createStorage, getValue, setValue } from '@glimmer/validator';
+import { StorageSource } from '@glimmer/interfaces';
 import { Cell } from './interfaces';
 
 class CellImpl<T> implements Cell<T> {
-  private _meta: TagMeta;
-  private _obj: object;
-  private _key: string;
-  private _tag: UpdatableTag;
-  private _value: T;
+  private storage: StorageSource<T>;
 
-  constructor(obj: object, key: string, initialValue: T) {
-    const meta = tagMetaFor(obj);
-    this._meta = meta;
-    this._obj = obj;
-    this._key = key;
-    this._tag = tagFor(obj, key, meta) as UpdatableTag;
-    this._value = initialValue;
+  constructor(_obj: object, _key: string, initialValue: T) {
+    this.storage = createStorage(initialValue);
   }
 
   get(): T {
-    consumeTag(this._tag);
-    return this._value;
+    return getValue(this.storage);
   }
 
   set(value: T) {
-    dirtyTagFor(this._obj, this._key, this._meta);
-    this._value = value;
+    setValue(this.storage, value);
   }
 }
 

packages/@glimmer/benchmark-env/src/interfaces.ts

@@ -1,6 +1,8 @@
 import { Dict, SerializedTemplateWithLazyBlock } from '@glimmer/interfaces';
 import { SimpleElement } from '@simple-dom/interface';
 
+export type ComponentArgs = Readonly<Dict<any>>;
+
 /**
  * This abstracts a tracked root.
  */
@@ -9,8 +11,6 @@ export interface Cell<T> {
   set(value: T): void;
 }
 
-export type ComponentArgs = Readonly<Dict<any>>;
-
 export interface Benchmark {
   /**
    * Register a template only component

packages/@glimmer/debug/lib/opcode-metadata.ts

@@ -1267,16 +1267,6 @@ METADATA[Op.CommitComponentTransaction] = {
   mnemonic: 'comp_commit',
   before: null,
   stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.DidCreateElement] = {
-  name: 'DidCreateElement',
-  mnemonic: 'comp_created',
-  before: null,
-  stackChange: 0,
   ops: [
     {
       name: 'state',
@@ -1287,9 +1277,9 @@ METADATA[Op.DidCreateElement] = {
   check: true,
 };
 
-METADATA[Op.DidRenderLayout] = {
-  name: 'DidRenderLayout',
-  mnemonic: 'comp_rendered',
+METADATA[Op.DidCreateElement] = {
+  name: 'DidCreateElement',
+  mnemonic: 'comp_created',
   before: null,
   stackChange: 0,
   ops: [

packages/@glimmer/global-context/index.ts

@@ -133,6 +133,31 @@ export let deprecate: (
   }
 ) => void;
 
+/**
+ * Hook to create a classic decorator version of tracked, for usage in Ember's
+ * classic classes
+ */
+export let createClassicTrackedDecorator: (
+  args: unknown[]
+) => (
+  target: object,
+  key: string,
+  desc: (PropertyDescriptor & { initializer?: any }) | undefined
+) => unknown;
+
+/**
+ * Hook to customize the tracked property descriptor, adding to the get/set and
+ * adding any other relevant changes
+ */
+export let extendTrackedPropertyDesc: (
+  target: object,
+  key: string,
+  desc: {
+    get: () => unknown;
+    set: (value: unknown) => void;
+  }
+) => void;
+
 //////////
 
 export interface GlobalContext {
@@ -154,6 +179,18 @@ export interface GlobalContext {
       id: string;
     }
   ) => void;
+  createClassicTrackedDecorator: (
+    args: unknown[]
+  ) => (
+    target: object,
+    key: string,
+    desc: (PropertyDescriptor & { initializer?: any }) | undefined
+  ) => unknown;
+  extendTrackedPropertyDesc: (
+    target: object,
+    key: string,
+    desc: { get: () => unknown; set: (value: unknown) => void }
+  ) => void;
 }
 
 let globalContextWasSet = false;
@@ -179,6 +216,8 @@ export default function setGlobalContext(context: GlobalContext) {
   warnIfStyleNotTrusted = context.warnIfStyleNotTrusted;
   assert = context.assert;
   deprecate = context.deprecate;
+  createClassicTrackedDecorator = context.createClassicTrackedDecorator;
+  extendTrackedPropertyDesc = context.extendTrackedPropertyDesc;
 }
 
 export let assertGlobalContextWasSet: (() => void) | undefined;
@@ -210,6 +249,8 @@ if (DEBUG) {
           warnIfStyleNotTrusted,
           assert,
           deprecate,
+          createClassicTrackedDecorator,
+          extendTrackedPropertyDesc,
         }
       : null;
 
@@ -233,6 +274,8 @@ if (DEBUG) {
     warnIfStyleNotTrusted = context?.warnIfStyleNotTrusted || (undefined as any);
     assert = context?.assert || (undefined as any);
     deprecate = context?.deprecate || (undefined as any);
+    createClassicTrackedDecorator = context?.createClassicTrackedDecorator || (undefined as any);
+    extendTrackedPropertyDesc = context?.extendTrackedPropertyDesc || (undefined as any);
 
     return originalGlobalContext;
   };

packages/@glimmer/integration-tests/index.ts

@@ -17,6 +17,5 @@ export * from './lib/suites';
 export * from './lib/test-helpers/module';
 export * from './lib/test-helpers/strings';
 export * from './lib/test-helpers/test';
-export * from './lib/test-helpers/tracked';
 export * from './lib/test-helpers/tracked-object';
 export * from './lib/test-helpers/define';