rapydscript-ns 0.9.3 → 0.9.5

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

@@ -6,7 +6,7 @@ from __python__ import hash_literals
 from utils import make_predicate, array_to_hash, defaults, has_prop, cache_file_name
 from errors import SyntaxError, ImportError
 from ast import (
-AST_Array, AST_Assign, AST_Binary, AST_BlockStatement, AST_Break,
+AST_Array, AST_Assign, AST_BigInt, AST_Binary, AST_BlockStatement, AST_Break,
 AST_Call, AST_Catch, AST_Class, AST_ClassCall, AST_Conditional,
 AST_Constant, AST_Continue, AST_DWLoop, AST_Debugger, AST_Decorator,
 AST_Definitions, AST_DictComprehension, AST_Directive, AST_Do, AST_Dot,
@@ -144,7 +144,7 @@ PRECEDENCE = (def(a, ret):
 
 STATEMENTS_WITH_LABELS = array_to_hash([ "for", "do", "while", "switch" ])
 
-ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "imaginary", "string", "bytes_literal", "regexp", "name", "js" ])
+ATOMIC_START_TOKEN = array_to_hash([ "atom", "num", "bigint", "imaginary", "string", "bytes_literal", "regexp", "name", "js" ])
 
 compile_time_decorators = ['staticmethod', 'classmethod', 'external', 'property']
 
@@ -520,7 +520,7 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             return new AST_Directive({
                 'value': tmp_
             })
-        elif tmp_ is "num" or tmp_ is "regexp" or tmp_ is "operator" or tmp_ is "atom" or tmp_ is "js":
+        elif tmp_ is "num" or tmp_ is "bigint" or tmp_ is "regexp" or tmp_ is "operator" or tmp_ is "atom" or tmp_ is "js":
             return simple_statement()
         elif tmp_ is "punc":
             tmp_ = S.token.value
@@ -797,6 +797,8 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             return new AST_String({'start': tok, 'value': tok.value, 'end': tok})
         elif tok.type is 'num':
             return new AST_Number({'start': tok, 'value': tok.value, 'end': tok})
+        elif tok.type is 'bigint':
+            return new AST_BigInt({'start': tok, 'value': tok.value, 'end': tok})
         elif tok.type is 'atom':
             if tok.value is 'True':
                 return new AST_True({'start': tok, 'end': tok})
@@ -810,15 +812,18 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
         """Parse a single atomic/closed pattern (no OR, no AS)."""
         start = S.token
 
-        # Negative number literal: -42
-        if is_('operator', '-') and peek().type is 'num':
+        # Negative number literal: -42 or -42n
+        if is_('operator', '-') and (peek().type is 'num' or peek().type is 'bigint'):
             next()  # consume '-'
-            val = -S.token.value
             tok = S.token
+            if tok.type is 'bigint':
+                val_node = new AST_BigInt({'start': start, 'value': '-' + tok.value, 'end': tok})
+            else:
+                val_node = new AST_Number({'start': start, 'value': -tok.value, 'end': tok})
             next()
             return new AST_MatchLiteral({
                 'start': start,
-                'value': new AST_Number({'start': start, 'value': val, 'end': tok}),
+                'value': val_node,
                 'end': prev()
             })
 
@@ -832,6 +837,16 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 'end': prev()
             })
 
+        # BigInt literal
+        if is_('bigint'):
+            tok = S.token
+            next()
+            return new AST_MatchLiteral({
+                'start': tok,
+                'value': new AST_BigInt({'start': tok, 'value': tok.value, 'end': tok}),
+                'end': prev()
+            })
+
         # String literal
         if is_('string'):
             tok = S.token
@@ -1607,6 +1622,20 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
             if parent_details and parent_details.has_attr_dunders:
                 definition.has_attr_dunders = True
                 class_details.has_attr_dunders = True
+        # Detect __slots__ = [...] in class body
+        for stmt in definition.body:
+            assign = stmt
+            if is_node_type(stmt, AST_SimpleStatement):
+                assign = stmt.body
+            if is_node_type(assign, AST_Assign) and is_node_type(assign.left, AST_SymbolRef) and assign.left.name is '__slots__':
+                if is_node_type(assign.right, AST_Array):
+                    slot_names = []
+                    for elem in assign.right.elements:
+                        if is_node_type(elem, AST_String):
+                            slot_names.push(elem.value)
+                    definition.slots = slot_names
+                    class_details.slots = slot_names
+                break
         # find the class variables
         class_var_names = {}
         # Ensure that if a class variable refers to another class variable in
@@ -2245,6 +2274,12 @@ def create_parser_ctx(S, import_dirs, module_id, baselib_items, imported_module_
                 'end': tok,
                 'value': tok.value
             })
+        elif tmp_ is "bigint":
+            return new AST_BigInt({
+                'start': tok,
+                'end': tok,
+                'value': tok.value
+            })
         elif tmp_ is "imaginary":
             return new AST_Call({
                 'start': tok,