rapydscript-ns 0.9.3 → 0.9.5

package/test/unit/index.js

@@ -2996,6 +2996,96 @@ assrt.equal(fib(15), 610)
         js_checks: ["ρσ_op_add(", "ρσ_op_sub(", "ρσ_op_or(", "ρσ_op_and("],
     },
 
+    {
+        name: "operator_dict_or",
+        description: "| on plain objects creates a new merged dict; numeric | still works",
+        src: [
+            "# globals: assrt",
+            "from __python__ import overload_operators",
+            "a = {'x': 1, 'y': 2}",
+            "b = {'z': 3}",
+            "c = a | b",
+            "assrt.deepEqual(c, {'x': 1, 'y': 2, 'z': 3})",
+            "assrt.notStrictEqual(c, a)",
+            "assrt.equal(5 | 3, 7)",
+        ].join("\n"),
+    },
+
+    {
+        name: "operator_dict_ior",
+        description: "|= on plain objects merges in-place",
+        src: [
+            "# globals: assrt",
+            "from __python__ import overload_operators",
+            "d = {'a': 1}",
+            "ref = d",
+            "d |= {'b': 2}",
+            "assrt.deepEqual(d, {'a': 1, 'b': 2})",
+            "assrt.strictEqual(d, ref)",
+        ].join("\n"),
+    },
+
+    {
+        name: "operator_dict_or_override",
+        description: "| on plain objects: right-hand values override left on key collision",
+        src: [
+            "# globals: assrt",
+            "from __python__ import overload_operators",
+            "a = {'x': 1, 'y': 2}",
+            "b = {'y': 99, 'z': 3}",
+            "c = a | b",
+            "assrt.equal(c['y'], 99)",
+            "assrt.equal(c['x'], 1)",
+            "assrt.equal(c['z'], 3)",
+        ].join("\n"),
+    },
+
+    {
+        name: "operator_type_error_bitwise",
+        description: "bitwise operators raise TypeError for invalid types",
+        src: [
+            "# globals: assrt",
+            "from __python__ import overload_operators",
+            "def check(fn, msg):",
+            "    try:",
+            "        fn()",
+            "        assrt.ok(False, 'expected TypeError for ' + msg)",
+            "    except TypeError:",
+            "        assrt.ok(True)",
+            'check(def(): "str" & 5;, "str & int")',
+            'check(def(): None | 5;, "None | int")',
+            'check(def(): "a" ^ 1;, "str ^ int")',
+            'check(def(): "a" << 1;, "str << int")',
+            'check(def(): "a" >> 1;, "str >> int")',
+            "assrt.equal(7 & 3, 3)",
+            "assrt.equal(1 | 2, 3)",
+            "assrt.equal(5 ^ 3, 6)",
+            "assrt.equal(1 << 3, 8)",
+            "assrt.equal(8 >> 2, 2)",
+        ].join("\n"),
+    },
+
+    {
+        name: "operator_type_error_unary",
+        description: "unary operators raise TypeError for invalid types",
+        src: [
+            "# globals: assrt",
+            "from __python__ import overload_operators",
+            "def check(fn, msg):",
+            "    try:",
+            "        fn()",
+            "        assrt.ok(False, 'expected TypeError for ' + msg)",
+            "    except TypeError:",
+            "        assrt.ok(True)",
+            'check(def(): -"hello";, "neg str")',
+            'check(def(): +None;, "pos None")',
+            'check(def(): ~"world";, "invert str")',
+            "assrt.equal(-5, -5)",
+            "assrt.equal(+3, 3)",
+            "assrt.equal(~0, -1)",
+        ].join("\n"),
+    },
+
     // ── nested comprehensions ──────────────────────────────────────────────
 
     {
@@ -5275,6 +5365,86 @@ assrt.equal(fib(15), 610)
         js_checks: [/let\s[^;]*ρσ_with_exception/, /let\s[^;]*ρσ_with_suppress/],
     },
 
+    // ── BigInt literals ────────────────────────────────────────────────────
+
+    {
+        name: "bigint_literal_basic",
+        description: "42n compiles to JS BigInt literal and has bigint type",
+        src: [
+            "# globals: assrt",
+            "x = 42n",
+            "assrt.ok(jstype(x) == 'bigint', 'type is bigint')",
+            "assrt.ok(x == 42n, 'value is 42n')",
+        ].join("\n"),
+        js_checks: ["42n"],
+    },
+
+    {
+        name: "bigint_literal_hex",
+        description: "0xFFn compiles to JS hex BigInt literal",
+        src: [
+            "# globals: assrt",
+            "x = 0xFFn",
+            "assrt.ok(x == 255n, 'hex bigint value')",
+        ].join("\n"),
+        js_checks: ["0xFFn"],
+    },
+
+    {
+        name: "bigint_literal_binary",
+        description: "0b1010n compiles to JS binary BigInt literal",
+        src: [
+            "# globals: assrt",
+            "x = 0b1010n",
+            "assrt.ok(x == 10n, 'binary bigint value')",
+        ].join("\n"),
+        js_checks: ["0b1010n"],
+    },
+
+    {
+        name: "bigint_literal_octal",
+        description: "0o77n compiles to JS octal BigInt literal",
+        src: [
+            "# globals: assrt",
+            "x = 0o77n",
+            "assrt.ok(x == 63n, 'octal bigint value')",
+        ].join("\n"),
+        js_checks: ["0o77n"],
+    },
+
+    {
+        name: "bigint_literal_zero",
+        description: "0n compiles and works",
+        src: [
+            "# globals: assrt",
+            "x = 0n",
+            "assrt.ok(jstype(x) == 'bigint', 'type is bigint')",
+            "assrt.ok(x == 0n, 'value is 0n')",
+        ].join("\n"),
+        js_checks: ["0n"],
+    },
+
+    {
+        name: "bigint_literal_arithmetic",
+        description: "BigInt arithmetic works correctly",
+        src: [
+            "# globals: assrt",
+            "x = 10n + 3n",
+            "assrt.ok(x == 13n, 'addition')",
+        ].join("\n"),
+    },
+
+    {
+        name: "bigint_literal_large",
+        description: "Large BigInt literal preserves precision",
+        src: [
+            "# globals: assrt",
+            "x = 999999999999999999999n",
+            "assrt.ok(x == 999999999999999999999n, 'large bigint')",
+        ].join("\n"),
+        js_checks: ["999999999999999999999n"],
+    },
+
     {
         name: "with_statement_suppresses_exception",
         description: "with statement __exit__ returning True suppresses the exception",
@@ -5293,6 +5463,291 @@ assrt.equal(fib(15), 610)
         ].join("\n"),
     },
 
