Fix errors

Author: wycats

packages/@glimmer-workspace/benchmark-env/lib/benchmark/create-registry.ts

@@ -89,13 +89,6 @@ export default function createRegistry(): Registry {
           document,
         },
         envDelegate,
-        sharedArtifacts,
-        {
-          lookupComponent: () => null,
-        }
-      );
-
-      const context = new EvaluationContextImpl(
         sharedArtifacts,
         {
           lookupHelper: (name) => helpers.get(name) ?? null,
@@ -104,7 +97,11 @@ export default function createRegistry(): Registry {
 
           lookupBuiltInHelper: () => null,
           lookupBuiltInModifier: () => null,
-        },
+        }
+      );
+
+      const context = new EvaluationContextImpl(
+        sharedArtifacts,
         (heap) => new RuntimeOpImpl(heap),
         runtime
       );
@@ -113,17 +110,7 @@ export default function createRegistry(): Registry {
         throw new Error(`missing ${entry} component`);
       }
 
-      return renderBenchmark(
-        sharedArtifacts,
-        context,
-        {
-          lookupComponent: () => null,
-        },
-        component,
-        args,
-        element as SimpleElement,
-        isInteractive
-      );
+      return renderBenchmark(context, component, args, element as SimpleElement);
     },
   };
 }

packages/@glimmer-workspace/benchmark-env/lib/benchmark/render-benchmark.ts

@@ -2,7 +2,6 @@ import type {
   Dict,
   EvaluationContext,
   ResolvedComponentDefinition,
-  RuntimeArtifacts,
   SimpleElement,
 } from '@glimmer/interfaces';
 import { NewTreeBuilder, renderComponent, renderSync } from '@glimmer/runtime';
