Merge pull request swiftlang#14351 from DougGregor/demangle-to-metadata-class-constraints

Author: swift-ci

stdlib/public/runtime/MetadataLookup.cpp

@@ -420,7 +420,7 @@ depthIndexToFlatIndex(unsigned depth, unsigned index,
   if (depth >= paramCounts.size()) return None;
 
   // Compute the flat index.
-  unsigned flatIndex = index + depth == 0 ? 0 :  paramCounts[depth - 1];
+  unsigned flatIndex = index + (depth == 0 ? 0 : paramCounts[depth - 1]);
 
   // Out-of-bounds index.
   if (flatIndex >= paramCounts[depth]) return None;
@@ -829,13 +829,9 @@ class DecodedMetadataBuilder {
 
 }
 
-SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERNAL
-const Metadata * _Nullable
-swift_getTypeByMangledName(const char *typeNameStart, size_t typeNameLength,
-                           size_t numberOfLevels,
-                           size_t *parametersPerLevel,
-                           const Metadata * const *flatSubstitutions) {
-  llvm::StringRef typeName(typeNameStart, typeNameLength);
+const Metadata *swift::_getTypeByMangledName(
+                          StringRef typeName,
+                          SubstGenericParameterFn substGenericParam) {
 
   Demangler demangler;
   NodePointer node;
@@ -860,20 +856,7 @@ swift_getTypeByMangledName(const char *typeNameStart, size_t typeNameLength,
     if (!node) return nullptr;
   }
 
-  DecodedMetadataBuilder builder(demangler,
-    [&](unsigned depth, unsigned index) -> const Metadata * {
-      if (depth >= numberOfLevels)
-        return nullptr;
-
-      if (index >= parametersPerLevel[depth])
-        return nullptr;
-
-      unsigned flatIndex = index;
-      for (unsigned i = 0; i < depth; ++i)
-        flatIndex += parametersPerLevel[i];
-
-      return flatSubstitutions[flatIndex];
-    },
+  DecodedMetadataBuilder builder(demangler, substGenericParam,
     [](const Metadata *base, StringRef assocType,
        const ProtocolDescriptor *protocol) -> const Metadata * {
       // Look for a conformance of the base type to the protocol.
@@ -893,3 +876,26 @@ swift_getTypeByMangledName(const char *typeNameStart, size_t typeNameLength,
 
   return Demangle::decodeMangledType(builder, node);
 }
+
+SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERNAL
+const Metadata * _Nullable
+swift_getTypeByMangledName(const char *typeNameStart, size_t typeNameLength,
+                           size_t numberOfLevels,
+                           size_t *parametersPerLevel,
+                           const Metadata * const *flatSubstitutions) {
+  llvm::StringRef typeName(typeNameStart, typeNameLength);
+  return _getTypeByMangledName(typeName,
+    [&](unsigned depth, unsigned index) -> const Metadata * {
+      if (depth >= numberOfLevels)
+        return nullptr;
+
+      if (index >= parametersPerLevel[depth])
+        return nullptr;
+
+      unsigned flatIndex = index;
+      for (unsigned i = 0; i < depth; ++i)
+        flatIndex += parametersPerLevel[i];
+
+      return flatSubstitutions[flatIndex];
+    });
+}

stdlib/public/runtime/Private.h

@@ -183,6 +183,14 @@ namespace swift {
   using SubstGenericParameterFn =
     llvm::function_ref<const Metadata *(unsigned depth, unsigned index)>;
 
+  /// Retrieve the type metadata described by the given type name.
+  ///
+  /// \p substGenericParam Function that provides generic argument metadata
+  /// given a particular generic parameter specified by depth/index.
+  const Metadata *_getTypeByMangledName(
+                                    StringRef typeName,
+                                    SubstGenericParameterFn substGenericParam);
+
   /// FIXME: Remove once this is in Metadata.h
   using GenericRequirementDescriptor =
     TargetGenericRequirementDescriptor<InProcess>;

stdlib/public/runtime/ProtocolConformance.cpp

@@ -763,10 +763,53 @@ bool swift::_checkGenericRequirements(
       continue;
     }
 
-    // FIXME: Handle all of the other cases.
-    default:
+    case GenericRequirementKind::SameType: {
+      // Demangle the second type under the given substitutions.
+      auto otherType =
+        _getTypeByMangledName(req.getMangledTypeName(), substGenericParam);
+      if (!otherType) return true;
+
+      assert(!req.getFlags().hasExtraArgument());
+
+      // Check that the types are equivalent.
+      if (subjectType != otherType) return true;
+
+      continue;
+    }
+
+    case GenericRequirementKind::Layout: {
+      switch (req.getLayout()) {
+      case GenericRequirementLayoutKind::Class:
+        // Check whether the subject type is a class.
+        if (!subjectType->isAnyClass()) return true;
+        continue;
+      }
+
+      // Unknown layout.
       return true;
     }
+
+    case GenericRequirementKind::BaseClass: {
+      // Demangle the base type under the given substitutions.
+      auto baseType =
+        _getTypeByMangledName(req.getMangledTypeName(), substGenericParam);
+      if (!baseType) return true;
+
+      // Check whether it's dynamically castable, which works as a superclass
+      // check.
+      if (!swift_dynamicCastMetatype(subjectType, baseType)) return true;
+
+      continue;
+    }
+
+    case GenericRequirementKind::SameConformance: {
+      // FIXME: Implement this check.
+      continue;
+    }
+    }
+
+    // Unknown generic requirement kind.
+    return true;
   }
 
   // Success!

test/Runtime/demangleToMetadata.swift

@@ -278,5 +278,60 @@ DemangleToMetadataTests.test("associated type conformance requirements") {
   expectNil(_typeByMangledName("4main3SG5VyAA12ConformsToP1cVG"))
 }
 
+struct SG6<T: P4> where T.Assoc1 == T.Assoc2 { }
+struct SG7<T: P4> where T.Assoc1 == Int { }
+struct SG8<T: P4> where T.Assoc1 == [T.Assoc2] { }
+
+struct ConformsToP4d : P4 {
+  typealias Assoc1 = [ConformsToP2]
+  typealias Assoc2 = ConformsToP2
+}
+
+DemangleToMetadataTests.test("same-type requirements") {
+  // Concrete type.
+  expectEqual(SG7<S>.self,
+    _typeByMangledName("4main3SG7VyAA1SVG")!)
+
+  // Other associated type.
+  expectEqual(SG6<ConformsToP4b>.self,
+    _typeByMangledName("4main3SG6VyAA13ConformsToP4bVG")!)
+  expectEqual(SG6<ConformsToP4c>.self,
+    _typeByMangledName("4main3SG6VyAA13ConformsToP4cVG")!)
+
+  // Structural type.
+  expectEqual(SG8<ConformsToP4d>.self,
+    _typeByMangledName("4main3SG8VyAA13ConformsToP4dVG")!)
+
+  // Failure cases: types don't match.
+  expectNil(_typeByMangledName("4main3SG7VyAA13ConformsToP4aVG"))
+  expectNil(_typeByMangledName("4main3SG6VyAA13ConformsToP4aVG"))
+  expectNil(_typeByMangledName("4main3SG8VyAA13ConformsToP4cVG"))
+}
+
+struct SG9<T: AnyObject> { }
+
+DemangleToMetadataTests.test("AnyObject requirements") {
+  expectEqual(SG9<C>.self,
+    _typeByMangledName("4main3SG9VyAA1CCG")!)
+
+  // Failure cases: failed AnyObject constraint.
+  expectNil(_typeByMangledName("4main3SG9VyAA1SVG"))
+}
+
+struct SG10<T: C> { }
+
+class C2 : C { }
+class C3 { }
+
+DemangleToMetadataTests.test("superclass requirements") {
+  expectEqual(SG10<C>.self,
+    _typeByMangledName("4main4SG10VyAA1CCG")!)
+  expectEqual(SG10<C2>.self,
+    _typeByMangledName("4main4SG10VyAA2C2CG")!)
+
+  // Failure cases: not a subclass.
+  expectNil(_typeByMangledName("4main4SG10VyAA2C3CG"))
+}
+
 runAllTests()