pxt-core 7.4.26 → 7.5.3

package/built/pxtblockly.js

@@ -3741,7 +3741,7 @@ var pxt;
                 }
                 else if (b.type == "argument_reporter_array") {
                     if (!tp) {
-                        tp = ground("any[]");
+                        tp = lookup(e, b, b.getFieldValue("VALUE")).type;
                     }
                 }
                 if (tp)
@@ -4054,8 +4054,14 @@ var pxt;
             // Last pass: if some variable has no type (because it was never used or
             // assigned to), just unify it with int...
             e.allVariables.forEach((v) => {
-                if (getConcreteType(v.type).type == null)
-                    union(v.type, ground(v.type.isArrayType ? "number[]" : pNumber.type));
+                if (getConcreteType(v.type).type == null) {
+                    if (!v.isFunctionParameter) {
+                        union(v.type, ground(v.type.isArrayType ? "number[]" : pNumber.type));
+                    }
+                    else if (v.type.isArrayType) {
+                        v.type.type = "any[]";
+                    }
+                }
             });
             function connectionCheck(i) {
                 return i.name ? i.connection && i.connection.check_ && i.connection.check_.length ? i.connection.check_[0] : "T" : undefined;
@@ -4144,9 +4150,31 @@ var pxt;
         function compileNumber(e, b, comments) {
             return blocks_1.H.mkNumberLiteral(extractNumber(b));
         }
+        function isNumericLiteral(e, b) {
+            if (!b)
+                return false;
+            if (b.type === "math_number" || b.type === "math_integer" || b.type === "math_number_minmax" || b.type === "math_whole_number") {
+                return true;
+            }
+            const blockInfo = e.stdCallTable[b.type];
+            if (!blockInfo)
+                return false;
+            const { comp } = blockInfo;
+            if (blockInfo.attrs.shim === "TD_ID" && comp.parameters.length === 1) {
+                const fieldValue = b.getFieldValue(comp.parameters[0].definitionName);
+                if (fieldValue) {
+                    return !isNaN(parseInt(fieldValue));
+                }
+                else {
+                    return isNumericLiteral(e, getInputTargetBlock(b, comp.parameters[0].definitionName));
+                }
+            }
+            return false;
+        }
+        function isLiteral(e, b) {
+            return isNumericLiteral(e, b) || b.type === "logic_boolean" || b.type === "text";
+        }
         let opToTok = {
-            // POWER gets a special treatment because there's no operator for it in
-            // TouchDevelop
             "ADD": "+",
             "MINUS": "-",
             "MULTIPLY": "*",
@@ -4161,11 +4189,21 @@ var pxt;
             "NEQ": "!=",
             "POWER": "**"
         };
+        function isComparisonOp(op) {
+            return ["LT", "LTE", "GT", "GTE", "EQ", "NEQ"].indexOf(op) !== -1;
+        }
         function compileArithmetic(e, b, comments) {
             let bOp = b.getFieldValue("OP");
             let left = getInputTargetBlock(b, "A");
             let right = getInputTargetBlock(b, "B");
             let args = [compileExpression(e, left, comments), compileExpression(e, right, comments)];
+            // Special handling for the case of comparing two literals (e.g. 0 === 5). TypeScript
+            // throws an error if we don't first cast to any
+            if (isComparisonOp(bOp) && isLiteral(e, left) && isLiteral(e, right)) {
+                if (blocks_1.flattenNode([args[0]]).output !== blocks_1.flattenNode([args[1]]).output) {
+                    args = args.map(arg => blocks_1.H.mkParenthesizedExpression(blocks_1.mkGroup([arg, blocks_1.mkText(" as any")])));
+                }
+            }
             let t = returnType(e, left).type;
             if (t == pString.type) {
                 if (bOp == "EQ")
@@ -4273,7 +4311,10 @@ var pxt;
             const stmts = getInputTargetBlock(b, "STACK");
             const argsDeclaration = b.getArguments().map(a => {
                 if (a.type == "Array") {
-                    return `${escapeVarName(a.name, e)}: any[]`;
+                    const binding = lookup(e, b, a.name);
+                    const declaredType = getConcreteType(binding.type);
+                    const paramType = ((declaredType === null || declaredType === void 0 ? void 0 : declaredType.type) && declaredType.type !== "Array") ? declaredType.type : "any[]";
+                    return `${escapeVarName(a.name, e)}: ${paramType}`;
                 }
                 return `${escapeVarName(a.name, e)}: ${a.type}`;
             });
@@ -5421,7 +5462,7 @@ var pxt;
             return res;
         }
         function getEscapedCBParameters(b, stdfun, e) {
-            return getCBParameters(b, stdfun).map(binding => lookup(e, b, binding[0]).escapedName);
+            return getCBParameters(b, stdfun).map(binding => lookup(e, b, binding.name).escapedName);
         }
         function getCBParameters(b, stdfun) {
             let handlerArgs = [];
@@ -5437,7 +5478,10 @@ var pxt;
                         varName = varBlock && varBlock.getField("VAR").getText();
                     }
                     if (varName !== null) {
-                        handlerArgs.push([varName, mkPoint(arg.type)]);
+                        handlerArgs.push({
+                            name: varName,
+                            type: mkPoint(arg.type)
+                        });
                     }
                     else {
                         break;
@@ -5450,7 +5494,10 @@ var pxt;
                     const varField = b.getField("HANDLER_" + arg.name);
                     const varName = varField && varField.getText();
                     if (varName !== null) {
-                        handlerArgs.push([varName, mkPoint(arg.type)]);
+                        handlerArgs.push({
+                            name: varName,
+                            type: mkPoint(arg.type)
+                        });
                     }
                     else {
                         break;
@@ -5653,11 +5700,7 @@ var pxt;
                 }
                 if (hasStatementInput(block)) {
                     const vars = getDeclaredVariables(block, e).map(binding => {
-                        return {
-                            name: binding[0],
-                            type: binding[1],
-                            id: id++
-                        };
+                        return Object.assign(Object.assign({}, binding), { id: id++ });
                     });
                     let parentScope = currentScope;
                     if (vars.length) {
@@ -5741,17 +5784,37 @@ var pxt;
             switch (block.type) {
                 case 'pxt_controls_for':
                 case 'controls_simple_for':
-                    return [[getLoopVariableField(block).getField("VAR").getText(), pNumber]];
+                    return [{
+                            name: getLoopVariableField(block).getField("VAR").getText(),
+                            type: pNumber
+                        }];
                 case 'pxt_controls_for_of':
                 case 'controls_for_of':
-                    return [[getLoopVariableField(block).getField("VAR").getText(), mkPoint(null)]];
+                    return [{
+                            name: getLoopVariableField(block).getField("VAR").getText(),
+                            type: mkPoint(null)
+                        }];
+                case 'function_definition':
+                    return block.getArguments().filter(arg => arg.type === "Array")
+                        .map(arg => {
+                        const point = mkPoint(null);
+                        point.isArrayType = true;
+                        return {
+                            name: arg.name,
+                            type: point,
+                            isFunctionParameter: true
+                        };
+                    });
                 default:
                     break;
             }
             if (isMutatingBlock(block)) {
                 const declarations = block.mutation.getDeclaredVariables();
                 if (declarations) {
-                    return Object.keys(declarations).map(varName => [varName, mkPoint(declarations[varName])]);
+                    return Object.keys(declarations).map(varName => ({
+                        name: varName,
+                        type: mkPoint(declarations[varName])
+                    }));
                 }
             }
             let stdFunc = e.stdCallTable[block.type];
@@ -7640,21 +7703,9 @@ var pxt;
                 || (nsinfo && nsinfo.attributes.color)
                 || pxt.toolbox.getNamespaceColor(ns)
                 || 255;
-            if (fn.attributes.help) {
-                const helpUrl = fn.attributes.help.replace(/^\//, '');
-                if (/^github:/.test(helpUrl)) {
-                    block.setHelpUrl(helpUrl);
-                }
-                else if (helpUrl !== "none") {
-                    block.setHelpUrl("/reference/" + helpUrl);
-                }
-            }
-            else if (fn.pkg && !pxt.appTarget.bundledpkgs[fn.pkg]) { // added package
-                let anchor = fn.qName.toLowerCase().split('.');
-                if (anchor[0] == fn.pkg)
-                    anchor.shift();
-                block.setHelpUrl(`/pkg/${fn.pkg}#${encodeURIComponent(anchor.join('-'))}`);
-            }
+            const helpUrl = pxt.blocks.getHelpUrl(fn);
+            if (helpUrl)
+                block.setHelpUrl(helpUrl);
             block.setColour(color);
             let blockShape = Blockly.OUTPUT_SHAPE_ROUND;
             if (fn.retType == "boolean")

package/built/pxtblocks.d.ts

@@ -39,6 +39,7 @@ declare namespace pxt.blocks {
         alreadyDeclared?: BlockDeclarationType;
         firstReference?: Blockly.Block;
         isAssigned?: boolean;
+        isFunctionParameter?: boolean;
     }
     function compileExpression(e: Environment, b: Blockly.Block, comments: string[]): JsNode;
     interface Environment {

package/built/pxtblocks.js

@@ -179,7 +179,7 @@ var pxt;
                 }
                 else if (b.type == "argument_reporter_array") {
                     if (!tp) {
-                        tp = ground("any[]");
+                        tp = lookup(e, b, b.getFieldValue("VALUE")).type;
                     }
                 }
                 if (tp)
@@ -492,8 +492,14 @@ var pxt;
             // Last pass: if some variable has no type (because it was never used or
             // assigned to), just unify it with int...
             e.allVariables.forEach((v) => {
-                if (getConcreteType(v.type).type == null)
-                    union(v.type, ground(v.type.isArrayType ? "number[]" : pNumber.type));
+                if (getConcreteType(v.type).type == null) {
+                    if (!v.isFunctionParameter) {
+                        union(v.type, ground(v.type.isArrayType ? "number[]" : pNumber.type));
+                    }
+                    else if (v.type.isArrayType) {
+                        v.type.type = "any[]";
+                    }
+                }
             });
             function connectionCheck(i) {
                 return i.name ? i.connection && i.connection.check_ && i.connection.check_.length ? i.connection.check_[0] : "T" : undefined;
@@ -582,9 +588,31 @@ var pxt;
         function compileNumber(e, b, comments) {
             return blocks_1.H.mkNumberLiteral(extractNumber(b));
         }
+        function isNumericLiteral(e, b) {
+            if (!b)
+                return false;
+            if (b.type === "math_number" || b.type === "math_integer" || b.type === "math_number_minmax" || b.type === "math_whole_number") {
+                return true;
+            }
+            const blockInfo = e.stdCallTable[b.type];
+            if (!blockInfo)
+                return false;
+            const { comp } = blockInfo;
+            if (blockInfo.attrs.shim === "TD_ID" && comp.parameters.length === 1) {
+                const fieldValue = b.getFieldValue(comp.parameters[0].definitionName);
+                if (fieldValue) {
+                    return !isNaN(parseInt(fieldValue));
+                }
+                else {
+                    return isNumericLiteral(e, getInputTargetBlock(b, comp.parameters[0].definitionName));
+                }
+            }
+            return false;
+        }
+        function isLiteral(e, b) {
+            return isNumericLiteral(e, b) || b.type === "logic_boolean" || b.type === "text";
+        }
         let opToTok = {
-            // POWER gets a special treatment because there's no operator for it in
-            // TouchDevelop
             "ADD": "+",
             "MINUS": "-",
             "MULTIPLY": "*",
@@ -599,11 +627,21 @@ var pxt;
             "NEQ": "!=",
             "POWER": "**"
         };
+        function isComparisonOp(op) {
+            return ["LT", "LTE", "GT", "GTE", "EQ", "NEQ"].indexOf(op) !== -1;
+        }
         function compileArithmetic(e, b, comments) {
             let bOp = b.getFieldValue("OP");
             let left = getInputTargetBlock(b, "A");
             let right = getInputTargetBlock(b, "B");
             let args = [compileExpression(e, left, comments), compileExpression(e, right, comments)];
+            // Special handling for the case of comparing two literals (e.g. 0 === 5). TypeScript
+            // throws an error if we don't first cast to any
+            if (isComparisonOp(bOp) && isLiteral(e, left) && isLiteral(e, right)) {
+                if (blocks_1.flattenNode([args[0]]).output !== blocks_1.flattenNode([args[1]]).output) {
+                    args = args.map(arg => blocks_1.H.mkParenthesizedExpression(blocks_1.mkGroup([arg, blocks_1.mkText(" as any")])));
+                }
+            }
             let t = returnType(e, left).type;
             if (t == pString.type) {
                 if (bOp == "EQ")
@@ -711,7 +749,10 @@ var pxt;
             const stmts = getInputTargetBlock(b, "STACK");
             const argsDeclaration = b.getArguments().map(a => {
                 if (a.type == "Array") {
-                    return `${escapeVarName(a.name, e)}: any[]`;
+                    const binding = lookup(e, b, a.name);
+                    const declaredType = getConcreteType(binding.type);
+                    const paramType = ((declaredType === null || declaredType === void 0 ? void 0 : declaredType.type) && declaredType.type !== "Array") ? declaredType.type : "any[]";
+                    return `${escapeVarName(a.name, e)}: ${paramType}`;
                 }
                 return `${escapeVarName(a.name, e)}: ${a.type}`;
             });
@@ -1859,7 +1900,7 @@ var pxt;
             return res;
         }
         function getEscapedCBParameters(b, stdfun, e) {
-            return getCBParameters(b, stdfun).map(binding => lookup(e, b, binding[0]).escapedName);
+            return getCBParameters(b, stdfun).map(binding => lookup(e, b, binding.name).escapedName);
         }
         function getCBParameters(b, stdfun) {
             let handlerArgs = [];
@@ -1875,7 +1916,10 @@ var pxt;
                         varName = varBlock && varBlock.getField("VAR").getText();
                     }
                     if (varName !== null) {
-                        handlerArgs.push([varName, mkPoint(arg.type)]);
+                        handlerArgs.push({
+                            name: varName,
+                            type: mkPoint(arg.type)
+                        });
                     }
                     else {
                         break;
@@ -1888,7 +1932,10 @@ var pxt;
                     const varField = b.getField("HANDLER_" + arg.name);
                     const varName = varField && varField.getText();
                     if (varName !== null) {
-                        handlerArgs.push([varName, mkPoint(arg.type)]);
+                        handlerArgs.push({
+                            name: varName,
+                            type: mkPoint(arg.type)
+                        });
                     }
                     else {
                         break;
@@ -2091,11 +2138,7 @@ var pxt;
                 }
                 if (hasStatementInput(block)) {
                     const vars = getDeclaredVariables(block, e).map(binding => {
-                        return {
-                            name: binding[0],
-                            type: binding[1],
-                            id: id++
-                        };
+                        return Object.assign(Object.assign({}, binding), { id: id++ });
                     });
                     let parentScope = currentScope;
                     if (vars.length) {
@@ -2179,17 +2222,37 @@ var pxt;
             switch (block.type) {
                 case 'pxt_controls_for':
                 case 'controls_simple_for':
-                    return [[getLoopVariableField(block).getField("VAR").getText(), pNumber]];
+                    return [{
+                            name: getLoopVariableField(block).getField("VAR").getText(),
+                            type: pNumber
+                        }];
                 case 'pxt_controls_for_of':
                 case 'controls_for_of':
-                    return [[getLoopVariableField(block).getField("VAR").getText(), mkPoint(null)]];
+                    return [{
+                            name: getLoopVariableField(block).getField("VAR").getText(),
+                            type: mkPoint(null)
+                        }];
+                case 'function_definition':
+                    return block.getArguments().filter(arg => arg.type === "Array")
+                        .map(arg => {
+                        const point = mkPoint(null);
+                        point.isArrayType = true;
+                        return {
+                            name: arg.name,
+                            type: point,
+                            isFunctionParameter: true
+                        };
+                    });
                 default:
                     break;
             }
             if (isMutatingBlock(block)) {
                 const declarations = block.mutation.getDeclaredVariables();
                 if (declarations) {
-                    return Object.keys(declarations).map(varName => [varName, mkPoint(declarations[varName])]);
+                    return Object.keys(declarations).map(varName => ({
+                        name: varName,
+                        type: mkPoint(declarations[varName])
+                    }));
                 }
             }
             let stdFunc = e.stdCallTable[block.type];
@@ -4078,21 +4141,9 @@ var pxt;
                 || (nsinfo && nsinfo.attributes.color)
                 || pxt.toolbox.getNamespaceColor(ns)
                 || 255;
-            if (fn.attributes.help) {
-                const helpUrl = fn.attributes.help.replace(/^\//, '');
-                if (/^github:/.test(helpUrl)) {
-                    block.setHelpUrl(helpUrl);
-                }
-                else if (helpUrl !== "none") {
-                    block.setHelpUrl("/reference/" + helpUrl);
-                }
-            }
-            else if (fn.pkg && !pxt.appTarget.bundledpkgs[fn.pkg]) { // added package
-                let anchor = fn.qName.toLowerCase().split('.');
-                if (anchor[0] == fn.pkg)
-                    anchor.shift();
-                block.setHelpUrl(`/pkg/${fn.pkg}#${encodeURIComponent(anchor.join('-'))}`);
-            }
+            const helpUrl = pxt.blocks.getHelpUrl(fn);
+            if (helpUrl)
+                block.setHelpUrl(helpUrl);
             block.setColour(color);
             let blockShape = Blockly.OUTPUT_SHAPE_ROUND;
             if (fn.retType == "boolean")

package/built/pxtcompiler.js

@@ -4620,6 +4620,8 @@ ${output}</xml>`;
                                 return getTaggedTemplateExpression(n);
                             case SK.CallExpression:
                                 return getStatementBlock(n, undefined, undefined, true);
+                            case SK.AsExpression:
+                                return getOutputBlock(n.expression);
                             default:
                                 error(n, pxtc.Util.lf("Unsupported syntax kind for output expression block: {0}", SK[n.kind]));
                                 break;
@@ -5500,11 +5502,14 @@ ${output}</xml>`;
                         r.mutationChildren = [];
                         n.parameters.forEach(p => {
                             const paramName = p.name.getText();
+                            let type = normalizeType(p.type.getText());
+                            if (pxt.U.endsWith(type, "[]"))
+                                type = "Array";
                             r.mutationChildren.push({
                                 nodeName: "arg",
                                 attributes: {
                                     name: paramName,
-                                    type: p.type.getText(),
+                                    type,
                                     id: env.functionParamIds[name][paramName]
                                 }
                             });
@@ -5580,11 +5585,14 @@ ${output}</xml>`;
                                     env.declaredFunctions[name].parameters.forEach((p, i) => {
                                         const paramName = p.name.getText();
                                         const argId = env.functionParamIds[name][paramName];
+                                        let type = normalizeType(p.type.getText());
+                                        if (pxt.U.endsWith(type, "[]"))
+                                            type = "Array";
                                         r.mutationChildren.push({
                                             nodeName: "arg",
                                             attributes: {
                                                 name: paramName,
-                                                type: p.type.getText(),
+                                                type: type,
                                                 id: argId
                                             }
                                         });
@@ -6452,7 +6460,8 @@ ${output}</xml>`;
                                 if (!type) {
                                     return pxtc.Util.lf("Function parameters must declare a type");
                                 }
-                                if (env.opts.allowedArgumentTypes.indexOf(normalizeType(type)) === -1) {
+                                const normalized = normalizeType(type);
+                                if (env.opts.allowedArgumentTypes.indexOf(normalized) === -1 && !pxtc.U.endsWith(normalized, "[]")) {
                                     return pxtc.Util.lf("Only types that can be added in blocks can be used for function arguments");
                                 }
                             }
@@ -6727,6 +6736,8 @@ ${output}</xml>`;
                         return checkStatement(n, env, true, undefined);
                     case SK.TaggedTemplateExpression:
                         return checkTaggedTemplateExpression(n, env);
+                    case SK.AsExpression:
+                        return checkAsExpression(n);
                 }
                 return pxtc.Util.lf("Unsupported syntax kind for output expression block: {0}", SK[n.kind]);
                 function checkStringLiteral(n) {
@@ -6823,6 +6834,31 @@ ${output}</xml>`;
                 // The compiler will have already caught any invalid tags or templates
                 return undefined;
             }
+            function checkAsExpression(n) {
+                // The only time we allow casts to decompile is in the very special case where someone has
+                // written a program comparing two string, boolean, or numeric literals in blocks and
+                // converted to text. e.g. 3 == 5 or true != false
+                if (n.type.getText().trim() === "any" && (ts.isStringOrNumericLiteral(n.expression) ||
+                    n.expression.kind === SK.TrueKeyword || n.expression.kind === SK.FalseKeyword)) {
+                    const [parent] = getParent(n);
+                    if (parent.kind === SK.BinaryExpression) {
+                        switch (parent.operatorToken.kind) {
+                            case SK.EqualsEqualsToken:
+                            case SK.EqualsEqualsEqualsToken:
+                            case SK.ExclamationEqualsToken:
+                            case SK.ExclamationEqualsEqualsToken:
+                            case SK.LessThanToken:
+                            case SK.LessThanEqualsToken:
+                            case SK.GreaterThanToken:
+                            case SK.GreaterThanEqualsToken:
+                                return undefined;
+                            default:
+                                break;
+                        }
+                    }
+                }
+                return pxtc.Util.lf("Casting not supported in blocks");
+            }
             function getParent(node) {
                 if (!node.parent) {
                     return [undefined, node];
@@ -12615,8 +12651,10 @@ ${lbl}: .short 0xffff
                     return needsNumberConversions() ? pxtc.ir.rtcall("pxt::toInt", [e]) : e;
                 };
                 // c = a[i]
-                if (iterVar)
+                if (iterVar) {
                     proc.emitExpr(iterVar.storeByRef(pxtc.ir.rtcall(indexer, [collectionVar.loadCore(), toInt(intVarIter.loadCore())])));
+                    emitBrk(node.initializer);
+                }
                 flushHoistedFunctionDefinitions();
                 emit(node.statement);
                 proc.emitLblDirect(l.cont);

package/built/pxtlib.d.ts

@@ -552,6 +552,7 @@ declare namespace pxt {
         multiUrl?: string;
         asseteditorUrl?: string;
         skillmapUrl?: string;
+        authcodeUrl?: string;
         isStatic?: boolean;
         verprefix?: string;
     }
@@ -656,6 +657,7 @@ declare namespace pxt.blocks {
     function normalizeBlock(b: string, err?: (msg: string) => void): string;
     function compileInfo(fn: pxtc.SymbolInfo): BlockCompileInfo;
     function hasHandler(fn: pxtc.SymbolInfo): boolean;
+    function getHelpUrl(fn: pxtc.SymbolInfo): string;
     /**
      * Returns which Blockly block type to use for an argument reporter based
      * on the specified TypeScript type.

package/built/pxtlib.js

@@ -3909,6 +3909,25 @@ var pxt;
             });
         }
         blocks.hasHandler = hasHandler;
+        function getHelpUrl(fn) {
+            if (fn.attributes.help) {
+                const helpUrl = fn.attributes.help.replace(/^\//, '');
+                if (/^github:/.test(helpUrl)) {
+                    return helpUrl;
+                }
+                else if (helpUrl !== "none") {
+                    return "/reference/" + helpUrl;
+                }
+            }
+            else if (fn.pkg && !pxt.appTarget.bundledpkgs[fn.pkg]) { // added package
+                let anchor = fn.qName.toLowerCase().split('.');
+                if (anchor[0] == fn.pkg)
+                    anchor.shift();
+                return `/pkg/${fn.pkg}#${encodeURIComponent(anchor.join('-'))}`;
+            }
+            return undefined;
+        }
+        blocks.getHelpUrl = getHelpUrl;
         /**
          * Returns which Blockly block type to use for an argument reporter based
          * on the specified TypeScript type.
@@ -3920,6 +3939,9 @@ var pxt;
             if (varType === "boolean" || varType === "number" || varType === "string") {
                 reporterType = `argument_reporter_${varType}`;
             }
+            if (/^(?:Array<(?:.+)>)|(?:(?:.+)\[\])$/.test(varType)) {
+                reporterType = "argument_reporter_array";
+            }
             return reporterType;
         }
         blocks.reporterTypeForArgType = reporterTypeForArgType;