[REFACTOR] Extract environment variables into global context

packages/@glimmer/benchmark-env/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@glimmer/benchmark-env",
-  "version": "0.56.1",
+  "version": "0.58.0",
   "private": true,
   "repository": "https://github.com/glimmerjs/glimmer-vm/tree/master/packages/@glimmer/benchmark-env",
   "dependencies": {
-    "@glimmer/reference": "^0.56.1",
-    "@glimmer/runtime": "^0.56.1",
-    "@glimmer/validator": "^0.56.1",
-    "@glimmer/util": "^0.56.1",
-    "@glimmer/interfaces": "^0.56.1",
-    "@glimmer/opcode-compiler": "^0.56.1",
+    "@glimmer/global-context": "^0.58.0",
+    "@glimmer/reference": "^0.58.0",
+    "@glimmer/runtime": "^0.58.0",
+    "@glimmer/validator": "^0.58.0",
+    "@glimmer/util": "^0.58.0",
+    "@glimmer/interfaces": "^0.58.0",
+    "@glimmer/opcode-compiler": "^0.58.0",
     "@simple-dom/interface": "^1.4.0"
   },
   "devDependencies": {

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

@@ -34,7 +34,7 @@ class BasicComponentManager
     args: VMArguments | null
   ) {
     const instance = new Component(argsProxy(args === null ? EMPTY_ARGS : args.capture()));
-    const self = new ComponentRootReference(instance, env);
+    const self = new ComponentRootReference(instance);
     return { env, instance, self };
   }
 

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

@@ -1,5 +1,6 @@
-import { EnvironmentDelegate, setScheduleDestroyed, setScheduleDestroy } from '@glimmer/runtime';
-import { Destroyable, Destructor } from '@glimmer/interfaces';
+import { EnvironmentDelegate } from '@glimmer/runtime';
+import { Destroyable, Destructor, RenderResult } from '@glimmer/interfaces';
+import setGlobalContext from '@glimmer/global-context';
 
 type Queue = (() => void)[];
 
@@ -11,17 +12,69 @@ function flush(queue: Queue) {
   queue.length = 0;
 }
 
