rapydscript-ng 0.7.24 → 0.8.1

package/src/output/stream.pyj

@@ -1,13 +1,23 @@
 # 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
 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
 
+# 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;})()'
+
+
+def _is_ident_char(ch):
+    code = ch.charCodeAt(0)
+    if code < 128:
+        return v'_IDENT_CHARS[code]'
+    return is_identifier_char(ch)
+
 
 def as_hex(code, sz):
     val = code.toString(16)
@@ -17,20 +27,20 @@ def as_hex(code, sz):
 
 
 def to_ascii(str_, identifier):
-    return str_.replace(/[\u0080-\uffff]/g, def(ch):
+    return str_.replace(/[\u0080-\uffff]/g, def (ch):
         code = ch.charCodeAt(0).toString(16)
         if code.length <= 2 and not identifier:
-            return "\\x" + as_hex(code, 2)
+            return '\\x' + as_hex(code, 2)
         else:
             return '\\u' + as_hex(code, 4)
-
     )
 
+
 def encode_string(str_):
-    return JSON.stringify(str_).replace(DANGEROUS, def(a):
+    return JSON.stringify(str_).replace(DANGEROUS, def (a):
             return '\\u' + as_hex(a.charCodeAt(0), 4)
     )
-require_semi_colon_chars = make_predicate("( [ + * / - , .")
+require_semi_colon_chars = make_predicate('( [ + * / - , .')
 
 output_stream_defaults = {
     'indent_start': 0,
@@ -43,6 +53,7 @@ output_stream_defaults = {
     'ie_proof': True,
     'beautify': False,
     'source_map': None,
+    'source_map_line_offset': 0,
     'bracketize': False,
     'semicolons': True,
     'comments': False,
@@ -53,26 +64,34 @@ output_stream_defaults = {
     'keep_docstrings': False,
     'discard_asserts': False,
     'module_cache_dir': '',
-    'js_version':5,
+    'js_version': 6,
     'write_name': True,
 }
 
-class OutputStream:
 
+class OutputStream:
     def __init__(self, options):
         self.options = defaults(options, output_stream_defaults, True)
         self._indentation = 0
         self.current_col = 0
         self.current_line = 1
         self.current_pos = 0
-        self.OUTPUT = ""
+        self._fragments = v'[]'
         self.might_need_space = False
         self.might_need_semicolon = False
         self._last = None
-        self._stack = []
+        self._stack = v'[]'
         self.index_counter = 0
         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
+        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.
+        if not self.options.source_map:
+            self.add_mapping = def (node): pass
 
     def new_try_else_counter(self):
         self.try_else_counter += 1
@@ -89,7 +108,13 @@ class OutputStream:
         self.print(self.make_name(name))
 
     def make_indent(self, back):
-        return repeat_string(" ", self.options.indent_start + self._indentation - back * 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)
+        self._indent_cache_val = target
+        self._indent_cache_str = s
+        return s
 
     # -----[ beautification/minification ]-----
     def last_char(self):
@@ -97,19 +122,19 @@ class OutputStream:
 
     def maybe_newline(self):
         if self.options.max_line_len and self.current_col > self.options.max_line_len:
-            self.print("\n")
+            self.print('\n')
 
     def print(self, str_):
         str_ = v"String(str_)"
         ch = str_.charAt(0)
         if self.might_need_semicolon:
-            if (not ch or ";}".indexOf(ch) < 0) and not /[;]$/.test(self._last):
+            if (not ch or ';}'.indexOf(ch) < 0) and not /[;]$/.test(self._last):
                 if self.options.semicolons or require_semi_colon_chars[ch]:
-                    self.OUTPUT += ";"
+                    self._fragments.push(';')
                     self.current_col += 1
                     self.current_pos += 1
                 else:
-                    self.OUTPUT += "\n"
+                    self._fragments.push('\n')
                     self.current_pos += 1
                     self.current_line += 1
                     self.current_col = 0
@@ -117,41 +142,41 @@ class OutputStream:
                 if not self.options.beautify:
                     self.might_need_space = False
 
-
             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]:
             target_line = self._stack[self._stack.length - 1].start.line
             while self.current_line < target_line:
-                self.OUTPUT += "\n"
+                self._fragments.push('\n')
                 self.current_pos += 1
                 self.current_line += 1
                 self.current_col = 0
                 self.might_need_space = False
 
-
         if self.might_need_space:
             prev = self.last_char()
-            if is_identifier_char(prev) and (is_identifier_char(ch) or ch is "\\")
+            if _is_ident_char(prev) and (_is_ident_char(ch) or ch is '\\')
             or /^[\+\-\/]$/.test(ch) and ch is prev:
-                self.OUTPUT += " "
+                self._fragments.push(' ')
                 self.current_col += 1
                 self.current_pos += 1
 
             self.might_need_space = False
 
-        a = str_.split(/\r?\n/)
-        n = a.length - 1
-        self.current_line += n
-        if n is 0:
-            self.current_col += a[n].length
+        # Fast path: no newlines (the vast majority of tokens).
+        # Avoids regex allocation and array creation for single-line fragments.
+        self.current_pos += str_.length
+        if str_.indexOf('\n') < 0:
+            self.current_col += str_.length
         else:
-            self.current_col = a[n].length
+            a = str_.split('\n')
+            n = a.length - 1
+            self.current_line += n
+            self.current_col = v'a[n].length'
 
-        self.current_pos += str_.length
         self._last = str_
-        self.OUTPUT += str_
+        self._fragments.push(str_)
 
     def space(self):
         if self.options.beautify:
@@ -185,17 +210,17 @@ class OutputStream:
 
     def newline(self):
         if self.options.beautify:
-            self.print("\n")
+            self.print('\n')
 
     def semicolon(self):
         if self.options.beautify:
-            self.print(";")
+            self.print(';')
         else:
             self.might_need_semicolon = True
 
     def force_semicolon(self):
         self.might_need_semicolon = False
-        self.print(";")
+        self.print(';')
 
     def next_indent(self):
         return self._indentation + self.options.indent_level
@@ -215,61 +240,49 @@ class OutputStream:
 
     def with_block(self, cont):
         ret = None
-        self.print("{")
+        self.print('{')
         self.newline()
-        self.with_indent(self.next_indent(), def():
+        self.with_indent(self.next_indent(), def ():
             nonlocal ret
             ret = cont()
         )
         self.indent()
-        self.print("}")
+        self.print('}')
         return ret
 
     def with_parens(self, cont):
-        self.print("(")
+        self.print('(')
         ret = cont()
-        self.print(")")
+        self.print(')')
         return ret
 
     def with_square(self, cont):
-        self.print("[")
+        self.print('[')
         ret = cont()
-        self.print("]")
+        self.print(']')
         return ret
 
     def comma(self):
-        self.print(",")
+        self.print(',')
         self.space()
 
     def colon(self):
-        self.print(":")
+        self.print(':')
         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
+        return self._fragments.join('')
     toString = get
 
     def assign(self, name):
         # generates: '[name] = '
-        if jstype(name) is "string":
+        if jstype(name) is 'string':
             self.print(name)
         else:
             name.print(self)
         self.space()
-        self.print("=")
+        self.print('=')
         self.space()
 
     def current_width(self):
@@ -304,3 +317,16 @@ class OutputStream:
 
     def parent(self, n):
         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]')
+
+    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]]')
+
+    def get_source_map_segments(self):
+        return self._source_map_segments

package/src/output/utils.pyj

@@ -4,6 +4,7 @@ from __python__ import hash_literals
 
 from ast import AST_BlockStatement, is_node_type
 
+
 def best_of(a):
     best = a[0]
     len_ = best.length
@@ -13,38 +14,41 @@ def best_of(a):
             len_ = best.length
     return best
 
+
 def make_num(num):
     str_ = num.toString(10)
-    a = [ str_.replace(/^0\./, ".").replace("e+", "e") ]
+    a = [str_.replace(/^0\./, '.').replace('e+', 'e')]
     m = None
 
     if Math.floor(num) is num:
         if num >= 0:
-            a.push("0x" + num.toString(16).toLowerCase(), # probably pointless
-            "0" + num.toString(8))
+            a.push('0x' + num.toString(16).toLowerCase(),  # probably pointless
+            '0' + num.toString(8))
         else:
-            a.push("-0x" + (-num).toString(16).toLowerCase(), # probably pointless
-            "-0" + (-num).toString(8))
+            a.push('-0x' + (-num).toString(16).toLowerCase(),  # probably pointless
+            '-0' + (-num).toString(8))
 
         if m = /^(.*?)(0+)$/.exec(num):
-            a.push(m[1] + "e" + m[2].length)
+            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)
 
+
 def make_block(stmt, output):
     if is_node_type(stmt, AST_BlockStatement):
         stmt.print(output)
         return
 
-    output.with_block(def():
+    output.with_block(def ():
         output.indent()
         stmt.print(output)
         output.newline()
     )
 
+
 def create_doctring(docstrings):
     ans = v'[]'
     for ds in docstrings: