fix: Make stubbing work with minification.

This updates stubbing to use direct function references rather than name
strings since the code references will be correctly updated during
minification.

This also makes it a bit more explicit when non-public functions are
being stubbed, and it slightly simplifies stubbing logic.

Author: BenHenning

src/screenreader/function_stubber_registry.ts

@@ -11,36 +11,34 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type StubCallback<T> = (instance: T, ...args: any) => void;
 
+/** The type representation of a generic function that can be stubbed. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type GenericFunction = (...args: any) => any;
+
 class Registration<T> {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private oldMethod: ((...args: any) => any) | null = null;
+  private oldMethod: GenericFunction | null = null;
 
   constructor(
     readonly callback: StubCallback<T>,
-    readonly methodNameToOverride: string,
+    readonly methodToOverride: GenericFunction,
     readonly classPrototype: T,
     readonly ensureOneCall: boolean,
   ) {}
 
   stubPrototype(): void {
-    // TODO: Figure out how to make this work with minification.
     if (this.oldMethod) {
       throw new Error(
-        `Function is already stubbed: ${this.methodNameToOverride}.`,
+        `Function is already stubbed: ${this.methodToOverride.name}.`,
       );
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const genericPrototype = this.classPrototype as any;
-    const oldMethod = genericPrototype[this.methodNameToOverride] as (
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ...args: any
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ) => any;
-    this.oldMethod = oldMethod;
+    this.oldMethod = this.methodToOverride;
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const registration = this;
+    const methodNameToOverride = this.methodToOverride.name;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    genericPrototype[this.methodNameToOverride] = function (...args: any): any {
+    genericPrototype[methodNameToOverride] = function (...args: any): any {
       let stubsCalled = this._internalStubsCalled as
         | {[key: string]: boolean}
         | undefined;
@@ -49,13 +47,13 @@ class Registration<T> {
         this._internalStubsCalled = stubsCalled;
       }
 
-      const result = oldMethod.call(this, ...args);
+      const result = registration.methodToOverride.call(this, ...args);
       if (
         !registration.ensureOneCall ||
-        !stubsCalled[registration.methodNameToOverride]
+        !stubsCalled[registration.methodToOverride.name]
       ) {
         registration.callback(this as unknown as T, ...args);
-        stubsCalled[registration.methodNameToOverride] = true;
+        stubsCalled[registration.methodToOverride.name] = true;
       }
       return result;
     };
@@ -96,12 +94,12 @@ export class FunctionStubber {
    *
    * @param callback The function to run when the stubbed method executes for
    *     the first time.
-   * @param methodNameToOverride The name of the method to override.
+   * @param methodToOverride The method within the prototype to override.
    * @param classPrototype The prototype of the class being stubbed.
    */
   registerInitializationStub<T>(
     callback: StubCallback<T>,
-    methodNameToOverride: string,
+    methodToOverride: GenericFunction,
     classPrototype: T,
   ) {
     if (this.isFinalized) {
@@ -111,7 +109,7 @@ export class FunctionStubber {
     }
     const registration = new Registration(
       callback,
-      methodNameToOverride,
+      methodToOverride,
       classPrototype,
       true,
     );
@@ -127,12 +125,12 @@ export class FunctionStubber {
    * This will throw an error if called after stubPrototypes() has been called.
    *
    * @param callback The function to run when the stubbed method executes.
-   * @param methodNameToOverride The name of the method to override.
+   * @param methodToOverride The method within the prototype to override.
    * @param classPrototype The prototype of the class being stubbed.
    */
   registerMethodStub<T>(
     callback: StubCallback<T>,
-    methodNameToOverride: string,
+    methodToOverride: GenericFunction,
     classPrototype: T,
   ) {
     if (this.isFinalized) {
@@ -142,7 +140,7 @@ export class FunctionStubber {
     }
     const registration = new Registration(
       callback,
-      methodNameToOverride,
+      methodToOverride,
       classPrototype,
       false,
     );

src/screenreader/stuboverrides/override_block_svg.ts

@@ -22,13 +22,14 @@ FunctionStubber.getInstance().registerInitializationStub(
     svgPath.tabIndex = -1;
     blockSvgUtils.setCurrentConnectionCandidate(block, null);
   },
-  'doInit_',
+  // @ts-expect-error Access to protected property doInit_.
+  Blockly.BlockSvg.prototype.doInit_,
   Blockly.BlockSvg.prototype,
 );
 
 FunctionStubber.getInstance().registerMethodStub(
   (block) => blockSvgUtils.recomputeAllWorkspaceAriaTrees(block.workspace),
-  'setParent',
+  Blockly.BlockSvg.prototype.setParent,
   Blockly.BlockSvg.prototype,
 );
 
@@ -39,7 +40,7 @@ FunctionStubber.getInstance().registerMethodStub(
     blockSvgUtils.setCurrentConnectionCandidate(block, candidate);
     blockSvgUtils.announceDynamicAriaStateForBlock(block, true, false);
   },
-  'startDrag',
+  Blockly.BlockSvg.prototype.startDrag,
   Blockly.BlockSvg.prototype,
 );
 
@@ -50,7 +51,7 @@ FunctionStubber.getInstance().registerMethodStub(
     blockSvgUtils.setCurrentConnectionCandidate(block, candidate);
     blockSvgUtils.announceDynamicAriaStateForBlock(block, true, false, newLoc);
   },
-  'drag',
+  Blockly.BlockSvg.prototype.drag,
   Blockly.BlockSvg.prototype,
 );
 
@@ -59,30 +60,30 @@ FunctionStubber.getInstance().registerMethodStub(
     blockSvgUtils.setCurrentConnectionCandidate(block, null);
     blockSvgUtils.announceDynamicAriaStateForBlock(block, false, false);
   },
-  'endDrag',
+  Blockly.BlockSvg.prototype.endDrag,
   Blockly.BlockSvg.prototype,
 );
 
 FunctionStubber.getInstance().registerMethodStub(
   (block) => {
     blockSvgUtils.announceDynamicAriaStateForBlock(block, false, true);
   },
-  'revertDrag',
+  Blockly.BlockSvg.prototype.revertDrag,
   Blockly.BlockSvg.prototype,
 );
 
 FunctionStubber.getInstance().registerMethodStub(
   (block) => {
     aria.setState(block.getFocusableElement(), aria.State.SELECTED, true);
   },
-  'onNodeFocus',
+  Blockly.BlockSvg.prototype.onNodeFocus,
   Blockly.BlockSvg.prototype,
 );
 
 FunctionStubber.getInstance().registerMethodStub(
   (block) => {
     aria.setState(block.getFocusableElement(), aria.State.SELECTED, false);
   },
-  'onNodeBlur',
+  Blockly.BlockSvg.prototype.onNodeBlur,
   Blockly.BlockSvg.prototype,
 );

src/screenreader/stuboverrides/override_collapsible_toolbox_category.ts

@@ -30,6 +30,6 @@ FunctionStubber.getInstance().registerInitializationStub(
       category.getFocusableTree() as Blockly.Toolbox,
     );
   },
-  'init',
+  Blockly.CollapsibleToolboxCategory.prototype.init,
   Blockly.CollapsibleToolboxCategory.prototype,
 );

src/screenreader/stuboverrides/override_comment_icon.ts

@@ -17,6 +17,6 @@ FunctionStubber.getInstance().registerInitializationStub(
       icon.bubbleIsVisible() ? 'Close Comment' : 'Open Comment',
     );
   },
-  'initView',
+  Blockly.icons.CommentIcon.prototype.initView,
   Blockly.icons.CommentIcon.prototype,
 );

src/screenreader/stuboverrides/override_field.ts

@@ -15,6 +15,7 @@ FunctionStubber.getInstance().registerInitializationStub(
     // @ts-expect-error Access to private property getTextElement.
     aria.setState(field.getTextElement(), aria.State.HIDDEN, true);
   },
-  'createTextElement_',
+  // @ts-expect-error Access to protected property createTextElement_.
+  Blockly.Field.prototype.createTextElement_,
   Blockly.Field.prototype,
 );

src/screenreader/stuboverrides/override_field_checkbox.ts

@@ -18,6 +18,6 @@ FunctionStubber.getInstance().registerInitializationStub(
       fieldCheckbox.name ? `Checkbox ${fieldCheckbox.name}` : 'Checkbox',
     );
   },
-  'initView',
+  Blockly.FieldCheckbox.prototype.initView,
   Blockly.FieldCheckbox.prototype,
 );

src/screenreader/stuboverrides/override_field_dropdown.ts

@@ -18,6 +18,6 @@ FunctionStubber.getInstance().registerInitializationStub(
       fieldDropdown.name ? `Item ${fieldDropdown.name}` : 'Item',
     );
   },
-  'initView',
+  Blockly.FieldDropdown.prototype.initView,
   Blockly.FieldDropdown.prototype,
 );

src/screenreader/stuboverrides/override_field_image.ts

@@ -18,6 +18,6 @@ FunctionStubber.getInstance().registerInitializationStub(
       fieldImage.name ? `Image ${fieldImage.name}` : 'Image',
     );
   },
-  'initView',
+  Blockly.FieldImage.prototype.initView,
   Blockly.FieldImage.prototype,
 );

src/screenreader/stuboverrides/override_field_input.ts

@@ -14,15 +14,15 @@ FunctionStubber.getInstance().registerInitializationStub(
   (fieldNumber) => {
     initializeFieldInput(fieldNumber);
   },
-  'init',
+  Blockly.FieldNumber.prototype.init,
   Blockly.FieldNumber.prototype,
 );
 
 FunctionStubber.getInstance().registerInitializationStub(
   (fieldTextInput) => {
     initializeFieldInput(fieldTextInput);
   },
-  'init',
+  Blockly.FieldTextInput.prototype.init,
   Blockly.FieldTextInput.prototype,
 );
 

src/screenreader/stuboverrides/override_field_label.ts

@@ -18,6 +18,6 @@ FunctionStubber.getInstance().registerInitializationStub(
       fieldLabel.getText(),
     );
   },
-  'initView',
+  Blockly.FieldLabel.prototype.initView,
   Blockly.FieldLabel.prototype,
 );