Repository: psf/black
File: src/black/trans.py (Python)

Code before:
                yield Ok(non_string_line)
        # Else the target string was the last leaf...
        else:
            last_line.append(rest_leaf)
            last_line.comments = line.comments.copy()
            yield Ok(last_line)

    def _get_nameescape_slices(self, string: str) -> List[Tuple[int, int]]:
        """
        Returns:
            List of all ranges of @string which, if @string were to be split there,
            would result in the splitting of an \\N{...} expression (which is NOT
            allowed).
        """
        slices = []
        backslash_count = 0
        it = iter(enumerate(string))
        for idx, c in it:
            if not backslash_count:
                if c == "\\":
                    backslash_count += 1
                continue
            if c == "\\":
                backslash_count += 1
                continue
            backslash_count = 0
            if c != "N":
                continue

            start = idx - 1  # the position of backslash before \N{...}
            for idx, c in it:
                if c == "}":
                    end = idx
                    break
            else:
                # malformed nameescape expression?
                # should have been detected by AST parsing earlier...
                raise RuntimeError(f"{self.__class__.__name__} LOGIC ERROR!")
            slices.append((start, end))

        return slices

    def _get_break_idx(self, string: str, max_break_idx: int) -> Optional[int]:
        """
        This method contains the algorithm that StringSplitter uses to
        determine which character to split each string at.

        Args:
            @string: The substring that we are attempting to split.
            @max_break_idx: The ideal break index. We will return this value if it
            meets all the necessary conditions. In the likely event that it

Review comment (bug):
If I'm not mistaken, with escaped backslashes this would function incorrectly: `\\N{something}` would result in `count = 2` and still finding a slice. So how about something like:

```python
previous_was_backslash = False
for idx, c in it:
    if c == "\\":
        if not previous_was_backslash:
            previous_was_backslash = True
        else:
            previous_was_backslash = False    
        continue

    if not previous_was_backslash or c != "N":
        continue

    # Do the slice
```
Other potential names: `unescaped`, `previous_was_unescaped`, `previous_backslash_was_unescaped` (lol maybe not)

Code after:
                append_leaves(non_string_line, line, LL[string_idx + 1 :])
                yield Ok(non_string_line)
        # Else the target string was the last leaf...
        else:
            last_line.append(rest_leaf)
            last_line.comments = line.comments.copy()
            yield Ok(last_line)

    def _iter_nameescape_slices(self, string: str) -> Iterator[Tuple[Index, Index]]:
        """
        Yields:
            All ranges of @string which, if @string were to be split there,
            would result in the splitting of an \\N{...} expression (which is NOT
            allowed).
        """
        # True - the previous backslash was unescaped
        # False - the previous backslash was escaped *or* there was no backslash
        previous_was_unescaped_backslash = False
        it = iter(enumerate(string))
        for idx, c in it:
            if c == "\\":
                previous_was_unescaped_backslash = not previous_was_unescaped_backslash
                continue
            if not previous_was_unescaped_backslash or c != "N":
                previous_was_unescaped_backslash = False
                continue
            previous_was_unescaped_backslash = False

            begin = idx - 1  # the position of backslash before \N{...}
            for idx, c in it:
                if c == "}":
                    end = idx
                    break
            else:
                # malformed nameescape expression?
                # should have been detected by AST parsing earlier...
                raise RuntimeError(f"{self.__class__.__name__} LOGIC ERROR!")
            yield begin, end

    def _iter_fexpr_slices(self, string: str) -> Iterator[Tuple[Index, Index]]:
        """
        Yields:
            All ranges of @string which, if @string were to be split there,
            would result in the splitting of an f-expression (which is NOT
            allowed).
        """
        if "f" not in get_string_prefix(string).lower():
            return

        for match in re.finditer(self.RE_FEXPR, string, re.VERBOSE):
            yield match.span()