use self.mode.preview

src/black/__init__.py

@@ -1176,7 +1176,7 @@ def _format_str_once(src_contents: str, *, mode: Mode) -> str:
         for feature in {Feature.TRAILING_COMMA_IN_CALL, Feature.TRAILING_COMMA_IN_DEF}
         if supports_feature(versions, feature)
     }
-    for current_line in lines.visit(src_node, preview=mode.preview):
+    for current_line in lines.visit(src_node):
         dst_contents.append(str(empty_line) * after)
         before, after = elt.maybe_empty_lines(current_line)
         dst_contents.append(str(empty_line) * before)

src/black/debug.py

@@ -16,14 +16,14 @@
 class DebugVisitor(Visitor[T]):
     tree_depth: int = 0
 
-    def visit_default(self, node: LN, *, preview: bool) -> Iterator[T]:
+    def visit_default(self, node: LN) -> Iterator[T]:
         indent = " " * (2 * self.tree_depth)
         if isinstance(node, Node):
             _type = type_repr(node.type)
             out(f"{indent}{_type}", fg="yellow")
             self.tree_depth += 1
             for child in node.children:
-                yield from self.visit(child, preview=preview)
+                yield from self.visit(child)
 
             self.tree_depth -= 1
             out(f"{indent}/{_type}", fg="yellow", bold=False)
@@ -37,12 +37,12 @@ def visit_default(self, node: LN, *, preview: bool) -> Iterator[T]:
             out(f" {node.value!r}", fg="blue", bold=False)
 
     @classmethod
-    def show(cls, code: Union[str, Leaf, Node], *, preview: bool) -> None:
+    def show(cls, code: Union[str, Leaf, Node]) -> None:
         """Pretty-print the lib2to3 AST of a given string of `code`.
 
         Convenience method for debugging.
         """
         v: DebugVisitor[None] = DebugVisitor()
         if isinstance(code, str):
             code = lib2to3_parse(code)
-        list(v.visit(code, preview=preview))
+        list(v.visit(code))

src/black/linegen.py

@@ -68,11 +68,11 @@ def line(self, indent: int = 0) -> Iterator[Line]:
         self.current_line = Line(mode=self.mode, depth=complete_line.depth + indent)
         yield complete_line
 
-    def visit_default(self, node: LN, *, preview: bool) -> Iterator[Line]:
+    def visit_default(self, node: LN) -> Iterator[Line]:
         """Default `visit_*()` implementation. Recurses to children of `node`."""
         if isinstance(node, Leaf):
             any_open_brackets = self.current_line.bracket_tracker.any_open_brackets()
-            for comment in generate_comments(node, preview=preview):
+            for comment in generate_comments(node, preview=self.mode.preview):
                 if any_open_brackets:
                     # any comment within brackets is subject to splitting
                     self.current_line.append(comment)
@@ -96,15 +96,15 @@ def visit_default(self, node: LN, *, preview: bool) -> Iterator[Line]:
                 normalize_numeric_literal(node)
             if node.type not in WHITESPACE:
                 self.current_line.append(node)
-        yield from super().visit_default(node, preview=preview)
+        yield from super().visit_default(node)
 
-    def visit_INDENT(self, node: Leaf, *, preview: bool) -> Iterator[Line]:
+    def visit_INDENT(self, node: Leaf) -> Iterator[Line]:
         """Increase indentation level, maybe yield a line."""
         # In blib2to3 INDENT never holds comments.
         yield from self.line(+1)
-        yield from self.visit_default(node, preview=preview)
+        yield from self.visit_default(node)
 
-    def visit_DEDENT(self, node: Leaf, *, preview: bool) -> Iterator[Line]:
+    def visit_DEDENT(self, node: Leaf) -> Iterator[Line]:
         """Decrease indentation level, maybe yield a line."""
         # The current line might still wait for trailing comments.  At DEDENT time
         # there won't be any (they would be prefixes on the preceding NEWLINE).
@@ -113,13 +113,13 @@ def visit_DEDENT(self, node: Leaf, *, preview: bool) -> Iterator[Line]:
 
         # While DEDENT has no value, its prefix may contain standalone comments
         # that belong to the current indentation level.  Get 'em.
-        yield from self.visit_default(node, preview=preview)
+        yield from self.visit_default(node)
 
         # Finally, emit the dedent.
         yield from self.line(-1)
 
     def visit_stmt(
-        self, node: Node, keywords: Set[str], parens: Set[str], *, preview: bool
+        self, node: Node, keywords: Set[str], parens: Set[str]
     ) -> Iterator[Line]:
         """Visit a statement.
 
@@ -132,29 +132,29 @@ def visit_stmt(
         `parens` holds a set of string leaf values immediately after which
         invisible parens should be put.
         """
-        normalize_invisible_parens(node, parens_after=parens, preview=preview)
+        normalize_invisible_parens(node, parens_after=parens, preview=self.mode.preview)
         for child in node.children:
             if is_name_token(child) and child.value in keywords:
                 yield from self.line()
 
