rapydscript-ns 0.9.2 → 0.9.3

package/src/output/treeshake.pyj

@@ -1,182 +1,182 @@
-# vim:fileencoding=utf-8
-# License: BSD
-from __python__ import hash_literals
-
-from ast import (
-    AST_Function, AST_Class, AST_SimpleStatement, AST_Assign,
-    AST_SymbolRef, AST_Dot, AST_Sub, AST_Imports, TreeWalker, is_node_type
-)
-from utils import has_prop
-
-
-def get_top_level_name(stmt):
-    if is_node_type(stmt, AST_Function) or is_node_type(stmt, AST_Class):
-        if stmt.name:
-            return stmt.name.name
-        return None
-    if is_node_type(stmt, AST_SimpleStatement):
-        body = stmt.body
-        if is_node_type(body, AST_Assign):
-            lhs = body.left
-            if is_node_type(lhs, AST_SymbolRef):
-                return lhs.name
-    return None
-
-
-def collect_refs_in_node(stmt, top_level_set, refs):
-    def visit_fn(node, descend):
-        if is_node_type(node, AST_SymbolRef):
-            if has_prop(top_level_set, node.name):
-                refs[node.name] = True
-    stmt.walk(TreeWalker(visit_fn))
-
-
-def compute_transitive_closure(body, direct_names, nonlocalvars):
-    nonlocal_set = {}
-    if nonlocalvars:
-        for nv in nonlocalvars:
-            nonlocal_set[nv] = True
-
-    name_map = {}
-    unnamed_stmts = []
-    for stmt in body:
-        name = get_top_level_name(stmt)
-        if name is not None:
-            name_map[name] = stmt
-        else:
-            unnamed_stmts.push(stmt)
-
-    top_level_set = {}
-    for name in Object.keys(name_map):
-        top_level_set[name] = True
-
-    needed = {}
-    queue = []
-
-    # Always include top-level assignments to nonlocal vars — they affect the
-    # global JavaScript scope and must never be filtered out.
-    for name in Object.keys(name_map):
-        if has_prop(nonlocal_set, name):
-            needed[name] = True
-            queue.push(name)
-
-    # Add directly imported names
-    for name in Object.keys(direct_names):
-        if not has_prop(needed, name):
-            needed[name] = True
-            queue.push(name)
-
-    # Unnamed statements (imports, if-blocks, bare expressions) are always
-    # included in output, so their references to named top-level items must
-    # also be included transitively.
-    always_refs = {}
-    for stmt in unnamed_stmts:
-        collect_refs_in_node(stmt, top_level_set, always_refs)
-    for ref_name in Object.keys(always_refs):
-        if not has_prop(needed, ref_name):
-            needed[ref_name] = True
-            queue.push(ref_name)
-
-    while queue.length > 0:
-        current = queue.shift()
-        if not has_prop(name_map, current):
-            continue
-        refs = {}
-        collect_refs_in_node(name_map[current], top_level_set, refs)
-        for ref_name in Object.keys(refs):
-            if not has_prop(needed, ref_name):
-                needed[ref_name] = True
-                queue.push(ref_name)
-
-    return needed
-
-
-def check_module_attr_access(main_body, info, alias_set):
-    def visit_fn(node, descend):
-        if is_node_type(node, AST_Dot):
-            expr = node.expression
-            if is_node_type(expr, AST_SymbolRef) and has_prop(alias_set, expr.name):
-                info.direct_names[node.property] = True
-                return True
-        if is_node_type(node, AST_Sub):
-            expr = node.expression
-            if is_node_type(expr, AST_SymbolRef) and has_prop(alias_set, expr.name):
-                info.can_tree_shake = False
-    for stmt in main_body:
-        stmt.walk(TreeWalker(visit_fn))
-
-
-def analyze_imports(main_body):
-    result = {}
-
-    # First pass: walk the entire AST recursively to collect all from-imports
-    # (including those nested inside functions or other scopes).
-    def visit_from_imports(node, descend):
-        if is_node_type(node, AST_Imports):
-            for imp in node.imports:
-                if imp.argnames:
-                    key = imp.key
-                    if not has_prop(result, key):
-                        result[key] = {'direct_names': {}, 'can_tree_shake': True}
-                    for argname in imp.argnames:
-                        result[key].direct_names[argname.name] = True
-    for stmt in main_body:
-        stmt.walk(TreeWalker(visit_from_imports))
-
-    # Second pass: handle top-level plain imports (import X as Y, import X).
-    # Attribute tracking via check_module_attr_access applies to main_body scope.
-    for stmt in main_body:
-        if not is_node_type(stmt, AST_Imports):
-            continue
-        for imp in stmt.imports:
-            if imp.argnames:
-                continue  # already handled in first pass
-            key = imp.key
-            if not has_prop(result, key):
-                result[key] = {'direct_names': {}, 'can_tree_shake': True}
-            info = result[key]
-            if imp.alias:
-                alias_set = {}
-                alias_set[imp.alias.name] = True
-                check_module_attr_access(main_body, info, alias_set)
-            else:
-                parts = key.split('.')
-                if parts.length > 1:
-                    # import X.Y with no alias: user accesses via X.Y.attr which
-                    # requires two-level dot traversal — disable tree-shaking safely
-                    info.can_tree_shake = False
-                else:
-                    alias_set = {}
-                    alias_set[parts[0]] = True
-                    check_module_attr_access(main_body, info, alias_set)
-
-    return result
-
-
-def tree_shake(ast, context):
-    import_infos = analyze_imports(ast.body)
-    for mod_key in Object.keys(import_infos):
-        info = import_infos[mod_key]
-        if not info.can_tree_shake:
-            continue
-        if not has_prop(ast.imports, mod_key):
-            continue
-        mod = ast.imports[mod_key]
-        # If body is missing (cached module), re-parse to get it
-        if not mod.body and mod.src_code:
-            parsed = context.parse(mod.src_code, {
-                'filename': mod.filename,
-                'module_id': mod_key,
-                'libdir': context.libdir,
-                'import_dirs': context.import_dirs or [],
-                'discard_asserts': context.discard_asserts,
-                'for_linting': True,
-            })
-            mod.body = parsed.body
-            mod.localvars = parsed.localvars
-            if not mod.nonlocalvars:
-                mod.nonlocalvars = parsed.nonlocalvars
-        if not mod.body:
-            continue
-        needed = compute_transitive_closure(mod.body, info.direct_names, mod.nonlocalvars)
-        mod.needed_names = needed
+# vim:fileencoding=utf-8
+# License: BSD
+from __python__ import hash_literals
+
+from ast import (
+    AST_Function, AST_Class, AST_SimpleStatement, AST_Assign,
+    AST_SymbolRef, AST_Dot, AST_Sub, AST_Imports, TreeWalker, is_node_type
+)
+from utils import has_prop
+
+
+def get_top_level_name(stmt):
+    if is_node_type(stmt, AST_Function) or is_node_type(stmt, AST_Class):
+        if stmt.name:
+            return stmt.name.name
+        return None
+    if is_node_type(stmt, AST_SimpleStatement):
+        body = stmt.body
+        if is_node_type(body, AST_Assign):
+            lhs = body.left
+            if is_node_type(lhs, AST_SymbolRef):
+                return lhs.name
+    return None
+
+
+def collect_refs_in_node(stmt, top_level_set, refs):
+    def visit_fn(node, descend):
+        if is_node_type(node, AST_SymbolRef):
+            if has_prop(top_level_set, node.name):
+                refs[node.name] = True
+    stmt.walk(TreeWalker(visit_fn))
+
+
+def compute_transitive_closure(body, direct_names, nonlocalvars):
+    nonlocal_set = {}
+    if nonlocalvars:
+        for nv in nonlocalvars:
+            nonlocal_set[nv] = True
+
+    name_map = {}
+    unnamed_stmts = []
+    for stmt in body:
+        name = get_top_level_name(stmt)
+        if name is not None:
+            name_map[name] = stmt
+        else:
+            unnamed_stmts.push(stmt)
+
+    top_level_set = {}
+    for name in Object.keys(name_map):
+        top_level_set[name] = True
+
+    needed = {}
+    queue = []
+
+    # Always include top-level assignments to nonlocal vars — they affect the
+    # global JavaScript scope and must never be filtered out.
+    for name in Object.keys(name_map):
+        if has_prop(nonlocal_set, name):
+            needed[name] = True
+            queue.push(name)
+
+    # Add directly imported names
+    for name in Object.keys(direct_names):
+        if not has_prop(needed, name):
+            needed[name] = True
+            queue.push(name)
+
+    # Unnamed statements (imports, if-blocks, bare expressions) are always
+    # included in output, so their references to named top-level items must
+    # also be included transitively.
+    always_refs = {}
+    for stmt in unnamed_stmts:
+        collect_refs_in_node(stmt, top_level_set, always_refs)
+    for ref_name in Object.keys(always_refs):
+        if not has_prop(needed, ref_name):
+            needed[ref_name] = True
+            queue.push(ref_name)
+
+    while queue.length > 0:
+        current = queue.shift()
+        if not has_prop(name_map, current):
+            continue
+        refs = {}
+        collect_refs_in_node(name_map[current], top_level_set, refs)
+        for ref_name in Object.keys(refs):
+            if not has_prop(needed, ref_name):
+                needed[ref_name] = True
+                queue.push(ref_name)
+
+    return needed
+
+
+def check_module_attr_access(main_body, info, alias_set):
+    def visit_fn(node, descend):
+        if is_node_type(node, AST_Dot):
+            expr = node.expression
+            if is_node_type(expr, AST_SymbolRef) and has_prop(alias_set, expr.name):
+                info.direct_names[node.property] = True
+                return True
+        if is_node_type(node, AST_Sub):
+            expr = node.expression
+            if is_node_type(expr, AST_SymbolRef) and has_prop(alias_set, expr.name):
+                info.can_tree_shake = False
+    for stmt in main_body:
+        stmt.walk(TreeWalker(visit_fn))
+
+
+def analyze_imports(main_body):
+    result = {}
+
+    # First pass: walk the entire AST recursively to collect all from-imports
+    # (including those nested inside functions or other scopes).
+    def visit_from_imports(node, descend):
+        if is_node_type(node, AST_Imports):
+            for imp in node.imports:
+                if imp.argnames:
+                    key = imp.key
+                    if not has_prop(result, key):
+                        result[key] = {'direct_names': {}, 'can_tree_shake': True}
+                    for argname in imp.argnames:
+                        result[key].direct_names[argname.name] = True
+    for stmt in main_body:
+        stmt.walk(TreeWalker(visit_from_imports))
+
+    # Second pass: handle top-level plain imports (import X as Y, import X).
+    # Attribute tracking via check_module_attr_access applies to main_body scope.
+    for stmt in main_body:
+        if not is_node_type(stmt, AST_Imports):
+            continue
+        for imp in stmt.imports:
+            if imp.argnames:
+                continue  # already handled in first pass
+            key = imp.key
+            if not has_prop(result, key):
+                result[key] = {'direct_names': {}, 'can_tree_shake': True}
+            info = result[key]
+            if imp.alias:
+                alias_set = {}
+                alias_set[imp.alias.name] = True
+                check_module_attr_access(main_body, info, alias_set)
+            else:
+                parts = key.split('.')
+                if parts.length > 1:
+                    # import X.Y with no alias: user accesses via X.Y.attr which
+                    # requires two-level dot traversal — disable tree-shaking safely
+                    info.can_tree_shake = False
+                else:
+                    alias_set = {}
+                    alias_set[parts[0]] = True
+                    check_module_attr_access(main_body, info, alias_set)
+
+    return result
+
+
+def tree_shake(ast, context):
+    import_infos = analyze_imports(ast.body)
+    for mod_key in Object.keys(import_infos):
+        info = import_infos[mod_key]
+        if not info.can_tree_shake:
+            continue
+        if not has_prop(ast.imports, mod_key):
+            continue
+        mod = ast.imports[mod_key]
+        # If body is missing (cached module), re-parse to get it
+        if not mod.body and mod.src_code:
+            parsed = context.parse(mod.src_code, {
+                'filename': mod.filename,
+                'module_id': mod_key,
+                'libdir': context.libdir,
+                'import_dirs': context.import_dirs or [],
+                'discard_asserts': context.discard_asserts,
+                'for_linting': True,
+            })
+            mod.body = parsed.body
+            mod.localvars = parsed.localvars
+            if not mod.nonlocalvars:
+                mod.nonlocalvars = parsed.nonlocalvars
+        if not mod.body:
+            continue
+        needed = compute_transitive_closure(mod.body, info.direct_names, mod.nonlocalvars)
+        mod.needed_names = needed

