rapydscript-ns 0.9.1 → 0.9.3

package/test/type_enforcement.pyj

@@ -0,0 +1,164 @@
+# vim:fileencoding=utf-8
+# Tests for from __python__ import type_enforcement
+# globals: assrt
+
+from __python__ import type_enforcement
+
+eq     = assrt.equal
+de     = assrt.deepEqual
+throws = assrt.throws
+ok     = assrt.ok
+
+def _err(fn):
+    """Call fn and return the TypeError message, or raise if no error."""
+    try:
+        fn()
+        raise AssertionError("Expected TypeError but none was raised")
+    except TypeError as e:
+        return e.message or str(e)
+
+# ---------------------------------------------------------------------------
+# 1. Max positional-arg count
+# ---------------------------------------------------------------------------
+
+def _fixed(a, b):
+    return a + b
+
+throws(def(): _fixed(1, 2, 3);, TypeError)
+eq(_fixed(1, 2), 3)
+
+# With defaults
+def _with_def(a, b=10):
+    return a + b
+
+throws(def(): _with_def(1, 2, 3);, TypeError)
+eq(_with_def(5), 15)
+eq(_with_def(5, 20), 25)
+
+# With *args: no max limit
+def _varargs(a, *rest):
+    return [a] + list(rest)
+
+de(_varargs(1, 2, 3), [1, 2, 3])
+
+# ---------------------------------------------------------------------------
+# 2. Missing required positional arg
+# ---------------------------------------------------------------------------
+
+msg = _err(def(): _fixed(1);)
+ok(msg.indexOf('missing required positional argument') >= 0)
+ok(msg.indexOf('b') >= 0)
+
+# Simple function (no defaults)
+def _simple(x):
+    return x * 2
+
+throws(def(): _simple();, TypeError)
+eq(_simple(7), 14)
+
+# Required arg can be provided as kwarg (valid for non-posonly)
+eq(_fixed(a=3, b=4), 7)
+
+# ---------------------------------------------------------------------------
+# 3. Positional-only enforcement
+# ---------------------------------------------------------------------------
+
+def _po(a, b, /):
+    return a - b
+
+eq(_po(10, 3), 7)
+throws(def(): _po(a=10, b=3);, TypeError)
+throws(def(): _po(b=3);, TypeError)
+
+# Mixed: posonly + normal
+def _mixed(x, /, y=5):
+    return x + y
+
+eq(_mixed(1), 6)
+eq(_mixed(1, y=10), 11)
+throws(def(): _mixed(x=1);, TypeError)
+
+# ---------------------------------------------------------------------------
+# 4. Keyword-only enforcement (bare *)
+# ---------------------------------------------------------------------------
+
+def _ko(a, *, b):
+    return a + b
+
+# b is required kwonly; must be passed as keyword
+eq(_ko(1, b=2), 3)
+throws(def(): _ko(1);, TypeError)   # b missing
+
+def _ko_opt(a, *, b=100):
+    return a + b
+
+eq(_ko_opt(1), 101)
+eq(_ko_opt(1, b=200), 201)
+
+# Cannot pass kwonly positionally (it goes to *args slot which doesn't exist here)
+# Passing positionally puts value into wrong position; enforce checks that b is set
+# In RapydScript, _ko(1, 2) passes 2 positionally but b is kwonly → b === undefined
+throws(def(): _ko(1, 2);, TypeError)
+
+# ---------------------------------------------------------------------------
+# 5. Positional-only + keyword-only combined
+# ---------------------------------------------------------------------------
+
+def _combo(a, b, /, c=1, *, d):
+    return a + b + c + d
+
+eq(_combo(1, 2, d=10), 14)
+eq(_combo(1, 2, c=3, d=10), 16)
+throws(def(): _combo(a=1, b=2, d=10);, TypeError)   # a is posonly
+throws(def(): _combo(1, 2);, TypeError)              # d is required kwonly
+
+# ---------------------------------------------------------------------------
+# 6. Type annotation enforcement
+# ---------------------------------------------------------------------------
+
+def _typed(x: int, y: str):
+    return str(x) + y
+
+eq(_typed(1, 'a'), '1a')
+throws(def(): _typed('bad', 'a');, TypeError)
+throws(def(): _typed(1, 42);, TypeError)
+
+# Type error message mentions the arg name
+msg = _err(def(): _typed('bad', 'ok');)
+ok(msg.indexOf("argument 'x' must be") >= 0)
+
+# Annotated with default: type checked when provided
+def _ann_def(n: int = 0):
+    return n + 1
+
+eq(_ann_def(), 1)
+eq(_ann_def(5), 6)
+throws(def(): _ann_def('five');, TypeError)
+
+# ---------------------------------------------------------------------------
+# 7. Class method enforcement
+# ---------------------------------------------------------------------------
+
+class Calc:
+    def add(self, a: int, b: int):
+        return a + b
+
+    def greet(self, name, /, *, loud=False):
+        return name.upper() if loud else name
+
+c = Calc()
+eq(c.add(3, 4), 7)
+throws(def(): c.add(3, 'x');, TypeError)       # b must be int
+throws(def(): c.add(3, 4, 5);, TypeError)      # too many args
+throws(def(): c.greet(name='Alice');, TypeError)  # name is posonly
+
+# ---------------------------------------------------------------------------
+# 8. Return annotation stored but not enforced (Python-compatible)
+# ---------------------------------------------------------------------------
+
+def _ret(x: int) -> int:
+    return x * 2
+
+eq(_ret(3), 6)
+# Return type is metadata only — no TypeError from returning wrong type
+# (this matches Python's own behaviour without beartype etc.)

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"\)\)/],
     },
 
     {
@@ -5227,6 +5227,72 @@ assrt.equal(fib(15), 610)
         },
     },
 
+    // ── Strict-mode var declarations ─────────────────────────────────────
+
+    {
+        name: "comprehension_unpack_var_declared",
+        description: "list comprehension with tuple unpacking declares var ρσ_unpack",
+        src: [
+            "# globals: assrt",
+            "pairs = [('a', 1), ('b', 2), ('c', 3)]",
+            "result = [v for k, v in pairs if k != 'b']",
+            "assrt.deepEqual(result, [1, 3])",
+        ].join("\n"),
+        js_checks: [/var\s[^;]*ρσ_unpack/],
+    },
+
+    {
+        name: "comprehension_unpack_nested_clauses",
+        description: "nested comprehension with tuple unpacking in inner clause declares ρσ_unpack",
+        src: [
+            "# globals: assrt",
+            "groups = [[(1, 'a'), (2, 'b')], [(3, 'c')]]",
+            "result = [s for row in groups for n, s in row]",
+            "assrt.deepEqual(result, ['a', 'b', 'c'])",
+        ].join("\n"),
+        js_checks: [/var\s[^;]*ρσ_unpack/],
+    },
+
+    {
+        name: "with_statement_scope_declared",
+        description: "with statement ρσ_with_exception/ρσ_with_suppress are scope-declared (not implicit globals)",
+        src: [
+            "# globals: assrt",
+            "class CM:",
+            "    def __init__(self):",
+            "        self.entered = False",
+            "        self.exited = False",
+            "    def __enter__(self):",
+            "        self.entered = True",
+            "        return self",
+            "    def __exit__(self, exc_type, exc_val, exc_tb):",
+            "        self.exited = True",
+            "        return False",
+            "with CM() as c:",
+            "    assrt.ok(c.entered)",
+            "assrt.ok(c.exited)",
+        ].join("\n"),
+        js_checks: [/let\s[^;]*ρσ_with_exception/, /let\s[^;]*ρσ_with_suppress/],
+    },
+
+    {
+        name: "with_statement_suppresses_exception",
+        description: "with statement __exit__ returning True suppresses the exception",
+        src: [
+            "# globals: assrt",
+            "class Suppressor:",
+            "    def __enter__(self):",
+            "        return self",
+            "    def __exit__(self, exc_type, exc_val, exc_tb):",
+            "        return True",
+            "caught = False",
+            "with Suppressor():",
+            "    raise ValueError('boom')",
+            "    caught = True  # should not reach",
+            "assrt.ok(not caught, 'line after raise should not execute')",
+        ].join("\n"),
+    },
+
 ];
 
 // ── Runner ───────────────────────────────────────────────────────────────────
@@ -5310,12 +5376,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 ────────────────────────────────────────────────
@@ -1254,6 +1258,121 @@ 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');
+            },
+        },
+
         {
             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) {
@@ -173,7 +188,7 @@ function make_tests(Diagnostics, RS, STDLIB_MODULES) {
             name: "undef_suppressed_extra_builtins",
             description: "extraBuiltins option prevents a name from being flagged",
             run: function () {
-                var inst = new Diagnostics(RS, { MY_GLOBAL: true, ANOTHER: true });
+                var inst = new Diagnostics(RS, ['MY_GLOBAL', 'ANOTHER']);
                 var markers = inst.check("print(MY_GLOBAL)\nprint(ANOTHER)");
                 assert.deepStrictEqual(markers, []);
             },
@@ -1467,6 +1482,115 @@ 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));
+            },
+        },
+
     ];
 
     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);