rapydscript-ns 0.8.2 → 0.8.4

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;