Implement same type checking at runtime

Author: Azoy

include/swift/Demangling/TypeDecoder.h

@@ -877,7 +877,9 @@ class TypeDecoder {
     case NodeKind::DependentGenericParamType: {
       auto depth = Node->getChild(0)->getIndex();
       auto index = Node->getChild(1)->getIndex();
-      return Builder.createGenericTypeParameterType(depth, index);
+      return TypeLookupErrorOr<BuiltType>(
+          Builder.createGenericTypeParameterType(depth, index),
+          /*ignoreValueCheck*/ true);
     }
     case NodeKind::EscapingObjCBlock:
     case NodeKind::ObjCBlock:

include/swift/Demangling/TypeLookupError.h

@@ -172,8 +172,8 @@ template <typename T> class TypeLookupErrorOr {
 public:
   TypeLookupErrorOr() : Value(TypeLookupError("freshly constructed error")) {}
 
-  TypeLookupErrorOr(const T &t) : Value(t) {
-    if (!t)
+  TypeLookupErrorOr(const T &t, bool ignoreValueCheck = false) : Value(t) {
+    if (!t && !ignoreValueCheck)
       Value = TypeLookupError("unknown error");
   }
 

stdlib/public/runtime/MetadataLookup.cpp

@@ -2443,7 +2443,12 @@ class DecodedMetadataBuilder {
   }
 
   TypeLookupErrorOr<BuiltType> createIntegerType(intptr_t value) {
-    return BuiltType(value);
+    // Note: We explicitly ignore the value check here because when the
+    // integer happens to be '0', we'll compare a MetadataPackOrValue against
+    // 'nullptr' which this is. We know this is still a good value for
+    // integers.
+    return TypeLookupErrorOr<BuiltType>(BuiltType(value),
+                                        /*ignoreValueCheck*/ true);
   }
 
   TypeLookupErrorOr<BuiltType> createNegativeIntegerType(intptr_t value) {
@@ -2785,7 +2790,7 @@ swift::getTypePackByMangledName(StringRef typeName,
   return type.getType().getMetadataPack();
 }
 
-TypeLookupErrorOr<size_t>
+TypeLookupErrorOr<intptr_t>
 swift::getTypeValueByMangledName(StringRef typeName,
                                 const void *const *origArgumentVector,
                                 SubstGenericParameterFn substGenericParam,
@@ -2800,15 +2805,14 @@ swift::getTypeValueByMangledName(StringRef typeName,
                                  substWitnessTable);
   auto type = Demangle::decodeMangledType(builder, node);
 
-  if (type.isError()) {
+  if (type.isError())
     return *type.getError();
-  }
-
-  if (!type.getType()) {
-    return TypeLookupError("NULL type but no error provided");
-  }
 
-  return type.getType().getValue();
+  // Note: We explicitly ignore the value check here because when the
+  // integer happens to be '0', we'll do '!value' which in this case converts
+  // the integer to a boolean, but '0' is a valid value.
+  return TypeLookupErrorOr<intptr_t>(type.getType().getValue(),
+                                     /*ignoreValueCheck*/ true);
 }
 
 // ==== Function metadata functions ----------------------------------------------

stdlib/public/runtime/Private.h

@@ -523,7 +523,7 @@ class TypeInfo {
   /// \p substWitnessTable Function that provides witness tables given a
   /// particular dependent conformance index.
   SWIFT_RUNTIME_LIBRARY_VISIBILITY
-  TypeLookupErrorOr<size_t> getTypeValueByMangledName(
+  TypeLookupErrorOr<intptr_t> getTypeValueByMangledName(
                                StringRef typeName,
                                const void * const *arguments,
                                SubstGenericParameterFn substGenericParam,

stdlib/public/runtime/ProtocolConformance.cpp

@@ -1654,8 +1654,51 @@ checkGenericValueRequirement(const GenericRequirementDescriptor &req,
                              SubstGenericParameterFn substGenericParam,
                              SubstDependentWitnessTableFn substWitnessTable,
                      llvm::SmallVectorImpl<InvertibleProtocolSet> &suppressed) {
-  // FIXME: implement
-  return std::nullopt;
+  assert(req.getFlags().isValueRequirement());
+
+  // Make sure we understand the requirement we're dealing with.
+  if (!req.hasKnownKind())
+    return TypeLookupError("unknown kind");
+
+  // Resolve the subject generic value.
+  auto result = swift::getTypeValueByMangledName(
+      req.getParam(), extraArguments.data(),
+      substGenericParam, substWitnessTable);
+
+  if (result.getError())
+    return *result.getError();
+
+  auto subjectValue = result.getType();
+
+  // Check the requirement.
+  switch (req.getKind()) {
+  case GenericRequirementKind::SameType: {
+    // Resolve the constraint generic value.
+    auto result = swift::getTypeValueByMangledName(
+        req.getMangledTypeName(), extraArguments.data(),
+        substGenericParam, substWitnessTable);
+
+    if (result.getError())
+      return *result.getError();
+
+    auto constraintValue = result.getType();
+
+    if (subjectValue != constraintValue) {
+      return TYPE_LOOKUP_ERROR_FMT(
+            "subject value %" PRIiPTR " does not match constraint value %" PRIiPTR,
+            subjectValue,
+            constraintValue);
+    }
+
+    return std::nullopt;
+  }
+
+  default: {
+    // Value requirements can only be same type'd at the moment.
+    return TYPE_LOOKUP_ERROR_FMT("unknown value generic requirement kind %u",
+                                 (unsigned)req.getKind());
+  }
+  }
 }
 
 static std::optional<TypeLookupError>

test/Runtime/check_create_type.swift

@@ -1,4 +1,4 @@
-// RUN: %target-run-simple-swift(-Xfrontend -disable-availability-checking)
+// RUN: %target-run-simple-swift(-Xfrontend -disable-availability-checking -enable-experimental-feature ValueGenerics)
 // REQUIRES: executable_test
 
 // UNSUPPORTED: CPU=arm64e
@@ -13,6 +13,8 @@ struct Variadic<each T> {
   struct Nested<U, each V: Equatable> {}
 }
 
+struct Value<let N: Int, let M: Int> {}
+
 @_silgen_name("swift_allocateMetadataPack")
 func allocateMetadataPack(
   _ packPointer: UnsafeRawPointer,
@@ -30,7 +32,7 @@ func metaPointer(_ x: Any.Type) -> UnsafeRawPointer {
   unsafeBitCast(x, to: UnsafeRawPointer.self)
 }
 
-testSuite.test("_swift_checkedCreateType non-variadic") {
+testSuite.test("_swift_instantiateCheckedGenericMetadata non-variadic") {
   let dictMeta = unsafeBitCast(
     [Int: Int].self as Any.Type,
     to: UnsafeRawPointer.self
@@ -53,7 +55,7 @@ testSuite.test("_swift_checkedCreateType non-variadic") {
   }
 }
 
-testSuite.test("_swift_checkedCreateType variadic") {
+testSuite.test("_swift_instantiateCheckedGenericMetadata variadic") {
   let variMeta = unsafeBitCast(
     Variadic< >.self as Any.Type,
     to: UnsafeRawPointer.self
@@ -84,7 +86,7 @@ testSuite.test("_swift_checkedCreateType variadic") {
   }
 }
 
-testSuite.test("_swift_checkedCreateType variadic nested with requirements") {
+testSuite.test("_swift_instantiateCheckedGenericMetadata variadic nested with requirements") {
   let nestedMeta = unsafeBitCast(
     Variadic< >.Nested<()>.self as Any.Type,
     to: UnsafeRawPointer.self
@@ -271,4 +273,28 @@ testSuite.test("_swift_instantiateCheckedGenericMetadata concrete generic types
   }
 }
 
+extension Value where N == M {
+  struct NestedNEqualsM {}
+}
+
+testSuite.test("_swift_instantiateCheckedGenericMetadata value generics") {
+  let nestedMeta1 = metaPointer(Value<0, 0>.NestedNEqualsM.self)
+  let nestedDesc1 = nestedMeta1.load(
+    fromByteOffset: MemoryLayout<Int>.size,
+    as: UnsafeRawPointer.self
+  )
+
+  let genericArgs1: [Int] = [123]
+
+  genericArgs1.withUnsafeBufferPointer {
+    let nested = _instantiateCheckedGenericMetadata(
+      nestedDesc1,
+      UnsafeRawPointer($0.baseAddress!),
+      UInt($0.count)
+    )
+
+    expectTrue(nested == Value<123, 123>.NestedNEqualsM.self)
+  }
+}
+
 runAllTests()