rapydscript-ns 0.8.3 → 0.9.0

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

@@ -22,19 +22,33 @@ const MESSAGES = {
     'dup-method':     'The method "{name}" was defined previously at line: {line}',
 };
 
+// Built-in stdlib modules that are always available in RapydScript (bundled
+// with the compiler from src/lib/).  These should never produce 'Unknown module'
+// errors regardless of what virtualFiles or stdlibFiles are configured.
+export const STDLIB_MODULES = [
+    'abc', 'aes', 'collections', 'copy', 'dataclasses', 'elementmaker', 'encodings', 'enum',
+    'functools', 'gettext', 'itertools', 'math', 'numpy', 'operator',
+    'pythonize', 'random', 're', 'react', 'traceback', 'typing', 'uuid',
+    // Pseudo-modules for language feature flags (from __python__ import ...)
+    '__python__', '__builtins__',
+];
+
+const _STDLIB_MODULE_SET = Object.create(null);
+STDLIB_MODULES.forEach(m => { _STDLIB_MODULE_SET[m] = true; });
+
 // Symbols always available in RapydScript (from tools/lint.js BUILTINS list).
 export const BASE_BUILTINS = (
     'this self window document chr ord iterator_symbol print len range dir' +
-    ' eval undefined arguments abs max min enumerate pow callable reversed sum' +
+    ' eval exec undefined arguments abs max min enumerate pow callable reversed sum' +
     ' getattr isFinite setattr hasattr parseInt parseFloat options_object' +
     ' isNaN JSON Math list set list_wrap ρσ_modules require bool int bin' +
-    ' float iter Error EvalError set_wrap frozenset RangeError ReferenceError SyntaxError' +
+    ' float complex iter Error EvalError set_wrap frozenset RangeError ReferenceError SyntaxError' +
     ' str TypeError URIError Exception AssertionError IndexError AttributeError KeyError' +
-    ' ValueError ZeroDivisionError map hex filter zip dict dict_wrap UnicodeDecodeError HTMLCollection' +
+    ' ValueError ZeroDivisionError ImportError ModuleNotFoundError StopIteration map hex filter zip dict dict_wrap UnicodeDecodeError HTMLCollection' +
     ' NodeList alert console Node Symbol NamedNodeMap ρσ_eslice ρσ_delslice Number' +
     ' Boolean encodeURIComponent decodeURIComponent setTimeout setInterval' +
     ' setImmediate clearTimeout clearInterval clearImmediate requestAnimationFrame' +
-    ' id repr sorted __name__ equals get_module ρσ_str jstype divmod NaN super Ellipsis slice'
+    ' id repr sorted __name__ equals get_module ρσ_str jstype divmod NaN super Ellipsis slice all any next __import__ ρσ_new ρσ_object_new hash ρσ_object_setattr ρσ_object_getattr ρσ_object_delattr ExceptionGroup BaseExceptionGroup tuple bytes bytearray format object vars locals globals'
 ).split(' ');
 
 // ---------------------------------------------------------------------------
