pyjsclear 0.1.0__py3-none-any.whl

pyjsclear/transforms/logical_to_if.py

@@ -0,0 +1,173 @@
+"""Convert logical expressions in statement position to if-statements.
+
+Converts:
+  a && b()           →  if (a) { b(); }
+  a || b()           →  if (!a) { b(); }
+  a && (b(), c())    →  if (a) { b(); c(); }
+  return a || 0, b(), c  →  if (!a) { 0; b(); } return c;
+  return await x(), y  →  await x(); return y;
+"""
+
+from ..utils.ast_helpers import make_block_statement
+from ..utils.ast_helpers import make_expression_statement
+from .base import Transform
+
+
+def _negate(expr):
+    """Wrap an expression in a logical NOT."""
+    return {
+        'type': 'UnaryExpression',
+        'operator': '!',
+        'prefix': True,
+        'argument': expr,
+    }
+
+
+class LogicalToIf(Transform):
+    """Convert logical/comma expressions in statement position to if-statements."""
+
+    def execute(self):
+        self._transform_bodies(self.ast)
+        return self.has_changed()
+
+    def _transform_bodies(self, node):
+        """Walk all statement arrays and apply transforms."""
+        if not isinstance(node, dict):
+            return
+        for key, child in node.items():
+            if isinstance(child, list):
+                if child and isinstance(child[0], dict) and 'type' in child[0]:
+                    self._process_stmt_array(child)
+                    for item in child:
+                        self._transform_bodies(item)
+            elif isinstance(child, dict) and 'type' in child:
+                self._transform_bodies(child)
+
+    def _process_stmt_array(self, stmts):
+        i = 0
+        while i < len(stmts):
+            stmt = stmts[i]
+            if not isinstance(stmt, dict):
+                i += 1
+                continue
+
+            replacement = self._try_convert_stmt(stmt)
+            if replacement is not None:
+                stmts[i : i + 1] = replacement
+                self.set_changed()
+                i += len(replacement)
+                continue
+
+            i += 1
+
+    def _try_convert_stmt(self, stmt):
+        """Try to convert a statement. Returns replacement list or None."""
+        match stmt.get('type'):
+            case 'ExpressionStatement':
+                return self._handle_expression_stmt(stmt)
+            case 'ReturnStatement':
+                return self._handle_return_stmt(stmt)
+        return None
+
+    def _handle_expression_stmt(self, stmt):
+        """Handle ExpressionStatement with logical or conditional."""
+        expression = stmt.get('expression')
+        if not isinstance(expression, dict):
+            return None
+        match expression.get('type'):
+            case 'LogicalExpression':
+                return self._logical_to_if(expression)
+            case 'ConditionalExpression':
+                return self._ternary_to_if(expression)
+        return None
+
+    def _handle_return_stmt(self, stmt):
+        """Handle ReturnStatement with sequence or logical expressions."""
+        argument = stmt.get('argument')
+        if not isinstance(argument, dict):
+            return None
+
+        # return a, b, c → a; b; return c;
+        if argument.get('type') == 'SequenceExpression':
+            return self._split_return_sequence(argument)
+
+        # return a || (b(), c) → if (!a) { b(); } return c;
+        if argument.get('type') == 'LogicalExpression':
+            return self._split_return_logical(argument)
+
+        return None
+
+    def _split_return_sequence(self, seq):
+        """Split return (a, b, c) into a; b; return c."""
+        exprs = seq.get('expressions', [])
+        if len(exprs) <= 1:
+            return None
+        new_stmts = []
+        for expression in exprs[:-1]:
+            if isinstance(expression, dict) and expression.get('type') == 'LogicalExpression':
+                converted = self._logical_to_if(expression)
+                if converted:
+                    new_stmts.extend(converted)
+                    continue
+            new_stmts.append(make_expression_statement(expression))
+        new_stmts.append({'type': 'ReturnStatement', 'argument': exprs[-1]})
+        return new_stmts
+
+    def _split_return_logical(self, logical):
+        """Split return a || (b(), c) into if (!a) { b(); } return c."""
+        right = logical.get('right')
+        if not (isinstance(right, dict) and right.get('type') == 'SequenceExpression'):
+            return None
+        exprs = right.get('expressions', [])
+        if len(exprs) <= 1:
+            return None
+
+        test = logical.get('left')
+        if logical.get('operator') == '||':
+            test = _negate(test)
+
+        body_stmts = [make_expression_statement(e) for e in exprs[:-1]]
+        if_stmt = {
+            'type': 'IfStatement',
+            'test': test,
+            'consequent': make_block_statement(body_stmts),
+            'alternate': None,
+        }
+        ret = {'type': 'ReturnStatement', 'argument': exprs[-1]}
+        return [if_stmt, ret]
+
+    def _logical_to_if(self, expr):
+        """Convert a LogicalExpression to if-statement(s). Returns list of stmts or None."""
+        left = expr.get('left')
+        match expr.get('operator'):
+            case '&&':
+                test = left
+            case '||':
+                test = _negate(left)
+            case _:
+                return None
+
+        body_stmts = self._expr_to_stmts(expr.get('right'))
+        if_stmt = {
+            'type': 'IfStatement',
+            'test': test,
+            'consequent': make_block_statement(body_stmts),
+            'alternate': None,
+        }
+        return [if_stmt]
+
+    def _ternary_to_if(self, expr):
+        """Convert a ConditionalExpression to if-else. Returns list of stmts or None."""
+        if_stmt = {
+            'type': 'IfStatement',
+            'test': expr.get('test'),
+            'consequent': make_block_statement(self._expr_to_stmts(expr.get('consequent'))),
+            'alternate': make_block_statement(self._expr_to_stmts(expr.get('alternate'))),
+        }
+        return [if_stmt]
+
+    def _expr_to_stmts(self, expr):
+        """Convert an expression to a list of statements."""
+        if isinstance(expr, dict) and expr.get('type') == 'SequenceExpression':
+            return [make_expression_statement(e) for e in expr.get('expressions', [])]
+        return [make_expression_statement(expr)]

