rapydscript-ng 0.7.24 → 0.8.0

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, is_node_type
@@ -39,7 +38,7 @@ 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.length is 1:
+    and self.object.expression.name is "dir" and self.object.args.args.length is 1:
         return True
     return False
 
@@ -49,13 +48,13 @@ def is_simple_for(self):
             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
+        a = self.object.args.args
         l = a.length
         if l < 3 or (
-            is_node_type(a[2], AST_Number) or (
-                is_node_type(a[2], AST_Unary) and a[2].operator is '-' and is_node_type(a[2].expression, AST_Number)
+            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])) or (l > 1 and not has_calls(a[1])):
+            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
 
@@ -65,10 +64,7 @@ def print_for_loop_body(output):
         if not (self.simple_for_index or is_simple_for_in(self)):
             # if we're using multiple iterators, unpack them
             output.indent()
-            if output.options.js_version is 5:
-                itervar = "ρσ_Iter" + output.index_counter + "[ρσ_Index" + output.index_counter + "]"
-            else:
-                itervar = "ρσ_Index" + output.index_counter
+            itervar = "ρσ_Index" + output.index_counter
             if is_node_type(self.init, AST_Array):
                 flat = self.init.flatten()
                 output.assign("ρσ_unpack")
@@ -112,18 +108,18 @@ def print_for_in(self, output):
     if is_simple_for(self):
         # optimize range() into a simple for loop
         increment = None
-        args = self.object.args
+        args = self.object.args.args
         tmp_ = args.length
         if tmp_ is 1:
             start = 0
-            end = args[0]
+            end = args[0].value
         elif tmp_ is 2:
-            start = args[0]
-            end = args[1]
+            start = args[0].value
+            end = args[1].value
         elif tmp_ is 3:
-            start = args[0]
-            end = args[1]
-            increment = args[2]
+            start = args[0].value
+            end = args[1].value
+            increment = args[2].value
 
         self.simple_for_index = idx = 'ρσ_Index' + output.index_counter
         output.index_counter += 1
@@ -164,43 +160,17 @@ def print_for_in(self, output):
             output.space()
             output.print('in')
             output.space()
-            self.object.args[0].print(output)
+            self.object.args.args[0].value.print(output)
         )
     else:
         # regular loop
-        if output.options.js_version is 5:
-            output.assign("var ρσ_Iter" + output.index_counter)
-            output.print("ρσ_Iterable")
-            output.with_parens(write_object)
-            output.semicolon()
-            output.newline()
-            output.indent()
-            output.print("for")
-            output.space()
-            output.with_parens(def():
-                output.print("var")
-                output.space()
-                output.assign("ρσ_Index" + output.index_counter)
-                output.print("0")
-                output.semicolon()
-                output.space()
-                output.print("ρσ_Index" + output.index_counter)
-                output.space()
-                output.print("<")
-                output.space()
-                output.print("ρσ_Iter" + output.index_counter + ".length")
-                output.semicolon()
-                output.space()
-                output.print("ρσ_Index" + output.index_counter + "++")
-            )
-        else:
-            itervar = "ρσ_Iter" + output.index_counter
-            output.assign("var " + itervar)
-            write_object()
-            output.end_statement()
-            init_es6_itervar(output, itervar)
-            output.indent()
-            output.spaced('for', '(var', 'ρσ_Index' + output.index_counter, 'of', itervar + ')')
+        itervar = "ρσ_Iter" + output.index_counter
+        output.assign("var " + itervar)
+        write_object()
+        output.end_statement()
+        init_es6_itervar(output, itervar)
+        output.indent()
+        output.spaced('for', '(var', 'ρσ_Index' + output.index_counter, 'of', itervar + ')')
 
     output.space()
     self._do_print_body(output)
@@ -209,7 +179,6 @@ 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]
     is_generator = tname is 'GeneratorComprehension'
-    es5 = output.options.js_version is 5
     if tname is 'DictComprehension':
         if self.is_pydict:
             result_obj = 'ρσ_dict()'
@@ -264,8 +233,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()
@@ -273,13 +240,7 @@ def print_list_comprehension(self, output):
                 output.set_indentation(output.next_indent())
             body_out.indent()
             body_out.assign("var ρσ_Iter")
-            if es5:
-                body_out.print("ρσ_Iterable")
-                body_out.with_parens(def():
-                    self.object.print(body_out)
-                )
-            else:
-                self.object.print(body_out)
+            self.object.print(body_out)
 
             if result_obj:
                 body_out.comma()
@@ -295,34 +256,17 @@ def print_list_comprehension(self, output):
                 self.init.print(body_out)
             body_out.end_statement()
 
