rapydscript-ng 0.7.24 → 0.8.0

package/src/lib/traceback.pyj

@@ -2,26 +2,162 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 # globals: ρσ_str, ρσ_last_exception
 
+_traceback_state = {'source_map': None, 'decoded': None}
+
+_VLQ_BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+
+
+def set_source_map_data(data):
+    _traceback_state['source_map'] = data
+    _traceback_state['decoded'] = None
+
+
+def serialize_error_for_formatting(err):
+    return {
+        'name': err.name or 'Error',
+        'stack': err.stack or '',
+        'message': err.message or '',
+    }
+
+def unserialize_error_for_formatting(err):
+    ans = new Error()
+    ans.name = err.name
+    ans.stack = err.stack
+    ans.message = err.message
+    return ans
+
+
+def _vlq_decode(encoded):
+    result = v'[]'
+    i = 0
+    n = encoded.length
+    while i < n:
+        value = 0
+        shift = 0
+        has_more = True
+        while has_more:
+            digit = _VLQ_BASE64.indexOf(encoded[i])
+            i += 1
+            has_more = (digit & 32) != 0
+            value += (digit & 31) << shift
+            shift += 5
+        if value & 1:
+            value = -(value >> 1)
+        else:
+            value = value >> 1
+        result.push(value)
+    return result
+
+
+def _decode_source_map(smap):
+    sources = smap.sources or v'[]'
+    source_root = smap.sourceRoot or ''
+    mappings_str = smap.mappings or ''
+    mapping_lines = mappings_str.split(';')
+    decoded = v'[]'
+    prev_src_idx = 0
+    prev_src_line = 0
+    prev_src_col = 0
+    for gen_line in range(mapping_lines.length):
+        line_str = mapping_lines[gen_line]
+        line_entries = v'[]'
+        if line_str:
+            segments = line_str.split(',')
+            prev_col = 0
+            for seg_str in segments:
+                if not seg_str:
+                    continue
+                fields = _vlq_decode(seg_str)
+                if fields.length >= 4:
+                    gen_col = prev_col + fields[0]
+                    prev_col = gen_col
+                    src_idx = prev_src_idx + fields[1]
+                    prev_src_idx = src_idx
+                    src_line = prev_src_line + fields[2]
+                    prev_src_line = src_line
+                    src_col = prev_src_col + fields[3]
+                    prev_src_col = src_col
+                    src_file = sources[src_idx] if src_idx >= 0 and src_idx < sources.length else ''
+                    if source_root and src_file:
+                        src_file = source_root + src_file
+                    line_entries.push({'gen_col': gen_col, 'src_file': src_file, 'src_line': src_line, 'src_col': src_col})
+                elif fields.length >= 1:
+                    prev_col += fields[0]
+        decoded.push(line_entries)
+    return decoded
+
+
+def _find_mapping(decoded, gen_line, gen_col):
+    if not decoded or gen_line < 0 or gen_line >= decoded.length:
+        return None
+    line_entries = decoded[gen_line]
+    if not line_entries or not line_entries.length:
+        return None
+    best = None
+    for entry in line_entries:
+        if entry.gen_col <= gen_col:
+            if best is None or entry.gen_col > best.gen_col:
+                best = entry
+    return best
+
+
+def _parse_stack_frame(line):
+    # Chrome/Node: "    at functionName (file:line:col)"
+    m = /^\s*at\s+(.*?)\s+\((.+):(\d+):(\d+)\)/.exec(line)
+    if m:
+        return {'func': m[1] or None, 'file': m[2], 'line': parseInt(m[3], 10) - 1, 'col': parseInt(m[4], 10) - 1}
+    # Chrome/Node: "    at file:line:col"
+    m = /^\s*at (.+):(\d+):(\d+)$/.exec(line)
+    if m:
+        return {'func': None, 'file': m[1], 'line': parseInt(m[2], 10) - 1, 'col': parseInt(m[3], 10) - 1}
+    # Firefox: "functionName@file:line:col"
+    m = /^(.*?)@(.+):(\d+):(\d+)$/.exec(line)
+    if m:
+        return {'func': m[1] or None, 'file': m[2], 'line': parseInt(m[3], 10) - 1, 'col': parseInt(m[4], 10) - 1}
+    return None
+
+
+def _get_decoded_map():
+    if _traceback_state['decoded'] is None and _traceback_state['source_map']:
+        _traceback_state['decoded'] = _decode_source_map(_traceback_state['source_map'])
+    return _traceback_state['decoded']
+
 
 def _get_internal_traceback(err):