pyjsclear/transforms/object_packer.py

@@ -0,0 +1,133 @@
+"""Consolidate sequential obj.x = ... assignments into object literal.
+
+Detects: var o = {}; o.x = 1; o.y = 2;
+Replaces: var o = {x: 1, y: 2};
+"""
+
+from ..utils.ast_helpers import get_child_keys
+from ..utils.ast_helpers import is_identifier
+from .base import Transform
+
+
+class ObjectPacker(Transform):
+    """Pack sequential property assignments into object initializers."""
+
+    def execute(self):
+        self._process_bodies(self.ast)
+        return self.has_changed()
+
+    def _process_bodies(self, node):
+        """Recursively find body arrays and try packing."""
+        if not isinstance(node, dict):
+            return
+        for key, child in node.items():
+            if isinstance(child, list):
+                if child and isinstance(child[0], dict) and 'type' in child[0]:
+                    self._try_pack_body(child)
+                    for item in child:
+                        self._process_bodies(item)
+            elif isinstance(child, dict) and 'type' in child:
+                self._process_bodies(child)
+
+    @staticmethod
+    def _find_empty_object_declaration(stmt):
+        """Find an empty object literal in a VariableDeclaration.
+
+        Returns (name, declarator, object_expression) or None.
+        """
+        if stmt.get('type') != 'VariableDeclaration':
+            return None
+        for declaration in stmt.get('declarations', []):
+            initializer = declaration.get('init')
+            if (
+                initializer
+                and initializer.get('type') == 'ObjectExpression'
+                and len(initializer.get('properties', [])) == 0
+                and declaration.get('id', {}).get('type') == 'Identifier'
+            ):
+                return declaration['id']['name'], declaration, initializer
+        return None
+
+    def _try_pack_body(self, body):
+        """Find empty object declarations followed by property assignments and pack them."""
+        i = 0
+        while i < len(body):
+            stmt = body[i]
+            if not isinstance(stmt, dict):
+                i += 1
+                continue
+
+            found = self._find_empty_object_declaration(stmt)
+            if not found:
+                i += 1
+                continue
+
+            obj_name, obj_decl, obj_expr = found
+
+            # Collect consecutive property assignments
+            assignments = []
+            j = i + 1
+            while j < len(body):
+                statement = body[j]
+                if not isinstance(statement, dict) or statement.get('type') != 'ExpressionStatement':
+                    break
+                expr = statement.get('expression')
+                if not expr or expr.get('type') != 'AssignmentExpression' or expr.get('operator') != '=':
+                    break
+                left = expr.get('left')
+                if not left or left.get('type') != 'MemberExpression':
+                    break
+                object_reference = left.get('object')
+                if not is_identifier(object_reference) or object_reference.get('name') != obj_name:
+                    break
+                property_node = left.get('property')
+                right = expr.get('right')
+                # Get property key
+                if property_node is None:
+                    break
+                # Support both computed and non-computed property keys
+                property_key = property_node
+
+                # Don't pack self-referential assignments (o.x = o.y)
+                if self._references_name(right, obj_name):
+                    break
+
+                computed = left.get('computed', False)
+                assignments.append((property_key, right, computed))
+                j += 1
+
+            if assignments:
+                # Pack into the object literal
+                for property_key, value, computed in assignments:
+                    property_node = {
+                        'type': 'Property',
+                        'key': property_key,
+                        'value': value,
+                        'kind': 'init',
+                        'method': False,
+                        'shorthand': False,
+                        'computed': computed,
+                    }
+                    obj_expr['properties'].append(property_node)
+                # Remove the assignment statements
+                del body[i + 1 : j]
+                self.set_changed()
+
+            i += 1
+
+    def _references_name(self, node, name):
+        """Check if a node references a given identifier name."""
+        if not isinstance(node, dict) or 'type' not in node:
+            return False
+        if node.get('type') == 'Identifier' and node.get('name') == name:
+            return True
+        for key in get_child_keys(node):
+            child = node.get(key)
+            if child is None:
+                continue
+            if isinstance(child, list):
+                if any(self._references_name(item, name) for item in child):
+                    return True
+            elif isinstance(child, dict) and self._references_name(child, name):
+                return True
+        return False

