stdlib: Use the re-mangler for _typeByName

The old method of constructing a mangled class name does not work anymore with the new mangling scheme.
Also, by using the re-mangler, _typeByName now works with class names containing non-ascii characters.

Author: eeckstein

stdlib/public/core/Misc.swift

@@ -84,8 +84,8 @@ func _typeName(_ type: Any.Type, qualified: Bool = true) -> String {
     input: UnsafeBufferPointer(start: stringPtr, count: count))
 }
 
-@_silgen_name("swift_getTypeByMangledName")
-func _getTypeByMangledName(
+@_silgen_name("swift_getTypeByName")
+func _getTypeByName(
     _ name: UnsafePointer<UInt8>,
     _ nameLength: UInt)
   -> Any.Type?
@@ -94,26 +94,10 @@ func _getTypeByMangledName(
 /// names is stabilized, this is limited to top-level class names (Foo.bar).
 public // SPI(Foundation)
 func _typeByName(_ name: String) -> Any.Type? {
-  let components = name.characters.split{$0 == "."}.map(String.init)
-  guard components.count == 2 else {
-    return nil
-  }
-
-  // Note: explicitly build a class name to match on, rather than matching
-  // on the result of _typeName(), to ensure the type we are resolving is
-  // actually a class.
-  var name = "C"
-  if components[0] == "Swift" {
-    name += "s"
-  } else {
-    name += String(components[0].characters.count) + components[0]
-  }
-  name += String(components[1].characters.count) + components[1]
-
   let nameUTF8 = Array(name.utf8)
   return nameUTF8.withUnsafeBufferPointer { (nameUTF8) in
-    let type = _getTypeByMangledName(nameUTF8.baseAddress!,
-                                     UInt(nameUTF8.endIndex))
+    let type = _getTypeByName(nameUTF8.baseAddress!,
+                              UInt(nameUTF8.endIndex))
 
     return type
   }

stdlib/public/runtime/MetadataLookup.cpp

@@ -16,6 +16,7 @@
 
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/Lazy.h"
+#include "swift/Basic/Demangle.h"
 #include "swift/Runtime/Concurrent.h"
 #include "swift/Runtime/HeapObject.h"
 #include "swift/Runtime/Metadata.h"
@@ -189,27 +190,46 @@ _searchTypeMetadataRecords(const TypeMetadataState &T,
 }
 
 static const Metadata *
-_typeByMangledName(const llvm::StringRef typeName) {
+_classByName(const llvm::StringRef typeName) {
+
+  size_t DotPos = typeName.find('.');
+  if (DotPos == llvm::StringRef::npos)
+    return nullptr;
+  if (typeName.find('.', DotPos + 1) != llvm::StringRef::npos)
+    return nullptr;
+
+  using namespace Demangle;
+
+  NodePointer ClassNd = NodeFactory::create(Node::Kind::Class);
+  NodePointer ModuleNd = NodeFactory::create(Node::Kind::Module,
+                                             typeName.substr(0, DotPos));
+  NodePointer NameNd = NodeFactory::create(Node::Kind::Module,
+                                           typeName.substr(DotPos + 1));
+  ClassNd->addChildren(ModuleNd, NameNd);
+
+  std::string Mangled = mangleNode(ClassNd);
+  StringRef MangledName = Mangled;
+
   const Metadata *foundMetadata = nullptr;
   auto &T = TypeMetadataRecords.get();
 
   // Look for an existing entry.
   // Find the bucket for the metadata entry.
-  if (auto Value = T.Cache.find(typeName))
+  if (auto Value = T.Cache.find(MangledName))
     return Value->getMetadata();
 
   // Check type metadata records
   T.SectionsToScanLock.withLock([&] {
-    foundMetadata = _searchTypeMetadataRecords(T, typeName);
+    foundMetadata = _searchTypeMetadataRecords(T, MangledName);
   });
 
   // Check protocol conformances table. Note that this has no support for
   // resolving generic types yet.
   if (!foundMetadata)
-    foundMetadata = _searchConformancesByMangledTypeName(typeName);
+    foundMetadata = _searchConformancesByMangledTypeName(MangledName);
 
   if (foundMetadata) {
-    T.Cache.getOrInsert(typeName, foundMetadata);
+    T.Cache.getOrInsert(MangledName, foundMetadata);
   }
 
 #if SWIFT_OBJC_INTEROP
@@ -226,13 +246,16 @@ _typeByMangledName(const llvm::StringRef typeName) {
   return foundMetadata;
 }
 
-/// Return the type metadata for a given mangled name, used in the
-/// implementation of _typeByName(). The human readable name returned
-/// by swift_getTypeName() is non-unique, so we used mangled names
-/// internally.
+/// Return the type metadata for a given name, used in the
+/// implementation of _typeByName().
+///
+/// Currently only top-level classes are supported.
+
+/// \param typeName The name of a class in the form: <module>.<class>
+/// \return Returns the metadata of the type, if found.
 SWIFT_RUNTIME_EXPORT
 const Metadata *
-swift_getTypeByMangledName(const char *typeName, size_t typeNameLength) {
+swift_getTypeByName(const char *typeName, size_t typeNameLength) {
   llvm::StringRef name(typeName, typeNameLength);
-  return _typeByMangledName(name);
+  return _classByName(name);
 }

test/stdlib/Runtime.swift.gyb

@@ -349,12 +349,14 @@ class SomeSubclass : SomeClass {}
 protocol SomeProtocol {}
 class SomeConformingClass : SomeProtocol {}
 class SomeConformingSubclass : SomeConformingClass {}
+class UnicodeCläss {}
 
 Runtime.test("typeByName") {
   expectTrue(_typeByName("a.SomeClass") == SomeClass.self)
   expectTrue(_typeByName("a.SomeSubclass") == SomeSubclass.self)
   // name lookup will be via protocol conformance table
   expectTrue(_typeByName("a.SomeConformingClass") == SomeConformingClass.self)
+  expectTrue(_typeByName("a.UnicodeCläss") == UnicodeCläss.self)
 }
 
 Runtime.test("demangleName") {