NCGenerics: break cycle with SuperclassTypeRequest

With NoncopyableGenerics, we get a cycle involving
`SuperclassTypeRequest` with this program:
```
public struct RawMarkupHeader {}
final class RawMarkup: ManagedBuffer<RawMarkupHeader, RawMarkup> { }
```
Because we generally don't support the following kind of relationship:
```
class Base<T: P>: P {}
class Derived: Base<Derived> {}
```
This commit works around the root-cause, which is that Derived's
synthesized conformance to Copyable gets superceded by the inherited one
 from Base. Instead of recording conformances in the ConformanceLookup
 table at all, create builtin conformances, since classes cannot be
 conditionally Copyable.

Author: kavon

lib/AST/ConformanceLookup.cpp

@@ -586,6 +586,20 @@ LookupConformanceInModuleRequest::evaluate(
   if (!nominal || isa<ProtocolDecl>(nominal))
     return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 
+  // We specially avoid recording conformances to invertible protocols in a
+  // class's conformance table. This prevents an evaulator cycle.
+  if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics) &&
+      isa<ClassDecl>(nominal)) {
+    if (auto ip = protocol->getInvertibleProtocolKind()) {
+      ImplicitKnownProtocolConformanceRequest req{nominal,
+                                                  getKnownProtocolKind(*ip)};
+      if (auto conformance = evaluateOrDefault(ctx.evaluator, req, nullptr))
+        return ProtocolConformanceRef(conformance);
+      else
+        return ProtocolConformanceRef::forInvalid();
+    }
+  }
+
   // Expand conformances added by extension macros.
   //
   // FIXME: This expansion should only be done if the

lib/AST/GenericEnvironment.cpp

@@ -417,6 +417,9 @@ Type GenericEnvironment::mapTypeIntoContext(GenericEnvironment *env,
 }
 
 Type MapTypeOutOfContext::operator()(SubstitutableType *type) const {
+  if (auto genericParam = dyn_cast<GenericTypeParamType>(type))
+    return genericParam;
+
   auto archetype = cast<ArchetypeType>(type);
   if (isa<OpaqueTypeArchetypeType>(archetype->getRoot()))
     return Type();

lib/AST/ProtocolConformance.cpp

@@ -1090,19 +1090,21 @@ void NominalTypeDecl::prepareConformanceTable() const {
   // Synthesize the unconditional conformances to invertible protocols.
   // For conditional ones, see findSynthesizedConformances .
   if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
-    bool missingOne = false;
-    for (auto ip : InvertibleProtocolSet::full()) {
-      auto invertible = getMarking(ip);
-      if (!invertible.getInverse() || bool(invertible.getPositive()))
-        addSynthesized(ctx.getProtocol(getKnownProtocolKind(ip)));
-      else
-        missingOne = true;
-    }
-
-    // FIXME: rdar://122289155 (NCGenerics: convert Equatable, Hashable, and RawRepresentable to ~Copyable.)
-    if (missingOne)
-      return;
+    // Classes get their conformances during ModuleDecl::lookupConformance.
+    if (!isa<ClassDecl>(this)) {
+      bool missingOne = false;
+      for (auto ip : InvertibleProtocolSet::full()) {
+        auto invertible = getMarking(ip);
+        if (!invertible.getInverse() || bool(invertible.getPositive()))
+          addSynthesized(ctx.getProtocol(getKnownProtocolKind(ip)));
+        else
+          missingOne = true;
+      }
 
+      // FIXME: rdar://122289155 (NCGenerics: convert Equatable, Hashable, and RawRepresentable to ~Copyable.)
+      if (missingOne)
+        return;
+    }
   } else if (!canBeCopyable()) {
     return; // No synthesized conformances for move-only nominals.
   }

lib/Sema/TypeCheckInvertible.cpp

@@ -349,16 +349,26 @@ ProtocolConformance *deriveConformanceForInvertible(Evaluator &evaluator,
   // The conformanceDC specifies THE decl context to use for the conformance.
   auto generateConformance =
       [&](DeclContext *conformanceDC) -> ProtocolConformance * {
-    // Form a conformance.
-    auto conformance = ctx.getNormalConformance(
-        nominal->getDeclaredInterfaceType(), proto, nominal->getLoc(),
-        conformanceDC, ProtocolConformanceState::Complete,
-        /*isUnchecked=*/false, /*isPreconcurrency=*/false);
-    conformance->setSourceKindAndImplyingConformance(
-        ConformanceEntryKind::Synthesized, nullptr);
-
-    nominal->registerProtocolConformance(conformance, /*synthesized=*/true);
-    return conformance;
+    if (!isa<ClassDecl>(nominal)) {
+      // Form a conformance.
+      auto conformance = ctx.getNormalConformance(
+          nominal->getDeclaredInterfaceType(), proto, nominal->getLoc(),
+          conformanceDC, ProtocolConformanceState::Complete,
+          /*isUnchecked=*/false, /*isPreconcurrency=*/false);
+      conformance->setSourceKindAndImplyingConformance(
+          ConformanceEntryKind::Synthesized, nullptr);
+
+      nominal->registerProtocolConformance(conformance, /*synthesized=*/true);
+      return conformance;
+    } else {
+      // Classes need to return a built-in conformance to avoid cycles with
+      // superclasses, such as:
+      //    class Base<T>: IP {}
+      //    class Derived: Base<Derived> {}
+      return ctx.getBuiltinConformance(nominal->getDeclaredInterfaceType(),
+                                       proto,
+                                       BuiltinConformanceKind::Synthesized);
+    }
   };
 
   auto generateConditionalConformance = [&]() -> ProtocolConformance * {

lib/Sema/TypeCheckProtocol.cpp

@@ -4864,6 +4864,11 @@ static void ensureRequirementsAreSatisfied(ASTContext &ctx,
       auto assocConf = conformance->getAssociatedConformance(depTy, proto);
       if (assocConf.isConcrete()) {
         auto *concrete = assocConf.getConcrete();
+
+        // Builtin conformances are always available
+        if (isa<BuiltinProtocolConformance>(concrete))
+          return false;
+
         auto replacementTy = dc->mapTypeIntoContext(concrete->getType());
         diagnoseConformanceAvailability(conformance->getLoc(),
                                         assocConf, where,