fix def lookup

riknoll · riknoll · commit d9bac1c9fafa · 2026-03-09T11:24:44.000-07:00
diff --git a/pxtblocks/blocksProgram.ts b/pxtblocks/blocksProgram.ts
@@ -63,6 +63,7 @@ export interface BlocksProgram {
     getVariableQualifiedName(varName: string, workspace: Blockly.Workspace): string;
     refreshSymbols?(): void;
     getVariableSymbol(varId: string): BlocksVariableSymbol;
+    getFunctionSymbol(functionName: string): BlocksFunctionSymbol;
 }
 
 
@@ -136,6 +137,11 @@ export class SingleWorkspaceBlocksProgram implements BlocksProgram {
         }
         return null;
     }
+
+    getFunctionSymbol(functionName: string): BlocksFunctionSymbol {
+        const allFunctions = getFunctionSymbols({ fileName: "main.blocks", workspace: this.workspace });
+        return allFunctions.find(f => f.name === functionName);
+    }
 }
 
 
@@ -332,6 +338,17 @@ export class MultiWorkspaceBlocksProgram implements BlocksProgram {
         return null;
     }
 
+    getFunctionSymbol(functionName: string): BlocksFunctionSymbol {
+        for (const symbols of this.symbolsCache.values()) {
+            for (const symbol of symbols) {
+                if (symbol.type === "function" && symbol.name === functionName) {
+                    return symbol;
+                }
+            }
+        }
+        return null;
+    }
+
     protected defineSymbolInWorkspace(symbol: BlocksSymbol, workspace: Blockly.Workspace) {
         const map = workspace.getVariableMap();
 
@@ -463,7 +480,7 @@ function getSymbolFromFunctionDefinitionBlock(block: FunctionDefinitionBlock, fi
             functionSymbol.arguments.push({
                 name: child.getAttribute("name"),
                 type: child.getAttribute("type"),
-                id: child.getAttribute("argid")
+                id: child.getAttribute("id")
             });
         }
     }
diff --git a/pxtblocks/plugins/functions/blocks/functionCallBlocks.ts b/pxtblocks/plugins/functions/blocks/functionCallBlocks.ts
@@ -5,7 +5,7 @@ import {
     FUNCTION_CALL_OUTPUT_BLOCK_TYPE,
     FUNCTION_DEFINITION_BLOCK_TYPE,
 } from "../constants";
-import { getArgMap, getDefinition, getShadowBlockInfoFromType_, isVariableBlockType, mutateCallersAndDefinition, mutationsAreEqual } from "../utils";
+import { getArgMap, getDefinition, getShadowBlockInfoFromType_, isVariableBlockType, lookupImportedFunctionDef, mutateCallersAndDefinition, mutationsAreEqual } from "../utils";
 import { MsgKey } from "../msg";
 import { BlocksFunctionSymbol, generateFunctionMutationFromSymbol } from "../../../blocksProgram";
 
