rapydscript-ns 0.8.4 → 0.9.1

package/src/output/functions.pyj

@@ -2,8 +2,9 @@
 # License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
 from __python__ import hash_literals
 
-from ast import AST_ClassCall, AST_New, has_calls, AST_Dot, AST_SymbolRef, is_node_type
+from ast import AST_ClassCall, AST_New, has_calls, AST_Dot, AST_SymbolRef, AST_String, is_node_type
 from output.stream import OutputStream
+from parse import parse as ρσ_rs_parse
 from output.statements import print_bracketed
 from output.utils import create_doctring
 from output.operators import print_getattr
@@ -449,6 +450,73 @@ def print_function_call(self, output):
                         output.comma()
                     a.print(output)
             )
+        elif (is_node_type(self.expression, AST_SymbolRef) and
+              self.expression.name is 'vars' and self.args.length is 0):
+            # vars() with no args → vars(this) so it captures the caller's instance
+            output.print('ρσ_vars')
+            output.with_parens(def():
+                output.print('this')
+            )
+        elif (is_node_type(self.expression, AST_SymbolRef) and
+              (self.expression.name is 'eval' or self.expression.name is 'exec') and
+              self.args.length >= 1 and is_node_type(self.args[0], AST_String)):
+            # Compile-time RapydScript → JS transformation for eval/exec string literals.
+            # The RapydScript source string is parsed and compiled to JS now; the emitted
+            # call receives the compiled JS string instead of the original RapydScript.
+            fn_name = self.expression.name
+            source  = self.args[0].value
+            inner_ast = ρσ_rs_parse(source, {
+                'filename':        '<eval>',
+                'module_id':       '__eval__',
+                'for_linting':     True,
+                'discard_asserts': output.options.discard_asserts,
+            })
+            inner_os = OutputStream({
+                'beautify':        False,
+                'js_version':      output.options.js_version,
+                'private_scope':   False,
+                'write_name':      False,
+                'omit_baselib':    True,
+                'discard_asserts': output.options.discard_asserts,
+            })
+            inner_ast.print(inner_os)
+            compiled_js = v'inner_os.get().trim()'
+
+            def _print_extra_args():
+                for a in self.args.slice(1):
+                    output.comma()
+                    a.print(output)
+
+            if fn_name is 'eval' and self.args.length is 1:
+                # eval("expr") → native direct eval for scope access
+                output.print('eval')
+                output.with_parens(def():
+                    output.print(JSON.stringify(compiled_js))
+                )
+            elif fn_name is 'eval':
+                # eval("expr", globals, locals) → ρσ_eval(compiled_js, globals, locals)
+                output.print('ρσ_eval')
+                output.with_parens(def():
+                    output.print(JSON.stringify(compiled_js))
+                    _print_extra_args()
+                )
+            else:
+                # exec("code", ...) → ρσ_exec(compiled_js, ...)
+                output.print('ρσ_exec')
+                output.with_parens(def():
+                    output.print(JSON.stringify(compiled_js))
+                    _print_extra_args()
+                )
+        elif is_node_type(self.expression, AST_SymbolRef) and self.expression.name is 'eval' and self.args.length > 1:
+            # eval(dynamic_expr, globals, locals) → ρσ_eval(dynamic_expr, globals, locals)
+            # The 1-arg form eval(expr) is left as native JS direct eval for scope access.
+            output.print('ρσ_eval')
+            output.with_parens(def():
+                for i, a in enumerate(self.args):
+                    if i:
+                        output.comma()
+                    a.print(output)
+            )
         elif is_node_type(self.expression, AST_SymbolRef) and self.python_truthiness:
             # __call__-aware dispatch when from __python__ import truthiness is active
             output.print('ρσ_callable_call(')
@@ -461,10 +529,15 @@ def print_function_call(self, output):
             # Method calls and other complex expressions — keep existing behaviour
             print_function_name()
             output.with_parens(def():
-                for i, a in enumerate(self.args):
-                    if i:
-                        output.comma()
-                    a.print(output)
+                # .split() with no args: default to ' ' so JS splits on space
+                # rather than returning [whole_string] (native JS no-arg behavior)
+                if is_node_type(self.expression, AST_Dot) and self.expression.property is 'split' and not self.args.length:
+                    output.print('" "')
+                else:
+                    for i, a in enumerate(self.args):
+                        if i:
+                            output.comma()
+                        a.print(output)
             )
         return
 

package/src/output/jsx.pyj