@@ -13,7 +12,6 @@ import { registerResult } from './create-env-delegate';
 import { measureRender } from './util';
 
 export default async function renderBenchmark(
-  artifacts: RuntimeArtifacts,
   context: EvaluationContext,
   component: ResolvedComponentDefinition,
   args: Dict,

packages/@glimmer-workspace/integration-tests/lib/modes/rehydration/partial-rehydration-delegate.ts

@@ -16,13 +16,13 @@ export class PartialRehydrationDelegate extends RehydrationDelegate {
     element: SimpleElement
   ): RenderResult {
     let cursor = { element, nextSibling: null };
-    let { program, runtime } = this.clientEnv;
-    let builder = this.getElementBuilder(runtime.env, cursor) as DebugRehydrationBuilder;
+    let context = this.clientContext;
+    let builder = this.getElementBuilder(context.env, cursor) as DebugRehydrationBuilder;
     let component = this.clientRegistry.lookupComponent(name)!;
 
-    let iterator = renderComponent(runtime, builder, program, {}, component.state, args);
+    let iterator = renderComponent(context, builder, {}, component.state, args);
 
-    const result = renderSync(runtime.env, iterator);
+    const result = renderSync(context.env, iterator);
 
     this.rehydrationStats = {
       clearedNodes: builder.clearedNodes,
@@ -34,14 +34,14 @@ export class PartialRehydrationDelegate extends RehydrationDelegate {
   renderComponentServerSide(name: string, args: Dict<unknown>): string {
     const element = this.serverDoc.createElement('div');
     let cursor = { element, nextSibling: null };
-    let { program, runtime } = this.serverEnv;
-    let builder = this.getElementBuilder(runtime.env, cursor);
+    let context = this.serverContext;
+    let builder = this.getElementBuilder(context.env, cursor);
 
     let component = this.serverRegistry.lookupComponent(name)!;
 
-    let iterator = renderComponent(runtime, builder, program, {}, component.state, args);
+    let iterator = renderComponent(context, builder, {}, component.state, args);
 
-    renderSync(runtime.env, iterator);
+    renderSync(context.env, iterator);
 
     return this.serialize(element);
   }

packages/@glimmer-workspace/integration-tests/test/debug-render-tree-test.ts

@@ -254,12 +254,8 @@ class DebugRenderTreeTest extends RenderTest {
         args: (actual) => {
           const args = { positional: [], named: { arg: 'first', arg2: { error } } };
           this.assert.deepEqual(actual, args);
-          this.assert.ok(
-            !this.delegate.context.runtime.env.isArgumentCaptureError!(actual.named['arg'])
-          );
-          this.assert.ok(
-            this.delegate.context.runtime.env.isArgumentCaptureError!(actual.named['arg2'])
-          );
+          this.assert.ok(!this.delegate.context.env.isArgumentCaptureError!(actual.named['arg']));
+          this.assert.ok(this.delegate.context.env.isArgumentCaptureError!(actual.named['arg2']));
           return true;
         },
         instance: (instance: EmberishCurlyComponent) => (instance as any).arg === 'first',

packages/@glimmer/debug-util/lib/platform-utils.ts

@@ -10,14 +10,15 @@ export function unwrap<T>(val: Maybe<T>): T {
   return val as T;
 }
 
-export const expect = (
-  LOCAL_DEBUG
-    ? <T>(value: T, _message: string) => value
-    : <T>(val: T, message: string): Present<T> => {
-        if (LOCAL_DEBUG) if (val === null || val === undefined) throw new Error(message);
-        return val as Present<T>;
-      }
-) as <T>(value: T, message: string) => NonNullable<T>;
+export const expect = (LOCAL_DEBUG
+  ? <T>(value: T, _message: string) => value
+  : <T>(val: T, message: string): Present<T> => {
+      if (LOCAL_DEBUG) if (val === null || val === undefined) throw new Error(message);
+      return val as Present<T>;
+    }) as <T>(value: T, message: string) => NonNullable<T> as <T>(
+  value: T,
+  message: string
+) => Present<T>;
 
 export const unreachable = LOCAL_DEBUG
   ? () => {}

packages/@glimmer/interfaces/lib/managers/internal/component.d.ts

@@ -2,14 +2,14 @@ import type { ComponentInstanceState, PreparedArguments } from '../../components
 import type { Destroyable, Nullable } from '../../core.js';
 import type { Bounds } from '../../dom/bounds.js';
 import type { SimpleElement } from '../../dom/simple.js';
+import type { ClassicResolver } from '../../program.js';
 import type { Reference } from '../../references.js';
 import type { Owner } from '../../runtime.js';
 import type { CapturedArguments, VMArguments } from '../../runtime/arguments.js';
 import type { RenderNode } from '../../runtime/debug-render-tree.js';
 import type { ElementOperations } from '../../runtime/element.js';
 import type { Environment } from '../../runtime/environment.js';
 import type { DynamicScope } from '../../runtime/scope.js';
-import type { RuntimeResolver } from '../../serialize.js';
 import type { CompilableProgram } from '../../template.js';
 import type { ProgramSymbolTable } from '../../tier1/symbol-table.js';
 
@@ -237,7 +237,7 @@ export interface WithUpdateHook<ComponentInstanceState = unknown>
 
 export interface WithDynamicLayout<
   I = ComponentInstanceState,
-  R extends RuntimeResolver = RuntimeResolver,
+  R extends ClassicResolver = ClassicResolver,
 > extends InternalComponentManager<I> {
   // Return the compiled layout to use for this component. This is called
   // *after* the component instance has been created, because you might

packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/shared.ts

@@ -1,5 +1,5 @@
 import type {
-  ContainingMetadata,
+  BlockMetadata,
   LayoutWithContext,
   NamedBlocks,
   Nullable,
@@ -105,7 +105,7 @@ export function CompilePositional(
   return positional.length;
 }
 
-export function meta(layout: LayoutWithContext): ContainingMetadata {
+export function meta(layout: LayoutWithContext): BlockMetadata {
   let [, symbols, , upvars, debugSymbols] = layout.block;
 
   return {

packages/@glimmer/program/lib/constants.ts

@@ -1,13 +1,11 @@
 import type {
-  CompileTimeConstants,
   ComponentDefinition,
   ComponentDefinitionState,
   ConstantPool,
   HelperDefinitionState,
   ModifierDefinitionState,
-  ResolutionTimeConstants,
-  ResolvedComponentDefinition,
   ProgramConstants,
+  ResolvedComponentDefinition,
   Template,
 } from '@glimmer/interfaces';
 import { constants } from '@glimmer/constants';
@@ -30,14 +28,33 @@ const WELL_KNOWN_EMPTY_ARRAY: unknown = Object.freeze([]);
 const STARTER_CONSTANTS = constants(WELL_KNOWN_EMPTY_ARRAY);
 const WELL_KNOWN_EMPTY_ARRAY_POSITION: number = STARTER_CONSTANTS.indexOf(WELL_KNOWN_EMPTY_ARRAY);
 
-export class CompileTimeConstantImpl implements CompileTimeConstants {
-  // `0` means NULL
+export class ConstantsImpl implements ProgramConstants {
+  protected reifiedArrs: { [key: number]: unknown[] } = {
+    [WELL_KNOWN_EMPTY_ARRAY_POSITION]: WELL_KNOWN_EMPTY_ARRAY as unknown[],
+  };
+
+  defaultTemplate: Template = templateFactory(DEFAULT_TEMPLATE)();
+
+  // Used for tests and debugging purposes, and to be able to analyze large apps
+  // This is why it's enabled even in production
+  helperDefinitionCount = 0;
+  modifierDefinitionCount = 0;
+  componentDefinitionCount = 0;
 
-  protected values: unknown[] = STARTER_CONSTANTS.slice();
-  protected indexMap: Map<unknown, number> = new Map(
+  private values: unknown[] = STARTER_CONSTANTS.slice();
+  private indexMap: Map<unknown, number> = new Map(
     this.values.map((value, index) => [value, index])
   );
 
+  private helperDefinitionCache = new WeakMap<HelperDefinitionState, number | null>();
+
+  private modifierDefinitionCache = new WeakMap<ModifierDefinitionState, number | null>();
+
+  private componentDefinitionCache = new WeakMap<
+    ComponentDefinitionState | ResolvedComponentDefinition,
+    ComponentDefinition | null
+  >();
+
   value(value: unknown) {
     let indexMap = this.indexMap;
     let index = indexMap.get(value);
@@ -67,55 +84,6 @@ export class CompileTimeConstantImpl implements CompileTimeConstants {
   toPool(): ConstantPool {
     return this.values;
   }
-}
-
-export class RuntimeConstantsImpl implements ProgramConstants {
-  protected values: unknown[];
-
-  constructor(pool: ConstantPool) {
-    this.values = pool;
-  }
-
-  getValue<T>(handle: number) {
-    return this.values[handle] as T;
-  }
-
-  getArray<T>(value: number): T[] {
-    let handles = this.getValue<number[]>(value);
-    let reified: T[] = new Array(handles.length);
-
-    for (const [i, n] of enumerate(handles)) {
-      reified[i] = this.getValue(n);
-    }
-
-    return reified;
-  }
-}
-
-export class ConstantsImpl
-  extends CompileTimeConstantImpl
-  implements ProgramConstants, ResolutionTimeConstants
-{
-  protected reifiedArrs: { [key: number]: unknown[] } = {
-    [WELL_KNOWN_EMPTY_ARRAY_POSITION]: WELL_KNOWN_EMPTY_ARRAY as unknown[],
-  };
-
-  defaultTemplate: Template = templateFactory(DEFAULT_TEMPLATE)();
-
-  // Used for tests and debugging purposes, and to be able to analyze large apps
-  // This is why it's enabled even in production
-  helperDefinitionCount = 0;
-  modifierDefinitionCount = 0;
-  componentDefinitionCount = 0;
-
-  private helperDefinitionCache = new WeakMap<HelperDefinitionState, number | null>();
-
-  private modifierDefinitionCache = new WeakMap<ModifierDefinitionState, number | null>();
-
-  private componentDefinitionCache = new WeakMap<
-    ComponentDefinitionState | ResolvedComponentDefinition,
-    ComponentDefinition | null
-  >();
 
   helper(
     definitionState: HelperDefinitionState,

packages/@glimmer/program/lib/helpers.ts

@@ -1,11 +1,11 @@
 import type { RuntimeArtifacts } from '@glimmer/interfaces';
 
 import { ConstantsImpl } from './constants';
-import { HeapImpl } from './program';
+import { ProgramHeapImpl } from './program';
 
 export function artifacts(): RuntimeArtifacts {
   return {
     constants: new ConstantsImpl(),
-    heap: new HeapImpl(),
+    heap: new ProgramHeapImpl(),
   };
 }

packages/@glimmer/program/lib/opcode.ts

@@ -1,9 +1,9 @@
-import type { OpcodeHeap, RuntimeOp, SomeVmOp } from '@glimmer/interfaces';
+import type { ProgramHeap, RuntimeOp, SomeVmOp } from '@glimmer/interfaces';
 import { ARG_SHIFT, MACHINE_MASK, OPERAND_LEN_MASK, TYPE_MASK } from '@glimmer/vm';
 
 export class RuntimeOpImpl implements RuntimeOp {
   public offset = 0;
-  constructor(readonly heap: OpcodeHeap) {}
+  constructor(readonly heap: ProgramHeap) {}
 
   get size() {
     let rawType = this.heap.getbyaddr(this.offset);

packages/@glimmer/program/lib/program.ts

@@ -1,12 +1,11 @@
 import type {
-  JitConstants,
+  Program,
+  ProgramConstants,
   ProgramHeap,
-  RuntimeHeap,
-  RuntimeProgram,
   SerializedHeap,
   StdLibOperand,
 } from '@glimmer/interfaces';
-import { expect, unwrap } from '@glimmer/debug-util';
+import { unwrap } from '@glimmer/debug-util';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
 import { MACHINE_MASK } from '@glimmer/vm';
 
@@ -24,36 +23,6 @@ export type StdlibPlaceholder = [number, StdLibOperand];
 
 const PAGE_SIZE = 0x100000;
 
-export class RuntimeHeapImpl implements RuntimeHeap {
-  private heap: Int32Array;
-  private table: number[];
-
-  constructor(serializedHeap: SerializedHeap) {
-    let { buffer, table } = serializedHeap;
-    this.heap = new Int32Array(buffer);
-    this.table = table;
-  }
-
-  // It is illegal to close over this address, as compaction
-  // may move it. However, it is legal to use this address
-  // multiple times between compactions.
-  getaddr(handle: number): number {
-    return unwrap(this.table[handle]);
-  }
-
-  getbyaddr(address: number): number {
-    return expect(this.heap[address], 'Access memory out of bounds of the heap');
-  }
-
-  sizeof(handle: number): number {
-    return sizeof(this.table, handle);
-  }
-}
-
-export function hydrateHeap(serializedHeap: SerializedHeap): RuntimeHeap {
-  return new RuntimeHeapImpl(serializedHeap);
-}
-
 /**
  * The Heap is responsible for dynamically allocating
  * memory in which we read/write the VM's instructions
@@ -74,7 +43,7 @@ export function hydrateHeap(serializedHeap: SerializedHeap): RuntimeHeap {
  * valid during the execution. This means you cannot close
  * over them as you will have a bad memory access exception.
  */
-export class HeapImpl implements ProgramHeap, RuntimeHeap {
+export class ProgramHeapImpl implements ProgramHeap {
   offset = 0;
 
   private heap: Int32Array;
@@ -202,14 +171,14 @@ export class HeapImpl implements ProgramHeap, RuntimeHeap {
   }
 }
 
-export class RuntimeProgramImpl implements RuntimeProgram {
+export class ProgramImpl implements Program {
   [key: number]: never;
 
   private _opcode: RuntimeOpImpl;
 
   constructor(
-    public constants: JitConstants,
-    public heap: RuntimeHeap
+    public constants: ProgramConstants,
+    public heap: ProgramHeap
   ) {
     this._opcode = new RuntimeOpImpl(this.heap);
   }