rapydscript-ns 0.8.1 → 0.8.3

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

@@ -770,6 +770,261 @@ function make_tests(SourceAnalyzer, RS) {
             },
         },
 
+        // ── Return type inference ─────────────────────────────────────────
+
+        {
+            name: "infer_return_type_list_literal",
+            description: "return [] infers return_type = 'list'",
+            run: function () {
+                var m = analyze("def get_items():\n    return []");
+                var sym = find(m.getAllSymbols(), "get_items");
+                assert.ok(sym, "Expected 'get_items' symbol");
+                assert.strictEqual(sym.return_type, "list",
+                    "Expected return_type 'list', got: " + sym.return_type);
+            },
+        },
+
+        {
+            name: "infer_return_type_dict_literal",
+            description: "return {} infers return_type = 'dict'",
+            run: function () {
+                var m = analyze("def get_map():\n    return {}");
+                var sym = find(m.getAllSymbols(), "get_map");
+                assert.ok(sym, "Expected 'get_map' symbol");
+                assert.strictEqual(sym.return_type, "dict",
+                    "Expected return_type 'dict', got: " + sym.return_type);
+            },
+        },
+
+        {
+            name: "infer_return_type_string_literal",
+            description: "return 'hello' infers return_type = 'str'",
+            run: function () {
+                var m = analyze("def get_name():\n    return 'hello'");
+                var sym = find(m.getAllSymbols(), "get_name");
+                assert.ok(sym, "Expected 'get_name' symbol");
+                assert.strictEqual(sym.return_type, "str",
+                    "Expected return_type 'str', got: " + sym.return_type);
+            },
+        },
+
+        {
+            name: "infer_return_type_number_literal",
+            description: "return 42 infers return_type = 'number'",
+            run: function () {
+                var m = analyze("def get_count():\n    return 42");
+                var sym = find(m.getAllSymbols(), "get_count");
+                assert.ok(sym, "Expected 'get_count' symbol");
+                assert.strictEqual(sym.return_type, "number",
+                    "Expected return_type 'number', got: " + sym.return_type);
+            },
+        },
+
+        {
+            name: "infer_return_type_bool_literal",
+            description: "return True infers return_type = 'bool'",
+            run: function () {
+                var m = analyze("def is_valid():\n    return True");
+                var sym = find(m.getAllSymbols(), "is_valid");
+                assert.ok(sym, "Expected 'is_valid' symbol");
+                assert.strictEqual(sym.return_type, "bool",
+                    "Expected return_type 'bool', got: " + sym.return_type);
+            },
+        },
+
+        {
+            name: "infer_return_type_constructor_call",
+            description: "return MyClass() infers return_type = 'MyClass'",
+            run: function () {
+                var m = analyze([
+                    "class MyClass:",
+                    "    def __init__(self):",
+                    "        pass",
+                    "def make():",
+                    "    return MyClass()",
+                ].join("\n"));
+                var sym = find(m.getAllSymbols(), "make");
+                assert.ok(sym, "Expected 'make' symbol");
+                assert.strictEqual(sym.return_type, "MyClass",
+                    "Expected return_type 'MyClass', got: " + sym.return_type);
+            },
+        },
+
+        {
+            name: "infer_return_type_local_variable",
+            description: "return local_var infers type from local variable's inferred_class",
+            run: function () {
+                var m = analyze([
+                    "def get_items():",
+                    "    result = []",
+                    "    return result",
+                ].join("\n"));
+                var sym = find(m.getAllSymbols(), "get_items");
+                assert.ok(sym, "Expected 'get_items' symbol");
+                assert.strictEqual(sym.return_type, "list",
+                    "Expected return_type 'list' via local var, got: " + sym.return_type);
+            },
+        },
+
+        {
+            name: "infer_return_type_consistent_multiple_returns",
+            description: "Multiple returns of the same type still infer correctly",
+            run: function () {
+                var m = analyze([
+                    "def get_name(flag):",
+                    "    if flag:",
+                    "        return 'yes'",
+                    "    return 'no'",
+                ].join("\n"));
+                var sym = find(m.getAllSymbols(), "get_name");
+                assert.ok(sym, "Expected 'get_name' symbol");
+                assert.strictEqual(sym.return_type, "str",
+                    "Expected return_type 'str' for consistent returns, got: " + sym.return_type);
+            },
+        },
+
+        {
+            name: "infer_return_type_mixed_returns_no_inference",
+            description: "Mixed return types produce no inference (return_type stays null)",
+            run: function () {
+                var m = analyze([
+                    "def ambiguous(flag):",
+                    "    if flag:",
+                    "        return []",
+                    "    return 'nope'",
+                ].join("\n"));
+                var sym = find(m.getAllSymbols(), "ambiguous");
+                assert.ok(sym, "Expected 'ambiguous' symbol");
+                assert.strictEqual(sym.return_type, null,
+                    "Expected return_type null for mixed types, got: " + sym.return_type);
+            },
+        },
+
+        {
+            name: "infer_return_type_bare_return_ignored",
+            description: "Bare return (no value) does not block inference from typed returns",
+            run: function () {
+                var m = analyze([
+                    "def maybe_get(flag):",
+                    "    if not flag:",
+                    "        return",
+                    "    return []",
+                ].join("\n"));
+                var sym = find(m.getAllSymbols(), "maybe_get");
+                assert.ok(sym, "Expected 'maybe_get' symbol");
+                assert.strictEqual(sym.return_type, "list",
+                    "Expected return_type 'list' ignoring bare return, got: " + sym.return_type);
+            },
+        },
+
+        {
+            name: "infer_return_type_explicit_annotation_not_overwritten",
+            description: "An explicit -> annotation is not replaced by inference",
+            run: function () {
+                var m = analyze("def get_name() -> str:\n    return 42");
+                var sym = find(m.getAllSymbols(), "get_name");
+                assert.ok(sym, "Expected 'get_name' symbol");
+                assert.strictEqual(sym.return_type, "str",
+                    "Explicit annotation should win, got: " + sym.return_type);
+            },
+        },
+
+        {
+            name: "infer_return_type_nested_function_not_confused",
+            description: "Returns inside a nested function do not affect the outer function's type",
+            run: function () {
+                var m = analyze([
+                    "def outer():",
+                    "    def inner():",
+                    "        return 'text'",
+                    "    return []",
+                ].join("\n"));
+                var outer = find(m.getAllSymbols(), "outer");
+                var inner = find(m.getAllSymbols(), "inner");
+                assert.ok(outer, "Expected 'outer' symbol");
+                assert.ok(inner, "Expected 'inner' symbol");
+                assert.strictEqual(outer.return_type, "list",
+                    "outer return_type should be 'list', got: " + outer.return_type);
+                assert.strictEqual(inner.return_type, "str",
+                    "inner return_type should be 'str', got: " + inner.return_type);
+            },
+        },
+
+        // ── Nested classes ────────────────────────────────────────────────
+
+        {
+            name: "nested_class_creates_inner_frame",
+            description: "A nested class definition creates its own 'class' frame inside the outer class frame",
+            run: function () {
+                var m = analyze([
+                    "class Outer:",
+                    "    class Inner:",
+                    "        def method(self):",
+                    "            pass",
+                ].join("\n"));
+                var cls_frames = m.frames.filter(function (f) { return f.kind === "class"; });
+                assert.ok(cls_frames.length >= 2, "Expected at least 2 class frames (Outer + Inner), got " + cls_frames.length);
+                var names = cls_frames.map(function (f) { return f.name; });
+                assert.ok(names.indexOf("Outer") >= 0, "Expected 'Outer' class frame");
+                assert.ok(names.indexOf("Inner") >= 0, "Expected 'Inner' class frame");
+            },
+        },
+
+        {
+            name: "nested_class_symbol_in_outer_scope",
+            description: "The nested class name appears as a 'class' symbol in the outer class frame",
+            run: function () {
+                var m = analyze([
+                    "class Outer:",
+                    "    class Inner:",
+                    "        pass",
+                ].join("\n"));
+                var outer_frame = m.frames.find(function (f) { return f.kind === "class" && f.name === "Outer"; });
+                assert.ok(outer_frame, "Expected 'Outer' class frame");
+                var inner_sym = outer_frame.getSymbol("Inner");
+                assert.ok(inner_sym, "Expected 'Inner' symbol in Outer's class frame");
+                assert.strictEqual(inner_sym.kind, "class");
+            },
+        },
+
+        {
+            name: "nested_class_methods_in_inner_frame",
+            description: "Methods of the nested class appear in the inner class frame, not the outer one",
+            run: function () {
+                var m = analyze([
+                    "class Outer:",
+                    "    class Inner:",
+                    "        def greet(self):",
+                    "            pass",
+                    "    def do_outer(self):",
+                    "        pass",
+                ].join("\n"));
+                var inner_frame = m.frames.find(function (f) { return f.kind === "class" && f.name === "Inner"; });
+                assert.ok(inner_frame, "Expected 'Inner' class frame");
+                assert.ok(inner_frame.getSymbol("greet"), "Expected 'greet' in Inner frame");
+                var outer_frame = m.frames.find(function (f) { return f.kind === "class" && f.name === "Outer"; });
+                assert.ok(outer_frame, "Expected 'Outer' class frame");
+                assert.ok(!outer_frame.getSymbol("greet"), "'greet' should NOT be in Outer frame");
+                assert.ok(outer_frame.getSymbol("do_outer"), "Expected 'do_outer' in Outer frame");
+            },
+        },
+
+        {
+            name: "nested_class_appears_in_module_scope",
+            description: "The outer class appears in module scope; the inner class does not pollute module scope",
+            run: function () {
+                var m = analyze([
+                    "class Outer:",
+                    "    class Inner:",
+                    "        pass",
+                ].join("\n"));
+                var module_frame = m.frames.find(function (f) { return f.kind === "module"; });
+                assert.ok(module_frame, "Expected module frame");
+                assert.ok(module_frame.getSymbol("Outer"), "Expected 'Outer' in module scope");
+                assert.ok(!module_frame.getSymbol("Inner"), "'Inner' should NOT appear directly in module scope");
+            },
+        },
+
     ];
 
     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,91 @@ 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));
