rapydscript-ns 0.8.1 → 0.8.3

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:
@@ -282,6 +296,16 @@ def ρσ_op_mul(a, b):
     if b is not None and jstype(b.__rmul__) is 'function': return b.__rmul__(a)
     if (jstype(a) is 'string' or v'a instanceof String') and jstype(b) is 'number': return a.repeat(b)
     if (jstype(b) is 'string' or v'b instanceof String') and jstype(a) is 'number': return b.repeat(a)
+    if Array.isArray(a) and jstype(b) is 'number':
+        result = v'[]'
+        for v'var ρσ_mi = 0; ρσ_mi < b; ρσ_mi++':
+            result = result.concat(a)  # noqa:undef
+        return ρσ_list_constructor(result)
+    if Array.isArray(b) and jstype(a) is 'number':
+        result = v'[]'
+        for v'var ρσ_mi = 0; ρσ_mi < a; ρσ_mi++':
+            result = result.concat(b)  # noqa:undef
+        return ρσ_list_constructor(result)
     return a * b
 
 def ρσ_op_truediv(a, b):
@@ -329,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

@@ -525,6 +525,40 @@ define_str_func('isspace', def():
     return this.length > 0 and /^\s+$/.test(this)
 )
 
+define_str_func('isalpha', def():
+    return this.length > 0 and /^[a-zA-Z]+$/.test(this)
+)
+
+define_str_func('isdigit', def():
+    return this.length > 0 and /^\d+$/.test(this)
+)
+
+define_str_func('isalnum', def():
+    return this.length > 0 and /^[a-zA-Z0-9]+$/.test(this)
+)
+
+define_str_func('isidentifier', def():
+    return this.length > 0 and /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(this)
+)
+
+define_str_func('casefold', def():
+    return this.toLowerCase()
+)
+
+define_str_func('removeprefix', def(prefix):
+    s = this.toString()
+    if s.startsWith(prefix):
+        return s.slice(prefix.length)
+    return s
+)
+
+define_str_func('removesuffix', def(suffix):
+    s = this.toString()
+    if suffix.length and s.endsWith(suffix):
+        return s.slice(0, s.length - suffix.length)
+    return s
+)
+
 define_str_func('join', def(iterable):
     if Array.isArray(iterable):
         return iterable.join(this)
@@ -795,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

@@ -6,24 +6,12 @@
 //   const scopeMap = analyzer.analyze(sourceCode, { virtualFiles: {...} });
 
 import { ScopeMap, ScopeFrame, SymbolInfo } from './scope.js';
+import { build_scoped_flags } from './diagnostics.js';
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-function build_scoped_flags(flags_str) {
-    const result = Object.create(null);
-    if (!flags_str) return result;
-    flags_str.split(',').forEach(flag => {
-        flag = flag.trim();
-        if (!flag) return;
-        let val = true;
-        if (flag.startsWith('no_')) { val = false; flag = flag.slice(3); }
-        result[flag] = val;
-    });
-    return result;
-}
-
 /** Convert AST token position {line (1-indexed), col (0-indexed)} → {line, column} (both 1-indexed). */
 function pos_from_token(tok) {
     if (!tok) return { line: 1, column: 1 };
@@ -58,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.
@@ -106,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() {
@@ -155,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;
@@ -188,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);
                 }
@@ -251,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
@@ -468,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',
@@ -114,6 +119,11 @@ const STUBS = [
         return_type: 'any',
         doc: 'Return the value of the named attribute of obj. If not found, return default (or raise AttributeError).' }),
 
+    new BuiltinInfo({ name: 'hash',
+        params: [p('obj')],
+        return_type: 'int',
+        doc: 'Return the hash value of obj. Strings and numbers are hashed by value; class instances by identity. Raises TypeError for unhashable types (list, set, dict). Objects with __hash__ dispatch to it.' }),
+
     new BuiltinInfo({ name: 'hasattr',
         params: [p('obj'), p('name', { type: 'str' })],
         return_type: 'bool',
@@ -139,10 +149,15 @@ const STUBS = [
         return_type: 'bool',
         doc: 'Return True if obj is an instance of classinfo (or a subclass thereof).' }),
 
+    new BuiltinInfo({ name: 'issubclass',
+        params: [p('cls'), p('classinfo')],
+        return_type: 'bool',
+        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')],
@@ -209,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',