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

2250943665ad21e0cc18ca0efa8edd7288a9329f
[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             self.maybe_remove_trailing_comma(leaf)
1446         if not self.append_comment(leaf):
1447             self.leaves.append(leaf)
1448
1449     def append_safe(self, leaf: Leaf, preformatted: bool = False) -> None:
1450         """Like :func:`append()` but disallow invalid standalone comment structure.
1451
1452         Raises ValueError when any `leaf` is appended after a standalone comment
1453         or when a standalone comment is not the first leaf on the line.
1454         """
1455         if self.bracket_tracker.depth == 0:
1456             if self.is_comment:
1457                 raise ValueError("cannot append to standalone comments")
1458
1459             if self.leaves and leaf.type == STANDALONE_COMMENT:
1460                 raise ValueError(
1461                     "cannot append standalone comments to a populated line"
1462                 )
1463
1464         self.append(leaf, preformatted=preformatted)
1465
1466     @property
1467     def is_comment(self) -> bool:
1468         """Is this line a standalone comment?"""
1469         return len(self.leaves) == 1 and self.leaves[0].type == STANDALONE_COMMENT
1470
1471     @property
1472     def is_decorator(self) -> bool:
1473         """Is this line a decorator?"""
1474         return bool(self) and self.leaves[0].type == token.AT
1475
1476     @property
1477     def is_import(self) -> bool:
1478         """Is this an import line?"""
1479         return bool(self) and is_import(self.leaves[0])
1480
1481     @property
1482     def is_class(self) -> bool:
1483         """Is this line a class definition?"""
1484         return (
1485             bool(self)
1486             and self.leaves[0].type == token.NAME
1487             and self.leaves[0].value == "class"
1488         )
1489
1490     @property
1491     def is_stub_class(self) -> bool:
1492         """Is this line a class definition with a body consisting only of "..."?"""
1493         return self.is_class and self.leaves[-3:] == [
1494             Leaf(token.DOT, ".") for _ in range(3)
1495         ]
1496
1497     @property
1498     def is_def(self) -> bool:
1499         """Is this a function definition? (Also returns True for async defs.)"""
1500         try:
1501             first_leaf = self.leaves[0]
1502         except IndexError:
1503             return False
1504
1505         try:
1506             second_leaf: Optional[Leaf] = self.leaves[1]
1507         except IndexError:
1508             second_leaf = None
1509         return (first_leaf.type == token.NAME and first_leaf.value == "def") or (
1510             first_leaf.type == token.ASYNC
1511             and second_leaf is not None
1512             and second_leaf.type == token.NAME
1513             and second_leaf.value == "def"
1514         )
1515
1516     @property
1517     def is_class_paren_empty(self) -> bool:
1518         """Is this a class with no base classes but using parentheses?
1519
1520         Those are unnecessary and should be removed.
1521         """
1522         return (
1523             bool(self)
1524             and len(self.leaves) == 4
1525             and self.is_class
1526             and self.leaves[2].type == token.LPAR
1527             and self.leaves[2].value == "("
1528             and self.leaves[3].type == token.RPAR
1529             and self.leaves[3].value == ")"
1530         )
1531
1532     @property
1533     def is_triple_quoted_string(self) -> bool:
1534         """Is the line a triple quoted string?"""
1535         return (
1536             bool(self)
1537             and self.leaves[0].type == token.STRING
1538             and self.leaves[0].value.startswith(('"""', "'''"))
1539         )
1540
1541     def contains_standalone_comments(self, depth_limit: int = sys.maxsize) -> bool:
1542         """If so, needs to be split before emitting."""
1543         for leaf in self.leaves:
1544             if leaf.type == STANDALONE_COMMENT and leaf.bracket_depth <= depth_limit:
1545                 return True
1546
1547         return False
1548
1549     def contains_uncollapsable_type_comments(self) -> bool:
1550         ignored_ids = set()
1551         try:
1552             last_leaf = self.leaves[-1]
1553             ignored_ids.add(id(last_leaf))
1554             if last_leaf.type == token.COMMA or (
1555                 last_leaf.type == token.RPAR and not last_leaf.value
1556             ):
1557                 # When trailing commas or optional parens are inserted by Black for
1558                 # consistency, comments after the previous last element are not moved
1559                 # (they don't have to, rendering will still be correct).  So we ignore
1560                 # trailing commas and invisible.
1561                 last_leaf = self.leaves[-2]
1562                 ignored_ids.add(id(last_leaf))
1563         except IndexError:
1564             return False
1565
1566         # A type comment is uncollapsable if it is attached to a leaf
1567         # that isn't at the end of the line (since that could cause it
1568         # to get associated to a different argument) or if there are
1569         # comments before it (since that could cause it to get hidden
1570         # behind a comment.
1571         comment_seen = False
1572         for leaf_id, comments in self.comments.items():
1573             for comment in comments:
1574                 if is_type_comment(comment):
1575                     if comment_seen or (
1576                         not is_type_comment(comment, " ignore")
1577                         and leaf_id not in ignored_ids
1578                     ):
1579                         return True
1580
1581                 comment_seen = True
1582
1583         return False
1584
1585     def contains_unsplittable_type_ignore(self) -> bool:
1586         if not self.leaves:
1587             return False
1588
1589         # If a 'type: ignore' is attached to the end of a line, we
1590         # can't split the line, because we can't know which of the
1591         # subexpressions the ignore was meant to apply to.
1592         #
1593         # We only want this to apply to actual physical lines from the
1594         # original source, though: we don't want the presence of a
1595         # 'type: ignore' at the end of a multiline expression to
1596         # justify pushing it all onto one line. Thus we
1597         # (unfortunately) need to check the actual source lines and
1598         # only report an unsplittable 'type: ignore' if this line was
1599         # one line in the original code.
1600
1601         # Grab the first and last line numbers, skipping generated leaves
1602         first_line = next((leaf.lineno for leaf in self.leaves if leaf.lineno != 0), 0)
1603         last_line = next(
1604             (leaf.lineno for leaf in reversed(self.leaves) if leaf.lineno != 0), 0
1605         )
1606
1607         if first_line == last_line:
1608             # We look at the last two leaves since a comma or an
1609             # invisible paren could have been added at the end of the
1610             # line.
1611             for node in self.leaves[-2:]:
1612                 for comment in self.comments.get(id(node), []):
1613                     if is_type_comment(comment, " ignore"):
1614                         return True
1615
1616         return False
1617
1618     def contains_multiline_strings(self) -> bool:
1619         return any(is_multiline_string(leaf) for leaf in self.leaves)
1620
1621     def maybe_remove_trailing_comma(self, closing: Leaf) -> bool:
1622         """Remove trailing comma if there is one and it's safe."""
1623         if not (
1624             self.leaves
1625             and self.leaves[-1].type == token.COMMA
1626             and closing.type in CLOSING_BRACKETS
1627         ):
1628             return False
1629
1630         if closing.type == token.RBRACE:
1631             self.remove_trailing_comma()
1632             return True
1633
1634         if closing.type == token.RSQB:
1635             comma = self.leaves[-1]
1636             if comma.parent and comma.parent.type == syms.listmaker:
1637                 self.remove_trailing_comma()
1638                 return True
1639
1640         # For parens let's check if it's safe to remove the comma.
1641         # Imports are always safe.
1642         if self.is_import:
1643             self.remove_trailing_comma()
1644             return True
1645
1646         # Otherwise, if the trailing one is the only one, we might mistakenly
1647         # change a tuple into a different type by removing the comma.
1648         depth = closing.bracket_depth + 1
1649         commas = 0
1650         opening = closing.opening_bracket
1651         for _opening_index, leaf in enumerate(self.leaves):
1652             if leaf is opening:
1653                 break
1654
1655         else:
1656             return False
1657
1658         for leaf in self.leaves[_opening_index + 1 :]:
1659             if leaf is closing:
1660                 break
1661
1662             bracket_depth = leaf.bracket_depth
1663             if bracket_depth == depth and leaf.type == token.COMMA:
1664                 commas += 1
1665                 if leaf.parent and leaf.parent.type in {
1666                     syms.arglist,
1667                     syms.typedargslist,
1668                 }:
1669                     commas += 1
1670                     break
1671
1672         if commas > 1:
1673             self.remove_trailing_comma()
1674             return True
1675
1676         return False
1677
1678     def append_comment(self, comment: Leaf) -> bool:
1679         """Add an inline or standalone comment to the line."""
1680         if (
1681             comment.type == STANDALONE_COMMENT
1682             and self.bracket_tracker.any_open_brackets()
1683         ):
1684             comment.prefix = ""
1685             return False
1686
1687         if comment.type != token.COMMENT:
1688             return False
1689
1690         if not self.leaves:
1691             comment.type = STANDALONE_COMMENT
1692             comment.prefix = ""
1693             return False
1694
1695         last_leaf = self.leaves[-1]
1696         if (
1697             last_leaf.type == token.RPAR
1698             and not last_leaf.value
1699             and last_leaf.parent
1700             and len(list(last_leaf.parent.leaves())) <= 3
1701             and not is_type_comment(comment)
1702         ):
1703             # Comments on an optional parens wrapping a single leaf should belong to
1704             # the wrapped node except if it's a type comment. Pinning the comment like
1705             # this avoids unstable formatting caused by comment migration.
1706             if len(self.leaves) < 2:
1707                 comment.type = STANDALONE_COMMENT
1708                 comment.prefix = ""
1709                 return False
1710
1711             last_leaf = self.leaves[-2]
1712         self.comments.setdefault(id(last_leaf), []).append(comment)
1713         return True
1714
1715     def comments_after(self, leaf: Leaf) -> List[Leaf]:
1716         """Generate comments that should appear directly after `leaf`."""
1717         return self.comments.get(id(leaf), [])
1718
1719     def remove_trailing_comma(self) -> None:
1720         """Remove the trailing comma and moves the comments attached to it."""
1721         trailing_comma = self.leaves.pop()
1722         trailing_comma_comments = self.comments.pop(id(trailing_comma), [])
1723         self.comments.setdefault(id(self.leaves[-1]), []).extend(
1724             trailing_comma_comments
1725         )
1726
1727     def is_complex_subscript(self, leaf: Leaf) -> bool:
1728         """Return True iff `leaf` is part of a slice with non-trivial exprs."""
1729         open_lsqb = self.bracket_tracker.get_open_lsqb()
1730         if open_lsqb is None:
1731             return False
1732
1733         subscript_start = open_lsqb.next_sibling
1734
1735         if isinstance(subscript_start, Node):
1736             if subscript_start.type == syms.listmaker:
1737                 return False
1738
1739             if subscript_start.type == syms.subscriptlist:
1740                 subscript_start = child_towards(subscript_start, leaf)
1741         return subscript_start is not None and any(
1742             n.type in TEST_DESCENDANTS for n in subscript_start.pre_order()
1743         )
1744
1745     def clone(self) -> "Line":
1746         return Line(
1747             depth=self.depth,
1748             inside_brackets=self.inside_brackets,
1749             should_explode=self.should_explode,
1750         )
1751
1752     def __str__(self) -> str:
1753         """Render the line."""
1754         if not self:
1755             return "\n"
1756
1757         indent = "    " * self.depth
1758         leaves = iter(self.leaves)
1759         first = next(leaves)
1760         res = f"{first.prefix}{indent}{first.value}"
1761         for leaf in leaves:
1762             res += str(leaf)
1763         for comment in itertools.chain.from_iterable(self.comments.values()):
1764             res += str(comment)
1765
1766         return res + "\n"
1767
1768     def __bool__(self) -> bool:
1769         """Return True if the line has leaves or comments."""
1770         return bool(self.leaves or self.comments)
1771
1772
1773 @dataclass
1774 class EmptyLineTracker:
1775     """Provides a stateful method that returns the number of potential extra
1776     empty lines needed before and after the currently processed line.
1777
1778     Note: this tracker works on lines that haven't been split yet.  It assumes
1779     the prefix of the first leaf consists of optional newlines.  Those newlines
1780     are consumed by `maybe_empty_lines()` and included in the computation.
1781     """
1782
1783     is_pyi: bool = False
1784     previous_line: Optional[Line] = None
1785     previous_after: int = 0
1786     previous_defs: List[int] = field(default_factory=list)
1787
1788     def maybe_empty_lines(self, current_line: Line) -> Tuple[int, int]:
1789         """Return the number of extra empty lines before and after the `current_line`.
1790
1791         This is for separating `def`, `async def` and `class` with extra empty
1792         lines (two on module-level).
1793         """
1794         before, after = self._maybe_empty_lines(current_line)
1795         before = (
1796             # Black should not insert empty lines at the beginning
1797             # of the file
1798             0
1799             if self.previous_line is None
1800             else before - self.previous_after
1801         )
1802         self.previous_after = after
1803         self.previous_line = current_line
1804         return before, after
1805
1806     def _maybe_empty_lines(self, current_line: Line) -> Tuple[int, int]:
1807         max_allowed = 1
1808         if current_line.depth == 0:
1809             max_allowed = 1 if self.is_pyi else 2
1810         if current_line.leaves:
1811             # Consume the first leaf's extra newlines.
1812             first_leaf = current_line.leaves[0]
1813             before = first_leaf.prefix.count("\n")
1814             before = min(before, max_allowed)
1815             first_leaf.prefix = ""
1816         else:
1817             before = 0
1818         depth = current_line.depth
1819         while self.previous_defs and self.previous_defs[-1] >= depth:
1820             self.previous_defs.pop()
1821             if self.is_pyi:
1822                 before = 0 if depth else 1
1823             else:
1824                 before = 1 if depth else 2
1825         if current_line.is_decorator or current_line.is_def or current_line.is_class:
1826             return self._maybe_empty_lines_for_class_or_def(current_line, before)
1827
1828         if (
1829             self.previous_line
1830             and self.previous_line.is_import
1831             and not current_line.is_import
1832             and depth == self.previous_line.depth
1833         ):
1834             return (before or 1), 0
1835
1836         if (
1837             self.previous_line
1838             and self.previous_line.is_class
1839             and current_line.is_triple_quoted_string
1840         ):
1841             return before, 1
1842
1843         return before, 0
1844
1845     def _maybe_empty_lines_for_class_or_def(
1846         self, current_line: Line, before: int
1847     ) -> Tuple[int, int]:
1848         if not current_line.is_decorator:
1849             self.previous_defs.append(current_line.depth)
1850         if self.previous_line is None:
1851             # Don't insert empty lines before the first line in the file.
1852             return 0, 0
1853
1854         if self.previous_line.is_decorator:
1855             return 0, 0
1856
1857         if self.previous_line.depth < current_line.depth and (
1858             self.previous_line.is_class or self.previous_line.is_def
1859         ):
1860             return 0, 0
1861
1862         if (
1863             self.previous_line.is_comment
1864             and self.previous_line.depth == current_line.depth
1865             and before == 0
1866         ):
1867             return 0, 0
1868
1869         if self.is_pyi:
1870             if self.previous_line.depth > current_line.depth:
1871                 newlines = 1
1872             elif current_line.is_class or self.previous_line.is_class:
1873                 if current_line.is_stub_class and self.previous_line.is_stub_class:
1874                     # No blank line between classes with an empty body
1875                     newlines = 0
1876                 else:
1877                     newlines = 1
1878             elif current_line.is_def and not self.previous_line.is_def:
1879                 # Blank line between a block of functions and a block of non-functions
1880                 newlines = 1
1881             else:
1882                 newlines = 0
1883         else:
1884             newlines = 2
1885         if current_line.depth and newlines:
1886             newlines -= 1
1887         return newlines, 0
1888
1889
1890 @dataclass
1891 class LineGenerator(Visitor[Line]):
1892     """Generates reformatted Line objects.  Empty lines are not emitted.
1893
1894     Note: destroys the tree it's visiting by mutating prefixes of its leaves
1895     in ways that will no longer stringify to valid Python code on the tree.
1896     """
1897
1898     is_pyi: bool = False
1899     normalize_strings: bool = True
1900     current_line: Line = field(default_factory=Line)
1901     remove_u_prefix: bool = False
1902
1903     def line(self, indent: int = 0) -> Iterator[Line]:
1904         """Generate a line.
1905
1906         If the line is empty, only emit if it makes sense.
1907         If the line is too long, split it first and then generate.
1908
1909         If any lines were generated, set up a new current_line.
1910         """
1911         if not self.current_line:
1912             self.current_line.depth += indent
1913             return  # Line is empty, don't emit. Creating a new one unnecessary.
1914
1915         complete_line = self.current_line
1916         self.current_line = Line(depth=complete_line.depth + indent)
1917         yield complete_line
1918
1919     def visit_default(self, node: LN) -> Iterator[Line]:
1920         """Default `visit_*()` implementation. Recurses to children of `node`."""
1921         if isinstance(node, Leaf):
1922             any_open_brackets = self.current_line.bracket_tracker.any_open_brackets()
1923             for comment in generate_comments(node):
1924                 if any_open_brackets:
1925                     # any comment within brackets is subject to splitting
1926                     self.current_line.append(comment)
1927                 elif comment.type == token.COMMENT:
1928                     # regular trailing comment
1929                     self.current_line.append(comment)
1930                     yield from self.line()
1931
1932                 else:
1933                     # regular standalone comment
1934                     yield from self.line()
1935
1936                     self.current_line.append(comment)
1937                     yield from self.line()
1938
1939             normalize_prefix(node, inside_brackets=any_open_brackets)
1940             if self.normalize_strings and node.type == token.STRING:
1941                 normalize_string_prefix(node, remove_u_prefix=self.remove_u_prefix)
1942                 normalize_string_quotes(node)
1943             if node.type == token.NUMBER:
1944                 normalize_numeric_literal(node)
1945             if node.type not in WHITESPACE:
1946                 self.current_line.append(node)
1947         yield from super().visit_default(node)
1948
1949     def visit_INDENT(self, node: Leaf) -> Iterator[Line]:
1950         """Increase indentation level, maybe yield a line."""
1951         # In blib2to3 INDENT never holds comments.
1952         yield from self.line(+1)
1953         yield from self.visit_default(node)
1954
1955     def visit_DEDENT(self, node: Leaf) -> Iterator[Line]:
1956         """Decrease indentation level, maybe yield a line."""
1957         # The current line might still wait for trailing comments.  At DEDENT time
1958         # there won't be any (they would be prefixes on the preceding NEWLINE).
1959         # Emit the line then.
1960         yield from self.line()
1961
1962         # While DEDENT has no value, its prefix may contain standalone comments
1963         # that belong to the current indentation level.  Get 'em.
1964         yield from self.visit_default(node)
1965
1966         # Finally, emit the dedent.
1967         yield from self.line(-1)
1968
1969     def visit_stmt(
1970         self, node: Node, keywords: Set[str], parens: Set[str]
1971     ) -> Iterator[Line]:
1972         """Visit a statement.
1973
1974         This implementation is shared for `if`, `while`, `for`, `try`, `except`,
1975         `def`, `with`, `class`, `assert` and assignments.
1976
1977         The relevant Python language `keywords` for a given statement will be
1978         NAME leaves within it. This methods puts those on a separate line.
1979
1980         `parens` holds a set of string leaf values immediately after which
1981         invisible parens should be put.
1982         """
1983         normalize_invisible_parens(node, parens_after=parens)
1984         for child in node.children:
1985             if child.type == token.NAME and child.value in keywords:  # type: ignore
1986                 yield from self.line()
1987
1988             yield from self.visit(child)
1989
1990     def visit_suite(self, node: Node) -> Iterator[Line]:
1991         """Visit a suite."""
1992         if self.is_pyi and is_stub_suite(node):
1993             yield from self.visit(node.children[2])
1994         else:
1995             yield from self.visit_default(node)
1996
1997     def visit_simple_stmt(self, node: Node) -> Iterator[Line]:
1998         """Visit a statement without nested statements."""
1999         is_suite_like = node.parent and node.parent.type in STATEMENT
2000         if is_suite_like:
2001             if self.is_pyi and is_stub_body(node):
2002                 yield from self.visit_default(node)
2003             else:
2004                 yield from self.line(+1)
2005                 yield from self.visit_default(node)
2006                 yield from self.line(-1)
2007
2008         else:
2009             if not self.is_pyi or not node.parent or not is_stub_suite(node.parent):
2010                 yield from self.line()
2011             yield from self.visit_default(node)
2012
2013     def visit_async_stmt(self, node: Node) -> Iterator[Line]:
2014         """Visit `async def`, `async for`, `async with`."""
2015         yield from self.line()
2016
2017         children = iter(node.children)
2018         for child in children:
2019             yield from self.visit(child)
2020
2021             if child.type == token.ASYNC:
2022                 break
2023
2024         internal_stmt = next(children)
2025         for child in internal_stmt.children:
2026             yield from self.visit(child)
2027
2028     def visit_decorators(self, node: Node) -> Iterator[Line]:
2029         """Visit decorators."""
2030         for child in node.children:
2031             yield from self.line()
2032             yield from self.visit(child)
2033
2034     def visit_SEMI(self, leaf: Leaf) -> Iterator[Line]:
2035         """Remove a semicolon and put the other statement on a separate line."""
2036         yield from self.line()
2037
2038     def visit_ENDMARKER(self, leaf: Leaf) -> Iterator[Line]:
2039         """End of file. Process outstanding comments and end with a newline."""
2040         yield from self.visit_default(leaf)
2041         yield from self.line()
2042
2043     def visit_STANDALONE_COMMENT(self, leaf: Leaf) -> Iterator[Line]:
2044         if not self.current_line.bracket_tracker.any_open_brackets():
2045             yield from self.line()
2046         yield from self.visit_default(leaf)
2047
2048     def visit_factor(self, node: Node) -> Iterator[Line]:
2049         """Force parentheses between a unary op and a binary power:
2050
2051         -2 ** 8 -> -(2 ** 8)
2052         """
2053         _operator, operand = node.children
2054         if (
2055             operand.type == syms.power
2056             and len(operand.children) == 3
2057             and operand.children[1].type == token.DOUBLESTAR
2058         ):
2059             lpar = Leaf(token.LPAR, "(")
2060             rpar = Leaf(token.RPAR, ")")
2061             index = operand.remove() or 0
2062             node.insert_child(index, Node(syms.atom, [lpar, operand, rpar]))
2063         yield from self.visit_default(node)
2064
2065     def visit_STRING(self, leaf: Leaf) -> Iterator[Line]:
2066         # Check if it's a docstring
2067         if prev_siblings_are(
2068             leaf.parent, [None, token.NEWLINE, token.INDENT, syms.simple_stmt]
2069         ) and is_multiline_string(leaf):
2070             prefix = "    " * self.current_line.depth
2071             docstring = fix_docstring(leaf.value[3:-3], prefix)
2072             leaf.value = leaf.value[0:3] + docstring + leaf.value[-3:]
2073             normalize_string_quotes(leaf)
2074
2075         yield from self.visit_default(leaf)
2076
2077     def __post_init__(self) -> None:
2078         """You are in a twisty little maze of passages."""
2079         v = self.visit_stmt
2080         Ø: Set[str] = set()
2081         self.visit_assert_stmt = partial(v, keywords={"assert"}, parens={"assert", ","})
2082         self.visit_if_stmt = partial(
2083             v, keywords={"if", "else", "elif"}, parens={"if", "elif"}
2084         )
2085         self.visit_while_stmt = partial(v, keywords={"while", "else"}, parens={"while"})
2086         self.visit_for_stmt = partial(v, keywords={"for", "else"}, parens={"for", "in"})
2087         self.visit_try_stmt = partial(
2088             v, keywords={"try", "except", "else", "finally"}, parens=Ø
2089         )
2090         self.visit_except_clause = partial(v, keywords={"except"}, parens=Ø)
2091         self.visit_with_stmt = partial(v, keywords={"with"}, parens=Ø)
2092         self.visit_funcdef = partial(v, keywords={"def"}, parens=Ø)
2093         self.visit_classdef = partial(v, keywords={"class"}, parens=Ø)
2094         self.visit_expr_stmt = partial(v, keywords=Ø, parens=ASSIGNMENTS)
2095         self.visit_return_stmt = partial(v, keywords={"return"}, parens={"return"})
2096         self.visit_import_from = partial(v, keywords=Ø, parens={"import"})
2097         self.visit_del_stmt = partial(v, keywords=Ø, parens={"del"})
2098         self.visit_async_funcdef = self.visit_async_stmt
2099         self.visit_decorated = self.visit_decorators
2100
2101
2102 IMPLICIT_TUPLE = {syms.testlist, syms.testlist_star_expr, syms.exprlist}
2103 BRACKET = {token.LPAR: token.RPAR, token.LSQB: token.RSQB, token.LBRACE: token.RBRACE}
2104 OPENING_BRACKETS = set(BRACKET.keys())
2105 CLOSING_BRACKETS = set(BRACKET.values())
2106 BRACKETS = OPENING_BRACKETS | CLOSING_BRACKETS
2107 ALWAYS_NO_SPACE = CLOSING_BRACKETS | {token.COMMA, STANDALONE_COMMENT}
2108
2109
2110 def whitespace(leaf: Leaf, *, complex_subscript: bool) -> str:  # noqa: C901
2111     """Return whitespace prefix if needed for the given `leaf`.
2112
2113     `complex_subscript` signals whether the given leaf is part of a subscription
2114     which has non-trivial arguments, like arithmetic expressions or function calls.
2115     """
2116     NO = ""
2117     SPACE = " "
2118     DOUBLESPACE = "  "
2119     t = leaf.type
2120     p = leaf.parent
2121     v = leaf.value
2122     if t in ALWAYS_NO_SPACE:
2123         return NO
2124
2125     if t == token.COMMENT:
2126         return DOUBLESPACE
2127
2128     assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}"
2129     if t == token.COLON and p.type not in {
2130         syms.subscript,
2131         syms.subscriptlist,
2132         syms.sliceop,
2133     }:
2134         return NO
2135
2136     prev = leaf.prev_sibling
2137     if not prev:
2138         prevp = preceding_leaf(p)
2139         if not prevp or prevp.type in OPENING_BRACKETS:
2140             return NO
2141
2142         if t == token.COLON:
2143             if prevp.type == token.COLON:
2144                 return NO
2145
2146             elif prevp.type != token.COMMA and not complex_subscript:
2147                 return NO
2148
2149             return SPACE
2150
2151         if prevp.type == token.EQUAL:
2152             if prevp.parent:
2153                 if prevp.parent.type in {
2154                     syms.arglist,
2155                     syms.argument,
2156                     syms.parameters,
2157                     syms.varargslist,
2158                 }:
2159                     return NO
2160
2161                 elif prevp.parent.type == syms.typedargslist:
2162                     # A bit hacky: if the equal sign has whitespace, it means we
2163                     # previously found it's a typed argument.  So, we're using
2164                     # that, too.
2165                     return prevp.prefix
2166
2167         elif prevp.type in VARARGS_SPECIALS:
2168             if is_vararg(prevp, within=VARARGS_PARENTS | UNPACKING_PARENTS):
2169                 return NO
2170
2171         elif prevp.type == token.COLON:
2172             if prevp.parent and prevp.parent.type in {syms.subscript, syms.sliceop}:
2173                 return SPACE if complex_subscript else NO
2174
2175         elif (
2176             prevp.parent
2177             and prevp.parent.type == syms.factor
2178             and prevp.type in MATH_OPERATORS
2179         ):
2180             return NO
2181
2182         elif (
2183             prevp.type == token.RIGHTSHIFT
2184             and prevp.parent
2185             and prevp.parent.type == syms.shift_expr
2186             and prevp.prev_sibling
2187             and prevp.prev_sibling.type == token.NAME
2188             and prevp.prev_sibling.value == "print"  # type: ignore
2189         ):
2190             # Python 2 print chevron
2191             return NO
2192
2193     elif prev.type in OPENING_BRACKETS:
2194         return NO
2195
2196     if p.type in {syms.parameters, syms.arglist}:
2197         # untyped function signatures or calls
2198         if not prev or prev.type != token.COMMA:
2199             return NO
2200
2201     elif p.type == syms.varargslist:
2202         # lambdas
2203         if prev and prev.type != token.COMMA:
2204             return NO
2205
2206     elif p.type == syms.typedargslist:
2207         # typed function signatures
2208         if not prev:
2209             return NO
2210
2211         if t == token.EQUAL:
2212             if prev.type != syms.tname:
2213                 return NO
2214
2215         elif prev.type == token.EQUAL:
2216             # A bit hacky: if the equal sign has whitespace, it means we
2217             # previously found it's a typed argument.  So, we're using that, too.
2218             return prev.prefix
2219
2220         elif prev.type != token.COMMA:
2221             return NO
2222
2223     elif p.type == syms.tname:
2224         # type names
2225         if not prev:
2226             prevp = preceding_leaf(p)
2227             if not prevp or prevp.type != token.COMMA:
2228                 return NO
2229
2230     elif p.type == syms.trailer:
2231         # attributes and calls
2232         if t == token.LPAR or t == token.RPAR:
2233             return NO
2234
2235         if not prev:
2236             if t == token.DOT:
2237                 prevp = preceding_leaf(p)
2238                 if not prevp or prevp.type != token.NUMBER:
2239                     return NO
2240
2241             elif t == token.LSQB:
2242                 return NO
2243
2244         elif prev.type != token.COMMA:
2245             return NO
2246
2247     elif p.type == syms.argument:
2248         # single argument
2249         if t == token.EQUAL:
2250             return NO
2251
2252         if not prev:
2253             prevp = preceding_leaf(p)
2254             if not prevp or prevp.type == token.LPAR:
2255                 return NO
2256
2257         elif prev.type in {token.EQUAL} | VARARGS_SPECIALS:
2258             return NO
2259
2260     elif p.type == syms.decorator:
2261         # decorators
2262         return NO
2263
2264     elif p.type == syms.dotted_name:
2265         if prev:
2266             return NO
2267
2268         prevp = preceding_leaf(p)
2269         if not prevp or prevp.type == token.AT or prevp.type == token.DOT:
2270             return NO
2271
2272     elif p.type == syms.classdef:
2273         if t == token.LPAR:
2274             return NO
2275
2276         if prev and prev.type == token.LPAR:
2277             return NO
2278
2279     elif p.type in {syms.subscript, syms.sliceop}:
2280         # indexing
2281         if not prev:
2282             assert p.parent is not None, "subscripts are always parented"
2283             if p.parent.type == syms.subscriptlist:
2284                 return SPACE
2285
2286             return NO
2287
2288         elif not complex_subscript:
2289             return NO
2290
2291     elif p.type == syms.atom:
2292         if prev and t == token.DOT:
2293             # dots, but not the first one.
2294             return NO
2295
2296     elif p.type == syms.dictsetmaker:
2297         # dict unpacking
2298         if prev and prev.type == token.DOUBLESTAR:
2299             return NO
2300
2301     elif p.type in {syms.factor, syms.star_expr}:
2302         # unary ops
2303         if not prev:
2304             prevp = preceding_leaf(p)
2305             if not prevp or prevp.type in OPENING_BRACKETS:
2306                 return NO
2307
2308             prevp_parent = prevp.parent
2309             assert prevp_parent is not None
2310             if prevp.type == token.COLON and prevp_parent.type in {
2311                 syms.subscript,
2312                 syms.sliceop,
2313             }:
2314                 return NO
2315
2316             elif prevp.type == token.EQUAL and prevp_parent.type == syms.argument:
2317                 return NO
2318
2319         elif t in {token.NAME, token.NUMBER, token.STRING}:
2320             return NO
2321
2322     elif p.type == syms.import_from:
2323         if t == token.DOT:
2324             if prev and prev.type == token.DOT:
2325                 return NO
2326
2327         elif t == token.NAME:
2328             if v == "import":
2329                 return SPACE
2330
2331             if prev and prev.type == token.DOT:
2332                 return NO
2333
2334     elif p.type == syms.sliceop:
2335         return NO
2336
2337     return SPACE
2338
2339
2340 def preceding_leaf(node: Optional[LN]) -> Optional[Leaf]:
2341     """Return the first leaf that precedes `node`, if any."""
2342     while node:
2343         res = node.prev_sibling
2344         if res:
2345             if isinstance(res, Leaf):
2346                 return res
2347
2348             try:
2349                 return list(res.leaves())[-1]
2350
2351             except IndexError:
2352                 return None
2353
2354         node = node.parent
2355     return None
2356
2357
2358 def prev_siblings_are(node: Optional[LN], tokens: List[Optional[NodeType]]) -> bool:
2359     """Return if the `node` and its previous siblings match types against the provided
2360     list of tokens; the provided `node`has its type matched against the last element in
2361     the list.  `None` can be used as the first element to declare that the start of the
2362     list is anchored at the start of its parent's children."""
2363     if not tokens:
2364         return True
2365     if tokens[-1] is None:
2366         return node is None
2367     if not node:
2368         return False
2369     if node.type != tokens[-1]:
2370         return False
2371     return prev_siblings_are(node.prev_sibling, tokens[:-1])
2372
2373
2374 def child_towards(ancestor: Node, descendant: LN) -> Optional[LN]:
2375     """Return the child of `ancestor` that contains `descendant`."""
2376     node: Optional[LN] = descendant
2377     while node and node.parent != ancestor:
2378         node = node.parent
2379     return node
2380
2381
2382 def container_of(leaf: Leaf) -> LN:
2383     """Return `leaf` or one of its ancestors that is the topmost container of it.
2384
2385     By "container" we mean a node where `leaf` is the very first child.
2386     """
2387     same_prefix = leaf.prefix
2388     container: LN = leaf
2389     while container:
2390         parent = container.parent
2391         if parent is None:
2392             break
2393
2394         if parent.children[0].prefix != same_prefix:
2395             break
2396
2397         if parent.type == syms.file_input:
2398             break
2399
2400         if parent.prev_sibling is not None and parent.prev_sibling.type in BRACKETS:
2401             break
2402
2403         container = parent
2404     return container
2405
2406
2407 def is_split_after_delimiter(leaf: Leaf, previous: Optional[Leaf] = None) -> Priority:
2408     """Return the priority of the `leaf` delimiter, given a line break after it.
2409
2410     The delimiter priorities returned here are from those delimiters that would
2411     cause a line break after themselves.
2412
2413     Higher numbers are higher priority.
2414     """
2415     if leaf.type == token.COMMA:
2416         return COMMA_PRIORITY
2417
2418     return 0
2419
2420
2421 def is_split_before_delimiter(leaf: Leaf, previous: Optional[Leaf] = None) -> Priority:
2422     """Return the priority of the `leaf` delimiter, given a line break before it.
2423
2424     The delimiter priorities returned here are from those delimiters that would
2425     cause a line break before themselves.
2426
2427     Higher numbers are higher priority.
2428     """
2429     if is_vararg(leaf, within=VARARGS_PARENTS | UNPACKING_PARENTS):
2430         # * and ** might also be MATH_OPERATORS but in this case they are not.
2431         # Don't treat them as a delimiter.
2432         return 0
2433
2434     if (
2435         leaf.type == token.DOT
2436         and leaf.parent
2437         and leaf.parent.type not in {syms.import_from, syms.dotted_name}
2438         and (previous is None or previous.type in CLOSING_BRACKETS)
2439     ):
2440         return DOT_PRIORITY
2441
2442     if (
2443         leaf.type in MATH_OPERATORS
2444         and leaf.parent
2445         and leaf.parent.type not in {syms.factor, syms.star_expr}
2446     ):
2447         return MATH_PRIORITIES[leaf.type]
2448
2449     if leaf.type in COMPARATORS:
2450         return COMPARATOR_PRIORITY
2451
2452     if (
2453         leaf.type == token.STRING
2454         and previous is not None
2455         and previous.type == token.STRING
2456     ):
2457         return STRING_PRIORITY
2458
2459     if leaf.type not in {token.NAME, token.ASYNC}:
2460         return 0
2461
2462     if (
2463         leaf.value == "for"
2464         and leaf.parent
2465         and leaf.parent.type in {syms.comp_for, syms.old_comp_for}
2466         or leaf.type == token.ASYNC
2467     ):
2468         if (
2469             not isinstance(leaf.prev_sibling, Leaf)
2470             or leaf.prev_sibling.value != "async"
2471         ):
2472             return COMPREHENSION_PRIORITY
2473
2474     if (
2475         leaf.value == "if"
2476         and leaf.parent
2477         and leaf.parent.type in {syms.comp_if, syms.old_comp_if}
2478     ):
2479         return COMPREHENSION_PRIORITY
2480
2481     if leaf.value in {"if", "else"} and leaf.parent and leaf.parent.type == syms.test:
2482         return TERNARY_PRIORITY
2483
2484     if leaf.value == "is":
2485         return COMPARATOR_PRIORITY
2486
2487     if (
2488         leaf.value == "in"
2489         and leaf.parent
2490         and leaf.parent.type in {syms.comp_op, syms.comparison}
2491         and not (
2492             previous is not None
2493             and previous.type == token.NAME
2494             and previous.value == "not"
2495         )
2496     ):
2497         return COMPARATOR_PRIORITY
2498
2499     if (
2500         leaf.value == "not"
2501         and leaf.parent
2502         and leaf.parent.type == syms.comp_op
2503         and not (
2504             previous is not None
2505             and previous.type == token.NAME
2506             and previous.value == "is"
2507         )
2508     ):
2509         return COMPARATOR_PRIORITY
2510
2511     if leaf.value in LOGIC_OPERATORS and leaf.parent:
2512         return LOGIC_PRIORITY
2513
2514     return 0
2515
2516
2517 FMT_OFF = {"# fmt: off", "# fmt:off", "# yapf: disable"}
2518 FMT_ON = {"# fmt: on", "# fmt:on", "# yapf: enable"}
2519
2520
2521 def generate_comments(leaf: LN) -> Iterator[Leaf]:
2522     """Clean the prefix of the `leaf` and generate comments from it, if any.
2523
2524     Comments in lib2to3 are shoved into the whitespace prefix.  This happens
2525     in `pgen2/driver.py:Driver.parse_tokens()`.  This was a brilliant implementation
2526     move because it does away with modifying the grammar to include all the
2527     possible places in which comments can be placed.
2528
2529     The sad consequence for us though is that comments don't "belong" anywhere.
2530     This is why this function generates simple parentless Leaf objects for
2531     comments.  We simply don't know what the correct parent should be.
2532
2533     No matter though, we can live without this.  We really only need to
2534     differentiate between inline and standalone comments.  The latter don't
2535     share the line with any code.
2536
2537     Inline comments are emitted as regular token.COMMENT leaves.  Standalone
2538     are emitted with a fake STANDALONE_COMMENT token identifier.
2539     """
2540     for pc in list_comments(leaf.prefix, is_endmarker=leaf.type == token.ENDMARKER):
2541         yield Leaf(pc.type, pc.value, prefix="\n" * pc.newlines)
2542
2543
2544 @dataclass
2545 class ProtoComment:
2546     """Describes a piece of syntax that is a comment.
2547
2548     It's not a :class:`blib2to3.pytree.Leaf` so that:
2549
2550     * it can be cached (`Leaf` objects should not be reused more than once as
2551       they store their lineno, column, prefix, and parent information);
2552     * `newlines` and `consumed` fields are kept separate from the `value`. This
2553       simplifies handling of special marker comments like ``# fmt: off/on``.
2554     """
2555
2556     type: int  # token.COMMENT or STANDALONE_COMMENT
2557     value: str  # content of the comment
2558     newlines: int  # how many newlines before the comment
2559     consumed: int  # how many characters of the original leaf's prefix did we consume
2560
2561
2562 @lru_cache(maxsize=4096)
2563 def list_comments(prefix: str, *, is_endmarker: bool) -> List[ProtoComment]:
2564     """Return a list of :class:`ProtoComment` objects parsed from the given `prefix`."""
2565     result: List[ProtoComment] = []
2566     if not prefix or "#" not in prefix:
2567         return result
2568
2569     consumed = 0
2570     nlines = 0
2571     ignored_lines = 0
2572     for index, line in enumerate(prefix.split("\n")):
2573         consumed += len(line) + 1  # adding the length of the split '\n'
2574         line = line.lstrip()
2575         if not line:
2576             nlines += 1
2577         if not line.startswith("#"):
2578             # Escaped newlines outside of a comment are not really newlines at
2579             # all. We treat a single-line comment following an escaped newline
2580             # as a simple trailing comment.
2581             if line.endswith("\\"):
2582                 ignored_lines += 1
2583             continue
2584
2585         if index == ignored_lines and not is_endmarker:
2586             comment_type = token.COMMENT  # simple trailing comment
2587         else:
2588             comment_type = STANDALONE_COMMENT
2589         comment = make_comment(line)
2590         result.append(
2591             ProtoComment(
2592                 type=comment_type, value=comment, newlines=nlines, consumed=consumed
2593             )
2594         )
2595         nlines = 0
2596     return result
2597
2598
2599 def make_comment(content: str) -> str:
2600     """Return a consistently formatted comment from the given `content` string.
2601
2602     All comments (except for "##", "#!", "#:", '#'", "#%%") should have a single
2603     space between the hash sign and the content.
2604
2605     If `content` didn't start with a hash sign, one is provided.
2606     """
2607     content = content.rstrip()
2608     if not content:
2609         return "#"
2610
2611     if content[0] == "#":
2612         content = content[1:]
2613     if content and content[0] not in " !:#'%":
2614         content = " " + content
2615     return "#" + content
2616
2617
2618 def transform_line(
2619     line: Line, mode: Mode, features: Collection[Feature] = ()
2620 ) -> Iterator[Line]:
2621     """Transform a `line`, potentially splitting it into many lines.
2622
2623     They should fit in the allotted `line_length` but might not be able to.
2624
2625     `features` are syntactical features that may be used in the output.
2626     """
2627     if line.is_comment:
2628         yield line
2629         return
2630
2631     line_str = line_to_string(line)
2632
2633     def init_st(ST: Type[StringTransformer]) -> StringTransformer:
2634         """Initialize StringTransformer"""
2635         return ST(mode.line_length, mode.string_normalization)
2636
2637     string_merge = init_st(StringMerger)
2638     string_paren_strip = init_st(StringParenStripper)
2639     string_split = init_st(StringSplitter)
2640     string_paren_wrap = init_st(StringParenWrapper)
2641
2642     transformers: List[Transformer]
2643     if (
2644         not line.contains_uncollapsable_type_comments()
2645         and not line.should_explode
2646         and (
2647             is_line_short_enough(line, line_length=mode.line_length, line_str=line_str)
2648             or line.contains_unsplittable_type_ignore()
2649         )
2650         and not (line.contains_standalone_comments() and line.inside_brackets)
2651     ):
2652         # Only apply basic string preprocessing, since lines shouldn't be split here.
2653         if mode.experimental_string_processing:
2654             transformers = [string_merge, string_paren_strip]
2655         else:
2656             transformers = []
2657     elif line.is_def:
2658         transformers = [left_hand_split]
2659     else:
2660
2661         def rhs(line: Line, features: Collection[Feature]) -> Iterator[Line]:
2662             for omit in generate_trailers_to_omit(line, mode.line_length):
2663                 lines = list(
2664                     right_hand_split(line, mode.line_length, features, omit=omit)
2665                 )
2666                 if is_line_short_enough(lines[0], line_length=mode.line_length):
2667                     yield from lines
2668                     return
2669
2670             # All splits failed, best effort split with no omits.
2671             # This mostly happens to multiline strings that are by definition
2672             # reported as not fitting a single line.
2673             # line_length=1 here was historically a bug that somehow became a feature.
2674             # See #762 and #781 for the full story.
2675             yield from right_hand_split(line, line_length=1, features=features)
2676
2677         if mode.experimental_string_processing:
2678             if line.inside_brackets:
2679                 transformers = [
2680                     string_merge,
2681                     string_paren_strip,
2682                     delimiter_split,
2683                     standalone_comment_split,
2684                     string_split,
2685                     string_paren_wrap,
2686                     rhs,
2687                 ]
2688             else:
2689                 transformers = [
2690                     string_merge,
2691                     string_paren_strip,
2692                     string_split,
2693                     string_paren_wrap,
2694                     rhs,
2695                 ]
2696         else:
2697             if line.inside_brackets:
2698                 transformers = [delimiter_split, standalone_comment_split, rhs]
2699             else:
2700                 transformers = [rhs]
2701
2702     for transform in transformers:
2703         # We are accumulating lines in `result` because we might want to abort
2704         # mission and return the original line in the end, or attempt a different
2705         # split altogether.
2706         result: List[Line] = []
2707         try:
2708             for transformed_line in transform(line, features):
2709                 if str(transformed_line).strip("\n") == line_str:
2710                     raise CannotTransform(
2711                         "Line transformer returned an unchanged result"
2712                     )
2713
2714                 result.extend(
2715                     transform_line(transformed_line, mode=mode, features=features)
2716                 )
2717         except CannotTransform:
2718             continue
2719         else:
2720             yield from result
2721             break
2722
2723     else:
2724         yield line
2725
2726
2727 @dataclass  # type: ignore
2728 class StringTransformer(ABC):
2729     """
2730     An implementation of the Transformer protocol that relies on its
2731     subclasses overriding the template methods `do_match(...)` and
2732     `do_transform(...)`.
2733
2734     This Transformer works exclusively on strings (for example, by merging
2735     or splitting them).
2736
2737     The following sections can be found among the docstrings of each concrete
2738     StringTransformer subclass.
2739
2740     Requirements:
2741         Which requirements must be met of the given Line for this
2742         StringTransformer to be applied?
2743
2744     Transformations:
2745         If the given Line meets all of the above requirements, which string
2746         transformations can you expect to be applied to it by this
2747         StringTransformer?
2748
2749     Collaborations:
2750         What contractual agreements does this StringTransformer have with other
2751         StringTransfomers? Such collaborations should be eliminated/minimized
2752         as much as possible.
2753     """
2754
2755     line_length: int
2756     normalize_strings: bool
2757
2758     @abstractmethod
2759     def do_match(self, line: Line) -> TMatchResult:
2760         """
2761         Returns:
2762             * Ok(string_idx) such that `line.leaves[string_idx]` is our target
2763             string, if a match was able to be made.
2764                 OR
2765             * Err(CannotTransform), if a match was not able to be made.
2766         """
2767
2768     @abstractmethod
2769     def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
2770         """
2771         Yields:
2772             * Ok(new_line) where new_line is the new transformed line.
2773                 OR
2774             * Err(CannotTransform) if the transformation failed for some reason. The
2775             `do_match(...)` template method should usually be used to reject
2776             the form of the given Line, but in some cases it is difficult to
2777             know whether or not a Line meets the StringTransformer's
2778             requirements until the transformation is already midway.
2779
2780         Side Effects:
2781             This method should NOT mutate @line directly, but it MAY mutate the
2782             Line's underlying Node structure. (WARNING: If the underlying Node
2783             structure IS altered, then this method should NOT be allowed to
2784             yield an CannotTransform after that point.)
2785         """
2786
2787     def __call__(self, line: Line, _features: Collection[Feature]) -> Iterator[Line]:
2788         """
2789         StringTransformer instances have a call signature that mirrors that of
2790         the Transformer type.
2791
2792         Raises:
2793             CannotTransform(...) if the concrete StringTransformer class is unable
2794             to transform @line.
2795         """
2796         # Optimization to avoid calling `self.do_match(...)` when the line does
2797         # not contain any string.
2798         if not any(leaf.type == token.STRING for leaf in line.leaves):
2799             raise CannotTransform("There are no strings in this line.")
2800
2801         match_result = self.do_match(line)
2802
2803         if isinstance(match_result, Err):
2804             cant_transform = match_result.err()
2805             raise CannotTransform(
2806                 f"The string transformer {self.__class__.__name__} does not recognize"
2807                 " this line as one that it can transform."
2808             ) from cant_transform
2809
2810         string_idx = match_result.ok()
2811
2812         for line_result in self.do_transform(line, string_idx):
2813             if isinstance(line_result, Err):
2814                 cant_transform = line_result.err()
2815                 raise CannotTransform(
2816                     "StringTransformer failed while attempting to transform string."
2817                 ) from cant_transform
2818             line = line_result.ok()
2819             yield line
2820
2821
2822 @dataclass
2823 class CustomSplit:
2824     """A custom (i.e. manual) string split.
2825
2826     A single CustomSplit instance represents a single substring.
2827
2828     Examples:
2829         Consider the following string:
2830         ```
2831         "Hi there friend."
2832         " This is a custom"
2833         f" string {split}."
2834         ```
2835
2836         This string will correspond to the following three CustomSplit instances:
2837         ```
2838         CustomSplit(False, 16)
2839         CustomSplit(False, 17)
2840         CustomSplit(True, 16)
2841         ```
2842     """
2843
2844     has_prefix: bool
2845     break_idx: int
2846
2847
2848 class CustomSplitMapMixin:
2849     """
2850     This mixin class is used to map merged strings to a sequence of
2851     CustomSplits, which will then be used to re-split the strings iff none of
2852     the resultant substrings go over the configured max line length.
2853     """
2854
2855     _Key = Tuple[StringID, str]
2856     _CUSTOM_SPLIT_MAP: Dict[_Key, Tuple[CustomSplit, ...]] = defaultdict(tuple)
2857
2858     @staticmethod
2859     def _get_key(string: str) -> "CustomSplitMapMixin._Key":
2860         """
2861         Returns:
2862             A unique identifier that is used internally to map @string to a
2863             group of custom splits.
2864         """
2865         return (id(string), string)
2866
2867     def add_custom_splits(
2868         self, string: str, custom_splits: Iterable[CustomSplit]
2869     ) -> None:
2870         """Custom Split Map Setter Method
2871
2872         Side Effects:
2873             Adds a mapping from @string to the custom splits @custom_splits.
2874         """
2875         key = self._get_key(string)
2876         self._CUSTOM_SPLIT_MAP[key] = tuple(custom_splits)
2877
2878     def pop_custom_splits(self, string: str) -> List[CustomSplit]:
2879         """Custom Split Map Getter Method
2880
2881         Returns:
2882             * A list of the custom splits that are mapped to @string, if any
2883             exist.
2884                 OR
2885             * [], otherwise.
2886
2887         Side Effects:
2888             Deletes the mapping between @string and its associated custom
2889             splits (which are returned to the caller).
2890         """
2891         key = self._get_key(string)
2892
2893         custom_splits = self._CUSTOM_SPLIT_MAP[key]
2894         del self._CUSTOM_SPLIT_MAP[key]
2895
2896         return list(custom_splits)
2897
2898     def has_custom_splits(self, string: str) -> bool:
2899         """
2900         Returns:
2901             True iff @string is associated with a set of custom splits.
2902         """
2903         key = self._get_key(string)
2904         return key in self._CUSTOM_SPLIT_MAP
2905
2906
2907 class StringMerger(CustomSplitMapMixin, StringTransformer):
2908     """StringTransformer that merges strings together.
2909
2910     Requirements:
2911         (A) The line contains adjacent strings such that at most one substring
2912         has inline comments AND none of those inline comments are pragmas AND
2913         the set of all substring prefixes is either of length 1 or equal to
2914         {"", "f"} AND none of the substrings are raw strings (i.e. are prefixed
2915         with 'r').
2916             OR
2917         (B) The line contains a string which uses line continuation backslashes.
2918
2919     Transformations:
2920         Depending on which of the two requirements above where met, either:
2921
2922         (A) The string group associated with the target string is merged.
2923             OR
2924         (B) All line-continuation backslashes are removed from the target string.
2925
2926     Collaborations:
2927         StringMerger provides custom split information to StringSplitter.
2928     """
2929
2930     def do_match(self, line: Line) -> TMatchResult:
2931         LL = line.leaves
2932
2933         is_valid_index = is_valid_index_factory(LL)
2934
2935         for (i, leaf) in enumerate(LL):
2936             if (
2937                 leaf.type == token.STRING
2938                 and is_valid_index(i + 1)
2939                 and LL[i + 1].type == token.STRING
2940             ):
2941                 return Ok(i)
2942
2943             if leaf.type == token.STRING and "\\\n" in leaf.value:
2944                 return Ok(i)
2945
2946         return TErr("This line has no strings that need merging.")
2947
2948     def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
2949         new_line = line
2950         rblc_result = self.__remove_backslash_line_continuation_chars(
2951             new_line, string_idx
2952         )
2953         if isinstance(rblc_result, Ok):
2954             new_line = rblc_result.ok()
2955
2956         msg_result = self.__merge_string_group(new_line, string_idx)
2957         if isinstance(msg_result, Ok):
2958             new_line = msg_result.ok()
2959
2960         if isinstance(rblc_result, Err) and isinstance(msg_result, Err):
2961             msg_cant_transform = msg_result.err()
2962             rblc_cant_transform = rblc_result.err()
2963             cant_transform = CannotTransform(
2964                 "StringMerger failed to merge any strings in this line."
2965             )
2966
2967             # Chain the errors together using `__cause__`.
2968             msg_cant_transform.__cause__ = rblc_cant_transform
2969             cant_transform.__cause__ = msg_cant_transform
2970
2971             yield Err(cant_transform)
2972         else:
2973             yield Ok(new_line)
2974
2975     @staticmethod
2976     def __remove_backslash_line_continuation_chars(
2977         line: Line, string_idx: int
2978     ) -> TResult[Line]:
2979         """
2980         Merge strings that were split across multiple lines using
2981         line-continuation backslashes.
2982
2983         Returns:
2984             Ok(new_line), if @line contains backslash line-continuation
2985             characters.
2986                 OR
2987             Err(CannotTransform), otherwise.
2988         """
2989         LL = line.leaves
2990
2991         string_leaf = LL[string_idx]
2992         if not (
2993             string_leaf.type == token.STRING
2994             and "\\\n" in string_leaf.value
2995             and not has_triple_quotes(string_leaf.value)
2996         ):
2997             return TErr(
2998                 f"String leaf {string_leaf} does not contain any backslash line"
2999                 " continuation characters."
3000             )
3001
3002         new_line = line.clone()
3003         new_line.comments = line.comments
3004         append_leaves(new_line, line, LL)
3005
3006         new_string_leaf = new_line.leaves[string_idx]
3007         new_string_leaf.value = new_string_leaf.value.replace("\\\n", "")
3008
3009         return Ok(new_line)
3010
3011     def __merge_string_group(self, line: Line, string_idx: int) -> TResult[Line]:
3012         """
3013         Merges string group (i.e. set of adjacent strings) where the first
3014         string in the group is `line.leaves[string_idx]`.
3015
3016         Returns:
3017             Ok(new_line), if ALL of the validation checks found in
3018             __validate_msg(...) pass.
3019                 OR
3020             Err(CannotTransform), otherwise.
3021         """
3022         LL = line.leaves
3023
3024         is_valid_index = is_valid_index_factory(LL)
3025
3026         vresult = self.__validate_msg(line, string_idx)
3027         if isinstance(vresult, Err):
3028             return vresult
3029
3030         # If the string group is wrapped inside an Atom node, we must make sure
3031         # to later replace that Atom with our new (merged) string leaf.
3032         atom_node = LL[string_idx].parent
3033
3034         # We will place BREAK_MARK in between every two substrings that we
3035         # merge. We will then later go through our final result and use the
3036         # various instances of BREAK_MARK we find to add the right values to
3037         # the custom split map.
3038         BREAK_MARK = "@@@@@ BLACK BREAKPOINT MARKER @@@@@"
3039
3040         QUOTE = LL[string_idx].value[-1]
3041
3042         def make_naked(string: str, string_prefix: str) -> str:
3043             """Strip @string (i.e. make it a "naked" string)
3044
3045             Pre-conditions:
3046                 * assert_is_leaf_string(@string)
3047
3048             Returns:
3049                 A string that is identical to @string except that
3050                 @string_prefix has been stripped, the surrounding QUOTE
3051                 characters have been removed, and any remaining QUOTE
3052                 characters have been escaped.
3053             """
3054             assert_is_leaf_string(string)
3055
3056             RE_EVEN_BACKSLASHES = r"(?:(?<!\\)(?:\\\\)*)"
3057             naked_string = string[len(string_prefix) + 1 : -1]
3058             naked_string = re.sub(
3059                 "(" + RE_EVEN_BACKSLASHES + ")" + QUOTE, r"\1\\" + QUOTE, naked_string
3060             )
3061             return naked_string
3062
3063         # Holds the CustomSplit objects that will later be added to the custom
3064         # split map.
3065         custom_splits = []
3066
3067         # Temporary storage for the 'has_prefix' part of the CustomSplit objects.
3068         prefix_tracker = []
3069
3070         # Sets the 'prefix' variable. This is the prefix that the final merged
3071         # string will have.
3072         next_str_idx = string_idx
3073         prefix = ""
3074         while (
3075             not prefix
3076             and is_valid_index(next_str_idx)
3077             and LL[next_str_idx].type == token.STRING
3078         ):
3079             prefix = get_string_prefix(LL[next_str_idx].value)
3080             next_str_idx += 1
3081
3082         # The next loop merges the string group. The final string will be
3083         # contained in 'S'.
3084         #
3085         # The following convenience variables are used:
3086         #
3087         #   S: string
3088         #   NS: naked string
3089         #   SS: next string
3090         #   NSS: naked next string
3091         S = ""
3092         NS = ""
3093         num_of_strings = 0
3094         next_str_idx = string_idx
3095         while is_valid_index(next_str_idx) and LL[next_str_idx].type == token.STRING:
3096             num_of_strings += 1
3097
3098             SS = LL[next_str_idx].value
3099             next_prefix = get_string_prefix(SS)
3100
3101             # If this is an f-string group but this substring is not prefixed
3102             # with 'f'...
3103             if "f" in prefix and "f" not in next_prefix:
3104                 # Then we must escape any braces contained in this substring.
3105                 SS = re.subf(r"(\{|\})", "{1}{1}", SS)
3106
3107             NSS = make_naked(SS, next_prefix)
3108
3109             has_prefix = bool(next_prefix)
3110             prefix_tracker.append(has_prefix)
3111
3112             S = prefix + QUOTE + NS + NSS + BREAK_MARK + QUOTE
3113             NS = make_naked(S, prefix)
3114
3115             next_str_idx += 1
3116
3117         S_leaf = Leaf(token.STRING, S)
3118         if self.normalize_strings:
3119             normalize_string_quotes(S_leaf)
3120
3121         # Fill the 'custom_splits' list with the appropriate CustomSplit objects.
3122         temp_string = S_leaf.value[len(prefix) + 1 : -1]
3123         for has_prefix in prefix_tracker:
3124             mark_idx = temp_string.find(BREAK_MARK)
3125             assert (
3126                 mark_idx >= 0
3127             ), "Logic error while filling the custom string breakpoint cache."
3128
3129             temp_string = temp_string[mark_idx + len(BREAK_MARK) :]
3130             breakpoint_idx = mark_idx + (len(prefix) if has_prefix else 0) + 1
3131             custom_splits.append(CustomSplit(has_prefix, breakpoint_idx))
3132
3133         string_leaf = Leaf(token.STRING, S_leaf.value.replace(BREAK_MARK, ""))
3134
3135         if atom_node is not None:
3136             replace_child(atom_node, string_leaf)
3137
3138         # Build the final line ('new_line') that this method will later return.
3139         new_line = line.clone()
3140         for (i, leaf) in enumerate(LL):
3141             if i == string_idx:
3142                 new_line.append(string_leaf)
3143
3144             if string_idx <= i < string_idx + num_of_strings:
3145                 for comment_leaf in line.comments_after(LL[i]):
3146                     new_line.append(comment_leaf, preformatted=True)
3147                 continue
3148
3149             append_leaves(new_line, line, [leaf])
3150
3151         self.add_custom_splits(string_leaf.value, custom_splits)
3152         return Ok(new_line)
3153
3154     @staticmethod
3155     def __validate_msg(line: Line, string_idx: int) -> TResult[None]:
3156         """Validate (M)erge (S)tring (G)roup
3157
3158         Transform-time string validation logic for __merge_string_group(...).
3159
3160         Returns:
3161             * Ok(None), if ALL validation checks (listed below) pass.
3162                 OR
3163             * Err(CannotTransform), if any of the following are true:
3164                 - The target string is not in a string group (i.e. it has no
3165                   adjacent strings).
3166                 - The string group has more than one inline comment.
3167                 - The string group has an inline comment that appears to be a pragma.
3168                 - The set of all string prefixes in the string group is of
3169                   length greater than one and is not equal to {"", "f"}.
3170                 - The string group consists of raw strings.
3171         """
3172         num_of_inline_string_comments = 0
3173         set_of_prefixes = set()
3174         num_of_strings = 0
3175         for leaf in line.leaves[string_idx:]:
3176             if leaf.type != token.STRING:
3177                 # If the string group is trailed by a comma, we count the
3178                 # comments trailing the comma to be one of the string group's
3179                 # comments.
3180                 if leaf.type == token.COMMA and id(leaf) in line.comments:
3181                     num_of_inline_string_comments += 1
3182                 break
3183
3184             if has_triple_quotes(leaf.value):
3185                 return TErr("StringMerger does NOT merge multiline strings.")
3186
3187             num_of_strings += 1
3188             prefix = get_string_prefix(leaf.value)
3189             if "r" in prefix:
3190                 return TErr("StringMerger does NOT merge raw strings.")
3191
3192             set_of_prefixes.add(prefix)
3193
3194             if id(leaf) in line.comments:
3195                 num_of_inline_string_comments += 1
3196                 if contains_pragma_comment(line.comments[id(leaf)]):
3197                     return TErr("Cannot merge strings which have pragma comments.")
3198
3199         if num_of_strings < 2:
3200             return TErr(
3201                 f"Not enough strings to merge (num_of_strings={num_of_strings})."
3202             )
3203
3204         if num_of_inline_string_comments > 1:
3205             return TErr(
3206                 f"Too many inline string comments ({num_of_inline_string_comments})."
3207             )
3208
3209         if len(set_of_prefixes) > 1 and set_of_prefixes != {"", "f"}:
3210             return TErr(f"Too many different prefixes ({set_of_prefixes}).")
3211
3212         return Ok(None)
3213
3214
3215 class StringParenStripper(StringTransformer):
3216     """StringTransformer that strips surrounding parentheses from strings.
3217
3218     Requirements:
3219         The line contains a string which is surrounded by parentheses and:
3220             - The target string is NOT the only argument to a function call).
3221             - If the target string contains a PERCENT, the brackets are not
3222               preceeded or followed by an operator with higher precedence than
3223               PERCENT.
3224
3225     Transformations:
3226         The parentheses mentioned in the 'Requirements' section are stripped.
3227
3228     Collaborations:
3229         StringParenStripper has its own inherent usefulness, but it is also
3230         relied on to clean up the parentheses created by StringParenWrapper (in
3231         the event that they are no longer needed).
3232     """
3233
3234     def do_match(self, line: Line) -> TMatchResult:
3235         LL = line.leaves
3236
3237         is_valid_index = is_valid_index_factory(LL)
3238
3239         for (idx, leaf) in enumerate(LL):
3240             # Should be a string...
3241             if leaf.type != token.STRING:
3242                 continue
3243
3244             # Should be preceded by a non-empty LPAR...
3245             if (
3246                 not is_valid_index(idx - 1)
3247                 or LL[idx - 1].type != token.LPAR
3248                 or is_empty_lpar(LL[idx - 1])
3249             ):
3250                 continue
3251
3252             # That LPAR should NOT be preceded by a function name or a closing
3253             # bracket (which could be a function which returns a function or a
3254             # list/dictionary that contains a function)...
3255             if is_valid_index(idx - 2) and (
3256                 LL[idx - 2].type == token.NAME or LL[idx - 2].type in CLOSING_BRACKETS
3257             ):
3258                 continue
3259
3260             string_idx = idx
3261
3262             # Skip the string trailer, if one exists.
3263             string_parser = StringParser()
3264             next_idx = string_parser.parse(LL, string_idx)
3265
3266             # if the leaves in the parsed string include a PERCENT, we need to
3267             # make sure the initial LPAR is NOT preceded by an operator with
3268             # higher or equal precedence to PERCENT
3269             if is_valid_index(idx - 2):
3270                 # mypy can't quite follow unless we name this
3271                 before_lpar = LL[idx - 2]
3272                 if token.PERCENT in {leaf.type for leaf in LL[idx - 1 : next_idx]} and (
3273                     (
3274                         before_lpar.type
3275                         in {
3276                             token.STAR,
3277                             token.AT,
3278                             token.SLASH,
3279                             token.DOUBLESLASH,
3280                             token.PERCENT,
3281                             token.TILDE,
3282                             token.DOUBLESTAR,
3283                             token.AWAIT,
3284                             token.LSQB,
3285                             token.LPAR,
3286                         }
3287                     )
3288                     or (
3289                         # only unary PLUS/MINUS
3290                         before_lpar.parent
3291                         and before_lpar.parent.type == syms.factor
3292                         and (before_lpar.type in {token.PLUS, token.MINUS})
3293                     )
3294                 ):
3295                     continue
3296
3297             # Should be followed by a non-empty RPAR...
3298             if (
3299                 is_valid_index(next_idx)
3300                 and LL[next_idx].type == token.RPAR
3301                 and not is_empty_rpar(LL[next_idx])
3302             ):
3303                 # That RPAR should NOT be followed by anything with higher
3304                 # precedence than PERCENT
3305                 if is_valid_index(next_idx + 1) and LL[next_idx + 1].type in {
3306                     token.DOUBLESTAR,
3307                     token.LSQB,
3308                     token.LPAR,
3309                     token.DOT,
3310                 }:
3311                     continue
3312
3313                 return Ok(string_idx)
3314
3315         return TErr("This line has no strings wrapped in parens.")
3316
3317     def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
3318         LL = line.leaves
3319
3320         string_parser = StringParser()
3321         rpar_idx = string_parser.parse(LL, string_idx)
3322
3323         for leaf in (LL[string_idx - 1], LL[rpar_idx]):
3324             if line.comments_after(leaf):
3325                 yield TErr(
3326                     "Will not strip parentheses which have comments attached to them."
3327                 )
3328
3329         new_line = line.clone()
3330         new_line.comments = line.comments.copy()
3331
3332         append_leaves(new_line, line, LL[: string_idx - 1])
3333
3334         string_leaf = Leaf(token.STRING, LL[string_idx].value)
3335         LL[string_idx - 1].remove()
3336         replace_child(LL[string_idx], string_leaf)
3337         new_line.append(string_leaf)
3338
3339         append_leaves(
3340             new_line, line, LL[string_idx + 1 : rpar_idx] + LL[rpar_idx + 1 :]
3341         )
3342
3343         LL[rpar_idx].remove()
3344
3345         yield Ok(new_line)
3346
3347
3348 class BaseStringSplitter(StringTransformer):
3349     """
3350     Abstract class for StringTransformers which transform a Line's strings by splitting
3351     them or placing them on their own lines where necessary to avoid going over
3352     the configured line length.
3353
3354     Requirements:
3355         * The target string value is responsible for the line going over the
3356         line length limit. It follows that after all of black's other line
3357         split methods have been exhausted, this line (or one of the resulting
3358         lines after all line splits are performed) would still be over the
3359         line_length limit unless we split this string.
3360             AND
3361         * The target string is NOT a "pointless" string (i.e. a string that has
3362         no parent or siblings).
3363             AND
3364         * The target string is not followed by an inline comment that appears
3365         to be a pragma.
3366             AND
3367         * The target string is not a multiline (i.e. triple-quote) string.
3368     """
3369
3370     @abstractmethod
3371     def do_splitter_match(self, line: Line) -> TMatchResult:
3372         """
3373         BaseStringSplitter asks its clients to override this method instead of
3374         `StringTransformer.do_match(...)`.
3375
3376         Follows the same protocol as `StringTransformer.do_match(...)`.
3377
3378         Refer to `help(StringTransformer.do_match)` for more information.
3379         """
3380
3381     def do_match(self, line: Line) -> TMatchResult:
3382         match_result = self.do_splitter_match(line)
3383         if isinstance(match_result, Err):
3384             return match_result
3385
3386         string_idx = match_result.ok()
3387         vresult = self.__validate(line, string_idx)
3388         if isinstance(vresult, Err):
3389             return vresult
3390
3391         return match_result
3392
3393     def __validate(self, line: Line, string_idx: int) -> TResult[None]:
3394         """
3395         Checks that @line meets all of the requirements listed in this classes'
3396         docstring. Refer to `help(BaseStringSplitter)` for a detailed
3397         description of those requirements.
3398
3399         Returns:
3400             * Ok(None), if ALL of the requirements are met.
3401                 OR
3402             * Err(CannotTransform), if ANY of the requirements are NOT met.
3403         """
3404         LL = line.leaves
3405
3406         string_leaf = LL[string_idx]
3407
3408         max_string_length = self.__get_max_string_length(line, string_idx)
3409         if len(string_leaf.value) <= max_string_length:
3410             return TErr(
3411                 "The string itself is not what is causing this line to be too long."
3412             )
3413
3414         if not string_leaf.parent or [L.type for L in string_leaf.parent.children] == [
3415             token.STRING,
3416             token.NEWLINE,
3417         ]:
3418             return TErr(
3419                 f"This string ({string_leaf.value}) appears to be pointless (i.e. has"
3420                 " no parent)."
3421             )
3422
3423         if id(line.leaves[string_idx]) in line.comments and contains_pragma_comment(
3424             line.comments[id(line.leaves[string_idx])]
3425         ):
3426             return TErr(
3427                 "Line appears to end with an inline pragma comment. Splitting the line"
3428                 " could modify the pragma's behavior."
3429             )
3430
3431         if has_triple_quotes(string_leaf.value):
3432             return TErr("We cannot split multiline strings.")
3433
3434         return Ok(None)
3435
3436     def __get_max_string_length(self, line: Line, string_idx: int) -> int:
3437         """
3438         Calculates the max string length used when attempting to determine
3439         whether or not the target string is responsible for causing the line to
3440         go over the line length limit.
3441
3442         WARNING: This method is tightly coupled to both StringSplitter and
3443         (especially) StringParenWrapper. There is probably a better way to
3444         accomplish what is being done here.
3445
3446         Returns:
3447             max_string_length: such that `line.leaves[string_idx].value >
3448             max_string_length` implies that the target string IS responsible
3449             for causing this line to exceed the line length limit.
3450         """
3451         LL = line.leaves
3452
3453         is_valid_index = is_valid_index_factory(LL)
3454
3455         # We use the shorthand "WMA4" in comments to abbreviate "We must
3456         # account for". When giving examples, we use STRING to mean some/any
3457         # valid string.
3458         #
3459         # Finally, we use the following convenience variables:
3460         #
3461         #   P:  The leaf that is before the target string leaf.
3462         #   N:  The leaf that is after the target string leaf.
3463         #   NN: The leaf that is after N.
3464
3465         # WMA4 the whitespace at the beginning of the line.
3466         offset = line.depth * 4
3467
3468         if is_valid_index(string_idx - 1):
3469             p_idx = string_idx - 1
3470             if (
3471                 LL[string_idx - 1].type == token.LPAR
3472                 and LL[string_idx - 1].value == ""
3473                 and string_idx >= 2
3474             ):
3475                 # If the previous leaf is an empty LPAR placeholder, we should skip it.
3476                 p_idx -= 1
3477
3478             P = LL[p_idx]
3479             if P.type == token.PLUS:
3480                 # WMA4 a space and a '+' character (e.g. `+ STRING`).
3481                 offset += 2
3482
3483             if P.type == token.COMMA:
3484                 # WMA4 a space, a comma, and a closing bracket [e.g. `), STRING`].
3485                 offset += 3
3486
3487             if P.type in [token.COLON, token.EQUAL, token.NAME]:
3488                 # This conditional branch is meant to handle dictionary keys,
3489                 # variable assignments, 'return STRING' statement lines, and
3490                 # 'else STRING' ternary expression lines.
3491
3492                 # WMA4 a single space.
3493                 offset += 1
3494
3495                 # WMA4 the lengths of any leaves that came before that space.
3496                 for leaf in LL[: p_idx + 1]:
3497                     offset += len(str(leaf))
3498
3499         if is_valid_index(string_idx + 1):
3500             N = LL[string_idx + 1]
3501             if N.type == token.RPAR and N.value == "" and len(LL) > string_idx + 2:
3502                 # If the next leaf is an empty RPAR placeholder, we should skip it.
3503                 N = LL[string_idx + 2]
3504
3505             if N.type == token.COMMA:
3506                 # WMA4 a single comma at the end of the string (e.g `STRING,`).
3507                 offset += 1
3508
3509             if is_valid_index(string_idx + 2):
3510                 NN = LL[string_idx + 2]
3511
3512                 if N.type == token.DOT and NN.type == token.NAME:
3513                     # This conditional branch is meant to handle method calls invoked
3514                     # off of a string literal up to and including the LPAR character.
3515
3516                     # WMA4 the '.' character.
3517                     offset += 1
3518
3519                     if (
3520                         is_valid_index(string_idx + 3)
3521                         and LL[string_idx + 3].type == token.LPAR
3522                     ):
3523                         # WMA4 the left parenthesis character.
3524                         offset += 1
3525
3526                     # WMA4 the length of the method's name.
3527                     offset += len(NN.value)
3528
3529         has_comments = False
3530         for comment_leaf in line.comments_after(LL[string_idx]):
3531             if not has_comments:
3532                 has_comments = True
3533                 # WMA4 two spaces before the '#' character.
3534                 offset += 2
3535
3536             # WMA4 the length of the inline comment.
3537             offset += len(comment_leaf.value)
3538
3539         max_string_length = self.line_length - offset
3540         return max_string_length
3541
3542
3543 class StringSplitter(CustomSplitMapMixin, BaseStringSplitter):
3544     """
3545     StringTransformer that splits "atom" strings (i.e. strings which exist on
3546     lines by themselves).
3547
3548     Requirements:
3549         * The line consists ONLY of a single string (with the exception of a
3550         '+' symbol which MAY exist at the start of the line), MAYBE a string
3551         trailer, and MAYBE a trailing comma.
3552             AND
3553         * All of the requirements listed in BaseStringSplitter's docstring.
3554
3555     Transformations:
3556         The string mentioned in the 'Requirements' section is split into as
3557         many substrings as necessary to adhere to the configured line length.
3558
3559         In the final set of substrings, no substring should be smaller than
3560         MIN_SUBSTR_SIZE characters.
3561
3562         The string will ONLY be split on spaces (i.e. each new substring should
3563         start with a space).
3564
3565         If the string is an f-string, it will NOT be split in the middle of an
3566         f-expression (e.g. in f"FooBar: {foo() if x else bar()}", {foo() if x
3567         else bar()} is an f-expression).
3568
3569         If the string that is being split has an associated set of custom split
3570         records and those custom splits will NOT result in any line going over
3571         the configured line length, those custom splits are used. Otherwise the
3572         string is split as late as possible (from left-to-right) while still
3573         adhering to the transformation rules listed above.
3574
3575     Collaborations:
3576         StringSplitter relies on StringMerger to construct the appropriate
3577         CustomSplit objects and add them to the custom split map.
3578     """
3579
3580     MIN_SUBSTR_SIZE = 6
3581     # Matches an "f-expression" (e.g. {var}) that might be found in an f-string.
3582     RE_FEXPR = r"""
3583     (?<!\{)\{
3584         (?:
3585             [^\{\}]
3586             | \{\{
3587             | \}\}
3588         )+?
3589     (?<!\})(?:\}\})*\}(?!\})
3590     """
3591
3592     def do_splitter_match(self, line: Line) -> TMatchResult:
3593         LL = line.leaves
3594
3595         is_valid_index = is_valid_index_factory(LL)
3596
3597         idx = 0
3598
3599         # The first leaf MAY be a '+' symbol...
3600         if is_valid_index(idx) and LL[idx].type == token.PLUS:
3601             idx += 1
3602
3603         # The next/first leaf MAY be an empty LPAR...
3604         if is_valid_index(idx) and is_empty_lpar(LL[idx]):
3605             idx += 1
3606
3607         # The next/first leaf MUST be a string...
3608         if not is_valid_index(idx) or LL[idx].type != token.STRING:
3609             return TErr("Line does not start with a string.")
3610
3611         string_idx = idx
3612
3613         # Skip the string trailer, if one exists.
3614         string_parser = StringParser()
3615         idx = string_parser.parse(LL, string_idx)
3616
3617         # That string MAY be followed by an empty RPAR...
3618         if is_valid_index(idx) and is_empty_rpar(LL[idx]):
3619             idx += 1
3620
3621         # That string / empty RPAR leaf MAY be followed by a comma...
3622         if is_valid_index(idx) and LL[idx].type == token.COMMA:
3623             idx += 1
3624
3625         # But no more leaves are allowed...
3626         if is_valid_index(idx):
3627             return TErr("This line does not end with a string.")
3628
3629         return Ok(string_idx)
3630
3631     def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
3632         LL = line.leaves
3633
3634         QUOTE = LL[string_idx].value[-1]
3635
3636         is_valid_index = is_valid_index_factory(LL)
3637         insert_str_child = insert_str_child_factory(LL[string_idx])
3638
3639         prefix = get_string_prefix(LL[string_idx].value)
3640
3641         # We MAY choose to drop the 'f' prefix from substrings that don't
3642         # contain any f-expressions, but ONLY if the original f-string
3643         # contains at least one f-expression. Otherwise, we will alter the AST
3644         # of the program.
3645         drop_pointless_f_prefix = ("f" in prefix) and re.search(
3646             self.RE_FEXPR, LL[string_idx].value, re.VERBOSE
3647         )
3648
3649         first_string_line = True
3650         starts_with_plus = LL[0].type == token.PLUS
3651
3652         def line_needs_plus() -> bool:
3653             return first_string_line and starts_with_plus
3654
3655         def maybe_append_plus(new_line: Line) -> None:
3656             """
3657             Side Effects:
3658                 If @line starts with a plus and this is the first line we are
3659                 constructing, this function appends a PLUS leaf to @new_line
3660                 and replaces the old PLUS leaf in the node structure. Otherwise
3661                 this function does nothing.
3662             """
3663             if line_needs_plus():
3664                 plus_leaf = Leaf(token.PLUS, "+")
3665                 replace_child(LL[0], plus_leaf)
3666                 new_line.append(plus_leaf)
3667
3668         ends_with_comma = (
3669             is_valid_index(string_idx + 1) and LL[string_idx + 1].type == token.COMMA
3670         )
3671
3672         def max_last_string() -> int:
3673             """
3674             Returns:
3675                 The max allowed length of the string value used for the last
3676                 line we will construct.
3677             """
3678             result = self.line_length
3679             result -= line.depth * 4
3680             result -= 1 if ends_with_comma else 0
3681             result -= 2 if line_needs_plus() else 0
3682             return result
3683
3684         # --- Calculate Max Break Index (for string value)
3685         # We start with the line length limit
3686         max_break_idx = self.line_length
3687         # The last index of a string of length N is N-1.
3688         max_break_idx -= 1
3689         # Leading whitespace is not present in the string value (e.g. Leaf.value).
3690         max_break_idx -= line.depth * 4
3691         if max_break_idx < 0:
3692             yield TErr(
3693                 f"Unable to split {LL[string_idx].value} at such high of a line depth:"
3694                 f" {line.depth}"
3695             )
3696             return
3697
3698         # Check if StringMerger registered any custom splits.
3699         custom_splits = self.pop_custom_splits(LL[string_idx].value)
3700         # We use them ONLY if none of them would produce lines that exceed the
3701         # line limit.
3702         use_custom_breakpoints = bool(
3703             custom_splits
3704             and all(csplit.break_idx <= max_break_idx for csplit in custom_splits)
3705         )
3706
3707         # Temporary storage for the remaining chunk of the string line that
3708         # can't fit onto the line currently being constructed.
3709         rest_value = LL[string_idx].value
3710
3711         def more_splits_should_be_made() -> bool:
3712             """
3713             Returns:
3714                 True iff `rest_value` (the remaining string value from the last
3715                 split), should be split again.
3716             """
3717             if use_custom_breakpoints:
3718                 return len(custom_splits) > 1
3719             else:
3720                 return len(rest_value) > max_last_string()
3721
3722         string_line_results: List[Ok[Line]] = []
3723         while more_splits_should_be_made():
3724             if use_custom_breakpoints:
3725                 # Custom User Split (manual)
3726                 csplit = custom_splits.pop(0)
3727                 break_idx = csplit.break_idx
3728             else:
3729                 # Algorithmic Split (automatic)
3730                 max_bidx = max_break_idx - 2 if line_needs_plus() else max_break_idx
3731                 maybe_break_idx = self.__get_break_idx(rest_value, max_bidx)
3732                 if maybe_break_idx is None:
3733                     # If we are unable to algorithmically determine a good split
3734                     # and this string has custom splits registered to it, we
3735                     # fall back to using them--which means we have to start
3736                     # over from the beginning.
3737                     if custom_splits:
3738                         rest_value = LL[string_idx].value
3739                         string_line_results = []
3740                         first_string_line = True
3741                         use_custom_breakpoints = True
3742                         continue
3743
3744                     # Otherwise, we stop splitting here.
3745                     break
3746
3747                 break_idx = maybe_break_idx
3748
3749             # --- Construct `next_value`
3750             next_value = rest_value[:break_idx] + QUOTE
3751             if (
3752                 # Are we allowed to try to drop a pointless 'f' prefix?
3753                 drop_pointless_f_prefix
3754                 # If we are, will we be successful?
3755                 and next_value != self.__normalize_f_string(next_value, prefix)
3756             ):
3757                 # If the current custom split did NOT originally use a prefix,
3758                 # then `csplit.break_idx` will be off by one after removing
3759                 # the 'f' prefix.
3760                 break_idx = (
3761                     break_idx + 1
3762                     if use_custom_breakpoints and not csplit.has_prefix
3763                     else break_idx
3764                 )
3765                 next_value = rest_value[:break_idx] + QUOTE
3766                 next_value = self.__normalize_f_string(next_value, prefix)
3767
3768             # --- Construct `next_leaf`
3769             next_leaf = Leaf(token.STRING, next_value)
3770             insert_str_child(next_leaf)
3771             self.__maybe_normalize_string_quotes(next_leaf)
3772
3773             # --- Construct `next_line`
3774             next_line = line.clone()
3775             maybe_append_plus(next_line)
3776             next_line.append(next_leaf)
3777             string_line_results.append(Ok(next_line))
3778
3779             rest_value = prefix + QUOTE + rest_value[break_idx:]
3780             first_string_line = False
3781
3782         yield from string_line_results
3783
3784         if drop_pointless_f_prefix:
3785             rest_value = self.__normalize_f_string(rest_value, prefix)
3786
3787         rest_leaf = Leaf(token.STRING, rest_value)
3788         insert_str_child(rest_leaf)
3789
3790         # NOTE: I could not find a test case that verifies that the following
3791         # line is actually necessary, but it seems to be. Otherwise we risk
3792         # not normalizing the last substring, right?
3793         self.__maybe_normalize_string_quotes(rest_leaf)
3794
3795         last_line = line.clone()
3796         maybe_append_plus(last_line)
3797
3798         # If there are any leaves to the right of the target string...
3799         if is_valid_index(string_idx + 1):
3800             # We use `temp_value` here to determine how long the last line
3801             # would be if we were to append all the leaves to the right of the
3802             # target string to the last string line.
3803             temp_value = rest_value
3804             for leaf in LL[string_idx + 1 :]:
3805                 temp_value += str(leaf)
3806                 if leaf.type == token.LPAR:
3807                     break
3808
3809             # Try to fit them all on the same line with the last substring...
3810             if (
3811                 len(temp_value) <= max_last_string()
3812                 or LL[string_idx + 1].type == token.COMMA
3813             ):
3814                 last_line.append(rest_leaf)
3815                 append_leaves(last_line, line, LL[string_idx + 1 :])
3816                 yield Ok(last_line)
3817             # Otherwise, place the last substring on one line and everything
3818             # else on a line below that...
3819             else:
3820                 last_line.append(rest_leaf)
3821                 yield Ok(last_line)
3822
3823                 non_string_line = line.clone()
3824                 append_leaves(non_string_line, line, LL[string_idx + 1 :])
3825                 yield Ok(non_string_line)
3826         # Else the target string was the last leaf...
3827         else:
3828             last_line.append(rest_leaf)
3829             last_line.comments = line.comments.copy()
3830             yield Ok(last_line)
3831
3832     def __get_break_idx(self, string: str, max_break_idx: int) -> Optional[int]:
3833         """
3834         This method contains the algorithm that StringSplitter uses to
3835         determine which character to split each string at.
3836
3837         Args:
3838             @string: The substring that we are attempting to split.
3839             @max_break_idx: The ideal break index. We will return this value if it
3840             meets all the necessary conditions. In the likely event that it
3841             doesn't we will try to find the closest index BELOW @max_break_idx
3842             that does. If that fails, we will expand our search by also
3843             considering all valid indices ABOVE @max_break_idx.
3844
3845         Pre-Conditions:
3846             * assert_is_leaf_string(@string)
3847             * 0 <= @max_break_idx < len(@string)
3848
3849         Returns:
3850             break_idx, if an index is able to be found that meets all of the
3851             conditions listed in the 'Transformations' section of this classes'
3852             docstring.
3853                 OR
3854             None, otherwise.
3855         """
3856         is_valid_index = is_valid_index_factory(string)
3857
3858         assert is_valid_index(max_break_idx)
3859         assert_is_leaf_string(string)
3860
3861         _fexpr_slices: Optional[List[Tuple[Index, Index]]] = None
3862
3863         def fexpr_slices() -> Iterator[Tuple[Index, Index]]:
3864             """
3865             Yields:
3866                 All ranges of @string which, if @string were to be split there,
3867                 would result in the splitting of an f-expression (which is NOT
3868                 allowed).
3869             """
3870             nonlocal _fexpr_slices
3871
3872             if _fexpr_slices is None:
3873                 _fexpr_slices = []
3874                 for match in re.finditer(self.RE_FEXPR, string, re.VERBOSE):
3875                     _fexpr_slices.append(match.span())
3876
3877             yield from _fexpr_slices
3878
3879         is_fstring = "f" in get_string_prefix(string)
3880
3881         def breaks_fstring_expression(i: Index) -> bool:
3882             """
3883             Returns:
3884                 True iff returning @i would result in the splitting of an
3885                 f-expression (which is NOT allowed).
3886             """
3887             if not is_fstring:
3888                 return False
3889
3890             for (start, end) in fexpr_slices():
3891                 if start <= i < end:
3892                     return True
3893
3894             return False
3895
3896         def passes_all_checks(i: Index) -> bool:
3897             """
3898             Returns:
3899                 True iff ALL of the conditions listed in the 'Transformations'
3900                 section of this classes' docstring would be be met by returning @i.
3901             """
3902             is_space = string[i] == " "
3903             is_big_enough = (
3904                 len(string[i:]) >= self.MIN_SUBSTR_SIZE
3905                 and len(string[:i]) >= self.MIN_SUBSTR_SIZE
3906             )
3907             return is_space and is_big_enough and not breaks_fstring_expression(i)
3908
3909         # First, we check all indices BELOW @max_break_idx.
3910         break_idx = max_break_idx
3911         while is_valid_index(break_idx - 1) and not passes_all_checks(break_idx):
3912             break_idx -= 1
3913
3914         if not passes_all_checks(break_idx):
3915             # If that fails, we check all indices ABOVE @max_break_idx.
3916             #
3917             # If we are able to find a valid index here, the next line is going
3918             # to be longer than the specified line length, but it's probably
3919             # better than doing nothing at all.
3920             break_idx = max_break_idx + 1
3921             while is_valid_index(break_idx + 1) and not passes_all_checks(break_idx):
3922                 break_idx += 1
3923
3924             if not is_valid_index(break_idx) or not passes_all_checks(break_idx):
3925                 return None
3926
3927         return break_idx
3928
3929     def __maybe_normalize_string_quotes(self, leaf: Leaf) -> None:
3930         if self.normalize_strings:
3931             normalize_string_quotes(leaf)
3932
3933     def __normalize_f_string(self, string: str, prefix: str) -> str:
3934         """
3935         Pre-Conditions:
3936             * assert_is_leaf_string(@string)
3937
3938         Returns:
3939             * If @string is an f-string that contains no f-expressions, we
3940             return a string identical to @string except that the 'f' prefix
3941             has been stripped and all double braces (i.e. '{{' or '}}') have
3942             been normalized (i.e. turned into '{' or '}').
3943                 OR
3944             * Otherwise, we return @string.
3945         """
3946         assert_is_leaf_string(string)
3947
3948         if "f" in prefix and not re.search(self.RE_FEXPR, string, re.VERBOSE):
3949             new_prefix = prefix.replace("f", "")
3950
3951             temp = string[len(prefix) :]
3952             temp = re.sub(r"\{\{", "{", temp)
3953             temp = re.sub(r"\}\}", "}", temp)
3954             new_string = temp
3955
3956             return f"{new_prefix}{new_string}"
3957         else:
3958             return string
3959
3960
3961 class StringParenWrapper(CustomSplitMapMixin, BaseStringSplitter):
3962     """
3963     StringTransformer that splits non-"atom" strings (i.e. strings that do not
3964     exist on lines by themselves).
3965
3966     Requirements:
3967         All of the requirements listed in BaseStringSplitter's docstring in
3968         addition to the requirements listed below:
3969
3970         * The line is a return/yield statement, which returns/yields a string.
3971             OR
3972         * The line is part of a ternary expression (e.g. `x = y if cond else
3973         z`) such that the line starts with `else <string>`, where <string> is
3974         some string.
3975             OR
3976         * The line is an assert statement, which ends with a string.
3977             OR
3978         * The line is an assignment statement (e.g. `x = <string>` or `x +=
3979         <string>`) such that the variable is being assigned the value of some
3980         string.
3981             OR
3982         * The line is a dictionary key assignment where some valid key is being
3983         assigned the value of some string.
3984
3985     Transformations:
3986         The chosen string is wrapped in parentheses and then split at the LPAR.
3987
3988         We then have one line which ends with an LPAR and another line that
3989         starts with the chosen string. The latter line is then split again at
3990         the RPAR. This results in the RPAR (and possibly a trailing comma)
3991         being placed on its own line.
3992
3993         NOTE: If any leaves exist to the right of the chosen string (except
3994         for a trailing comma, which would be placed after the RPAR), those
3995         leaves are placed inside the parentheses.  In effect, the chosen
3996         string is not necessarily being "wrapped" by parentheses. We can,
3997         however, count on the LPAR being placed directly before the chosen
3998         string.
3999
4000         In other words, StringParenWrapper creates "atom" strings. These
4001         can then be split again by StringSplitter, if necessary.
4002
4003     Collaborations:
4004         In the event that a string line split by StringParenWrapper is
4005         changed such that it no longer needs to be given its own line,
4006         StringParenWrapper relies on StringParenStripper to clean up the
4007         parentheses it created.
4008     """
4009
4010     def do_splitter_match(self, line: Line) -> TMatchResult:
4011         LL = line.leaves
4012
4013         string_idx = None
4014         string_idx = string_idx or self._return_match(LL)
4015         string_idx = string_idx or self._else_match(LL)
4016         string_idx = string_idx or self._assert_match(LL)
4017         string_idx = string_idx or self._assign_match(LL)
4018         string_idx = string_idx or self._dict_match(LL)
4019
4020         if string_idx is not None:
4021             string_value = line.leaves[string_idx].value
4022             # If the string has no spaces...
4023             if " " not in string_value:
4024                 # And will still violate the line length limit when split...
4025                 max_string_length = self.line_length - ((line.depth + 1) * 4)
4026                 if len(string_value) > max_string_length:
4027                     # And has no associated custom splits...
4028                     if not self.has_custom_splits(string_value):
4029                         # Then we should NOT put this string on its own line.
4030                         return TErr(
4031                             "We do not wrap long strings in parentheses when the"
4032                             " resultant line would still be over the specified line"
4033                             " length and can't be split further by StringSplitter."
4034                         )
4035             return Ok(string_idx)
4036
4037         return TErr("This line does not contain any non-atomic strings.")
4038
4039     @staticmethod
4040     def _return_match(LL: List[Leaf]) -> Optional[int]:
4041         """
4042         Returns:
4043             string_idx such that @LL[string_idx] is equal to our target (i.e.
4044             matched) string, if this line matches the return/yield statement
4045             requirements listed in the 'Requirements' section of this classes'
4046             docstring.
4047                 OR
4048             None, otherwise.
4049         """
4050         # If this line is apart of a return/yield statement and the first leaf
4051         # contains either the "return" or "yield" keywords...
4052         if parent_type(LL[0]) in [syms.return_stmt, syms.yield_expr] and LL[
4053             0
4054         ].value in ["return", "yield"]:
4055             is_valid_index = is_valid_index_factory(LL)
4056
4057             idx = 2 if is_valid_index(1) and is_empty_par(LL[1]) else 1
4058             # The next visible leaf MUST contain a string...
4059             if is_valid_index(idx) and LL[idx].type == token.STRING:
4060                 return idx
4061
4062         return None
4063
4064     @staticmethod
4065     def _else_match(LL: List[Leaf]) -> Optional[int]:
4066         """
4067         Returns:
4068             string_idx such that @LL[string_idx] is equal to our target (i.e.
4069             matched) string, if this line matches the ternary expression
4070             requirements listed in the 'Requirements' section of this classes'
4071             docstring.
4072                 OR
4073             None, otherwise.
4074         """
4075         # If this line is apart of a ternary expression and the first leaf
4076         # contains the "else" keyword...
4077         if (
4078             parent_type(LL[0]) == syms.test
4079             and LL[0].type == token.NAME
4080             and LL[0].value == "else"
4081         ):
4082             is_valid_index = is_valid_index_factory(LL)
4083
4084             idx = 2 if is_valid_index(1) and is_empty_par(LL[1]) else 1
4085             # The next visible leaf MUST contain a string...
4086             if is_valid_index(idx) and LL[idx].type == token.STRING:
4087                 return idx
4088
4089         return None
4090
4091     @staticmethod
4092     def _assert_match(LL: List[Leaf]) -> Optional[int]:
4093         """
4094         Returns:
4095             string_idx such that @LL[string_idx] is equal to our target (i.e.
4096             matched) string, if this line matches the assert statement
4097             requirements listed in the 'Requirements' section of this classes'
4098             docstring.
4099                 OR
4100             None, otherwise.
4101         """
4102         # If this line is apart of an assert statement and the first leaf
4103         # contains the "assert" keyword...
4104         if parent_type(LL[0]) == syms.assert_stmt and LL[0].value == "assert":
4105             is_valid_index = is_valid_index_factory(LL)
4106
4107             for (i, leaf) in enumerate(LL):
4108                 # We MUST find a comma...
4109                 if leaf.type == token.COMMA:
4110                     idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
4111
4112                     # That comma MUST be followed by a string...
4113                     if is_valid_index(idx) and LL[idx].type == token.STRING:
4114                         string_idx = idx
4115
4116                         # Skip the string trailer, if one exists.
4117                         string_parser = StringParser()
4118                         idx = string_parser.parse(LL, string_idx)
4119
4120                         # But no more leaves are allowed...
4121                         if not is_valid_index(idx):
4122                             return string_idx
4123
4124         return None
4125
4126     @staticmethod
4127     def _assign_match(LL: List[Leaf]) -> Optional[int]:
4128         """
4129         Returns:
4130             string_idx such that @LL[string_idx] is equal to our target (i.e.
4131             matched) string, if this line matches the assignment statement
4132             requirements listed in the 'Requirements' section of this classes'
4133             docstring.
4134                 OR
4135             None, otherwise.
4136         """
4137         # If this line is apart of an expression statement or is a function
4138         # argument AND the first leaf contains a variable name...
4139         if (
4140             parent_type(LL[0]) in [syms.expr_stmt, syms.argument, syms.power]
4141             and LL[0].type == token.NAME
4142         ):
4143             is_valid_index = is_valid_index_factory(LL)
4144
4145             for (i, leaf) in enumerate(LL):
4146                 # We MUST find either an '=' or '+=' symbol...
4147                 if leaf.type in [token.EQUAL, token.PLUSEQUAL]:
4148                     idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
4149
4150                     # That symbol MUST be followed by a string...
4151                     if is_valid_index(idx) and LL[idx].type == token.STRING:
4152                         string_idx = idx
4153
4154                         # Skip the string trailer, if one exists.
4155                         string_parser = StringParser()
4156                         idx = string_parser.parse(LL, string_idx)
4157
4158                         # The next leaf MAY be a comma iff this line is apart
4159                         # of a function argument...
4160                         if (
4161                             parent_type(LL[0]) == syms.argument
4162                             and is_valid_index(idx)
4163                             and LL[idx].type == token.COMMA
4164                         ):
4165                             idx += 1
4166
4167                         # But no more leaves are allowed...
4168                         if not is_valid_index(idx):
4169                             return string_idx
4170
4171         return None
4172
4173     @staticmethod
4174     def _dict_match(LL: List[Leaf]) -> Optional[int]:
4175         """
4176         Returns:
4177             string_idx such that @LL[string_idx] is equal to our target (i.e.
4178             matched) string, if this line matches the dictionary key assignment
4179             statement requirements listed in the 'Requirements' section of this
4180             classes' docstring.
4181                 OR
4182             None, otherwise.
4183         """
4184         # If this line is apart of a dictionary key assignment...
4185         if syms.dictsetmaker in [parent_type(LL[0]), parent_type(LL[0].parent)]:
4186             is_valid_index = is_valid_index_factory(LL)
4187
4188             for (i, leaf) in enumerate(LL):
4189                 # We MUST find a colon...
4190                 if leaf.type == token.COLON:
4191                     idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1
4192
4193                     # That colon MUST be followed by a string...
4194                     if is_valid_index(idx) and LL[idx].type == token.STRING:
4195                         string_idx = idx
4196
4197                         # Skip the string trailer, if one exists.
4198                         string_parser = StringParser()
4199                         idx = string_parser.parse(LL, string_idx)
4200
4201                         # That string MAY be followed by a comma...
4202                         if is_valid_index(idx) and LL[idx].type == token.COMMA:
4203                             idx += 1
4204
4205                         # But no more leaves are allowed...
4206                         if not is_valid_index(idx):
4207                             return string_idx
4208
4209         return None
4210
4211     def do_transform(self, line: Line, string_idx: int) -> Iterator[TResult[Line]]:
4212         LL = line.leaves
4213
4214         is_valid_index = is_valid_index_factory(LL)
4215         insert_str_child = insert_str_child_factory(LL[string_idx])
4216
4217         comma_idx = len(LL) - 1
4218         ends_with_comma = False
4219         if LL[comma_idx].type == token.COMMA:
4220             ends_with_comma = True
4221
4222         leaves_to_steal_comments_from = [LL[string_idx]]
4223         if ends_with_comma:
4224             leaves_to_steal_comments_from.append(LL[comma_idx])
4225
4226         # --- First Line
4227         first_line = line.clone()
4228         left_leaves = LL[:string_idx]
4229
4230         # We have to remember to account for (possibly invisible) LPAR and RPAR
4231         # leaves that already wrapped the target string. If these leaves do
4232         # exist, we will replace them with our own LPAR and RPAR leaves.
4233         old_parens_exist = False
4234         if left_leaves and left_leaves[-1].type == token.LPAR:
4235             old_parens_exist = True
4236             leaves_to_steal_comments_from.append(left_leaves[-1])
4237             left_leaves.pop()
4238
4239         append_leaves(first_line, line, left_leaves)
4240
4241         lpar_leaf = Leaf(token.LPAR, "(")
4242         if old_parens_exist:
4243             replace_child(LL[string_idx - 1], lpar_leaf)
4244         else:
4245             insert_str_child(lpar_leaf)
4246         first_line.append(lpar_leaf)
4247
4248         # We throw inline comments that were originally to the right of the
4249         # target string to the top line. They will now be shown to the right of
4250         # the LPAR.
4251         for leaf in leaves_to_steal_comments_from:
4252             for comment_leaf in line.comments_after(leaf):
4253                 first_line.append(comment_leaf, preformatted=True)
4254
4255         yield Ok(first_line)
4256
4257         # --- Middle (String) Line
4258         # We only need to yield one (possibly too long) string line, since the
4259         # `StringSplitter` will break it down further if necessary.
4260         string_value = LL[string_idx].value
4261         string_line = Line(
4262             depth=line.depth + 1,
4263             inside_brackets=True,
4264             should_explode=line.should_explode,
4265         )
4266         string_leaf = Leaf(token.STRING, string_value)
4267         insert_str_child(string_leaf)
4268         string_line.append(string_leaf)
4269
4270         old_rpar_leaf = None
4271         if is_valid_index(string_idx + 1):
4272             right_leaves = LL[string_idx + 1 :]
4273             if ends_with_comma:
4274                 right_leaves.pop()
4275
4276             if old_parens_exist:
4277                 assert (
4278                     right_leaves and right_leaves[-1].type == token.RPAR
4279                 ), "Apparently, old parentheses do NOT exist?!"
4280                 old_rpar_leaf = right_leaves.pop()
4281
4282             append_leaves(string_line, line, right_leaves)
4283
4284         yield Ok(string_line)
4285
4286         # --- Last Line
4287         last_line = line.clone()
4288         last_line.bracket_tracker = first_line.bracket_tracker
4289
4290         new_rpar_leaf = Leaf(token.RPAR, ")")
4291         if old_rpar_leaf is not None:
4292             replace_child(old_rpar_leaf, new_rpar_leaf)
4293         else:
4294             insert_str_child(new_rpar_leaf)
4295         last_line.append(new_rpar_leaf)
4296
4297         # If the target string ended with a comma, we place this comma to the
4298         # right of the RPAR on the last line.
4299         if ends_with_comma:
4300             comma_leaf = Leaf(token.COMMA, ",")
4301             replace_child(LL[comma_idx], comma_leaf)
4302             last_line.append(comma_leaf)
4303
4304         yield Ok(last_line)
4305
4306
4307 class StringParser:
4308     """
4309     A state machine that aids in parsing a string's "trailer", which can be
4310     either non-existent, an old-style formatting sequence (e.g. `% varX` or `%
4311     (varX, varY)`), or a method-call / attribute access (e.g. `.format(varX,
4312     varY)`).
4313
4314     NOTE: A new StringParser object MUST be instantiated for each string
4315     trailer we need to parse.
4316
4317     Examples:
4318         We shall assume that `line` equals the `Line` object that corresponds
4319         to the following line of python code:
4320         ```
4321         x = "Some {}.".format("String") + some_other_string
4322         ```
4323
4324         Furthermore, we will assume that `string_idx` is some index such that:
4325         ```
4326         assert line.leaves[string_idx].value == "Some {}."
4327         ```
4328
4329         The following code snippet then holds:
4330         ```
4331         string_parser = StringParser()
4332         idx = string_parser.parse(line.leaves, string_idx)
4333         assert line.leaves[idx].type == token.PLUS
4334         ```
4335     """
4336
4337     DEFAULT_TOKEN = -1
4338
4339     # String Parser States
4340     START = 1
4341     DOT = 2
4342     NAME = 3
4343     PERCENT = 4
4344     SINGLE_FMT_ARG = 5
4345     LPAR = 6
4346     RPAR = 7
4347     DONE = 8
4348
4349     # Lookup Table for Next State
4350     _goto: Dict[Tuple[ParserState, NodeType], ParserState] = {
4351         # A string trailer may start with '.' OR '%'.
4352         (START, token.DOT): DOT,
4353         (START, token.PERCENT): PERCENT,
4354         (START, DEFAULT_TOKEN): DONE,
4355         # A '.' MUST be followed by an attribute or method name.
4356         (DOT, token.NAME): NAME,
4357         # A method name MUST be followed by an '(', whereas an attribute name
4358         # is the last symbol in the string trailer.
4359         (NAME, token.LPAR): LPAR,
4360         (NAME, DEFAULT_TOKEN): DONE,
4361         # A '%' symbol can be followed by an '(' or a single argument (e.g. a
4362         # string or variable name).
4363         (PERCENT, token.LPAR): LPAR,
4364         (PERCENT, DEFAULT_TOKEN): SINGLE_FMT_ARG,
4365         # If a '%' symbol is followed by a single argument, that argument is
4366         # the last leaf in the string trailer.
4367         (SINGLE_FMT_ARG, DEFAULT_TOKEN): DONE,
4368         # If present, a ')' symbol is the last symbol in a string trailer.
4369         # (NOTE: LPARS and nested RPARS are not included in this lookup table,
4370         # since they are treated as a special case by the parsing logic in this
4371         # classes' implementation.)
4372         (RPAR, DEFAULT_TOKEN): DONE,
4373     }
4374
4375     def __init__(self) -> None:
4376         self._state = self.START
4377         self._unmatched_lpars = 0
4378
4379     def parse(self, leaves: List[Leaf], string_idx: int) -> int:
4380         """
4381         Pre-conditions:
4382             * @leaves[@string_idx].type == token.STRING
4383
4384         Returns:
4385             The index directly after the last leaf which is apart of the string
4386             trailer, if a "trailer" exists.
4387                 OR
4388             @string_idx + 1, if no string "trailer" exists.
4389         """
4390         assert leaves[string_idx].type == token.STRING
4391
4392         idx = string_idx + 1
4393         while idx < len(leaves) and self._next_state(leaves[idx]):
4394             idx += 1
4395         return idx
4396
4397     def _next_state(self, leaf: Leaf) -> bool:
4398         """
4399         Pre-conditions:
4400             * On the first call to this function, @leaf MUST be the leaf that
4401             was directly after the string leaf in question (e.g. if our target
4402             string is `line.leaves[i]` then the first call to this method must
4403             be `line.leaves[i + 1]`).
4404             * On the next call to this function, the leaf parameter passed in
4405             MUST be the leaf directly following @leaf.
4406
4407         Returns:
4408             True iff @leaf is apart of the string's trailer.
4409         """
4410         # We ignore empty LPAR or RPAR leaves.
4411         if is_empty_par(leaf):
4412             return True
4413
4414         next_token = leaf.type
4415         if next_token == token.LPAR:
4416             self._unmatched_lpars += 1
4417
4418         current_state = self._state
4419
4420         # The LPAR parser state is a special case. We will return True until we
4421         # find the matching RPAR token.
4422         if current_state == self.LPAR:
4423             if next_token == token.RPAR:
4424                 self._unmatched_lpars -= 1
4425                 if self._unmatched_lpars == 0:
4426                     self._state = self.RPAR
4427         # Otherwise, we use a lookup table to determine the next state.
4428         else:
4429             # If the lookup table matches the current state to the next
4430             # token, we use the lookup table.
4431             if (current_state, next_token) in self._goto:
4432                 self._state = self._goto[current_state, next_token]
4433             else:
4434                 # Otherwise, we check if a the current state was assigned a
4435                 # default.
4436                 if (current_state, self.DEFAULT_TOKEN) in self._goto:
4437                     self._state = self._goto[current_state, self.DEFAULT_TOKEN]
4438                 # If no default has been assigned, then this parser has a logic
4439                 # error.
4440                 else:
4441                     raise RuntimeError(f"{self.__class__.__name__} LOGIC ERROR!")
4442
4443             if self._state == self.DONE:
4444                 return False
4445
4446         return True
4447
4448
4449 def TErr(err_msg: str) -> Err[CannotTransform]:
4450     """(T)ransform Err
4451
4452     Convenience function used when working with the TResult type.
4453     """
4454     cant_transform = CannotTransform(err_msg)
4455     return Err(cant_transform)
4456
4457
4458 def contains_pragma_comment(comment_list: List[Leaf]) -> bool:
4459     """
4460     Returns:
4461         True iff one of the comments in @comment_list is a pragma used by one
4462         of the more common static analysis tools for python (e.g. mypy, flake8,
4463         pylint).
4464     """
4465     for comment in comment_list:
4466         if comment.value.startswith(("# type:", "# noqa", "# pylint:")):
4467             return True
4468
4469     return False
4470
4471
4472 def insert_str_child_factory(string_leaf: Leaf) -> Callable[[LN], None]:
4473     """
4474     Factory for a convenience function that is used to orphan @string_leaf
4475     and then insert multiple new leaves into the same part of the node
4476     structure that @string_leaf had originally occupied.
4477
4478     Examples:
4479         Let `string_leaf = Leaf(token.STRING, '"foo"')` and `N =
4480         string_leaf.parent`. Assume the node `N` has the following
4481         original structure:
4482
4483         Node(
4484             expr_stmt, [
4485                 Leaf(NAME, 'x'),
4486                 Leaf(EQUAL, '='),
4487                 Leaf(STRING, '"foo"'),
4488             ]
4489         )
4490
4491         We then run the code snippet shown below.
4492         ```
4493         insert_str_child = insert_str_child_factory(string_leaf)
4494
4495         lpar = Leaf(token.LPAR, '(')
4496         insert_str_child(lpar)
4497
4498         bar = Leaf(token.STRING, '"bar"')
4499         insert_str_child(bar)
4500
4501         rpar = Leaf(token.RPAR, ')')
4502         insert_str_child(rpar)
4503         ```
4504
4505         After which point, it follows that `string_leaf.parent is None` and
4506         the node `N` now has the following structure:
4507
4508         Node(
4509             expr_stmt, [
4510                 Leaf(NAME, 'x'),
4511                 Leaf(EQUAL, '='),
4512                 Leaf(LPAR, '('),
4513                 Leaf(STRING, '"bar"'),
4514                 Leaf(RPAR, ')'),
4515             ]
4516         )
4517     """
4518     string_parent = string_leaf.parent
4519     string_child_idx = string_leaf.remove()
4520
4521     def insert_str_child(child: LN) -> None:
4522         nonlocal string_child_idx
4523
4524         assert string_parent is not None
4525         assert string_child_idx is not None
4526
4527         string_parent.insert_child(string_child_idx, child)
4528         string_child_idx += 1
4529
4530     return insert_str_child
4531
4532
4533 def has_triple_quotes(string: str) -> bool:
4534     """
4535     Returns:
4536         True iff @string starts with three quotation characters.
4537     """
4538     raw_string = string.lstrip(STRING_PREFIX_CHARS)
4539     return raw_string[:3] in {'"""', "'''"}
4540
4541
4542 def parent_type(node: Optional[LN]) -> Optional[NodeType]:
4543     """
4544     Returns:
4545         @node.parent.type, if @node is not None and has a parent.
4546             OR
4547         None, otherwise.
4548     """
4549     if node is None or node.parent is None:
4550         return None
4551
4552     return node.parent.type
4553
4554
4555 def is_empty_par(leaf: Leaf) -> bool:
4556     return is_empty_lpar(leaf) or is_empty_rpar(leaf)
4557
4558
4559 def is_empty_lpar(leaf: Leaf) -> bool:
4560     return leaf.type == token.LPAR and leaf.value == ""
4561
4562
4563 def is_empty_rpar(leaf: Leaf) -> bool:
4564     return leaf.type == token.RPAR and leaf.value == ""
4565
4566
4567 def is_valid_index_factory(seq: Sequence[Any]) -> Callable[[int], bool]:
4568     """
4569     Examples:
4570         ```
4571         my_list = [1, 2, 3]
4572
4573         is_valid_index = is_valid_index_factory(my_list)
4574
4575         assert is_valid_index(0)
4576         assert is_valid_index(2)
4577
4578         assert not is_valid_index(3)
4579         assert not is_valid_index(-1)
4580         ```
4581     """
4582
4583     def is_valid_index(idx: int) -> bool:
4584         """
4585         Returns:
4586             True iff @idx is positive AND seq[@idx] does NOT raise an
4587             IndexError.
4588         """
4589         return 0 <= idx < len(seq)
4590
4591     return is_valid_index
4592
4593
4594 def line_to_string(line: Line) -> str:
4595     """Returns the string representation of @line.
4596
4597     WARNING: This is known to be computationally expensive.
4598     """
4599     return str(line).strip("\n")
4600
4601
4602 def append_leaves(new_line: Line, old_line: Line, leaves: List[Leaf]) -> None:
4603     """
4604     Append leaves (taken from @old_line) to @new_line, making sure to fix the
4605     underlying Node structure where appropriate.
4606
4607     All of the leaves in @leaves are duplicated. The duplicates are then
4608     appended to @new_line and used to replace their originals in the underlying
4609     Node structure. Any comments attached to the old leaves are reattached to
4610     the new leaves.
4611
4612     Pre-conditions:
4613         set(@leaves) is a subset of set(@old_line.leaves).
4614     """
4615     for old_leaf in leaves:
4616         new_leaf = Leaf(old_leaf.type, old_leaf.value)
4617         replace_child(old_leaf, new_leaf)
4618         new_line.append(new_leaf)
4619
4620         for comment_leaf in old_line.comments_after(old_leaf):
4621             new_line.append(comment_leaf, preformatted=True)
4622
4623
4624 def replace_child(old_child: LN, new_child: LN) -> None:
4625     """
4626     Side Effects:
4627         * If @old_child.parent is set, replace @old_child with @new_child in
4628         @old_child's underlying Node structure.
4629             OR
4630         * Otherwise, this function does nothing.
4631     """
4632     parent = old_child.parent
4633     if not parent:
4634         return
4635
4636     child_idx = old_child.remove()
4637     if child_idx is not None:
4638         parent.insert_child(child_idx, new_child)
4639
4640
4641 def get_string_prefix(string: str) -> str:
4642     """
4643     Pre-conditions:
4644         * assert_is_leaf_string(@string)
4645
4646     Returns:
4647         @string's prefix (e.g. '', 'r', 'f', or 'rf').
4648     """
4649     assert_is_leaf_string(string)
4650
4651     prefix = ""
4652     prefix_idx = 0
4653     while string[prefix_idx] in STRING_PREFIX_CHARS:
4654         prefix += string[prefix_idx].lower()
4655         prefix_idx += 1
4656
4657     return prefix
4658
4659
4660 def assert_is_leaf_string(string: str) -> None:
4661     """
4662     Checks the pre-condition that @string has the format that you would expect
4663     of `leaf.value` where `leaf` is some Leaf such that `leaf.type ==
4664     token.STRING`. A more precise description of the pre-conditions that are
4665     checked are listed below.
4666
4667     Pre-conditions:
4668         * @string starts with either ', ", <prefix>', or <prefix>" where
4669         `set(<prefix>)` is some subset of `set(STRING_PREFIX_CHARS)`.
4670         * @string ends with a quote character (' or ").
4671
4672     Raises:
4673         AssertionError(...) if the pre-conditions listed above are not
4674         satisfied.
4675     """
4676     dquote_idx = string.find('"')
4677     squote_idx = string.find("'")
4678     if -1 in [dquote_idx, squote_idx]:
4679         quote_idx = max(dquote_idx, squote_idx)
4680     else:
4681         quote_idx = min(squote_idx, dquote_idx)
4682
4683     assert (
4684         0 <= quote_idx < len(string) - 1
4685     ), f"{string!r} is missing a starting quote character (' or \")."
4686     assert string[-1] in (
4687         "'",
4688         '"',
4689     ), f"{string!r} is missing an ending quote character (' or \")."
4690     assert set(string[:quote_idx]).issubset(
4691         set(STRING_PREFIX_CHARS)
4692     ), f"{set(string[:quote_idx])} is NOT a subset of {set(STRING_PREFIX_CHARS)}."
4693
4694
4695 def left_hand_split(line: Line, _features: Collection[Feature] = ()) -> Iterator[Line]:
4696     """Split line into many lines, starting with the first matching bracket pair.
4697
4698     Note: this usually looks weird, only use this for function definitions.
4699     Prefer RHS otherwise.  This is why this function is not symmetrical with
4700     :func:`right_hand_split` which also handles optional parentheses.
4701     """
4702     tail_leaves: List[Leaf] = []
4703     body_leaves: List[Leaf] = []
4704     head_leaves: List[Leaf] = []
4705     current_leaves = head_leaves
4706     matching_bracket: Optional[Leaf] = None
4707     for leaf in line.leaves:
4708         if (
4709             current_leaves is body_leaves
4710             and leaf.type in CLOSING_BRACKETS
4711             and leaf.opening_bracket is matching_bracket
4712         ):
4713             current_leaves = tail_leaves if body_leaves else head_leaves
4714         current_leaves.append(leaf)
4715         if current_leaves is head_leaves:
4716             if leaf.type in OPENING_BRACKETS:
4717                 matching_bracket = leaf
4718                 current_leaves = body_leaves
4719     if not matching_bracket:
4720         raise CannotSplit("No brackets found")
4721
4722     head = bracket_split_build_line(head_leaves, line, matching_bracket)
4723     body = bracket_split_build_line(body_leaves, line, matching_bracket, is_body=True)
4724     tail = bracket_split_build_line(tail_leaves, line, matching_bracket)
4725     bracket_split_succeeded_or_raise(head, body, tail)
4726     for result in (head, body, tail):
4727         if result:
4728             yield result
4729
4730
4731 def right_hand_split(
4732     line: Line,
4733     line_length: int,
4734     features: Collection[Feature] = (),
4735     omit: Collection[LeafID] = (),
4736 ) -> Iterator[Line]:
4737     """Split line into many lines, starting with the last matching bracket pair.
4738
4739     If the split was by optional parentheses, attempt splitting without them, too.
4740     `omit` is a collection of closing bracket IDs that shouldn't be considered for
4741     this split.
4742
4743     Note: running this function modifies `bracket_depth` on the leaves of `line`.
4744     """
4745     tail_leaves: List[Leaf] = []
4746     body_leaves: List[Leaf] = []
4747     head_leaves: List[Leaf] = []
4748     current_leaves = tail_leaves
4749     opening_bracket: Optional[Leaf] = None
4750     closing_bracket: Optional[Leaf] = None
4751     for leaf in reversed(line.leaves):
4752         if current_leaves is body_leaves:
4753             if leaf is opening_bracket:
4754                 current_leaves = head_leaves if body_leaves else tail_leaves
4755         current_leaves.append(leaf)
4756         if current_leaves is tail_leaves:
4757             if leaf.type in CLOSING_BRACKETS and id(leaf) not in omit:
4758                 opening_bracket = leaf.opening_bracket
4759                 closing_bracket = leaf
4760                 current_leaves = body_leaves
4761     if not (opening_bracket and closing_bracket and head_leaves):
4762         # If there is no opening or closing_bracket that means the split failed and
4763         # all content is in the tail.  Otherwise, if `head_leaves` are empty, it means
4764         # the matching `opening_bracket` wasn't available on `line` anymore.
4765         raise CannotSplit("No brackets found")
4766
4767     tail_leaves.reverse()
4768     body_leaves.reverse()
4769     head_leaves.reverse()
4770     head = bracket_split_build_line(head_leaves, line, opening_bracket)
4771     body = bracket_split_build_line(body_leaves, line, opening_bracket, is_body=True)
4772     tail = bracket_split_build_line(tail_leaves, line, opening_bracket)
4773     bracket_split_succeeded_or_raise(head, body, tail)
4774     if (
4775         # the body shouldn't be exploded
4776         not body.should_explode
4777         # the opening bracket is an optional paren
4778         and opening_bracket.type == token.LPAR
4779         and not opening_bracket.value
4780         # the closing bracket is an optional paren
4781         and closing_bracket.type == token.RPAR
4782         and not closing_bracket.value
4783         # it's not an import (optional parens are the only thing we can split on
4784         # in this case; attempting a split without them is a waste of time)
4785         and not line.is_import
4786         # there are no standalone comments in the body
4787         and not body.contains_standalone_comments(0)
4788         # and we can actually remove the parens
4789         and can_omit_invisible_parens(body, line_length)
4790     ):
4791         omit = {id(closing_bracket), *omit}
4792         try:
4793             yield from right_hand_split(line, line_length, features=features, omit=omit)
4794             return
4795
4796         except CannotSplit:
4797             if not (
4798                 can_be_split(body)
4799                 or is_line_short_enough(body, line_length=line_length)
4800             ):
4801                 raise CannotSplit(
4802                     "Splitting failed, body is still too long and can't be split."
4803                 )
4804
4805             elif head.contains_multiline_strings() or tail.contains_multiline_strings():
4806                 raise CannotSplit(
4807                     "The current optional pair of parentheses is bound to fail to"
4808                     " satisfy the splitting algorithm because the head or the tail"
4809                     " contains multiline strings which by definition never fit one"
4810                     " line."
4811                 )
4812
4813     ensure_visible(opening_bracket)
4814     ensure_visible(closing_bracket)
4815     for result in (head, body, tail):
4816         if result:
4817             yield result
4818
4819
4820 def bracket_split_succeeded_or_raise(head: Line, body: Line, tail: Line) -> None:
4821     """Raise :exc:`CannotSplit` if the last left- or right-hand split failed.
4822
4823     Do nothing otherwise.
4824
4825     A left- or right-hand split is based on a pair of brackets. Content before
4826     (and including) the opening bracket is left on one line, content inside the
4827     brackets is put on a separate line, and finally content starting with and
4828     following the closing bracket is put on a separate line.
4829
4830     Those are called `head`, `body`, and `tail`, respectively. If the split
4831     produced the same line (all content in `head`) or ended up with an empty `body`
4832     and the `tail` is just the closing bracket, then it's considered failed.
4833     """
4834     tail_len = len(str(tail).strip())
4835     if not body:
4836         if tail_len == 0:
4837             raise CannotSplit("Splitting brackets produced the same line")
4838
4839         elif tail_len < 3:
4840             raise CannotSplit(
4841                 f"Splitting brackets on an empty body to save {tail_len} characters is"
4842                 " not worth it"
4843             )
4844
4845
4846 def bracket_split_build_line(
4847     leaves: List[Leaf], original: Line, opening_bracket: Leaf, *, is_body: bool = False
4848 ) -> Line:
4849     """Return a new line with given `leaves` and respective comments from `original`.
4850
4851     If `is_body` is True, the result line is one-indented inside brackets and as such
4852     has its first leaf's prefix normalized and a trailing comma added when expected.
4853     """
4854     result = Line(depth=original.depth)
4855     if is_body:
4856         result.inside_brackets = True
4857         result.depth += 1
4858         if leaves:
4859             # Since body is a new indent level, remove spurious leading whitespace.
4860             normalize_prefix(leaves[0], inside_brackets=True)
4861             # Ensure a trailing comma for imports and standalone function arguments, but
4862             # be careful not to add one after any comments or within type annotations.
4863             no_commas = (
4864                 original.is_def
4865                 and opening_bracket.value == "("
4866                 and not any(leaf.type == token.COMMA for leaf in leaves)
4867             )
4868
4869             if original.is_import or no_commas:
4870                 for i in range(len(leaves) - 1, -1, -1):
4871                     if leaves[i].type == STANDALONE_COMMENT:
4872                         continue
4873
4874                     if leaves[i].type != token.COMMA:
4875                         leaves.insert(i + 1, Leaf(token.COMMA, ","))
4876                     break
4877
4878     # Populate the line
4879     for leaf in leaves:
4880         result.append(leaf, preformatted=True)
4881         for comment_after in original.comments_after(leaf):
4882             result.append(comment_after, preformatted=True)
4883     if is_body:
4884         result.should_explode = should_explode(result, opening_bracket)
4885     return result
4886
4887
4888 def dont_increase_indentation(split_func: Transformer) -> Transformer:
4889     """Normalize prefix of the first leaf in every line returned by `split_func`.
4890
4891     This is a decorator over relevant split functions.
4892     """
4893
4894     @wraps(split_func)
4895     def split_wrapper(line: Line, features: Collection[Feature] = ()) -> Iterator[Line]:
4896         for line in split_func(line, features):
4897             normalize_prefix(line.leaves[0], inside_brackets=True)
4898             yield line
4899
4900     return split_wrapper
4901
4902
4903 @dont_increase_indentation
4904 def delimiter_split(line: Line, features: Collection[Feature] = ()) -> Iterator[Line]:
4905     """Split according to delimiters of the highest priority.
4906
4907     If the appropriate Features are given, the split will add trailing commas
4908     also in function signatures and calls that contain `*` and `**`.
4909     """
4910     try:
4911         last_leaf = line.leaves[-1]
4912     except IndexError:
4913         raise CannotSplit("Line empty")
4914
4915     bt = line.bracket_tracker
4916     try:
4917         delimiter_priority = bt.max_delimiter_priority(exclude={id(last_leaf)})
4918     except ValueError:
4919         raise CannotSplit("No delimiters found")
4920
4921     if delimiter_priority == DOT_PRIORITY:
4922         if bt.delimiter_count_with_priority(delimiter_priority) == 1:
4923             raise CannotSplit("Splitting a single attribute from its owner looks wrong")
4924
4925     current_line = Line(depth=line.depth, inside_brackets=line.inside_brackets)
4926     lowest_depth = sys.maxsize
4927     trailing_comma_safe = True
4928
4929     def append_to_line(leaf: Leaf) -> Iterator[Line]:
4930         """Append `leaf` to current line or to new line if appending impossible."""
4931         nonlocal current_line
4932         try:
4933             current_line.append_safe(leaf, preformatted=True)
4934         except ValueError:
4935             yield current_line
4936
4937             current_line = Line(depth=line.depth, inside_brackets=line.inside_brackets)
4938             current_line.append(leaf)
4939
4940     for leaf in line.leaves:
4941         yield from append_to_line(leaf)
4942
4943         for comment_after in line.comments_after(leaf):
4944             yield from append_to_line(comment_after)
4945
4946         lowest_depth = min(lowest_depth, leaf.bracket_depth)
4947         if leaf.bracket_depth == lowest_depth:
4948             if is_vararg(leaf, within={syms.typedargslist}):
4949                 trailing_comma_safe = (
4950                     trailing_comma_safe and Feature.TRAILING_COMMA_IN_DEF in features
4951                 )
4952             elif is_vararg(leaf, within={syms.arglist, syms.argument}):
4953                 trailing_comma_safe = (
4954                     trailing_comma_safe and Feature.TRAILING_COMMA_IN_CALL in features
4955                 )
4956
4957         leaf_priority = bt.delimiters.get(id(leaf))
4958         if leaf_priority == delimiter_priority:
4959             yield current_line
4960
4961             current_line = Line(depth=line.depth, inside_brackets=line.inside_brackets)
4962     if current_line:
4963         if (
4964             trailing_comma_safe
4965             and delimiter_priority == COMMA_PRIORITY
4966             and current_line.leaves[-1].type != token.COMMA
4967             and current_line.leaves[-1].type != STANDALONE_COMMENT
4968         ):
4969             current_line.append(Leaf(token.COMMA, ","))
4970         yield current_line
4971
4972
4973 @dont_increase_indentation
4974 def standalone_comment_split(
4975     line: Line, features: Collection[Feature] = ()
4976 ) -> Iterator[Line]:
4977     """Split standalone comments from the rest of the line."""
4978     if not line.contains_standalone_comments(0):
4979         raise CannotSplit("Line does not have any standalone comments")
4980
4981     current_line = Line(depth=line.depth, inside_brackets=line.inside_brackets)
4982
4983     def append_to_line(leaf: Leaf) -> Iterator[Line]:
4984         """Append `leaf` to current line or to new line if appending impossible."""
4985         nonlocal current_line
4986         try:
4987             current_line.append_safe(leaf, preformatted=True)
4988         except ValueError:
4989             yield current_line
4990
4991             current_line = Line(depth=line.depth, inside_brackets=line.inside_brackets)
4992             current_line.append(leaf)
4993
4994     for leaf in line.leaves:
4995         yield from append_to_line(leaf)
4996
4997         for comment_after in line.comments_after(leaf):
4998             yield from append_to_line(comment_after)
4999
5000     if current_line:
5001         yield current_line
5002
5003
5004 def is_import(leaf: Leaf) -> bool:
5005     """Return True if the given leaf starts an import statement."""
5006     p = leaf.parent
5007     t = leaf.type
5008     v = leaf.value
5009     return bool(
5010         t == token.NAME
5011         and (
5012             (v == "import" and p and p.type == syms.import_name)
5013             or (v == "from" and p and p.type == syms.import_from)
5014         )
5015     )
5016
5017
5018 def is_type_comment(leaf: Leaf, suffix: str = "") -> bool:
5019     """Return True if the given leaf is a special comment.
5020     Only returns true for type comments for now."""
5021     t = leaf.type
5022     v = leaf.value
5023     return t in {token.COMMENT, STANDALONE_COMMENT} and v.startswith("# type:" + suffix)
5024
5025
5026 def normalize_prefix(leaf: Leaf, *, inside_brackets: bool) -> None:
5027     """Leave existing extra newlines if not `inside_brackets`. Remove everything
5028     else.
5029
5030     Note: don't use backslashes for formatting or you'll lose your voting rights.
5031     """
5032     if not inside_brackets:
5033         spl = leaf.prefix.split("#")
5034         if "\\" not in spl[0]:
5035             nl_count = spl[-1].count("\n")
5036             if len(spl) > 1:
5037                 nl_count -= 1
5038             leaf.prefix = "\n" * nl_count
5039             return
5040
5041     leaf.prefix = ""
5042
5043
5044 def normalize_string_prefix(leaf: Leaf, remove_u_prefix: bool = False) -> None:
5045     """Make all string prefixes lowercase.
5046
5047     If remove_u_prefix is given, also removes any u prefix from the string.
5048
5049     Note: Mutates its argument.
5050     """
5051     match = re.match(r"^([" + STRING_PREFIX_CHARS + r"]*)(.*)$", leaf.value, re.DOTALL)
5052     assert match is not None, f"failed to match string {leaf.value!r}"
5053     orig_prefix = match.group(1)
5054     new_prefix = orig_prefix.replace("F", "f").replace("B", "b").replace("U", "u")
5055     if remove_u_prefix:
5056         new_prefix = new_prefix.replace("u", "")
5057     leaf.value = f"{new_prefix}{match.group(2)}"
5058
5059
5060 def normalize_string_quotes(leaf: Leaf) -> None:
5061     """Prefer double quotes but only if it doesn't cause more escaping.
5062
5063     Adds or removes backslashes as appropriate. Doesn't parse and fix
5064     strings nested in f-strings (yet).
5065
5066     Note: Mutates its argument.
5067     """
5068     value = leaf.value.lstrip(STRING_PREFIX_CHARS)
5069     if value[:3] == '"""':
5070         return
5071
5072     elif value[:3] == "'''":
5073         orig_quote = "'''"
5074         new_quote = '"""'
5075     elif value[0] == '"':
5076         orig_quote = '"'
5077         new_quote = "'"
5078     else:
5079         orig_quote = "'"
5080         new_quote = '"'
5081     first_quote_pos = leaf.value.find(orig_quote)
5082     if first_quote_pos == -1:
5083         return  # There's an internal error
5084
5085     prefix = leaf.value[:first_quote_pos]
5086     unescaped_new_quote = re.compile(rf"(([^\\]|^)(\\\\)*){new_quote}")
5087     escaped_new_quote = re.compile(rf"([^\\]|^)\\((?:\\\\)*){new_quote}")
5088     escaped_orig_quote = re.compile(rf"([^\\]|^)\\((?:\\\\)*){orig_quote}")
5089     body = leaf.value[first_quote_pos + len(orig_quote) : -len(orig_quote)]
5090     if "r" in prefix.casefold():
5091         if unescaped_new_quote.search(body):
5092             # There's at least one unescaped new_quote in this raw string
5093             # so converting is impossible
5094             return
5095
5096         # Do not introduce or remove backslashes in raw strings
5097         new_body = body
5098     else:
5099         # remove unnecessary escapes
5100         new_body = sub_twice(escaped_new_quote, rf"\1\2{new_quote}", body)
5101         if body != new_body:
5102             # Consider the string without unnecessary escapes as the original
5103             body = new_body
5104             leaf.value = f"{prefix}{orig_quote}{body}{orig_quote}"
5105         new_body = sub_twice(escaped_orig_quote, rf"\1\2{orig_quote}", new_body)
5106         new_body = sub_twice(unescaped_new_quote, rf"\1\\{new_quote}", new_body)
5107     if "f" in prefix.casefold():
5108         matches = re.findall(
5109             r"""
5110             (?:[^{]|^)\{  # start of the string or a non-{ followed by a single {
5111                 ([^{].*?)  # contents of the brackets except if begins with {{
5112             \}(?:[^}]|$)  # A } followed by end of the string or a non-}
5113             """,
5114             new_body,
5115             re.VERBOSE,
5116         )
5117         for m in matches:
5118             if "\\" in str(m):
5119                 # Do not introduce backslashes in interpolated expressions
5120                 return
5121
5122     if new_quote == '"""' and new_body[-1:] == '"':
5123         # edge case:
5124         new_body = new_body[:-1] + '\\"'
5125     orig_escape_count = body.count("\\")
5126     new_escape_count = new_body.count("\\")
5127     if new_escape_count > orig_escape_count:
5128         return  # Do not introduce more escaping
5129
5130     if new_escape_count == orig_escape_count and orig_quote == '"':
5131         return  # Prefer double quotes
5132
5133     leaf.value = f"{prefix}{new_quote}{new_body}{new_quote}"
5134
5135
5136 def normalize_numeric_literal(leaf: Leaf) -> None:
5137     """Normalizes numeric (float, int, and complex) literals.
5138
5139     All letters used in the representation are normalized to lowercase (except
5140     in Python 2 long literals).
5141     """
5142     text = leaf.value.lower()
5143     if text.startswith(("0o", "0b")):
5144         # Leave octal and binary literals alone.
5145         pass
5146     elif text.startswith("0x"):
5147         # Change hex literals to upper case.
5148         before, after = text[:2], text[2:]
5149         text = f"{before}{after.upper()}"
5150     elif "e" in text:
5151         before, after = text.split("e")
5152         sign = ""
5153         if after.startswith("-"):
5154             after = after[1:]
5155             sign = "-"
5156         elif after.startswith("+"):
5157             after = after[1:]
5158         before = format_float_or_int_string(before)
5159         text = f"{before}e{sign}{after}"
5160     elif text.endswith(("j", "l")):
5161         number = text[:-1]
5162         suffix = text[-1]
5163         # Capitalize in "2L" because "l" looks too similar to "1".
5164         if suffix == "l":
5165             suffix = "L"
5166         text = f"{format_float_or_int_string(number)}{suffix}"
5167     else:
5168         text = format_float_or_int_string(text)
5169     leaf.value = text
5170
5171
5172 def format_float_or_int_string(text: str) -> str:
5173     """Formats a float string like "1.0"."""
5174     if "." not in text:
5175         return text
5176
5177     before, after = text.split(".")
5178     return f"{before or 0}.{after or 0}"
5179
5180
5181 def normalize_invisible_parens(node: Node, parens_after: Set[str]) -> None:
5182     """Make existing optional parentheses invisible or create new ones.
5183
5184     `parens_after` is a set of string leaf values immediately after which parens
5185     should be put.
5186
5187     Standardizes on visible parentheses for single-element tuples, and keeps
5188     existing visible parentheses for other tuples and generator expressions.
5189     """
5190     for pc in list_comments(node.prefix, is_endmarker=False):
5191         if pc.value in FMT_OFF:
5192             # This `node` has a prefix with `# fmt: off`, don't mess with parens.
5193             return
5194     check_lpar = False
5195     for index, child in enumerate(list(node.children)):
5196         # Fixes a bug where invisible parens are not properly stripped from
5197         # assignment statements that contain type annotations.
5198         if isinstance(child, Node) and child.type == syms.annassign:
5199             normalize_invisible_parens(child, parens_after=parens_after)
5200
5201         # Add parentheses around long tuple unpacking in assignments.
5202         if (
5203             index == 0
5204             and isinstance(child, Node)
5205             and child.type == syms.testlist_star_expr
5206         ):
5207             check_lpar = True
5208
5209         if check_lpar:
5210             if is_walrus_assignment(child):
5211                 continue
5212
5213             if child.type == syms.atom:
5214                 if maybe_make_parens_invisible_in_atom(child, parent=node):
5215                     wrap_in_parentheses(node, child, visible=False)
5216             elif is_one_tuple(child):
5217                 wrap_in_parentheses(node, child, visible=True)
5218             elif node.type == syms.import_from:
5219                 # "import from" nodes store parentheses directly as part of
5220                 # the statement
5221                 if child.type == token.LPAR:
5222                     # make parentheses invisible
5223                     child.value = ""  # type: ignore
5224                     node.children[-1].value = ""  # type: ignore
5225                 elif child.type != token.STAR:
5226                     # insert invisible parentheses
5227                     node.insert_child(index, Leaf(token.LPAR, ""))
5228                     node.append_child(Leaf(token.RPAR, ""))
5229                 break
5230
5231             elif not (isinstance(child, Leaf) and is_multiline_string(child)):
5232                 wrap_in_parentheses(node, child, visible=False)
5233
5234         check_lpar = isinstance(child, Leaf) and child.value in parens_after
5235
5236
5237 def normalize_fmt_off(node: Node) -> None:
5238     """Convert content between `# fmt: off`/`# fmt: on` into standalone comments."""
5239     try_again = True
5240     while try_again:
5241         try_again = convert_one_fmt_off_pair(node)
5242
5243
5244 def convert_one_fmt_off_pair(node: Node) -> bool:
5245     """Convert content of a single `# fmt: off`/`# fmt: on` into a standalone comment.
5246
5247     Returns True if a pair was converted.
5248     """
5249     for leaf in node.leaves():
5250         previous_consumed = 0
5251         for comment in list_comments(leaf.prefix, is_endmarker=False):
5252             if comment.value in FMT_OFF:
5253                 # We only want standalone comments. If there's no previous leaf or
5254                 # the previous leaf is indentation, it's a standalone comment in
5255                 # disguise.
5256                 if comment.type != STANDALONE_COMMENT:
5257                     prev = preceding_leaf(leaf)
5258                     if prev and prev.type not in WHITESPACE:
5259                         continue
5260
5261                 ignored_nodes = list(generate_ignored_nodes(leaf))
5262                 if not ignored_nodes:
5263                     continue
5264
5265                 first = ignored_nodes[0]  # Can be a container node with the `leaf`.
5266                 parent = first.parent
5267                 prefix = first.prefix
5268                 first.prefix = prefix[comment.consumed :]
5269                 hidden_value = (
5270                     comment.value + "\n" + "".join(str(n) for n in ignored_nodes)
5271                 )
5272                 if hidden_value.endswith("\n"):
5273                     # That happens when one of the `ignored_nodes` ended with a NEWLINE
5274                     # leaf (possibly followed by a DEDENT).
5275                     hidden_value = hidden_value[:-1]
5276                 first_idx: Optional[int] = None
5277                 for ignored in ignored_nodes:
5278                     index = ignored.remove()
5279                     if first_idx is None:
5280                         first_idx = index
5281                 assert parent is not None, "INTERNAL ERROR: fmt: on/off handling (1)"
5282                 assert first_idx is not None, "INTERNAL ERROR: fmt: on/off handling (2)"
5283                 parent.insert_child(
5284                     first_idx,
5285                     Leaf(
5286                         STANDALONE_COMMENT,
5287                         hidden_value,
5288                         prefix=prefix[:previous_consumed] + "\n" * comment.newlines,
5289                     ),
5290                 )
5291                 return True
5292
5293             previous_consumed = comment.consumed
5294
5295     return False
5296
5297
5298 def generate_ignored_nodes(leaf: Leaf) -> Iterator[LN]:
5299     """Starting from the container of `leaf`, generate all leaves until `# fmt: on`.
5300
5301     Stops at the end of the block.
5302     """
5303     container: Optional[LN] = container_of(leaf)
5304     while container is not None and container.type != token.ENDMARKER:
5305         if is_fmt_on(container):
5306             return
5307
5308         # fix for fmt: on in children
5309         if contains_fmt_on_at_column(container, leaf.column):
5310             for child in container.children:
5311                 if contains_fmt_on_at_column(child, leaf.column):
5312                     return
5313                 yield child
5314         else:
5315             yield container
5316             container = container.next_sibling
5317
5318
5319 def is_fmt_on(container: LN) -> bool:
5320     """Determine whether formatting is switched on within a container.
5321     Determined by whether the last `# fmt:` comment is `on` or `off`.
5322     """
5323     fmt_on = False
5324     for comment in list_comments(container.prefix, is_endmarker=False):
5325         if comment.value in FMT_ON:
5326             fmt_on = True
5327         elif comment.value in FMT_OFF:
5328             fmt_on = False
5329     return fmt_on
5330
5331
5332 def contains_fmt_on_at_column(container: LN, column: int) -> bool:
5333     """Determine if children at a given column have formatting switched on."""
5334     for child in container.children:
5335         if (
5336             isinstance(child, Node)
5337             and first_leaf_column(child) == column
5338             or isinstance(child, Leaf)
5339             and child.column == column
5340         ):
5341             if is_fmt_on(child):
5342                 return True
5343
5344     return False
5345
5346
5347 def first_leaf_column(node: Node) -> Optional[int]:
5348     """Returns the column of the first leaf child of a node."""
5349     for child in node.children:
5350         if isinstance(child, Leaf):
5351             return child.column
5352     return None
5353
5354
5355 def maybe_make_parens_invisible_in_atom(node: LN, parent: LN) -> bool:
5356     """If it's safe, make the parens in the atom `node` invisible, recursively.
5357     Additionally, remove repeated, adjacent invisible parens from the atom `node`
5358     as they are redundant.
5359
5360     Returns whether the node should itself be wrapped in invisible parentheses.
5361
5362     """
5363     if (
5364         node.type != syms.atom
5365         or is_empty_tuple(node)
5366         or is_one_tuple(node)
5367         or (is_yield(node) and parent.type != syms.expr_stmt)
5368         or max_delimiter_priority_in_atom(node) >= COMMA_PRIORITY
5369     ):
5370         return False
5371
5372     first = node.children[0]
5373     last = node.children[-1]
5374     if first.type == token.LPAR and last.type == token.RPAR:
5375         middle = node.children[1]
5376         # make parentheses invisible
5377         first.value = ""  # type: ignore
5378         last.value = ""  # type: ignore
5379         maybe_make_parens_invisible_in_atom(middle, parent=parent)
5380
5381         if is_atom_with_invisible_parens(middle):
5382             # Strip the invisible parens from `middle` by replacing
5383             # it with the child in-between the invisible parens
5384             middle.replace(middle.children[1])
5385
5386         return False
5387
5388     return True
5389
5390
5391 def is_atom_with_invisible_parens(node: LN) -> bool:
5392     """Given a `LN`, determines whether it's an atom `node` with invisible
5393     parens. Useful in dedupe-ing and normalizing parens.
5394     """
5395     if isinstance(node, Leaf) or node.type != syms.atom:
5396         return False
5397
5398     first, last = node.children[0], node.children[-1]
5399     return (
5400         isinstance(first, Leaf)
5401         and first.type == token.LPAR
5402         and first.value == ""
5403         and isinstance(last, Leaf)
5404         and last.type == token.RPAR
5405         and last.value == ""
5406     )
5407
5408
5409 def is_empty_tuple(node: LN) -> bool:
5410     """Return True if `node` holds an empty tuple."""
5411     return (
5412         node.type == syms.atom
5413         and len(node.children) == 2
5414         and node.children[0].type == token.LPAR
5415         and node.children[1].type == token.RPAR
5416     )
5417
5418
5419 def unwrap_singleton_parenthesis(node: LN) -> Optional[LN]:
5420     """Returns `wrapped` if `node` is of the shape ( wrapped ).
5421
5422     Parenthesis can be optional. Returns None otherwise"""
5423     if len(node.children) != 3:
5424         return None
5425
5426     lpar, wrapped, rpar = node.children
5427     if not (lpar.type == token.LPAR and rpar.type == token.RPAR):
5428         return None
5429
5430     return wrapped
5431
5432
5433 def wrap_in_parentheses(parent: Node, child: LN, *, visible: bool = True) -> None:
5434     """Wrap `child` in parentheses.
5435
5436     This replaces `child` with an atom holding the parentheses and the old
5437     child.  That requires moving the prefix.
5438
5439     If `visible` is False, the leaves will be valueless (and thus invisible).
5440     """
5441     lpar = Leaf(token.LPAR, "(" if visible else "")
5442     rpar = Leaf(token.RPAR, ")" if visible else "")
5443     prefix = child.prefix
5444     child.prefix = ""
5445     index = child.remove() or 0
5446     new_child = Node(syms.atom, [lpar, child, rpar])
5447     new_child.prefix = prefix
5448     parent.insert_child(index, new_child)
5449
5450
5451 def is_one_tuple(node: LN) -> bool:
5452     """Return True if `node` holds a tuple with one element, with or without parens."""
5453     if node.type == syms.atom:
5454         gexp = unwrap_singleton_parenthesis(node)
5455         if gexp is None or gexp.type != syms.testlist_gexp:
5456             return False
5457
5458         return len(gexp.children) == 2 and gexp.children[1].type == token.COMMA
5459
5460     return (
5461         node.type in IMPLICIT_TUPLE
5462         and len(node.children) == 2
5463         and node.children[1].type == token.COMMA
5464     )
5465
5466
5467 def is_walrus_assignment(node: LN) -> bool:
5468     """Return True iff `node` is of the shape ( test := test )"""
5469     inner = unwrap_singleton_parenthesis(node)
5470     return inner is not None and inner.type == syms.namedexpr_test
5471
5472
5473 def is_yield(node: LN) -> bool:
5474     """Return True if `node` holds a `yield` or `yield from` expression."""
5475     if node.type == syms.yield_expr:
5476         return True
5477
5478     if node.type == token.NAME and node.value == "yield":  # type: ignore
5479         return True
5480
5481     if node.type != syms.atom:
5482         return False
5483
5484     if len(node.children) != 3:
5485         return False
5486
5487     lpar, expr, rpar = node.children
5488     if lpar.type == token.LPAR and rpar.type == token.RPAR:
5489         return is_yield(expr)
5490
5491     return False
5492
5493
5494 def is_vararg(leaf: Leaf, within: Set[NodeType]) -> bool:
5495     """Return True if `leaf` is a star or double star in a vararg or kwarg.
5496
5497     If `within` includes VARARGS_PARENTS, this applies to function signatures.
5498     If `within` includes UNPACKING_PARENTS, it applies to right hand-side
5499     extended iterable unpacking (PEP 3132) and additional unpacking
5500     generalizations (PEP 448).
5501     """
5502     if leaf.type not in VARARGS_SPECIALS or not leaf.parent:
5503         return False
5504
5505     p = leaf.parent
5506     if p.type == syms.star_expr:
5507         # Star expressions are also used as assignment targets in extended
5508         # iterable unpacking (PEP 3132).  See what its parent is instead.
5509         if not p.parent:
5510             return False
5511
5512         p = p.parent
5513
5514     return p.type in within
5515
5516
5517 def is_multiline_string(leaf: Leaf) -> bool:
5518     """Return True if `leaf` is a multiline string that actually spans many lines."""
5519     return has_triple_quotes(leaf.value) and "\n" in leaf.value
5520
5521
5522 def is_stub_suite(node: Node) -> bool:
5523     """Return True if `node` is a suite with a stub body."""
5524     if (
5525         len(node.children) != 4
5526         or node.children[0].type != token.NEWLINE
5527         or node.children[1].type != token.INDENT
5528         or node.children[3].type != token.DEDENT
5529     ):
5530         return False
5531
5532     return is_stub_body(node.children[2])
5533
5534
5535 def is_stub_body(node: LN) -> bool:
5536     """Return True if `node` is a simple statement containing an ellipsis."""
5537     if not isinstance(node, Node) or node.type != syms.simple_stmt:
5538         return False
5539
5540     if len(node.children) != 2:
5541         return False
5542
5543     child = node.children[0]
5544     return (
5545         child.type == syms.atom
5546         and len(child.children) == 3
5547         and all(leaf == Leaf(token.DOT, ".") for leaf in child.children)
5548     )
5549
5550
5551 def max_delimiter_priority_in_atom(node: LN) -> Priority:
5552     """Return maximum delimiter priority inside `node`.
5553
5554     This is specific to atoms with contents contained in a pair of parentheses.
5555     If `node` isn't an atom or there are no enclosing parentheses, returns 0.
5556     """
5557     if node.type != syms.atom:
5558         return 0
5559
5560     first = node.children[0]
5561     last = node.children[-1]
5562     if not (first.type == token.LPAR and last.type == token.RPAR):
5563         return 0
5564
5565     bt = BracketTracker()
5566     for c in node.children[1:-1]:
5567         if isinstance(c, Leaf):
5568             bt.mark(c)
5569         else:
5570             for leaf in c.leaves():
5571                 bt.mark(leaf)
5572     try:
5573         return bt.max_delimiter_priority()
5574
5575     except ValueError:
5576         return 0
5577
5578
5579 def ensure_visible(leaf: Leaf) -> None:
5580     """Make sure parentheses are visible.
5581
5582     They could be invisible as part of some statements (see
5583     :func:`normalize_invisible_parens` and :func:`visit_import_from`).
5584     """
5585     if leaf.type == token.LPAR:
5586         leaf.value = "("
5587     elif leaf.type == token.RPAR:
5588         leaf.value = ")"
5589
5590
5591 def should_explode(line: Line, opening_bracket: Leaf) -> bool:
5592     """Should `line` immediately be split with `delimiter_split()` after RHS?"""
5593
5594     if not (
5595         opening_bracket.parent
5596         and opening_bracket.parent.type in {syms.atom, syms.import_from}
5597         and opening_bracket.value in "[{("
5598     ):
5599         return False
5600
5601     try:
5602         last_leaf = line.leaves[-1]
5603         exclude = {id(last_leaf)} if last_leaf.type == token.COMMA else set()
5604         max_priority = line.bracket_tracker.max_delimiter_priority(exclude=exclude)
5605     except (IndexError, ValueError):
5606         return False
5607
5608     return max_priority == COMMA_PRIORITY
5609
5610
5611 def get_features_used(node: Node) -> Set[Feature]:
5612     """Return a set of (relatively) new Python features used in this file.
5613
5614     Currently looking for:
5615     - f-strings;
5616     - underscores in numeric literals;
5617     - trailing commas after * or ** in function signatures and calls;
5618     - positional only arguments in function signatures and lambdas;
5619     """
5620     features: Set[Feature] = set()
5621     for n in node.pre_order():
5622         if n.type == token.STRING:
5623             value_head = n.value[:2]  # type: ignore
5624             if value_head in {'f"', 'F"', "f'", "F'", "rf", "fr", "RF", "FR"}:
5625                 features.add(Feature.F_STRINGS)
5626
5627         elif n.type == token.NUMBER:
5628             if "_" in n.value:  # type: ignore
5629                 features.add(Feature.NUMERIC_UNDERSCORES)
5630
5631         elif n.type == token.SLASH:
5632             if n.parent and n.parent.type in {syms.typedargslist, syms.arglist}:
5633                 features.add(Feature.POS_ONLY_ARGUMENTS)
5634
5635         elif n.type == token.COLONEQUAL:
5636             features.add(Feature.ASSIGNMENT_EXPRESSIONS)
5637
5638         elif (
5639             n.type in {syms.typedargslist, syms.arglist}
5640             and n.children
5641             and n.children[-1].type == token.COMMA
5642         ):
5643             if n.type == syms.typedargslist:
5644                 feature = Feature.TRAILING_COMMA_IN_DEF
5645             else:
5646                 feature = Feature.TRAILING_COMMA_IN_CALL
5647
5648             for ch in n.children:
5649                 if ch.type in STARS:
5650                     features.add(feature)
5651
5652                 if ch.type == syms.argument:
5653                     for argch in ch.children:
5654                         if argch.type in STARS:
5655                             features.add(feature)
5656
5657     return features
5658
5659
5660 def detect_target_versions(node: Node) -> Set[TargetVersion]:
5661     """Detect the version to target based on the nodes used."""
5662     features = get_features_used(node)
5663     return {
5664         version for version in TargetVersion if features <= VERSION_TO_FEATURES[version]
5665     }
5666
5667
5668 def generate_trailers_to_omit(line: Line, line_length: int) -> Iterator[Set[LeafID]]:
5669     """Generate sets of closing bracket IDs that should be omitted in a RHS.
5670
5671     Brackets can be omitted if the entire trailer up to and including
5672     a preceding closing bracket fits in one line.
5673
5674     Yielded sets are cumulative (contain results of previous yields, too).  First
5675     set is empty.
5676     """
5677
5678     omit: Set[LeafID] = set()
5679     yield omit
5680
5681     length = 4 * line.depth
5682     opening_bracket: Optional[Leaf] = None
5683     closing_bracket: Optional[Leaf] = None
5684     inner_brackets: Set[LeafID] = set()
5685     for index, leaf, leaf_length in enumerate_with_length(line, reversed=True):
5686         length += leaf_length
5687         if length > line_length:
5688             break
5689
5690         has_inline_comment = leaf_length > len(leaf.value) + len(leaf.prefix)
5691         if leaf.type == STANDALONE_COMMENT or has_inline_comment:
5692             break
5693
5694         if opening_bracket:
5695             if leaf is opening_bracket:
5696                 opening_bracket = None
5697             elif leaf.type in CLOSING_BRACKETS:
5698                 inner_brackets.add(id(leaf))
5699         elif leaf.type in CLOSING_BRACKETS:
5700             if index > 0 and line.leaves[index - 1].type in OPENING_BRACKETS:
5701                 # Empty brackets would fail a split so treat them as "inner"
5702                 # brackets (e.g. only add them to the `omit` set if another
5703                 # pair of brackets was good enough.
5704                 inner_brackets.add(id(leaf))
5705                 continue
5706
5707             if closing_bracket:
5708                 omit.add(id(closing_bracket))
5709                 omit.update(inner_brackets)
5710                 inner_brackets.clear()
5711                 yield omit
5712
5713             if leaf.value:
5714                 opening_bracket = leaf.opening_bracket
5715                 closing_bracket = leaf
5716
5717
5718 def get_future_imports(node: Node) -> Set[str]:
5719     """Return a set of __future__ imports in the file."""
5720     imports: Set[str] = set()
5721
5722     def get_imports_from_children(children: List[LN]) -> Generator[str, None, None]:
5723         for child in children:
5724             if isinstance(child, Leaf):
5725                 if child.type == token.NAME:
5726                     yield child.value
5727
5728             elif child.type == syms.import_as_name:
5729                 orig_name = child.children[0]
5730                 assert isinstance(orig_name, Leaf), "Invalid syntax parsing imports"
5731                 assert orig_name.type == token.NAME, "Invalid syntax parsing imports"
5732                 yield orig_name.value
5733
5734             elif child.type == syms.import_as_names:
5735                 yield from get_imports_from_children(child.children)
5736
5737             else:
5738                 raise AssertionError("Invalid syntax parsing imports")
5739
5740     for child in node.children:
5741         if child.type != syms.simple_stmt:
5742             break
5743
5744         first_child = child.children[0]
5745         if isinstance(first_child, Leaf):
5746             # Continue looking if we see a docstring; otherwise stop.
5747             if (
5748                 len(child.children) == 2
5749                 and first_child.type == token.STRING
5750                 and child.children[1].type == token.NEWLINE
5751             ):
5752                 continue
5753
5754             break
5755
5756         elif first_child.type == syms.import_from:
5757             module_name = first_child.children[1]
5758             if not isinstance(module_name, Leaf) or module_name.value != "__future__":
5759                 break
5760
5761             imports |= set(get_imports_from_children(first_child.children[3:]))
5762         else:
5763             break
5764
5765     return imports
5766
5767
5768 @lru_cache()
5769 def get_gitignore(root: Path) -> PathSpec:
5770     """ Return a PathSpec matching gitignore content if present."""
5771     gitignore = root / ".gitignore"
5772     lines: List[str] = []
5773     if gitignore.is_file():
5774         with gitignore.open() as gf:
5775             lines = gf.readlines()
5776     return PathSpec.from_lines("gitwildmatch", lines)
5777
5778
5779 def normalize_path_maybe_ignore(
5780     path: Path, root: Path, report: "Report"
5781 ) -> Optional[str]:
5782     """Normalize `path`. May return `None` if `path` was ignored.
5783
5784     `report` is where "path ignored" output goes.
5785     """
5786     try:
5787         normalized_path = path.resolve().relative_to(root).as_posix()
5788     except OSError as e:
5789         report.path_ignored(path, f"cannot be read because {e}")
5790         return None
5791
5792     except ValueError:
5793         if path.is_symlink():
5794             report.path_ignored(path, f"is a symbolic link that points outside {root}")
5795             return None
5796
5797         raise
5798
5799     return normalized_path
5800
5801
5802 def gen_python_files(
5803     paths: Iterable[Path],
5804     root: Path,
5805     include: Optional[Pattern[str]],
5806     exclude: Pattern[str],
5807     force_exclude: Optional[Pattern[str]],
5808     report: "Report",
5809     gitignore: PathSpec,
5810 ) -> Iterator[Path]:
5811     """Generate all files under `path` whose paths are not excluded by the
5812     `exclude_regex` or `force_exclude` regexes, but are included by the `include` regex.
5813
5814     Symbolic links pointing outside of the `root` directory are ignored.
5815
5816     `report` is where output about exclusions goes.
5817     """
5818     assert root.is_absolute(), f"INTERNAL ERROR: `root` must be absolute but is {root}"
5819     for child in paths:
5820         normalized_path = normalize_path_maybe_ignore(child, root, report)
5821         if normalized_path is None:
5822             continue
5823
5824         # First ignore files matching .gitignore
5825         if gitignore.match_file(normalized_path):
5826             report.path_ignored(child, "matches the .gitignore file content")
5827             continue
5828
5829         # Then ignore with `--exclude` and `--force-exclude` options.
5830         normalized_path = "/" + normalized_path
5831         if child.is_dir():
5832             normalized_path += "/"
5833
5834         exclude_match = exclude.search(normalized_path) if exclude else None
5835         if exclude_match and exclude_match.group(0):
5836             report.path_ignored(child, "matches the --exclude regular expression")
5837             continue
5838
5839         force_exclude_match = (
5840             force_exclude.search(normalized_path) if force_exclude else None
5841         )
5842         if force_exclude_match and force_exclude_match.group(0):
5843             report.path_ignored(child, "matches the --force-exclude regular expression")
5844             continue
5845
5846         if child.is_dir():
5847             yield from gen_python_files(
5848                 child.iterdir(),
5849                 root,
5850                 include,
5851                 exclude,
5852                 force_exclude,
5853                 report,
5854                 gitignore,
5855             )
5856
5857         elif child.is_file():
5858             include_match = include.search(normalized_path) if include else True
5859             if include_match:
5860                 yield child
5861
5862
5863 @lru_cache()
5864 def find_project_root(srcs: Iterable[str]) -> Path:
5865     """Return a directory containing .git, .hg, or pyproject.toml.
5866
5867     That directory will be a common parent of all files and directories
5868     passed in `srcs`.
5869
5870     If no directory in the tree contains a marker that would specify it's the
5871     project root, the root of the file system is returned.
5872     """
5873     if not srcs:
5874         return Path("/").resolve()
5875
5876     path_srcs = [Path(Path.cwd(), src).resolve() for src in srcs]
5877
5878     # A list of lists of parents for each 'src'. 'src' is included as a
5879     # "parent" of itself if it is a directory
5880     src_parents = [
5881         list(path.parents) + ([path] if path.is_dir() else []) for path in path_srcs
5882     ]
5883
5884     common_base = max(
5885         set.intersection(*(set(parents) for parents in src_parents)),
5886         key=lambda path: path.parts,
5887     )
5888
5889     for directory in (common_base, *common_base.parents):
5890         if (directory / ".git").exists():
5891             return directory
5892
5893         if (directory / ".hg").is_dir():
5894             return directory
5895
5896         if (directory / "pyproject.toml").is_file():
5897             return directory
5898
5899     return directory
5900
5901
5902 @dataclass
5903 class Report:
5904     """Provides a reformatting counter. Can be rendered with `str(report)`."""
5905
5906     check: bool = False
5907     diff: bool = False
5908     quiet: bool = False
5909     verbose: bool = False
5910     change_count: int = 0
5911     same_count: int = 0
5912     failure_count: int = 0
5913
5914     def done(self, src: Path, changed: Changed) -> None:
5915         """Increment the counter for successful reformatting. Write out a message."""
5916         if changed is Changed.YES:
5917             reformatted = "would reformat" if self.check or self.diff else "reformatted"
5918             if self.verbose or not self.quiet:
5919                 out(f"{reformatted} {src}")
5920             self.change_count += 1
5921         else:
5922             if self.verbose:
5923                 if changed is Changed.NO:
5924                     msg = f"{src} already well formatted, good job."
5925                 else:
5926                     msg = f"{src} wasn't modified on disk since last run."
5927                 out(msg, bold=False)
5928             self.same_count += 1
5929
5930     def failed(self, src: Path, message: str) -> None:
5931         """Increment the counter for failed reformatting. Write out a message."""
5932         err(f"error: cannot format {src}: {message}")
5933         self.failure_count += 1
5934
5935     def path_ignored(self, path: Path, message: str) -> None:
5936         if self.verbose:
5937             out(f"{path} ignored: {message}", bold=False)
5938
5939     @property
5940     def return_code(self) -> int:
5941         """Return the exit code that the app should use.
5942
5943         This considers the current state of changed files and failures:
5944         - if there were any failures, return 123;
5945         - if any files were changed and --check is being used, return 1;
5946         - otherwise return 0.
5947         """
5948         # According to http://tldp.org/LDP/abs/html/exitcodes.html starting with
5949         # 126 we have special return codes reserved by the shell.
5950         if self.failure_count:
5951             return 123
5952
5953         elif self.change_count and self.check:
5954             return 1
5955
5956         return 0
5957
5958     def __str__(self) -> str:
5959         """Render a color report of the current state.
5960
5961         Use `click.unstyle` to remove colors.
5962         """
5963         if self.check or self.diff:
5964             reformatted = "would be reformatted"
5965             unchanged = "would be left unchanged"
5966             failed = "would fail to reformat"
5967         else:
5968             reformatted = "reformatted"
5969             unchanged = "left unchanged"
5970             failed = "failed to reformat"
5971         report = []
5972         if self.change_count:
5973             s = "s" if self.change_count > 1 else ""
5974             report.append(
5975                 click.style(f"{self.change_count} file{s} {reformatted}", bold=True)
5976             )
5977         if self.same_count:
5978             s = "s" if self.same_count > 1 else ""
5979             report.append(f"{self.same_count} file{s} {unchanged}")
5980         if self.failure_count:
5981             s = "s" if self.failure_count > 1 else ""
5982             report.append(
5983                 click.style(f"{self.failure_count} file{s} {failed}", fg="red")
5984             )
5985         return ", ".join(report) + "."
5986
5987
5988 def parse_ast(src: str) -> Union[ast.AST, ast3.AST, ast27.AST]:
5989     filename = "<unknown>"
5990     if sys.version_info >= (3, 8):
5991         # TODO: support Python 4+ ;)
5992         for minor_version in range(sys.version_info[1], 4, -1):
5993             try:
5994                 return ast.parse(src, filename, feature_version=(3, minor_version))
5995             except SyntaxError:
5996                 continue
5997     else:
5998         for feature_version in (7, 6):
5999             try:
6000                 return ast3.parse(src, filename, feature_version=feature_version)
6001             except SyntaxError:
6002                 continue
6003
6004     return ast27.parse(src)
6005
6006
6007 def _fixup_ast_constants(
6008     node: Union[ast.AST, ast3.AST, ast27.AST]
6009 ) -> Union[ast.AST, ast3.AST, ast27.AST]:
6010     """Map ast nodes deprecated in 3.8 to Constant."""
6011     if isinstance(node, (ast.Str, ast3.Str, ast27.Str, ast.Bytes, ast3.Bytes)):
6012         return ast.Constant(value=node.s)
6013
6014     if isinstance(node, (ast.Num, ast3.Num, ast27.Num)):
6015         return ast.Constant(value=node.n)
6016
6017     if isinstance(node, (ast.NameConstant, ast3.NameConstant)):
6018         return ast.Constant(value=node.value)
6019
6020     return node
6021
6022
6023 def _stringify_ast(
6024     node: Union[ast.AST, ast3.AST, ast27.AST], depth: int = 0
6025 ) -> Iterator[str]:
6026     """Simple visitor generating strings to compare ASTs by content."""
6027
6028     node = _fixup_ast_constants(node)
6029
6030     yield f"{'  ' * depth}{node.__class__.__name__}("
6031
6032     for field in sorted(node._fields):  # noqa: F402
6033         # TypeIgnore has only one field 'lineno' which breaks this comparison
6034         type_ignore_classes = (ast3.TypeIgnore, ast27.TypeIgnore)
6035         if sys.version_info >= (3, 8):
6036             type_ignore_classes += (ast.TypeIgnore,)
6037         if isinstance(node, type_ignore_classes):
6038             break
6039
6040         try:
6041             value = getattr(node, field)
6042         except AttributeError:
6043             continue
6044
6045         yield f"{'  ' * (depth+1)}{field}="
6046
6047         if isinstance(value, list):
6048             for item in value:
6049                 # Ignore nested tuples within del statements, because we may insert
6050                 # parentheses and they change the AST.
6051                 if (
6052                     field == "targets"
6053                     and isinstance(node, (ast.Delete, ast3.Delete, ast27.Delete))
6054                     and isinstance(item, (ast.Tuple, ast3.Tuple, ast27.Tuple))
6055                 ):
6056                     for item in item.elts:
6057                         yield from _stringify_ast(item, depth + 2)
6058
6059                 elif isinstance(item, (ast.AST, ast3.AST, ast27.AST)):
6060                     yield from _stringify_ast(item, depth + 2)
6061
6062         elif isinstance(value, (ast.AST, ast3.AST, ast27.AST)):
6063             yield from _stringify_ast(value, depth + 2)
6064
6065         else:
6066             # Constant strings may be indented across newlines, if they are
6067             # docstrings; fold spaces after newlines when comparing. Similarly,
6068             # trailing and leading space may be removed.
6069             if (
6070                 isinstance(node, ast.Constant)
6071                 and field == "value"
6072                 and isinstance(value, str)
6073             ):
6074                 normalized = re.sub(r" *\n[ \t]*", "\n", value).strip()
6075             else:
6076                 normalized = value
6077             yield f"{'  ' * (depth+2)}{normalized!r},  # {value.__class__.__name__}"
6078
6079     yield f"{'  ' * depth})  # /{node.__class__.__name__}"
6080
6081
6082 def assert_equivalent(src: str, dst: str) -> None:
6083     """Raise AssertionError if `src` and `dst` aren't equivalent."""
6084     try:
6085         src_ast = parse_ast(src)
6086     except Exception as exc:
6087         raise AssertionError(
6088             "cannot use --safe with this file; failed to parse source file.  AST"
6089             f" error message: {exc}"
6090         )
6091
6092     try:
6093         dst_ast = parse_ast(dst)
6094     except Exception as exc:
6095         log = dump_to_file("".join(traceback.format_tb(exc.__traceback__)), dst)
6096         raise AssertionError(
6097             f"INTERNAL ERROR: Black produced invalid code: {exc}. Please report a bug"
6098             " on https://github.com/psf/black/issues.  This invalid output might be"
6099             f" helpful: {log}"
6100         ) from None
6101
6102     src_ast_str = "\n".join(_stringify_ast(src_ast))
6103     dst_ast_str = "\n".join(_stringify_ast(dst_ast))
6104     if src_ast_str != dst_ast_str:
6105         log = dump_to_file(diff(src_ast_str, dst_ast_str, "src", "dst"))
6106         raise AssertionError(
6107             "INTERNAL ERROR: Black produced code that is not equivalent to the"
6108             " source.  Please report a bug on https://github.com/psf/black/issues. "
6109             f" This diff might be helpful: {log}"
6110         ) from None
6111
6112
6113 def assert_stable(src: str, dst: str, mode: Mode) -> None:
6114     """Raise AssertionError if `dst` reformats differently the second time."""
6115     newdst = format_str(dst, mode=mode)
6116     if dst != newdst:
6117         log = dump_to_file(
6118             diff(src, dst, "source", "first pass"),
6119             diff(dst, newdst, "first pass", "second pass"),
6120         )
6121         raise AssertionError(
6122             "INTERNAL ERROR: Black produced different code on the second pass of the"
6123             " formatter.  Please report a bug on https://github.com/psf/black/issues."
6124             f"  This diff might be helpful: {log}"
6125         ) from None
6126
6127
6128 @mypyc_attr(patchable=True)
6129 def dump_to_file(*output: str) -> str:
6130     """Dump `output` to a temporary file. Return path to the file."""
6131     with tempfile.NamedTemporaryFile(
6132         mode="w", prefix="blk_", suffix=".log", delete=False, encoding="utf8"
6133     ) as f:
6134         for lines in output:
6135             f.write(lines)
6136             if lines and lines[-1] != "\n":
6137                 f.write("\n")
6138     return f.name
6139
6140
6141 @contextmanager
6142 def nullcontext() -> Iterator[None]:
6143     """Return an empty context manager.
6144
6145     To be used like `nullcontext` in Python 3.7.
6146     """
6147     yield
6148
6149
6150 def diff(a: str, b: str, a_name: str, b_name: str) -> str:
6151     """Return a unified diff string between strings `a` and `b`."""
6152     import difflib
6153
6154     a_lines = [line + "\n" for line in a.splitlines()]
6155     b_lines = [line + "\n" for line in b.splitlines()]
6156     return "".join(
6157         difflib.unified_diff(a_lines, b_lines, fromfile=a_name, tofile=b_name, n=5)
6158     )
6159
6160
6161 def cancel(tasks: Iterable["asyncio.Task[Any]"]) -> None:
6162     """asyncio signal handler that cancels all `tasks` and reports to stderr."""
6163     err("Aborted!")
6164     for task in tasks:
6165         task.cancel()
6166
6167
6168 def shutdown(loop: asyncio.AbstractEventLoop) -> None:
6169     """Cancel all pending tasks on `loop`, wait for them, and close the loop."""
6170     try:
6171         if sys.version_info[:2] >= (3, 7):
6172             all_tasks = asyncio.all_tasks
6173         else:
6174             all_tasks = asyncio.Task.all_tasks
6175         # This part is borrowed from asyncio/runners.py in Python 3.7b2.
6176         to_cancel = [task for task in all_tasks(loop) if not task.done()]
6177         if not to_cancel:
6178             return
6179
6180         for task in to_cancel:
6181             task.cancel()
6182         loop.run_until_complete(
6183             asyncio.gather(*to_cancel, loop=loop, return_exceptions=True)
6184         )
6185     finally:
6186         # `concurrent.futures.Future` objects cannot be cancelled once they
6187         # are already running. There might be some when the `shutdown()` happened.
6188         # Silence their logger's spew about the event loop being closed.
6189         cf_logger = logging.getLogger("concurrent.futures")
6190         cf_logger.setLevel(logging.CRITICAL)
6191         loop.close()
6192
6193
6194 def sub_twice(regex: Pattern[str], replacement: str, original: str) -> str:
6195     """Replace `regex` with `replacement` twice on `original`.
6196
6197     This is used by string normalization to perform replaces on
6198     overlapping matches.
6199     """
6200     return regex.sub(replacement, regex.sub(replacement, original))
6201
6202
6203 def re_compile_maybe_verbose(regex: str) -> Pattern[str]:
6204     """Compile a regular expression string in `regex`.
6205
6206     If it contains newlines, use verbose mode.
6207     """
6208     if "\n" in regex:
6209         regex = "(?x)" + regex
6210     compiled: Pattern[str] = re.compile(regex)
6211     return compiled
6212
6213
6214 def enumerate_reversed(sequence: Sequence[T]) -> Iterator[Tuple[Index, T]]:
6215     """Like `reversed(enumerate(sequence))` if that were possible."""
6216     index = len(sequence) - 1
6217     for element in reversed(sequence):
6218         yield (index, element)
6219         index -= 1
6220
6221
6222 def enumerate_with_length(
6223     line: Line, reversed: bool = False
6224 ) -> Iterator[Tuple[Index, Leaf, int]]:
6225     """Return an enumeration of leaves with their length.
6226
6227     Stops prematurely on multiline strings and standalone comments.
6228     """
6229     op = cast(
6230         Callable[[Sequence[Leaf]], Iterator[Tuple[Index, Leaf]]],
6231         enumerate_reversed if reversed else enumerate,
6232     )
6233     for index, leaf in op(line.leaves):
6234         length = len(leaf.prefix) + len(leaf.value)
6235         if "\n" in leaf.value:
6236             return  # Multiline strings, we can't continue.
6237
6238         for comment in line.comments_after(leaf):
6239             length += len(comment.value)
6240
6241         yield index, leaf, length
6242
6243
6244 def is_line_short_enough(line: Line, *, line_length: int, line_str: str = "") -> bool:
6245     """Return True if `line` is no longer than `line_length`.
6246
6247     Uses the provided `line_str` rendering, if any, otherwise computes a new one.
6248     """
6249     if not line_str:
6250         line_str = line_to_string(line)
6251     return (
6252         len(line_str) <= line_length
6253         and "\n" not in line_str  # multiline strings
6254         and not line.contains_standalone_comments()
6255     )
6256
6257
6258 def can_be_split(line: Line) -> bool:
6259     """Return False if the line cannot be split *for sure*.
6260
6261     This is not an exhaustive search but a cheap heuristic that we can use to
6262     avoid some unfortunate formattings (mostly around wrapping unsplittable code
6263     in unnecessary parentheses).
6264     """
6265     leaves = line.leaves
6266     if len(leaves) < 2:
6267         return False
6268
6269     if leaves[0].type == token.STRING and leaves[1].type == token.DOT:
6270         call_count = 0
6271         dot_count = 0
6272         next = leaves[-1]
6273         for leaf in leaves[-2::-1]:
6274             if leaf.type in OPENING_BRACKETS:
6275                 if next.type not in CLOSING_BRACKETS:
6276                     return False
6277
6278                 call_count += 1
6279             elif leaf.type == token.DOT:
6280                 dot_count += 1
6281             elif leaf.type == token.NAME:
6282                 if not (next.type == token.DOT or next.type in OPENING_BRACKETS):
6283                     return False
6284
6285             elif leaf.type not in CLOSING_BRACKETS:
6286                 return False
6287
6288             if dot_count > 1 and call_count > 1:
6289                 return False
6290
6291     return True
6292
6293
6294 def can_omit_invisible_parens(line: Line, line_length: int) -> bool:
6295     """Does `line` have a shape safe to reformat without optional parens around it?
6296
6297     Returns True for only a subset of potentially nice looking formattings but
6298     the point is to not return false positives that end up producing lines that
6299     are too long.
6300     """
6301     bt = line.bracket_tracker
6302     if not bt.delimiters:
6303         # Without delimiters the optional parentheses are useless.
6304         return True
6305
6306     max_priority = bt.max_delimiter_priority()
6307     if bt.delimiter_count_with_priority(max_priority) > 1:
6308         # With more than one delimiter of a kind the optional parentheses read better.
6309         return False
6310
6311     if max_priority == DOT_PRIORITY:
6312         # A single stranded method call doesn't require optional parentheses.
6313         return True
6314
6315     assert len(line.leaves) >= 2, "Stranded delimiter"
6316
6317     first = line.leaves[0]
6318     second = line.leaves[1]
6319     penultimate = line.leaves[-2]
6320     last = line.leaves[-1]
6321
6322     # With a single delimiter, omit if the expression starts or ends with
6323     # a bracket.
6324     if first.type in OPENING_BRACKETS and second.type not in CLOSING_BRACKETS:
6325         remainder = False
6326         length = 4 * line.depth
6327         for _index, leaf, leaf_length in enumerate_with_length(line):
6328             if leaf.type in CLOSING_BRACKETS and leaf.opening_bracket is first:
6329                 remainder = True
6330             if remainder:
6331                 length += leaf_length
6332                 if length > line_length:
6333                     break
6334
6335                 if leaf.type in OPENING_BRACKETS:
6336                     # There are brackets we can further split on.
6337                     remainder = False
6338
6339         else:
6340             # checked the entire string and line length wasn't exceeded
6341             if len(line.leaves) == _index + 1:
6342                 return True
6343
6344         # Note: we are not returning False here because a line might have *both*
6345         # a leading opening bracket and a trailing closing bracket.  If the
6346         # opening bracket doesn't match our rule, maybe the closing will.
6347
6348     if (
6349         last.type == token.RPAR
6350         or last.type == token.RBRACE
6351         or (
6352             # don't use indexing for omitting optional parentheses;
6353             # it looks weird
6354             last.type == token.RSQB
6355             and last.parent
6356             and last.parent.type != syms.trailer
6357         )
6358     ):
6359         if penultimate.type in OPENING_BRACKETS:
6360             # Empty brackets don't help.
6361             return False
6362
6363         if is_multiline_string(first):
6364             # Additional wrapping of a multiline string in this situation is
6365             # unnecessary.
6366             return True
6367
6368         length = 4 * line.depth
6369         seen_other_brackets = False
6370         for _index, leaf, leaf_length in enumerate_with_length(line):
6371             length += leaf_length
6372             if leaf is last.opening_bracket:
6373                 if seen_other_brackets or length <= line_length:
6374                     return True
6375
6376             elif leaf.type in OPENING_BRACKETS:
6377                 # There are brackets we can further split on.
6378                 seen_other_brackets = True
6379
6380     return False
6381
6382
6383 def get_cache_file(mode: Mode) -> Path:
6384     return CACHE_DIR / f"cache.{mode.get_cache_key()}.pickle"
6385
6386
6387 def read_cache(mode: Mode) -> Cache:
6388     """Read the cache if it exists and is well formed.
6389
6390     If it is not well formed, the call to write_cache later should resolve the issue.
6391     """
6392     cache_file = get_cache_file(mode)
6393     if not cache_file.exists():
6394         return {}
6395
6396     with cache_file.open("rb") as fobj:
6397         try:
6398             cache: Cache = pickle.load(fobj)
6399         except (pickle.UnpicklingError, ValueError):
6400             return {}
6401
6402     return cache
6403
6404
6405 def get_cache_info(path: Path) -> CacheInfo:
6406     """Return the information used to check if a file is already formatted or not."""
6407     stat = path.stat()
6408     return stat.st_mtime, stat.st_size
6409
6410
6411 def filter_cached(cache: Cache, sources: Iterable[Path]) -> Tuple[Set[Path], Set[Path]]:
6412     """Split an iterable of paths in `sources` into two sets.
6413
6414     The first contains paths of files that modified on disk or are not in the
6415     cache. The other contains paths to non-modified files.
6416     """
6417     todo, done = set(), set()
6418     for src in sources:
6419         src = src.resolve()
6420         if cache.get(src) != get_cache_info(src):
6421             todo.add(src)
6422         else:
6423             done.add(src)
6424     return todo, done
6425
6426
6427 def write_cache(cache: Cache, sources: Iterable[Path], mode: Mode) -> None:
6428     """Update the cache file."""
6429     cache_file = get_cache_file(mode)
6430     try:
6431         CACHE_DIR.mkdir(parents=True, exist_ok=True)
6432         new_cache = {**cache, **{src.resolve(): get_cache_info(src) for src in sources}}
6433         with tempfile.NamedTemporaryFile(dir=str(cache_file.parent), delete=False) as f:
6434             pickle.dump(new_cache, f, protocol=4)
6435         os.replace(f.name, cache_file)
6436     except OSError:
6437         pass
6438
6439
6440 def patch_click() -> None:
6441     """Make Click not crash.
6442
6443     On certain misconfigured environments, Python 3 selects the ASCII encoding as the
6444     default which restricts paths that it can access during the lifetime of the
6445     application.  Click refuses to work in this scenario by raising a RuntimeError.
6446
6447     In case of Black the likelihood that non-ASCII characters are going to be used in
6448     file paths is minimal since it's Python source code.  Moreover, this crash was
6449     spurious on Python 3.7 thanks to PEP 538 and PEP 540.
6450     """
6451     try:
6452         from click import core
6453         from click import _unicodefun  # type: ignore
6454     except ModuleNotFoundError:
6455         return
6456
6457     for module in (core, _unicodefun):
6458         if hasattr(module, "_verify_python3_env"):
6459             module._verify_python3_env = lambda: None
6460
6461
6462 def patched_main() -> None:
6463     freeze_support()
6464     patch_click()
6465     main()
6466
6467
6468 def fix_docstring(docstring: str, prefix: str) -> str:
6469     # https://www.python.org/dev/peps/pep-0257/#handling-docstring-indentation
6470     if not docstring:
6471         return ""
6472     # Convert tabs to spaces (following the normal Python rules)
6473     # and split into a list of lines:
6474     lines = docstring.expandtabs().splitlines()
6475     # Determine minimum indentation (first line doesn't count):
6476     indent = sys.maxsize
6477     for line in lines[1:]:
6478         stripped = line.lstrip()
6479         if stripped:
6480             indent = min(indent, len(line) - len(stripped))
6481     # Remove indentation (first line is special):
6482     trimmed = [lines[0].strip()]
6483     if indent < sys.maxsize:
6484         last_line_idx = len(lines) - 2
6485         for i, line in enumerate(lines[1:]):
6486             stripped_line = line[indent:].rstrip()
6487             if stripped_line or i == last_line_idx:
6488                 trimmed.append(prefix + stripped_line)
6489             else:
6490                 trimmed.append("")
6491     # Return a single string:
6492     return "\n".join(trimmed)
6493
6494
6495 if __name__ == "__main__":
6496     patched_main()