[pre-commit.ci] pre-commit autoupdate (#3837)

[etc/vim.git] / src / black / nodes.py

diff --git a/src/black/nodes.py b/src/black/nodes.py
index 8f341ab35d63e6e9212489bc1f4bdaf8de04909e..45423b2596be6946b203151c9a93200e25eb92df 100644 (file)
--- a/src/black/nodes.py
+++ b/src/black/nodes.py
@@ -3,12 +3,8 @@ blib2to3 Node/Leaf transformation-related utility functions.
 """
 
 import sys
 """
 
 import sys

-from typing import Generic, Iterator, List, Optional, Set, Tuple, TypeVar, Union
+from typing import Final, Generic, Iterator, List, Optional, Set, Tuple, TypeVar, Union

 
 

-if sys.version_info >= (3, 8):
-    from typing import Final
-else:
-    from typing_extensions import Final

 if sys.version_info >= (3, 10):
     from typing import TypeGuard
 else:
 if sys.version_info >= (3, 10):
     from typing import TypeGuard
 else:


@@ -181,9 +177,9 @@ def whitespace(leaf: Leaf, *, complex_subscript: bool) -> str:  # noqa: C901
     `complex_subscript` signals whether the given leaf is part of a subscription
     which has non-trivial arguments, like arithmetic expressions or function calls.
     """
     `complex_subscript` signals whether the given leaf is part of a subscription
     which has non-trivial arguments, like arithmetic expressions or function calls.
     """

-    NO: Final = ""
-    SPACE: Final = " "
-    DOUBLESPACE: Final = "  "
+    NO: Final[str] = ""
+    SPACE: Final[str] = " "
+    DOUBLESPACE: Final[str] = "  "

     t = leaf.type
     p = leaf.parent
     v = leaf.value
     t = leaf.type
     p = leaf.parent
     v = leaf.value


@@ -502,12 +498,14 @@ def container_of(leaf: Leaf) -> LN:
     return container
 
 
     return container
 
 

-def first_leaf_column(node: Node) -> Optional[int]:
-    """Returns the column of the first leaf child of a node."""
-    for child in node.children:
-        if isinstance(child, Leaf):
-            return child.column
-    return None
+def first_leaf_of(node: LN) -> Optional[Leaf]:
+    """Returns the first leaf of the node tree."""
+    if isinstance(node, Leaf):
+        return node
+    if node.children:
+        return first_leaf_of(node.children[0])
+    else:
+        return None

 
 
 def is_arith_like(node: LN) -> bool:
 
 
 def is_arith_like(node: LN) -> bool:


@@ -561,6 +559,17 @@ def is_one_tuple(node: LN) -> bool:
     )
 
 
     )
 
 

+def is_tuple_containing_walrus(node: LN) -> bool:
+    """Return True if `node` holds a tuple that contains a walrus operator."""
+    if node.type != syms.atom:
+        return False
+    gexp = unwrap_singleton_parenthesis(node)
+    if gexp is None or gexp.type != syms.testlist_gexp:
+        return False
+
+    return any(child.type == syms.namedexpr_test for child in gexp.children)
+
+

 def is_one_sequence_between(
     opening: Leaf,
     closing: Leaf,
 def is_one_sequence_between(
     opening: Leaf,
     closing: Leaf,


@@ -705,6 +714,11 @@ def is_multiline_string(leaf: Leaf) -> bool:
 
 def is_stub_suite(node: Node) -> bool:
     """Return True if `node` is a suite with a stub body."""
 
 def is_stub_suite(node: Node) -> bool:
     """Return True if `node` is a suite with a stub body."""

+
+    # If there is a comment, we want to keep it.
+    if node.prefix.strip():
+        return False
+

     if (
         len(node.children) != 4
         or node.children[0].type != token.NEWLINE
     if (
         len(node.children) != 4
         or node.children[0].type != token.NEWLINE


@@ -713,6 +727,9 @@ def is_stub_suite(node: Node) -> bool:
     ):
         return False
 
     ):
         return False
 

+    if node.children[3].prefix.strip():
+        return False
+

     return is_stub_body(node.children[2])
 
 
     return is_stub_body(node.children[2])
 
 


@@ -726,7 +743,8 @@ def is_stub_body(node: LN) -> bool:
 
     child = node.children[0]
     return (
 
     child = node.children[0]
     return (

-        child.type == syms.atom
+        not child.prefix.strip()
+        and child.type == syms.atom

         and len(child.children) == 3
         and all(leaf == Leaf(token.DOT, ".") for leaf in child.children)
     )
         and len(child.children) == 3
         and all(leaf == Leaf(token.DOT, ".") for leaf in child.children)
     )


@@ -776,12 +794,54 @@ def is_import(leaf: Leaf) -> bool:
     )
 
 
     )
 
 