-setScheduleDestroy(<T extends Destroyable>(destroyable: T, destructor: Destructor<T>) => {
-  scheduledDestructors.push(() => destructor(destroyable));
-});
+let result: RenderResult;
+let resolveRender: () => void;
+
+export function registerResult(_result: RenderResult, _resolveRender: () => void) {
+  result = _result;
+  resolveRender = _resolveRender;
+}
+
+let revalidateScheduled = false;
+
+setGlobalContext({
+  scheduleRevalidate() {
+    if (!revalidateScheduled) {
+      Promise.resolve().then(() => {
+        const { env } = result;
+        env.begin();
+        result.rerender();
+        revalidateScheduled = false;
+        env.commit();
+        // only resolve if commit didn't dirty again
+        if (!revalidateScheduled && resolveRender !== undefined) {
+          resolveRender();
+        }
+      });
+    }
+  },
+
+  getProp(obj: unknown, prop: string) {
+    return (obj as Record<string, unknown>)[prop];
+  },
+
+  setProp(obj: unknown, prop: string, value) {
+    (obj as Record<string, unknown>)[prop] = value;
+  },
+
+  getPath(obj: unknown, path: string) {
+    return (obj as Record<string, unknown>)[path];
+  },
+
+  toBool(value) {
+    return Boolean(value);
+  },
+
+  toIterator() {
+    return null;
+  },
+
+  warnIfStyleNotTrusted() {},
+
+  scheduleDestroy<T extends Destroyable>(destroyable: T, destructor: Destructor<T>) {
+    scheduledDestructors.push(() => destructor(destroyable));
+  },
 
-setScheduleDestroyed((fn: () => void) => {
-  scheduledFinalizers.push(fn);
+  scheduleDestroyed(fn: () => void) {
+    scheduledFinalizers.push(fn);
+  },
 });
 
 export default function createEnvDelegate(isInteractive: boolean): EnvironmentDelegate {
   return {
     isInteractive,
+    extra: undefined,
+    onTransactionBegin() {},
     onTransactionCommit() {
       flush(scheduledDestructors);
       flush(scheduledFinalizers);

packages/@glimmer/benchmark-env/src/benchmark/if-helper.ts

@@ -1,24 +1,16 @@
-import { VMArguments, VM } from '@glimmer/interfaces';
-import {
-  Reference,
-  PathReference,
-  CachedReference,
-  PropertyReference,
-  TemplateReferenceEnvironment,
-} from '@glimmer/reference';
+import { VMArguments } from '@glimmer/interfaces';
+import { Reference, PathReference, CachedReference, PropertyReference } from '@glimmer/reference';
 
 class IfHelperReference extends CachedReference<unknown> {
   condition: Reference;
   truthyValue: Reference;
   falsyValue: Reference | undefined;
-  env: TemplateReferenceEnvironment;
 
-  constructor({ positional }: VMArguments, env: TemplateReferenceEnvironment) {
+  constructor({ positional }: VMArguments) {
     super();
     this.condition = positional.at(0);
     this.truthyValue = positional.at(1);
     this.falsyValue = positional.length > 2 ? positional.at(2) : undefined;
-    this.env = env;
   }
 
   compute() {
@@ -33,10 +25,10 @@ class IfHelperReference extends CachedReference<unknown> {
   }
 
   get(key: string): PathReference {
-    return new PropertyReference(this, key, this.env);
+    return new PropertyReference(this, key);
   }
 }
 
-export default function ifHelper(args: VMArguments, vm: VM): PathReference {
-  return new IfHelperReference(args, vm.env);
+export default function ifHelper(args: VMArguments): PathReference {
+  return new IfHelperReference(args);
 }

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

@@ -5,7 +5,6 @@ import {
   ComponentDefinition,
   CompilableProgram,
 } from '@glimmer/interfaces';
-import { setPropertyDidChange } from '@glimmer/validator';
 import { ComponentRootReference, PathReference } from '@glimmer/reference';
 import {
   NewElementBuilder,
@@ -15,7 +14,7 @@ import {
   renderJitComponent,
 } from '@glimmer/runtime';
 
-import createEnvDelegate from './create-env-delegate';
+import createEnvDelegate, { registerResult } from './create-env-delegate';
 import { measureRender } from './util';
 import { UpdateBenchmark } from '../interfaces';
 
@@ -29,6 +28,7 @@ export default async function renderBenchmark(
   isInteractive = true
 ): Promise<UpdateBenchmark> {
   let resolveRender: (() => void) | undefined;
+
   await measureRender('render', 'renderStart', 'renderEnd', () => {
     const document = element.ownerDocument;
     const envDelegate = createEnvDelegate(isInteractive);
@@ -43,7 +43,7 @@ export default async function renderBenchmark(
     const env = runtime.env;
     const cursor = { element, nextSibling: null };
     const treeBuilder = NewElementBuilder.forInitialRender(env, cursor);
-    const rootRef = new ComponentRootReference(root, env);
+    const rootRef = new ComponentRootReference(root);
 
     const args: Dict<PathReference> = {};
     for (const key of Object.keys(root)) {
@@ -55,21 +55,10 @@ export default async function renderBenchmark(
       renderJitComponent(runtime, treeBuilder, context, component, layout, args)
     );
 
-    let scheduled = false;
-    setPropertyDidChange(() => {
-      if (!scheduled) {
-        Promise.resolve().then(() => {
-          const { env } = result;
-          env.begin();
-          result.rerender();
-          scheduled = false;
-          env.commit();
-          // only resolve if commit didn't dirty again
-          if (!scheduled && resolveRender !== undefined) {
-            resolveRender();
-            resolveRender = undefined;
-          }
-        });
+    registerResult(result, () => {
+      if (resolveRender !== undefined) {
+        resolveRender();
+        resolveRender = undefined;
       }
     });
   });