rapydscript-ng 0.8.2 → 0.8.4

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)

package/src/output/stream.pyj

@@ -5,11 +5,24 @@ from __python__ import hash_literals
 from tokenizer import is_identifier_char
 from utils import make_predicate, defaults, repeat_string
 
-DANGEROUS = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g
+DANGEROUS = RegExp(
+    '[\\u0000\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5' +
+    '\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f' +
+    '\\ufeff\\ufff0-\\uffff]', 'g'
+)
+
 
 # Pre-computed ASCII lookup for identifier characters used in the space-emission
-# hot path. Avoids the full unicode-aware is_identifier_char() for the common case.
-_IDENT_CHARS = v'(function(){var t=new Uint8Array(128),s="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$";for(var i=0;i<s.length;i++)t[s.charCodeAt(i)]=1;return t;})()'
+# hot path. Avoids the full unicode-aware is_identifier_char() for the
+# common case.
+def _make_ident_chars():
+    t = v'new Uint8Array(128)'
+    s = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$'
+    for i in range(s.length):
+        t[s.charCodeAt(i)] = 1
+    return t
+
+_IDENT_CHARS = _make_ident_chars()
 
 
 def _is_ident_char(ch):
@@ -85,11 +98,13 @@ class OutputStream:
         self.with_counter = 0
         self.try_else_counter = 0
         self._source_map_segments = v'[]' if self.options.source_map else None
-        # Indentation string cache: avoids repeat_string() on every indent() call
+        # Indentation string cache: avoids repeat_string() on every
+        # indent() call
         self._indent_cache_val = -1
         self._indent_cache_str = ''
-        # Install no-op add_mapping on the instance when source maps are disabled,
-        # avoiding a null check and array push per node in the hot output walk.
+        # Install no-op add_mapping on the instance when source maps are
+        # disabled, avoiding a null check and array push per node in the
+        # hot output walk.
         if not self.options.source_map:
             self.add_mapping = def (node): pass
 
@@ -108,7 +123,10 @@ class OutputStream:
         self.print(self.make_name(name))
 
     def make_indent(self, back):
-        target = self.options.indent_start + self._indentation - (back or 0) * self.options.indent_level
+        target = (
+            self.options.indent_start + self._indentation -
+            (back or 0) * self.options.indent_level
+        )
         if target == self._indent_cache_val:
             return self._indent_cache_str
         s = repeat_string(' ', target)
@@ -121,7 +139,8 @@ class OutputStream:
         return self._last.charAt(self._last.length - 1)
 
     def maybe_newline(self):
-        if self.options.max_line_len and self.current_col > self.options.max_line_len:
+        if (self.options.max_line_len and
+                self.current_col > self.options.max_line_len):
             self.print('\n')
 
     def print(self, str_):
@@ -145,7 +164,9 @@ class OutputStream:
             self.might_need_semicolon = False
             self.maybe_newline()
 
-        if not self.options.beautify and self.options.preserve_line and self._stack[self._stack.length - 1]:
+        if (not self.options.beautify and
+                self.options.preserve_line and
+                self._stack[self._stack.length - 1]):
             target_line = self._stack[self._stack.length - 1].start.line
             while self.current_line < target_line:
                 self._fragments.push('\n')
@@ -319,14 +340,24 @@ class OutputStream:
         return self._stack[self._stack.length - 2 - (n or 0)]
 
     def add_mapping(self, node):
-        if self._source_map_segments is not None and node.start and node.start.file:
-            self._source_map_segments.push(v'[self.current_line - 1 + self.options.source_map_line_offset, self.current_col, node.start.file, node.start.line - 1, node.start.col]')
+        if (self._source_map_segments is not None and
+                node.start and node.start.file):
+            self._source_map_segments.push([
+                self.current_line - 1 +
+                self.options.source_map_line_offset,
+                self.current_col,
+                node.start.file,
+                node.start.line - 1,
+                node.start.col
+            ])
 
     def add_cached_mappings(self, segments, line_offset):
         if self._source_map_segments is None:
             return
         for seg in segments:
-            self._source_map_segments.push(v'[seg[0] + line_offset, seg[1], seg[2], seg[3], seg[4]]')
+            self._source_map_segments.push(
+                v'[seg[0] + line_offset, seg[1], seg[2], seg[3], seg[4]]'
+            )
 
     def get_source_map_segments(self):
         return self._source_map_segments

package/src/output/utils.pyj

@@ -25,14 +25,18 @@ def make_num(num):
             a.push('0x' + num.toString(16).toLowerCase(),  # probably pointless
             '0' + num.toString(8))
         else:
-            a.push('-0x' + (-num).toString(16).toLowerCase(),  # probably pointless
+            # probably pointless
+            a.push('-0x' + (-num).toString(16).toLowerCase(),
             '-0' + (-num).toString(8))
 
         if m = /^(.*?)(0+)$/.exec(num):
             a.push(m[1] + 'e' + m[2].length)
 
     elif m = /^0?\.(0+)(.*)$/.exec(num):
-        a.push(m[2] + 'e-' + (m[1].length + m[2].length), str_.substr(str_.indexOf('.')))
+        a.push(
+            m[2] + 'e-' + (m[1].length + m[2].length),
+            str_.substr(str_.indexOf('.'))
+        )
 
     return best_of(a)
 
@@ -65,7 +69,10 @@ def create_doctring(docstrings):
                 lines.push(v'["", ""]')
             else:
                 leading_whitespace = leading_whitespace.replace(/\t/g, '    ')
-                if leading_whitespace and (not min_leading_whitespace or leading_whitespace.length < min_leading_whitespace.length):
+                if leading_whitespace and (
+                    not min_leading_whitespace or
+                    leading_whitespace.length < min_leading_whitespace.length
+                ):
                     min_leading_whitespace = leading_whitespace
                 lines.push(v'[leading_whitespace, line]')
         for lw, l in lines: