rapydscript-ns 0.8.0

package/src/monaco-language-service/index.js

@@ -0,0 +1,386 @@
+// index.js — RapydScript Monaco Language Service
+// Public API: registerRapydScript(monaco, options) → service
+//
+// Usage:
+//   import { registerRapydScript } from './monaco-language-service/index.js';
+//
+//   const service = registerRapydScript(monaco, {
+//     compiler:     window.RapydScript,   // compiled rapydscript bundle
+//     virtualFiles: { 'mymod': 'def f(): pass' },  // optional
+//     dtsFiles:     [{ name: 'dom', content: '...' }],  // optional (Phase 6)
+//     parseDelay:   300,  // ms debounce (default: 300)
+//   });
+//
+//   service.setVirtualFiles({ 'mymod': newSource });
+//   service.addDts('name', dtsText);   // Phase 6 stub for now
+//   service.dispose();                 // remove all Monaco providers
+
+import { Diagnostics, BASE_BUILTINS } from './diagnostics.js';
+import { SourceAnalyzer }             from './analyzer.js';
+import { CompletionEngine }           from './completions.js';
+import { SignatureHelpEngine }        from './signature.js';
+import { HoverEngine }               from './hover.js';
+import { DtsRegistry }               from './dts.js';
+import { BuiltinsRegistry }          from './builtins.js';
+
+const LANGUAGE_ID = 'rapydscript';
+
+// ---------------------------------------------------------------------------
+// Per-model state
+// ---------------------------------------------------------------------------
+
+class ModelState {
+    constructor(model, service) {
+        this._model    = model;
+        this._service  = service;
+        this._timer    = null;
+        this._scopeMap = null;  // most recent ScopeMap for this model
+
+        // Run immediately on first attach
+        this._schedule(0);
+
+        // Re-run on every edit
+        this._subscription = model.onDidChangeContent(() => {
+            this._schedule(service._parseDelay);
+        });
+    }
+
+    _schedule(delay) {
+        clearTimeout(this._timer);
+        this._timer = setTimeout(() => this._run(), delay);
+    }
+
+    _run() {
+        const service = this._service;
+        const code    = this._model.getValue();
+        const opts    = { virtualFiles: service._virtualFiles };
+
+        // Diagnostics (syntax errors + lint markers)
+        const markers = service._diagnostics.check(code, {
+            ...opts,
+            markerSeverity: service._monaco.MarkerSeverity,
+        });
+        service._monaco.editor.setModelMarkers(this._model, LANGUAGE_ID, markers);
+
+        // Scope analysis (feeds Phase 3 completions and Phase 5 hover)
+        this._scopeMap = service._analyzer.analyze(code, opts);
+    }
+
+    dispose() {
+        clearTimeout(this._timer);
+        this._subscription.dispose();
+        // Clear markers when detaching
+        this._service._monaco.editor.setModelMarkers(this._model, LANGUAGE_ID, []);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// RapydScriptLanguageService
+// ---------------------------------------------------------------------------
+
+class RapydScriptLanguageService {
+    constructor(monaco, options) {
+        this._monaco       = monaco;
+        this._parseDelay   = options.parseDelay !== undefined ? options.parseDelay : 300;
+        this._virtualFiles = Object.assign({}, options.virtualFiles || {});
+        this._disposables  = [];
+        this._modelStates  = new Map();  // model → ModelState
+
+        // Build compiler reference — accept either the raw RapydScript global
+        // or a web_repl instance (we only need the parse-level API).
+        const compiler = options.compiler;
+        if (!compiler) throw new Error('registerRapydScript: options.compiler is required');
+
+        this._diagnostics = new Diagnostics(compiler, options.extraBuiltins, options.pythonFlags);
+        this._analyzer    = new SourceAnalyzer(compiler, options.pythonFlags);
+
+        // Preserve extra builtin names so they survive addDts() rebuilds
+        this._extraBuiltinNames = options.extraBuiltins ? Object.keys(options.extraBuiltins) : [];
+        this._stdlibFiles = Object.assign({}, options.stdlibFiles || {});
+
+        // DTS registry — load any files supplied at construction time
+        this._dts = new DtsRegistry();
+        if (options.dtsFiles) {
+            options.dtsFiles.forEach(f => this._dts.addDts(f.name, f.content));
+        }
+
+        // Built-in stubs registry (always present)
+        this._builtins = new BuiltinsRegistry();
+        this._builtins.enablePythonizeStrings();
+
+        // Merge BASE_BUILTINS + extra globals + DTS globals for completions
+        const builtin_names = BASE_BUILTINS
+            .concat(this._extraBuiltinNames)
+            .concat(this._dts.getGlobalNames());
+
+        this._completions    = new CompletionEngine(this._analyzer, {
+            virtualFiles:    this._virtualFiles,
+            stdlibFiles:     this._stdlibFiles,
+            builtinNames:    builtin_names,
+            dtsRegistry:     this._dts,
+            builtinsRegistry: this._builtins,
+        });
+        this._signature_help = new SignatureHelpEngine(this._builtins);
+        this._hover          = new HoverEngine(this._dts, this._builtins);
+
+        // Suppress diagnostics warnings for DTS globals
+        if (this._dts.getGlobalNames().length) {
+            this._diagnostics.addGlobals(this._dts.getGlobalNames());
+        }
+
+        // Store loadDts callback for lazy loading
+        this._loadDts = options.loadDts || null;
+
+        // Register language id if not already registered
+        const existing = monaco.languages.getLanguages().find(l => l.id === LANGUAGE_ID);
+        if (!existing) monaco.languages.register({ id: LANGUAGE_ID });
+
+        // Apply Python syntax highlighting — RapydScript is syntactically Python-like
+        // enough that Monaco's built-in Python tokenizer gives correct coloring.
+        // We then inject game-specific token rules so the same theme colors used for
+        // JS/TS files (ns, netscriptfunction, otherkeyvars, this) apply here too.
+        const extra_names = this._extraBuiltinNames;
+        const pythonLang = monaco.languages.getLanguages().find(l => l.id === 'python');
+        if (pythonLang && pythonLang.loader) {
+            pythonLang.loader().then(function(mod) {
+                const lang = mod.language;
+
+                // Python equivalents of the JS/TS otherkeyvars / this custom tokens.
+                // Unshift in reverse-priority order (last unshift = highest priority).
+                lang.tokenizer.root.unshift(
+                    // self → 'this' color (Python's equivalent of JS `this`)
+                    [/\bself\b/, { token: 'this' }],
+                    // True / False / None / ... → 'otherkeyvars' (accent color, distinct from keywords)
+                    [/\b(True|False|None)\b/, { token: 'otherkeyvars' }],
+                    [/\.\.\./, { token: 'otherkeyvars' }],
+                );
+
+                // ns → 'ns' token (the game API namespace object)
+                lang.tokenizer.root.unshift([/\bns\b/, { token: 'ns' }]);
+
+                // extraBuiltins → 'netscriptfunction' token (all NS API names)
+                if (extra_names.length) {
+                    const alt = extra_names
+                        .map(n => n.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+                        .join('|');
+                    lang.tokenizer.root.unshift([
+                        new RegExp('\\b(?:' + alt + ')\\b'),
+                        { token: 'netscriptfunction' },
+                    ]);
+                }
+
+                monaco.languages.setMonarchTokensProvider(LANGUAGE_ID, lang);
+                monaco.languages.setLanguageConfiguration(LANGUAGE_ID, mod.conf);
+            });
+        }
+
+        // Attach to all currently open rapydscript models
+        monaco.editor.getModels().forEach(model => this._maybeAttach(model));
+
+        // Attach to future models
+        this._disposables.push(
+            monaco.editor.onDidCreateModel(model => this._maybeAttach(model))
+        );
+
+        // Detach when a model is disposed
+        this._disposables.push(
+            monaco.editor.onWillDisposeModel(model => this._detach(model))
+        );
+
+        // Register completion provider
+        const self = this;
+        this._disposables.push(
+            monaco.languages.registerCompletionItemProvider(LANGUAGE_ID, {
+                triggerCharacters: ['.'],
+                provideCompletionItems(model, position) {
+                    if (model.getLanguageId() !== LANGUAGE_ID) return { suggestions: [] };
+                    const state = self._modelStates.get(model);
+                    const scopeMap = state ? state._scopeMap : null;
+                    const line_content = model.getLineContent(position.lineNumber);
+                    const line_prefix  = line_content.substring(0, position.column - 1);
+                    return self._completions.getCompletions(
+                        scopeMap,
+                        position,
+                        line_prefix,
+                        monaco.languages.CompletionItemKind
+                    );
+                },
+            })
+        );
+
+        // Register signature help provider
+        this._disposables.push(
+            monaco.languages.registerSignatureHelpProvider(LANGUAGE_ID, {
+                signatureHelpTriggerCharacters:   ['(', ','],
+                signatureHelpRetriggerCharacters: [','],
+                provideSignatureHelp(model, position) {
+                    if (model.getLanguageId() !== LANGUAGE_ID) return null;
+                    const state = self._modelStates.get(model);
+                    const scopeMap = state ? state._scopeMap : null;
+                    const line_content = model.getLineContent(position.lineNumber);
+                    const line_prefix  = line_content.substring(0, position.column - 1);
+                    return self._signature_help.getSignatureHelp(
+                        scopeMap,
+                        position,
+                        line_prefix
+                    );
+                },
+            })
+        );
+
+        // Register hover provider
+        this._disposables.push(
+            monaco.languages.registerHoverProvider(LANGUAGE_ID, {
+                provideHover(model, position) {
+                    if (model.getLanguageId() !== LANGUAGE_ID) return null;
+                    const state   = self._modelStates.get(model);
+                    const scopeMap = state ? state._scopeMap : null;
+                    const word_info = model.getWordAtPosition(position);
+                    const word = word_info ? word_info.word : null;
+                    const line_content = model.getLineContent(position.lineNumber);
+                    // Text before the word's start column, used to detect dot-chain access
+                    const line_before_word = word_info
+                        ? line_content.substring(0, word_info.startColumn - 1)
+                        : '';
+                    return self._hover.getHover(scopeMap, position, word, line_before_word);
+                },
+            })
+        );
+    }
+
+    // ---- internal ----------------------------------------------------------
+
+    _maybeAttach(model) {
+        if (model.getLanguageId() !== LANGUAGE_ID) return;
+        if (this._modelStates.has(model)) return;
+        this._modelStates.set(model, new ModelState(model, this));
+    }
+
+    _detach(model) {
+        const state = this._modelStates.get(model);
+        if (!state) return;
+        state.dispose();
+        this._modelStates.delete(model);
+    }
+
+    // ---- public API --------------------------------------------------------
+
+    /**
+     * Replace / merge virtual files available to the import resolver.
+     * Triggers an immediate re-check of all open models.
+     * @param {Object.<string,string>} files
+     */
+    setVirtualFiles(files) {
+        Object.assign(this._virtualFiles, files);
+        this._completions.setVirtualFiles(this._virtualFiles);
+        this._modelStates.forEach(state => state._schedule(0));
+    }
+
+    /**
+     * Remove a virtual file by name.
+     * @param {string} name
+     */
+    removeVirtualFile(name) {
+        delete this._virtualFiles[name];
+        this._completions.setVirtualFiles(this._virtualFiles);
+        this._modelStates.forEach(state => state._schedule(0));
+    }
+
+    /**
+     * Add additional global symbol names (e.g. from d.ts) so they are not
+     * flagged as undefined.  Phase 6 will call this automatically.
+     * @param {string[]} names
+     */
+    addGlobals(names) {
+        this._diagnostics.addGlobals(names);
+        this._modelStates.forEach(state => state._schedule(0));
+    }
+
+    /**
+     * Return the most recently built ScopeMap for a given Monaco model.
+     * Returns null if the model is not attached or has not been analysed yet.
+     * Used by Phase 3 (completions) and Phase 5 (hover).
+     * @param {object} model - Monaco ITextModel
+     * @returns {import('./scope.js').ScopeMap|null}
+     */
+    getScopeMap(model) {
+        const state = this._modelStates.get(model);
+        return state ? state._scopeMap : null;
+    }
+
+    /**
+     * Stub for Phase 6 (DtsRegistry).  Calling it is safe but has no effect yet.
+     * @param {string} _name
+     * @param {string} _dtsText
+     */
+    addDts(name, dtsText) {
+        this._dts.addDts(name, dtsText);
+        const new_names = this._dts.getGlobalNames();
+        // Suppress undef warnings for newly added globals
+        this._diagnostics.addGlobals(new_names);
+        // Rebuild builtin list so completions include new DTS names (preserve extraBuiltins)
+        const builtin_names = BASE_BUILTINS.concat(this._extraBuiltinNames).concat(new_names);
+        this._completions = new CompletionEngine(this._analyzer, {
+            virtualFiles:    this._virtualFiles,
+            stdlibFiles:     this._stdlibFiles,
+            builtinNames:    builtin_names,
+            dtsRegistry:     this._dts,
+            builtinsRegistry: this._builtins,
+        });
+        // Re-run diagnostics on all open models
+        this._modelStates.forEach(state => state._schedule(0));
+    }
+
+    /**
+     * Asynchronously fetch a .d.ts file using the `loadDts` callback supplied
+     * in options, then register it with addDts().
+     *
+     * Requires `options.loadDts` to have been provided at construction time.
+     * Returns a Promise that resolves when the file has been parsed and registered.
+     *
+     * @param {string} name  identifier passed to the loadDts callback
+     * @returns {Promise<void>}
+     */
+    loadDts(name) {
+        if (!this._loadDts) {
+            return Promise.reject(
+                new Error('registerRapydScript: options.loadDts was not provided')
+            );
+        }
+        const self = this;
+        return Promise.resolve(this._loadDts(name)).then(function (text) {
+            self.addDts(name, text);
+        });
+    }
+
+    /**
+     * Remove all Monaco providers and event listeners registered by this service.
+     */
+    dispose() {
+        this._modelStates.forEach(state => state.dispose());
+        this._modelStates.clear();
+        this._disposables.forEach(d => d.dispose());
+        this._disposables = [];
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Exported factory
+// ---------------------------------------------------------------------------
+
+/**
+ * Register the RapydScript language service with a Monaco instance.
+ *
+ * @param {object} monaco   - the Monaco global (window.monaco or require('monaco-editor'))
+ * @param {object} options
+ * @param {object} options.compiler          - window.RapydScript compiled bundle (required)
+ * @param {object} [options.virtualFiles]    - map of module-name → source
+ * @param {Array}  [options.dtsFiles]        - [{name, content}] d.ts files (Phase 6)
+ * @param {number} [options.parseDelay=300]  - debounce ms
+ * @param {object} [options.extraBuiltins]   - extra {name: true} globals to suppress undef warnings
+ * @param {string} [options.pythonFlags]     - comma-separated python flags (e.g. "dict_literals,overload_getitem")
+ * @returns {RapydScriptLanguageService}
+ */
+export function registerRapydScript(monaco, options) {
+    return new RapydScriptLanguageService(monaco, options || {});
+}

package/src/monaco-language-service/scope.js

@@ -0,0 +1,162 @@
+// scope.js — ScopeMap data structures for the RapydScript language service.
+//
+// Position convention throughout this file:
+//   line   — 1-indexed  (matches Monaco's lineNumber)
+//   column — 1-indexed  (matches Monaco's column)
+// AST tokens use 1-indexed lines and 0-indexed cols; the analyzer converts
+// before storing so callers always work with fully 1-indexed numbers.
+
+// ---------------------------------------------------------------------------
+// SymbolInfo
+// ---------------------------------------------------------------------------
+
+export class SymbolInfo {
+    /**
+     * @param {object} opts
+     * @param {string}  opts.name
+     * @param {string}  opts.kind  'function'|'method'|'class'|'variable'|'parameter'|'import'
+     * @param {{line:number,column:number}} opts.defined_at  1-indexed line and column
+     * @param {number}  opts.scope_depth
+     * @param {string|null} [opts.doc]
+     * @param {Array|null}  [opts.params]  [{name, is_rest, is_kwargs}] for functions/methods
+     */
+    constructor(opts) {
+        this.name        = opts.name;
+        this.kind        = opts.kind;
+        this.defined_at  = opts.defined_at;   // {line, column} both 1-indexed
+        this.scope_depth = opts.scope_depth;
+        this.doc            = opts.doc   || null;
+        this.params         = opts.params || null;
+        this.inferred_class = opts.inferred_class || null;  // 'ClassName' when x = ClassName(...)
+        this.dts_call_path  = opts.dts_call_path  || null;  // 'ns.getServer' when x = ns.getServer(...)
+        this.type           = null;              // Phase 6: TypeInfo
+    }
+}
+
+// ---------------------------------------------------------------------------
+// ScopeFrame
+// ---------------------------------------------------------------------------
+
+export class ScopeFrame {
+    /**
+     * @param {object} opts
+     * @param {string}  opts.kind  'module'|'function'|'class'|'comprehension'|'block'
+     * @param {string|null} opts.name
+     * @param {{start:{line,column}, end:{line,column}}} opts.range  1-indexed
+     * @param {ScopeFrame|null} opts.parent
+     * @param {number} opts.depth
+     */
+    constructor(opts) {
+        this.kind    = opts.kind;
+        this.name    = opts.name || null;
+        this.range   = opts.range;
+        this.parent  = opts.parent || null;
+        this.depth   = opts.depth;
+        this.symbols = new Map();  // name → SymbolInfo
+    }
+
+    /** Add or overwrite a symbol in this frame. */
+    addSymbol(sym) {
+        this.symbols.set(sym.name, sym);
+    }
+
+    /** Return a symbol by exact name, or null. */
+    getSymbol(name) {
+        return this.symbols.get(name) || null;
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Range helpers (all positions 1-indexed)
+// ---------------------------------------------------------------------------
+
+function range_contains(range, line, column) {
+    const { start, end } = range;
+    const after_start = (line > start.line) || (line === start.line && column >= start.column);
+    const before_end  = (line < end.line)   || (line === end.line   && column <= end.column);
+    return after_start && before_end;
+}
+
+// ---------------------------------------------------------------------------
+// ScopeMap
+// ---------------------------------------------------------------------------
+
+export class ScopeMap {
+    constructor() {
+        /** All frames in document order (outer to inner). @type {ScopeFrame[]} */
+        this.frames = [];
+    }
+
+    /** @internal Called by ScopeBuilder as frames are created. */
+    addFrame(frame) {
+        this.frames.push(frame);
+    }
+
+    /**
+     * Return all ScopeFrames whose range contains (line, column), innermost first.
+     * Both line and column are 1-indexed (Monaco format).
+     * @param {number} line
+     * @param {number} column
+     * @returns {ScopeFrame[]}
+     */
+    getScopesAtPosition(line, column) {
+        return this.frames
+            .filter(f => range_contains(f.range, line, column))
+            .sort((a, b) => b.depth - a.depth);
+    }
+
+    /**
+     * Return every symbol visible at (line, column).
+     * When two scopes define the same name, the innermost one wins.
+     * Both line and column are 1-indexed (Monaco format).
+     * @param {number} line
+     * @param {number} column
+     * @returns {SymbolInfo[]}
+     */
+    getSymbolsAtPosition(line, column) {
+        const scopes = this.getScopesAtPosition(line, column);
+        const seen   = new Set();
+        const result = [];
+        for (const scope of scopes) {
+            for (const [name, sym] of scope.symbols) {
+                if (!seen.has(name)) {
+                    seen.add(name);
+                    result.push(sym);
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Look up a single symbol by name that is visible at (line, column).
+     * Returns the innermost definition, or null if not found.
+     * Both line and column are 1-indexed (Monaco format).
+     * @param {string} name
+     * @param {number} line
+     * @param {number} column
+     * @returns {SymbolInfo|null}
+     */
+    getSymbol(name, line, column) {
+        const scopes = this.getScopesAtPosition(line, column);
+        for (const scope of scopes) {
+            const sym = scope.getSymbol(name);
+            if (sym) return sym;
+        }
+        return null;
+    }
+
+    /**
+     * Return all symbols across every scope in the document.
+     * @returns {SymbolInfo[]}
+     */
+    getAllSymbols() {
+        const result = [];
+        for (const frame of this.frames) {
+            for (const sym of frame.symbols.values()) {
+                result.push(sym);
+            }
+        }
+        return result;
+    }
+}

package/src/monaco-language-service/signature.js

@@ -0,0 +1,144 @@
+// signature.js — Signature help provider for the RapydScript language service.
+//
+// Usage:
+//   import { SignatureHelpEngine, detect_call_context } from './signature.js';
+//   const engine = new SignatureHelpEngine();
+//   const help   = engine.getSignatureHelp(scopeMap, position, linePrefix);
+
+// ---------------------------------------------------------------------------
+// Context detection
+// ---------------------------------------------------------------------------
+
+/**
+ * Walk backwards through linePrefix to find the nearest unclosed `(`.
+ * Returns the callee name and which argument position the cursor is in,
+ * or null if the cursor is not inside a call.
+ *
+ * @param {string} linePrefix  text from column 1 up to (but not including) the cursor
+ * @returns {{ callee: string, activeParameter: number }|null}
+ */
+export function detect_call_context(linePrefix) {
+    let depth = 0;
+    let paren_pos = -1;
+
+    // Scan backwards to find the outermost unclosed '('
+    for (let i = linePrefix.length - 1; i >= 0; i--) {
+        const ch = linePrefix[i];
+        if (ch === ')') {
+            depth++;
+        } else if (ch === '(') {
+            if (depth === 0) {
+                paren_pos = i;
+                break;
+            }
+            depth--;
+        }
+    }
+
+    if (paren_pos < 0) return null;  // not inside a call
+
+    // Extract the callee: identifier immediately before the '('
+    const before_paren = linePrefix.slice(0, paren_pos).trimEnd();
+    const callee_match = before_paren.match(/(\w+)$/);
+    if (!callee_match) return null;
+
+    // Count commas at depth 0 between the '(' and the cursor
+    let active_param = 0;
+    let inner_depth  = 0;
+    for (let j = paren_pos + 1; j < linePrefix.length; j++) {
+        const ch = linePrefix[j];
+        if (ch === '(' || ch === '[') {
+            inner_depth++;
+        } else if (ch === ')' || ch === ']') {
+            inner_depth--;
+        } else if (ch === ',' && inner_depth === 0) {
+            active_param++;
+        }
+    }
+
+    return { callee: callee_match[1], activeParameter: active_param };
+}
+
+// ---------------------------------------------------------------------------
+// SignatureHelpEngine
+// ---------------------------------------------------------------------------
+
+export class SignatureHelpEngine {
+
+    /**
+     * @param {import('./builtins.js').BuiltinsRegistry|null} [builtinsRegistry]
+     *   Optional built-in stubs; used as fallback when the callee is not in ScopeMap.
+     */
+    constructor(builtinsRegistry) {
+        this._builtins = builtinsRegistry || null;
+    }
+
+    /**
+     * Return a Monaco ISignatureHelpResult for the cursor position, or null
+     * if the cursor is not inside a known function call.
+     *
+     * Priority: ScopeMap (user-defined) → built-in stubs.
+     *
+     * @param {import('./scope.js').ScopeMap|null} scopeMap
+     * @param {{lineNumber:number,column:number}} position  1-indexed Monaco position
+     * @param {string} linePrefix  text on the current line up to the cursor
+     * @returns {{ value: object, dispose: function }|null}
+     */
+    getSignatureHelp(scopeMap, position, linePrefix) {
+        const ctx = detect_call_context(linePrefix);
+        if (!ctx) return null;
+
+        // 1. User-defined function from ScopeMap
+        if (scopeMap) {
+            const sym = scopeMap.getSymbol(ctx.callee, position.lineNumber, position.column);
+            if (sym && sym.params && sym.params.length > 0) {
+                const param_labels = sym.params.map(function (p) {
+                    if (p.is_separator) return p.name;  // '/' or '*'
+                    if (p.is_kwargs) return '**' + p.name;
+                    if (p.is_rest)   return '*'  + p.name;
+                    return p.name;
+                });
+
+                let active = ctx.activeParameter;
+                if (active > param_labels.length - 1) active = param_labels.length - 1;
+
+                return {
+                    value: {
+                        signatures: [{
+                            label:         ctx.callee + '(' + param_labels.join(', ') + ')',
+                            documentation: sym.doc || undefined,
+                            parameters:    param_labels.map(function (l) { return { label: l }; }),
+                        }],
+                        activeSignature: 0,
+                        activeParameter: active,
+                    },
+                    dispose: function () {},
+                };
+            }
+        }
+
+        // 2. Built-in stubs
+        if (this._builtins) {
+            const info = this._builtins.getSignatureInfo(ctx.callee);
+            if (info) {
+                let active = ctx.activeParameter;
+                if (active > info.params.length - 1) active = info.params.length - 1;
+
+                return {
+                    value: {
+                        signatures: [{
+                            label:         info.label,
+                            documentation: info.doc || undefined,
+                            parameters:    info.params,
+                        }],
+                        activeSignature: 0,
+                        activeParameter: active,
+                    },
+                    dispose: function () {},
+                };
+            }
+        }
+
+        return null;
+    }
+}