package/src/output/utils.pyj

@@ -1,72 +1,72 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-from __python__ import hash_literals
-
-from ast import AST_BlockStatement, is_node_type
-
-def best_of(a):
-    best = a[0]
-    len_ = best.length
-    for i in range(1, a.length):
-        if a[i].length < len_:
-            best = a[i]
-            len_ = best.length
-    return best
-
-def make_num(num):
-    str_ = num.toString(10)
-    a = [ str_.replace(/^0\./, ".").replace("e+", "e") ]
-    m = None
-
-    if Math.floor(num) is num:
-        if num >= 0:
-            a.push("0x" + num.toString(16).toLowerCase(), # probably pointless
-            "0" + num.toString(8))
-        else:
-            a.push("-0x" + (-num).toString(16).toLowerCase(), # probably pointless
-            "-0" + (-num).toString(8))
-
-        if m = /^(.*?)(0+)$/.exec(num):
-            a.push(m[1] + "e" + m[2].length)
-
-    elif m = /^0?\.(0+)(.*)$/.exec(num):
-        a.push(m[2] + "e-" + (m[1].length + m[2].length), str_.substr(str_.indexOf(".")))
-
-    return best_of(a)
-
-def make_block(stmt, output):
-    if is_node_type(stmt, AST_BlockStatement):
-        stmt.print(output)
-        return
-
-    output.with_block(def():
-        output.indent()
-        stmt.print(output)
-        output.newline()
-    )
-
-def create_doctring(docstrings):
-    ans = v'[]'
-    for ds in docstrings:
-        ds = str.rstrip(ds.value)
-        lines = v'[]'
-        min_leading_whitespace = ''
-        for line in ds.split(/$/gm):
-            r = /^\s+/.exec(line)
-            leading_whitespace = ''
-            if r:
-                leading_whitespace = r[0].replace(/[\n\r]/g, '') if r else ''
-                line = line[r[0].length:]
-            if not str.strip(line):
-                lines.push(v'["", ""]')
-            else:
-                leading_whitespace = leading_whitespace.replace(/\t/g, '    ')
-                if leading_whitespace and (not min_leading_whitespace or leading_whitespace.length < min_leading_whitespace.length):
-                    min_leading_whitespace = leading_whitespace
-                lines.push(v'[leading_whitespace, line]')
-        for lw, l in lines:
-            if min_leading_whitespace:
-                lw = lw[min_leading_whitespace.length:]
-            ans.push(lw + l)
-        ans.push('')
-    return str.rstrip(ans.join('\n'))
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+from __python__ import hash_literals
+
+from ast import AST_BlockStatement, is_node_type
+
+def best_of(a):
+    best = a[0]
+    len_ = best.length
+    for i in range(1, a.length):
+        if a[i].length < len_:
+            best = a[i]
+            len_ = best.length
+    return best
+
+def make_num(num):
+    str_ = num.toString(10)
+    a = [ str_.replace(/^0\./, ".").replace("e+", "e") ]
+    m = None
+
+    if Math.floor(num) is num:
+        if num >= 0:
+            a.push("0x" + num.toString(16).toLowerCase(), # probably pointless
+            "0" + num.toString(8))
+        else:
+            a.push("-0x" + (-num).toString(16).toLowerCase(), # probably pointless
+            "-0" + (-num).toString(8))
+
+        if m = /^(.*?)(0+)$/.exec(num):
+            a.push(m[1] + "e" + m[2].length)
+
+    elif m = /^0?\.(0+)(.*)$/.exec(num):
+        a.push(m[2] + "e-" + (m[1].length + m[2].length), str_.substr(str_.indexOf(".")))
+
+    return best_of(a)
+
+def make_block(stmt, output):
+    if is_node_type(stmt, AST_BlockStatement):
+        stmt.print(output)
+        return
+
+    output.with_block(def():
+        output.indent()
+        stmt.print(output)
+        output.newline()
+    )
+
+def create_doctring(docstrings):
+    ans = v'[]'
+    for ds in docstrings:
+        ds = str.rstrip(ds.value)
+        lines = v'[]'
+        min_leading_whitespace = ''
+        for line in ds.split(/$/gm):
+            r = /^\s+/.exec(line)
+            leading_whitespace = ''
+            if r:
+                leading_whitespace = r[0].replace(/[\n\r]/g, '') if r else ''
+                line = line[r[0].length:]
+            if not str.strip(line):
+                lines.push(v'["", ""]')
+            else:
+                leading_whitespace = leading_whitespace.replace(/\t/g, '    ')
+                if leading_whitespace and (not min_leading_whitespace or leading_whitespace.length < min_leading_whitespace.length):
+                    min_leading_whitespace = leading_whitespace
+                lines.push(v'[leading_whitespace, line]')
+        for lw, l in lines:
+            if min_leading_whitespace:
+                lw = lw[min_leading_whitespace.length:]
+            ans.push(lw + l)
+        ans.push('')
+    return str.rstrip(ans.join('\n'))

