Maintainability and Legacy Code Questions

import java.util.ArrayDeque;
import java.util.Deque;

class TreeNode {
    long val;
    TreeNode left, right;
    TreeNode(long v){ val = v; }
}

public long sum(TreeNode root) {
    if (root == null) return 0;
    long total = 0;
    Deque<TreeNode> stack = new ArrayDeque<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        total += node.val;
        // push children — push left then right or vice versa doesn't matter for sum
        if (node.right != null) stack.push(node.right);
        if (node.left  != null) stack.push(node.left);
    }
    return total;
}

# python
import ast, astor, pathlib

OLD_OBJ = ("old_logger",)  # could be names or attributes
NEW_OBJ = "new_logger"

class RefactorTransformer(ast.NodeTransformer):
    def visit_Call(self, node):
        # visit children first
        self.generic_visit(node)
        # match attribute call: X.log(...)
        if isinstance(node.func, ast.Attribute) and node.func.attr == "log":
            # check receiver name is old_logger (simple case)
            target = node.func.value
            if isinstance(target, ast.Name) and target.id in OLD_OBJ:
                # check if 'context' already provided
                has_context = any(
                    isinstance(kw, ast.keyword) and kw.arg == "context" for kw in node.keywords
                )
                if not has_context:
                    # change receiver to new_logger
                    node.func.value = ast.copy_location(ast.Name(id=NEW_OBJ, ctx=ast.Load()), target)
                    # append context kwarg = {}
                    node.keywords.append(ast.keyword(arg="context", value=ast.Dict(keys=[], values=[])))
        return node

def rewrite_file(path: pathlib.Path):
    src = path.read_text()
    tree = ast.parse(src)
    new_tree = RefactorTransformer().visit(tree)
    ast.fix_missing_locations(new_tree)
    new_src = astor.to_source(new_tree)
    path.write_text(new_src)

# iterate repo
for p in pathlib.Path("path/to/repo").rglob("*.py"):
    rewrite_file(p)

from functools import wraps

# injectable logger for testability
def default_logger(action, data):
    print(f"{action}: {data}")

def require_fields(*fields):
    """Return a validator function that raises ValueError if required fields missing."""
    def validator(data):
        missing = [f for f in fields if not data.get(f)]
        if missing:
            raise ValueError(f"Missing fields: {', '.join(missing)}")
    return validator

def validate_and_log(validator, logger=default_logger, action_name=None):
    """Decorator to run validation and logging before the core action."""
    def decorator(func):
        name = action_name or func.__name__
        @wraps(func)
        def wrapper(data, *args, **kwargs):
            validator(data)
            logger(name, data)
            return func(data, *args, **kwargs)
        return wrapper
    return decorator

# Core action implementations are now focused and easy to test
@validate_and_log(require_fields('email'), action_name='create')
def create_user(data):
    # perform create logic
    return {"status": "created", "email": data['email']}

@validate_and_log(require_fields('id', 'email'), action_name='update')
def update_user(data):
    # perform update logic
    return {"status": "updated", "id": data['id']}

@validate_and_log(require_fields('id'), action_name='delete')
def delete_user(data):
    # perform delete logic
    return {"status": "deleted", "id": data['id']}