pxt-core 7.5.45 → 7.5.48

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
                     }
@@ -247,7 +264,7 @@ var pxt;
             let sym = lookupApi(name);
             if (sym)
                 getOrSetSymbolType(sym);
-            else if (name.indexOf(".")) {
+            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)) {
@@ -336,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);
@@ -661,17 +681,22 @@ var pxt;
             return n.symInfo;
         }
         // TODO optimize ?
-        function listClassFields(cd, excludeVariables = true) {
+        function listClassFields(cd) {
             let qn = cd.symInfo.qName;
-            return pxt.U.values(internalApis).filter(e => e.namespace == qn && ((e.kind == 4 /* Variable */ && !excludeVariables) || e.kind == 2 /* Property */));
+            return pxt.U.values(internalApis).filter(e => e.namespace == qn && e.kind == 2 /* Property */);
         }
-        function getClassField(ct, n, checkOnly = false, skipBases = false) {
+        function getClassField(ct, n, isStatic, checkOnly = false, skipBases = false) {
             let qid;
             if (n === "__init__") {
                 qid = ct.pyQName + ".__constructor";
             }
             else {
-                qid = ct.pyQName + "." + n;
+                if (n.startsWith(ct.pyQName + ".")) {
+                    qid = n;
+                }
+                else {
+                    qid = ct.pyQName + "." + n;
+                }
             }
             let f = lookupGlobalSymbol(qid);
             if (f)
@@ -682,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;
                     }
@@ -690,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;
@@ -707,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)) {
@@ -1124,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);
                             }
@@ -1220,7 +1243,7 @@ var pxt;
                     }
                 }
                 const classDefs = n.body.filter(s => n.isNamespace || s.kind === "FunctionDef");
-                const staticStmts = n.isNamespace ? [] : n.body.filter(s => classDefs.indexOf(s) === -1);
+                const staticStmts = n.isNamespace ? [] : n.body.filter(s => classDefs.indexOf(s) === -1 && s.kind !== "Pass");
                 let body = stmts(classDefs);
                 nodes.push(body);
                 // Python classes allow arbitrary statements in their bodies, sort of like namespaces.
@@ -1237,18 +1260,20 @@ var pxt;
                     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))
+                    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 instanceFields = fieldDefs.filter(f => !isStatic(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 = fieldDefs.filter(f => isStatic(f))
-                        .map((f) => B.mkStmt(accessAnnot(f), B.mkText("static "), 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) {
@@ -1563,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
@@ -1965,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") {
@@ -2162,7 +2190,6 @@ var pxt;
                         ]);
                     }
                 }
-                // 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");
@@ -2826,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