pyjsclear 0.1.0__py3-none-any.whl

pyjsclear/transforms/proxy_functions.py

@@ -0,0 +1,193 @@
+"""Proxy function detection and inlining.
+
+Detects patterns like:
+  function _proxy(a, b) { return a + b; }
+  _proxy(x, y)  ->  x + y
+"""
+
+from ..scope import build_scope_tree
+from ..traverser import traverse
+from ..utils.ast_helpers import deep_copy
+from ..utils.ast_helpers import get_child_keys
+from ..utils.ast_helpers import is_identifier
+from ..utils.ast_helpers import replace_identifiers
+from .base import Transform
+
+
+class ProxyFunctionInliner(Transform):
+    """Inline proxy function calls."""
+
+    rebuild_scope = True
+
+    def execute(self):
+        scope_tree, node_scope = build_scope_tree(self.ast)
+
+        # Find proxy functions
+        proxy_fns = {}  # name -> (func_node, scope, binding)
+        self._find_proxy_functions(scope_tree, proxy_fns)
+
+        if not proxy_fns:
+            return False
+
+        # Collect call sites with depth info
+        call_sites = []  # (call_node, parent, key, index, proxy_info, depth)
+        depth_counter = [0]
+
+        def enter(node, parent, key, index):
+            depth_counter[0] += 1
+            if node.get('type') != 'CallExpression':
+                return
+            callee = node.get('callee')
+            if not is_identifier(callee):
+                return
+            name = callee.get('name', '')
+            if name not in proxy_fns:
+                return
+            call_sites.append((node, parent, key, index, proxy_fns[name], depth_counter[0]))
+
+        traverse(self.ast, {'enter': enter})
+
+        # Process innermost calls first
+        call_sites.sort(key=lambda x: x[5], reverse=True)
+
+        for (
+            call_node,
+            parent,
+            key,
+            index,
+            (func_node, scope, binding),
+            depth,
+        ) in call_sites:
+            replacement = self._get_replacement(func_node, call_node.get('arguments', []))
+            if replacement is None:
+                continue
+            # Replace the call with the inlined expression
+            if index is not None:
+                parent[key][index] = replacement
+            else:
+                parent[key] = replacement
+            self.set_changed()
+
+        return self.has_changed()
+
+    def _find_proxy_functions(self, scope, result):
+        """Find all proxy function bindings in the scope tree."""
+        for name, binding in scope.bindings.items():
+            if not binding.is_constant:
+                continue
+            func_node = self._get_function_expr(binding)
+            if func_node and self._is_proxy_function(func_node):
+                result[name] = (func_node, scope, binding)
+
+        for child in scope.children:
+            self._find_proxy_functions(child, result)
+
+    def _get_function_expr(self, binding):
+        """Get the function expression from a binding."""
+        node = binding.node
+        if isinstance(node, dict):
+            node_type = node.get('type', '')
+            if node_type in (
+                'FunctionDeclaration',
+                'FunctionExpression',
+                'ArrowFunctionExpression',
+            ):
+                return node
+            if node_type == 'VariableDeclarator':
+                init = node.get('init')
+                if init and init.get('type') in (
+                    'FunctionExpression',
+                    'ArrowFunctionExpression',
+                ):
+                    return init
+        return None
+
+    def _is_proxy_function(self, func_node):
+        """Check if a function is a simple proxy (single return of an expression)."""
+        params = func_node.get('params', [])
+        if not all(parameter.get('type') == 'Identifier' for parameter in params):
+            return False
+
+        body = func_node.get('body')
+        if not body:
+            return False
+
+        # Arrow function with expression body
+        if func_node.get('type') == 'ArrowFunctionExpression' and body.get('type') != 'BlockStatement':
+            return self._is_proxy_value(body)
+
+        # Block with single return
+        if body.get('type') == 'BlockStatement':
+            stmts = body.get('body', [])
+            if len(stmts) != 1:
+                return False
+            stmt = stmts[0]
+            if stmt.get('type') != 'ReturnStatement':
+                return False
+            arg = stmt.get('argument')
+            if arg is None:
+                return True  # returns undefined
+            return self._is_proxy_value(arg)
+
+        return False
+
+    _DISALLOWED_PROXY_TYPES = frozenset(
+        {
+            'FunctionExpression',
+            'FunctionDeclaration',
+            'ArrowFunctionExpression',
+            'BlockStatement',
+            'SequenceExpression',
+            'AssignmentExpression',
+        }
+    )
+
+    def _is_proxy_value(self, node):
+        """Check if an expression is a valid proxy return value (no side effects)."""
+        if not isinstance(node, dict) or 'type' not in node:
+            return False
+        if node.get('type', '') in self._DISALLOWED_PROXY_TYPES:
+            return False
+        for key in get_child_keys(node):
+            child = node.get(key)
+            if child is None:
+                continue
+            if isinstance(child, list):
+                if any(isinstance(item, dict) and item.get('type') in self._DISALLOWED_PROXY_TYPES for item in child):
+                    return False
+            elif isinstance(child, dict) and child.get('type') in self._DISALLOWED_PROXY_TYPES:
+                return False
+        return True
+
+    def _get_replacement(self, func_node, args):
+        """Get the replacement expression for a proxy function call."""
+        body = func_node.get('body')
+        if not body:
+            return {'type': 'Identifier', 'name': 'undefined'}
+
+        # Arrow with expression body
+        if func_node.get('type') == 'ArrowFunctionExpression' and body.get('type') != 'BlockStatement':
+            expr = deep_copy(body)
+        elif body.get('type') == 'BlockStatement':
+            stmts = body.get('body', [])
+            if not stmts or stmts[0].get('type') != 'ReturnStatement':
+                return None
+            arg = stmts[0].get('argument')
+            if arg is None:
+                return {'type': 'Identifier', 'name': 'undefined'}
+            expr = deep_copy(arg)
+        else:
+            return None
+
+        # Build parameter map
+        params = func_node.get('params', [])
+        param_map = {}
+        for i, parameter in enumerate(params):
+            if parameter.get('type') == 'Identifier':
+                if i < len(args):
+                    param_map[parameter['name']] = args[i]
+                else:
+                    param_map[parameter['name']] = {'type': 'Identifier', 'name': 'undefined'}
+
+        replace_identifiers(expr, param_map)
+        return expr

