pxt-core 7.5.44 → 7.5.47

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;
     }

package/built/pxtpy.js

@@ -186,6 +186,7 @@ var pxt;
             return mkType({ primType: tp });
         }
         function getOrSetSymbolType(sym) {
+            var _a;
             if (!sym.pySymbolType) {
                 currErrorCtx = sym.pyQName;
                 if (sym.parameters) {
@@ -207,8 +208,24 @@ var pxt;
                     sym.pyRetType = mkType({ moduleType: sym });
                 }
                 else {
-                    if (sym.retType)
-                        sym.pyRetType = mapTsType(sym.retType);
+                    if (sym.retType) {
+                        if (((_a = sym.qName) === null || _a === void 0 ? void 0 : _a.endsWith(".__constructor")) && sym.retType === "void") {
+                            // This must be a TS class. Because python treats constructors as functions,
+                            // set the return type to be the class instead of void
+                            const classSym = lookupGlobalSymbol(sym.qName.substring(0, sym.qName.lastIndexOf(".")));
+                            if (classSym) {
+                                sym.pyRetType = mkType({
+                                    classType: classSym
+                                });
+                            }
+                            else {
+                                sym.pyRetType = mapTsType(sym.retType);
+                            }
+                        }
+                        else {
+                            sym.pyRetType = mapTsType(sym.retType);
+                        }
+                    }
                     else if (sym.pyRetType) {
                         // nothing to do
                     }
@@ -241,11 +258,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(".") && !name.endsWith(".__constructor")) {
+                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) {
@@ -328,7 +353,10 @@ var pxt;
                     pref += ".";
                 }
                 let qualifiedName = pref + name;
-                if (isLocalScope(scope)
+                if (scope.kind === "ClassDef") {
+                    varSym = addSymbol(2 /* Property */, qualifiedName);
+                }
+                else if (isLocalScope(scope)
                     && (modifier === py_1.VarModifier.Global
                         || modifier === py_1.VarModifier.NonLocal)) {
                     varSym = addSymbol(4 /* Variable */, name);
@@ -442,7 +470,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)
@@ -657,8 +685,19 @@ var pxt;
             let qn = cd.symInfo.qName;
             return pxt.U.values(internalApis).filter(e => e.namespace == qn && e.kind == 2 /* Property */);
         }
-        function getClassField(ct, n, checkOnly = false, skipBases = false) {
-            let qid = ct.pyQName + "." + n;
+        function getClassField(ct, n, isStatic, checkOnly = false, skipBases = false) {
+            let qid;
+            if (n === "__init__") {
+                qid = ct.pyQName + ".__constructor";
+            }
+            else {
+                if (n.startsWith(ct.pyQName + ".")) {
+                    qid = n;
+                }
+                else {
+                    qid = ct.pyQName + "." + n;
+                }
+            }
             let f = lookupGlobalSymbol(qid);
             if (f)
                 return f;
@@ -668,7 +707,7 @@ var pxt;
                     if (sym) {
                         if (sym == ct)
                             pxt.U.userError("field lookup loop on: " + sym.qName + " / " + n);
-                        let classF = getClassField(sym, n, true);
+                        let classF = getClassField(sym, n, isStatic, true);
                         if (classF)
                             return classF;
                     }
@@ -676,7 +715,7 @@ var pxt;
             }
             if (!checkOnly && ct.pyAST && ct.pyAST.kind == "ClassDef") {
                 let sym = addSymbol(2 /* Property */, qid);
-                sym.isInstance = true;
+                sym.isInstance = !isStatic;
                 return sym;
             }
             return null;
@@ -693,16 +732,14 @@ var pxt;
             const recvType = typeOf(recv);
             const constructorTypes = getTypesForFieldLookup(recvType);
             for (let ct of constructorTypes) {
-                let f = getClassField(ct, n, checkOnly);
+                let isModule = !!recvType.moduleType;
+                let f = getClassField(ct, n, isModule, checkOnly);
                 if (f) {
-                    let isModule = !!recvType.moduleType;
                     if (isModule) {
                         if (f.isInstance)
                             error(null, 9505, pxt.U.lf("the field '{0}' of '{1}' is not static", n, ct.pyQName));
                     }
                     else {
-                        if (!f.isInstance)
-                            error(null, 9504, pxt.U.lf("the field '{0}' of '{1}' is static", n, ct.pyQName));
                         if (isSuper(recv))
                             f.isProtected = true;
                         else if (isThis(recv)) {
@@ -885,14 +922,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"))
@@ -1054,6 +1094,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;
@@ -1106,7 +1147,7 @@ var pxt;
                             let scopeValueVar = n.vars["value"];
                             let valueVar = scopeValueVar === null || scopeValueVar === void 0 ? void 0 : scopeValueVar.symbol;
                             if (funname == "__set__" && valueVar) {
-                                let cf = getClassField(ctx.currClass.symInfo, "__get__");
+                                let cf = getClassField(ctx.currClass.symInfo, "__get__", false);
                                 if (cf && cf.pyAST && cf.pyAST.kind == "FunctionDef")
                                     unify(n, valueVar.pyRetType, cf.pyRetType);
                             }
@@ -1114,6 +1155,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));
                     }
@@ -1125,7 +1169,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);
@@ -1133,6 +1177,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) {
@@ -1176,22 +1227,61 @@ 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 && s.kind !== "Pass");
+                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) {
+                    const fieldDefs = listClassFields(n)
+                        .map(f => {
+                        if (!f.pyName || !f.pyRetType)
+                            error(n, 9535, lf("field definition missing py name or return type", f.qName));
+                        return f;
+                    });
+                    const staticFieldSymbols = fieldDefs.filter(f => !f.isInstance);
+                    const instanceFields = fieldDefs.filter(f => f.isInstance)
+                        .map((f) => B.mkStmt(accessAnnot(f), quote(f.pyName), typeAnnot(f.pyRetType)));
+                    const staticFields = staticFieldSymbols
+                        .map((f) => B.mkGroup([
+                        B.mkStmt(accessAnnot(f), B.mkText("static "), quote(f.pyName), typeAnnot(f.pyRetType)),
+                        declareLocalStatic(quoteStr(n.name), quoteStr(f.pyName), t2s(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) => {
@@ -1498,7 +1588,7 @@ var pxt;
                 // class fields can't be const
                 // hack: value in @namespace should always be const
                 isConstCall = !!(value && ctx.currClass.isNamespace);
-                let fd = getClassField(ctx.currClass.symInfo, nm);
+                let fd = getClassField(ctx.currClass.symInfo, nm, true);
                 if (!fd)
                     error(n, 9544, lf("cannot get class field"));
                 // TODO: use or remove this code
@@ -1540,7 +1630,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));
@@ -1606,6 +1698,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;
@@ -1640,6 +1733,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);
         }
@@ -1653,20 +1750,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) {
@@ -1874,6 +1978,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);
@@ -1885,6 +1990,9 @@ var pxt;
                 let methName = "";
                 if (isClass) {
                     fun = lookupSymbol(namedSymbol.pyQName + ".__constructor");
+                    if (!fun) {
+                        fun = addSymbolFor(3 /* Function */, createDummyConstructorSymbol(namedSymbol === null || namedSymbol === void 0 ? void 0 : namedSymbol.pyAST));
+                    }
                 }
                 else {
                     if (n.func.kind == "Attribute") {
@@ -1904,7 +2012,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");
                 }
@@ -1964,6 +2072,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));
                 }