-    if isinstance(err, Exception) and err.stack:
-        lines = ρσ_str.splitlines(err.stack)
-        final_lines = v'[]'
-        found_sentinel = False
-        for i, line in enumerate(lines):
-            sline = ρσ_str.strip(line)
-            if i is 0:
-                final_lines.push(line)
-                continue
-            if found_sentinel:
-                final_lines.push(line)
-                continue
-            # These two conditions work on desktop Chrome and Firefox to identify the correct
-            # line in the traceback.
-            if sline.startsWith('at new ' + err.name) or sline.startsWith(err.name + '@'):
-                found_sentinel = True
-        return final_lines.join('\n')
-    return err and err.stack
+    lines = ρσ_str.splitlines(err.stack or '')
+    final_lines = v'[]'
+    start_line_idx = -1
+    for i, line in enumerate(lines):
+        if i > 0:
+            line = line.trim()
+            if line.startsWith('at new ' + err.name) or line.startsWith(err.name + '@'):
+                # this is the constructor for a RapydScript Exception
+                start_line_idx = i + 1
+                break
+    if start_line_idx < 0:
+        start_line_idx = 1
+        for i, xline in enumerate(lines):
+            if i > 0:
+                line = xline.trim()
+                if v"line.startsWith('at ') || line.includes('@') || /:\d+:\d+$/.test(line)":
+                    start_line_idx = i
+                    break
+    frame_lines = lines[start_line_idx:]
+    final_lines = final_lines.concat(frame_lines)
+    decoded = _get_decoded_map()
+    mapped_lines = v'[]'
+    if decoded:
+        for frame_line in frame_lines:
+            frame = _parse_stack_frame(frame_line)
+            if frame:
+                mapping = _find_mapping(decoded, frame.line, frame.col)
+                if mapping:
+                    loc = '  File "' + mapping.src_file + '", line ' + (mapping.src_line + 1) + ', col ' + (mapping.src_col + 1)
+                    if frame.func:
+                        loc += ', in ' + frame.func
+                    mapped_lines.push(loc)
+    return lines[0], final_lines, mapped_lines
+
 
 def format_exception(exc, limit):
     if jstype(exc) is 'undefined':
@@ -30,17 +166,18 @@ def format_exception(exc, limit):
         if exc and exc.toString:
             return [exc.toString()]
         return []
-    tb = _get_internal_traceback(exc)
-    if tb:
-        lines = ρσ_str.splitlines(tb)
-        e = lines[0]
-        lines = lines[1:]
+    e, js_lines, rs_lines = _get_internal_traceback(exc)
+    if js_lines.length > 0:
         if limit:
-            lines = lines[:limit+1] if limit > 0 else lines[limit:]
-        lines.reverse()
-        lines.push(e)
-        lines.insert(0, 'Traceback (most recent call last):')
-        return [l+'\n' for l in lines]
+            js_lines = js_lines[:limit] if limit > 0 else js_lines[limit:]
+            rs_lines = rs_lines[:limit] if limit > 0 else rs_lines[limit:]
+        js_lines.reverse()
+        rs_lines.reverse()
+        js_lines.push(e)
+        js_lines = v"['Traceback (most recent call last):'].concat(js_lines)"
+        if rs_lines.length > 0:
+            js_lines = js_lines.concat(['', 'Mapped Traceback (RapydScript):']).concat(rs_lines)
+        return [l+'\n' for l in js_lines]
     return [exc.toString()]
 
 def format_exc(limit):

package/src/lib/uuid.pyj

@@ -47,7 +47,7 @@ def uuid4():
 def num_to_string(numbers, alphabet, pad_to_length):
     ans = v'[]'
     alphabet_len = alphabet.length
-    numbers = Array.prototype.slice.call(numbers)
+    numbers = Array.from(numbers)
     for v'var i = 0; i < numbers.length - 1; i++':
         x = divmod(numbers[i], alphabet_len)
         numbers[i] = x[0]

package/src/output/codegen.pyj

@@ -2,7 +2,7 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
 
