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

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