rapydscript-ng 0.7.24 → 0.8.1

package/src/output/codegen.pyj

@@ -2,10 +2,6 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
 
-# globals:console,regenerate,writefile
-
-from utils import noop
-from parse import PRECEDENCE
 from ast import (
     AST_Array, AST_Assign, AST_BaseCall, AST_Binary, AST_BlockStatement, AST_Break,
     AST_Class, AST_Conditional, AST_Constant, AST_Continue,
@@ -18,22 +14,25 @@ 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
+from output.comments import print_comments
+from output.exceptions import print_try
+from output.functions import print_function, print_function_call
 from output.literals import print_array, print_obj_literal, print_object, print_set, print_regexp
 from output.loops import print_do_loop, print_while_loop, print_for_loop_body, print_for_in, print_list_comprehension
 from output.modules import print_top_level, print_imports
-from output.comments import print_comments
 from output.operators import (
     print_getattr, print_getitem, print_rich_getitem, print_splice_assignment,
     print_unary_prefix, print_binary_op, print_assign,
     print_conditional, print_seq, print_existential
 )
-from output.functions import print_function, print_function_call
 from output.statements import print_bracketed, first_in_statement, force_statement, print_with, print_assert
 from output.utils import make_block, make_num
+from parse import PRECEDENCE
+from utils import noop
+
 
 # -----[ code generators ]-----
 def generate_code():
@@ -41,23 +40,25 @@ def generate_code():
     def DEFPRINT(nodetype, generator):
         nodetype.prototype._codegen = generator
 
-    AST_Node.prototype.print = def(stream, force_parens):
+    AST_Node.prototype.print = def (stream, force_parens):
         self = this
         generator = self._codegen
         stream.push_node(self)
         if force_parens or self.needs_parens(stream):
-            stream.with_parens(def():
+            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()
 
     # -----[ comments ]-----
-    AST_Node.prototype.add_comments = def(output):
+    AST_Node.prototype.add_comments = def (output):
         if not is_node_type(this, AST_Toplevel):
             print_comments(this, output)
 
@@ -65,51 +66,48 @@ def generate_code():
     def PARENS(nodetype, func):
         nodetype.prototype.needs_parens = func
 
-    PARENS(AST_Node, def():
+    PARENS(AST_Node, def ():
         return False
     )
     # a function expression needs parens around it when it's provably
     # the first token to appear in a statement.
-    PARENS(AST_Function, def(output):
+    PARENS(AST_Function, def (output):
         return first_in_statement(output)
     )
     # same goes for an object literal, because otherwise it would be
     # interpreted as a block of code.
-    PARENS(AST_Object, def(output):
+    PARENS(AST_Object, def (output):
         return first_in_statement(output)
     )
-    PARENS(AST_Unary, def(output):
+    PARENS(AST_Unary, def (output):
         p = output.parent()
         return is_node_type(p, AST_PropAccess) and p.expression is this
     )
-    PARENS(AST_Seq, def(output):
+    PARENS(AST_Seq, def (output):
         p = output.parent()
         return is_node_type(p, AST_Unary) or is_node_type(p, AST_VarDef) or is_node_type(p, AST_Dot) or is_node_type(p, AST_ObjectProperty) or is_node_type(p, AST_Conditional)
     )
-    PARENS(AST_Binary, def(output):
+    PARENS(AST_Binary, def (output):
         p = output.parent()
         # (foo && bar)()
         if is_node_type(p, AST_BaseCall) and p.expression is this:
             return True
-
         # typeof (foo && bar)
         if is_node_type(p, AST_Unary):
             return True
-
         # (foo && bar)["prop"], (foo && bar).prop
         if is_node_type(p, AST_PropAccess) and p.expression is this:
             return True
-
         # this deals with precedence: 3 * (2 + 1)
         if is_node_type(p, AST_Binary):
             po = p.operator
             pp = PRECEDENCE[po]
             so = this.operator
             sp = PRECEDENCE[so]
-            if pp > sp or pp is sp and this is p.right and not (so is po and (so is "*" or so is "&&" or so is "||")):
+            if pp > sp or pp is sp and this is p.right and not (so is po and (so is '*' or so is '&&' or so is '||')):
                 return True
     )
-    PARENS(AST_PropAccess, def(output):
+    PARENS(AST_PropAccess, def (output):
         p = output.parent()
         if is_node_type(p, AST_New) and p.expression is this:
             # i.e. new (foo.bar().baz)
@@ -119,7 +117,7 @@ def generate_code():
             # interpreted as passing the arguments to the upper New
             # expression.
             try:
-                this.walk(new TreeWalker(def(node):
+                this.walk(new TreeWalker(def (node):
                     if is_node_type(node, AST_BaseCall):
                         raise p
                 ))
@@ -128,26 +126,27 @@ def generate_code():
                     raise ex
                 return True
     )
-    PARENS(AST_BaseCall, def(output):
+    PARENS(AST_BaseCall, def (output):
         p = output.parent()
         return is_node_type(p, AST_New) and p.expression is this
     )
-    PARENS(AST_New, def(output):
+    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
     )
-    PARENS(AST_Number, def(output):
+    PARENS(AST_Number, def (output):
         p = output.parent()
         if this.value < 0 and is_node_type(p, AST_PropAccess) and p.expression is this:
             return True
     )
-    PARENS(AST_NaN, def(output):
+    PARENS(AST_NaN, def (output):
         p = output.parent()
         if is_node_type(p, AST_PropAccess) and p.expression is this:
             return True
     )
+
     def assign_and_conditional_paren_rules(output):
         p = output.parent()
         # !(a = false) → true
@@ -174,18 +173,18 @@ def generate_code():
     PARENS(AST_Conditional, assign_and_conditional_paren_rules)
 
     # -----[ PRINTERS ]-----
-    DEFPRINT(AST_Directive, def(self, output):
+    DEFPRINT(AST_Directive, def (self, output):
         output.print_string(self.value)
         output.semicolon()
     )
-    DEFPRINT(AST_Debugger, def(self, output):
-        output.print("debugger")
+    DEFPRINT(AST_Debugger, def (self, output):
+        output.print('debugger')
         output.semicolon()
     )
-    AST_StatementWithBody.prototype._do_print_body = def(output):
+    AST_StatementWithBody.prototype._do_print_body = def (output):
         force_statement(this.body, output)
 
-    DEFPRINT(AST_Statement, def(self, output):
+    DEFPRINT(AST_Statement, def (self, output):
         self.body.print(output)
         output.semicolon()
     )
@@ -193,16 +192,16 @@ def generate_code():
 
     DEFPRINT(AST_Imports, print_imports)
 
-    DEFPRINT(AST_SimpleStatement, def(self, output):
+    DEFPRINT(AST_SimpleStatement, def (self, output):
         if not (is_node_type(self.body, AST_EmptyStatement)):
             self.body.print(output)
             output.semicolon()
     )
-    DEFPRINT(AST_BlockStatement, def(self, output):
+    DEFPRINT(AST_BlockStatement, def (self, output):
         print_bracketed(self, output)
     )
 
-    DEFPRINT(AST_EmptyStatement, def(self, output):
+    DEFPRINT(AST_EmptyStatement, def (self, output):
         pass
     )
 
@@ -214,19 +213,19 @@ def generate_code():
 
     DEFPRINT(AST_ForIn, print_for_in)
 
-    AST_ForJS.prototype._do_print_body = def(output):
+    AST_ForJS.prototype._do_print_body = def (output):
         self = this
-        output.with_block(def():
+        output.with_block(def ():
             for stmt in self.body.body:
                 output.indent()
                 stmt.print(output)
                 output.newline()
         )
 
-    DEFPRINT(AST_ForJS, def(self, output):
-        output.print("for")
+    DEFPRINT(AST_ForJS, def (self, output):
+        output.print('for')
         output.space()
-        output.with_parens(def():
+        output.with_parens(def ():
             self.condition.print(output)
         )
         output.space()
@@ -241,15 +240,15 @@ def generate_code():
 
     AST_Lambda.prototype._do_print = print_function
 
-    DEFPRINT(AST_Lambda, def(self, output):
+    DEFPRINT(AST_Lambda, def (self, output):
         self._do_print(output)
     )
     AST_Class.prototype._do_print = print_class
-    DEFPRINT(AST_Class, def(self, output):
+    DEFPRINT(AST_Class, def (self, output):
         self._do_print(output)
     )
     # -----[ exits ]-----
-    AST_Exit.prototype._do_print = def(output, kind):
+    AST_Exit.prototype._do_print = def (output, kind):
         self = this
         output.print(kind)
         if self.value:
@@ -258,18 +257,23 @@ def generate_code():
 
         output.semicolon()
 
-    DEFPRINT(AST_Yield, def(self, output):
-        self._do_print(output, "yield" + ('*' if self.is_yield_from else ''))
+    DEFPRINT(AST_Yield, def (self, output):
+        self._do_print(output, 'yield' + ('*' if self.is_yield_from else ''))
     )
-    DEFPRINT(AST_Return, def(self, output):
-        self._do_print(output, "return")
+    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')
     )
-    DEFPRINT(AST_Throw, def(self, output):
-        self._do_print(output, "throw")
+    DEFPRINT(AST_Throw, def (self, output):
+        self._do_print(output, 'throw')
     )
 
     # -----[ loop control ]-----
-    AST_LoopControl.prototype._do_print = def(output, kind):
+    AST_LoopControl.prototype._do_print = def (output, kind):
         output.print(kind)
         if this.label:
             output.space()
@@ -277,11 +281,11 @@ def generate_code():
 
         output.semicolon()
 
-    DEFPRINT(AST_Break, def(self, output):
-        self._do_print(output, "break")
+    DEFPRINT(AST_Break, def (self, output):
+        self._do_print(output, 'break')
     )
-    DEFPRINT(AST_Continue, def(self, output):
-        self._do_print(output, "continue")
+    DEFPRINT(AST_Continue, def (self, output):
+        self._do_print(output, 'continue')
     )
 
     # -----[ if ]-----
@@ -323,27 +327,26 @@ def generate_code():
 
         force_statement(self.body, output)
 
-    DEFPRINT(AST_If, def(self, output):
-        output.print("if")
+    DEFPRINT(AST_If, def (self, output):
+        output.print('if')
         output.space()
-        output.with_parens(def(): self.condition.print(output);)
+        output.with_parens(def (): self.condition.print(output);)
         output.space()
         if self.alternative:
             make_then(self, output)
             output.space()
-            output.print("else")
+            output.print('else')
             output.space()
             force_statement(self.alternative, output)
         else:
             self._do_print_body(output)
-
     )
 
     # -----[ exceptions ]-----
     DEFPRINT(AST_Try, print_try)
 
     # -----[ var/const ]-----
-    AST_Definitions.prototype._do_print = def(output, kind):
+    AST_Definitions.prototype._do_print = def (output, kind):
         output.print(kind)
         output.space()
         for i, def_ in enumerate(this.definitions):
@@ -356,9 +359,10 @@ def generate_code():
         if not avoid_semicolon:
             output.semicolon()
 
-    DEFPRINT(AST_Var, def(self, output):
-        self._do_print(output, "var")
+    DEFPRINT(AST_Var, def (self, output):
+        self._do_print(output, 'var')
     )
+
     def parenthesize_for_noin(node, output, noin):
         if not noin:
             node.print(output)
@@ -366,8 +370,8 @@ def generate_code():
             try:
                 # need to take some precautions here:
                 #    https://github.com/mishoo/RapydScript2/issues/60
-                node.walk(new TreeWalker(def(node):
-                    if is_node_type(node, AST_Binary) and node.operator is "in":
+                node.walk(new TreeWalker(def (node):
+                    if is_node_type(node, AST_Binary) and node.operator is 'in':
                         raise output
                 ))
                 node.print(output)
@@ -376,10 +380,10 @@ def generate_code():
                     raise ex
                 node.print(output, True)
 
-    DEFPRINT(AST_VarDef, def(self, output):
+    DEFPRINT(AST_VarDef, def (self, output):
         self.name.print(output)
         if self.value:
-            output.assign("")
+            output.assign('')
             #            output.space()
             #            output.print("=")
             #            output.space()
@@ -393,7 +397,7 @@ def generate_code():
 
     AST_Seq.prototype._do_print = print_seq
 
-    DEFPRINT(AST_Seq, def(self, output):
+    DEFPRINT(AST_Seq, def (self, output):
         self._do_print(output)
     )
     DEFPRINT(AST_Dot, print_getattr)
@@ -421,44 +425,44 @@ def generate_code():
 
     DEFPRINT(AST_Object, print_object)
 
-    DEFPRINT(AST_ObjectKeyVal, def(self, output):
+    DEFPRINT(AST_ObjectKeyVal, def (self, output):
         self.key.print(output)
         output.colon()
         self.value.print(output)
     )
     DEFPRINT(AST_Set, print_set)
 
-    AST_Symbol.prototype.definition = def():
+    AST_Symbol.prototype.definition = def ():
         return this.thedef
 
-    DEFPRINT(AST_Symbol, def(self, output):
+    DEFPRINT(AST_Symbol, def (self, output):
         def_ = self.definition()
         output.print_name((def_.mangled_name or def_.name) if def_ else self.name)
     )
-    DEFPRINT(AST_Undefined, def(self, output):
-        output.print("void 0")
+    DEFPRINT(AST_Undefined, def (self, output):
+        output.print('void 0')
     )
     DEFPRINT(AST_Hole, noop)
 
-    DEFPRINT(AST_Infinity, def(self, output):
-        output.print("1/0")
+    DEFPRINT(AST_Infinity, def (self, output):
+        output.print('1/0')
     )
-    DEFPRINT(AST_NaN, def(self, output):
-        output.print("0/0")
+    DEFPRINT(AST_NaN, def (self, output):
+        output.print('0/0')
     )
-    DEFPRINT(AST_This, def(self, output):
-        output.print("this")
+    DEFPRINT(AST_This, def (self, output):
+        output.print('this')
     )
-    DEFPRINT(AST_Constant, def(self, output):
+    DEFPRINT(AST_Constant, def (self, output):
         output.print(self.value)
     )
-    DEFPRINT(AST_String, def(self, output):
+    DEFPRINT(AST_String, def (self, output):
         output.print_string(self.value)
     )
-    DEFPRINT(AST_Verbatim, def(self, output):
+    DEFPRINT(AST_Verbatim, def (self, output):
         output.print(self.value)
     )
-    DEFPRINT(AST_Number, def(self, output):
+    DEFPRINT(AST_Number, def (self, output):
         output.print(make_num(self.value))
     )
     DEFPRINT(AST_RegExp, print_regexp)

package/src/output/comments.pyj

@@ -7,13 +7,13 @@ from ast import AST_Exit, is_node_type
 
 def output_comments(comments, output, nlb):
     for comm in comments:
-        if comm.type is "comment1":
-            output.print("//" + comm.value + "\n")
+        if comm.type is 'comment1':
+            output.print('//' + comm.value + '\n')
             output.indent()
-        elif comm.type is "comment2":
-            output.print("/*" + comm.value + "*/")
+        elif comm.type is 'comment2':
+            output.print('/*' + comm.value + '*/')
             if nlb:
-                output.print("\n")
+                output.print('\n')
                 output.indent()
             else:
                 output.space()
@@ -34,11 +34,11 @@ def print_comments(self, output):
                 self.value.start.comments_before = v'[]'
 
             if c.test:
-                comments = comments.filter(def(comment):
+                comments = comments.filter(def (comment):
                     return c.test(comment.value)
                 )
-            elif jstype(c) is "function":
-                comments = comments.filter(def(comment):
+            elif jstype(c) is 'function':
+                comments = comments.filter(def (comment):
                     return c(self, comment)
                 )
 

package/src/output/exceptions.pyj

@@ -7,12 +7,13 @@ from output.statements import print_bracketed
 
 def print_try(self, output):
     else_var_name = None
+
     def update_output_var(output):
         output.indent(), output.assign(else_var_name), output.print('true'), output.end_statement()
     if self.belse:
         else_var_name = output.new_try_else_counter()
         output.assign('var ' + else_var_name), output.print('false'), output.end_statement(), output.indent()
-    output.print("try")
+    output.print('try')
     output.space()
     print_bracketed(self, output, False, None, None, update_output_var if else_var_name else None)
     if self.bcatch:
@@ -28,35 +29,33 @@ def print_try(self, output):
 
 
 def print_catch(self, output):
-    output.print("catch")
+    output.print('catch')
     output.space()
-    output.with_parens(def():
-        output.print("ρσ_Exception")
+    output.with_parens(def ():
+        output.print('ρσ_Exception')
     )
     output.space()
-    output.with_block(def():
+    output.with_block(def ():
         output.indent()
         output.spaced('ρσ_last_exception', '=', 'ρσ_Exception'), output.end_statement()
         output.indent()
         no_default = True
         for i, exception in enumerate(self.body):
             if i:
-                output.print("else ")
-
+                output.print('else ')
             if exception.errors.length:
-                output.print("if")
+                output.print('if')
                 output.space()
-                output.with_parens(def():
+                output.with_parens(def ():
                     for i, err in enumerate(exception.errors):
                         if i:
                             output.newline()
                             output.indent()
-                            output.print("||")
+                            output.print('||')
                             output.space()
-
-                        output.print("ρσ_Exception")
+                        output.print('ρσ_Exception')
                         output.space()
-                        output.print("instanceof")
+                        output.print('instanceof')
                         output.space()
                         if err.name is 'Exception':
                             output.print('Error')
@@ -69,13 +68,13 @@ def print_catch(self, output):
             print_bracketed(exception, output, True)
             output.space()
         if no_default:
-            output.print("else")
+            output.print('else')
             output.space()
-            output.with_block(def():
+            output.with_block(def ():
                 output.indent()
-                output.print("throw")
+                output.print('throw')
                 output.space()
-                output.print("ρσ_Exception")
+                output.print('ρσ_Exception')
                 output.semicolon()
                 output.newline()
             )
@@ -84,13 +83,13 @@ def print_catch(self, output):
 
 
 def print_finally(self, output, belse, else_var_name):
-    output.print("finally")
+    output.print('finally')
     output.space()
     if else_var_name:
-        output.with_block(def():
-            output.indent(), output.print("try")
+        output.with_block(def ():
+            output.indent(), output.print('try')
             output.space()
-            output.with_block(def():
+            output.with_block(def ():
                 print_else(belse, else_var_name, output)
             )
             print_finally(self, output)