bpo-30688: support \N{name} escapes in re patterns

Doc/library/re.rst

@@ -468,13 +468,13 @@ Most of the standard escapes supported by Python string literals are also
 accepted by the regular expression parser::
 
    \a      \b      \f      \n
-   \r      \t      \u      \U
-   \v      \x      \\
+   \N      \r      \t      \u
+   \U      \v      \x      \\
 
 (Note that ``\b`` is used to represent word boundaries, and means "backspace"
 only inside character classes.)
 
-``'\u'`` and ``'\U'`` escape sequences are only recognized in Unicode
+``'\u'``, ``'\U'``, and ``'\N'`` escape sequences are only recognized in Unicode
 patterns.  In bytes patterns they are errors.
 
 Octal escapes are included in a limited form.  If the first digit is a 0, or if
@@ -488,6 +488,9 @@ three digits in length.
 .. versionchanged:: 3.6
    Unknown escapes consisting of ``'\'`` and an ASCII letter now are errors.
 
+.. versionchanged:: 3.7
+   The ``'\N{name}'`` escape sequence has been added. As in string literals,
+   it expands to the named Unicode character (e.g. ``'\N{EM DASH}'``).
 
 .. seealso::
 

Lib/sre_parse.py

@@ -13,6 +13,7 @@
 # XXX: show string offset and offending character for all errors
 
 from sre_constants import *
+from ast import literal_eval
 
 SPECIAL_CHARS = ".\\[{()*+?^$|"
 REPEAT_CHARS = "*+?{"
@@ -25,6 +26,11 @@
 
 WHITESPACE = frozenset(" \t\n\r\v\f")
 
+UNICODE_NAME = ASCIILETTERS | DIGITS | frozenset(' -')
+CLOSING_BRACE = frozenset("}")
+OPENING_BRACE = frozenset("{")
+
+
 _REPEATCODES = frozenset({MIN_REPEAT, MAX_REPEAT})
 _UNITCODES = frozenset({ANY, RANGE, IN, LITERAL, NOT_LITERAL, CATEGORY})
 
@@ -322,6 +328,17 @@ def _class_escape(source, escape):
             c = int(escape[2:], 16)
             chr(c) # raise ValueError for invalid code
             return LITERAL, c
+        elif c == "N" and source.istext:
+            # named unicode escape e.g. \N{EM DASH}
+            escape += source.getwhile(1, OPENING_BRACE)
+            escape += source.getwhile(100, UNICODE_NAME)
+            escape += source.getwhile(1, CLOSING_BRACE)
+            try:
+                c = ord(literal_eval('"%s"' % escape))
+            except SyntaxError:
+                charname = escape[2:].strip('{}')
+                raise source.error("unknown Unicode character name %s" % charname, len(escape))
+            return LITERAL, c
         elif c in OCTDIGITS:
             # octal escape (up to three digits)
             escape += source.getwhile(2, OCTDIGITS)
@@ -370,6 +387,17 @@ def _escape(source, escape, state):
             c = int(escape[2:], 16)
             chr(c) # raise ValueError for invalid code
             return LITERAL, c
+        elif c == "N" and source.istext:
+            # named unicode escape e.g. \N{EM DASH}
+            escape += source.getwhile(1, OPENING_BRACE)
+            escape += source.getwhile(100, UNICODE_NAME)
+            escape += source.getwhile(1, CLOSING_BRACE)
+            try:
+                c = ord(literal_eval('"%s"' % escape))
+            except SyntaxError:
+                charname = escape[2:].strip('{}')
+                raise source.error("unknown Unicode character name %s" % charname, len(escape))
+            return LITERAL, c
         elif c == "0":
             # octal escape
             escape += source.getwhile(2, OCTDIGITS)

Lib/test/test_re.py

@@ -700,6 +700,39 @@ def test_other_escapes(self):
             with self.subTest(c):
                 self.assertRaises(re.error, re.compile, '[\\%c]' % c)
 
+    def test_named_unicode_escapes(self):
+        # test individual Unicode named escapes
+        suites = [
+            [   # basic matches
+                ['\u2014', r'\u2014', '\N{EM DASH}',
+                 r'\N{EM DASH}'],                               # pattern
+                ['\u2014', '\N{EM DASH}', '—', '—and more'],    # matches
+                ['\u2015', '\N{EN DASH}']                       # no match
+            ],
+            [   # character set matches
+                ['[\u2014-\u2020]', r'[\u2014-\u2020]',
+                 '[\N{EM DASH}-\N{DAGGER}]', r'[\N{EM DASH}-\N{DAGGER}]',
+                 '[\u2014-\N{DAGGER}]', '[\N{EM DASH}-\u2020]',],                               # pattern
+                ['\u2014', '\N{EM DASH}', '—', '—and more', '\u2020',
+                 '\N{DAGGER}', '†', '\u2017', '\N{DOUBLE LOW LINE}'],
+                ['\u2011', '\N{EN DASH}', '\u2013', 'xyz', '\u2021']
+            ],
+        ]
+
+        for patterns, match_yes, match_no in suites:
+            for pat in patterns:
+                for target in match_yes:
+                    self.assertTrue(re.match(pat, target))
+                for target in match_no:
+                    self.assertIsNone(re.match(pat, target))
+
+        # test errors in \N{name} handling - only valid names should pass
+        badly_formed = [r'\N{BUBBA DASH}', r'\N{EM DASH',
+                        r'\NEM DASH}', r'\NOGGIN']
+        for bad in badly_formed:
+            with self.assertRaises(re.error):
+                re.compile(bad)
+
     def test_string_boundaries(self):
         # See http://bugs.python.org/issue10713
         self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1),