rapydscript-ns 0.9.2 → 0.9.3

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) {
@@ -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);