[Keypaths] Start using mangled type names for non-dependent types.

When a type in keypath metadata is non-dependent, use a mangled type name
rather than a symbolic reference to an accessor function.

Part of rdar://problem/38038799.

Author: DougGregor

lib/IRGen/GenKeyPath.cpp

@@ -706,8 +706,14 @@ emitMetadataGeneratorForKeyPath(IRGenModule &IGM,
                                 CanType type,
                                 GenericEnvironment *genericEnv,
                                 ArrayRef<GenericRequirement> requirements) {
-  // TODO: Use a mangled name when we can.
+  // 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();

lib/IRGen/MetadataRequest.cpp

@@ -222,10 +222,19 @@ llvm::Constant *IRGenModule::getAddrOfStringForMetadataRef(
     StringRef symbolName,
     bool shouldSetLowBit,
     llvm::function_ref<ConstantInitFuture (ConstantInitBuilder &)> body) {
+  // Call this to form the return value.
+  auto returnValue = [&](llvm::Constant *addr) {
+    if (!shouldSetLowBit)
+      return addr;
+
+    auto bitConstant = llvm::ConstantInt::get(IntPtrTy, 1);
+    return llvm::ConstantExpr::getGetElementPtr(nullptr, addr, bitConstant);
+  };
+
   // Check whether we already have an entry with this name.
   auto &entry = StringsForTypeRef[symbolName];
   if (entry.second) {
-    return entry.second;
+    return returnValue(entry.second);
   }
 
   // Construct the initializer.
@@ -250,16 +259,9 @@ llvm::Constant *IRGenModule::getAddrOfStringForMetadataRef(
 
   // Drill down to the i8* at the beginning of the constant.
   auto addr = llvm::ConstantExpr::getBitCast(var, Int8PtrTy);
-
-  // If requested, set the low bit.
-  if (shouldSetLowBit) {
-    auto bitConstant = llvm::ConstantInt::get(IntPtrTy, 1);
-    addr = llvm::ConstantExpr::getGetElementPtr(nullptr, addr, bitConstant);
-  }
-
   StringsForTypeRef[symbolName] = { var, addr };
 
-  return addr;
+  return returnValue(addr);
 }
 
 llvm::Constant *IRGenModule::getAddrOfStringForTypeRef(StringRef str,

stdlib/public/core/KeyPath.swift

@@ -2378,6 +2378,24 @@ public func _swift_getKeyPath(pattern: UnsafeMutableRawPointer,
 // A reference to metadata, which is a pointer to a mangled name.
 internal typealias MetadataReference = UnsafeRawPointer
 
+// Determine the length of the given mangled name.
+internal func _getSymbolicMangledNameLength(_ base: UnsafeRawPointer) -> Int {
+  var end = base
+  while let current = Optional(end.load(as: UInt8.self)), current != 0 {
+    // Skip the current character
+    end = end + 1
+
+    // Skip over a symbolic reference
+    if current >= 0x1 && current <= 0x17 {
+      end += 4
+    } else if current >= 0x18 && current <= 0x1F {
+      end += MemoryLayout<Int>.size
+    }
+  }
+
+  return end - base
+}
+
 // Resolve the given generic argument reference to a generic argument.
 internal func _resolveKeyPathGenericArgReference(_ reference: UnsafeRawPointer,
                                                  arguments: UnsafeRawPointer)
@@ -2405,7 +2423,23 @@ internal func _resolveKeyPathGenericArgReference(_ reference: UnsafeRawPointer,
     return accessor(arguments)
   }
 
-  fatalError("unhandled keypath metadata reference")
+  let nameLength = _getSymbolicMangledNameLength(referenceStart)
+  let namePtr = referenceStart.bindMemory(to: UInt8.self,
+                                          capacity: nameLength + 1)
+  // FIXME: Could extract this information from the mangled name.
+  let parametersPerLevel: [UInt] = []
+  let substitutions: [Any.Type] = []
+  guard let result = _getTypeByMangledName(namePtr, UInt(nameLength), 0,
+                                           parametersPerLevel, substitutions)
+    else {
+      let nameStr = String._fromUTF8Repairing(
+        UnsafeBufferPointer(start: namePtr, count: nameLength)
+      ).0
+
+      fatalError("could not demangle keypath type from '\(nameStr)'")
+    }
+
+  return unsafeBitCast(result, to: UnsafeRawPointer.self)
 }
 
 // Resolve the given metadata reference to (type) metadata.

test/IRGen/keypaths.sil

@@ -47,8 +47,8 @@ sil_vtable C2 {}
 // -- %a: S.x
 // CHECK: [[KP_A:@keypath(\..*)?]] = private global <{ {{.*}} }> <{
 // CHECK-SAME: [[WORD]]* @keypath_once
-// CHECK-SAME: @"keypath_get_type 8keypaths1SV
-// CHECK-SAME: @"keypath_get_type Si
+// CHECK-SAME: @"symbolic 8keypaths1SV"
+// CHECK-SAME: @"symbolic Si
 //               -- instantiable in-line, size 4
 // CHECK-SAME: <i32 0x8000_0004>,
 // -- offset of S.x, mutable
@@ -57,8 +57,8 @@ sil_vtable C2 {}
 // -- %b: S.y
 // CHECK: [[KP_B:@keypath(\..*)?]] = private global <{ {{.*}} }> <{
 // CHECK-SAME: [[WORD]]* @keypath_once
-// CHECK-SAME: @"keypath_get_type 8keypaths1SV
-// CHECK-SAME: @"keypath_get_type SS
+// CHECK-SAME: @"symbolic 8keypaths1SV
+// CHECK-SAME: @"symbolic SS
 //               -- instantiable in-line, size 4
 // CHECK-SAME: <i32 0x8000_0004>,
 // -- offset of S.y, immutable
@@ -68,8 +68,8 @@ sil_vtable C2 {}
 // -- %c: S.z
 // CHECK: [[KP_C:@keypath(\..*)?]] = private global <{ {{.*}} }> <{
 // CHECK-SAME: [[WORD]]* @keypath_once
-// CHECK-SAME: @"keypath_get_type 8keypaths1SV
-// CHECK-SAME: @"keypath_get_type 8keypaths1CC
+// CHECK-SAME: @"symbolic 8keypaths1SV
+// CHECK-SAME: @"symbolic 8keypaths1CC
 //               -- instantiable in-line, size 4
 // CHECK-SAME: <i32 0x8000_0004>,
 // -- offset of S.z, mutable
@@ -79,8 +79,8 @@ sil_vtable C2 {}
 // -- %d: C.x
 // CHECK: [[KP_D:@keypath(\..*)?]] = private global <{ {{.*}} }> <{
 // CHECK-SAME: [[WORD]]* @keypath_once
-// CHECK-SAME: @"keypath_get_type
-// CHECK-SAME: @"keypath_get_type
+// CHECK-SAME: @"symbolic
+// CHECK-SAME: @"symbolic
 //               -- instantiable in-line, size 4
 // CHECK-SAME: <i32 0x8000_0004>,
 // -- 0x0300_0000 (class) + mutable + offset of C.x
@@ -90,8 +90,8 @@ sil_vtable C2 {}
 // -- %e: C.y
 // CHECK: [[KP_E:@keypath(\..*)?]] = private global <{ {{.*}} }> <{
 // CHECK-SAME: [[WORD]]* @keypath_once
-// CHECK-SAME: @"keypath_get_type
-// CHECK-SAME: @"keypath_get_type
+// CHECK-SAME: @"symbolic
+// CHECK-SAME: @"symbolic
 //               -- instantiable in-line, size 4
 // CHECK-SAME: <i32 0x8000_0004>,
 // -- 0x0300_0000 (class) + immutable + offset of C.y
@@ -101,8 +101,8 @@ sil_vtable C2 {}
 // -- %f: C.z
 // CHECK: [[KP_F:@keypath(\..*)?]] = private global <{ {{.*}} }> <{
 // CHECK-SAME: [[WORD]]* @keypath_once
-// CHECK-SAME: @"keypath_get_type
-// CHECK-SAME: @"keypath_get_type
+// CHECK-SAME: @"symbolic
+// CHECK-SAME: @"symbolic
 //               -- instantiable in-line, size 4
 // CHECK-SAME: <i32 0x8000_0004>,
 // -- 0x0300_0000 (class) + mutable offset of C.z
@@ -112,36 +112,36 @@ sil_vtable C2 {}
 // -- %g: S.z.x
 // CHECK: [[KP_G:@keypath(\..*)?]] = private global <{ {{.*}} }> <{
 // CHECK-SAME: [[WORD]]* @keypath_once
-// CHECK-SAME: @"keypath_get_type
-// CHECK-SAME: @"keypath_get_type
+// CHECK-SAME: @"symbolic
+// CHECK-SAME: @"symbolic
 //                  -- instantiable in-line, size 12
 // CHECK-SAME: <i32 0x8000_000c>,
 // -- offset of S.z
 // CHECK-32-SAME: <i32 0x0180_0010>,
 // CHECK-64-SAME: <i32 0x0180_0018>,
-// CHECK: @"keypath_get_type
+// CHECK: @"symbolic
 // -- 0x0300_0000 (class) + offset of C.x
 // CHECK-32-SAME: <i32 0x0380_0008> }>
 // CHECK-64-SAME: <i32 0x0380_0010> }>
 
 // -- %h: C.z.x
 // CHECK: [[KP_H:@keypath(\..*)?]] = private global <{ {{.*}} }> <{
 // CHECK-SAME: [[WORD]]* @keypath_once
-// CHECK-SAME: @"keypath_get_type
-// CHECK-SAME: @"keypath_get_type
+// CHECK-SAME: @"symbolic
+// CHECK-SAME: @"symbolic
 // CHECK-SAME: <i32 0x8000_000c>,
 // -- 0x0300_0000 (class) + offset of C.z
 // CHECK-32-SAME: <i32 0x0380_0018>,
 // CHECK-64-SAME: <i32 0x0380_0028>,
-// CHECK: @"keypath_get_type
+// CHECK: @"symbolic
 // -- offset of S.x
 // CHECK-SAME: <i32 0x0180_0000> }>
 
 // -- %k: computed
 // CHECK: [[KP_K:@keypath(\..*)?]] = private global <{ {{.*}} }> <{
 // CHECK-SAME: [[WORD]]* @keypath_once
-// CHECK-SAME: @"keypath_get_type
-// CHECK-SAME: @"keypath_get_type
+// CHECK-SAME: @"symbolic
+// CHECK-SAME: @"symbolic
 //              -- instantiable in-line, size 12
 // CHECK-SAME: <i32 0x8000_000c>,
 // -- computed, get-only, identified by (indirected) function pointer, no args
@@ -152,8 +152,8 @@ sil_vtable C2 {}
 // -- %l: computed
 // CHECK: [[KP_L:@keypath(\..*)?]] = private global <{ {{.*}} }> <{
 // CHECK-SAME: [[WORD]]* @keypath_once
-// CHECK-SAME: @"keypath_get_type
-// CHECK-SAME: @"keypath_get_type
+// CHECK-SAME: @"symbolic
+// CHECK-SAME: @"symbolic
 //              -- instantiable in-line, size 16
 // CHECK-SAME: <i32 0x8000_0010>,
 // -- computed, settable, nonmutating, identified by indirect pointer, no args
@@ -165,8 +165,8 @@ sil_vtable C2 {}
 // -- %m: computed
 // CHECK: [[KP_M:@keypath(\..*)?]] = private global <{ {{.*}} }> <{
 // CHECK-SAME: [[WORD]]* @keypath_once
-// CHECK-SAME: @"keypath_get_type
-// CHECK-SAME: @"keypath_get_type
+// CHECK-SAME: @"symbolic
+// CHECK-SAME: @"symbolic
 //              -- instantiable in-line, size 16
 // CHECK-SAME: <i32 0x8000_0010>,
 // -- computed, settable, nonmutating, identified by property offset, no args