Manually define _rawHashValue in compatibility libraries, AST fixes for builtin protocol conformance

Remember to use substituted type in builtin conformance substitution

Author: Azoy

lib/AST/ProtocolConformance.cpp

@@ -1170,9 +1170,24 @@ ProtocolConformance::subst(TypeSubstitutionFn subs,
                                    const_cast<ProtocolConformance *>(this),
                                    subMap);
   }
-  case ProtocolConformanceKind::Self:
-  case ProtocolConformanceKind::Builtin:
+  case ProtocolConformanceKind::Self: {
     return const_cast<ProtocolConformance*>(this);
+  }
+  case ProtocolConformanceKind::Builtin: {
+    auto origType = getType();
+    if (!origType->hasTypeParameter() &&
+        !origType->hasArchetype())
+      return const_cast<ProtocolConformance *>(this);
+
+    auto substType = origType.subst(subs, conformances, options);
+    if (substType->isEqual(origType))
+      return const_cast<ProtocolConformance *>(this);
+
+    // All builtin conformances are concrete at the moment, so it's safe to
+    // directly call getConcrete.
+    return getProtocol()->getModuleContext()
+      ->lookupConformance(substType, getProtocol()).getConcrete();
+  }
   case ProtocolConformanceKind::Inherited: {
     // Substitute the base.
     auto inheritedConformance

lib/AST/SubstitutionMap.cpp

@@ -420,7 +420,19 @@ SubstitutionMap::lookupConformance(CanType type, ProtocolDecl *proto) const {
     // For the second step, we're looking into the requirement signature for
     // this protocol.
     auto concrete = conformance.getConcrete();
-    auto normal = concrete->getRootNormalConformance();
+    auto root = concrete->getRootConformance();
+
+    // If we see a builtin conformance here as the root, simply lookup the
+    // conformance for the substitute type.
+    if (isa<BuiltinProtocolConformance>(root)) {
+      auto substType = type.subst(*this);
+      if (substType->hasError())
+        return ProtocolConformanceRef(proto);
+
+      return proto->getParentModule()->lookupConformance(substType, proto);
+    }
+
+    auto normal = cast<NormalProtocolConformance>(root);
 
     // If we haven't set the signature conformances yet, force the issue now.
     if (normal->getSignatureConformances().empty()) {

stdlib/toolchain/Compatibility53/BuiltinProtocolConformances.cpp

@@ -497,6 +497,27 @@ void _emplaceTupleHashableDescriptor() {
   *tupleHashableConf = intptr_t(hashable) - intptr_t(tupleHashableConf);
 }
 
+using RawHashValueFn = SWIFT_CC(swift) intptr_t(intptr_t seed,
+                                                const Metadata *Self,
+                                                const WitnessTable *witnessTable,
+                                                SWIFT_CONTEXT OpaqueValue *value);
+
+static RawHashValueFn *get_rawHashValueDefaultImplFunc() {
+  auto func = SWIFT_LAZY_CONSTANT(
+    reinterpret_cast<RawHashValueFn *>(
+                    dlsym(RTLD_DEFAULT, "$sSHsE13_rawHashValue4seedS2i_tF")));
+  return func;
+}
+
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+intptr_t _swift_tupleHashable_rawHashValue(intptr_t seed,
+                                           SWIFT_CONTEXT OpaqueValue *tuple,
+                                           const Metadata *Self,
+                                           const WitnessTable *witnessTable) {
+  auto _rawHashValue = get_rawHashValueDefaultImplFunc();
+  return _rawHashValue(seed, Self, witnessTable, tuple);
+}
+
 // The base Equatable protocol is itself a requirement, thus the requirement
 // count is 4 (Equatable + hashValue + hash(into:) + _rawHashValue) and the
 // witness is the tuple Equatable table.
@@ -507,24 +528,10 @@ _WitnessTable<4> _swift_tupleHashable_wt = {
     reinterpret_cast<const void *>(&_swift_tupleEquatable_wt),
     reinterpret_cast<void *>(_swift_tupleHashable_hashValue),
     reinterpret_cast<void *>(_swift_tupleHashable_hash),
-    nullptr
+    reinterpret_cast<void *>(_swift_tupleHashable_rawHashValue)
   }
 };
 
-static void *get_rawHashValueDefaultImplFunc() {
-  auto impl = SWIFT_LAZY_CONSTANT(
-    dlsym(RTLD_DEFAULT, "$sSHsE13_rawHashValue4seedS2i_tF"));
-  return impl;
-}
-
-// Due to the fact that the compatibility libraries can't have a hard
-// dependency to libswiftCore (which is where the _rawHashValue default impl
-// lives), we have to manually implant this before calling any user code.
-__attribute__((constructor))
-void _emplaceTupleHashable_rawHashValueDefaultImpl() {
-  _swift_tupleHashable_wt.Witnesses[3] = get_rawHashValueDefaultImplFunc();
-}
-
 using HashValueFn = SWIFT_CC(swift) intptr_t(OpaqueValue *value, Metadata *Self,
                                              void *witnessTable);
 using HasherCombineFn = SWIFT_CC(swift) void(OpaqueValue *value,
@@ -533,17 +540,17 @@ using HasherCombineFn = SWIFT_CC(swift) void(OpaqueValue *value,
                                              SWIFT_CONTEXT OpaqueValue *hasher);
 
 static HashValueFn *get_hashValueFunc() {
-  auto descriptor = SWIFT_LAZY_CONSTANT(
+  auto func = SWIFT_LAZY_CONSTANT(
     reinterpret_cast<HashValueFn *>(
                      dlsym(RTLD_DEFAULT, XSTR(SWIFT_HASHVALUE_FUNC))));
-  return descriptor;
+  return func;
 }
 
 static HasherCombineFn *getHashCombineFunc() {
-  auto descriptor = SWIFT_LAZY_CONSTANT(
+  auto func = SWIFT_LAZY_CONSTANT(
     reinterpret_cast<HasherCombineFn *>(
                      dlsym(RTLD_DEFAULT, XSTR(SWIFT_HASHER_COMBINE_FUNC))));
-  return descriptor;
+  return func;
 }
 
 SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)

test/IRGen/builtin_conformances.swift

@@ -74,15 +74,15 @@ public func hashValue<T: Hashable>(for instance: T) -> Int {
 
 public func useHashable<T: Hashable>(_ thing: T) -> Int {
   // CHECK: [[USE_HASHABLE_WT:%.*]] = call i8** @swift_getWitnessTable(%swift.protocol_conformance_descriptor* @_swift_tupleHashable_conf, %swift.type* {{%.*}}, i8*** {{%.*}})
-  // CHECK-NEXT: {{%.*}} = call swiftcc i64 {{.*}}(%swift.opaque* noalias nocapture {{%.*}}, %swift.type* {{%.*}}, i8** [[USE_HASHABLE_WT]])
+  // CHECK-NEXT: {{%.*}} = call swiftcc i{{.*}} {{.*}}(%swift.opaque* noalias nocapture {{%.*}}, %swift.type* {{%.*}}, i8** [[USE_HASHABLE_WT]])
   hashValue(for: (thing, thing))
 }
 
 public func testTupleHashable() {
   // CHECK: [[TEST_TUPLE_HASHABLE_WT1:%.*]] = call i8** @swift_getWitnessTable(%swift.protocol_conformance_descriptor* @_swift_tupleHashable_conf, %swift.type* getelementptr inbounds (%swift.full_type, %swift.full_type* @"$sytN", i32 0, i32 1), i8*** undef)
-  // CHECK: {{%.*}} = call swiftcc i64 {{.*}}(%swift.opaque* noalias nocapture undef, %swift.type* getelementptr inbounds (%swift.full_type, %swift.full_type* @"$sytN", i32 0, i32 1), i8** [[TEST_TUPLE_HASHABLE_WT1]])
+  // CHECK: {{%.*}} = call swiftcc i{{.*}} {{.*}}(%swift.opaque* noalias nocapture undef, %swift.type* getelementptr inbounds (%swift.full_type, %swift.full_type* @"$sytN", i32 0, i32 1), i8** [[TEST_TUPLE_HASHABLE_WT1]])
   let _ = hashValue(for: ())
 
-  // CHECK: {{%.*}} = call swiftcc i64 {{.*}}(%swift.type* {{%.*}}, i8** [[TEST_TUPLE_HASHABLE_WT1]], {{%.*}} noalias nocapture swiftself undef)
+  // CHECK: {{%.*}} = call swiftcc i{{.*}} {{.*}}(%swift.type* {{%.*}}, i8** [[TEST_TUPLE_HASHABLE_WT1]], {{%.*}} noalias nocapture swiftself undef)
   let _ = Wrapper(value: ()).hashValue
 }