@@ -1,164 +1,164 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-from __python__ import hash_literals
-
-from ast import AST_String, AST_JSXText, AST_JSXSpread, AST_JSXExprContainer, is_node_type
-
-def _is_component_tag(tag):
-    # Components start with uppercase or use dot notation (e.g. Router.Route)
-    first = tag[0]
-    return (first >= 'A' and first <= 'Z') or '.' in tag
-
-def _needs_quoting(name):
-    # Attribute names containing non-identifier chars (e.g. aria-label) need quoting
-    return not v'/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)'
-
-def _decode_html_entities(text):
-    # Decode HTML entities in a single pass to avoid double-decoding (e.g. &amp;lt; -> &lt;)
-    return text.replace(/&(?:#x([0-9a-fA-F]+)|#(\d+)|([a-zA-Z]+));/g, def(match, hex, dec, name):
-        if hex:
-            return String.fromCharCode(parseInt(hex, 16))
-        if dec:
-            return String.fromCharCode(parseInt(dec, 10))
-        if name is 'amp':
-            return '&'
-        if name is 'lt':
-            return '<'
-        if name is 'gt':
-            return '>'
-        if name is 'quot':
-            return '"'
-        if name is 'apos':
-            return "'"
-        if name is 'nbsp':
-            return '\u00a0'
-        return match
-    )
-
-def _normalize_jsx_whitespace(text):
-    # Implements the Babel JSX whitespace algorithm:
-    # - Split by newlines; trim leading whitespace from all lines except the first,
-    #   trailing whitespace from all lines except the last.
-    # - Lines that are empty after trimming are dropped.
-    # - Remaining non-empty lines are joined; each line except the last non-empty
-    #   gets a trailing space to separate it from the next.
-    lines = text.split('\n')
-    last_non_empty = -1
-    for i in range(lines.length):
-        if /[^ \t]/.test(lines[i]):
-            last_non_empty = i
-    result = ''
-    for i in range(lines.length):
-        line = lines[i].replace(/\t/g, ' ')
-        is_first = (i is 0)
-        is_last = (i is lines.length - 1)
-        if not is_first:
-            line = line.replace(/^[ ]+/, '')
-        if not is_last:
-            line = line.replace(/[ ]+$/, '')
-        if line:
-            if i is not last_non_empty:
-                line += ' '
-            result += line
-    return result
-
-def _process_jsx_text(text):
-    text = _normalize_jsx_whitespace(text)
-    if text:
-        text = _decode_html_entities(text)
-    return text
-
-def _print_tag(tag, output):
-    if _is_component_tag(tag):
-        output.print(tag)
-    else:
-        output.print('"')
-        output.print(tag)
-        output.print('"')
-
-def _print_props(props, output):
-    if not props or not props.length:
-        output.print('null')
-        return
-    output.print('{')
-    first = True
-    for prop in props:
-        if not first:
-            output.print(', ')
-        first = False
-        if is_node_type(prop, AST_JSXSpread):
-            output.print('...')
-            prop.expression.print(output)
-        else:
-            if _needs_quoting(prop.name):
-                output.print('"')
-                output.print(prop.name)
-                output.print('"')
-            else:
-                output.print(prop.name)
-            output.print(': ')
-            if prop.value is None:
-                output.print('true')
-            elif is_node_type(prop.value, AST_String):
-                output.print_string(prop.value.value)
-            else:
-                prop.value.print(output)
-    output.print('}')
-
-def _print_children(children, output):
-    for child in children:
-        if is_node_type(child, AST_JSXText):
-            text = _process_jsx_text(child.value)
-            if text:
-                output.print(', ')
-                output.print_string(text)
-        elif is_node_type(child, AST_JSXExprContainer):
-            output.print(', ')
-            child.expression.print(output)
-        else:
-            output.print(', ')
-            child.print(output)
-
-def print_jsx_element(self, output):
-    output.print('React.createElement(')
-    _print_tag(self.tag, output)
-    output.print(', ')
-    _print_props(self.props, output)
-    if not self.self_closing:
-        _print_children(self.children, output)
-    output.print(')')
-
-def print_jsx_fragment(self, output):
-    output.print('React.createElement(React.Fragment, null')
-    _print_children(self.children, output)
-    output.print(')')
-
-def print_jsx_attribute(self, output):
-    # Handled directly by _print_props; kept for completeness
-    if _needs_quoting(self.name):
-        output.print('"')
-        output.print(self.name)
-        output.print('"')
-    else:
-        output.print(self.name)
-    if self.value is not None:
-        output.print(': ')
-        if is_node_type(self.value, AST_String):
-            output.print_string(self.value.value)
-        else:
-            self.value.print(output)
-
-def print_jsx_spread(self, output):
-    # Handled directly by _print_props; kept for completeness
-    output.print('...')
-    self.expression.print(output)
-
-def print_jsx_text(self, output):
-    # Handled directly by _print_children; kept for completeness
-    text = _process_jsx_text(self.value)
-    if text:
-        output.print_string(text)
-
-def print_jsx_expr_container(self, output):
-    # Handled directly by _print_children; kept for completeness
-    self.expression.print(output)
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+from __python__ import hash_literals
+
+from ast import AST_String, AST_JSXText, AST_JSXSpread, AST_JSXExprContainer, is_node_type
+
+def _is_component_tag(tag):
+    # Components start with uppercase or use dot notation (e.g. Router.Route)
+    first = tag[0]
+    return (first >= 'A' and first <= 'Z') or '.' in tag
+
+def _needs_quoting(name):
+    # Attribute names containing non-identifier chars (e.g. aria-label) need quoting
+    return not v'/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)'
+
+def _decode_html_entities(text):
+    # Decode HTML entities in a single pass to avoid double-decoding (e.g. &amp;lt; -> &lt;)
+    return text.replace(/&(?:#x([0-9a-fA-F]+)|#(\d+)|([a-zA-Z]+));/g, def(match, hex, dec, name):
+        if hex:
+            return String.fromCharCode(parseInt(hex, 16))
+        if dec:
+            return String.fromCharCode(parseInt(dec, 10))
+        if name is 'amp':
+            return '&'
+        if name is 'lt':
+            return '<'
+        if name is 'gt':
+            return '>'
+        if name is 'quot':
+            return '"'
+        if name is 'apos':
+            return "'"
+        if name is 'nbsp':
+            return '\u00a0'
+        return match
+    )
+
+def _normalize_jsx_whitespace(text):
+    # Implements the Babel JSX whitespace algorithm:
+    # - Split by newlines; trim leading whitespace from all lines except the first,
+    #   trailing whitespace from all lines except the last.
+    # - Lines that are empty after trimming are dropped.
+    # - Remaining non-empty lines are joined; each line except the last non-empty
+    #   gets a trailing space to separate it from the next.
+    lines = text.split('\n')
+    last_non_empty = -1
+    for i in range(lines.length):
+        if /[^ \t]/.test(lines[i]):
+            last_non_empty = i
+    result = ''
+    for i in range(lines.length):
+        line = lines[i].replace(/\t/g, ' ')
+        is_first = (i is 0)
+        is_last = (i is lines.length - 1)
+        if not is_first:
+            line = line.replace(/^[ ]+/, '')
+        if not is_last:
+            line = line.replace(/[ ]+$/, '')
+        if line:
+            if i is not last_non_empty:
+                line += ' '
+            result += line
+    return result
+
+def _process_jsx_text(text):
+    text = _normalize_jsx_whitespace(text)
+    if text:
+        text = _decode_html_entities(text)
+    return text
+
+def _print_tag(tag, output):
+    if _is_component_tag(tag):
+        output.print(tag)
+    else:
+        output.print('"')
+        output.print(tag)
+        output.print('"')
+
+def _print_props(props, output):
+    if not props or not props.length:
+        output.print('null')
+        return
+    output.print('{')
+    first = True
+    for prop in props:
+        if not first:
+            output.print(', ')
+        first = False
+        if is_node_type(prop, AST_JSXSpread):
+            output.print('...')
+            prop.expression.print(output)
+        else:
+            if _needs_quoting(prop.name):
+                output.print('"')
+                output.print(prop.name)
+                output.print('"')
+            else:
+                output.print(prop.name)
+            output.print(': ')
+            if prop.value is None:
+                output.print('true')
+            elif is_node_type(prop.value, AST_String):
+                output.print_string(prop.value.value)
+            else:
+                prop.value.print(output)
+    output.print('}')
+
+def _print_children(children, output):
+    for child in children:
+        if is_node_type(child, AST_JSXText):
+            text = _process_jsx_text(child.value)
+            if text:
+                output.print(', ')
+                output.print_string(text)
+        elif is_node_type(child, AST_JSXExprContainer):
+            output.print(', ')
+            child.expression.print(output)
+        else:
+            output.print(', ')
+            child.print(output)
+
+def print_jsx_element(self, output):
+    output.print('React.createElement(')
+    _print_tag(self.tag, output)
+    output.print(', ')
+    _print_props(self.props, output)
+    if not self.self_closing:
+        _print_children(self.children, output)
+    output.print(')')
+
+def print_jsx_fragment(self, output):
+    output.print('React.createElement(React.Fragment, null')
+    _print_children(self.children, output)
+    output.print(')')
+
+def print_jsx_attribute(self, output):
+    # Handled directly by _print_props; kept for completeness
+    if _needs_quoting(self.name):
+        output.print('"')
+        output.print(self.name)
+        output.print('"')
+    else:
+        output.print(self.name)
+    if self.value is not None:
+        output.print(': ')
+        if is_node_type(self.value, AST_String):
+            output.print_string(self.value.value)
+        else:
+            self.value.print(output)
+
+def print_jsx_spread(self, output):
+    # Handled directly by _print_props; kept for completeness
+    output.print('...')
+    self.expression.print(output)
+
+def print_jsx_text(self, output):
+    # Handled directly by _print_children; kept for completeness
+    text = _process_jsx_text(self.value)
+    if text:
+        output.print_string(text)
+
+def print_jsx_expr_container(self, output):
+    # Handled directly by _print_children; kept for completeness
+    self.expression.print(output)

package/src/output/loops.pyj

@@ -456,10 +456,13 @@ def print_list_comprehension(self, output):
                 body_out.print(result_obj)
             # Locally scope all loop variables (outer and inner clauses)
             def decl_loop_vars(init_node):
+                # Recursively declare all leaf variable names from nested tuples/seqs
                 if is_node_type(init_node, AST_Array):
                     for i in init_node.elements:
-                        body_out.comma()
-                        i.print(body_out)
+                        decl_loop_vars(i)
+                elif is_node_type(init_node, AST_Seq):
+                    for i in init_node.to_array():
+                        decl_loop_vars(i)
                 else:
                     body_out.comma()
                     init_node.print(body_out)

package/src/output/operators.pyj

@@ -43,7 +43,7 @@ def print_getitem(self, output):  # AST_Sub
         expr.print(output)
         output.print('['), prop.print(output), output.print(']')
         return
-    is_negative_number = is_node_type(prop, AST_Unary) and prop.operator is "-" and is_node_type(prop.expression, AST_Number)
+    is_negative_number = is_node_type(prop, AST_Unary) and prop.operator is "-" and is_node_type(prop.expression, AST_Number) and not prop.overloaded
     is_repeatable = is_node_type(expr, AST_SymbolRef)
     if is_repeatable:
         expr.print(output)
@@ -187,7 +187,7 @@ function_ops = {
     'nin': '!ρσ_in',
 }
 
-# Maps binary operators to their overloading helper function names.
+# Maps binary operators to their overloading helper function names (strict_arithmetic on).
 overloaded_binary_ops = {
     '+':  'ρσ_op_add',
     '-':  'ρσ_op_sub',
@@ -201,9 +201,34 @@ overloaded_binary_ops = {
     '^':  'ρσ_op_xor',
     '<<': 'ρσ_op_lshift',
     '>>': 'ρσ_op_rshift',
+    '<':  'ρσ_op_lt',
+    '>':  'ρσ_op_gt',
+    '<=': 'ρσ_op_le',
+    '>=': 'ρσ_op_ge',
 }
 
-# Maps augmented-assignment operators to their overloading helper names.
+# Maps binary operators to no-strict helpers (overload_operators on, strict_arithmetic off).
+# Operators that never threw TypeError reuse the same helper; others use _ns variants.
+overloaded_binary_ops_ns = {
+    '+':  'ρσ_op_add_ns',
+    '-':  'ρσ_op_sub_ns',
+    '*':  'ρσ_op_mul_ns',
+    '/':  'ρσ_op_truediv_ns',
+    '//': 'ρσ_op_floordiv_ns',
+    '%':  'ρσ_op_mod_ns',
+    '**': 'ρσ_op_pow_ns',
+    '&':  'ρσ_op_and',
+    '|':  'ρσ_op_or',
+    '^':  'ρσ_op_xor',
+    '<<': 'ρσ_op_lshift',
+    '>>': 'ρσ_op_rshift',
+    '<':  'ρσ_op_lt_ns',
+    '>':  'ρσ_op_gt_ns',
+    '<=': 'ρσ_op_le_ns',
+    '>=': 'ρσ_op_ge_ns',
+}
+
+# Maps augmented-assignment operators to their overloading helper names (strict_arithmetic on).
 overloaded_augmented_ops = {
     '+=':  'ρσ_op_iadd',
     '-=':  'ρσ_op_isub',
@@ -219,10 +244,78 @@ overloaded_augmented_ops = {
     '>>=': 'ρσ_op_irshift',
 }
 
+# Maps augmented-assignment operators to no-strict helpers (strict_arithmetic off).
+overloaded_augmented_ops_ns = {
+    '+=':  'ρσ_op_iadd_ns',
+    '-=':  'ρσ_op_isub_ns',
+    '*=':  'ρσ_op_imul_ns',
+    '/=':  'ρσ_op_itruediv_ns',
+    '//=': 'ρσ_op_ifloordiv_ns',
+    '%=':  'ρσ_op_imod_ns',
+    '**=': 'ρσ_op_ipow_ns',
+    '&=':  'ρσ_op_iand',
+    '|=':  'ρσ_op_ior',
+    '^=':  'ρσ_op_ixor',
+    '<<=': 'ρσ_op_ilshift',
+    '>>=': 'ρσ_op_irshift',
+}
+
 
 def print_binary_op(self, output):
-    if self.overloaded and overloaded_binary_ops[self.operator]:
-        output.print(overloaded_binary_ops[self.operator] + '(')
+    if comparators[self.operator] and is_node_type(self.left, AST_Binary) and comparators[self.left.operator]:
+        # A chained comparison such as a < b < c
+        # With overload_operators: ρσ_op_lt(a, b) && ρσ_op_lt(b, c)
+        # Without:                 a < b && b < c
+        if is_node_type(self.left.right, AST_Symbol):
+            # Middle is a simple variable — no caching needed.
+            # self.left.print recurses into print_binary_op and handles overloaded case.
+            self.left.print(output)
+            leftvar = self.left.right.name
+        else:
+            # Middle is a complex expression — must cache to avoid double evaluation.
+            left_ops_map = overloaded_binary_ops if self.left.strict_arith else overloaded_binary_ops_ns
+            if self.left.overloaded and left_ops_map[self.left.operator]:
+                output.print(left_ops_map[self.left.operator] + '(')
+                self.left.left.print(output)
+                output.comma()
+                output.with_parens(def():
+                    nonlocal leftvar
+                    output.assign("ρσ_cond_temp")
+                    self.left.right.print(output)
+                    leftvar = "ρσ_cond_temp"
+                )
+                output.print(')')
+            else:
+                self.left.left.print(output)
+                output.space()
+                output.print(self.left.operator)
+                output.space()
+                output.with_parens(def():
+                    nonlocal leftvar
+                    output.assign("ρσ_cond_temp")
+                    self.left.right.print(output)
+                    leftvar = "ρσ_cond_temp"
+                )
+        ops_map = overloaded_binary_ops if self.strict_arith else overloaded_binary_ops_ns
+        output.space()
+        output.print("&&")
+        output.space()
+        if self.overloaded and ops_map[self.operator]:
+            output.print(ops_map[self.operator] + '(')
+            output.print(leftvar)
+            output.comma()
+            self.right.print(output)
+            output.print(')')
+        else:
+            output.print(leftvar)
+            output.space()
+            output.print(self.operator)
+            output.space()
+            self.right.print(output)
+        return
+    ops_map = overloaded_binary_ops if self.strict_arith else overloaded_binary_ops_ns
+    if self.overloaded and ops_map[self.operator]:
+        output.print(ops_map[self.operator] + '(')
         self.left.print(output)
         output.comma()
         self.right.print(output)
@@ -235,34 +328,6 @@ def print_binary_op(self, output):
             output.comma()
             self.right.print(output)
         )
-    elif comparators[self.operator] and is_node_type(self.left, AST_Binary) and comparators[self.left.operator]:
-        # A chained comparison such as a < b < c
-        if is_node_type(self.left.right, AST_Symbol):
-            # left side compares against a regular variable,
-            # no caching needed
-            self.left.print(output)
-            leftvar = self.left.right.name
-        else:
-            # some logic is being performed, let's cache it
-            self.left.left.print(output)
-            output.space()
-            output.print(self.left.operator)
-            output.space()
-            output.with_parens(def():
-                nonlocal leftvar
-                output.assign("ρσ_cond_temp")
-                self.left.right.print(output)
-                leftvar = "ρσ_cond_temp"
-            )
-
-        output.space()
-        output.print("&&")
-        output.space()
-        output.print(leftvar)
-        output.space()
-        output.print(self.operator)
-        output.space()
-        self.right.print(output)
     elif self.operator is '//':
         output.print('Math.floor')
         output.with_parens(def():
@@ -400,7 +465,8 @@ def print_assignment(self, output):
 
 def print_assign(self, output):
     if self.overloaded and overloaded_augmented_ops[self.operator]:
-        helper = overloaded_augmented_ops[self.operator]
+        aug_map = overloaded_augmented_ops if self.strict_arith else overloaded_augmented_ops_ns
+        helper = aug_map[self.operator]
         output.assign(self.left)
         output.print(helper + '(')
         self.left.print(output)