rapydscript-ns 0.8.1 → 0.8.2

package/src/output/loops.pyj

@@ -47,16 +47,49 @@ def print_do_loop(self, output):
     output.space()
     output.print("while")
     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.semicolon()
 
 def print_while_loop(self, output):
+    # while/else: wrap in a labeled block; break inside will skip the else
+    forelse_label = None
+    if self.belse:
+        forelse_label = output.new_forelse_label()
+        output.forelse_stack.push(forelse_label)
+        output.print(forelse_label + ':')
+        output.space()
+        output.print('{')
+        output.newline()
+        output.set_indentation(output.next_indent())
+        output.indent()
+    else:
+        output.forelse_stack.push(None)
+
     output.print("while")
     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()
     self._do_print_body(output)
 
+    output.forelse_stack.pop()
+
+    if forelse_label:
+        if self.belse and self.belse.body and self.belse.body.length:
+            output.newline()
+            for stmt in self.belse.body:
+                output.indent()
+                stmt.print(output)
+                output.newline()
+        output.set_indentation(output._indentation - output.options.indent_level)
+        output.indent()
+        output.print('}')
+
 def is_simple_for_in(self):
     # return true if this loop can be simplified into a basic for (i in j) loop
     if is_node_type(self.object, AST_BaseCall)
@@ -131,6 +164,21 @@ def print_for_in(self, output):
         else:
             self.object.print(output)
 
+    # for/else: wrap in a labeled block; break inside will use the label to skip else
+    forelse_label = None
+    if self.belse:
+        forelse_label = output.new_forelse_label()
+        output.forelse_stack.push(forelse_label)
+        output.print(forelse_label + ':')
+        output.space()
+        output.print('{')
+        output.newline()
+        output.set_indentation(output.next_indent())
+        output.indent()
+    else:
+        # Push null so nested for loops don't mistakenly grab an outer forelse label
+        output.forelse_stack.push(None)
+
     if is_simple_for(self):
         # optimize range() into a simple for loop
         increment = None
@@ -227,6 +275,20 @@ def print_for_in(self, output):
     output.space()
     self._do_print_body(output)
 
+    output.forelse_stack.pop()
+
+    if forelse_label:
+        # Emit else body, then close the labeled block
+        if self.belse and self.belse.body and self.belse.body.length:
+            output.newline()
+            for stmt in self.belse.body:
+                output.indent()
+                stmt.print(output)
+                output.newline()
+        output.set_indentation(output._indentation - output.options.indent_level)
+        output.indent()
+        output.print('}')
+
 def print_list_comprehension(self, output):
     tname = self.constructor.name.slice(4)
     result_obj = {'ListComprehension':'[]', 'DictComprehension':('Object.create(null)' if self.is_jshash else '{}'), 'SetComprehension':'ρσ_set()'}[tname]

package/src/output/operators.pyj

@@ -110,6 +110,16 @@ def print_unary_prefix(self, output):
         if op is '~':
             output.print('ρσ_op_invert('), self.expression.print(output), output.print(')')
             return
+    if op is '!' and self.python_truthiness:
+        output.print('!ρσ_bool(')
+        if self.parenthesized:
+            output.with_parens(def():
+                self.expression.print(output)
+            )
+        else:
+            self.expression.print(output)
+        output.print(')')
+        return
     output.print(op)
     if /^[a-z]/i.test(op):
         output.space()
@@ -284,6 +294,36 @@ def print_binary_op(self, output):
             output.spaced(nan_check, '!==' if self.operator is '===' else '===', nan_check)
         else:
             output.spaced(self.left, self.operator, self.right)
