Function maybe_make_parens_invisible_in_atom

src/black/linegen.py:1803–1913

If it's safe, make the parens in the atom `node` invisible, recursively. Additionally, remove repeated, adjacent invisible parens from the atom `node` as they are redundant. Returns whether the node should itself be wrapped in invisible parentheses.

(
    node: LN,
    parent: LN,
    mode: Mode,
    features: Collection[Feature],
    remove_brackets_around_comma: bool = False,
    allow_star_expr: bool = False,
)

def maybe_make_parens_invisible_in_atom(
    node: LN,
    parent: LN,
    mode: Mode,
    features: Collection[Feature],
    remove_brackets_around_comma: bool = False,
    allow_star_expr: bool = False,
) -> bool:
    """If it's safe, make the parens in the atom `node` invisible, recursively.
    Additionally, remove repeated, adjacent invisible parens from the atom `node`
    as they are redundant.

    Returns whether the node should itself be wrapped in invisible parentheses.
    """
    if (
        node.type not in (syms.atom, syms.expr)
        or is_empty_tuple(node)
        or is_one_tuple(node)
        or (is_tuple(node) and parent.type == syms.asexpr_test)
        or (
            is_tuple(node)
            and parent.type == syms.with_stmt
            and has_sibling_with_type(node, token.COMMA)
        )
        or (is_yield(node) and parent.type != syms.expr_stmt)
        or (
            # This condition tries to prevent removing non-optional brackets
            # around a tuple, however, can be a bit overzealous so we provide
            # and option to skip this check for `for` and `with` statements.
            not remove_brackets_around_comma
            and max_delimiter_priority_in_atom(node) >= COMMA_PRIORITY
            # Remove parentheses around multiple exception types in except and
            # except* without as. See PEP 758 for details.
            and not (
                Feature.UNPARENTHESIZED_EXCEPT_TYPES in features
                # is a tuple
                and is_tuple(node)
                # has a parent node
                and node.parent is not None
                # parent is an except clause
                and node.parent.type == syms.except_clause
                # is not immediately followed by as clause
                and not (
                    node.next_sibling is not None
                    and is_name_token(node.next_sibling)
                    and node.next_sibling.value == "as"
                )
            )
        )
        or is_tuple_containing_walrus(node)
        or (not allow_star_expr and is_tuple_containing_star(node))
        or is_generator(node)
    ):
        return False

    if is_walrus_assignment(node):
        if parent.type in [
            syms.annassign,