-            if not es5:
-                init_es6_itervar(body_out, 'ρσ_Iter')
+            init_es6_itervar(body_out, 'ρσ_Iter')
             body_out.indent()
             body_out.print("for")
             body_out.space()
             body_out.with_parens(def():
-                if es5:
-                    body_out.print("var")
-                    body_out.space()
-                    body_out.assign("ρσ_Index")
-                    body_out.print("0")
-                    body_out.semicolon()
-                    body_out.space()
-                    body_out.print("ρσ_Index")
-                    body_out.space()
-                    body_out.print("<")
-                    body_out.space()
-                    body_out.print("ρσ_Iter.length")
-                    body_out.semicolon()
-                    body_out.space()
-                    body_out.print("ρσ_Index++")
-                else:
-                    body_out.spaced('var', 'ρσ_Index', 'of', 'ρσ_Iter')
+                body_out.spaced('var', 'ρσ_Index', 'of', 'ρσ_Iter')
             )
             body_out.space()
             body_out.with_block(def():
                 body_out.indent()
-                itervar = 'ρσ_Iter[ρσ_Index]' if es5 else 'ρσ_Index'
+                itervar = 'ρσ_Index'
                 if is_node_type(self.init, AST_Array):
                     flat = self.init.flatten()
                     body_out.assign("ρσ_unpack")
@@ -362,12 +306,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

@@ -1,15 +1,11 @@
 # vim:fileencoding=utf-8
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-# globals: writefile
 from __python__ import hash_literals
 
 from output.statements import declare_vars, display_body
-from output.stream import OutputStream
 from output.utils import create_doctring
 from output.comments import print_comments, output_comments
 from output.functions import set_module_name
-from parse import get_compiler_version
-from utils import cache_file_name
 
 
 def write_imports(module, output):
@@ -103,14 +99,10 @@ def prologue(module, output):
     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()
-    if output.options.js_version > 5:
-        # Needed for Chrome < 51 and Edge as of August 2016
-        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()
+    # Needed for Chrome < 51 and Edge as of August 2016
+    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()
     # 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')
@@ -198,41 +190,7 @@ def print_module(self, output):
                 output.print('"' + self.module_id + '"')
                 output.semicolon()
                 output.newline()
-            def output_key(beautify, keep_docstrings, js_version):
-                return 'beautify:' + beautify + ' keep_docstrings:' + keep_docstrings + ' js_version:' + js_version
-            okey = output_key(output.options.beautify, output.options.keep_docstrings, output.options.js_version)
-            if self.is_cached and okey in self.outputs:
-                output.print(self.outputs[okey])
-            else:
-                output_module(output)
-                if self.srchash and self.filename:
-                    cached = {
-                        'version':get_compiler_version(), 'signature':self.srchash, 'classes': {}, 'baselib':self.baselib,
-                        'nonlocalvars':self.nonlocalvars, 'imported_module_ids':self.imported_module_ids, 'exports':[],
-                        'outputs':{}, 'discard_asserts': v'!!output.options.discard_asserts'
-                    }
-                    for cname in Object.keys(self.classes):
-                        cobj = self.classes[cname]
-                        cached.classes[cname] = {'name':{'name':cobj.name.name}, 'static':cobj.static, 'bound':cobj.bound, 'classvars':cobj.classvars}
-                    for symdef in self.exports:
-                        cached.exports.push({'name':symdef.name})
-                    for beautify in [True, False]:
-                        for keep_docstrings in [True, False]:
-                            for js_version in [5, 6]:
-                                co = OutputStream({
-                                    'beautify':beautify, 'keep_docstrings':keep_docstrings,
-                                    'js_version':js_version, 'private_scope':False,
-                                    'write_name':False, 'discard_asserts':output.options.discard_asserts
-                                })
-                                co.with_indent(output.indentation(), def():
-                                    output_module(co)
-                                )
-                                raw = co.get()
-                                cached.outputs[output_key(beautify, keep_docstrings, js_version)] = raw
-                    try:
-                        writefile(cache_file_name(self.filename, output.options.module_cache_dir), JSON.stringify(cached, None, '\t'))
-                    except Error as e:
-                        console.error('Failed to write output cache file:', self.filename + '-cached', 'with error:', e)
+            output_module(output)
         )
     )
     output.print("()")

package/src/output/statements.pyj

@@ -82,7 +82,7 @@ def display_complex_body(node, is_toplevel, output, function_preamble):
         output.indent()
         output.print("var")
         output.space()
-        output.assign(node.argnames[0])
+        output.assign(node.argnames.args[0])
         output.print("this")
         output.semicolon()
         output.newline()

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
@@ -8,6 +7,16 @@ from tokenizer import is_identifier_char
 
 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)
@@ -43,6 +52,7 @@ output_stream_defaults = {
     'ie_proof': True,
     'beautify': False,
     'source_map': None,
+    'source_map_line_offset': 0,
     'bracketize': False,
     'semicolons': True,
     'comments': False,
@@ -53,7 +63,7 @@ output_stream_defaults = {
     'keep_docstrings': False,
     'discard_asserts': False,
     'module_cache_dir': '',
-    'js_version':5,
+    'js_version':6,
     'write_name': True,
 }
 
@@ -65,14 +75,22 @@ class OutputStream:
         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 +107,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):
@@ -105,11 +129,11 @@ class OutputStream:
         if self.might_need_semicolon:
             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
@@ -124,7 +148,7 @@ class OutputStream:
         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
@@ -133,25 +157,27 @@ class OutputStream:
 
         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:
@@ -246,20 +272,8 @@ 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
+        return self._fragments.join('')
     toString = get
 
     def assign(self, name):
@@ -304,3 +318,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