@@ -384,7 +398,13 @@ function Linter(RS, toplevel, code, builtins, knownModules) {
     };
 
     this.handle_symbol_funarg = function() {
-        this.add_binding(this.current_node.name);
+        const node = this.current_node;
+        this.add_binding(node.name);
+        // Suppress undefined-symbol errors for type names used in argument
+        // annotations: `def foo(x: MyType):` — MyType is a hint, not a ref.
+        if (node.annotation instanceof RS.AST_SymbolRef) {
+            node.annotation.lint_visited = true;
+        }
     };
 
     this.handle_comprehension = function() {
@@ -403,24 +423,23 @@ function Linter(RS, toplevel, code, builtins, knownModules) {
 
     this.handle_for_in = function() {
         const node = this.current_node;
+        const add_loop_var = (cnode) => {
+            if (cnode instanceof RS.AST_Seq) {
+                cnode.to_array().forEach(add_loop_var);
+            } else if (cnode instanceof RS.AST_Array) {
+                cnode.elements.forEach(add_loop_var);
+            } else if (cnode instanceof RS.AST_SymbolRef) {
+                this.current_node = cnode;
+                cnode.lint_visited = true;
+                this.add_binding(cnode.name).is_loop = true;
+                this.current_node = node;
+            }
+        };
         if (node.init instanceof RS.AST_SymbolRef) {
             this.add_binding(node.init.name).is_loop = true;
             node.init.lint_visited = true;
         } else if (node.init instanceof RS.AST_Array) {
-            node.init.elements.forEach(cnode => {
-                if (cnode instanceof RS.AST_Seq) cnode = cnode.to_array();
-                if (cnode instanceof RS.AST_SymbolRef) cnode = [cnode];
-                if (Array.isArray(cnode)) {
-                    cnode.forEach(elem => {
-                        if (elem instanceof RS.AST_SymbolRef) {
-                            this.current_node = elem;
-                            elem.lint_visited = true;
-                            this.add_binding(elem.name).is_loop = true;
-                            this.current_node = node;
-                        }
-                    });
-                }
-            });
+            node.init.elements.forEach(add_loop_var);
         }
     };
 
@@ -681,6 +700,8 @@ export class Diagnostics {
         const sf = options.stdlibFiles;
         if ((vf && Object.keys(vf).length > 0) || (sf && Object.keys(sf).length > 0)) {
             knownModules = Object.create(null);
+            // Always include built-in stdlib so they never produce bad-import errors.
+            Object.assign(knownModules, _STDLIB_MODULE_SET);
             if (vf) Object.keys(vf).forEach(k => { knownModules[k] = true; });
             if (sf) Object.keys(sf).forEach(k => { knownModules[k] = true; });
         }

package/src/output/classes.pyj

@@ -2,7 +2,7 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
 
-from ast import AST_Class, AST_Method, is_node_type
+from ast import AST_Class, AST_Method, AST_AnnotatedAssign, AST_SymbolRef, is_node_type
 from output.functions import decorate, function_definition, function_annotation
 from output.utils import create_doctring
 from utils import has_prop
@@ -82,19 +82,75 @@ def print_class(output):
         output.with_block(def():
             output.indent()
             cname = self.name.name
-            output.print('if (!(this instanceof ' + cname + ')) return new ' + cname + '(...arguments);')
-            output.newline()
+            if self.has_new:
+                # When __new__ is defined, call it to get the instance
+                output.print('if (!(this instanceof ' + cname + '))')
+                output.space()
+                output.with_block(def():
+                    output.indent()
+                    output.print('var ρσ_instance = ')
+                    self.name.print(output)
+                    output.print('.__new__(')
+                    self.name.print(output)
+                    output.print(', ...arguments)')
+                    output.end_statement()
+                    output.indent()
+                    output.print('if (ρσ_instance instanceof ')
+                    self.name.print(output)
+                    output.print(')')
+                    output.space()
+                    output.with_block(def():
+                        output.indent()
+                        output.spaced('if', '(ρσ_instance.ρσ_object_id', '===', 'undefined)', 'Object.defineProperty(ρσ_instance,', '"ρσ_object_id",', '{"value":++ρσ_object_counter})')
+                        output.end_statement()
+                        if self.bound.length:
+                            output.indent()
+                            self.name.print(output), output.print('.prototype.__bind_methods__ && ')
+                            self.name.print(output), output.print('.prototype.__bind_methods__.call(ρσ_instance)')
+                            output.end_statement()
+                        output.indent()
+                        self.name.print(output)
+                        output.print('.prototype.__init__.apply(ρσ_instance'), output.comma(), output.print('arguments)')
+                        output.end_statement()
+                    )
+                    output.newline()
+                    output.indent()
+                    output.print('return ρσ_instance')
+                    output.end_statement()
+                )
+                output.newline()
+            else:
+                output.print('if (!(this instanceof ' + cname + ')) return new ' + cname + '(...arguments);')
+                output.newline()
             output.indent()
             output.spaced('if', '(this.ρσ_object_id', '===', 'undefined)', 'Object.defineProperty(this,', '"ρσ_object_id",', '{"value":++ρσ_object_counter})')
             output.end_statement()
-            if self.bound.length:
+            if self.has_attr_dunders:
+                # Wrap in a Proxy so __getattr__/__setattr__/__delattr__/__getattribute__ are triggered.
                 output.indent()
-                self.name.print(output), output.print(".prototype.__bind_methods__.call(this)")
+                output.print('var ρσ_proxy = ρσ_JS_Proxy ? new ρσ_JS_Proxy(this, ρσ_attr_proxy_handler) : this')
+                output.end_statement()
+                if self.bound.length:
+                    output.indent()
+                    self.name.print(output), output.print(".prototype.__bind_methods__ && ")
+                    self.name.print(output), output.print(".prototype.__bind_methods__.call(ρσ_proxy)")
+                    output.end_statement()
+                output.indent()
+                self.name.print(output)
+                output.print(".prototype.__init__.apply(ρσ_proxy"), output.comma(), output.print('arguments)')
+                output.end_statement()
+                output.indent()
+                output.print('return ρσ_proxy')
+                output.end_statement()
+            else:
+                if self.bound.length:
+                    output.indent()
+                    self.name.print(output), output.print(".prototype.__bind_methods__.call(this)")
+                    output.end_statement()
+                output.indent()
+                self.name.print(output)
+                output.print(".prototype.__init__.apply(this"), output.comma(), output.print('arguments)')
                 output.end_statement()
-            output.indent()
-            self.name.print(output)
-            output.print(".prototype.__init__.apply(this"), output.comma(), output.print('arguments)')
-            output.end_statement()
         )
 
     decorators = self.decorators or v'[]'
@@ -235,6 +291,24 @@ def print_class(output):
             output.end_statement()
         )
 
+    if not defined_methods['__format__']:
+        define_default_method('__format__', def():
+            if self.parent:
+                output.print('if('), self.parent.print(output), output.spaced('.prototype.__format__)', 'return', self.parent)
+                output.print('.prototype.__format__.call(this, arguments[0])'), output.end_statement()
+            output.indent(), output.spaced('if', '(!arguments[0])', 'return', 'this.__str__()')
+            output.end_statement()
+            output.indent(), output.spaced('throw', 'new TypeError("unsupported format specification")')
+            output.end_statement()
+        )
+
+    # Python semantics: defining __eq__ without __hash__ makes the class unhashable
+    if defined_methods['__eq__'] and not defined_methods['__hash__']:
+        output.indent()
+        self.name.print(output)
+        output.print('.prototype.__hash__ = null')
+        output.end_statement()
+
     # Multiple inheritance
     add_hidden_property('__bases__', def():
         output.print('[')
@@ -256,22 +330,10 @@ def print_class(output):
     output.print('.prototype, "__class__", {get: function() { return this.constructor; }, configurable: true})')
     output.end_statement()
 
-    if self.bases.length > 1:
-        output.indent()
-        output.print("ρσ_mixin(")
-        self.name.print(output)
-        for v'var i = 1; i < self.bases.length; i++':
-            output.comma()
-            self.bases[i].print(output)
-        output.print(')'), output.end_statement()
-
-    # Docstring
-    if self.docstrings and self.docstrings.length and output.options.keep_docstrings:
-        add_hidden_property('__doc__', def():
-            output.print(JSON.stringify(create_doctring(self.docstrings)))
-        )
-
-    # Other statements in the class context (including nested class definitions)
+    # Other statements in the class context (including nested class definitions).
+    # Emitted BEFORE __init_subclass__ so that the hook can see class variables.
+    # This matches Python's behaviour: the class body executes first, then the
+    # hook is called with the fully-populated class namespace.
     for stmt in self.statements:
         if is_node_type(stmt, AST_Class):
             # Print the nested class in full, then attach it to the outer class.
@@ -295,6 +357,80 @@ def print_class(output):
             stmt.print(output)
             output.newline()
 
+    # Emit __annotations__ for annotated class variables so that @dataclass and
+    # similar decorators can introspect field names and their declaration order.
+    # Only annotation-with-value statements (x: T = v) AND annotation-only
+    # statements (x: T) are collected; the value (if any) is already emitted
+    # above as a prototype assignment.  We store null as the type since type
+    # information is erased in the JS output.
+    annotated_field_names = []
+    for stmt in self.statements:
+        if is_node_type(stmt, AST_AnnotatedAssign) and is_node_type(stmt.target, AST_SymbolRef):
+            annotated_field_names.push(stmt.target.name)
+    if annotated_field_names.length:
+        output.indent()
+        self.name.print(output)
+        output.print('.__annotations__ = {')
+        for i in range(annotated_field_names.length):
+            if i > 0:
+                output.comma()
+            output.print(JSON.stringify(annotated_field_names[i]) + ': null')
+        output.print('}')
+        output.end_statement()
+
+    # __init_subclass__ hook: call after identity properties and class variables
+    # so cls.__name__ is correct and cls.prototype reflects the full class body.
+    if self.parent:
+        output.indent()
+        output.print('if (typeof ')
+        self.parent.print(output)
+        output.print('.__init_subclass__ === "function")')
+        output.space()
+        kws = self.class_kwargs
+        if kws and kws.length:
+            output.with_block(def():
+                output.indent()
+                output.print('var ρσ_isc_kw = {')
+                for v'var ρσ_kwi = 0; ρσ_kwi < kws.length; ρσ_kwi++':
+                    if ρσ_kwi > 0:
+                        output.comma()
+                    output.print(kws[ρσ_kwi][0].name + ':')
+                    output.space()
+                    kws[ρσ_kwi][1].print(output)
+                output.print('}')
+                output.end_statement()
+                output.indent()
+                output.print('ρσ_isc_kw[ρσ_kwargs_symbol] = true')
+                output.end_statement()
+                output.indent()
+                self.parent.print(output)
+                output.print('.__init_subclass__.call(')
+                self.name.print(output)
+                output.print(', ρσ_isc_kw)')
+                output.end_statement()
+            )
+        else:
+            self.parent.print(output)
+            output.print('.__init_subclass__.call(')
+            self.name.print(output)
+            output.print(')')
+            output.end_statement()
+
+    if self.bases.length > 1:
+        output.indent()
+        output.print("ρσ_mixin(")
+        self.name.print(output)
+        for v'var i = 1; i < self.bases.length; i++':
+            output.comma()
+            self.bases[i].print(output)
+        output.print(')'), output.end_statement()
+
+    # Docstring
+    if self.docstrings and self.docstrings.length and output.options.keep_docstrings:
+        add_hidden_property('__doc__', def():
+            output.print(JSON.stringify(create_doctring(self.docstrings)))
+        )
+
     if decorators.length:
         output.indent()
         output.assign(self.name)

package/src/output/codegen.pyj

@@ -13,13 +13,14 @@ from ast import (
     AST_EmptyStatement, AST_Exit, AST_ExpressiveObject, AST_ForIn,
     AST_ForJS, AST_Function, AST_Hole, AST_If, AST_Imports, AST_Infinity,
     AST_Lambda, AST_ListComprehension, AST_LoopControl, AST_NaN, AST_NamedExpr, AST_New, AST_Node,
-    AST_Number, AST_Object, AST_ObjectKeyVal, AST_ObjectProperty, AST_ObjectSpread, AST_PropAccess,
+    AST_Number, AST_Object, AST_ObjectKeyVal, AST_ObjectProperty, AST_ObjectSpread, AST_Spread, AST_PropAccess,
     AST_RegExp, AST_Return, AST_Set, AST_Seq, AST_SimpleStatement, AST_Splice,
     AST_Statement, AST_StatementWithBody, AST_String, AST_Sub, AST_ItemAccess,
     AST_Symbol, AST_This, AST_Throw, AST_Toplevel, AST_Try, AST_Unary,
     AST_UnaryPrefix, AST_Undefined, AST_Var, AST_VarDef, AST_Assert,
     AST_Verbatim, AST_While, AST_With, AST_Yield, AST_Await, TreeWalker, AST_Existential,
-    AST_Match, AST_AnnotatedAssign, AST_Super
+    AST_Match, AST_AnnotatedAssign, AST_Super,
+    AST_JSXElement, AST_JSXFragment, AST_JSXAttribute, AST_JSXSpread, AST_JSXText, AST_JSXExprContainer
 )
 from output.exceptions import print_try
 from output.classes import print_class
@@ -34,6 +35,7 @@ from output.operators import (
 )
 from output.functions import print_function, print_function_call
 from output.statements import print_bracketed, first_in_statement, force_statement, print_with, print_assert, print_match, print_annotated_assign
+from output.jsx import print_jsx_element, print_jsx_fragment, print_jsx_attribute, print_jsx_spread, print_jsx_text, print_jsx_expr_container
 from output.utils import make_block, make_num
 
 # -----[ code generators ]-----
@@ -486,6 +488,10 @@ def generate_code():
         output.print('**')
         self.value.print(output)
     )
+    DEFPRINT(AST_Spread, def(self, output):
+        output.print('...')
+        self.expression.print(output)
+    )
     DEFPRINT(AST_Set, print_set)
 
     AST_Symbol.prototype.definition = def():
@@ -525,3 +531,11 @@ def generate_code():
         output.print(make_num(self.value))
     )
     DEFPRINT(AST_RegExp, print_regexp)
+
+    # -----[ JSX ]-----
+    DEFPRINT(AST_JSXElement, print_jsx_element)
+    DEFPRINT(AST_JSXFragment, print_jsx_fragment)
+    DEFPRINT(AST_JSXAttribute, print_jsx_attribute)
+    DEFPRINT(AST_JSXSpread, print_jsx_spread)
+    DEFPRINT(AST_JSXText, print_jsx_text)
+    DEFPRINT(AST_JSXExprContainer, print_jsx_expr_container)

package/src/output/exceptions.pyj

@@ -2,7 +2,7 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
 
-from output.statements import print_bracketed
+from output.statements import print_bracketed, display_body
 
 
 def print_try(self, output):
@@ -28,6 +28,10 @@ def print_try(self, output):
 
 
 def print_catch(self, output):
+    # Dispatch to except* handler when any clause is an exception group handler
+    if self.body.length and self.body[0].is_star:
+        print_catch_star(self, output)
+        return
     output.print("catch")
     output.space()
     output.with_parens(def():
@@ -83,6 +87,98 @@ def print_catch(self, output):
     )
 
 
+def _eg_type_cond(errors, varname):
+    # Build a JS condition string testing varname against each error type
+    parts = []
+    for err in errors:
+        if err.name is 'Exception':
+            parts.push(varname + " instanceof Error")
+        else:
+            parts.push(varname + " instanceof " + err.name)
+    return parts.join(" || ")
+
+
+def print_catch_star(self, output):
+    output.print("catch")
+    output.space()
+    output.with_parens(def():
+        output.print("ρσ_Exception")
+    )
+    output.space()
+    output.with_block(def():
+        output.indent()
+        output.spaced('ρσ_last_exception', '=', 'ρσ_Exception'), output.end_statement()
+
+        # Normalise: wrap non-ExceptionGroup exception into a one-element array
+        output.indent()
+        output.print("var ρσ_eg_exceptions = (ρσ_Exception instanceof ExceptionGroup) ? ρσ_Exception.exceptions.slice() : [ρσ_Exception]")
+        output.semicolon(), output.newline()
+        output.indent()
+        output.print("var ρσ_eg_raised = []")
+        output.semicolon(), output.newline()
+
+        for ei, exception in enumerate(self.body):
+            idx = str(ei)
+            if exception.errors.length:
+                cond = _eg_type_cond(exception.errors, "ρσ_et")
+                output.indent()
+                output.print("var ρσ_eg_matched_" + idx + " = ρσ_eg_exceptions.filter(function(ρσ_et) { return " + cond + "; })")
+                output.semicolon(), output.newline()
+                output.indent()
+                output.print("ρσ_eg_exceptions = ρσ_eg_exceptions.filter(function(ρσ_et) { return !(" + cond + "); })")
+                output.semicolon(), output.newline()
+            else:
+                # Bare except*: take all remaining
+                output.indent()
+                output.print("var ρσ_eg_matched_" + idx + " = ρσ_eg_exceptions.slice()")
+                output.semicolon(), output.newline()
+                output.indent()
+                output.print("ρσ_eg_exceptions = []")
+                output.semicolon(), output.newline()
+
+            output.indent()
+            output.print("if (ρσ_eg_matched_" + idx + ".length > 0)")
+            output.space()
+            output.with_block(def():
+                if exception.argname:
+                    output.indent()
+                    output.print("var ")
+                    output.assign(exception.argname)
+                    output.print("(ρσ_Exception instanceof ExceptionGroup) ? new ExceptionGroup(ρσ_Exception.message, ρσ_eg_matched_" + idx + ") : ρσ_eg_matched_" + idx + "[0]")
+                    output.semicolon(), output.newline()
+                output.indent()
+                output.print("try")
+                output.space()
+                output.with_block(def():
+                    display_body(exception.body, False, output)
+                )
+                output.print(" catch (ρσ_eg_exc_" + idx + ")")
+                output.space()
+                output.with_block(def():
+                    output.indent()
+                    output.print("ρσ_eg_raised.push(ρσ_eg_exc_" + idx + ")")
+                    output.semicolon(), output.newline()
+                )
+                output.newline()
+            )
+            output.newline()
+
+        # Re-raise unmatched exceptions and any raised by handlers
+        output.indent()
+        output.print("var ρσ_eg_unhandled = ρσ_eg_exceptions.concat(ρσ_eg_raised)")
+        output.semicolon(), output.newline()
+        output.indent()
+        output.print("if (ρσ_eg_unhandled.length > 0)")
+        output.space()
+        output.with_block(def():
+            output.indent()
+            output.print("throw (ρσ_eg_unhandled.length === 1 && !(ρσ_Exception instanceof ExceptionGroup)) ? ρσ_eg_unhandled[0] : new ExceptionGroup((ρσ_Exception instanceof ExceptionGroup) ? ρσ_Exception.message : \"unhandled exceptions\", ρσ_eg_unhandled)")
+            output.semicolon(), output.newline()
+        )
+        output.newline()
+    )
+
+
 def print_finally(self, output, belse, else_var_name):
     output.print("finally")
     output.space()

package/src/output/functions.pyj

@@ -2,8 +2,9 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
 
-from ast import AST_ClassCall, AST_New, has_calls, AST_Dot, AST_SymbolRef, is_node_type
+from ast import AST_ClassCall, AST_New, has_calls, AST_Dot, AST_SymbolRef, AST_String, is_node_type
 from output.stream import OutputStream
+from parse import parse as ρσ_rs_parse
 from output.statements import print_bracketed
 from output.utils import create_doctring
 from output.operators import print_getattr
@@ -150,6 +151,15 @@ def function_preamble(node, output, offset):
         output.print('.pop()')
         output.end_statement()
 
+    # Convert the plain JS kwargs object to a proper Python dict so that
+    # kw.items(), kw.keys(), etc. work in the function body.
+    # This must happen AFTER defaults/kwonly/starargs processing which rely on
+    # plain property access (kw.name) and ρσ_kwargs_symbol checks.
+    if a.kwargs:
+        output.indent()
+        output.spaced(kw, '=', 'ρσ_kwargs_to_dict(' + kw + ')')
+        output.end_statement()
+
 def has_annotations(self):
     if self.return_annotation:
         return True
@@ -440,6 +450,73 @@ def print_function_call(self, output):
                         output.comma()
                     a.print(output)
             )
