rapydscript-ns 0.8.2 → 0.8.3

package/test/unit/index.js

@@ -185,6 +185,84 @@ var TESTS = [
         js_checks: ["Math.pow(2, 10)", "Math.pow(3, 3)", "Math.pow(10, 0)"],
     },
 
+    // ── List concatenation ────────────────────────────────────────────────
+
+    {
+        name: "list_concatenation_literals",
+        description: "list + list returns a new concatenated list (literal operands)",
+        src: [
+            "# globals: assrt",
+            "result = [1, 2] + [3, 4]",
+            "assrt.deepEqual(result, [1, 2, 3, 4])",
+            "assrt.equal(result.length, 4)",
+            "# originals not mutated",
+            "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])",
+        ].join("\n"),
+        js_checks: ["ρσ_list_add("],
+    },
+
+    {
+        name: "list_concatenation_variables",
+        description: "list + list works with variable references",
+        src: [
+            "# globals: assrt",
+            "a = [10, 20]",
+            "b = [30]",
+            "assrt.deepEqual(a + b, [10, 20, 30])",
+            "assrt.deepEqual([] + [1], [1])",
+            "assrt.deepEqual([1] + [], [1])",
+            "assrt.deepEqual([] + [], [])",
+        ].join("\n"),
+    },
+
+    {
+        name: "list_iadd_extends_in_place",
+        description: "list += list extends the list in-place (same object)",
+        src: [
+            "# globals: assrt",
+            "a = [1, 2]",
+            "ref = a",
+            "a += [3, 4]",
+            "assrt.deepEqual(a, [1, 2, 3, 4])",
+            "# ref still points to same object, now extended",
+            "assrt.deepEqual(ref, [1, 2, 3, 4])",
+            "assrt.ok(a is ref)",
+        ].join("\n"),
+        js_checks: ["ρσ_list_iadd("],
+    },
+
+    {
+        name: "list_concat_does_not_break_number_add",
+        description: "numbers still add correctly after list-concat helpers are introduced",
+        src: [
+            "# globals: assrt",
+            "assrt.equal(1 + 2, 3)",
+            "assrt.equal(3 + 4, 7)",
+            "assrt.equal(0 + 0, 0)",
+            "x = 10",
+            "x += 5",
+            "assrt.equal(x, 15)",
+        ].join("\n"),
+    },
+
+    {
+        name: "list_concat_does_not_break_string_concat",
+        description: "string concatenation still works correctly",
+        src: [
+            "# globals: assrt",
+            "assrt.equal('hello' + ' world', 'hello world')",
+            "assrt.equal('a' + 'b' + 'c', 'abc')",
+            "s = 'foo'",
+            "s += 'bar'",
+            "assrt.equal(s, 'foobar')",
+        ].join("\n"),
+    },
+
     {
         name: "not_operator",
         description: '"not" compiles to "!"',
@@ -424,8 +502,8 @@ var TESTS = [
             "increment()",
             "assrt.equal(counter, 3)",
         ].join("\n"),
-        // nonlocal → the outer variable is accessed/modified directly
-        js_checks: ["counter += 1"],
+        // nonlocal → the outer variable is accessed/modified directly via ρσ_list_iadd
+        js_checks: ["ρσ_list_iadd(counter,"],
     },
 
     // ── Classes ───────────────────────────────────────────────────────────
@@ -1093,7 +1171,7 @@ assrt.equal(fib(15), 610)
             "    return fn(x)",
             "assrt.equal(apply(lambda x: x * x, 5), 25)",
             "nums = [3, 1, 2]",
-            "nums.sort(lambda a, b: a - b)",
+            "nums.sort()",
             "assrt.deepEqual(nums, [1, 2, 3])",
         ].join("\n"),
         js_checks: [],
@@ -2664,15 +2742,14 @@ assrt.equal(fib(15), 610)
 
     {
         name: "operator_overloading_no_flag",
-        description: "Without overload_operators flag operators emit native JS (no helpers in user code)",
+        description: "Without overload_operators flag: + uses ρσ_list_add (not ρσ_op_add), * is native",
         src: [
             "# globals: assrt",
             "assrt.equal(2 + 3, 5)",
             "assrt.equal(3 * 4, 12)",
         ].join("\n"),
-        // Verify user-code expressions compile to native operators, not helper calls
-        js_checks: [/assrt\.equal\(2 \+ 3, 5\)/, /assrt\.equal\(3 \* 4, 12\)/],
-        js_not_checks: [],
+        // + should compile to ρσ_list_add (lightweight list/number/string helper)
+        js_checks: ["ρσ_list_add(2, 3)", /assrt\.equal\(3 \* 4, 12\)/],
     },
 
     {
@@ -2874,6 +2951,41 @@ assrt.equal(fib(15), 610)
         },
     },
 
