Correctly end tokens in mathtext parsing.

This avoids parsing `\sinx` as `\sin x` (it now raises an error
instead), and removes the need for `accentprefixed` (because `\doteq`
is treated as a single token now, instead of `\dot{eq}`).  This also
means that `\doteq` (and friends) are now correctly treated as relations
(per `_relation_symbols`, thus changing the spacing around them); hence
then change in baseline images.  Adjust test strings accordingly to undo
the spacing, to avoid regen'ing baselines.

Also shaves ~2% off drawing all the current mathtext tests, i.e.
```
MPLBACKEND=agg python -c 'import time; from pylab import *; from matplotlib.tests.test_mathtext import math_tests; fig = figure(figsize=(3, 10)); fig.text(0, 0, "\n".join(filter(None, math_tests)), size=6); start = time.perf_counter(); [fig.canvas.draw() for _ in range(10)]; print((time.perf_counter() - start) / 10)'
```
(including adjustment for the removed test case), probably because
accentprefixed was previously extremely commonly checked, being at the
top of the placeable list; however, performance wasn't really the main
goal here.

Author: anntzer

lib/matplotlib/_mathtext.py

@@ -1718,13 +1718,27 @@ def set_names_and_parse_actions():
 
         # Root definitions.
 
+        # In TeX parlance, a csname is a control sequence name (a "\foo").
+        def csnames(group, names):
+            ends_with_alpha = []
+            ends_with_nonalpha = []
+            for name in names:
+                if name[-1].isalpha():
+                    ends_with_alpha.append(name)
+                else:
+                    ends_with_nonalpha.append(name)
+            return Regex(r"\\(?P<{}>(?:{})(?![A-Za-z]){})".format(
+                group,
+                "|".join(map(re.escape, ends_with_alpha)),
+                "".join(f"|{s}" for s in map(re.escape, ends_with_nonalpha)),
+            ))
+
         p.float_literal  = Regex(r"[-+]?([0-9]+\.?[0-9]*|\.[0-9]+)")
         p.space          = oneOf(self._space_widths)("space")
 
         p.style_literal  = oneOf(
             [str(e.value) for e in self._MathStyle])("style_literal")
 
-        p.accentprefixed = "\\" + oneOf(self._accentprefixed)("sym")
         p.symbol         = Regex(
             r"[a-zA-Z0-9 +\-*/<>=:,.;!\?&'@()\[\]|\U00000080-\U0001ffff]"
             r"|\\[%${}\[\]_|]"
@@ -1733,7 +1747,7 @@ def set_names_and_parse_actions():
         )("sym").leaveWhitespace()
         p.unknown_symbol = Regex(r"\\[A-Za-z]*")("name")
 
-        p.font           = "\\" + oneOf(self._fontnames)("font")
+        p.font           = csnames("font", self._fontnames)
         p.start_group    = (
             Optional(r"\math" + oneOf(self._fontnames)("font")) + "{")
         p.end_group      = Literal("}")
@@ -1770,11 +1784,10 @@ def set_names_and_parse_actions():
         p.customspace <<= cmd(r"\hspace", "{" + p.float_literal("space") + "}")
 
         p.accent <<= (
-            "\\"
-            + oneOf([*self._accent_map, *self._wide_accents])("accent")
+            csnames("accent", [*self._accent_map, *self._wide_accents])
             - p.placeable("sym"))
 
-        p.function     <<= "\\" + oneOf(self._function_names)("name")
+        p.function <<= csnames("name", self._function_names)
         p.operatorname <<= cmd(
             r"\operatorname",
             "{" + ZeroOrMore(p.simple | p.unknown_symbol)("name") + "}")
@@ -1815,10 +1828,8 @@ def set_names_and_parse_actions():
             p.optional_group("annotation") + p.optional_group("body"))
 
         p.placeable     <<= (
-            p.accentprefixed  # Must be before accent so named symbols that are
-                              # prefixed with an accent name work
-            | p.accent   # Must be before symbol as all accents are symbols
-            | p.symbol   # Must be third to catch all named symbols and single
+            p.accent     # Must be before symbol as all accents are symbols
+            | p.symbol   # Must be second to catch all named symbols and single
                          # chars not in a group
             | p.function
             | p.operatorname
@@ -2014,8 +2025,6 @@ def symbol(self, s, loc, toks):
                 return [Hlist([char, self._make_space(0.2)], do_kern=True)]
         return [char]
 
-    accentprefixed = symbol
-
     def unknown_symbol(self, s, loc, toks):
         raise ParseFatalException(s, loc, f"Unknown symbol: {toks['name']}")
 
@@ -2044,12 +2053,6 @@ def unknown_symbol(self, s, loc, toks):
 
     _wide_accents = set(r"widehat widetilde widebar".split())
 
-    # make a lambda and call it to get the namespace right
-    _accentprefixed = (lambda am: [
-        p for p in tex2uni
-        if any(p.startswith(a) and a != p for a in am)
-    ])(set(_accent_map))
-
     def accent(self, s, loc, toks):
         state = self.get_state()
         thickness = state.get_current_underline_thickness()