-            yield from self.visit(child, preview=preview)
+            yield from self.visit(child)
 
-    def visit_match_case(self, node: Node, *, preview: bool) -> Iterator[Line]:
+    def visit_match_case(self, node: Node) -> Iterator[Line]:
         """Visit either a match or case statement."""
-        normalize_invisible_parens(node, parens_after=set(), preview=preview)
+        normalize_invisible_parens(node, parens_after=set(), preview=self.mode.preview)
 
         yield from self.line()
         for child in node.children:
-            yield from self.visit(child, preview=preview)
+            yield from self.visit(child)
 
-    def visit_suite(self, node: Node, *, preview: bool) -> Iterator[Line]:
+    def visit_suite(self, node: Node) -> Iterator[Line]:
         """Visit a suite."""
         if self.mode.is_pyi and is_stub_suite(node):
-            yield from self.visit(node.children[2], preview=preview)
+            yield from self.visit(node.children[2])
         else:
-            yield from self.visit_default(node, preview=preview)
+            yield from self.visit_default(node)
 
-    def visit_simple_stmt(self, node: Node, *, preview: bool) -> Iterator[Line]:
+    def visit_simple_stmt(self, node: Node) -> Iterator[Line]:
         """Visit a statement without nested statements."""
         prev_type: Optional[int] = None
         for child in node.children:
@@ -165,10 +165,10 @@ def visit_simple_stmt(self, node: Node, *, preview: bool) -> Iterator[Line]:
         is_suite_like = node.parent and node.parent.type in STATEMENT
         if is_suite_like:
             if self.mode.is_pyi and is_stub_body(node):
-                yield from self.visit_default(node, preview=preview)
+                yield from self.visit_default(node)
             else:
                 yield from self.line(+1)
-                yield from self.visit_default(node, preview=preview)
+                yield from self.visit_default(node)
                 yield from self.line(-1)
 
         else:
@@ -178,30 +178,30 @@ def visit_simple_stmt(self, node: Node, *, preview: bool) -> Iterator[Line]:
                 or not is_stub_suite(node.parent)
             ):
                 yield from self.line()
-            yield from self.visit_default(node, preview=preview)
+            yield from self.visit_default(node)
 
-    def visit_async_stmt(self, node: Node, *, preview: bool) -> Iterator[Line]:
+    def visit_async_stmt(self, node: Node) -> Iterator[Line]:
         """Visit `async def`, `async for`, `async with`."""
         yield from self.line()
 
         children = iter(node.children)
         for child in children:
-            yield from self.visit(child, preview=preview)
+            yield from self.visit(child)
 
             if child.type == token.ASYNC:
                 break
 
         internal_stmt = next(children)
         for child in internal_stmt.children:
-            yield from self.visit(child, preview=preview)
+            yield from self.visit(child)
 
-    def visit_decorators(self, node: Node, *, preview: bool) -> Iterator[Line]:
+    def visit_decorators(self, node: Node) -> Iterator[Line]:
         """Visit decorators."""
         for child in node.children:
             yield from self.line()
-            yield from self.visit(child, preview=preview)
+            yield from self.visit(child)
 
-    def visit_power(self, node: Node, *, preview: bool) -> Iterator[Line]:
+    def visit_power(self, node: Node) -> Iterator[Line]:
         for idx, leaf in enumerate(node.children[:-1]):
             next_leaf = node.children[idx + 1]
 
@@ -221,23 +221,23 @@ def visit_power(self, node: Node, *, preview: bool) -> Iterator[Line]:
             ):
                 wrap_in_parentheses(node, leaf)
 
-        yield from self.visit_default(node, preview=preview)
+        yield from self.visit_default(node)
 
-    def visit_SEMI(self, leaf: Leaf, *, preview: bool) -> Iterator[Line]:
+    def visit_SEMI(self, leaf: Leaf) -> Iterator[Line]:
         """Remove a semicolon and put the other statement on a separate line."""
         yield from self.line()
 
-    def visit_ENDMARKER(self, leaf: Leaf, *, preview: bool) -> Iterator[Line]:
+    def visit_ENDMARKER(self, leaf: Leaf) -> Iterator[Line]:
         """End of file. Process outstanding comments and end with a newline."""
-        yield from self.visit_default(leaf, preview=preview)
+        yield from self.visit_default(leaf)
         yield from self.line()
 
-    def visit_STANDALONE_COMMENT(self, leaf: Leaf, *, preview: bool) -> Iterator[Line]:
+    def visit_STANDALONE_COMMENT(self, leaf: Leaf) -> Iterator[Line]:
         if not self.current_line.bracket_tracker.any_open_brackets():
             yield from self.line()
-        yield from self.visit_default(leaf, preview=preview)
+        yield from self.visit_default(leaf)
 
