rapydscript-ns 0.9.2 → 0.9.3

package/src/output/functions.pyj

@@ -45,11 +45,69 @@ def function_args(argnames, output, strip_first):
 
 def function_preamble(node, output, offset):
     a = node.argnames
-    if a is None or a is undefined or a.is_simple_func:
+    if a is None or a is undefined:
+        return
+    type_enforce = node.type_enforce
+    if a.is_simple_func and not type_enforce:
         return
     # If this function has optional parameters/*args/**kwargs declare it differently
     fname = node.name.name if node.name else anonfunc
     kw = 'arguments[arguments.length-1]'
+
+    # === Type enforcement: max positional-arg count check ===
+    if type_enforce:
+        max_pos = 0
+        for c, arg in enumerate(a):
+            if c >= offset and not arg.kwonly:
+                max_pos += 1
+        if a.is_simple_func:
+            # Simple function: named JS params; arguments.length gives true count
+            if not a.starargs:
+                # Strip a trailing kwargs-marker object so a `*args, **kwargs`
+                # caller does not get blamed for an extra positional argument
+                # (matches the complex-func variant below).
+                output.indent()
+                output.spaced('var', 'ρσ_nargs', '=', 'arguments.length')
+                output.end_statement()
+                output.indent()
+                output.print('if (ρσ_nargs > 0 && arguments[ρσ_nargs-1] !== null && typeof arguments[ρσ_nargs-1] === "object" && arguments[ρσ_nargs-1][ρσ_kwargs_symbol] === true) ρσ_nargs--')
+                output.end_statement()
+                max_msg = fname + '() takes ' + max_pos + ' positional argument' + ('' if max_pos == 1 else 's') + ' but '
+                output.indent()
+                output.print('if (ρσ_nargs > ' + max_pos + ') throw new TypeError(' + JSON.stringify(max_msg) + ' + ρσ_nargs + " were given")')
+                output.end_statement()
+            # Required-arg and type-annotation checks (variables are direct JS params)
+            for c, arg in enumerate(a):
+                if c < offset:
+                    continue
+                if not arg.kwonly:
+                    miss_msg = fname + '() missing required positional argument: \'' + arg.name + '\''
+                    output.indent()
+                    output.print('if (' + arg.name + ' === undefined) throw new TypeError(' + JSON.stringify(miss_msg) + ')')
+                    output.end_statement()
+                if arg.annotation:
+                    annot_name = arg.annotation.name or ''
+                    type_msg = fname + '() argument \'' + arg.name + '\' must be ' + annot_name
+                    output.indent()
+                    output.print('if (' + arg.name + ' !== undefined && !ρσ_instanceof(' + arg.name + ', ')
+                    arg.annotation.print(output)
+                    output.print(')) throw new TypeError(' + JSON.stringify(type_msg) + ')')
+                    output.end_statement()
+            return  # simple func: only enforcement, no complex preamble
+
+        # Complex function: must handle arguments object; strip trailing kwargs marker
+        if not a.starargs:
+            output.indent()
+            output.spaced('var', 'ρσ_nargs', '=', 'arguments.length')
+            output.end_statement()
+            output.indent()
+            output.print('if (ρσ_nargs > 0 && arguments[ρσ_nargs-1] !== null && typeof arguments[ρσ_nargs-1] === "object" && arguments[ρσ_nargs-1][ρσ_kwargs_symbol] === true) ρσ_nargs--')
+            output.end_statement()
+            max_msg = fname + '() takes ' + max_pos + ' positional argument' + ('' if max_pos == 1 else 's') + ' but '
+            output.indent()
+            output.print('if (ρσ_nargs > ' + max_pos + ') throw new TypeError(' + JSON.stringify(max_msg) + ' + ρσ_nargs + " were given")')
+            output.end_statement()
+
     # Define all formal parameters
     positional_count = 0
     for c, arg in enumerate(a):
@@ -89,6 +147,22 @@ def function_preamble(node, output, offset):
         output.indent()
         output.spaced('if', '(' + kw, '===', 'null', '||', 'typeof', kw, '!==', '"object"', '||', kw, '[ρσ_kwargs_symbol]', '!==', 'true)', kw, '=', '{}')
         output.end_statement()
+        # === Type enforcement: positional-only args must not appear in kwargs ===
+        if type_enforce:
+            posonly_count = a.posonly_count or 0
+            for pi in range(posonly_count):
+                if pi < offset:
+                    continue
+                parg = a[pi]
+                posonly_msg = fname + '() got some positional-only arguments passed as keyword arguments: \'' + parg.name + '\''
+                output.indent()
+                output.spaced('if', '(Object.prototype.hasOwnProperty.call(' + kw + ',', '"' + parg.name + '"))')
+                output.with_block(def():
+                    output.indent()
+                    output.print('throw new TypeError(' + JSON.stringify(posonly_msg) + ')')
+                    output.end_statement()
+                )
+                output.newline()
         # Read values from the kwargs object for non-positional-only formal parameters with defaults
         if a.has_defaults:
             for dname in Object.keys(a.defaults):