@@ -2071,7 +2190,13 @@ var pxt;
                         ]);
                     }
                 }
-                let fn = methName ? B.mkInfix(expr(recv), ".", B.mkText(methName)) : expr(n.func);
+                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("("),
@@ -2728,6 +2853,68 @@ var pxt;
                     break;
             }
         }
+        function createDummyConstructorSymbol(def, sym = def.symInfo) {
+            var _a;
+            const existing = lookupApi(sym.pyQName + ".__constructor");
+            if (!existing && ((_a = sym.extendsTypes) === null || _a === void 0 ? void 0 : _a.length)) {
+                const parentSymbol = lookupSymbol(sym.extendsTypes[0]) || lookupGlobalSymbol(sym.extendsTypes[0]);
+                if (parentSymbol) {
+                    return createDummyConstructorSymbol(def, parentSymbol);
+                }
+            }
+            const result = {
+                kind: "FunctionDef",
+                name: "__init__",
+                startPos: def.startPos,
+                endPos: def.endPos,
+                parent: def,
+                body: [],
+                args: {
+                    kind: "Arguments",
+                    startPos: 0,
+                    endPos: 0,
+                    args: [{
+                            startPos: 0,
+                            endPos: 0,
+                            kind: "Arg",
+                            arg: "self"
+                        }],
+                    kw_defaults: [],
+                    kwonlyargs: [],
+                    defaults: []
+                },
+                decorator_list: [],
+                vars: {},
+                symInfo: mkSymbol(3 /* Function */, def.symInfo.qName + ".__constructor")
+            };
+            result.symInfo.parameters = [];
+            result.symInfo.pyRetType = mkType({ classType: def.symInfo });
+            if (existing) {
+                result.args.args.push(...existing.parameters.map(p => ({
+                    startPos: 0,
+                    endPos: 0,
+                    kind: "Arg",
+                    arg: p.name,
+                })));
+                result.symInfo.parameters.push(...existing.parameters.map(p => {
+                    if (p.pyType)
+                        return p;
+                    const res = Object.assign(Object.assign({}, p), { pyType: mapTsType(p.type) });
+                    return res;
+                }));
+            }
+            return result;
+        }
+        function declareLocalStatic(className, name, type) {
+            const isSetVar = `___${name}_is_set`;
+            const localVar = `___${name}`;
+            return B.mkStmt(B.mkStmt(B.mkText(`private ${isSetVar}: boolean`)), B.mkStmt(B.mkText(`private ${localVar}: ${type}`)), B.mkStmt(B.mkText(`get ${name}(): ${type}`), B.mkBlock([
+                B.mkText(`return this.${isSetVar} ? this.${localVar} : ${className}.${name}`)
+            ])), B.mkStmt(B.mkText(`set ${name}(value: ${type})`), B.mkBlock([
+                B.mkStmt(B.mkText(`this.${isSetVar} = true`)),
+                B.mkStmt(B.mkText(`this.${localVar} = value`)),
+            ])));
+        }
     })(py = pxt.py || (pxt.py = {}));
 })(pxt || (pxt = {}));
 // Lexer spec: https://docs.python.org/3/reference/lexical_analysis.html