-def is_type_comment(leaf: Leaf, suffix: str = "") -> bool:
-    """Return True if the given leaf is a special comment.
-    Only returns true for type comments for now."""
+def is_with_or_async_with_stmt(leaf: Leaf) -> bool:
+    """Return True if the given leaf starts a with or async with statement."""
+    return bool(
+        leaf.type == token.NAME
+        and leaf.value == "with"
+        and leaf.parent
+        and leaf.parent.type == syms.with_stmt
+    ) or bool(
+        leaf.type == token.ASYNC
+        and leaf.next_sibling
+        and leaf.next_sibling.type == syms.with_stmt
+    )
+
+
+def is_async_stmt_or_funcdef(leaf: Leaf) -> bool:
+    """Return True if the given leaf starts an async def/for/with statement.
+
+    Note that `async def` can be either an `async_stmt` or `async_funcdef`,
+    the latter is used when it has decorators.
+    """
+    return bool(
+        leaf.type == token.ASYNC
+        and leaf.parent
+        and leaf.parent.type in {syms.async_stmt, syms.async_funcdef}
+    )
+
+
+def is_type_comment(leaf: Leaf) -> bool:
+    """Return True if the given leaf is a type comment. This function should only
+    be used for general type comments (excluding ignore annotations, which should
+    use `is_type_ignore_comment`). Note that general type comments are no longer
+    used in modern version of Python, this function may be deprecated in the future."""

     t = leaf.type
     v = leaf.value
     t = leaf.type
     v = leaf.value

-    return t in {token.COMMENT, STANDALONE_COMMENT} and v.startswith("# type:" + suffix)
+    return t in {token.COMMENT, STANDALONE_COMMENT} and v.startswith("# type:")
+
+
+def is_type_ignore_comment(leaf: Leaf) -> bool:
+    """Return True if the given leaf is a type comment with ignore annotation."""
+    t = leaf.type
+    v = leaf.value
+    return t in {token.COMMENT, STANDALONE_COMMENT} and is_type_ignore_comment_string(v)
+
+
+def is_type_ignore_comment_string(value: str) -> bool:
+    """Return True if the given string match with type comment with
+    ignore annotation."""
+    return value.startswith("# type: ignore")

 
 
 def wrap_in_parentheses(parent: Node, child: LN, *, visible: bool = True) -> None:
 
 
 def wrap_in_parentheses(parent: Node, child: LN, *, visible: bool = True) -> None:


@@ -846,3 +906,15 @@ def is_string_token(nl: NL) -> TypeGuard[Leaf]:
 
 def is_number_token(nl: NL) -> TypeGuard[Leaf]:
     return nl.type == token.NUMBER
 
 def is_number_token(nl: NL) -> TypeGuard[Leaf]:
     return nl.type == token.NUMBER

+
+
+def is_part_of_annotation(leaf: Leaf) -> bool:
+    """Returns whether this leaf is part of type annotations."""
+    ancestor = leaf.parent
+    while ancestor is not None:
+        if ancestor.prev_sibling and ancestor.prev_sibling.type == token.RARROW:
+            return True
+        if ancestor.parent and ancestor.parent.type == syms.tname:
+            return True
+        ancestor = ancestor.parent
+    return False