pxt-core 7.5.44 → 7.5.45

package/built/pxt.js

@@ -140422,11 +140422,19 @@ var pxt;
             return pxt.U.lookup(internalApis, name) || pxt.U.lookup(externalApis, name);
         }
         function lookupGlobalSymbol(name) {
+            var _a;
             if (!name)
                 return undefined;
             let sym = lookupApi(name);
             if (sym)
                 getOrSetSymbolType(sym);
+            else if (name.indexOf(".")) {
+                const base = name.substring(0, name.lastIndexOf("."));
+                const baseSymbol = lookupGlobalSymbol(base);
+                if ((baseSymbol === null || baseSymbol === void 0 ? void 0 : baseSymbol.kind) === 8 /* Class */ && ((_a = baseSymbol.extendsTypes) === null || _a === void 0 ? void 0 : _a.length)) {
+                    return lookupGlobalSymbol(baseSymbol.extendsTypes[0] + name.substring(base.length));
+                }
+            }
             return sym;
         }
         function initApis(apisInfo, tsShadowFiles) {
@@ -140623,7 +140631,7 @@ var pxt;
                 };
             }
         }
-        // next free error 9575
+        // next free error 9576
         function error(astNode, code, msg) {
             diagnostics.push(mkDiag(astNode, pxtc.DiagnosticCategory.Error, code, msg));
             //const pos = position(astNode ? astNode.startPos || 0 : 0, mod.source)
@@ -140834,12 +140842,18 @@ var pxt;
             return n.symInfo;
         }
         // TODO optimize ?
