Upload try_new_mutation.py with huggingface_hub

try_new_mutation.py

@@ -0,0 +1,922 @@
+# import ast
+# import astor
+
+# class dependencychecker(ast.nodevisitor):
+    # def __init__(self):
+        # self.read_vars = set()
+        # self.assigned_vars = set()
+
+    # def visit_name(self, node):
+        # if isinstance(node.ctx, ast.load):
+            # self.read_vars.add(node.id)
+        # elif isinstance(node.ctx, ast.store):
+            # self.assigned_vars.add(node.id)
+
+# def are_independent(stmt1, stmt2):
+    # # check dependencies of stmt1
+    # checker1 = dependencychecker()
+    # checker1.visit(stmt1)
+    
+    # # check dependencies of stmt2
+    # checker2 = dependencychecker()
+    # checker2.visit(stmt2)
+    
+    # # check for intersection between assigned variables and read variables
+    # independent = (checker1.assigned_vars.isdisjoint(checker2.read_vars) and
+                   # checker2.assigned_vars.isdisjoint(checker1.read_vars))
+    
+    # return independent
+
+# # sample source code
+# source_code1 = """
+# a = [1]
+# b= 5-a[-1]
+# e = a.append(2) 
+# c = 3
+# d = 4
+# """
+
+# # parse the source code into an ast
+
+
+
+
+# # ensure there are at least two statements to compare
+# def pos_mut(source_code, v=0):
+    # parsed_ast = ast.parse(source_code)
+    # # print the original code
+    # if v==1:
+        # print("original code:")
+        # print(astor.to_source(parsed_ast))
+    # for i in range(len(parsed_ast.body) - 1):
+        # stmt1 = parsed_ast.body[i]
+        # stmt2 = parsed_ast.body[i + 1]
+        
+        # if are_independent(stmt1, stmt2):
+            # # swap the two independent statements
+            # parsed_ast.body[i], parsed_ast.body[i + 1] = parsed_ast.body[i + 1], parsed_ast.body[i]
+            # break  # swap only the first pair of independent statements
+
+    # # convert the modified ast back to source code
+    # modified_code = astor.to_source(parsed_ast)
+    # if v==1:
+        # print("\nmodified code:")
+        # print(modified_code)
+    # return modified_code
+    
+    
+# pos_mut(source_code, v=1)
+# def neg_mut(source_code):
+    # parsed_ast = ast.parse(source_code)
+    # for i in range(len(parsed_ast.body) - 1):
+        # stmt1 = parsed_ast.body[i]
+        # stmt2 = parsed_ast.body[i + 1]
+        
+        # if not are_independent(stmt1, stmt2):
+            # # swap the two independent statements
+            # parsed_ast.body[i], parsed_ast.body[i + 1] = parsed_ast.body[i + 1], parsed_ast.body[i]
+            # break  # swap only the first pair of independent statements
+
+    # # convert the modified ast back to source code
+    # modified_code = astor.to_source(parsed_ast)
+    # return modified_code
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+import ast
+import astor
+
+class dependencychecker(ast.NodeVisitor):
+    def __init__(self):
+        self.read_vars = set()
+        self.assigned_vars = set()
+        self.mutated_vars = set()
+
+    def visit_name(self, node):
+        if isinstance(node.ctx, ast.load):
+            self.read_vars.add(node.id)
+        elif isinstance(node.ctx, ast.store):
+            self.assigned_vars.add(node.id)
+
+    def visit_attribute(self, node):
+        # handle object attributes like a.append(), a[-1], etc.
+        if isinstance(node.ctx, ast.load):
+            self.read_vars.add(node.value.id)
+        elif isinstance(node.ctx, ast.store):
+            self.assigned_vars.add(node.value.id)
+        self.generic_visit(node)
+
+    def visit_subscript(self, node):
+        # handle subscripting like a[-1]
+        if isinstance(node.ctx, ast.load):
+            self.read_vars.add(node.value.id)
+        elif isinstance(node.ctx, ast.store):
+            self.mutated_vars.add(node.value.id)
+        self.generic_visit(node)
+
+    def visit_call(self, node):
+        # handle function calls like a.append()
+        if isinstance(node.func, ast.attribute):
+            self.mutated_vars.add(node.func.value.id)
+        self.generic_visit(node)
+
+def are_independent(stmt1, stmt2):
+    # check dependencies of stmt1
+    checker1 = dependencychecker()
+    checker1.visit(stmt1)
+    
+    # check dependencies of stmt2
+    checker2 = dependencychecker()
+    checker2.visit(stmt2)
+    
+    # check for intersection between assigned/mutated variables and read variables
+    independent = (checker1.assigned_vars.isdisjoint(checker2.read_vars | checker2.mutated_vars) and
+                   checker2.assigned_vars.isdisjoint(checker1.read_vars | checker1.mutated_vars) and
+                   checker1.mutated_vars.isdisjoint(checker2.read_vars | checker2.mutated_vars) and
+                   checker2.mutated_vars.isdisjoint(checker1.read_vars | checker1.mutated_vars))
+    
+    return independent
+
+# sample source code
+
+source_code = """
+a = [1]
+b = 5 - a[-1]
+a[0] = a[0] + 1
+c = 3
+d = 4
+"""
+def pos_mut(source_code, verbose=False):
+# parse the source code into an ast
+    parsed_ast = ast.parse(source_code)
+
+    # print the original code
+    if verbose==True:
+        print("original code:")
+        print(astor.to_source(parsed_ast))
+
+    # ensure there are at least two statements to compare
+    for i in range(len(parsed_ast.body) - 1):
+        stmt1 = parsed_ast.body[i]
+        stmt2 = parsed_ast.body[i + 1]
+        
+        if are_independent(stmt1, stmt2):
+            # swap the two independent statements
+            parsed_ast.body[i], parsed_ast.body[i + 1] = parsed_ast.body[i + 1], parsed_ast.body[i]
+            break  # swap only the first pair of independent statements
+
+    # convert the modified ast back to source code
+    modified_code = astor.to_source(parsed_ast)
+
+    # print the modified code
+    if verbose==True:
+        print("\nmodified code:")
+        print(modified_code)
+
+pos_mut(source_code, verbose=True)
+
+def neg_mut(source_code, verbose=False):
+# parse the source code into an ast
+    parsed_ast = ast.parse(source_code)
+
+    # print the original code
+    if verbose==True:
+        print("original code:")
+        print(astor.to_source(parsed_ast))
+
+    # ensure there are at least two statements to compare
+    for i in range(len(parsed_ast.body) - 1):
+        stmt1 = parsed_ast.body[i]
+        stmt2 = parsed_ast.body[i + 1]
+        
+        if not are_independent(stmt1, stmt2):
+            # swap the two independent statements
+            parsed_ast.body[i], parsed_ast.body[i + 1] = parsed_ast.body[i + 1], parsed_ast.body[i]
+            break  # swap only the first pair of independent statements
+
+    # convert the modified ast back to source code
+    modified_code = astor.to_source(parsed_ast)
+
+    # print the modified code
+    if verbose==True:
+        print("\nmodified code:")
+        print(modified_code)
+
+neg_mut(source_code, verbose=True)
+
+# import ast
+# import astor
+# import random
+# import string
+
+# class VariableRenamer(ast.NodeTransformer):
+    # def __init__(self, rename_map=None):
+        # # Mapping from original variable names to their new names
+        # if rename_map is None:
+            # self.rename_map = {}
+        # else:
+            # self.rename_map = rename_map
+
+    # def generate_new_name(self, old_name):
+        # # Generate a new name for the variable
+        # if old_name not in self.rename_map:
+            # new_name = ''.join(random.choices(string.ascii_lowercase, k=5))
+            # self.rename_map[old_name] = new_name
+        # return self.rename_map[old_name]
+
+    # def visit_Name(self, node):
+        # if isinstance(node.ctx, (ast.Load, ast.Store, ast.Del)):
+            # node.id = self.generate_new_name(node.id)
+        # return node
+
+    # def visit_FunctionDef(self, node):
+        # # Rename function arguments
+        # node.args.args = [ast.arg(arg=self.generate_new_name(arg.arg), annotation=arg.annotation) for arg in node.args.args]
+        # # Rename the function body
+        # self.generic_visit(node)
+        # return node
+
+    # def visit_Assign(self, node):
+        # # Rename variables in assignments
+        # self.generic_visit(node)
+        # return node
+
+    # def visit_Attribute(self, node):
+        # # Skip renaming attributes (e.g., object.method) to avoid unintended changes
+        # self.generic_visit(node)
+        # return node
+
+# def rename_variables(source_code):
+    # # Parse the source code into an AST
+    # parsed_ast = ast.parse(source_code)
+
+    # # Create a renamer instance
+    # renamer = VariableRenamer()
+
+    # # Transform the AST by renaming variables
+    # renamed_ast = renamer.visit(parsed_ast)
+
+    # # Convert the modified AST back to source code
+    # renamed_code = astor.to_source(renamed_ast)
+
+    # return renamed_code
+
+# # Sample source code
+# source_code = """
+# def example_function(x, y):
+    # a = x + y
+    # b = a * 2
+    # return b
+
+# x = 5
+# y = 10
+# result = example_function(x, y)
+# print(result)
+# """
+
+# # Rename variables in the source code
+# renamed_code = rename_variables(source_code)
+
+# # Print the original and modified code
+# print("Original code:")
+# print(source_code)
+# print("\nRenamed code:")
+# print(renamed_code)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# import com.github.javaparser.StaticJavaParser;
+# import com.github.javaparser.ast.CompilationUnit;
+# import com.github.javaparser.ast.body.MethodDeclaration;
+# import com.github.javaparser.ast.body.Parameter;
+# import com.github.javaparser.ast.expr.SimpleName;
+# import com.github.javaparser.ast.visitor.ModifierVisitor;
+# import com.github.javaparser.ast.visitor.VoidVisitorAdapter;
+
+# import java.io.FileInputStream;
+# import java.io.FileNotFoundException;
+# import java.util.HashMap;
+# import java.util.Map;
+# import java.util.Random;
+
+# public class VariableRenamer {
+    # private static Map<String, String> renameMap = new HashMap<>();
+
+    # public static void main(String[] args) throws FileNotFoundException {
+        # FileInputStream in = new FileInputStream("Example.java"); // Your Java file
+
+        # CompilationUnit cu = StaticJavaParser.parse(in);
+
+        # // Rename variables
+        # new ModifierVisitor<Void>() {
+            # @Override
+            # public SimpleName visit(SimpleName n, Void arg) {
+                # String originalName = n.getIdentifier();
+                # if (!renameMap.containsKey(originalName)) {
+                    # renameMap.put(originalName, generateNewName());
+                # }
+                # n.setIdentifier(renameMap.get(originalName));
+                # return n;
+            # }
+
+            # @Override
+            # public MethodDeclaration visit(MethodDeclaration md, Void arg) {
+                # for (Parameter parameter : md.getParameters()) {
+                    # String originalName = parameter.getNameAsString();
+                    # if (!renameMap.containsKey(originalName)) {
+                        # renameMap.put(originalName, generateNewName());
+                    # }
+                    # parameter.setName(renameMap.get(originalName));
+                # }
+                # return super.visit(md, arg);
+            # }
+        # }.visit(cu, null);
+
+        # System.out.println(cu.toString());
+    # }
+
+    # // Generates a random 5-letter name
+    # private static String generateNewName() {
+        # int length = 5;
+        # String chars = "abcdefghijklmnopqrstuvwxyz";
+        # Random random = new Random();
+        # StringBuilder newName = new StringBuilder(length);
+        # for (int i = 0; i < length; i++) {
+            # newName.append(chars.charAt(random.nextInt(chars.length())));
+        # }
+        # return newName.toString();
+    # }
+# }
+
+
+
+
+
+
+
+
+# import javalang
+# import random
+# import string
+
+# # Generate a consistent new name for a given old name
+# def generate_new_name(existing_names):
+    # new_name = ''.join(random.choices(string.ascii_lowercase, k=5))
+    # while new_name in existing_names:
+        # new_name = ''.join(random.choices(string.ascii_lowercase, k=5))
+    # return new_name
+
+# # Perform the variable renaming
+# def rename_variables(java_code):
+    # tree = javalang.parse.parse(java_code)
+    # rename_map = {}
+    # existing_names = set()
+
+    # for path, node in tree:
+        # if isinstance(node, javalang.tree.VariableDeclarator):
+            # var_name = node.name
+            # if var_name not in rename_map:
+                # new_name = generate_new_name(existing_names)
+                # rename_map[var_name] = new_name
+                # existing_names.add(new_name)
+            # node.name = rename_map[var_name]
+
+        # elif isinstance(node, javalang.tree.MemberReference):
+            # var_name = node.member
+            # if var_name in rename_map:
+                # node.member = rename_map[var_name]
+
+        # elif isinstance(node, javalang.tree.FormalParameter):
+            # param_name = node.name
+            # if param_name not in rename_map:
+                # new_name = generate_new_name(existing_names)
+                # rename_map[param_name] = new_name
+                # existing_names.add(new_name)
+            # node.name = rename_map[param_name]
+
+    # return tree, rename_map
+
+# # Convert the modified AST back to Java code
+# def ast_to_code(tree):
+    # code = []
+    # for path, node in tree:
+        # if isinstance(node, javalang.tree.ClassDeclaration):
+            # code.append(f"class {node.name} " + "{\n")
+        # elif isinstance(node, javalang.tree.MethodDeclaration):
+            # modifiers = ' '.join(node.modifiers)
+            # return_type = node.return_type.name if node.return_type else 'void'
+            # params = ', '.join(f"{param.type.name} {param.name}" for param in node.parameters)
+            # code.append(f"    {modifiers} {return_type} {node.name}({params}) " + "{\n")
+        # elif isinstance(node, javalang.tree.VariableDeclarator):
+            # code.append(f"        {node.name} = {node.initializer};\n")
+        # elif isinstance(node, javalang.tree.Assignment):
+            # code.append(f"        {node.expressionl.member} = {node.value.member};\n")
+        # elif isinstance(node, javalang.tree.MemberReference):
+            # code.append(f"        {node.member};\n")
+        # elif isinstance(node, javalang.tree.Literal):
+            # code.append(f"{node.value}")
+        # elif isinstance(node, javalang.tree.MethodInvocation):
+            # code.append(f"        {node.name}({', '.join(arg.member if isinstance(arg, javalang.tree.MemberReference) else str(arg) for arg in node.arguments)});\n")
+        # elif isinstance(node, javalang.tree.StatementExpression):
+            # code.append(f"        {node.expression.member};\n")
+        # elif isinstance(node, javalang.tree.ReturnStatement):
+            # code.append(f"        return {node.expression.member if isinstance(node.expression, javalang.tree.MemberReference) else str(node.expression)};\n")
+        # elif isinstance(node, javalang.tree.IfStatement):
+            # code.append(f"        if ({node.condition.member if isinstance(node.condition, javalang.tree.MemberReference) else str(node.condition)}) " + "{\n")
+            # code.append(f"        }}\n")
+        # elif isinstance(node, javalang.tree.ConstructorDeclaration):
+            # modifiers = ' '.join(node.modifiers)
+            # params = ', '.join(f"{param.type.name} {param.name}" for param in node.parameters)
+            # code.append(f"    {modifiers} {node.name}({params}) " + "{\n")
+
+    # code.append("}\n")
+    # return ''.join(code)
+
+# # Sample Java source code
+# java_code = """
+# public class Example {
+    # public static void main(String[] args) {
+        # int a = 5;
+        # int b = a + 10;
+        # System.out.println(b);
+    # }
+# }
+# """
+
+# # Rename variables in the Java code
+# ast, rename_map = rename_variables(java_code)
+
+# # Convert the modified AST back to Java code
+# modified_code = ast_to_code(ast)
+
+# # Print the original and modified Java code
+# print("Original Java code:")
+# print(java_code)
+# print("\nRenamed Java code:")
+# print(modified_code)
+
+
+
+
+
+
+
+# import ast
+# import astor
+# import random
+# import string
+
+# class DefUseBreakTransformer(ast.NodeTransformer):
+    # def __init__(self):
+        # self.def_use_count = {}
+        # self.rename_map = {}
+
+    # def generate_new_name(self):
+        # return ''.join(random.choices(string.ascii_lowercase, k=5))
+
+    # def visit_FunctionDef(self, node):
+        # # Reset state for each function
+        # self.def_use_count = {}
+        # self.rename_map = {}
+        # return self.generic_visit(node)
+
+    # def visit_Assign(self, node):
+        # if isinstance(node.targets[0], ast.Name):
+            # var_name = node.targets[0].id
+            
+            # # Track the count of each variable's definition
+            # if var_name not in self.def_use_count:
+                # self.def_use_count[var_name] = 1
+            # else:
+                # self.def_use_count[var_name] += 1
+
+            # # If it's the second or later definition, rename the variable
+            # if self.def_use_count[var_name] == 2:
+                # new_name = self.generate_new_name()
+                # self.rename_map[var_name] = new_name
+                # node.targets[0].id = new_name
+            # elif var_name in self.rename_map:
+                # node.targets[0].id = self.rename_map[var_name]
+        
+        # self.generic_visit(node)
+        # return node
+
+    # def visit_Name(self, node):
+        # var_name = node.id
+        # if var_name in self.rename_map:
+            # node.id = self.rename_map[var_name]
+        # return node
+
+# def def_use_break(source_code):
+    # tree = ast.parse(source_code)
+    # transformer = DefUseBreakTransformer()
+    # new_tree = transformer.visit(tree)
+    # return astor.to_source(new_tree)
+
+# # Example Python source code
+# source_code = """
+# def example_function():
+    # a = 5
+    # b = a + 10
+    # a = b + 1
+    # print(a)
+# """
+
+# # Apply the Def-Use Break mutation
+# modified_code = def_use_break(source_code)
+
+# # Print the original and modified code
+# print("Original code:")
+# print(source_code)
+# print("\nModified code:")
+# print(modified_code)
+
+
+
+
+
+
+
+
+
+# import ast
+# import astor
+
+# class LineNumberStatementRemover(ast.NodeTransformer):
+    # def __init__(self, target_lineno):
+        # self.target_lineno = target_lineno
+        # self.found = False
+
+    # def visit(self, node):
+        # """
+        # Recursively visit each node in the AST, and if the node matches the target line number,
+        # remove the node and everything nested inside it.
+        # """
+        # # If we already found and removed the target node, return the node unchanged
+        # if self.found:
+            # return node
+
+        # # Check if the current node starts on the target line number
+        # if hasattr(node, 'lineno') and node.lineno == self.target_lineno:
+            # self.found = True
+            # return None  # Removing the node
+
+        # # For compound statements, check their body to find and remove the target node
+        # if hasattr(node, 'body'):
+            # new_body = []
+            # for stmt in node.body:
+                # if hasattr(stmt, 'lineno') and stmt.lineno == self.target_lineno:
+                    # self.found = True
+                # else:
+                    # new_body.append(self.visit(stmt))
+            # node.body = [stmt for stmt in new_body if stmt is not None]
+
+        # return node
+
+# def remove_statement_by_line(source_code, target_lineno):
+    # """
+    # Removes the statement at the specified line number and everything nested inside it.
+    
+    # :param source_code: A string containing the Python source code.
+    # :param target_lineno: The line number of the statement to remove.
+    # :return: The transformed source code with the target statement removed.
+    # """
+    # # Parse the source code into an AST
+    # tree = ast.parse(source_code)
+    
+    # # Create a transformer to remove the node corresponding to the target line number
+    # transformer = LineNumberStatementRemover(target_lineno)
+    
+    # # Transform the tree by removing the target node
+    # transformed_tree = transformer.visit(tree)
+    
+    # # Convert the transformed AST back to source code
+    # transformed_code = astor.to_source(transformed_tree)
+    
+    # return transformed_code
+
+# # Example Usage
+# source_code = """
+# def example():
+    # x = 1
+    # if x > 0:
+        # print("Positive")
+        # if x == 1:
+            # print("One")
+    # for i in range(5):
+        # print(i)
+# """
+
+# # Remove the statement at line 4 (the first 'if' statement) and everything nested within it
+# target_lineno = 6
+# transformed_code = remove_statement_by_line(source_code, target_lineno)
+
+# print(transformed_code)
+
+
+
+
+
+
+# import ast
+# import astor
+
+# class BooleanInverter(ast.NodeTransformer):
+    # def __init__(self, bool_var_name):
+        # self.bool_var_name = bool_var_name
+
+    # def visit_Assign(self, node):
+        # """
+        # Visit assignment statements and invert the boolean value if it matches the boolean variable.
+        # """
+        # if isinstance(node.targets[0], ast.Name) and node.targets[0].id == self.bool_var_name:
+            # if isinstance(node.value, ast.Constant) and isinstance(node.value.value, bool):
+                # # Invert the boolean value
+                # node.value.value = not node.value.value
+        # return self.generic_visit(node)
+
+    # def visit_Name(self, node):
+        # """
+        # Invert the usage of the boolean variable by wrapping it in a `not` expression.
+        # """
+        # if isinstance(node.ctx, ast.Load) and node.id == self.bool_var_name:
+            # return ast.UnaryOp(op=ast.Not(), operand=node)
+        # return node
+
+    # def visit_UnaryOp(self, node):
+        # """
+        # Handle double negation (`not not var`) by simplifying it.
+        # """
+        # if isinstance(node.op, ast.Not) and isinstance(node.operand, ast.UnaryOp) and isinstance(node.operand.op, ast.Not):
+            # return self.visit(node.operand.operand)
+        # return self.generic_visit(node)
+
+# def invert_boolean_variable(source_code, bool_var_name):
+    # """
+    # Inverts the value of the specified boolean variable and propagates the change throughout the code.
+    
+    # :param source_code: A string containing the Python source code.
+    # :param bool_var_name: The name of the boolean variable to invert.
+    # :return: The transformed source code with the boolean variable inverted and logic preserved.
+    # """
+    # # Parse the source code into an AST
+    # tree = ast.parse(source_code)
+    
+    # # Create a transformer to invert the boolean variable
+    # transformer = BooleanInverter(bool_var_name)
+    
+    # # Transform the tree by inverting the boolean variable
+    # transformed_tree = transformer.visit(tree)
+    
+    # # Convert the transformed AST back to source code
+    # transformed_code = astor.to_source(transformed_tree)
+    
+    # return transformed_code
+
+# # Example Usage
+# source_code = """
+# def example():
+    # flag = True
+    # if flag:
+        # print("Flag is true")
+    # else:
+        # print("Flag is false")
+
+    # while flag:
+        # print("Still true")
+        # flag = False
+        # print(flag)
+# """
+
+# # Invert the boolean variable "flag"
+# bool_var_name = "flag"
+# transformed_code = invert_boolean_variable(source_code, bool_var_name)
+
+# print(transformed_code)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# import ast
+# import astor
+
+# class DeadCodeEliminator(ast.NodeTransformer):
+    # def eliminate_dead_code(self, statements):
+        # """
+        # Eliminate dead code from a list of statements. If a return, break, continue, or raise
+        # statement is encountered, all following code in that block is considered dead and removed.
+        # """
+        # live_statements = []
+        # for stmt in statements:
+            # live_statements.append(stmt)
+
+            # if isinstance(stmt, (ast.Return, ast.Raise, ast.Break, ast.Continue)):
+                # # Any code after this is dead, so stop adding further statements
+                # break
+
+        # return live_statements
+
+    # def visit_FunctionDef(self, node):
+        # node.body = self.eliminate_dead_code(node.body)
+        # return node
+
+    # def visit_If(self, node):
+        # node.body = self.eliminate_dead_code(node.body)
+        # node.orelse = self.eliminate_dead_code(node.orelse)
+        # return node
+
+    # def visit_While(self, node):
+        # node.body = self.eliminate_dead_code(node.body)
+        # node.orelse = self.eliminate_dead_code(node.orelse)
+        # return node
+
+    # def visit_For(self, node):
+        # node.body = self.eliminate_dead_code(node.body)
+        # node.orelse = self.eliminate_dead_code(node.orelse)
+        # return node
+
+# def eliminate_dead_code(source_code):
+    # """
+    # Eliminate dead code from the given source code.
+    
+    # :param source_code: A string containing the Python source code.
+    # :return: The transformed source code with dead code removed.
+    # """
+    # # Parse the source code into an AST
+    # tree = ast.parse(source_code)
+    
+    # # Create a transformer to eliminate dead code
+    # transformer = DeadCodeEliminator()
+    
+    # # Transform the tree by eliminating dead code
+    # transformed_tree = transformer.visit(tree)
+    
+    # # Convert the transformed AST back to source code
+    # transformed_code = astor.to_source(transformed_tree)
+    
+    # return transformed_code
+
+# # Example Usage
+# source_code = """
+# def example():
+    # x = 10
+    # if x > 5:
+        # return x
+        # print("This is dead code")
+    # else:
+        # print("This is alive")
+        # raise ValueError("This also makes code below dead")
+        # print("This is also dead code")
+
+    # print("This is unreachable")
+
+    # while x > 0:
+        # break
+        # print("Dead code after break")
+# """
+
+# # Eliminate dead code
+# transformed_code = eliminate_dead_code(source_code)
+
+# print(transformed_code)
+
+
+# NOT 
+
+
+
+
+
+
+
+
+
+
+# import ast
+# import astor
+# import random
+
+# class ExpressionRefactorer(ast.NodeTransformer):
+    # def visit_BinOp(self, node):
+        # # Reorder commutative operations: a + b -> b + a
+        # if isinstance(node.op, (ast.Add, ast.Mult, ast.BitOr, ast.BitAnd)):
+            # if isinstance(node.left, (ast.Name, ast.Constant)) and isinstance(node.right, (ast.Name, ast.Constant)):
+                # node.left, node.right = node.right, node.left
+
+        # # Optionally recurse into subexpressions
+        # self.generic_visit(node)
+        # return node
+    
+    # def visit_Assign(self, node):
+        # # Check if there are multiple assignments that can be merged or split
+        # if isinstance(node.value, ast.BinOp):
+            # if random.choice([True, False]):
+                # # Merge adjacent assignments into a single expression
+                # return self.merge_expressions(node)
+            # else:
+                # # Split a complex assignment into simpler ones
+                # return self.split_expressions(node)
+        
+        # return node
+
+    # def merge_expressions(self, node):
+        # """
+        # Merge multiple assignments into a single complex expression.
+        # """
+        # if isinstance(node.value, ast.BinOp):
+            # left_var = node.targets[0].id
+            # new_expr = ast.BinOp(
+                # left=ast.Name(id=left_var, ctx=ast.Load()),
+                # op=node.value.op,
+                # right=node.value.right
+            # )
+            # new_assign = ast.Assign(
+                # targets=[ast.Name(id=left_var, ctx=ast.Store())],
+                # value=new_expr
+            # )
+            # return new_assign
+        # return node
+    
+    # def split_expressions(self, node):
+        # """
+        # Split a complex assignment into multiple simpler ones.
+        # """
+        # if isinstance(node.value, ast.BinOp):
+            # temp_var_name = "temp_" + node.targets[0].id
+            # first_assign = ast.Assign(
+                # targets=[ast.Name(id=temp_var_name, ctx=ast.Store())],
+                # value=node.value.left
+            # )
+            # second_assign = ast.Assign(
+                # targets=node.targets,
+                # value=ast.BinOp(
+                    # left=ast.Name(id=temp_var_name, ctx=ast.Load()),
+                    # op=node.value.op,
+                    # right=node.value.right
+                # )
+            # )
+            # return [first_assign, second_assign]
+        # return node
+
+# def refactor_code(code):
+    # # Parse the code into an AST
+    # tree = ast.parse(code)
+    
+    # # Apply the refactoring
+    # refactorer = ExpressionRefactorer()
+    # refactored_tree = refactorer.visit(tree)
+    
+    # # Convert the refactored AST back to code
+    # refactored_code = astor.to_source(refactored_tree)
+    
+    # return refactored_code
+
+# # Example usage
+# original_code = """
+# a = 5
+# b = a
+# x = a + b
+# y = c * d
+
+# z = (a + b) * (c + d)
+# """
+
+# refactored_code = refactor_code(original_code)
+# print(refactored_code)