feat: transform private method invocations in forward and reverse passes

Extend the private method transform to also handle MemberExpression
nodes with PrivateName properties (e.g. this.#foo()), not just
ClassPrivateMethod definitions. This ensures the intermediate AST is
fully consistent—both definitions and call sites use the prefixed
public name—so intermediate plugins can process the code correctly.

Made-with: Cursor

Author: a-chabot

packages/@lwc/babel-plugin-component/src/__tests__/private-method-transform.spec.ts

@@ -660,4 +660,132 @@ describe('private method transform validation', () => {
             /Private fields are not currently supported/
         );
     });
+
+    test('forward-only output transforms call sites to prefixed names', () => {
+        const source = `
+            import { LightningElement } from 'lwc';
+            export default class Test extends LightningElement {
+                #doWork(x) { return x * 2; }
+                connectedCallback() {
+                    const result = this.#doWork(21);
+                    console.log(result);
+                }
+            }
+        `;
+
+        const result = transformForwardOnly(source);
+        const code = result.code!;
+        expect(code).toContain('this.__lwc_component_class_internal_private_doWork(21)');
+        expect(code).not.toContain('this.#doWork');
+    });
+
+    test('forward references in call sites are transformed', () => {
+        const source = `
+            import { LightningElement } from 'lwc';
+            export default class Test extends LightningElement {
+                connectedCallback() {
+                    return this.#helper();
+                }
+                #helper() { return 42; }
+            }
+        `;
+
+        const result = transformForwardOnly(source);
+        const code = result.code!;
+        expect(code).toContain('this.__lwc_component_class_internal_private_helper()');
+        expect(code).not.toContain('this.#helper');
+
+        const roundTrip = transformWithFullPipeline(source);
+        expect(roundTrip.code).toContain('this.#helper()');
+        expect(roundTrip.code).not.toContain('__lwc_component_class_internal_private_');
+    });
+
+    test('multiple invocations of the same private method are all transformed', () => {
+        const source = `
+            import { LightningElement } from 'lwc';
+            export default class Test extends LightningElement {
+                #compute(x) { return x * 2; }
+                run() {
+                    const a = this.#compute(1);
+                    const b = this.#compute(2);
+                    const c = this.#compute(3);
+                    return a + b + c;
+                }
+            }
+        `;
+
+        const result = transformForwardOnly(source);
+        const code = result.code!;
+        const matches = code.match(/__lwc_component_class_internal_private_compute/g);
+        // 1 definition + 3 call sites = 4 occurrences
+        expect(matches).toHaveLength(4);
+
+        const roundTrip = transformWithFullPipeline(source);
+        expect(roundTrip.code).not.toContain('__lwc_component_class_internal_private_');
+        const privateMatches = roundTrip.code!.match(/#compute/g);
+        expect(privateMatches).toHaveLength(4);
+    });
+
+    test('self-referencing private method round-trips', () => {
+        const source = `
+            import { LightningElement } from 'lwc';
+            export default class Test extends LightningElement {
+                #recursive(n) {
+                    if (n <= 0) return 0;
+                    return n + this.#recursive(n - 1);
+                }
+            }
+        `;
+
+        const result = transformForwardOnly(source);
+        const code = result.code!;
+        expect(code).toContain('this.__lwc_component_class_internal_private_recursive(n - 1)');
+
+        const roundTrip = transformWithFullPipeline(source);
+        expect(roundTrip.code).toContain('this.#recursive(n - 1)');
+        expect(roundTrip.code).not.toContain('__lwc_component_class_internal_private_');
+    });
+
+    test('private method reference without call round-trips', () => {
+        const source = `
+            import { LightningElement } from 'lwc';
+            export default class Test extends LightningElement {
+                #handler() { return 42; }
+                connectedCallback() {
+                    const fn = this.#handler;
+                    setTimeout(this.#handler, 100);
+                }
+            }
+        `;
+
+        const result = transformForwardOnly(source);
+        const code = result.code!;
+        expect(code).toContain('this.__lwc_component_class_internal_private_handler;');
+        expect(code).toContain('this.__lwc_component_class_internal_private_handler, 100');
+        expect(code).not.toContain('this.#handler');
+
+        const roundTrip = transformWithFullPipeline(source);
+        expect(roundTrip.code).toContain('this.#handler;');
+        expect(roundTrip.code).toContain('this.#handler, 100');
+        expect(roundTrip.code).not.toContain('__lwc_component_class_internal_private_');
+    });
+
+    test('cross-method private call sites in forward-only output', () => {
+        const source = `
+            import { LightningElement } from 'lwc';
+            export default class Test extends LightningElement {
+                #helper() { return 42; }
+                #caller() {
+                    return this.#helper() + 1;
+                }
+            }
+        `;
+
+        const result = transformForwardOnly(source);
+        const code = result.code!;
+        expect(code).toContain('this.__lwc_component_class_internal_private_helper()');
+        expect(code).toContain('__lwc_component_class_internal_private_caller');
+        expect(code).not.toContain('#helper');
+        expect(code).not.toContain('#caller');
+    });
 });

packages/@lwc/babel-plugin-component/src/private-method-transform.ts

@@ -36,6 +36,20 @@ export default function privateMethodTransform({
             Program(path: NodePath<types.Program>, state: LwcBabelPluginPass) {
                 const transformedNames = new Set<string>();
 
+                // Phase 1: Collect base names of all private methods (kind: 'method')
+                // so that Phase 2 can transform invocations even for forward references
+                // (call site visited before the method definition).
+                const privateMethodBaseNames = new Set<string>();
+                path.traverse({
+                    ClassPrivateMethod(methodPath: NodePath<types.ClassPrivateMethod>) {
+                        const key = methodPath.get('key');
+                        if (key.isPrivateName() && methodPath.node.kind === METHOD_KIND) {
+                            privateMethodBaseNames.add(key.node.id.name);
+                        }
+                    },
+                });
+
+                // Phase 2: Transform definitions and invocations
                 path.traverse(
                     {
                         ClassPrivateMethod(
@@ -98,6 +112,19 @@ export default function privateMethodTransform({
                             transformedNames.add(transformedName);
                         },
 
+                        MemberExpression(memberPath: NodePath<types.MemberExpression>) {
+                            const property = memberPath.node.property;
+                            if (t.isPrivateName(property)) {
+                                const baseName = (property as types.PrivateName).id.name;
+                                if (privateMethodBaseNames.has(baseName)) {
+                                    const prefixedName = `${PRIVATE_METHOD_PREFIX}${baseName}`;
+                                    memberPath
+                                        .get('property')
+                                        .replaceWith(t.identifier(prefixedName));
+                                }
+                            }
+                        },
+
                         ClassPrivateProperty(
                             propPath: NodePath<types.ClassPrivateProperty>,
                             propState: LwcBabelPluginPass

packages/@lwc/babel-plugin-component/src/reverse-private-method-transform.ts

@@ -12,7 +12,8 @@ import type { types, NodePath, PluginObj } from '@babel/core';
 
 /**
  * Standalone Babel plugin that reverses the private method transformation by converting
- * methods with prefix {@link PRIVATE_METHOD_PREFIX} back to ClassPrivateMethod nodes.
+ * methods with prefix {@link PRIVATE_METHOD_PREFIX} back to ClassPrivateMethod nodes,
+ * and restoring prefixed MemberExpression properties back to PrivateName nodes.
  *
  * This must be registered AFTER @babel/plugin-transform-class-properties so that
  * class properties are fully transformed before private methods are restored.
@@ -80,6 +81,24 @@ export default function reversePrivateMethodTransform({
                 }
             },
 
+            MemberExpression(path: NodePath<types.MemberExpression>, state: LwcBabelPluginPass) {
+                const property = path.node.property;
+                if (!t.isIdentifier(property) || !property.name.startsWith(PRIVATE_METHOD_PREFIX)) {
+                    return;
+                }
+
+                const forwardTransformedNames: Set<string> | undefined = (
+                    state.file.metadata as any
+                )[PRIVATE_METHOD_METADATA_KEY];
+
+                if (!forwardTransformedNames || !forwardTransformedNames.has(property.name)) {
+                    return;
+                }
+
+                const originalName = property.name.replace(PRIVATE_METHOD_PREFIX, '');
+                path.get('property').replaceWith(t.privateName(t.identifier(originalName)));
+            },
+
             // After all nodes have been visited, verify that every method the forward transform
             // renamed was also restored by the reverse transform. A mismatch here means an
             // intermediate plugin (e.g. @babel/plugin-transform-class-properties) removed or