pyjsclear/transforms/object_simplifier.py

@@ -0,0 +1,192 @@
+"""Inline proxy object property accesses.
+
+Detects: const o = {x: 1, y: "hello"}; ... o.x ... o.y ...
+Replaces: ... 1 ... "hello" ...
+"""
+
+from ..scope import build_scope_tree
+from ..traverser import find_parent
+from ..utils.ast_helpers import deep_copy
+from ..utils.ast_helpers import is_literal
+from ..utils.ast_helpers import is_string_literal
+from ..utils.ast_helpers import replace_identifiers
+from .base import Transform
+
+
+class ObjectSimplifier(Transform):
+    """Replace proxy object property accesses with their literal values."""
+
+    rebuild_scope = True
+
+    def execute(self):
+        scope_tree, _ = build_scope_tree(self.ast)
+        self._process_scope(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
+            node = binding.node
+            if not isinstance(node, dict) or node.get('type') != 'VariableDeclarator':
+                continue
+            initializer = node.get('init')
+            if not initializer or initializer.get('type') != 'ObjectExpression':
+                continue
+
+            # Build property map (only literals and simple function expressions)
+            properties = initializer.get('properties', [])
+            if not self._is_proxy_object(properties):
+                continue
+
+            prop_map = {}
+            for property_node in properties:
+                key = self._get_property_key(property_node)
+                if key is None:
+                    continue
+                value = property_node.get('value')
+                if is_literal(value):
+                    prop_map[key] = value
+                elif value and value.get('type') in (
+                    'FunctionExpression',
+                    'ArrowFunctionExpression',
+                ):
+                    prop_map[key] = value
+
+            if not prop_map:
+                continue
+
+            if self._has_property_assignment(binding):
+                continue
+
+            # Replace property accesses
+            for reference_node, ref_parent, ref_key, ref_index in binding.references:
+                if not ref_parent or ref_parent.get('type') != 'MemberExpression':
+                    continue
+                if ref_key != 'object':
+                    continue
+
+                member_expression = ref_parent
+                property_name = self._get_member_prop_name(member_expression)
+                if property_name is None or property_name not in prop_map:
+                    continue
+
+                value = prop_map[property_name]
+                if is_literal(value):
+                    self._replace_node(member_expression, deep_copy(value))
+                    self.set_changed()
+                    continue
+
+                if value.get('type') not in (
+                    'FunctionExpression',
+                    'ArrowFunctionExpression',
+                ):
+                    continue
+                self._try_inline_function_call(member_expression, value)
+
+        for child in scope.children:
+            self._process_scope(child)
+
+    def _has_property_assignment(self, binding):
+        """Check if any reference to the binding is a property assignment target."""
+        for reference_node, reference_parent, ref_key, ref_index in binding.references:
+            if not (reference_parent and reference_parent.get('type') == 'MemberExpression' and ref_key == 'object'):
+                continue
+            me_parent_info = find_parent(self.ast, reference_parent)
+            if not me_parent_info:
+                continue
+            parent, key, _ = me_parent_info
+            if parent and parent.get('type') == 'AssignmentExpression' and key == 'left':
+                return True
+        return False
+
+    def _try_inline_function_call(self, member_expression, function_value):
+        """Try to inline a function call at a MemberExpression site."""
+        me_parent_info = find_parent(self.ast, member_expression)
+        if not me_parent_info:
+            return
+        parent, key, _ = me_parent_info
+        if not (parent and parent.get('type') == 'CallExpression' and key == 'callee'):
+            return
+        replacement = self._inline_func(function_value, parent.get('arguments', []))
+        if not replacement:
+            return
+        self._replace_node(parent, replacement)
+        self.set_changed()
+
+    def _is_proxy_object(self, properties):
+        """Check if all properties are literals or simple functions."""
+        for p in properties:
+            if p.get('type') != 'Property':
+                return False
+            val = p.get('value')
+            if not val:
+                return False
+            if is_literal(val):
+                continue
+            if val.get('type') in ('FunctionExpression', 'ArrowFunctionExpression'):
+                continue
+            return False
+        return True
+
+    def _get_property_key(self, prop):
+        """Get the string key of a property."""
+        key = prop.get('key')
+        if not key:
+            return None
+        match key.get('type'):
+            case 'Identifier':
+                return key['name']
+            case 'Literal' if is_string_literal(key):
+                return key['value']
+        return None
+
+    def _get_member_prop_name(self, member_expr):
+        """Get property name from a member expression."""
+        prop = member_expr.get('property')
+        if not prop:
+            return None
+        if member_expr.get('computed'):
+            if is_string_literal(prop):
+                return prop['value']
+            return None
+        if prop.get('type') == 'Identifier':
+            return prop['name']
+        return None
+
+    def _replace_node(self, target, replacement):
+        """Replace target node in the AST."""
+        result = find_parent(self.ast, target)
+        if result:
+            parent, key, index = result
+            if index is not None:
+                parent[key][index] = replacement
+            else:
+                parent[key] = replacement
+
+    def _inline_func(self, func, args):
+        """Inline a simple function call."""
+        body = func.get('body')
+        if not body:
+            return None
+        if func.get('type') == 'ArrowFunctionExpression' and body.get('type') != 'BlockStatement':
+            expr = deep_copy(body)
+        elif body.get('type') == 'BlockStatement':
+            stmts = body.get('body', [])
+            if len(stmts) != 1 or stmts[0].get('type') != 'ReturnStatement':
+                return None
+            argument = stmts[0].get('argument')
+            if not argument:
+                return None
+            expr = deep_copy(argument)
+        else:
+            return None
+
+        params = func.get('params', [])
+        param_map = {}
+        for i, parameter in enumerate(params):
+            if parameter.get('type') == 'Identifier':
+                param_map[parameter['name']] = args[i] if i < len(args) else {'type': 'Identifier', 'name': 'undefined'}
+
+        replace_identifiers(expr, param_map)
+        return expr

pyjsclear/transforms/property_simplifier.py

@@ -0,0 +1,43 @@
+"""Convert computed property access to dot notation: obj["x"] -> obj.x"""
+
+from ..traverser import traverse
+from ..utils.ast_helpers import is_string_literal
+from ..utils.ast_helpers import is_valid_identifier
+from .base import Transform
+
+
+class PropertySimplifier(Transform):
+    """Simplify obj["prop"] to obj.prop when prop is a valid identifier."""
+
+    def execute(self):
+        def enter(node, parent, key, index):
+            if node.get('type') != 'MemberExpression':
+                return
+            if not node.get('computed'):
+                return
+            property_node = node.get('property')
+            if not is_string_literal(property_node):
+                return
+            name = property_node.get('value', '')
+            if not is_valid_identifier(name):
+                return
+            # Convert to dot notation
+            node['computed'] = False
+            node['property'] = {'type': 'Identifier', 'name': name}
+            self.set_changed()
+
+        traverse(self.ast, {'enter': enter})
+
+        # Also simplify computed property keys in object literals
+        def enter_obj(node, parent, key, index):
+            if node.get('type') != 'Property':
+                return
+            if not node.get('computed'):
+                # Check string literal keys
+                key_node = node.get('key')
+                if is_string_literal(key_node) and is_valid_identifier(key_node.get('value', '')):
+                    node['key'] = {'type': 'Identifier', 'name': key_node['value']}
+                    self.set_changed()
+
+        traverse(self.ast, {'enter': enter_obj})
+        return self.has_changed()