-        function listClassFields(cd) {
+        function listClassFields(cd, excludeVariables = true) {
             let qn = cd.symInfo.qName;
-            return pxt.U.values(internalApis).filter(e => e.namespace == qn && e.kind == 2 /* Property */);
+            return pxt.U.values(internalApis).filter(e => e.namespace == qn && ((e.kind == 4 /* Variable */ && !excludeVariables) || e.kind == 2 /* Property */));
         }
         function getClassField(ct, n, checkOnly = false, skipBases = false) {
-            let qid = ct.pyQName + "." + n;
+            let qid;
+            if (n === "__init__") {
+                qid = ct.pyQName + ".__constructor";
+            }
+            else {
+                qid = ct.pyQName + "." + n;
+            }
             let f = lookupGlobalSymbol(qid);
             if (f)
                 return f;
@@ -141066,14 +141080,17 @@ var pxt;
             return mkType({});
         }
         function doArgs(n, isMethod) {
+            var _a;
             const args = n.args;
             if (args.kwonlyargs.length)
                 error(n, 9517, pxt.U.lf("keyword-only arguments not supported yet"));
             let nargs = args.args.slice();
             if (isMethod) {
-                if (nargs[0].arg != "self")
-                    error(n, 9518, pxt.U.lf("first argument of method has to be called 'self'"));
-                nargs.shift();
+                if (((_a = nargs[0]) === null || _a === void 0 ? void 0 : _a.arg) !== "self")
+                    n.symInfo.isStatic = true;
+                else {
+                    nargs.shift();
+                }
             }
             else {
                 if (nargs.some(a => a.arg == "self"))
@@ -141235,6 +141252,7 @@ var pxt;
         }
         function emitFunctionDef(n, inline = false) {
             return guardedScope(n, () => {
+                var _a, _b, _c, _d;
                 const isMethod = !!ctx.currClass && !ctx.currFun;
                 const topLev = isTopLevel();
                 const nested = !!ctx.currFun;
@@ -141295,6 +141313,9 @@ var pxt;
                         }
                         if (!prefix) {
                             prefix = funname[0] == "_" ? (sym.isProtected ? "protected" : "private") : "public";
+                            if (n.symInfo.isStatic) {
+                                prefix += " static";
+                            }
                         }
                         nodes.push(B.mkText(prefix + " "), quote(funname));
                     }
@@ -141306,7 +141327,7 @@ var pxt;
                     else
                         nodes.push(B.mkText("export function "), quote(funname));
                 }
-                let retType = n.returns ? compileType(n.returns) : sym.pyRetType;
+                let retType = n.name == "__init__" ? undefined : (n.returns ? compileType(n.returns) : sym.pyRetType);
                 nodes.push(doArgs(n, isMethod), retType && canonicalize(retType) != tpVoid ? typeAnnot(retType) : B.mkText(""));
                 // make sure type is initialized
                 getOrSetSymbolType(sym);
@@ -141314,6 +141335,13 @@ var pxt;
                 if (n.name == "__init__") {
                     if (!ctx.currClass)
                         error(n, 9533, lf("__init__ method '{0}' is missing current class context", sym.pyQName));
+                    if ((_a = ctx.currClass) === null || _a === void 0 ? void 0 : _a.baseClass) {
+                        const firstStatement = n.body[0];
+                        const superConstructor = ctx.currClass.baseClass.pyQName + ".__constructor";
+                        if (((_d = (_c = (_b = firstStatement.value) === null || _b === void 0 ? void 0 : _b.func) === null || _c === void 0 ? void 0 : _c.symbolInfo) === null || _d === void 0 ? void 0 : _d.pyQName) !== superConstructor) {
+                            error(n, 9575, lf("Sub classes must call 'super().__init__' as the first statement inside an __init__ method"));
+                        }
+                    }
                     for (let f of listClassFields(ctx.currClass)) {
                         let p = f.pyAST;
                         if (p && p.value) {
@@ -141357,22 +141385,59 @@ var pxt;
                         nodes.push(B.mkCommaSep(n.bases.map(expr)));
                         let b = getClassDef(n.bases[0]);
                         if (b) {
-                            n.baseClass = b;
+                            n.baseClass = b.symInfo;
                             sym.extendsTypes = [b.symInfo.pyQName];
                         }
+                        else {
+                            const nm = tryGetName(n.bases[0]);
+                            if (nm) {
+                                const localSym = lookupSymbol(nm);
+                                const globalSym = lookupGlobalSymbol(nm);
+                                n.baseClass = localSym || globalSym;
+                                if (n.baseClass)
+                                    sym.extendsTypes = [n.baseClass.pyQName];
+                            }
+                        }
                     }
                 }
-                let body = stmts(n.body);
+                const classDefs = n.body.filter(s => n.isNamespace || s.kind === "FunctionDef");
+                const staticStmts = n.isNamespace ? [] : n.body.filter(s => classDefs.indexOf(s) === -1);
+                let body = stmts(classDefs);
                 nodes.push(body);
-                let fieldDefs = listClassFields(n)
-                    .filter(f => f.kind == 2 /* Property */ && f.isInstance)
-                    .map(f => {
-                    if (!f.pyName || !f.pyRetType)
-                        error(n, 9535, lf("field definition missing py name or ret type", f.qName));
-                    return f;
-                })
-                    .map((f) => B.mkStmt(accessAnnot(f), quote(f.pyName), typeAnnot(f.pyRetType)));
-                body.children = fieldDefs.concat(body.children);
+                // Python classes allow arbitrary statements in their bodies, sort of like namespaces.
+                // Take all of these statements and put them in a static method that we can call when
+                // the class is defined.
+                let generatedInitFunction = false;
+                if (staticStmts.length) {
+                    generatedInitFunction = true;
+                    const staticBody = stmts(staticStmts);
+                    const initFun = B.mkStmt(B.mkGroup([
+                        B.mkText(`public static __init${n.name}() `),
+                        staticBody
+                    ]));
+                    body.children.unshift(initFun);
+                }
+                if (!n.isNamespace) {
+                    let isStatic = (f) => f.kind === 2 /* Property */ && !f.isInstance || f.kind === 4 /* Variable */;
+                    const fieldDefs = listClassFields(n, false)
+                        .filter(f => f.kind == 2 /* Property */ || isStatic(f))
+                        .map(f => {
+                        if (!f.pyName || !f.pyRetType)
+                            error(n, 9535, lf("field definition missing py name or return type", f.qName));
+                        return f;
+                    });
+                    const instanceFields = fieldDefs.filter(f => !isStatic(f))
+                        .map((f) => B.mkStmt(accessAnnot(f), quote(f.pyName), typeAnnot(f.pyRetType)));
+                    const staticFields = fieldDefs.filter(f => isStatic(f))
+                        .map((f) => B.mkStmt(accessAnnot(f), B.mkText("static "), quote(f.pyName), typeAnnot(f.pyRetType)));
+                    body.children = staticFields.concat(instanceFields).concat(body.children);
+                }
+                if (generatedInitFunction) {
+                    nodes = [
+                        B.mkStmt(B.mkGroup(nodes)),
+                        B.mkStmt(B.mkText(`${n.name}.__init${n.name}()`))
+                    ];
+                }
                 return B.mkStmt(B.mkGroup(nodes));
             }),
             Return: (n) => {
@@ -141721,7 +141786,9 @@ var pxt;
                     error(n, 9539, lf("function '{0}' missing return type", fd.pyQName));
                 unifyTypeOf(target, fd.pyRetType);
                 fd.isInstance = false;
-                pref = ctx.currClass.isNamespace ? `export ${isConstCall ? "const" : "let"} ` : "static ";
+                if (ctx.currClass.isNamespace) {
+                    pref = `export ${isConstCall ? "const" : "let"} `;
+                }
             }
             if (value)
                 unifyTypeOf(target, typeOf(value));
@@ -141787,6 +141854,7 @@ var pxt;
             }
         }
         function possibleDef(n, excludeLet = false) {
+            var _a, _b;
             let id = n.id;
             let currScopeVar = lookupScopeSymbol(id);
             let curr = currScopeVar === null || currScopeVar === void 0 ? void 0 : currScopeVar.symbol;
@@ -141821,6 +141889,10 @@ var pxt;
             if (n.isdef && !excludeLet) {
                 return B.mkGroup([B.mkText("let "), quote(id)]);
             }
+            else if ((curr === null || curr === void 0 ? void 0 : curr.namespace) && (curr === null || curr === void 0 ? void 0 : curr.qName) && !(((_a = ctx.currClass) === null || _a === void 0 ? void 0 : _a.isNamespace) && ((_b = ctx.currClass) === null || _b === void 0 ? void 0 : _b.name) === (curr === null || curr === void 0 ? void 0 : curr.namespace))) {
+                // If this is a static variable in a class, we want the full qname
+                return quote(curr.qName);
+            }
             else
                 return quote(id);
         }