+            },
+        },
+
+        {
+            name: "slice_builtin_no_undef_error",
+            description: "slice() usage produces no 'Undefined symbol' diagnostic",
+            run: function () {
+                var inst = new Diagnostics(RS);
+                var markers = inst.check([
+                    "s = slice(1, 5)",
+                    "x = [1, 2, 3, 4, 5]",
+                    "ok = isinstance(s, slice)",
+                ].join("\n"));
+                var undef = markers.filter(function (m) {
+                    return m.message.indexOf("Undefined symbol") !== -1 &&
+                           m.message.indexOf("slice") !== -1;
+                });
+                assert.deepStrictEqual(undef, [],
+                    "Expected no 'Undefined symbol: slice' but got: " + JSON.stringify(undef));
+            },
+        },
+
+        {
+            name: "list_concat_no_diagnostics",
+            description: "list + list and += produce no diagnostic errors",
+            run: function () {
+                var markers = d().check([
+                    "a = [1, 2]",
+                    "b = [3, 4]",
+                    "c = a + b",
+                    "a += [5, 6]",
+                    "print(c)",
+                    "print(a)",
+                ].join("\n"));
+                assert_count(markers, SEV_ERROR, 0, "list concat");
+            },
+        },
+
     ];
 
     return TESTS;

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

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

