pxt-core 11.4.7 → 11.4.8

package/built/pxt.js

@@ -126305,15 +126305,17 @@ function ${id}(s) {
                         write(`r0 = ${emitExprInto(e)};`);
                 }
             }
+            function vTableRef(info) {
+                return `${info.id}_VT`;
+            }
             function checkSubtype(info, r0 = "r0") {
-                const vt = `${info.id}_VT`;
-                return `checkSubtype(${r0}, ${vt})`;
+                return `checkSubtype(${r0}, ${vTableRef(info)})`;
             }
             function emitInstanceOf(info, tp, r0 = "r0") {
                 if (tp == "bool")
                     write(`r0 = ${checkSubtype(info)};`);
                 else if (tp == "validate") {
-                    write(`if (!${checkSubtype(info, r0)}) failedCast(${r0});`);
+                    write(`if (!${checkSubtype(info, r0)}) failedCast(${r0}, ${vTableRef(info)});`);
                 }
                 else {
                     pxtc.U.oops();
@@ -153245,6 +153247,9 @@ var pxsim;
         }
         pxtrt.mapSet = mapSet;
         function mapGetByString(map, key) {
+            if (!map) {
+                pxsim.throwFailedPropertyAccessError(map, key);
+            }
             key += "";
             if (map instanceof RefRecord) {
                 let r = map;
@@ -153258,8 +153263,12 @@ var pxsim;
         }
         pxtrt.mapGetByString = mapGetByString;
         function mapDeleteByString(map, key) {
-            if (!(map instanceof RefMap))
-                pxtrt.panic(923);
+            if (map === undefined || map === null) {
+                pxsim.throwNullUndefinedAsObjectError();
+            }
+            if (!(map instanceof RefMap)) {
+                pxsim.throwFailedCastError(map, "object");
+            }
             let i = map.findIdx(key);
             if (i >= 0)
                 map.data.splice(i, 1);
@@ -153269,6 +153278,9 @@ var pxsim;
         pxtrt.mapSetGeneric = mapSetByString;
         pxtrt.mapGetGeneric = mapGetByString;
         function mapSetByString(map, key, val) {
+            if (!map) {
+                pxsim.throwFailedPropertyAccessError(map, key);
+            }
             key += "";
             if (map instanceof RefRecord) {
                 let r = map;
@@ -153288,6 +153300,9 @@ var pxsim;
         }
         pxtrt.mapSetByString = mapSetByString;
         function keysOf(v) {
+            if (v === undefined || v === null) {
+                pxsim.throwNullUndefinedAsObjectError();
+            }
             let r = new pxsim.RefCollection();
             if (v instanceof RefMap)
                 for (let k of v.data) {
@@ -153326,6 +153341,7 @@ var pxsim;
         }
         thread.pause = pause;
         function runInBackground(a) {
+            typeCheck(a);
             pxsim.runtime.runFiberAsync(a);
         }
         thread.runInBackground = runInBackground;
@@ -153335,10 +153351,16 @@ var pxsim;
                     .then(() => pxsim.U.delay(20))
                     .then(loop);
             }
-            pxtrt.nullCheck(a);
+            typeCheck(a);
             loop();
         }
         thread.forever = forever;
+        function typeCheck(a) {
+            if (!a || !(a instanceof RefAction) && !a.info) {
+                pxsim.throwFailedCastError(a, "function");
+            }
+        }
+        thread.typeCheck = typeCheck;
     })(thread = pxsim.thread || (pxsim.thread = {}));
 })(pxsim || (pxsim = {}));
 var pxsim;
@@ -153437,35 +153459,35 @@ var pxsim;
         }
         Array_.isArray = isArray;
         function length(c) {
-            pxsim.pxtrt.nullCheck(c);
+            typeCheck(c);
             return c.getLength();
         }
         Array_.length = length;
         function setLength(c, x) {
-            pxsim.pxtrt.nullCheck(c);
+            typeCheck(c);
             c.setLength(x);
         }
         Array_.setLength = setLength;
         function push(c, x) {
-            pxsim.pxtrt.nullCheck(c);
+            typeCheck(c);
             c.push(x);
         }
         Array_.push = push;
         function pop(c, x) {
-            pxsim.pxtrt.nullCheck(c);
+            typeCheck(c);
             let ret = c.pop();
             // no decr() since we're returning it
             return ret;
         }
         Array_.pop = pop;
         function getAt(c, x) {
-            pxsim.pxtrt.nullCheck(c);
+            typeCheck(c);
             let tmp = c.getAt(x);
             return tmp;
         }
         Array_.getAt = getAt;
         function removeAt(c, x) {
-            pxsim.pxtrt.nullCheck(c);
+            typeCheck(c);
             if (!c.isValidIndex(x))
                 return;
             // no decr() since we're returning it
@@ -153473,22 +153495,22 @@ var pxsim;
         }
         Array_.removeAt = removeAt;
         function insertAt(c, x, y) {
-            pxsim.pxtrt.nullCheck(c);
+            typeCheck(c);
             c.insertAt(x, y);
         }
         Array_.insertAt = insertAt;
         function setAt(c, x, y) {
-            pxsim.pxtrt.nullCheck(c);
+            typeCheck(c);
             c.setAt(x, y);
         }
         Array_.setAt = setAt;
         function indexOf(c, x, start) {
-            pxsim.pxtrt.nullCheck(c);
+            typeCheck(c);
             return c.indexOf(x, start);
         }
         Array_.indexOf = indexOf;
         function removeElement(c, x) {
-            pxsim.pxtrt.nullCheck(c);
+            typeCheck(c);
             let idx = indexOf(c, x, 0);
             if (idx >= 0) {
                 removeAt(c, idx);
@@ -153497,6 +153519,12 @@ var pxsim;
             return 0;
         }
         Array_.removeElement = removeElement;
+        function typeCheck(c) {
+            if (!(c instanceof RefCollection)) {
+                pxsim.throwFailedCastError(c, "Array");
+            }
+        }
+        Array_.typeCheck = typeCheck;
     })(Array_ = pxsim.Array_ || (pxsim.Array_ = {}));
     let Math_;
     (function (Math_) {
@@ -153712,24 +153740,28 @@ var pxsim;
         }
         String_.fromCharCode = fromCharCode;
         function toNumber(s) {
+            typeCheck(s);
             return parseFloat(s);
         }
         String_.toNumber = toNumber;
         // TODO check edge-conditions
         function concat(a, b) {
+            typeCheck(a);
             return (a + b);
         }
         String_.concat = concat;
         function substring(s, i, j) {
-            pxsim.pxtrt.nullCheck(s);
+            typeCheck(s);
             return (s.slice(i, i + j));
         }
         String_.substring = substring;
         function equals(s1, s2) {
+            typeCheck(s1);
             return s1 == s2;
         }
         String_.equals = equals;
         function compare(s1, s2) {
+            typeCheck(s1);
             if (s1 == s2)
                 return 0;
             if (s1 < s2)
@@ -153738,6 +153770,7 @@ var pxsim;
         }
         String_.compare = compare;
         function compareDecr(s1, s2) {
+            typeCheck(s1);
             if (s1 == s2) {
                 return 0;
             }
@@ -153747,47 +153780,56 @@ var pxsim;
         }
         String_.compareDecr = compareDecr;
         function length(s) {
+            typeCheck(s);
             return s.length;
         }
         String_.length = length;
         function substr(s, start, length) {
+            typeCheck(s);
             return (s.substr(start, length));
         }
         String_.substr = substr;
         function inRange(s, i) {
-            pxsim.pxtrt.nullCheck(s);
+            typeCheck(s);
             return 0 <= i && i < s.length;
         }
         function charAt(s, i) {
+            typeCheck(s);
             return (s.charAt(i));
         }
         String_.charAt = charAt;
         function charCodeAt(s, i) {
-            pxsim.pxtrt.nullCheck(s);
+            typeCheck(s);
             return inRange(s, i) ? s.charCodeAt(i) : 0;
         }
         String_.charCodeAt = charCodeAt;
         function indexOf(s, searchValue, start) {
-            pxsim.pxtrt.nullCheck(s);
+            typeCheck(s);
             if (searchValue == null)
                 return -1;
             return s.indexOf(searchValue, start);
         }
         String_.indexOf = indexOf;
         function lastIndexOf(s, searchValue, start) {
-            pxsim.pxtrt.nullCheck(s);
+            typeCheck(s);
             if (searchValue == null)
                 return -1;
             return s.lastIndexOf(searchValue, start);
         }
         String_.lastIndexOf = lastIndexOf;
         function includes(s, searchValue, start) {
-            pxsim.pxtrt.nullCheck(s);
+            typeCheck(s);
             if (searchValue == null)
                 return false;
             return s.includes(searchValue, start);
         }
         String_.includes = includes;
+        function typeCheck(s) {
+            if (typeof s !== "string") {
+                pxsim.throwFailedCastError(s, "string");
+            }
+        }
+        String_.typeCheck = typeCheck;
     })(String_ = pxsim.String_ || (pxsim.String_ = {}));
     let Boolean_;
     (function (Boolean_) {
@@ -153880,6 +153922,7 @@ var pxsim;
             return { size, signed, swap, isFloat };
         }
         function getNumber(buf, fmt, offset) {
+            typeCheck(buf);
             let inf = fmtInfo(fmt);
             if (inf.isFloat) {
                 let subarray = buf.data.buffer.slice(offset, offset + inf.size);
@@ -153909,6 +153952,7 @@ var pxsim;
         }
         BufferMethods.getNumber = getNumber;
         function setNumber(buf, fmt, offset, r) {
+            typeCheck(buf);
             let inf = fmtInfo(fmt);
             if (inf.isFloat) {
                 let arr = new Uint8Array(inf.size);
@@ -153935,6 +153979,7 @@ var pxsim;
         }
         BufferMethods.createBuffer = createBuffer;
         function createBufferFromHex(hex) {
+            String_.typeCheck(hex);
             let r = createBuffer(hex.length >> 1);
             for (let i = 0; i < hex.length; i += 2)
                 r.data[i >> 1] = parseInt(hex.slice(i, i + 2), 16);
@@ -153943,23 +153988,26 @@ var pxsim;
         }
         BufferMethods.createBufferFromHex = createBufferFromHex;
         function isReadOnly(buf) {
+            typeCheck(buf);
             return buf.isStatic;
         }
         BufferMethods.isReadOnly = isReadOnly;
         function getBytes(buf) {
+            typeCheck(buf);
             // not sure if this is any useful...
             return buf.data;
         }
         BufferMethods.getBytes = getBytes;
         function inRange(buf, off) {
-            pxsim.pxtrt.nullCheck(buf);
             return 0 <= off && off < buf.data.length;
         }
         function getUint8(buf, off) {
+            typeCheck(buf);
             return getByte(buf, off);
         }
         BufferMethods.getUint8 = getUint8;
         function getByte(buf, off) {
+            typeCheck(buf);
             if (inRange(buf, off))
                 return buf.data[off];
             else
@@ -153967,6 +154015,7 @@ var pxsim;
         }
         BufferMethods.getByte = getByte;
         function setUint8(buf, off, v) {
+            typeCheck(buf);
             setByte(buf, off, v);
         }
         BufferMethods.setUint8 = setUint8;
@@ -153975,6 +154024,7 @@ var pxsim;
                 pxsim.U.userError("Writing to read only buffer.");
         }
         function setByte(buf, off, v) {
+            typeCheck(buf);
             if (inRange(buf, off)) {
                 checkWrite(buf);
                 buf.data[off] = v;
@@ -153982,10 +154032,12 @@ var pxsim;
         }
         BufferMethods.setByte = setByte;
         function length(buf) {
+            typeCheck(buf);
             return buf.data.length;
         }
         BufferMethods.length = length;
         function fill(buf, value, offset = 0, length = -1) {
+            typeCheck(buf);
             if (offset < 0 || offset > buf.data.length)
                 return;
             if (length < 0)
@@ -153996,6 +154048,7 @@ var pxsim;
         }
         BufferMethods.fill = fill;
         function slice(buf, offset, length) {
+            typeCheck(buf);
             offset = Math.min(buf.data.length, offset);
             if (length < 0)
                 length = buf.data.length;
@@ -154004,6 +154057,7 @@ var pxsim;
         }
         BufferMethods.slice = slice;
         function toHex(buf) {
+            typeCheck(buf);
             const hex = "0123456789abcdef";
             let res = "";
             for (let i = 0; i < buf.data.length; ++i) {
@@ -154014,6 +154068,7 @@ var pxsim;
         }
         BufferMethods.toHex = toHex;
         function toString(buf) {
+            typeCheck(buf);
             return pxsim.U.fromUTF8Array(buf.data);
         }
         BufferMethods.toString = toString;
@@ -154028,6 +154083,7 @@ var pxsim;
         }
         const INT_MIN = -0x80000000;
         function shift(buf, offset, start, len) {
+            typeCheck(buf);
             if (len < 0)
                 len = buf.data.length - start;
             if (start < 0 || start + len > buf.data.length || start + len < start
@@ -154053,6 +154109,7 @@ var pxsim;
         }
         BufferMethods.shift = shift;
         function rotate(buf, offset, start, len) {
+            typeCheck(buf);
             if (len < 0)
                 len = buf.data.length - start;
             if (start < 0 || start + len > buf.data.length || start + len < start
@@ -154083,6 +154140,8 @@ var pxsim;
         }
         BufferMethods.rotate = rotate;
         function write(buf, dstOffset, src, srcOffset = 0, length = -1) {
+            typeCheck(buf);
+            typeCheck(src);
             if (length < 0)
                 length = src.data.length;
             if (srcOffset < 0 || dstOffset < 0 || dstOffset > buf.data.length)
@@ -154094,12 +154153,19 @@ var pxsim;
             memmove(buf.data, dstOffset, src.data, srcOffset, length);
         }
         BufferMethods.write = write;
+        function typeCheck(buf) {
+            if (!(buf instanceof RefBuffer)) {
+                pxsim.throwFailedCastError(buf, "Buffer");
+            }
+        }
+        BufferMethods.typeCheck = typeCheck;
     })(BufferMethods = pxsim.BufferMethods || (pxsim.BufferMethods = {}));
 })(pxsim || (pxsim = {}));
 (function (pxsim) {
     var control;
     (function (control) {
         function createBufferFromUTF8(str) {
+            pxsim.String_.typeCheck(str);
             return new pxsim.RefBuffer(pxsim.U.toUTF8Array(str));
         }
         control.createBufferFromUTF8 = createBufferFromUTF8;
@@ -155394,11 +155460,12 @@ var pxsim;
                     return true;
                 return vt2 && vt.classNo <= vt2.classNo && vt2.classNo <= vt.lastSubtypeNo;
             }
-            function failedCast(v) {
+            function failedCast(v, expectedType) {
                 // TODO generate the right panic codes
-                if (pxsim.control && pxsim.control.dmesgValue)
+                if (pxsim.control && pxsim.control.dmesgValue) {
                     pxsim.control.dmesgValue(v);
-                oops("failed cast on " + v);
+                }
+                throwFailedCastError(v, expectedType === null || expectedType === void 0 ? void 0 : expectedType.name);
             }
             function buildResume(s, retPC) {
                 if (currResume)
@@ -155923,6 +155990,69 @@ var pxsim;
         }
     }
     pxsim.Runtime = Runtime;
+    function throwUserException(message) {
+        throw new Error(message);
+    }
+    pxsim.throwUserException = throwUserException;
+    function throwTypeError(message) {
+        throwUserException(pxsim.localization.lf("TypeError: {0}", message));
+    }
+    pxsim.throwTypeError = throwTypeError;
+    function throwFailedCastError(value, expectedType) {
+        const typename = getType(value);
+        if (expectedType) {
+            if (value === null || value === undefined) {
+                throwTypeError(pxsim.localization.lf("Expected type {0} but received type {1}. Did you forget to assign a variable?", expectedType, typename));
+            }
+            else {
+                throwTypeError(pxsim.localization.lf("Expected type {0} but received type {1}", expectedType, typename));
+            }
+        }
+        else {
+            throwTypeError(pxsim.localization.lf("Cannot read properties of {0}", typename));
+        }
+    }
+    pxsim.throwFailedCastError = throwFailedCastError;
+    function throwFailedPropertyAccessError(value, propertyName) {
+        const typename = getType(value);
+        if (propertyName) {
+            throwTypeError(pxsim.localization.lf("Cannot read properties of {0} (reading '{1}')", typename, propertyName));
+        }
+        else {
+            throwTypeError(pxsim.localization.lf("Cannot read properties of {0}", typename));
+        }
+    }
+    pxsim.throwFailedPropertyAccessError = throwFailedPropertyAccessError;
+    function throwNullUndefinedAsObjectError() {
+        throwTypeError(pxsim.localization.lf("Cannot convert undefined or null to object"));
+    }
+    pxsim.throwNullUndefinedAsObjectError = throwNullUndefinedAsObjectError;
+    function getType(value) {
+        let typename;
+        const vtable = value === null || value === void 0 ? void 0 : value.vtable;
+        if (vtable) {
+            typename = vtable.name;
+        }
+        else if (value === null) {
+            typename = "null";
+        }
+        else if (value === undefined) {
+            typename = "undefined";
+        }
+        else if (value instanceof pxsim.RefCollection) {
+            typename = "Array";
+        }
+        else if (value instanceof pxsim.RefBuffer) {
+            typename = "Buffer";
+        }
+        else if (value instanceof pxsim.RefAction) {
+            typename = "function";
+        }
+        else {
+            typename = typeof value;
+        }
+        return typename;
+    }
     function setParentMuteState(state) {
         Runtime.postMessage({
             type: "setmutebuttonstate",

package/built/pxtcompiler.js

@@ -2640,15 +2640,17 @@ function ${id}(s) {
                         write(`r0 = ${emitExprInto(e)};`);
                 }
             }
+            function vTableRef(info) {
+                return `${info.id}_VT`;
+            }
             function checkSubtype(info, r0 = "r0") {
-                const vt = `${info.id}_VT`;
-                return `checkSubtype(${r0}, ${vt})`;
+                return `checkSubtype(${r0}, ${vTableRef(info)})`;
             }
             function emitInstanceOf(info, tp, r0 = "r0") {
                 if (tp == "bool")
                     write(`r0 = ${checkSubtype(info)};`);
                 else if (tp == "validate") {
-                    write(`if (!${checkSubtype(info, r0)}) failedCast(${r0});`);
+                    write(`if (!${checkSubtype(info, r0)}) failedCast(${r0}, ${vTableRef(info)});`);
                 }
                 else {
                     pxtc.U.oops();

package/built/pxtsim.d.ts

@@ -836,6 +836,7 @@ declare namespace pxsim {
         function pause(ms: number): void;
         function runInBackground(a: RefAction): void;
         function forever(a: RefAction): void;
+        function typeCheck(a: RefAction): void;
     }
 }
 declare namespace pxsim {
@@ -874,6 +875,7 @@ declare namespace pxsim {
         function setAt(c: RefCollection, x: number, y: any): void;
         function indexOf(c: RefCollection, x: any, start: number): number;
         function removeElement(c: RefCollection, x: any): 0 | 1;
+        function typeCheck(c: RefCollection): void;
     }
     namespace Math_ {
         const imul: (x: number, y: number) => number;
@@ -964,6 +966,7 @@ declare namespace pxsim {
         function indexOf(s: string, searchValue: string, start?: number): number;
         function lastIndexOf(s: string, searchValue: string, start?: number): number;
         function includes(s: string, searchValue: string, start?: number): boolean;
+        function typeCheck(s: string): void;
     }
     namespace Boolean_ {
         function toString(v: boolean): "true" | "false";
@@ -1017,6 +1020,7 @@ declare namespace pxsim {
         function shift(buf: RefBuffer, offset: number, start: number, len: number): void;
         function rotate(buf: RefBuffer, offset: number, start: number, len: number): void;
         function write(buf: RefBuffer, dstOffset: number, src: RefBuffer, srcOffset?: number, length?: number): void;
+        function typeCheck(buf: RefBuffer): void;
     }
 }
 declare namespace pxsim.control {
@@ -1308,6 +1312,11 @@ declare namespace pxsim {
         cleanScheduledExpired(): void;
         registerUserInteraction(): void;
     }
+    export function throwUserException(message: string): void;
+    export function throwTypeError(message: string): void;
+    export function throwFailedCastError(value: any, expectedType?: string): void;
+    export function throwFailedPropertyAccessError(value: any, propertyName?: string): void;
+    export function throwNullUndefinedAsObjectError(): void;
     export function setParentMuteState(state: "muted" | "unmuted" | "disabled"): void;
     export class PerfCounter {
         name: string;