fix(gxt-backend): unblock strict-mode runtime template compiler this/curried-helper

The GXT-mode `template()` runtime compiler in
@ember/template-compiler/runtime had two latent gaps that the
Strict-Mode - Runtime Template Compiler suite exercises but the
strict-mode `precompileTemplate` scope-merge work did not cover:

1. `Can use \`this\` from explicit scope` — when the user provides
   `scope: () => ({ this: state })`, the binding was passed verbatim
   as a `scopeValues.this` entry. The GXT compiler still emitted
   literal `this.X` references against the rendering context, so the
   user's `state` object was never reached. Pre-rewrite `{{this.X}}` /
   `(this.X` / `<this.X` path heads to a non-keyword alias
   (`__gxtExplicitThis`) and rebind that alias in `scopeValues`, so
   GXT compiles the access as a normal binding-path lookup.

2. `Can use a curried dynamic helper` (implicit form) — direct `eval()`
   in the test method's lexical scope was resolving `helper` to a
   leaked module-level `let helper;` declared by the in-element
   null-check helper in the same bundle. The implicit form's free-name
   extractor then bound `helper` as a scope value, suppressing the
   strict-mode `helper` keyword path. Filter `helper` and `modifier`
   from `_extractScopeFromEval` so the keyword path always wins for
   the implicit form. Users who genuinely want to shadow them can do
   so via the explicit `scope` form.

Also defensively strip a stray `this` entry from the implicit form's
extracted scope, so a class-form template using `eval()` plus
`component: this` cannot accidentally have its rendering context
rewritten.

Validation:
- testem Basic Test: 15 fail -> 12 fail; both target tests now pass.
- Smoke 333/333 unchanged.
- No regression in any previously-passing test.

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>

Author: lifeart

packages/@ember/template-compiler/lib/template.ts

@@ -290,6 +290,15 @@ function _extractScopeFromEval(
 
   // Try to resolve each identifier via eval
   for (const name of identifiers) {
+    // Skip GXT/Ember built-in keywords. These are part of the template
+    // language (resolved by the compiler/runtime), so the user must opt-in
+    // to shadowing them via the explicit `scope` form. The implicit form
+    // can accidentally pick them up via `eval()` when the surrounding
+    // bundle exposes a same-named binding (e.g. an internal `let helper`
+    // declared by a sibling Glimmer runtime module).
+    if (_GXT_KEYWORD_NAMES.has(name)) {
+      continue;
+    }
     try {
       const value = evalFn(name);
       if (value !== undefined) {
@@ -303,6 +312,18 @@ function _extractScopeFromEval(
   return Object.keys(scope).length > 0 ? scope : (undefined as any);
 }
 
+// GXT/Ember strict-mode keywords whose names are reserved for the curried
+// helper / modifier syntactic forms (`{{helper foo "x"}}`,
+// `{{modifier foo "x"}}`). These are never imported as bindings in
+// idiomatic Ember code — the user invokes them as keywords instead — but
+// the bundled test runtime can expose same-named module-level `let`
+// declarations (e.g. `let helper;` from the in-element-null-check helper
+// scaffolding) that direct `eval()` will resolve to. Skipping them in the
+// implicit-form scope extraction prevents the leaked binding from silently
+// shadowing the keyword. Users who genuinely want to shadow them can do so
+// via the explicit `scope: () => ({ helper: myHelper })` form.
+const _GXT_KEYWORD_NAMES = new Set<string>(['helper', 'modifier']);
+
 // HBS syntax words that should not be treated as variable references
 const _HBS_SYNTAX_WORDS = new Set([
   'as',
@@ -385,20 +406,68 @@ export function template(
 
       // Extract scope values from explicit scope() or implicit eval()
       let scopeValues: Record<string, unknown> | undefined;
+      // Track whether `this` was bound by the *explicit* form. The implicit
+      // `eval()` form can also accidentally resolve `this` to the eval method's
+      // outer `this`, but in that case the user did NOT intend to override the
+      // template's rendering context — so we must not rewrite `{{this.X}}` for
+      // implicit-form templates.
+      let explicitlyProvidedThis = false;
 
       if ('scope' in gxtOptions && typeof (gxtOptions as any).scope === 'function') {
         // Explicit form: scope: () => ({ Foo, bar })
         scopeValues = ((gxtOptions as any).scope as () => Record<string, unknown>)();
+        if (
+          scopeValues &&
+          Object.prototype.hasOwnProperty.call(scopeValues, 'this') &&
+          scopeValues['this'] !== undefined
+        ) {
+          explicitlyProvidedThis = true;
+        }
       } else if ('eval' in gxtOptions && typeof (gxtOptions as any).eval === 'function') {
         // Implicit form: eval() { return eval(arguments[0]) }
         // Extract free variable names from the template and resolve them via eval
         scopeValues = _extractScopeFromEval(
           templateString,
           (gxtOptions as any).eval as (v: string) => unknown
         );
+        // Defensive: even if `_extractScopeFromEval` somehow returns `this`,
+        // strip it. The implicit form must never override the rendering
+        // context — see the explicit-form branch above for the intended way
+        // to shadow `this`.
+        if (scopeValues && Object.prototype.hasOwnProperty.call(scopeValues, 'this')) {
+          delete (scopeValues as Record<string, unknown>)['this'];
+        }
+      }
+
+      // Strict-mode `this` shadowing: when the user explicitly provides `this`
+      // via `scope: () => ({ this: state })`, the GXT compiler would otherwise
+      // emit a literal `this.X` reference for `{{this.X}}` — which picks up
+      // the rendering context, not the user's value. Rewrite the path head to
+      // a non-`this` alias and rebind it in scopeValues so the GXT compiler
+      // emits a normal binding-path lookup.
+      let processedTemplate = templateString;
+      if (explicitlyProvidedThis && scopeValues) {
+        const explicitThisAlias = '__gxtExplicitThis';
+        // Avoid clobbering an existing alias — extremely unlikely, but guard
+        // against pathological user-supplied scopes.
+        if (!Object.prototype.hasOwnProperty.call(scopeValues, explicitThisAlias)) {
+          // Replace path heads in the template:
+          //   {{this.X}}     → {{__gxtExplicitThis.X}}
+          //   {{this}}       → {{__gxtExplicitThis}}      (rare but safe)
+          //   (this.X        → (__gxtExplicitThis.X
+          //   <this.X        → <__gxtExplicitThis.X
+          // The substitution is purely textual but only inside expression
+          // positions: a leading `{{`, `(`, or `<` must precede the `this`.
+          processedTemplate = processedTemplate.replace(
+            /(\{\{[#/!]?\s*|\(\s*|<\s*)this\b/g,
+            (_full, prefix: string) => `${prefix}${explicitThisAlias}`
+          );
+          scopeValues = { ...scopeValues, [explicitThisAlias]: scopeValues['this'] };
+          delete (scopeValues as Record<string, unknown>)['this'];
+        }
       }
 
-      const gxtTemplate = gxtCompile(templateString, {
+      const gxtTemplate = gxtCompile(processedTemplate, {
         moduleName: (gxtOptions as any).moduleName,
         strictMode: true,
         scopeValues,