@@ -141834,20 +141906,27 @@ var pxt;
             //return id.replace(/([a-z0-9])_([a-zA-Z0-9])/g, (f: string, x: string, y: string) => x + y.toUpperCase())
         }
         function tryGetName(e) {
+            var _a;
             if (e.kind == "Name") {
                 let s = e.id;
                 let scopeV = lookupVar(s);
                 let v = scopeV === null || scopeV === void 0 ? void 0 : scopeV.symbol;
-                if (v && v.expandsTo)
-                    return v.expandsTo;
-                else
-                    return s;
+                if (v) {
+                    if (v.expandsTo)
+                        return v.expandsTo;
+                    else if (ctx.currClass && !ctx.currFun && !(scopeV === null || scopeV === void 0 ? void 0 : scopeV.modifier) && v.qName)
+                        return v.qName;
+                }
+                return s;
             }
             if (e.kind == "Attribute") {
                 let pref = tryGetName(e.value);
                 if (pref)
                     return pref + "." + e.attr;
             }
+            if (isSuper(e) && ((_a = ctx.currClass) === null || _a === void 0 ? void 0 : _a.baseClass)) {
+                return ctx.currClass.baseClass.qName;
+            }
             return undefined;
         }
         function getName(e) {
@@ -142055,6 +142134,7 @@ var pxt;
                 return r;
             },
             Call: (n) => {
+                var _a, _b, _c, _d, _e;
                 // TODO(dz): move body out; needs seperate PR that doesn't touch content
                 n.func.inCalledPosition = true;
                 let nm = tryGetName(n.func);
@@ -142085,7 +142165,7 @@ var pxt;
                     if (ctx.currClass && ctx.currClass.baseClass) {
                         if (!n.tsType)
                             error(n, 9543, lf("call expr missing ts type"));
-                        unifyClass(n, n.tsType, ctx.currClass.baseClass.symInfo);
+                        unifyClass(n, n.tsType, ctx.currClass.baseClass);
                     }
                     return B.mkText("super");
                 }
@@ -142145,6 +142225,17 @@ var pxt;
                     unify(n, n.tsType, tpString);
                     return B.mkInfix(B.mkText(`""`), "+", expr(n.args[0]));
                 }
