rapydscript-ns 0.8.2 → 0.8.4

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

@@ -0,0 +1,350 @@
+/*
+ * test/unit/language-service-index.js
+ *
+ * Tests for src/monaco-language-service/index.js (RapydScriptLanguageService).
+ * Focuses on the automatic virtualFiles population from open Monaco models,
+ * which enables cross-file return-type inference without explicit setVirtualFiles calls.
+ *
+ * Usage:
+ *   node test/unit/language-service-index.js              # run all tests
+ *   node test/unit/language-service-index.js <test-name>  # run a single test
+ */
+"use strict";
+
+var assert          = require("assert");
+var path            = require("path");
+var url             = require("url");
+var fs              = require("fs");
+var compiler_module = require("../../tools/compiler");
+var utils           = require("../../tools/utils");
+var colored         = utils.safe_colored;
+
+// ---------------------------------------------------------------------------
+// Mock Monaco helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Create a minimal mock Monaco environment.
+ * initial_models: models that exist before registerRapydScript is called.
+ */
+function make_mock_monaco(initial_models) {
+    var models = (initial_models || []).slice();
+    var create_listeners  = [];
+    var dispose_listeners = [];
+
+    var mock = {
+        MarkerSeverity: { Error: 8, Warning: 4, Info: 2, Hint: 1 },
+        languages: {
+            getLanguages: function() { return []; },
+            register: function() {},
+            registerCompletionItemProvider: function() { return { dispose: function() {} }; },
+            registerSignatureHelpProvider:  function() { return { dispose: function() {} }; },
+            registerHoverProvider:          function() { return { dispose: function() {} }; },
+            setMonarchTokensProvider:       function() {},
+            setLanguageConfiguration:       function() {},
+            CompletionItemKind: { Function: 1, Variable: 6, Class: 5, Module: 8, Keyword: 17, Method: 0 },
+        },
+        editor: {
+            getModels:          function() { return models.slice(); },
+            setModelMarkers:    function() {},
+            onDidCreateModel:   function(cb) { create_listeners.push(cb);  return { dispose: function() {} }; },
+            onWillDisposeModel: function(cb) { dispose_listeners.push(cb); return { dispose: function() {} }; },
+        },
+        // Test helpers — simulate adding/removing a model after service creation
+        _addModel: function(model) {
+            models.push(model);
+            create_listeners.forEach(function(cb) { cb(model); });
+        },
+        _disposeModel: function(model) {
+            models = models.filter(function(m) { return m !== model; });
+            dispose_listeners.forEach(function(cb) { cb(model); });
+        },
+    };
+    return mock;
+}
+
+/**
+ * Create a minimal mock Monaco TextModel.
+ * @param {string}  code     - source content
+ * @param {string}  uri_path - the path portion of the URI (e.g. '/scripts/utils.py')
+ * @param {string}  [lang]   - language id (default: 'rapydscript')
+ */
+function make_model(code, uri_path, lang) {
+    lang = lang || 'rapydscript';
+    var listeners = [];
+    var current_code = code;
+    return {
+        getLanguageId:      function()    { return lang; },
+        getValue:           function()    { return current_code; },
+        uri:                { path: uri_path || '/unnamed.py' },
+        onDidChangeContent: function(cb)  { listeners.push(cb); return { dispose: function() {} }; },
+        // Test helper — simulate an edit
+        _setContent: function(new_code) {
+            current_code = new_code;
+            listeners.forEach(function(cb) { cb({ changes: [] }); });
+        },
+    };
+}
+
+/** Wait for all pending setTimeout(fn, 0) callbacks to fire. */
+function flush(ms) {
+    return new Promise(function(resolve) { setTimeout(resolve, ms || 20); });
+}
+
+// ---------------------------------------------------------------------------
+// Test definitions  (each test returns a Promise or is sync)
+// ---------------------------------------------------------------------------
+
+function make_tests(registerRapydScript, RS) {
+
+    var builtins_src = fs.readFileSync(
+        path.join(__dirname, '../../dev/baselib-plain-pretty.js'), 'utf-8'
+    );
+
+    function make_service(models, extra_opts) {
+        var compiler = RS.web_repl ? RS.web_repl() : RS;
+        var monaco = make_mock_monaco(models);
+        var svc = registerRapydScript(monaco, Object.assign({
+            compiler: compiler,
+        }, extra_opts || {}));
+        return { svc: svc, monaco: monaco };
+    }
+
+    var TESTS = [
+
+        // ── Module name derivation ────────────────────────────────────────
+
+        {
+            name: "module_name_from_uri_path",
+            description: "ModelState derives the module name from the URI path (strip dir + .py extension)",
+            run_async: function() {
+                var utils_model = make_model("def foo():\n    return []\n", "/scripts/utils.py");
+                var env = make_service([utils_model]);
+                return flush().then(function() {
+                    assert.ok(
+                        Object.prototype.hasOwnProperty.call(env.svc._virtualFiles, 'utils'),
+                        "Expected 'utils' in _virtualFiles after model _run(); got keys: " +
+                        JSON.stringify(Object.keys(env.svc._virtualFiles))
+                    );
+                    assert.strictEqual(
+                        env.svc._virtualFiles['utils'],
+                        "def foo():\n    return []\n",
+                        "virtualFiles['utils'] should contain the model source"
+                    );
+                });
+            },
+        },
+
+        {
+            name: "module_name_pyj_extension",
+            description: "ModelState also handles .pyj extensions",
+            run_async: function() {
+                var model = make_model("x = 1\n", "/lib/helpers.pyj");
+                var env = make_service([model]);
+                return flush().then(function() {
+                    assert.ok(
+                        Object.prototype.hasOwnProperty.call(env.svc._virtualFiles, 'helpers'),
+                        "Expected 'helpers' in _virtualFiles for .pyj model"
+                    );
+                });
+            },
+        },
+
+        // ── Auto-population on model attach ───────────────────────────────
+
+        {
+            name: "virtual_files_populated_on_attach",
+            description: "Opening a second model after service creation populates _virtualFiles",
+            run_async: function() {
+                var main_model  = make_model("from utils import get_items\n", "/main.py");
+                var utils_model = make_model("def get_items():\n    return []\n", "/utils.py");
+                var env = make_service([main_model]);
+                // utils.py is opened after initial service creation
+                env.monaco._addModel(utils_model);
+                return flush().then(function() {
+                    assert.ok(
+                        Object.prototype.hasOwnProperty.call(env.svc._virtualFiles, 'utils'),
+                        "Expected 'utils' in _virtualFiles after model added dynamically"
+                    );
+                });
+            },
+        },
+
+        // ── Cleanup on model detach ───────────────────────────────────────
+
+        {
+            name: "virtual_files_cleaned_on_detach",
+            description: "Closing a model removes its entry from _virtualFiles",
+            run_async: function() {
+                var utils_model = make_model("def get_items():\n    return []\n", "/utils.py");
+                var env = make_service([utils_model]);
+                return flush().then(function() {
+                    assert.ok(
+                        Object.prototype.hasOwnProperty.call(env.svc._virtualFiles, 'utils'),
+                        "Pre-condition: 'utils' should be in _virtualFiles before detach"
+                    );
+                    env.monaco._disposeModel(utils_model);
+                    assert.ok(
+                        !Object.prototype.hasOwnProperty.call(env.svc._virtualFiles, 'utils'),
+                        "Expected 'utils' to be removed from _virtualFiles after model detach"
+                    );
+                });
+            },
+        },
+
+        // ── Content updates ───────────────────────────────────────────────
+
+        {
+            name: "virtual_files_updated_on_content_change",
+            description: "Editing a model updates its entry in _virtualFiles",
+            run_async: function() {
+                var model = make_model("def get_items():\n    return []\n", "/utils.py");
+                // Use parseDelay:0 so the re-run fires immediately after content change.
+                var env   = make_service([model], { parseDelay: 0 });
+                return flush().then(function() {
+                    model._setContent("def get_items():\n    return {}\n");
+                    return flush(20);
+                }).then(function() {
+                    assert.strictEqual(
+                        env.svc._virtualFiles['utils'],
+                        "def get_items():\n    return {}\n",
+                        "_virtualFiles['utils'] should reflect the updated content"
+                    );
+                });
+            },
+        },
+
+        // ── Cross-file inferred return type via auto-populated virtualFiles ─
+
+        {
+            name: "cross_file_inferred_return_type_list",
+            description: "Importing from an open model resolves inferred return_type='list' for completions",
+            run_async: function() {
+                var builtins_mod = require(path.join(__dirname, '../../src/monaco-language-service/builtins.js'));
+                var SourceAnalyzer  = require(url.fileURLToPath(url.pathToFileURL(
+                    path.join(__dirname, '../../src/monaco-language-service/analyzer.js')
+                ).href));
+
+                var utils_model = make_model(
+                    "def get_items():\n    return []\n",
+                    "/utils.py"
+                );
+                var env = make_service([utils_model]);
+
+                return flush().then(function() {
+                    // _virtualFiles['utils'] should now be populated automatically
+                    assert.ok(
+                        env.svc._virtualFiles['utils'],
+                        "Pre-condition: virtualFiles['utils'] must be set"
+                    );
+
+                    // Simulate the current file importing from utils
+                    var CompletionEngine = require(url.fileURLToPath(url.pathToFileURL(
+                        path.join(__dirname, '../../src/monaco-language-service/completions.js')
+                    ).href));
+                    var analyzer = new SourceAnalyzer.SourceAnalyzer(RS);
+                    var engine   = new CompletionEngine.CompletionEngine(analyzer, {
+                        virtualFiles:     env.svc._virtualFiles,
+                        builtinNames:     ['print', 'len'],
+                        builtinsRegistry: new builtins_mod.BuiltinsRegistry(),
+                    });
+
+                    var scopeMap = analyzer.analyze([
+                        "from utils import get_items",
+                        "items = get_items()",
+                        "pass",
+                    ].join("\n"), { virtualFiles: env.svc._virtualFiles });
+
+                    // items. should suggest list members
+                    var MockKind = { Function: 1, Variable: 6 };
+                    var list = engine.getCompletions(scopeMap, { lineNumber: 3, column: 8 }, "items.", MockKind);
+                    var labels = list.suggestions.map(function(s) { return s.label; });
+                    assert.ok(labels.indexOf('append') !== -1,
+                        "Expected 'append' in completions for items. (inferred list); got: " + JSON.stringify(labels));
+                });
+            },
+        },
+
+    ];
+
+    return TESTS;
+}
+
+// ---------------------------------------------------------------------------
+// Async-aware runner
+// ---------------------------------------------------------------------------
+
+function run_tests(TESTS, filter) {
+    var tests = filter
+        ? TESTS.filter(function(t) { return t.name === filter; })
+        : TESTS;
+
+    if (tests.length === 0) {
+        console.error(colored("No test found: " + filter, "red"));
+        process.exit(1);
+    }
+
+    var failures = [];
+
+    function run_next(i) {
+        if (i >= tests.length) {
+            console.log("");
+            if (failures.length) {
+                console.log(colored(failures.length + " test(s) failed.", "red"));
+                process.exit(1);
+            } else {
+                console.log(colored("All " + tests.length + " language-service-index tests passed!", "green"));
+                process.exit(0);
+            }
+            return;
+        }
+
+        var test = tests[i];
+
+        function on_pass() {
+            console.log(colored("PASS  " + test.name, "green") + "  \u2013  " + test.description);
+            run_next(i + 1);
+        }
+        function on_fail(e) {
+            failures.push(test.name);
+            console.log(colored("FAIL  " + test.name, "red") +
+                        "\n      " + (e.message || String(e)) + "\n");
+            run_next(i + 1);
+        }
+
+        if (typeof test.run_async === "function") {
+            Promise.resolve().then(function() {
+                return test.run_async();
+            }).then(on_pass).catch(on_fail);
+        } else {
+            try {
+                test.run();
+                on_pass();
+            } catch (e) {
+                on_fail(e);
+            }
+        }
+    }
+
+    run_next(0);
+}
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
+var index_path = url.pathToFileURL(
+    path.join(__dirname, "../../src/monaco-language-service/index.js")
+).href;
+
+var filter = process.argv[2] || null;
+
+import(index_path).then(function(mod) {
+    var registerRapydScript = mod.registerRapydScript;
+    var RS = compiler_module.create_compiler();
+    var TESTS = make_tests(registerRapydScript, RS);
+    run_tests(TESTS, filter);
+}).catch(function(e) {
+    console.error(colored("Failed to load index module:", "red"), e);
+    process.exit(1);
+});

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;