Sema: Remove inference of conditional Copyable conformance from generic parameters

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -7623,10 +7623,6 @@ NOTE(add_inverse,none,
 NOTE(note_inverse_preventing_conformance,none,
      "%0 has '~%1' constraint preventing implicit '%1' conformance",
      (Type, StringRef))
-NOTE(note_inverse_preventing_conformance_implicit,none,
-     "%kind0 has '~%1' constraint on a generic parameter, "
-     "making its '%1' conformance conditional",
-     (const ValueDecl *, StringRef))
 NOTE(note_inverse_preventing_conformance_explicit,none,
      "%kind0 has '~%1' constraint preventing '%1' conformance",
      (const ValueDecl *, StringRef))

include/swift/AST/InverseMarking.h

@@ -24,7 +24,6 @@ namespace swift {
 struct InverseMarking {
   enum class Kind : uint8_t {
     None,            // No inverse marking is present
-    Inferred,        // Inverse is inferred based on generic parameters.
     Explicit,        // Inverse is explicitly present.
     LegacyExplicit,   // An equivalent, explicit legacy annotation is present.
   };
@@ -84,25 +83,6 @@ struct InverseMarking {
       return Mark(k, loc);
     }
   };
-
-private:
-  Mark inverse;
-  Mark positive;
-
-public:
-
-  // Creates an empty marking.
-  InverseMarking() {}
-
-  Mark const& getInverse() const { return inverse; }
-  Mark const& getPositive() const { return positive; }
-
-  static InverseMarking forInverse(Kind kind, SourceLoc loc = SourceLoc()) {
-    InverseMarking marking;
-    marking.inverse.set(kind, loc);
-    marking.positive.set(Kind::None);
-    return marking;
-  }
 };
 
 }

lib/AST/ConformanceLookup.cpp

@@ -421,7 +421,6 @@ getBuiltinInvertibleProtocolConformance(NominalTypeDecl *nominal,
         // An inverse ~Copyable prevents conformance.
         return ProtocolConformanceRef::forInvalid();
 
-      case InverseMarking::Kind::Inferred: // ignore "inferred" inverse marking
       case InverseMarking::Kind::None:
         break;
       }

lib/AST/Decl.cpp

@@ -6694,9 +6694,9 @@ NominalTypeDecl::hasInverseMarking(InvertibleProtocolKind target) const {
   if (!ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics))
     return InverseMarking::Mark(InverseMarking::Kind::None);
 
-  // Claim that the tuple decl has an inferred ~TARGET marking.
+  // Claim that the tuple decl has an explicit ~TARGET marking.
   if (isa<BuiltinTupleDecl>(this))
-    return InverseMarking::Mark(InverseMarking::Kind::Inferred);
+    return InverseMarking::Mark(InverseMarking::Kind::Explicit);
 
   if (auto P = dyn_cast<ProtocolDecl>(this))
     return P->hasInverseMarking(target);
@@ -6705,57 +6705,6 @@ NominalTypeDecl::hasInverseMarking(InvertibleProtocolKind target) const {
   if (auto inverse = findInverseInInheritance(getInherited(), target))
     return inverse;
 
-  // Check the generic parameters for an explicit ~TARGET marking
-  // which would result in an Inferred ~TARGET marking for this context.
-  auto *gpList = getParsedGenericParams();
-  if (!gpList)
-    return InverseMarking::Mark();
-
-  llvm::SmallSet<GenericTypeParamDecl *, 4> params;
-
-  // Scan the inheritance clauses of generic parameters only for an inverse.
-  for (GenericTypeParamDecl *param : gpList->getParams()) {
-    auto inverse = findInverseInInheritance(param->getInherited(), target);
-
-    // Inverse is inferred from one of the generic parameters.
-    if (inverse)
-      return inverse.with(InverseMarking::Kind::Inferred);
-
-    params.insert(param);
-  }
-
-  // Next, scan the where clause and return the result.
-  auto whereClause = getTrailingWhereClause();
-  if (!whereClause)
-    return InverseMarking::Mark();
-
-  auto requirements = whereClause->getRequirements();
-  for (unsigned i : indices(requirements)) {
-    auto requirementRepr = requirements[i];
-    if (requirementRepr.getKind() != RequirementReprKind::TypeConstraint)
-      continue;
-
-    auto *subjectRepr =
-        dyn_cast<UnqualifiedIdentTypeRepr>(requirementRepr.getSubjectRepr());
-
-    if (!(subjectRepr && subjectRepr->isBound()))
-      continue;
-
-    auto *subjectGP =
-        dyn_cast<GenericTypeParamDecl>(subjectRepr->getBoundDecl());
-    if (!subjectGP || !params.contains(subjectGP))
-      continue;
-
-    auto *constraintRepr =
-        dyn_cast<InverseTypeRepr>(requirementRepr.getConstraintRepr());
-    if (!constraintRepr || constraintRepr->isInvalid())
-      continue;
-
-    if (constraintRepr->isInverseOf(target, getDeclContext()))
-      return InverseMarking::Mark(InverseMarking::Kind::Inferred,
-                                  constraintRepr->getLoc());
-  }
-
   return InverseMarking::Mark();
 }
 

lib/AST/FeatureSet.cpp

@@ -15,6 +15,7 @@
 #include "swift/AST/Decl.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/InverseMarking.h"
+#include "swift/AST/NameLookup.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/Pattern.h"
 #include "clang/AST/DeclObjC.h"
@@ -525,22 +526,49 @@ static bool usesFeatureRawLayout(Decl *decl) {
 UNINTERESTING_FEATURE(Embedded)
 
 static bool usesFeatureNoncopyableGenerics(Decl *decl) {
-  auto checkInverseMarking = [](auto &marking) -> bool {
-    switch (marking.getKind()) {
-    case InverseMarking::Kind::None:
-    case InverseMarking::Kind::LegacyExplicit: // covered by other checks.
-      return false;
+  if (auto *valueDecl = dyn_cast<ValueDecl>(decl)) {
+    if (isa<StructDecl, EnumDecl, ClassDecl>(decl)) {
+      auto *nominalDecl = cast<NominalTypeDecl>(valueDecl);
 
-    case InverseMarking::Kind::Explicit:
-    case InverseMarking::Kind::Inferred:
-      return true;
+      InvertibleProtocolSet inverses;
+      bool anyObject = false;
+      getDirectlyInheritedNominalTypeDecls(nominalDecl, inverses, anyObject);
+      if (!inverses.empty())
+        return true;
     }
-  };
 
-  return hasInverse(decl, InvertibleProtocolKind::Copyable,
-                    checkInverseMarking) ||
-         hasInverse(decl, InvertibleProtocolKind::Escapable,
-                    checkInverseMarking);
+    if (isa<AbstractFunctionDecl>(valueDecl) ||
+        isa<AbstractStorageDecl>(valueDecl)) {
+      if (valueDecl->getInterfaceType().findIf([&](Type type) -> bool {
+            if (auto *nominalDecl = type->getAnyNominal()) {
+              if (isa<StructDecl, EnumDecl, ClassDecl>(nominalDecl))
+                return usesFeatureNoncopyableGenerics(nominalDecl);
+            }
+            return false;
+          })) {
+        return true;
+      }
+    }
+  }
+
+  if (auto *ext = dyn_cast<ExtensionDecl>(decl)) {
+    if (auto *nominal = ext->getExtendedNominal())
+      if (usesFeatureNoncopyableGenerics(nominal))
+        return true;
+  }
+
+  SmallVector<Requirement, 2> reqs;
+  SmallVector<InverseRequirement, 2> inverseReqs;
+
+  if (auto *proto = dyn_cast<ProtocolDecl>(decl)) {
+    proto->getRequirementSignature().getRequirementsWithInverses(
+        proto, reqs, inverseReqs);
+  } else if (auto *genCtx = decl->getAsGenericContext()) {
+    if (auto genericSig = genCtx->getGenericSignature())
+      genericSig->getRequirementsWithInverses(reqs, inverseReqs);
+  }
+
+  return !inverseReqs.empty();
 }
 
 static bool usesFeatureStructLetDestructuring(Decl *decl) {

lib/Sema/TypeCheckInvertible.cpp

@@ -71,15 +71,7 @@ static void emitAdviceToApplyInverseAfter(InFlightDiagnostic &&diag,
     }
   }
 
-  auto &ctx = nominal->getASTContext();
-
   switch (inverseMarking.getKind()) {
-  case InverseMarking::Kind::Inferred:
-    // Note that the enclosing type is conditionally conforming to KP first.
-    ctx.Diags.diagnose(inverseMarking.getLoc(),
-                       diag::note_inverse_preventing_conformance_implicit,
-                       nominal, getProtocolName(kp));
-    LLVM_FALLTHROUGH;
   case InverseMarking::Kind::None: {
     // Suggest adding ~KP to make it non-KP.
     auto diag = nominal->diagnose(diag::add_inverse,
@@ -144,12 +136,6 @@ static void tryEmitContainmentFixits(InFlightDiagnostic &&diag,
       case InverseMarking::Kind::None:
         assert(false && "how did it become noncopyable/nonescapable then?");
         break;
-      case InverseMarking::Kind::Inferred:
-        assert(loc);
-        ctx.Diags.diagnose(loc,
-                           diag::note_inverse_preventing_conformance_implicit,
-                           nominal, getProtocolName(kp));
-        break;
       case InverseMarking::Kind::LegacyExplicit:
       case InverseMarking::Kind::Explicit:
         assert(loc);
@@ -344,7 +330,6 @@ ProtocolConformance *deriveConformanceForInvertible(Evaluator &evaluator,
     llvm_unreachable("not an invertible protocol");
 
   assert(!isa<ClassDecl>(nominal) && "classes aren't handled here");
-  auto file = cast<FileUnit>(nominal->getModuleScopeContext());
 
   // Generates a conformance for the nominal to the protocol.
   // The conformanceDC specifies THE decl context to use for the conformance.
@@ -362,58 +347,13 @@ ProtocolConformance *deriveConformanceForInvertible(Evaluator &evaluator,
     return conformance;
   };
 
-  auto generateConditionalConformance = [&]() -> ProtocolConformance * {
-    // Generate an extension with a conditional conformance to IP that
-    // requires all generic parameters to be IP.
-    auto protoTy = proto->getDeclaredInterfaceType();
-    auto dc = nominal->getDeclContext();
-
-    // extension Nominal: P { ... }
-    SmallVector<InheritedEntry, 1> inherited;
-    inherited.emplace_back(TypeLoc::withoutLoc(protoTy));
-    auto *ext = ExtensionDecl::create(ctx, SourceLoc(), nullptr,
-                                      ctx.AllocateCopy(inherited),
-                                      dc, nullptr);
-    ext->setImplicit();
-
-    // Build a generic signature for this extension that looks like this:
-    // <T_1..., T_n where T_1: IP, ... T_n: IP>
-    auto genericSig = nominal->getGenericSignature();
-    auto params = genericSig.getGenericParams();
-    SmallVector<Requirement, 2> reqs;
-
-    for (auto param : params)
-      reqs.push_back({RequirementKind::Conformance, param, protoTy});
-
-    genericSig = buildGenericSignature(ctx, genericSig, {}, reqs,
-                                       /*allowInverses=*/false);
-    ext->setGenericSignature(genericSig);
-
-    // Bind the extension.
-    evaluator.cacheOutput(ExtendedTypeRequest{ext},
-                          nominal->getDeclaredInterfaceType());
-    ext->setExtendedNominal(nominal);
-    nominal->addExtension(ext);
-
-    // Make it accessible to getTopLevelDecls() so it gets type-checked.
-    file->getOrCreateSynthesizedFile().addTopLevelDecl(ext);
-
-    // Then create the conformance using the extension as the conformance's
-    // DeclContext, which is how we register these conditional requirements
-    // with the conformance.
-    return generateConformance(ext);
-  };
-
   // Check what kind of inverse-marking we have to determine whether to generate
   // a conformance for IP.
   switch (nominal->hasInverseMarking(*ip).getKind()) {
   case InverseMarking::Kind::LegacyExplicit:
   case InverseMarking::Kind::Explicit:
     return nullptr; // No positive IP conformance will be inferred.
 
-  case InverseMarking::Kind::Inferred:
-    return generateConditionalConformance();
-
   case InverseMarking::Kind::None:
     // All types already start with conformances to the invertible protocols in
     // this case, within `NominalTypeDecl::prepareConformanceTable`.

test/Generics/inverse_extension_signatures.swift

@@ -44,32 +44,6 @@
 
 // CHECK-LABEL: ExtensionDecl {{.*}} base=Outer.InnerVariation2
 // CHECK: Generic signature: <A, D where A : Escapable, D : Copyable>
-
-// CHECK-LABEL: ExtensionDecl line=0 base=Outer<A>.InnerStruct<C>
-// CHECK-NEXT: (normal_conformance type="Outer<A>.InnerStruct<C>" protocol="Copyable"
-// CHECK-NEXT:   (requirement "A" conforms_to "Copyable")
-// CHECK-NEXT:   (requirement "C" conforms_to "Copyable"))
-
-// CHECK-LABEL: ExtensionDecl line=0 base=Outer<A>.InnerVariation1<D>
-// CHECK-NEXT: (normal_conformance type="Outer<A>.InnerVariation1<D>" protocol="Copyable"
-// CHECK-NEXT:   (requirement "A" conforms_to "Copyable")
-// CHECK-NEXT:   (requirement "D" conforms_to "Copyable"))
-
-// CHECK-LABEL: ExtensionDecl line=0 base=Outer<A>.InnerVariation2<D>
-// CHECK-NEXT: (normal_conformance type="Outer<A>.InnerVariation2<D>" protocol="Escapable"
-// CHECK-NEXT:   (requirement "D" conforms_to "Escapable"))
-
-// CHECK-LABEL: ExtensionDecl line=0 base=Outer<A>
-// CHECK-NEXT: (normal_conformance type="Outer<A>" protocol="Copyable"
-// CHECK-NEXT:   (requirement "A" conforms_to "Copyable"))
-
-// CHECK-LABEL: ExtensionDecl line=0 base=Freestanding<T>
-// CHECK-NEXT: (normal_conformance type="Freestanding<T>" protocol="Escapable"
-// CHECK-NEXT:   (requirement "T" conforms_to "Escapable"))
-
-// CHECK-LABEL: ExtensionDecl line=0 base=Freestanding<T>
-// CHECK-NEXT: (normal_conformance type="Freestanding<T>" protocol="Copyable"
-// CHECK-NEXT:   (requirement "T" conforms_to "Copyable"))
 
 public struct Outer<A: ~Copyable> {
   public func innerFn<B: ~Copyable>(_ b: borrowing B) {}