rapydscript-ns 0.8.2 → 0.8.4

package/test/unit/language-service.js

@@ -10,6 +10,7 @@
 "use strict";
 
 var assert         = require("assert");
+var fs             = require("fs");
 var path           = require("path");
 var url            = require("url");
 var compiler_module = require("../../tools/compiler");
@@ -55,7 +56,20 @@ function assert_line(markers, line, label) {
 //   description {string}  – what is exercised
 //   run(d)                – receives a Diagnostics instance; throws on failure
 
-function make_tests(Diagnostics, RS) {
+// Path to src/lib/ relative to this test file — used for coverage checks.
+var LIB_DIR = path.join(__dirname, "../../src/lib");
+
+/**
+ * Return the module names of all .pyj files currently in src/lib/.
+ * Excludes cache files (.pyj-cached) and any non-.pyj entries.
+ */
+function get_lib_module_names() {
+    return fs.readdirSync(LIB_DIR)
+        .filter(function (f) { return f.endsWith(".pyj") && !f.endsWith(".pyj-cached"); })
+        .map(function (f) { return f.replace(/\.pyj$/, ""); });
+}
+
+function make_tests(Diagnostics, RS, STDLIB_MODULES) {
 
     function d(extras) { return new Diagnostics(RS, extras); }
 
@@ -763,6 +777,612 @@ function make_tests(Diagnostics, RS) {
             },
         },
 
+        {
+            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");
+            },
+        },
+
+        // ── Stdlib import recognition ──────────────────────────────────────
+
+        {
+            name: "stdlib_collections_no_bad_import",
+            description: "from collections import defaultdict produces no bad-import error when virtualFiles are present",
+            run: function () {
+                // A virtualFile being present activates the knownModules registry.
+                // Before the fix, 'collections' was not in knownModules and was
+                // flagged as 'Unknown module'.
+                var markers = d().check(
+                    "from collections import defaultdict\nd = defaultdict(list)\nd['x'].append(1)",
+                    { virtualFiles: { mymod: "def foo(): pass" } }
+                );
+                var bad = markers.filter(function (m) { return m.message.indexOf('Unknown module') !== -1; });
+                assert.deepStrictEqual(bad, [],
+                    "Expected no 'Unknown module' for stdlib collections, got: " + JSON.stringify(bad));
+            },
+        },
+
+        {
+            name: "stdlib_all_modules_no_bad_import",
+            description: "All bundled stdlib modules produce no bad-import error when a module registry is active",
+            run: function () {
+                var stdlib_mods = [
+                    'aes', 'collections', 'copy', 'elementmaker', 'encodings', 'functools',
+                    'gettext', 'itertools', 'math', 'numpy', 'operator', 'pythonize',
+                    'random', 're', 'traceback', 'uuid',
+                ];
+                stdlib_mods.forEach(function (mod) {
+                    var markers = d().check(
+                        "from " + mod + " import x\nprint(x)",
+                        { virtualFiles: { mymod: "def foo(): pass" } }
+                    );
+                    var bad = markers.filter(function (m) { return m.message.indexOf('Unknown module') !== -1; });
+                    assert.deepStrictEqual(bad, [],
+                        "Expected no 'Unknown module' for stdlib '" + mod + "', got: " + JSON.stringify(bad));
+                });
+            },
+        },
+
+        {
+            name: "stdlib_python_pseudo_module_no_bad_import",
+            description: "from __python__ import overload_operators produces no bad-import error when virtualFiles are present",
+            run: function () {
+                var markers = d().check(
+                    "from __python__ import overload_operators\nclass V:\n    def __add__(self, o): return V()\nV()",
+                    { virtualFiles: { mymod: "def foo(): pass" } }
+                );
+                var bad = markers.filter(function (m) { return m.message.indexOf('Unknown module') !== -1; });
+                assert.deepStrictEqual(bad, [],
+                    "Expected no 'Unknown module' for __python__ pseudo-module, got: " + JSON.stringify(bad));
+            },
+        },
+
+        {
+            name: "stdlib_unknown_still_flagged",
+            description: "A genuinely unknown module is still flagged as bad-import when registry is active",
+            run: function () {
+                var markers = d().check(
+                    "from definitely_not_a_stdlib_module import foo\nprint(foo())",
+                    { virtualFiles: { mymod: "def bar(): pass" } }
+                );
+                var bad = markers.filter(function (m) { return m.message.indexOf('Unknown module') !== -1; });
+                assert.ok(bad.length >= 1,
+                    "Expected at least one 'Unknown module' for a genuinely unknown module, got: " + JSON.stringify(markers));
+            },
+        },
+
+        {
+            name: "stdlib_collections_all_classes",
+            description: "Importing all collections classes produces no errors",
+            run: function () {
+                var markers = d().check([
+                    "from collections import defaultdict, Counter, OrderedDict, deque, namedtuple",
+                    "d = defaultdict(list)",
+                    "c = Counter([1, 2, 2, 3])",
+                    "od = OrderedDict()",
+                    "dq = deque([1, 2, 3])",
+                    "Point = namedtuple('Point', 'x y')",
+                    "print(d, c, od, dq, Point)",
+                ].join("\n"),
+                    { virtualFiles: { mymod: "def foo(): pass" } }
+                );
+                var bad = markers.filter(function (m) { return m.message.indexOf('Unknown module') !== -1; });
+                assert.deepStrictEqual(bad, [],
+                    "Expected no bad-import for collections classes, got: " + JSON.stringify(bad));
+            },
+        },
+
+        {
+            name: "stdlib_math_no_bad_import",
+            description: "from math import sqrt, pi, floor, ceil produces no bad-import",
+            run: function () {
+                var markers = d().check(
+                    "from math import sqrt, pi, floor, ceil\nprint(sqrt(pi), floor(3.7), ceil(3.2))",
+                    { virtualFiles: { mymod: "x = 1" } }
+                );
+                var bad = markers.filter(function (m) { return m.message.indexOf('Unknown module') !== -1; });
+                assert.deepStrictEqual(bad, [],
+                    "Expected no bad-import for math, got: " + JSON.stringify(bad));
+            },
+        },
+
+        {
+            name: "copy_no_bad_import",
+            description: "from copy import copy, deepcopy produces no bad-import error",
+            run: function () {
+                var markers = d().check(
+                    "from copy import copy, deepcopy\na = [1, 2, 3]\nb = copy(a)\nc = deepcopy(a)\nprint(b, c)",
+                    { virtualFiles: { sentinel: "x = 1" } }
+                );
+                var bad = markers.filter(function (m) { return m.message.indexOf('Unknown module') !== -1; });
+                assert.deepStrictEqual(bad, [],
+                    "Expected no bad-import for copy module, got: " + JSON.stringify(bad));
+            },
+        },
+
+        {
+            name: "copy_symbols_no_undef",
+            description: "copy and deepcopy are not flagged as undefined after import",
+            run: function () {
+                var markers = d().check([
+                    "from copy import copy, deepcopy",
+                    "class Pt:",
+                    "    def __init__(self, x, y):",
+                    "        self.x = x",
+                    "        self.y = y",
+                    "    def __copy__(self):",
+                    "        return Pt(self.x, self.y)",
+                    "    def __deepcopy__(self, memo):",
+                    "        return Pt(self.x, self.y)",
+                    "p = Pt(1, 2)",
+                    "q = copy(p)",
+                    "r = deepcopy(p)",
+                    "print(q.x, r.y)",
+                ].join("\n"));
+                var undef = markers.filter(function (m) { return m.message.indexOf('Undefined symbol') !== -1; });
+                assert.deepStrictEqual(undef, [],
+                    "Expected no undef errors, got: " + JSON.stringify(undef));
+            },
+        },
+
+        {
+            name: "stdlib_functools_no_bad_import",
+            description: "from functools import reduce, partial produces no bad-import",
+            run: function () {
+                var markers = d().check(
+                    "from functools import reduce, partial\nadd = partial(lambda a, b: a + b, 1)\nprint(reduce(lambda a, b: a + b, [1, 2, 3]))",
+                    { virtualFiles: { mymod: "x = 1" } }
+                );
+                var bad = markers.filter(function (m) { return m.message.indexOf('Unknown module') !== -1; });
+                assert.deepStrictEqual(bad, [],
+                    "Expected no bad-import for functools, got: " + JSON.stringify(bad));
+            },
+        },
+
+        {
+            name: "stdlib_react_hooks_no_errors",
+            description: "Importing and using React hooks and utilities produces no errors",
+            run: function () {
+                var markers = d().check([
+                    "from react import useState, useEffect, useRef, useCallback, useMemo",
+                    "from react import useContext, useReducer, useId, useTransition",
+                    "from react import Component, PureComponent, Fragment",
+                    "from react import createElement, createContext, createRef, memo, lazy",
+                    "from react import forwardRef, cloneElement, isValidElement",
+                    "count, setCount = useState(0)",
+                    "ref = useRef(None)",
+                    "ref2 = createRef()",
+                    "ctx = createContext(None)",
+                    "cb = useCallback(lambda: None, [])",
+                    "val = useMemo(lambda: 42, [])",
+                    "id_ = useId()",
+                    "el = createElement('div', None)",
+                    "valid = isValidElement(el)",
+                    "print(count, setCount, ref, ref2, ctx, cb, val, id_, el, valid)",
+                    "print(Component, PureComponent, Fragment, forwardRef, cloneElement)",
+                    "print(useEffect, useContext, useReducer, useTransition, memo, lazy)",
+                ].join("\n"),
+                    { virtualFiles: { sentinel: "x = 1" } }
+                );
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors for react imports and usage, got: " +
+                    JSON.stringify(errors.map(function (m) { return m.message; })));
+            },
+        },
+
+        // ── STDLIB_MODULES coverage (filesystem-driven) ───────────────────
+        //
+        // These tests read src/lib/ at runtime and cross-check against
+        // STDLIB_MODULES so that any future .pyj file addition that is
+        // not reflected in the constant causes an immediate test failure.
+
+        {
+            name: "stdlib_modules_covers_all_lib_files",
+            description: "Every .pyj file in src/lib/ has its module name listed in STDLIB_MODULES",
+            run: function () {
+                if (!STDLIB_MODULES) {
+                    // Graceful skip when called without the constant (shouldn't happen)
+                    throw new Error("STDLIB_MODULES was not passed to make_tests()");
+                }
+                var lib_names   = get_lib_module_names();
+                var stdlib_set  = Object.create(null);
+                STDLIB_MODULES.forEach(function (m) { stdlib_set[m] = true; });
+
+                var missing = lib_names.filter(function (name) {
+                    return !stdlib_set[name];
+                });
+
+                assert.deepStrictEqual(missing, [],
+                    "The following src/lib/ modules are missing from STDLIB_MODULES " +
+                    "in diagnostics.js — add them to avoid false 'Unknown module' IDE errors:\n  " +
+                    missing.join(", ")
+                );
+            },
+        },
+
+        {
+            name: "stdlib_modules_no_phantom_entries",
+            description: "Every non-pseudo entry in STDLIB_MODULES corresponds to an actual src/lib/*.pyj file",
+            run: function () {
+                if (!STDLIB_MODULES) {
+                    throw new Error("STDLIB_MODULES was not passed to make_tests()");
+                }
+                // Pseudo-modules that do not have a corresponding .pyj file are OK.
+                var PSEUDO = { '__python__': true, '__builtins__': true };
+
+                var lib_set   = Object.create(null);
+                get_lib_module_names().forEach(function (n) { lib_set[n] = true; });
+
+                var phantom = STDLIB_MODULES.filter(function (m) {
+                    return !PSEUDO[m] && !lib_set[m];
+                });
+
+                assert.deepStrictEqual(phantom, [],
+                    "The following STDLIB_MODULES entries have no matching src/lib/*.pyj file — " +
+                    "remove them from STDLIB_MODULES or add the missing library:\n  " +
+                    phantom.join(", ")
+                );
+            },
+        },
+
+        {
+            name: "hash_dunder_no_errors",
+            description: "__hash__ method in a class produces no error markers",
+            run: function () {
+                var markers = d().check([
+                    "class Hashable:",
+                    "    def __init__(self, v):",
+                    "        self.v = v",
+                    "    def __hash__(self):",
+                    "        return hash(self.v)",
+                    "h = Hashable(42)",
+                    "result = hash(h)",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors but got: " + JSON.stringify(errors));
+            },
+        },
+
+        {
+            name: "hash_eq_and_hash_no_errors",
+            description: "class with both __eq__ and __hash__ produces no error markers",
+            run: function () {
+                var markers = d().check([
+                    "class Key:",
+                    "    def __init__(self, v):",
+                    "        self.v = v",
+                    "    def __eq__(self, other):",
+                    "        return self.v == other.v",
+                    "    def __hash__(self):",
+                    "        return hash(self.v)",
+                    "k = Key(1)",
+                    "h = hash(k)",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors but got: " + JSON.stringify(errors));
+            },
+        },
+
+        {
+            name: "stdlib_new_lib_file_no_bad_import",
+            description: "Every .pyj module in src/lib/ produces zero error-severity markers when imported with virtualFiles present",
+            run: function () {
+                var lib_names = get_lib_module_names();
+                lib_names.forEach(function (mod) {
+                    var markers = d().check(
+                        "from " + mod + " import x\nprint(x)",
+                        { virtualFiles: { sentinel: "x = 1" } }
+                    );
+                    // Check for ANY error-severity marker, not just bad-import.
+                    // This catches: bad-import ('Unknown module'), import-err, syntax-err,
+                    // and any other error category that might arise for a new lib file.
+                    var errors = markers.filter(function (m) {
+                        return m.severity === SEV_ERROR;
+                    });
+                    assert.deepStrictEqual(errors, [],
+                        "src/lib/" + mod + ".pyj exists but 'from " + mod + " import x' " +
+                        "produces error markers — if this is a bad-import, add '" + mod +
+                        "' to STDLIB_MODULES in diagnostics.js. Markers: " +
+                        JSON.stringify(errors.map(function (m) { return m.message; }))
+                    );
+                });
+            },
+        },
+
+        // ── __getattr__ / __setattr__ / __delattr__ / __getattribute__ ────────
+
+        {
+            name: "attr_dunders_no_errors",
+            description: "Classes with __getattr__/__setattr__/__delattr__/__getattribute__ produce no error markers",
+            run: function () {
+                var markers = d().check([
+                    "class Bag:",
+                    "    def __init__(self):",
+                    "        self.data = {}",
+                    "    def __getattr__(self, name):",
+                    "        return 'missing_' + name",
+                    "    def __setattr__(self, name, value):",
+                    "        object.__setattr__(self, name, value)",
+                    "    def __delattr__(self, name):",
+                    "        object.__delattr__(self, name)",
+                    "    def __getattribute__(self, name):",
+                    "        return object.__getattribute__(self, name)",
+                    "b = Bag()",
+                    "x = b.foo",
+                    "b.bar = 1",
+                    "del b.bar",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors but got: " + JSON.stringify(errors));
+            },
+        },
+
+        {
+            name: "class_getitem_no_errors",
+            description: "__class_getitem__ method in a class produces no error markers",
+            run: function () {
+                var markers = d().check([
+                    "class Box:",
+                    "    def __class_getitem__(cls, item):",
+                    "        return cls.__name__ + '[' + str(item) + ']'",
+                    "result = Box[42]",
+                    "print(result)",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors but got: " + JSON.stringify(errors));
+            },
+        },
+
+        {
+            name: "class_getitem_subclass_no_errors",
+            description: "subclass inheriting __class_getitem__ produces no error markers",
+            run: function () {
+                var markers = d().check([
+                    "class Base:",
+                    "    def __class_getitem__(cls, item):",
+                    "        return cls",
+                    "class Child(Base):",
+                    "    pass",
+                    "x = Child[int]",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors but got: " + JSON.stringify(errors));
+            },
+        },
+
+        {
+            name: "init_subclass_no_errors",
+            description: "__init_subclass__ method in a class produces no error markers",
+            run: function () {
+                var markers = d().check([
+                    "log = []",
+                    "class Base:",
+                    "    def __init_subclass__(cls, **kwargs):",
+                    "        log.append(cls.__name__)",
+                    "class Child(Base):",
+                    "    pass",
+                    "print(log)",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors but got: " + JSON.stringify(errors));
+            },
+        },
+
+        {
+            name: "init_subclass_kwargs_no_errors",
+            description: "__init_subclass__ with class kwargs produces no error markers",
+            run: function () {
+                var markers = d().check([
+                    "class Base:",
+                    "    def __init_subclass__(cls, tag=None, **kwargs):",
+                    "        cls._tag = tag",
+                    "class Child(Base, tag='hello'):",
+                    "    pass",
+                    "print(Child._tag)",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors but got: " + JSON.stringify(errors));
+            },
+        },
+
+        {
+            name: "except_star_no_errors",
+            description: "except* syntax and ExceptionGroup produce no error markers",
+            run: function () {
+                var markers = d().check([
+                    'eg = ExceptionGroup("mixed", [ValueError("v"), TypeError("t")])',
+                    "val_msgs = []",
+                    "try:",
+                    "    raise eg",
+                    "except* ValueError as g:",
+                    "    for e in g.exceptions:",
+                    "        val_msgs.append(str(e))",
+                    "except* TypeError as g:",
+                    "    pass",
+                    "print(val_msgs)",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors but got: " + JSON.stringify(errors));
+            },
+        },
+
+        {
+            name: "except_star_var_bound_no_errors",
+            description: "the as-variable in except* is correctly bound in the language service",
+            run: function () {
+                var markers = d().check([
+                    "try:",
+                    '    raise ExceptionGroup("eg", [ValueError("v")])',
+                    "except* ValueError as grp:",
+                    "    x = len(grp.exceptions)",
+                    "    print(x)",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors but got: " + JSON.stringify(errors));
+            },
+        },
+
+        {
+            name: "attr_dunders_object_bypass_no_errors",
+            description: "object.__setattr__/object.__getattribute__/object.__delattr__ produce no error markers",
+            run: function () {
+                var markers = d().check([
+                    "class Validated:",
+                    "    def __setattr__(self, name, value):",
+                    "        if jstype(value) is 'number' and value < 0:",
+                    "            raise ValueError('negative')",
+                    "        object.__setattr__(self, name, value)",
+                    "    def __getattribute__(self, name):",
+                    "        return object.__getattribute__(self, name)",
+                    "    def __delattr__(self, name):",
+                    "        object.__delattr__(self, name)",
+                    "v = Validated()",
+                    "v.x = 5",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors but got: " + JSON.stringify(errors));
+            },
+        },
+
+        // ── * and ** unpacking operators ─────────────────────────────────────
+        {
+            name: "list_spread_no_errors",
+            description: "list spread [*a, 1, *b] produces no linter errors",
+            run: function () {
+                var markers = d().check([
+                    "a = [1, 2]",
+                    "b = [3, 4]",
+                    "c = [*a, 0, *b]",
+                    "d2 = [*c]",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors but got: " + JSON.stringify(errors));
+            },
+        },
+
+        {
+            name: "set_spread_no_errors",
+            description: "set spread {*a, 1} and function **expr produce no linter errors",
+            run: function () {
+                var markers = d().check([
+                    "a = [1, 2, 3]",
+                    "s = {*a, 4}",
+                    "opts = {'x': 10}",
+                    "def f(x=0):",
+                    "    return x",
+                    "f(**opts)",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors but got: " + JSON.stringify(errors));
+            },
+        },
+
+        // ── tuple type ────────────────────────────────────────────────────────
+
+        {
+            name: "tuple_annotation_no_undef",
+            description: "tuple used as a variable or argument type annotation produces no undefined-symbol errors",
+            run: function () {
+                var markers = d().check([
+                    "def swap(pair: tuple) -> tuple:",
+                    "    return (pair[1], pair[0])",
+                    "coords: tuple = (3, 4)",
+                    "result = swap(coords)",
+                ].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: "tuple_runtime_no_errors",
+            description: "calling tuple() at runtime produces no linter errors",
+            run: function () {
+                var markers = d().check([
+                    "t = tuple([1, 2, 3])",
+                    "x = t[0]",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors but got: " + JSON.stringify(errors));
+            },
+        },
+
+        // ── str.expandtabs language-service tests ─────────────────────────
+
+        {
+            name: "expandtabs_no_errors",
+            description: "str.expandtabs() call produces no linter errors",
+            run: function () {
+                var markers = d().check([
+                    "s = 'hello\\tworld'",
+                    "result = str.expandtabs(s)",
+                    "result2 = str.expandtabs(s, 4)",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors but got: " + JSON.stringify(errors));
+            },
+        },
+
+        {
+            name: "expandtabs_result_used_no_errors",
+            description: "assigning expandtabs result and using it produces no linter errors",
+            run: function () {
+                var markers = d().check([
+                    "lines = ['a\\tb', 'c\\td']",
+                    "expanded = [str.expandtabs(line, 4) for line in lines]",
+                    "print(expanded)",
+                ].join("\n"));
+                var errors = markers.filter(function (m) { return m.severity === SEV_ERROR; });
+                assert.deepStrictEqual(errors, [],
+                    "Expected no errors but got: " + JSON.stringify(errors));
+            },
+        },
+
     ];
 
     return TESTS;
@@ -817,9 +1437,10 @@ var diagnostics_path = url.pathToFileURL(
 var filter = process.argv[2] || null;
 
 import(diagnostics_path).then(function (mod) {
-    var Diagnostics = mod.Diagnostics;
-    var RS          = compiler_module.create_compiler();
-    var TESTS       = make_tests(Diagnostics, RS);
+    var Diagnostics    = mod.Diagnostics;
+    var STDLIB_MODULES = mod.STDLIB_MODULES;
+    var RS             = compiler_module.create_compiler();
+    var TESTS          = make_tests(Diagnostics, RS, STDLIB_MODULES);
     run_tests(TESTS, filter);
 }).catch(function (e) {
     console.error(colored("Failed to load language service module:", "red"), e);

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-index.js",
     "language-service-bundle.js",
     "web-repl.js",
 ];