package/src/parse.pyj

@@ -31,7 +31,7 @@ TreeWalker
 from tokenizer import tokenizer, is_token, RESERVED_WORDS
 
 COMPILER_VERSION = '__COMPILER_VERSION__'
-PYTHON_FLAGS = {'dict_literals':True, 'overload_getitem':True, 'bound_methods':True, 'hash_literals':True, 'overload_operators':True, 'truthiness':True, 'jsx':True, 'strict_arithmetic':True}
+PYTHON_FLAGS = {'dict_literals':True, 'overload_getitem':True, 'bound_methods':True, 'hash_literals':True, 'overload_operators':True, 'truthiness':True, 'jsx':True, 'strict_arithmetic':True, 'python_modulo':True, 'type_enforcement':True}
 
 
 def get_compiler_version():
@@ -620,8 +620,15 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     })
             elif tmp_ is "async":
                 start = prev()
+                if is_("keyword", "for"):
+                    # async for: consume an async iterable using JS `for await ... of`
+                    next()
+                    forstmt = for_()
+                    forstmt.is_async = True
+                    forstmt.start = start
+                    return forstmt
                 if not is_("keyword", "def"):
-                    croak("Expected 'def' after 'async'")
+                    croak("Expected 'def' or 'for' after 'async'")
                 next()
                 func = function_(S.in_class[-1], False, True)
                 func.start = start
