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

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