-    def visit_factor(self, node: Node, *, preview: bool) -> Iterator[Line]:
+    def visit_factor(self, node: Node) -> Iterator[Line]:
         """Force parentheses between a unary op and a binary power:
 
         -2 ** 8 -> -(2 ** 8)
@@ -252,9 +252,9 @@ def visit_factor(self, node: Node, *, preview: bool) -> Iterator[Line]:
             rpar = Leaf(token.RPAR, ")")
             index = operand.remove() or 0
             node.insert_child(index, Node(syms.atom, [lpar, operand, rpar]))
-        yield from self.visit_default(node, preview=preview)
+        yield from self.visit_default(node)
 
-    def visit_STRING(self, leaf: Leaf, *, preview: bool) -> Iterator[Line]:
+    def visit_STRING(self, leaf: Leaf) -> Iterator[Line]:
         if is_docstring(leaf) and "\\\n" not in leaf.value:
             # We're ignoring docstrings with backslash newline escapes because changing
             # indentation of those changes the AST representation of the code.
@@ -296,7 +296,7 @@ def visit_STRING(self, leaf: Leaf, *, preview: bool) -> Iterator[Line]:
             quote = quote_char * quote_len
             leaf.value = prefix + quote + docstring + quote
 
-        yield from self.visit_default(leaf, preview=preview)
+        yield from self.visit_default(leaf)
 
     def __post_init__(self) -> None:
         """You are in a twisty little maze of passages."""

src/black/nodes.py

@@ -154,7 +154,7 @@
 class Visitor(Generic[T]):
     """Basic lib2to3 visitor that yields things of type `T` on `visit()`."""
 
-    def visit(self, node: LN, *, preview: bool) -> Iterator[T]:
+    def visit(self, node: LN) -> Iterator[T]:
         """Main method to visit `node` and its children.
 
         It tries to find a `visit_*()` method for the given `node.type`, like
@@ -174,15 +174,15 @@ def visit(self, node: LN, *, preview: bool) -> Iterator[T]:
         # generate a native call to visit_default.
         visitf = getattr(self, f"visit_{name}", None)
         if visitf:
-            yield from visitf(node, preview=preview)
+            yield from visitf(node)
         else:
-            yield from self.visit_default(node, preview=preview)
+            yield from self.visit_default(node)
 
-    def visit_default(self, node: LN, *, preview: bool) -> Iterator[T]:
+    def visit_default(self, node: LN) -> Iterator[T]:
         """Default `visit_*()` implementation. Recurses to children of `node`."""
         if isinstance(node, Node):
             for child in node.children:
-                yield from self.visit(child, preview=preview)
+                yield from self.visit(child)
 
 
 def whitespace(leaf: Leaf, *, complex_subscript: bool) -> str:  # noqa: C901

tests/test_black.py

@@ -857,7 +857,7 @@ def err(msg: str, **kwargs: Any) -> None:
             err_lines.append(msg)
 
         with patch("black.debug.out", out):
-            DebugVisitor.show(source, preview=False)
+            DebugVisitor.show(source)
         actual = "\n".join(out_lines) + "\n"
         log_name = ""
         if expected != actual:

tests/util.py

@@ -29,21 +29,21 @@
 fs = partial(black.format_str, mode=DEFAULT_MODE)
 
 
-def _assert_format_equal(expected: str, actual: str, *, preview: bool) -> None:
+def _assert_format_equal(expected: str, actual: str) -> None:
     if actual != expected and not os.environ.get("SKIP_AST_PRINT"):
         bdv: DebugVisitor[Any]
         out("Expected tree:", fg="green")
         try:
             exp_node = black.lib2to3_parse(expected)
             bdv = DebugVisitor()
-            list(bdv.visit(exp_node, preview=preview))
+            list(bdv.visit(exp_node))
         except Exception as ve:
             err(str(ve))
         out("Actual tree:", fg="red")
         try:
             exp_node = black.lib2to3_parse(actual)
             bdv = DebugVisitor()
-            list(bdv.visit(exp_node, preview=preview))
+            list(bdv.visit(exp_node))
         except Exception as ve:
             err(str(ve))
 
@@ -68,7 +68,7 @@ def assert_format(
     separate from TargetVerson Mode configuration.
     """
     actual = black.format_str(source, mode=mode)
-    _assert_format_equal(expected, actual, preview=mode.preview)
+    _assert_format_equal(expected, actual)
     # It's not useful to run safety checks if we're expecting no changes anyway. The
     # assertion right above will raise if reality does actually make changes. This just
     # avoids wasted CPU cycles.
@@ -87,7 +87,7 @@ def dump_to_stderr(*output: str) -> str:
 
 class BlackBaseTestCase(unittest.TestCase):
     def assertFormatEqual(self, expected: str, actual: str) -> None:
-        _assert_format_equal(expected, actual, preview=False)
+        _assert_format_equal(expected, actual)
 
 
 def read_data(name: str, data: bool = True) -> Tuple[str, str]: