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

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