rapydscript-ns 0.8.2 → 0.8.3

package/language-service/language-service.d.ts

@@ -0,0 +1,40 @@
+// language-service.d.ts — Ambient type declarations for language-service.js
+// The actual implementation lives in language-service.js (bundled, do not edit directly).
+
+export interface WebReplInstance {
+  in_block_mode: boolean;
+  compile(code: string, opts?: Record<string, unknown>): string;
+  compile_mapped(code: string, opts?: Record<string, unknown>): { code: string; sourceMap: string };
+  runjs(code: string): unknown;
+  replace_print(writeLine: (...args: unknown[]) => void): void;
+  is_input_complete(source: string): boolean;
+  init_completions(completelib: unknown): void;
+  find_completions(line: string): unknown;
+}
+
+export interface RapydScriptOptions {
+  compiler?: unknown;
+  virtualFiles?: Record<string, string>;
+  stdlibFiles?: Record<string, string>;
+  dtsFiles?: Array<{ name: string; content: string }>;
+  parseDelay?: number;
+  extraBuiltins?: Record<string, true>;
+  pythonFlags?: string;
+  pythonize_strings?: boolean;
+  loadDts?: (name: string) => string | Promise<string>;
+}
+
+export declare class RapydScriptLanguageService {
+  constructor(monaco: unknown, options: RapydScriptOptions);
+
+  setVirtualFiles(files: Record<string, string>): void;
+  removeVirtualFile(name: string): void;
+  addGlobals(names: string[]): void;
+  getScopeMap(model: unknown): unknown | null;
+  addDts(name: string, dtsText: string): void;
+  loadDts(name: string): Promise<void>;
+  dispose(): void;
+}
+
+export declare function registerRapydScript(monaco: unknown, options?: RapydScriptOptions): RapydScriptLanguageService;
+export declare function web_repl(): WebReplInstance;

package/package.json

@@ -2,6 +2,11 @@
   "name": "rapydscript-ns",
   "description": "Pythonic JavaScript that doesn't suck",
   "homepage": "https://github.com/ficocelliguy/rapydscript-ns",
