rapydscript-ns 0.8.0

package/src/lib/traceback.pyj

@@ -0,0 +1,63 @@
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+# globals: ρσ_str, ρσ_last_exception
+
+
+def _get_internal_traceback(err):
+    if isinstance(err, Exception) and err.stack:
+        lines = ρσ_str.splitlines(err.stack)
+        final_lines = v'[]'
+        found_sentinel = False
+        for i, line in enumerate(lines):
+            sline = ρσ_str.strip(line)
+            if i is 0:
+                final_lines.push(line)
+                continue
+            if found_sentinel:
+                final_lines.push(line)
+                continue
+            # These two conditions work on desktop Chrome and Firefox to identify the correct
+            # line in the traceback.
+            if sline.startsWith('at new ' + err.name) or sline.startsWith(err.name + '@'):
+                found_sentinel = True
+        return final_lines.join('\n')
+    return err and err.stack
+
+def format_exception(exc, limit):
+    if jstype(exc) is 'undefined':
+        exc = ρσ_last_exception
+    if not isinstance(exc, Error):
+        if exc and exc.toString:
+            return [exc.toString()]
+        return []
+    tb = _get_internal_traceback(exc)
+    if tb:
+        lines = ρσ_str.splitlines(tb)
+        e = lines[0]
+        lines = lines[1:]
+        if limit:
+            lines = lines[:limit+1] if limit > 0 else lines[limit:]
+        lines.reverse()
+        lines.push(e)
+        lines.insert(0, 'Traceback (most recent call last):')
+        return [l+'\n' for l in lines]
+    return [exc.toString()]
+
+def format_exc(limit):
+    return format_exception(ρσ_last_exception, limit).join('')
+
+def print_exc(limit):
+    print(format_exc(limit))
+
+def format_stack(limit):
+    stack = Error().stack
+    if not stack:
+        return []
+    lines = str.splitlines(stack)[2:]
+    lines.reverse()
+    if limit:
+        lines = lines[:limit+1] if limit > 0 else lines[limit:]
+    return [l + '\n' for l in lines]
+
+def print_stack(limit):
+    print(format_stack(limit).join(''))

package/src/lib/uuid.pyj

@@ -0,0 +1,77 @@
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2017, Kovid Goyal <kovid at kovidgoyal.net>
+# globals: crypto
+from __python__ import hash_literals
+
+from encodings import hexlify, urlsafe_b64decode, urlsafe_b64encode
+
+RFC_4122 = 1
+
+if jstype(crypto) is 'object' and crypto.getRandomValues:
+    random_bytes = def (num):
+        ans = Uint8Array(num or 16)
+        crypto.getRandomValues(ans)
+        return ans
+else:
+    random_bytes = def (num):
+        ans = Uint8Array(num or 16)
+        for i in range(ans.length):
+            ans[i] = Math.floor(Math.random() * 256)
+        return ans
+
+
+def uuid4_bytes():
+    data = random_bytes()
+    data[6] = 0b01000000 | (data[6] & 0b1111)
+    data[8] = (((data[8] >> 4) & 0b11 | 0b1000) << 4) | (data[8] & 0b1111)
+    return data
+
+
+def as_str():
+    h = this.hex
+    return h[:8] + '-' + h[8:12] + '-' + h[12:16] + '-' + h[16:20] + '-' + h[20:]
+
+
+def uuid4():
+    b = uuid4_bytes()
+    return {
+        'hex': hexlify(b),
+        'bytes': b,
+        'variant': RFC_4122,
+        'version': 4,
+        '__str__': as_str,
+        'toString': as_str,
+    }
+
+
+def num_to_string(numbers, alphabet, pad_to_length):
+    ans = v'[]'
+    alphabet_len = alphabet.length
+    numbers = Array.prototype.slice.call(numbers)
+    for v'var i = 0; i < numbers.length - 1; i++':
+        x = divmod(numbers[i], alphabet_len)
+        numbers[i] = x[0]
+        numbers[i+1] += x[1]
+    for v'var i = 0; i < numbers.length; i++':
+        number = numbers[i]
+        while number:
+            x = divmod(number, alphabet_len)
+            number = x[0]
+            ans.push(alphabet[x[1]])
+    if pad_to_length and pad_to_length > ans.length:
+        ans.push(alphabet[0].repeat(pad_to_length - ans.length))
+    return ans.join('')
+
+
+def short_uuid():
+    # A totally random uuid encoded using only URL and filename safe characters
+    return urlsafe_b64encode(random_bytes(), '')
+
+
+def short_uuid4():
+    # A uuid4 encoded using only URL and filename safe characters
+    return urlsafe_b64encode(uuid4_bytes(), '')
+
+
+def decode_short_uuid(val):
+    return urlsafe_b64decode(val + '==')

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

