rapydscript-ns 0.8.0 → 0.8.2

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

@@ -0,0 +1,83 @@
+/*
+ * test/unit/language-service-bundle.js
+ *
+ * Verifies that the built web-repl/language-service.js can be loaded as an
+ * ES module without errors (e.g. duplicate top-level declarations).
+ *
+ * Usage:
+ *   node test/unit/language-service-bundle.js
+ */
+"use strict";
+
+var path   = require("path");
+var url    = require("url");
+var fs     = require("fs");
+var utils  = require("../../tools/utils");
+var colored = utils.safe_colored;
+
+var bundle_path = path.join(__dirname, "../../web-repl/language-service.js");
+
+if (!fs.existsSync(bundle_path)) {
+    console.error(colored("SKIP  language_service_bundle_loads", "yellow") +
+        "  –  web-repl/language-service.js not found; run: npm run build:ls");
+    process.exit(0);
+}
+
+var bundle_url = url.pathToFileURL(bundle_path).href;
+
+import(bundle_url).then(function (mod) {
+    var passed = 0;
+    var failed = 0;
+
+    function pass(name, desc) {
+        passed++;
+        console.log(colored("PASS  " + name, "green") + "  \u2013  " + desc);
+    }
+    function fail(name, desc, err) {
+        failed++;
+        console.log(colored("FAIL  " + name, "red") +
+            "  \u2013  " + desc + "\n      " + (err.message || String(err)));
+    }
+
+    // Test 1: module loads without parse/runtime errors (implicit — we got here)
+    pass("language_service_bundle_loads",
+        "web-repl/language-service.js loads as an ES module without errors");
+
+    // Test 2: registerRapydScript is exported
+    try {
+        if (typeof mod.registerRapydScript !== "function")
+            throw new Error("registerRapydScript is not a function, got: " + typeof mod.registerRapydScript);
+        pass("language_service_bundle_exports_register",
+            "registerRapydScript is exported as a function");
+    } catch (e) {
+        fail("language_service_bundle_exports_register",
+            "registerRapydScript is exported as a function", e);
+    }
+
+    // Test 3: web_repl is exported
+    try {
+        if (typeof mod.web_repl !== "function")
+            throw new Error("web_repl is not a function, got: " + typeof mod.web_repl);
+        pass("language_service_bundle_exports_web_repl",
+            "web_repl is exported as a function");
+    } catch (e) {
+        fail("language_service_bundle_exports_web_repl",
+            "web_repl is exported as a function", e);
+    }
+
+    console.log("");
+    if (failed) {
+        console.log(colored(failed + " test(s) failed.", "red"));
+        process.exit(1);
+    } else {
+        console.log(colored("All " + passed + " language-service-bundle tests passed!", "green"));
+    }
+
+}).catch(function (e) {
+    console.log(colored("FAIL  language_service_bundle_loads", "red") +
+        "  \u2013  web-repl/language-service.js failed to load as an ES module");
+    console.log("      " + (e.message || String(e)));
+    console.log("");
+    console.log(colored("1 test(s) failed.", "red"));
+    process.exit(1);
+});

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

@@ -26,6 +26,7 @@ var MockKind = {
     Class:     5,
     Variable:  6,
     Module:    8,
+    Keyword:   17,
 };
 
 // Mock Monaco position object
@@ -988,6 +989,114 @@ function make_tests(CompletionEngine, detect_context, SourceAnalyzer, DtsRegistr
             },
         },
 
