Remove lexicalSymbols from wire format and dead debugSymbols codepath

Now that the scope bag is an object (`Record<string, unknown>`), lexical
symbol names are always available via `Object.keys(scope())`. This makes
two things redundant:

- The optional `lexicalSymbols` slot in `SerializedTemplateBlock` (previously
  only populated when `emit.debugSymbols` was enabled)
- The `emit.debugSymbols` option itself — removed from the compiler,
  `PrecompileOptionsWithLexicalScope` type, test helpers, and test callsites

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: NullVoxPopuli

packages/@glimmer-workspace/integration-tests/lib/compile.ts

@@ -29,10 +29,6 @@ export function createTemplate(
     reifiedScope[key] = scopeValues[key];
   }
 
-  if ('emit' in options && options.emit?.debugSymbols) {
-    block.push(usedLocals);
-  }
-
   let templateBlock: SerializedTemplateWithLazyBlock = {
     id: String(templateId++),
     block: JSON.stringify(block),

packages/@glimmer-workspace/integration-tests/lib/test-helpers/define.ts

@@ -5,7 +5,7 @@ import type {
   ModifierManager,
   Owner,
 } from '@glimmer/interfaces';
-import type { PrecompileOptionsWithLexicalScope } from '@glimmer/syntax';
+
 import { registerDestructor } from '@glimmer/destroyable';
 import {
   helperCapabilities,
@@ -100,29 +100,19 @@ export interface DefineComponentOptions {
 
   // additional strict-mode keywords
   keywords?: string[];
-
-  emit?: PrecompileOptionsWithLexicalScope['emit'];
 }
 
 export function defComponent(
   templateSource: string,
   options?: {
     component?: object | undefined;
     scope?: Record<string, unknown> | undefined;
-    emit?: {
-      moduleName?: string;
-      debugSymbols?: boolean;
-    };
   }
 ) {
   let definition = options?.component ?? templateOnlyComponent();
   let templateFactory = createTemplate(
     templateSource,
-    {
-      strictMode: true,
-      meta: { moduleName: options?.emit?.moduleName },
-      emit: { debugSymbols: options?.emit?.debugSymbols ?? true },
-    },
+    { strictMode: true },
     options?.scope ?? {}
   );
   setComponentTemplate(templateFactory, definition);
@@ -146,7 +136,7 @@ export function defineComponent(
   let definition = options.definition ?? templateOnlyComponent();
   let templateFactory = createTemplate(
     templateSource,
-    { strictMode, keywords, emit: options.emit },
+    { strictMode, keywords },
     scopeValues ?? {}
   );
   setComponentTemplate(templateFactory, definition);

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

@@ -83,7 +83,7 @@ class DebugRenderTreeTest extends RenderTest {
     const HelloWorld = defComponent('{{@arg}}');
     const Root = defComponent(
       `<HelloWorld @arg="first"/>{{#if state.showSecond}}<HelloWorld @arg="second"/>{{/if}}`,
-      { scope: { HelloWorld, state }, emit: { moduleName: 'root.hbs' } }
+      { scope: { HelloWorld, state } }
     );
 
     this.renderComponent(Root);
@@ -94,7 +94,7 @@ class DebugRenderTreeTest extends RenderTest {
         name: '{ROOT}',
         args: { positional: [], named: {} },
         instance: null,
-        template: 'root.hbs',
+        template: '(unknown template module)',
         bounds: this.elementBounds(this.delegate.getInitialElement()),
         children: [
           {
@@ -111,11 +111,10 @@ class DebugRenderTreeTest extends RenderTest {
     ]);
   }
 
-  @test 'strict-mode components without debug symbols preserve names from scope'() {
+  @test 'strict-mode components preserve names from scope'() {
     const HelloWorld = defComponent('{{@arg}}');
     const Root = defComponent(`<HelloWorld @arg="first"/>`, {
       scope: { HelloWorld },
-      emit: { moduleName: 'root.hbs', debugSymbols: false },
     });
 
     this.renderComponent(Root);
@@ -126,7 +125,7 @@ class DebugRenderTreeTest extends RenderTest {
         name: '{ROOT}',
         args: { positional: [], named: {} },
         instance: null,
-        template: 'root.hbs',
+        template: '(unknown template module)',
         bounds: this.elementBounds(this.delegate.getInitialElement()),
         children: [
           {
@@ -152,7 +151,6 @@ class DebugRenderTreeTest extends RenderTest {
 
     const RootDef = defComponent(`<this.HelloWorld @arg="first"/>`, {
       component: Root,
-      emit: { moduleName: 'root.hbs' },
     });
 
     this.renderComponent(RootDef);
@@ -173,9 +171,7 @@ class DebugRenderTreeTest extends RenderTest {
 
   @test({ skip: !DEBUG }) 'dynamic component via <@argComponent>'() {
     const HelloWorld = defComponent('{{@arg}}');
-    const Root = defComponent(`<@Greeting @arg="first"/>`, {
-      emit: { moduleName: 'root.hbs' },
-    });
+    const Root = defComponent(`<@Greeting @arg="first"/>`);
 
     this.renderComponent(Root, { Greeting: HelloWorld });
 
@@ -201,7 +197,7 @@ class DebugRenderTreeTest extends RenderTest {
     const noop = defineSimpleModifier(noopFn);
     const Root = defComponent(
       `<HelloWorld {{noop}} @arg="first"/>{{#if state.showSecond}}<HelloWorld @arg="second"/>{{/if}}`,
-      { scope: { HelloWorld, state, noop }, emit: { moduleName: 'root.hbs' } }
+      { scope: { HelloWorld, state, noop } }
     );
 
     this.renderComponent(Root);
@@ -214,7 +210,7 @@ class DebugRenderTreeTest extends RenderTest {
         name: '{ROOT}',
         args: { positional: [], named: {} },
         instance: null,
-        template: 'root.hbs',
+        template: '(unknown template module)',
         bounds: this.elementBounds(element),
         children: [
           {

packages/@glimmer/compiler/lib/compiler.ts

@@ -123,10 +123,6 @@ export function precompile(
 ): TemplateJavascript {
   const [block, usedLocals] = precompileJSON(source, options);
 
-  if ('emit' in options && options.emit?.debugSymbols && usedLocals.length > 0) {
-    block.push(usedLocals);
-  }
-
   const moduleName = options.meta?.moduleName;
   const idFn = options.id || defaultId;
   const blockJSON = JSON.stringify(block);

packages/@glimmer/interfaces/lib/compile/wire-format/api.d.ts

@@ -373,7 +373,6 @@ export type SerializedTemplateBlock = [
   statements: Statements.Statement[],
   locals: string[],
   upvars: string[],
-  lexicalSymbols?: string[],
 ];
 
 /**

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

@@ -106,14 +106,14 @@ export function CompilePositional(
 }
 
 export function meta(layout: LayoutWithContext): BlockMetadata {
-  let [, locals, upvars, lexicalSymbols] = layout.block;
+  let [, locals, upvars] = layout.block;
   let scopeRecord = layout.scope?.() ?? null;
 
   return {
     symbols: {
       locals,
       upvars,
-      lexical: scopeRecord ? Object.keys(scopeRecord) : lexicalSymbols,
+      lexical: scopeRecord ? Object.keys(scopeRecord) : undefined,
     },
     scopeValues: scopeRecord ? Object.values(scopeRecord) : null,
     isStrictMode: layout.isStrictMode,

packages/@glimmer/syntax/lib/parser/tokenizer-event-handlers.ts

@@ -688,16 +688,6 @@ export interface PrecompileOptions extends PreprocessOptions {
 
 export interface PrecompileOptionsWithLexicalScope extends PrecompileOptions {
   lexicalScope: (variable: string) => boolean;
-
-  /**
-   * If `emit.debugSymbols` is set to `true`, the name of lexical local variables
-   * will be included in the wire format.
-   */
-  emit?:
-    | {
-        debugSymbols?: boolean;
-      }
-    | undefined;
 }
 
 export interface PreprocessOptions {