pxt-core 13.2.1 → 13.2.3

package/built/pxt.js

@@ -108611,8 +108611,29 @@ var pxt;
             }
             async loadConfigAsync(repopath, tag) {
                 if (!tag) {
-                    pxt.debug(`dep: default to master branch`);
-                    tag = "master";
+                    pxt.debug(`dep: no tag specified, try master and main`);
+                    let res;
+                    let error;
+                    try {
+                        res = await this.loadConfigAsync(repopath, "master");
+                    }
+                    catch (e) {
+                        error = e;
+                        pxt.log(`Error loading default master config for ${repopath}: ${e.message}`);
+                    }
+                    if (res)
+                        return res;
+                    try {
+                        res = await this.loadConfigAsync(repopath, "main");
+                    }
+                    catch (e) {
+                        error = e;
+                        pxt.log(`Error loading default main config for ${repopath}: ${e.message}`);
+                    }
+                    if (res)
+                        return res;
+                    else
+                        throw error;
                 }
                 // cache lookup
                 const key = `${repopath}/${tag}`;
@@ -108646,8 +108667,29 @@ var pxt;
             }
             async loadPackageAsync(repopath, tag, fallbackPackageFiles) {
                 if (!tag) {
-                    pxt.debug(`load pkg: default to master branch`);
-                    tag = "master";
+                    pxt.debug(`load pkg: no tag specified, try master and main`);
+                    let res;
+                    let error;
+                    try {
+                        res = await this.loadPackageAsync(repopath, "master", fallbackPackageFiles);
+                    }
+                    catch (e) {
+                        error = e;
+                        pxt.log(`Error loading default master package for ${repopath}: ${e.message}`);
+                    }
+                    if (res)
+                        return res;
+                    try {
+                        res = await this.loadPackageAsync(repopath, "main", fallbackPackageFiles);
+                    }
+                    catch (e) {
+                        error = e;
+                        pxt.log(`Error loading default main package for ${repopath}: ${e.message}`);
+                    }
+                    if (res)
+                        return res;
+                    else
+                        throw error;
                 }
                 // try using github proxy first
                 if (hasProxy()) {
@@ -108933,16 +108975,27 @@ var pxt;
             });
         }
         github.mergeAsync = mergeAsync;
