pxt-core 8.2.12 → 8.2.14

package/built/pxtcompiler.js

@@ -438,7 +438,7 @@ var ts;
                             const decl = getDecl(child);
                             if (decl && decl.getSourceFile().fileName !== pxt.MAIN_TS && decl.kind == ts.SyntaxKind.VariableDeclaration) {
                                 const info = pxtc.pxtInfo(child);
-                                info.flags |= 4 /* IsGlobalIdentifier */;
+                                info.flags |= 4 /* PxtNodeFlags.IsGlobalIdentifier */;
                                 if (!info.commentAttrs) {
                                     info.commentAttrs = pxtc.parseComments(decl);
                                 }
@@ -554,7 +554,7 @@ var ts;
                         symbol: { isBogusSymbol: true, name: namedNode.name.getText() },
                         name: namedNode.name,
                     };
-                    pxtc.pxtInfo(decl).flags |= 2 /* IsBogusFunction */;
+                    pxtc.pxtInfo(decl).flags |= 2 /* PxtNodeFlags.IsBogusFunction */;
                 }
                 return decl;
             }
@@ -1072,7 +1072,7 @@ ${baseLabel}_nochk:
                 else if (inf.size == 2) {
                     inf.immLimit = 64;
                 }
-                if (b == 1 /* Int8 */ || b == 3 /* Int16 */) {
+                if (b == 1 /* BitSize.Int8 */ || b == 3 /* BitSize.Int16 */) {
                     inf.needsSignExt = true;
                 }
                 return inf;
@@ -2661,7 +2661,7 @@ function ${id}(s) {
                     text = args.length == 2 ? `(${args[0]} ${pxtc.U.lookup(jsOpMap, name)} ${args[1]})` : `(${pxtc.U.lookup(jsOpMap, name)} ${args[0]})`;
                 else
                     text = `${shimToJs(name)}(${args.join(", ")})`;
-                if (topExpr.callingConvention == 0 /* Plain */) {
+                if (topExpr.callingConvention == 0 /* ir.CallingConvention.Plain */) {
                     write(`r0 = ${text};`);
                 }
                 else {
@@ -2670,7 +2670,7 @@ function ${id}(s) {
                     if (name == "String_::stringConv") {
                         write(`if ((${args[0]}) && (${args[0]}).vtable) {`);
                     }
-                    if (topExpr.callingConvention == 2 /* Promise */) {
+                    if (topExpr.callingConvention == 2 /* ir.CallingConvention.Promise */) {
                         write(`(function(cb) { ${text}.then(cb) })(buildResume(s, ${loc}));`);
                     }
                     else {
@@ -2793,13 +2793,13 @@ function ${id}(s) {
             }
             function bitSizeConverter(b) {
                 switch (b) {
-                    case 0 /* None */: return "";
-                    case 1 /* Int8 */: return "pxtrt.toInt8";
-                    case 3 /* Int16 */: return "pxtrt.toInt16";
-                    case 5 /* Int32 */: return "pxtrt.toInt32";
-                    case 2 /* UInt8 */: return "pxtrt.toUInt8";
-                    case 4 /* UInt16 */: return "pxtrt.toUInt16";
-                    case 6 /* UInt32 */: return "pxtrt.toUInt32";
+                    case 0 /* BitSize.None */: return "";
+                    case 1 /* BitSize.Int8 */: return "pxtrt.toInt8";
+                    case 3 /* BitSize.Int16 */: return "pxtrt.toInt16";
+                    case 5 /* BitSize.Int32 */: return "pxtrt.toInt32";
+                    case 2 /* BitSize.UInt8 */: return "pxtrt.toUInt8";
+                    case 4 /* BitSize.UInt16 */: return "pxtrt.toUInt16";
+                    case 6 /* BitSize.UInt32 */: return "pxtrt.toUInt32";
                     default: throw pxtc.oops();
                 }
             }
@@ -3948,7 +3948,7 @@ _start_${name}:
                         emitExpr(src);
                         let cell = trg.data;
                         let instr = "st" + cellref(cell);
-                        if (cell.isGlobal() && (cell.bitSize != 0 /* None */)) {
+                        if (cell.isGlobal() && (cell.bitSize != 0 /* BitSize.None */)) {
                             const enc = pxtc.sizeOfBitSize(cell.bitSize) |
                                 (pxtc.isBitSizeSigned(cell.bitSize) ? 0x10 : 0x00);
                             write("bitconv " + enc);
@@ -4360,7 +4360,7 @@ ${output}</xml>`;
                     }
                     return {
                         paramDefl: {},
-                        callingConvention: 0 /* Plain */
+                        callingConvention: 0 /* ir.CallingConvention.Plain */
                     };
                 }
                 function compInfo(callInfo) {
@@ -6849,7 +6849,7 @@ ${output}</xml>`;
                                 const parentInfo = pxtc.pxtInfo(parent).callInfo;
                                 if (parentInfo && parentInfo.args) {
                                     const api = env.blocks.apis.byQName[parentInfo.qName];
-                                    const instance = api.kind == 1 /* Method */ || api.kind == 2 /* Property */;
+                                    const instance = api.kind == 1 /* pxtc.SymbolKind.Method */ || api.kind == 2 /* pxtc.SymbolKind.Property */;
                                     if (api) {
                                         parentInfo.args.forEach((arg, i) => {
                                             if (arg === child) {
@@ -6966,7 +6966,7 @@ ${output}</xml>`;
                 return node && node.kind === SK.Identifier && node.text === "undefined";
             }
             function isDeclaredElsewhere(node) {
-                return !!(pxtc.pxtInfo(node).flags & 4 /* IsGlobalIdentifier */);
+                return !!(pxtc.pxtInfo(node).flags & 4 /* PxtNodeFlags.IsGlobalIdentifier */);
             }
             function hasStatementInput(info, attributes) {
                 if (attributes.blockId === pxtc.PAUSE_UNTIL_TYPE)
@@ -7339,21 +7339,21 @@ var ts;
                 if (!sym)
                     return undefined;
                 switch (sym.kind) {
-                    case 3 /* Function */:
-                    case 1 /* Method */:
+                    case 3 /* SymbolKind.Function */:
+                    case 1 /* SymbolKind.Method */:
                         return displayStringForFunction(sym, python, apiInfo);
-                    case 6 /* Enum */:
-                    case 7 /* EnumMember */:
+                    case 6 /* SymbolKind.Enum */:
+                    case 7 /* SymbolKind.EnumMember */:
                         return displayStringForEnum(sym, python);
-                    case 5 /* Module */:
+                    case 5 /* SymbolKind.Module */:
                         return displayStringForNamepsace(sym, python);
-                    case 9 /* Interface */:
+                    case 9 /* SymbolKind.Interface */:
                         return displayStringForInterface(sym, python);
-                    case 8 /* Class */:
+                    case 8 /* SymbolKind.Class */:
                         return displayStringForClass(sym, python);
-                    case 4 /* Variable */:
+                    case 4 /* SymbolKind.Variable */:
                         return displayStringForVariable(sym, python, apiInfo);
-                    case 2 /* Property */:
+                    case 2 /* SymbolKind.Property */:
                         return displayStringForProperty(sym, python, apiInfo);
                 }
                 return `**${sym.qName}**`;
@@ -7365,7 +7365,7 @@ var ts;
             service.displayStringForKeyword = displayStringForKeyword;
             function displayStringForFunction(sym, python, apiInfo) {
                 let prefix = "";
-                if (sym.kind === 3 /* Function */) {
+                if (sym.kind === 3 /* SymbolKind.Function */) {
                     prefix += python ? "def " : "function ";
                 }
                 else {
@@ -7384,7 +7384,7 @@ var ts;
             }
             function displayStringForEnum(sym, python) {
                 const qName = python ? sym.pyQName : sym.qName;
-                if (sym.kind === 6 /* Enum */) {
+                if (sym.kind === 6 /* SymbolKind.Enum */) {
                     return codeBlock(`enum ${qName}`, python);
                 }
                 let memberString = `(enum member) ${qName}`;
@@ -8028,7 +8028,7 @@ var ts;
                     this.exprKind = exprKind;
                     this.args = args;
                     this.data = data;
-                    this.callingConvention = 0 /* Plain */;
+                    this.callingConvention = 0 /* CallingConvention.Plain */;
                 }
                 static clone(e) {
                     let copy = new Expr(e.exprKind, e.args ? e.args.slice(0) : null, e.data);
@@ -8236,7 +8236,7 @@ var ts;
                     this._isGlobal = false;
                     this._debugType = "?";
                     this.isUserVariable = false;
-                    this.bitSize = 0 /* None */;
+                    this.bitSize = 0 /* BitSize.None */;
                     if (def) {
                         if (!pxtc.isInPxtModules(def)) {
                             this.isUserVariable = true;
@@ -8277,8 +8277,8 @@ var ts;
                 }
                 load() {
                     let r = this.loadCore();
-                    if (pxtc.target.isNative && !pxtc.isStackMachine() && this.bitSize != 0 /* None */) {
-                        if (this.bitSize == 6 /* UInt32 */)
+                    if (pxtc.target.isNative && !pxtc.isStackMachine() && this.bitSize != 0 /* BitSize.None */) {
+                        if (this.bitSize == 6 /* BitSize.UInt32 */)
                             return rtcall("pxt::fromUInt", [r]);
                         return rtcall("pxt::fromInt", [r]);
                     }
@@ -8297,8 +8297,8 @@ var ts;
                         return rtcall("pxtrt::stlocRef", [this.loadCore(), src]);
                     }
                     else {
-                        if (pxtc.target.isNative && !pxtc.isStackMachine() && this.bitSize != 0 /* None */) {
-                            let cnv = this.bitSize == 6 /* UInt32 */ ? "pxt::toUInt" : "pxt::toInt";
+                        if (pxtc.target.isNative && !pxtc.isStackMachine() && this.bitSize != 0 /* BitSize.None */) {
+                            let cnv = this.bitSize == 6 /* BitSize.UInt32 */ ? "pxt::toUInt" : "pxt::toInt";
                             return this.storeDirect(rtcall(cnv, [src], 1));
                         }
                         return this.storeDirect(src);
@@ -8863,25 +8863,25 @@ var ts;
             constructor(wave, id) {
                 this.wave = wave;
                 this.id = id;
-                this.flags = 0 /* None */;
+                this.flags = 0 /* PxtNodeFlags.None */;
                 this.resetAll();
             }
             refresh() {
                 // clear IsUsed flag
-                this.flags &= ~8 /* IsUsed */;
+                this.flags &= ~8 /* PxtNodeFlags.IsUsed */;
                 // this happens for top-level function expression - we just re-emit them
                 if (this.proc && !this.usedActions && !getEnclosingFunction(this.proc.action))
                     this.resetEmit();
                 else if (this.proc && !this.proc.cachedJS)
                     this.resetEmit();
                 else if (this.usedNodes)
-                    this.flags |= 32 /* FromPreviousCompile */;
+                    this.flags |= 32 /* PxtNodeFlags.FromPreviousCompile */;
                 if (this.classInfo)
                     this.classInfo.reset();
             }
             resetEmit() {
                 // clear IsUsed flag
-                this.flags &= ~(8 /* IsUsed */ | 32 /* FromPreviousCompile */);
+                this.flags &= ~(8 /* PxtNodeFlags.IsUsed */ | 32 /* PxtNodeFlags.FromPreviousCompile */);
                 if (this.proc && this.proc.classInfo && this.proc.classInfo.ctor == this.proc)
                     this.proc.classInfo.ctor = null;
                 this.functionInfo = null;
@@ -8896,7 +8896,7 @@ var ts;
             }
             resetTSC() {
                 // clear all flags except for InPxtModules
-                this.flags &= 16 /* InPxtModules */;
+                this.flags &= 16 /* PxtNodeFlags.InPxtModules */;
                 this.typeCache = null;
                 this.symbolCache = null;
                 this.commentAttrs = null;
@@ -8994,7 +8994,7 @@ var ts;
         let currNodeWave = 1;
         function isInPxtModules(node) {
             if (node.pxt)
-                return !!(node.pxt.flags & 16 /* InPxtModules */);
+                return !!(node.pxt.flags & 16 /* PxtNodeFlags.InPxtModules */);
             const src = ts.getSourceFileOfNode(node);
             return src ? pxtc.isPxtModulesFilename(src.fileName) : false;
         }
@@ -9003,7 +9003,7 @@ var ts;
             if (!n.pxt) {
                 const info = new PxtNode(currNodeWave, ++lastNodeId);
                 if (isInPxtModules(n))
-                    info.flags |= 16 /* InPxtModules */;
+                    info.flags |= 16 /* PxtNodeFlags.InPxtModules */;
                 n.pxt = info;
                 return info;
             }
@@ -9014,7 +9014,7 @@ var ts;
                     if (!pxtc.compileOptions || !pxtc.compileOptions.skipPxtModulesTSC)
                         info.resetAll();
                     else {
-                        if (info.flags & 16 /* InPxtModules */) {
+                        if (info.flags & 16 /* PxtNodeFlags.InPxtModules */) {
                             if (pxtc.compileOptions.skipPxtModulesEmit)
                                 info.refresh();
                             else
@@ -9101,43 +9101,43 @@ var ts;
         }
         function getBitSize(decl) {
             if (!decl || !decl.type)
-                return 0 /* None */;
+                return 0 /* BitSize.None */;
             if (!(isNumberType(typeOf(decl))))
-                return 0 /* None */;
+                return 0 /* BitSize.None */;
             if (decl.type.kind != pxtc.SK.TypeReference)
-                return 0 /* None */;
+                return 0 /* BitSize.None */;
             switch (decl.type.typeName.getText()) {
-                case "int8": return 1 /* Int8 */;
-                case "int16": return 3 /* Int16 */;
-                case "int32": return 5 /* Int32 */;
-                case "uint8": return 2 /* UInt8 */;
-                case "uint16": return 4 /* UInt16 */;
-                case "uint32": return 6 /* UInt32 */;
-                default: return 0 /* None */;
+                case "int8": return 1 /* BitSize.Int8 */;
+                case "int16": return 3 /* BitSize.Int16 */;
+                case "int32": return 5 /* BitSize.Int32 */;
+                case "uint8": return 2 /* BitSize.UInt8 */;
+                case "uint16": return 4 /* BitSize.UInt16 */;
+                case "uint32": return 6 /* BitSize.UInt32 */;
+                default: return 0 /* BitSize.None */;
             }
         }
         function sizeOfBitSize(b) {
             switch (b) {
-                case 0 /* None */: return pxtc.target.shortPointers ? 2 : 4;
-                case 1 /* Int8 */: return 1;
-                case 3 /* Int16 */: return 2;
-                case 5 /* Int32 */: return 4;
-                case 2 /* UInt8 */: return 1;
-                case 4 /* UInt16 */: return 2;
-                case 6 /* UInt32 */: return 4;
+                case 0 /* BitSize.None */: return pxtc.target.shortPointers ? 2 : 4;
+                case 1 /* BitSize.Int8 */: return 1;
+                case 3 /* BitSize.Int16 */: return 2;
+                case 5 /* BitSize.Int32 */: return 4;
+                case 2 /* BitSize.UInt8 */: return 1;
+                case 4 /* BitSize.UInt16 */: return 2;
+                case 6 /* BitSize.UInt32 */: return 4;
                 default: throw pxtc.oops();
             }
         }
         pxtc.sizeOfBitSize = sizeOfBitSize;
         function isBitSizeSigned(b) {
             switch (b) {
-                case 1 /* Int8 */:
-                case 3 /* Int16 */:
-                case 5 /* Int32 */:
+                case 1 /* BitSize.Int8 */:
+                case 3 /* BitSize.Int16 */:
+                case 5 /* BitSize.Int32 */:
                     return true;
-                case 2 /* UInt8 */:
-                case 4 /* UInt16 */:
-                case 6 /* UInt32 */:
+                case 2 /* BitSize.UInt8 */:
+                case 4 /* BitSize.UInt16 */:
+                case 6 /* BitSize.UInt32 */:
                     return false;
                 default: throw pxtc.oops();
             }
@@ -9152,7 +9152,7 @@ var ts;
                     pxtc.oops("void-typed variable, " + l.toString());
                 }
                 l.bitSize = getBitSize(l.def);
-                if (l.bitSize != 0 /* None */) {
+                if (l.bitSize != 0 /* BitSize.None */) {
                     l._debugType = (isBitSizeSigned(l.bitSize) ? "int" : "uint") + (8 * sizeOfBitSize(l.bitSize));
                 }
                 else if (isStringType(tp)) {
@@ -9162,8 +9162,8 @@ var ts;
                     l._debugType = "number";
                 }
             }
-            if (l.isLocal() && l.bitSize != 0 /* None */) {
-                l.bitSize = 0 /* None */;
+            if (l.isLocal() && l.bitSize != 0 /* BitSize.None */) {
+                l.bitSize = 0 /* BitSize.None */;
                 userError(9256, lf("bit sizes are not supported for locals and parameters"));
             }
         }
@@ -9315,7 +9315,7 @@ var ts;
                 this.itable = null;
             }
             get isUsed() {
-                return !!(pxtInfo(this.decl).flags & 8 /* IsUsed */);
+                return !!(pxtInfo(this.decl).flags & 8 /* PxtNodeFlags.IsUsed */);
             }
             allMethods() {
                 const r = [];
@@ -9330,7 +9330,7 @@ var ts;
                 for (let k of Object.keys(this.methods))
                     for (let m of this.methods[k]) {
                         const info = pxtInfo(m);
-                        if (info.flags & 8 /* IsUsed */)
+                        if (info.flags & 8 /* PxtNodeFlags.IsUsed */)
                             r.push(m);
                     }
                 return r;
@@ -9381,7 +9381,7 @@ var ts;
         pxtc.parseCommentsOnSymbol = parseCommentsOnSymbol;
         function parseComments(node) {
             const pinfo = node ? pxtInfo(node) : null;
-            if (!pinfo || pinfo.flags & 2 /* IsBogusFunction */)
+            if (!pinfo || pinfo.flags & 2 /* PxtNodeFlags.IsBogusFunction */)
                 return pxtc.parseCommentString("");
             if (pinfo.commentAttrs)
                 return pinfo.commentAttrs;
@@ -9648,7 +9648,7 @@ var ts;
                 this.capturedVars = [];
             }
             get isUsed() {
-                return !!(pxtInfo(this.decl).flags & 8 /* IsUsed */);
+                return !!(pxtInfo(this.decl).flags & 8 /* PxtNodeFlags.IsUsed */);
             }
         }
         pxtc.FunctionAddInfo = FunctionAddInfo;
@@ -9763,7 +9763,7 @@ var ts;
             };
             _rootFunction = rootFunction;
             const pinfo = pxtInfo(rootFunction);
-            pinfo.flags |= 1 /* IsRootFunction */ | 2 /* IsBogusFunction */;
+            pinfo.flags |= 1 /* PxtNodeFlags.IsRootFunction */ | 2 /* PxtNodeFlags.IsBogusFunction */;
             markUsed(rootFunction);
             usedWorkList = [];
             reset();
@@ -10042,7 +10042,7 @@ var ts;
                     for (let m of ci.allMethods()) {
                         const pinfo = pxtInfo(m);
                         const info = getFunctionInfo(m);
-                        if (pinfo.flags & 8 /* IsUsed */) {
+                        if (pinfo.flags & 8 /* PxtNodeFlags.IsUsed */) {
                             // we need to mark the parent as used, otherwise vtable layout fails, see #3740
                             if (info.virtualParent)
                                 markFunctionUsed(info.virtualParent.decl);
@@ -10180,8 +10180,8 @@ var ts;
                 }
             }
             function needsFullRecompileIfCached(pxtinfo) {
-                if ((pxtinfo.flags & 32 /* FromPreviousCompile */) ||
-                    (pxtinfo.flags & 16 /* InPxtModules */ &&
+                if ((pxtinfo.flags & 32 /* PxtNodeFlags.FromPreviousCompile */) ||
+                    (pxtinfo.flags & 16 /* PxtNodeFlags.InPxtModules */ &&
                         pxtc.compileOptions.skipPxtModulesEmit)) {
                     res.needsFullRecompile = true;
                     throw userError(9200, lf("full recompile required"));
@@ -10233,9 +10233,9 @@ var ts;
                             const pfield = pxtc.U.lookup(prevFields, key);
                             if (pfield) {
                                 const pxtinfo = pxtInfo(pfield);
-                                if (!(pxtinfo.flags & 64 /* IsOverridden */)) {
-                                    pxtinfo.flags |= 64 /* IsOverridden */;
-                                    if (pxtinfo.flags & 8 /* IsUsed */)
+                                if (!(pxtinfo.flags & 64 /* PxtNodeFlags.IsOverridden */)) {
+                                    pxtinfo.flags |= 64 /* PxtNodeFlags.IsOverridden */;
+                                    if (pxtinfo.flags & 8 /* PxtNodeFlags.IsUsed */)
                                         getIfaceMemberId(key, true);
                                     needsFullRecompileIfCached(pxtinfo);
                                 }
@@ -10435,7 +10435,7 @@ ${lbl}: .short 0xffff
                 let expr = emitExpr(e);
                 if (pxtc.target.isNative || isStringLiteral(e))
                     return irToNode(expr, isRef);
-                expr = pxtc.ir.rtcallMask("String_::stringConv", 1, 1 /* Async */, [expr]);
+                expr = pxtc.ir.rtcallMask("String_::stringConv", 1, 1 /* ir.CallingConvention.Async */, [expr]);
                 return irToNode(expr, true);
             }
             function emitTemplateExpression(node) {
@@ -10589,14 +10589,14 @@ ${lbl}: .short 0xffff
             function isSlowField(decl) {
                 if (decl.kind == pxtc.SK.Parameter || decl.kind == pxtc.SK.PropertyDeclaration) {
                     const pinfo = pxtInfo(decl);
-                    return !!pxtc.target.switches.slowFields || !!(pinfo.flags & 64 /* IsOverridden */);
+                    return !!pxtc.target.switches.slowFields || !!(pinfo.flags & 64 /* PxtNodeFlags.IsOverridden */);
                 }
                 return false;
             }
             function emitIndexedAccess(node, assign = null) {
                 let t = typeOf(node.expression);
                 let attrs = {
-                    callingConvention: 0 /* Plain */,
+                    callingConvention: 0 /* ir.CallingConvention.Plain */,
                     paramDefl: {},
                 };
                 let indexer = null;
@@ -10654,7 +10654,7 @@ ${lbl}: .short 0xffff
                     return true;
                 const info = pxtInfo(node);
                 if (bin.finalPass)
-                    return !!(info.flags & 8 /* IsUsed */);
+                    return !!(info.flags & 8 /* PxtNodeFlags.IsUsed */);
                 else
                     return info == currUsingContext;
             }
@@ -10671,8 +10671,8 @@ ${lbl}: .short 0xffff
                 if (isStackMachine() && isClassFunction(decl))
                     getIfaceMemberId(getName(decl), true);
                 recordUsage(decl);
-                if (!(pinfo.flags & 8 /* IsUsed */)) {
-                    pinfo.flags |= 8 /* IsUsed */;
+                if (!(pinfo.flags & 8 /* PxtNodeFlags.IsUsed */)) {
+                    pinfo.flags |= 8 /* PxtNodeFlags.IsUsed */;
                     if (isOnDemandDecl(decl))
                         usedWorkList.push(decl);
                 }
@@ -10724,7 +10724,7 @@ ${lbl}: .short 0xffff
                         symbol: { isBogusSymbol: true, name: namedNode.name.getText() },
                         name: namedNode.name,
                     };
-                    pxtInfo(decl).flags |= 2 /* IsBogusFunction */;
+                    pxtInfo(decl).flags |= 2 /* PxtNodeFlags.IsBogusFunction */;
                 }
                 pinfo.declCache = decl || null;
                 return decl;
@@ -11102,17 +11102,17 @@ ${lbl}: .short 0xffff
                 // smaller immediate range than plain "str" (and same for "ldr")
                 // All the pointers go at the end, for GC
                 globals.forEach((g, i) => g.index = i);
-                const sz = (b) => b == 0 /* None */ ? 10 : sizeOfBitSize(b);
+                const sz = (b) => b == 0 /* BitSize.None */ ? 10 : sizeOfBitSize(b);
                 globals.sort((a, b) => sz(a.bitSize) - sz(b.bitSize) ||
                     a.index - b.index);
                 let currOff = pxtc.numReservedGlobals * 4;
                 let firstPointer = 0;
                 for (let g of globals) {
-                    const bitSize = isStackMachine() ? 0 /* None */ : g.bitSize;
+                    const bitSize = isStackMachine() ? 0 /* BitSize.None */ : g.bitSize;
                     let sz = sizeOfBitSize(bitSize);
                     while (currOff & (sz - 1))
                         currOff++; // align
-                    if (!firstPointer && bitSize == 0 /* None */)
+                    if (!firstPointer && bitSize == 0 /* BitSize.None */)
                         firstPointer = currOff;
                     g.index = currOff;
                     currOff += sz;
@@ -11172,7 +11172,7 @@ ${lbl}: .short 0xffff
                     return;
                 // U.assert(!bin.finalPass)
                 const pinfo = pxtInfo(info.decl);
-                pinfo.flags |= 8 /* IsUsed */;
+                pinfo.flags |= 8 /* PxtNodeFlags.IsUsed */;
                 if (info.baseClassInfo)
                     markVTableUsed(info.baseClassInfo);
                 bin.usedClassInfos.push(info);
@@ -11522,7 +11522,7 @@ ${lbl}: .short 0xffff
                     pxtc.assert(!bin.finalPass, "!bin.finalPass");
                     const pinfo = pxtInfo(node);
                     const myProc = new pxtc.ir.Procedure();
-                    myProc.isRoot = !!(pinfo.flags & 1 /* IsRootFunction */);
+                    myProc.isRoot = !!(pinfo.flags & 1 /* PxtNodeFlags.IsRootFunction */);
                     myProc.action = node;
                     myProc.info = info;
                     pinfo.proc = myProc;
@@ -11653,7 +11653,7 @@ ${lbl}: .short 0xffff
             function emitFunctionDeclaration(node) {
                 if (!shouldEmitNow(node))
                     return undefined;
-                if (pxtInfo(node).flags & 32 /* FromPreviousCompile */)
+                if (pxtInfo(node).flags & 32 /* PxtNodeFlags.FromPreviousCompile */)
                     return undefined;
                 let attrs = parseComments(node);
                 if (attrs.shim != null) {
@@ -12246,7 +12246,7 @@ ${lbl}: .short 0xffff
                 return isNumberLikeType(typeOf(e));
             }
             function rtcallMaskDirect(name, args) {
-                return pxtc.ir.rtcallMask(name, (1 << args.length) - 1, 0 /* Plain */, args);
+                return pxtc.ir.rtcallMask(name, (1 << args.length) - 1, 0 /* ir.CallingConvention.Plain */, args);
             }
             function rtcallMask(name, args, attrs, append = null) {
                 let fmt = [];
@@ -12334,7 +12334,7 @@ ${lbl}: .short 0xffff
                         throw pxtc.U.oops("invalid format specifier: " + f);
                     }
                 });
-                let r = pxtc.ir.rtcallMask(name, mask, attrs ? attrs.callingConvention : 0 /* Plain */, args2);
+                let r = pxtc.ir.rtcallMask(name, mask, attrs ? attrs.callingConvention : 0 /* ir.CallingConvention.Plain */, args2);
                 if (!r.mask)
                     r.mask = { refMask: 0 };
                 r.mask.conversions = convInfos;
@@ -12500,7 +12500,7 @@ ${lbl}: .short 0xffff
                 let shim = (n) => {
                     n = mapIntOpName(n);
                     let args = [node.left, node.right];
-                    return pxtc.ir.rtcallMask(n, getMask(args), 0 /* Plain */, args.map(x => emitExpr(x)));
+                    return pxtc.ir.rtcallMask(n, getMask(args), 0 /* ir.CallingConvention.Plain */, args.map(x => emitExpr(x)));
                 };
                 if (node.operatorToken.kind == pxtc.SK.CommaToken) {
                     if (isNoopExpr(node.left))
@@ -12833,7 +12833,7 @@ ${lbl}: .short 0xffff
                         // we assume the value we're switching over will stay alive
                         // so, the mask only applies to the case expression if needed
                         // switch_eq() will decr(expr) if result is true
-                        let cmpCall = pxtc.ir.rtcallMask(mapIntOpName("pxt::switch_eq"), mask, 0 /* Plain */, [cmpExpr, expr]);
+                        let cmpCall = pxtc.ir.rtcallMask(mapIntOpName("pxt::switch_eq"), mask, 0 /* ir.CallingConvention.Plain */, [cmpExpr, expr]);
                         proc.emitJmp(lbl, cmpCall, pxtc.ir.JmpMode.IfNotZero, expr);
                     }
                     else if (cl.kind == pxtc.SK.DefaultClause) {
@@ -13992,13 +13992,13 @@ var pxt;
                 addFileOff++;
             let mapEnd = 0;
             for (let s of progHeaders) {
-                if (s.type == 1 /* LOAD */)
+                if (s.type == 1 /* PHT.LOAD */)
                     mapEnd = Math.max(mapEnd, s.vaddr + s.memsz);
             }
             let addMemOff = ((mapEnd + pageSize - 1) & ~(pageSize - 1)) + (addFileOff & (pageSize - 1));
             let phOffset = -1;
             for (let s of progHeaders) {
-                if (s.type == 4 /* NOTE */) {
+                if (s.type == 4 /* PHT.NOTE */) {
                     phOffset = s._filepos;
                 }
             }
@@ -14028,13 +14028,13 @@ var pxt;
             pxt.U.memcpy(resBuf, info.imageFileStart, program);
             let ph = {
                 _filepos: info.phOffset,
-                type: 1 /* LOAD */,
+                type: 1 /* PHT.LOAD */,
                 offset: info.imageFileStart,
                 vaddr: info.imageMemStart,
                 paddr: info.imageMemStart,
                 filesz: program.length,
                 memsz: program.length,
-                flags: 4 /* R */ | 1 /* X */,
+                flags: 4 /* PHF.R */ | 1 /* PHF.X */,
                 align: pageSize
             };
             savePH(resBuf, ph);
@@ -16498,10 +16498,10 @@ var ts;
                     // special case for enum members and enum members exported as constants,
                     // which have the return type 'EnumName.MemberName'. we want to match 'EnumName'
                     if (isEnum) {
-                        if (i.symbol.kind == 7 /* EnumMember */) {
+                        if (i.symbol.kind == 7 /* SymbolKind.EnumMember */) {
                             retType = i.symbol.namespace;
                         }
-                        else if (i.symbol.kind == 4 /* Variable */) {
+                        else if (i.symbol.kind == 4 /* SymbolKind.Variable */) {
                             const enumParts = (_b = (_a = i.symbol.attributes) === null || _a === void 0 ? void 0 : _a.enumIdentity) === null || _b === void 0 ? void 0 : _b.split(".");
                             if ((enumParts === null || enumParts === void 0 ? void 0 : enumParts.length) > 1)
                                 retType = enumParts[0];
@@ -16539,20 +16539,20 @@ var ts;
             service.getBasicKindDefault = getBasicKindDefault;
             function tsSymbolToPxtSymbolKind(ts) {
                 if (ts.flags & ts_1.SymbolFlags.Variable)
-                    return 4 /* Variable */;
+                    return 4 /* SymbolKind.Variable */;
                 if (ts.flags & ts_1.SymbolFlags.Class)
-                    return 8 /* Class */;
+                    return 8 /* SymbolKind.Class */;
                 if (ts.flags & ts_1.SymbolFlags.Enum)
-                    return 6 /* Enum */;
+                    return 6 /* SymbolKind.Enum */;
                 if (ts.flags & ts_1.SymbolFlags.EnumMember)
-                    return 7 /* EnumMember */;
+                    return 7 /* SymbolKind.EnumMember */;
                 if (ts.flags & ts_1.SymbolFlags.Method)
-                    return 1 /* Method */;
+                    return 1 /* SymbolKind.Method */;
                 if (ts.flags & ts_1.SymbolFlags.Module)
-                    return 5 /* Module */;
+                    return 5 /* SymbolKind.Module */;
                 if (ts.flags & ts_1.SymbolFlags.Property)
-                    return 2 /* Property */;
-                return 0 /* None */;
+                    return 2 /* SymbolKind.Property */;
+                return 0 /* SymbolKind.None */;
             }
             service.tsSymbolToPxtSymbolKind = tsSymbolToPxtSymbolKind;
             function makePxtSymbolFromKeyword(keyword) {
@@ -16560,14 +16560,14 @@ var ts;
                 //       type than "SymbolInfo" to carry auto completion information.
                 //       Some progress on this exists here: dazuniga/completionitem_refactor
                 let sym = {
-                    kind: 0 /* None */,
+                    kind: 0 /* SymbolKind.None */,
                     name: keyword,
                     pyName: keyword,
                     qName: keyword,
                     pyQName: keyword,
                     namespace: "",
                     attributes: {
-                        callingConvention: 0 /* Plain */,
+                        callingConvention: 0 /* ir.CallingConvention.Plain */,
                         paramDefl: {},
                     },
                     fileName: pxt.MAIN_TS,
@@ -16595,7 +16595,7 @@ var ts;
                     pyQName: qname,
                     namespace: ns,
                     attributes: {
-                        callingConvention: 0 /* Plain */,
+                        callingConvention: 0 /* ir.CallingConvention.Plain */,
                         paramDefl: {},
                     },
                     fileName: pxt.MAIN_TS,
@@ -16977,7 +16977,7 @@ var ts;
                 resultSymbols
                     .map(sym => {
                     // skip for enum member completions (eg "AnimalMob."" should have "Chicken", not "CHICKEN")
-                    if (sym.symbol.attributes.alias && !(isMemberCompletion && sym.symbol.kind === 7 /* EnumMember */)) {
+                    if (sym.symbol.attributes.alias && !(isMemberCompletion && sym.symbol.kind === 7 /* SymbolKind.EnumMember */)) {
                         return completionSymbol(service.lastApiInfo.apis.byQName[sym.symbol.attributes.alias], sym.weight);
                     }
                     else {
@@ -17246,29 +17246,29 @@ var ts;
             switch (node.kind) {
                 case pxtc.SK.MethodDeclaration:
                 case pxtc.SK.MethodSignature:
-                    return 1 /* Method */;
+                    return 1 /* SymbolKind.Method */;
                 case pxtc.SK.PropertyDeclaration:
                 case pxtc.SK.PropertySignature:
                 case pxtc.SK.GetAccessor:
                 case pxtc.SK.SetAccessor:
-                    return 2 /* Property */;
+                    return 2 /* SymbolKind.Property */;
                 case pxtc.SK.Constructor:
                 case pxtc.SK.FunctionDeclaration:
-                    return 3 /* Function */;
+                    return 3 /* SymbolKind.Function */;
                 case pxtc.SK.VariableDeclaration:
-                    return 4 /* Variable */;
+                    return 4 /* SymbolKind.Variable */;
                 case pxtc.SK.ModuleDeclaration:
-                    return 5 /* Module */;
+                    return 5 /* SymbolKind.Module */;
                 case pxtc.SK.EnumDeclaration:
-                    return 6 /* Enum */;
+                    return 6 /* SymbolKind.Enum */;
                 case pxtc.SK.EnumMember:
-                    return 7 /* EnumMember */;
+                    return 7 /* SymbolKind.EnumMember */;
                 case pxtc.SK.ClassDeclaration:
-                    return 8 /* Class */;
+                    return 8 /* SymbolKind.Class */;
                 case pxtc.SK.InterfaceDeclaration:
-                    return 9 /* Interface */;
+                    return 9 /* SymbolKind.Interface */;
                 default:
-                    return 0 /* None */;
+                    return 0 /* SymbolKind.None */;
             }
         }
         function createSymbolInfo(typechecker, qName, stmt) {
@@ -17292,13 +17292,13 @@ var ts;
                 return readableName;
             }
             let kind = getSymbolKind(stmt);
-            if (kind != 0 /* None */) {
+            if (kind != 0 /* SymbolKind.None */) {
                 let decl = stmt;
                 let attributes = pxtc.parseComments(decl);
                 if (attributes.weight < 0)
                     return null;
                 let m = /^(.*)\.(.*)/.exec(qName);
-                let hasParams = kind == 3 /* Function */ || kind == 1 /* Method */;
+                let hasParams = kind == 3 /* SymbolKind.Function */ || kind == 1 /* SymbolKind.Method */;
                 let pkg = null;
                 let pkgs = null;
                 let src = ts.getSourceFileOfNode(stmt);
@@ -17308,7 +17308,7 @@ var ts;
                         pkg = m[1];
                 }
                 let extendsTypes = undefined;
-                if (kind == 8 /* Class */ || kind == 9 /* Interface */) {
+                if (kind == 8 /* SymbolKind.Class */ || kind == 9 /* SymbolKind.Interface */) {
                     let cl = stmt;
                     extendsTypes = [];
                     if (cl.heritageClauses)
@@ -17320,7 +17320,7 @@ var ts;
                             }
                         }
                 }
-                if (kind == 6 /* Enum */ || kind === 7 /* EnumMember */) {
+                if (kind == 6 /* SymbolKind.Enum */ || kind === 7 /* SymbolKind.EnumMember */) {
                     (extendsTypes || (extendsTypes = [])).push("Number");
                 }
                 let r = {
@@ -17334,7 +17334,7 @@ var ts;
                     pkgs,
                     extendsTypes,
                     retType: stmt.kind == ts.SyntaxKind.Constructor ? "void" :
-                        kind == 5 /* Module */ ? "" :
+                        kind == 5 /* SymbolKind.Module */ ? "" :
                             typeOf(decl.type, decl, hasParams),
                     parameters: !hasParams ? null : pxtc.Util.toArray(decl.parameters).map((p, i) => {
                         let n = pxtc.getName(p);
@@ -17401,19 +17401,19 @@ var ts;
                     snippet: ts.isFunctionLike(stmt) ? null : undefined
                 };
                 switch (r.kind) {
-                    case 7 /* EnumMember */:
+                    case 7 /* SymbolKind.EnumMember */:
                         r.pyName = pxtc.U.snakify(r.name).toUpperCase();
                         break;
-                    case 4 /* Variable */:
-                    case 1 /* Method */:
-                    case 2 /* Property */:
-                    case 3 /* Function */:
+                    case 4 /* SymbolKind.Variable */:
+                    case 1 /* SymbolKind.Method */:
+                    case 2 /* SymbolKind.Property */:
+                    case 3 /* SymbolKind.Function */:
                         r.pyName = pxtc.U.snakify(r.name);
                         break;
-                    case 6 /* Enum */:
-                    case 8 /* Class */:
-                    case 9 /* Interface */:
-                    case 5 /* Module */:
+                    case 6 /* SymbolKind.Enum */:
+                    case 8 /* SymbolKind.Class */:
+                    case 9 /* SymbolKind.Interface */:
+                    case 5 /* SymbolKind.Module */:
                     default:
                         r.pyName = r.name;
                         break;
@@ -17431,7 +17431,7 @@ var ts;
             pxt.debug(JSON.stringify(Object.keys(apiInfo.byQName), null, 2));
             const files = {};
             const infos = pxtc.Util.values(apiInfo.byQName);
-            const enumMembers = infos.filter(si => si.kind == 7 /* EnumMember */)
+            const enumMembers = infos.filter(si => si.kind == 7 /* SymbolKind.EnumMember */)
                 .sort(compareSymbols);
             const snippetStrings = {};
             const locStrings = {};
@@ -17444,7 +17444,7 @@ var ts;
                     return; // skip functions starting with __
                 pxt.debug(`loc: ${si.qName}`);
                 // must match blockly loader
-                if (si.kind != 7 /* EnumMember */) {
+                if (si.kind != 7 /* SymbolKind.EnumMember */) {
                     const ns = ts.pxtc.blocksCategory(si);
                     if (ns)
                         locStrings[`{id:category}${ns}`] = ns;
@@ -17470,7 +17470,7 @@ var ts;
                 files[pkg + name + "-strings.json"] = JSON.stringify(locs, null, 2);
             };
             for (const info of infos) {
-                const isNamespace = info.kind == 5 /* Module */;
+                const isNamespace = info.kind == 5 /* SymbolKind.Module */;
                 if (isNamespace) {
                     if (!infos.filter(si => si.namespace == info.name && !!si.attributes.jsDoc)[0])
                         continue; // nothing in namespace
@@ -17528,14 +17528,14 @@ var ts;
             // sort by symbol kind
             if (!symbolKindWeight) {
                 symbolKindWeight = {};
-                symbolKindWeight[4 /* Variable */] = 100;
-                symbolKindWeight[5 /* Module */] = 101;
-                symbolKindWeight[3 /* Function */] = 99;
-                symbolKindWeight[2 /* Property */] = 98;
-                symbolKindWeight[1 /* Method */] = 97;
-                symbolKindWeight[8 /* Class */] = 89;
-                symbolKindWeight[6 /* Enum */] = 81;
-                symbolKindWeight[7 /* EnumMember */] = 80;
+                symbolKindWeight[4 /* SymbolKind.Variable */] = 100;
+                symbolKindWeight[5 /* SymbolKind.Module */] = 101;
+                symbolKindWeight[3 /* SymbolKind.Function */] = 99;
+                symbolKindWeight[2 /* SymbolKind.Property */] = 98;
+                symbolKindWeight[1 /* SymbolKind.Method */] = 97;
+                symbolKindWeight[8 /* SymbolKind.Class */] = 89;
+                symbolKindWeight[6 /* SymbolKind.Enum */] = 81;
+                symbolKindWeight[7 /* SymbolKind.EnumMember */] = 80;
             }
             c = cmpr(s => symbolKindWeight[s.kind] || 0);
             if (c)
@@ -17579,11 +17579,11 @@ var ts;
                         let existing = pxtc.U.lookup(res.byQName, qName);
                         if (existing) {
                             // we can have a function and an interface of the same name
-                            if (existing.kind == 9 /* Interface */ && si.kind != 9 /* Interface */) {
+                            if (existing.kind == 9 /* SymbolKind.Interface */ && si.kind != 9 /* SymbolKind.Interface */) {
                                 // save existing entry
                                 res.byQName[qName + "@type"] = existing;
                             }
-                            else if (existing.kind != 9 /* Interface */ && si.kind == 9 /* Interface */) {
+                            else if (existing.kind != 9 /* SymbolKind.Interface */ && si.kind == 9 /* SymbolKind.Interface */) {
                                 res.byQName[qName + "@type"] = si;
                                 si = existing;
                             }
@@ -17602,7 +17602,7 @@ var ts;
                                 // Check if the colliding symbols are namespace definitions. The same namespace can be
                                 // defined in different packages/extensions, so we want to keep track of that information.
                                 // That way, we can make sure each cached extension has a copy of the namespace
-                                if (existing.kind === 5 /* Module */) {
+                                if (existing.kind === 5 /* SymbolKind.Module */) {
                                     // Reference the existing array of packages where this namespace has been defined
                                     si.pkgs = existing.pkgs || [];
                                     if (existing.pkg !== si.pkg) {
@@ -18430,14 +18430,13 @@ var ts;
             }
             service.snippetAddsDefinitions = snippetAddsDefinitions;
             function getSnippet(context, fn, decl, python, recursionDepth = 0) {
-                var _a;
+                var _a, _b;
                 // TODO: a lot of this is duplicate logic with blocklyloader.ts:buildBlockFromDef; we should
                 //  unify these approaches
                 let { apis, takenNames, blocksInfo, screenSize, checker } = context;
                 const PY_INDENT = pxt.py.INDENT;
                 const fileType = python ? "python" : "typescript";
                 let snippetPrefix = fn.namespace;
-                let isInstance = false;
                 let addNamespace = false;
                 let namespaceToUse = "";
                 let functionCount = 0;
@@ -18487,6 +18486,11 @@ var ts;
                         if (python && snippetPrefix)
                             snippetPrefix = pxtc.U.snakify(snippetPrefix);
                     }
+                    else if (((_b = params.thisParameter) === null || _b === void 0 ? void 0 : _b.shadowBlockId) === "variables_get") {
+                        snippetPrefix = params.thisParameter.defaultValue || params.thisParameter.definitionName;
+                        if (python && snippetPrefix)
+                            snippetPrefix = pxtc.U.snakify(snippetPrefix);
+                    }
                     else if (element.namespace) { // some blocks don't have a namespace such as parseInt
                         const nsInfo = apis.byQName[element.namespace];
                         if (nsInfo.attributes.fixedInstances) {
@@ -18498,7 +18502,7 @@ var ts;
                                     .reduce((x, y) => x.concat(y.extendsTypes), []);
                             };
                             // all fixed instances for this namespace
-                            let fixedInstances = instances.filter(value => value.kind === 4 /* Variable */ &&
+                            let fixedInstances = instances.filter(value => value.kind === 4 /* pxtc.SymbolKind.Variable */ &&
                                 value.attributes.fixedInstance);
                             let instanceToUse;
                             // first try to get fixed instances whose retType matches nsInfo.name
@@ -18525,9 +18529,8 @@ var ts;
                             if (namespaceToUse) {
                                 addNamespace = true;
                             }
-                            isInstance = true;
                         }
-                        else if (element.kind == 1 /* Method */ || element.kind == 2 /* Property */) {
+                        else if (element.kind == 1 /* pxtc.SymbolKind.Method */ || element.kind == 2 /* pxtc.SymbolKind.Property */) {
                             if (params.thisParameter) {
                                 let varName = undefined;
                                 if (params.thisParameter.definitionName) {
@@ -18539,9 +18542,8 @@ var ts;
                                 if (python && snippetPrefix)
                                     snippetPrefix = pxtc.U.snakify(snippetPrefix);
                             }
-                            isInstance = true;
                         }
-                        else if (nsInfo.kind === 8 /* Class */) {
+                        else if (nsInfo.kind === 8 /* pxtc.SymbolKind.Class */) {
                             return undefined;
                         }
                     }
@@ -18554,7 +18556,7 @@ var ts;
                 }
                 else {
                     snippet = [fnName];
-                    if ((args === null || args === void 0 ? void 0 : args.length) || element.kind == 1 /* Method */ || element.kind == 3 /* Function */ || element.kind == 8 /* Class */) {
+                    if ((args === null || args === void 0 ? void 0 : args.length) || element.kind == 1 /* pxtc.SymbolKind.Method */ || element.kind == 3 /* pxtc.SymbolKind.Function */ || element.kind == 8 /* pxtc.SymbolKind.Class */) {
                         const argsWithCommas = args.reduce((p, n) => [...p, p.length ? ", " : "", n], []);
                         snippet = snippet.concat(["(", ...argsWithCommas, ")"]);
                     }
@@ -18720,7 +18722,7 @@ var ts;
                     return undefined;
                 }
                 function getFixedInstancesOf(type) {
-                    return pxt.Util.values(apis.byQName).filter(sym => sym.kind === 4 /* Variable */
+                    return pxt.Util.values(apis.byQName).filter(sym => sym.kind === 4 /* pxtc.SymbolKind.Variable */
                         && sym.attributes.fixedInstance
                         && isSubtype(apis, sym.retType, type.qName));
                 }