pxt-core 7.5.44 → 7.5.45

package/built/pxtpy.js

@@ -241,11 +241,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) {
@@ -442,7 +450,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)
@@ -653,12 +661,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;
@@ -885,14 +899,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 +1071,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;
@@ -1114,6 +1132,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 +1146,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 +1154,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 +1204,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) => {
@@ -1540,7 +1605,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 +1673,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 +1708,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 +1725,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 +1953,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);
@@ -1904,7 +1984,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 +2044,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 +2162,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("("),