rapydscript-ng 0.8.3 → 0.8.4

package/src/output/loops.pyj

@@ -2,7 +2,10 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
 
-from ast import AST_BaseCall, AST_SymbolRef, AST_Array, AST_Unary, AST_Number, has_calls, AST_Seq, AST_ListComprehension, is_node_type
+from ast import (
+    AST_BaseCall, AST_SymbolRef, AST_Array, AST_Unary, AST_Number,
+    has_calls, AST_Seq, AST_ListComprehension, is_node_type
+)
 
 
 def unpack_tuple(elems, output, in_statement):
@@ -41,21 +44,28 @@ 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)
     and is_node_type(self.object.expression, AST_SymbolRef)
-    and self.object.expression.name is 'dir' and self.object.args.args.length is 1:
+    and self.object.expression.name is 'dir'
+    and self.object.args.args.length is 1:
         return True
     return False
 
 
 def is_simple_for(self):
-    # returns true if this loop can be simplified into a basic for(i=n;i<h;i++) loop
+    # returns true if this loop can be simplified into a
+    # basic for(i=n;i<h;i++) loop
     if (is_node_type(self.object, AST_BaseCall) and
             is_node_type(self.object.expression, AST_SymbolRef) and
             self.object.expression.name is 'range' and
             not (is_node_type(self.init, AST_Array))):
         a = self.object.args.args
         l = a.length
-        if l < 3 or (is_node_type(a[2].value, AST_Number) or (is_node_type(a[2].value, AST_Unary) and a[2].value.operator is '-' and is_node_type(a[2].value.expression, AST_Number))):
-            if (l is 1 and not has_calls(a[0].value)) or (l > 1 and not has_calls(a[1].value)):
+        if (l < 3 or (
+                is_node_type(a[2].value, AST_Number) or (
+                    is_node_type(a[2].value, AST_Unary) and
+                    a[2].value.operator is '-' and
+                    is_node_type(a[2].value.expression, AST_Number)))):
+            if ((l is 1 and not has_calls(a[0].value)) or
+                    (l > 1 and not has_calls(a[1].value))):
                 return True
     return False
 
@@ -150,13 +160,18 @@ def print_for_in(self, output):
             output.space()
             output.print(idx)
             output.space()
-            output.print('>') if is_node_type(increment, AST_Unary) else output.print('<')
+            if is_node_type(increment, AST_Unary):
+                output.print('>')
+            else:
+                output.print('<')
             output.space()
             end.print(output)
             output.semicolon()
             output.space()
             output.print(idx)
-            if increment and (not (is_node_type(increment, AST_Unary)) or increment.expression.value is not '1'):
+            if (increment and (
+                    not (is_node_type(increment, AST_Unary)) or
+                    increment.expression.value is not '1')):
                 if is_node_type(increment, AST_Unary):
                     output.print('-=')
                     increment.expression.print(output)
@@ -204,7 +219,9 @@ def print_list_comprehension(self, output):
     tname = self.constructor.name.slice(4)
     result_obj = {
         'ListComprehension': '[]',
-        'DictComprehension': ('Object.create(null)' if self.is_jshash else '{}'),
+        'DictComprehension': (
+            'Object.create(null)' if self.is_jshash else '{}'
+        ),
         'SetComprehension': 'ρσ_set()',
     }[tname]
     is_generator = tname is 'GeneratorComprehension'
@@ -219,7 +236,9 @@ def print_list_comprehension(self, output):
                     output.space(), output.print(','), output.space()
                     output.with_parens(def ():
                         if self.value_statement.constructor is AST_Seq:
-                            output.with_square(def (): self.value_statement.print(output);)
+                            output.with_square(def ():
+                                self.value_statement.print(output)
+                            )
                         else:
                             self.value_statement.print(output)
                     )