@@ -0,0 +1,526 @@
+// analyzer.js — AST walker that builds a ScopeMap for a RapydScript source file.
+//
+// Usage:
+//   import { SourceAnalyzer } from './analyzer.js';
+//   const analyzer = new SourceAnalyzer(compiler);
+//   const scopeMap = analyzer.analyze(sourceCode, { virtualFiles: {...} });
+
+import { ScopeMap, ScopeFrame, SymbolInfo } from './scope.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 };
+    return { line: tok.line, column: tok.col + 1 };
+}
+
+/**
+ * Extract the first docstring value from a scope node, if present.
+ * The parser populates node.docstrings for AST_Scope nodes.
+ */
+function extract_doc(node) {
+    if (node.docstrings && node.docstrings.length > 0) {
+        const ds = node.docstrings[0];
+        return ds.value !== undefined ? ds.value : null;
+    }
+    return null;
+}
+
+/**
+ * Recursively build a dot-path string from a chain of AST_Dot / AST_SymbolRef nodes.
+ * Returns null if the node is not a plain dot-chain (e.g. bracket subscript access).
+ * Examples:
+ *   AST_SymbolRef{name:'ns'}                        → 'ns'
+ *   AST_Dot{expr: AST_SymbolRef{name:'ns'}, prop: 'getServer'}  → 'ns.getServer'
+ */
+function dot_path_from_node(node, RS) {
+    if (node instanceof RS.AST_SymbolRef) return node.name;
+    if (node instanceof RS.AST_Dot) {
+        const left = dot_path_from_node(node.expression, RS);
+        return left ? left + '.' + node.property : null;
+    }
+    return null;
+}
+
+/**
+ * Collect parameter descriptors from an AST_Lambda node.
+ * Handles regular args, positional-only (/), keyword-only (*), *args, and **kwargs.
+ * Each entry: { name, is_rest, is_kwargs, is_posonly, is_kwonly, is_separator }
+ * Separator entries have is_separator=true and name='/' or '*'.
+ */
+function extract_params(lambda_node) {
+    const params = [];
+    const argnames = lambda_node.argnames;
+    if (!argnames) return params;
+
+    let posonly_done = false;
+    argnames.forEach(arg => {
+        if (!arg || !arg.name) return;
+        // Emit '/' separator after all positional-only args
+        if (!posonly_done && !arg.posonly && (argnames.posonly_count || 0) > 0) {
+            params.push({ name: '/', is_rest: false, is_kwargs: false, is_posonly: false, is_kwonly: false, is_separator: true });
+            posonly_done = true;
+        } else if (!posonly_done && arg.posonly) {
+            posonly_done = false; // still in posonly section
+        }
+        params.push({ name: arg.name, is_rest: false, is_kwargs: false,
+                      is_posonly: !!arg.posonly, is_kwonly: !!arg.kwonly, is_separator: false });
+    });
+    // If all args were posonly, still emit the '/' separator
+    if (!posonly_done && (argnames.posonly_count || 0) > 0 && !argnames.starargs && !argnames.bare_star) {
+        params.push({ name: '/', is_rest: false, is_kwargs: false, is_posonly: false, is_kwonly: false, is_separator: true });
+    }
+    if (argnames.bare_star) {
+        params.push({ name: '*', is_rest: false, is_kwargs: false, is_posonly: false, is_kwonly: false, is_separator: true });
+    }
+    if (argnames.starargs && argnames.starargs.name) {
+        params.push({ name: argnames.starargs.name, is_rest: true,  is_kwargs: false, is_posonly: false, is_kwonly: false, is_separator: false });
+    }
+    if (argnames.kwargs && argnames.kwargs.name) {
+        params.push({ name: argnames.kwargs.name,  is_rest: false, is_kwargs: true,  is_posonly: false, is_kwonly: false, is_separator: false });
+    }
+    return params;
+}
+
+// ---------------------------------------------------------------------------
+// ScopeBuilder — internal AST visitor
+// Mirrors the structure of tools/lint.js's Linter but builds a ScopeMap
+// instead of recording lint errors.
+// ---------------------------------------------------------------------------
+
+class ScopeBuilder {
+    constructor(RS, map) {
+        this._RS          = RS;
+        this._map         = map;
+        this._scopes      = [];   // stack of ScopeFrame
+        this.current_node = null;
+    }
+
+    _current_scope() {
+        return this._scopes.length ? this._scopes[this._scopes.length - 1] : null;
+    }
+
+    _push_scope(kind, name, node) {
+        const parent = this._current_scope();
+        const depth  = parent ? parent.depth + 1 : 0;
+
+        const start_tok = node.start;
+        const end_tok   = node.end;
+
+        const frame = new ScopeFrame({
+            kind,
+            name,
+            range: {
+                start: start_tok ? { line: start_tok.line, column: start_tok.col + 1 } : { line: 1, column: 1 },
+                end:   end_tok   ? { line: end_tok.line,   column: end_tok.col   + 1 } : { line: 999999, column: 999999 },
+            },
+            parent,
+            depth,
+        });
+
+        this._map.addFrame(frame);
+        this._scopes.push(frame);
+        return frame;
+    }
+
+    _pop_scope() {
+        return this._scopes.pop();
+    }
+
+    _add_symbol(opts) {
+        const scope = this._current_scope();
+        if (!scope || !opts.name) return null;
+        const sym = new SymbolInfo({
+            name:           opts.name,
+            kind:           opts.kind,
+            defined_at:     opts.defined_at || { line: 1, column: 1 },
+            scope_depth:    scope.depth,
+            doc:            opts.doc            || null,
+            params:         opts.params         || null,
+            inferred_class: opts.inferred_class || null,
+            dts_call_path:  opts.dts_call_path  || null,
+        });
+        scope.addSymbol(sym);
+        return sym;
+    }
+
+    // ---- The visitor function called by node.walk() ----------------------
+
+    _visit(node, cont) {
+        this.current_node = node;
+        const RS          = this._RS;
+        const prev_depth  = this._scopes.length;
+
+        // ------------------------------------------------------------------
+        // 1. Scope-creating nodes — push a frame BEFORE recursing.
+        //    Order matters: more specific classes first (AST_Method < AST_Lambda < AST_Scope).
+        // ------------------------------------------------------------------
+
+        if (node instanceof RS.AST_Lambda) {
+            // Covers AST_Function and AST_Method.
+            const is_method = node instanceof RS.AST_Method;
+            const name      = node.name ? node.name.name : null;
+
+            // Add the function/method symbol to the PARENT scope first.
+            if (name) {
+                const parent = this._current_scope();
+                if (parent) {
+                    const sym = new SymbolInfo({
+                        name,
+                        kind:        is_method ? 'method' : 'function',
+                        defined_at:  pos_from_token(node.start),
+                        scope_depth: parent.depth,
+                        doc:         extract_doc(node),
+                        params:      extract_params(node),
+                    });
+                    parent.addSymbol(sym);
+                }
+            }
+
+            // Push a new scope for the function body.
+            this._push_scope(is_method ? 'function' : 'function', name, node);
+
+        } else if (node instanceof RS.AST_Class) {
+            const name = node.name ? node.name.name : null;
+
+            // Add class symbol to the parent scope.
+            if (name) {
+                const parent = this._current_scope();
+                if (parent) {
+                    parent.addSymbol(new SymbolInfo({
+                        name,
+                        kind:        'class',
+                        defined_at:  pos_from_token(node.start),
+                        scope_depth: parent.depth,
+                        doc:         extract_doc(node),
+                        params:      null,
+                    }));
+                }
+            }
+
+            // Push class scope.
+            this._push_scope('class', name, node);
+
+        } else if (node instanceof RS.AST_ListComprehension) {
+            // AST_ListComprehension extends AST_ForIn, NOT AST_Scope.
+            // We give it its own scope so its loop variable doesn't leak.
+            this._push_scope('comprehension', null, node);
+
+            // The loop variable (node.init) is visited by the walk, but we
+            // add it now so it lands in the comprehension frame.
+            if (node.init instanceof RS.AST_SymbolRef) {
+                this._add_symbol({
+                    name:       node.init.name,
+                    kind:       'variable',
+                    defined_at: pos_from_token(node.init.start),
+                });
+                node.init.scope_builder_visited = true;
+            }
+
+        } else if (node instanceof RS.AST_Scope) {
+            // AST_Toplevel and any other raw scope nodes.
+            const kind = node instanceof RS.AST_Toplevel ? 'module' : 'block';
+            this._push_scope(kind, null, node);
+        }
+
+        // ------------------------------------------------------------------
+        // 2. Symbol-producing nodes (order doesn't matter for these).
+        // ------------------------------------------------------------------
+
+        if (node instanceof RS.AST_SymbolFunarg) {
+            // A regular function parameter; starargs/kwargs are also SymbolFunarg.
+            this._add_symbol({
+                name:       node.name,
+                kind:       'parameter',
+                defined_at: pos_from_token(node.start),
+            });
+
+        } 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) {
+                this._add_symbol({
+                    name,
+                    kind:       'import',
+                    defined_at: pos_from_token(node.start),
+                });
+            }
+
+        } else if (node instanceof RS.AST_Import && !node.argnames) {
+            // `import X` or `import X as Y` (no from-clause)
+            const name = (node.alias && node.alias.name)
+                ? node.alias.name
+                : (node.key ? node.key.split('.')[0] : null);
+            if (name) {
+                this._add_symbol({
+                    name,
+                    kind:       'import',
+                    defined_at: pos_from_token(node.start),
+                });
+            }
+
+        } else if (node instanceof RS.AST_VarDef) {
+            // `var` declarations emitted by the compiler; name can be SymbolVar or SymbolNonlocal.
+            if (node.name && !(node.name instanceof RS.AST_SymbolNonlocal)) {
+                const name = typeof node.name.name === 'string' ? node.name.name : null;
+                if (name) {
+                    this._add_symbol({
+                        name,
+                        kind:       'variable',
+                        defined_at: pos_from_token(node.start),
+                    });
+                }
+            }
+
+        } else if (node instanceof RS.AST_Assign && node.operator === '=') {
+            // Simple assignment: add left-hand symbol if new to this scope,
+            // or update inferred_class on an existing symbol (hoisted var declarations
+            // inside functions are added by AST_VarDef without type info; the
+            // assignment provides the type).
+            // Tuple/starred unpacking: register each variable in the LHS
+            if (node.left instanceof RS.AST_Array) {
+                const scope = this._current_scope();
+                if (scope) {
+                    node.left.flatten().forEach(elem => {
+                        let sym = null;
+                        if (elem instanceof RS.AST_Starred && elem.expression instanceof RS.AST_SymbolRef) {
+                            sym = elem.expression;
+                        } else if (elem instanceof RS.AST_SymbolRef) {
+                            sym = elem;
+                        }
+                        if (sym && !scope.getSymbol(sym.name)) {
+                            this._add_symbol({
+                                name:       sym.name,
+                                kind:       'variable',
+                                defined_at: pos_from_token(sym.start),
+                                inferred_class: elem instanceof RS.AST_Starred ? 'list' : null,
+                            });
+                        }
+                    });
+                }
+            } else if (node.left instanceof RS.AST_SymbolRef) {
+                const name  = node.left.name;
+                const scope = this._current_scope();
+                if (scope) {
+                    // Detect the RHS type regardless of whether the symbol exists.
+                    let inferred_class = null;
+                    let dts_call_path  = null;
+                    if (node.right instanceof RS.AST_BaseCall &&
+                        node.right.expression instanceof RS.AST_SymbolRef) {
+                        inferred_class = node.right.expression.name;
+                    } else if (node.right instanceof RS.AST_BaseCall &&
+                               node.right.expression instanceof RS.AST_Dot) {
+                        // x = obj.method(...) — capture the full dot-path for DTS type resolution.
+                        const call_path = dot_path_from_node(node.right.expression, RS);
+                        if (call_path) dts_call_path = call_path;
+                    } else if (node.right instanceof RS.AST_Array) {
+                        inferred_class = 'list';
+                    } else if (node.right instanceof RS.AST_Object) {
+                        inferred_class = 'dict';
+                    } else if (node.right instanceof RS.AST_String) {
+                        inferred_class = 'str';
+                    } else if (node.right instanceof RS.AST_Number) {
+                        inferred_class = 'number';
+                    }
+                    const existing = scope.getSymbol(name);
+                    if (!existing) {
+                        this._add_symbol({
+                            name,
+                            kind:           'variable',
+                            defined_at:     pos_from_token(node.left.start),
+                            inferred_class,
+                            dts_call_path,
+                        });
+                    } else if (inferred_class && !existing.inferred_class) {
+                        // Update the hoisted-but-untyped symbol with the inferred type.
+                        existing.inferred_class = inferred_class;
+                    } else if (dts_call_path && !existing.dts_call_path) {
+                        existing.dts_call_path = dts_call_path;
+                    }
+                }
+            }
+
+        } else if (node instanceof RS.AST_NamedExpr) {
+            // Walrus operator: name := value — register the name in the current scope.
+            const name  = node.name && node.name.name;
+            const scope = this._current_scope();
+            if (name && scope && !scope.getSymbol(name)) {
+                this._add_symbol({
+                    name,
+                    kind:       'variable',
+                    defined_at: pos_from_token(node.name.start),
+                });
+            }
+
+        } else if (
+            node instanceof RS.AST_ForIn &&
+            !(node instanceof RS.AST_ListComprehension) &&
+            node.init instanceof RS.AST_SymbolRef &&
+            !node.init.scope_builder_visited
+        ) {
+            // Regular `for x in ...` loop variable.
+            this._add_symbol({
+                name:       node.init.name,
+                kind:       'variable',
+                defined_at: pos_from_token(node.init.start),
+            });
+            node.init.scope_builder_visited = true;
+
+        } else if (node instanceof RS.AST_Except && node.argname) {
+            // `except SomeError as e`
+            this._add_symbol({
+                name:       node.argname.name,
+                kind:       'variable',
+                defined_at: pos_from_token(node.argname.start),
+            });
+
+        } else if (node instanceof RS.AST_WithClause && node.alias) {
+            // `with ctx as alias`
+            this._add_symbol({
+                name:       node.alias.name,
+                kind:       'variable',
+                defined_at: pos_from_token(node.alias.start),
+            });
+
+        } else if (RS.AST_MatchCapture && node instanceof RS.AST_MatchCapture) {
+            // match/case capture pattern: `case x:` → binds x
+            if (node.name) {
+                this._add_symbol({
+                    name:       node.name,
+                    kind:       'variable',
+                    defined_at: pos_from_token(node.start),
+                });
+            }
+
+        } else if (RS.AST_MatchAs && node instanceof RS.AST_MatchAs) {
+            // match/case AS pattern: `case pattern as name:` → binds name
+            if (node.name) {
+                this._add_symbol({
+                    name:       node.name,
+                    kind:       'variable',
+                    defined_at: pos_from_token(node.start),
+                });
+            }
+
+        } else if (RS.AST_MatchStar && node instanceof RS.AST_MatchStar) {
+            // Star element in sequence pattern: `case [*rest]` → binds rest
+            if (node.name) {
+                this._add_symbol({
+                    name:       node.name,
+                    kind:       'variable',
+                    defined_at: pos_from_token(node.start),
+                });
+            }
+
+        } else if (RS.AST_MatchMapping && node instanceof RS.AST_MatchMapping && node.rest_name) {
+            // Mapping rest: `case {"k": v, **rest}` → binds rest
+            this._add_symbol({
+                name:       node.rest_name,
+                kind:       'variable',
+                defined_at: pos_from_token(node.start),
+            });
+
+        } else if (RS.AST_AnnotatedAssign && node instanceof RS.AST_AnnotatedAssign) {
+            // Variable type annotation: `x: int = value` or `x: int`
+            if (node.target instanceof RS.AST_SymbolRef) {
+                const name  = node.target.name;
+                const scope = this._current_scope();
+                if (name && scope) {
+                    let inferred_class = null;
+                    // Use the annotation as the declared type for inferred_class
+                    if (node.annotation instanceof RS.AST_SymbolRef) {
+                        inferred_class = node.annotation.name;
+                    }
+                    const existing = scope.getSymbol(name);
+                    if (!existing) {
+                        this._add_symbol({
+                            name,
+                            kind:           'variable',
+                            defined_at:     pos_from_token(node.target.start),
+                            inferred_class,
+                        });
+                    } else if (inferred_class && !existing.inferred_class) {
+                        existing.inferred_class = inferred_class;
+                    }
+                }
+            }
+        }
+
+        // ------------------------------------------------------------------
+        // 3. Recurse into child nodes.
+        // ------------------------------------------------------------------
+
+        if (cont) cont();
+
+        // ------------------------------------------------------------------
+        // 4. Pop the scope we pushed (if any).
+        // ------------------------------------------------------------------
+
+        if (this._scopes.length > prev_depth) {
+            this._pop_scope();
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// SourceAnalyzer — public API
+// ---------------------------------------------------------------------------
+
+export class SourceAnalyzer {
+    /**
+     * @param {object} compiler     - window.RapydScript (the compiled compiler bundle)
+     * @param {string} [pythonFlags] - comma-separated python flags to enable globally
+     */
+    constructor(compiler, pythonFlags) {
+        this._RS = compiler;
+        this._scoped_flags = build_scoped_flags(pythonFlags);
+    }
+
+    /**
+     * Parse `code` and walk the resulting AST to build a ScopeMap.
+     * Returns an empty ScopeMap if parsing fails.
+     *
+     * @param {string} code
+     * @param {object} [options]
+     * @param {object} [options.virtualFiles]  - map of module-name → source
+     * @returns {ScopeMap}
+     */
+    analyze(code, options) {
+        options = options || {};
+        const RS  = this._RS;
+        const map = new ScopeMap();
+
+        let toplevel;
+        try {
+            toplevel = RS.parse(code, {
+                filename:    'editor.pyj',
+                for_linting: true,
+                ...(options.virtualFiles ? { virtual_files: options.virtualFiles } : {}),
+                ...(Object.keys(this._scoped_flags).length ? { scoped_flags: this._scoped_flags } : {}),
+            });
+        } catch (_e) {
+            // Syntax/import error — return the empty map; diagnostics.js handles errors.
+            return map;
+        }
+
+        const builder = new ScopeBuilder(RS, map);
+        toplevel.walk(builder);
+        return map;
+    }
+}