Generalize emission of opaque type descriptor to use generic signature.

Use the generic signature and substitution map of `OpaqueTypeDecl` to
emit type metadata for each opaque generic parameter (rather than only
the "underyling type") and each conformance requirement on an opaque
generic parameter (or dependent member thereof) that needs a witness
table.

Fix a bug where opaque result type metadata would miscount the number
of witness tables, because it counted conformance requirements without
accounting for `@objc` and marker protocols that don't have witness
tables.

Author: DougGregor

lib/IRGen/GenMeta.cpp

@@ -2001,6 +2001,37 @@ namespace {
     using super = ContextDescriptorBuilderBase;
 
     OpaqueTypeDecl *O;
+
+    /// Whether the given requirement is a conformance requirement that
+    /// requires a witness table in the opaque type descriptor.
+    ///
+    /// When it does, returns the protocol.
+    ProtocolDecl *requiresWitnessTable(const Requirement &req) const {
+      // We only care about conformance requirements.
+      if (req.getKind() != RequirementKind::Conformance)
+        return nullptr;
+
+      // The protocol must require a witness table.
+      auto proto = req.getProtocolDecl();
+      if (!Lowering::TypeConverter::protocolRequiresWitnessTable(proto))
+        return nullptr;
+
+      // The type itself must be anchored on one of the generic parameters of
+      // the opaque type (not an outer context).
+      Type subject = req.getFirstType();
+      while (auto depMember = subject->getAs<DependentMemberType>()) {
+        subject = depMember->getBase();
+      }
+
+      if (auto genericParam = subject->getAs<GenericTypeParamType>()) {
+        unsigned opaqueDepth = O->getOpaqueGenericParams().front()->getDepth();
+        if (genericParam->getDepth() == opaqueDepth)
+          return proto;
+      }
+
+      return nullptr;
+    }
+
   public:
 
     OpaqueTypeDescriptorBuilder(IRGenModule &IGM, OpaqueTypeDecl *O)
@@ -2015,29 +2046,28 @@ namespace {
 
     void addUnderlyingTypeAndConformances() {
       auto sig = O->getOpaqueInterfaceGenericSignature();
-      auto underlyingType = Type(O->getUnderlyingInterfaceType())
-        .subst(*O->getUnderlyingTypeSubstitutions())
-        ->getCanonicalType(sig);
-
       auto contextSig = O->getGenericSignature().getCanonicalSignature();
+      auto subs = *O->getUnderlyingTypeSubstitutions();
 
-      B.addRelativeAddress(IGM.getTypeRef(underlyingType, contextSig,
-                                          MangledTypeRefRole::Metadata).first);
-      
-      auto opaqueType = O->getDeclaredInterfaceType()
-                         ->castTo<OpaqueTypeArchetypeType>();
-      
-      for (auto proto : opaqueType->getConformsTo()) {
-        auto conformance = ProtocolConformanceRef(proto);
-        auto underlyingConformance = conformance
-          .subst(O->getUnderlyingInterfaceType(),
-                 *O->getUnderlyingTypeSubstitutions());
-
-        // Skip protocols without Witness tables, e.g. @objc protocols.
-        if (!Lowering::TypeConverter::protocolRequiresWitnessTable(
-                underlyingConformance.getRequirement()))
+      // Add the underlying types for each generic parameter.
+      for (auto genericParam : O->getOpaqueGenericParams()) {
+        auto underlyingType = Type(genericParam).subst(subs)->getCanonicalType(sig);
+        B.addRelativeAddress(
+            IGM.getTypeRef(underlyingType, contextSig,
+            MangledTypeRefRole::Metadata).first);
+      }
+
+      // Add witness tables for each of the conformance requirements.
+      for (const auto &req : sig.getRequirements()) {
+        auto proto = requiresWitnessTable(req);
+        if (!proto)
           continue;
 
+        auto underlyingDependentType = req.getFirstType()->getCanonicalType();
+        auto underlyingType = underlyingDependentType.subst(subs)
+            ->getCanonicalType();
+        auto underlyingConformance =
+            subs.lookupConformance(underlyingDependentType, proto);
         auto witnessTableRef = IGM.emitWitnessTableRefString(
                                           underlyingType, underlyingConformance,
                                           contextSig,
@@ -2113,11 +2143,14 @@ namespace {
     }
 
     uint16_t getKindSpecificFlags() {
-      // Store the size of the type and conformances vector in the flags.
-      auto opaqueType = O->getDeclaredInterfaceType()
-        ->castTo<OpaqueTypeArchetypeType>();
-
-      return 1 + opaqueType->getConformsTo().size();
+      // Store the number of types and witness tables in the flags.
+      unsigned numWitnessTables = llvm::count_if(
+          O->getOpaqueInterfaceGenericSignature().getRequirements(),
+          [&](const Requirement &req) {
+            return requiresWitnessTable(req) != nullptr;
+          });
+
+      return O->getOpaqueGenericParams().size() + numWitnessTables;
     }
   };
 } // end anonymous namespace

test/IRGen/opaque_result_type.swift

@@ -28,6 +28,9 @@ extension Int: O, O2 {
   public func baz() {}
 }
 
+@_marker protocol Marker { }
+extension Int: Marker { }
+
 extension String: P {
   // CHECK-LABEL: @"$sSS18opaque_result_typeE3pooQryFQOMQ" = {{.*}}constant <{ {{.*}} }> <{
   // -- header: opaque type context (0x4), generic (0x80), unique (0x40), two entries (0x2_0000)
@@ -135,6 +138,22 @@ func baz<T: P & Q>(z: T) -> some P & Q {
   return z
 }
 
+// CHECK-LABEL: @"$s18opaque_result_type4fizz1zQrx_tAA6MarkerRzAA1PRzAA1QRzlFQOMQ" = {{.*}} constant <{ {{.*}} }> <{
+// -- header: opaque type context (0x4), generic (0x80), unique (0x40), three entries (0x3_0000)
+// CHECK-SAME:         <i32 0x3_00c4>
+// -- parent context: anon context for function
+// CHECK-SAME:         @"$s18opaque_result_type4fizz1zQrx_tAA6MarkerRzAA1PRzAA1QRzlFMXX"
+// -- mangled underlying type
+// CHECK-SAME:         @"symbolic x"
+// -- conformance to P
+// CHECK-SAME:         @"get_witness_table 18opaque_result_type6MarkerRzAA1PRzAA1QRzlxAaCHD2_
+// -- conformance to Q
+// CHECK-SAME:         @"get_witness_table 18opaque_result_type6MarkerRzAA1PRzAA1QRzlxAaDHD3_
+// CHECK-SAME:  }>
+func fizz<T: P & Q & Marker>(z: T) -> some P & Q & Marker {
+  return z
+}
+
 // Ensure the local type's opaque descriptor gets emitted.
 // CHECK-LABEL: @"$s18opaque_result_type11localOpaqueQryF0D0L_QryFQOMQ" = 
 func localOpaque() -> some P {