Apply binding to all path reads, add #let block param test

Move GetPropertyBound emission into withPath so ALL multi-segment
path reads (this.*, @arg.*, blockParam.*, lexical.*) tag the last
segment's ref with its parent. With the ref-tagging approach this
is safe — the value identity is unchanged, only on/fn check the tag.

This means {{#let this.obj as |o|}} followed by o.method correctly
binds method to obj, matching the behavior of this.obj.method.

Also adds a test for the #let + fn pattern per review request:
  {{#let this.obj as |o|}}
    <button {{on 'click' (fn o.method 'did it')}}>click me</button>
  {{/let}}

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

Author: NullVoxPopuli

packages/@ember/-internals/glimmer/tests/integration/this-binding-test.gjs

@@ -1,4 +1,5 @@
 import { RenderingTestCase, moduleFor, runTask } from 'internal-test-helpers';
+import { fn } from '@ember/helper';
 import { on } from '@ember/modifier';
 import { Component } from '../utils/helpers';
 
@@ -70,5 +71,47 @@ moduleFor(
         '`this` inside the nested method should be the inner object instance'
       );
     }
+    ['@test #let block param preserves this binding on method access'](assert) {
+      let innerInstance;
+      let seenThis;
+      let receivedArg;
+
+      class Inner {
+        constructor() {
+          innerInstance = this;
+        }
+
+        method(arg) {
+          seenThis = this;
+          receivedArg = arg;
+        }
+      }
+
+      class Demo extends Component {
+        constructor(...args) {
+          super(...args);
+          this.obj = new Inner();
+        }
+
+        <template>
+          {{#let this.obj as |o|}}
+            <button type="button" {{on "click" (fn o.method "did it")}}>click me</button>
+          {{/let}}
+        </template>
+      }
+
+      this.render(`<this.Demo />`, { Demo });
+
+      assert.ok(innerInstance, 'inner instance was captured');
+
+      runTask(() => this.$('button').click());
+
+      assert.strictEqual(
+        seenThis,
+        innerInstance,
+        '`this` inside o.method should be the inner object instance'
+      );
+      assert.strictEqual(receivedArg, 'did it', 'argument from fn is passed through');
+    }
   }
 );

packages/@glimmer/opcode-compiler/lib/syntax/expressions.ts

@@ -56,17 +56,7 @@ EXPRESSIONS.add(SexpOpcodes.Curry, (op, [, expr, type, positional, named]) => {
 
 EXPRESSIONS.add(SexpOpcodes.GetSymbol, (op, [, sym, path]) => {
   op(VM_GET_VARIABLE_OP, sym);
-
-  if (sym === 0 && path !== undefined && path.length > 0) {
-    // For `this.*` paths, emit GetPropertyBound for the last segment so that
-    // class methods preserve their `this` binding when passed as callbacks.
-    for (let i = 0; i < path.length - 1; i++) {
-      op(VM_GET_PROPERTY_OP, path[i]);
-    }
-    op(VM_GET_PROPERTY_BOUND_OP, path[path.length - 1]);
-  } else {
-    withPath(op, path);
-  }
+  withPath(op, path);
 });
 
 EXPRESSIONS.add(SexpOpcodes.GetLexicalSymbol, (op, [, sym, path]) => {
@@ -95,9 +85,13 @@ EXPRESSIONS.add(SexpOpcodes.GetFreeAsHelperHead, (op, expr) => {
 function withPath(op: PushExpressionOp, path?: string[]) {
   if (path === undefined || path.length === 0) return;
 
-  for (let i = 0; i < path.length; i++) {
+  for (let i = 0; i < path.length - 1; i++) {
     op(VM_GET_PROPERTY_OP, path[i]);
   }
+
+  // The last segment uses GetPropertyBound to tag the ref with its parent,
+  // so that consumers (on, fn) can bind `this` at invocation time.
+  op(VM_GET_PROPERTY_BOUND_OP, path[path.length - 1]);
 }
 
 EXPRESSIONS.add(SexpOpcodes.Undefined, (op) => PushPrimitiveReference(op, undefined));