+  "version": "0.8.3",
+  "license": "BSD-2-Clause",
+  "engines": {
+    "node": ">=0.12.0"
+  },
   "keywords": [
     "javascript",
     "rapydscript",
@@ -11,7 +16,10 @@
   "main": "tools/compiler.js",
   "exports": {
     ".": "./tools/compiler.js",
-    "./language-service": "./web-repl/language-service.js"
+    "./language-service": {
+      "types": "./language-service/language-service.d.ts",
+      "default": "./language-service/index.js"
+    }
   },
   "scripts": {
     "test": "node bin/rapydscript self --complete --test && npm run test:unit && npm run test:ls",
@@ -23,11 +31,6 @@
     "build": "rm -rf **/*pyj-cached dev && node bin/rapydscript self --complete && node bin/web-repl-export web-repl && node tools/build-language-service.js",
     "prepublishOnly": "node tools/build-language-service.js"
   },
-  "version": "0.8.2",
-  "license": "BSD-2-Clause",
-  "engines": {
-    "node": ">=0.12.0"
-  },
   "maintainers": [
     {
       "name": "Michael Ficocelli",
@@ -39,7 +42,6 @@
     "url": "https://github.com/ficocelliguy/rapydscript-ns.git"
   },
   "dependencies": {
-    "regenerator": ">= 0.12.1",
     "uglify-js": ">= 3.0.15"
   },
   "bin": {

package/src/baselib-builtins.pyj

@@ -164,7 +164,22 @@ def ρσ_reversed(iterable):
         return ans
     raise TypeError('reversed() can only be called on arrays or strings')
 
-def ρσ_iter(iterable):
+def ρσ_iter(iterable, sentinel):
+    # Two-argument form: iter(callable, sentinel) — call repeatedly until sentinel is returned
+    if arguments.length >= 2:
+        callable_ = iterable
+        ans = v'{"_callable":callable_,"_sentinel":sentinel,"_done":false}'
+        ans[ρσ_iterator_symbol] = def():
+            return this
+        ans['next'] = def():
+            if this._done:
+                return v"{'done':true}"
+            val = ρσ_callable_call(this._callable)
+            if v'val === this._sentinel':
+                this._done = True
+                return v"{'done':true}"
+            return v"{'done':false,'value':val}"
+        return ans
     # Generate a JavaScript iterator object from iterable
     if jstype(iterable[ρσ_iterator_symbol]) is 'function':
         return iterable.keys() if jstype(Map) is 'function' and v'iterable instanceof Map' else iterable[ρσ_iterator_symbol]()
@@ -363,6 +378,66 @@ def ρσ_max(*args, **kwargs):
     raise TypeError('expected at least one argument')
 
 
+class ρσ_slice:
+    def __init__(self, start_or_stop, stop, step):
+        if arguments.length is 1:
+            self.start = None
+            self.stop = start_or_stop
+            self.step = None
+        elif arguments.length is 2:
+            self.start = start_or_stop
+            self.stop = stop
+            self.step = None
+        else:
+            self.start = start_or_stop
+            self.stop = stop
+            self.step = step
+
+    def indices(self, length):
+        step = 1 if self.step is None else self.step
+        if step is 0:
+            raise ValueError('slice step cannot be zero')
+        if step > 0:
+            lower = 0
+            upper = length
+            start = lower if self.start is None else self.start
+            stop  = upper if self.stop  is None else self.stop
+        else:
+            lower = -1
+            upper = length - 1
+            start = upper if self.start is None else self.start
+            stop  = lower if self.stop  is None else self.stop
+        # Only clamp values that were explicitly provided (None defaults are already correct).
+        if self.start is not None:
+            if start < 0:
+                start = max(start + length, lower)
+            if start > upper:
+                start = upper
+        if self.stop is not None:
+            if stop < 0:
+                stop = max(stop + length, lower)
+            if stop > upper:
+                stop = upper
+        return start, stop, step
+
+    def __repr__(self):
+        s = 'None' if self.start is None else String(self.start)
+        stop = 'None' if self.stop is None else String(self.stop)
+        step = 'None' if self.step is None else String(self.step)
+        return 'slice(' + s + ', ' + stop + ', ' + step + ')'
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __eq__(self, other):
+        if not v'other instanceof ρσ_slice':
+            return False
+        return self.start is other.start and self.stop is other.stop and self.step is other.step
+
+    def __hash__(self):
+        raise TypeError("unhashable type: 'slice'")
+
+
 v'var abs = Math.abs, max = ρσ_max.bind(Math.max), min = ρσ_max.bind(Math.min), bool = ρσ_bool, type = ρσ_type'
 v'var float = ρσ_float, int = ρσ_int, arraylike = ρσ_arraylike_creator(), ρσ_arraylike = arraylike'
 v'var id = ρσ_id, get_module = ρσ_get_module, pow = ρσ_pow, divmod = ρσ_divmod'
@@ -371,3 +446,4 @@ v'var enumerate = ρσ_enumerate, iter = ρσ_iter, reversed = ρσ_reversed, le
 v'var range = ρσ_range, getattr = ρσ_getattr, setattr = ρσ_setattr, hasattr = ρσ_hasattr, issubclass = ρσ_issubclass, hash = ρσ_hash, next = ρσ_next'
 v'var ρσ_Ellipsis = Object.freeze({toString: function(){return "Ellipsis";}, __repr__: function(){return "Ellipsis";}})'
 v'var Ellipsis = ρσ_Ellipsis'
+v'var slice = ρσ_slice'

package/src/baselib-containers.pyj

@@ -140,7 +140,7 @@ def ρσ_list_sort(key=None, reverse=False):
         k = this[i]  # noqa:undef
         keymap.set(k, key(k))
         posmap.set(k, i)
-    this.sort(def (a, b): return mult * ρσ_list_sort_cmp(keymap.get(a), keymap.get(b), posmap.get(a), posmap.get(b));)
+    Array.prototype.sort.call(this, def (a, b): return mult * ρσ_list_sort_cmp(keymap.get(a), keymap.get(b), posmap.get(a), posmap.get(b));)
 
 def ρσ_list_concat():  # ensure concat() returns an object of type list
     ans = Array.prototype.concat.apply(this, arguments)
@@ -190,14 +190,18 @@ def ρσ_list_decorate(ans):
     ans.inspect = ρσ_list_to_string
     ans.extend = ρσ_list_extend
     ans.index = ρσ_list_index
-    ans.pypop = ρσ_list_pop
+    ans.jspop = Array.prototype.pop      # native JS pop (no bounds check, ignores args)
+    ans.pop = ρσ_list_pop                # Python pop (bounds-checked, supports negative index)
+    ans.pypop = ρσ_list_pop              # backward-compat alias for pop
     ans.remove = ρσ_list_remove
     ans.insert = ρσ_list_insert
     ans.copy = ρσ_list_copy
     ans.clear = ρσ_list_clear
     ans.count = ρσ_list_count
     ans.concat = ρσ_list_concat
-    ans.pysort = ρσ_list_sort
+    ans.jssort = Array.prototype.sort    # native JS sort (lexicographic by default)
+    ans.sort = ρσ_list_sort              # Python sort (numeric by default)
+    ans.pysort = ρσ_list_sort            # backward-compat alias for sort
     ans.slice = ρσ_list_slice
     ans.as_array = ρσ_list_as_array
     ans.__len__ = ρσ_list_len
@@ -235,7 +239,7 @@ v'var list = ρσ_list_constructor, list_wrap = ρσ_list_decorate'
 
 def sorted(iterable, key=None, reverse=False):
     ans = ρσ_list_constructor(iterable)
-    ans.pysort(key, reverse)
+    ans.sort(key, reverse)
     return ans
 # }}}
 

package/src/baselib-internal.pyj

@@ -1,7 +1,7 @@
 # vim:fileencoding=utf-8
 # License: BSD
 
-# globals: exports, console, ρσ_iterator_symbol, ρσ_kwargs_symbol, ρσ_arraylike, ρσ_list_contains, ρσ_list_constructor, ρσ_str, ρσ_int, ρσ_float
+# globals: exports, console, ρσ_iterator_symbol, ρσ_kwargs_symbol, ρσ_arraylike, ρσ_list_contains, ρσ_list_constructor, ρσ_str, ρσ_int, ρσ_float, ρσ_slice
 
 def ρσ_eslice(arr, step, start, end):
     if jstype(arr) is 'string' or v'arr instanceof String':
@@ -179,6 +179,11 @@ def ρσ_interpolate_kwargs_constructor(apply, f, supplied_args):
 def ρσ_getitem(obj, key):
     if obj.__getitem__:
         return obj.__getitem__(key)
+    if v'typeof ρσ_slice !== "undefined" && key instanceof ρσ_slice':
+        return ρσ_eslice(obj,
+            v'(key.step  !== null && key.step  !== undefined) ? key.step  : 1',
+            v'(key.start !== null && key.start !== undefined) ? key.start : undefined',
+            v'(key.stop  !== null && key.stop  !== undefined) ? key.stop  : undefined')
     if jstype(key) is 'number' and key < 0:
         key += obj.length
     return obj[key]
@@ -186,6 +191,10 @@ def ρσ_getitem(obj, key):
 def ρσ_setitem(obj, key, val):
     if obj.__setitem__:
         obj.__setitem__(key, val)
+    elif v'typeof ρσ_slice !== "undefined" && key instanceof ρσ_slice':
+        ρσ_splice(obj, val,
+            v'(key.start !== null && key.start !== undefined) ? key.start : 0',
+            v'(key.stop  !== null && key.stop  !== undefined) ? key.stop  : obj.length')
     else:
         if jstype(key) is 'number' and key < 0:
             key += obj.length
@@ -195,6 +204,11 @@ def ρσ_setitem(obj, key, val):
 def ρσ_delitem(obj, key):
     if obj.__delitem__:
         obj.__delitem__(key)
+    elif v'typeof ρσ_slice !== "undefined" && key instanceof ρσ_slice':
+        ρσ_delslice(obj,
+            v'(key.step  !== null && key.step  !== undefined) ? key.step  : 1',
+            v'(key.start !== null && key.start !== undefined) ? key.start : undefined',
+            v'(key.stop  !== null && key.stop  !== undefined) ? key.stop  : undefined')
     elif jstype(obj.splice) is 'function':
         obj.splice(key, 1)
     else:
@@ -339,6 +353,21 @@ def ρσ_op_rshift(a, b):
     if b is not None and jstype(b.__rrshift__) is 'function': return b.__rrshift__(a)
     return a >> b
 
+# List-concatenation helpers (always available, no overload_operators required).
+# ρσ_list_add: used for the + operator; creates a new list when both sides are arrays.
+# NOTE: the fallback uses v'a + b' (verbatim JS) to avoid recursive self-compilation.
+def ρσ_list_add(a, b):
+    if Array.isArray(a) and Array.isArray(b):
+        return ρσ_list_constructor(a.concat(b))
+    return v'a + b'
+
+# ρσ_list_iadd: used for +=; extends a in-place when both sides are arrays (Python semantics).
+def ρσ_list_iadd(a, b):
+    if Array.isArray(a) and Array.isArray(b):
+        v'Array.prototype.push.apply(a, b)'
+        return a
+    return v'a + b'
+
 # Unary operator overloading helpers
 def ρσ_op_neg(a):
     if a is not None and jstype(a.__neg__) is 'function': return a.__neg__()

package/src/baselib-str.pyj

@@ -829,4 +829,11 @@ define_str_func('zfill', def(width):
 ρσ_str.whitespace   = ' \t\n\r\x0b\x0c'
 
 v'define_str_func = undefined'
-v'var str = ρσ_str, repr = ρσ_repr'
+def ρσ_format(value, spec):
+    if value is not None and value is not undefined and v'typeof value.__format__ === "function"':
+        return value.__format__(spec if spec is not undefined else '')
+    if spec is undefined or spec is '':
+        return ρσ_str(value)
+    return str.format('{:' + spec + '}', value)
+
+v'var str = ρσ_str, repr = ρσ_repr, format = ρσ_format'

package/src/lib/collections.pyj

@@ -353,7 +353,7 @@ class Counter:
 
     def most_common(self, n=None):
         items = [[k, self._data[k]] for k in self._data]
-        items.pysort(key=def(pair): return -pair[1];)
+        items.sort(key=def(pair): return -pair[1];)
         if n is not None:
             return items[:n]
         return items

package/src/lib/numpy.pyj

@@ -1055,7 +1055,7 @@ def sort(a, axis=-1):
     a = asarray(a)
     if a.ndim is 1 or axis is None:
         data = a._data.slice()
-        data.sort(def(x, y): return x - y;)
+        data.jssort(def(x, y): return x - y;)
         return ndarray(a.shape.slice(), a.dtype, data, True)
     # 2D sort along last axis (axis=1 or axis=-1)
     if axis < 0:
@@ -1066,7 +1066,7 @@ def sort(a, axis=-1):
     if axis is 1:
         for i in range(rows):
             row = a._data.slice(i * cols, (i + 1) * cols)
-            row.sort(def(x, y): return x - y;)
+            row.jssort(def(x, y): return x - y;)
             for v in row:
                 new_data.push(v)
     elif axis is 0:
@@ -1074,7 +1074,7 @@ def sort(a, axis=-1):
             col = []
             for i in range(rows):
                 col.push(a._data[i * cols + j])
-            col.sort(def(x, y): return x - y;)
+            col.jssort(def(x, y): return x - y;)
             for i in range(rows):
                 new_data[i * cols + j] = col[i]
         if new_data.length is 0:
@@ -1089,14 +1089,14 @@ def argsort(a, axis=-1):
         for i in range(a.size):
             indices.push(i)
         data = a._data.slice()
-        indices.sort(def(i, j): return data[i] - data[j];)
+        indices.jssort(def(i, j): return data[i] - data[j];)
         return ndarray([a.size], 'int32', indices, True)
     # Flatten and sort
     data = a._data.slice()
     indices = []
     for i in range(data.length):
         indices.push(i)
-    indices.sort(def(i, j): return data[i] - data[j];)
+    indices.jssort(def(i, j): return data[i] - data[j];)
     return ndarray([indices.length], 'int32', indices, True)
 
 def searchsorted(a, v, side='left'):
@@ -1157,7 +1157,7 @@ def where(condition, x=None, y=None):
 def median(a, axis=None):
     a = asarray(a)
     data = a._data.slice()
-    data.sort(def(x, y): return x - y;)
+    data.jssort(def(x, y): return x - y;)
     n = data.length
     if n % 2 is 1:
         return data[Math.floor(n / 2)]
@@ -1166,7 +1166,7 @@ def median(a, axis=None):
 def percentile(a, q, axis=None):
     a = asarray(a)
     data = a._data.slice()
-    data.sort(def(x, y): return x - y;)
+    data.jssort(def(x, y): return x - y;)
     n = data.length
     idx = q / 100.0 * (n - 1)
     lo = Math.floor(idx)
@@ -1497,7 +1497,7 @@ def union1d(ar1, ar2):
         if not seen[key]:
             seen[key] = True
             unique.push(v)
-    unique.sort(def(a, b): return a - b;)
+    unique.jssort(def(a, b): return a - b;)
     return ndarray([unique.length], 'float64', unique, True)
 
 def intersect1d(ar1, ar2):
@@ -1513,7 +1513,7 @@ def intersect1d(ar1, ar2):
         if s[key] and not seen[key]:
             seen[key] = True
             result.push(v)
-    result.sort(def(a, b): return a - b;)
+    result.jssort(def(a, b): return a - b;)
     return ndarray([result.length], 'float64', result, True)
 
 def setdiff1d(ar1, ar2):
@@ -1529,7 +1529,7 @@ def setdiff1d(ar1, ar2):
         if not s[key] and not seen[key]:
             seen[key] = True
             result.push(v)
-    result.sort(def(a, b): return a - b;)
+    result.jssort(def(a, b): return a - b;)
     return ndarray([result.length], 'float64', result, True)
 
 def in1d(ar1, ar2):

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

@@ -46,6 +46,95 @@ function dot_path_from_node(node, RS) {
     return null;
 }
 
+/**
+ * Infer the type of a single return-value expression.
+ * Returns a type string ('list', 'dict', 'str', 'number', 'bool', or a class name),
+ * or null if the type cannot be determined from this expression alone.
+ *
+ * @param {object}     node   - The AST expression node (return value)
+ * @param {ScopeFrame} scope  - The function's own scope frame (fully populated)
+ * @param {object}     RS     - RapydScript compiler object
+ * @returns {string|null}
+ */
+function infer_expr_type(node, scope, RS) {
+    if (node instanceof RS.AST_Array)  return 'list';
+    if (node instanceof RS.AST_Object) return 'dict';
+    if (node instanceof RS.AST_String) return 'str';
+    if (node instanceof RS.AST_Number) return 'number';
+    if ((RS.AST_True  && node instanceof RS.AST_True) ||
+        (RS.AST_False && node instanceof RS.AST_False)) return 'bool';
+    if (RS.AST_Null && node instanceof RS.AST_Null) return null;  // None → not counted
+
+    if (node instanceof RS.AST_SymbolRef) {
+        const sym = scope ? scope.getSymbol(node.name) : null;
+        return (sym && sym.inferred_class) ? sym.inferred_class : null;
+    }
+
+    if (node instanceof RS.AST_BaseCall && node.expression instanceof RS.AST_SymbolRef) {
+        const name = node.expression.name;
+        // PascalCase → assume class constructor, use name as type
+        if (/^[A-Z]/.test(name)) return name;
+        // Known local function with an already-resolved return_type
+        const sym = scope ? scope.getSymbol(name) : null;
+        if (sym && sym.return_type) return sym.return_type;
+    }
+
+    return null;
+}
+
+/**
+ * Walk a function node's body, collect all return-expression types, and return
+ * the single inferred type if every non-None return agrees on one type.
+ * Skips nested function bodies (their returns don't belong to this function).
+ * Returns null if returns disagree, are unrecognised, or the body has no typed returns.
+ *
+ * @param {object}     func_node  - AST_Lambda node
+ * @param {ScopeFrame} func_scope - The function's own scope frame (already populated)
+ * @param {object}     RS         - RapydScript compiler object
+ * @returns {string|null}
+ */
+function collect_return_type(func_node, func_scope, RS) {
+    const types = new Set();
+    // Use a plain visitor object (same pattern as ScopeBuilder): _visit(node, descend)
+    // receives the node and a closure that walks its children; call descend() to recurse.
+    func_node.walk({
+        _visit: function (node, descend) {
+            // Stop descent into nested functions — their returns are not ours.
+            if (node !== func_node && node instanceof RS.AST_Lambda) return;
+            if (node instanceof RS.AST_Return && node.value) {
+                const t = infer_expr_type(node.value, func_scope, RS);
+                if (t) types.add(t);
+            }
+            if (descend) descend();  // recurse into children
+        },
+    });
+    return types.size === 1 ? [...types][0] : null;
+}
+
+/**
+ * Extract the return type annotation from a function node as a normalized string.
+ * Maps `-> [X]` to 'list', `-> {k: v}` to 'dict', `-> str` to 'str', etc.
+ * Returns null if no annotation or unrecognised shape.
+ * @param {object} func_node
+ * @param {object} RS
+ * @returns {string|null}
+ */
+function extract_return_type(func_node, RS) {
+    const ann = func_node.return_annotation;
+    if (!ann) return null;
+    if (ann instanceof RS.AST_Array) return 'list';
+    if (ann instanceof RS.AST_Object) return 'dict';
+    if (ann instanceof RS.AST_SymbolRef ||
+        (RS.AST_SymbolVar && ann instanceof RS.AST_SymbolVar)) {
+        const n = ann.name;
+        if (n === 'str' || n === 'string') return 'str';
+        if (n === 'int' || n === 'float' || n === 'number') return 'number';
+        if (n === 'bool' || n === 'boolean') return 'bool';
+        return n;  // user-defined class name or 'list'/'dict' spelled out
+    }
+    return null;
+}
+
 /**
  * Collect parameter descriptors from an AST_Lambda node.
  * Handles regular args, positional-only (/), keyword-only (*), *args, and **kwargs.
@@ -94,10 +183,11 @@ function extract_params(lambda_node) {
 
 class ScopeBuilder {
     constructor(RS, map) {
-        this._RS          = RS;
-        this._map         = map;
-        this._scopes      = [];   // stack of ScopeFrame
-        this.current_node = null;
+        this._RS                  = RS;
+        this._map                 = map;
+        this._scopes              = [];   // stack of ScopeFrame
+        this.current_node         = null;
+        this._current_from_module = null; // set while inside an AST_Import with argnames
     }
 
     _current_scope() {
@@ -143,6 +233,9 @@ class ScopeBuilder {
             params:         opts.params         || null,
             inferred_class: opts.inferred_class || null,
             dts_call_path:  opts.dts_call_path  || null,
+            return_type:    opts.return_type    || null,
+            source_module:  opts.source_module  || null,
+            original_name:  opts.original_name  || null,
         });
         scope.addSymbol(sym);
         return sym;
@@ -176,6 +269,7 @@ class ScopeBuilder {
                         scope_depth: parent.depth,
                         doc:         extract_doc(node),
                         params:      extract_params(node),
+                        return_type: extract_return_type(node, RS),
                     });
                     parent.addSymbol(sym);
                 }
@@ -239,18 +333,28 @@ class ScopeBuilder {
                 defined_at: pos_from_token(node.start),
             });
 
+        } else if (node instanceof RS.AST_Import && node.argnames) {
+            // `from X import name [as alias], ...` — record module name so children can use it.
+            const mod_node = node.module;
+            this._current_from_module = mod_node
+                ? (mod_node.name || mod_node.value || null)
+                : null;
+
         } else if (node instanceof RS.AST_ImportedVar) {
             // `from X import name` or `from X import name as alias`
-            const name = (node.alias && node.alias.name) ? node.alias.name : node.name;
-            if (name) {
+            const alias = (node.alias && node.alias.name) ? node.alias.name : node.name;
+            if (alias) {
                 this._add_symbol({
-                    name,
-                    kind:       'import',
-                    defined_at: pos_from_token(node.start),
+                    name:          alias,
+                    kind:          'import',
+                    defined_at:    pos_from_token(node.start),
+                    source_module: this._current_from_module || null,
+                    original_name: (node.name !== alias) ? node.name : null,
                 });
             }
 
         } else if (node instanceof RS.AST_Import && !node.argnames) {
+            this._current_from_module = null;
             // `import X` or `import X as Y` (no from-clause)
             const name = (node.alias && node.alias.name)
                 ? node.alias.name
@@ -456,6 +560,24 @@ class ScopeBuilder {
 
         if (cont) cont();
 
+        // ------------------------------------------------------------------
+        // 3b. Post-traversal: infer return type for unannotated functions.
+        //     The function's own scope is fully populated at this point, so
+        //     local variable inferred_class values are available for lookup.
+        // ------------------------------------------------------------------
+
+        if (node instanceof RS.AST_Lambda && this._scopes.length > prev_depth) {
+            const func_scope   = this._current_scope();
+            const parent_frame = func_scope ? func_scope.parent : null;
+            const fname        = node.name ? node.name.name : null;
+            if (fname && parent_frame) {
+                const sym = parent_frame.getSymbol(fname);
+                if (sym && !sym.return_type) {
+                    sym.return_type = collect_return_type(node, func_scope, RS);
+                }
+            }
+        }
+
         // ------------------------------------------------------------------
         // 4. Pop the scope we pushed (if any).
         // ------------------------------------------------------------------

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

@@ -104,6 +104,11 @@ const STUBS = [
         return_type: 'iterable',
         doc: 'Return an iterator of elements from iterable for which function returns true.' }),
 
+    new BuiltinInfo({ name: 'format',
+        params: [p('value'), p('spec', { type: 'str', optional: true })],
+        return_type: 'str',
+        doc: 'Return value formatted according to the format spec string.\n\nEquivalent to calling `value.__format__(spec)` or applying spec as a `str.format()` format-spec field. The spec mini-language is the same as what follows `:` in f-strings and `str.format()` fields: alignment (`<>^=`), sign (`+-`), width, grouping (`,_`), precision (`.N`), and type (`bcdoxXeEfFgGns%`).\n\nExamples:\n\n    format(42, \'08b\')    # \'00101010\'\n    format(3.14, \'.2f\')  # \'3.14\'\n    format(\'hi\', \'>10\')  # \'        hi\'\n    format(42)           # \'42\'' }),
+
     new BuiltinInfo({ name: 'float', kind: 'class',
         params: [p('x', { optional: true })],
         return_type: 'float',
@@ -150,9 +155,9 @@ const STUBS = [
         doc: 'Return True if cls is a subclass of classinfo. classinfo may be a class or tuple of classes.' }),
 
     new BuiltinInfo({ name: 'iter',
-        params: [p('obj')],
+        params: [p('obj'), p('sentinel', { optional: true })],
         return_type: 'iterator',
-        doc: 'Return an iterator object for obj.' }),
+        doc: 'iter(iterable) → iterator over iterable. iter(callable, sentinel) → calls callable repeatedly until it returns sentinel.' }),
 
     new BuiltinInfo({ name: 'len',
         params: [p('s')],
@@ -219,6 +224,11 @@ const STUBS = [
         return_type: 'set',
         doc: 'Create a new set, optionally populated from an iterable.' }),
 
+    new BuiltinInfo({ name: 'slice', kind: 'class',
+        params: [p('start_or_stop', { type: 'int' }), p('stop', { type: 'int', optional: true }), p('step', { type: 'int', optional: true })],
+        return_type: 'slice',
+        doc: 'Create a slice object representing the set of indices specified by range(start, stop, step).\n\nForms:\n- `slice(stop)` — equivalent to `slice(None, stop, None)`\n- `slice(start, stop)` — equivalent to `slice(start, stop, None)`\n- `slice(start, stop, step)` — full form\n\nAttributes: `.start`, `.stop`, `.step` (each may be `None`).\n\nMethod: `.indices(length)` — returns `(start, stop, step)` normalized for a sequence of the given length.\n\nExample:\n\n    s = slice(1, 5)\n    lst[s]         # same as lst[1:5]\n    s.indices(10)  # (1, 5, 1)' }),
+
     new BuiltinInfo({ name: 'setattr',
         params: [p('obj'), p('name', { type: 'str' }), p('value')],
         return_type: 'None',