rapydscript-ns 0.8.1 → 0.8.3

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
 // ---------------------------------------------------------------------------
@@ -26,6 +45,13 @@ import { resolve_first_type } from './dts.js';
  * @returns {{ type: string, objectName?: string, moduleName?: string, prefix: string }}
  */
 export function detect_context(linePrefix) {
+    // `obj.method().attr` — dot access on a call result (single-level call expression).
+    // Must be checked before the plain dot match since `[\w.]+` cannot span `()`.
+    const call_result_match = linePrefix.match(/([\w.]+)\([^)]*\)\.([\w]*)$/);
+    if (call_result_match) {
+        return { type: 'call_result', callPath: call_result_match[1], prefix: call_result_match[2] };
+    }
+
     // `obj.attr` or `obj.sub.attr` — dot access (captures multi-level path)
     const dot_match = linePrefix.match(/([\w.]+)\.([\w]*)$/);
     if (dot_match) {
@@ -246,6 +272,9 @@ export class CompletionEngine {
     getCompletions(scopeMap, position, linePrefix, monacoKind) {
         const ctx = detect_context(linePrefix);
 
+        if (ctx.type === 'call_result') {
+            return { suggestions: this._call_result_completions(position, ctx, monacoKind, scopeMap) };
+        }
         if (ctx.type === 'dot') {
             return { suggestions: this._dot_completions(scopeMap, position, ctx, monacoKind) };
         }
@@ -267,7 +296,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 +326,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,9 +338,100 @@ 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;
     }
 
+    // ---- Return-type helpers -----------------------------------------------
+
+    /**
+     * Analyze a module and return the `return_type` of a named function.
+     * @param {string} func_name
+     * @param {string} module_name
+     * @returns {string|null}
+     */
+    _get_return_type_from_module(func_name, module_name) {
+        const src = this._virtualFiles[module_name] || this._stdlibFiles[module_name];
+        if (!src) return null;
+        let mod_map;
+        try {
+            mod_map = this._analyzer.analyze(src, {});
+        } catch (_e) {
+            return null;
+        }
+        const mod_frame = mod_map.frames.find(f => f.kind === 'module');
+        if (!mod_frame) return null;
+        const fn_sym = mod_frame.getSymbol(func_name);
+        if (fn_sym && fn_sym.return_type) return fn_sym.return_type;
+        return null;
+    }
+
+    /**
+     * Resolve a type name (e.g. from inferred_class) through function return annotations,
+     * including cross-file imports. Returns the resolved type name, or null if unresolvable.
+     * @param {string} name
+     * @param {import('./scope.js').ScopeMap} scopeMap
+     * @returns {string|null}
+     */
+    _resolve_type_through_functions(name, scopeMap) {
+        let sym = null;
+        for (const frame of scopeMap.frames) {
+            const s = frame.getSymbol(name);
+            if (s) { sym = s; break; }
+        }
+        if (!sym) return null;
+
+        if (sym.kind === 'function' || sym.kind === 'method') {
+            // return_type is set by explicit annotation or inferred by the analyzer
+            if (sym.return_type) return sym.return_type;
+            return null;
+        }
+
+        if (sym.kind === 'import' && sym.source_module) {
+            const orig = sym.original_name || sym.name;
+            return this._get_return_type_from_module(orig, sym.source_module);
+        }
+
+        return null;
+    }
+
+    /**
+     * Get the member map for a given type name.
+     * Checks builtins, then user class frames. Returns null if unknown.
+     * @param {string} type_name
+     * @param {import('./scope.js').ScopeMap|null} scopeMap
+     * @returns {Map|null}
+     */
+    _get_members_for_type(type_name, scopeMap) {
+        if (!type_name) return null;
+        if (this._builtins) {
+            const m = this._builtins.getTypeMembers(type_name);
+            if (m) return m;
+        }
+        if (scopeMap) {
+            for (const frame of scopeMap.frames) {
+                if (frame.kind === 'class' && frame.name === type_name) {
+                    return frame.symbols;
+                }
+            }
+        }
+        return null;
+    }
+
     // ---- Dot completions ---------------------------------------------------
 
     _dot_completions(scopeMap, position, ctx, monacoKind) {
@@ -361,6 +499,13 @@ export class CompletionEngine {
                 }
             }
 
+            // Resolve class_name through function return type annotations.
+            // e.g. x = getAllServers() → inferred_class='getAllServers' → resolve 'list'
+            if (class_name) {
+                const resolved = this._resolve_type_through_functions(class_name, scopeMap);
+                if (resolved) class_name = resolved;
+            }
+
             if (class_name) {
                 for (const frame of scopeMap.frames) {
                     if (frame.kind === 'class' && frame.name === class_name) {
@@ -381,7 +526,13 @@ export class CompletionEngine {
         // 1.5. Built-in type members — list, str, dict, number.
         //      Used when inferred_class names a built-in type, not a user class.
         if (!scope_matched && this._builtins && obj_sym && obj_sym.inferred_class) {
-            const members = this._builtins.getTypeMembers(obj_sym.inferred_class);
+            // Re-resolve in case inferred_class itself is a function name.
+            let type_name = obj_sym.inferred_class;
+            if (scopeMap) {
+                const resolved = this._resolve_type_through_functions(type_name, scopeMap);
+                if (resolved) type_name = resolved;
+            }
+            const members = this._builtins.getTypeMembers(type_name);
             if (members) {
                 scope_matched = true;
                 for (const [name, member] of members) {
@@ -444,6 +595,76 @@ export class CompletionEngine {
         return items;
     }
 
+    // ---- Call-result dot completions (e.g. ns.self().attr) -----------------
+
+    _call_result_completions(position, ctx, monacoKind, scopeMap) {
+        const range     = word_range(position, ctx.prefix);
+        const items     = [];
+        const seen      = new Set();
+        const call_path = ctx.callPath;
+        const last_dot  = call_path.lastIndexOf('.');
+
+        // --- DTS path (existing logic) ---
+        if (this._dts) {
+            let member_ti = null;
+            if (last_dot > 0) {
+                const object_path = call_path.slice(0, last_dot);
+                const method_name = call_path.slice(last_dot + 1);
+                member_ti = this._dts.getMemberInfo(object_path, method_name);
+            } else {
+                member_ti = this._dts.getGlobal(call_path);
+            }
+            if (member_ti && member_ti.return_type) {
+                const return_ti = this._dts.getGlobal(resolve_first_type(member_ti.return_type));
+                if (return_ti && return_ti.members) {
+                    for (const [name, member] of return_ti.members) {
+                        if (!ctx.prefix || name.startsWith(ctx.prefix)) {
+                            seen.add(name);
+                            items.push(_dts_member_to_item(member, range, monacoKind));
+                        }
+                    }
+                }
+            }
+        }
+
+        // --- User-defined function return types (scopeMap) ---
+        if (scopeMap && last_dot < 0) {
+            // Simple call like getAllServers() — look up function in scope
+            let sym = null;
+            for (const frame of scopeMap.frames) {
+                const s = frame.getSymbol(call_path);
+                if (s) { sym = s; break; }
+            }
+            if (sym) {
+                let return_type = null;
+                if (sym.kind === 'function' || sym.kind === 'method') {
+                    return_type = sym.return_type;
+                } else if (sym.kind === 'import' && sym.source_module) {
+                    const orig = sym.original_name || sym.name;
+                    return_type = this._get_return_type_from_module(orig, sym.source_module);
+                }
+                if (return_type) {
+                    const members = this._get_members_for_type(return_type, scopeMap);
+                    if (members) {
+                        for (const [name, member] of members) {
+                            if (!seen.has(name) && (!ctx.prefix || name.startsWith(ctx.prefix))) {
+                                seen.add(name);
+                                // members may be SymbolInfo (class frame) or TypeInfo/BuiltinInfo
+                                const item = member.kind === 'function' || member.kind === 'method' ||
+                                             member.kind === 'variable' || member.kind === 'parameter'
+                                    ? symbol_to_item(member, range, monacoKind, '0')
+                                    : _dts_member_to_item(member, range, monacoKind);
+                                items.push(item);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return items;
+    }
+
     // ---- from X import completions -----------------------------------------
 
     _from_import_completions(position, ctx, monacoKind) {

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,13 +28,13 @@ 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' +
     ' Boolean encodeURIComponent decodeURIComponent setTimeout setInterval' +
     ' setImmediate clearTimeout clearInterval clearImmediate requestAnimationFrame' +
-    ' id repr sorted __name__ equals get_module ρσ_str jstype divmod NaN super Ellipsis'
+    ' id repr sorted __name__ equals get_module ρσ_str jstype divmod NaN super Ellipsis slice'
 ).split(' ');
 
 // ---------------------------------------------------------------------------
@@ -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

@@ -36,6 +36,13 @@ class ModelState {
         this._timer    = null;
         this._scopeMap = null;  // most recent ScopeMap for this model
 
+        // Derive the module name from the model URI so this model's content can
+        // be registered in _virtualFiles for cross-file import resolution.
+        // e.g. URI path "/scripts/utils.py" → module name "utils"
+        const uri_path = (model.uri && (model.uri.path || model.uri.fsPath)) || '';
+        const basename = uri_path.split('/').pop() || '';
+        this._module_name = basename.replace(/\.pyj?x?$/, '') || null;
+
         // Run immediately on first attach
         this._schedule(0);
 
@@ -53,7 +60,13 @@ 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 };
+
+        // Register this model's content in the shared virtualFiles pool so other
+        // open models can resolve cross-file imports from it.
+        if (this._module_name) {
+            service._virtualFiles[this._module_name] = code;
+        }
 
         // Diagnostics (syntax errors + lint markers)
         const markers = service._diagnostics.check(code, {
@@ -69,6 +82,10 @@ class ModelState {
     dispose() {
         clearTimeout(this._timer);
         this._subscription.dispose();
+        // Remove this model's content from the virtualFiles pool on detach.
+        if (this._module_name) {
+            delete this._service._virtualFiles[this._module_name];
+        }
         // Clear markers when detaching
         this._service._monaco.editor.setModelMarkers(this._model, LANGUAGE_ID, []);
     }
@@ -108,9 +125,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 +338,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/monaco-language-service/scope.js

@@ -30,6 +30,9 @@ export class SymbolInfo {
         this.inferred_class = opts.inferred_class || null;  // 'ClassName' when x = ClassName(...)
         this.dts_call_path  = opts.dts_call_path  || null;  // 'ns.getServer' when x = ns.getServer(...)
         this.type           = null;              // Phase 6: TypeInfo
+        this.return_type    = opts.return_type   || null;  // annotated return type, e.g. 'list', 'str', 'MyClass'
+        this.source_module  = opts.source_module || null;  // module name when kind='import' (from X import Y)
+        this.original_name  = opts.original_name || null;  // pre-alias name for imports (from X import Y as Z → 'Y')
     }
 }
 

package/src/output/classes.pyj

@@ -214,7 +214,7 @@ def print_class(output):
                 output.end_statement()
 
         elif is_node_type(stmt, AST_Class):
-            console.error('Nested classes aren\'t supported yet')  # noqa:undef
+            pass  # nested classes are emitted in the statements section below
 
     if not defined_methods['__repr__']:
         define_default_method('__repr__', def():
@@ -271,9 +271,26 @@ def print_class(output):
             output.print(JSON.stringify(create_doctring(self.docstrings)))
         )
 
-    # Other statements in the class context
+    # Other statements in the class context (including nested class definitions)
     for stmt in self.statements:
-        if not is_node_type(stmt, AST_Method):
+        if is_node_type(stmt, AST_Class):
+            # Print the nested class in full, then attach it to the outer class.
+            # Two assignments mirror Python semantics:
+            #   Outer.Inner        — class-level access (Outer.Inner())
+            #   Outer.prototype.Inner — instance-level access (self.Inner() inside methods)
+            output.indent()
+            stmt.print(output)
+            output.newline()
+            nested_name = stmt.name.name
+            output.indent()
+            self.name.print(output)
+            output.print('.' + nested_name + ' = ' + nested_name)
+            output.end_statement()
+            output.indent()
+            self.name.print(output)
+            output.print('.prototype.' + nested_name + ' = ' + nested_name)
+            output.end_statement()
+        elif not is_node_type(stmt, AST_Method):
             output.indent()
             stmt.print(output)
             output.newline()

package/src/output/codegen.pyj

@@ -2,7 +2,7 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
 
-# globals:console,regenerate,writefile
+# globals:console,writefile
 
 from utils import noop
 from parse import PRECEDENCE
@@ -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)