cleanup? does ai know what cleanup is?

NullVoxPopuli · NullVoxPopuli · commit 19079169a072 · 2026-03-06T16:17:49.000-05:00
diff --git a/packages/@glimmer-workspace/integration-tests/lib/compile.ts b/packages/@glimmer-workspace/integration-tests/lib/compile.ts
@@ -28,10 +28,6 @@ export function createTemplate(
     usedLocals.map((key) => [key, scopeValues[key]])
   );
 
-  if ('emit' in options && options.emit?.debugSymbols) {
-    block.push(usedLocals);
-  }
-
   let templateBlock: SerializedTemplateWithLazyBlock = {
     id: String(templateId++),
     block: JSON.stringify(block),
diff --git a/packages/@glimmer/compiler/lib/compiler.ts b/packages/@glimmer/compiler/lib/compiler.ts
@@ -119,10 +119,6 @@ export function precompile(
 ): TemplateJavascript {
   const [block, usedLexicals] = precompileJSON(source, options);
 
-  if ('emit' in options && options.emit?.debugSymbols && usedLexicals.length > 0) {
-    block.push(usedLexicals);
-  }
-
   const moduleName = options.meta?.moduleName;
   const idFn = options.id || defaultId;
   const blockJSON = JSON.stringify(block);
diff --git a/packages/@glimmer/compiler/lib/passes/2-encoding/content.ts b/packages/@glimmer/compiler/lib/passes/2-encoding/content.ts
@@ -56,7 +56,7 @@ export class ContentEncoder {
   private visitContent(stmt: mir.Statement): WireFormat.Statement | WireStatements {
     switch (stmt.type) {
       case 'Debugger':
-        return [SexpOpcodes.Debugger, ...stmt.scope.getDebugInfo()];
+        return [SexpOpcodes.Debugger, stmt.scope.getDebugInfo()];
       case 'AppendComment':
         return this.AppendComment(stmt);
       case 'AppendTextNode':
diff --git a/packages/@glimmer/debug/lib/dism/opcode.ts b/packages/@glimmer/debug/lib/dism/opcode.ts
@@ -21,11 +21,7 @@ import { array } from '../render/combinators';
 import { as, frag, Fragment } from '../render/fragment';
 
 export class SerializeBlockContext {
-  readonly #symbols: Nullable<BlockSymbolNames>;
-
-  constructor(symbols: Nullable<BlockSymbolNames>) {
-    this.#symbols = symbols;
-  }
+  constructor(_symbols: Nullable<BlockSymbolNames>) {}
 
   serialize(param: SomeDisassembledOperand): IntoFragment {
     switch (param.type) {
@@ -47,12 +43,6 @@ export class SerializeBlockContext {
         const value = param.value;
         if (value === 0) {
           return frag`{${as.kw('this')}}`;
-        } else if (this.#symbols?.lexical && this.#symbols.lexical.length >= value) {
-          // @fixme something is wrong here -- remove the `&&` to get test failures
-          return frag`${as.varReference(
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
-            this.#symbols.lexical[value - 1]!
-          )}${frag`:${value}`.subtle()}`;
         } else {
           return frag`{${as.register('$fp')}+${value}}`;
         }
@@ -87,8 +77,6 @@ export class SerializeBlockContext {
       case 'variable': {
         if (value === 0) {
           return `{this}`;
-        } else if (this.#symbols?.lexical && this.#symbols.lexical.length >= (value as number)) {
-          return `{${this.#symbols.lexical[(value as number) - 1]}:${value}}`;
         } else {
           return `{$fp+${value}}`;
         }
diff --git a/packages/@glimmer/debug/lib/dism/operands.ts b/packages/@glimmer/debug/lib/dism/operands.ts
@@ -91,8 +91,8 @@ export const OPERANDS = Disassembler.build((d) => {
     ])
     .add(['register'], ({ value }) => ['register', decodeRegister(value)])
     .add(['const/any'], ({ value, constants }) => ['dynamic', constants.getValue<unknown>(value)])
-    .add(['variable'], ({ value, meta }) => {
-      return ['variable', value, { name: meta?.symbols.lexical?.at(value) ?? null }];
+    .add(['variable'], ({ value }) => {
+      return ['variable', value, { name: value === 0 ? 'this' : null }];
     })
     .add(['register/instruction'], ({ value }) => ['instruction', value])
     .add(['imm/enum<curry>'], ({ value }) => ['enum<curry>', decodeCurry(value)])
diff --git a/packages/@glimmer/debug/lib/render/basic.ts b/packages/@glimmer/debug/lib/render/basic.ts
@@ -63,7 +63,7 @@ export function value(item: unknown, options?: ValueRefOptions): Fragment {
         table.parameters.length === 0
           ? empty()
           : frag` as |${join(
-              table.parameters.map((s) => item.meta.symbols.lexical?.at(s - 1) ?? `?${s}`),
+              table.parameters.map((s) => `?${s}`),
               ' '
             )}|`;
       return debugValue(item, {
diff --git a/packages/@glimmer/interfaces/lib/compile/operands.d.ts b/packages/@glimmer/interfaces/lib/compile/operands.d.ts
@@ -33,11 +33,7 @@ export interface IsStrictModeOperand {
 
 export interface DebugSymbolsOperand {
   type: DebugSymbolsOperandType;
-  value: {
-    locals: Record<string, number>;
-    upvars: Record<string, number>;
-    lexical: Record<string, number>;
-  };
+  value: Record<string, number>;
 }
 
 export interface BlockOperand {
diff --git a/packages/@glimmer/interfaces/lib/compile/wire-format/api.d.ts b/packages/@glimmer/interfaces/lib/compile/wire-format/api.d.ts
@@ -72,11 +72,7 @@ export type SexpOpcode = keyof SexpOpcodeMap;
 export namespace Core {
   export type Expression = Expressions.Expression;
 
-  export type DebugSymbols = [
-    locals: Record<string, number>,
-    upvars: Record<string, number>,
-    lexical: Record<string, number>,
-  ];
+  export type DebugSymbols = Record<string, number>;
 
   export type CallArgs = [Params, Hash];
   export type Path = [string, ...string[]];
@@ -259,12 +255,7 @@ export namespace Statements {
     | TrustingDynamicAttr
     | TrustingComponentAttr;
 
-  export type Debugger = [
-    op: DebuggerOpcode,
-    locals: Record<string, number>,
-    upvars: Record<string, number>,
-    lexical: Record<string, number>,
-  ];
+  export type Debugger = [op: DebuggerOpcode, locals: Record<string, number>];
   export type InElement = [
     op: InElementOpcode,
     block: SerializedInlineBlock,
@@ -375,9 +366,8 @@ export type SerializedInlineBlock = [statements: Statements.Statement[], paramet
  */
 export type SerializedTemplateBlock = [
   statements: Statements.Statement[],
-  locals: string[],
+  symbols: string[],
   upvars: string[],
-  lexicalSymbols?: string[],
 ];
 
 /**
diff --git a/packages/@glimmer/interfaces/lib/template.d.ts b/packages/@glimmer/interfaces/lib/template.d.ts
@@ -1,7 +1,7 @@
 import type { PresentArray } from './array.js';
 import type { EncoderError } from './compile/encoder.js';
 import type { Operand, SerializedInlineBlock, SerializedTemplateBlock } from './compile/index.js';
-import type { Nullable, Optional } from './core.js';
+import type { Nullable } from './core.js';
 import type { InternalComponentCapabilities } from './managers/internal/component.js';
 import type { ConstantPool, EvaluationContext, SerializedHeap } from './program.js';
 import type { Owner } from './runtime.js';
@@ -105,16 +105,10 @@ export interface CompilableTemplate<S extends SymbolTable = SymbolTable> {
 }
 
 export interface BlockSymbolNames {
-  locals: Nullable<string[]>;
-  lexical?: Optional<string[]>;
   upvars: Nullable<string[]>;
 }
 
-export interface DebuggerInfo {
-  locals: Record<string, number>;
-  lexical: Record<string, number>;
-  upvars: Record<string, number>;
-}
+export type DebuggerInfo = Record<string, number>;
 
 export interface BlockMetadata {
   symbols: BlockSymbolNames;
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/shared.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/shared.ts
@@ -106,18 +106,16 @@ export function CompilePositional(
 }
 
 export function meta(layout: LayoutWithContext): BlockMetadata {
-  let [, locals, upvars, lexicalSymbols] = layout.block;
+  let [, symbols, upvars] = layout.block;
 
   return {
     symbols: {
-      locals,
       upvars,
-      lexical: lexicalSymbols,
     },
     scopeValues: layout.scope?.() ?? null,
     isStrictMode: layout.isStrictMode,
     moduleName: layout.moduleName,
     owner: layout.owner,
-    size: locals.length,
+    size: symbols.length,
   };
 }
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/stdlib.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/stdlib.ts
@@ -118,7 +118,6 @@ export function compileStd(context: EvaluationContext): StdLib {
 
 export const STDLIB_META: BlockMetadata = {
   symbols: {
-    locals: null,
     upvars: null,
   },
   moduleName: 'stdlib',
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/operands.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/operands.ts
@@ -38,12 +38,8 @@ export function labelOperand(value: string): LabelOperand {
   return { type: HighLevelOperands.Label, value };
 }
 
-export function debugSymbolsOperand(
-  locals: Record<string, number>,
-  upvars: Record<string, number>,
-  lexical: Record<string, number>
-): DebugSymbolsOperand {
-  return { type: HighLevelOperands.DebugSymbols, value: { locals, upvars, lexical } };
+export function debugSymbolsOperand(locals: Record<string, number>): DebugSymbolsOperand {
+  return { type: HighLevelOperands.DebugSymbols, value: locals };
 }
 
 export function isStrictMode(): IsStrictModeOperand {
diff --git a/packages/@glimmer/opcode-compiler/lib/syntax/statements.ts b/packages/@glimmer/opcode-compiler/lib/syntax/statements.ts
@@ -163,8 +163,8 @@ STATEMENTS.add(SexpOpcodes.Yield, (op, [, to, params]) => YieldBlock(op, to, par
 
 STATEMENTS.add(SexpOpcodes.AttrSplat, (op, [, to]) => YieldBlock(op, to, null));
 
-STATEMENTS.add(SexpOpcodes.Debugger, (op, [, locals, upvars, lexical]) => {
-  op(VM_DEBUGGER_OP, debugSymbolsOperand(locals, upvars, lexical));
+STATEMENTS.add(SexpOpcodes.Debugger, (op, [, locals]) => {
+  op(VM_DEBUGGER_OP, debugSymbolsOperand(locals));
 });
 
 STATEMENTS.add(SexpOpcodes.Append, (op, [, value]) => {
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/debugger.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/debugger.ts
@@ -35,18 +35,13 @@ export function resetDebuggerCallback() {
 }
 
 class ScopeInspector {
-  #symbols: DebuggerInfo;
-
   constructor(
     private scope: Scope,
-    symbols: DebuggerInfo
-  ) {
-    this.#symbols = symbols;
-  }
+    private symbols: DebuggerInfo
+  ) {}
 
   get(path: string): Reference {
-    let { scope } = this;
-    let symbols = this.#symbols;
+    let { scope, symbols } = this;
 
     let parts = path.split('.');
     let [head, ...tail] = path.split('.') as [string, ...string[]];
@@ -55,8 +50,8 @@ class ScopeInspector {
 
     if (head === 'this') {
       ref = scope.getSelf();
-    } else if (symbols.locals[head]) {
-      ref = unwrap(scope.getSymbol(symbols.locals[head]));
+    } else if (symbols[head]) {
+      ref = unwrap(scope.getSymbol(symbols[head]));
     } else {
       ref = this.scope.getSelf();
       tail = parts;
diff --git a/packages/@glimmer/syntax/lib/symbol-table.ts b/packages/@glimmer/syntax/lib/symbol-table.ts
@@ -1,4 +1,4 @@
-import type { Core, Dict } from '@glimmer/interfaces';
+import type { Dict } from '@glimmer/interfaces';
 import { setLocalDebugType, unwrap } from '@glimmer/debug-util';
 import { dict } from '@glimmer/util';
 import { SexpOpcodes } from '@glimmer/wire-format';
@@ -33,7 +33,7 @@ export abstract class SymbolTable {
   abstract hasLexical(name: string): boolean;
 
   abstract getLocalsMap(): Dict<number>;
-  abstract getDebugInfo(): Core.DebugSymbols;
+  abstract getDebugInfo(): Record<string, number>;
 
   abstract allocateFree(name: string, resolution: ASTv2.FreeVarResolution): number;
   abstract allocateNamed(name: string): number;
@@ -116,12 +116,11 @@ export class ProgramSymbolTable extends SymbolTable {
     return dict();
   }
 
-  getDebugInfo(): Core.DebugSymbols {
-    return [
-      this.getLocalsMap(),
-      this.named,
-      Object.fromEntries(this.usedLexicals.map((s, i) => [s, i])),
-    ];
+  getDebugInfo(): Record<string, number> {
+    return {
+      ...this.getLocalsMap(),
+      ...this.named,
+    };
   }
 
   allocateFree(name: string, resolution: ASTv2.FreeVarResolution): number {
@@ -230,16 +229,12 @@ export class BlockSymbolTable extends SymbolTable {
     return dict;
   }
 
-  getDebugInfo(): Core.DebugSymbols {
+  getDebugInfo(): Record<string, number> {
     const locals = this.getLocalsMap();
     const root = this.root();
     const named = root.named;
 
-    return [
-      { ...locals, ...named },
-      Object.fromEntries(root.upvars.map((s, i) => [s, i])),
-      Object.fromEntries(root.usedLexicals.map((s, i) => [s, i])),
-    ];
+    return { ...locals, ...named };
   }
 
   allocateFree(name: string, resolution: ASTv2.FreeVarResolution): number {
