rapydscript-ns 0.8.0 → 0.8.2

package/src/baselib-containers.pyj

@@ -468,7 +468,7 @@ Object.defineProperties(ρσ_set.prototype, {
     return '{' + list(this).join(', ') + '}'
 
 ρσ_set.prototype.__eq__ = def(other):
-    if not v'other instanceof this.constructor':
+    if v'!other || !other.jsset':
         return False
     if other.size is not this.size:
         return False
@@ -490,6 +490,142 @@ def ρσ_set_wrap(x):
 v'var set = ρσ_set, set_wrap = ρσ_set_wrap'
 # }}}
 
+# frozenset {{{
+def ρσ_frozenset(iterable):
+    if v'this instanceof ρσ_frozenset':
+        this.jsset = new ρσ_set_implementation()  # noqa:undef
+        ans = this
+        if iterable is undefined:
+            return ans
+        s = ans.jsset
+        if ρσ_arraylike(iterable):
+            for v'var i = 0; i < iterable.length; i++':
+                s.add(iterable[i])
+        elif jstype(iterable[ρσ_iterator_symbol]) is 'function':
+            iterator = iterable.keys() if jstype(Map) is 'function' and v'iterable instanceof Map' else iterable[ρσ_iterator_symbol]()
+            result = iterator.next()
+            while not result.done:
+                s.add(result.value)
+                result = iterator.next()
+        else:
+            keys = Object.keys(iterable)
+            for v'var j=0; j < keys.length; j++':
+                s.add(keys[j])
+        return ans
+    else:
+        return new ρσ_frozenset(iterable)
+ρσ_frozenset.prototype.__name__ = 'frozenset'
+
+Object.defineProperties(ρσ_frozenset.prototype, {
+    'length': { 'get': def(): return this.jsset.size; },
+    'size': { 'get': def(): return this.jsset.size; },
+})
+
+ρσ_frozenset.prototype.__len__ = def(): return this.jsset.size
+ρσ_frozenset.prototype.has = ρσ_frozenset.prototype.__contains__ = def(x): return this.jsset.has(x)
+ρσ_frozenset.prototype.copy = def(): return ρσ_frozenset(this)
+ρσ_frozenset.prototype[ρσ_iterator_symbol] = def(): return this.jsset.values()
+
+ρσ_frozenset.prototype.difference = def():
+    ans = new ρσ_frozenset()
+    s = ans.jsset
+    iterator = this.jsset.values()
+    r = iterator.next()
+    while not r.done:
+        x = r.value
+        has = False
+        for v'var i = 0; i < arguments.length; i++':
+            if arguments[i].has(x):  # noqa:undef
+                has = True
+                break
+        if not has:
+            s.add(x)
+        r = iterator.next()
+    return ans
+
+ρσ_frozenset.prototype.intersection = def():
+    ans = new ρσ_frozenset()
+    s = ans.jsset
+    iterator = this.jsset.values()
+    r = iterator.next()
+    while not r.done:
+        x = r.value
+        has = True
+        for v'var i = 0; i < arguments.length; i++':
+            if not arguments[i].has(x):  # noqa:undef
+                has = False
+                break
+        if has:
+            s.add(x)
+        r = iterator.next()
+    return ans
+
+ρσ_frozenset.prototype.isdisjoint = def(other):
+    iterator = this.jsset.values()
+    r = iterator.next()
+    while not r.done:
+        x = r.value
+        if other.has(x):
+            return False
+        r = iterator.next()
+    return True
+
+ρσ_frozenset.prototype.issubset = def(other):
+    iterator = this.jsset.values()
+    r = iterator.next()
+    while not r.done:
+        x = r.value
+        if not other.has(x):
+            return False
+        r = iterator.next()
+    return True
+
+ρσ_frozenset.prototype.issuperset = def(other):
+    s = this.jsset
+    iterator = other[ρσ_iterator_symbol]()
+    r = iterator.next()
+    while not r.done:
+        x = r.value
+        if not s.has(x):
+            return False
+        r = iterator.next()
+    return True
+
+ρσ_frozenset.prototype.symmetric_difference = def(other):
+    return this.union(other).difference(this.intersection(other))
+
+ρσ_frozenset.prototype.union = def():
+    ans = ρσ_frozenset(this)
+    s = ans.jsset
+    for v'var i=0; i < arguments.length; i++':
+        iterator = arguments[i][ρσ_iterator_symbol]()  # noqa:undef
+        r = iterator.next()
+        while not r.done:
+            s.add(r.value)
+            r = iterator.next()
+    return ans
+
+ρσ_frozenset.prototype.toString = ρσ_frozenset.prototype.__repr__ = ρσ_frozenset.prototype.__str__ = ρσ_frozenset.prototype.inspect = def():
+    return 'frozenset({' + list(this).join(', ') + '})'
+
+ρσ_frozenset.prototype.__eq__ = def(other):
+    if v'!other || !other.jsset':
+        return False
+    if other.size is not this.size:
+        return False
+    if other.size is 0:
+        return True
+    iterator = other[ρσ_iterator_symbol]()
+    r = iterator.next()
+    while not r.done:
+        if not this.has(r.value):
+            return False
+        r = iterator.next()
+    return True
+
+v'var frozenset = ρσ_frozenset'
+# }}}
+
 # dict {{{
 v'var ρσ_dict_implementation'
 
@@ -704,6 +840,15 @@ Object.defineProperties(ρσ_dict.prototype, {
         r = iterator.next()
     return True
 
+ρσ_dict.prototype.__or__ = def(other):
+    result = ρσ_dict(this)
+    result.update(other)
+    return result
+
+ρσ_dict.prototype.__ior__ = def(other):
+    this.update(other)
+    return this
+
 ρσ_dict.prototype.as_object = def(other):
     ans = {}
     iterator = this.jsmap.entries()

package/src/baselib-errors.pyj

@@ -35,3 +35,6 @@ class AssertionError(Exception):
 
 class ZeroDivisionError(Exception):
     pass
+
+class StopIteration(Exception):
+    pass

package/src/baselib-internal.pyj

@@ -282,6 +282,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):

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)

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 };

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

@@ -114,6 +114,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,6 +144,11 @@ 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')],
         return_type: 'iterator',

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

@@ -8,6 +8,25 @@
 import { SourceAnalyzer } from './analyzer.js';
 import { resolve_first_type } from './dts.js';
 
+// ---------------------------------------------------------------------------
+// Language keywords
+// ---------------------------------------------------------------------------
+
+/**
+ * RapydScript / Python keywords that are valid identifier-completion tokens.
+ * Shown in the `identifier` completion context only (not dot / import contexts).
+ */
+export const KEYWORDS = [
+    'and', 'as', 'assert', 'async', 'await',
+    'break', 'class', 'continue', 'def', 'del',
+    'elif', 'else', 'except', 'finally', 'for',
+    'from', 'global', 'if', 'import', 'in', 'is',
+    'lambda', 'nonlocal', 'not', 'or', 'pass',
+    'raise', 'return', 'try', 'while', 'with',
+    'yield',
+    'True', 'False', 'None',
+];
+
 // ---------------------------------------------------------------------------
 // Context detection
 // ---------------------------------------------------------------------------
@@ -267,7 +286,25 @@ export class CompletionEngine {
         const seen    = new Set();
 
         if (scopeMap) {
-            const symbols = scopeMap.getSymbolsAtPosition(position.lineNumber, position.column);
+            let symbols = scopeMap.getSymbolsAtPosition(position.lineNumber, position.column);
+
+            // Fallback: cursor is on a new line not yet covered by the last debounced parse
+            // (e.g. the user typed Return and is now on a line past the end of the last AST).
+            // Collect all symbols from all frames, innermost-first, so locals remain visible.
+            if (symbols.length === 0 && scopeMap.frames.length > 0) {
+                const all_frames = scopeMap.frames.slice().sort((a, b) => b.depth - a.depth);
+                const fallback_seen = new Set();
+                symbols = [];
+                for (const frame of all_frames) {
+                    for (const [name, sym] of frame.symbols) {
+                        if (!fallback_seen.has(name)) {
+                            fallback_seen.add(name);
+                            symbols.push(sym);
+                        }
+                    }
+                }
+            }
+
             for (const sym of symbols) {
                 if (!ctx.prefix || sym.name.startsWith(ctx.prefix)) {
                     if (!seen.has(sym.name)) {
@@ -279,7 +316,7 @@ export class CompletionEngine {
             }
         }
 
-        // Builtins (lowest priority) — use rich stub item when available
+        // Builtins (lower priority) — use rich stub item when available
         for (const name of this._builtinNames) {
             if (!seen.has(name) && (!ctx.prefix || name.startsWith(ctx.prefix))) {
                 seen.add(name);
@@ -291,6 +328,21 @@ export class CompletionEngine {
             }
         }
 
+        // Keywords (lowest priority)
+        const kw_kind = monacoKind.Keyword !== undefined ? monacoKind.Keyword : monacoKind.Variable;
+        for (const kw of KEYWORDS) {
+            if (!seen.has(kw) && (!ctx.prefix || kw.startsWith(ctx.prefix))) {
+                seen.add(kw);
+                items.push({
+                    label:      kw,
+                    kind:       kw_kind,
+                    sortText:   '3_' + kw,
+                    insertText: kw,
+                    range,
+                });
+            }
+        }
+
         return items;
     }
 

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

@@ -16,6 +16,7 @@ const MESSAGES = {
     'func-in-branch': 'Named functions/classes inside a branch are not allowed in strict mode',
     'syntax-err':     'Syntax error: {name}',
     'import-err':     'Import error: {name}',
+    'bad-import':     'Unknown module: "{name}"',
     'def-after-use':  'The symbol "{name}" is defined (at line {line}) after it is used',
     'dup-key':        'Duplicate key "{name}" in object literal',
     'dup-method':     'The method "{name}" was defined previously at line: {line}',
@@ -27,7 +28,7 @@ export const BASE_BUILTINS = (
     ' eval 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 RangeError ReferenceError SyntaxError' +
+    ' float 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' +
     ' NodeList alert console Node Symbol NamedNodeMap ρσ_eslice ρσ_delslice Number' +
@@ -44,7 +45,7 @@ function has_prop(obj, name) {
     return Object.prototype.hasOwnProperty.call(obj, name);
 }
 
-function build_scoped_flags(flags_str) {
+export function build_scoped_flags(flags_str) {
     const result = Object.create(null);
     if (!flags_str) return result;
     flags_str.split(',').forEach(flag => {
@@ -205,7 +206,7 @@ Scope.prototype.messages = function() {
 // Linter — mirrors the Linter in tools/lint.js
 // ---------------------------------------------------------------------------
 
-function Linter(RS, toplevel, code, builtins) {
+function Linter(RS, toplevel, code, builtins, knownModules) {
     this.RS             = RS;
     this.scopes         = [];
     this.walked_scopes  = [];
@@ -213,6 +214,7 @@ function Linter(RS, toplevel, code, builtins) {
     this.branches       = [];
     this.messages       = [];
     this.builtins       = builtins;
+    this._knownModules  = knownModules || null;
 
     this.add_binding = function(name, binding_node) {
         const scope = this.scopes[this.scopes.length - 1];
@@ -240,6 +242,26 @@ function Linter(RS, toplevel, code, builtins) {
             const name = node.alias ? node.alias.name : node.key.split('.', 1)[0];
             this.add_binding(name, node.alias || node);
         }
+        // Flag imports of modules not present in the known-module registry.
+        // Only active when at least one virtualFile or stdlibFile is registered,
+        // to avoid false positives when no module system is configured.
+        if (this._knownModules) {
+            const root = node.key.split('.')[0];
+            if (!has_prop(this._knownModules, root)) {
+                const sline = node.start ? node.start.line : 1;
+                const scol  = node.start ? node.start.col  : 0;
+                this.messages.push({
+                    start_line: sline,
+                    start_col:  scol,
+                    end_line:   sline,
+                    end_col:    scol + node.key.length - 1,
+                    ident:      'bad-import',
+                    message:    MESSAGES['bad-import'].replace('{name}', node.key),
+                    level:      ERROR,
+                    name:       node.key,
+                });
+            }
+        }
     };
 
     this.handle_imported_var = function() {
@@ -312,6 +334,23 @@ function Linter(RS, toplevel, code, builtins) {
         }
     };
 
+    this.handle_annotated_assign = function() {
+        const node = this.current_node;
+        // Variable type annotation: `x: int = value` or `x: int`
+        // Register the target as a binding (with or without a value).
+        if (node.target instanceof RS.AST_SymbolRef) {
+            node.target.lint_visited = true;
+            this.current_node = node.target;
+            this.add_binding(node.target.name);
+            this.current_node = node;
+        }
+        // Mark annotation symbol refs as visited so they aren't treated as uses
+        // of undefined variables (e.g. `int`, `str` are type names, not runtime refs).
+        if (node.annotation instanceof RS.AST_SymbolRef) {
+            node.annotation.lint_visited = true;
+        }
+    };
+
     this.handle_vardef = function() {
         const node = this.current_node;
         if (node.name instanceof RS.AST_SymbolNonlocal) {
@@ -461,6 +500,7 @@ function Linter(RS, toplevel, code, builtins) {
         else if (node instanceof RS.AST_Assign)          this.handle_assign();
         else if (node instanceof RS.AST_NamedExpr)       this.handle_named_expr();
         else if (node instanceof RS.AST_VarDef)          this.handle_vardef();
+        else if (RS.AST_AnnotatedAssign && node instanceof RS.AST_AnnotatedAssign) this.handle_annotated_assign();
         else if (node instanceof RS.AST_SymbolRef)       this.handle_symbol_ref();
         else if (node instanceof RS.AST_Decorator)       this.handle_decorator();
         else if (node instanceof RS.AST_SymbolFunarg)    this.handle_symbol_funarg();
@@ -634,7 +674,17 @@ export class Diagnostics {
         }
 
         // --- Lint ---
-        const linter = new Linter(RS, toplevel, code, this._builtins);
+        // Build known-module set for import validation.
+        // Only activates when the caller has registered at least one module.
+        let knownModules = null;
+        const vf = options.virtualFiles;
+        const sf = options.stdlibFiles;
+        if ((vf && Object.keys(vf).length > 0) || (sf && Object.keys(sf).length > 0)) {
+            knownModules = Object.create(null);
+            if (vf) Object.keys(vf).forEach(k => { knownModules[k] = true; });
+            if (sf) Object.keys(sf).forEach(k => { knownModules[k] = true; });
+        }
+        const linter = new Linter(RS, toplevel, code, this._builtins, knownModules);
         toplevel.walk(linter);
         messages = linter.resolve(noqa);
 

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

@@ -53,7 +53,7 @@ class ModelState {
     _run() {
         const service = this._service;
         const code    = this._model.getValue();
-        const opts    = { virtualFiles: service._virtualFiles };
+        const opts    = { virtualFiles: service._virtualFiles, stdlibFiles: service._stdlibFiles };
 
         // Diagnostics (syntax errors + lint markers)
         const markers = service._diagnostics.check(code, {
@@ -108,9 +108,12 @@ class RapydScriptLanguageService {
         this._builtins = new BuiltinsRegistry();
         this._builtins.enablePythonizeStrings();
 
-        // Merge BASE_BUILTINS + extra globals + DTS globals for completions
+        // Merge BASE_BUILTINS + DTS globals for completions.
+        // NOTE: _extraBuiltinNames (NS API keys like grow, growthAnalyze, etc.) are
+        // intentionally excluded here — they are handled by the DTS registry as dot-
+        // completions on ns.* and should NOT appear as free-floating identifier
+        // suggestions. They are still used for tokenization and diagnostics suppression.
         const builtin_names = BASE_BUILTINS
-            .concat(this._extraBuiltinNames)
             .concat(this._dts.getGlobalNames());
 
         this._completions    = new CompletionEngine(this._analyzer, {
@@ -318,8 +321,9 @@ class RapydScriptLanguageService {
         const new_names = this._dts.getGlobalNames();
         // Suppress undef warnings for newly added globals
         this._diagnostics.addGlobals(new_names);
-        // Rebuild builtin list so completions include new DTS names (preserve extraBuiltins)
-        const builtin_names = BASE_BUILTINS.concat(this._extraBuiltinNames).concat(new_names);
+        // Rebuild builtin list so completions include new DTS names.
+        // _extraBuiltinNames are excluded — they are dot-completions only (see constructor).
+        const builtin_names = BASE_BUILTINS.concat(new_names);
         this._completions = new CompletionEngine(this._analyzer, {
             virtualFiles:    this._virtualFiles,
             stdlibFiles:     this._stdlibFiles,

package/src/output/codegen.pyj

@@ -279,7 +279,28 @@ def generate_code():
         self._do_print(output, "return")
     )
     DEFPRINT(AST_Throw, def(self, output):
-        self._do_print(output, "throw")
+        if self.cause:
+            # raise X from Y: set __cause__ on exception before throwing
+            output.print('var ρσ_throw_tmp')
+            output.space()
+            output.print('=')
+            output.space()
+            self.value.print(output)
+            output.semicolon()
+            output.newline()
+            output.indent()
+            output.print('ρσ_throw_tmp.__cause__')
+            output.space()
+            output.print('=')
+            output.space()
+            self.cause.print(output)
+            output.semicolon()
+            output.newline()
+            output.indent()
+            output.print('throw ρσ_throw_tmp')
+            output.semicolon()
+        else:
+            self._do_print(output, "throw")
     )
 
     # -----[ loop control ]-----
@@ -292,6 +313,17 @@ def generate_code():
         output.semicolon()
 
     DEFPRINT(AST_Break, def(self, output):
+        # If we are directly inside a for/else labeled block and this break has
+        # no explicit label, redirect it to the forelse label so the else clause
+        # is skipped.
+        if not self.label and output.forelse_stack and output.forelse_stack.length:
+            top = output.forelse_stack[output.forelse_stack.length - 1]
+            if top:
+                output.print('break')
+                output.space()
+                output.print(top)
+                output.semicolon()
+                return
         self._do_print(output, "break")
     )
     DEFPRINT(AST_Continue, def(self, output):
@@ -340,7 +372,10 @@ def generate_code():
     DEFPRINT(AST_If, def(self, output):
         output.print("if")
         output.space()
-        output.with_parens(def(): self.condition.print(output);)
+        if self.python_truthiness:
+            output.with_parens(def(): output.print('ρσ_bool('), self.condition.print(output), output.print(')');)
+        else:
+            output.with_parens(def(): self.condition.print(output);)
         output.space()
         if self.alternative:
             make_then(self, output)

package/src/output/functions.pyj

@@ -45,7 +45,7 @@ def function_args(argnames, output, strip_first):
 
 def function_preamble(node, output, offset):
     a = node.argnames
-    if not a or a.is_simple_func:
+    if a is None or a is undefined or a.is_simple_func:
         return
     # If this function has optional parameters/*args/**kwargs declare it differently
     fname = node.name.name if node.name else anonfunc
@@ -433,20 +433,42 @@ def print_function_call(self, output):
         return # new A is the same as new A() in javascript
 
     if not has_kwargs and not self.args.starargs:
-        # A simple function call, do nothing special
+        # A simple function call
         if is_new:
             output.print('new'), output.space()
-        # Bare print(...) → console.log(...) to avoid clobbering window.print
-        if not is_new and is_node_type(self.expression, AST_SymbolRef) and self.expression.name is 'print':
+            print_function_name()
+            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.expression.name is 'print':
+            # Bare print(...) → console.log(...) to avoid clobbering window.print
             output.print('console.log')
-        else:
+            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(')
             print_function_name()
-        output.with_parens(def():
             for i, a in enumerate(self.args):
-                if i:
-                    output.comma()
+                output.comma()
                 a.print(output)
-        )
+            output.print(')')
+        else:
+            # 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)
+            )
         return
 
     is_repeatable = is_new or not has_calls(self.expression)