@@ -708,21 +715,70 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
     def with_():
         clauses = v'[]'
         start = S.token
-        while True:
-            if is_('eof'):
-                unexpected()
-            expr = expression()
-            alias = None
-            if is_('keyword', 'as'):
-                next()
-                alias = as_symbol(AST_SymbolAlias)
-            clauses.push(new AST_WithClause({'expression':expr, 'alias':alias}))
-            if is_('punc', ','):
-                next()
-                continue
-            if not is_('punc', ':'):
-                unexpected()
-            break
+
+        # Detect Python 3.10+ parenthesized form: with (cm1 as a, cm2 as b):
+        # vs traditional: with cm as a:  or  with (expr) as a:
+        # Lookahead: scan tokens inside the `(` for an `as` keyword at depth 0
+        # before the matching `)`. If found, it's the parenthesized form.
+        is_parenthesized_with = False
+        if is_('punc', '('):
+            depth = 0
+            i = 0
+            while True:
+                while S.peeked.length <= i:
+                    S.peeked.push(S.input())
+                tok = S.peeked[i]
+                if tok.type is 'eof':
+                    break
+                if tok.type is 'punc':
+                    if tok.value is '(' or tok.value is '[' or tok.value is '{':
+                        depth += 1
+                    elif tok.value is ')' or tok.value is ']' or tok.value is '}':
+                        if depth is 0:
+                            break
+                        depth -= 1
+                elif tok.type is 'keyword' and tok.value is 'as' and depth is 0:
+                    is_parenthesized_with = True
+                    break
+                i += 1
+
+        if is_parenthesized_with:
+            next()  # consume `(`
+            while True:
+                if is_('eof'):
+                    unexpected()
+                if is_('punc', ')'):
+                    next()  # trailing comma before closing `)`
+                    break
+                expr = expression()
+                alias = None
+                if is_('keyword', 'as'):
+                    next()
+                    alias = as_symbol(AST_SymbolAlias)
+                clauses.push(new AST_WithClause({'expression': expr, 'alias': alias}))
+                if is_('punc', ','):
+                    next()
+                    continue
+                if not is_('punc', ')'):
+                    unexpected()
+                next()  # consume `)`
+                break
+        else:
+            while True:
+                if is_('eof'):
+                    unexpected()
+                expr = expression()
+                alias = None
+                if is_('keyword', 'as'):
+                    next()
+                    alias = as_symbol(AST_SymbolAlias)
+                clauses.push(new AST_WithClause({'expression':expr, 'alias':alias}))
+                if is_('punc', ','):
+                    next()
+                    continue
+                if not is_('punc', ':'):
+                    unexpected()
+                break
 
         if not clauses.length:
             token_error(start, 'with statement must have at least one clause')