@@ -167,10 +167,10 @@ const FUNCTION_CALL_MIXIN: FunctionCallMixin = {
                 // Propagate the functionId of the definition to the caller
                 this.functionId_ = def.functionId_;
             } else {
-                const importedDef = this.workspace.getVariableMap().getVariableById(this.functionId_);
+                const importedFunction = lookupImportedFunctionDef(name, this.workspace, this.functionId_);
 
-                if (importedDef) {
-                    const mutation = generateFunctionMutationFromSymbol(JSON.parse(importedDef.getName()) as BlocksFunctionSymbol);
+                if (importedFunction) {
+                    const mutation = generateFunctionMutationFromSymbol(importedFunction);
 
                     if (!mutationsAreEqual(this.mutationToDom(), mutation)) {
                         mutateCallersAndDefinition(this.getName(), this.workspace, this.mutationToDom(), mutation);
@@ -200,9 +200,9 @@ const FUNCTION_CALL_MIXIN: FunctionCallMixin = {
             // this caller.
             const name = this.getName();
             const def = getDefinition(name, this.workspace);
-            const importedDef = !def && this.workspace.getVariableMap().getVariableById(this.functionId_);
+            const importedFunction = !def && lookupImportedFunctionDef(name, this.workspace, this.functionId_);
 
-            if (!def && !importedDef) {
+            if (!def && !importedFunction) {
                 Blockly.Events.setGroup(event.group);
                 this.dispose(true);
                 Blockly.Events.setGroup(false);
diff --git a/pxtblocks/plugins/functions/commonFunctionMixin.ts b/pxtblocks/plugins/functions/commonFunctionMixin.ts
@@ -5,9 +5,10 @@ import {
     FUNCTION_DECLARATION_BLOCK_TYPE,
     FUNCTION_DEFINITION_BLOCK_TYPE,
 } from "./constants";
-import { getDefinition, idsInUse, isCustomType, StringMap } from "./utils";
+import { getDefinition, idsInUse, isCustomType, lookupImportedFunctionDef, StringMap } from "./utils";
 import { MsgKey } from "./msg";
 import { BlocksFunctionSymbol } from "../../blocksProgram";
+import { external } from "../..";
 
 type CommonFunctionMixinType = typeof COMMON_FUNCTION_MIXIN;
 
@@ -288,17 +289,18 @@ export const COMMON_FUNCTION_MIXIN = {
                     }
                 }
                 else {
-                    const importedDef = this.workspace.getVariableMap().getVariableById(this.functionId_);
-                    if (importedDef) {
-                        const importedDefArgs = JSON.parse(importedDef.getName()) as BlocksFunctionSymbol;
+                    const importedFunction = lookupImportedFunctionDef(this.name_, this.workspace, this.functionId_);
+                    if (importedFunction) {
                         for (let i = 0; i < this.arguments_.length; ++i) {
-                            for (let j = 0; j < importedDefArgs.arguments.length; ++j) {
-                                if (importedDefArgs.arguments[j].name == this.arguments_[i].name) {
-                                    this.arguments_[i].id = importedDefArgs.arguments[j].id;
+                            for (let j = 0; j < importedFunction.arguments.length; ++j) {
+                                if (importedFunction.arguments[j].name == this.arguments_[i].name) {
+                                    this.arguments_[i].id = importedFunction.arguments[j].id;
                                     break;
                                 }
                             }
                         }
+
+                        this.functionId_ = importedFunction.id;
                     }
                 }
                 break;
diff --git a/pxtblocks/plugins/functions/utils.ts b/pxtblocks/plugins/functions/utils.ts
@@ -21,6 +21,7 @@ import { ArgumentReporterBlock } from "./blocks/argumentReporterBlocks";
 import { DRAGGABLE_PARAM_INPUT_PREFIX } from "../../loader";
 import { getGlobalProgram } from "../../external";
 import { createFlyoutGroupLabel } from "../../toolbox";
+import { BlocksFunctionSymbol, IMPORTED_FUNCTION_TYPE } from "../../blocksProgram";
 
 
 export type StringMap<T> = { [index: string]: T };
@@ -231,7 +232,7 @@ export function mutateCallersAndDefinition(name: string, ws: Blockly.Workspace,
         } as CallerChange))
 
     const change = new MutateFunctionEvent(
-        definitionBlock.id,
+        definitionBlock?.id || newMutation.getAttribute("functionid"),
         callerChanges,
         Blockly.Xml.domToText(oldMutation),
         Blockly.Xml.domToText(newMutation),
@@ -595,6 +596,27 @@ export function isVariableBlockType(type: string) {
     return false;
 }
 
+export function lookupImportedFunctionDef(name: string, workspace: Blockly.Workspace, functionId?: string) {
+    const program = getGlobalProgram();
+    const symbol = program?.getFunctionSymbol(name);
+
+    let varModel: Blockly.IVariableModel<Blockly.IVariableState> | undefined;
+
+    if (symbol) {
+        varModel = workspace.getVariableMap().getVariableById(symbol.id);
+    }
+    if (!varModel && functionId) {
+        varModel = workspace.getVariableMap().getVariableById(functionId);
+    }
+
+    if (varModel?.getType() === IMPORTED_FUNCTION_TYPE) {
+        if (symbol) return symbol;
+        return JSON.parse(varModel.getName()) as BlocksFunctionSymbol;
+    }
+
+    return undefined;
+}
+
 interface DescendantChange {
     id: string;
     type: string;

Original file line number	Diff line number	Diff line change
`@@ -63,6 +63,7 @@ export interface BlocksProgram {`
`63`	`63`	`getVariableQualifiedName(varName: string, workspace: Blockly.Workspace): string;`
`64`	`64`	`refreshSymbols?(): void;`
`65`	`65`	`getVariableSymbol(varId: string): BlocksVariableSymbol;`
	`66`	`+ getFunctionSymbol(functionName: string): BlocksFunctionSymbol;`
`66`	`67`	`}`
`67`	`68`
`68`	`69`
`@@ -136,6 +137,11 @@ export class SingleWorkspaceBlocksProgram implements BlocksProgram {`
`136`	`137`	`}`
`137`	`138`	`return null;`
`138`	`139`	`}`
	`140`	`+`
	`141`	`+ getFunctionSymbol(functionName: string): BlocksFunctionSymbol {`
	`142`	`+ const allFunctions = getFunctionSymbols({ fileName: "main.blocks", workspace: this.workspace });`
	`143`	`+ return allFunctions.find(f => f.name === functionName);`
	`144`	`+ }`
`139`	`145`	`}`
`140`	`146`
`141`	`147`
`@@ -332,6 +338,17 @@ export class MultiWorkspaceBlocksProgram implements BlocksProgram {`
`332`	`338`	`return null;`
`333`	`339`	`}`
`334`	`340`
	`341`	`+ getFunctionSymbol(functionName: string): BlocksFunctionSymbol {`
	`342`	`+ for (const symbols of this.symbolsCache.values()) {`
	`343`	`+ for (const symbol of symbols) {`
	`344`	`+ if (symbol.type === "function" && symbol.name === functionName) {`
	`345`	`+ return symbol;`
	`346`	`+ }`
	`347`	`+ }`
	`348`	`+ }`
	`349`	`+ return null;`
	`350`	`+ }`
	`351`	`+`
`335`	`352`	`protected defineSymbolInWorkspace(symbol: BlocksSymbol, workspace: Blockly.Workspace) {`
`336`	`353`	`const map = workspace.getVariableMap();`
`337`	`354`
`@@ -463,7 +480,7 @@ function getSymbolFromFunctionDefinitionBlock(block: FunctionDefinitionBlock, fi`
`463`	`480`	`functionSymbol.arguments.push({`
`464`	`481`	`name: child.getAttribute("name"),`
`465`	`482`	`type: child.getAttribute("type"),`
`466`		`- id: child.getAttribute("argid")`
	`483`	`+ id: child.getAttribute("id")`
`467`	`484`	`});`
`468`	`485`	`}`
`469`	`486`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,9 +5,10 @@ import {`
`5`	`5`	`FUNCTION_DECLARATION_BLOCK_TYPE,`
`6`	`6`	`FUNCTION_DEFINITION_BLOCK_TYPE,`
`7`	`7`	`} from "./constants";`
`8`		`-import { getDefinition, idsInUse, isCustomType, StringMap } from "./utils";`
	`8`	`+import { getDefinition, idsInUse, isCustomType, lookupImportedFunctionDef, StringMap } from "./utils";`
`9`	`9`	`import { MsgKey } from "./msg";`
`10`	`10`	`import { BlocksFunctionSymbol } from "../../blocksProgram";`
	`11`	`+import { external } from "../..";`
`11`	`12`
`12`	`13`	`type CommonFunctionMixinType = typeof COMMON_FUNCTION_MIXIN;`
`13`	`14`
`@@ -288,17 +289,18 @@ export const COMMON_FUNCTION_MIXIN = {`
`288`	`289`	`}`
`289`	`290`	`}`
`290`	`291`	`else {`
`291`		`- const importedDef = this.workspace.getVariableMap().getVariableById(this.functionId_);`
`292`		`- if (importedDef) {`
`293`		`- const importedDefArgs = JSON.parse(importedDef.getName()) as BlocksFunctionSymbol;`
	`292`	`+ const importedFunction = lookupImportedFunctionDef(this.name_, this.workspace, this.functionId_);`
	`293`	`+ if (importedFunction) {`
`294`	`294`	`for (let i = 0; i < this.arguments_.length; ++i) {`
`295`		`- for (let j = 0; j < importedDefArgs.arguments.length; ++j) {`
`296`		`- if (importedDefArgs.arguments[j].name == this.arguments_[i].name) {`
`297`		`- this.arguments_[i].id = importedDefArgs.arguments[j].id;`
	`295`	`+ for (let j = 0; j < importedFunction.arguments.length; ++j) {`
	`296`	`+ if (importedFunction.arguments[j].name == this.arguments_[i].name) {`
	`297`	`+ this.arguments_[i].id = importedFunction.arguments[j].id;`
`298`	`298`	`break;`
`299`	`299`	`}`
`300`	`300`	`}`
`301`	`301`	`}`
	`302`	`+`
	`303`	`+ this.functionId_ = importedFunction.id;`
`302`	`304`	`}`
`303`	`305`	`}`
`304`	`306`	`break;`