@@ -235,13 +254,18 @@ def print_list_comprehension(self, output):
                 output.space(), output.print('='), output.space()
                 output.with_parens(def ():
                     if self.value_statement.constructor is AST_Seq:
-                        output.with_square(def (): self.value_statement.print(output);)
+                        output.with_square(def ():
+                            self.value_statement.print(output)
+                        )
                     else:
                         self.value_statement.print(output)
                 )
                 output.end_statement()
     else:
-        push_func = 'ρσ_Result.' + ('push' if self.constructor is AST_ListComprehension else 'add')
+        push_func = 'ρσ_Result.' + (
+            'push' if self.constructor is AST_ListComprehension
+            else 'add'
+        )
         if is_generator:
             push_func = 'yield '
         add_to_result = def (output):
@@ -263,7 +287,9 @@ def print_list_comprehension(self, output):
             body_out = output
             if is_generator:
                 body_out.indent()
-                body_out.print('function* js_generator()'), body_out.space(), body_out.print('{')
+                body_out.print('function* js_generator()')
+                body_out.space()
+                body_out.print('{')
                 body_out.newline()
                 previous_indentation = output.indentation()
                 output.set_indentation(output.next_indent())
@@ -311,7 +337,9 @@ def print_list_comprehension(self, output):
                     body_out.indent()
                     body_out.print('if')
                     body_out.space()