-# globals:console,regenerate,writefile
+# globals:console
 
 from utils import noop
 from parse import PRECEDENCE
@@ -18,7 +18,7 @@ from ast import (
     AST_Statement, AST_StatementWithBody, AST_String, AST_Sub, AST_ItemAccess,
     AST_Symbol, AST_This, AST_Throw, AST_Toplevel, AST_Try, AST_Unary,
     AST_UnaryPrefix, AST_Undefined, AST_Var, AST_VarDef, AST_Assert,
-    AST_Verbatim, AST_While, AST_With, AST_Yield, TreeWalker, AST_Existential
+    AST_Verbatim, AST_While, AST_With, AST_Yield, AST_Await, TreeWalker, AST_Existential
 )
 from output.exceptions import print_try
 from output.classes import print_class
@@ -48,10 +48,12 @@ def generate_code():
         if force_parens or self.needs_parens(stream):
             stream.with_parens(def():
                 self.add_comments(stream)
+                stream.add_mapping(self)
                 generator(self, stream)
             )
         else:
             self.add_comments(stream)
+            stream.add_mapping(self)
             generator(self, stream)
 
         stream.pop_node()
@@ -134,7 +136,7 @@ def generate_code():
     )
     PARENS(AST_New, def(output):
         p = output.parent()
-        if this.args.length is 0 and (is_node_type(p, AST_PropAccess) or is_node_type(p, AST_BaseCall) and p.expression is this):
+        if this.args.args.length is 0 and (is_node_type(p, AST_PropAccess) or is_node_type(p, AST_BaseCall) and p.expression is this):
             # (new foo)(bar)
             return True
     )
@@ -261,6 +263,11 @@ def generate_code():
     DEFPRINT(AST_Yield, def(self, output):
         self._do_print(output, "yield" + ('*' if self.is_yield_from else ''))
     )
+    DEFPRINT(AST_Await, def(self, output):
+        output.print("await")
+        output.space()
+        self.value.print(output)
+    )
     DEFPRINT(AST_Return, def(self, output):
         self._do_print(output, "return")
     )

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
@@ -35,8 +34,8 @@ def decorate(decorators, output, func):
 
 def function_args(argnames, output, strip_first):
     output.with_parens(def():
-        if argnames and argnames.length and (argnames.is_simple_func is True or argnames.is_simple_func is undefined):
-            for i, arg in enumerate((argnames.slice(1) if strip_first else argnames)):
+        if argnames and argnames.args.length and (argnames.is_simple_func is True or argnames.is_simple_func is undefined):
+            for i, arg in enumerate((argnames.args.slice(1) if strip_first else argnames.args)):
                 if i:
                     output.comma()
                 arg.print(output)
@@ -51,7 +50,7 @@ def function_preamble(node, output, offset):
     fname = node.name.name if node.name else anonfunc
     kw = 'arguments[arguments.length-1]'
     # Define all formal parameters
-    for c, arg in enumerate(a):
+    for c, arg in enumerate(a.args):
         i = c - offset
         if i >= 0:
             output.indent()
@@ -97,7 +96,7 @@ def function_preamble(node, output, offset):
 
     if a.starargs is not undefined:
         # Define the *args parameter, putting in whatever is left after assigning the formal parameters and the options object
-        nargs = a.length - offset
+        nargs = a.args.length - offset
         output.indent()
         output.spaced('var', a.starargs.name, '=', 'Array.prototype.slice.call(arguments,', nargs + ')')
         output.end_statement()
@@ -110,7 +109,7 @@ def function_preamble(node, output, offset):
 def has_annotations(self):
     if self.return_annotation:
         return True
-    for arg in self.argnames:
+    for arg in self.argnames.args:
         if arg.annotation:
             return True
     return False
@@ -123,13 +122,13 @@ def function_annotation(self, output, strip_first, name):
     if has_annotations(self):
         props.__annotations__ = def():
             output.print('{')
-            if self.argnames and self.argnames.length:
-                for i, arg in enumerate(self.argnames):
+            if self.argnames and self.argnames.args.length:
+                for i, arg in enumerate(self.argnames.args):
                     if arg.annotation:
                         arg.print(output)
                         output.print(':'), output.space()
                         arg.annotation.print(output)
-                        if i < self.argnames.length - 1 or self.return_annotation:
+                        if i < self.argnames.args.length - 1 or self.return_annotation:
                             output.comma()
             if self.return_annotation:
                 output.print('return:'), output.space()
@@ -154,14 +153,14 @@ def function_annotation(self, output, strip_first, name):
             output.print('true')
 
     # Create __argnames__
-    if self.argnames.length > (1 if strip_first else 0):
+    if self.argnames.args.length > (1 if strip_first else 0):
         props.__argnames__ = def():
             output.print('[')
-            for i, arg in enumerate(self.argnames):
+            for i, arg in enumerate(self.argnames.args):
                 if strip_first and i is 0:
                     continue
                 output.print(JSON.stringify(arg.name))
-                if i is not self.argnames.length - 1:
+                if i is not self.argnames.args.length - 1:
                     output.comma()
             output.print(']')
 
@@ -197,6 +196,8 @@ def function_definition(self, output, strip_first, as_expression):
         output.set_indentation(output.next_indent())
         output.spaced('(function()', '{'), output.newline()
         output.indent(), output.spaced('var', anonfunc, '='), output.space()
+    if self.is_async:
+        output.print("async"), output.space()
     output.print("function"), output.space()
     if self.name:
         self.name.print(output)
@@ -204,21 +205,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)')
@@ -338,19 +328,20 @@ def print_function_call(self, output):
     def print_positional_args():
         # basic arguments
         i = 0
