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

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