pyjsclear/transforms/reassignment.py

@@ -0,0 +1,183 @@
+"""Remove redundant variable reassignments.
+
+Detects: var x = y; (where y is also a variable)
+And replaces all references to x with y, then removes x.
+"""
+
+from ..scope import build_scope_tree
+from ..traverser import REMOVE
+from ..traverser import traverse
+from ..utils.ast_helpers import is_identifier
+from .base import Transform
+
+
+class ReassignmentRemover(Transform):
+    """Remove redundant reassignments like x = y where y is used identically."""
+
+    # Well-known globals that are safe to inline as reassignment targets
+    _WELL_KNOWN_GLOBALS = frozenset(
+        {
+            'JSON',
+            'Object',
+            'Array',
+            'String',
+            'Number',
+            'Boolean',
+            'Math',
+            'Date',
+            'RegExp',
+            'Error',
+            'Map',
+            'Set',
+            'WeakMap',
+            'WeakSet',
+            'Promise',
+            'Symbol',
+            'Proxy',
+            'Reflect',
+            'console',
+            'parseInt',
+            'parseFloat',
+            'isNaN',
+            'isFinite',
+            'Buffer',
+            'process',
+            'require',
+            'undefined',
+            'NaN',
+            'Infinity',
+        }
+    )
+
+    rebuild_scope = True
+
+    def execute(self):
+        scope_tree, _ = build_scope_tree(self.ast)
+        self._process_scope(scope_tree)
+        self._inline_assignment_aliases(scope_tree)
+        return self.has_changed()
+
+    def _process_scope(self, scope):
+        for name, binding in list(scope.bindings.items()):
+            if not binding.is_constant:
+                continue
+            if binding.kind == 'param':
+                continue
+
+            node = binding.node
+            if not isinstance(node, dict) or node.get('type') != 'VariableDeclarator':
+                continue
+
+            initializer = node.get('init')
+            if not initializer or not is_identifier(initializer):
+                continue
+
+            target_name = initializer.get('name', '')
+            if target_name == name:
+                continue
+            target_binding = scope.get_binding(target_name)
+            # Allow inlining if target is a well-known global or a constant binding
+            if target_binding:
+                if not target_binding.is_constant:
+                    continue
+            elif target_name not in self._WELL_KNOWN_GLOBALS:
+                continue
+
+            # Replace all references to `name` with `target_name`
+            for reference_node, reference_parent, reference_key, reference_index in binding.references:
+                if (
+                    reference_parent
+                    and reference_parent.get('type') == 'AssignmentExpression'
+                    and reference_key == 'left'
+                ):
+                    continue
+                if reference_parent and reference_parent.get('type') == 'VariableDeclarator' and reference_key == 'id':
+                    continue
+                new_id = {'type': 'Identifier', 'name': target_name}
+                if reference_index is not None:
+                    reference_parent[reference_key][reference_index] = new_id
+                else:
+                    reference_parent[reference_key] = new_id
+                self.set_changed()
+
+        for child in scope.children:
+            self._process_scope(child)
+
+    def _inline_assignment_aliases(self, scope_tree):
+        """Inline aliases created by `var x; ... x = y;` patterns.
+
+        Handles the obfuscator pattern where a variable is declared without
+        init, then assigned once to another identifier, and only read after that.
+        """
+        self._process_assignment_aliases(scope_tree)
+
+    def _remove_assignment_statement(self, assignment_node):
+        """Remove the ExpressionStatement containing the given assignment expression."""
+
+        def enter(node, parent, key, index):
+            if node.get('type') == 'ExpressionStatement' and node.get('expression') is assignment_node:
+                self.set_changed()
+                return REMOVE
+
+        traverse(self.ast, {'enter': enter})
+
+    def _process_assignment_aliases(self, scope):
+        for name, binding in list(scope.bindings.items()):
+            if binding.is_constant or binding.kind == 'param':
+                continue
+
+            node = binding.node
+            if not isinstance(node, dict) or node.get('type') != 'VariableDeclarator':
+                continue
+
+            # Must be declared without init: `var x;`
+            if node.get('init') is not None:
+                continue
+
+            # Look for exactly one write (assignment) in references
+            writes = []
+            reads = []
+            for reference_node, reference_parent, reference_key, reference_index in binding.references:
+                if (
+                    reference_parent
+                    and reference_parent.get('type') == 'AssignmentExpression'
+                    and reference_key == 'left'
+                ):
+                    writes.append((reference_node, reference_parent, reference_key, reference_index))
+                else:
+                    reads.append((reference_node, reference_parent, reference_key, reference_index))
+
+            if len(writes) != 1:
+                continue
+
+            # The single write must be: x = <identifier>
+            _, write_parent, _, _ = writes[0]
+            right_hand_side = write_parent.get('right')
+            if not right_hand_side or not is_identifier(right_hand_side):
+                continue
+
+            target_name = right_hand_side['name']
+            if target_name == name:
+                continue
+
+            # The target must be constant or a well-known global
+            target_binding = scope.get_binding(target_name)
+            if target_binding:
+                if not target_binding.is_constant:
+                    continue
+            elif target_name not in self._WELL_KNOWN_GLOBALS:
+                continue
+
+            # Replace all reads of `name` with `target_name`
+            for reference_node, reference_parent, reference_key, reference_index in reads:
+                new_id = {'type': 'Identifier', 'name': target_name}
+                if reference_index is not None:
+                    reference_parent[reference_key][reference_index] = new_id
+                else:
+                    reference_parent[reference_key] = new_id
+                self.set_changed()
+
+            self._remove_assignment_statement(write_parent)
+
+        for child in scope.children:
+            self._process_assignment_aliases(child)