+        elif (is_node_type(self.expression, AST_SymbolRef) and
+              self.expression.name is 'vars' and self.args.length is 0):
+            # vars() with no args → vars(this) so it captures the caller's instance
+            output.print('ρσ_vars')
+            output.with_parens(def():
+                output.print('this')
+            )
+        elif (is_node_type(self.expression, AST_SymbolRef) and
+              (self.expression.name is 'eval' or self.expression.name is 'exec') and
+              self.args.length >= 1 and is_node_type(self.args[0], AST_String)):
+            # Compile-time RapydScript → JS transformation for eval/exec string literals.
+            # The RapydScript source string is parsed and compiled to JS now; the emitted
+            # call receives the compiled JS string instead of the original RapydScript.
+            fn_name = self.expression.name
+            source  = self.args[0].value
+            inner_ast = ρσ_rs_parse(source, {
+                'filename':        '<eval>',
+                'module_id':       '__eval__',
+                'for_linting':     True,
+                'discard_asserts': output.options.discard_asserts,
+            })
+            inner_os = OutputStream({
+                'beautify':        False,
+                'js_version':      output.options.js_version,
+                'private_scope':   False,
+                'write_name':      False,
+                'omit_baselib':    True,
+                'discard_asserts': output.options.discard_asserts,
+            })
+            inner_ast.print(inner_os)
+            compiled_js = v'inner_os.get().trim()'
+
+            def _print_extra_args():
+                for a in self.args.slice(1):
+                    output.comma()
+                    a.print(output)
+
+            if fn_name is 'eval' and self.args.length is 1:
+                # eval("expr") → native direct eval for scope access
+                output.print('eval')
+                output.with_parens(def():
+                    output.print(JSON.stringify(compiled_js))
+                )
+            elif fn_name is 'eval':
+                # eval("expr", globals, locals) → ρσ_eval(compiled_js, globals, locals)
+                output.print('ρσ_eval')
+                output.with_parens(def():
+                    output.print(JSON.stringify(compiled_js))
+                    _print_extra_args()
+                )
+            else:
+                # exec("code", ...) → ρσ_exec(compiled_js, ...)
+                output.print('ρσ_exec')
+                output.with_parens(def():
+                    output.print(JSON.stringify(compiled_js))
+                    _print_extra_args()
+                )
+        elif is_node_type(self.expression, AST_SymbolRef) and self.expression.name is 'eval' and self.args.length > 1:
+            # eval(dynamic_expr, globals, locals) → ρσ_eval(dynamic_expr, globals, locals)
+            # The 1-arg form eval(expr) is left as native JS direct eval for scope access.
+            output.print('ρσ_eval')
+            output.with_parens(def():
+                for i, a in enumerate(self.args):
+                    if i:
+                        output.comma()
+                    a.print(output)
+            )
         elif is_node_type(self.expression, AST_SymbolRef) and self.python_truthiness:
             # __call__-aware dispatch when from __python__ import truthiness is active
             output.print('ρσ_callable_call(')
@@ -452,10 +529,15 @@ def print_function_call(self, output):
             # Method calls and other complex expressions — keep existing behaviour
             print_function_name()
             output.with_parens(def():
-                for i, a in enumerate(self.args):
-                    if i:
-                        output.comma()
-                    a.print(output)
+                # .split() with no args: default to ' ' so JS splits on space
+                # rather than returning [whole_string] (native JS no-arg behavior)
+                if is_node_type(self.expression, AST_Dot) and self.expression.property is 'split' and not self.args.length:
+                    output.print('" "')
+                else:
+                    for i, a in enumerate(self.args):
+                        if i:
+                            output.comma()
+                        a.print(output)
             )
         return