+    {
+        name: "python_flag_truthiness_via_scoped_flags",
+        description: "truthiness flag via scoped_flags wraps if-conditions with ρσ_bool(; plain code does not",
+        run: function() {
+            var src = "if x:\n    pass";
+            var src_inline  = "from __python__ import truthiness\n" + src;
+            var js_inline   = compile(src_inline);
+            var js_flagged  = compile_with_flags(src, { truthiness: true });
+            var js_plain    = compile(src);
+            assert.ok(/if\s*\(ρσ_bool\(/.test(js_inline),
+                "inline import: expected if(ρσ_bool( in: " + js_inline);
+            assert.ok(/if\s*\(ρσ_bool\(/.test(js_flagged),
+                "scoped_flags: expected if(ρσ_bool( in: " + js_flagged);
+            assert.ok(!/if\s*\(ρσ_bool\(/.test(js_plain),
+                "no flag: if(ρσ_bool( should NOT appear in: " + js_plain);
+        },
+    },
+
+    {
+        name: "python_flag_truthiness_via_python_flags_option",
+        description: "truthiness passed as python_flags string to embedded_compiler wraps if-conditions",
+        run: function() {
+            var make_ec = require("../../tools/embedded_compiler.js");
+            var src = "if x:\n    pass";
+            var ec_with = make_ec(RapydScript, baselib, null);
+            var js_with = ec_with.compile(src, { python_flags: "truthiness" });
+            assert.ok(/if\s*\(ρσ_bool\(/.test(js_with),
+                "python_flags='truthiness': expected if(ρσ_bool( in: " + js_with);
+            var ec_without = make_ec(RapydScript, baselib, null);
+            var js_without = ec_without.compile(src, {});
+            assert.ok(!/if\s*\(ρσ_bool\(/.test(js_without),
+                "no python_flags: if(ρσ_bool( should NOT appear in: " + js_without);
+        },
+    },
+
     {
         name: "python_flag_all_flags_runtime",
         description: "overload_operators + overload_getitem work correctly at runtime via scoped_flags",

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

@@ -734,6 +734,76 @@ function make_tests(BuiltinsRegistry, BuiltinInfo, HoverEngine, SignatureHelpEng
             },
         },
 
+        // ── slice builtin ─────────────────────────────────────────────────
+
+        {
+            name: "slice_registered_as_class",
+            description: "slice is registered in BuiltinsRegistry with kind='class'",
+            run: function () {
+                var reg = new BuiltinsRegistry();
+                var bi  = reg.get('slice');
+                assert.ok(bi, 'slice should be registered');
+                assert.strictEqual(bi.name, 'slice');
+                assert.strictEqual(bi.kind, 'class');
+                assert.ok(Array.isArray(bi.params));
+                assert.ok(bi.doc && bi.doc.length > 0, 'slice should have a docstring');
+            },
+        },
+
+        {
+            name: "slice_hover_markdown",
+            description: "slice hover markdown includes signature and doc",
+            run: function () {
+                var reg = new BuiltinsRegistry();
+                var md  = reg.getHoverMarkdown('slice');
+                assert.ok(md, 'slice should have hover markdown');
+                assert.ok(md.indexOf('slice') !== -1, 'hover should mention slice');
+                assert.ok(md.indexOf('start_or_stop') !== -1, 'hover should mention start_or_stop param');
+            },
+        },
+
+        {
+            name: "slice_in_completions",
+            description: "slice appears in completion list as a built-in class",
+            run: function () {
+                var reg      = new BuiltinsRegistry();
+                var analyzer = new SourceAnalyzer(RS);
+                var engine   = new CompletionEngine(analyzer, {
+                    virtualFiles:    {},
+                    builtinNames:    ['slice'],
+                    builtinsRegistry: reg,
+                });
+                var list = engine.getCompletions(null, pos(1, 6), 'slice', MockKind);
+                var item = list.suggestions.find(function (s) { return s.label === 'slice'; });
+                assert.ok(item, 'slice should appear in completions');
+                assert.strictEqual(item.kind, MockKind.Class, 'slice should have Class kind');
+            },
+        },
+
+        {
+            name: "slice_signature_help",
+            description: "slice signature help returns start_or_stop, stop, step params",
+            run: function () {
+                var reg  = new BuiltinsRegistry();
+                var info = reg.getSignatureInfo('slice');
+                assert.ok(info, 'slice should have signature info');
+                assert.ok(info.label.indexOf('slice') !== -1, 'label should contain slice');
+                assert.ok(info.params.length >= 1, 'should have at least 1 param');
+                assert.strictEqual(info.params[0].label, 'start_or_stop: int');
+            },
+        },
+
+        {
+            name: "slice_in_getNames",
+            description: "slice appears in BuiltinsRegistry.getNames()",
+            run: function () {
+                var reg   = new BuiltinsRegistry();
+                var names = reg.getNames();
+                assert.ok(names.indexOf('slice') !== -1,
+                    'slice should be in getNames(), got: ' + names.join(', '));
+            },
+        },
+
     ];
 
     return TESTS;

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

@@ -1,7 +1,7 @@
 /*
  * test/unit/language-service-bundle.js
  *
- * Verifies that the built web-repl/language-service.js can be loaded as an
+ * Verifies that the built language-service/index.js can be loaded as an
  * ES module without errors (e.g. duplicate top-level declarations).
  *
  * Usage:
@@ -15,11 +15,11 @@ 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");
+var bundle_path = path.join(__dirname, "../../language-service/index.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");
+        "  –  language-service/index.js not found; run: npm run build:ls");
     process.exit(0);
 }
 
@@ -41,7 +41,7 @@ import(bundle_url).then(function (mod) {
 
     // 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");
+        "language-service/index.js loads as an ES module without errors");
 
     // Test 2: registerRapydScript is exported
     try {
@@ -75,7 +75,7 @@ import(bundle_url).then(function (mod) {
 
 }).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");
+        "  \u2013  language-service/index.js failed to load as an ES module");
     console.log("      " + (e.message || String(e)));
     console.log("");
     console.log(colored("1 test(s) failed.", "red"));

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

@@ -1097,6 +1097,186 @@ function make_tests(CompletionEngine, detect_context, SourceAnalyzer, DtsRegistr
             },
         },
 
+        // ── Return-type inference ─────────────────────────────────────────
+
+        {
+            name: "return_type_local_fn_list_annotation",
+            description: "def fn() -> [str]: — call result completions include list members",
+            run: function () {
+                var builtins_mod = require(path.join(__dirname, '../../src/monaco-language-service/builtins.js'));
+                var engine = make_engine({}, [], null, builtins_mod);
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze([
+                    "def getAllServers() -> [str]:",
+                    "    return []",
+                    "pass",
+                ].join("\n"), {});
+
+                // fn().l — call_result context
+                var list = engine.getCompletions(scopeMap, pos(3, 18), "getAllServers().", MockKind);
+                assert_has(list, 'length', 'list.length via call_result return type');
+                assert_has(list, 'append', 'list.append via call_result return type');
+            },
+        },
+
+        {
+            name: "return_type_local_fn_dot_var",
+            description: "x = fn() where fn() -> [str] — x. completions include list members",
+            run: function () {
+                var builtins_mod = require(path.join(__dirname, '../../src/monaco-language-service/builtins.js'));
+                var engine = make_engine({}, [], null, builtins_mod);
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze([
+                    "def getAllServers() -> [str]:",
+                    "    return []",
+                    "servers = getAllServers()",
+                    "pass",
+                ].join("\n"), {});
+
+                var list = engine.getCompletions(scopeMap, pos(4, 9), "servers.", MockKind);
+                assert_has(list, 'length', 'list.length on var assigned from annotated fn');
+                assert_has(list, 'append', 'list.append on var assigned from annotated fn');
+            },
+        },
+
+        {
+            name: "return_type_imported_fn_call_result",
+            description: "getAllServers().l — imported fn with -> [str] annotation suggests list members",
+            run: function () {
+                var builtins_mod = require(path.join(__dirname, '../../src/monaco-language-service/builtins.js'));
+                var servers_src = [
+                    "def getAllServers() -> [str]:",
+                    "    return []",
+                ].join("\n");
+                var engine = make_engine({ servers: servers_src }, [], null, builtins_mod);
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze([
+                    "from servers import getAllServers",
+                    "pass",
+                ].join("\n"), {});
+
+                // getAllServers().l — call_result context
+                var list = engine.getCompletions(scopeMap, pos(2, 18), "getAllServers().", MockKind);
+                assert_has(list, 'length', 'list.length via cross-file return type (call_result)');
+                assert_has(list, 'append', 'list.append via cross-file return type (call_result)');
+            },
+        },
+
+        {
+            name: "return_type_imported_fn_dot_var",
+            description: "x = getAllServers() from import — x. includes list members",
+            run: function () {
+                var builtins_mod = require(path.join(__dirname, '../../src/monaco-language-service/builtins.js'));
+                var servers_src = [
+                    "def getAllServers() -> [str]:",
+                    "    return []",
+                ].join("\n");
+                var engine = make_engine({ servers: servers_src }, [], null, builtins_mod);
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze([
+                    "from servers import getAllServers",
+                    "servers = getAllServers()",
+                    "pass",
+                ].join("\n"), {});
+
+                var list = engine.getCompletions(scopeMap, pos(3, 10), "servers.", MockKind);
+                assert_has(list, 'length', 'list.length on var from cross-file fn');
+                assert_has(list, 'append', 'list.append on var from cross-file fn');
+            },
+        },
+
+        // ── Inferred return type for imported functions (no annotation) ───────
+
+        {
+            name: "return_type_imported_fn_inferred_call_result",
+            description: "imported fn with no annotation, return [] — call result completions include list members",
+            run: function () {
+                var builtins_mod = require(path.join(__dirname, '../../src/monaco-language-service/builtins.js'));
+                var servers_src = [
+                    "def getAllServers():",
+                    "    return []",
+                ].join("\n");
+                var engine = make_engine({ servers: servers_src }, [], null, builtins_mod);
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze([
+                    "from servers import getAllServers",
+                    "pass",
+                ].join("\n"), {});
+
+                var list = engine.getCompletions(scopeMap, pos(2, 18), "getAllServers().", MockKind);
+                assert_has(list, 'length', 'list.length via inferred cross-file return type (call_result)');
+                assert_has(list, 'append', 'list.append via inferred cross-file return type (call_result)');
+            },
+        },
+
+        {
+            name: "return_type_imported_fn_inferred_dot_var",
+            description: "x = fn() from import, fn returns [] — x. includes list members",
+            run: function () {
+                var builtins_mod = require(path.join(__dirname, '../../src/monaco-language-service/builtins.js'));
+                var servers_src = [
+                    "def getAllServers():",
+                    "    return []",
+                ].join("\n");
+                var engine = make_engine({ servers: servers_src }, [], null, builtins_mod);
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze([
+                    "from servers import getAllServers",
+                    "servers = getAllServers()",
+                    "pass",
+                ].join("\n"), {});
+
+                var list = engine.getCompletions(scopeMap, pos(3, 10), "servers.", MockKind);
+                assert_has(list, 'length', 'list.length on var from inferred cross-file fn');
+                assert_has(list, 'append', 'list.append on var from inferred cross-file fn');
+            },
+        },
+
+        {
+            name: "return_type_imported_fn_inferred_dict",
+            description: "imported fn with return {} — call result completions include dict members",
+            run: function () {
+                var builtins_mod = require(path.join(__dirname, '../../src/monaco-language-service/builtins.js'));
+                var utils_src = [
+                    "def get_config():",
+                    "    return {}",
+                ].join("\n");
+                var engine = make_engine({ utils: utils_src }, [], null, builtins_mod);
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze([
+                    "from utils import get_config",
+                    "pass",
+                ].join("\n"), {});
+
+                var list = engine.getCompletions(scopeMap, pos(2, 14), "get_config().", MockKind);
+                assert_has(list, 'keys', 'dict.keys via inferred cross-file return type');
+                assert_has(list, 'values', 'dict.values via inferred cross-file return type');
+            },
+        },
+
+        {
+            name: "return_type_imported_fn_inferred_consistent_branches",
+            description: "imported fn with multiple return [] branches — type still inferred as list",
+            run: function () {
+                var builtins_mod = require(path.join(__dirname, '../../src/monaco-language-service/builtins.js'));
+                var utils_src = [
+                    "def get_items(flag):",
+                    "    if flag:",
+                    "        return []",
+                    "    return []",
+                ].join("\n");
+                var engine = make_engine({ utils: utils_src }, [], null, builtins_mod);
+                var analyzer = new SourceAnalyzer(RS);
+                var scopeMap = analyzer.analyze([
+                    "from utils import get_items",
+                    "pass",
+                ].join("\n"), {});
+
+                var list = engine.getCompletions(scopeMap, pos(2, 12), "get_items().", MockKind);
+                assert_has(list, 'append', 'list.append via inferred multi-branch import');
+            },
+        },
+
     ];
 
     return TESTS;