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

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