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

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