rapydscript-ns 0.8.1 → 0.8.3

package/src/output/functions.pyj

@@ -1,6 +1,5 @@
 # vim:fileencoding=utf-8
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-# globals:regenerate
 from __python__ import hash_literals
 
 from ast import AST_ClassCall, AST_New, has_calls, AST_Dot, AST_SymbolRef, is_node_type
@@ -45,7 +44,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
@@ -263,21 +262,10 @@ def function_definition(self, output, strip_first, as_expression):
     if self.is_generator:
         output.print('()'), output.space()
         output.with_block(def():
-            if output.options.js_version >= 6:
-                output.indent()
-                output.print('function* js_generator')
-                function_args(self.argnames, output, strip_first)
-                print_bracketed(self, output, True, function_preamble)
-            else:
-                temp = OutputStream({'beautify':True})
-                temp.print('function* js_generator')
-                function_args(self.argnames, temp, strip_first)
-                print_bracketed(self, temp, True, function_preamble)
-                transpiled = regenerate(temp.get(), output.options.beautify).replace(/regeneratorRuntime.(wrap|mark)/g, 'ρσ_regenerator.regeneratorRuntime.$1')
-                if output.options.beautify:
-                    ci = output.make_indent(0)
-                    transpiled = [ci + x for x in transpiled.split('\n')].join('\n')
-                output.print(transpiled)
+            output.indent()
+            output.print('function* js_generator')
+            function_args(self.argnames, output, strip_first)
+            print_bracketed(self, output, True, function_preamble)
             output.newline()
             output.indent()
             output.spaced('var', 'result', '=', 'js_generator.apply(this,', 'arguments)')
@@ -433,20 +421,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)

package/src/output/loops.pyj

@@ -1,6 +1,5 @@
 # vim:fileencoding=utf-8
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-# globals: regenerate
 from __python__ import hash_literals
 
 from ast import AST_BaseCall, AST_SymbolRef, AST_Array, AST_Unary, AST_Number, has_calls, AST_Seq, AST_ListComprehension, AST_Starred, is_node_type
@@ -47,16 +46,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 +163,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 +274,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]
@@ -374,8 +435,6 @@ def print_list_comprehension(self, output):
         output.with_block(def():
             body_out = output
             if is_generator:
-                if es5:
-                    body_out = OutputStream({'beautify':True})
                 body_out.indent()
                 body_out.print('function* js_generator()'), body_out.space(), body_out.print('{')
                 body_out.newline()
@@ -423,12 +482,6 @@ def print_list_comprehension(self, output):
             if is_generator:
                 output.set_indentation(previous_indentation)
                 body_out.newline(), body_out.indent(), body_out.print('}')  # end js_generator
-                if es5:
-                    transpiled = regenerate(body_out.get(), output.options.beautify).replace(/regeneratorRuntime.(wrap|mark)/g, 'ρσ_regenerator.regeneratorRuntime.$1')
-                    if output.options.beautify:
-                        ci = output.make_indent(0)
-                        transpiled = [ci + x for x in transpiled.split('\n')].join('\n')
-                    output.print(transpiled)
                 output.newline(), output.indent()
                 output.spaced('var', 'result', '=', 'js_generator.call(this)')
                 output.end_statement()

package/src/output/modules.pyj

@@ -18,7 +18,7 @@ def write_imports(module, output):
     imports = []
     for import_id in Object.keys(module.imports):
         imports.push(module.imports[import_id])
-    imports.sort(def(a, b):
+    imports.jssort(def(a, b):
         a, b = a.import_order, b.import_order
         return -1 if a < b else (1 if a > b else 0)
     )
@@ -122,9 +122,6 @@ def prologue(module, output):
         output.indent(), output.spaced('if(', 'typeof', 'HTMLCollection', '!==', '"undefined"', '&&', 'typeof', 'Symbol', '===', '"function")',
             'NodeList.prototype[Symbol.iterator]', '=', 'HTMLCollection.prototype[Symbol.iterator]', '=', 'NamedNodeMap.prototype[Symbol.iterator]', '=', 'Array.prototype[Symbol.iterator]')
         output.end_statement()
-    needs_yield = output.options.js_version < 6 and module.baselib['yield']
-    if needs_yield:
-        output.dump_yield()
     # output the baselib
     if not output.options.baselib_plain:
         raise ValueError('The baselib is missing! Remember to set the baselib_plain field on the options for OutputStream')

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()
@@ -270,6 +280,12 @@ def print_binary_op(self, output):
         write_smart_equality(self, output)
     elif self.operator is 'instanceof':
         write_instanceof(self.left, self.right, output)
+    elif self.operator is '+':
+        output.print('ρσ_list_add(')
+        self.left.print(output)
+        output.comma()
+        self.right.print(output)
+        output.print(')')
     elif self.operator is '*' and is_node_type(self.left, AST_String):
         self.left.print(output), output.print('.repeat('), self.right.print(output), output.print(')')
     elif self.operator is '===' or self.operator is '!==':
@@ -284,6 +300,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 +414,21 @@ 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 '+=':
+        output.assign(self.left)
+        output.print('ρσ_list_iadd(')
+        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 +451,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

@@ -1,6 +1,5 @@
 # vim:fileencoding=utf-8
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-# globals:regenerate
 from __python__ import hash_literals
 
 from utils import make_predicate, defaults, repeat_string
@@ -76,6 +75,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
@@ -249,18 +254,6 @@ class OutputStream:
         if self.options.space_colon:
             self.space()
 
-    def dump_yield(self):
-        self.indent()
-        self.spaced('var', 'ρσ_regenerator', '=', '{}')
-        self.end_statement()
-        code = 'ρσ_regenerator.regeneratorRuntime = ' + regenerate(False, self.options.beautify)
-        if self.options.beautify:
-            code = code.replace(/\/\/.*$/mg, '\n').replace(/^\s*$/gm, '')  # strip comments
-            ci = self.make_indent(0)
-            code = [ci + x for x in code.split('\n')].join('\n')
-        self.print(code + '})(ρσ_regenerator)')
-        self.end_statement()
-
     def get(self):
         return self.OUTPUT
     toString = get

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++":
@@ -1367,6 +1416,18 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         bases = v'[]'
         class_parent = None
 
+        # If this class is nested inside another class, register it under its
+        # full dotted path (e.g. "Outer.Inner") in the module-level class scope
+        # (S.classes[0]).  This lets get_class_in_scope() find "Outer.Inner" as
+        # a class and produce a correct AST_New constructor call instead of
+        # treating it as a method call on Outer.
+        outer_class_parts = []
+        for _outer in S.in_class:
+            if _outer:
+                outer_class_parts.push(_outer)
+        if outer_class_parts.length > 0:
+            S.classes[0][outer_class_parts.join('.') + '.' + name.name] = class_details
+
         # read the bases of the class, if any
         if is_("punc", "("):
             S.in_parenthesized_expr = True
@@ -1472,7 +1533,11 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         visitor = new walker()
 
         for stmt in definition.body:
-            if not is_node_type(stmt, AST_Class):
+            if is_node_type(stmt, AST_Class):
+                # Nested class: include in statements but don't walk through the
+                # class-var mangling visitor (nested classes have their own scope).
+                definition.statements.push(stmt)
+            else:
                 stmt.walk(visitor)
                 definition.statements.push(stmt)
         return definition
@@ -1865,7 +1930,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 +1983,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 +2745,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 +2836,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 +2873,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 +2894,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([
     "//=",
     "/=",
     "*=",
+    "**=",
     "%=",
     ">>=",
     "<<=",