pyjsclear/transforms/sequence_splitter.py

@@ -0,0 +1,215 @@
+"""Split sequence expressions into individual statements.
+
+Converts: (a(), b(), c()) in statement position → a(); b(); c();
+Also splits multi-declarator var statements: var a = 1, b = 2 → var a = 1; var b = 2;
+Also normalizes loop/if bodies to block statements.
+"""
+
+from ..traverser import traverse
+from ..utils.ast_helpers import make_block_statement
+from ..utils.ast_helpers import make_expression_statement
+from .base import Transform
+
+
+class SequenceSplitter(Transform):
+    """Split sequence expressions and normalize control flow bodies."""
+
+    def execute(self):
+        self._normalize_bodies(self.ast)
+        self._split_in_body_arrays(self.ast)
+        return self.has_changed()
+
+    def _normalize_bodies(self, ast):
+        """Ensure if/while/for bodies are BlockStatements."""
+
+        def enter(node, parent, key, index):
+            node_type = node.get('type', '')
+            if node_type not in (
+                'IfStatement',
+                'WhileStatement',
+                'DoWhileStatement',
+                'ForStatement',
+                'ForInStatement',
+                'ForOfStatement',
+            ):
+                return
+            body = node.get('body')
+            if body and body.get('type') != 'BlockStatement':
+                node['body'] = make_block_statement([body])
+                self.set_changed()
+            if node_type == 'IfStatement':
+                self._normalize_if_branches(node)
+
+        traverse(ast, {'enter': enter})
+
+    def _normalize_if_branches(self, node):
+        """Wrap non-block consequent/alternate of IfStatement in BlockStatements."""
+        consequent = node.get('consequent')
+        if consequent and consequent.get('type') != 'BlockStatement':
+            node['consequent'] = make_block_statement([consequent])
+            self.set_changed()
+        alternate = node.get('alternate')
+        if alternate and alternate.get('type') not in ('BlockStatement', 'IfStatement', None):
+            node['alternate'] = make_block_statement([alternate])
+            self.set_changed()
+
+    def _split_in_body_arrays(self, node):
+        """Find all arrays that contain statements and split sequences + var decls in them."""
+        if not isinstance(node, dict):
+            return
+        for key, child in node.items():
+            if isinstance(child, list):
+                # Check if this looks like a statement array
+                if child and isinstance(child[0], dict) and 'type' in child[0]:
+                    self._process_stmt_array(child)
+                    # Recurse into items
+                    for item in child:
+                        self._split_in_body_arrays(item)
+            elif isinstance(child, dict) and 'type' in child:
+                self._split_in_body_arrays(child)
+
+    def _extract_indirect_call_prefixes(self, stmt):
+        """Extract dead prefix expressions from (0, fn)(args) patterns.
+
+        Only extracts from:
+        - Direct expression of ExpressionStatement
+        - Direct init of VariableDeclarator
+        - Argument of AwaitExpression in those positions
+        - Argument of ReturnStatement
+        """
+        prefixes = []
+
+        def extract_from_call(node):
+            """If node is a CallExpression with SequenceExpression callee, extract prefixes."""
+            if not isinstance(node, dict):
+                return
+            target = node
+            if target.get('type') == 'AwaitExpression' and isinstance(target.get('argument'), dict):
+                target = target['argument']
+            if target.get('type') != 'CallExpression':
+                return
+            callee = target.get('callee')
+            if not isinstance(callee, dict) or callee.get('type') != 'SequenceExpression':
+                return
+            exprs = callee.get('expressions', [])
+            if len(exprs) <= 1:
+                return
+            prefixes.extend(exprs[:-1])
+            target['callee'] = exprs[-1]
+
+        stype = stmt.get('type', '')
+        if stype == 'ExpressionStatement':
+            extract_from_call(stmt.get('expression'))
+        elif stype == 'VariableDeclaration':
+            for d in stmt.get('declarations', []):
+                extract_from_call(d.get('init'))
+        elif stype == 'ReturnStatement':
+            extract_from_call(stmt.get('argument'))
+        # Also check assignment expressions in ExpressionStatements:
+        # x = (0, fn)(args)
+        if stype == 'ExpressionStatement':
+            expr = stmt.get('expression')
+            if isinstance(expr, dict) and expr.get('type') == 'AssignmentExpression':
+                extract_from_call(expr.get('right'))
+
+        return prefixes
+
+    def _process_stmt_array(self, statements):
+        """Split sequence expressions and multi-var declarations in a statement array."""
+        i = 0
+        while i < len(statements):
+            statement = statements[i]
+            if not isinstance(statement, dict):
+                i += 1
+                continue
+
+            # Extract dead prefix from indirect call patterns: (0, fn)(args) → 0; fn(args);
+            prefixes = self._extract_indirect_call_prefixes(statement)
+            if prefixes:
+                new_stmts = [make_expression_statement(expression) for expression in prefixes]
+                new_stmts.append(statement)
+                statements[i : i + 1] = new_stmts
+                i += len(new_stmts)
+                self.set_changed()
+                continue
+
+            # Split SequenceExpression in ExpressionStatement
+            if (
+                statement.get('type') == 'ExpressionStatement'
+                and isinstance(statement.get('expression'), dict)
+                and statement['expression'].get('type') == 'SequenceExpression'
+            ):
+                expressions = statement['expression'].get('expressions', [])
+                if len(expressions) > 1:
+                    new_stmts = [make_expression_statement(expression) for expression in expressions]
+                    statements[i : i + 1] = new_stmts
+                    i += len(new_stmts)
+                    self.set_changed()
+                    continue
+
+            # Split multi-declarator VariableDeclaration
+            # (but not inside for-loop init — those aren't in body arrays)
+            if statement.get('type') == 'VariableDeclaration':
+                decls = statement.get('declarations', [])
+                if len(decls) > 1:
+                    kind = statement.get('kind', 'var')
+                    new_stmts = [
+                        {
+                            'type': 'VariableDeclaration',
+                            'kind': kind,
+                            'declarations': [declaration],
+                        }
+                        for declaration in decls
+                    ]
+                    statements[i : i + 1] = new_stmts
+                    i += len(new_stmts)
+                    self.set_changed()
+                    continue
+
+                # Split SequenceExpression in single declarator init
+                if len(decls) == 1:
+                    split_result = self._try_split_single_declarator_init(statement, decls[0])
+                    if split_result:
+                        statements[i : i + 1] = split_result
+                        i += len(split_result)
+                        self.set_changed()
+                        continue
+
+            i += 1
+
+    @staticmethod
+    def _try_split_single_declarator_init(stmt, declarator):
+        """Split SequenceExpression from a single VariableDeclarator init.
+
+        Handles both direct sequences and sequences inside AwaitExpression.
+        Returns a list of replacement statements, or None.
+        """
+        init = declarator.get('init')
+        if not isinstance(init, dict):
+            return None
+
+        # Direct: const x = (a, b, expr()) → a; b; const x = expr();
+        if init.get('type') == 'SequenceExpression':
+            exprs = init.get('expressions', [])
+            if len(exprs) <= 1:
+                return None
+            prefix = [make_expression_statement(e) for e in exprs[:-1]]
+            declarator['init'] = exprs[-1]
+            prefix.append(stmt)
+            return prefix
+
+        # Await-wrapped: var x = await (a, b, expr()) → a; b; var x = await expr();
+        if (
+            init.get('type') == 'AwaitExpression'
+            and isinstance(init.get('argument'), dict)
+            and init['argument'].get('type') == 'SequenceExpression'
+        ):
+            exprs = init['argument'].get('expressions', [])
+            if len(exprs) <= 1:
+                return None
+            prefix = [make_expression_statement(e) for e in exprs[:-1]]
+            init['argument'] = exprs[-1]
+            prefix.append(stmt)
+            return prefix
+
+        return None