[NCGenerics] fix Combine issue

The solution is to add the unconditional conformances when building the
conformance lookup table for each nominal, instead of waiting until
conformance lookup infers it.

At the moment, because the stdlib isn't being built with Copyable
conformances injected into it, we still end up needing to infer Copyable
conformances for nominals like `Int` from the stdlib when trying to test
the feature, since it loads those nominals, but they lack conformance.

That should go away once we do enable NoncopyableGenerics for the stdlib
by default, and we'll be left with only inferring the conditional
conformance in TypeCheckInvertible.

Author: kavon

lib/AST/ProtocolConformance.cpp

@@ -23,6 +23,7 @@
 #include "swift/AST/FileUnit.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/InFlightSubstitution.h"
+#include "swift/AST/InverseMarking.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/PackConformance.h"
@@ -1091,6 +1092,16 @@ void NominalTypeDecl::prepareConformanceTable() const {
     }
   };
 
+  // Synthesize the unconditional conformances to invertible protocols.
+  // For conditional ones, see findSynthesizedConformances .
+  if (haveNoncopyableGenerics) {
+    for (auto ip : InvertibleProtocolSet::full()) {
+      auto invertible = getMarking(ip);
+      if (!invertible.getInverse() || bool(invertible.getPositive()))
+        addSynthesized(ctx.getProtocol(getKnownProtocolKind(ip)));
+    }
+  }
+
   // Add protocols for any synthesized protocol attributes.
   for (auto attr : getAttrs().getAttributes<SynthesizedProtocolAttr>()) {
     addSynthesized(attr->getProtocol());
@@ -1263,9 +1274,12 @@ static SmallVector<ProtocolConformance *, 2> findSynthesizedConformances(
   if (!isa<ProtocolDecl>(nominal)) {
     trySynthesize(KnownProtocolKind::Sendable);
 
-    if (nominal->getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
-      trySynthesize(KnownProtocolKind::Copyable);
-      trySynthesize(KnownProtocolKind::Escapable);
+    // Triggers synthesis of a possibly conditional conformance.
+    // For the unconditional ones, see NominalTypeDecl::prepareConformanceTable
+    if (nominal->getASTContext().LangOpts.hasFeature(
+            Feature::NoncopyableGenerics)) {
+      for (auto ip : InvertibleProtocolSet::full())
+        trySynthesize(getKnownProtocolKind(ip));
     }
 
     if (nominal->getASTContext().LangOpts.hasFeature(

lib/Sema/TypeCheckInvertible.cpp

@@ -464,6 +464,14 @@ ProtocolConformance *deriveConformanceForInvertible(Evaluator &evaluator,
     return generateConditionalConformance();
 
   case InverseMarking::Kind::None:
+    // All types already start with conformances to the invertible protocols in
+    // this case, within `NominalTypeDecl::prepareConformanceTable`.
+    //
+    // I'm currently unsure what happens when rebuilding a module from its
+    // interface, so this might not be unreachable code just yet.
+    if (SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS)
+      llvm_unreachable("when can this actually happen??");
+
     // If there's no inverse, we infer a positive IP conformance.
     return generateConformance(nominal);
   }

test/Generics/inverse_generics.swift

@@ -415,3 +415,10 @@ func checkOwnership<T: HasMember>(_ t: T,
                                   _ o: T.Member.NCBuddy.NCBuddy
 // expected-error@-1 {{parameter of noncopyable type 'T.Member.NCBuddy.NCBuddy' must specify ownership}} // expected-note@-1 3{{add}}
 ) {}
+
+// Covers an issue when building Combine from its interface.
+public struct Record<Output> {
+  public init(recording: Record<Output>) {}
+}
+protocol P {}
+extension Record : Decodable where Output : P {}