+        // ── Keyword completions ───────────────────────────────────────────
+
+        {
+            name: "keywords_present_in_scope_completions",
+            description: "Control-flow keywords appear in identifier completions",
+            run: function () {
+                var engine = make_engine();
+                var list = engine.getCompletions(null, pos(1, 1), "", MockKind);
+                assert_has(list, 'continue', 'continue keyword');
+                assert_has(list, 'break',    'break keyword');
+                assert_has(list, 'return',   'return keyword');
+                assert_has(list, 'for',      'for keyword');
+                assert_has(list, 'while',    'while keyword');
+                assert_has(list, 'if',       'if keyword');
+                assert_has(list, 'def',      'def keyword');
+                assert_has(list, 'class',    'class keyword');
+                assert_has(list, 'try',      'try keyword');
+                assert_has(list, 'pass',     'pass keyword');
+                assert_has(list, 'yield',    'yield keyword');
+                assert_has(list, 'True',     'True keyword');
+                assert_has(list, 'False',    'False keyword');
+                assert_has(list, 'None',     'None keyword');
+            },
+        },
+
+        {
+            name: "keywords_prefix_filter",
+            description: "Prefix filter narrows keyword completions",
+            run: function () {
+                var engine = make_engine();
+                var list = engine.getCompletions(null, pos(1, 4), "con", MockKind);
+                assert_has(list,    'continue', 'continue matches con');
+                assert_missing(list,'break',    'break does not match con');
+                assert_missing(list,'return',   'return does not match con');
+            },
+        },
+
+        {
+            name: "keywords_have_keyword_kind",
+            description: "Keyword completion items use the Keyword kind",
+            run: function () {
+                var engine = make_engine();
+                var list = engine.getCompletions(null, pos(1, 4), "con", MockKind);
+                var item = find_item(list, 'continue');
+                assert.ok(item, 'continue should be in suggestions');
+                assert.strictEqual(item.kind, MockKind.Keyword, 'continue should have Keyword kind');
+            },
+        },
+
+        {
+            name: "keywords_sort_after_builtins",
+            description: "Keywords sort after builtins (sortText '3_' vs '2_')",
+            run: function () {
+                var engine = make_engine({}, ['for_builtin_test']);
+                var list = engine.getCompletions(null, pos(1, 1), "", MockKind);
+                var builtin_item = find_item(list, 'for_builtin_test');
+                var kw_item      = find_item(list, 'for');
+                assert.ok(builtin_item, 'builtin should be present');
+                assert.ok(kw_item,      'keyword should be present');
+                assert.ok(builtin_item.sortText < kw_item.sortText,
+                    'builtin sorts before keyword: ' + builtin_item.sortText + ' vs ' + kw_item.sortText);
+            },
+        },
+
+        {
+            name: "keywords_not_in_dot_completions",
+            description: "Keywords do not appear in dot (attribute) completions",
+            run: function () {
+                var engine = make_engine();
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze([
+                    "class Dog:",
+                    "    def bark(self): return 'woof'",
+                    "d = Dog()",
+                    "pass",
+                ].join("\n"), {});
+
+                var list = engine.getCompletions(scopeMap, pos(4, 1), "d.", MockKind);
+                assert_missing(list, 'continue', 'continue must not appear in dot completions');
+                assert_missing(list, 'return',   'return must not appear in dot completions');
+            },
+        },
+
+        {
+            name: "keywords_not_in_from_import_completions",
+            description: "Keywords do not appear in from X import completions",
+            run: function () {
+                var vf = { mymod: "def foo(): pass" };
+                var engine = make_engine(vf);
+                var list = engine.getCompletions(null, pos(1, 22), "from mymod import ", MockKind);
+                assert_missing(list, 'continue', 'continue must not appear in from-import completions');
+                assert_missing(list, 'return',   'return must not appear in from-import completions');
+            },
+        },
+
+        {
+            name: "keywords_deduplicated_from_builtins",
+            description: "Keywords that overlap with builtins are not duplicated",
+            run: function () {
+                // 'not', 'in', 'is' etc. are keywords; if any also appear as a builtin name
+                // they must not appear twice.
+                var engine = make_engine({}, ['True']);  // True is also a keyword
+                var list = engine.getCompletions(null, pos(1, 1), "", MockKind);
+                var true_items = list.suggestions.filter(function (s) { return s.label === 'True'; });
+                assert.strictEqual(true_items.length, 1, 'True should appear exactly once');
+            },
+        },
+
     ];
 
     return TESTS;