package/test/unit/web-repl.js

@@ -445,6 +445,140 @@ var TESTS = [
         },
     },
 
+    {
+        name: "nested_class_web_repl",
+        description: "Nested class definitions compile and run correctly via the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "class Outer:",
+                "    class Inner:",
+                "        def __init__(self, val):",
+                "            self.val = val",
+                "    def __init__(self, v):",
+                "        self.inner = Outer.Inner(v)",
+                "o = Outer(99)",
+                "assrt.equal(o.inner.val, 99)",
+                "assrt.ok(isinstance(o.inner, Outer.Inner))",
+                "assrt.ok(o.Inner is Outer.Inner)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── slice() builtin ───────────────────────────────────────────────────
+
+    {
+        name: "bundle_slice_constructor",
+        description: "slice() constructor stores start/stop/step attributes correctly",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "s1 = slice(5)",
+                "assrt.equal(s1.start, None)",
+                "assrt.equal(s1.stop, 5)",
+                "assrt.equal(s1.step, None)",
+                "s2 = slice(2, 8)",
+                "assrt.equal(s2.start, 2)",
+                "assrt.equal(s2.stop, 8)",
+                "assrt.equal(s2.step, None)",
+                "s3 = slice(1, 9, 2)",
+                "assrt.equal(s3.start, 1)",
+                "assrt.equal(s3.stop, 9)",
+                "assrt.equal(s3.step, 2)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_slice_subscript",
+        description: "slice object used as list subscript returns the correct sub-list",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from __python__ import overload_getitem",
+                "lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]",
+                "s = slice(2, 5)",
+                "assrt.deepEqual(lst[s], [2, 3, 4])",
+                "assrt.deepEqual(lst[slice(0, 6, 2)], [0, 2, 4])",
+                "assrt.deepEqual(lst[slice(5, 1, -1)], [5, 4, 3, 2])",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_slice_indices",
+        description: "slice.indices() returns normalised (start, stop, step) tuple",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "s = slice(2, 8)",
+                "idx = s.indices(10)",
+                "assrt.equal(idx[0], 2)",
+                "assrt.equal(idx[1], 8)",
+                "assrt.equal(idx[2], 1)",
+                "# negative indices normalised",
+                "s2 = slice(-3, -1)",
+                "idx2 = s2.indices(10)",
+                "assrt.equal(idx2[0], 7)",
+                "assrt.equal(idx2[1], 9)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_slice_repr",
+        description: "str(slice(...)) produces the Python-style repr",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "assrt.equal(str(slice(1, 5, None)), 'slice(1, 5, None)')",
+                "assrt.equal(str(slice(None, 5, 2)), 'slice(None, 5, 2)')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_slice_isinstance",
+        description: "isinstance(slice(...), slice) returns True in bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "s = slice(1, 5)",
+                "assrt.ok(isinstance(s, slice))",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_list_concatenation",
+        description: "list + list returns a concatenated list in the bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "a = [1, 2]",
+                "b = [3, 4]",
+                "c = a + b",
+                "assrt.deepEqual(c, [1, 2, 3, 4])",
+                "assrt.deepEqual(a, [1, 2])",
+                "assrt.deepEqual(b, [3, 4])",
+                "# iadd extends in-place",
+                "a += [5]",
+                "assrt.deepEqual(a, [1, 2, 5])",
+                "# numbers still work",
+                "assrt.equal(1 + 2, 3)",
+                "# strings still work",
+                "assrt.equal('foo' + 'bar', 'foobar')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
 ];
 
 // ---------------------------------------------------------------------------

package/tools/build-language-service.js

@@ -14,7 +14,7 @@ var path = require("path");
 
 var SRC_DIR     = path.join(__dirname, "..", "src", "monaco-language-service");
 var COMPILER_JS = path.join(__dirname, "..", "web-repl", "rapydscript.js");
-var DEFAULT_OUT = path.join(__dirname, "..", "web-repl", "language-service.js");
+var DEFAULT_OUT = path.join(__dirname, "..", "language-service", "index.js");
 
 // Parse --out flag
 var out_path = DEFAULT_OUT;
@@ -124,7 +124,7 @@ var chunks = [
     "// language-service.js — RapydScript Monaco Language Service",
     "// Auto-generated by tools/build-language-service.js — do not edit directly.",
     "// Source: src/monaco-language-service/  +  web-repl/rapydscript.js (embedded)",
-    "// Usage:  import { registerRapydScript } from './language-service.js';",
+    "// Usage:  import { registerRapydScript } from 'rapydscript-ns/language-service';",
     "//         No external compiler bundle needed — the compiler is bundled inside.",
     "",
     compiler_chunk,

package/tools/compiler.js

@@ -13,7 +13,6 @@ var path = require("path");
 var fs = require("fs");
 var crypto = require('crypto');
 var vm = require("vm");
-var regenerator = require('regenerator');
 var UglifyJS = require("uglify-js");
 
 function sha1sum(data) { 
@@ -38,28 +37,6 @@ function uglify(code) {
 }
 
 
-function regenerate(code, beautify) {
-    var ans, start, end;
-    if (code) {
-        ans = regenerator.compile(code).code;
-        if (!beautify) {
-            ans = uglify(ans);
-        }
-    } else {
-        // Return the runtime
-        ans = regenerator.compile('', {includeRuntime:true}).code;
-        start = ans.indexOf('=') + 1;
-        end = ans.lastIndexOf('typeof');
-        end = ans.lastIndexOf('}(', end);
-        ans = ans.slice(start + 1, end);
-        if (!beautify) {
-            var extra = '})()';
-            ans = uglify(ans + extra).slice(0, extra.length);
-        }
-    }
-    return ans;
-}
-
 var _current_virtual_files = null;
 
 function virtual_readfile(name, encoding) {
@@ -90,7 +67,6 @@ function create_compiler() {
         writefile     : virtual_writefile,
         sha1sum       : sha1sum,
         require       : require,
-        regenerate    : regenerate,
         exports       : compiler_exports,
     });