]> 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:

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