+    elif (self.operator is '&&' or self.operator is '||') and self.python_truthiness:
+        # Python `and`/`or` use Python truthiness (only when from __python__ import truthiness is set).
+        # `a and b` → `ρσ_bool(a) ? b : a`   (returns a if falsy, else b)
+        # `a or b`  → `ρσ_bool(a) ? a : b`   (returns a if truthy, else b)
+        # For non-simple left operands, cache in ρσ_expr_temp to avoid double evaluation.
+        is_and = self.operator is '&&'
+        if is_node_type(self.left, AST_SymbolRef):
+            output.print('(ρσ_bool(')
+            self.left.print(output)
+            output.print(') ? ')
+            if is_and:
+                self.right.print(output)
+                output.print(' : ')
+                self.left.print(output)
+            else:
+                self.left.print(output)
+                output.print(' : ')
+                self.right.print(output)
+            output.print(')')
+        else:
+            output.print('(ρσ_expr_temp = ')
+            self.left.print(output)
+            output.print(', ρσ_bool(ρσ_expr_temp) ? ')
+            if is_and:
+                self.right.print(output)
+                output.print(' : ρσ_expr_temp)')
+            else:
+                output.print('ρσ_expr_temp : ')
+                self.right.print(output)
+                output.print(')')
     else:
         output.spaced(self.left, self.operator, self.right)
 
@@ -368,6 +408,13 @@ def print_assign(self, output):
             self.right.print(output)
         )
         return
+    if self.operator is '**=':
+        output.assign(self.left)
+        if output.options.js_version > 6:
+            output.print('(('), self.left.print(output), output.spaced(')', '**', '('), self.right.print(output), output.print('))')
+        else:
+            output.print('Math.pow('), self.left.print(output), output.comma(), self.right.print(output), output.print(')')
+        return
     if self.operator is '=' and self.is_chained():
         left_hand_sides, rhs = self.traverse_chain()
         is_compound_assign = False
@@ -390,7 +437,12 @@ def print_assign(self, output):
 
 def print_conditional(self, output, condition, consequent, alternative):
     condition, consequent, alternative = self.condition, self.consequent, self.alternative
-    output.with_parens(def():condition.print(output);)
+    if self.python_truthiness:
+        output.print('ρσ_bool(')
+        condition.print(output)
+        output.print(')')
+    else:
+        output.with_parens(def(): condition.print(output);)
     output.space()
     output.print("?")
     output.space()

package/src/output/statements.pyj

@@ -156,15 +156,16 @@ def print_with(self, output):
     output.with_block(def():
         output.indent(), output.assign('ρσ_with_exception'), output.print('e'), output.end_statement()
     )
+    reversed_exits = exits.slice().reverse()
     output.newline(), output.indent(), output.spaced('if', '(ρσ_with_exception', '===', 'undefined)')
     output.with_block(def():
-        for clause in exits:
+        for clause in reversed_exits:
             output.indent(), output.print(clause + '.__exit__()'), output.end_statement()
     )
     output.space(), output.print('else'), output.space()
     output.with_block(def():
         output.indent(), output.assign('ρσ_with_suppress'), output.print('false'), output.end_statement()
-        for clause in exits:
+        for clause in reversed_exits:
             output.indent()
             output.spaced('ρσ_with_suppress', '|=', 'ρσ_bool(' + clause + '.__exit__(ρσ_with_exception.constructor,',
                             'ρσ_with_exception,', 'ρσ_with_exception.stack))')
@@ -175,7 +176,10 @@ def print_with(self, output):
 def print_assert(self, output):
     if output.options.discard_asserts:
         return
-    output.spaced('if', '(!('), self.condition.print(output), output.spaced('))', 'throw new AssertionError')
+    if self.python_truthiness:
+        output.spaced('if', '(!ρσ_bool('), self.condition.print(output), output.spaced('))', 'throw new AssertionError')
+    else:
+        output.spaced('if', '(!('), self.condition.print(output), output.spaced('))', 'throw new AssertionError')
     if self.message:
         output.print('(')
         self.message.print(output)

package/src/output/stream.pyj

@@ -76,6 +76,12 @@ class OutputStream:
         self.with_counter = 0
         self.try_else_counter = 0
         self.match_counter = 0
+        self.forelse_counter = 0
+        self.forelse_stack = v'[]'
+
+    def new_forelse_label(self):
+        self.forelse_counter += 1
+        return 'ρσ_forelse_' + self.forelse_counter
 
     def new_try_else_counter(self):
         self.try_else_counter += 1

package/src/parse.pyj

@@ -24,12 +24,13 @@ AST_Undefined, AST_Var, AST_VarDef, AST_Verbatim, AST_While, AST_With, AST_WithC
 AST_Yield, AST_Await, AST_Assert, AST_Existential, AST_NamedExpr, AST_AnnotatedAssign, AST_Super, AST_Starred, is_node_type,
 AST_Match, AST_MatchCase,
 AST_MatchWildcard, AST_MatchCapture, AST_MatchLiteral, AST_MatchOr,
-AST_MatchAs, AST_MatchStar, AST_MatchSequence, AST_MatchMapping, AST_MatchClass
+AST_MatchAs, AST_MatchStar, AST_MatchSequence, AST_MatchMapping, AST_MatchClass,
+TreeWalker
 )
 from tokenizer import tokenizer, is_token, RESERVED_WORDS
 
 COMPILER_VERSION = '__COMPILER_VERSION__'
-PYTHON_FLAGS = {'dict_literals':True, 'overload_getitem':True, 'bound_methods':True, 'hash_literals':True, 'overload_operators':True}
+PYTHON_FLAGS = {'dict_literals':True, 'overload_getitem':True, 'bound_methods':True, 'hash_literals':True, 'overload_operators':True, 'truthiness':True}
 
 
 def get_compiler_version():
@@ -116,7 +117,7 @@ FORBIDDEN_CLASS_VARS = 'prototype constructor'.split(' ')
 # -----[ Parser (constants) ]-----
 UNARY_PREFIX = make_predicate('typeof void delete ~ - + ! @')
 
-ASSIGNMENT = make_predicate('= += -= /= //= *= %= >>= <<= >>>= |= ^= &=')
+ASSIGNMENT = make_predicate('= += -= /= //= *= **= %= >>= <<= >>>= |= ^= &=')
 
 PRECEDENCE = (def(a, ret):
     for i in range(a.length):
@@ -336,7 +337,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     continue
 
                 # recursive descent into conditional, loop and exception bodies
-                for option in ('body', 'alternative', 'bcatch', 'condition'):
+                for option in ('body', 'alternative', 'bcatch', 'belse', 'condition'):
                     opt = stmt[option]
                     if opt:
                         extend(scan_for_local_vars(opt))
@@ -402,6 +403,23 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
 
         elif is_node_type(body, AST_ForIn):
             add_for_in(body)
+            # Also scan conditions for walrus operators (e.g. comprehension filters)
+            if body.condition:
+                extend(scan_for_local_vars(body.condition))
+            if body.clauses:
+                for clause in body.clauses:
+                    if clause.condition:
+                        extend(scan_for_local_vars(clause.condition))
+
+        else:
+            # Generic expression node — walk for walrus operators, stopping at scope boundaries
+            if body.walk:
+                body.walk(new TreeWalker(def(node):
+                    if is_node_type(node, AST_NamedExpr):
+                        push(node.name.name)
+                    if is_node_type(node, AST_Scope):
+                        return True  # prune: don't descend into inner function scopes
+                ))
 
         return localvars
 
@@ -550,7 +568,8 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                             croak('Assignments in do loop conditions are not allowed')
                         semicolon()
                         return tmp
-                    )()
+                    )(),
+                    'python_truthiness': S.scoped_flags.get('truthiness', False)
                 })
             elif tmp_ is "while":
                 while_cond = expression(True)
@@ -558,9 +577,21 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     croak('Assignments in while loop conditions are not allowed')
                 if not is_('punc', ':'):
                     croak('Expected a colon after the while statement')
+                while_body = in_loop(statement)
+                while_belse = None
+                if is_("keyword", "else"):
+                    start = S.token
+                    next()
+                    while_belse = new AST_Else({
+                        'start': start,
+                        'body': block_(),
+                        'end': prev()
+                    })
                 return new AST_While({
                     'condition': while_cond,
-                    'body': in_loop(statement)
+                    'body': while_body,
+                    'belse': while_belse,
+                    'python_truthiness': S.scoped_flags.get('truthiness', False)
                 })
             elif tmp_ is "for":
                 if is_('js'):
