[ABI] Use generic environment to handle mangled generic keypath types.

Always use mangled type names to represent type metadata in keypath patterns.
For generic types, use the generic environment to pull substituted types
from the instantiation arguments.

Finishes the type metadata part of rdar://problem/38038799.

Author: DougGregor

docs/ABI/Mangling.rst

@@ -90,9 +90,9 @@ The following symbolic reference kinds are currently implemented:
    dependent-associated-conformance ::= '\x05' .{4}  // Reference points directly to associated conformance descriptor (NOT IMPLEMENTED)
    dependent-associated-conformance ::= '\x06' .{4}  // Reference points indirectly to associated conformance descriptor (NOT IMPLEMENTED)
 
-   associated-conformance-acceess-function ::= '\x07' .{4}  // Reference points directly to associated conformance access function relative to the protocol
-   associated-conformance-acceess-function ::= '\x08' .{4}  // Reference points directly to associated conformance access function relative to the conforming type
-   keypath-metadata-access-function ::= '\x09' {.4}  // Reference points directly to keypath type metadata access function
+   associated-conformance-access-function ::= '\x07' .{4}  // Reference points directly to associated conformance access function relative to the protocol
+   associated-conformance-access-function ::= '\x08' .{4}  // Reference points directly to associated conformance access function relative to the conforming type
+   keypath-metadata-access-function ::= '\x09' {.4}  // Reference points directly to keypath conformance access function
 
 Globals
 ~~~~~~~

lib/IRGen/GenKeyPath.cpp

@@ -707,34 +707,11 @@ emitMetadataGeneratorForKeyPath(IRGenModule &IGM,
                                 CanType type,
                                 GenericEnvironment *genericEnv,
                                 ArrayRef<GenericRequirement> requirements) {
-  // If we have a non-dependent type, use a normal mangled type name.
-  if (!type->hasTypeParameter()) {
-    auto constant = IGM.getTypeRef(type, MangledTypeRefRole::Metadata);
-    auto bitConstant = llvm::ConstantInt::get(IGM.IntPtrTy, 1);
-    return llvm::ConstantExpr::getGetElementPtr(nullptr, constant, bitConstant);
-  }
-
-  // Otherwise, create an accessor.
-  CanGenericSignature genericSig;
-  if (genericEnv)
-    genericSig = genericEnv->getGenericSignature()->getCanonicalSignature();
-
-  IRGenMangler mangler;
-  std::string symbolName =
-    mangler.mangleSymbolNameForKeyPathMetadata(
-      "keypath_get_type", genericSig, type,
-      ProtocolConformanceRef::forInvalid());
-
-  // TODO: Use the standard metadata accessor when there are no arguments
-  // and the metadata accessor is defined.
-  return emitGeneratorForKeyPath(IGM, symbolName, type,
-    IGM.TypeMetadataPtrTy,
-    genericEnv, requirements,
-    [&](IRGenFunction &IGF, CanType substType) {
-      auto ret = IGF.emitTypeMetadataRef(substType);
-      IGF.Builder.CreateRet(ret);
-    });
-};
+  // Produce a mangled name for the type.
+  auto constant = IGM.getTypeRef(type, MangledTypeRefRole::Metadata);
+  auto bitConstant = llvm::ConstantInt::get(IGM.IntPtrTy, 1);
+  return llvm::ConstantExpr::getGetElementPtr(nullptr, constant, bitConstant);
+}
 
 static llvm::Constant *
 emitWitnessTableGeneratorForKeyPath(IRGenModule &IGM,

stdlib/public/core/KeyPath.swift

@@ -723,9 +723,9 @@ internal final class NonmutatingWritebackBuffer<CurValue, NewValue> {
 }
 
 internal typealias KeyPathComputedArgumentLayoutFn = @convention(thin)
-  (_ patternArguments: UnsafeRawPointer) -> (size: Int, alignmentMask: Int)
+  (_ patternArguments: UnsafeRawPointer?) -> (size: Int, alignmentMask: Int)
 internal typealias KeyPathComputedArgumentInitializerFn = @convention(thin)
-  (_ patternArguments: UnsafeRawPointer,
+  (_ patternArguments: UnsafeRawPointer?,
    _ instanceArguments: UnsafeMutableRawPointer) -> ()
 
 internal enum KeyPathComputedIDKind {
@@ -2397,8 +2397,10 @@ internal func _getSymbolicMangledNameLength(_ base: UnsafeRawPointer) -> Int {
 }
 
 // Resolve the given generic argument reference to a generic argument.
-internal func _resolveKeyPathGenericArgReference(_ reference: UnsafeRawPointer,
-                                                 arguments: UnsafeRawPointer)
+internal func _resolveKeyPathGenericArgReference(
+    _ reference: UnsafeRawPointer,
+    genericEnvironment: UnsafeRawPointer?,
+    arguments: UnsafeRawPointer?)
     -> UnsafeRawPointer {
   // If the low bit is clear, it's a direct reference to the argument.
   if (UInt(bitPattern: reference) & 0x01 == 0) {
@@ -2412,7 +2414,7 @@ internal func _resolveKeyPathGenericArgReference(_ reference: UnsafeRawPointer,
   let first = referenceStart.load(as: UInt8.self)
   if first == 255 && reference.load(as: UInt8.self) == 9 {
     typealias MetadataAccessor =
-      @convention(c) (UnsafeRawPointer) -> UnsafeRawPointer
+      @convention(c) (UnsafeRawPointer?) -> UnsafeRawPointer
 
     // Unaligned load of the offset.
     let pointerReference = reference + 1
@@ -2428,7 +2430,10 @@ internal func _resolveKeyPathGenericArgReference(_ reference: UnsafeRawPointer,
   let namePtr = referenceStart.bindMemory(to: UInt8.self,
                                           capacity: nameLength + 1)
   // FIXME: Could extract this information from the mangled name.
-  guard let result = _getTypeByMangledName(namePtr, UInt(nameLength))
+  guard let result =
+    _getTypeByMangledName(namePtr, UInt(nameLength),
+                         genericEnvironment: genericEnvironment,
+                         genericArguments: arguments)
     else {
       let nameStr = String._fromUTF8Repairing(
         UnsafeBufferPointer(start: namePtr, count: nameLength)
@@ -2441,11 +2446,16 @@ internal func _resolveKeyPathGenericArgReference(_ reference: UnsafeRawPointer,
 }
 
 // Resolve the given metadata reference to (type) metadata.
-internal func _resolveKeyPathMetadataReference(_ reference: UnsafeRawPointer,
-                                               arguments: UnsafeRawPointer)
+internal func _resolveKeyPathMetadataReference(
+    _ reference: UnsafeRawPointer,
+    genericEnvironment: UnsafeRawPointer?,
+    arguments: UnsafeRawPointer?)
     -> Any.Type {
   return unsafeBitCast(
-           _resolveKeyPathGenericArgReference(reference, arguments: arguments),
+           _resolveKeyPathGenericArgReference(
+             reference,
+             genericEnvironment: genericEnvironment,
+             arguments: arguments),
            to: Any.Type.self)
 }
 
@@ -2797,9 +2807,10 @@ internal struct GetKeyPathClassAndInstanceSizeFromPattern
   var didChain: Bool = false
   var root: Any.Type!
   var leaf: Any.Type!
-  let patternArgs: UnsafeRawPointer
+  var genericEnvironment: UnsafeRawPointer?
+  let patternArgs: UnsafeRawPointer?
 
-  init(patternArgs: UnsafeRawPointer) {
+  init(patternArgs: UnsafeRawPointer?) {
     self.patternArgs = patternArgs
   }
 
@@ -2811,12 +2822,17 @@ internal struct GetKeyPathClassAndInstanceSizeFromPattern
                             rootMetadataRef: MetadataReference,
                             leafMetadataRef: MetadataReference,
                             kvcCompatibilityString: UnsafeRawPointer?) {
+    self.genericEnvironment = genericEnvironment
     // Get the root and leaf type metadata so we can form the class type
     // for the entire key path.
-    root = _resolveKeyPathMetadataReference(rootMetadataRef,
-                                            arguments: patternArgs)
-    leaf = _resolveKeyPathMetadataReference(leafMetadataRef,
-                                            arguments: patternArgs)
+    root = _resolveKeyPathMetadataReference(
+              rootMetadataRef,
+              genericEnvironment: genericEnvironment,
+              arguments: patternArgs)
+    leaf = _resolveKeyPathMetadataReference(
+              leafMetadataRef,
+              genericEnvironment: genericEnvironment,
+              arguments: patternArgs)
   }
 
   mutating func visitStoredComponent(kind: KeyPathStructOrClass,
@@ -2997,11 +3013,12 @@ internal func _getKeyPathClassAndInstanceSizeFromPattern(
 
 internal struct InstantiateKeyPathBuffer : KeyPathPatternVisitor {
   var destData: UnsafeMutableRawBufferPointer
-  let patternArgs: UnsafeRawPointer
+  var genericEnvironment: UnsafeRawPointer?
+  let patternArgs: UnsafeRawPointer?
   var base: Any.Type
 
   init(destData: UnsafeMutableRawBufferPointer,
-       patternArgs: UnsafeRawPointer,
+       patternArgs: UnsafeRawPointer?,
        root: Any.Type) {
     self.destData = destData
     self.patternArgs = patternArgs
@@ -3044,6 +3061,7 @@ internal struct InstantiateKeyPathBuffer : KeyPathPatternVisitor {
                             rootMetadataRef: MetadataReference,
                             leafMetadataRef: MetadataReference,
                             kvcCompatibilityString: UnsafeRawPointer?) {
+    self.genericEnvironment = genericEnvironment
   }
 
   mutating func visitStoredComponent(kind: KeyPathStructOrClass,
@@ -3213,8 +3231,10 @@ internal struct InstantiateKeyPathBuffer : KeyPathPatternVisitor {
         let base = externalArgs.baseAddress.unsafelyUnwrapped + i
         let offset = base.pointee
         let metadataRef = UnsafeRawPointer(base) + Int(offset)
-        let result = _resolveKeyPathGenericArgReference(metadataRef,
-                                                       arguments: patternArgs)
+        let result = _resolveKeyPathGenericArgReference(
+                       metadataRef,
+                       genericEnvironment: genericEnvironment,
+                       arguments: patternArgs)
         pushDest(result)
       }
     }
@@ -3238,8 +3258,10 @@ internal struct InstantiateKeyPathBuffer : KeyPathPatternVisitor {
 
   mutating func visitIntermediateComponentType(metadataRef: MetadataReference) {
     // Get the metadata for the intermediate type.
-    let metadata = _resolveKeyPathMetadataReference(metadataRef,
-                                                    arguments: patternArgs)
+    let metadata = _resolveKeyPathMetadataReference(
+                     metadataRef,
+                     genericEnvironment: genericEnvironment,
+                     arguments: patternArgs)
     pushDest(metadata)
     base = metadata
   }

stdlib/public/core/Misc.swift

@@ -85,12 +85,16 @@ func _typeByName(_ name: String) -> Any.Type? {
   let nameUTF8 = Array(name.utf8)
   return nameUTF8.withUnsafeBufferPointer { (nameUTF8) in
     return  _getTypeByMangledName(nameUTF8.baseAddress!,
-                                  UInt(nameUTF8.endIndex))
+                                  UInt(nameUTF8.endIndex),
+                                  genericEnvironment: nil,
+                                  genericArguments: nil)
   }
 }
 
 @_silgen_name("swift_stdlib_getTypeByMangledName")
 internal func _getTypeByMangledName(
   _ name: UnsafePointer<UInt8>,
-  _ nameLength: UInt)
+  _ nameLength: UInt,
+  genericEnvironment: UnsafeRawPointer?,
+  genericArguments: UnsafeRawPointer?)
   -> Any.Type?

stdlib/public/runtime/MetadataLookup.cpp

@@ -1270,15 +1270,15 @@ TypeInfo swift_getTypeByMangledNameImpl(
 
 SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERNAL
 const Metadata * _Nullable
-swift_stdlib_getTypeByMangledName(const char *typeNameStart,
-                                  size_t typeNameLength) {
+swift_stdlib_getTypeByMangledName(
+                        const char *typeNameStart,
+                        size_t typeNameLength,
+                        const TargetGenericEnvironment<InProcess> *environment,
+                        const void * const *genericArgs) {
   llvm::StringRef typeName(typeNameStart, typeNameLength);
-  auto metadata =
-    swift_getTypeByMangledName(
-      typeName,
-      [](unsigned depth, unsigned index) { return nullptr; },
-      [](const Metadata *type, unsigned index) { return nullptr; });
-
+  SubstGenericParametersFromMetadata substitutions(environment, genericArgs);
+  auto metadata = swift_getTypeByMangledName(typeName, substitutions,
+                                             substitutions);
   if (!metadata) return nullptr;
 
   return swift_checkMetadataState(MetadataState::Complete, metadata).Value;
@@ -1318,12 +1318,58 @@ buildDescriptorPath(const ContextDescriptor *context) const {
   return numKeyGenericParamsInParent + numKeyGenericParamsHere;
 }
 
+  /// Builds a path from the generic environment.
+unsigned SubstGenericParametersFromMetadata::
+buildEnvironmentPath(
+    const TargetGenericEnvironment<InProcess> *environment) const {
+  unsigned totalParamCount = 0;
+  unsigned totalKeyParamCount = 0;
+  auto genericParams = environment->getGenericParameters();
+  for (unsigned numLocalParams : environment->getGenericParameterCounts()) {
+    // Get the local generic parameters.
+    auto localGenericParams = genericParams.slice(0, numLocalParams);
+    genericParams = genericParams.slice(numLocalParams);
+
+    // Count the parameters.
+    unsigned numKeyGenericParamsInParent = totalKeyParamCount;
+    unsigned numKeyGenericParamsHere = 0;
+    bool hasNonKeyGenericParams = false;
+    for (const auto &genericParam : localGenericParams) {
+      if (genericParam.hasKeyArgument())
+        ++numKeyGenericParamsHere;
+      else
+        hasNonKeyGenericParams = true;
+    }
+
+    // Update totals.
+    totalParamCount += numLocalParams;
+    totalKeyParamCount += numKeyGenericParamsHere;
+
+    // Add to the descriptor path.
+    descriptorPath.push_back(PathElement{localGenericParams,
+                                         totalParamCount,
+                                         numKeyGenericParamsInParent,
+                                         numKeyGenericParamsHere,
+                                         hasNonKeyGenericParams});
+  }
+
+  return totalKeyParamCount;
+}
+
 void SubstGenericParametersFromMetadata::setup() const {
-  if (!descriptorPath.empty() || !base)
+  if (!descriptorPath.empty())
     return;
 
-  auto descriptor = base->getTypeContextDescriptor();
-  numKeyGenericParameters = buildDescriptorPath(descriptor);
+  if (sourceIsMetadata && base) {
+    auto descriptor = base->getTypeContextDescriptor();
+    numKeyGenericParameters = buildDescriptorPath(descriptor);
+    return;
+  }
+
+  if (!sourceIsMetadata && environment) {
+    numKeyGenericParameters = buildEnvironmentPath(environment);
+    return;
+  }
 }
 
 const Metadata *

stdlib/public/runtime/Private.h

@@ -241,7 +241,13 @@ class TypeInfo {
   /// Use with \c _getTypeByMangledName to decode potentially-generic
   /// types.
   class SWIFT_RUNTIME_LIBRARY_VISIBILITY SubstGenericParametersFromMetadata {
-    const Metadata *base;
+    /// Whether the source is metadata (vs. a generic environment);
+    const bool sourceIsMetadata;
+
+    union {
+      const Metadata *base;
+      const TargetGenericEnvironment<InProcess> *environment;
+    };
 
     /// The generic arguments.
     const void * const *genericArgs;
@@ -277,16 +283,28 @@ class TypeInfo {
     /// the path up to this point.
     unsigned buildDescriptorPath(const ContextDescriptor *context) const;
 
+    /// Builds a path from the generic environment.
+    unsigned buildEnvironmentPath(
+               const TargetGenericEnvironment<InProcess> *environment) const;
+
     // Set up the state we need to compute substitutions.
     void setup() const;
 
   public:
     /// Produce substitutions entirely from the given metadata.
     explicit SubstGenericParametersFromMetadata(const Metadata *base)
-      : base(base),
+      : sourceIsMetadata(true), base(base),
         genericArgs(base ? (const void * const *)base->getGenericArgs()
                          : nullptr) { }
 
+    /// Produce substitutions from the given instantiation arguments for the
+    /// given generic environment.
+    explicit SubstGenericParametersFromMetadata(
+               const TargetGenericEnvironment<InProcess> *environment,
+               const void * const *arguments)
+      : sourceIsMetadata(false), environment(environment),
+        genericArgs(arguments) { }
+
     const Metadata *operator()(unsigned depth, unsigned index) const;
     const WitnessTable *operator()(const Metadata *type, unsigned index) const;
   };

test/IRGen/keypaths.sil

@@ -183,8 +183,9 @@ sil_vtable C2 {}
 // -- %i: Gen<A>.x
 // CHECK: [[KP_I:@keypath(\..*)?]] = private global <{ {{.*}} }> <{
 // CHECK-SAME: i32 0
-// CHECK-SAME: @"keypath_get_type
-// CHECK-SAME: @"keypath_get_type
+// CHECK-SAME: @"generic environment l"
+// CHECK-SAME: @"symbolic 8keypaths3GenVyxxG"
+// CHECK-SAME: @"symbolic x"
 //             -- size 8
 // CHECK-SAME: i32 8,
 //             -- struct with runtime-resolved offset, mutable
@@ -196,8 +197,8 @@ sil_vtable C2 {}
 // CHECK: [[KP_J:@keypath(\..*)?]] = private global <{ {{.*}} }> <{
 // CHECK-SAME: i32 0
 // CHECK-SAME: @"generic environment l"
-// CHECK-SAME: @"keypath_get_type
-// CHECK-SAME: @"keypath_get_type
+// CHECK-SAME: @"symbolic 8keypaths3GenVyxxG"
+// CHECK-SAME: @"symbolic x"
 //             -- size 8
 // CHECK-SAME: i32 8,
 //             -- struct with runtime-resolved offset
@@ -210,14 +211,14 @@ sil_vtable C2 {}
 
 // -- %t
 // CHECK: [[KP_T:@keypath(\..*)?]] = private global <{ {{.*}} }> <{ {{.*}} i32 1, {{.*}} @"got.$s8keypaths1GV1xxvpMV"
-// CHECK-SAME:   @"keypath_get_type
+// CHECK-SAME:   @"symbolic x"
 //            -- computed get-only property, identified by indirect pointer
 // CHECK-SAME:   <i32 0x0208_0002>
 
 // -- %u
 // CHECK: [[KP_U:@keypath(\..*)?]] = private global <{ {{.*}} }> <{ {{.*}} i32 3, {{.*}} @"got.$s8keypaths1GVyxqd__cSHRd__luipMV"
-// CHECK-SAME:   @"keypath_get_type
-// CHECK-SAME:   @"keypath_get_type
+// CHECK-SAME:   @"symbolic q_"
+// CHECK-SAME:   @"symbolic x"
 // CHECK-SAME:   @"keypath_get_witness_table
 //            -- computed get-only property, identified by indirect pointer
 // CHECK-SAME:   <i32 0x0208_0002>