+                const isSuperAttribute = n.func.kind === "Attribute" && isSuper(n.func.value);
+                if (!fun && isSuperAttribute) {
+                    fun = lookupGlobalSymbol(nm);
+                }
+                const isSuperConstructor = ((_a = ctx.currFun) === null || _a === void 0 ? void 0 : _a.name) === "__init__" &&
+                    (fun === null || fun === void 0 ? void 0 : fun.name) === "__constructor" &&
+                    ((_c = (_b = ctx.currClass) === null || _b === void 0 ? void 0 : _b.baseClass) === null || _c === void 0 ? void 0 : _c.pyQName) === (fun === null || fun === void 0 ? void 0 : fun.namespace) &&
+                    isSuperAttribute;
+                if (isSuperConstructor) {
+                    fun = lookupSymbol(((_e = (_d = ctx.currClass) === null || _d === void 0 ? void 0 : _d.baseClass) === null || _e === void 0 ? void 0 : _e.pyQName) + ".__constructor");
+                }
                 if (!fun) {
                     error(n, 9508, pxt.U.lf("can't find called function '{0}'", nm));
                 }
@@ -142252,7 +142343,14 @@ var pxt;
                         ]);
                     }
                 }
-                let fn = methName ? B.mkInfix(expr(recv), ".", B.mkText(methName)) : expr(n.func);
+                // TODO (riknoll): Make sure __init__ isn't being added as a symbol by the super call in the subclass. Should be converted to .__constructor
+                let fn;
+                if (isSuperConstructor) {
+                    fn = B.mkText("super");
+                }
+                else {
+                    fn = methName ? B.mkInfix(expr(recv), ".", B.mkText(methName)) : expr(n.func);
+                }
                 let nodes = [
                     fn,
                     B.mkText("("),

package/built/pxtblockly.js

@@ -14988,6 +14988,15 @@ var pxtblockly;
     }
 })(pxtblockly || (pxtblockly = {}));
 /// <reference path="../../localtypings/pxtblockly.d.ts" />
+// common time options -- do not remove
+// lf("100 ms")
+// lf("200 ms")
+// lf("500 ms")
+// lf("1 second")
+// lf("2 seconds")
+// lf("5 seconds")
+// lf("1 minute")
+// lf("1 hour")
 var pxtblockly;
 (function (pxtblockly) {
     class FieldNumberDropdown extends Blockly.FieldNumberDropdown {
@@ -14999,7 +15008,12 @@ var pxtblockly;
             let newOptions;
             if (this.menuGenerator_) {
                 newOptions = JSON.parse(this.menuGenerator_).map((x) => {
-                    return (typeof x == 'object') ? x : [String(x), String(x)];
+                    if (typeof x == 'object') {
+                        return [pxt.Util.rlf(x[0]), x[1]];
+                    }
+                    else {
+                        return [String(x), String(x)];
+                    }
                 });
             }
             return newOptions;

package/built/pxtblocks.js

@@ -11426,6 +11426,15 @@ var pxtblockly;
     }
 })(pxtblockly || (pxtblockly = {}));
 /// <reference path="../../localtypings/pxtblockly.d.ts" />
+// common time options -- do not remove
+// lf("100 ms")
+// lf("200 ms")
+// lf("500 ms")
+// lf("1 second")
+// lf("2 seconds")
+// lf("5 seconds")
+// lf("1 minute")
+// lf("1 hour")
 var pxtblockly;
 (function (pxtblockly) {
     class FieldNumberDropdown extends Blockly.FieldNumberDropdown {
@@ -11437,7 +11446,12 @@ var pxtblockly;
             let newOptions;
             if (this.menuGenerator_) {
                 newOptions = JSON.parse(this.menuGenerator_).map((x) => {
-                    return (typeof x == 'object') ? x : [String(x), String(x)];
+                    if (typeof x == 'object') {
+                        return [pxt.Util.rlf(x[0]), x[1]];
+                    }
+                    else {
+                        return [String(x), String(x)];
+                    }
                 });
             }
             return newOptions;

package/built/pxtpy.d.ts

@@ -16,6 +16,7 @@ declare namespace pxt.py {
         pyAST?: AST;
         isProtected?: boolean;
         moduleTypeMarker?: {};
+        isStatic?: boolean;
         declared?: number;
     }
     interface TypeOptions {
@@ -170,7 +171,7 @@ declare namespace pxt.py {
         keywords: Keyword[];
         body: Stmt[];
         decorator_list: Expr[];
-        baseClass?: ClassDef;
+        baseClass?: SymbolInfo;
         isEnum?: boolean;
         isNamespace?: boolean;
     }