[Runtime] Stub out the implementation of _typeByMangledName().

Introduce a standard library/runtime entry point that produces type metadata
given a mangled name, based on the TypeDecoder logic lifted from the remote
mirrors library.

Implement support for tuple types as a proof-of-concept.

Author: DougGregor

stdlib/public/core/Misc.swift

@@ -111,6 +111,25 @@ func _typeByName(_ name: String) -> Any.Type? {
   }
 }
 
+@_silgen_name("swift_getTypeByMangledName")
+internal func _getTypeByMangledName(
+  _ name: UnsafePointer<UInt8>,
+  _ nameLength: UInt)
+  -> Any.Type?
+
+/// Lookup a class given a mangled name. This is a placeholder while we bring
+/// up this functionality.
+public  // TEMPORARY
+func _typeByMangledName(_ name: String) -> Any.Type? {
+  let nameUTF8 = Array(name.utf8)
+  return nameUTF8.withUnsafeBufferPointer { (nameUTF8) in
+    let type = _getTypeByMangledName(nameUTF8.baseAddress!,
+                                     UInt(nameUTF8.endIndex))
+
+    return type
+  }
+}
+
 /// Returns `floor(log(x))`.  This equals to the position of the most
 /// significant non-zero bit, or 63 - number-of-zeros before it.
 ///

stdlib/public/runtime/MetadataLookup.cpp

@@ -17,6 +17,7 @@
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/Lazy.h"
 #include "swift/Demangling/Demangler.h"
+#include "swift/Demangling/TypeDecoder.h"
 #include "swift/Runtime/Concurrent.h"
 #include "swift/Runtime/HeapObject.h"
 #include "swift/Runtime/Metadata.h"
@@ -244,3 +245,127 @@ _getTypeByName(const char *typeName, size_t typeNameLength) {
   llvm::StringRef name(typeName, typeNameLength);
   return _classByName(name);
 }
+
+#pragma mark Metadata lookup via mangled name
+
+namespace {
+/// Constructs metadata by decoding a mangled type name, for use with
+/// \c TypeDecoder.
+class DecodedMetadataBuilder {
+public:
+  using BuiltType = const Metadata *;
+  using BuiltNominalTypeDecl = const NominalTypeDescriptor *;
+
+  BuiltNominalTypeDecl createNominalTypeDecl(
+                                     const Demangle::NodePointer &node) const {
+    // FIXME: Implement.
+    return BuiltNominalTypeDecl();
+  }
+
+  BuiltType createNominalType(BuiltNominalTypeDecl typeDecl,
+                              BuiltType parent) const {
+    // FIXME: Implement.
+    return BuiltType();
+  }
+
+  BuiltType createBoundGenericType(BuiltNominalTypeDecl typeDecl,
+                                   ArrayRef<BuiltType> genericArgs,
+                                   BuiltType parent) const {
+    // FIXME: Implement.
+    return BuiltType();
+  }
+
+  BuiltType createBuiltinType(StringRef mangledName) const {
+    // FIXME: Implement.
+    return BuiltType();
+  }
+
+  BuiltType createMetatypeType(BuiltType instance, bool wasAbstract) const {
+    // FIXME: Implement.
+    return BuiltType();
+  }
+
+  BuiltType createExistentialMetatypeType(BuiltType instance) const {
+    // FIXME: Implement.
+    return BuiltType();
+  }
+
+  BuiltType createProtocolCompositionType(ArrayRef<BuiltType> protocols,
+                                          bool hasExplicitAnyObject) const {
+    // FIXME: Implement.
+    // NOTE: protocols.back() could be a class type. Clean up this API.
+    return BuiltType();
+  }
+
+  BuiltType createProtocolType(StringRef mangledName, StringRef moduleName,
+                               StringRef privateDiscriminator,
+                               StringRef name) const {
+    // FIXME: Implement.
+    return BuiltType();
+  }
+
+  BuiltType createGenericTypeParameterType(unsigned depth,
+                                           unsigned index) const {
+    // FIXME: Implement.
+    return BuiltType();
+  }
+
+  BuiltType createFunctionType(
+                           ArrayRef<Demangle::FunctionParam<BuiltType>> params,
+                           BuiltType result, FunctionTypeFlags flags) const {
+    // FIXME: Implement.
+    return BuiltType();
+  }
+
+  BuiltType createTupleType(ArrayRef<BuiltType> elements,
+                            std::string labels,
+                            bool variadic) const {
+    // TODO: 'variadic' should no longer exist
+    return swift_getTupleTypeMetadata(elements.size(), elements.data(),
+                                      labels.empty() ? nullptr : labels.c_str(),
+                                      /*proposedWitnesses=*/nullptr);
+  }
+
+  BuiltType createDependentMemberType(StringRef name, BuiltType base,
+                                      BuiltType protocol) const {
+    // FIXME: Implement.
+    return BuiltType();
+  }
+
+  BuiltType createUnownedStorageType(BuiltType base) const {
+    // FIXME: Implement.
+    return BuiltType();
+  }
+
+  BuiltType createUnmanagedStorageType(BuiltType base) const {
+    // FIXME: Implement.
+    return BuiltType();
+  }
+
+  BuiltType createWeakStorageType(BuiltType base) const {
+    // FIXME: Implement.
+    return BuiltType();
+  }
+
+  BuiltType createSILBoxType(BuiltType base) const {
+    // FIXME: Implement.
+    return BuiltType();
+  }
+};
+
+}
+
+SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERNAL
+const Metadata * _Nullable
+swift_getTypeByMangledName(const char *typeNameStart, size_t typeNameLength) {
+  // Demangle the type name.
+  llvm::StringRef typeName(typeNameStart, typeNameLength);
+  Demangler demangler;
+  NodePointer node = demangler.demangleType(typeName);
+  if (!node) {
+    return nullptr;
+  }
+
+  DecodedMetadataBuilder builder;
+  return Demangle::decodeMangledType(builder, node);
+}

test/Runtime/demangleToMetadata.swift

@@ -0,0 +1,22 @@
+// RUN: %target-run-simple-swift
+// REQUIRES: executable_test
+
+import StdlibUnittest
+
+let DemangleToMetadataTests = TestSuite("DemangleToMetadata")
+
+
+DemangleToMetadataTests.test("malformed mangled names") {
+  expectNil(_typeByMangledName("blah"))
+}
+
+DemangleToMetadataTests.test("tuple types") {
+  expectEqual(type(of: ()), _typeByMangledName("yt")!)
+  expectEqual(type(of: ((), ())), _typeByMangledName("yt_ytt")!)
+  expectEqual(type(of: ((), b: ())), _typeByMangledName("yt_yt1bt")!)
+  expectEqual(type(of: (a: (), ())), _typeByMangledName("yt1a_ytt")!)
+  expectEqual(type(of: (a: (), b: ())), _typeByMangledName("yt1a_yt1bt")!)
+}
+
+runAllTests()
+