@@ -1396,6 +1452,9 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                     argnames.push(aname)
                     if is_('punc', ','):
                         next()
+                        if bracketed and is_('punc', ')'):
+                            next()
+                            break
                     else:
                         if bracketed:
                             if is_('punc', ')'):
@@ -1824,6 +1883,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             )(S.in_loop, S.labels)
         })
         definition.return_annotation = return_annotation
+        definition.type_enforce = S.scoped_flags.get('type_enforcement', False)
         definition.is_generator = is_generator[0]
         definition.is_async = is_async
         if is_node_type(definition, AST_Method):
@@ -3242,6 +3302,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 'end': right.end,
                 'overloaded': S.scoped_flags.get('overload_operators', False),
                 'strict_arith': S.scoped_flags.get('overload_operators', False) and S.scoped_flags.get('strict_arithmetic', True),
+                'python_mod': (op is '%') and S.scoped_flags.get('python_modulo', True),
                 'python_truthiness': S.scoped_flags.get('truthiness', False) and (op is '&&' or op is '||')
             })
             return expr_op(ret, min_prec, no_in)
@@ -3324,6 +3385,8 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             if S.scoped_flags.get('overload_operators', False) and val is not '=':
                 asgn.overloaded = True
                 asgn.strict_arith = S.scoped_flags.get('strict_arithmetic', True)
+            if val is '%=':
+                asgn.python_mod = S.scoped_flags.get('python_modulo', True)
             return asgn
         return left