@@ -622,7 +653,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 if is_('punc', ','):
                     next()
                     msg = expression(False)
-                return new AST_Assert({'start': start, 'condition':cond, 'message':msg, 'end':prev()})
+                return new AST_Assert({'start': start, 'condition':cond, 'message':msg, 'end':prev(), 'python_truthiness': S.scoped_flags.get('truthiness', False)})
             elif tmp_ is "if":
                 return if_()
             elif tmp_ is "pass":
@@ -647,10 +678,17 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     })
 
                 tmp = expression(True)
+                cause = None
+                if is_("keyword", "from"):
+                    next()
+                    cause = expression(True)
                 semicolon()
-                return new AST_Throw({
+                node = new AST_Throw({
                     'value': tmp
                 })
+                if cause is not None:
+                    node.cause = cause
+                return node
             elif tmp_ is "try":
                 return try_()
             elif tmp_ is "nonlocal":
@@ -1116,11 +1154,22 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 'object': obj
             }
 
+        body = in_loop(statement)
+        belse = None
+        if is_("keyword", "else"):
+            start = S.token
+            next()
+            belse = new AST_Else({
+                'start': start,
+                'body': block_(),
+                'end': prev()
+            })
         return new AST_ForIn({
             'init': init,
             'name': lhs,
             'object': obj,
-            'body': in_loop(statement)
+            'body': body,
+            'belse': belse
         })
 
     # A native JavaScript for loop - for v"var i=0; i<5000; i++":
@@ -1865,7 +1914,8 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         return new AST_If({
             'condition': cond,
             'body': body,
-            'alternative': belse
+            'alternative': belse,
+            'python_truthiness': S.scoped_flags.get('truthiness', False)
         })
 
     def is_docstring(stmt):
@@ -1917,10 +1967,19 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             next()
             exceptions = []
             if not is_("punc", ":") and not is_("keyword", "as"):
+                # Accept both: except TypeError, ValueError:
+                #          and: except (TypeError, ValueError):
+                paren_wrapped = is_("punc", "(")
+                if paren_wrapped:
+                    next()
                 exceptions.push(as_symbol(AST_SymbolVar))
                 while is_("punc", ","):
                     next()
+                    if paren_wrapped and is_("punc", ")"):
+                        break  # trailing comma inside parens
                     exceptions.push(as_symbol(AST_SymbolVar))
+                if paren_wrapped:
+                    expect(")")
 
             name = None
             if is_("keyword", "as"):
@@ -2670,7 +2729,8 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 'start': start,
                 'expression': expr,
                 'args': func_call_list(),
-                'end': prev()
+                'end': prev(),
+                'python_truthiness': S.scoped_flags.get('truthiness', False) and is_node_type(expr, AST_SymbolRef)
             }), True)
             S.in_parenthesized_expr = False
             return ret
@@ -2760,6 +2820,8 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             ex.end = prev()
             if S.scoped_flags.get('overload_operators', False) and (start.value is '-' or start.value is '+' or start.value is '~'):
                 ex.overloaded = True
+            if S.scoped_flags.get('truthiness', False) and start.value is '!':
+                ex.python_truthiness = True
             return ex
 
         val = expr_atom(allow_calls)
@@ -2795,7 +2857,8 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 'operator': op,
                 'right': right,
                 'end': right.end,
-                'overloaded': S.scoped_flags.get('overload_operators', False)
+                'overloaded': S.scoped_flags.get('overload_operators', False),
+                'python_truthiness': S.scoped_flags.get('truthiness', False) and (op is '&&' or op is '||')
             })
             return expr_op(ret, min_prec, no_in)
         return left
@@ -2815,7 +2878,8 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 'condition': ne,
                 'consequent': expr,
                 'alternative': expression(False, no_in),
-                'end': peek()
+                'end': peek(),
+                'python_truthiness': S.scoped_flags.get('truthiness', False)
             })
             return conditional
         return expr

package/src/tokenizer.pyj

@@ -53,6 +53,7 @@ OPERATORS = make_predicate([
     "//=",
     "/=",
     "*=",
+    "**=",
     "%=",
     ">>=",
     "<<=",