]> git.madduck.net Git - etc/vim.git/blob - src/black/__init__.py

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

67eef95390d76693be184a7f67c81836b28e8409
[etc/vim.git] / src / black / __init__.py
1 import ast
2 import asyncio
3 from abc import ABC, abstractmethod
4 from collections import defaultdict
5 from concurrent.futures import Executor, ThreadPoolExecutor, ProcessPoolExecutor
6 from contextlib import contextmanager
7 from datetime import datetime
8 from enum import Enum
9 from functools import lru_cache, partial, wraps
10 import io
11 import itertools
12 import logging
13 from multiprocessing import Manager, freeze_support
14 import os
15 from pathlib import Path
16 import pickle
17 import regex as re
18 import signal
19 import sys
20 import tempfile
21 import tokenize
22 import traceback
23 from typing import (
24     Any,
25     Callable,
26     Collection,
27     Dict,
28     Generator,
29     Generic,
30     Iterable,
31     Iterator,
32     List,
33     Optional,
34     Pattern,
35     Sequence,
36     Set,
37     Sized,
38     Tuple,
39     Type,
40     TypeVar,
41     Union,
42     cast,
43     TYPE_CHECKING,
44 )
45 from mypy_extensions import mypyc_attr
46
47 from appdirs import user_cache_dir
48 from dataclasses import dataclass, field, replace
49 import click
50 import toml
51 from typed_ast import ast3, ast27
52 from pathspec import PathSpec
53
54 # lib2to3 fork
55 from blib2to3.pytree import Node, Leaf, type_repr
56 from blib2to3 import pygram, pytree
57 from blib2to3.pgen2 import driver, token
58 from blib2to3.pgen2.grammar import Grammar
59 from blib2to3.pgen2.parse import ParseError
60
61 from _black_version import version as __version__
62
63 if sys.version_info < (3, 8):
64     from typing_extensions import Final
65 else:
66     from typing import Final
67
68 if TYPE_CHECKING:
69     import colorama  # noqa: F401
70
71 DEFAULT_LINE_LENGTH = 88
72 DEFAULT_EXCLUDES = r"/(\.direnv|\.eggs|\.git|\.hg|\.mypy_cache|\.nox|\.tox|\.venv|\.svn|_build|buck-out|build|dist)/"  # noqa: B950
73 DEFAULT_INCLUDES = r"\.pyi?$"
74 CACHE_DIR = Path(user_cache_dir("black", version=__version__))
75 STDIN_PLACEHOLDER = "__BLACK_STDIN_FILENAME__"
76
77 STRING_PREFIX_CHARS: Final = "furbFURB"  # All possible string prefix characters.
78
79
80 # types
81 FileContent = str
82 Encoding = str
83 NewLine = str
84 Depth = int
85 NodeType = int
86 ParserState = int
87 LeafID = int
88 StringID = int
89 Priority = int
90 Index = int
91 LN = Union[Leaf, Node]
92 Transformer = Callable[["Line", Collection["Feature"]], Iterator["Line"]]
93 Timestamp = float
94 FileSize = int
95 CacheInfo = Tuple[Timestamp, FileSize]
96 Cache = Dict[str, CacheInfo]
97 out = partial(click.secho, bold=True, err=True)
98 err = partial(click.secho, fg="red", err=True)
99
100 pygram.initialize(CACHE_DIR)
101 syms = pygram.python_symbols
102
103
104 class NothingChanged(UserWarning):
105     """Raised when reformatted code is the same as source."""
106
107
108 class CannotTransform(Exception):
109     """Base class for errors raised by Transformers."""
110
111
112 class CannotSplit(CannotTransform):
113     """A readable split that fits the allotted line length is impossible."""
114
115
116 class InvalidInput(ValueError):
117     """Raised when input source code fails all parse attempts."""
118
119
120 class BracketMatchError(KeyError):
121     """Raised when an opening bracket is unable to be matched to a closing bracket."""
122
123
124 T = TypeVar("T")
125 E = TypeVar("E", bound=Exception)
126
127
128 class Ok(Generic[T]):
129     def __init__(self, value: T) -> None:
130         self._value = value
131
132     def ok(self) -> T:
133         return self._value
134
135
136 class Err(Generic[E]):
137     def __init__(self, e: E) -> None:
138         self._e = e
139
140     def err(self) -> E:
141         return self._e
142
143
144 # The 'Result' return type is used to implement an error-handling model heavily
145 # influenced by that used by the Rust programming language
146 # (see https://doc.rust-lang.org/book/ch09-00-error-handling.html).
147 Result = Union[Ok[T], Err[E]]
148 TResult = Result[T, CannotTransform]  # (T)ransform Result
149 TMatchResult = TResult[Index]
150
151
152 class WriteBack(Enum):
153     NO = 0
154     YES = 1
155     DIFF = 2
156     CHECK = 3
157     COLOR_DIFF = 4
158
159     @classmethod
160     def from_configuration(
161         cls, *, check: bool, diff: bool, color: bool = False
162     ) -> "WriteBack":
163         if check and not diff:
164             return cls.CHECK
165
166         if diff and color:
167             return cls.COLOR_DIFF
168
169         return cls.DIFF if diff else cls.YES
170
171
172 class Changed(Enum):
173     NO = 0
174     CACHED = 1
175     YES = 2
176
177
178 class TargetVersion(Enum):
179     PY27 = 2
180     PY33 = 3
181     PY34 = 4
182     PY35 = 5
183     PY36 = 6
184     PY37 = 7
185     PY38 = 8
186     PY39 = 9
187
188     def is_python2(self) -> bool:
189         return self is TargetVersion.PY27
190
191
192 class Feature(Enum):
193     # All string literals are unicode
194     UNICODE_LITERALS = 1
195     F_STRINGS = 2
196     NUMERIC_UNDERSCORES = 3
197     TRAILING_COMMA_IN_CALL = 4
198     TRAILING_COMMA_IN_DEF = 5
199     # The following two feature-flags are mutually exclusive, and exactly one should be
200     # set for every version of python.
201     ASYNC_IDENTIFIERS = 6
202     ASYNC_KEYWORDS = 7
203     ASSIGNMENT_EXPRESSIONS = 8
204     POS_ONLY_ARGUMENTS = 9
205     RELAXED_DECORATORS = 10
206     FORCE_OPTIONAL_PARENTHESES = 50
207
208
209 VERSION_TO_FEATURES: Dict[TargetVersion, Set[Feature]] = {
210     TargetVersion.PY27: {Feature.ASYNC_IDENTIFIERS},
211     TargetVersion.PY33: {Feature.UNICODE_LITERALS, Feature.ASYNC_IDENTIFIERS},
212     TargetVersion.PY34: {Feature.UNICODE_LITERALS, Feature.ASYNC_IDENTIFIERS},
213     TargetVersion.PY35: {
214         Feature.UNICODE_LITERALS,
215         Feature.TRAILING_COMMA_IN_CALL,
216         Feature.ASYNC_IDENTIFIERS,
217     },
218     TargetVersion.PY36: {
219         Feature.UNICODE_LITERALS,
220         Feature.F_STRINGS,
221         Feature.NUMERIC_UNDERSCORES,
222         Feature.TRAILING_COMMA_IN_CALL,
223         Feature.TRAILING_COMMA_IN_DEF,
224         Feature.ASYNC_IDENTIFIERS,
225     },
226     TargetVersion.PY37: {
227         Feature.UNICODE_LITERALS,
228         Feature.F_STRINGS,
229         Feature.NUMERIC_UNDERSCORES,
230         Feature.TRAILING_COMMA_IN_CALL,
231         Feature.TRAILING_COMMA_IN_DEF,
232         Feature.ASYNC_KEYWORDS,
233     },
234     TargetVersion.PY38: {
235         Feature.UNICODE_LITERALS,
236         Feature.F_STRINGS,
237         Feature.NUMERIC_UNDERSCORES,
238         Feature.TRAILING_COMMA_IN_CALL,
239         Feature.TRAILING_COMMA_IN_DEF,
240         Feature.ASYNC_KEYWORDS,
241         Feature.ASSIGNMENT_EXPRESSIONS,
242         Feature.POS_ONLY_ARGUMENTS,
243     },
244     TargetVersion.PY39: {
245         Feature.UNICODE_LITERALS,
246         Feature.F_STRINGS,
247         Feature.NUMERIC_UNDERSCORES,
248         Feature.TRAILING_COMMA_IN_CALL,
249         Feature.TRAILING_COMMA_IN_DEF,
250         Feature.ASYNC_KEYWORDS,
251         Feature.ASSIGNMENT_EXPRESSIONS,
252         Feature.RELAXED_DECORATORS,
253         Feature.POS_ONLY_ARGUMENTS,
254     },
255 }
256
257
258 @dataclass
259 class Mode:
260     target_versions: Set[TargetVersion] = field(default_factory=set)
261     line_length: int = DEFAULT_LINE_LENGTH
262     string_normalization: bool = True
263     magic_trailing_comma: bool = True
264     experimental_string_processing: bool = False
265     is_pyi: bool = False
266
267     def get_cache_key(self) -> str:
268         if self.target_versions:
269             version_str = ",".join(
270                 str(version.value)
271                 for version in sorted(self.target_versions, key=lambda v: v.value)
272             )
273         else:
274             version_str = "-"
275         parts = [
276             version_str,
277             str(self.line_length),
278             str(int(self.string_normalization)),
279             str(int(self.is_pyi)),
280         ]
281         return ".".join(parts)
282
283
284 # Legacy name, left for integrations.
285 FileMode = Mode
286
287
288 def supports_feature(target_versions: Set[TargetVersion], feature: Feature) -> bool:
289     return all(feature in VERSION_TO_FEATURES[version] for version in target_versions)
290
291
292 def find_pyproject_toml(path_search_start: Iterable[str]) -> Optional[str]:
293     """Find the absolute filepath to a pyproject.toml if it exists"""
294     path_project_root = find_project_root(path_search_start)
295     path_pyproject_toml = path_project_root / "pyproject.toml"
296     return str(path_pyproject_toml) if path_pyproject_toml.is_file() else None
297
298
299 def parse_pyproject_toml(path_config: str) -> Dict[str, Any]:
300     """Parse a pyproject toml file, pulling out relevant parts for Black
301
302     If parsing fails, will raise a toml.TomlDecodeError
303     """
304     pyproject_toml = toml.load(path_config)
305     config = pyproject_toml.get("tool", {}).get("black", {})
306     return {k.replace("--", "").replace("-", "_"): v for k, v in config.items()}
307
308
309 def read_pyproject_toml(
310     ctx: click.Context, param: click.Parameter, value: Optional[str]
311 ) -> Optional[str]:
312     """Inject Black configuration from "pyproject.toml" into defaults in `ctx`.
313
314     Returns the path to a successfully found and read configuration file, None
315     otherwise.
316     """
317     if not value:
318         value = find_pyproject_toml(ctx.params.get("src", ()))
319         if value is None:
320             return None
321
322     try:
323         config = parse_pyproject_toml(value)
324     except (toml.TomlDecodeError, OSError) as e:
325         raise click.FileError(
326             filename=value, hint=f"Error reading configuration file: {e}"
327         )
328
329     if not config:
330         return None
331     else:
332         # Sanitize the values to be Click friendly. For more information please see:
333         # https://github.com/psf/black/issues/1458
334         # https://github.com/pallets/click/issues/1567
335         config = {
336             k: str(v) if not isinstance(v, (list, dict)) else v
337             for k, v in config.items()
338         }
339
340     target_version = config.get("target_version")
341     if target_version is not None and not isinstance(target_version, list):
342         raise click.BadOptionUsage(
343             "target-version", "Config key target-version must be a list"
344         )
345
346     default_map: Dict[str, Any] = {}
347     if ctx.default_map:
348         default_map.update(ctx.default_map)
349     default_map.update(config)
350
351     ctx.default_map = default_map
352     return value
353
354
355 def target_version_option_callback(
356     c: click.Context, p: Union[click.Option, click.Parameter], v: Tuple[str, ...]
357 ) -> List[TargetVersion]:
358     """Compute the target versions from a --target-version flag.
359
360     This is its own function because mypy couldn't infer the type correctly
361     when it was a lambda, causing mypyc trouble.
362     """
363     return [TargetVersion[val.upper()] for val in v]
364
365
366 @click.command(context_settings=dict(help_option_names=["-h", "--help"]))
367 @click.option("-c", "--code", type=str, help="Format the code passed in as a string.")
368 @click.option(
369     "-l",
370     "--line-length",
371     type=int,
372     default=DEFAULT_LINE_LENGTH,
373     help="How many characters per line to allow.",
374     show_default=True,
375 )
376 @click.option(
377     "-t",
378     "--target-version",
379     type=click.Choice([v.name.lower() for v in TargetVersion]),
380     callback=target_version_option_callback,
381     multiple=True,
382     help=(
383         "Python versions that should be supported by Black's output. [default: per-file"
384         " auto-detection]"
385     ),
386 )
387 @click.option(
388     "--pyi",
389     is_flag=True,
390     help=(
391         "Format all input files like typing stubs regardless of file extension (useful"
392         " when piping source on standard input)."
393     ),
394 )
395 @click.option(
396     "-S",
397     "--skip-string-normalization",
398     is_flag=True,
399     help="Don't normalize string quotes or prefixes.",
400 )
401 @click.option(
402     "-C",
403     "--skip-magic-trailing-comma",
404     is_flag=True,
405     help="Don't use trailing commas as a reason to split lines.",
406 )
407 @click.option(
408     "--experimental-string-processing",
409     is_flag=True,
410     hidden=True,
411     help=(
412         "Experimental option that performs more normalization on string literals."
413         " Currently disabled because it leads to some crashes."
414     ),
415 )
416 @click.option(
417     "--check",
418     is_flag=True,
419     help=(
420         "Don't write the files back, just return the status.  Return code 0 means"
421         " nothing would change.  Return code 1 means some files would be reformatted."
422         " Return code 123 means there was an internal error."
423     ),
424 )
425 @click.option(
426     "--diff",
427     is_flag=True,
428     help="Don't write the files back, just output a diff for each file on stdout.",
429 )
430 @click.option(
431     "--color/--no-color",
432     is_flag=True,
433     help="Show colored diff. Only applies when `--diff` is given.",
434 )
435 @click.option(
436     "--fast/--safe",
437     is_flag=True,
438     help="If --fast given, skip temporary sanity checks. [default: --safe]",
439 )
440 @click.option(
441     "--include",
442     type=str,
443     default=DEFAULT_INCLUDES,
444     help=(
445         "A regular expression that matches files and directories that should be"
446         " included on recursive searches.  An empty value means all files are included"
447         " regardless of the name.  Use forward slashes for directories on all platforms"
448         " (Windows, too).  Exclusions are calculated first, inclusions later."
449     ),
450     show_default=True,
451 )
452 @click.option(
453     "--exclude",
454     type=str,
455     default=DEFAULT_EXCLUDES,
456     help=(
457         "A regular expression that matches files and directories that should be"
458         " excluded on recursive searches.  An empty value means no paths are excluded."
459         " Use forward slashes for directories on all platforms (Windows, too). "
460         " Exclusions are calculated first, inclusions later."
461     ),
462     show_default=True,
463 )
464 @click.option(
465     "--force-exclude",
466     type=str,
467     help=(
468         "Like --exclude, but files and directories matching this regex will be "
469         "excluded even when they are passed explicitly as arguments."
470     ),
471 )
472 @click.option(
473     "--stdin-filename",
474     type=str,
475     help=(
476         "The name of the file when passing it through stdin. Useful to make "
477         "sure Black will respect --force-exclude option on some "
478         "editors that rely on using stdin."
479     ),
480 )
481 @click.option(
482     "-q",
483     "--quiet",
484     is_flag=True,
485     help=(
486         "Don't emit non-error messages to stderr. Errors are still emitted; silence"
487         " those with 2>/dev/null."
488     ),
489 )
490 @click.option(
491     "-v",
492     "--verbose",
493     is_flag=True,
494     help=(
495         "Also emit messages to stderr about files that were not changed or were ignored"
496         " due to --exclude=."
497     ),
498 )
499 @click.version_option(version=__version__)
500 @click.argument(
501     "src",
502     nargs=-1,
503     type=click.Path(
504         exists=True, file_okay=True, dir_okay=True, readable=True, allow_dash=True
505     ),
506     is_eager=True,
507 )
508 @click.option(
509     "--config",
510     type=click.Path(
511         exists=True,
512         file_okay=True,
513         dir_okay=False,
514         readable=True,
515         allow_dash=False,
516         path_type=str,
517     ),
518     is_eager=True,
519     callback=read_pyproject_toml,
520     help="Read configuration from FILE path.",
521 )
522 @click.pass_context
523 def main(
524     ctx: click.Context,
525     code: Optional[str],
526     line_length: int,
527     target_version: List[TargetVersion],
528     check: bool,
529     diff: bool,
530     color: bool,
531     fast: bool,
532     pyi: bool,
533     skip_string_normalization: bool,
534     skip_magic_trailing_comma: bool,
535     experimental_string_processing: bool,
536     quiet: bool,
537     verbose: bool,
538     include: str,
539     exclude: str,
540     force_exclude: Optional[str],
541     stdin_filename: Optional[str],
542     src: Tuple[str, ...],
543     config: Optional[str],
544 ) -> None:
545     """The uncompromising code formatter."""
546     write_back = WriteBack.from_configuration(check=check, diff=diff, color=color)
547     if target_version:
548         versions = set(target_version)
549     else:
550         # We'll autodetect later.
551         versions = set()
552     mode = Mode(
553         target_versions=versions,
554         line_length=line_length,
555         is_pyi=pyi,
556         string_normalization=not skip_string_normalization,
557         magic_trailing_comma=not skip_magic_trailing_comma,
558         experimental_string_processing=experimental_string_processing,
559     )
560     if config and verbose:
561         out(f"Using configuration from {config}.", bold=False, fg="blue")
562     if code is not None:
563         print(format_str(code, mode=mode))
564         ctx.exit(0)
565     report = Report(check=check, diff=diff, quiet=quiet, verbose=verbose)
566     sources = get_sources(
567         ctx=ctx,
568         src=src,
569         quiet=quiet,
570         verbose=verbose,
571         include=include,
572         exclude=exclude,
573         force_exclude=force_exclude,
574         report=report,
575         stdin_filename=stdin_filename,
576     )
577
578     path_empty(
579         sources,
580         "No Python files are present to be formatted. Nothing to do 😴",
581         quiet,
582         verbose,
583         ctx,
584     )
585
586     if len(sources) == 1:
587         reformat_one(
588             src=sources.pop(),
589             fast=fast,
590             write_back=write_back,
591             mode=mode,
592             report=report,
593         )
594     else:
595         reformat_many(
596             sources=sources, fast=fast, write_back=write_back, mode=mode, report=report
597         )
598
599     if verbose or not quiet:
600         out("Oh no! 💥 💔 💥" if report.return_code else "All done! ✨ 🍰 ✨")
601         click.secho(str(report), err=True)
602     ctx.exit(report.return_code)
603
604
605 def get_sources(
606     *,
607     ctx: click.Context,
608     src: Tuple[str, ...],
609     quiet: bool,
610     verbose: bool,
611     include: str,
612     exclude: str,
613     force_exclude: Optional[str],
614     report: "Report",
615     stdin_filename: Optional[str],
616 ) -> Set[Path]:
617     """Compute the set of files to be formatted."""
618     try:
619         include_regex = re_compile_maybe_verbose(include)
620     except re.error:
621         err(f"Invalid regular expression for include given: {include!r}")
622         ctx.exit(2)
623     try:
624         exclude_regex = re_compile_maybe_verbose(exclude)
625     except re.error:
626         err(f"Invalid regular expression for exclude given: {exclude!r}")
627         ctx.exit(2)
628     try:
629         force_exclude_regex = (
630             re_compile_maybe_verbose(force_exclude) if force_exclude else None
631         )
632     except re.error:
633         err(f"Invalid regular expression for force_exclude given: {force_exclude!r}")
634         ctx.exit(2)
635
636     root = find_project_root(src)
637     sources: Set[Path] = set()
638     path_empty(src, "No Path provided. Nothing to do 😴", quiet, verbose, ctx)
639     gitignore = get_gitignore(root)
640
641     for s in src:
642         if s == "-" and stdin_filename:
643             p = Path(stdin_filename)
644             is_stdin = True
645         else:
646             p = Path(s)
647             is_stdin = False
648
649         if is_stdin or p.is_file():
650             normalized_path = normalize_path_maybe_ignore(p, root, report)
651             if normalized_path is None:
652                 continue
653
654             normalized_path = "/" + normalized_path
655             # Hard-exclude any files that matches the `--force-exclude` regex.
656             if force_exclude_regex:
657                 force_exclude_match = force_exclude_regex.search(normalized_path)
658             else:
659                 force_exclude_match = None
660             if force_exclude_match and force_exclude_match.group(0):
661                 report.path_ignored(p, "matches the --force-exclude regular expression")
662                 continue
663
664             if is_stdin:
665                 p = Path(f"{STDIN_PLACEHOLDER}{str(p)}")
666
667             sources.add(p)
668         elif p.is_dir():
669             sources.update(
670                 gen_python_files(
671                     p.iterdir(),
672                     root,
673                     include_regex,
674                     exclude_regex,
675                     force_exclude_regex,
676                     report,
677                     gitignore,
678                 )
679             )
680         elif s == "-":
681             sources.add(p)
682         else:
683             err(f"invalid path: {s}")
684     return sources
685
686
687 def path_empty(
688     src: Sized, msg: str, quiet: bool, verbose: bool, ctx: click.Context
689 ) -> None:
690     """
691     Exit if there is no `src` provided for formatting
692     """
693     if not src and (verbose or not quiet):
694         out(msg)
695         ctx.exit(0)
696
697
698 def reformat_one(
699     src: Path, fast: bool, write_back: WriteBack, mode: Mode, report: "Report"
700 ) -> None:
701     """Reformat a single file under `src` without spawning child processes.
702
703     `fast`, `write_back`, and `mode` options are passed to
704     :func:`format_file_in_place` or :func:`format_stdin_to_stdout`.
705     """
706     try:
707         changed = Changed.NO
708
709         if str(src) == "-":
710             is_stdin = True
711         elif str(src).startswith(STDIN_PLACEHOLDER):
712             is_stdin = True
713             # Use the original name again in case we want to print something
714             # to the user
715             src = Path(str(src)[len(STDIN_PLACEHOLDER) :])
716         else:
717             is_stdin = False
718
719         if is_stdin:
720             if format_stdin_to_stdout(fast=fast, write_back=write_back, mode=mode):
721                 changed = Changed.YES
722         else:
723             cache: Cache = {}
724             if write_back not in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
725                 cache = read_cache(mode)
726                 res_src = src.resolve()
727                 res_src_s = str(res_src)
728                 if res_src_s in cache and cache[res_src_s] == get_cache_info(res_src):
729                     changed = Changed.CACHED
730             if changed is not Changed.CACHED and format_file_in_place(
731                 src, fast=fast, write_back=write_back, mode=mode
732             ):
733                 changed = Changed.YES
734             if (write_back is WriteBack.YES and changed is not Changed.CACHED) or (
735                 write_back is WriteBack.CHECK and changed is Changed.NO
736             ):
737                 write_cache(cache, [src], mode)
738         report.done(src, changed)
739     except Exception as exc:
740         if report.verbose:
741             traceback.print_exc()
742         report.failed(src, str(exc))
743
744
745 def reformat_many(
746     sources: Set[Path], fast: bool, write_back: WriteBack, mode: Mode, report: "Report"
747 ) -> None:
748     """Reformat multiple files using a ProcessPoolExecutor."""
749     executor: Executor
750     loop = asyncio.get_event_loop()
751     worker_count = os.cpu_count()
752     if sys.platform == "win32":
753         # Work around https://bugs.python.org/issue26903
754         worker_count = min(worker_count, 60)
755     try:
756         executor = ProcessPoolExecutor(max_workers=worker_count)
757     except (ImportError, OSError):
758         # we arrive here if the underlying system does not support multi-processing
759         # like in AWS Lambda or Termux, in which case we gracefully fallback to
760         # a ThreadPollExecutor with just a single worker (more workers would not do us
761         # any good due to the Global Interpreter Lock)
762         executor = ThreadPoolExecutor(max_workers=1)
763
764     try:
765         loop.run_until_complete(
766             schedule_formatting(
767                 sources=sources,
768                 fast=fast,
769                 write_back=write_back,
770                 mode=mode,
771                 report=report,
772                 loop=loop,
773                 executor=executor,
774             )
775         )
776     finally:
777         shutdown(loop)
778         if executor is not None:
779             executor.shutdown()
780
781
782 async def schedule_formatting(
783     sources: Set[Path],
784     fast: bool,
785     write_back: WriteBack,
786     mode: Mode,
787     report: "Report",
788     loop: asyncio.AbstractEventLoop,
789     executor: Executor,
790 ) -> None:
791     """Run formatting of `sources` in parallel using the provided `executor`.
792
793     (Use ProcessPoolExecutors for actual parallelism.)
794
795     `write_back`, `fast`, and `mode` options are passed to
796     :func:`format_file_in_place`.
797     """
798     cache: Cache = {}
799     if write_back not in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
800         cache = read_cache(mode)
801         sources, cached = filter_cached(cache, sources)
802         for src in sorted(cached):
803             report.done(src, Changed.CACHED)
804     if not sources:
805         return
806
807     cancelled = []
808     sources_to_cache = []
809     lock = None
810     if write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
811         # For diff output, we need locks to ensure we don't interleave output
812         # from different processes.
813         manager = Manager()
814         lock = manager.Lock()
815     tasks = {
816         asyncio.ensure_future(
817             loop.run_in_executor(
818                 executor, format_file_in_place, src, fast, mode, write_back, lock
819             )
820         ): src
821         for src in sorted(sources)
822     }
823     pending: Iterable["asyncio.Future[bool]"] = tasks.keys()
824     try:
825         loop.add_signal_handler(signal.SIGINT, cancel, pending)
826         loop.add_signal_handler(signal.SIGTERM, cancel, pending)
827     except NotImplementedError:
828         # There are no good alternatives for these on Windows.
829         pass
830     while pending:
831         done, _ = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
832         for task in done:
833             src = tasks.pop(task)
834             if task.cancelled():
835                 cancelled.append(task)
836             elif task.exception():
837                 report.failed(src, str(task.exception()))
838             else:
839                 changed = Changed.YES if task.result() else Changed.NO
840                 # If the file was written back or was successfully checked as
841                 # well-formatted, store this information in the cache.
842                 if write_back is WriteBack.YES or (
843                     write_back is WriteBack.CHECK and changed is Changed.NO
844                 ):
845                     sources_to_cache.append(src)
846                 report.done(src, changed)
847     if cancelled:
848         await asyncio.gather(*cancelled, loop=loop, return_exceptions=True)
849     if sources_to_cache:
850         write_cache(cache, sources_to_cache, mode)
851
852
853 def format_file_in_place(
854     src: Path,
855     fast: bool,
856     mode: Mode,
857     write_back: WriteBack = WriteBack.NO,
858     lock: Any = None,  # multiprocessing.Manager().Lock() is some crazy proxy
859 ) -> bool:
860     """Format file under `src` path. Return True if changed.
861
862     If `write_back` is DIFF, write a diff to stdout. If it is YES, write reformatted
863     code to the file.
864     `mode` and `fast` options are passed to :func:`format_file_contents`.
865     """
866     if src.suffix == ".pyi":
867         mode = replace(mode, is_pyi=True)
868
869     then = datetime.utcfromtimestamp(src.stat().st_mtime)
870     with open(src, "rb") as buf:
871         src_contents, encoding, newline = decode_bytes(buf.read())
872     try:
873         dst_contents = format_file_contents(src_contents, fast=fast, mode=mode)
874     except NothingChanged:
875         return False
876
877     if write_back == WriteBack.YES:
878         with open(src, "w", encoding=encoding, newline=newline) as f:
879             f.write(dst_contents)
880     elif write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
881         now = datetime.utcnow()
882         src_name = f"{src}\t{then} +0000"
883         dst_name = f"{src}\t{now} +0000"
884         diff_contents = diff(src_contents, dst_contents, src_name, dst_name)
885
886         if write_back == write_back.COLOR_DIFF:
887             diff_contents = color_diff(diff_contents)
888
889         with lock or nullcontext():
890             f = io.TextIOWrapper(
891                 sys.stdout.buffer,
892                 encoding=encoding,
893                 newline=newline,
894                 write_through=True,
895             )
896             f = wrap_stream_for_windows(f)
897             f.write(diff_contents)
898             f.detach()
899
900     return True
901
902
903 def color_diff(contents: str) -> str:
904     """Inject the ANSI color codes to the diff."""
905     lines = contents.split("\n")
906     for i, line in enumerate(lines):
907         if line.startswith("+++") or line.startswith("---"):
908             line = "\033[1;37m" + line + "\033[0m"  # bold white, reset
909         elif line.startswith("@@"):
910             line = "\033[36m" + line + "\033[0m"  # cyan, reset
911         elif line.startswith("+"):
912             line = "\033[32m" + line + "\033[0m"  # green, reset
913         elif line.startswith("-"):
914             line = "\033[31m" + line + "\033[0m"  # red, reset
915         lines[i] = line
916     return "\n".join(lines)
917
918
919 def wrap_stream_for_windows(
920     f: io.TextIOWrapper,
921 ) -> Union[io.TextIOWrapper, "colorama.AnsiToWin32"]:
922     """
923     Wrap stream with colorama's wrap_stream so colors are shown on Windows.
924
925     If `colorama` is unavailable, the original stream is returned unmodified.
926     Otherwise, the `wrap_stream()` function determines whether the stream needs
927     to be wrapped for a Windows environment and will accordingly either return
928     an `AnsiToWin32` wrapper or the original stream.
929     """
930     try:
931         from colorama.initialise import wrap_stream
932     except ImportError:
933         return f
934     else:
935         # Set `strip=False` to avoid needing to modify test_express_diff_with_color.
936         return wrap_stream(f, convert=None, strip=False, autoreset=False, wrap=True)
937
938
939 def format_stdin_to_stdout(
940     fast: bool, *, write_back: WriteBack = WriteBack.NO, mode: Mode
941 ) -> bool:
942     """Format file on stdin. Return True if changed.
943
944     If `write_back` is YES, write reformatted code back to stdout. If it is DIFF,
945     write a diff to stdout. The `mode` argument is passed to
946     :func:`format_file_contents`.
947     """
948     then = datetime.utcnow()
949     src, encoding, newline = decode_bytes(sys.stdin.buffer.read())
950     dst = src
951     try:
952         dst = format_file_contents(src, fast=fast, mode=mode)
953         return True
954
955     except NothingChanged:
956         return False
957
958     finally:
959         f = io.TextIOWrapper(
960             sys.stdout.buffer, encoding=encoding, newline=newline, write_through=True
961         )
962         if write_back == WriteBack.YES:
963             f.write(dst)
964         elif write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF):
965             now = datetime.utcnow()
966             src_name = f"STDIN\t{then} +0000"
967             dst_name = f"STDOUT\t{now} +0000"
968             d = diff(src, dst, src_name, dst_name)
969             if write_back == WriteBack.COLOR_DIFF:
970                 d = color_diff(d)
971                 f = wrap_stream_for_windows(f)
972             f.write(d)
973         f.detach()
974
975
976 def format_file_contents(src_contents: str, *, fast: bool, mode: Mode) -> FileContent:
977     """Reformat contents of a file and return new contents.
978
979     If `fast` is False, additionally confirm that the reformatted code is
980     valid by calling :func:`assert_equivalent` and :func:`assert_stable` on it.
981     `mode` is passed to :func:`format_str`.
982     """
983     if not src_contents.strip():
984         raise NothingChanged
985
986     dst_contents = format_str(src_contents, mode=mode)
987     if src_contents == dst_contents:
988         raise NothingChanged
989
990     if not fast:
991         assert_equivalent(src_contents, dst_contents)
992         assert_stable(src_contents, dst_contents, mode=mode)
993     return dst_contents
994
995
996 def format_str(src_contents: str, *, mode: Mode) -> FileContent:
997     """Reformat a string and return new contents.
998
999     `mode` determines formatting options, such as how many characters per line are
1000     allowed.  Example:
1001
1002     >>> import black
1003     >>> print(black.format_str("def f(arg:str='')->None:...", mode=black.Mode()))
1004     def f(arg: str = "") -> None:
1005         ...
1006
1007     A more complex example:
1008
1009     >>> print(
1010     ...   black.format_str(
1011     ...     "def f(arg:str='')->None: hey",
1012     ...     mode=black.Mode(
1013     ...       target_versions={black.TargetVersion.PY36},
1014     ...       line_length=10,
1015     ...       string_normalization=False,
1016     ...       is_pyi=False,
1017     ...     ),
1018     ...   ),
1019     ... )
1020     def f(
1021         arg: str = '',
1022     ) -> None:
1023         hey
1024
1025     """
1026     src_node = lib2to3_parse(src_contents.lstrip(), mode.target_versions)
1027     dst_contents = []
1028     future_imports = get_future_imports(src_node)
1029     if mode.target_versions:
1030         versions = mode.target_versions
1031     else:
1032         versions = detect_target_versions(src_node)
1033     normalize_fmt_off(src_node)
1034     lines = LineGenerator(
1035         mode=mode,
1036         remove_u_prefix="unicode_literals" in future_imports
1037         or supports_feature(versions, Feature.UNICODE_LITERALS),
1038     )
1039     elt = EmptyLineTracker(is_pyi=mode.is_pyi)
1040     empty_line = Line(mode=mode)
1041     after = 0
1042     split_line_features = {
1043         feature
1044         for feature in {Feature.TRAILING_COMMA_IN_CALL, Feature.TRAILING_COMMA_IN_DEF}
1045         if supports_feature(versions, feature)
1046     }
1047     for current_line in lines.visit(src_node):
1048         dst_contents.append(str(empty_line) * after)
1049         before, after = elt.maybe_empty_lines(current_line)
1050         dst_contents.append(str(empty_line) * before)
1051         for line in transform_line(
1052             current_line, mode=mode, features=split_line_features
1053         ):
1054             dst_contents.append(str(line))
1055     return "".join(dst_contents)
1056
1057
1058 def decode_bytes(src: bytes) -> Tuple[FileContent, Encoding, NewLine]:
1059     """Return a tuple of (decoded_contents, encoding, newline).
1060
1061     `newline` is either CRLF or LF but `decoded_contents` is decoded with
1062     universal newlines (i.e. only contains LF).
1063     """
1064     srcbuf = io.BytesIO(src)
1065     encoding, lines = tokenize.detect_encoding(srcbuf.readline)
1066     if not lines:
1067         return "", encoding, "\n"
1068
1069     newline = "\r\n" if b"\r\n" == lines[0][-2:] else "\n"
1070     srcbuf.seek(0)
1071     with io.TextIOWrapper(srcbuf, encoding) as tiow:
1072         return tiow.read(), encoding, newline
1073
1074
1075 def get_grammars(target_versions: Set[TargetVersion]) -> List[Grammar]:
1076     if not target_versions:
1077         # No target_version specified, so try all grammars.
1078         return [
1079             # Python 3.7+
1080             pygram.python_grammar_no_print_statement_no_exec_statement_async_keywords,
1081             # Python 3.0-3.6
1082             pygram.python_grammar_no_print_statement_no_exec_statement,
1083             # Python 2.7 with future print_function import
1084             pygram.python_grammar_no_print_statement,
1085             # Python 2.7
1086             pygram.python_grammar,
1087         ]
1088
1089     if all(version.is_python2() for version in target_versions):
1090         # Python 2-only code, so try Python 2 grammars.
1091         return [
1092             # Python 2.7 with future print_function import
1093             pygram.python_grammar_no_print_statement,
1094             # Python 2.7
1095             pygram.python_grammar,
1096         ]
1097
1098     # Python 3-compatible code, so only try Python 3 grammar.
1099     grammars = []
1100     # If we have to parse both, try to parse async as a keyword first
1101     if not supports_feature(target_versions, Feature.ASYNC_IDENTIFIERS):
1102         # Python 3.7+
1103         grammars.append(
1104             pygram.python_grammar_no_print_statement_no_exec_statement_async_keywords
1105         )
1106     if not supports_feature(target_versions, Feature.ASYNC_KEYWORDS):
1107         # Python 3.0-3.6
1108         grammars.append(pygram.python_grammar_no_print_statement_no_exec_statement)
1109     # At least one of the above branches must have been taken, because every Python
1110     # version has exactly one of the two 'ASYNC_*' flags
1111     return grammars
1112
1113
1114 def lib2to3_parse(src_txt: str, target_versions: Iterable[TargetVersion] = ()) -> Node:
1115     """Given a string with source, return the lib2to3 Node."""
1116     if not src_txt.endswith("\n"):
1117         src_txt += "\n"
1118
1119     for grammar in get_grammars(set(target_versions)):
1120         drv = driver.Driver(grammar, pytree.convert)
1121         try:
1122             result = drv.parse_string(src_txt, True)
1123             break
1124
1125         except ParseError as pe:
1126             lineno, column = pe.context[1]
1127             lines = src_txt.splitlines()
1128             try:
1129                 faulty_line = lines[lineno - 1]
1130             except IndexError:
1131                 faulty_line = "<line number missing in source>"
1132             exc = InvalidInput(f"Cannot parse: {lineno}:{column}: {faulty_line}")
1133     else:
1134         raise exc from None
1135
1136     if isinstance(result, Leaf):
1137         result = Node(syms.file_input, [result])
1138     return result
1139
1140
1141 def lib2to3_unparse(node: Node) -> str:
1142     """Given a lib2to3 node, return its string representation."""
1143     code = str(node)
1144     return code
1145
1146
1147 class Visitor(Generic[T]):
1148     """Basic lib2to3 visitor that yields things of type `T` on `visit()`."""
1149
1150     def visit(self, node: LN) -> Iterator[T]:
1151         """Main method to visit `node` and its children.
1152
1153         It tries to find a `visit_*()` method for the given `node.type`, like
1154         `visit_simple_stmt` for Node objects or `visit_INDENT` for Leaf objects.
1155         If no dedicated `visit_*()` method is found, chooses `visit_default()`
1156         instead.
1157
1158         Then yields objects of type `T` from the selected visitor.
1159         """
1160         if node.type < 256:
1161             name = token.tok_name[node.type]
1162         else:
1163             name = str(type_repr(node.type))
1164         # We explicitly branch on whether a visitor exists (instead of
1165         # using self.visit_default as the default arg to getattr) in order
1166         # to save needing to create a bound method object and so mypyc can
1167         # generate a native call to visit_default.
1168         visitf = getattr(self, f"visit_{name}", None)
1169         if visitf:
1170             yield from visitf(node)
1171         else:
1172             yield from self.visit_default(node)
1173
1174     def visit_default(self, node: LN) -> Iterator[T]:
1175         """Default `visit_*()` implementation. Recurses to children of `node`."""
1176         if isinstance(node, Node):
1177             for child in node.children:
1178                 yield from self.visit(child)
1179
1180
1181 @dataclass
1182 class DebugVisitor(Visitor[T]):
1183     tree_depth: int = 0
1184
1185     def visit_default(self, node: LN) -> Iterator[T]:
1186         indent = " " * (2 * self.tree_depth)
1187         if isinstance(node, Node):
1188             _type = type_repr(node.type)
1189             out(f"{indent}{_type}", fg="yellow")
1190             self.tree_depth += 1
1191             for child in node.children:
1192                 yield from self.visit(child)
1193
1194             self.tree_depth -= 1
1195             out(f"{indent}/{_type}", fg="yellow", bold=False)
1196         else:
1197             _type = token.tok_name.get(node.type, str(node.type))
1198             out(f"{indent}{_type}", fg="blue", nl=False)
1199             if node.prefix:
1200                 # We don't have to handle prefixes for `Node` objects since
1201                 # that delegates to the first child anyway.
1202                 out(f" {node.prefix!r}", fg="green", bold=False, nl=False)
1203             out(f" {node.value!r}", fg="blue", bold=False)
1204
1205     @classmethod
1206     def show(cls, code: Union[str, Leaf, Node]) -> None:
1207         """Pretty-print the lib2to3 AST of a given string of `code`.
1208
1209         Convenience method for debugging.
1210         """
1211         v: DebugVisitor[None] = DebugVisitor()
1212         if isinstance(code, str):
1213             code = lib2to3_parse(code)
1214         list(v.visit(code))
1215
1216
1217 WHITESPACE: Final = {token.DEDENT, token.INDENT, token.NEWLINE}
1218 STATEMENT: Final = {
1219     syms.if_stmt,
1220     syms.while_stmt,
1221     syms.for_stmt,
1222     syms.try_stmt,
1223     syms.except_clause,
1224     syms.with_stmt,
1225     syms.funcdef,
1226     syms.classdef,
1227 }
1228 STANDALONE_COMMENT: Final = 153
1229 token.tok_name[STANDALONE_COMMENT] = "STANDALONE_COMMENT"
1230 LOGIC_OPERATORS: Final = {"and", "or"}
1231 COMPARATORS: Final = {
1232     token.LESS,
1233     token.GREATER,
1234     token.EQEQUAL,
1235     token.NOTEQUAL,
1236     token.LESSEQUAL,
1237     token.GREATEREQUAL,
1238 }
1239 MATH_OPERATORS: Final = {
1240     token.VBAR,
1241     token.CIRCUMFLEX,
1242     token.AMPER,
1243     token.LEFTSHIFT,
1244     token.RIGHTSHIFT,
1245     token.PLUS,
1246     token.MINUS,
1247     token.STAR,
1248     token.SLASH,
1249     token.DOUBLESLASH,
1250     token.PERCENT,
1251     token.AT,
1252     token.TILDE,
1253     token.DOUBLESTAR,
1254 }
1255 STARS: Final = {token.STAR, token.DOUBLESTAR}
1256 VARARGS_SPECIALS: Final = STARS | {token.SLASH}
1257 VARARGS_PARENTS: Final = {
1258     syms.arglist,
1259     syms.argument,  # double star in arglist
1260     syms.trailer,  # single argument to call
1261     syms.typedargslist,
1262     syms.varargslist,  # lambdas
1263 }
1264 UNPACKING_PARENTS: Final = {
1265     syms.atom,  # single element of a list or set literal
1266     syms.dictsetmaker,
1267     syms.listmaker,
1268     syms.testlist_gexp,
1269     syms.testlist_star_expr,
1270 }
1271 TEST_DESCENDANTS: Final = {
1272     syms.test,
1273     syms.lambdef,
1274     syms.or_test,
1275     syms.and_test,
1276     syms.not_test,
1277     syms.comparison,
1278     syms.star_expr,
1279     syms.expr,
1280     syms.xor_expr,
1281     syms.and_expr,
1282     syms.shift_expr,
1283     syms.arith_expr,
1284     syms.trailer,
1285     syms.term,
1286     syms.power,
1287 }
1288 ASSIGNMENTS: Final = {
1289     "=",
1290     "+=",
1291     "-=",
1292     "*=",
1293     "@=",
1294     "/=",
1295     "%=",
1296     "&=",
1297     "|=",
1298     "^=",
1299     "<<=",
1300     ">>=",
1301     "**=",
1302     "//=",
1303 }
1304 COMPREHENSION_PRIORITY: Final = 20
1305 COMMA_PRIORITY: Final = 18
1306 TERNARY_PRIORITY: Final = 16
1307 LOGIC_PRIORITY: Final = 14
1308 STRING_PRIORITY: Final = 12
1309 COMPARATOR_PRIORITY: Final = 10
1310 MATH_PRIORITIES: Final = {
1311     token.VBAR: 9,
1312     token.CIRCUMFLEX: 8,
1313     token.AMPER: 7,
1314     token.LEFTSHIFT: 6,
1315     token.RIGHTSHIFT: 6,
1316     token.PLUS: 5,
1317     token.MINUS: 5,
1318     token.STAR: 4,
1319     token.SLASH: 4,
1320     token.DOUBLESLASH: 4,
1321     token.PERCENT: 4,
1322     token.AT: 4,
1323     token.TILDE: 3,
1324     token.DOUBLESTAR: 2,
1325 }
1326 DOT_PRIORITY: Final = 1
1327
1328
1329 @dataclass
1330 class BracketTracker:
1331     """Keeps track of brackets on a line."""
1332
1333     depth: int = 0
1334     bracket_match: Dict[Tuple[Depth, NodeType], Leaf] = field(default_factory=dict)
1335     delimiters: Dict[LeafID, Priority] = field(default_factory=dict)
1336     previous: Optional[Leaf] = None
1337     _for_loop_depths: List[int] = field(default_factory=list)
1338     _lambda_argument_depths: List[int] = field(default_factory=list)
1339     invisible: List[Leaf] = field(default_factory=list)
1340
1341     def mark(self, leaf: Leaf) -> None:
1342         """Mark `leaf` with bracket-related metadata. Keep track of delimiters.
1343
1344         All leaves receive an int `bracket_depth` field that stores how deep
1345         within brackets a given leaf is. 0 means there are no enclosing brackets
1346         that started on this line.
1347
1348         If a leaf is itself a closing bracket, it receives an `opening_bracket`
1349         field that it forms a pair with. This is a one-directional link to
1350         avoid reference cycles.
1351
1352         If a leaf is a delimiter (a token on which Black can split the line if
1353         needed) and it's on depth 0, its `id()` is stored in the tracker's
1354         `delimiters` field.
1355         """
1356         if leaf.type == token.COMMENT:
1357             return
1358
1359         self.maybe_decrement_after_for_loop_variable(leaf)
1360         self.maybe_decrement_after_lambda_arguments(leaf)
1361         if leaf.type in CLOSING_BRACKETS:
1362             self.depth -= 1
1363             try:
1364                 opening_bracket = self.bracket_match.pop((self.depth, leaf.type))
1365             except KeyError as e:
1366                 raise BracketMatchError(
1367                     "Unable to match a closing bracket to the following opening"
1368                     f" bracket: {leaf}"
1369                 ) from e
1370             leaf.opening_bracket = opening_bracket
1371             if not leaf.value:
1372                 self.invisible.append(leaf)
1373         leaf.bracket_depth = self.depth
1374         if self.depth == 0:
1375             delim = is_split_before_delimiter(leaf, self.previous)
1376             if delim and self.previous is not None:
1377                 self.delimiters[id(self.previous)] = delim
1378             else:
1379                 delim = is_split_after_delimiter(leaf, self.previous)
1380                 if delim:
1381                     self.delimiters[id(leaf)] = delim
1382         if leaf.type in OPENING_BRACKETS:
1383             self.bracket_match[self.depth, BRACKET[leaf.type]] = leaf
1384             self.depth += 1
1385             if not leaf.value:
1386                 self.invisible.append(leaf)
1387         self.previous = leaf
1388         self.maybe_increment_lambda_arguments(leaf)
1389         self.maybe_increment_for_loop_variable(leaf)
1390
1391     def any_open_brackets(self) -> bool:
1392         """Return True if there is an yet unmatched open bracket on the line."""
1393         return bool(self.bracket_match)
1394
1395     def max_delimiter_priority(self, exclude: Iterable[LeafID] = ()) -> Priority:
1396         """Return the highest priority of a delimiter found on the line.
1397
1398         Values are consistent with what `is_split_*_delimiter()` return.
1399         Raises ValueError on no delimiters.
1400         """
1401         return max(v for k, v in self.delimiters.items() if k not in exclude)
1402
1403     def delimiter_count_with_priority(self, priority: Priority = 0) -> int:
1404         """Return the number of delimiters with the given `priority`.
1405
1406         If no `priority` is passed, defaults to max priority on the line.
1407         """
1408         if not self.delimiters:
1409             return 0
1410
1411         priority = priority or self.max_delimiter_priority()
1412         return sum(1 for p in self.delimiters.values() if p == priority)
1413
1414     def maybe_increment_for_loop_variable(self, leaf: Leaf) -> bool:
1415         """In a for loop, or comprehension, the variables are often unpacks.
1416
1417         To avoid splitting on the comma in this situation, increase the depth of
1418         tokens between `for` and `in`.
1419         """
1420         if leaf.type == token.NAME and leaf.value == "for":
1421             self.depth += 1
1422             self._for_loop_depths.append(self.depth)
1423             return True
1424
1425         return False
1426
1427     def maybe_decrement_after_for_loop_variable(self, leaf: Leaf) -> bool:
1428         """See `maybe_increment_for_loop_variable` above for explanation."""
1429         if (
1430             self._for_loop_depths
1431             and self._for_loop_depths[-1] == self.depth
1432             and leaf.type == token.NAME
1433             and leaf.value == "in"
1434         ):
1435             self.depth -= 1
1436             self._for_loop_depths.pop()
1437             return True
1438
1439         return False
1440
1441     def maybe_increment_lambda_arguments(self, leaf: Leaf) -> bool:
1442         """In a lambda expression, there might be more than one argument.
1443
1444         To avoid splitting on the comma in this situation, increase the depth of
1445         tokens between `lambda` and `:`.
1446         """
1447         if leaf.type == token.NAME and leaf.value == "lambda":
1448             self.depth += 1
1449             self._lambda_argument_depths.append(self.depth)
1450             return True
1451
1452         return False
1453
1454     def maybe_decrement_after_lambda_arguments(self, leaf: Leaf) -> bool:
1455         """See `maybe_increment_lambda_arguments` above for explanation."""
1456         if (
1457             self._lambda_argument_depths
1458             and self._lambda_argument_depths[-1] == self.depth
1459             and leaf.type == token.COLON
1460         ):
1461             self.depth -= 1
1462             self._lambda_argument_depths.pop()
1463             return True
1464
1465         return False
1466
1467     def get_open_lsqb(self) -> Optional[Leaf]:
1468         """Return the most recent opening square bracket (if any)."""
1469         return self.bracket_match.get((self.depth - 1, token.RSQB))
1470
1471
1472 @dataclass
1473 class Line:
1474     """Holds leaves and comments. Can be printed with `str(line)`."""
1475
1476     mode: Mode
1477     depth: int = 0
1478     leaves: List[Leaf] = field(default_factory=list)
1479     # keys ordered like `leaves`
1480     comments: Dict[LeafID, List[Leaf]] = field(default_factory=dict)
1481     bracket_tracker: BracketTracker = field(default_factory=BracketTracker)
1482     inside_brackets: bool = False
1483     should_explode: bool = False
1484     magic_trailing_comma: Optional[Leaf] = None
1485
1486     def append(self, leaf: Leaf, preformatted: bool = False) -> None:
1487         """Add a new `leaf` to the end of the line.
1488
1489         Unless `preformatted` is True, the `leaf` will receive a new consistent
1490         whitespace prefix and metadata applied by :class:`BracketTracker`.
1491         Trailing commas are maybe removed, unpacked for loop variables are
1492         demoted from being delimiters.
1493
1494         Inline comments are put aside.
1495         """
1496         has_value = leaf.type in BRACKETS or bool(leaf.value.strip())
1497         if not has_value:
1498             return
1499
1500         if token.COLON == leaf.type and self.is_class_paren_empty:
1501             del self.leaves[-2:]
1502         if self.leaves and not preformatted:
1503             # Note: at this point leaf.prefix should be empty except for
1504             # imports, for which we only preserve newlines.
1505             leaf.prefix += whitespace(
1506                 leaf, complex_subscript=self.is_complex_subscript(leaf)
1507             )
1508         if self.inside_brackets or not preformatted:
1509             self.bracket_tracker.mark(leaf)
1510             if self.mode.magic_trailing_comma:
1511                 if self.has_magic_trailing_comma(leaf):
1512                     self.magic_trailing_comma = leaf
1513             elif self.has_magic_trailing_comma(leaf, ensure_removable=True):
1514                 self.remove_trailing_comma()
1515         if not self.append_comment(leaf):
1516             self.leaves.append(leaf)
1517
1518     def append_safe(self, leaf: Leaf, preformatted: bool = False) -> None:
1519         """Like :func:`append()` but disallow invalid standalone comment structure.
1520
1521         Raises ValueError when any `leaf` is appended after a standalone comment
1522         or when a standalone comment is not the first leaf on the line.
1523         """
1524         if self.bracket_tracker.depth == 0:
1525             if self.is_comment:
1526                 raise ValueError("cannot append to standalone comments")
1527
1528             if self.leaves and leaf.type == STANDALONE_COMMENT:
1529                 raise ValueError(
1530                     "cannot append standalone comments to a populated line"
1531                 )
1532
1533         self.append(leaf, preformatted=preformatted)
1534
1535     @property
1536     def is_comment(self) -> bool:
1537         """Is this line a standalone comment?"""
1538         return len(self.leaves) == 1 and self.leaves[0].type == STANDALONE_COMMENT
1539
1540     @property
1541     def is_decorator(self) -> bool:
1542         """Is this line a decorator?"""
1543         return bool(self) and self.leaves[0].type == token.AT
1544
1545     @property
1546     def is_import(self) -> bool:
1547         """Is this an import line?"""
1548         return bool(self) and is_import(self.leaves[0])
1549
1550     @property
1551     def is_class(self) -> bool:
1552         """Is this line a class definition?"""
1553         return (
1554             bool(self)
1555             and self.leaves[0].type == token.NAME
1556             and self.leaves[0].value == "class"
1557         )
1558
1559     @property
1560     def is_stub_class(self) -> bool:
1561         """Is this line a class definition with a body consisting only of "..."?"""
1562         return self.is_class and self.leaves[-3:] == [
1563             Leaf(token.DOT, ".") for _ in range(3)
1564         ]
1565
1566     @property
1567     def is_def(self) -> bool:
1568         """Is this a function definition? (Also returns True for async defs.)"""
1569         try:
1570             first_leaf = self.leaves[0]
1571         except IndexError:
1572             return False
1573
1574         try:
1575             second_leaf: Optional[Leaf] = self.leaves[1]
1576         except IndexError:
1577             second_leaf = None
1578         return (first_leaf.type == token.NAME and first_leaf.value == "def") or (
1579             first_leaf.type == token.ASYNC
1580             and second_leaf is not None
1581             and second_leaf.type == token.NAME
1582             and second_leaf.value == "def"
1583         )
1584
1585     @property
1586     def is_class_paren_empty(self) -> bool:
1587         """Is this a class with no base classes but using parentheses?
1588
1589         Those are unnecessary and should be removed.
1590         """
1591         return (
1592             bool(self)
1593             and len(self.leaves) == 4
1594             and self.is_class
1595             and self.leaves[2].type == token.LPAR
1596             and self.leaves[2].value == "("
1597             and self.leaves[3].type == token.RPAR
1598             and self.leaves[3].value == ")"
1599         )
1600
1601     @property
1602     def is_triple_quoted_string(self) -> bool:
1603         """Is the line a triple quoted string?"""
1604         return (
1605             bool(self)
1606             and self.leaves[0].type == token.STRING
1607             and self.leaves[0].value.startswith(('"""', "'''"))
1608         )
1609
1610     def contains_standalone_comments(self, depth_limit: int = sys.maxsize) -> bool:
1611         """If so, needs to be split before emitting."""
1612         for leaf in self.leaves:
1613             if leaf.type == STANDALONE_COMMENT and leaf.bracket_depth <= depth_limit:
1614                 return True
1615
1616         return False
1617
1618     def contains_uncollapsable_type_comments(self) -> bool:
1619         ignored_ids = set()
1620         try:
1621             last_leaf = self.leaves[-1]
1622             ignored_ids.add(id(last_leaf))
1623             if last_leaf.type == token.COMMA or (
1624                 last_leaf.type == token.RPAR and not last_leaf.value
1625             ):
1626                 # When trailing commas or optional parens are inserted by Black for
1627                 # consistency, comments after the previous last element are not moved
1628                 # (they don't have to, rendering will still be correct).  So we ignore
1629                 # trailing commas and invisible.
1630                 last_leaf = self.leaves[-2]
1631                 ignored_ids.add(id(last_leaf))
1632         except IndexError:
1633             return False
1634
1635         # A type comment is uncollapsable if it is attached to a leaf
1636         # that isn't at the end of the line (since that could cause it
1637         # to get associated to a different argument) or if there are
1638         # comments before it (since that could cause it to get hidden
1639         # behind a comment.
1640         comment_seen = False
1641         for leaf_id, comments in self.comments.items():
1642             for comment in comments:
1643                 if is_type_comment(comment):
1644                     if comment_seen or (
1645                         not is_type_comment(comment, " ignore")
1646                         and leaf_id not in ignored_ids
1647                     ):
1648                         return True
1649
1650                 comment_seen = True
1651
1652         return False
1653
1654     def contains_unsplittable_type_ignore(self) -> bool:
1655         if not self.leaves:
1656             return False
1657
1658         # If a 'type: ignore' is attached to the end of a line, we
1659         # can't split the line, because we can't know which of the
1660         # subexpressions the ignore was meant to apply to.
1661         #
1662         # We only want this to apply to actual physical lines from the
1663         # original source, though: we don't want the presence of a
1664         # 'type: ignore' at the end of a multiline expression to
1665         # justify pushing it all onto one line. Thus we
1666         # (unfortunately) need to check the actual source lines and
1667         # only report an unsplittable 'type: ignore' if this line was
1668         # one line in the original code.
1669
1670         # Grab the first and last line numbers, skipping generated leaves
1671         first_line = next((leaf.lineno for leaf in self.leaves if leaf.lineno != 0), 0)
1672         last_line = next(
1673             (leaf.lineno for leaf in reversed(self.leaves) if leaf.lineno != 0), 0
1674         )
1675
1676         if first_line == last_line:
1677             # We look at the last two leaves since a comma or an
1678             # invisible paren could have been added at the end of the
1679             # line.
1680             for node in self.leaves[-2:]:
1681                 for comment in self.comments.get(id(node), []):
1682                     if is_type_comment(comment, " ignore"):
1683                         return True
1684
1685         return False
1686
1687     def contains_multiline_strings(self) -> bool:
1688         return any(is_multiline_string(leaf) for leaf in self.leaves)
1689
1690     def has_magic_trailing_comma(
1691         self, closing: Leaf, ensure_removable: bool = False
1692     ) -> bool:
1693         """Return True if we have a magic trailing comma, that is when:
1694         - there's a trailing comma here
1695         - it's not a one-tuple
1696         Additionally, if ensure_removable:
1697         - it's not from square bracket indexing
1698         """
1699         if not (
1700             closing.type in CLOSING_BRACKETS
1701             and self.leaves
1702             and self.leaves[-1].type == token.COMMA
1703         ):
1704             return False
1705
1706         if closing.type == token.RBRACE:
1707             return True
1708
1709         if closing.type == token.RSQB:
1710             if not ensure_removable:
1711                 return True
1712             comma = self.leaves[-1]
1713             return bool(comma.parent and comma.parent.type == syms.listmaker)
1714
1715         if self.is_import:
1716             return True
1717
1718         if not is_one_tuple_between(closing.opening_bracket, closing, self.leaves):
1719             return True
1720
1721         return False
1722
1723     def append_comment(self, comment: Leaf) -> bool:
1724         """Add an inline or standalone comment to the line."""
1725         if (
1726             comment.type == STANDALONE_COMMENT
1727             and self.bracket_tracker.any_open_brackets()
1728         ):
1729             comment.prefix = ""
1730             return False
1731
1732         if comment.type != token.COMMENT:
1733             return False
1734
1735         if not self.leaves:
1736             comment.type = STANDALONE_COMMENT
1737             comment.prefix = ""
1738             return False
1739
1740         last_leaf = self.leaves[-1]
1741         if (
1742             last_leaf.type == token.RPAR
1743             and not last_leaf.value
1744             and last_leaf.parent
1745             and len(list(last_leaf.parent.leaves())) <= 3
1746             and not is_type_comment(comment)
1747         ):
1748             # Comments on an optional parens wrapping a single leaf should belong to
1749             # the wrapped node except if it's a type comment. Pinning the comment like
1750             # this avoids unstable formatting caused by comment migration.
1751             if len(self.leaves) < 2:
1752                 comment.type = STANDALONE_COMMENT
1753                 comment.prefix = ""
1754                 return False
1755
1756             last_leaf = self.leaves[-2]
1757         self.comments.setdefault(id(last_leaf), []).append(comment)
1758         return True
1759
1760     def comments_after(self, leaf: Leaf) -> List[Leaf]:
1761         """Generate comments that should appear directly after `leaf`."""
1762         return self.comments.get(id(leaf), [])
1763
1764     def remove_trailing_comma(self) -> None:
1765         """Remove the trailing comma and moves the comments attached to it."""
1766         trailing_comma = self.leaves.pop()
1767         trailing_comma_comments = self.comments.pop(id(trailing_comma), [])
1768         self.comments.setdefault(id(self.leaves[-1]), []).extend(
1769             trailing_comma_comments
1770         )
1771
1772     def is_complex_subscript(self, leaf: Leaf) -> bool:
1773         """Return True iff `leaf` is part of a slice with non-trivial exprs."""
1774         open_lsqb = self.bracket_tracker.get_open_lsqb()
1775         if open_lsqb is None:
1776             return False
1777
1778         subscript_start = open_lsqb.next_sibling
1779
1780         if isinstance(subscript_start, Node):
1781             if subscript_start.type == syms.listmaker:
1782                 return False
1783
1784             if subscript_start.type == syms.subscriptlist:
1785                 subscript_start = child_towards(subscript_start, leaf)
1786         return subscript_start is not None and any(
1787             n.type in TEST_DESCENDANTS for n in subscript_start.pre_order()
1788         )
1789
1790     def clone(self) -> "Line":
1791         return Line(
1792             mode=self.mode,
1793             depth=self.depth,
1794             inside_brackets=self.inside_brackets,
1795             should_explode=self.should_explode,
1796             magic_trailing_comma=self.magic_trailing_comma,
1797         )
1798
1799     def __str__(self) -> str:
1800         """Render the line."""
1801         if not self:
1802             return "\n"
1803
1804         indent = "    " * self.depth
1805         leaves = iter(self.leaves)
1806         first = next(leaves)
1807         res = f"{first.prefix}{indent}{first.value}"
1808         for leaf in leaves:
1809             res += str(leaf)
1810         for comment in itertools.chain.from_iterable(self.comments.values()):
1811             res += str(comment)
1812
1813         return res + "\n"
1814
1815     def __bool__(self) -> bool:
1816         """Return True if the line has leaves or comments."""
1817         return bool(self.leaves or self.comments)
1818
1819
1820 @dataclass
1821 class EmptyLineTracker:
1822     """Provides a stateful method that returns the number of potential extra
1823     empty lines needed before and after the currently processed line.
1824
1825     Note: this tracker works on lines that haven't been split yet.  It assumes
1826     the prefix of the first leaf consists of optional newlines.  Those newlines
1827     are consumed by `maybe_empty_lines()` and included in the computation.
1828     """
1829
1830     is_pyi: bool = False
1831     previous_line: Optional[Line] = None
1832     previous_after: int = 0
1833     previous_defs: List[int] = field(default_factory=list)
1834
1835     def maybe_empty_lines(self, current_line: Line) -> Tuple[int, int]:
1836         """Return the number of extra empty lines before and after the `current_line`.
1837
1838         This is for separating `def`, `async def` and `class` with extra empty
1839         lines (two on module-level).
1840         """
1841         before, after = self._maybe_empty_lines(current_line)
1842         before = (
1843             # Black should not insert empty lines at the beginning
1844             # of the file
1845             0
1846             if self.previous_line is None
1847             else before - self.previous_after
1848         )
1849         self.previous_after = after
1850         self.previous_line = current_line
1851         return before, after
1852
1853     def _maybe_empty_lines(self, current_line: Line) -> Tuple[int, int]:
1854         max_allowed = 1
1855         if current_line.depth == 0:
1856             max_allowed = 1 if self.is_pyi else 2
1857         if current_line.leaves:
1858             # Consume the first leaf's extra newlines.
1859             first_leaf = current_line.leaves[0]
1860             before = first_leaf.prefix.count("\n")
1861             before = min(before, max_allowed)
1862             first_leaf.prefix = ""
1863         else:
1864             before = 0
1865         depth = current_line.depth
1866         while self.previous_defs and self.previous_defs[-1] >= depth:
1867             self.previous_defs.pop()
1868             if self.is_pyi:
1869                 before = 0 if depth else 1
1870             else:
1871                 before = 1 if depth else 2
1872         if current_line.is_decorator or current_line.is_def or current_line.is_class:
1873             return self._maybe_empty_lines_for_class_or_def(current_line, before)
1874
1875         if (
1876             self.previous_line
1877             and self.previous_line.is_import
1878             and not current_line.is_import
1879             and depth == self.previous_line.depth
1880         ):
1881             return (before or 1), 0
1882
1883         if (
1884             self.previous_line
1885             and self.previous_line.is_class
1886             and current_line.is_triple_quoted_string
1887         ):
1888             return before, 1
1889
1890         return before, 0
1891
1892     def _maybe_empty_lines_for_class_or_def(
1893         self, current_line: Line, before: int
1894     ) -> Tuple[int, int]:
1895         if not current_line.is_decorator:
1896             self.previous_defs.append(current_line.depth)
1897         if self.previous_line is None:
1898             # Don't insert empty lines before the first line in the file.
1899             return 0, 0
1900
1901         if self.previous_line.is_decorator:
1902             if self.is_pyi and current_line.is_stub_class:
1903                 # Insert an empty line after a decorated stub class
1904                 return 0, 1
1905
1906             return 0, 0
1907
1908         if self.previous_line.depth < current_line.depth and (
1909             self.previous_line.is_class or self.previous_line.is_def
1910         ):
1911             return 0, 0
1912
1913         if (
1914             self.previous_line.is_comment
1915             and self.previous_line.depth == current_line.depth
1916             and before == 0
1917         ):
1918             return 0, 0
1919
1920         if self.is_pyi:
1921             if self.previous_line.depth > current_line.depth:
1922                 newlines = 1
1923             elif current_line.is_class or self.previous_line.is_class:
1924                 if current_line.is_stub_class and self.previous_line.is_stub_class:
1925                     # No blank line between classes with an empty body
1926                     newlines = 0
1927                 else:
1928                     newlines = 1
1929             elif (
1930                 current_line.is_def or current_line.is_decorator
1931             ) and not self.previous_line.is_def:
1932                 # Blank line between a block of functions (maybe with preceding
1933                 # decorators) and a block of non-functions
1934                 newlines = 1
1935             else:
1936                 newlines = 0
1937         else:
1938             newlines = 2
1939         if current_line.depth and newlines:
1940             newlines -= 1
1941         return newlines, 0
1942
1943
1944 @dataclass
1945 class LineGenerator(Visitor[Line]):
1946     """Generates reformatted Line objects.  Empty lines are not emitted.
1947
1948     Note: destroys the tree it's visiting by mutating prefixes of its leaves
1949     in ways that will no longer stringify to valid Python code on the tree.
1950     """
1951
1952     mode: Mode
1953     remove_u_prefix: bool = False
1954     current_line: Line = field(init=False)
1955
1956     def line(self, indent: int = 0) -> Iterator[Line]:
1957         """Generate a line.
1958
1959         If the line is empty, only emit if it makes sense.
1960         If the line is too long, split it first and then generate.
1961
1962         If any lines were generated, set up a new current_line.
1963         """
1964         if not self.current_line:
1965             self.current_line.depth += indent
1966             return  # Line is empty, don't emit. Creating a new one unnecessary.
1967
1968         complete_line = self.current_line
1969         self.current_line = Line(mode=self.mode, depth=complete_line.depth + indent)
1970         yield complete_line
1971
1972     def visit_default(self, node: LN) -> Iterator[Line]:
1973         """Default `visit_*()` implementation. Recurses to children of `node`."""
1974         if isinstance(node, Leaf):
1975             any_open_brackets = self.current_line.bracket_tracker.any_open_brackets()
1976             for comment in generate_comments(node):
1977                 if any_open_brackets:
1978                     # any comment within brackets is subject to splitting
1979                     self.current_line.append(comment)
1980                 elif comment.type == token.COMMENT:
1981                     # regular trailing comment
1982                     self.current_line.append(comment)
1983                     yield from self.line()
1984
1985                 else:
1986                     # regular standalone comment
1987                     yield from self.line()
1988
1989                     self.current_line.append(comment)
1990                     yield from self.line()
1991
1992             normalize_prefix(node, inside_brackets=any_open_brackets)
1993             if self.mode.string_normalization and node.type == token.STRING:
1994                 normalize_string_prefix(node, remove_u_prefix=self.remove_u_prefix)
1995                 normalize_string_quotes(node)
1996             if node.type == token.NUMBER:
1997                 normalize_numeric_literal(node)
1998             if node.type not in WHITESPACE:
1999                 self.current_line.append(node)
2000         yield from super().visit_default(node)
2001
2002     def visit_INDENT(self, node: Leaf) -> Iterator[Line]:
2003         """Increase indentation level, maybe yield a line."""
2004         # In blib2to3 INDENT never holds comments.
2005         yield from self.line(+1)
2006         yield from self.visit_default(node)
2007
2008     def visit_DEDENT(self, node: Leaf) -> Iterator[Line]:
2009         """Decrease indentation level, maybe yield a line."""
2010         # The current line might still wait for trailing comments.  At DEDENT time
2011         # there won't be any (they would be prefixes on the preceding NEWLINE).
2012         # Emit the line then.
2013         yield from self.line()
2014
2015         # While DEDENT has no value, its prefix may contain standalone comments
2016         # that belong to the current indentation level.  Get 'em.
2017         yield from self.visit_default(node)
2018
2019         # Finally, emit the dedent.
2020         yield from self.line(-1)
2021
2022     def visit_stmt(
2023         self, node: Node, keywords: Set[str], parens: Set[str]
2024     ) -> Iterator[Line]:
2025         """Visit a statement.
2026
2027         This implementation is shared for `if`, `while`, `for`, `try`, `except`,
2028         `def`, `with`, `class`, `assert` and assignments.
2029
2030         The relevant Python language `keywords` for a given statement will be
2031         NAME leaves within it. This methods puts those on a separate line.
2032
2033         `parens` holds a set of string leaf values immediately after which
2034         invisible parens should be put.
2035         """
2036         normalize_invisible_parens(node, parens_after=parens)
2037         for child in node.children:
2038             if child.type == token.NAME and child.value in keywords:  # type: ignore
2039                 yield from self.line()
2040
2041             yield from self.visit(child)
2042
2043     def visit_suite(self, node: Node) -> Iterator[Line]:
2044         """Visit a suite."""
2045         if self.mode.is_pyi and is_stub_suite(node):
2046             yield from self.visit(node.children[2])
2047         else:
2048             yield from self.visit_default(node)
2049
2050     def visit_simple_stmt(self, node: Node) -> Iterator[Line]:
2051         """Visit a statement without nested statements."""
2052         is_suite_like = node.parent and node.parent.type in STATEMENT
2053         if is_suite_like:
2054             if self.mode.is_pyi and is_stub_body(node):
2055                 yield from self.visit_default(node)
2056             else:
2057                 yield from self.line(+1)
2058                 yield from self.visit_default(node)
2059                 yield from self.line(-1)
2060
2061         else:
2062             if (
2063                 not self.mode.is_pyi
2064                 or not node.parent
2065                 or not is_stub_suite(node.parent)
2066             ):
2067                 yield from self.line()
2068             yield from self.visit_default(node)
2069
2070     def visit_async_stmt(self, node: Node) -> Iterator[Line]:
2071         """Visit `async def`, `async for`, `async with`."""
2072         yield from self.line()
2073
2074         children = iter(node.children)
2075         for child in children:
2076             yield from self.visit(child)
2077
2078             if child.type == token.ASYNC:
2079                 break
2080
2081         internal_stmt = next(children)
2082         for child in internal_stmt.children:
2083             yield from self.visit(child)
2084
2085     def visit_decorators(self, node: Node) -> Iterator[Line]:
2086         """Visit decorators."""
2087         for child in node.children:
2088             yield from self.line()
2089             yield from self.visit(child)
2090
2091     def visit_SEMI(self, leaf: Leaf) -> Iterator[Line]:
2092         """Remove a semicolon and put the other statement on a separate line."""
2093         yield from self.line()
2094
2095     def visit_ENDMARKER(self, leaf: Leaf) -> Iterator[Line]:
2096         """End of file. Process outstanding comments and end with a newline."""
2097         yield from self.visit_default(leaf)
2098         yield from self.line()
2099
2100     def visit_STANDALONE_COMMENT(self, leaf: Leaf) -> Iterator[Line]:
2101         if not self.current_line.bracket_tracker.any_open_brackets():
2102             yield from self.line()
2103         yield from self.visit_default(leaf)
2104
2105     def visit_factor(self, node: Node) -> Iterator[Line]:
2106         """Force parentheses between a unary op and a binary power:
2107
2108         -2 ** 8 -> -(2 ** 8)
2109         """
2110         _operator, operand = node.children
2111         if (
2112             operand.type == syms.power
2113             and len(operand.children) == 3
2114             and operand.children[1].type == token.DOUBLESTAR
2115         ):
2116             lpar = Leaf(token.LPAR, "(")
2117             rpar = Leaf(token.RPAR, ")")
2118             index = operand.remove() or 0
2119             node.insert_child(index, Node(syms.atom, [lpar, operand, rpar]))
2120         yield from self.visit_default(node)
2121
2122     def visit_STRING(self, leaf: Leaf) -> Iterator[Line]:
2123         if is_docstring(leaf) and "\\\n" not in leaf.value:
2124             # We're ignoring docstrings with backslash newline escapes because changing
2125             # indentation of those changes the AST representation of the code.
2126             prefix = get_string_prefix(leaf.value)
2127             lead_len = len(prefix) + 3
2128             tail_len = -3
2129             indent = " " * 4 * self.current_line.depth
2130             docstring = fix_docstring(leaf.value[lead_len:tail_len], indent)
2131             if docstring:
2132                 if leaf.value[lead_len - 1] == docstring[0]:
2133                     docstring = " " + docstring
2134                 if leaf.value[tail_len + 1] == docstring[-1]:
2135                     docstring = docstring + " "
2136             leaf.value = leaf.value[0:lead_len] + docstring + leaf.value[tail_len:]
2137
2138         yield from self.visit_default(leaf)
2139
2140     def __post_init__(self) -> None:
2141         """You are in a twisty little maze of passages."""
2142         self.current_line = Line(mode=self.mode)
2143
2144         v = self.visit_stmt
2145         Ø: Set[str] = set()
2146         self.visit_assert_stmt = partial(v, keywords={"assert"}, parens={"assert", ","})
2147         self.visit_if_stmt = partial(
2148             v, keywords={"if", "else", "elif"}, parens={"if", "elif"}
2149         )
2150         self.visit_while_stmt = partial(v, keywords={"while", "else"}, parens={"while"})
2151         self.visit_for_stmt = partial(v, keywords={"for", "else"}, parens={"for", "in"})
2152         self.visit_try_stmt = partial(
2153             v, keywords={"try", "except", "else", "finally"}, parens=Ø
2154         )
2155         self.visit_except_clause = partial(v, keywords={"except"}, parens=Ø)
2156         self.visit_with_stmt = partial(v, keywords={"with"}, parens=Ø)
2157         self.visit_funcdef = partial(v, keywords={"def"}, parens=Ø)
2158         self.visit_classdef = partial(v, keywords={"class"}, parens=Ø)
2159         self.visit_expr_stmt = partial(v, keywords=Ø, parens=ASSIGNMENTS)
2160         self.visit_return_stmt = partial(v, keywords={"return"}, parens={"return"})
2161         self.visit_import_from = partial(v, keywords=Ø, parens={"import"})
2162         self.visit_del_stmt = partial(v, keywords=Ø, parens={"del"})
2163         self.visit_async_funcdef = self.visit_async_stmt
2164         self.visit_decorated = self.visit_decorators
2165
2166
2167 IMPLICIT_TUPLE = {syms.testlist, syms.testlist_star_expr, syms.exprlist}
2168 BRACKET = {token.LPAR: token.RPAR, token.LSQB: token.RSQB, token.LBRACE: token.RBRACE}
2169 OPENING_BRACKETS = set(BRACKET.keys())
2170 CLOSING_BRACKETS = set(BRACKET.values())
2171 BRACKETS = OPENING_BRACKETS | CLOSING_BRACKETS
2172 ALWAYS_NO_SPACE = CLOSING_BRACKETS | {token.COMMA, STANDALONE_COMMENT}
2173
2174
2175 def whitespace(leaf: Leaf, *, complex_subscript: bool) -> str:  # noqa: C901
2176     """Return whitespace prefix if needed for the given `leaf`.
2177
2178     `complex_subscript` signals whether the given leaf is part of a subscription
2179     which has non-trivial arguments, like arithmetic expressions or function calls.
2180     """
2181     NO = ""
2182     SPACE = " "
2183     DOUBLESPACE = "  "
2184     t = leaf.type
2185     p = leaf.parent
2186     v = leaf.value
2187     if t in ALWAYS_NO_SPACE:
2188         return NO
2189
2190     if t == token.COMMENT:
2191         return DOUBLESPACE
2192
2193     assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}"
2194     if t == token.COLON and p.type not in {
2195         syms.subscript,
2196         syms.subscriptlist,
2197         syms.sliceop,
2198     }:
2199         return NO
2200
2201     prev = leaf.prev_sibling
2202     if not prev:
2203         prevp = preceding_leaf(p)
2204         if not prevp or prevp.type in OPENING_BRACKETS:
2205             return NO
2206
2207         if t == token.COLON:
2208             if prevp.type == token.COLON:
2209                 return NO
2210
2211             elif prevp.type != token.COMMA and not complex_subscript:
2212                 return NO
2213
2214             return SPACE
2215
2216         if prevp.type == token.EQUAL:
2217             if prevp.parent:
2218                 if prevp.parent.type in {
2219                     syms.arglist,
2220                     syms.argument,
2221                     syms.parameters,
2222                     syms.varargslist,
2223                 }:
2224                     return NO
2225
2226                 elif prevp.parent.type == syms.typedargslist:
2227                     # A bit hacky: if the equal sign has whitespace, it means we
2228                     # previously found it's a typed argument.  So, we're using
2229                     # that, too.
2230                     return prevp.prefix
2231
2232         elif prevp.type in VARARGS_SPECIALS:
2233             if is_vararg(prevp, within=VARARGS_PARENTS | UNPACKING_PARENTS):
2234                 return NO
2235
2236         elif prevp.type == token.COLON:
2237             if prevp.parent and prevp.parent.type in {syms.subscript, syms.sliceop}:
2238                 return SPACE if complex_subscript else NO
2239
2240         elif (
2241             prevp.parent
2242             and prevp.parent.type == syms.factor
2243             and prevp.type in MATH_OPERATORS
2244         ):
2245             return NO
2246
2247         elif (
2248             prevp.type == token.RIGHTSHIFT
2249             and prevp.parent
2250             and prevp.parent.type == syms.shift_expr
2251             and prevp.prev_sibling
2252             and prevp.prev_sibling.type == token.NAME
2253             and prevp.prev_sibling.value == "print"  # type: ignore
2254         ):
2255             # Python 2 print chevron
2256             return NO
2257         elif prevp.type == token.AT and p.parent and p.parent.type == syms.decorator:
2258             # no space in decorators
2259             return NO
2260
2261     elif prev.type in OPENING_BRACKETS:
2262         return NO
2263
2264     if p.type in {syms.parameters, syms.arglist}:
2265         # untyped function signatures or calls
2266         if not prev or prev.type != token.COMMA:
2267             return NO
2268
2269     elif p.type == syms.varargslist:
2270         # lambdas
2271         if prev and prev.type != token.COMMA:
2272             return NO
2273
2274     elif p.type == syms.typedargslist:
2275         # typed function signatures
2276         if not prev:
2277             return NO
2278
2279         if t == token.EQUAL:
2280             if prev.type != syms.tname:
2281                 return NO
2282
2283         elif prev.type == token.EQUAL:
2284             # A bit hacky: if the equal sign has whitespace, it means we
2285             # previously found it's a typed argument.  So, we're using that, too.
2286             return prev.prefix
2287
2288         elif prev.type != token.COMMA:
2289             return NO
2290
2291     elif p.type == syms.tname:
2292         # type names
2293         if not prev:
2294             prevp = preceding_leaf(p)
2295             if not prevp or prevp.type != token.COMMA:
2296                 return NO
2297
2298     elif p.type == syms.trailer:
2299         # attributes and calls
2300         if t == token.LPAR or t == token.RPAR:
2301             return NO
2302
2303         if not prev:
2304             if t == token.DOT:
2305                 prevp = preceding_leaf(p)
2306                 if not prevp or prevp.type != token.NUMBER:
2307                     return NO
2308
2309             elif t == token.LSQB:
2310                 return NO
2311
2312         elif prev.type != token.COMMA:
2313             return NO
2314
2315     elif p.type == syms.argument:
2316         # single argument
2317         if t == token.EQUAL:
2318             return NO
2319
2320         if not prev:
2321             prevp = preceding_leaf(p)
2322             if not prevp or prevp.type == token.LPAR:
2323                 return NO
2324
2325         elif prev.type in {token.EQUAL} | VARARGS_SPECIALS:
2326             return NO
2327
2328     elif p.type == syms.decorator:
2329         # decorators
2330         return NO
2331
2332     elif p.type == syms.dotted_name:
2333         if prev:
2334             return NO
2335
2336         prevp = preceding_leaf(p)
2337         if not prevp or prevp.type == token.AT or prevp.type == token.DOT:
2338             return NO
2339
2340     elif p.type == syms.classdef:
2341         if t == token.LPAR:
2342             return NO
2343
2344         if prev and prev.type == token.LPAR:
2345             return NO
2346
2347     elif p.type in {syms.subscript, syms.sliceop}:
2348         # indexing
2349         if not prev:
2350             assert p.parent is not None, "subscripts are always parented"
2351             if p.parent.type == syms.subscriptlist:
2352                 return SPACE
2353
2354             return NO
2355
2356         elif not complex_subscript:
2357             return NO
2358
2359     elif p.type == syms.atom:
2360         if prev and t == token.DOT:
2361             # dots, but not the first one.
2362             return NO
2363
2364     elif p.type == syms.dictsetmaker:
2365         # dict unpacking
2366         if prev and prev.type == token.DOUBLESTAR:
2367             return NO
2368
2369     elif p.type in {syms.factor, syms.star_expr}:
2370         # unary ops
2371         if not prev:
2372             prevp = preceding_leaf(p)
2373             if not prevp or prevp.type in OPENING_BRACKETS:
2374                 return NO
2375
2376             prevp_parent = prevp.parent
2377             assert prevp_parent is not None
2378             if prevp.type == token.COLON and prevp_parent.type in {
2379                 syms.subscript,
2380                 syms.sliceop,
2381             }:
2382                 return NO
2383
2384             elif prevp.type == token.EQUAL and prevp_parent.type == syms.argument:
2385                 return NO
2386
2387         elif t in {token.NAME, token.NUMBER, token.STRING}:
2388             return NO
2389
2390     elif p.type == syms.import_from:
2391         if t == token.DOT:
2392             if prev and prev.type == token.DOT:
2393                 return NO
2394
2395         elif t == token.NAME:
2396             if v == "import":
2397                 return SPACE
2398
2399             if prev and prev.type == token.DOT:
2400                 return NO
2401
2402     elif p.type == syms.sliceop:
2403         return NO
2404
2405     return SPACE
2406
2407
2408 def preceding_leaf(node: Optional[LN]) -> Optional[Leaf]:
2409     """Return the first leaf that precedes `node`, if any."""
2410     while node:
2411         res = node.prev_sibling
2412         if res:
2413             if isinstance(res, Leaf):
2414                 return res
2415
2416             try:
2417                 return list(res.leaves())[-1]
2418
2419             except IndexError:
2420                 return None
2421
2422         node = node.parent
2423     return None
2424
2425
2426 def prev_siblings_are(node: Optional[LN], tokens: List[Optional[NodeType]]) -> bool:
2427     """Return if the `node` and its previous siblings match types against the provided
2428     list of tokens; the provided `node`has its type matched against the last element in
2429     the list.  `None` can be used as the first element to declare that the start of the
2430     list is anchored at the start of its parent's children."""
2431     if not tokens:
2432         return True
2433     if tokens[-1] is None:
2434         return node is None
2435     if not node:
2436         return False
2437     if node.type != tokens[-1]:
2438         return False
2439     return prev_siblings_are(node.prev_sibling, tokens[:-1])
2440
2441
2442 def child_towards(ancestor: Node, descendant: LN) -> Optional[LN]:
2443     """Return the child of `ancestor` that contains `descendant`."""
2444     node: Optional[LN] = descendant
2445     while node and node.parent != ancestor:
2446         node = node.parent
2447     return node
2448
2449
2450 def container_of(leaf: Leaf) -> LN:
2451     """Return `leaf` or one of its ancestors that is the topmost container of it.
2452
2453     By "container" we mean a node where `leaf` is the very first child.
2454     """
2455     same_prefix = leaf.prefix
2456     container: LN = leaf
2457     while container:
2458         parent = container.parent
2459         if parent is None:
2460             break
2461
2462         if parent.children[0].prefix != same_prefix:
2463             break
2464
2465         if parent.type == syms.file_input:
2466             break
2467
2468         if parent.prev_sibling is not None and parent.prev_sibling.type in BRACKETS:
2469             break
2470
2471         container = parent
2472     return container
2473
2474
2475 def is_split_after_delimiter(leaf: Leaf, previous: Optional[Leaf] = None) -> Priority:
2476     """Return the priority of the `leaf` delimiter, given a line break after it.
2477
2478     The delimiter priorities returned here are from those delimiters that would
2479     cause a line break after themselves.
2480
2481     Higher numbers are higher priority.
2482     """
2483     if leaf.type == token.COMMA:
2484         return COMMA_PRIORITY
2485
2486     return 0
2487
2488
2489 def is_split_before_delimiter(leaf: Leaf, previous: Optional[Leaf] = None) -> Priority:
2490     """Return the priority of the `leaf` delimiter, given a line break before it.
2491
2492     The delimiter priorities returned here are from those delimiters that would
2493     cause a line break before themselves.
2494
2495     Higher numbers are higher priority.
2496     """
2497     if is_vararg(leaf, within=VARARGS_PARENTS | UNPACKING_PARENTS):
2498         # * and ** might also be MATH_OPERATORS but in this case they are not.
2499         # Don't treat them as a delimiter.
2500         return 0
2501
2502     if (
2503         leaf.type == token.DOT
2504         and leaf.parent
2505         and leaf.parent.type not in {syms.import_from, syms.dotted_name}
2506         and (previous is None or previous.type in CLOSING_BRACKETS)
2507     ):
2508         return DOT_PRIORITY
2509
2510     if (
2511         leaf.type in MATH_OPERATORS
2512         and leaf.parent
2513         and leaf.parent.type not in {syms.factor, syms.star_expr}
2514     ):
2515         return MATH_PRIORITIES[leaf.type]
2516
2517     if leaf.type in COMPARATORS:
2518         return COMPARATOR_PRIORITY
2519
2520     if (
2521         leaf.type == token.STRING
2522         and previous is not None
2523         and previous.type == token.STRING
2524     ):
2525         return STRING_PRIORITY
2526
2527     if leaf.type not in {token.NAME, token.ASYNC}:
2528         return 0
2529
2530     if (
2531         leaf.value == "for"
2532         and leaf.parent
2533         and leaf.parent.type in {syms.comp_for, syms.old_comp_for}
2534         or leaf.type == token.ASYNC
2535     ):
2536         if (
2537             not isinstance(leaf.prev_sibling, Leaf)
2538             or leaf.prev_sibling.value != "async"
2539         ):
2540             return COMPREHENSION_PRIORITY
2541
2542     if (
2543         leaf.value == "if"
2544         and leaf.parent
2545         and leaf.parent.type in {syms.comp_if, syms.old_comp_if}
2546     ):
2547         return COMPREHENSION_PRIORITY
2548
2549     if leaf.value in {"if", "else"} and leaf.parent and leaf.parent.type == syms.test:
2550         return TERNARY_PRIORITY
2551
2552     if leaf.value == "is":
2553         return COMPARATOR_PRIORITY
2554
2555     if (
2556         leaf.value == "in"
2557         and leaf.parent
2558         and leaf.parent.type in {syms.comp_op, syms.comparison}
2559         and not (
2560             previous is not None
2561             and previous.type == token.NAME
2562             and previous.value == "not"
2563         )
2564     ):
2565         return COMPARATOR_PRIORITY
2566
2567     if (
2568         leaf.value == "not"
2569         and leaf.parent
2570         and leaf.parent.type == syms.comp_op
2571         and not (
2572             previous is not None
2573             and previous.type == token.NAME
2574             and previous.value == "is"
2575         )
2576     ):
2577         return COMPARATOR_PRIORITY
2578
2579     if leaf.value in LOGIC_OPERATORS and leaf.parent:
2580         return LOGIC_PRIORITY
2581
2582     return 0
2583
2584
2585 FMT_OFF = {"# fmt: off", "# fmt:off", "# yapf: disable"}
2586 FMT_SKIP = {"# fmt: skip", "# fmt:skip"}
2587 FMT_PASS = {*FMT_OFF, *FMT_SKIP}
2588 FMT_ON = {"# fmt: on", "# fmt:on", "# yapf: enable"}
2589
2590
2591 def generate_comments(leaf: LN) -> Iterator[Leaf]:
2592     """Clean the prefix of the `leaf` and generate comments from it, if any.
2593
2594     Comments in lib2to3 are shoved into the whitespace prefix.  This happens
2595     in `pgen2/driver.py:Driver.parse_tokens()`.  This was a brilliant implementation
2596     move because it does away with modifying the grammar to include all the
2597     possible places in which comments can be placed.
2598
2599     The sad consequence for us though is that comments don't "belong" anywhere.
2600     This is why this function generates simple parentless Leaf objects for
2601     comments.  We simply don't know what the correct parent should be.
2602
2603     No matter though, we can live without this.  We really only need to
2604     differentiate between inline and standalone comments.  The latter don't
2605     share the line with any code.
2606
2607     Inline comments are emitted as regular token.COMMENT leaves.  Standalone
2608     are emitted with a fake STANDALONE_COMMENT token identifier.
2609     """
2610     for pc in list_comments(leaf.prefix, is_endmarker=leaf.type == token.ENDMARKER):
2611         yield Leaf(pc.type, pc.value, prefix="\n" * pc.newlines)
2612
2613
2614 @dataclass
2615 class ProtoComment:
2616     """Describes a piece of syntax that is a comment.
2617
2618     It's not a :class:`blib2to3.pytree.Leaf` so that:
2619
2620     * it can be cached (`Leaf` objects should not be reused more than once as
2621       they store their lineno, column, prefix, and parent information);
2622     * `newlines` and `consumed` fields are kept separate from the `value`. This
2623       simplifies handling of special marker comments like ``# fmt: off/on``.
2624     """
2625
2626     type: int  # token.COMMENT or STANDALONE_COMMENT
2627     value: str  # content of the comment
2628     newlines: int  # how many newlines before the comment
2629     consumed: int  # how many characters of the original leaf's prefix did we consume
2630
2631
2632 @lru_cache(maxsize=4096)
2633 def list_comments(prefix: str, *, is_endmarker: bool) -> List[ProtoComment]:
2634     """Return a list of :class:`ProtoComment` objects parsed from the given `prefix`."""
2635     result: List[ProtoComment] = []
2636     if not prefix or "#" not in prefix:
2637         return result
2638
2639     consumed = 0
2640     nlines = 0
2641     ignored_lines = 0
2642     for index, line in enumerate(re.split("\r?\n", prefix)):
2643         consumed += len(line) + 1  # adding the length of the split '\n'
2644         line = line.lstrip()
2645         if not line:
2646             nlines += 1
2647         if not line.startswith("#"):
2648             # Escaped newlines outside of a comment are not really newlines at
2649             # all. We treat a single-line comment following an escaped newline
2650             # as a simple trailing comment.
2651             if line.endswith("\\"):
2652                 ignored_lines += 1
2653             continue
2654
2655         if index == ignored_lines and not is_endmarker:
2656             comment_type = token.COMMENT  # simple trailing comment
2657         else:
2658             comment_type = STANDALONE_COMMENT
2659         comment = make_comment(line)
2660         result.append(
2661             ProtoComment(
2662                 type=comment_type, value=comment, newlines=nlines, consumed=consumed
2663             )
2664         )
2665         nlines = 0
2666     return result
2667
2668
2669 def make_comment(content: str) -> str:
2670     """Return a consistently formatted comment from the given `content` string.
2671
2672     All comments (except for "##", "#!", "#:", '#'", "#%%") should have a single
2673     space between the hash sign and the content.
2674
2675     If `content` didn't start with a hash sign, one is provided.
2676     """
2677     content = content.rstrip()
2678     if not content:
2679         return "#"
2680
2681     if content[0] == "#":
2682         content = content[1:]
2683     if content and content[0] not in " !:#'%":
2684         content = " " + content
2685     return "#" + content
2686
2687
2688 def transform_line(
2689     line: Line, mode: Mode, features: Collection[Feature] = ()
2690 ) -> Iterator[Line]:
2691     """Transform a `line`, potentially splitting it into many lines.
2692
2693     They should fit in the allotted `line_length` but might not be able to.
2694
2695     `features` are syntactical features that may be used in the output.
2696     """
2697     if line.is_comment:
2698         yield line
2699         return
2700
2701     line_str = line_to_string(line)
2702
2703     def init_st(ST: Type[StringTransformer]) -> StringTransformer:
2704         """Initialize StringTransformer"""
2705         return ST(mode.line_length, mode.string_normalization)
2706
2707     string_merge = init_st(StringMerger)
2708     string_paren_strip = init_st(StringParenStripper)
2709     string_split = init_st(StringSplitter)
2710     string_paren_wrap = init_st(StringParenWrapper)
2711
2712     transformers: List[Transformer]
2713     if (
2714         not line.contains_uncollapsable_type_comments()
2715         and not (line.should_explode or line.magic_trailing_comma)
2716         and (
2717             is_line_short_enough(line, line_length=mode.line_length, line_str=line_str)
2718             or line.contains_unsplittable_type_ignore()
2719         )
2720         and not (line.inside_brackets and line.contains_standalone_comments())
2721     ):
2722         # Only apply basic string preprocessing, since lines shouldn't be split here.
2723         if mode.experimental_string_processing:
2724             transformers = [string_merge, string_paren_strip]
2725         else:
2726             transformers = []
2727     elif line.is_def:
2728         transformers = [left_hand_split]
2729     else:
2730
2731         def rhs(line: Line, features: Collection[Feature]) -> Iterator[Line]:
2732             """Wraps calls to `right_hand_split`.
2733
2734             The calls increasingly `omit` right-hand trailers (bracket pairs with
2735             content), meaning the trailers get glued together to split on another
2736             bracket pair instead.
2737             """
2738             for omit in generate_trailers_to_omit(line, mode.line_length):
2739                 lines = list(
2740                     right_hand_split(line, mode.line_length, features, omit=omit)
2741                 )
2742                 # Note: this check is only able to figure out if the first line of the
2743                 # *current* transformation fits in the line length.  This is true only
2744                 # for simple cases.  All others require running more transforms via
2745                 # `transform_line()`.  This check doesn't know if those would succeed.
2746                 if is_line_short_enough(lines[0], line_length=mode.line_length):
2747                     yield from lines
2748                     return
2749
2750             # All splits failed, best effort split with no omits.
2751             # This mostly happens to multiline strings that are by definition
2752             # reported as not fitting a single line, as well as lines that contain
2753             # trailing commas (those have to be exploded).
2754             yield from right_hand_split(
2755                 line, line_length=mode.line_length, features=features
2756             )
2757
2758         if mode.experimental_string_processing:
2759             if line.inside_brackets:
2760                 transformers = [
2761                     string_merge,
2762                     string_paren_strip,
2763                     string_split,
2764                     delimiter_split,
2765                     standalone_comment_split,
2766                     string_paren_wrap,
2767                     rhs,
2768                 ]
2769             else:
2770                 transformers = [
2771                     string_merge,
2772                     string_paren_strip,
2773                     string_split,
2774                     string_paren_wrap,
2775                     rhs,
2776                 ]
2777         else:
2778             if line.inside_brackets:
2779                 transformers = [delimiter_split, standalone_comment_split, rhs]
2780             else:
2781                 transformers = [rhs]
2782
2783     for transform in transformers:
2784         # We are accumulating lines in `result` because we might want to abort
2785         # mission and return the original line in the end, or attempt a different
2786         # split altogether.
2787         try:
2788             result = run_transformer(line, transform, mode, features, line_str=line_str)
2789         except CannotTransform:
2790             continue
2791         else:
2792             yield from result
2793             break
2794
2795     else:
2796         yield line
2797
2798
2799 @dataclass  # type: ignore
2800 class StringTransformer(ABC):
2801     """
2802     An implementation of the Transformer protocol that relies on its
2803     subclasses overriding the template methods `do_match(...)` and
2804     `do_transform(...)`.
2805
2806     This Transformer works exclusively on strings (for example, by merging
2807     or splitting them).
2808
2809     The following sections can be found among the docstrings of each concrete
2810     StringTransformer subclass.
2811
2812     Requirements:
2813         Which requirements must be met of the given Line for this
2814         StringTransformer to be applied?
2815
2816     Transformations:
2817         If the given Line meets all of the above requirements, which string
2818         transformations can you expect to be applied to it by this
2819         StringTransformer?
2820
2821     Collaborations:
2822         What contractual agreements does this StringTransformer have with other
2823         StringTransfomers? Such collaborations should be eliminated/minimized
2824         as much as possible.
2825     """
2826
2827     line_length: int
2828     normalize_strings: bool
2829     __name__ = "StringTransformer"
2830
2831     @abstractmethod
2832     def do_match(self, line: Line) -> TMatchResult:
2833         """
2834         Returns:
2835             * Ok(string_idx) such that `line.leaves[string_idx]` is our target
2836             string, if a match was able to be made.
2837                 OR
2838             * Err(CannotTransform), if a match was not able to be made.
2839         """
2840
2841     @abstractmethod
2842     def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
2843         """
2844         Yields:
2845             * Ok(new_line) where new_line is the new transformed line.
2846                 OR
2847             * Err(CannotTransform) if the transformation failed for some reason. The
2848             `do_match(...)` template method should usually be used to reject
2849             the form of the given Line, but in some cases it is difficult to
2850             know whether or not a Line meets the StringTransformer's
2851             requirements until the transformation is already midway.
2852
2853         Side Effects:
2854             This method should NOT mutate @line directly, but it MAY mutate the
2855             Line's underlying Node structure. (WARNING: If the underlying Node
2856             structure IS altered, then this method should NOT be allowed to
2857             yield an CannotTransform after that point.)
2858         """
2859
2860     def __call__(self, line: Line, _features: Collection[Feature]) -> Iterator[Line]:
2861         """
2862         StringTransformer instances have a call signature that mirrors that of
2863         the Transformer type.
2864
2865         Raises:
2866             CannotTransform(...) if the concrete StringTransformer class is unable
2867             to transform @line.
2868         """
2869         # Optimization to avoid calling `self.do_match(...)` when the line does
2870         # not contain any string.
2871         if not any(leaf.type == token.STRING for leaf in line.leaves):
2872             raise CannotTransform("There are no strings in this line.")
2873
2874         match_result = self.do_match(line)
2875
2876         if isinstance(match_result, Err):
2877             cant_transform = match_result.err()
2878             raise CannotTransform(
2879                 f"The string transformer {self.__class__.__name__} does not recognize"
2880                 " this line as one that it can transform."
2881             ) from cant_transform
2882
2883         string_idx = match_result.ok()
2884
2885         for line_result in self.do_transform(line, string_idx):
2886             if isinstance(line_result, Err):
2887                 cant_transform = line_result.err()
2888                 raise CannotTransform(
2889                     "StringTransformer failed while attempting to transform string."
2890                 ) from cant_transform
2891             line = line_result.ok()
2892             yield line
2893
2894
2895 @dataclass
2896 class CustomSplit:
2897     """A custom (i.e. manual) string split.
2898
2899     A single CustomSplit instance represents a single substring.
2900
2901     Examples:
2902         Consider the following string:
2903         ```
2904         "Hi there friend."
2905         " This is a custom"
2906         f" string {split}."
2907         ```
2908
2909         This string will correspond to the following three CustomSplit instances:
2910         ```
2911         CustomSplit(False, 16)
2912         CustomSplit(False, 17)
2913         CustomSplit(True, 16)
2914         ```
2915     """
2916
2917     has_prefix: bool
2918     break_idx: int
2919
2920
2921 class CustomSplitMapMixin:
2922     """
2923     This mixin class is used to map merged strings to a sequence of
2924     CustomSplits, which will then be used to re-split the strings iff none of
2925     the resultant substrings go over the configured max line length.
2926     """
2927
2928     _Key = Tuple[StringID, str]
2929     _CUSTOM_SPLIT_MAP: Dict[_Key, Tuple[CustomSplit, ...]] = defaultdict(tuple)
2930
2931     @staticmethod
2932     def _get_key(string: str) -> "CustomSplitMapMixin._Key":
2933         """
2934         Returns:
2935             A unique identifier that is used internally to map @string to a
2936             group of custom splits.
2937         """
2938         return (id(string), string)
2939
2940     def add_custom_splits(
2941         self, string: str, custom_splits: Iterable[CustomSplit]
2942     ) -> None:
2943         """Custom Split Map Setter Method
2944
2945         Side Effects:
2946             Adds a mapping from @string to the custom splits @custom_splits.
2947         """
2948         key = self._get_key(string)
2949         self._CUSTOM_SPLIT_MAP[key] = tuple(custom_splits)
2950
2951     def pop_custom_splits(self, string: str) -> List[CustomSplit]:
2952         """Custom Split Map Getter Method
2953
2954         Returns:
2955             * A list of the custom splits that are mapped to @string, if any
2956             exist.
2957                 OR
2958             * [], otherwise.
2959
2960         Side Effects:
2961             Deletes the mapping between @string and its associated custom
2962             splits (which are returned to the caller).
2963         """
2964         key = self._get_key(string)
2965
2966         custom_splits = self._CUSTOM_SPLIT_MAP[key]
2967         del self._CUSTOM_SPLIT_MAP[key]
2968
2969         return list(custom_splits)
2970
2971     def has_custom_splits(self, string: str) -> bool:
2972         """
2973         Returns:
2974             True iff @string is associated with a set of custom splits.
2975         """
2976         key = self._get_key(string)
2977         return key in self._CUSTOM_SPLIT_MAP
2978
2979
2980 class StringMerger(CustomSplitMapMixin, StringTransformer):
2981     """StringTransformer that merges strings together.
2982
2983     Requirements:
2984         (A) The line contains adjacent strings such that ALL of the validation checks
2985         listed in StringMerger.__validate_msg(...)'s docstring pass.
2986             OR
2987         (B) The line contains a string which uses line continuation backslashes.
2988
2989     Transformations:
2990         Depending on which of the two requirements above where met, either:
2991
2992         (A) The string group associated with the target string is merged.
2993             OR
2994         (B) All line-continuation backslashes are removed from the target string.
2995
2996     Collaborations:
2997         StringMerger provides custom split information to StringSplitter.
2998     """
2999
3000     def do_match(self, line: Line) -> TMatchResult:
3001         LL = line.leaves
3002
3003         is_valid_index = is_valid_index_factory(LL)
3004
3005         for (i, leaf) in enumerate(LL):
3006             if (
3007                 leaf.type == token.STRING
3008                 and is_valid_index(i + 1)
3009                 and LL[i + 1].type == token.STRING
3010             ):
3011                 return Ok(i)
3012
3013             if leaf.type == token.STRING and "\\\n" in leaf.value:
3014                 return Ok(i)
3015
3016         return TErr("This line has no strings that need merging.")
3017
3018     def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
3019         new_line = line
3020         rblc_result = self.__remove_backslash_line_continuation_chars(
3021             new_line, string_idx
3022         )
3023         if isinstance(rblc_result, Ok):
3024             new_line = rblc_result.ok()
3025
3026         msg_result = self.__merge_string_group(new_line, string_idx)
3027         if isinstance(msg_result, Ok):
3028             new_line = msg_result.ok()
3029
3030         if isinstance(rblc_result, Err) and isinstance(msg_result, Err):
3031             msg_cant_transform = msg_result.err()
3032             rblc_cant_transform = rblc_result.err()
3033             cant_transform = CannotTransform(
3034                 "StringMerger failed to merge any strings in this line."
3035             )
3036
3037             # Chain the errors together using `__cause__`.
3038             msg_cant_transform.__cause__ = rblc_cant_transform
3039             cant_transform.__cause__ = msg_cant_transform
3040
3041             yield Err(cant_transform)
3042         else:
3043             yield Ok(new_line)
3044
3045     @staticmethod
3046     def __remove_backslash_line_continuation_chars(
3047         line: Line, string_idx: int
3048     ) -> TResult[Line]:
3049         """
3050         Merge strings that were split across multiple lines using
3051         line-continuation backslashes.
3052
3053         Returns:
3054             Ok(new_line), if @line contains backslash line-continuation
3055             characters.
3056                 OR
3057             Err(CannotTransform), otherwise.
3058         """
3059         LL = line.leaves
3060
3061         string_leaf = LL[string_idx]
3062         if not (
3063             string_leaf.type == token.STRING
3064             and "\\\n" in string_leaf.value
3065             and not has_triple_quotes(string_leaf.value)
3066         ):
3067             return TErr(
3068                 f"String leaf {string_leaf} does not contain any backslash line"
3069                 " continuation characters."
3070             )
3071
3072         new_line = line.clone()
3073         new_line.comments = line.comments.copy()
3074         append_leaves(new_line, line, LL)
3075
3076         new_string_leaf = new_line.leaves[string_idx]
3077         new_string_leaf.value = new_string_leaf.value.replace("\\\n", "")
3078
3079         return Ok(new_line)
3080
3081     def __merge_string_group(self, line: Line, string_idx: int) -> TResult[Line]:
3082         """
3083         Merges string group (i.e. set of adjacent strings) where the first
3084         string in the group is `line.leaves[string_idx]`.
3085
3086         Returns:
3087             Ok(new_line), if ALL of the validation checks found in
3088             __validate_msg(...) pass.
3089                 OR
3090             Err(CannotTransform), otherwise.
3091         """
3092         LL = line.leaves
3093
3094         is_valid_index = is_valid_index_factory(LL)
3095
3096         vresult = self.__validate_msg(line, string_idx)
3097         if isinstance(vresult, Err):
3098             return vresult
3099
3100         # If the string group is wrapped inside an Atom node, we must make sure
3101         # to later replace that Atom with our new (merged) string leaf.
3102         atom_node = LL[string_idx].parent
3103
3104         # We will place BREAK_MARK in between every two substrings that we
3105         # merge. We will then later go through our final result and use the
3106         # various instances of BREAK_MARK we find to add the right values to
3107         # the custom split map.
3108         BREAK_MARK = "@@@@@ BLACK BREAKPOINT MARKER @@@@@"
3109
3110         QUOTE = LL[string_idx].value[-1]
3111
3112         def make_naked(string: str, string_prefix: str) -> str:
3113             """Strip @string (i.e. make it a "naked" string)
3114
3115             Pre-conditions:
3116                 * assert_is_leaf_string(@string)
3117
3118             Returns:
3119                 A string that is identical to @string except that
3120                 @string_prefix has been stripped, the surrounding QUOTE
3121                 characters have been removed, and any remaining QUOTE
3122                 characters have been escaped.
3123             """
3124             assert_is_leaf_string(string)
3125
3126             RE_EVEN_BACKSLASHES = r"(?:(?<!\\)(?:\\\\)*)"
3127             naked_string = string[len(string_prefix) + 1 : -1]
3128             naked_string = re.sub(
3129                 "(" + RE_EVEN_BACKSLASHES + ")" + QUOTE, r"\1\\" + QUOTE, naked_string
3130             )
3131             return naked_string
3132
3133         # Holds the CustomSplit objects that will later be added to the custom
3134         # split map.
3135         custom_splits = []
3136
3137         # Temporary storage for the 'has_prefix' part of the CustomSplit objects.
3138         prefix_tracker = []
3139
3140         # Sets the 'prefix' variable. This is the prefix that the final merged
3141         # string will have.
3142         next_str_idx = string_idx
3143         prefix = ""
3144         while (
3145             not prefix
3146             and is_valid_index(next_str_idx)
3147             and LL[next_str_idx].type == token.STRING
3148         ):
3149             prefix = get_string_prefix(LL[next_str_idx].value)
3150             next_str_idx += 1
3151
3152         # The next loop merges the string group. The final string will be
3153         # contained in 'S'.
3154         #
3155         # The following convenience variables are used:
3156         #
3157         #   S: string
3158         #   NS: naked string
3159         #   SS: next string
3160         #   NSS: naked next string
3161         S = ""
3162         NS = ""
3163         num_of_strings = 0
3164         next_str_idx = string_idx
3165         while is_valid_index(next_str_idx) and LL[next_str_idx].type == token.STRING:
3166             num_of_strings += 1
3167
3168             SS = LL[next_str_idx].value
3169             next_prefix = get_string_prefix(SS)
3170
3171             # If this is an f-string group but this substring is not prefixed
3172             # with 'f'...
3173             if "f" in prefix and "f" not in next_prefix:
3174                 # Then we must escape any braces contained in this substring.
3175                 SS = re.subf(r"(\{|\})", "{1}{1}", SS)
3176
3177             NSS = make_naked(SS, next_prefix)
3178
3179             has_prefix = bool(next_prefix)
3180             prefix_tracker.append(has_prefix)
3181
3182             S = prefix + QUOTE + NS + NSS + BREAK_MARK + QUOTE
3183             NS = make_naked(S, prefix)
3184
3185             next_str_idx += 1
3186
3187         S_leaf = Leaf(token.STRING, S)
3188         if self.normalize_strings:
3189             normalize_string_quotes(S_leaf)
3190
3191         # Fill the 'custom_splits' list with the appropriate CustomSplit objects.
3192         temp_string = S_leaf.value[len(prefix) + 1 : -1]
3193         for has_prefix in prefix_tracker:
3194             mark_idx = temp_string.find(BREAK_MARK)
3195             assert (
3196                 mark_idx >= 0
3197             ), "Logic error while filling the custom string breakpoint cache."
3198
3199             temp_string = temp_string[mark_idx + len(BREAK_MARK) :]
3200             breakpoint_idx = mark_idx + (len(prefix) if has_prefix else 0) + 1
3201             custom_splits.append(CustomSplit(has_prefix, breakpoint_idx))
3202
3203         string_leaf = Leaf(token.STRING, S_leaf.value.replace(BREAK_MARK, ""))
3204
3205         if atom_node is not None:
3206             replace_child(atom_node, string_leaf)
3207
3208         # Build the final line ('new_line') that this method will later return.
3209         new_line = line.clone()
3210         for (i, leaf) in enumerate(LL):
3211             if i == string_idx:
3212                 new_line.append(string_leaf)
3213
3214             if string_idx <= i < string_idx + num_of_strings:
3215                 for comment_leaf in line.comments_after(LL[i]):
3216                     new_line.append(comment_leaf, preformatted=True)
3217                 continue
3218
3219             append_leaves(new_line, line, [leaf])
3220
3221         self.add_custom_splits(string_leaf.value, custom_splits)
3222         return Ok(new_line)
3223
3224     @staticmethod
3225     def __validate_msg(line: Line, string_idx: int) -> TResult[None]:
3226         """Validate (M)erge (S)tring (G)roup
3227
3228         Transform-time string validation logic for __merge_string_group(...).
3229
3230         Returns:
3231             * Ok(None), if ALL validation checks (listed below) pass.
3232                 OR
3233             * Err(CannotTransform), if any of the following are true:
3234                 - The target string group does not contain ANY stand-alone comments.
3235                 - The target string is not in a string group (i.e. it has no
3236                   adjacent strings).
3237                 - The string group has more than one inline comment.
3238                 - The string group has an inline comment that appears to be a pragma.
3239                 - The set of all string prefixes in the string group is of
3240                   length greater than one and is not equal to {"", "f"}.
3241                 - The string group consists of raw strings.
3242         """
3243         # We first check for "inner" stand-alone comments (i.e. stand-alone
3244         # comments that have a string leaf before them AND after them).
3245         for inc in [1, -1]:
3246             i = string_idx
3247             found_sa_comment = False
3248             is_valid_index = is_valid_index_factory(line.leaves)
3249             while is_valid_index(i) and line.leaves[i].type in [
3250                 token.STRING,
3251                 STANDALONE_COMMENT,
3252             ]:
3253                 if line.leaves[i].type == STANDALONE_COMMENT:
3254                     found_sa_comment = True
3255                 elif found_sa_comment:
3256                     return TErr(
3257                         "StringMerger does NOT merge string groups which contain "
3258                         "stand-alone comments."
3259                     )
3260
3261                 i += inc
3262
3263         num_of_inline_string_comments = 0
3264         set_of_prefixes = set()
3265         num_of_strings = 0
3266         for leaf in line.leaves[string_idx:]:
3267             if leaf.type != token.STRING:
3268                 # If the string group is trailed by a comma, we count the
3269                 # comments trailing the comma to be one of the string group's
3270                 # comments.
3271                 if leaf.type == token.COMMA and id(leaf) in line.comments:
3272                     num_of_inline_string_comments += 1
3273                 break
3274
3275             if has_triple_quotes(leaf.value):
3276                 return TErr("StringMerger does NOT merge multiline strings.")
3277
3278             num_of_strings += 1
3279             prefix = get_string_prefix(leaf.value)
3280             if "r" in prefix:
3281                 return TErr("StringMerger does NOT merge raw strings.")
3282
3283             set_of_prefixes.add(prefix)
3284
3285             if id(leaf) in line.comments:
3286                 num_of_inline_string_comments += 1
3287                 if contains_pragma_comment(line.comments[id(leaf)]):
3288                     return TErr("Cannot merge strings which have pragma comments.")
3289
3290         if num_of_strings < 2:
3291             return TErr(
3292                 f"Not enough strings to merge (num_of_strings={num_of_strings})."
3293             )
3294
3295         if num_of_inline_string_comments > 1:
3296             return TErr(
3297                 f"Too many inline string comments ({num_of_inline_string_comments})."
3298             )
3299
3300         if len(set_of_prefixes) > 1 and set_of_prefixes != {"", "f"}:
3301             return TErr(f"Too many different prefixes ({set_of_prefixes}).")
3302
3303         return Ok(None)
3304
3305
3306 class StringParenStripper(StringTransformer):
3307     """StringTransformer that strips surrounding parentheses from strings.
3308
3309     Requirements:
3310         The line contains a string which is surrounded by parentheses and:
3311             - The target string is NOT the only argument to a function call.
3312             - The target string is NOT a "pointless" string.
3313             - If the target string contains a PERCENT, the brackets are not
3314               preceeded or followed by an operator with higher precedence than
3315               PERCENT.
3316
3317     Transformations:
3318         The parentheses mentioned in the 'Requirements' section are stripped.
3319
3320     Collaborations:
3321         StringParenStripper has its own inherent usefulness, but it is also
3322         relied on to clean up the parentheses created by StringParenWrapper (in
3323         the event that they are no longer needed).
3324     """
3325
3326     def do_match(self, line: Line) -> TMatchResult:
3327         LL = line.leaves
3328
3329         is_valid_index = is_valid_index_factory(LL)
3330
3331         for (idx, leaf) in enumerate(LL):
3332             # Should be a string...
3333             if leaf.type != token.STRING:
3334                 continue
3335
3336             # If this is a "pointless" string...
3337             if (
3338                 leaf.parent
3339                 and leaf.parent.parent
3340                 and leaf.parent.parent.type == syms.simple_stmt
3341             ):
3342                 continue
3343
3344             # Should be preceded by a non-empty LPAR...
3345             if (
3346                 not is_valid_index(idx - 1)
3347                 or LL[idx - 1].type != token.LPAR
3348                 or is_empty_lpar(LL[idx - 1])
3349             ):
3350                 continue
3351
3352             # That LPAR should NOT be preceded by a function name or a closing
3353             # bracket (which could be a function which returns a function or a
3354             # list/dictionary that contains a function)...
3355             if is_valid_index(idx - 2) and (
3356                 LL[idx - 2].type == token.NAME or LL[idx - 2].type in CLOSING_BRACKETS
3357             ):
3358                 continue
3359
3360             string_idx = idx
3361
3362             # Skip the string trailer, if one exists.
3363             string_parser = StringParser()
3364             next_idx = string_parser.parse(LL, string_idx)
3365
3366             # if the leaves in the parsed string include a PERCENT, we need to
3367             # make sure the initial LPAR is NOT preceded by an operator with
3368             # higher or equal precedence to PERCENT
3369             if is_valid_index(idx - 2):
3370                 # mypy can't quite follow unless we name this
3371                 before_lpar = LL[idx - 2]
3372                 if token.PERCENT in {leaf.type for leaf in LL[idx - 1 : next_idx]} and (
3373                     (
3374                         before_lpar.type
3375                         in {
3376                             token.STAR,
3377                             token.AT,
3378                             token.SLASH,
3379                             token.DOUBLESLASH,
3380                             token.PERCENT,
3381                             token.TILDE,
3382                             token.DOUBLESTAR,
3383                             token.AWAIT,
3384                             token.LSQB,
3385                             token.LPAR,
3386                         }
3387                     )
3388                     or (
3389                         # only unary PLUS/MINUS
3390                         before_lpar.parent
3391                         and before_lpar.parent.type == syms.factor
3392                         and (before_lpar.type in {token.PLUS, token.MINUS})
3393                     )
3394                 ):
3395                     continue
3396
3397             # Should be followed by a non-empty RPAR...
3398             if (
3399                 is_valid_index(next_idx)
3400                 and LL[next_idx].type == token.RPAR
3401                 and not is_empty_rpar(LL[next_idx])
3402             ):
3403                 # That RPAR should NOT be followed by anything with higher
3404                 # precedence than PERCENT
3405                 if is_valid_index(next_idx + 1) and LL[next_idx + 1].type in {
3406                     token.DOUBLESTAR,
3407                     token.LSQB,
3408                     token.LPAR,
3409                     token.DOT,
3410                 }:
3411                     continue
3412
3413                 return Ok(string_idx)
3414
3415         return TErr("This line has no strings wrapped in parens.")
3416
3417     def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
3418         LL = line.leaves
3419
3420         string_parser = StringParser()
3421         rpar_idx = string_parser.parse(LL, string_idx)
3422
3423         for leaf in (LL[string_idx - 1], LL[rpar_idx]):
3424             if line.comments_after(leaf):
3425                 yield TErr(
3426                     "Will not strip parentheses which have comments attached to them."
3427                 )
3428                 return
3429
3430         new_line = line.clone()
3431         new_line.comments = line.comments.copy()
3432         try:
3433             append_leaves(new_line, line, LL[: string_idx - 1])
3434         except BracketMatchError:
3435             # HACK: I believe there is currently a bug somewhere in
3436             # right_hand_split() that is causing brackets to not be tracked
3437             # properly by a shared BracketTracker.
3438             append_leaves(new_line, line, LL[: string_idx - 1], preformatted=True)
3439
3440         string_leaf = Leaf(token.STRING, LL[string_idx].value)
3441         LL[string_idx - 1].remove()
3442         replace_child(LL[string_idx], string_leaf)
3443         new_line.append(string_leaf)
3444
3445         append_leaves(
3446             new_line, line, LL[string_idx + 1 : rpar_idx] + LL[rpar_idx + 1 :]
3447         )
3448
3449         LL[rpar_idx].remove()
3450
3451         yield Ok(new_line)
3452
3453
3454 class BaseStringSplitter(StringTransformer):
3455     """
3456     Abstract class for StringTransformers which transform a Line's strings by splitting
3457     them or placing them on their own lines where necessary to avoid going over
3458     the configured line length.
3459
3460     Requirements:
3461         * The target string value is responsible for the line going over the
3462         line length limit. It follows that after all of black's other line
3463         split methods have been exhausted, this line (or one of the resulting
3464         lines after all line splits are performed) would still be over the
3465         line_length limit unless we split this string.
3466             AND
3467         * The target string is NOT a "pointless" string (i.e. a string that has
3468         no parent or siblings).
3469             AND
3470         * The target string is not followed by an inline comment that appears
3471         to be a pragma.
3472             AND
3473         * The target string is not a multiline (i.e. triple-quote) string.
3474     """
3475
3476     @abstractmethod
3477     def do_splitter_match(self, line: Line) -> TMatchResult:
3478         """
3479         BaseStringSplitter asks its clients to override this method instead of
3480         `StringTransformer.do_match(...)`.
3481
3482         Follows the same protocol as `StringTransformer.do_match(...)`.
3483
3484         Refer to `help(StringTransformer.do_match)` for more information.
3485         """
3486
3487     def do_match(self, line: Line) -> TMatchResult:
3488         match_result = self.do_splitter_match(line)
3489         if isinstance(match_result, Err):
3490             return match_result
3491
3492         string_idx = match_result.ok()
3493         vresult = self.__validate(line, string_idx)
3494         if isinstance(vresult, Err):
3495             return vresult
3496
3497         return match_result
3498
3499     def __validate(self, line: Line, string_idx: int) -> TResult[None]:
3500         """
3501         Checks that @line meets all of the requirements listed in this classes'
3502         docstring. Refer to `help(BaseStringSplitter)` for a detailed
3503         description of those requirements.
3504
3505         Returns:
3506             * Ok(None), if ALL of the requirements are met.
3507                 OR
3508             * Err(CannotTransform), if ANY of the requirements are NOT met.
3509         """
3510         LL = line.leaves
3511
3512         string_leaf = LL[string_idx]
3513
3514         max_string_length = self.__get_max_string_length(line, string_idx)
3515         if len(string_leaf.value) <= max_string_length:
3516             return TErr(
3517                 "The string itself is not what is causing this line to be too long."
3518             )
3519
3520         if not string_leaf.parent or [L.type for L in string_leaf.parent.children] == [
3521             token.STRING,
3522             token.NEWLINE,
3523         ]:
3524             return TErr(
3525                 f"This string ({string_leaf.value}) appears to be pointless (i.e. has"
3526                 " no parent)."
3527             )
3528
3529         if id(line.leaves[string_idx]) in line.comments and contains_pragma_comment(
3530             line.comments[id(line.leaves[string_idx])]
3531         ):
3532             return TErr(
3533                 "Line appears to end with an inline pragma comment. Splitting the line"
3534                 " could modify the pragma's behavior."
3535             )
3536
3537         if has_triple_quotes(string_leaf.value):
3538             return TErr("We cannot split multiline strings.")
3539
3540         return Ok(None)
3541
3542     def __get_max_string_length(self, line: Line, string_idx: int) -> int:
3543         """
3544         Calculates the max string length used when attempting to determine
3545         whether or not the target string is responsible for causing the line to
3546         go over the line length limit.
3547
3548         WARNING: This method is tightly coupled to both StringSplitter and
3549         (especially) StringParenWrapper. There is probably a better way to
3550         accomplish what is being done here.
3551
3552         Returns:
3553             max_string_length: such that `line.leaves[string_idx].value >
3554             max_string_length` implies that the target string IS responsible
3555             for causing this line to exceed the line length limit.
3556         """
3557         LL = line.leaves
3558
3559         is_valid_index = is_valid_index_factory(LL)
3560
3561         # We use the shorthand "WMA4" in comments to abbreviate "We must
3562         # account for". When giving examples, we use STRING to mean some/any
3563         # valid string.
3564         #
3565         # Finally, we use the following convenience variables:
3566         #
3567         #   P:  The leaf that is before the target string leaf.
3568         #   N:  The leaf that is after the target string leaf.
3569         #   NN: The leaf that is after N.
3570
3571         # WMA4 the whitespace at the beginning of the line.
3572         offset = line.depth * 4
3573
3574         if is_valid_index(string_idx - 1):
3575             p_idx = string_idx - 1
3576             if (
3577                 LL[string_idx - 1].type == token.LPAR
3578                 and LL[string_idx - 1].value == ""
3579                 and string_idx >= 2
3580             ):
3581                 # If the previous leaf is an empty LPAR placeholder, we should skip it.
3582                 p_idx -= 1
3583
3584             P = LL[p_idx]
3585             if P.type == token.PLUS:
3586                 # WMA4 a space and a '+' character (e.g. `+ STRING`).
3587                 offset += 2
3588
3589             if P.type == token.COMMA:
3590                 # WMA4 a space, a comma, and a closing bracket [e.g. `), STRING`].
3591                 offset += 3
3592
3593             if P.type in [token.COLON, token.EQUAL, token.NAME]:
3594                 # This conditional branch is meant to handle dictionary keys,
3595                 # variable assignments, 'return STRING' statement lines, and
3596                 # 'else STRING' ternary expression lines.
3597
3598                 # WMA4 a single space.
3599                 offset += 1
3600
3601                 # WMA4 the lengths of any leaves that came before that space,
3602                 # but after any closing bracket before that space.
3603                 for leaf in reversed(LL[: p_idx + 1]):
3604                     offset += len(str(leaf))
3605                     if leaf.type in CLOSING_BRACKETS:
3606                         break
3607
3608         if is_valid_index(string_idx + 1):
3609             N = LL[string_idx + 1]
3610             if N.type == token.RPAR and N.value == "" and len(LL) > string_idx + 2:
3611                 # If the next leaf is an empty RPAR placeholder, we should skip it.
3612                 N = LL[string_idx + 2]
3613
3614             if N.type == token.COMMA:
3615                 # WMA4 a single comma at the end of the string (e.g `STRING,`).
3616                 offset += 1
3617
3618             if is_valid_index(string_idx + 2):
3619                 NN = LL[string_idx + 2]
3620
3621                 if N.type == token.DOT and NN.type == token.NAME:
3622                     # This conditional branch is meant to handle method calls invoked
3623                     # off of a string literal up to and including the LPAR character.
3624
3625                     # WMA4 the '.' character.
3626                     offset += 1
3627
3628                     if (
3629                         is_valid_index(string_idx + 3)
3630                         and LL[string_idx + 3].type == token.LPAR
3631                     ):
3632                         # WMA4 the left parenthesis character.
3633                         offset += 1
3634
3635                     # WMA4 the length of the method's name.
3636                     offset += len(NN.value)
3637
3638         has_comments = False
3639         for comment_leaf in line.comments_after(LL[string_idx]):
3640             if not has_comments:
3641                 has_comments = True
3642                 # WMA4 two spaces before the '#' character.
3643                 offset += 2
3644
3645             # WMA4 the length of the inline comment.
3646             offset += len(comment_leaf.value)
3647
3648         max_string_length = self.line_length - offset
3649         return max_string_length
3650
3651
3652 class StringSplitter(CustomSplitMapMixin, BaseStringSplitter):
3653     """
3654     StringTransformer that splits "atom" strings (i.e. strings which exist on
3655     lines by themselves).
3656
3657     Requirements:
3658         * The line consists ONLY of a single string (with the exception of a
3659         '+' symbol which MAY exist at the start of the line), MAYBE a string
3660         trailer, and MAYBE a trailing comma.
3661             AND
3662         * All of the requirements listed in BaseStringSplitter's docstring.
3663
3664     Transformations:
3665         The string mentioned in the 'Requirements' section is split into as
3666         many substrings as necessary to adhere to the configured line length.
3667
3668         In the final set of substrings, no substring should be smaller than
3669         MIN_SUBSTR_SIZE characters.
3670
3671         The string will ONLY be split on spaces (i.e. each new substring should
3672         start with a space). Note that the string will NOT be split on a space
3673         which is escaped with a backslash.
3674
3675         If the string is an f-string, it will NOT be split in the middle of an
3676         f-expression (e.g. in f"FooBar: {foo() if x else bar()}", {foo() if x
3677         else bar()} is an f-expression).
3678
3679         If the string that is being split has an associated set of custom split
3680         records and those custom splits will NOT result in any line going over
3681         the configured line length, those custom splits are used. Otherwise the
3682         string is split as late as possible (from left-to-right) while still
3683         adhering to the transformation rules listed above.
3684
3685     Collaborations:
3686         StringSplitter relies on StringMerger to construct the appropriate
3687         CustomSplit objects and add them to the custom split map.
3688     """
3689
3690     MIN_SUBSTR_SIZE = 6
3691     # Matches an "f-expression" (e.g. {var}) that might be found in an f-string.
3692     RE_FEXPR = r"""
3693     (?<!\{) (?:\{\{)* \{ (?!\{)
3694         (?:
3695             [^\{\}]
3696             | \{\{
3697             | \}\}
3698             | (?R)
3699         )+?
3700     (?<!\}) \} (?:\}\})* (?!\})
3701     """
3702
3703     def do_splitter_match(self, line: Line) -> TMatchResult:
3704         LL = line.leaves
3705
3706         is_valid_index = is_valid_index_factory(LL)
3707
3708         idx = 0
3709
3710         # The first leaf MAY be a '+' symbol...
3711         if is_valid_index(idx) and LL[idx].type == token.PLUS:
3712             idx += 1
3713
3714         # The next/first leaf MAY be an empty LPAR...
3715         if is_valid_index(idx) and is_empty_lpar(LL[idx]):
3716             idx += 1
3717
3718         # The next/first leaf MUST be a string...
3719         if not is_valid_index(idx) or LL[idx].type != token.STRING:
3720             return TErr("Line does not start with a string.")
3721
3722         string_idx = idx
3723
3724         # Skip the string trailer, if one exists.
3725         string_parser = StringParser()
3726         idx = string_parser.parse(LL, string_idx)
3727
3728         # That string MAY be followed by an empty RPAR...
3729         if is_valid_index(idx) and is_empty_rpar(LL[idx]):
3730             idx += 1
3731
3732         # That string / empty RPAR leaf MAY be followed by a comma...
3733         if is_valid_index(idx) and LL[idx].type == token.COMMA:
3734             idx += 1
3735
3736         # But no more leaves are allowed...
3737         if is_valid_index(idx):
3738             return TErr("This line does not end with a string.")
3739
3740         return Ok(string_idx)
3741
3742     def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
3743         LL = line.leaves
3744
3745         QUOTE = LL[string_idx].value[-1]
3746
3747         is_valid_index = is_valid_index_factory(LL)
3748         insert_str_child = insert_str_child_factory(LL[string_idx])
3749
3750         prefix = get_string_prefix(LL[string_idx].value)
3751
3752         # We MAY choose to drop the 'f' prefix from substrings that don't
3753         # contain any f-expressions, but ONLY if the original f-string
3754         # contains at least one f-expression. Otherwise, we will alter the AST
3755         # of the program.
3756         drop_pointless_f_prefix = ("f" in prefix) and re.search(
3757             self.RE_FEXPR, LL[string_idx].value, re.VERBOSE
3758         )
3759
3760         first_string_line = True
3761         starts_with_plus = LL[0].type == token.PLUS
3762
3763         def line_needs_plus() -> bool:
3764             return first_string_line and starts_with_plus
3765
3766         def maybe_append_plus(new_line: Line) -> None:
3767             """
3768             Side Effects:
3769                 If @line starts with a plus and this is the first line we are
3770                 constructing, this function appends a PLUS leaf to @new_line
3771                 and replaces the old PLUS leaf in the node structure. Otherwise
3772                 this function does nothing.
3773             """
3774             if line_needs_plus():
3775                 plus_leaf = Leaf(token.PLUS, "+")
3776                 replace_child(LL[0], plus_leaf)
3777                 new_line.append(plus_leaf)
3778
3779         ends_with_comma = (
3780             is_valid_index(string_idx + 1) and LL[string_idx + 1].type == token.COMMA
3781         )
3782
3783         def max_last_string() -> int:
3784             """
3785             Returns:
3786                 The max allowed length of the string value used for the last
3787                 line we will construct.
3788             """
3789             result = self.line_length
3790             result -= line.depth * 4
3791             result -= 1 if ends_with_comma else 0
3792             result -= 2 if line_needs_plus() else 0
3793             return result
3794
3795         # --- Calculate Max Break Index (for string value)
3796         # We start with the line length limit
3797         max_break_idx = self.line_length
3798         # The last index of a string of length N is N-1.
3799         max_break_idx -= 1
3800         # Leading whitespace is not present in the string value (e.g. Leaf.value).
3801         max_break_idx -= line.depth * 4
3802         if max_break_idx < 0:
3803             yield TErr(
3804                 f"Unable to split {LL[string_idx].value} at such high of a line depth:"
3805                 f" {line.depth}"
3806             )
3807             return
3808
3809         # Check if StringMerger registered any custom splits.
3810         custom_splits = self.pop_custom_splits(LL[string_idx].value)
3811         # We use them ONLY if none of them would produce lines that exceed the
3812         # line limit.
3813         use_custom_breakpoints = bool(
3814             custom_splits
3815             and all(csplit.break_idx <= max_break_idx for csplit in custom_splits)
3816         )
3817
3818         # Temporary storage for the remaining chunk of the string line that
3819         # can't fit onto the line currently being constructed.
3820         rest_value = LL[string_idx].value
3821
3822         def more_splits_should_be_made() -> bool:
3823             """
3824             Returns:
3825                 True iff `rest_value` (the remaining string value from the last
3826                 split), should be split again.
3827             """
3828             if use_custom_breakpoints:
3829                 return len(custom_splits) > 1
3830             else:
3831                 return len(rest_value) > max_last_string()
3832
3833         string_line_results: List[Ok[Line]] = []
3834         while more_splits_should_be_made():
3835             if use_custom_breakpoints:
3836                 # Custom User Split (manual)
3837                 csplit = custom_splits.pop(0)
3838                 break_idx = csplit.break_idx
3839             else:
3840                 # Algorithmic Split (automatic)
3841                 max_bidx = max_break_idx - 2 if line_needs_plus() else max_break_idx
3842                 maybe_break_idx = self.__get_break_idx(rest_value, max_bidx)
3843                 if maybe_break_idx is None:
3844                     # If we are unable to algorithmically determine a good split
3845                     # and this string has custom splits registered to it, we
3846                     # fall back to using them--which means we have to start
3847                     # over from the beginning.
3848                     if custom_splits:
3849                         rest_value = LL[string_idx].value
3850                         string_line_results = []
3851                         first_string_line = True
3852                         use_custom_breakpoints = True
3853                         continue
3854
3855                     # Otherwise, we stop splitting here.
3856                     break
3857
3858                 break_idx = maybe_break_idx
3859
3860             # --- Construct `next_value`
3861             next_value = rest_value[:break_idx] + QUOTE
3862             if (
3863                 # Are we allowed to try to drop a pointless 'f' prefix?
3864                 drop_pointless_f_prefix
3865                 # If we are, will we be successful?
3866                 and next_value != self.__normalize_f_string(next_value, prefix)
3867             ):
3868                 # If the current custom split did NOT originally use a prefix,
3869                 # then `csplit.break_idx` will be off by one after removing
3870                 # the 'f' prefix.
3871                 break_idx = (
3872                     break_idx + 1
3873                     if use_custom_breakpoints and not csplit.has_prefix
3874                     else break_idx
3875                 )
3876                 next_value = rest_value[:break_idx] + QUOTE
3877                 next_value = self.__normalize_f_string(next_value, prefix)
3878
3879             # --- Construct `next_leaf`
3880             next_leaf = Leaf(token.STRING, next_value)
3881             insert_str_child(next_leaf)
3882             self.__maybe_normalize_string_quotes(next_leaf)
3883
3884             # --- Construct `next_line`
3885             next_line = line.clone()
3886             maybe_append_plus(next_line)
3887             next_line.append(next_leaf)
3888             string_line_results.append(Ok(next_line))
3889
3890             rest_value = prefix + QUOTE + rest_value[break_idx:]
3891             first_string_line = False
3892
3893         yield from string_line_results
3894
3895         if drop_pointless_f_prefix:
3896             rest_value = self.__normalize_f_string(rest_value, prefix)
3897
3898         rest_leaf = Leaf(token.STRING, rest_value)
3899         insert_str_child(rest_leaf)
3900
3901         # NOTE: I could not find a test case that verifies that the following
3902         # line is actually necessary, but it seems to be. Otherwise we risk
3903         # not normalizing the last substring, right?
3904         self.__maybe_normalize_string_quotes(rest_leaf)
3905
3906         last_line = line.clone()
3907         maybe_append_plus(last_line)
3908
3909         # If there are any leaves to the right of the target string...
3910         if is_valid_index(string_idx + 1):
3911             # We use `temp_value` here to determine how long the last line
3912             # would be if we were to append all the leaves to the right of the
3913             # target string to the last string line.
3914             temp_value = rest_value
3915             for leaf in LL[string_idx + 1 :]:
3916                 temp_value += str(leaf)
3917                 if leaf.type == token.LPAR:
3918                     break
3919
3920             # Try to fit them all on the same line with the last substring...
3921             if (
3922                 len(temp_value) <= max_last_string()
3923                 or LL[string_idx + 1].type == token.COMMA
3924             ):
3925                 last_line.append(rest_leaf)
3926                 append_leaves(last_line, line, LL[string_idx + 1 :])
3927                 yield Ok(last_line)
3928             # Otherwise, place the last substring on one line and everything
3929             # else on a line below that...
3930             else:
3931                 last_line.append(rest_leaf)
3932                 yield Ok(last_line)
3933
3934                 non_string_line = line.clone()
3935                 append_leaves(non_string_line, line, LL[string_idx + 1 :])
3936                 yield Ok(non_string_line)
3937         # Else the target string was the last leaf...
3938         else:
3939             last_line.append(rest_leaf)
3940             last_line.comments = line.comments.copy()
3941             yield Ok(last_line)
3942
3943     def __get_break_idx(self, string: str, max_break_idx: int) -> Optional[int]:
3944         """
3945         This method contains the algorithm that StringSplitter uses to
3946         determine which character to split each string at.
3947
3948         Args:
3949             @string: The substring that we are attempting to split.
3950             @max_break_idx: The ideal break index. We will return this value if it
3951             meets all the necessary conditions. In the likely event that it
3952             doesn't we will try to find the closest index BELOW @max_break_idx
3953             that does. If that fails, we will expand our search by also
3954             considering all valid indices ABOVE @max_break_idx.
3955
3956         Pre-Conditions:
3957             * assert_is_leaf_string(@string)
3958             * 0 <= @max_break_idx < len(@string)
3959
3960         Returns:
3961             break_idx, if an index is able to be found that meets all of the
3962             conditions listed in the 'Transformations' section of this classes'
3963             docstring.
3964                 OR
3965             None, otherwise.
3966         """
3967         is_valid_index = is_valid_index_factory(string)
3968
3969         assert is_valid_index(max_break_idx)
3970         assert_is_leaf_string(string)
3971
3972         _fexpr_slices: Optional[List[Tuple[Index, Index]]] = None
3973
3974         def fexpr_slices() -> Iterator[Tuple[Index, Index]]:
3975             """
3976             Yields:
3977                 All ranges of @string which, if @string were to be split there,
3978                 would result in the splitting of an f-expression (which is NOT
3979                 allowed).
3980             """
3981             nonlocal _fexpr_slices
3982
3983             if _fexpr_slices is None:
3984                 _fexpr_slices = []
3985                 for match in re.finditer(self.RE_FEXPR, string, re.VERBOSE):
3986                     _fexpr_slices.append(match.span())
3987
3988             yield from _fexpr_slices
3989
3990         is_fstring = "f" in get_string_prefix(string)
3991
3992         def breaks_fstring_expression(i: Index) -> bool:
3993             """
3994             Returns:
3995                 True iff returning @i would result in the splitting of an
3996                 f-expression (which is NOT allowed).
3997             """
3998             if not is_fstring:
3999                 return False
4000
4001             for (start, end) in fexpr_slices():
4002                 if start <= i < end:
4003                     return True
4004
4005             return False
4006
4007         def passes_all_checks(i: Index) -> bool:
4008             """
4009             Returns:
4010                 True iff ALL of the conditions listed in the 'Transformations'
4011                 section of this classes' docstring would be be met by returning @i.
4012             """
4013             is_space = string[i] == " "
4014
4015             is_not_escaped = True
4016             j = i - 1
4017             while is_valid_index(j) and string[j] == "\\":
4018                 is_not_escaped = not is_not_escaped
4019                 j -= 1
4020
4021             is_big_enough = (
4022                 len(string[i:]) >= self.MIN_SUBSTR_SIZE
4023                 and len(string[:i]) >= self.MIN_SUBSTR_SIZE
4024             )
4025             return (
4026                 is_space
4027                 and is_not_escaped
4028                 and is_big_enough
4029                 and not breaks_fstring_expression(i)
4030             )
4031
4032         # First, we check all indices BELOW @max_break_idx.
4033         break_idx = max_break_idx
4034         while is_valid_index(break_idx - 1) and not passes_all_checks(break_idx):
4035             break_idx -= 1
4036
4037         if not passes_all_checks(break_idx):
4038             # If that fails, we check all indices ABOVE @max_break_idx.
4039             #
4040             # If we are able to find a valid index here, the next line is going
4041             # to be longer than the specified line length, but it's probably
4042             # better than doing nothing at all.
4043             break_idx = max_break_idx + 1
4044             while is_valid_index(break_idx + 1) and not passes_all_checks(break_idx):
4045                 break_idx += 1
4046
4047             if not is_valid_index(break_idx) or not passes_all_checks(break_idx):
4048                 return None
4049
4050         return break_idx
4051
4052     def __maybe_normalize_string_quotes(self, leaf: Leaf) -> None:
4053         if self.normalize_strings:
4054             normalize_string_quotes(leaf)
4055
4056     def __normalize_f_string(self, string: str, prefix: str) -> str:
4057         """
4058         Pre-Conditions:
4059             * assert_is_leaf_string(@string)
4060
4061         Returns:
4062             * If @string is an f-string that contains no f-expressions, we
4063             return a string identical to @string except that the 'f' prefix
4064             has been stripped and all double braces (i.e. '{{' or '}}') have
4065             been normalized (i.e. turned into '{' or '}').
4066                 OR
4067             * Otherwise, we return @string.
4068         """
4069         assert_is_leaf_string(string)
4070
4071         if "f" in prefix and not re.search(self.RE_FEXPR, string, re.VERBOSE):
4072             new_prefix = prefix.replace("f", "")
4073
4074             temp = string[len(prefix) :]
4075             temp = re.sub(r"\{\{", "{", temp)
4076             temp = re.sub(r"\}\}", "}", temp)
4077             new_string = temp
4078
4079             return f"{new_prefix}{new_string}"
4080         else:
4081             return string
4082
4083
4084 class StringParenWrapper(CustomSplitMapMixin, BaseStringSplitter):
4085     """
4086     StringTransformer that splits non-"atom" strings (i.e. strings that do not
4087     exist on lines by themselves).
4088
4089     Requirements:
4090         All of the requirements listed in BaseStringSplitter's docstring in
4091         addition to the requirements listed below:
4092
4093         * The line is a return/yield statement, which returns/yields a string.
4094             OR
4095         * The line is part of a ternary expression (e.g. `x = y if cond else
4096         z`) such that the line starts with `else <string>`, where <string> is
4097         some string.
4098             OR
4099         * The line is an assert statement, which ends with a string.
4100             OR
4101         * The line is an assignment statement (e.g. `x = <string>` or `x +=
4102         <string>`) such that the variable is being assigned the value of some
4103         string.
4104             OR
4105         * The line is a dictionary key assignment where some valid key is being
4106         assigned the value of some string.
4107
4108     Transformations:
4109         The chosen string is wrapped in parentheses and then split at the LPAR.
4110
4111         We then have one line which ends with an LPAR and another line that
4112         starts with the chosen string. The latter line is then split again at
4113         the RPAR. This results in the RPAR (and possibly a trailing comma)
4114         being placed on its own line.
4115
4116         NOTE: If any leaves exist to the right of the chosen string (except
4117         for a trailing comma, which would be placed after the RPAR), those
4118         leaves are placed inside the parentheses.  In effect, the chosen
4119         string is not necessarily being "wrapped" by parentheses. We can,
4120         however, count on the LPAR being placed directly before the chosen
4121         string.
4122
4123         In other words, StringParenWrapper creates "atom" strings. These
4124         can then be split again by StringSplitter, if necessary.
4125
4126     Collaborations:
4127         In the event that a string line split by StringParenWrapper is
4128         changed such that it no longer needs to be given its own line,
4129         StringParenWrapper relies on StringParenStripper to clean up the
4130         parentheses it created.
4131     """
4132
4133     def do_splitter_match(self, line: Line) -> TMatchResult:
4134         LL = line.leaves
4135
4136         string_idx = (
4137             self._return_match(LL)
4138             or self._else_match(LL)
4139             or self._assert_match(LL)
4140             or self._assign_match(LL)
4141             or self._dict_match(LL)
4142         )
4143
4144         if string_idx is not None:
4145             string_value = line.leaves[string_idx].value
4146             # If the string has no spaces...
4147             if " " not in string_value:
4148                 # And will still violate the line length limit when split...
4149                 max_string_length = self.line_length - ((line.depth + 1) * 4)
4150                 if len(string_value) > max_string_length:
4151                     # And has no associated custom splits...
4152                     if not self.has_custom_splits(string_value):
4153                         # Then we should NOT put this string on its own line.
4154                         return TErr(
4155                             "We do not wrap long strings in parentheses when the"
4156                             " resultant line would still be over the specified line"
4157                             " length and can't be split further by StringSplitter."
4158                         )
4159             return Ok(string_idx)
4160
4161         return TErr("This line does not contain any non-atomic strings.")
4162
4163     @staticmethod
4164     def _return_match(LL: List[Leaf]) -> Optional[int]:
4165         """
4166         Returns:
4167             string_idx such that @LL[string_idx] is equal to our target (i.e.
4168             matched) string, if this line matches the return/yield statement
4169             requirements listed in the 'Requirements' section of this classes'
4170             docstring.
4171                 OR
4172             None, otherwise.
4173         """
4174         # If this line is apart of a return/yield statement and the first leaf
4175         # contains either the "return" or "yield" keywords...
4176         if parent_type(LL[0]) in [syms.return_stmt, syms.yield_expr] and LL[
4177             0
4178         ].value in ["return", "yield"]:
4179             is_valid_index = is_valid_index_factory(LL)
4180
4181             idx = 2 if is_valid_index(1) and is_empty_par(LL[1]) else 1
4182             # The next visible leaf MUST contain a string...
4183             if is_valid_index(idx) and LL[idx].type == token.STRING:
4184                 return idx
4185
4186         return None
4187
4188     @staticmethod
4189     def _else_match(LL: List[Leaf]) -> Optional[int]:
4190         """
4191         Returns:
4192             string_idx such that @LL[string_idx] is equal to our target (i.e.
4193             matched) string, if this line matches the ternary expression
4194             requirements listed in the 'Requirements' section of this classes'
4195             docstring.
4196                 OR
4197             None, otherwise.
4198         """
4199         # If this line is apart of a ternary expression and the first leaf
4200         # contains the "else" keyword...
4201         if (
4202             parent_type(LL[0]) == syms.test
4203             and LL[0].type == token.NAME
4204             and LL[0].value == "else"
4205         ):
4206             is_valid_index = is_valid_index_factory(LL)
4207
4208             idx = 2 if is_valid_index(1) and is_empty_par(LL[1]) else 1
4209             # The next visible leaf MUST contain a string...
4210             if is_valid_index(idx) and LL[idx].type == token.STRING:
4211                 return idx
4212
4213         return None
4214
4215     @staticmethod
4216     def _assert_match(LL: List[Leaf]) -> Optional[int]:
4217         """
4218         Returns:
4219             string_idx such that @LL[string_idx] is equal to our target (i.e.
4220             matched) string, if this line matches the assert statement
4221             requirements listed in the 'Requirements' section of this classes'
4222             docstring.
4223                 OR
4224             None, otherwise.
4225         """
4226         # If this line is apart of an assert statement and the first leaf
4227         # contains the "assert" keyword...
4228         if parent_type(LL[0]) == syms.assert_stmt and LL[0].value == "assert":
4229             is_valid_index = is_valid_index_factory(LL)
4230
4231             for (i, leaf) in enumerate(LL):
4232                 # We MUST find a comma...
4233                 if leaf.type == token.COMMA:
4234                     idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
4235
4236                     # That comma MUST be followed by a string...
4237                     if is_valid_index(idx) and LL[idx].type == token.STRING:
4238                         string_idx = idx
4239
4240                         # Skip the string trailer, if one exists.
4241                         string_parser = StringParser()
4242                         idx = string_parser.parse(LL, string_idx)
4243
4244                         # But no more leaves are allowed...
4245                         if not is_valid_index(idx):
4246                             return string_idx
4247
4248         return None
4249
4250     @staticmethod
4251     def _assign_match(LL: List[Leaf]) -> Optional[int]:
4252         """
4253         Returns:
4254             string_idx such that @LL[string_idx] is equal to our target (i.e.
4255             matched) string, if this line matches the assignment statement
4256             requirements listed in the 'Requirements' section of this classes'
4257             docstring.
4258                 OR
4259             None, otherwise.
4260         """
4261         # If this line is apart of an expression statement or is a function
4262         # argument AND the first leaf contains a variable name...
4263         if (
4264             parent_type(LL[0]) in [syms.expr_stmt, syms.argument, syms.power]
4265             and LL[0].type == token.NAME
4266         ):
4267             is_valid_index = is_valid_index_factory(LL)
4268
4269             for (i, leaf) in enumerate(LL):
4270                 # We MUST find either an '=' or '+=' symbol...
4271                 if leaf.type in [token.EQUAL, token.PLUSEQUAL]:
4272                     idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
4273
4274                     # That symbol MUST be followed by a string...
4275                     if is_valid_index(idx) and LL[idx].type == token.STRING:
4276                         string_idx = idx
4277
4278                         # Skip the string trailer, if one exists.
4279                         string_parser = StringParser()
4280                         idx = string_parser.parse(LL, string_idx)
4281
4282                         # The next leaf MAY be a comma iff this line is apart
4283                         # of a function argument...
4284                         if (
4285                             parent_type(LL[0]) == syms.argument
4286                             and is_valid_index(idx)
4287                             and LL[idx].type == token.COMMA
4288                         ):
4289                             idx += 1
4290
4291                         # But no more leaves are allowed...
4292                         if not is_valid_index(idx):
4293                             return string_idx
4294
4295         return None
4296
4297     @staticmethod
4298     def _dict_match(LL: List[Leaf]) -> Optional[int]:
4299         """
4300         Returns:
4301             string_idx such that @LL[string_idx] is equal to our target (i.e.
4302             matched) string, if this line matches the dictionary key assignment
4303             statement requirements listed in the 'Requirements' section of this
4304             classes' docstring.
4305                 OR
4306             None, otherwise.
4307         """
4308         # If this line is apart of a dictionary key assignment...
4309         if syms.dictsetmaker in [parent_type(LL[0]), parent_type(LL[0].parent)]:
4310             is_valid_index = is_valid_index_factory(LL)
4311
4312             for (i, leaf) in enumerate(LL):
4313                 # We MUST find a colon...
4314                 if leaf.type == token.COLON:
4315                     idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
4316
4317                     # That colon MUST be followed by a string...
4318                     if is_valid_index(idx) and LL[idx].type == token.STRING:
4319                         string_idx = idx
4320
4321                         # Skip the string trailer, if one exists.
4322                         string_parser = StringParser()
4323                         idx = string_parser.parse(LL, string_idx)
4324
4325                         # That string MAY be followed by a comma...
4326                         if is_valid_index(idx) and LL[idx].type == token.COMMA:
4327                             idx += 1
4328
4329                         # But no more leaves are allowed...
4330                         if not is_valid_index(idx):
4331                             return string_idx
4332
4333         return None
4334
4335     def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
4336         LL = line.leaves
4337
4338         is_valid_index = is_valid_index_factory(LL)
4339         insert_str_child = insert_str_child_factory(LL[string_idx])
4340
4341         comma_idx = -1
4342         ends_with_comma = False
4343         if LL[comma_idx].type == token.COMMA:
4344             ends_with_comma = True
4345
4346         leaves_to_steal_comments_from = [LL[string_idx]]
4347         if ends_with_comma:
4348             leaves_to_steal_comments_from.append(LL[comma_idx])
4349
4350         # --- First Line
4351         first_line = line.clone()
4352         left_leaves = LL[:string_idx]
4353
4354         # We have to remember to account for (possibly invisible) LPAR and RPAR
4355         # leaves that already wrapped the target string. If these leaves do
4356         # exist, we will replace them with our own LPAR and RPAR leaves.
4357         old_parens_exist = False
4358         if left_leaves and left_leaves[-1].type == token.LPAR:
4359             old_parens_exist = True
4360             leaves_to_steal_comments_from.append(left_leaves[-1])
4361             left_leaves.pop()
4362
4363         append_leaves(first_line, line, left_leaves)
4364
4365         lpar_leaf = Leaf(token.LPAR, "(")
4366         if old_parens_exist:
4367             replace_child(LL[string_idx - 1], lpar_leaf)
4368         else:
4369             insert_str_child(lpar_leaf)
4370         first_line.append(lpar_leaf)
4371
4372         # We throw inline comments that were originally to the right of the
4373         # target string to the top line. They will now be shown to the right of
4374         # the LPAR.
4375         for leaf in leaves_to_steal_comments_from:
4376             for comment_leaf in line.comments_after(leaf):
4377                 first_line.append(comment_leaf, preformatted=True)
4378
4379         yield Ok(first_line)
4380
4381         # --- Middle (String) Line
4382         # We only need to yield one (possibly too long) string line, since the
4383         # `StringSplitter` will break it down further if necessary.
4384         string_value = LL[string_idx].value
4385         string_line = Line(
4386             mode=line.mode,
4387             depth=line.depth + 1,
4388             inside_brackets=True,
4389             should_explode=line.should_explode,
4390             magic_trailing_comma=line.magic_trailing_comma,
4391         )
4392         string_leaf = Leaf(token.STRING, string_value)
4393         insert_str_child(string_leaf)
4394         string_line.append(string_leaf)
4395
4396         old_rpar_leaf = None
4397         if is_valid_index(string_idx + 1):
4398             right_leaves = LL[string_idx + 1 :]
4399             if ends_with_comma:
4400                 right_leaves.pop()
4401
4402             if old_parens_exist:
4403                 assert (
4404                     right_leaves and right_leaves[-1].type == token.RPAR
4405                 ), "Apparently, old parentheses do NOT exist?!"
4406                 old_rpar_leaf = right_leaves.pop()
4407
4408             append_leaves(string_line, line, right_leaves)
4409
4410         yield Ok(string_line)
4411
4412         # --- Last Line
4413         last_line = line.clone()
4414         last_line.bracket_tracker = first_line.bracket_tracker
4415
4416         new_rpar_leaf = Leaf(token.RPAR, ")")
4417         if old_rpar_leaf is not None:
4418             replace_child(old_rpar_leaf, new_rpar_leaf)
4419         else:
4420             insert_str_child(new_rpar_leaf)
4421         last_line.append(new_rpar_leaf)
4422
4423         # If the target string ended with a comma, we place this comma to the
4424         # right of the RPAR on the last line.
4425         if ends_with_comma:
4426             comma_leaf = Leaf(token.COMMA, ",")
4427             replace_child(LL[comma_idx], comma_leaf)
4428             last_line.append(comma_leaf)
4429
4430         yield Ok(last_line)
4431
4432
4433 class StringParser:
4434     """
4435     A state machine that aids in parsing a string's "trailer", which can be
4436     either non-existent, an old-style formatting sequence (e.g. `% varX` or `%
4437     (varX, varY)`), or a method-call / attribute access (e.g. `.format(varX,
4438     varY)`).
4439
4440     NOTE: A new StringParser object MUST be instantiated for each string
4441     trailer we need to parse.
4442
4443     Examples:
4444         We shall assume that `line` equals the `Line` object that corresponds
4445         to the following line of python code:
4446         ```
4447         x = "Some {}.".format("String") + some_other_string
4448         ```
4449
4450         Furthermore, we will assume that `string_idx` is some index such that:
4451         ```
4452         assert line.leaves[string_idx].value == "Some {}."
4453         ```
4454
4455         The following code snippet then holds:
4456         ```
4457         string_parser = StringParser()
4458         idx = string_parser.parse(line.leaves, string_idx)
4459         assert line.leaves[idx].type == token.PLUS
4460         ```
4461     """
4462
4463     DEFAULT_TOKEN = -1
4464
4465     # String Parser States
4466     START = 1
4467     DOT = 2
4468     NAME = 3
4469     PERCENT = 4
4470     SINGLE_FMT_ARG = 5
4471     LPAR = 6
4472     RPAR = 7
4473     DONE = 8
4474
4475     # Lookup Table for Next State
4476     _goto: Dict[Tuple[ParserState, NodeType], ParserState] = {
4477         # A string trailer may start with '.' OR '%'.
4478         (START, token.DOT): DOT,
4479         (START, token.PERCENT): PERCENT,
4480         (START, DEFAULT_TOKEN): DONE,
4481         # A '.' MUST be followed by an attribute or method name.
4482         (DOT, token.NAME): NAME,
4483         # A method name MUST be followed by an '(', whereas an attribute name
4484         # is the last symbol in the string trailer.
4485         (NAME, token.LPAR): LPAR,
4486         (NAME, DEFAULT_TOKEN): DONE,
4487         # A '%' symbol can be followed by an '(' or a single argument (e.g. a
4488         # string or variable name).
4489         (PERCENT, token.LPAR): LPAR,
4490         (PERCENT, DEFAULT_TOKEN): SINGLE_FMT_ARG,
4491         # If a '%' symbol is followed by a single argument, that argument is
4492         # the last leaf in the string trailer.
4493         (SINGLE_FMT_ARG, DEFAULT_TOKEN): DONE,
4494         # If present, a ')' symbol is the last symbol in a string trailer.
4495         # (NOTE: LPARS and nested RPARS are not included in this lookup table,
4496         # since they are treated as a special case by the parsing logic in this
4497         # classes' implementation.)
4498         (RPAR, DEFAULT_TOKEN): DONE,
4499     }
4500
4501     def __init__(self) -> None:
4502         self._state = self.START
4503         self._unmatched_lpars = 0
4504
4505     def parse(self, leaves: List[Leaf], string_idx: int) -> int:
4506         """
4507         Pre-conditions:
4508             * @leaves[@string_idx].type == token.STRING
4509
4510         Returns:
4511             The index directly after the last leaf which is apart of the string
4512             trailer, if a "trailer" exists.
4513                 OR
4514             @string_idx + 1, if no string "trailer" exists.
4515         """
4516         assert leaves[string_idx].type == token.STRING
4517
4518         idx = string_idx + 1
4519         while idx < len(leaves) and self._next_state(leaves[idx]):
4520             idx += 1
4521         return idx
4522
4523     def _next_state(self, leaf: Leaf) -> bool:
4524         """
4525         Pre-conditions:
4526             * On the first call to this function, @leaf MUST be the leaf that
4527             was directly after the string leaf in question (e.g. if our target
4528             string is `line.leaves[i]` then the first call to this method must
4529             be `line.leaves[i + 1]`).
4530             * On the next call to this function, the leaf parameter passed in
4531             MUST be the leaf directly following @leaf.
4532
4533         Returns:
4534             True iff @leaf is apart of the string's trailer.
4535         """
4536         # We ignore empty LPAR or RPAR leaves.
4537         if is_empty_par(leaf):
4538             return True
4539
4540         next_token = leaf.type
4541         if next_token == token.LPAR:
4542             self._unmatched_lpars += 1
4543
4544         current_state = self._state
4545
4546         # The LPAR parser state is a special case. We will return True until we
4547         # find the matching RPAR token.
4548         if current_state == self.LPAR:
4549             if next_token == token.RPAR:
4550                 self._unmatched_lpars -= 1
4551                 if self._unmatched_lpars == 0:
4552                     self._state = self.RPAR
4553         # Otherwise, we use a lookup table to determine the next state.
4554         else:
4555             # If the lookup table matches the current state to the next
4556             # token, we use the lookup table.
4557             if (current_state, next_token) in self._goto:
4558                 self._state = self._goto[current_state, next_token]
4559             else:
4560                 # Otherwise, we check if a the current state was assigned a
4561                 # default.
4562                 if (current_state, self.DEFAULT_TOKEN) in self._goto:
4563                     self._state = self._goto[current_state, self.DEFAULT_TOKEN]
4564                 # If no default has been assigned, then this parser has a logic
4565                 # error.
4566                 else:
4567                     raise RuntimeError(f"{self.__class__.__name__} LOGIC ERROR!")
4568
4569             if self._state == self.DONE:
4570                 return False
4571
4572         return True
4573
4574
4575 def TErr(err_msg: str) -> Err[CannotTransform]:
4576     """(T)ransform Err
4577
4578     Convenience function used when working with the TResult type.
4579     """
4580     cant_transform = CannotTransform(err_msg)
4581     return Err(cant_transform)
4582
4583
4584 def contains_pragma_comment(comment_list: List[Leaf]) -> bool:
4585     """
4586     Returns:
4587         True iff one of the comments in @comment_list is a pragma used by one
4588         of the more common static analysis tools for python (e.g. mypy, flake8,
4589         pylint).
4590     """
4591     for comment in comment_list:
4592         if comment.value.startswith(("# type:", "# noqa", "# pylint:")):
4593             return True
4594
4595     return False
4596
4597
4598 def insert_str_child_factory(string_leaf: Leaf) -> Callable[[LN], None]:
4599     """
4600     Factory for a convenience function that is used to orphan @string_leaf
4601     and then insert multiple new leaves into the same part of the node
4602     structure that @string_leaf had originally occupied.
4603
4604     Examples:
4605         Let `string_leaf = Leaf(token.STRING, '"foo"')` and `N =
4606         string_leaf.parent`. Assume the node `N` has the following
4607         original structure:
4608
4609         Node(
4610             expr_stmt, [
4611                 Leaf(NAME, 'x'),
4612                 Leaf(EQUAL, '='),
4613                 Leaf(STRING, '"foo"'),
4614             ]
4615         )
4616
4617         We then run the code snippet shown below.
4618         ```
4619         insert_str_child = insert_str_child_factory(string_leaf)
4620
4621         lpar = Leaf(token.LPAR, '(')
4622         insert_str_child(lpar)
4623
4624         bar = Leaf(token.STRING, '"bar"')
4625         insert_str_child(bar)
4626
4627         rpar = Leaf(token.RPAR, ')')
4628         insert_str_child(rpar)
4629         ```
4630
4631         After which point, it follows that `string_leaf.parent is None` and
4632         the node `N` now has the following structure:
4633
4634         Node(
4635             expr_stmt, [
4636                 Leaf(NAME, 'x'),
4637                 Leaf(EQUAL, '='),
4638                 Leaf(LPAR, '('),
4639                 Leaf(STRING, '"bar"'),
4640                 Leaf(RPAR, ')'),
4641             ]
4642         )
4643     """
4644     string_parent = string_leaf.parent
4645     string_child_idx = string_leaf.remove()
4646
4647     def insert_str_child(child: LN) -> None:
4648         nonlocal string_child_idx
4649
4650         assert string_parent is not None
4651         assert string_child_idx is not None
4652
4653         string_parent.insert_child(string_child_idx, child)
4654         string_child_idx += 1
4655
4656     return insert_str_child
4657
4658
4659 def has_triple_quotes(string: str) -> bool:
4660     """
4661     Returns:
4662         True iff @string starts with three quotation characters.
4663     """
4664     raw_string = string.lstrip(STRING_PREFIX_CHARS)
4665     return raw_string[:3] in {'"""', "'''"}
4666
4667
4668 def parent_type(node: Optional[LN]) -> Optional[NodeType]:
4669     """
4670     Returns:
4671         @node.parent.type, if @node is not None and has a parent.
4672             OR
4673         None, otherwise.
4674     """
4675     if node is None or node.parent is None:
4676         return None
4677
4678     return node.parent.type
4679
4680
4681 def is_empty_par(leaf: Leaf) -> bool:
4682     return is_empty_lpar(leaf) or is_empty_rpar(leaf)
4683
4684
4685 def is_empty_lpar(leaf: Leaf) -> bool:
4686     return leaf.type == token.LPAR and leaf.value == ""
4687
4688
4689 def is_empty_rpar(leaf: Leaf) -> bool:
4690     return leaf.type == token.RPAR and leaf.value == ""
4691
4692
4693 def is_valid_index_factory(seq: Sequence[Any]) -> Callable[[int], bool]:
4694     """
4695     Examples:
4696         ```
4697         my_list = [1, 2, 3]
4698
4699         is_valid_index = is_valid_index_factory(my_list)
4700
4701         assert is_valid_index(0)
4702         assert is_valid_index(2)
4703
4704         assert not is_valid_index(3)
4705         assert not is_valid_index(-1)
4706         ```
4707     """
4708
4709     def is_valid_index(idx: int) -> bool:
4710         """
4711         Returns:
4712             True iff @idx is positive AND seq[@idx] does NOT raise an
4713             IndexError.
4714         """
4715         return 0 <= idx < len(seq)
4716
4717     return is_valid_index
4718
4719
4720 def line_to_string(line: Line) -> str:
4721     """Returns the string representation of @line.
4722
4723     WARNING: This is known to be computationally expensive.
4724     """
4725     return str(line).strip("\n")
4726
4727
4728 def append_leaves(
4729     new_line: Line, old_line: Line, leaves: List[Leaf], preformatted: bool = False
4730 ) -> None:
4731     """
4732     Append leaves (taken from @old_line) to @new_line, making sure to fix the
4733     underlying Node structure where appropriate.
4734
4735     All of the leaves in @leaves are duplicated. The duplicates are then
4736     appended to @new_line and used to replace their originals in the underlying
4737     Node structure. Any comments attached to the old leaves are reattached to
4738     the new leaves.
4739
4740     Pre-conditions:
4741         set(@leaves) is a subset of set(@old_line.leaves).
4742     """
4743     for old_leaf in leaves:
4744         new_leaf = Leaf(old_leaf.type, old_leaf.value)
4745         replace_child(old_leaf, new_leaf)
4746         new_line.append(new_leaf, preformatted=preformatted)
4747
4748         for comment_leaf in old_line.comments_after(old_leaf):
4749             new_line.append(comment_leaf, preformatted=True)
4750
4751
4752 def replace_child(old_child: LN, new_child: LN) -> None:
4753     """
4754     Side Effects:
4755         * If @old_child.parent is set, replace @old_child with @new_child in
4756         @old_child's underlying Node structure.
4757             OR
4758         * Otherwise, this function does nothing.
4759     """
4760     parent = old_child.parent
4761     if not parent:
4762         return
4763
4764     child_idx = old_child.remove()
4765     if child_idx is not None:
4766         parent.insert_child(child_idx, new_child)
4767
4768
4769 def get_string_prefix(string: str) -> str:
4770     """
4771     Pre-conditions:
4772         * assert_is_leaf_string(@string)
4773
4774     Returns:
4775         @string's prefix (e.g. '', 'r', 'f', or 'rf').
4776     """
4777     assert_is_leaf_string(string)
4778
4779     prefix = ""
4780     prefix_idx = 0
4781     while string[prefix_idx] in STRING_PREFIX_CHARS:
4782         prefix += string[prefix_idx].lower()
4783         prefix_idx += 1
4784
4785     return prefix
4786
4787
4788 def assert_is_leaf_string(string: str) -> None:
4789     """
4790     Checks the pre-condition that @string has the format that you would expect
4791     of `leaf.value` where `leaf` is some Leaf such that `leaf.type ==
4792     token.STRING`. A more precise description of the pre-conditions that are
4793     checked are listed below.
4794
4795     Pre-conditions:
4796         * @string starts with either ', ", <prefix>', or <prefix>" where
4797         `set(<prefix>)` is some subset of `set(STRING_PREFIX_CHARS)`.
4798         * @string ends with a quote character (' or ").
4799
4800     Raises:
4801         AssertionError(...) if the pre-conditions listed above are not
4802         satisfied.
4803     """
4804     dquote_idx = string.find('"')
4805     squote_idx = string.find("'")
4806     if -1 in [dquote_idx, squote_idx]:
4807         quote_idx = max(dquote_idx, squote_idx)
4808     else:
4809         quote_idx = min(squote_idx, dquote_idx)
4810
4811     assert (
4812         0 <= quote_idx < len(string) - 1
4813     ), f"{string!r} is missing a starting quote character (' or \")."
4814     assert string[-1] in (
4815         "'",
4816         '"',
4817     ), f"{string!r} is missing an ending quote character (' or \")."
4818     assert set(string[:quote_idx]).issubset(
4819         set(STRING_PREFIX_CHARS)
4820     ), f"{set(string[:quote_idx])} is NOT a subset of {set(STRING_PREFIX_CHARS)}."
4821
4822
4823 def left_hand_split(line: Line, _features: Collection[Feature] = ()) -> Iterator[Line]:
4824     """Split line into many lines, starting with the first matching bracket pair.
4825
4826     Note: this usually looks weird, only use this for function definitions.
4827     Prefer RHS otherwise.  This is why this function is not symmetrical with
4828     :func:`right_hand_split` which also handles optional parentheses.
4829     """
4830     tail_leaves: List[Leaf] = []
4831     body_leaves: List[Leaf] = []
4832     head_leaves: List[Leaf] = []
4833     current_leaves = head_leaves
4834     matching_bracket: Optional[Leaf] = None
4835     for leaf in line.leaves:
4836         if (
4837             current_leaves is body_leaves
4838             and leaf.type in CLOSING_BRACKETS
4839             and leaf.opening_bracket is matching_bracket
4840         ):
4841             current_leaves = tail_leaves if body_leaves else head_leaves
4842         current_leaves.append(leaf)
4843         if current_leaves is head_leaves:
4844             if leaf.type in OPENING_BRACKETS:
4845                 matching_bracket = leaf
4846                 current_leaves = body_leaves
4847     if not matching_bracket:
4848         raise CannotSplit("No brackets found")
4849
4850     head = bracket_split_build_line(head_leaves, line, matching_bracket)
4851     body = bracket_split_build_line(body_leaves, line, matching_bracket, is_body=True)
4852     tail = bracket_split_build_line(tail_leaves, line, matching_bracket)
4853     bracket_split_succeeded_or_raise(head, body, tail)
4854     for result in (head, body, tail):
4855         if result:
4856             yield result
4857
4858
4859 def right_hand_split(
4860     line: Line,
4861     line_length: int,
4862     features: Collection[Feature] = (),
4863     omit: Collection[LeafID] = (),
4864 ) -> Iterator[Line]:
4865     """Split line into many lines, starting with the last matching bracket pair.
4866
4867     If the split was by optional parentheses, attempt splitting without them, too.
4868     `omit` is a collection of closing bracket IDs that shouldn't be considered for
4869     this split.
4870
4871     Note: running this function modifies `bracket_depth` on the leaves of `line`.
4872     """
4873     tail_leaves: List[Leaf] = []
4874     body_leaves: List[Leaf] = []
4875     head_leaves: List[Leaf] = []
4876     current_leaves = tail_leaves
4877     opening_bracket: Optional[Leaf] = None
4878     closing_bracket: Optional[Leaf] = None
4879     for leaf in reversed(line.leaves):
4880         if current_leaves is body_leaves:
4881             if leaf is opening_bracket:
4882                 current_leaves = head_leaves if body_leaves else tail_leaves
4883         current_leaves.append(leaf)
4884         if current_leaves is tail_leaves:
4885             if leaf.type in CLOSING_BRACKETS and id(leaf) not in omit:
4886                 opening_bracket = leaf.opening_bracket
4887                 closing_bracket = leaf
4888                 current_leaves = body_leaves
4889     if not (opening_bracket and closing_bracket and head_leaves):
4890         # If there is no opening or closing_bracket that means the split failed and
4891         # all content is in the tail.  Otherwise, if `head_leaves` are empty, it means
4892         # the matching `opening_bracket` wasn't available on `line` anymore.
4893         raise CannotSplit("No brackets found")
4894
4895     tail_leaves.reverse()
4896     body_leaves.reverse()
4897     head_leaves.reverse()
4898     head = bracket_split_build_line(head_leaves, line, opening_bracket)
4899     body = bracket_split_build_line(body_leaves, line, opening_bracket, is_body=True)
4900     tail = bracket_split_build_line(tail_leaves, line, opening_bracket)
4901     bracket_split_succeeded_or_raise(head, body, tail)
4902     if (
4903         Feature.FORCE_OPTIONAL_PARENTHESES not in features
4904         # the opening bracket is an optional paren
4905         and opening_bracket.type == token.LPAR
4906         and not opening_bracket.value
4907         # the closing bracket is an optional paren
4908         and closing_bracket.type == token.RPAR
4909         and not closing_bracket.value
4910         # it's not an import (optional parens are the only thing we can split on
4911         # in this case; attempting a split without them is a waste of time)
4912         and not line.is_import
4913         # there are no standalone comments in the body
4914         and not body.contains_standalone_comments(0)
4915         # and we can actually remove the parens
4916         and can_omit_invisible_parens(body, line_length, omit_on_explode=omit)
4917     ):
4918         omit = {id(closing_bracket), *omit}
4919         try:
4920             yield from right_hand_split(line, line_length, features=features, omit=omit)
4921             return
4922
4923         except CannotSplit:
4924             if not (
4925                 can_be_split(body)
4926                 or is_line_short_enough(body, line_length=line_length)
4927             ):
4928                 raise CannotSplit(
4929                     "Splitting failed, body is still too long and can't be split."
4930                 )
4931
4932             elif head.contains_multiline_strings() or tail.contains_multiline_strings():
4933                 raise CannotSplit(
4934                     "The current optional pair of parentheses is bound to fail to"
4935                     " satisfy the splitting algorithm because the head or the tail"
4936                     " contains multiline strings which by definition never fit one"
4937                     " line."
4938                 )
4939
4940     ensure_visible(opening_bracket)
4941     ensure_visible(closing_bracket)
4942     for result in (head, body, tail):
4943         if result:
4944             yield result
4945
4946
4947 def bracket_split_succeeded_or_raise(head: Line, body: Line, tail: Line) -> None:
4948     """Raise :exc:`CannotSplit` if the last left- or right-hand split failed.
4949
4950     Do nothing otherwise.
4951
4952     A left- or right-hand split is based on a pair of brackets. Content before
4953     (and including) the opening bracket is left on one line, content inside the
4954     brackets is put on a separate line, and finally content starting with and
4955     following the closing bracket is put on a separate line.
4956
4957     Those are called `head`, `body`, and `tail`, respectively. If the split
4958     produced the same line (all content in `head`) or ended up with an empty `body`
4959     and the `tail` is just the closing bracket, then it's considered failed.
4960     """
4961     tail_len = len(str(tail).strip())
4962     if not body:
4963         if tail_len == 0:
4964             raise CannotSplit("Splitting brackets produced the same line")
4965
4966         elif tail_len < 3:
4967             raise CannotSplit(
4968                 f"Splitting brackets on an empty body to save {tail_len} characters is"
4969                 " not worth it"
4970             )
4971
4972
4973 def bracket_split_build_line(
4974     leaves: List[Leaf], original: Line, opening_bracket: Leaf, *, is_body: bool = False
4975 ) -> Line:
4976     """Return a new line with given `leaves` and respective comments from `original`.
4977
4978     If `is_body` is True, the result line is one-indented inside brackets and as such
4979     has its first leaf's prefix normalized and a trailing comma added when expected.
4980     """
4981     result = Line(mode=original.mode, depth=original.depth)
4982     if is_body:
4983         result.inside_brackets = True
4984         result.depth += 1
4985         if leaves:
4986             # Since body is a new indent level, remove spurious leading whitespace.
4987             normalize_prefix(leaves[0], inside_brackets=True)
4988             # Ensure a trailing comma for imports and standalone function arguments, but
4989             # be careful not to add one after any comments or within type annotations.
4990             no_commas = (
4991                 original.is_def
4992                 and opening_bracket.value == "("
4993                 and not any(leaf.type == token.COMMA for leaf in leaves)
4994             )
4995
4996             if original.is_import or no_commas:
4997                 for i in range(len(leaves) - 1, -1, -1):
4998                     if leaves[i].type == STANDALONE_COMMENT:
4999                         continue
5000
5001                     if leaves[i].type != token.COMMA:
5002                         new_comma = Leaf(token.COMMA, ",")
5003                         leaves.insert(i + 1, new_comma)
5004                     break
5005
5006     # Populate the line
5007     for leaf in leaves:
5008         result.append(leaf, preformatted=True)
5009         for comment_after in original.comments_after(leaf):
5010             result.append(comment_after, preformatted=True)
5011     if is_body and should_split(result, opening_bracket):
5012         result.should_explode = True
5013     return result
5014
5015
5016 def dont_increase_indentation(split_func: Transformer) -> Transformer:
5017     """Normalize prefix of the first leaf in every line returned by `split_func`.
5018
5019     This is a decorator over relevant split functions.
5020     """
5021
5022     @wraps(split_func)
5023     def split_wrapper(line: Line, features: Collection[Feature] = ()) -> Iterator[Line]:
5024         for line in split_func(line, features):
5025             normalize_prefix(line.leaves[0], inside_brackets=True)
5026             yield line
5027
5028     return split_wrapper
5029
5030
5031 @dont_increase_indentation
5032 def delimiter_split(line: Line, features: Collection[Feature] = ()) -> Iterator[Line]:
5033     """Split according to delimiters of the highest priority.
5034
5035     If the appropriate Features are given, the split will add trailing commas
5036     also in function signatures and calls that contain `*` and `**`.
5037     """
5038     try:
5039         last_leaf = line.leaves[-1]
5040     except IndexError:
5041         raise CannotSplit("Line empty")
5042
5043     bt = line.bracket_tracker
5044     try:
5045         delimiter_priority = bt.max_delimiter_priority(exclude={id(last_leaf)})
5046     except ValueError:
5047         raise CannotSplit("No delimiters found")
5048
5049     if delimiter_priority == DOT_PRIORITY:
5050         if bt.delimiter_count_with_priority(delimiter_priority) == 1:
5051             raise CannotSplit("Splitting a single attribute from its owner looks wrong")
5052
5053     current_line = Line(
5054         mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
5055     )
5056     lowest_depth = sys.maxsize
5057     trailing_comma_safe = True
5058
5059     def append_to_line(leaf: Leaf) -> Iterator[Line]:
5060         """Append `leaf` to current line or to new line if appending impossible."""
5061         nonlocal current_line
5062         try:
5063             current_line.append_safe(leaf, preformatted=True)
5064         except ValueError:
5065             yield current_line
5066
5067             current_line = Line(
5068                 mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
5069             )
5070             current_line.append(leaf)
5071
5072     for leaf in line.leaves:
5073         yield from append_to_line(leaf)
5074
5075         for comment_after in line.comments_after(leaf):
5076             yield from append_to_line(comment_after)
5077
5078         lowest_depth = min(lowest_depth, leaf.bracket_depth)
5079         if leaf.bracket_depth == lowest_depth:
5080             if is_vararg(leaf, within={syms.typedargslist}):
5081                 trailing_comma_safe = (
5082                     trailing_comma_safe and Feature.TRAILING_COMMA_IN_DEF in features
5083                 )
5084             elif is_vararg(leaf, within={syms.arglist, syms.argument}):
5085                 trailing_comma_safe = (
5086                     trailing_comma_safe and Feature.TRAILING_COMMA_IN_CALL in features
5087                 )
5088
5089         leaf_priority = bt.delimiters.get(id(leaf))
5090         if leaf_priority == delimiter_priority:
5091             yield current_line
5092
5093             current_line = Line(
5094                 mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
5095             )
5096     if current_line:
5097         if (
5098             trailing_comma_safe
5099             and delimiter_priority == COMMA_PRIORITY
5100             and current_line.leaves[-1].type != token.COMMA
5101             and current_line.leaves[-1].type != STANDALONE_COMMENT
5102         ):
5103             new_comma = Leaf(token.COMMA, ",")
5104             current_line.append(new_comma)
5105         yield current_line
5106
5107
5108 @dont_increase_indentation
5109 def standalone_comment_split(
5110     line: Line, features: Collection[Feature] = ()
5111 ) -> Iterator[Line]:
5112     """Split standalone comments from the rest of the line."""
5113     if not line.contains_standalone_comments(0):
5114         raise CannotSplit("Line does not have any standalone comments")
5115
5116     current_line = Line(
5117         mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets
5118     )
5119
5120     def append_to_line(leaf: Leaf) -> Iterator[Line]:
5121         """Append `leaf` to current line or to new line if appending impossible."""
5122         nonlocal current_line
5123         try:
5124             current_line.append_safe(leaf, preformatted=True)
5125         except ValueError:
5126             yield current_line
5127
5128             current_line = Line(
5129                 line.mode, depth=line.depth, inside_brackets=line.inside_brackets
5130             )
5131             current_line.append(leaf)
5132
5133     for leaf in line.leaves:
5134         yield from append_to_line(leaf)
5135
5136         for comment_after in line.comments_after(leaf):
5137             yield from append_to_line(comment_after)
5138
5139     if current_line:
5140         yield current_line
5141
5142
5143 def is_import(leaf: Leaf) -> bool:
5144     """Return True if the given leaf starts an import statement."""
5145     p = leaf.parent
5146     t = leaf.type
5147     v = leaf.value
5148     return bool(
5149         t == token.NAME
5150         and (
5151             (v == "import" and p and p.type == syms.import_name)
5152             or (v == "from" and p and p.type == syms.import_from)
5153         )
5154     )
5155
5156
5157 def is_type_comment(leaf: Leaf, suffix: str = "") -> bool:
5158     """Return True if the given leaf is a special comment.
5159     Only returns true for type comments for now."""
5160     t = leaf.type
5161     v = leaf.value
5162     return t in {token.COMMENT, STANDALONE_COMMENT} and v.startswith("# type:" + suffix)
5163
5164
5165 def normalize_prefix(leaf: Leaf, *, inside_brackets: bool) -> None:
5166     """Leave existing extra newlines if not `inside_brackets`. Remove everything
5167     else.
5168
5169     Note: don't use backslashes for formatting or you'll lose your voting rights.
5170     """
5171     if not inside_brackets:
5172         spl = leaf.prefix.split("#")
5173         if "\\" not in spl[0]:
5174             nl_count = spl[-1].count("\n")
5175             if len(spl) > 1:
5176                 nl_count -= 1
5177             leaf.prefix = "\n" * nl_count
5178             return
5179
5180     leaf.prefix = ""
5181
5182
5183 def normalize_string_prefix(leaf: Leaf, remove_u_prefix: bool = False) -> None:
5184     """Make all string prefixes lowercase.
5185
5186     If remove_u_prefix is given, also removes any u prefix from the string.
5187
5188     Note: Mutates its argument.
5189     """
5190     match = re.match(r"^([" + STRING_PREFIX_CHARS + r"]*)(.*)$", leaf.value, re.DOTALL)
5191     assert match is not None, f"failed to match string {leaf.value!r}"
5192     orig_prefix = match.group(1)
5193     new_prefix = orig_prefix.replace("F", "f").replace("B", "b").replace("U", "u")
5194     if remove_u_prefix:
5195         new_prefix = new_prefix.replace("u", "")
5196     leaf.value = f"{new_prefix}{match.group(2)}"
5197
5198
5199 def normalize_string_quotes(leaf: Leaf) -> None:
5200     """Prefer double quotes but only if it doesn't cause more escaping.
5201
5202     Adds or removes backslashes as appropriate. Doesn't parse and fix
5203     strings nested in f-strings (yet).
5204
5205     Note: Mutates its argument.
5206     """
5207     value = leaf.value.lstrip(STRING_PREFIX_CHARS)
5208     if value[:3] == '"""':
5209         return
5210
5211     elif value[:3] == "'''":
5212         orig_quote = "'''"
5213         new_quote = '"""'
5214     elif value[0] == '"':
5215         orig_quote = '"'
5216         new_quote = "'"
5217     else:
5218         orig_quote = "'"
5219         new_quote = '"'
5220     first_quote_pos = leaf.value.find(orig_quote)
5221     if first_quote_pos == -1:
5222         return  # There's an internal error
5223
5224     prefix = leaf.value[:first_quote_pos]
5225     unescaped_new_quote = re.compile(rf"(([^\\]|^)(\\\\)*){new_quote}")
5226     escaped_new_quote = re.compile(rf"([^\\]|^)\\((?:\\\\)*){new_quote}")
5227     escaped_orig_quote = re.compile(rf"([^\\]|^)\\((?:\\\\)*){orig_quote}")
5228     body = leaf.value[first_quote_pos + len(orig_quote) : -len(orig_quote)]
5229     if "r" in prefix.casefold():
5230         if unescaped_new_quote.search(body):
5231             # There's at least one unescaped new_quote in this raw string
5232             # so converting is impossible
5233             return
5234
5235         # Do not introduce or remove backslashes in raw strings
5236         new_body = body
5237     else:
5238         # remove unnecessary escapes
5239         new_body = sub_twice(escaped_new_quote, rf"\1\2{new_quote}", body)
5240         if body != new_body:
5241             # Consider the string without unnecessary escapes as the original
5242             body = new_body
5243             leaf.value = f"{prefix}{orig_quote}{body}{orig_quote}"
5244         new_body = sub_twice(escaped_orig_quote, rf"\1\2{orig_quote}", new_body)
5245         new_body = sub_twice(unescaped_new_quote, rf"\1\\{new_quote}", new_body)
5246     if "f" in prefix.casefold():
5247         matches = re.findall(
5248             r"""
5249             (?:[^{]|^)\{  # start of the string or a non-{ followed by a single {
5250                 ([^{].*?)  # contents of the brackets except if begins with {{
5251             \}(?:[^}]|$)  # A } followed by end of the string or a non-}
5252             """,
5253             new_body,
5254             re.VERBOSE,
5255         )
5256         for m in matches:
5257             if "\\" in str(m):
5258                 # Do not introduce backslashes in interpolated expressions
5259                 return
5260
5261     if new_quote == '"""' and new_body[-1:] == '"':
5262         # edge case:
5263         new_body = new_body[:-1] + '\\"'
5264     orig_escape_count = body.count("\\")
5265     new_escape_count = new_body.count("\\")
5266     if new_escape_count > orig_escape_count:
5267         return  # Do not introduce more escaping
5268
5269     if new_escape_count == orig_escape_count and orig_quote == '"':
5270         return  # Prefer double quotes
5271
5272     leaf.value = f"{prefix}{new_quote}{new_body}{new_quote}"
5273
5274
5275 def normalize_numeric_literal(leaf: Leaf) -> None:
5276     """Normalizes numeric (float, int, and complex) literals.
5277
5278     All letters used in the representation are normalized to lowercase (except
5279     in Python 2 long literals).
5280     """
5281     text = leaf.value.lower()
5282     if text.startswith(("0o", "0b")):
5283         # Leave octal and binary literals alone.
5284         pass
5285     elif text.startswith("0x"):
5286         text = format_hex(text)
5287     elif "e" in text:
5288         text = format_scientific_notation(text)
5289     elif text.endswith(("j", "l")):
5290         text = format_long_or_complex_number(text)
5291     else:
5292         text = format_float_or_int_string(text)
5293     leaf.value = text
5294
5295
5296 def format_hex(text: str) -> str:
5297     """
5298     Formats a hexadecimal string like "0x12b3"
5299
5300     Uses lowercase because of similarity between "B" and "8", which
5301     can cause security issues.
5302     see: https://github.com/psf/black/issues/1692
5303     """
5304
5305     before, after = text[:2], text[2:]
5306     return f"{before}{after.lower()}"
5307
5308
5309 def format_scientific_notation(text: str) -> str:
5310     """Formats a numeric string utilizing scentific notation"""
5311     before, after = text.split("e")
5312     sign = ""
5313     if after.startswith("-"):
5314         after = after[1:]
5315         sign = "-"
5316     elif after.startswith("+"):
5317         after = after[1:]
5318     before = format_float_or_int_string(before)
5319     return f"{before}e{sign}{after}"
5320
5321
5322 def format_long_or_complex_number(text: str) -> str:
5323     """Formats a long or complex string like `10L` or `10j`"""
5324     number = text[:-1]
5325     suffix = text[-1]
5326     # Capitalize in "2L" because "l" looks too similar to "1".
5327     if suffix == "l":
5328         suffix = "L"
5329     return f"{format_float_or_int_string(number)}{suffix}"
5330
5331
5332 def format_float_or_int_string(text: str) -> str:
5333     """Formats a float string like "1.0"."""
5334     if "." not in text:
5335         return text
5336
5337     before, after = text.split(".")
5338     return f"{before or 0}.{after or 0}"
5339
5340
5341 def normalize_invisible_parens(node: Node, parens_after: Set[str]) -> None:
5342     """Make existing optional parentheses invisible or create new ones.
5343
5344     `parens_after` is a set of string leaf values immediately after which parens
5345     should be put.
5346
5347     Standardizes on visible parentheses for single-element tuples, and keeps
5348     existing visible parentheses for other tuples and generator expressions.
5349     """
5350     for pc in list_comments(node.prefix, is_endmarker=False):
5351         if pc.value in FMT_OFF:
5352             # This `node` has a prefix with `# fmt: off`, don't mess with parens.
5353             return
5354     check_lpar = False
5355     for index, child in enumerate(list(node.children)):
5356         # Fixes a bug where invisible parens are not properly stripped from
5357         # assignment statements that contain type annotations.
5358         if isinstance(child, Node) and child.type == syms.annassign:
5359             normalize_invisible_parens(child, parens_after=parens_after)
5360
5361         # Add parentheses around long tuple unpacking in assignments.
5362         if (
5363             index == 0
5364             and isinstance(child, Node)
5365             and child.type == syms.testlist_star_expr
5366         ):
5367             check_lpar = True
5368
5369         if check_lpar:
5370             if is_walrus_assignment(child):
5371                 pass
5372
5373             elif child.type == syms.atom:
5374                 if maybe_make_parens_invisible_in_atom(child, parent=node):
5375                     wrap_in_parentheses(node, child, visible=False)
5376             elif is_one_tuple(child):
5377                 wrap_in_parentheses(node, child, visible=True)
5378             elif node.type == syms.import_from:
5379                 # "import from" nodes store parentheses directly as part of
5380                 # the statement
5381                 if child.type == token.LPAR:
5382                     # make parentheses invisible
5383                     child.value = ""  # type: ignore
5384                     node.children[-1].value = ""  # type: ignore
5385                 elif child.type != token.STAR:
5386                     # insert invisible parentheses
5387                     node.insert_child(index, Leaf(token.LPAR, ""))
5388                     node.append_child(Leaf(token.RPAR, ""))
5389                 break
5390
5391             elif not (isinstance(child, Leaf) and is_multiline_string(child)):
5392                 wrap_in_parentheses(node, child, visible=False)
5393
5394         check_lpar = isinstance(child, Leaf) and child.value in parens_after
5395
5396
5397 def normalize_fmt_off(node: Node) -> None:
5398     """Convert content between `# fmt: off`/`# fmt: on` into standalone comments."""
5399     try_again = True
5400     while try_again:
5401         try_again = convert_one_fmt_off_pair(node)
5402
5403
5404 def convert_one_fmt_off_pair(node: Node) -> bool:
5405     """Convert content of a single `# fmt: off`/`# fmt: on` into a standalone comment.
5406
5407     Returns True if a pair was converted.
5408     """
5409     for leaf in node.leaves():
5410         previous_consumed = 0
5411         for comment in list_comments(leaf.prefix, is_endmarker=False):
5412             if comment.value not in FMT_PASS:
5413                 previous_consumed = comment.consumed
5414                 continue
5415             # We only want standalone comments. If there's no previous leaf or
5416             # the previous leaf is indentation, it's a standalone comment in
5417             # disguise.
5418             if comment.value in FMT_PASS and comment.type != STANDALONE_COMMENT:
5419                 prev = preceding_leaf(leaf)
5420                 if prev:
5421                     if comment.value in FMT_OFF and prev.type not in WHITESPACE:
5422                         continue
5423                     if comment.value in FMT_SKIP and prev.type in WHITESPACE:
5424                         continue
5425
5426             ignored_nodes = list(generate_ignored_nodes(leaf, comment))
5427             if not ignored_nodes:
5428                 continue
5429
5430             first = ignored_nodes[0]  # Can be a container node with the `leaf`.
5431             parent = first.parent
5432             prefix = first.prefix
5433             first.prefix = prefix[comment.consumed :]
5434             hidden_value = "".join(str(n) for n in ignored_nodes)
5435             if comment.value in FMT_OFF:
5436                 hidden_value = comment.value + "\n" + hidden_value
5437             if comment.value in FMT_SKIP:
5438                 hidden_value += "  " + comment.value
5439             if hidden_value.endswith("\n"):
5440                 # That happens when one of the `ignored_nodes` ended with a NEWLINE
5441                 # leaf (possibly followed by a DEDENT).
5442                 hidden_value = hidden_value[:-1]
5443             first_idx: Optional[int] = None
5444             for ignored in ignored_nodes:
5445                 index = ignored.remove()
5446                 if first_idx is None:
5447                     first_idx = index
5448             assert parent is not None, "INTERNAL ERROR: fmt: on/off handling (1)"
5449             assert first_idx is not None, "INTERNAL ERROR: fmt: on/off handling (2)"
5450             parent.insert_child(
5451                 first_idx,
5452                 Leaf(
5453                     STANDALONE_COMMENT,
5454                     hidden_value,
5455                     prefix=prefix[:previous_consumed] + "\n" * comment.newlines,
5456                 ),
5457             )
5458             return True
5459
5460     return False
5461
5462
5463 def generate_ignored_nodes(leaf: Leaf, comment: ProtoComment) -> Iterator[LN]:
5464     """Starting from the container of `leaf`, generate all leaves until `# fmt: on`.
5465
5466     If comment is skip, returns leaf only.
5467     Stops at the end of the block.
5468     """
5469     container: Optional[LN] = container_of(leaf)
5470     if comment.value in FMT_SKIP:
5471         prev_sibling = leaf.prev_sibling
5472         if comment.value in leaf.prefix and prev_sibling is not None:
5473             leaf.prefix = leaf.prefix.replace(comment.value, "")
5474             siblings = [prev_sibling]
5475             while (
5476                 "\n" not in prev_sibling.prefix
5477                 and prev_sibling.prev_sibling is not None
5478             ):
5479                 prev_sibling = prev_sibling.prev_sibling
5480                 siblings.insert(0, prev_sibling)
5481             for sibling in siblings:
5482                 yield sibling
5483         elif leaf.parent is not None:
5484             yield leaf.parent
5485         return
5486     while container is not None and container.type != token.ENDMARKER:
5487         if is_fmt_on(container):
5488             return
5489
5490         # fix for fmt: on in children
5491         if contains_fmt_on_at_column(container, leaf.column):
5492             for child in container.children:
5493                 if contains_fmt_on_at_column(child, leaf.column):
5494                     return
5495                 yield child
5496         else:
5497             yield container
5498             container = container.next_sibling
5499
5500
5501 def is_fmt_on(container: LN) -> bool:
5502     """Determine whether formatting is switched on within a container.
5503     Determined by whether the last `# fmt:` comment is `on` or `off`.
5504     """
5505     fmt_on = False
5506     for comment in list_comments(container.prefix, is_endmarker=False):
5507         if comment.value in FMT_ON:
5508             fmt_on = True
5509         elif comment.value in FMT_OFF:
5510             fmt_on = False
5511     return fmt_on
5512
5513
5514 def contains_fmt_on_at_column(container: LN, column: int) -> bool:
5515     """Determine if children at a given column have formatting switched on."""
5516     for child in container.children:
5517         if (
5518             isinstance(child, Node)
5519             and first_leaf_column(child) == column
5520             or isinstance(child, Leaf)
5521             and child.column == column
5522         ):
5523             if is_fmt_on(child):
5524                 return True
5525
5526     return False
5527
5528
5529 def first_leaf_column(node: Node) -> Optional[int]:
5530     """Returns the column of the first leaf child of a node."""
5531     for child in node.children:
5532         if isinstance(child, Leaf):
5533             return child.column
5534     return None
5535
5536
5537 def maybe_make_parens_invisible_in_atom(node: LN, parent: LN) -> bool:
5538     """If it's safe, make the parens in the atom `node` invisible, recursively.
5539     Additionally, remove repeated, adjacent invisible parens from the atom `node`
5540     as they are redundant.
5541
5542     Returns whether the node should itself be wrapped in invisible parentheses.
5543
5544     """
5545     if (
5546         node.type != syms.atom
5547         or is_empty_tuple(node)
5548         or is_one_tuple(node)
5549         or (is_yield(node) and parent.type != syms.expr_stmt)
5550         or max_delimiter_priority_in_atom(node) >= COMMA_PRIORITY
5551     ):
5552         return False
5553
5554     first = node.children[0]
5555     last = node.children[-1]
5556     if first.type == token.LPAR and last.type == token.RPAR:
5557         middle = node.children[1]
5558         # make parentheses invisible
5559         first.value = ""  # type: ignore
5560         last.value = ""  # type: ignore
5561         maybe_make_parens_invisible_in_atom(middle, parent=parent)
5562
5563         if is_atom_with_invisible_parens(middle):
5564             # Strip the invisible parens from `middle` by replacing
5565             # it with the child in-between the invisible parens
5566             middle.replace(middle.children[1])
5567
5568         return False
5569
5570     return True
5571
5572
5573 def is_atom_with_invisible_parens(node: LN) -> bool:
5574     """Given a `LN`, determines whether it's an atom `node` with invisible
5575     parens. Useful in dedupe-ing and normalizing parens.
5576     """
5577     if isinstance(node, Leaf) or node.type != syms.atom:
5578         return False
5579
5580     first, last = node.children[0], node.children[-1]
5581     return (
5582         isinstance(first, Leaf)
5583         and first.type == token.LPAR
5584         and first.value == ""
5585         and isinstance(last, Leaf)
5586         and last.type == token.RPAR
5587         and last.value == ""
5588     )
5589
5590
5591 def is_empty_tuple(node: LN) -> bool:
5592     """Return True if `node` holds an empty tuple."""
5593     return (
5594         node.type == syms.atom
5595         and len(node.children) == 2
5596         and node.children[0].type == token.LPAR
5597         and node.children[1].type == token.RPAR
5598     )
5599
5600
5601 def unwrap_singleton_parenthesis(node: LN) -> Optional[LN]:
5602     """Returns `wrapped` if `node` is of the shape ( wrapped ).
5603
5604     Parenthesis can be optional. Returns None otherwise"""
5605     if len(node.children) != 3:
5606         return None
5607
5608     lpar, wrapped, rpar = node.children
5609     if not (lpar.type == token.LPAR and rpar.type == token.RPAR):
5610         return None
5611
5612     return wrapped
5613
5614
5615 def wrap_in_parentheses(parent: Node, child: LN, *, visible: bool = True) -> None:
5616     """Wrap `child` in parentheses.
5617
5618     This replaces `child` with an atom holding the parentheses and the old
5619     child.  That requires moving the prefix.
5620
5621     If `visible` is False, the leaves will be valueless (and thus invisible).
5622     """
5623     lpar = Leaf(token.LPAR, "(" if visible else "")
5624     rpar = Leaf(token.RPAR, ")" if visible else "")
5625     prefix = child.prefix
5626     child.prefix = ""
5627     index = child.remove() or 0
5628     new_child = Node(syms.atom, [lpar, child, rpar])
5629     new_child.prefix = prefix
5630     parent.insert_child(index, new_child)
5631
5632
5633 def is_one_tuple(node: LN) -> bool:
5634     """Return True if `node` holds a tuple with one element, with or without parens."""
5635     if node.type == syms.atom:
5636         gexp = unwrap_singleton_parenthesis(node)
5637         if gexp is None or gexp.type != syms.testlist_gexp:
5638             return False
5639
5640         return len(gexp.children) == 2 and gexp.children[1].type == token.COMMA
5641
5642     return (
5643         node.type in IMPLICIT_TUPLE
5644         and len(node.children) == 2
5645         and node.children[1].type == token.COMMA
5646     )
5647
5648
5649 def is_walrus_assignment(node: LN) -> bool:
5650     """Return True iff `node` is of the shape ( test := test )"""
5651     inner = unwrap_singleton_parenthesis(node)
5652     return inner is not None and inner.type == syms.namedexpr_test
5653
5654
5655 def is_simple_decorator_trailer(node: LN, last: bool = False) -> bool:
5656     """Return True iff `node` is a trailer valid in a simple decorator"""
5657     return node.type == syms.trailer and (
5658         (
5659             len(node.children) == 2
5660             and node.children[0].type == token.DOT
5661             and node.children[1].type == token.NAME
5662         )
5663         # last trailer can be arguments
5664         or (
5665             last
5666             and len(node.children) == 3
5667             and node.children[0].type == token.LPAR
5668             # and node.children[1].type == syms.argument
5669             and node.children[2].type == token.RPAR
5670         )
5671     )
5672
5673
5674 def is_simple_decorator_expression(node: LN) -> bool:
5675     """Return True iff `node` could be a 'dotted name' decorator
5676
5677     This function takes the node of the 'namedexpr_test' of the new decorator
5678     grammar and test if it would be valid under the old decorator grammar.
5679
5680     The old grammar was: decorator: @ dotted_name [arguments] NEWLINE
5681     The new grammar is : decorator: @ namedexpr_test NEWLINE
5682     """
5683     if node.type == token.NAME:
5684         return True
5685     if node.type == syms.power:
5686         if node.children:
5687             return (
5688                 node.children[0].type == token.NAME
5689                 and all(map(is_simple_decorator_trailer, node.children[1:-1]))
5690                 and (
5691                     len(node.children) < 2
5692                     or is_simple_decorator_trailer(node.children[-1], last=True)
5693                 )
5694             )
5695     return False
5696
5697
5698 def is_yield(node: LN) -> bool:
5699     """Return True if `node` holds a `yield` or `yield from` expression."""
5700     if node.type == syms.yield_expr:
5701         return True
5702
5703     if node.type == token.NAME and node.value == "yield":  # type: ignore
5704         return True
5705
5706     if node.type != syms.atom:
5707         return False
5708
5709     if len(node.children) != 3:
5710         return False
5711
5712     lpar, expr, rpar = node.children
5713     if lpar.type == token.LPAR and rpar.type == token.RPAR:
5714         return is_yield(expr)
5715
5716     return False
5717
5718
5719 def is_vararg(leaf: Leaf, within: Set[NodeType]) -> bool:
5720     """Return True if `leaf` is a star or double star in a vararg or kwarg.
5721
5722     If `within` includes VARARGS_PARENTS, this applies to function signatures.
5723     If `within` includes UNPACKING_PARENTS, it applies to right hand-side
5724     extended iterable unpacking (PEP 3132) and additional unpacking
5725     generalizations (PEP 448).
5726     """
5727     if leaf.type not in VARARGS_SPECIALS or not leaf.parent:
5728         return False
5729
5730     p = leaf.parent
5731     if p.type == syms.star_expr:
5732         # Star expressions are also used as assignment targets in extended
5733         # iterable unpacking (PEP 3132).  See what its parent is instead.
5734         if not p.parent:
5735             return False
5736
5737         p = p.parent
5738
5739     return p.type in within
5740
5741
5742 def is_multiline_string(leaf: Leaf) -> bool:
5743     """Return True if `leaf` is a multiline string that actually spans many lines."""
5744     return has_triple_quotes(leaf.value) and "\n" in leaf.value
5745
5746
5747 def is_stub_suite(node: Node) -> bool:
5748     """Return True if `node` is a suite with a stub body."""
5749     if (
5750         len(node.children) != 4
5751         or node.children[0].type != token.NEWLINE
5752         or node.children[1].type != token.INDENT
5753         or node.children[3].type != token.DEDENT
5754     ):
5755         return False
5756
5757     return is_stub_body(node.children[2])
5758
5759
5760 def is_stub_body(node: LN) -> bool:
5761     """Return True if `node` is a simple statement containing an ellipsis."""
5762     if not isinstance(node, Node) or node.type != syms.simple_stmt:
5763         return False
5764
5765     if len(node.children) != 2:
5766         return False
5767
5768     child = node.children[0]
5769     return (
5770         child.type == syms.atom
5771         and len(child.children) == 3
5772         and all(leaf == Leaf(token.DOT, ".") for leaf in child.children)
5773     )
5774
5775
5776 def max_delimiter_priority_in_atom(node: LN) -> Priority:
5777     """Return maximum delimiter priority inside `node`.
5778
5779     This is specific to atoms with contents contained in a pair of parentheses.
5780     If `node` isn't an atom or there are no enclosing parentheses, returns 0.
5781     """
5782     if node.type != syms.atom:
5783         return 0
5784
5785     first = node.children[0]
5786     last = node.children[-1]
5787     if not (first.type == token.LPAR and last.type == token.RPAR):
5788         return 0
5789
5790     bt = BracketTracker()
5791     for c in node.children[1:-1]:
5792         if isinstance(c, Leaf):
5793             bt.mark(c)
5794         else:
5795             for leaf in c.leaves():
5796                 bt.mark(leaf)
5797     try:
5798         return bt.max_delimiter_priority()
5799
5800     except ValueError:
5801         return 0
5802
5803
5804 def ensure_visible(leaf: Leaf) -> None:
5805     """Make sure parentheses are visible.
5806
5807     They could be invisible as part of some statements (see
5808     :func:`normalize_invisible_parens` and :func:`visit_import_from`).
5809     """
5810     if leaf.type == token.LPAR:
5811         leaf.value = "("
5812     elif leaf.type == token.RPAR:
5813         leaf.value = ")"
5814
5815
5816 def should_split(line: Line, opening_bracket: Leaf) -> bool:
5817     """Should `line` be immediately split with `delimiter_split()` after RHS?"""
5818
5819     if not (opening_bracket.parent and opening_bracket.value in "[{("):
5820         return False
5821
5822     # We're essentially checking if the body is delimited by commas and there's more
5823     # than one of them (we're excluding the trailing comma and if the delimiter priority
5824     # is still commas, that means there's more).
5825     exclude = set()
5826     trailing_comma = False
5827     try:
5828         last_leaf = line.leaves[-1]
5829         if last_leaf.type == token.COMMA:
5830             trailing_comma = True
5831             exclude.add(id(last_leaf))
5832         max_priority = line.bracket_tracker.max_delimiter_priority(exclude=exclude)
5833     except (IndexError, ValueError):
5834         return False
5835
5836     return max_priority == COMMA_PRIORITY and (
5837         (line.mode.magic_trailing_comma and trailing_comma)
5838         # always explode imports
5839         or opening_bracket.parent.type in {syms.atom, syms.import_from}
5840     )
5841
5842
5843 def is_one_tuple_between(opening: Leaf, closing: Leaf, leaves: List[Leaf]) -> bool:
5844     """Return True if content between `opening` and `closing` looks like a one-tuple."""
5845     if opening.type != token.LPAR and closing.type != token.RPAR:
5846         return False
5847
5848     depth = closing.bracket_depth + 1
5849     for _opening_index, leaf in enumerate(leaves):
5850         if leaf is opening:
5851             break
5852
5853     else:
5854         raise LookupError("Opening paren not found in `leaves`")
5855
5856     commas = 0
5857     _opening_index += 1
5858     for leaf in leaves[_opening_index:]:
5859         if leaf is closing:
5860             break
5861
5862         bracket_depth = leaf.bracket_depth
5863         if bracket_depth == depth and leaf.type == token.COMMA:
5864             commas += 1
5865             if leaf.parent and leaf.parent.type in {
5866                 syms.arglist,
5867                 syms.typedargslist,
5868             }:
5869                 commas += 1
5870                 break
5871
5872     return commas < 2
5873
5874
5875 def get_features_used(node: Node) -> Set[Feature]:
5876     """Return a set of (relatively) new Python features used in this file.
5877
5878     Currently looking for:
5879     - f-strings;
5880     - underscores in numeric literals;
5881     - trailing commas after * or ** in function signatures and calls;
5882     - positional only arguments in function signatures and lambdas;
5883     - assignment expression;
5884     - relaxed decorator syntax;
5885     """
5886     features: Set[Feature] = set()
5887     for n in node.pre_order():
5888         if n.type == token.STRING:
5889             value_head = n.value[:2]  # type: ignore
5890             if value_head in {'f"', 'F"', "f'", "F'", "rf", "fr", "RF", "FR"}:
5891                 features.add(Feature.F_STRINGS)
5892
5893         elif n.type == token.NUMBER:
5894             if "_" in n.value:  # type: ignore
5895                 features.add(Feature.NUMERIC_UNDERSCORES)
5896
5897         elif n.type == token.SLASH:
5898             if n.parent and n.parent.type in {syms.typedargslist, syms.arglist}:
5899                 features.add(Feature.POS_ONLY_ARGUMENTS)
5900
5901         elif n.type == token.COLONEQUAL:
5902             features.add(Feature.ASSIGNMENT_EXPRESSIONS)
5903
5904         elif n.type == syms.decorator:
5905             if len(n.children) > 1 and not is_simple_decorator_expression(
5906                 n.children[1]
5907             ):
5908                 features.add(Feature.RELAXED_DECORATORS)
5909
5910         elif (
5911             n.type in {syms.typedargslist, syms.arglist}
5912             and n.children
5913             and n.children[-1].type == token.COMMA
5914         ):
5915             if n.type == syms.typedargslist:
5916                 feature = Feature.TRAILING_COMMA_IN_DEF
5917             else:
5918                 feature = Feature.TRAILING_COMMA_IN_CALL
5919
5920             for ch in n.children:
5921                 if ch.type in STARS:
5922                     features.add(feature)
5923
5924                 if ch.type == syms.argument:
5925                     for argch in ch.children:
5926                         if argch.type in STARS:
5927                             features.add(feature)
5928
5929     return features
5930
5931
5932 def detect_target_versions(node: Node) -> Set[TargetVersion]:
5933     """Detect the version to target based on the nodes used."""
5934     features = get_features_used(node)
5935     return {
5936         version for version in TargetVersion if features <= VERSION_TO_FEATURES[version]
5937     }
5938
5939
5940 def generate_trailers_to_omit(line: Line, line_length: int) -> Iterator[Set[LeafID]]:
5941     """Generate sets of closing bracket IDs that should be omitted in a RHS.
5942
5943     Brackets can be omitted if the entire trailer up to and including
5944     a preceding closing bracket fits in one line.
5945
5946     Yielded sets are cumulative (contain results of previous yields, too).  First
5947     set is empty, unless the line should explode, in which case bracket pairs until
5948     the one that needs to explode are omitted.
5949     """
5950
5951     omit: Set[LeafID] = set()
5952     if not line.should_explode and not line.magic_trailing_comma:
5953         yield omit
5954
5955     length = 4 * line.depth
5956     opening_bracket: Optional[Leaf] = None
5957     closing_bracket: Optional[Leaf] = None
5958     inner_brackets: Set[LeafID] = set()
5959     for index, leaf, leaf_length in enumerate_with_length(line, reversed=True):
5960         length += leaf_length
5961         if length > line_length:
5962             break
5963
5964         has_inline_comment = leaf_length > len(leaf.value) + len(leaf.prefix)
5965         if leaf.type == STANDALONE_COMMENT or has_inline_comment:
5966             break
5967
5968         if opening_bracket:
5969             if leaf is opening_bracket:
5970                 opening_bracket = None
5971             elif leaf.type in CLOSING_BRACKETS:
5972                 prev = line.leaves[index - 1] if index > 0 else None
5973                 if (
5974                     line.magic_trailing_comma
5975                     and prev
5976                     and prev.type == token.COMMA
5977                     and not is_one_tuple_between(
5978                         leaf.opening_bracket, leaf, line.leaves
5979                     )
5980                 ):
5981                     # Never omit bracket pairs with trailing commas.
5982                     # We need to explode on those.
5983                     break
5984
5985                 inner_brackets.add(id(leaf))
5986         elif leaf.type in CLOSING_BRACKETS:
5987             prev = line.leaves[index - 1] if index > 0 else None
5988             if prev and prev.type in OPENING_BRACKETS:
5989                 # Empty brackets would fail a split so treat them as "inner"
5990                 # brackets (e.g. only add them to the `omit` set if another
5991                 # pair of brackets was good enough.
5992                 inner_brackets.add(id(leaf))
5993                 continue
5994
5995             if closing_bracket:
5996                 omit.add(id(closing_bracket))
5997                 omit.update(inner_brackets)
5998                 inner_brackets.clear()
5999                 yield omit
6000
6001             if (
6002                 line.magic_trailing_comma
6003                 and prev
6004                 and prev.type == token.COMMA
6005                 and not is_one_tuple_between(leaf.opening_bracket, leaf, line.leaves)
6006             ):
6007                 # Never omit bracket pairs with trailing commas.
6008                 # We need to explode on those.
6009                 break
6010
6011             if leaf.value:
6012                 opening_bracket = leaf.opening_bracket
6013                 closing_bracket = leaf
6014
6015
6016 def get_future_imports(node: Node) -> Set[str]:
6017     """Return a set of __future__ imports in the file."""
6018     imports: Set[str] = set()
6019
6020     def get_imports_from_children(children: List[LN]) -> Generator[str, None, None]:
6021         for child in children:
6022             if isinstance(child, Leaf):
6023                 if child.type == token.NAME:
6024                     yield child.value
6025
6026             elif child.type == syms.import_as_name:
6027                 orig_name = child.children[0]
6028                 assert isinstance(orig_name, Leaf), "Invalid syntax parsing imports"
6029                 assert orig_name.type == token.NAME, "Invalid syntax parsing imports"
6030                 yield orig_name.value
6031
6032             elif child.type == syms.import_as_names:
6033                 yield from get_imports_from_children(child.children)
6034
6035             else:
6036                 raise AssertionError("Invalid syntax parsing imports")
6037
6038     for child in node.children:
6039         if child.type != syms.simple_stmt:
6040             break
6041
6042         first_child = child.children[0]
6043         if isinstance(first_child, Leaf):
6044             # Continue looking if we see a docstring; otherwise stop.
6045             if (
6046                 len(child.children) == 2
6047                 and first_child.type == token.STRING
6048                 and child.children[1].type == token.NEWLINE
6049             ):
6050                 continue
6051
6052             break
6053
6054         elif first_child.type == syms.import_from:
6055             module_name = first_child.children[1]
6056             if not isinstance(module_name, Leaf) or module_name.value != "__future__":
6057                 break
6058
6059             imports |= set(get_imports_from_children(first_child.children[3:]))
6060         else:
6061             break
6062
6063     return imports
6064
6065
6066 @lru_cache()
6067 def get_gitignore(root: Path) -> PathSpec:
6068     """ Return a PathSpec matching gitignore content if present."""
6069     gitignore = root / ".gitignore"
6070     lines: List[str] = []
6071     if gitignore.is_file():
6072         with gitignore.open() as gf:
6073             lines = gf.readlines()
6074     return PathSpec.from_lines("gitwildmatch", lines)
6075
6076
6077 def normalize_path_maybe_ignore(
6078     path: Path, root: Path, report: "Report"
6079 ) -> Optional[str]:
6080     """Normalize `path`. May return `None` if `path` was ignored.
6081
6082     `report` is where "path ignored" output goes.
6083     """
6084     try:
6085         abspath = path if path.is_absolute() else Path.cwd() / path
6086         normalized_path = abspath.resolve().relative_to(root).as_posix()
6087     except OSError as e:
6088         report.path_ignored(path, f"cannot be read because {e}")
6089         return None
6090
6091     except ValueError:
6092         if path.is_symlink():
6093             report.path_ignored(path, f"is a symbolic link that points outside {root}")
6094             return None
6095
6096         raise
6097
6098     return normalized_path
6099
6100
6101 def gen_python_files(
6102     paths: Iterable[Path],
6103     root: Path,
6104     include: Optional[Pattern[str]],
6105     exclude: Pattern[str],
6106     force_exclude: Optional[Pattern[str]],
6107     report: "Report",
6108     gitignore: PathSpec,
6109 ) -> Iterator[Path]:
6110     """Generate all files under `path` whose paths are not excluded by the
6111     `exclude_regex` or `force_exclude` regexes, but are included by the `include` regex.
6112
6113     Symbolic links pointing outside of the `root` directory are ignored.
6114
6115     `report` is where output about exclusions goes.
6116     """
6117     assert root.is_absolute(), f"INTERNAL ERROR: `root` must be absolute but is {root}"
6118     for child in paths:
6119         normalized_path = normalize_path_maybe_ignore(child, root, report)
6120         if normalized_path is None:
6121             continue
6122
6123         # First ignore files matching .gitignore
6124         if gitignore.match_file(normalized_path):
6125             report.path_ignored(child, "matches the .gitignore file content")
6126             continue
6127
6128         # Then ignore with `--exclude` and `--force-exclude` options.
6129         normalized_path = "/" + normalized_path
6130         if child.is_dir():
6131             normalized_path += "/"
6132
6133         exclude_match = exclude.search(normalized_path) if exclude else None
6134         if exclude_match and exclude_match.group(0):
6135             report.path_ignored(child, "matches the --exclude regular expression")
6136             continue
6137
6138         force_exclude_match = (
6139             force_exclude.search(normalized_path) if force_exclude else None
6140         )
6141         if force_exclude_match and force_exclude_match.group(0):
6142             report.path_ignored(child, "matches the --force-exclude regular expression")
6143             continue
6144
6145         if child.is_dir():
6146             yield from gen_python_files(
6147                 child.iterdir(),
6148                 root,
6149                 include,
6150                 exclude,
6151                 force_exclude,
6152                 report,
6153                 gitignore,
6154             )
6155
6156         elif child.is_file():
6157             include_match = include.search(normalized_path) if include else True
6158             if include_match:
6159                 yield child
6160
6161
6162 @lru_cache()
6163 def find_project_root(srcs: Iterable[str]) -> Path:
6164     """Return a directory containing .git, .hg, or pyproject.toml.
6165
6166     That directory will be a common parent of all files and directories
6167     passed in `srcs`.
6168
6169     If no directory in the tree contains a marker that would specify it's the
6170     project root, the root of the file system is returned.
6171     """
6172     if not srcs:
6173         return Path("/").resolve()
6174
6175     path_srcs = [Path(Path.cwd(), src).resolve() for src in srcs]
6176
6177     # A list of lists of parents for each 'src'. 'src' is included as a
6178     # "parent" of itself if it is a directory
6179     src_parents = [
6180         list(path.parents) + ([path] if path.is_dir() else []) for path in path_srcs
6181     ]
6182
6183     common_base = max(
6184         set.intersection(*(set(parents) for parents in src_parents)),
6185         key=lambda path: path.parts,
6186     )
6187
6188     for directory in (common_base, *common_base.parents):
6189         if (directory / ".git").exists():
6190             return directory
6191
6192         if (directory / ".hg").is_dir():
6193             return directory
6194
6195         if (directory / "pyproject.toml").is_file():
6196             return directory
6197
6198     return directory
6199
6200
6201 @dataclass
6202 class Report:
6203     """Provides a reformatting counter. Can be rendered with `str(report)`."""
6204
6205     check: bool = False
6206     diff: bool = False
6207     quiet: bool = False
6208     verbose: bool = False
6209     change_count: int = 0
6210     same_count: int = 0
6211     failure_count: int = 0
6212
6213     def done(self, src: Path, changed: Changed) -> None:
6214         """Increment the counter for successful reformatting. Write out a message."""
6215         if changed is Changed.YES:
6216             reformatted = "would reformat" if self.check or self.diff else "reformatted"
6217             if self.verbose or not self.quiet:
6218                 out(f"{reformatted} {src}")
6219             self.change_count += 1
6220         else:
6221             if self.verbose:
6222                 if changed is Changed.NO:
6223                     msg = f"{src} already well formatted, good job."
6224                 else:
6225                     msg = f"{src} wasn't modified on disk since last run."
6226                 out(msg, bold=False)
6227             self.same_count += 1
6228
6229     def failed(self, src: Path, message: str) -> None:
6230         """Increment the counter for failed reformatting. Write out a message."""
6231         err(f"error: cannot format {src}: {message}")
6232         self.failure_count += 1
6233
6234     def path_ignored(self, path: Path, message: str) -> None:
6235         if self.verbose:
6236             out(f"{path} ignored: {message}", bold=False)
6237
6238     @property
6239     def return_code(self) -> int:
6240         """Return the exit code that the app should use.
6241
6242         This considers the current state of changed files and failures:
6243         - if there were any failures, return 123;
6244         - if any files were changed and --check is being used, return 1;
6245         - otherwise return 0.
6246         """
6247         # According to http://tldp.org/LDP/abs/html/exitcodes.html starting with
6248         # 126 we have special return codes reserved by the shell.
6249         if self.failure_count:
6250             return 123
6251
6252         elif self.change_count and self.check:
6253             return 1
6254
6255         return 0
6256
6257     def __str__(self) -> str:
6258         """Render a color report of the current state.
6259
6260         Use `click.unstyle` to remove colors.
6261         """
6262         if self.check or self.diff:
6263             reformatted = "would be reformatted"
6264             unchanged = "would be left unchanged"
6265             failed = "would fail to reformat"
6266         else:
6267             reformatted = "reformatted"
6268             unchanged = "left unchanged"
6269             failed = "failed to reformat"
6270         report = []
6271         if self.change_count:
6272             s = "s" if self.change_count > 1 else ""
6273             report.append(
6274                 click.style(f"{self.change_count} file{s} {reformatted}", bold=True)
6275             )
6276         if self.same_count:
6277             s = "s" if self.same_count > 1 else ""
6278             report.append(f"{self.same_count} file{s} {unchanged}")
6279         if self.failure_count:
6280             s = "s" if self.failure_count > 1 else ""
6281             report.append(
6282                 click.style(f"{self.failure_count} file{s} {failed}", fg="red")
6283             )
6284         return ", ".join(report) + "."
6285
6286
6287 def parse_ast(src: str) -> Union[ast.AST, ast3.AST, ast27.AST]:
6288     filename = "<unknown>"
6289     if sys.version_info >= (3, 8):
6290         # TODO: support Python 4+ ;)
6291         for minor_version in range(sys.version_info[1], 4, -1):
6292             try:
6293                 return ast.parse(src, filename, feature_version=(3, minor_version))
6294             except SyntaxError:
6295                 continue
6296     else:
6297         for feature_version in (7, 6):
6298             try:
6299                 return ast3.parse(src, filename, feature_version=feature_version)
6300             except SyntaxError:
6301                 continue
6302
6303     return ast27.parse(src)
6304
6305
6306 def _fixup_ast_constants(
6307     node: Union[ast.AST, ast3.AST, ast27.AST]
6308 ) -> Union[ast.AST, ast3.AST, ast27.AST]:
6309     """Map ast nodes deprecated in 3.8 to Constant."""
6310     if isinstance(node, (ast.Str, ast3.Str, ast27.Str, ast.Bytes, ast3.Bytes)):
6311         return ast.Constant(value=node.s)
6312
6313     if isinstance(node, (ast.Num, ast3.Num, ast27.Num)):
6314         return ast.Constant(value=node.n)
6315
6316     if isinstance(node, (ast.NameConstant, ast3.NameConstant)):
6317         return ast.Constant(value=node.value)
6318
6319     return node
6320
6321
6322 def _stringify_ast(
6323     node: Union[ast.AST, ast3.AST, ast27.AST], depth: int = 0
6324 ) -> Iterator[str]:
6325     """Simple visitor generating strings to compare ASTs by content."""
6326
6327     node = _fixup_ast_constants(node)
6328
6329     yield f"{'  ' * depth}{node.__class__.__name__}("
6330
6331     for field in sorted(node._fields):  # noqa: F402
6332         # TypeIgnore has only one field 'lineno' which breaks this comparison
6333         type_ignore_classes = (ast3.TypeIgnore, ast27.TypeIgnore)
6334         if sys.version_info >= (3, 8):
6335             type_ignore_classes += (ast.TypeIgnore,)
6336         if isinstance(node, type_ignore_classes):
6337             break
6338
6339         try:
6340             value = getattr(node, field)
6341         except AttributeError:
6342             continue
6343
6344         yield f"{'  ' * (depth+1)}{field}="
6345
6346         if isinstance(value, list):
6347             for item in value:
6348                 # Ignore nested tuples within del statements, because we may insert
6349                 # parentheses and they change the AST.
6350                 if (
6351                     field == "targets"
6352                     and isinstance(node, (ast.Delete, ast3.Delete, ast27.Delete))
6353                     and isinstance(item, (ast.Tuple, ast3.Tuple, ast27.Tuple))
6354                 ):
6355                     for item in item.elts:
6356                         yield from _stringify_ast(item, depth + 2)
6357
6358                 elif isinstance(item, (ast.AST, ast3.AST, ast27.AST)):
6359                     yield from _stringify_ast(item, depth + 2)
6360
6361         elif isinstance(value, (ast.AST, ast3.AST, ast27.AST)):
6362             yield from _stringify_ast(value, depth + 2)
6363
6364         else:
6365             # Constant strings may be indented across newlines, if they are
6366             # docstrings; fold spaces after newlines when comparing. Similarly,
6367             # trailing and leading space may be removed.
6368             if (
6369                 isinstance(node, ast.Constant)
6370                 and field == "value"
6371                 and isinstance(value, str)
6372             ):
6373                 normalized = re.sub(r" *\n[ \t]*", "\n", value).strip()
6374             else:
6375                 normalized = value
6376             yield f"{'  ' * (depth+2)}{normalized!r},  # {value.__class__.__name__}"
6377
6378     yield f"{'  ' * depth})  # /{node.__class__.__name__}"
6379
6380
6381 def assert_equivalent(src: str, dst: str) -> None:
6382     """Raise AssertionError if `src` and `dst` aren't equivalent."""
6383     try:
6384         src_ast = parse_ast(src)
6385     except Exception as exc:
6386         raise AssertionError(
6387             "cannot use --safe with this file; failed to parse source file.  AST"
6388             f" error message: {exc}"
6389         )
6390
6391     try:
6392         dst_ast = parse_ast(dst)
6393     except Exception as exc:
6394         log = dump_to_file("".join(traceback.format_tb(exc.__traceback__)), dst)
6395         raise AssertionError(
6396             f"INTERNAL ERROR: Black produced invalid code: {exc}. Please report a bug"
6397             " on https://github.com/psf/black/issues.  This invalid output might be"
6398             f" helpful: {log}"
6399         ) from None
6400
6401     src_ast_str = "\n".join(_stringify_ast(src_ast))
6402     dst_ast_str = "\n".join(_stringify_ast(dst_ast))
6403     if src_ast_str != dst_ast_str:
6404         log = dump_to_file(diff(src_ast_str, dst_ast_str, "src", "dst"))
6405         raise AssertionError(
6406             "INTERNAL ERROR: Black produced code that is not equivalent to the"
6407             " source.  Please report a bug on https://github.com/psf/black/issues. "
6408             f" This diff might be helpful: {log}"
6409         ) from None
6410
6411
6412 def assert_stable(src: str, dst: str, mode: Mode) -> None:
6413     """Raise AssertionError if `dst` reformats differently the second time."""
6414     newdst = format_str(dst, mode=mode)
6415     if dst != newdst:
6416         log = dump_to_file(
6417             str(mode),
6418             diff(src, dst, "source", "first pass"),
6419             diff(dst, newdst, "first pass", "second pass"),
6420         )
6421         raise AssertionError(
6422             "INTERNAL ERROR: Black produced different code on the second pass of the"
6423             " formatter.  Please report a bug on https://github.com/psf/black/issues."
6424             f"  This diff might be helpful: {log}"
6425         ) from None
6426
6427
6428 @mypyc_attr(patchable=True)
6429 def dump_to_file(*output: str) -> str:
6430     """Dump `output` to a temporary file. Return path to the file."""
6431     with tempfile.NamedTemporaryFile(
6432         mode="w", prefix="blk_", suffix=".log", delete=False, encoding="utf8"
6433     ) as f:
6434         for lines in output:
6435             f.write(lines)
6436             if lines and lines[-1] != "\n":
6437                 f.write("\n")
6438     return f.name
6439
6440
6441 @contextmanager
6442 def nullcontext() -> Iterator[None]:
6443     """Return an empty context manager.
6444
6445     To be used like `nullcontext` in Python 3.7.
6446     """
6447     yield
6448
6449
6450 def diff(a: str, b: str, a_name: str, b_name: str) -> str:
6451     """Return a unified diff string between strings `a` and `b`."""
6452     import difflib
6453
6454     a_lines = [line + "\n" for line in a.splitlines()]
6455     b_lines = [line + "\n" for line in b.splitlines()]
6456     return "".join(
6457         difflib.unified_diff(a_lines, b_lines, fromfile=a_name, tofile=b_name, n=5)
6458     )
6459
6460
6461 def cancel(tasks: Iterable["asyncio.Task[Any]"]) -> None:
6462     """asyncio signal handler that cancels all `tasks` and reports to stderr."""
6463     err("Aborted!")
6464     for task in tasks:
6465         task.cancel()
6466
6467
6468 def shutdown(loop: asyncio.AbstractEventLoop) -> None:
6469     """Cancel all pending tasks on `loop`, wait for them, and close the loop."""
6470     try:
6471         if sys.version_info[:2] >= (3, 7):
6472             all_tasks = asyncio.all_tasks
6473         else:
6474             all_tasks = asyncio.Task.all_tasks
6475         # This part is borrowed from asyncio/runners.py in Python 3.7b2.
6476         to_cancel = [task for task in all_tasks(loop) if not task.done()]
6477         if not to_cancel:
6478             return
6479
6480         for task in to_cancel:
6481             task.cancel()
6482         loop.run_until_complete(
6483             asyncio.gather(*to_cancel, loop=loop, return_exceptions=True)
6484         )
6485     finally:
6486         # `concurrent.futures.Future` objects cannot be cancelled once they
6487         # are already running. There might be some when the `shutdown()` happened.
6488         # Silence their logger's spew about the event loop being closed.
6489         cf_logger = logging.getLogger("concurrent.futures")
6490         cf_logger.setLevel(logging.CRITICAL)
6491         loop.close()
6492
6493
6494 def sub_twice(regex: Pattern[str], replacement: str, original: str) -> str:
6495     """Replace `regex` with `replacement` twice on `original`.
6496
6497     This is used by string normalization to perform replaces on
6498     overlapping matches.
6499     """
6500     return regex.sub(replacement, regex.sub(replacement, original))
6501
6502
6503 def re_compile_maybe_verbose(regex: str) -> Pattern[str]:
6504     """Compile a regular expression string in `regex`.
6505
6506     If it contains newlines, use verbose mode.
6507     """
6508     if "\n" in regex:
6509         regex = "(?x)" + regex
6510     compiled: Pattern[str] = re.compile(regex)
6511     return compiled
6512
6513
6514 def enumerate_reversed(sequence: Sequence[T]) -> Iterator[Tuple[Index, T]]:
6515     """Like `reversed(enumerate(sequence))` if that were possible."""
6516     index = len(sequence) - 1
6517     for element in reversed(sequence):
6518         yield (index, element)
6519         index -= 1
6520
6521
6522 def enumerate_with_length(
6523     line: Line, reversed: bool = False
6524 ) -> Iterator[Tuple[Index, Leaf, int]]:
6525     """Return an enumeration of leaves with their length.
6526
6527     Stops prematurely on multiline strings and standalone comments.
6528     """
6529     op = cast(
6530         Callable[[Sequence[Leaf]], Iterator[Tuple[Index, Leaf]]],
6531         enumerate_reversed if reversed else enumerate,
6532     )
6533     for index, leaf in op(line.leaves):
6534         length = len(leaf.prefix) + len(leaf.value)
6535         if "\n" in leaf.value:
6536             return  # Multiline strings, we can't continue.
6537
6538         for comment in line.comments_after(leaf):
6539             length += len(comment.value)
6540
6541         yield index, leaf, length
6542
6543
6544 def is_line_short_enough(line: Line, *, line_length: int, line_str: str = "") -> bool:
6545     """Return True if `line` is no longer than `line_length`.
6546
6547     Uses the provided `line_str` rendering, if any, otherwise computes a new one.
6548     """
6549     if not line_str:
6550         line_str = line_to_string(line)
6551     return (
6552         len(line_str) <= line_length
6553         and "\n" not in line_str  # multiline strings
6554         and not line.contains_standalone_comments()
6555     )
6556
6557
6558 def can_be_split(line: Line) -> bool:
6559     """Return False if the line cannot be split *for sure*.
6560
6561     This is not an exhaustive search but a cheap heuristic that we can use to
6562     avoid some unfortunate formattings (mostly around wrapping unsplittable code
6563     in unnecessary parentheses).
6564     """
6565     leaves = line.leaves
6566     if len(leaves) < 2:
6567         return False
6568
6569     if leaves[0].type == token.STRING and leaves[1].type == token.DOT:
6570         call_count = 0
6571         dot_count = 0
6572         next = leaves[-1]
6573         for leaf in leaves[-2::-1]:
6574             if leaf.type in OPENING_BRACKETS:
6575                 if next.type not in CLOSING_BRACKETS:
6576                     return False
6577
6578                 call_count += 1
6579             elif leaf.type == token.DOT:
6580                 dot_count += 1
6581             elif leaf.type == token.NAME:
6582                 if not (next.type == token.DOT or next.type in OPENING_BRACKETS):
6583                     return False
6584
6585             elif leaf.type not in CLOSING_BRACKETS:
6586                 return False
6587
6588             if dot_count > 1 and call_count > 1:
6589                 return False
6590
6591     return True
6592
6593
6594 def can_omit_invisible_parens(
6595     line: Line,
6596     line_length: int,
6597     omit_on_explode: Collection[LeafID] = (),
6598 ) -> bool:
6599     """Does `line` have a shape safe to reformat without optional parens around it?
6600
6601     Returns True for only a subset of potentially nice looking formattings but
6602     the point is to not return false positives that end up producing lines that
6603     are too long.
6604     """
6605     bt = line.bracket_tracker
6606     if not bt.delimiters:
6607         # Without delimiters the optional parentheses are useless.
6608         return True
6609
6610     max_priority = bt.max_delimiter_priority()
6611     if bt.delimiter_count_with_priority(max_priority) > 1:
6612         # With more than one delimiter of a kind the optional parentheses read better.
6613         return False
6614
6615     if max_priority == DOT_PRIORITY:
6616         # A single stranded method call doesn't require optional parentheses.
6617         return True
6618
6619     assert len(line.leaves) >= 2, "Stranded delimiter"
6620
6621     # With a single delimiter, omit if the expression starts or ends with
6622     # a bracket.
6623     first = line.leaves[0]
6624     second = line.leaves[1]
6625     if first.type in OPENING_BRACKETS and second.type not in CLOSING_BRACKETS:
6626         if _can_omit_opening_paren(line, first=first, line_length=line_length):
6627             return True
6628
6629         # Note: we are not returning False here because a line might have *both*
6630         # a leading opening bracket and a trailing closing bracket.  If the
6631         # opening bracket doesn't match our rule, maybe the closing will.
6632
6633     penultimate = line.leaves[-2]
6634     last = line.leaves[-1]
6635     if line.should_explode or line.magic_trailing_comma:
6636         try:
6637             penultimate, last = last_two_except(line.leaves, omit=omit_on_explode)
6638         except LookupError:
6639             # Turns out we'd omit everything.  We cannot skip the optional parentheses.
6640             return False
6641
6642     if (
6643         last.type == token.RPAR
6644         or last.type == token.RBRACE
6645         or (
6646             # don't use indexing for omitting optional parentheses;
6647             # it looks weird
6648             last.type == token.RSQB
6649             and last.parent
6650             and last.parent.type != syms.trailer
6651         )
6652     ):
6653         if penultimate.type in OPENING_BRACKETS:
6654             # Empty brackets don't help.
6655             return False
6656
6657         if is_multiline_string(first):
6658             # Additional wrapping of a multiline string in this situation is
6659             # unnecessary.
6660             return True
6661
6662         if line.magic_trailing_comma and penultimate.type == token.COMMA:
6663             # The rightmost non-omitted bracket pair is the one we want to explode on.
6664             return True
6665
6666         if _can_omit_closing_paren(line, last=last, line_length=line_length):
6667             return True
6668
6669     return False
6670
6671
6672 def _can_omit_opening_paren(line: Line, *, first: Leaf, line_length: int) -> bool:
6673     """See `can_omit_invisible_parens`."""
6674     remainder = False
6675     length = 4 * line.depth
6676     _index = -1
6677     for _index, leaf, leaf_length in enumerate_with_length(line):
6678         if leaf.type in CLOSING_BRACKETS and leaf.opening_bracket is first:
6679             remainder = True
6680         if remainder:
6681             length += leaf_length
6682             if length > line_length:
6683                 break
6684
6685             if leaf.type in OPENING_BRACKETS:
6686                 # There are brackets we can further split on.
6687                 remainder = False
6688
6689     else:
6690         # checked the entire string and line length wasn't exceeded
6691         if len(line.leaves) == _index + 1:
6692             return True
6693
6694     return False
6695
6696
6697 def _can_omit_closing_paren(line: Line, *, last: Leaf, line_length: int) -> bool:
6698     """See `can_omit_invisible_parens`."""
6699     length = 4 * line.depth
6700     seen_other_brackets = False
6701     for _index, leaf, leaf_length in enumerate_with_length(line):
6702         length += leaf_length
6703         if leaf is last.opening_bracket:
6704             if seen_other_brackets or length <= line_length:
6705                 return True
6706
6707         elif leaf.type in OPENING_BRACKETS:
6708             # There are brackets we can further split on.
6709             seen_other_brackets = True
6710
6711     return False
6712
6713
6714 def last_two_except(leaves: List[Leaf], omit: Collection[LeafID]) -> Tuple[Leaf, Leaf]:
6715     """Return (penultimate, last) leaves skipping brackets in `omit` and contents."""
6716     stop_after = None
6717     last = None
6718     for leaf in reversed(leaves):
6719         if stop_after:
6720             if leaf is stop_after:
6721                 stop_after = None
6722             continue
6723
6724         if last:
6725             return leaf, last
6726
6727         if id(leaf) in omit:
6728             stop_after = leaf.opening_bracket
6729         else:
6730             last = leaf
6731     else:
6732         raise LookupError("Last two leaves were also skipped")
6733
6734
6735 def run_transformer(
6736     line: Line,
6737     transform: Transformer,
6738     mode: Mode,
6739     features: Collection[Feature],
6740     *,
6741     line_str: str = "",
6742 ) -> List[Line]:
6743     if not line_str:
6744         line_str = line_to_string(line)
6745     result: List[Line] = []
6746     for transformed_line in transform(line, features):
6747         if str(transformed_line).strip("\n") == line_str:
6748             raise CannotTransform("Line transformer returned an unchanged result")
6749
6750         result.extend(transform_line(transformed_line, mode=mode, features=features))
6751
6752     if not (
6753         transform.__name__ == "rhs"
6754         and line.bracket_tracker.invisible
6755         and not any(bracket.value for bracket in line.bracket_tracker.invisible)
6756         and not line.contains_multiline_strings()
6757         and not result[0].contains_uncollapsable_type_comments()
6758         and not result[0].contains_unsplittable_type_ignore()
6759         and not is_line_short_enough(result[0], line_length=mode.line_length)
6760     ):
6761         return result
6762
6763     line_copy = line.clone()
6764     append_leaves(line_copy, line, line.leaves)
6765     features_fop = set(features) | {Feature.FORCE_OPTIONAL_PARENTHESES}
6766     second_opinion = run_transformer(
6767         line_copy, transform, mode, features_fop, line_str=line_str
6768     )
6769     if all(
6770         is_line_short_enough(ln, line_length=mode.line_length) for ln in second_opinion
6771     ):
6772         result = second_opinion
6773     return result
6774
6775
6776 def get_cache_file(mode: Mode) -> Path:
6777     return CACHE_DIR / f"cache.{mode.get_cache_key()}.pickle"
6778
6779
6780 def read_cache(mode: Mode) -> Cache:
6781     """Read the cache if it exists and is well formed.
6782
6783     If it is not well formed, the call to write_cache later should resolve the issue.
6784     """
6785     cache_file = get_cache_file(mode)
6786     if not cache_file.exists():
6787         return {}
6788
6789     with cache_file.open("rb") as fobj:
6790         try:
6791             cache: Cache = pickle.load(fobj)
6792         except (pickle.UnpicklingError, ValueError):
6793             return {}
6794
6795     return cache
6796
6797
6798 def get_cache_info(path: Path) -> CacheInfo:
6799     """Return the information used to check if a file is already formatted or not."""
6800     stat = path.stat()
6801     return stat.st_mtime, stat.st_size
6802
6803
6804 def filter_cached(cache: Cache, sources: Iterable[Path]) -> Tuple[Set[Path], Set[Path]]:
6805     """Split an iterable of paths in `sources` into two sets.
6806
6807     The first contains paths of files that modified on disk or are not in the
6808     cache. The other contains paths to non-modified files.
6809     """
6810     todo, done = set(), set()
6811     for src in sources:
6812         res_src = src.resolve()
6813         if cache.get(str(res_src)) != get_cache_info(res_src):
6814             todo.add(src)
6815         else:
6816             done.add(src)
6817     return todo, done
6818
6819
6820 def write_cache(cache: Cache, sources: Iterable[Path], mode: Mode) -> None:
6821     """Update the cache file."""
6822     cache_file = get_cache_file(mode)
6823     try:
6824         CACHE_DIR.mkdir(parents=True, exist_ok=True)
6825         new_cache = {
6826             **cache,
6827             **{str(src.resolve()): get_cache_info(src) for src in sources},
6828         }
6829         with tempfile.NamedTemporaryFile(dir=str(cache_file.parent), delete=False) as f:
6830             pickle.dump(new_cache, f, protocol=4)
6831         os.replace(f.name, cache_file)
6832     except OSError:
6833         pass
6834
6835
6836 def patch_click() -> None:
6837     """Make Click not crash.
6838
6839     On certain misconfigured environments, Python 3 selects the ASCII encoding as the
6840     default which restricts paths that it can access during the lifetime of the
6841     application.  Click refuses to work in this scenario by raising a RuntimeError.
6842
6843     In case of Black the likelihood that non-ASCII characters are going to be used in
6844     file paths is minimal since it's Python source code.  Moreover, this crash was
6845     spurious on Python 3.7 thanks to PEP 538 and PEP 540.
6846     """
6847     try:
6848         from click import core
6849         from click import _unicodefun  # type: ignore
6850     except ModuleNotFoundError:
6851         return
6852
6853     for module in (core, _unicodefun):
6854         if hasattr(module, "_verify_python3_env"):
6855             module._verify_python3_env = lambda: None
6856
6857
6858 def patched_main() -> None:
6859     freeze_support()
6860     patch_click()
6861     main()
6862
6863
6864 def is_docstring(leaf: Leaf) -> bool:
6865     if not is_multiline_string(leaf):
6866         # For the purposes of docstring re-indentation, we don't need to do anything
6867         # with single-line docstrings.
6868         return False
6869
6870     if prev_siblings_are(
6871         leaf.parent, [None, token.NEWLINE, token.INDENT, syms.simple_stmt]
6872     ):
6873         return True
6874
6875     # Multiline docstring on the same line as the `def`.
6876     if prev_siblings_are(leaf.parent, [syms.parameters, token.COLON, syms.simple_stmt]):
6877         # `syms.parameters` is only used in funcdefs and async_funcdefs in the Python
6878         # grammar. We're safe to return True without further checks.
6879         return True
6880
6881     return False
6882
6883
6884 def lines_with_leading_tabs_expanded(s: str) -> List[str]:
6885     """
6886     Splits string into lines and expands only leading tabs (following the normal
6887     Python rules)
6888     """
6889     lines = []
6890     for line in s.splitlines():
6891         # Find the index of the first non-whitespace character after a string of
6892         # whitespace that includes at least one tab
6893         match = re.match(r"\s*\t+\s*(\S)", line)
6894         if match:
6895             first_non_whitespace_idx = match.start(1)
6896
6897             lines.append(
6898                 line[:first_non_whitespace_idx].expandtabs()
6899                 + line[first_non_whitespace_idx:]
6900             )
6901         else:
6902             lines.append(line)
6903     return lines
6904
6905
6906 def fix_docstring(docstring: str, prefix: str) -> str:
6907     # https://www.python.org/dev/peps/pep-0257/#handling-docstring-indentation
6908     if not docstring:
6909         return ""
6910     lines = lines_with_leading_tabs_expanded(docstring)
6911     # Determine minimum indentation (first line doesn't count):
6912     indent = sys.maxsize
6913     for line in lines[1:]:
6914         stripped = line.lstrip()
6915         if stripped:
6916             indent = min(indent, len(line) - len(stripped))
6917     # Remove indentation (first line is special):
6918     trimmed = [lines[0].strip()]
6919     if indent < sys.maxsize:
6920         last_line_idx = len(lines) - 2
6921         for i, line in enumerate(lines[1:]):
6922             stripped_line = line[indent:].rstrip()
6923             if stripped_line or i == last_line_idx:
6924                 trimmed.append(prefix + stripped_line)
6925             else:
6926                 trimmed.append("")
6927     return "\n".join(trimmed)
6928
6929
6930 if __name__ == "__main__":
6931     patched_main()