+    // ── Exception.args ───────────────────────────────────────────────────────
+    {
+        name: "exception_args_single",
+        description: "Exception with single arg populates .args and .message",
+        src: [
+            "# globals: assrt",
+            "e = Exception('hello')",
+            "assrt.deepEqual(e.args, ['hello'])",
+            "assrt.equal(e.message, 'hello')",
+        ].join("\n"),
+    },
+    {
+        name: "exception_args_multiple",
+        description: "Exception with multiple args populates .args tuple",
+        src: [
+            "# globals: assrt",
+            "e = Exception('err', 42, 'extra')",
+            "assrt.deepEqual(e.args, ['err', 42, 'extra'])",
+            "assrt.equal(e.message, 'err')",
+            "assrt.equal(e.args[1], 42)",
+            "assrt.equal(e.args[2], 'extra')",
+        ].join("\n"),
+    },
+    {
+        name: "exception_args_empty",
+        description: "Exception with no args has empty .args and empty .message",
+        src: [
+            "# globals: assrt",
+            "e = Exception()",
+            "assrt.deepEqual(e.args, [])",
+            "assrt.equal(e.message, '')",
+        ].join("\n"),
+    },
+    {
+        name: "exception_args_subclass",
+        description: "Exception subclass inherits .args behavior",
+        src: [
+            "# globals: assrt",
+            "e = ValueError('bad', 'value')",
+            "assrt.deepEqual(e.args, ['bad', 'value'])",
+            "assrt.equal(e.message, 'bad')",
+            "assrt.ok(isinstance(e, ValueError))",
+            "assrt.ok(isinstance(e, Exception))",
+        ].join("\n"),
+    },
+    {
+        name: "exception_args_catch",
+        description: "Caught exception preserves .args",
+        src: [
+            "# globals: assrt",
+            "try:",
+            "    raise ValueError('oops', 123)",
+            "except ValueError as e:",
+            "    assrt.deepEqual(e.args, ['oops', 123])",
+            "    assrt.equal(e.message, 'oops')",
+            "    assrt.equal(e.args[1], 123)",
+        ].join("\n"),
+    },
+    {
+        name: "exception_args_len",
+        description: "len() works on exception .args",
+        src: [
+            "# globals: assrt",
+            "e = Exception('a', 'b', 'c')",
+            "assrt.equal(len(e.args), 3)",
+            "e2 = Exception()",
+            "assrt.equal(len(e2.args), 0)",
+        ].join("\n"),
+    },
+    {
+        name: "exception_args_exception_group",
+        description: "ExceptionGroup .args contains message and exceptions list",
+        src: [
+            "# globals: assrt",
+            "eg = ExceptionGroup('grp', [ValueError('v')])",
+            "assrt.equal(eg.args[0], 'grp')",
+            "assrt.equal(len(eg.args), 2)",
+            "assrt.equal(eg.message, 'grp')",
+            "assrt.ok(isinstance(eg.args[1][0], ValueError))",
+        ].join("\n"),
+    },
+    {
+        name: "exception_args_custom_class",
+        description: "Custom exception class with __init__ can use .args",
+        src: [
+            "# globals: assrt",
+            "class MyError(Exception):",
+            "    def __init__(self, code, detail):",
+            "        Exception.__init__(self, code, detail)",
+            "        self.code = code",
+            "        self.detail = detail",
+            "e = MyError(404, 'not found')",
+            "assrt.deepEqual(e.args, [404, 'not found'])",
+            "assrt.equal(e.code, 404)",
+            "assrt.equal(e.detail, 'not found')",
+            "assrt.equal(e.message, 404)",
+        ].join("\n"),
+    },
+
+    // ── __slots__ ─────────────────────────────────────────────────────────────
+    {
+        name: "slots_basic",
+        description: "__slots__ allows declared attributes",
+        src: [
+            "# globals: assrt",
+            "class Point:",
+            "    __slots__ = ['x', 'y']",
+            "    def __init__(self, x, y):",
+            "        self.x = x",
+            "        self.y = y",
+            "p = Point(1, 2)",
+            "assrt.equal(p.x, 1)",
+            "assrt.equal(p.y, 2)",
+            "p.x = 10",
+            "assrt.equal(p.x, 10)",
+        ].join("\n"),
+    },
+    {
+        name: "slots_raises_attributeerror",
+        description: "__slots__ raises AttributeError for undeclared attrs",
+        src: [
+            "# globals: assrt",
+            "class Point:",
+            "    __slots__ = ['x', 'y']",
+            "    def __init__(self, x, y):",
+            "        self.x = x",
+            "        self.y = y",
+            "p = Point(1, 2)",
+            "try:",
+            "    p.z = 3",
+            "    assrt.ok(False, 'should have raised')",
+            "except AttributeError as e:",
+            "    assrt.ok(str(e).indexOf('z') != -1)",
+        ].join("\n"),
+    },
+    {
+        name: "slots_inherited",
+        description: "Subclass with __slots__ merges parent slots",
+        src: [
+            "# globals: assrt",
+            "class Base:",
+            "    __slots__ = ['x']",
+            "    def __init__(self):",
+            "        self.x = 1",
+            "class Child(Base):",
+            "    __slots__ = ['y']",
+            "    def __init__(self):",
+            "        Base.__init__(self)",
+            "        self.y = 2",
+            "c = Child()",
+            "assrt.equal(c.x, 1)",
+            "assrt.equal(c.y, 2)",
+            "try:",
+            "    c.z = 3",
+            "    assrt.ok(False, 'should have raised')",
+            "except AttributeError:",
+            "    assrt.ok(True)",
+        ].join("\n"),
+    },
+    {
+        name: "slots_subclass_no_slots",
+        description: "Subclass without __slots__ is unrestricted",
+        src: [
+            "# globals: assrt",
+            "class Base:",
+            "    __slots__ = ['x']",
+            "    def __init__(self):",
+            "        self.x = 1",
+            "class Child(Base):",
+            "    def __init__(self):",
+            "        Base.__init__(self)",
+            "        self.y = 2",
+            "c = Child()",
+            "assrt.equal(c.x, 1)",
+            "assrt.equal(c.y, 2)",
+            "c.z = 3",
+            "assrt.equal(c.z, 3)",
+        ].join("\n"),
+    },
+    {
+        name: "slots_empty",
+        description: "__slots__ = [] allows no instance attributes",
+        src: [
+            "# globals: assrt",
+            "class Empty:",
+            "    __slots__ = []",
+            "    pass",
+            "e = Empty()",
+            "try:",
+            "    e.x = 1",
+            "    assrt.ok(False, 'should have raised')",
+            "except AttributeError:",
+            "    assrt.ok(True)",
+        ].join("\n"),
+    },
+    {
+        name: "slots_with_attr_dunders",
+        description: "__setattr__ takes priority over __slots__",
+        src: [
+            "# globals: assrt",
+            "class Tracked:",
+            "    __slots__ = ['x']",
+            "    def __init__(self):",
+            "        object.__setattr__(self, 'log', [])",
+            "        self.x = 1",
+            "    def __setattr__(self, name, value):",
+            "        self.log.append(name)",
+            "        object.__setattr__(self, name, value)",
+            "t = Tracked()",
+            "assrt.equal(t.x, 1)",
+            "assrt.ok(t.log.length > 0)",
+        ].join("\n"),
+    },
+
+    // ── Container pretty-printing ─────────────────────────────────────────────
+
+    {
+        name: "repr_list_pretty",
+        description: "repr/str of lists uses repr on elements (quotes strings, shows None/True)",
+        src: [
+            "# globals: assrt",
+            "assrt.equal(repr([1, 'hello', None, True]), \"[1, 'hello', None, True]\")",
+            "assrt.equal(str([1, 'hello', None, True]), \"[1, 'hello', None, True]\")",
+            "assrt.equal(repr([]), '[]')",
+            "assrt.equal(str([]), '[]')",
+        ].join("\n"),
+    },
+
+    {
+        name: "repr_dict_pretty",
+        description: "repr/str of dicts uses single-quoted keys and values",
+        src: [
+            "# globals: assrt",
+            "d = dict()",
+            "d.set('key', 'val')",
+            "assrt.equal(repr(d), \"{'key': 'val'}\")",
+            "assrt.equal(str(d), \"{'key': 'val'}\")",
+        ].join("\n"),
+    },
+
+    {
+        name: "repr_set_pretty",
+        description: "repr/str of sets uses repr on elements",
+        src: [
+            "# globals: assrt",
+            "s = {1, 'two'}",
+            "r = repr(s)",
+            "assrt.ok(r.indexOf(\"'two'\") >= 0, 'set repr should quote strings')",
+            "assrt.ok(r.indexOf('1') >= 0, 'set repr should include numbers')",
+            "assrt.ok(r[0] is '{' and r[r.length-1] is '}', 'set repr uses braces')",
+        ].join("\n"),
+    },
+
+    {
+        name: "repr_nested_containers",
+        description: "repr handles nested containers correctly",
+        src: [
+            "# globals: assrt",
+            "assrt.equal(repr([[1], [2, 3]]), '[[1], [2, 3]]')",
+            "assrt.equal(repr([None, True, False]), '[None, True, False]')",
+        ].join("\n"),
+    },
+
+    {
+        name: "repr_string_single_quotes",
+        description: "repr of strings uses Python-style single quotes",
+        src: [
+            "# globals: assrt",
+            "assrt.equal(repr('hello'), \"'hello'\")",
+            "assrt.equal(repr(''), \"''\")",
+        ].join("\n"),
+    },
+
+    {
+        name: "repr_frozenset_pretty",
+        description: "repr/str of frozenset uses repr on elements",
+        src: [
+            "# globals: assrt",
+            "fs = frozenset([1, 'x'])",
+            "r = repr(fs)",
+            "assrt.ok(r.indexOf('frozenset(') is 0, 'starts with frozenset(')",
+            "assrt.ok(r.indexOf(\"'x'\") >= 0, 'frozenset repr should quote strings')",
+        ].join("\n"),
+    },
+
 ];
 
 // ── Runner ───────────────────────────────────────────────────────────────────