-        function getRefAsync(repopath, branch) {
-            branch = branch || "master";
-            return ghGetJsonAsync("https://api.github.com/repos/" + repopath + "/git/refs/heads/" + branch)
-                .then(resolveRefAsync)
-                .catch(err => {
-                if (err.statusCode == 404)
+        async function getRefAsync(repopath, branch) {
+            if (!branch) {
+                // try master and main
+                let res = await getRefAsync(repopath, "master");
+                if (!res)
+                    res = await getRefAsync(repopath, "main");
+                return res;
+            }
+            try {
+                const ref = await ghGetJsonAsync("https://api.github.com/repos/" + repopath + "/git/refs/heads/" + branch);
+                return resolveRefAsync(ref);
+            }
+            catch (e) {
+                pxt.debug(`Error fetching ref for ${repopath} branch ${branch}: ${e.message}`);
+                if (e.statusCode === 404) {
                     return undefined;
-                else
-                    Promise.reject(err);
-            });
+                }
+                else {
+                    throw e;
+                }
+            }
         }
         github.getRefAsync = getRefAsync;
         function generateNextRefName(res, pref) {
@@ -113528,7 +113581,7 @@ var pxt;
                                         }]
                                 },
                                 {
-                                    name: lf("booming kick"),
+                                    name: lf("boom kick"),
                                     startFrequency: 100,
                                     startVolume: 1024,
                                     steps: [{
@@ -119033,10 +119086,12 @@ var pxt;
          * @param skipIDs string[] a list of string ids (block id, asset id, or file name) to ignore
          **/
         isAssetUsed(asset, files, skipIDs) {
-            var _a, _b, _c;
-            let blockIds = ((_b = (_a = asset.meta) === null || _a === void 0 ? void 0 : _a.blockIDs) === null || _b === void 0 ? void 0 : _b.filter(id => !skipIDs || (skipIDs === null || skipIDs === void 0 ? void 0 : skipIDs.indexOf(id)) < 0)) || [];
-            if (blockIds.length > 0)
-                return true;
+            var _a, _b, _c, _d, _e;
+            if (!((_a = asset.meta) === null || _a === void 0 ? void 0 : _a.displayName) || !files) {
+                let blockIds = ((_c = (_b = asset.meta) === null || _b === void 0 ? void 0 : _b.blockIDs) === null || _c === void 0 ? void 0 : _c.filter(id => !skipIDs || (skipIDs === null || skipIDs === void 0 ? void 0 : skipIDs.indexOf(id)) < 0)) || [];
+                if (blockIds.length > 0)
+                    return true;
+            }
             if (asset.type == "tile" /* pxt.AssetType.Tile */) {
                 for (const tm of this.getAssets("tilemap" /* AssetType.Tilemap */)) {
                     if ((skipIDs === null || skipIDs === void 0 ? void 0 : skipIDs.indexOf(tm.id)) >= 0) {
@@ -119048,84 +119103,83 @@ var pxt;
                 }
             }
             if (files) {
-                const shortId = pxt.Util.escapeForRegex(getShortIDForAsset(asset));
-                const displayName = pxt.Util.escapeForRegex((_c = asset.meta) === null || _c === void 0 ? void 0 : _c.displayName) || "";
-                let assetTsRefs;
-                switch (asset.type) {
-                    case "tile" /* pxt.AssetType.Tile */:
-                        assetTsRefs = `myTiles.${shortId}|assets.tile\`${shortId}\``;
-                        if (displayName)
-                            assetTsRefs += `|assets.tile\`${displayName}\``;
-                        break;
-                    case "tilemap" /* pxt.AssetType.Tilemap */:
-                        assetTsRefs = `tilemap\`${shortId}\``;
-                        break;
-                    case "animation" /* pxt.AssetType.Animation */:
-                        assetTsRefs = `assets.animation\`${shortId}\``;
-                        if (displayName)
-                            assetTsRefs += `|assets.animation\`${displayName}\``;
-                        break;
-                    case "song" /* pxt.AssetType.Song */:
-                        assetTsRefs = `assets.song\`${shortId}\``;
-                        if (displayName)
-                            assetTsRefs += `|assets.song\`${displayName}\``;
-                        break;
-                    case "json" /* pxt.AssetType.Json */:
-                        assetTsRefs = `assets.json\`${shortId}\``;
-                        if (displayName)
-                            assetTsRefs += `|assets.json\`${displayName}\``;
-                        break;
-                    default:
-                        assetTsRefs = `assets.image\`${shortId}\``;
-                        if (displayName)
-                            assetTsRefs += `|assets.image\`${displayName}\``;
-                        break;
+                const config = pxt.U.jsonTryParse((_d = files["pxt.json"]) === null || _d === void 0 ? void 0 : _d.content);
+                const filesToCheck = [];
+                if (config === null || config === void 0 ? void 0 : config.files) {
+                    for (const file of config.files) {
+                        if (file.endsWith(".g.ts"))
+                            continue;
+                        if (skipIDs && (skipIDs.indexOf(file) !== -1))
+                            continue;
+                        if (file.endsWith(".ts") && file !== pxt.MAIN_TS || file.endsWith(".py") && file !== pxt.MAIN_PY) {
+                            filesToCheck.push(file);
+                        }
+                    }
+                }
+                if ((config === null || config === void 0 ? void 0 : config.preferredEditor) === pxt.BLOCKS_PROJECT_NAME) {
+                    filesToCheck.push(pxt.MAIN_BLOCKS);
                 }
-                const assetTsRegex = new RegExp(assetTsRefs, "gm");
-                let assetPyRefs;
+                else if ((config === null || config === void 0 ? void 0 : config.preferredEditor) === pxt.JAVASCRIPT_PROJECT_NAME) {
+                    filesToCheck.push(pxt.MAIN_TS);
+                }
+                else if ((config === null || config === void 0 ? void 0 : config.preferredEditor) === pxt.PYTHON_PROJECT_NAME) {
+                    filesToCheck.push(pxt.MAIN_PY);
+                }
+                const references = [];
+                const shortId = pxt.Util.escapeForRegex(getShortIDForAsset(asset));
+                const displayName = pxt.Util.escapeForRegex((_e = asset.meta) === null || _e === void 0 ? void 0 : _e.displayName) || "";
+                const addNamespaceReference = (namespace, fun, id) => {
+                    references.push(`${namespace}\\s*\\.\\s*${fun}\`\\s*${id}\\s*\``);
+                };
                 switch (asset.type) {
                     case "tile" /* pxt.AssetType.Tile */:
-                        assetPyRefs = `myTiles.${shortId}|assets.tile\("""${shortId}"""\)`;
+                        references.push(`myTiles\\s*\\.\\s*${shortId}\\s*`);
+                        addNamespaceReference("assets", "tile", shortId);
                         if (displayName)
-                            assetPyRefs += `|assets.tile\("""${displayName}"""\)`;
+                            addNamespaceReference("assets", "tile", displayName);
                         break;
                     case "tilemap" /* pxt.AssetType.Tilemap */:
-                        assetPyRefs = `assets.tilemap\("""${shortId}"""\)`;
+                        references.push(`tilemap\`\\s*${shortId}\\s*\``);
+                        addNamespaceReference("assets", "tilemap", shortId);
+                        if (displayName) {
+                            references.push(`tilemap\`\\s*${displayName}\\s*\``);
+                            addNamespaceReference("assets", "tilemap", displayName);
+                        }
                         break;
                     case "animation" /* pxt.AssetType.Animation */:
-                        assetPyRefs = `assets.animation\("""${shortId}"""\)`;
+                        addNamespaceReference("assets", "animation", shortId);
                         if (displayName)
-                            assetPyRefs += `|assets.animation\("""${displayName}"""\)`;
+                            addNamespaceReference("assets", "animation", displayName);
                         break;
                     case "song" /* pxt.AssetType.Song */:
-                        assetPyRefs = `assets.song\("""${shortId}"""\)`;
+                        addNamespaceReference("assets", "song", shortId);
                         if (displayName)
-                            assetPyRefs += `|assets.song\("""${displayName}"""\)`;
+                            addNamespaceReference("assets", "song", displayName);
                         break;
                     case "json" /* pxt.AssetType.Json */:
-                        assetPyRefs = `assets.json\("""${shortId}"""\)`;
+                        addNamespaceReference("assets", "json", shortId);
                         if (displayName)
-                            assetPyRefs += `|assets.json\("""${displayName}"""\)`;
+                            addNamespaceReference("assets", "json", displayName);
                         break;
                     default:
-                        assetPyRefs = `assets.image\("""${shortId}"""\)`;
+                        addNamespaceReference("assets", "image", shortId);
                         if (displayName)
-                            assetPyRefs += `|assets.image\("""${displayName}"""\)`;
+                            addNamespaceReference("assets", "image", displayName);
                         break;
                 }
-                const assetPyRegex = new RegExp(assetPyRefs, "gm");
-                for (let filename of Object.keys(files)) {
-                    if ((skipIDs === null || skipIDs === void 0 ? void 0 : skipIDs.indexOf(filename)) >= 0)
-                        continue;
-                    const f = files[filename];
-                    // Match .ts files that are not generated (.g.ts)
-                    if (filename.match(/((?!\.g).{2}|^.{0,1})\.ts$/i)) {
-                        if (f.content.match(assetTsRegex))
+                const regex = new RegExp(references.map(r => `(?:${r})`).join("|"));
+                const pyRegex = new RegExp(references.map(r => `(?:${r})`).join("|").replace(/`/g, '"""'));
+                for (const file of filesToCheck) {
+                    const content = files[file].content;
+                    if (file.endsWith(".py")) {
+                        if (pyRegex.test(content)) {
                             return true;
+                        }
                     }
-                    else if (filename.endsWith(".py")) {
-                        if (f.content.match(assetPyRegex))
+                    else {
+                        if (regex.test(content)) {
                             return true;
+                        }
                     }
                 }
             }
@@ -126068,6 +126122,10 @@ ${baseLabel}_nochk:
             }
             emitFieldAccess(e, store = false) {
                 let info = e.data;
+                if (!store && this.shouldSpecializeCheckedFieldLoad(info)) {
+                    this.emitCheckedFieldLoad(info);
+                    return;
+                }
                 let pref = store ? "st" : "ld";
                 let lbl = pref + "fld_" + info.classInfo.id + "_" + info.name;
                 if (info.needsCheck && !pxtc.target.switches.skipClassCheck) {
@@ -126086,6 +126144,32 @@ ${baseLabel}_nochk:
                     this.write(`ldr r0, [r0, ${xoff}]`);
                 return;
             }
+            checkedFieldAccessCountKey(info) {
+                return `${info.classInfo.id}:${info.name}:get`;
+            }
+            shouldSpecializeCheckedFieldLoad(info) {
+                if (!pxtc.isThumb() || !this.bin.finalPass || pxtc.target.switches.noIfaceSpec)
+                    return false;
+                if (pxtc.target.switches.skipClassCheck || !info.needsCheck)
+                    return false;
+                return (this.bin.checkedFieldAccessCounts[this.checkedFieldAccessCountKey(info)] || 0) >= 5;
+            }
+            emitCheckedFieldLoad(info) {
+                const helperKey = "ldfldchk_" + info.classInfo.id + "_" + info.name;
+                const helper = this.ensureLabelledHelper(helperKey, () => {
+                    this.write(this.t.helper_prologue());
+                    this.emitInstanceOf(info.classInfo, "validate");
+                    let off = info.idx * 4 + 4;
+                    let xoff = "#" + off;
+                    if (off > 124) {
+                        this.write(this.t.emit_int(off, "r3"));
+                        xoff = "r3";
+                    }
+                    this.write(`ldr r0, [r0, ${xoff}]`);
+                    this.write(this.t.helper_epilogue());
+                });
+                this.write(this.t.call_lbl(helper, false, this.stackAlignmentNeeded(0)));
+            }
             writeFailBranch() {
                 this.write(`.fail:`);
                 this.write(`mov r1, lr`);
@@ -126306,12 +126390,50 @@ ${baseLabel}_nochk:
             }
             emitIfaceCall(procid, numargs, getset = "") {
                 pxtc.U.assert(procid.ifaceIndex > 0);
-                this.write(this.t.emit_int(procid.ifaceIndex, "r1"));
-                this.emitLabelledHelper("ifacecall" + numargs + "_" + getset, () => {
+                const helperKey = "ifacecall" + numargs + "_" + getset;
+                const helper = this.ensureLabelledHelper(helperKey, () => {
                     this.write(`ldr r0, [sp, #0] ; ld-this`);
                     this.loadVTable();
                     this.ifaceCallCore(numargs, getset);
                 });
+                if (this.shouldSpecializeIfaceCall(procid.ifaceIndex, numargs, getset)) {
+                    const thunkKey = helperKey + "_i" + procid.ifaceIndex;
+                    this.emitLabelledHelper(thunkKey, () => {
+                        this.write(this.t.emit_int(procid.ifaceIndex, "r1"));
+                        this.write(`ldlit r7, ${helper}@fn`);
+                        this.write(`bx r7`);
+                    });
+                }
+                else {
+                    this.write(this.t.emit_int(procid.ifaceIndex, "r1"));
+                    this.write(this.t.call_lbl(helper));
+                }
+            }
+            ifaceCallCountKey(ifaceIndex, numargs, getset) {
+                return `${ifaceIndex}:${numargs}:${getset || "call"}`;
+            }
+            // Count-driven specialization decisions (this method and the related
+            // shouldSpecializeCheckedFieldLoad / shouldSpecializeMapSetByFieldId) assume:
+            //  - bin.finalPass is true, AND
+            //  - the count maps were populated during the same final-pass emit()
+            //    call that builds the IR this asm walk consumes.
+            // This is currently true because the frontend populates counts during IR
+            // generation and the backend reads them only during the subsequent asm walk.
+            // Any future change that interleaves IR generation with asm emission would
+            // silently regress these to "always false".
+            //
+            // Threshold of 3 is the break-even point for the labelled-thunk pattern:
+            // each shared call site saves ~4 bytes vs an inline call, and the thunk
+            // itself costs ~12 bytes. At 3 callers, savings break even with thunk cost.
+            shouldSpecializeIfaceCall(ifaceIndex, numargs, getset) {
+                if (!pxtc.isThumb() || !this.bin.finalPass || pxtc.target.switches.noIfaceSpec)
+                    return false;
+                const count = this.bin.ifaceCallCounts[this.ifaceCallCountKey(ifaceIndex, numargs, getset)] || 0;
+                if (getset == "get" && numargs == 1)
+                    return count >= 3;
+                if (getset == "set" || !getset)
+                    return count >= 3;
+                return false;
             }
             // vtable in r3; clobber r2
             checkSubtype(info, failLbl = ".fail", r2 = "r2") {
@@ -126409,6 +126531,8 @@ ${baseLabel}_nochk:
             }
             emitRtCall(topExpr, genCall = null) {
                 let name = topExpr.data;
+                const mapSetFieldId = this.mapSetByFieldId(topExpr);
+                const specializeMapSetFieldId = mapSetFieldId !== undefined && this.shouldSpecializeMapSetByFieldId(mapSetFieldId);
                 if (name == "pxt::beginTry") {
                     return this.emitBeginTry(topExpr);
                 }
@@ -126421,6 +126545,8 @@ ${baseLabel}_nochk:
                     isRef: (maskInfo.refMask & (1 << i)) != 0,
                     conv: convs.find(c => c.argIdx == i)
                 }));
+                if (specializeMapSetFieldId)
+                    allArgs = allArgs.filter(a => a.idx != 1);
                 pxtc.U.assert(allArgs.length <= 4);
                 let seenUpdate = false;
                 for (let a of pxtc.U.reversed(allArgs)) {
@@ -126523,33 +126649,69 @@ ${baseLabel}_nochk:
                     genCall();
                 }
                 else {
-                    if (name != "langsupp::ignore")
+                    if (specializeMapSetFieldId)
+                        this.emitMapSetByFieldIdCall(mapSetFieldId);
+                    else if (name != "langsupp::ignore")
                         this.alignedCall(name, "", 0, true);
                 }
                 if (clearStack) {
                     this.clearArgs(complexArgs.filter(a => !a.isRef).map(a => a.expr), complexArgs.filter(a => a.isRef).map(a => a.expr));
                 }
             }
+            mapSetByFieldId(topExpr) {
+                if (topExpr.data != "pxtrt::mapSet" || topExpr.args.length != 3)
+                    return undefined;
+                const fieldId = topExpr.args[1];
+                if (fieldId.exprKind != pxtc.ir.EK.NumberLiteral || typeof fieldId.data != "number")
+                    return undefined;
+                return fieldId.data;
+            }
+            shouldSpecializeMapSetByFieldId(fieldId) {
+                if (!pxtc.isThumb() || !this.bin.finalPass || pxtc.target.switches.noIfaceSpec)
+                    return false;
+                return (this.bin.mapSetByFieldIdCounts[fieldId + ""] || 0) >= 3;
+            }
+            emitMapSetByFieldIdCall(fieldId) {
+                const helper = this.ensureLabelledHelper("mapset_i" + fieldId, () => {
+                    this.write(this.t.helper_prologue());
+                    this.write(this.t.emit_int(fieldId, "r1"));
+                    this.write(this.t.callCPP("pxtrt::mapSet"));
+                    this.write(this.t.helper_epilogue());
+                });
+                this.write(this.t.call_lbl(helper, false, this.stackAlignmentNeeded(0)));
+            }
             alignedCall(name, cmt = "", off = 0, saveStack = false) {
                 if (pxtc.U.startsWith(name, "_cmp_") || pxtc.U.startsWith(name, "_pxt_"))
                     saveStack = false;
                 this.write(this.t.call_lbl(name, saveStack, this.stackAlignmentNeeded(off)) + cmt);
             }
-            emitLabelledHelper(lbl, generate) {
+            // Lazily emit a deduped helper body and return its label.
+            // Use this when you want to BRANCH to (or reference) the helper without
+            // emitting a `bl` at the current cursor -- e.g. when wrapping the call in
+            // a thunk, or storing the label for later use.
+            ensureLabelledHelper(lbl, generate) {
                 if (!this.labelledHelpers[lbl]) {
                     let outp = this.redirectOutput(generate);
-                    this.emitHelper(outp, lbl);
-                    this.labelledHelpers[lbl] = this.bin.codeHelpers[outp];
-                }
-                else {
-                    this.write(this.t.call_lbl(this.labelledHelpers[lbl]));
+                    this.labelledHelpers[lbl] = this.helperLabel(outp, lbl);
                 }
+                return this.labelledHelpers[lbl];
             }
-            emitHelper(asm, baseName = "hlp") {
+            // Ensure a deduped helper exists and emit a `bl` to it at the cursor.
+            // Use this for the common case of "factor this sequence into a helper and call it here".
+            emitLabelledHelper(lbl, generate) {
+                const helper = this.ensureLabelledHelper(lbl, generate);
+                this.write(this.t.call_lbl(helper));
+                return helper;
+            }
+            helperLabel(asm, baseName = "hlp") {
                 if (!this.bin.codeHelpers[asm]) {
                     let len = Object.keys(this.bin.codeHelpers).length;
                     this.bin.codeHelpers[asm] = `_${baseName}_${len}`;
                 }
+                return this.bin.codeHelpers[asm];
+            }
+            emitHelper(asm, baseName = "hlp") {
+                this.helperLabel(asm, baseName);
                 this.write(this.t.call_lbl(this.bin.codeHelpers[asm]));
             }
             pushToExprStack(a) {
@@ -126586,48 +126748,85 @@ ${baseLabel}_nochk:
                     }
                 }
             }
-            emitFieldMethods() {
-                for (let op of ["get", "set"]) {
-                    this.write(`
+            emitFieldMethod(op) {
+                this.write(`
                 ${this.helperObject(op)}
                 .section code
                 _pxt_map_${op}:
                 `);
-                    this.loadVTable("r4");
-                    this.checkSubtype(this.builtInClassNo(pxt.BuiltInType.RefMap), ".notmap", "r4");
-                    this.write(this.t.callCPPPush(op == "set" ? "pxtrt::mapSetByString" : "pxtrt::mapGetByString"));
-                    this.write(".notmap:");
-                    let numargs = op == "set" ? 2 : 1;
-                    let hasAlign = false;
-                    this.write("mov r4, r3 ; save VT");
-                    if (op == "set") {
-                        if (pxtc.target.stackAlign) {
-                            hasAlign = true;
-                            this.write("push {lr} ; align");
-                        }
-                        this.write(`
+                this.loadVTable("r4");
+                this.checkSubtype(this.builtInClassNo(pxt.BuiltInType.RefMap), ".notmap", "r4");
+                this.write(this.t.callCPPPush(op == "set" ? "pxtrt::mapSetByString" : "pxtrt::mapGetByString"));
+                this.write(".notmap:");
+                let numargs = op == "set" ? 2 : 1;
+                let hasAlign = false;
+                this.write("mov r4, r3 ; save VT");
+                if (op == "set") {
+                    if (pxtc.target.stackAlign) {
+                        hasAlign = true;
+                        this.write("push {lr} ; align");
+                    }
+                    this.write(`
                             push {r0, r2, lr}
                             mov r0, r1
                         `);
-                    }
-                    else {
-                        this.write(`
+                }
+                else {
+                    this.write(`
                             push {r0, lr}
                             mov r0, r1
                         `);
-                    }
-                    this.write(`
+                }
+                this.write(`
                     bl pxtrt::lookupMapKey
                     mov r1, r0 ; put key index in r1
                     ldr r0, [sp, #0] ; restore obj pointer
                     mov r3, r4 ; restore vt
                     bl .dowork
                 `);
-                    this.write(this.t.pop_locals(numargs + (hasAlign ? 1 : 0)));
-                    this.write("pop {pc}");
-                    this.write(".dowork:");
-                    this.ifaceCallCore(numargs, op, true);
-                }
+                this.write(this.t.pop_locals(numargs + (hasAlign ? 1 : 0)));
+                this.write("pop {pc}");
+                this.write(".dowork:");
+                this.ifaceCallCore(numargs, op, true);
+            }
+            emitStringMapSetMethod() {
+                // Fast path for the well-typed "map with string index signature" case.
+                // - tagged-int / null receivers: unrecoverable, panic with failedCast (matches the
+                //   pre-optimization mapSetGeneric path, which also can't proceed on these).
+                // - non-RefMap pointer receivers: tail-call _pxt_map_set, which handles
+                //   non-map objects via interface dispatch. Preserves back-compat for code that
+                //   casts non-map objects to a string-index-signature type.
+                //
+                // Emitted only when the final-pass IR selected mapSetByStringOnly
+                // (never under `noIfaceSpec`): unreferenced helper text costs image
+                // space in every program otherwise.
+                if (!this.bin.usesMapSetByStringOnly)
+                    return;
+                this.write(`
+                ${this.helperObject("set string map")}
+                .section code
+                _pxt_map_set_by_string:
+                    lsls r4, r0, #30
+                    bne .badtype
+                    cmp r0, #0
+                    beq .badtype
+                    ldr r3, [r0, #0]
+                `);
+                this.write(`
+                ldrh r4, [r3, #8]
+                cmp r4, #${pxt.BuiltInType.RefMap}
+                bne .fallback
+            `);
+                this.write(this.t.callCPPPush("pxtrt::mapSetByString"));
+                this.write(`
+                .fallback:
+                    b _pxt_map_set
+                .badtype:
+                    mov r1, lr
+                    mov r7, sp
+                    str r7, [r6, #4]
+                    bl pxt::failedCast
+            `);
             }
             emitArrayMethod(op, isBuffer) {
                 this.write(`
@@ -126713,6 +126912,12 @@ ${baseLabel}_nochk:
                     this.emitArrayMethod(op, false);
                 }
             }
+            emitFieldMethods() {
+                for (let op of ["get", "set"]) {
+                    this.emitFieldMethod(op);
+                }
+                this.emitStringMapSetMethod();
+            }
             emitLambdaTrampoline() {
                 let r3 = pxtc.target.stackAlign ? "r3," : "";
                 this.write(`
@@ -127060,6 +127265,12 @@ ${baseLabel}_nochk:
                     this.write(`.short 0, 0 ; no captured vars`);
                     this.write(`.word ${this.proc.label()}_args@fn`);
                 }
+                if (this.proc.useExactIfaceWrapper) {
+                    this.write(`${this.proc.label()}_iface:`);
+                    this.write(`b ${this.proc.label()}_nochk`);
+                    if (!this.proc.info.usedAsValue)
+                        return;
+                }
                 this.write(`${this.proc.label()}_args:`);
                 let numargs = this.proc.args.length;
                 if (numargs == 0)
@@ -127828,6 +128039,17 @@ var ts;
             "pxt::fromInt": "_numops_fromInt",
             "pxt::switch_eq": "_pxt_switch_eq",
         };
+        // Boolean conversion fast paths, kept out of inlineArithmetic so the
+        // `noBoolLower` flag can drop the group (redirects and helper bodies alike).
+        const inlineBoolOps = {
+            "pxt::fromBool": "_pxt_fromBool",
+            "numops::toBool": "_numops_toBool",
+            "numops::toBoolDecr": "_numops_toBoolDecr",
+            "Boolean_::bang": "_pxt_boolean_bang",
+        };
+        function boolLowerEnabled() {
+            return !pxtc.target.switches.noBoolLower;
+        }
         // snippets for ARM Thumb assembly
         class ThumbSnippets extends pxtc.AssemblerSnippets {
             stackAligned() {
@@ -127935,6 +128157,8 @@ ${lbl}:`;
             }
             call_lbl(lbl, saveStack, stackAlign) {
                 let o = pxtc.U.lookup(inlineArithmetic, lbl);
+                if (!o && boolLowerEnabled())
+                    o = pxtc.U.lookup(inlineBoolOps, lbl);
                 if (o) {
                     lbl = o;
                     saveStack = false;
@@ -128106,6 +128330,99 @@ _numops_fromInt:
     blx lr
 .over2:
     ${this.callCPPPush("pxt::fromInt")}
+`;
+                // skipped under `noBoolLower` flag: unreferenced helper text still costs image space
+                if (boolLowerEnabled())
+                    r += `
+; Tag a raw 0/1 truth value into a boolean object (taggedTrue/taggedFalse).
+; Inverse of the toBool fast paths below; matches C++ pxt::fromBool.
+_pxt_fromBool:
+    @scope _pxt_fromBool
+    cmp r0, #0
+    beq .false
+.true:
+    movs r0, #${pxtc.taggedTrue}
+    blx lr
+.false:
+    movs r0, #${pxtc.taggedFalse}
+    blx lr
+
+; Logical NOT of a raw 0/1 truth value -> raw 0/1 (matches C++ bool bang(bool)).
+; Callers pass an already-tested condition, so this is raw-in / raw-out; value
+; context (x = !y) wraps the result with fromBool to re-tag it.
+_pxt_boolean_bang:
+    @scope _pxt_boolean_bang
+    cmp r0, #0
+    beq .true
+.false:
+    movs r0, #0
+    blx lr
+.true:
+    movs r0, #1
+    blx lr
+
+; Fast-path truthiness test: tagged value in r0 -> raw 0/1 in r0.
+; Value encodings (see taggedSpecialValue in emitter.ts): tagged int = (n<<1)|1
+; (low bit set); special tags = (n<<2)|2 with undefined=0, null, false, NaN,
+; true; heap objects have low 2 bits 00.
+; Only non-pointer values are decided inline here; any heap object is handed to
+; the C++ helper at .boxed (which also handles boxed numbers/strings like 0.0
+; and ""). INVARIANT: the falsy set below must match C++ numops::toBool exactly
+; -- if a new falsy tagged value is ever added, it must be added here too, or it
+; will fall through to .true.
+_numops_toBool:
+    @scope _numops_toBool
+    cmp r0, #0          ; undefined (0)            -> false
+    beq .false
+    cmp r0, #1          ; integer 0 ((0<<1)|1)     -> false
+    beq .false
+    lsls r1, r0, #31    ; odd => nonzero tagged int -> true
+    bne .true
+    cmp r0, #${pxtc.taggedNull}   ; null  -> false
+    beq .false
+    cmp r0, #${pxtc.taggedFalse}  ; false -> false
+    beq .false
+    cmp r0, #${pxtc.taggedNaN}    ; NaN   -> false
+    beq .false
+    lsls r1, r0, #30    ; low 2 bits 00 => heap object -> defer to C++
+    beq .boxed
+.true:                  ; remaining specials (e.g. true) are truthy
+    movs r0, #1
+    blx lr
+.false:
+    movs r0, #0
+    blx lr
+.boxed:
+    ${this.callCPPPush("numops::toBool")}
+
+; Same truthiness classification as _numops_toBool (see comments above), but
+; this variant also consumes (ref-decrements) its argument. Only heap objects
+; are ref-counted, and those go through the C++ fallback which does the decr;
+; the inline non-pointer paths carry no refcount, so they need none.
+_numops_toBoolDecr:
+    @scope _numops_toBoolDecr
+    cmp r0, #0          ; undefined (0)            -> false
+    beq .false
+    cmp r0, #1          ; integer 0 ((0<<1)|1)     -> false
+    beq .false
+    lsls r1, r0, #31    ; odd => nonzero tagged int -> true
+    bne .true
+    cmp r0, #${pxtc.taggedNull}   ; null  -> false
+    beq .false
+    cmp r0, #${pxtc.taggedFalse}  ; false -> false
+    beq .false
+    cmp r0, #${pxtc.taggedNaN}    ; NaN   -> false
+    beq .false
+    lsls r1, r0, #30    ; low 2 bits 00 => heap object -> defer to C++
+    beq .boxed
+.true:
+    movs r0, #1
+    blx lr
+.false:
+    movs r0, #0
+    blx lr
+.boxed:
+    ${this.callCPPPush("numops::toBoolDecr")}
 `;
                 for (let op of Object.keys(pxtc.thumbCmpMap)) {
                     op = op.replace(/.*::/, "");
@@ -128130,9 +128447,10 @@ _cmp_${op}:
                     // the cmp isn't really needed, given how toBoolDecr() is compiled,
                     // but better not rely on it
                     // Also, cmp isn't needed when ref-counting (it ends with movs r0, r4)
+                    const toBoolDecr = boolLowerEnabled() ? "_numops_toBoolDecr" : "numops::toBoolDecr";
                     r += boxedOp(`
                         bl numops::${op}
-                        bl numops::toBoolDecr
+                        bl ${toBoolDecr}
                         cmp r0, #0`);
                 }
                 // switch(x){case k:} compiles to equality tests via pxt::switch_eq.
@@ -133578,6 +133896,7 @@ var ts;
                     this.classInfo = null;
                     this.perfCounterName = null;
                     this.perfCounterNo = 0;
+                    this.useExactIfaceWrapper = false;
                     this.body = [];
                     this.lblNo = 0;
                     this.action = null;
@@ -133595,6 +133914,11 @@ var ts;
                 isGetter() {
                     return this.action && this.action.kind == ts.SyntaxKind.GetAccessor;
                 }
+                // Returns the proc's "_args" entry label -- the full arg-shuffling
+                // wrapper. Use this for any vtable-style reference where the caller
+                // cannot guarantee the wrapper-skip preconditions (numargs >= proc.args.length).
+                // For iface-table entries that CAN accept the optimization, the consumer
+                // (hexfile.ts) inspects useExactIfaceWrapper directly and picks _iface instead.
                 vtLabel() {
                     return this.label() + (pxtc.isStackMachine() ? "" : "_args");
                 }
@@ -134137,6 +134461,11 @@ var ts;
                 argsFmt: ["T", "T", "S", "T"],
                 value: 0
             },
+            "pxtrt::mapSetByStringOnly": {
+                name: "_pxt_map_set_by_string",
+                argsFmt: ["T", "T", "S", "T"],
+                value: 0
+            },
         };
         let EK = pxtc.ir.EK;
         pxtc.SK = ts.SyntaxKind;
@@ -134870,6 +135199,87 @@ var ts;
             bin.breakpoints = opts.breakpoints;
             bin.name = opts.name;
             bin.target = opts.target;
+            function ifaceCallKindCounts(ifaceIndex, getset) {
+                const suffix = ":" + (getset || "call");
+                return Object.keys(bin.ifaceCallCounts)
+                    .filter(k => pxtc.U.startsWith(k, ifaceIndex + ":") && pxtc.U.endsWith(k, suffix))
+                    .map(k => ({
+                    numargs: parseInt(k.split(":")[1]),
+                    count: bin.ifaceCallCounts[k]
+                }));
+            }
+            // Decides whether `proc` (an iface-dispatched method) can safely skip the
+            // arg-shuffling _args wrapper and have its iface vtable entry point directly
+            // at _nochk. Safe iff every call site that targets this (ifaceIndex, getset)
+            // bucket passes at least `proc.args.length` arguments -- that's exactly the
+            // condition the wrapper would short-circuit on (`cmp r4, #numargs; bge _nochk`).
+            //
+            // Notes:
+            // - The counts are a per-(ifaceIndex, getset) projection, not per-proc. In a
+            //   polymorphic iface bucket each proc is evaluated independently; eligibility
+            //   ends up cascading to the proc with the largest args.length in the bucket.
+            // - toString is excluded because hexfile.ts:~841 wires toString's vtable
+            //   slot to `vtLabel()` (i.e. _args). The fixed-slot dispatch through that
+            //   vtable entry has no arg-count guarantees, so the wrapper is required.
+            //   Skipping it for a toString proc would dangle the _args reference.
+            //   Any future fixed-slot vtable consumer that uses vtLabel() must add a
+            //   matching exclusion here.
+            // - dynamicIfaceCalls disqualifies any ifaceIndex ever dispatched without a
+            //   known decl (line ~2503). Those callers don't go through the counted path.
+            // - The "no get calls in a non-get bucket" check is conservative: a "get"
+            //   syntax call has args.length == 1 which could under-feed a multi-arg call
+            //   target sharing the bucket.
+            function canUseExactIfaceWrapper(proc, ifaceIndex, getset) {
+                if (!isThumb() || !proc || !proc.info.usedAsIface || proc.args.length == 0)
+                    return false;
+                if (proc.action && isToString(proc.action))
+                    return false;
+                if (bin.dynamicIfaceCalls[ifaceIndex + ""])
+                    return false;
+                if (!getset && ifaceCallKindCounts(ifaceIndex, "get").length)
+                    return false;
+                const counts = ifaceCallKindCounts(ifaceIndex, getset);
+                return counts.every(c => c.numargs >= proc.args.length);
+            }
+            // Must run AFTER the final-pass emit(rootFunction) has populated
+            // bin.ifaceCallCounts and bin.dynamicIfaceCalls, and BEFORE
+            // hexfile.ts emits iface vtables (which read useExactIfaceWrapper to
+            // pick _iface vs _args per entry) and backbase.ts emits proc wrappers
+            // (which read useExactIfaceWrapper to decide whether to emit _iface).
+            function markExactIfaceWrappers() {
+                bin.procs.forEach(p => p.useExactIfaceWrapper = false);
+                if (!isThumb() || pxtc.target.switches.noIfaceSpec)
+                    return;
+                const eligible = {};
+                const seen = {};
+                const note = (proc, ifaceIndex, getset) => {
+                    if (!proc || proc.args.length == 0)
+                        return;
+                    const key = proc.seqNo + "";
+                    seen[key] = true;
+                    if (eligible[key] === undefined)
+                        eligible[key] = true;
+                    if (!canUseExactIfaceWrapper(proc, ifaceIndex, getset))
+                        eligible[key] = false;
+                };
+                for (const info of bin.usedClassInfos) {
+                    if (!info.itable)
+                        continue;
+                    for (const entry of info.itable) {
+                        if (entry.proc)
+                            note(entry.proc, entry.idx, entry.proc.isGetter() ? "get" : "");
+                        if (entry.setProc)
+                            note(entry.setProc, entry.idx, "set");
+                    }
+                }
+                for (const proc of bin.procs) {
+                    const key = proc.seqNo + "";
+                    proc.useExactIfaceWrapper = !!seen[key] && !!eligible[key];
+                }
+            }
+            function emitEscapedExpression(expr, reason) {
+                return emitExpr(expr);
+            }
             function reset() {
                 bin.reset();
                 proc = null;
@@ -134950,7 +135360,13 @@ var ts;
             reset();
             needsUsingInfo = false;
             bin.finalPass = true;
+            bin.ifaceCallCounts = {};
+            bin.mapSetByFieldIdCounts = {};
+            bin.checkedFieldAccessCounts = {};
+            bin.dynamicIfaceCalls = {};
+            bin.usesMapSetByStringOnly = false;
             emit(rootFunction);
+            markExactIfaceWrappers();
             pxtc.U.assert(usedWorkList.length == 0);
             res.configData = [];
             for (let k of Object.keys(configEntries)) {
@@ -135640,7 +136056,7 @@ ${lbl}: .short 0xffff
                 let coll = pxtc.ir.shared(pxtc.ir.rtcall("Array_::mk", []));
                 for (let elt of node.elements) {
                     let mask = isRefCountedExpr(elt) ? (1 << 1) : 0;
-                    proc.emitExpr(pxtc.ir.rtcall("Array_::push", [coll, emitExpr(elt)], mask));
+                    proc.emitExpr(pxtc.ir.rtcall("Array_::push", [coll, emitEscapedExpression(elt, "arrayElement")], mask));
                 }
                 if (node.elements.length > 0)
                     // Make sure there is at least one use of the array, so it doesn't get GC-ed away in the last push.
@@ -135682,8 +136098,11 @@ ${lbl}: .short 0xffff
                         if (isRefCountedExpr(p.initializer))
                             mask |= 1 << 2;
                     }
+                    const nativeFieldId = pxtc.target.isNative ? getIfaceMemberId(keyName) : undefined;
+                    if (nativeFieldId !== undefined)
+                        bin.mapSetByFieldIdCounts[nativeFieldId + ""] = (bin.mapSetByFieldIdCounts[nativeFieldId + ""] || 0) + 1;
                     const fieldId = pxtc.target.isNative
-                        ? pxtc.ir.numlit(getIfaceMemberId(keyName))
+                        ? pxtc.ir.numlit(nativeFieldId)
                         : pxtc.ir.ptrlit(null, JSON.stringify(keyName));
                     const args = [
                         expr,
@@ -135743,6 +136162,9 @@ ${lbl}: .short 0xffff
                             return emitShim(fld, decl, [node.expression]);
                         }
                         else {
+                            if (idx.needsCheck && !pxtc.target.switches.skipClassCheck) {
+                                bin.checkedFieldAccessCounts[checkedFieldAccessCountKey(idx)] = (bin.checkedFieldAccessCounts[checkedFieldAccessCountKey(idx)] || 0) + 1;
+                            }
                             return pxtc.ir.op(EK.FieldAccess, [emitExpr(node.expression)], idx);
                         }
                     }
@@ -135796,7 +136218,17 @@ ${lbl}: .short 0xffff
                     indexer = assign ? attrs.indexerSet : attrs.indexerGet;
                 }
                 if (!indexer && (t.flags & (ts.TypeFlags.Any | ts.TypeFlags.StructuredOrTypeVariable))) {
-                    indexer = assign ? "pxtrt::mapSetGeneric" : "pxtrt::mapGetGeneric";
+                    const hasIndexSignature = !!checker.getIndexTypeOfType(t, ts.IndexKind.String) || !!checker.getIndexTypeOfType(t, ts.IndexKind.Number);
+                    // Native-only: mapSetByStringOnly resolves to the _pxt_map_set_by_string
+                    // thumb helper. The JS backend has no such runtime entry, so the generic
+                    // setter is the only valid choice there.
+                    const mapOnlySet = !pxtc.target.switches.noIfaceSpec && pxtc.target.isNative
+                        && !!assign && !(t.flags & ts.TypeFlags.Any) && hasIndexSignature;
+                    if (mapOnlySet)
+                        bin.usesMapSetByStringOnly = true;
+                    indexer = assign
+                        ? (mapOnlySet ? "pxtrt::mapSetByStringOnly" : "pxtrt::mapSetGeneric")
+                        : "pxtrt::mapGetGeneric";
                     stringOk = true;
                 }
                 if (indexer) {
@@ -136133,7 +136565,7 @@ ${lbl}: .short 0xffff
                         lst.push(tracked);
                 }
                 function emitPlain() {
-                    let r = mkProcCall(decl, node, args.map((x) => emitExpr(x)));
+                    let r = mkProcCall(decl, node, args.map(x => emitEscapedExpression(x, "callArgument")));
                     let pp = r.data;
                     if (args[0] && pp.proc && pp.proc.classInfo)
                         pp.isThis = args[0].kind == pxtc.SK.ThisKeyword;
@@ -136160,7 +136592,7 @@ ${lbl}: .short 0xffff
                         baseCtor = p.ctor;
                     if (!baseCtor && bin.finalPass)
                         throw userError(9280, lf("super() call requires an explicit constructor in base class"));
-                    let ctorArgs = args.map((x) => emitExpr(x));
+                    let ctorArgs = args.map((x) => emitEscapedExpression(x, "callArgument"));
                     ctorArgs.unshift(emitThis(funcExpr));
                     return mkProcCallCore(baseCtor, node, ctorArgs);
                 }
@@ -136176,9 +136608,11 @@ ${lbl}: .short 0xffff
                         // TODO in VT accessor/field/method -> different
                         pxtc.U.assert(funcExpr.kind == pxtc.SK.PropertyAccessExpression);
                         const fieldName = funcExpr.name.text;
+                        const ifaceIndex = getIfaceMemberId(fieldName, true);
+                        bin.dynamicIfaceCalls[ifaceIndex + ""] = true;
                         // completely dynamic dispatch
-                        return mkMethodCall(args.map((x) => emitExpr(x)), {
-                            ifaceIndex: getIfaceMemberId(fieldName, true),
+                        return mkMethodCall(args.map((x) => emitEscapedExpression(x, "callArgument")), {
+                            ifaceIndex,
                             callLocationIndex: markCallLocation(node),
                             noArgs
                         });
@@ -136202,7 +136636,7 @@ ${lbl}: .short 0xffff
                             pxtc.U.assert(false);
                         }
                         pxtc.U.assert(!bin.finalPass || info.virtualIndex != null, "!bin.finalPass || info.virtualIndex != null");
-                        return mkMethodCall(args.map((x) => emitExpr(x)), {
+                        return mkMethodCall(args.map((x) => emitEscapedExpression(x, "callArgument")), {
                             classInfo: info.parentClassInfo,
                             virtualIndex: info.virtualIndex,
                             noArgs,
@@ -136242,9 +136676,15 @@ ${lbl}: .short 0xffff
                         return emitPlain();
                     }
                     else if (needsVCall || pxtc.target.switches.slowMethods || !forceMethod) {
-                        return mkMethodCall(args.map((x) => emitExpr(x)), {
-                            ifaceIndex: getIfaceMemberId(getName(decl), true),
-                            isSet: noArgs && args.length == 2,
+                        const ifaceIndex = getIfaceMemberId(getName(decl), true);
+                        const isSet = noArgs && args.length == 2;
+                        const callKind = isSet ? "set" : noArgs ? "get" : "call";
+                        const helperGetSet = callKind == "call" ? "" : callKind;
+                        const countKey = `${ifaceIndex}:${args.length}:${helperGetSet || "call"}`;
+                        bin.ifaceCallCounts[countKey] = (bin.ifaceCallCounts[countKey] || 0) + 1;
+                        return mkMethodCall(args.map((x) => emitEscapedExpression(x, "callArgument")), {
+                            ifaceIndex,
+                            isSet,
                             callLocationIndex: markCallLocation(node),
                             noArgs
                         });
@@ -136263,7 +136703,7 @@ ${lbl}: .short 0xffff
                 // here's where we will recurse to generate funcExpr
                 args.unshift(funcExpr);
                 pxtc.U.assert(!noArgs);
-                return mkMethodCall(args.map(x => emitExpr(x)), {
+                return mkMethodCall(args.map(x => emitEscapedExpression(x, "callArgument")), {
                     virtualIndex: -1,
                     callLocationIndex: markCallLocation(node),
                     noArgs
@@ -136359,6 +136799,8 @@ ${lbl}: .short 0xffff
                 }
             }
             function getCtor(decl) {
+                if (!decl.members)
+                    return null;
                 return decl.members.filter(m => m.kind == pxtc.SK.Constructor)[0];
             }
             function isIfaceMemberUsed(name) {
@@ -136406,7 +136848,7 @@ ${lbl}: .short 0xffff
                         // let sig = checker.getResolvedSignature(node)
                         // TODO: can we have overloeads?
                         addDefaultParametersAndTypeCheck(checker.getResolvedSignature(node), args, ctorAttrs);
-                        let compiled = args.map((x) => emitExpr(x));
+                        let compiled = args.map((x) => emitEscapedExpression(x, "callArgument"));
                         if (ctorAttrs.shim) {
                             // TODO need to deal with refMask and tagged ints here
                             // we drop 'obj' variable
@@ -136795,7 +137237,7 @@ ${lbl}: .short 0xffff
                 for (let f of initalizedFields) {
                     let idx = fieldIndexCore(proc.classInfo, getFieldInfo(proc.classInfo, getName(f)), false);
                     let trg2 = pxtc.ir.op(EK.FieldAccess, [emitLocalLoad(info.thisParameter)], idx);
-                    proc.emitExpr(pxtc.ir.op(EK.Store, [trg2, emitExpr(f.initializer)]));
+                    proc.emitExpr(pxtc.ir.op(EK.Store, [trg2, emitEscapedExpression(f.initializer, "initializer")]));
                 }
                 flushHoistedFunctionDefinitions();
                 if (node.body.kind == pxtc.SK.Block) {
@@ -137013,9 +137455,12 @@ ${lbl}: .short 0xffff
                     isRef: true,
                     shimName: attrs.shim,
                     classInfo: info,
-                    needsCheck
+                    needsCheck,
                 };
             }
+            function checkedFieldAccessCountKey(info) {
+                return `${info.classInfo.id}:${info.name}:get`;
+            }
             function fieldIndex(pacc) {
                 const tp = typeOf(pacc.expression);
                 if (isPossiblyGenericClassType(tp)) {
@@ -137046,7 +137491,7 @@ ${lbl}: .short 0xffff
                     if (decl && (isGlobal || isVar(decl) || isParameter(decl))) {
                         let l = lookupCell(decl);
                         recordUse(decl, true);
-                        proc.emitExpr(l.storeByRef(emitExpr(src)));
+                        proc.emitExpr(l.storeByRef(emitEscapedExpression(src, "assignment")));
                     }
                     else {
                         unhandled(trg, lf("bad target identifier"), 9248);
@@ -137062,7 +137507,10 @@ ${lbl}: .short 0xffff
                         }
                         proc.emitExpr(emitCallCore(trg, trg, [src], null, decl));
                     }
-                    else if (decl && (decl.kind == pxtc.SK.PropertySignature || decl.kind == pxtc.SK.PropertyAssignment || isSlowField(decl))) {
+                    else if (decl && (decl.kind == pxtc.SK.PropertySignature || decl.kind == pxtc.SK.PropertyAssignment)) {
+                        proc.emitExpr(emitCallCore(trg, trg, [src], null, decl));
+                    }
+                    else if (decl && isSlowField(decl)) {
                         proc.emitExpr(emitCallCore(trg, trg, [src], null, decl));
                     }
                     else {
@@ -137078,7 +137526,7 @@ ${lbl}: .short 0xffff
                                 }
                             }
                             let trg2 = emitExpr(trg);
-                            proc.emitExpr(pxtc.ir.op(EK.Store, [trg2, emitExpr(src)]));
+                            proc.emitExpr(pxtc.ir.op(EK.Store, [trg2, emitEscapedExpression(src, "assignment")]));
                             break;
                         }
                     }
@@ -137489,7 +137937,7 @@ ${lbl}: .short 0xffff
                 let mask = getMask(args);
                 let convInfos = [];
                 let args2 = args.map((a, i) => {
-                    let r = emitExpr(a);
+                    let r = emitEscapedExpression(a, "runtimeCallArgument");
                     if (!needsNumberConversions())
                         return r;
                     let f = fmt[i + 1];
@@ -137827,6 +138275,43 @@ ${lbl}: .short 0xffff
                 emitExprAsStmt(node.expression);
             }
             function emitCondition(expr, inner = null) {
+                // with `noBoolLower` flag, the generic paths below handle every condition
+                const boolLower = !pxtc.target.switches.noBoolLower;
+                // Lower `&&` / `||` used as a condition into short-circuiting jumps
+                // that yield 0/1 directly, instead of boxing the intermediate
+                // booleans and converting them back with a runtime helper.
+                if (boolLower && !inner && !isStackMachine() && expr.kind == pxtc.SK.BinaryExpression) {
+                    const binary = expr;
+                    const op = binary.operatorToken.kind;
+                    if (op == pxtc.SK.AmpersandAmpersandToken || op == pxtc.SK.BarBarToken) {
+                        const shortCircuitLabel = proc.mkLabel("lazycond");
+                        const doneLabel = proc.mkLabel("lazycondfin");
+                        if (op == pxtc.SK.AmpersandAmpersandToken) {
+                            proc.emitJmp(shortCircuitLabel, emitCondition(binary.left), pxtc.ir.JmpMode.IfZero);
+                            proc.emitJmp(shortCircuitLabel, emitCondition(binary.right), pxtc.ir.JmpMode.IfZero);
+                            proc.emitJmp(doneLabel, pxtc.ir.numlit(1), pxtc.ir.JmpMode.Always);
+                            proc.emitLbl(shortCircuitLabel);
+                            proc.emitJmp(doneLabel, pxtc.ir.numlit(0), pxtc.ir.JmpMode.Always);
+                        }
+                        else {
+                            proc.emitJmp(shortCircuitLabel, emitCondition(binary.left), pxtc.ir.JmpMode.IfNotZero);
+                            proc.emitJmp(shortCircuitLabel, emitCondition(binary.right), pxtc.ir.JmpMode.IfNotZero);
+                            proc.emitJmp(doneLabel, pxtc.ir.numlit(0), pxtc.ir.JmpMode.Always);
+                            proc.emitLbl(shortCircuitLabel);
+                            proc.emitJmp(doneLabel, pxtc.ir.numlit(1), pxtc.ir.JmpMode.Always);
+                        }
+                        proc.emitLbl(doneLabel);
+                        return captureJmpValue();
+                    }
+                }
+                // Lower `!expr` used as a condition by negating the operand's
+                // condition directly, avoiding a boxed boolean just to invert it.
+                if (boolLower && !inner && !isStackMachine() && expr.kind == pxtc.SK.PrefixUnaryExpression) {
+                    const unary = expr;
+                    if (unary.operator == pxtc.SK.ExclamationToken) {
+                        return pxtc.ir.rtcall("Boolean_::bang", [emitCondition(unary.operand)]);
+                    }
+                }
                 if (!inner && isThumb() && expr.kind == pxtc.SK.BinaryExpression) {
                     let be = expr;
                     let mapped = pxtc.U.lookup(pxtc.thumbCmpMap, simpleInstruction(be, be.operatorToken.kind));
@@ -138278,7 +138763,10 @@ ${lbl}: .short 0xffff
                         }
                     }
                     typeCheckSubtoSup(node.initializer, node);
-                    proc.emitExpr(loc.storeByRef(emitExpr(node.initializer)));
+                    const initializerExpr = isGlobalVar(node)
+                        ? emitEscapedExpression(node.initializer, "initializer")
+                        : emitExpr(node.initializer);
+                    proc.emitExpr(loc.storeByRef(initializerExpr));
                     currJres = null;
                     proc.stackEmpty();
                 }
@@ -138303,8 +138791,17 @@ ${lbl}: .short 0xffff
                     exres = pxtc.ir.op(EK.FieldAccess, [objRef], fieldIndexCore(info, getFieldInfo(info, fieldName)));
                 }
                 else {
+                    // Dynamic field access on a non-class-typed receiver (any, structural type,
+                    // etc). The call site supplies exactly 1 arg (the receiver) but the target
+                    // proc resolved via iface dispatch may be a method that expects more --
+                    // the _args wrapper is what normally fills in the missing args. Flag this
+                    // ifaceIndex so canUseExactIfaceWrapper disqualifies the wrapper-skip
+                    // optimization for any proc reachable here. Mirrors the dynamic-method-call
+                    // path above.
+                    const ifaceIndex = getIfaceMemberId(fieldName, true);
+                    bin.dynamicIfaceCalls[ifaceIndex + ""] = true;
                     exres = mkMethodCall([objRef], {
-                        ifaceIndex: getIfaceMemberId(fieldName, true),
+                        ifaceIndex,
                         callLocationIndex: markCallLocation(node),
                         noArgs: true
                     });
@@ -138687,6 +139184,11 @@ ${lbl}: .short 0xffff
                 this.usedChars = new Uint32Array(0x10000 / 32);
                 this.explicitlyUsedIfaceMembers = {};
                 this.ifaceMemberMap = {};
+                this.ifaceCallCounts = {};
+                this.mapSetByFieldIdCounts = {};
+                this.checkedFieldAccessCounts = {};
+                this.dynamicIfaceCalls = {};
+                this.usesMapSetByStringOnly = false;
                 this.strings = {};
                 this.hexlits = {};
                 this.doubles = {};
@@ -141137,9 +141639,9 @@ ${lbl}: ${snippets.obj_header("pxt::number_vt")}
             uint32_t ifaceHashMult;
             PVoid methods[2 or 4];
             */
-            const ifaceInfo = computeHashMultiplier(info.itable.map(e => e.idx));
-            //if (info.itable.length == 0)
-            //    ifaceInfo.mult = 0
+            const ifaceInfo = info.itable.length
+                ? computeHashMultiplier(info.itable.map(e => e.idx))
+                : { mult: 0, mapping: new Uint16Array(0), size: 0 };
             let ptrSz = pxtc.target.shortPointers ? ".short" : ".word";
             let s = `
         .object ${info.id}_VT
@@ -141173,6 +141675,11 @@ ${info.id}_IfaceVT:
 `;
             const descSize = 8;
             const zeroOffset = ifaceInfo.mapping.length * 2;
+            // Iface table is the one consumer that can elect the wrapper-skip
+            // optimization. Procs with useExactIfaceWrapper get pointed at _iface
+            // (which `b _nochk`); everyone else gets the usual _args wrapper entry.
+            // canUseExactIfaceWrapper guarantees this is safe for the elected procs.
+            const procIfaceLabel = (p) => (p.useExactIfaceWrapper ? p.label() + "_iface" : p.vtLabel()) + "@fn";
             let descs = "";
             let offset = zeroOffset;
             let offsets = {};
@@ -141180,11 +141687,11 @@ ${info.id}_IfaceVT:
                 offsets[e.idx + ""] = offset;
                 const desc = !e.proc ? 0 : e.proc.isGetter() ? 1 : 2;
                 descs += `  .short ${e.idx}, ${desc} ; ${e.name}\n`;
-                descs += `  .word ${e.proc ? e.proc.vtLabel() + "@fn" : e.info}\n`;
+                descs += `  .word ${e.proc ? procIfaceLabel(e.proc) : e.info}\n`;
                 offset += descSize;
                 if (e.setProc) {
                     descs += `  .short ${e.idx}, 0 ; set ${e.name}\n`;
-                    descs += `  .word ${e.setProc.vtLabel()}@fn\n`;
+                    descs += `  .word ${procIfaceLabel(e.setProc)}\n`;
                     offset += descSize;
                 }
             }
@@ -141197,7 +141704,9 @@ ${info.id}_IfaceVT:
                     bin.itFullEntries++;
             }
             // offsets are relative to the position in the array
-            s += "  .short " + pxtc.U.toArray(map).map((e, i) => (offsets[e + ""] || zeroOffset) - (i * 2)).join(", ") + "\n";
+            const hashOffsets = pxtc.U.toArray(map).map((e, i) => (offsets[e + ""] || zeroOffset) - (i * 2));
+            if (hashOffsets.length)
+                s += "  .short " + hashOffsets.join(", ") + "\n";
             s += descs;
             s += "\n";
             return s;