-        while i < self.args.length:
-            expr = self.args[i]
+        pargs = self.args.args
+        while i < pargs.length:
+            expr = pargs[i]
             is_first = i is 0
             if not is_first:
                 output.print('.concat(')
             if expr.is_array:
-                expr.print(output)
+                expr.value.print(output)
                 i += 1
             else:
                 output.print('[')
-                while i < self.args.length and not self.args[i].is_array:
-                    self.args[i].print(output)
-                    if i + 1 < self.args.length and not self.args[i+1].is_array:
+                while i < pargs.length and not pargs[i].is_array:
+                    pargs[i].value.print(output)
+                    if i + 1 < pargs.length and not pargs[i+1].is_array:
                         output.print(',')
                         output.space()
                     i += 1
@@ -364,7 +355,7 @@ def print_function_call(self, output):
     is_new = is_node_type(self, AST_New)
     is_repeatable = True
 
-    if is_new and not self.args.length and not has_kwargs and not self.args.starargs:
+    if is_new and not self.args.args.length and not has_kwargs and not self.args.starargs:
         output.print('new'), output.space()
         print_function_name()
         return # new A is the same as new A() in javascript
@@ -375,10 +366,10 @@ def print_function_call(self, output):
             output.print('new'), output.space()
         print_function_name()
         output.with_parens(def():
-            for i, a in enumerate(self.args):
+            for i, a in enumerate(self.args.args):
                 if i:
                     output.comma()
-                a.print(output)
+                a.value.print(output)
         )
         return
 
@@ -404,18 +395,18 @@ def print_function_call(self, output):
             output.print('.apply(')
             do_print_this()
 
-    if is_prototype_call and self.args.length > 1:
-        self.args.shift()
+    if is_prototype_call and self.args.args.length > 1:
+        self.args.args.shift()
 
     print_positional_args()
 
     if has_kwargs:
-        if self.args.length:
+        if self.args.args.length:
             output.print('.concat(')
         output.print('[')
         print_kwargs()
         output.print(']')
-        if self.args.length:
+        if self.args.args.length:
             output.print(')')
 
     output.print(')')

package/src/output/literals.pyj

@@ -5,20 +5,17 @@ from __python__ import hash_literals
 from ast import AST_Binary, is_node_type
 
 def print_array(self, output):
-    output.print('ρσ_list_decorate')
-    output.with_parens(def():
-        output.with_square(def():
-            a = self.elements
-            len_ = a.length
-            if len_ > 0:
-                output.space()
-            for i, exp in enumerate(a):
-                if i:
-                    output.comma()
-                exp.print(output)
-            if len_ > 0:
-                output.space()
-        )
+    output.with_square(def():
+        a = self.elements
+        len_ = a.length
+        if len_ > 0:
+            output.space()
+        for i, exp in enumerate(a):
+            if i:
+                output.comma()
+            exp.print(output)
+        if len_ > 0:
+            output.space()
     )