package/test/unit/language-service-completions.js

@@ -969,6 +969,7 @@ function make_tests(CompletionEngine, detect_context, SourceAnalyzer, DtsRegistr
                 assert_has(list, 'Counter',     'Counter in collections completions');
                 assert_has(list, 'OrderedDict', 'OrderedDict in collections completions');
                 assert_has(list, 'defaultdict', 'defaultdict in collections completions');
+                assert_has(list, 'ChainMap',    'ChainMap in collections completions');
             },
         },
 
@@ -1370,6 +1371,7 @@ function make_tests(CompletionEngine, detect_context, SourceAnalyzer, DtsRegistr
                 assert_has(list, 'Counter',     'Counter from collections');
                 assert_has(list, 'OrderedDict', 'OrderedDict from collections');
                 assert_has(list, 'defaultdict', 'defaultdict from collections');
+                assert_has(list, 'ChainMap',    'ChainMap from collections');
             },
         },
 

package/test/unit/language-service-dts.js

@@ -458,6 +458,119 @@ function make_tests(parse_dts, DtsRegistry, TypeInfo) {
             },
         },
 
+        // ── Interface extends ─────────────────────────────────────────────
+
+        {
+            name: "parse_interface_extends",
+            description: "interface extends clause is parsed into extends_names",
+            run: function () {
+                var src = [
+                    "interface Animal {",
+                    "    name: string;",
+                    "}",
+                    "interface Dog extends Animal {",
+                    "    breed: string;",
+                    "}",
+                ].join("\n");
+                var types = parse_dts(src);
+                assert.strictEqual(types.length, 2);
+                var dog = types[1];
+                assert.strictEqual(dog.name, "Dog");
+                assert.ok(dog.extends_names, "should have extends_names");
+                assert.deepStrictEqual(dog.extends_names, ["Animal"]);
+                // Animal should have no extends_names
+                assert.strictEqual(types[0].extends_names, null);
+            },
+        },
+
+        {
+            name: "parse_interface_extends_multiple",
+            description: "interface extends multiple parents parsed correctly",
+            run: function () {
+                var src = [
+                    "interface A { a: number; }",
+                    "interface B { b: string; }",
+                    "interface C extends A, B {",
+                    "    c: boolean;",
+                    "}",
+                ].join("\n");
+                var types = parse_dts(src);
+                var c = types.find(function (t) { return t.name === "C"; });
+                assert.ok(c, "should find C");
+                assert.deepStrictEqual(c.extends_names, ["A", "B"]);
+            },
+        },
+
+        {
+            name: "registry_getAllMembers_inherits",
+            description: "getAllMembers includes inherited members",
+            run: function () {
+                var reg = new DtsRegistry();
+                reg.addDts("test", [
+                    "interface Person {",
+                    "    name: string;",
+                    "    age: number;",
+                    "}",
+                    "interface Player extends Person {",
+                    "    score: number;",
+                    "}",
+                ].join("\n"));
+                var player = reg.getGlobal("Player");
+                var all = reg.getAllMembers(player);
+                assert.ok(all.has("score"), "should have own member score");
+                assert.ok(all.has("name"),  "should have inherited member name");
+                assert.ok(all.has("age"),   "should have inherited member age");
+                assert.strictEqual(all.size, 3);
+            },
+        },
+
+        {
+            name: "registry_getAllMembers_override",
+            description: "child members shadow parent members",
+            run: function () {
+                var reg = new DtsRegistry();
+                reg.addDts("test", [
+                    "interface Base {",
+                    "    value: string;",
+                    "    info(): string;",
+                    "}",
+                    "interface Child extends Base {",
+                    "    value: number;",
+                    "}",
+                ].join("\n"));
+                var child = reg.getGlobal("Child");
+                var all = reg.getAllMembers(child);
+                assert.strictEqual(all.get("value").return_type, "number",
+                    "child value should override parent");
+                assert.ok(all.has("info"), "should inherit info");
+            },
+        },
+
+        {
+            name: "registry_getMemberInfo_inherits",
+            description: "getMemberInfo finds inherited members",
+            run: function () {
+                var reg = new DtsRegistry();
+                reg.addDts("test", [
+                    "interface Person {",
+                    "    city: string;",
+                    "}",
+                    "interface Player extends Person {",
+                    "    score: number;",
+                    "}",
+                    "declare var player: Player;",
+                ].join("\n"));
+                // Direct member
+                var score = reg.getMemberInfo("player", "score");
+                assert.ok(score, "should find direct member score");
+                assert.strictEqual(score.return_type, "number");
+                // Inherited member
+                var city = reg.getMemberInfo("player", "city");
+                assert.ok(city, "should find inherited member city");
+                assert.strictEqual(city.return_type, "string");
+            },
+        },
+
     ];
 
     return TESTS;