package/test/unit/language-service.js

@@ -242,7 +242,7 @@ function make_tests(Diagnostics, RS) {
 
         {
             name: "import_error_caught",
-            description: "An unresolvable import is caught and returned as a single Error marker",
+            description: "An unresolvable import produces a single Error marker (unused-import) when no module registry is configured",
             run: function () {
                 var markers = d().check("from nonexistent_lib_xyz import something");
                 assert.strictEqual(markers.length, 1);
@@ -250,6 +250,78 @@ function make_tests(Diagnostics, RS) {
             },
         },
 
+        // ── Bad-import squiggles ───────────────────────────────────────────
+
+        {
+            name: "bad_import_unknown_module",
+            description: "Importing from an unknown module produces a bad-import Error when a module registry is active",
+            run: function () {
+                var markers = d().check(
+                    "from typo_mod import foo\nprint(foo())",
+                    { virtualFiles: { mymod: "def foo(): return 1" } }
+                );
+                var bad = markers.filter(function (m) { return m.message.indexOf('Unknown module') !== -1; });
+                assert.ok(bad.length >= 1, "Expected at least one 'Unknown module' marker, got: " + JSON.stringify(markers));
+                assert.strictEqual(bad[0].severity, SEV_ERROR);
+                // Squiggle should point at the module name on line 1
+                assert.strictEqual(bad[0].startLineNumber, 1);
+            },
+        },
+
+        {
+            name: "bad_import_known_module_no_error",
+            description: "Importing from a registered module produces no bad-import error",
+            run: function () {
+                var markers = d().check(
+                    "from mymod import foo\nprint(foo())",
+                    { virtualFiles: { mymod: "def foo(): return 1" } }
+                );
+                var bad = markers.filter(function (m) { return m.message.indexOf('Unknown module') !== -1; });
+                assert.strictEqual(bad.length, 0, "Expected no 'Unknown module' marker for a known module");
+            },
+        },
+
+        {
+            name: "bad_import_no_registry_no_error",
+            description: "Unknown imports produce no bad-import error when no module registry is configured",
+            run: function () {
+                var markers = d().check("from anything import foo\nprint(foo())");
+                var bad = markers.filter(function (m) { return m.message.indexOf('Unknown module') !== -1; });
+                assert.strictEqual(bad.length, 0, "Expected no 'Unknown module' marker when no registry is configured");
+            },
+        },
+
+        {
+            name: "bad_import_squiggle_span",
+            description: "The bad-import squiggle covers the module name",
+            run: function () {
+                var markers = d().check(
+                    "from typo_mod import foo",
+                    { virtualFiles: { mymod: "def foo(): return 1" } }
+                );
+                var bad = markers.filter(function (m) { return m.message.indexOf('Unknown module') !== -1; });
+                assert.ok(bad.length >= 1, "Expected a bad-import marker");
+                var m = bad[0];
+                // 'typo_mod' appears after 'from ' (col 5, 1-indexed col 6)
+                assert.strictEqual(m.startColumn, 6, "startColumn should be 6 (start of 'typo_mod')");
+                // endColumn should cover all of 'typo_mod' (8 chars)
+                assert.ok(m.endColumn > m.startColumn, "endColumn should be past startColumn");
+            },
+        },
+
+        {
+            name: "bad_import_stdlib_registry",
+            description: "Importing from a registered stdlib module produces no bad-import error",
+            run: function () {
+                var markers = d().check(
+                    "from mathlib import sqrt",
+                    { stdlibFiles: { mathlib: "def sqrt(x): return x ** 0.5" } }
+                );
+                var bad = markers.filter(function (m) { return m.message.indexOf('Unknown module') !== -1; });
+                assert.strictEqual(bad.length, 0, "Expected no 'Unknown module' marker for a known stdlib module");
+            },
+        },
+
         // ── Semicolon warnings ────────────────────────────────────────────
 
         {
@@ -641,6 +713,56 @@ function make_tests(Diagnostics, RS) {
             },
         },
 
+        // ── Type annotations ──────────────────────────────────────────────
+
+        {
+            name: "annotated_assign_no_undef",
+            description: "Variable declared with type annotation (a: int = 5) is not flagged as undefined",
+            run: function () {
+                var markers = d().check([
+                    "async def main():",
+                    "    a: int = 5",
+                    "    a += 4",
+                ].join("\n"));
+                var undef = markers.filter(function (m) { return m.message.indexOf("Undefined symbol") !== -1; });
+                assert.deepStrictEqual(undef, [],
+                    "Expected no 'Undefined symbol' errors but got: " + JSON.stringify(undef));
+            },
+        },
+
+        {
+            name: "annotated_assign_used",
+            description: "Variable declared with type annotation is recognized as used when referenced",
+            run: function () {
+                var markers = d().check([
+                    "def foo():",
+                    "    x: str = 'hello'",
+                    "    return x",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors for annotated var used in same scope, got: " + JSON.stringify(errors));
+            },
+        },
+
+        {
+            name: "annotated_assign_compound_ops",
+            description: "All compound assignment operators work on annotated variables without undef errors",
+            run: function () {
+                var markers = d().check([
+                    "def bar():",
+                    "    n: int = 10",
+                    "    n += 1",
+                    "    n -= 1",
+                    "    n *= 2",
+                    "    return n",
+                ].join("\n"));
+                var undef = markers.filter(function (m) { return m.message.indexOf("Undefined symbol") !== -1; });
+                assert.deepStrictEqual(undef, [],
+                    "Expected no 'Undefined symbol' errors but got: " + JSON.stringify(undef));
+            },
+        },
+
     ];
 
     return TESTS;

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

@@ -24,6 +24,7 @@ var FILES = [
     "language-service-hover.js",
     "language-service-dts.js",
     "language-service-builtins.js",
+    "language-service-bundle.js",
     "web-repl.js",
 ];
 

package/tools/lint.js

@@ -33,7 +33,7 @@ var BUILTINS = Object.create(null);
  ' eval undefined arguments abs max min enumerate pow callable reversed sum' + 
  ' getattr isFinite setattr hasattr parseInt parseFloat options_object' +
  ' isNaN JSON Math list set list_wrap ρσ_modules require bool int bin' +
- ' float iter Error EvalError set_wrap RangeError ReferenceError SyntaxError' +
+ ' float iter Error EvalError set_wrap frozenset RangeError ReferenceError SyntaxError' +
  ' str TypeError URIError Exception AssertionError IndexError AttributeError KeyError' +
  ' ValueError ZeroDivisionError map hex filter zip dict dict_wrap UnicodeDecodeError HTMLCollection' +
  ' NodeList alert console Node Symbol NamedNodeMap ρσ_eslice ρσ_delslice Number' +

package/tools/self.js

@@ -91,7 +91,7 @@ function check_for_changes(base_path, src_path, signatures) {
 }
 
 
-function compile(src_path, lib_path, sources, source_hash, profile) {
+function compile(src_path, lib_path, sources, source_hash) {
     var file = path.join(src_path, 'compiler.pyj');
     var t1 = new Date().getTime();
     var RapydScript = require('./compiler').create_compiler();
@@ -116,15 +116,7 @@ function compile(src_path, lib_path, sources, source_hash, profile) {
 	}
 
     try {
-        if (profile) {
-            profiler = require('v8-profiler');
-            profiler.startProfiling();
-        }
         toplevel = parse_file(raw, file);
-        if (profile) {
-            cpu_profile = profiler.stopProfiling();
-            fs.writeFileSync('self.cpuprofile', JSON.stringify(cpu_profile), 'utf-8');
-        }
     } catch (e) {
         if (!(e instanceof RapydScript.SyntaxError)) throw e;
         console.error(e.toString());