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

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