store block param localization in translation cache (#10593)

Author: riknoll

pxtblocks/loader.ts

@@ -26,6 +26,9 @@ import { FieldDropdown } from "./fields/field_dropdown";
 import { setDraggableShadowBlocks, setDuplicateOnDrag, setDuplicateOnDragStrategy } from "./plugins/duplicateOnDrag";
 import { initCopyPaste } from "./copyPaste";
 import { FieldVariable } from "./plugins/newVariableField/fieldVariable";
+import { ArgumentReporterBlock, FieldArgumentReporter, setArgumentReporterLocalizeFunction } from "./plugins/functions";
+import { getArgumentReporterParent } from "./plugins/functions/utils";
+import { isFunctionDefinition } from "./compiler/util";
 
 export const DRAGGABLE_PARAM_INPUT_PREFIX = "HANDLER_DRAG_PARAM_";
 
@@ -104,7 +107,11 @@ export function blockSymbol(type: string): pxtc.SymbolInfo {
 export function injectBlocks(blockInfo: pxtc.BlocksInfo): pxtc.SymbolInfo[] {
     cachedBlockInfo = blockInfo;
 
-   setDraggableShadowBlocks(blockInfo.blocks.filter(fn => fn.attributes.duplicateShadowOnDrag).map(fn => fn.attributes.blockId));
+    setDraggableShadowBlocks(blockInfo.blocks.filter(fn => fn.attributes.duplicateShadowOnDrag).map(fn => fn.attributes.blockId));
+
+    setArgumentReporterLocalizeFunction((arg, block) => {
+        return localizeArgumentReporter(blockInfo, arg, block);
+    });
 
     // inject Blockly with all block definitions
     return blockInfo.blocks
@@ -849,3 +856,37 @@ export function setVarFieldValue(block: Blockly.Block, fieldName: string, newNam
         varField.setValue(model.getId());
     }
 }
+
+
+function localizeArgumentReporter(blocksInfo: pxtc.BlocksInfo, field: FieldArgumentReporter, block: ArgumentReporterBlock): string | undefined {
+    let result: string = undefined;
+
+    const mutationName = block.getLocalizationName();
+    if (mutationName) {
+        const localized = pxt.U.rlf(mutationName);
+        if (localized !== mutationName) {
+            result = localized;
+        }
+        else {
+            result = pxtc.getBlockTranslationsCacheKey(mutationName);
+        }
+    }
+
+    const parent = getArgumentReporterParent(block, block);
+
+    if (!parent || isFunctionDefinition(parent)) return result;
+
+    const fn = blocksInfo.blocksById[parent.type];
+
+    if (!fn) return result;
+
+    const comp = pxt.blocks.compileInfo(fn);
+
+    const handlerArg = comp.handlerArgs?.find(arg => arg.name === field.getValue());
+
+    if (handlerArg) {
+        return pxtc.getBlockTranslationsCacheKey(handlerArg.localizationKey);
+    }
+
+    return result;
+}

pxtblocks/plugins/functions/fields/fieldArgumentReporter.ts

@@ -2,14 +2,15 @@ import * as Blockly from "blockly";
 import { isFunctionArgumentReporter } from "../utils";
 import { ArgumentReporterBlock } from "../blocks/argumentReporterBlocks";
 
+let localizeFunction: (arg: FieldArgumentReporter, block: ArgumentReporterBlock) => string;
+
 export class FieldArgumentReporter extends Blockly.FieldLabelSerializable {
     protected override getDisplayText_(): string {
         const source = this.getSourceBlock();
-        if (source && isFunctionArgumentReporter(source)) {
-            const localizeKey = (source as ArgumentReporterBlock).getLocalizationName();
+        if (source && isFunctionArgumentReporter(source) && localizeFunction) {
+            const localized = localizeFunction(this, source as ArgumentReporterBlock);
 
-            const localized = localizeKey && pxt.U.rlf(localizeKey);
-            if (localized && localized !== localizeKey) {
+            if (localized) {
                 return localized;
             }
         }
@@ -18,4 +19,8 @@ export class FieldArgumentReporter extends Blockly.FieldLabelSerializable {
     }
 }
 
+export function setArgumentReporterLocalizeFunction(func: (arg: FieldArgumentReporter, block: ArgumentReporterBlock) => string) {
+    localizeFunction = func;
+}
+
 Blockly.registry.register(Blockly.registry.Type.FIELD, "field_argument_reporter", FieldArgumentReporter);

pxtblocks/plugins/functions/utils.ts

@@ -278,7 +278,7 @@ export function doArgumentReporterDragChecks(a: Blockly.RenderedConnection, b: B
     return !!(getArgumentReporterParent(draggedBlock, destinationBlock));
 }
 
-function getArgumentReporterParent(reporter: Blockly.Block, location: Blockly.Block): Blockly.Block | undefined {
+export function getArgumentReporterParent(reporter: Blockly.Block, location: Blockly.Block): Blockly.Block | undefined {
     pxt.U.assert(isFunctionArgumentReporter(reporter));
 
     const varName = reporter.getFieldValue("VALUE");

pxtlib/service.ts

@@ -30,6 +30,7 @@ namespace ts.pxtc {
 
     export const NATIVE_TYPE_THUMB = "thumb";
     export const NATIVE_TYPE_VM = "vm";
+    export const BLOCK_TRANSLATION_CACHE_KEY = "_blocks";
 
     export interface BlocksInfo {
         apis: ApisInfo;
@@ -724,6 +725,20 @@ namespace ts.pxtc {
             const nsDoc = loc['{id:category}' + Util.capitalize(fn.qName)];
             let locBlock = loc[`${fn.qName}|block`] || fn.attributes.locs?.[attrBlockLocsKey];
 
+            if (fn.attributes.block) {
+                const comp = pxt.blocks.compileInfo(fn);
+                if (comp.handlerArgs) {
+                    for (const arg of comp.handlerArgs) {
+                        if (loc[arg.localizationKey]) {
+                           setBlockTranslationCacheKey(arg.localizationKey, loc[arg.localizationKey]);
+                        }
+                        else {
+                            clearBlockTranslationCacheKey(arg.localizationKey);
+                        }
+                    }
+                }
+            }
+
             if (!locBlock && altLocSrcFn) {
                 const otherTranslation = loc[`${altLocSrcFn.qName}|block`] || altLocSrcFn.attributes.locs?.[attrBlockLocsKey];
                 const isSameBlockDef = fn.attributes.block === (altLocSrcFn.attributes._untranslatedBlock || altLocSrcFn.attributes.block);
@@ -795,6 +810,34 @@ namespace ts.pxtc {
         return apis;
     }
 
+    function setBlockTranslationCacheKey(key: string, value: string) {
+        const cache = pxt.Util.translationsCache();
+
+        if (!cache[BLOCK_TRANSLATION_CACHE_KEY]) {
+            cache[BLOCK_TRANSLATION_CACHE_KEY] = {};
+        }
+
+        cache[BLOCK_TRANSLATION_CACHE_KEY][key] = value;
+    }
+
+    function clearBlockTranslationCacheKey(key: string) {
+        const cache = pxt.Util.translationsCache();
+
+        if (cache[BLOCK_TRANSLATION_CACHE_KEY]) {
+            delete cache[BLOCK_TRANSLATION_CACHE_KEY][key];
+        }
+    }
+
+    export function getBlockTranslationsCacheKey(key: string): string | undefined {
+        const cache = pxt.Util.translationsCache();
+
+        if (cache[BLOCK_TRANSLATION_CACHE_KEY]) {
+            return cache[BLOCK_TRANSLATION_CACHE_KEY][key];
+        }
+
+        return undefined;
+    }
+
     function hasEquivalentParameters(a: pxt.blocks.BlockCompileInfo, b: pxt.blocks.BlockCompileInfo) {
         if (a.parameters.length != b.parameters.length) {
             pxt.debug(`Localized block has extra or missing parameters`);