Fixes from 3.6 (#1489)

* Fixes from 3.6

* Fix failing test

Author: slozier

Src/IronPython/Modules/unicodedata.cs

@@ -154,7 +154,61 @@ public UCD(string version) {
             public string unidata_version { get; private set; }
 
             public string lookup(string name) {
-                return char.ConvertFromUtf32(nameLookup[name]);
+                if (TryLookup(name, out int code))
+                    return char.ConvertFromUtf32(code);
+                throw PythonOps.KeyError("undefined character name");
+            }
+
+            private static bool IsUnifiedIdeograph(int code) {
+                return (0x3400 <= code && code <= 0x4DB5) || // CJK Ideograph Extension A
+                    (0x4E00 <= code && code <= 0x9FEF) || // CJK Ideograph
+                    (0x20000 <= code && code <= 0x2A6D6) || // CJK Ideograph Extension B
+                    (0x2A700 <= code && code <= 0x2B734) || // CJK Ideograph Extension C - 5.2
+                    (0x2B740 <= code && code <= 0x2B81D) || // CJK Ideograph Extension D - 6.0
+                    (0x2B820 <= code && code <= 0x2CEA1) || // CJK Ideograph Extension E - 8.0
+                    (0x2CEB0 <= code && code <= 0x2EBEF) || // CJK Ideograph Extension F - 10.0
+                    (0x30000 <= code && code <= 0x3134A);   // CJK Ideograph Extension G - 13.0
+            }
+
+            private bool TryLookup(string name, out int code) {
+                code = 0;
+
+                if (name.StartsWith("CJK UNIFIED IDEOGRAPH-", StringComparison.Ordinal)) {
+                    var val = name.AsSpan(22);
+                    if (val.Length != 4 && val.Length != 5) return false;
+                    foreach (var c in val) {
+                        code *= 16;
+                        switch (c) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                code += c - '0';
+                                break;
+                            case 'A':
+                            case 'B':
+                            case 'C':
+                            case 'D':
+                            case 'E':
+                            case 'F':
+                                code += c - 'A' + 10;
+                                break;
+                            default:
+                                code = 0;
+                                return false;
+                        }
+                    }
+                    return IsUnifiedIdeograph(code);
+
+                }
+
+                return nameLookup.TryGetValue(name, out code);
             }
 
 #nullable enable
@@ -166,6 +220,10 @@ public string name([NotNone] string unichr)
                 => TryGetName(GetRune(unichr), out var name) ? name : @default;
 
             internal bool TryGetName(int rune, [NotNullWhen(true)] out string? name) {
+                if (IsUnifiedIdeograph(rune)) {
+                    name = $"CJK UNIFIED IDEOGRAPH-{rune:X}";
+                    return true;
+                }
                 if (TryGetInfo(rune, out CharInfo info, excludeRanges: true)) {
                     name = info.Name;
                     return true;

Src/IronPython/Runtime/Operations/StringOps.cs

@@ -840,6 +840,33 @@ public static string lstrip([NotNone] this string self, string? chars) {
             return self.TrimStart(chars.ToCharArray());
         }
 
+        [StaticExtensionMethod]
+        public static PythonDictionary maketrans([NotNone] PythonDictionary x) {
+            var res = new PythonDictionary();
+            foreach (var p in x) {
+                object from = p.Key switch {
+                    bool b => ScriptingRuntimeHelpers.Int32ToObject(b ? 1 : 0),
+                    int i => ScriptingRuntimeHelpers.Int32ToObject(i),
+                    BigInteger bi => bi,
+                    Extensible<BigInteger> ebi => ebi.Value,
+                    string s => FromString(s),
+                    Extensible<string> es => FromString(es.Value),
+                    _ => throw PythonOps.TypeError("keys in translate table must be strings or integers"),
+                };
+                res[from] = p.Value;
+            }
+            return res;
+
+            static int FromString(string s) {
+                // TODO: revisit this once we implement https://github.com/IronLanguages/ironpython3/issues/252
+                if (s.Length == 1) {
+                    return s[0];
+                }
+
+                throw PythonOps.ValueError("string keys in translate table must be of length 1");
+            }
+        }
+
         [StaticExtensionMethod]
         public static PythonDictionary maketrans([NotNone] string from, [NotNone] string to) {
             if (from.Length != to.Length) throw PythonOps.ValueError("maketrans arguments must have same length");

Src/IronPython/Runtime/StringFormatter.cs

@@ -333,7 +333,9 @@ private void WriteConversion() {
                 // single character (int or single char str)
                 case 'c': AppendChar(); return;
                 // string (repr() version)
-                case 'r': AppendRepr(); return;
+                case 'r':
+                    if (_asBytes) goto case 'a';
+                    AppendRepr(); return;
                 // string (str() version)
                 case 's':
                     if (_asBytes) goto case 'b';

Tests/test_regressions.py

@@ -1103,12 +1103,7 @@ def test_ipy2_gh357(self):
 
         import unicodedata
 
-        if is_cli:
-            with self.assertRaises(ValueError):
-                unicodedata.name(u'\u4e2d')
-        else:
-            self.assertEqual(unicodedata.name(u'\u4e2d'), 'CJK UNIFIED IDEOGRAPH-4E2D')
-
+        self.assertEqual(unicodedata.name(u'\u4e2d'), 'CJK UNIFIED IDEOGRAPH-4E2D')
         self.assertRaises(ValueError, unicodedata.decimal, u'\u4e2d')
         self.assertEqual(unicodedata.decimal(u'\u4e2d', 0), 0)
         self.assertRaises(ValueError, unicodedata.digit, u'\u4e2d')

Tests/test_unicode_stdlib.py

@@ -95,7 +95,7 @@ def load_tests(loader, standard_tests, pattern):
         suite.addTest(test.test_unicode.UnicodeTest('test_literals'))
         suite.addTest(test.test_unicode.UnicodeTest('test_ljust'))
         suite.addTest(unittest.expectedFailure(test.test_unicode.UnicodeTest('test_lower')))
-        suite.addTest(unittest.expectedFailure(test.test_unicode.UnicodeTest('test_maketrans_translate')))
+        suite.addTest(test.test_unicode.UnicodeTest('test_maketrans_translate'))
         suite.addTest(unittest.expectedFailure(test.test_unicode.UnicodeTest('test_mul')))
         suite.addTest(test.test_unicode.UnicodeTest('test_none_arguments'))
         suite.addTest(unittest.expectedFailure(test.test_unicode.UnicodeTest('test_partition')))