@@ -138,6 +212,29 @@ def function_preamble(node, output, offset):
                         output.end_statement()
                 )
                 output.newline()
+    elif type_enforce and (a.posonly_count or 0) > 0:
+        # No kwargs block, but function has positional-only params.
+        # A caller using foo(posonly_name=val) still passes a kwargs object as the
+        # last argument; detect and reject it here.
+        posonly_count = a.posonly_count or 0
+        posonly_names = []
+        for pi in range(posonly_count):
+            if pi >= offset:
+                posonly_names.push(a[pi].name)
+        if posonly_names.length > 0:
+            output.indent()
+            output.spaced('var', 'ρσ_kw_chk', '=', 'arguments[arguments.length-1]')
+            output.end_statement()
+            output.indent()
+            output.spaced('if', '(ρσ_kw_chk !== null && typeof ρσ_kw_chk === "object" && ρσ_kw_chk[ρσ_kwargs_symbol] === true)')
+            output.with_block(def():
+                for pname in posonly_names:
+                    posonly_msg = fname + '() got some positional-only arguments passed as keyword arguments: \'' + pname + '\''
+                    output.indent()
+                    output.print('if (Object.prototype.hasOwnProperty.call(ρσ_kw_chk, "' + pname + '")) throw new TypeError(' + JSON.stringify(posonly_msg) + ')')
+                    output.end_statement()
+            )
+            output.newline()
 
     if a.starargs is not undefined:
         # Define the *args parameter, putting in whatever is left after assigning the formal parameters and the options object
@@ -160,6 +257,44 @@ def function_preamble(node, output, offset):
         output.spaced(kw, '=', 'ρσ_kwargs_to_dict(' + kw + ')')
         output.end_statement()
 
+    # === Type enforcement: required-arg, required-kwonly, and type-annotation checks ===
+    # These run after all variable resolution (kwargs reading, starargs setup, dict conversion)
+    # so each variable holds its final value when checked.
+    if type_enforce:
+        # Required positional args (no default, not kwonly)
+        for c, arg in enumerate(a):
+            if c < offset:
+                continue
+            if arg.kwonly:
+                continue
+            if not Object.prototype.hasOwnProperty.call(a.defaults, arg.name):
+                miss_msg = fname + '() missing required positional argument: \'' + arg.name + '\''
+                output.indent()
+                output.print('if (' + arg.name + ' === undefined) throw new TypeError(' + JSON.stringify(miss_msg) + ')')
+                output.end_statement()
+        # Required keyword-only args (no default)
+        for c, arg in enumerate(a):
+            if not arg.kwonly:
+                continue
+            if not Object.prototype.hasOwnProperty.call(a.defaults, arg.name):
+                miss_kw = fname + '() missing required keyword-only argument: \'' + arg.name + '\''
+                output.indent()
+                output.print('if (' + arg.name + ' === undefined) throw new TypeError(' + JSON.stringify(miss_kw) + ')')
+                output.end_statement()
+        # Type annotation checks (skip *args and **kwargs)
+        for c, arg in enumerate(a):
+            if c < offset:
+                continue
+            if not arg.annotation:
+                continue
+            annot_name = arg.annotation.name or ''
+            type_msg = fname + '() argument \'' + arg.name + '\' must be ' + annot_name
+            output.indent()
+            output.print('if (' + arg.name + ' !== undefined && !ρσ_instanceof(' + arg.name + ', ')
+            arg.annotation.print(output)
+            output.print(')) throw new TypeError(' + JSON.stringify(type_msg) + ')')
+            output.end_statement()
+
 def has_annotations(self):
     if self.return_annotation:
         return True
@@ -169,8 +304,6 @@ def has_annotations(self):
     return False
 
 def function_annotation(self, output, strip_first, name):
-    if output.options.omit_function_metadata:
-        return
     fname = name or (self.name.name if self.name else anonfunc)
     props = Object.create(None)
 
@@ -263,27 +396,37 @@ 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:
+    # Async generators (async def with yield) are emitted as a sync wrapper that
+    # returns the async iterator directly (matching Python semantics, where calling
+    # an async generator function returns the iterator immediately without await).
+    # The inner js_generator is `async function*`. The outer wrapper is sync.
+    if self.is_async and not self.is_generator:
         output.print("async"), output.space()
     output.print("function"), output.space()
     if self.name:
         self.name.print(output)
 
     if self.is_generator:
+        inner_decl = 'async function* js_generator' if self.is_async else 'function* js_generator'
         output.print('()'), output.space()
         output.with_block(def():
             output.indent()
-            output.print('function* js_generator')
+            output.print(inner_decl)
             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)')
             output.end_statement()
-            # Python's generator objects use a separate method to send data to the generator
+            # Python's generator objects use a separate method to send data to the generator.
+            # For async generators, asend() is the async equivalent — alias it to next as well.
             output.indent()
             output.spaced('result.send', '=', 'result.next')
             output.end_statement()
+            if self.is_async:
+                output.indent()
+                output.spaced('result.asend', '=', 'result.next')
+                output.end_statement()
             output.indent()
             output.spaced('return', 'result')
             output.end_statement()
@@ -443,12 +586,15 @@ def print_function_call(self, output):
             )
         elif is_node_type(self.expression, AST_SymbolRef) and self.expression.name is 'print':
             # Bare print(...) → console.log(...) to avoid clobbering window.print
+            # Wrap each arg in ρσ_str() so type() and other objects display like Python
             output.print('console.log')
             output.with_parens(def():
                 for i, a in enumerate(self.args):
                     if i:
                         output.comma()
+                    output.print('ρσ_str(')
                     a.print(output)
+                    output.print(')')
             )
         elif (is_node_type(self.expression, AST_SymbolRef) and
               self.expression.name is 'vars' and self.args.length is 0):

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

@@ -119,7 +119,10 @@ 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:
+            # `async for` always emits ES6+ `for await ... of` syntax (regardless
+            # of js_version), so the loop variable holds the value directly —
+            # not an integer index into an array.
+            if output.options.js_version is 5 and not self.is_async:
                 itervar = "ρσ_Iter" + output.index_counter + "[ρσ_Index" + output.index_counter + "]"
             else:
                 itervar = "ρσ_Index" + output.index_counter
@@ -237,7 +240,19 @@ def print_for_in(self, output):
         )
     else:
         # regular loop
-        if output.options.js_version is 5:
+        if self.is_async:
+            # async for: emit native `for await ... of` regardless of js_version.
+            # Async iteration is an ES2018 feature; if the user wrote `async for`
+            # they have already opted into a modern runtime. The ρσ_Iterable
+            # bridge is skipped because async iterators don't expose .length
+            # or Map keys — the JS engine handles Symbol.asyncIterator natively.
+            itervar = "ρσ_Iter" + output.index_counter
+            output.assign("var " + itervar)
+            write_object()
+            output.end_statement()
+            output.indent()
+            output.spaced('for', 'await', '(var', 'ρσ_Index' + output.index_counter, 'of', itervar + ')')
+        elif output.options.js_version is 5:
             output.assign("var ρσ_Iter" + output.index_counter)
             output.print("ρσ_Iterable")
             output.with_parens(write_object)

package/src/output/modules.pyj

@@ -94,7 +94,7 @@ def declare_exports(module_id, exports, output, docstrings):
 def _inject_pythonize_strings(output):
     str_funcs = ('capitalize strip lstrip rstrip islower isupper isspace lower upper swapcase title'
         ' center count endswith startswith find rfind index rindex format join ljust rjust'
-        ' partition rpartition splitlines zfill').split(' ')
+        ' partition rpartition replace splitlines zfill').split(' ')
     output.newline()
     output.indent()
     output.print('(function(){var _f=' + JSON.stringify(str_funcs) + ';for(var _i=0;_i<_f.length;_i++)String.prototype[_f[_i]]=\u03c1\u03c3_str.prototype[_f[_i]];})()')

package/src/output/operators.pyj

@@ -321,6 +321,13 @@ def print_binary_op(self, output):
         self.right.print(output)
         output.print(')')
         return
+    if self.operator is '%' and self.python_mod:
+        output.print('ρσ_op_mod_ns(')
+        self.left.print(output)
+        output.comma()
+        self.right.print(output)
+        output.print(')')
+        return
     if function_ops[self.operator]:
         output.print(function_ops[self.operator])
         output.with_parens(def():
@@ -485,6 +492,14 @@ def print_assign(self, output):
             self.right.print(output)
         )
         return
+    if self.operator is '%=' and self.python_mod:
+        output.assign(self.left)
+        output.print('ρσ_op_mod_ns(')
+        self.left.print(output)
+        output.comma()
+        self.right.print(output)
+        output.print(')')
+        return
     if self.operator is '**=':
         output.assign(self.left)
         if output.options.js_version > 6:

package/src/output/stream.pyj

@@ -54,7 +54,6 @@ output_stream_defaults = {
     'module_cache_dir': '',
     'js_version':5,
     'write_name': True,
-    'omit_function_metadata': False,
     'pythonize_strings': False,
     'repl_mode': False,
 }