Runtime: Make getTypeByMangledNameIn(Context|Environment) a public entry point.

This can be used by compiler-generated code as a size optimization for metadata access, using a
mangled name instead of possibly many open-coded metadata calls. It can also allow reflection
libraries outside of the standard library to turn type reference strings into in-process metadata
pointers in a robust way. rdar://problem/46451849

Author: jckarter

stdlib/public/core/Misc.swift

@@ -91,7 +91,7 @@ func _typeByName(_ name: String) -> Any.Type? {
   }
 }
 
-@_silgen_name("swift_stdlib_getTypeByMangledName")
+@_silgen_name("swift_getTypeByMangledNameInEnvironment")
 internal func _getTypeByMangledName(
   _ name: UnsafePointer<UInt8>,
   _ nameLength: UInt,

stdlib/public/runtime/MetadataLookup.cpp

@@ -1269,9 +1269,9 @@ TypeInfo swift_getTypeByMangledNameImpl(
                                     substWitnessTable);
 }
 
-SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERNAL
+SWIFT_CC(swift) SWIFT_RUNTIME_EXPORT
 const Metadata * _Nullable
-swift_stdlib_getTypeByMangledName(
+swift_getTypeByMangledNameInEnvironment(
                         const char *typeNameStart,
                         size_t typeNameLength,
                         const TargetGenericEnvironment<InProcess> *environment,
@@ -1285,6 +1285,22 @@ swift_stdlib_getTypeByMangledName(
   return swift_checkMetadataState(MetadataState::Complete, metadata).Value;
 }
 
+SWIFT_CC(swift) SWIFT_RUNTIME_EXPORT
+const Metadata * _Nullable
+swift_getTypeByMangledNameInContext(
+                        const char *typeNameStart,
+                        size_t typeNameLength,
+                        const TargetContextDescriptor<InProcess> *context,
+                        const void * const *genericArgs) {
+  llvm::StringRef typeName(typeNameStart, typeNameLength);
+  SubstGenericParametersFromMetadata substitutions(context, genericArgs);
+  auto metadata = swift_getTypeByMangledName(typeName, substitutions,
+                                             substitutions);
+  if (!metadata) return nullptr;
+
+  return swift_checkMetadataState(MetadataState::Complete, metadata).Value;
+}
+
 #if SWIFT_OBJC_INTEROP
 
 // Return the ObjC class for the given type name.
@@ -1301,9 +1317,9 @@ static objc_hook_getClass OldGetClassHook;
 static BOOL
 getObjCClassByMangledName(const char * _Nonnull typeName,
                           Class _Nullable * _Nonnull outClass) {
-  auto metadata = swift_stdlib_getTypeByMangledName(typeName, strlen(typeName),
-                                                    /* no substitutions */
-                                                    nullptr, nullptr);
+  auto metadata = swift_getTypeByMangledNameInEnvironment(typeName, strlen(typeName),
+                                             /* no substitutions */
+                                             nullptr, nullptr);
   if (metadata) {
     auto objcClass =
       reinterpret_cast<Class>(
@@ -1421,9 +1437,8 @@ void SubstGenericParametersFromMetadata::setup() const {
   if (!descriptorPath.empty())
     return;
 
-  if (sourceIsMetadata && base) {
-    auto descriptor = base->getTypeContextDescriptor();
-    numKeyGenericParameters = buildDescriptorPath(descriptor);
+  if (sourceIsMetadata && baseContext) {
+    numKeyGenericParameters = buildDescriptorPath(baseContext);
     return;
   }
 

stdlib/public/runtime/Private.h

@@ -245,7 +245,7 @@ class TypeInfo {
     const bool sourceIsMetadata;
 
     union {
-      const Metadata *base;
+      const TargetContextDescriptor<InProcess> *baseContext;
       const TargetGenericEnvironment<InProcess> *environment;
     };
 
@@ -293,9 +293,16 @@ class TypeInfo {
   public:
     /// Produce substitutions entirely from the given metadata.
     explicit SubstGenericParametersFromMetadata(const Metadata *base)
-      : sourceIsMetadata(true), base(base),
+      : sourceIsMetadata(true), baseContext(base->getTypeContextDescriptor()),
         genericArgs(base ? (const void * const *)base->getGenericArgs()
                          : nullptr) { }
+    
+    /// Produce substitutions from the given instantiation arguments for the
+    /// given context.
+    explicit SubstGenericParametersFromMetadata(const ContextDescriptor *base,
+                                                const void * const *args)
+      : sourceIsMetadata(true), baseContext(base), genericArgs(args)
+    {}
 
     /// Produce substitutions from the given instantiation arguments for the
     /// given generic environment.