-                    body_out.with_parens(def (): self.condition.print(body_out);)
+                    body_out.with_parens(def ():
+                        self.condition.print(body_out)
+                    )
                     body_out.space()
                     body_out.with_block(def ():
                         add_to_result(body_out)
@@ -323,7 +351,10 @@ def print_list_comprehension(self, output):
             body_out.newline()
             if self.constructor is AST_ListComprehension:
                 body_out.indent()
-                body_out.spaced('ρσ_Result', '=', 'ρσ_list_constructor(ρσ_Result)')
+                body_out.spaced(
+                    'ρσ_Result', '=',
+                    'ρσ_list_constructor(ρσ_Result)'
+                )
                 body_out.end_statement()
             if not is_generator:
                 body_out.indent()
@@ -331,11 +362,14 @@ def print_list_comprehension(self, output):
                 body_out.end_statement()
             if is_generator:
                 output.set_indentation(previous_indentation)
-                body_out.newline(), body_out.indent(), body_out.print('}')  # end js_generator
+                body_out.newline()
+                body_out.indent()
+                body_out.print('}')  # end js_generator
                 output.newline(), output.indent()
                 output.spaced('var', 'result', '=', 'js_generator.call(this)')
                 output.end_statement()
-                # Python's generator objects use a separate method to send data to the generator
+                # Python's generator objects use a separate method to
+                # send data to the generator
                 output.indent()
                 output.spaced('result.send', '=', 'result.next')
                 output.end_statement()

package/src/output/modules.pyj

@@ -42,7 +42,8 @@ def write_imports(module, output):
                 output.print('ρσ_modules.' + module_id)
             else:
                 output.print('ρσ_modules["' + module_id + '"]')
-            output.space(), output.print('='), output.space(), output.print('{}')
+            output.space(), output.print('=')
+            output.space(), output.print('{}')
             output.end_statement()
 
     # Output module code
@@ -63,7 +64,8 @@ def write_main_name(output):
 
 def const_decl(js_version):
     # return 'const' if js_version > 5 else 'var'
-    # Workaround for bug in Chrome eval(). eval() barfs if it sees const before a function.
+    # Workaround for bug in Chrome eval(). eval() barfs if it sees const
+    # before a function.
     # See https://github.com/kovidgoyal/rapydscript-ng/issues/29
     return 'var'
 
@@ -74,7 +76,8 @@ def declare_exports(module_id, exports, output, docstrings):
         exports.push({'name': '__doc__', 'refname': 'ρσ_module_doc__'})
         output.newline(), output.indent()
         v = const_decl(output.options.js_version)
-        output.assign(v + ' ρσ_module_doc__'), output.print(JSON.stringify(create_doctring(docstrings)))
+        output.assign(v + ' ρσ_module_doc__')
+        output.print(JSON.stringify(create_doctring(docstrings)))
         output.end_statement()
     output.newline()
     for symbol in exports:
@@ -84,7 +87,8 @@ def declare_exports(module_id, exports, output, docstrings):
                 output.print('ρσ_modules.' + module_id + '.' + symbol.name)
             else:
                 output.print('ρσ_modules["' + module_id + '"].' + symbol.name)
-            output.space(), output.print('='), output.space(), output.print(symbol.refname or symbol.name)
+            output.space(), output.print('=')
+            output.space(), output.print(symbol.refname or symbol.name)
             seen[symbol.name] = True
             output.end_statement()
 
@@ -98,17 +102,36 @@ def prologue(module, output):
     output.print(v), output.space()
     output.spaced.apply(
         output,
-        (('ρσ_iterator_symbol = (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") ? Symbol.iterator : "iterator-Symbol-5d0927e5554349048cf0e3762a228256"'.split(' ')))
+        ((
+            'ρσ_iterator_symbol = (typeof Symbol === "function"' +
+            ' && typeof Symbol.iterator === "symbol") ?' +
+            ' Symbol.iterator : "iterator-Symbol-' +
+            '5d0927e5554349048cf0e3762a228256"'
+        ).split(' '))
     )
     output.end_statement()
     output.indent(), output.print(v), output.space()
     output.spaced.apply(
         output,
-        (('ρσ_kwargs_symbol = (typeof Symbol === "function") ? Symbol("kwargs-object") : "kwargs-object-Symbol-5d0927e5554349048cf0e3762a228256"'.split(' ')))
+        ((
+            'ρσ_kwargs_symbol = (typeof Symbol === "function") ?' +
+            ' Symbol("kwargs-object") : "kwargs-object-Symbol-' +
+            '5d0927e5554349048cf0e3762a228256"'
+        ).split(' '))
     )
     output.end_statement()
-    output.indent(), output.spaced('var', 'ρσ_cond_temp,', 'ρσ_expr_temp,', 'ρσ_last_exception'), output.end_statement()
-    output.indent(), output.spaced('var', 'ρσ_object_counter', '=', '0'), output.end_statement()
+    output.indent(), output.spaced(
+        'var',
+        'ρσ_cond_temp,',
+        'ρσ_expr_temp,',
+        'ρσ_last_exception'
+    ), output.end_statement()
+    output.indent(), output.spaced(
+        'var',
+        'ρσ_object_counter',
+        '=',
+        '0'
+    ), output.end_statement()
     # Needed for Chrome < 51 and Edge as of August 2016
     output.indent(), output.spaced(
         'if(',
@@ -132,7 +155,10 @@ def prologue(module, output):
     output.end_statement()
     # 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')
+        raise ValueError(
+            'The baselib is missing! Remember to set the' +
+            ' baselib_plain field on the options for OutputStream'
+        )
     output.print(output.options.baselib_plain)
     output.end_statement()
 
@@ -142,17 +168,20 @@ def print_top_level(self, output):
     is_main = self.module_id is '__main__'
 
     def write_docstrings():
-        if is_main and output.options.keep_docstrings and self.docstrings and self.docstrings.length:
+        if (is_main and output.options.keep_docstrings
+                and self.docstrings and self.docstrings.length):
             output.newline(), output.indent()
             v = const_decl(output.options.js_version)
-            output.assign(v + ' ρσ_module_doc__'), output.print(JSON.stringify(create_doctring(self.docstrings)))
+            output.assign(v + ' ρσ_module_doc__')
+            output.print(JSON.stringify(create_doctring(self.docstrings)))
             output.end_statement()
 
     if output.options.private_scope and is_main:
         output.with_parens(def ():
             output.print('function()')
             output.with_block(def ():
-                # strict mode is more verbose about errors, and less forgiving about them
+                # strict mode is more verbose about errors, and less
+                # forgiving about them
                 # kind of like Python
                 output.indent()
                 output.print('"use strict"')

package/src/output/operators.pyj

@@ -26,11 +26,18 @@ def print_getattr(self, output, skip_expression):  # AST_Dot
 def print_getitem(self, output):  # AST_Sub
     expr = self.expression
     prop = self.property
-    if (is_node_type(prop, AST_Number) or is_node_type(prop, AST_String)) or (is_node_type(prop, AST_SymbolRef) and prop.name and prop.name.startsWith('ρσ_')):
+    if (
+        is_node_type(prop, AST_Number) or is_node_type(prop, AST_String)
+        or (is_node_type(prop, AST_SymbolRef) and prop.name
+            and prop.name.startsWith('ρσ_'))
+    ):
         expr.print(output)
         output.print('['), prop.print(output), output.print(']')
         return
-    is_negative_number = is_node_type(prop, AST_Unary) and prop.operator is '-' and is_node_type(prop.expression, AST_Number)
+    is_negative_number = (
+        is_node_type(prop, AST_Unary) and prop.operator is '-'
+        and is_node_type(prop.expression, AST_Number)
+    )
     is_repeatable = is_node_type(expr, AST_SymbolRef)
     if is_repeatable:
         expr.print(output)
@@ -39,17 +46,27 @@ def print_getitem(self, output):  # AST_Sub
         expr = {'print': def (): output.print('ρσ_expr_temp');}
 
     if is_negative_number:
-        output.print('['), expr.print(output), output.print('.length'), prop.print(output), output.print(']')
+        output.print('['), expr.print(output)
+        output.print('.length'), prop.print(output)
+        output.print(']')
         return
     is_repeatable = is_node_type(prop, AST_SymbolRef)
     # We have to check the type of the property because if it is a Symbol, it
     # will raise a TypeError with the < operator.
     if is_repeatable:
         output.spaced('[(typeof', prop, '===', '"number"', '&&', prop)
-        output.spaced('', '<', '0)', '?', expr), output.spaced('.length', '+', prop, ':', prop)
+        output.spaced(
+            '',
+            '<',
+            '0)',
+            '?',
+            expr
+        ), output.spaced('.length', '+', prop, ':', prop)
         output.print(']')
     else:
-        output.print('[ρσ_bound_index('), prop.print(output), output.comma(), expr.print(output), output.print(')]')
+        output.print('[ρσ_bound_index(')
+        prop.print(output), output.comma(), expr.print(output)
+        output.print(')]')
 
 
 def print_rich_getitem(self, output):  # AST_ItemAccess
@@ -74,7 +91,8 @@ def print_rich_getitem(self, output):  # AST_ItemAccess
 def print_splice_assignment(self, output):  # AST_Splice
     # splice assignment via pythonic array[start:end]
     output.print('ρσ_splice(')
-    self.expression.print(output), output.comma(), self.assignment.print(output), output.comma()
+    self.expression.print(output), output.comma()
+    self.assignment.print(output), output.comma()
     self.property.print(output) if self.property else output.print('0')
     if self.property2:
         output.comma()
@@ -86,7 +104,9 @@ def print_delete(self, output):
     if is_node_type(self, AST_Symbol):
         output.assign(self), output.print('undefined')
     elif is_node_type(self, AST_Sub) or is_node_type(self, AST_ItemAccess):
-        output.print('ρσ_delitem('), self.expression.print(output), output.comma(), self.property.print(output), output.print(')')
+        output.print('ρσ_delitem(')
+        self.expression.print(output), output.comma()
+        self.property.print(output), output.print(')')
     else:
         output.spaced('delete', self)
 
@@ -122,28 +142,61 @@ def write_instanceof(left, right, output):
         do_many(right.elements)
     else:
         output.print('ρσ_instanceof(')
-        left.print(output), output.comma(), right.print(output), output.print(')')
+        left.print(output), output.comma()
+        right.print(output), output.print(')')
 
 
 def write_smart_equality(self, output):
     def is_ok(x):
         return not (
-            is_node_type(x, AST_Array) or is_node_type(x, AST_Set) or is_node_type(x, AST_Object) or
-            is_node_type(x, AST_Statement) or is_node_type(x, AST_Binary) or is_node_type(x, AST_Conditional)
+            is_node_type(x, AST_Array) or is_node_type(x, AST_Set)
+            or is_node_type(x, AST_Object) or is_node_type(x, AST_Statement)
+            or is_node_type(x, AST_Binary)
+            or is_node_type(x, AST_Conditional)
             or is_node_type(x, AST_BaseCall)
         )
     if is_ok(self.left) and is_ok(self.right):
         if self.operator is '==':
             output.print('(')
-            output.spaced(self.left, '===', self.right, '||', 'typeof', self.left, '===', '"object"', '&&', 'ρσ_equals(')
-            self.left.print(output), output.print(','), output.space(), self.right.print(output), output.print('))')
+            output.spaced(
+                self.left,
+                '===',
+                self.right,
+                '||',
+                'typeof',
+                self.left,
+                '===',
+                '"object"',
+                '&&',
+                'ρσ_equals('
+            )
+            self.left.print(output), output.print(',')
+            output.space(), self.right.print(output)
+            output.print('))')
         else:
             output.print('(')
-            output.spaced(self.left, '!==', self.right, '&&', '(typeof', self.left, '!==', '"object"', '||', 'ρσ_not_equals(')
-            self.left.print(output), output.print(','), output.space(), self.right.print(output), output.print(')))')
+            output.spaced(
+                self.left,
+                '!==',
+                self.right,
+                '&&',
+                '(typeof',
+                self.left,
+                '!==',
+                '"object"',
+                '||',
+                'ρσ_not_equals('
+            )
+            self.left.print(output), output.print(',')
+            output.space(), self.right.print(output)
+            output.print(')))')
     else:
-        output.print('ρσ_' + ('equals(' if self.operator is '==' else 'not_equals('))
-        self.left.print(output), output.print(','), output.space(), self.right.print(output), output.print(')')
+        output.print(
+            'ρσ_' + ('equals(' if self.operator is '==' else 'not_equals(')
+        )
+        self.left.print(output), output.print(',')
+        output.space(), self.right.print(output)
+        output.print(')')
 
 
 comparators = {
@@ -167,7 +220,10 @@ def print_binary_op(self, output):
             output.comma()
             self.right.print(output)
         )
-    elif comparators[self.operator] and is_node_type(self.left, AST_Binary) and comparators[self.left.operator]:
+    elif comparators[self.operator] and is_node_type(
+        self.left,
+        AST_Binary
+    ) and comparators[self.left.operator]:
         # A chained comparison such as a < b < c
         if is_node_type(self.left.right, AST_Symbol):
             # left side compares against a regular variable,
@@ -210,15 +266,22 @@ def print_binary_op(self, output):
             left = self.left.expression
             output.print(self.left.operator)
         if output.options.js_version > 6:
-            output.print('(('), left.print(output), output.spaced(')', '**', '('), self.right.print(output), output.print('))')
+            output.print('(('), left.print(output), output.spaced(
+                ')',
+                '**',
+                '('
+            ), self.right.print(output), output.print('))')
         else:
-            output.print('Math.pow('), left.print(output), output.comma(), self.right.print(output), output.print(')')
+            output.print('Math.pow('), left.print(output)
+            output.comma(), self.right.print(output)
+            output.print(')')
     elif self.operator is '==' or self.operator is '!=':
         write_smart_equality(self, output)
     elif self.operator is 'instanceof':
         write_instanceof(self.left, self.right, output)
     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(')')
+        self.left.print(output), output.print('.repeat(')
+        self.right.print(output), output.print(')')
     elif self.operator is '===' or self.operator is '!==':
         nan_check = None
         if is_node_type(self.right, AST_Symbol) and self.right.name is 'NaN':
@@ -228,7 +291,11 @@ def print_binary_op(self, output):
         if nan_check is not None:
             # We use the fact that NaN is the only object that is not equal to
             # itself
-            output.spaced(nan_check, '!==' if self.operator is '===' else '===', nan_check)
+            output.spaced(
+                nan_check,
+                '!==' if self.operator is '===' else '===',
+                nan_check
+            )
         else:
             output.spaced(self.left, self.operator, self.right)
     else:
@@ -238,20 +305,54 @@ after_map = {'.': 'd', '(': 'c', '[': 'd', 'g': 'g', 'null': 'n'}
 
 
 def print_existential(self, output):
-    key = after_map[self.after] if self.after is None or jstype(self.after) is 'string' else 'e'
+    key = (
+        after_map[self.after]
+        if self.after is None or jstype(self.after) is 'string' else 'e'
+    )
     if is_node_type(self.expression, AST_SymbolRef):
         if key is 'n':
-            output.spaced('(typeof', self.expression, '!==', '"undefined"', '&&', self.expression, '!==', 'null)')
+            output.spaced(
+                '(typeof',
+                self.expression,
+                '!==',
+                '"undefined"',
+                '&&',
+                self.expression,
+                '!==',
+                'null)'
+            )
             return
         if key is 'c':
-            output.spaced('(typeof', self.expression, '===', '"function"', '?', self.expression, ':', '(function(){return undefined;}))')
+            output.spaced(
+                '(typeof',
+                self.expression,
+                '===',
+                '"function"',
+                '?',
+                self.expression,
+                ':',
+                '(function(){return undefined;}))'
+            )
             return
         after = self.after
         if key is 'd':
             after = 'Object.create(null)'
         elif key is 'g':
             after = '{__getitem__:function(){return undefined;}}'
-        output.spaced('(typeof', self.expression, '!==', '"undefined"', '&&', self.expression, '!==', 'null', '?', self.expression, ':', after)
+        output.spaced(
+            '(typeof',
+            self.expression,
+            '!==',
+            '"undefined"',
+            '&&',
+            self.expression,
+            '!==',
+            'null',
+            '?',
+            self.expression,
+            ':',
+            after
+        )
         output.print(')')
         return
     output.print('ρσ_exists.' + key + '(')
@@ -282,9 +383,13 @@ def print_assignment(self, output):
         self.right.print(output)
     if is_node_type(left, AST_Array):
         output.end_statement()
-        if not is_node_type(self.right, AST_Seq) and not is_node_type(self.right, AST_Array):
+        if not is_node_type(
+            self.right,
+            AST_Seq
+        ) and not is_node_type(self.right, AST_Array):
             output.assign('ρσ_unpack')
-            output.print('ρσ_unpack_asarray(' + flat.length), output.comma(), output.print('ρσ_unpack)')
+            output.print('ρσ_unpack_asarray(' + flat.length)
+            output.comma(), output.print('ρσ_unpack)')
             output.end_statement()
         unpack_tuple(flat, output, True)
 
@@ -305,15 +410,31 @@ def print_assign(self, output):
         left_hand_sides, rhs = self.traverse_chain()
         is_compound_assign = False
         for lhs in left_hand_sides:
-            if is_node_type(lhs, AST_Seq) or is_node_type(lhs, AST_Array) or is_node_type(lhs, AST_ItemAccess):
+            if (
+                is_node_type(lhs, AST_Seq)
+                or is_node_type(lhs, AST_Array)
+                or is_node_type(lhs, AST_ItemAccess)
+            ):
                 is_compound_assign = True
                 break
         if is_compound_assign:
             temp_rhs = new AST_SymbolRef({'name': 'ρσ_chain_assign_temp'})
-            print_assignment(new AST_Assign({'left': temp_rhs, 'operator': '=', 'right': rhs}), output)
+            print_assignment(
+                new AST_Assign({
+                    'left': temp_rhs, 'operator': '=', 'right': rhs
+                }),
+                output
+            )
             for lhs in left_hand_sides:
                 output.end_statement(), output.indent()
-                print_assignment(new AST_Assign({'left': lhs, 'right': temp_rhs, 'operator': self.operator}), output)
+                print_assignment(
+                    new AST_Assign({
+                        'left': lhs,
+                        'right': temp_rhs,
+                        'operator': self.operator
+                    }),
+                    output
+                )
         else:
             for lhs in left_hand_sides:
                 output.spaced(lhs, '=', '')
@@ -323,7 +444,9 @@ def print_assign(self, output):
 
 
 def print_conditional(self, output, condition, consequent, alternative):
-    condition, consequent, alternative = self.condition, self.consequent, self.alternative
+    condition = self.condition
+    consequent = self.consequent
+    alternative = self.alternative
     output.with_parens(def (): condition.print(output);)
     output.space()
     output.print('?')

package/src/output/statements.pyj

@@ -70,7 +70,8 @@ def declare_vars(vars, output):
 def display_body(body, is_toplevel, output):
     last = body.length - 1
     for i, stmt in enumerate(body):
-        if not (is_node_type(stmt, AST_EmptyStatement)) and not (is_node_type(stmt, AST_Definitions)):
+        if (not (is_node_type(stmt, AST_EmptyStatement))
+                and not (is_node_type(stmt, AST_Definitions))):
             output.indent()
             stmt.print(output)
             if not (i is last and is_toplevel):
@@ -134,7 +135,9 @@ def print_bracketed(node, output, complex, function_preamble, before, after):
 
 def print_with(self, output):
     exits = v'[]'
-    output.assign('ρσ_with_exception'), output.print('undefined'), output.end_statement()
+    output.assign('ρσ_with_exception')
+    output.print('undefined')
+    output.end_statement()
     for clause in self.clauses:
         output.with_counter += 1
         clause_name = 'ρσ_with_clause_' + output.with_counter
@@ -155,29 +158,54 @@ def print_with(self, output):
     )
     output.space(), output.print('catch(e)')
     output.with_block(def ():
-        output.indent(), output.assign('ρσ_with_exception'), output.print('e'), output.end_statement()
+        output.indent()
+        output.assign('ρσ_with_exception')
+        output.print('e')
+        output.end_statement()
+    )
+    output.newline(), output.indent(), output.spaced(
+        'if',
+        '(ρσ_with_exception',
+        '===',
+        'undefined)'
     )
-    output.newline(), output.indent(), output.spaced('if', '(ρσ_with_exception', '===', 'undefined)')
     output.with_block(def ():
         for clause in exits:
-            output.indent(), output.print(clause + '.__exit__()'), output.end_statement()
+            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()
+        output.indent()
+        output.assign('ρσ_with_suppress')
+        output.print('false')
+        output.end_statement()
         for clause in exits:
             output.indent()
-            output.spaced('ρσ_with_suppress', '|=', 'ρσ_bool(' + clause + '.__exit__(ρσ_with_exception.constructor,',
-                            'ρσ_with_exception,', 'ρσ_with_exception.stack))')
+            output.spaced(
+                'ρσ_with_suppress', '|=',
+                'ρσ_bool(' + clause
+                + '.__exit__(ρσ_with_exception.constructor,',
+                'ρσ_with_exception,',
+                'ρσ_with_exception.stack))'
+            )
             output.end_statement()
-        output.indent(), output.spaced('if', '(!ρσ_with_suppress)', 'throw ρσ_with_exception'), output.end_statement()
+        output.indent()
+        output.spaced('if', '(!ρσ_with_suppress)', 'throw ρσ_with_exception')
+        output.end_statement()
     )
 
 
 def print_assert(self, output):
     if output.options.discard_asserts:
         return
-    output.spaced('if', '(!('), self.condition.print(output), output.spaced('))', 'throw new AssertionError')
+    output.spaced(
+        'if',
+        '(!('
+    ), self.condition.print(output), output.spaced(
+        '))', 'throw new AssertionError'
+    )
     if self.message:
         output.print('(')
         self.message.print(output)