rapydscript-ng 0.7.24 → 0.8.1

package/src/output/loops.pyj

@@ -1,77 +1,79 @@
 # 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
 from output.stream import OutputStream
 
+
 def unpack_tuple(elems, output, in_statement):
     for i, elem in enumerate(elems):
         output.indent()
         output.assign(elem)
-        output.print("ρσ_unpack")
-        output.with_square(def():
+        output.print('ρσ_unpack')
+        output.with_square(def ():
             output.print(i)
         )
         if not in_statement or i < elems.length - 1:
             output.semicolon()
             output.newline()
 
+
 def print_do_loop(self, output):
-    output.print("do")
+    output.print('do')
     output.space()
     self._do_print_body(output)
     output.space()
-    output.print("while")
+    output.print('while')
     output.space()
-    output.with_parens(def(): self.condition.print(output);)
+    output.with_parens(def (): self.condition.print(output);)
     output.semicolon()
 
+
 def print_while_loop(self, output):
-    output.print("while")
+    output.print('while')
     output.space()
-    output.with_parens(def(): self.condition.print(output);)
+    output.with_parens(def (): self.condition.print(output);)
     output.space()
     self._do_print_body(output)
 
+
 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
 
+
 def is_simple_for(self):
     # returns true if this loop can be simplified into a basic for(i=n;i<h;i++) loop
     if (is_node_type(self.object, AST_BaseCall) and
             is_node_type(self.object.expression, AST_SymbolRef) and
-            self.object.expression.name is "range" 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
 
+
 def print_for_loop_body(output):
     self = this
-    output.with_block(def():
+    output.with_block(def ():
         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")
+                output.assign('ρσ_unpack')
                 if flat.length > self.init.elements.length:
                     output.print('ρσ_flatten(' + itervar + ')')
                 else:
@@ -82,208 +84,173 @@ def print_for_loop_body(output):
                 output.assign(self.init)
                 output.print(itervar)
                 output.end_statement()
-
             output.index_counter += 1
         if self.simple_for_index:
             output.indent()
             output.assign(self.init)
             output.print(self.simple_for_index)
             output.end_statement()
-
         for stmt in self.body.body:
             output.indent()
             stmt.print(output)
             output.newline()
     )
 
+
 def init_es6_itervar(output, itervar):
     output.indent()
     output.spaced(itervar, '=', '((typeof', itervar + '[Symbol.iterator]', '===', '"function")', '?',
-                    '('+itervar, 'instanceof', 'Map', '?', itervar + '.keys()', ':', itervar+')', ':', 'Object.keys(' + itervar + '))')
+                    '(' + itervar, 'instanceof', 'Map', '?', itervar + '.keys()', ':', itervar + ')', ':', 'Object.keys(' + itervar + '))')
     output.end_statement()
 
+
 def print_for_in(self, output):
     def write_object():
         if self.object.constructor is AST_Seq:
-            (new AST_Array({'elements':self.object.to_array()})).print(output)
+            (new AST_Array({'elements': self.object.to_array()})).print(output)
         else:
             self.object.print(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
-        output.print("for")
+        output.print('for')
         output.space()
-        output.with_parens(def():
+        output.with_parens(def ():
             output.spaced('var', idx, '='), output.space()
             start.print(output) if start.print else output.print(start)
             output.semicolon()
             output.space()
             output.print(idx)
             output.space()
-            output.print(">") if is_node_type(increment, AST_Unary) else output.print("<")
+            output.print('>') if is_node_type(increment, AST_Unary) else output.print('<')
             output.space()
             end.print(output)
             output.semicolon()
             output.space()
             output.print(idx)
-            if increment and (not (is_node_type(increment, AST_Unary)) or increment.expression.value is not "1"):
+            if increment and (not (is_node_type(increment, AST_Unary)) or increment.expression.value is not '1'):
                 if is_node_type(increment, AST_Unary):
-                    output.print("-=")
+                    output.print('-=')
                     increment.expression.print(output)
                 else:
-                    output.print("+=")
+                    output.print('+=')
                     increment.print(output)
             else:
                 if is_node_type(increment, AST_Unary):
-                    output.print("--")
+                    output.print('--')
                 else:
-                    output.print("++")
+                    output.print('++')
         )
     elif is_simple_for_in(self):
         # optimize dir() into a simple for in loop
-        output.print("for")
+        output.print('for')
         output.space()
-        output.with_parens(def():
+        output.with_parens(def ():
             self.init.print(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)
 
+
 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]
+    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()'
-            add_to_result = def(output):
+            add_to_result = def (output):
                 output.indent()
                 output.print('ρσ_Result.set')
-                output.with_parens(def():
+                output.with_parens(def ():
                     self.statement.print(output)
                     output.space(), output.print(','), output.space()
-                    output.with_parens(def():
+                    output.with_parens(def ():
                         if self.value_statement.constructor is AST_Seq:
-                            output.with_square(def():self.value_statement.print(output);)
+                            output.with_square(def (): self.value_statement.print(output);)
                         else:
                             self.value_statement.print(output)
                     )
                 )
                 output.end_statement()
         else:
-            add_to_result = def(output):
+            add_to_result = def (output):
                 output.indent()
                 output.print('ρσ_Result')
-                output.with_square(def():
+                output.with_square(def ():
                     self.statement.print(output)
                 )
                 output.space(), output.print('='), output.space()
-                output.with_parens(def():
+                output.with_parens(def ():
                     if self.value_statement.constructor is AST_Seq:
-                        output.with_square(def():self.value_statement.print(output);)
+                        output.with_square(def (): self.value_statement.print(output);)
                     else:
                         self.value_statement.print(output)
                 )
                 output.end_statement()
     else:
-        push_func = "ρσ_Result." + ('push' if self.constructor is AST_ListComprehension else 'add')
+        push_func = 'ρσ_Result.' + ('push' if self.constructor is AST_ListComprehension else 'add')
         if is_generator:
             push_func = 'yield '
-        add_to_result = def(output):
+        add_to_result = def (output):
             output.indent()
             output.print(push_func)
-            output.with_parens(def():
+            output.with_parens(def ():
                 if self.statement.constructor is AST_Seq:
-                    output.with_square(def():self.statement.print(output);)
+                    output.with_square(def (): self.statement.print(output);)
                 else:
                     self.statement.print(output)
             )
             output.end_statement()
 
-    output.with_parens(def():
-        output.print("function")
-        output.print("()")
+    output.with_parens(def ():
+        output.print('function')
+        output.print('()')
         output.space()
-        output.with_block(def():
+        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()
                 previous_indentation = output.indentation()
                 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)
-
+            body_out.assign('var ρσ_Iter')
+            self.object.print(body_out)
             if result_obj:
                 body_out.comma()
-                body_out.assign("ρσ_Result")
+                body_out.assign('ρσ_Result')
                 body_out.print(result_obj)
             # make sure to locally scope loop variables
             if is_node_type(self.init, AST_Array):
@@ -294,38 +261,20 @@ def print_list_comprehension(self, output):
                 body_out.comma()
                 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.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.with_parens(def ():
+                body_out.spaced('var', 'ρσ_Index', 'of', 'ρσ_Iter')
             )
             body_out.space()
-            body_out.with_block(def():
+            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")
+                    body_out.assign('ρσ_unpack')
                     if flat.length > self.init.elements.length:
                         body_out.print('ρσ_flatten(' + itervar + ')')
                     else:
@@ -336,14 +285,13 @@ def print_list_comprehension(self, output):
                     body_out.assign(self.init)
                     body_out.print(itervar)
                     body_out.end_statement()
-
                 if self.condition:
                     body_out.indent()
-                    body_out.print("if")
+                    body_out.print('if')
                     body_out.space()
-                    body_out.with_parens(def(): self.condition.print(body_out);)
+                    body_out.with_parens(def (): self.condition.print(body_out);)
                     body_out.space()
-                    body_out.with_block(def():
+                    body_out.with_block(def ():
                         add_to_result(body_out)
                     )
                     body_out.newline()
@@ -357,17 +305,11 @@ def print_list_comprehension(self, output):
                 body_out.end_statement()
             if not is_generator:
                 body_out.indent()
-                body_out.print("return ρσ_Result")
+                body_out.print('return ρσ_Result')
                 body_out.end_statement()
             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()
@@ -380,4 +322,4 @@ def print_list_comprehension(self, output):
                 output.end_statement()
         )
     )
-    output.print("()")
+    output.print('()')