rapydscript-ns 0.9.2 → 0.9.4

package/test/unit/index.js

@@ -1831,13 +1831,13 @@ assrt.equal(fib(15), 610)
 
     {
         name: "print_compiles_to_console_log",
-        description: "print(x) compiles directly to console.log(x)",
+        description: "print(x) compiles to console.log(ρσ_str(x)) for Python-style string conversion",
         src: [
             "# globals: assrt",
             "print('hello')",
             "print(1, 2, 3)",
         ].join("\n"),
-        js_checks: ["console.log(\"hello\")", "console.log(1, 2, 3)"],
+        js_checks: ["console.log(ρσ_str(\"hello\"))", "console.log(ρσ_str(1), ρσ_str(2), ρσ_str(3))"],
     },
 
     {
@@ -1883,7 +1883,7 @@ assrt.equal(fib(15), 610)
             "print('test')",
         ].join("\n"),
         // The compiled JS must NOT contain 'var print = ' (which would overwrite window.print)
-        js_checks: [/console\.log\("test"\)/],
+        js_checks: [/console\.log\(ρσ_str\("test"\)\)/],
     },
 
     {
@@ -5275,6 +5275,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",
@@ -5376,12 +5456,20 @@ function run_tests(filter) {
                     "  –  " + test.description);
     });
 
+    var passed = tests.length - failures.length;
     console.log("");
     if (failures.length) {
-        console.log(colored(failures.length + " test(s) failed.", "red"));
-    } else {
-        console.log(colored("All " + tests.length + " unit tests passed!", "green"));
+        console.log(colored("Failed tests:", "red"));
+        failures.forEach(function (name) {
+            console.log(colored("  ✗ " + name, "red"));
+        });
+        console.log("");
     }
+    var summary = "unit tests — " +
+        colored("passed: " + passed, "green") + "  " +
+        (failures.length ? colored("failed: " + failures.length, "red") : colored("failed: 0", "green")) +
+        "  total: " + tests.length;
+    console.log(summary);
     process.exit(failures.length ? 1 : 0);
 }
 

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

@@ -87,6 +87,10 @@ function make_tests(CompletionEngine, detect_context, SourceAnalyzer, DtsRegistr
         require('path').join(__dirname, '../../src/lib/collections.pyj'), 'utf-8'
     );
 
+    var RE_SRC = require('fs').readFileSync(
+        require('path').join(__dirname, '../../src/lib/re.pyj'), 'utf-8'
+    );
+
     var TESTS = [
 
         // ── detect_context ────────────────────────────────────────────────
@@ -965,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');
             },
         },
 
@@ -1254,6 +1259,122 @@ function make_tests(CompletionEngine, detect_context, SourceAnalyzer, DtsRegistr
             },
         },
 
+        // ── Bare import dot completions (import X; X.attr) ──────────────
+
+        {
+            name: "bare_import_virtual_dot_completions",
+            description: "import mymod; mymod. shows module-level symbols from virtual file",
+            run: function () {
+                var vf = {
+                    mymod: [
+                        "def foo():",
+                        "    return 1",
+                        "def bar():",
+                        "    return 2",
+                        "BAZ = 42",
+                    ].join("\n"),
+                };
+                var engine = make_engine(vf);
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze("import mymod\npass", { virtualFiles: vf });
+                var list = engine.getCompletions(scopeMap, pos(2, 7), "mymod.", MockKind);
+                assert_has(list, 'foo', 'foo from virtual module');
+                assert_has(list, 'bar', 'bar from virtual module');
+                assert_has(list, 'BAZ', 'BAZ from virtual module');
+            },
+        },
+
+        {
+            name: "bare_import_virtual_dot_prefix",
+            description: "import mymod; mymod.f filters completions by prefix",
+            run: function () {
+                var vf = {
+                    mymod: "def foo():\n    return 1\ndef bar():\n    return 2",
+                };
+                var engine = make_engine(vf);
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze("import mymod\npass", { virtualFiles: vf });
+                var list = engine.getCompletions(scopeMap, pos(2, 8), "mymod.f", MockKind);
+                assert_has(list,    'foo', 'foo matches prefix f');
+                assert_missing(list,'bar', 'bar does not match prefix f');
+            },
+        },
+
+        {
+            name: "bare_import_re_dot_completions",
+            description: "import re; re. shows re module exports via stdlibFiles",
+            run: function () {
+                var engine = make_engine({}, ['print', 'len', 'range'], null, null, { re: RE_SRC });
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze("import re\npass", { virtualFiles: { re: RE_SRC } });
+                var list = engine.getCompletions(scopeMap, pos(2, 4), "re.", MockKind);
+                assert_has(list, 'match',   'match from re module');
+                assert_has(list, 'search',  'search from re module');
+                assert_has(list, 'compile', 'compile from re module');
+                assert_has(list, 'sub',     'sub from re module');
+                assert_has(list, 'findall', 'findall from re module');
+                assert_has(list, 'split',   'split from re module');
+            },
+        },
+
+        {
+            name: "bare_import_re_dot_prefix",
+            description: "import re; re.ma filters to matching names like match",
+            run: function () {
+                var engine = make_engine({}, ['print', 'len', 'range'], null, null, { re: RE_SRC });
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze("import re\npass", { virtualFiles: { re: RE_SRC } });
+                var list = engine.getCompletions(scopeMap, pos(2, 6), "re.ma", MockKind);
+                assert_has(list,    'match',   'match matches prefix ma');
+                assert_missing(list,'compile', 'compile does not match prefix ma');
+            },
+        },
+
+        {
+            name: "bare_import_alias_dot_completions",
+            description: "import mymod as mm; mm. shows module-level symbols",
+            run: function () {
+                var vf = {
+                    mymod: "def foo():\n    return 1\nVAL = 10",
+                };
+                var engine = make_engine(vf);
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze("import mymod as mm\npass", { virtualFiles: vf });
+                var list = engine.getCompletions(scopeMap, pos(2, 4), "mm.", MockKind);
+                assert_has(list, 'foo', 'foo from aliased module');
+                assert_has(list, 'VAL', 'VAL from aliased module');
+            },
+        },
+
+        {
+            name: "bare_import_unknown_module_empty",
+            description: "import unknown; unknown. returns empty when module source unavailable",
+            run: function () {
+                var engine = make_engine({});
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze("import unknown\npass", {});
+                var list = engine.getCompletions(scopeMap, pos(2, 9), "unknown.", MockKind);
+                assert.strictEqual(list.suggestions.length, 0, 'unknown module → no dot suggestions');
+            },
+        },
+
+        {
+            name: "bare_import_collections_dot_completions",
+            description: "import collections; collections. shows namedtuple, deque, Counter, etc.",
+            run: function () {
+                var engine = make_engine({}, ['print', 'len', 'range'], null, null, { collections: COLLECTIONS_SRC });
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze("import collections\npass", { virtualFiles: { collections: COLLECTIONS_SRC } });
+                var list = engine.getCompletions(scopeMap, pos(2, 13), "collections.", MockKind);
+                assert_has(list, 'namedtuple',  'namedtuple from collections');
+                assert_has(list, 'deque',       'deque from collections');
+                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');
+            },
+        },
+
         {
             name: "return_type_imported_fn_inferred_consistent_branches",
             description: "imported fn with multiple return [] branches — type still inferred as list",

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

@@ -613,6 +613,38 @@ function make_tests(SourceAnalyzer, RS) {
             },
         },
 
+        {
+            name: "async_generator_local_var_visible",
+            description: "Inside `async def` with `yield`, local vars are tracked in scope",
+            run: function () {
+                // Async generators (async def + yield) should not break scope analysis.
+                // Local assignments should be picked up the same as in regular functions.
+                var m = analyze([
+                    "async def aiter():",
+                    "    counter = 0",
+                    "    yield counter",
+                    "    counter += 1",
+                    "    yield counter",
+                ].join("\n"));
+                var sym = find(m.getAllSymbols(), "counter");
+                assert.ok(sym, "Expected 'counter' symbol in async-generator scope");
+            },
+        },
+
+        {
+            name: "async_for_loop_var_visible",
+            description: "`async for x in ...` loop variable is registered in scope",
+            run: function () {
+                var m = analyze([
+                    "async def consume(it):",
+                    "    async for item in it:",
+                    "        print(item)",
+                ].join("\n"));
+                var sym = find(m.getAllSymbols(), "item");
+                assert.ok(sym, "Expected 'item' loop variable in async-for scope");
+            },
+        },
+
         {
             name: "inferred_class_no_inference_for_variable_rhs",
             description: "x = some_var does not set inferred_class (unknown rhs)",

package/test/unit/language-service.js

@@ -61,12 +61,27 @@ var LIB_DIR = path.join(__dirname, "../../src/lib");
 
 /**
  * Return the module names of all .pyj files currently in src/lib/.
+ * Also includes sub-package directory names that contain an __init__.pyj.
  * Excludes cache files (.pyj-cached) and any non-.pyj entries.
  */
 function get_lib_module_names() {
-    return fs.readdirSync(LIB_DIR)
-        .filter(function (f) { return f.endsWith(".pyj") && !f.endsWith(".pyj-cached"); })
-        .map(function (f) { return f.replace(/\.pyj$/, ""); });
+    var names = [];
+    fs.readdirSync(LIB_DIR).forEach(function (f) {
+        if (f.endsWith(".pyj-cached")) return;
+        if (f.endsWith(".pyj")) {
+            names.push(f.replace(/\.pyj$/, ""));
+        } else {
+            // Directory with __init__.pyj counts as a package module.
+            var full = path.join(LIB_DIR, f);
+            try {
+                var stat = fs.statSync(full);
+                if (stat.isDirectory() && fs.existsSync(path.join(full, "__init__.pyj"))) {
+                    names.push(f);
+                }
+            } catch (e) {}
+        }
+    });
+    return names;
 }
 
 function make_tests(Diagnostics, RS, STDLIB_MODULES) {
@@ -885,13 +900,14 @@ function make_tests(Diagnostics, RS, STDLIB_MODULES) {
             description: "Importing all collections classes produces no errors",
             run: function () {
                 var markers = d().check([
-                    "from collections import defaultdict, Counter, OrderedDict, deque, namedtuple",
+                    "from collections import defaultdict, Counter, OrderedDict, deque, namedtuple, ChainMap",
                     "d = defaultdict(list)",
                     "c = Counter([1, 2, 2, 3])",
                     "od = OrderedDict()",
                     "dq = deque([1, 2, 3])",
                     "Point = namedtuple('Point', 'x y')",
-                    "print(d, c, od, dq, Point)",
+                    "cm = ChainMap({'a': 1}, {'b': 2})",
+                    "print(d, c, od, dq, Point, cm)",
                 ].join("\n"),
                     { virtualFiles: { mymod: "def foo(): pass" } }
                 );
@@ -915,6 +931,36 @@ function make_tests(Diagnostics, RS, STDLIB_MODULES) {
             },
         },
 
+        {
+            name: "stdlib_statistics_no_bad_import",
+            description: "Importing and using statistics functions produces no errors",
+            run: function () {
+                var markers = d().check([
+                    "from statistics import mean, median, mode, stdev, variance",
+                    "from statistics import quantiles, correlation, linear_regression",
+                    "from statistics import NormalDist, StatisticsError",
+                    "data = [1, 2, 3, 4, 5]",
+                    "m = mean(data)",
+                    "md = median(data)",
+                    "mo = mode(data)",
+                    "sd = stdev(data)",
+                    "v = variance(data)",
+                    "q = quantiles(data)",
+                    "c = correlation(data, data)",
+                    "lr = linear_regression(data, data)",
+                    "nd = NormalDist(0, 1)",
+                    "print(m, md, mo, sd, v, q, c, lr.slope, lr.intercept)",
+                    "print(nd.mean, nd.stdev, nd.cdf(0), nd.pdf(0), StatisticsError)",
+                ].join("\n"),
+                    { virtualFiles: { sentinel: "x = 1" } }
+                );
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors for statistics imports and usage, got: " +
+                    JSON.stringify(errors.map(function (m) { return m.message; })));
+            },
+        },
+
         {
             name: "copy_no_bad_import",
             description: "from copy import copy, deepcopy produces no bad-import error",
@@ -1467,6 +1513,145 @@ function make_tests(Diagnostics, RS, STDLIB_MODULES) {
             },
         },
 
+        // ── Infinite-loop detection ───────────────────────────────────────
+
+        {
+            name: "infinite_loop_while_true",
+            description: "while True: with no await inside is flagged as a warning",
+            run: function () {
+                var markers = d().check([
+                    "while True:",
+                    "    x = 1",
+                ].join("\n"));
+                var warnings = markers.filter(function (m) {
+                    return m.severity === SEV_WARNING &&
+                           m.message.indexOf("while loop") !== -1;
+                });
+                assert.ok(warnings.length >= 1,
+                    "Expected an infinite-loop warning but got: " + JSON.stringify(markers));
+            },
+        },
+
+        {
+            name: "infinite_loop_while_1",
+            description: "while 1: with no await inside is flagged as a warning",
+            run: function () {
+                var markers = d().check([
+                    "while 1:",
+                    "    pass",
+                ].join("\n"));
+                var warnings = markers.filter(function (m) {
+                    return m.severity === SEV_WARNING &&
+                           m.message.indexOf("while loop") !== -1;
+                });
+                assert.ok(warnings.length >= 1,
+                    "Expected an infinite-loop warning for while 1: but got: " + JSON.stringify(markers));
+            },
+        },
+
+        {
+            name: "infinite_loop_suppressed_by_await",
+            description: "while True: containing an await does NOT produce a warning",
+            run: function () {
+                var markers = d().check([
+                    "async def run():",
+                    "    while True:",
+                    "        await some_task()",
+                ].join("\n"));
+                var inf = markers.filter(function (m) {
+                    return m.message.indexOf("while loop") !== -1;
+                });
+                assert.deepStrictEqual(inf, [],
+                    "Expected no infinite-loop warning when await is present but got: " + JSON.stringify(inf));
+            },
+        },
+
+        {
+            name: "async_generator_no_diagnostics",
+            description: "async def with yield (async generator) parses cleanly with no syntax errors",
+            run: function () {
+                var markers = d().check([
+                    "async def aiter():",
+                    "    yield 1",
+                    "    yield 2",
+                    "",
+                    "async def consume():",
+                    "    out = []",
+                    "    async for x in aiter():",
+                    "        out.append(x)",
+                    "    return out",
+                ].join("\n"));
+                var errs = markers.filter(function (m) { return m.severity === 1 || m.severity === 8; });
+                assert.deepStrictEqual(errs, [],
+                    "Expected no syntax errors for async generator + async for, got: " + JSON.stringify(errs));
+            },
+        },
+
+        {
+            name: "async_generator_local_no_undef",
+            description: "Local vars inside an async generator (with `await` and `yield`) resolve correctly",
+            run: function () {
+                var markers = d().check([
+                    "async def stream():",
+                    "    n = await Promise.resolve(3)",
+                    "    i = 0",
+                    "    while i < n:",
+                    "        yield i",
+                    "        i += 1",
+                ].join("\n"));
+                var undef = markers.filter(function (m) { return m.message.indexOf("Undefined symbol") !== -1; });
+                assert.deepStrictEqual(undef, [],
+                    "Expected no 'Undefined symbol' errors in async generator, got: " + JSON.stringify(undef));
+            },
+        },
+
+        {
+            name: "infinite_loop_no_false_positive_for_condition",
+            description: "while x > 0: (non-constant condition) does not produce a warning",
+            run: function () {
+                var markers = d().check([
+                    "x = 10",
+                    "while x > 0:",
+                    "    x -= 1",
+                ].join("\n"));
+                var inf = markers.filter(function (m) {
+                    return m.message.indexOf("while loop") !== -1;
+                });
+                assert.deepStrictEqual(inf, [],
+                    "Expected no infinite-loop warning for non-constant condition but got: " + JSON.stringify(inf));
+            },
+        },
+
+        // ── BigInt literals ──────────────────────────────────────────────
+
+        {
+            name: "bigint_literal_no_errors",
+            description: "BigInt literals (42n, 0xFFn, 0b1010n, 0o77n) produce no markers",
+            run: function () {
+                var markers = d().check([
+                    "x = 42n",
+                    "y = 0xFFn",
+                    "z = 0b1010n",
+                    "w = 0o77n",
+                ].join("\n"));
+                assert.deepStrictEqual(markers, [],
+                    "Expected no markers for bigint literals, got: " + JSON.stringify(markers));
+            },
+        },
+
+        {
+            name: "bigint_literal_assignment_no_errors",
+            description: "BigInt literal assignment and arithmetic produce no markers",
+            run: function () {
+                var markers = d().check([
+                    "x = 42n",
+                    "y = x + 1n",
+                ].join("\n"));
+                assert.deepStrictEqual(markers, [],
+                    "Expected no markers for bigint assignment, got: " + JSON.stringify(markers));
+            },
+        },
+
     ];
 
     return TESTS;

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

@@ -29,7 +29,7 @@ var FILES = [
     "web-repl.js",
 ];
 
-var failed = false;
+var failed_files = [];
 
 FILES.forEach(function (file) {
     var result = spawn(
@@ -37,7 +37,21 @@ FILES.forEach(function (file) {
         [path.join(__dirname, file)],
         { stdio: "inherit" }
     );
-    if (result.status !== 0) failed = true;
+    if (result.status !== 0) failed_files.push(file);
 });
 
-process.exit(failed ? 1 : 0);
+console.log("");
+if (failed_files.length) {
+    console.log(colored("Failed test files:", "red"));
+    failed_files.forEach(function (file) {
+        console.log(colored("  ✗ " + file, "red"));
+    });
+    console.log("");
+}
+var passed_count = FILES.length - failed_files.length;
+var summary = "test suites — " +
+    colored("passed: " + passed_count, "green") + "  " +
+    (failed_files.length ? colored("failed: " + failed_files.length, "red") : colored("failed: 0", "green")) +
+    "  total: " + FILES.length;
+console.log(summary);
+process.exit(failed_files.length ? 1 : 0);