Improvements to contributing docs (#3753)

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

diff --git a/src/black/lines.py b/src/black/lines.py
index 0d074534defe491b81ad16a29b51bc48f30c08f9..ea8fe520756d3a61702cf9e81453416bf534b632 100644 (file)
--- a/src/black/lines.py
+++ b/src/black/lines.py
@@ -1,4 +1,5 @@
 import itertools
 import itertools

+import math

 import sys
 from dataclasses import dataclass, field
 from typing import (
 import sys
 from dataclasses import dataclass, field
 from typing import (


@@ -10,10 +11,11 @@ from typing import (
     Sequence,
     Tuple,
     TypeVar,
     Sequence,
     Tuple,
     TypeVar,

+    Union,

     cast,
 )
 
     cast,
 )
 

-from black.brackets import DOT_PRIORITY, BracketTracker
+from black.brackets import COMMA_PRIORITY, DOT_PRIORITY, BracketTracker

 from black.mode import Mode, Preview
 from black.nodes import (
     BRACKETS,
 from black.mode import Mode, Preview
 from black.nodes import (
     BRACKETS,


@@ -26,10 +28,13 @@ from black.nodes import (
     is_multiline_string,
     is_one_sequence_between,
     is_type_comment,
     is_multiline_string,
     is_one_sequence_between,
     is_type_comment,

+    is_type_ignore_comment,
+    is_with_or_async_with_stmt,

     replace_child,
     syms,
     whitespace,
 )
     replace_child,
     syms,
     whitespace,
 )

+from black.strings import str_width

 from blib2to3.pgen2 import token
 from blib2to3.pytree import Leaf, Node
 
 from blib2to3.pgen2 import token
 from blib2to3.pytree import Leaf, Node
 


@@ -37,6 +42,7 @@ from blib2to3.pytree import Leaf, Node
 T = TypeVar("T")
 Index = int
 LeafID = int
 T = TypeVar("T")
 Index = int
 LeafID = int

+LN = Union[Leaf, Node]

 
 
 @dataclass
 
 
 @dataclass


@@ -53,7 +59,9 @@ class Line:
     should_split_rhs: bool = False
     magic_trailing_comma: Optional[Leaf] = None
 
     should_split_rhs: bool = False
     magic_trailing_comma: Optional[Leaf] = None
 

-    def append(self, leaf: Leaf, preformatted: bool = False) -> None:
+    def append(
+        self, leaf: Leaf, preformatted: bool = False, track_bracket: bool = False
+    ) -> None:

         """Add a new `leaf` to the end of the line.
 
         Unless `preformatted` is True, the `leaf` will receive a new consistent
         """Add a new `leaf` to the end of the line.
 
         Unless `preformatted` is True, the `leaf` will receive a new consistent


@@ -75,7 +83,7 @@ class Line:
             leaf.prefix += whitespace(
                 leaf, complex_subscript=self.is_complex_subscript(leaf)
             )
             leaf.prefix += whitespace(
                 leaf, complex_subscript=self.is_complex_subscript(leaf)
             )

-        if self.inside_brackets or not preformatted:
+        if self.inside_brackets or not preformatted or track_bracket:

             self.bracket_tracker.mark(leaf)
             if self.mode.magic_trailing_comma:
                 if self.has_magic_trailing_comma(leaf):
             self.bracket_tracker.mark(leaf)
             if self.mode.magic_trailing_comma:
                 if self.has_magic_trailing_comma(leaf):


@@ -117,6 +125,11 @@ class Line:
         """Is this an import line?"""
         return bool(self) and is_import(self.leaves[0])
 
         """Is this an import line?"""
         return bool(self) and is_import(self.leaves[0])
 

+    @property
+    def is_with_or_async_with_stmt(self) -> bool:
+        """Is this a with_stmt line?"""
+        return bool(self) and is_with_or_async_with_stmt(self.leaves[0])
+

     @property
     def is_class(self) -> bool:
         """Is this line a class definition?"""
     @property
     def is_class(self) -> bool:
         """Is this line a class definition?"""


@@ -184,6 +197,26 @@ class Line:
             return False
         return self.leaves[-1].type == token.COLON
 
             return False
         return self.leaves[-1].type == token.COLON
 

+    def is_fmt_pass_converted(
+        self, *, first_leaf_matches: Optional[Callable[[Leaf], bool]] = None
+    ) -> bool:
+        """Is this line converted from fmt off/skip code?
+
+        If first_leaf_matches is not None, it only returns True if the first
+        leaf of converted code matches.
+        """
+        if len(self.leaves) != 1:
+            return False
+        leaf = self.leaves[0]
+        if (
+            leaf.type != STANDALONE_COMMENT
+            or leaf.fmt_pass_converted_first_leaf is None
+        ):
+            return False
+        return first_leaf_matches is None or first_leaf_matches(
+            leaf.fmt_pass_converted_first_leaf
+        )
+

     def contains_standalone_comments(self, depth_limit: int = sys.maxsize) -> bool:
         """If so, needs to be split before emitting."""
         for leaf in self.leaves:
     def contains_standalone_comments(self, depth_limit: int = sys.maxsize) -> bool:
         """If so, needs to be split before emitting."""
         for leaf in self.leaves:


@@ -219,7 +252,7 @@ class Line:
             for comment in comments:
                 if is_type_comment(comment):
                     if comment_seen or (
             for comment in comments:
                 if is_type_comment(comment):
                     if comment_seen or (

-                        not is_type_comment(comment, " ignore")
+                        not is_type_ignore_comment(comment)

                         and leaf_id not in ignored_ids
                     ):
                         return True
                         and leaf_id not in ignored_ids
                     ):
                         return True


@@ -256,7 +289,7 @@ class Line:
             # line.
             for node in self.leaves[-2:]:
                 for comment in self.comments.get(id(node), []):
             # line.
             for node in self.leaves[-2:]:
                 for comment in self.comments.get(id(node), []):

-                    if is_type_comment(comment, " ignore"):
+                    if is_type_ignore_comment(comment):

                         return True
 
         return False
                         return True
 
         return False


@@ -273,8 +306,7 @@ class Line:
         - it's not a single-element subscript
         Additionally, if ensure_removable:
         - it's not from square bracket indexing
         - it's not a single-element subscript
         Additionally, if ensure_removable:
         - it's not from square bracket indexing

-        (specifically, single-element square bracket indexing with
-        Preview.skip_magic_trailing_comma_in_subscript)
+        (specifically, single-element square bracket indexing)

         """
         if not (
             closing.type in CLOSING_BRACKETS
         """
         if not (
             closing.type in CLOSING_BRACKETS


@@ -288,8 +320,7 @@ class Line:
 
         if closing.type == token.RSQB:
             if (
 
         if closing.type == token.RSQB:
             if (

-                Preview.one_element_subscript in self.mode
-                and closing.parent
+                closing.parent

                 and closing.parent.type == syms.trailer
                 and closing.opening_bracket
                 and is_one_sequence_between(
                 and closing.parent.type == syms.trailer
                 and closing.opening_bracket
                 and is_one_sequence_between(


@@ -307,18 +338,16 @@ class Line:
             comma = self.leaves[-1]
             if comma.parent is None:
                 return False
             comma = self.leaves[-1]
             if comma.parent is None:
                 return False

-            if Preview.skip_magic_trailing_comma_in_subscript in self.mode:
-                return (
-                    comma.parent.type != syms.subscriptlist
-                    or closing.opening_bracket is None
-                    or not is_one_sequence_between(
-                        closing.opening_bracket,
-                        closing,
-                        self.leaves,
-                        brackets=(token.LSQB, token.RSQB),
-                    )
+            return (
+                comma.parent.type != syms.subscriptlist
+                or closing.opening_bracket is None
+                or not is_one_sequence_between(
+                    closing.opening_bracket,
+                    closing,
+                    self.leaves,
+                    brackets=(token.LSQB, token.RSQB),

                 )
                 )

-            return comma.parent.type == syms.listmaker
+            )

 
         if self.is_import:
             return True
 
         if self.is_import:
             return True


@@ -448,6 +477,17 @@ class Line:
         return bool(self.leaves or self.comments)
 
 
         return bool(self.leaves or self.comments)
 
 

+@dataclass
+class RHSResult:
+    """Intermediate split result from a right hand split."""
+
+    head: Line
+    body: Line
+    tail: Line
+    opening_bracket: Leaf
+    closing_bracket: Leaf
+
+

 @dataclass
 class LinesBlock:
     """Class that holds information about a block of formatted lines.
 @dataclass
 class LinesBlock:
     """Class that holds information about a block of formatted lines.


@@ -483,7 +523,7 @@ class EmptyLineTracker:
     mode: Mode
     previous_line: Optional[Line] = None
     previous_block: Optional[LinesBlock] = None
     mode: Mode
     previous_line: Optional[Line] = None
     previous_block: Optional[LinesBlock] = None

-    previous_defs: List[int] = field(default_factory=list)
+    previous_defs: List[Line] = field(default_factory=list)

     semantic_leading_comment: Optional[LinesBlock] = None
 
     def maybe_empty_lines(self, current_line: Line) -> LinesBlock:
     semantic_leading_comment: Optional[LinesBlock] = None
 
     def maybe_empty_lines(self, current_line: Line) -> LinesBlock:


@@ -518,7 +558,8 @@ class EmptyLineTracker:
                 and (self.semantic_leading_comment is None or before)
             ):
                 self.semantic_leading_comment = block
                 and (self.semantic_leading_comment is None or before)
             ):
                 self.semantic_leading_comment = block

-        elif not current_line.is_decorator:
+        # `or before` means this decorator already has an empty line before
+        elif not current_line.is_decorator or before:

             self.semantic_leading_comment = None
 
         self.previous_line = current_line
             self.semantic_leading_comment = None
 
         self.previous_line = current_line


@@ -538,12 +579,18 @@ class EmptyLineTracker:
         else:
             before = 0
         depth = current_line.depth
         else:
             before = 0
         depth = current_line.depth

-        while self.previous_defs and self.previous_defs[-1] >= depth:
+        while self.previous_defs and self.previous_defs[-1].depth >= depth:

             if self.mode.is_pyi:
                 assert self.previous_line is not None
                 if depth and not current_line.is_def and self.previous_line.is_def:
                     # Empty lines between attributes and methods should be preserved.
                     before = min(1, before)
             if self.mode.is_pyi:
                 assert self.previous_line is not None
                 if depth and not current_line.is_def and self.previous_line.is_def:
                     # Empty lines between attributes and methods should be preserved.
                     before = min(1, before)

+                elif (
+                    Preview.blank_line_after_nested_stub_class in self.mode
+                    and self.previous_defs[-1].is_class
+                    and not self.previous_defs[-1].is_stub_class
+                ):
+                    before = 1

                 elif depth:
                     before = 0
                 else:
                 elif depth:
                     before = 0
                 else:


@@ -553,7 +600,7 @@ class EmptyLineTracker:
                     before = 1
                 elif (
                     not depth
                     before = 1
                 elif (
                     not depth

-                    and self.previous_defs[-1]
+                    and self.previous_defs[-1].depth

                     and current_line.leaves[-1].type == token.COLON
                     and (
                         current_line.leaves[0].value
                     and current_line.leaves[-1].type == token.COLON
                     and (
                         current_line.leaves[0].value


@@ -578,6 +625,7 @@ class EmptyLineTracker:
             self.previous_line
             and self.previous_line.is_import
             and not current_line.is_import
             self.previous_line
             and self.previous_line.is_import
             and not current_line.is_import

+            and not current_line.is_fmt_pass_converted(first_leaf_matches=is_import)

             and depth == self.previous_line.depth
         ):
             return (before or 1), 0
             and depth == self.previous_line.depth
         ):
             return (before or 1), 0


@@ -587,13 +635,11 @@ class EmptyLineTracker:
             and self.previous_line.is_class
             and current_line.is_triple_quoted_string
         ):
             and self.previous_line.is_class
             and current_line.is_triple_quoted_string
         ):

+            if Preview.no_blank_line_before_class_docstring in current_line.mode:
+                return 0, 1

             return before, 1
 
             return before, 1
 

-        if (
-            Preview.remove_block_trailing_newline in current_line.mode
-            and self.previous_line
-            and self.previous_line.opens_block
-        ):
+        if self.previous_line and self.previous_line.opens_block:

             return 0, 0
         return before, 0
 
             return 0, 0
         return before, 0
 


@@ -601,7 +647,7 @@ class EmptyLineTracker:
         self, current_line: Line, before: int
     ) -> Tuple[int, int]:
         if not current_line.is_decorator:
         self, current_line: Line, before: int
     ) -> Tuple[int, int]:
         if not current_line.is_decorator:

-            self.previous_defs.append(current_line.depth)
+            self.previous_defs.append(current_line)

         if self.previous_line is None:
             # Don't insert empty lines before the first line in the file.
             return 0, 0
         if self.previous_line is None:
             # Don't insert empty lines before the first line in the file.
             return 0, 0


@@ -626,9 +672,7 @@ class EmptyLineTracker:
         ):
             slc = self.semantic_leading_comment
             if (
         ):
             slc = self.semantic_leading_comment
             if (

-                Preview.empty_lines_before_class_or_def_with_leading_comments
-                in current_line.mode
-                and slc is not None
+                slc is not None

                 and slc.previous_block is not None
                 and not slc.previous_block.original_line.is_class
                 and not slc.previous_block.original_line.opens_block
                 and slc.previous_block is not None
                 and not slc.previous_block.original_line.is_class
                 and not slc.previous_block.original_line.opens_block


@@ -708,18 +752,95 @@ def append_leaves(
             new_line.append(comment_leaf, preformatted=True)
 
 
             new_line.append(comment_leaf, preformatted=True)
 
 

-def is_line_short_enough(line: Line, *, line_length: int, line_str: str = "") -> bool:
-    """Return True if `line` is no longer than `line_length`.
-
+def is_line_short_enough(  # noqa: C901
+    line: Line, *, mode: Mode, line_str: str = ""
+) -> bool:
+    """For non-multiline strings, return True if `line` is no longer than `line_length`.
+    For multiline strings, looks at the context around `line` to determine
+    if it should be inlined or split up.

     Uses the provided `line_str` rendering, if any, otherwise computes a new one.
     """
     if not line_str:
         line_str = line_to_string(line)
     Uses the provided `line_str` rendering, if any, otherwise computes a new one.
     """
     if not line_str:
         line_str = line_to_string(line)

-    return (
-        len(line_str) <= line_length
-        and "\n" not in line_str  # multiline strings
-        and not line.contains_standalone_comments()
-    )
+
+    width = str_width if mode.preview else len
+
+    if Preview.multiline_string_handling not in mode:
+        return (
+            width(line_str) <= mode.line_length
+            and "\n" not in line_str  # multiline strings
+            and not line.contains_standalone_comments()
+        )
+
+    if line.contains_standalone_comments():
+        return False
+    if "\n" not in line_str:
+        # No multiline strings (MLS) present
+        return width(line_str) <= mode.line_length
+
+    first, *_, last = line_str.split("\n")
+    if width(first) > mode.line_length or width(last) > mode.line_length:
+        return False
+
+    # Traverse the AST to examine the context of the multiline string (MLS),
+    # tracking aspects such as depth and comma existence,
+    # to determine whether to split the MLS or keep it together.
+    # Depth (which is based on the existing bracket_depth concept)
+    # is needed to determine nesting level of the MLS.
+    # Includes special case for trailing commas.
+    commas: List[int] = []  # tracks number of commas per depth level
+    multiline_string: Optional[Leaf] = None
+    # store the leaves that contain parts of the MLS
+    multiline_string_contexts: List[LN] = []
+
+    max_level_to_update: Union[int, float] = math.inf  # track the depth of the MLS
+    for i, leaf in enumerate(line.leaves):
+        if max_level_to_update == math.inf:
+            had_comma: Optional[int] = None
+            if leaf.bracket_depth + 1 > len(commas):
+                commas.append(0)
+            elif leaf.bracket_depth + 1 < len(commas):
+                had_comma = commas.pop()
+            if (
+                had_comma is not None
+                and multiline_string is not None
+                and multiline_string.bracket_depth == leaf.bracket_depth + 1
+            ):
+                # Have left the level with the MLS, stop tracking commas
+                max_level_to_update = leaf.bracket_depth
+                if had_comma > 0:
+                    # MLS was in parens with at least one comma - force split
+                    return False
+
+        if leaf.bracket_depth <= max_level_to_update and leaf.type == token.COMMA:
+            # Ignore non-nested trailing comma
+            # directly after MLS/MLS-containing expression
+            ignore_ctxs: List[Optional[LN]] = [None]
+            ignore_ctxs += multiline_string_contexts
+            if not (leaf.prev_sibling in ignore_ctxs and i == len(line.leaves) - 1):
+                commas[leaf.bracket_depth] += 1
+        if max_level_to_update != math.inf:
+            max_level_to_update = min(max_level_to_update, leaf.bracket_depth)
+
+        if is_multiline_string(leaf):
+            if len(multiline_string_contexts) > 0:
+                # >1 multiline string cannot fit on a single line - force split
+                return False
+            multiline_string = leaf
+            ctx: LN = leaf
+            # fetch the leaf components of the MLS in the AST
+            while str(ctx) in line_str:
+                multiline_string_contexts.append(ctx)
+                if ctx.parent is None:
+                    break
+                ctx = ctx.parent
+
+    # May not have a triple-quoted multiline string at all,
+    # in case of a regular string with embedded newlines and line continuations
+    if len(multiline_string_contexts) == 0:
+        return True
+
+    return all(val == 0 for val in commas)

 
 
 def can_be_split(line: Line) -> bool:
 
 
 def can_be_split(line: Line) -> bool:


@@ -759,25 +880,42 @@ def can_be_split(line: Line) -> bool:
 
 
 def can_omit_invisible_parens(
 
 
 def can_omit_invisible_parens(

-    line: Line,
+    rhs: RHSResult,

     line_length: int,
 ) -> bool:
     line_length: int,
 ) -> bool:

-    """Does `line` have a shape safe to reformat without optional parens around it?
+    """Does `rhs.body` have a shape safe to reformat without optional parens around it?

 
     Returns True for only a subset of potentially nice looking formattings but
     the point is to not return false positives that end up producing lines that
     are too long.
     """
 
     Returns True for only a subset of potentially nice looking formattings but
     the point is to not return false positives that end up producing lines that
     are too long.
     """

+    line = rhs.body

     bt = line.bracket_tracker
     if not bt.delimiters:
         # Without delimiters the optional parentheses are useless.
         return True
 
     max_priority = bt.max_delimiter_priority()
     bt = line.bracket_tracker
     if not bt.delimiters:
         # Without delimiters the optional parentheses are useless.
         return True
 
     max_priority = bt.max_delimiter_priority()

-    if bt.delimiter_count_with_priority(max_priority) > 1:
+    delimiter_count = bt.delimiter_count_with_priority(max_priority)
+    if delimiter_count > 1:

         # With more than one delimiter of a kind the optional parentheses read better.
         return False
 
         # With more than one delimiter of a kind the optional parentheses read better.
         return False
 

+    if delimiter_count == 1:
+        if (
+            Preview.wrap_multiple_context_managers_in_parens in line.mode
+            and max_priority == COMMA_PRIORITY
+            and rhs.head.is_with_or_async_with_stmt
+        ):
+            # For two context manager with statements, the optional parentheses read
+            # better. In this case, `rhs.body` is the context managers part of
+            # the with statement. `rhs.head` is the `with (` part on the previous
+            # line.
+            return False
+        # Otherwise it may also read better, but we don't do it today and requires
+        # careful considerations for all possible cases. See
+        # https://github.com/psf/black/issues/2156.
+

     if max_priority == DOT_PRIORITY:
         # A single stranded method call doesn't require optional parentheses.
         return True
     if max_priority == DOT_PRIORITY:
         # A single stranded method call doesn't require optional parentheses.
         return True