Use new noncopyable types infrastructure

include/swift/AST/Decl.h

@@ -4392,10 +4392,6 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// Type if it `isEscapable` instead of using this.
   CanBeInvertible::Result canBeEscapable() const;
 
-  /// Determine whether this type has ~<target>` stated on
-  /// itself, one of its inherited types or `Self` requirements.
-  InverseMarking::Mark hasInverseMarking(InvertibleProtocolKind target) const;
-
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_NominalTypeDecl &&

include/swift/AST/DiagnosticsSema.def

@@ -7676,9 +7676,6 @@ ERROR(bitwise_copyable_outside_module,none,
       (const ValueDecl *))
 
 // -- older ones below --
-ERROR(noncopyable_cannot_conform_to_type, none,
-     "noncopyable %kind0 cannot conform to %1",
-     (const ValueDecl *, Type))
 ERROR(noncopyable_parameter_requires_ownership, none,
       "parameter of noncopyable type %0 must specify ownership", (Type))
 ERROR(noncopyable_parameter_subscript_unsupported, none,

include/swift/AST/Requirement.h

@@ -270,6 +270,8 @@ struct InverseRequirement {
   static void expandDefaults(ASTContext &ctx,
                              ArrayRef<Type> gps,
                              SmallVectorImpl<StructuralRequirement> &result);
+
+  void print(raw_ostream &os, const PrintOptions &opts, bool forInherited=false) const;
 };
 
 } // end namespace swift

include/swift/Frontend/ModuleInterfaceLoader.h

@@ -486,19 +486,6 @@ struct RequireOSSAModules_t {
   explicit operator bool() const { return bool(value); }
 };
 
-/// Help prevent confusion between different bools being passed around.
-struct RequireNoncopyableGenerics_t {
-private:
-  bool value;
-public:
-  RequireNoncopyableGenerics_t(const ASTContext &ctx)
-    : RequireNoncopyableGenerics_t(ctx.LangOpts) {}
-  RequireNoncopyableGenerics_t(const LangOptions &opts)
-      : value(opts.hasFeature(Feature::NoncopyableGenerics)) {}
-
-  explicit operator bool() const { return value; }
-};
-
 class ModuleInterfaceCheckerImpl: public ModuleInterfaceChecker {
   friend class ModuleInterfaceLoader;
   ASTContext &Ctx;
@@ -507,26 +494,22 @@ class ModuleInterfaceCheckerImpl: public ModuleInterfaceChecker {
   std::string BackupInterfaceDir;
   ModuleInterfaceLoaderOptions Opts;
   RequireOSSAModules_t RequiresOSSAModules;
-  RequireNoncopyableGenerics_t RequireNCGenerics;
 
 public:
   explicit ModuleInterfaceCheckerImpl(ASTContext &Ctx, StringRef cacheDir,
                                 StringRef prebuiltCacheDir,
                                 StringRef BackupInterfaceDir,
                                 ModuleInterfaceLoaderOptions opts,
-                                RequireOSSAModules_t requiresOSSAModules,
-                                RequireNoncopyableGenerics_t requireNCGenerics)
+                                RequireOSSAModules_t requiresOSSAModules)
       : Ctx(Ctx), CacheDir(cacheDir), PrebuiltCacheDir(prebuiltCacheDir),
         BackupInterfaceDir(BackupInterfaceDir),
-        Opts(opts), RequiresOSSAModules(requiresOSSAModules),
-        RequireNCGenerics(requireNCGenerics) {}
+        Opts(opts), RequiresOSSAModules(requiresOSSAModules) {}
   explicit ModuleInterfaceCheckerImpl(ASTContext &Ctx, StringRef cacheDir,
                                 StringRef prebuiltCacheDir,
                                 ModuleInterfaceLoaderOptions opts,
-                                RequireOSSAModules_t requiresOSSAModules,
-                                RequireNoncopyableGenerics_t requireNCGenerics):
+                                RequireOSSAModules_t requiresOSSAModules):
     ModuleInterfaceCheckerImpl(Ctx, cacheDir, prebuiltCacheDir, StringRef(),
-                               opts, requiresOSSAModules, requireNCGenerics) {}
+                               opts, requiresOSSAModules) {}
   std::vector<std::string>
   getCompiledModuleCandidatesForInterface(StringRef moduleName,
                                           StringRef interfacePath) override;
@@ -602,7 +585,6 @@ class ModuleInterfaceLoader : public SerializedModuleLoaderBase {
       bool SerializeDependencyHashes, bool TrackSystemDependencies,
       ModuleInterfaceLoaderOptions Opts,
       RequireOSSAModules_t RequireOSSAModules,
-      RequireNoncopyableGenerics_t RequireNCGenerics,
       bool silenceInterfaceDiagnostics);
 
   /// Unconditionally build \p InPath (a swiftinterface file) to \p OutPath (as
@@ -657,8 +639,7 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
                                      const ClangImporterOptions &clangImporterOpts,
                                      const CASOptions &casOpts,
                                      bool suppressRemarks,
-                                     RequireOSSAModules_t requireOSSAModules,
-                                     RequireNoncopyableGenerics_t requireNCGenerics);
+                                     RequireOSSAModules_t requireOSSAModules);
   bool extractSwiftInterfaceVersionAndArgs(CompilerInvocation &subInvocation,
                                            SwiftInterfaceInfo &interfaceInfo,
                                            StringRef interfacePath,
@@ -671,8 +652,7 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
       ModuleInterfaceLoaderOptions LoaderOpts, bool buildModuleCacheDirIfAbsent,
       StringRef moduleCachePath, StringRef prebuiltCachePath,
       StringRef backupModuleInterfaceDir, bool serializeDependencyHashes,
-      bool trackSystemDependencies, RequireOSSAModules_t requireOSSAModules,
-      RequireNoncopyableGenerics_t requireNCGenerics);
+      bool trackSystemDependencies, RequireOSSAModules_t requireOSSAModules);
 
   template<typename ...ArgTypes>
   static InFlightDiagnostic diagnose(StringRef interfacePath,

include/swift/Serialization/SerializedModuleLoader.h

@@ -182,7 +182,6 @@ class SerializedModuleLoaderBase : public ModuleLoader {
                      ModuleLoadingBehavior transitiveBehavior,
                      bool isFramework,
                      bool isRequiredOSSAModules,
-                     bool isRequiredNoncopyableGenerics,
                      StringRef SDKName,
                      StringRef packageName,
                      llvm::vfs::FileSystem *fileSystem,
@@ -212,7 +211,6 @@ class SerializedModuleLoaderBase : public ModuleLoader {
           bool isFramework);
 
   bool isRequiredOSSAModules() const;
-  bool isRequiredNoncopyableGenerics() const;
 
   /// Check whether the module with a given name can be imported without
   /// importing it.

include/swift/Serialization/Validation.h

@@ -86,10 +86,6 @@ enum class Status {
   /// The module file was built with a different SDK than the one in use
   /// to build the client.
   SDKMismatch,
-
-  /// The module file was built with a different NoncopyableGenerics feature
-  /// mode than the compiler loading it.
-  NoncopyableGenericsMismatch,
 };
 
 /// Returns the string for the Status enum.
@@ -262,8 +258,6 @@ struct SearchPath {
 /// refers directly into this buffer.
 /// \param requiresOSSAModules If true, necessitates the module to be
 /// compiled with -enable-ossa-modules.
-/// \param requiresNoncopyableGenerics requires the module to have been built
-/// with the feature \c NoncopyableGenerics enabled.
 /// \param requiredSDK If not empty, only accept modules built with
 /// a compatible SDK. The StringRef represents the canonical SDK name.
 /// \param[out] extendedInfo If present, will be populated with additional
@@ -272,7 +266,7 @@ struct SearchPath {
 /// \param[out] dependencies If present, will be populated with list of
 /// input files the module depends on, if present in INPUT_BLOCK.
 ValidationInfo validateSerializedAST(
-    StringRef data, bool requiresOSSAModules, bool requiresNoncopyableGenerics,
+    StringRef data, bool requiresOSSAModules,
     StringRef requiredSDK,
     ExtendedValidationInfo *extendedInfo = nullptr,
     SmallVectorImpl<SerializationOptions::FileDependency> *dependencies =

lib/APIDigester/ModuleAnalyzerNodes.cpp

@@ -17,6 +17,7 @@ static PrintOptions getTypePrintOpts(CheckerOptions CheckerOpts) {
   PrintOptions Opts;
   Opts.SynthesizeSugarOnTypes = true;
   Opts.UseOriginallyDefinedInModuleNames = true;
+  Opts.PrintInverseRequirements = true; // Only inverses are relevant for ABI stability
   if (!CheckerOpts.Migrator) {
     // We should always print fully qualified type names for checking either
     // API or ABI stability.
@@ -1222,8 +1223,15 @@ Requirement getCanonicalRequirement(Requirement &Req) {
   }
 }
 
+// Get an inverse requirement with the subject type canonicalized.
+InverseRequirement getCanonicalInverseRequirement(InverseRequirement &Req) {
+  return {Req.subject->getCanonicalType(), Req.protocol, Req.loc};
+}
+
 static
-StringRef printGenericSignature(SDKContext &Ctx, ArrayRef<Requirement> AllReqs,
+StringRef printGenericSignature(SDKContext &Ctx,
+                                ArrayRef<Requirement> AllReqs,
+                                ArrayRef<InverseRequirement> Inverses,
                                 bool Canonical) {
   llvm::SmallString<32> Result;
   llvm::raw_svector_ostream OS(Result);
@@ -1243,6 +1251,17 @@ StringRef printGenericSignature(SDKContext &Ctx, ArrayRef<Requirement> AllReqs,
     else
       Req.print(OS, Opts);
   }
+  for (auto Inv: Inverses) {
+    if (!First) {
+      OS << ", ";
+    } else {
+      First = false;
+    }
+    if (Canonical)
+      getCanonicalInverseRequirement(Inv).print(OS, Opts);
+    else
+      Inv.print(OS, Opts);
+  }
   OS << ">";
   return Ctx.buffer(OS.str());
 }
@@ -1251,8 +1270,10 @@ static StringRef printGenericSignature(SDKContext &Ctx, Decl *D, bool Canonical)
   llvm::SmallString<32> Result;
   llvm::raw_svector_ostream OS(Result);
   if (auto *PD = dyn_cast<ProtocolDecl>(D)) {
-    return printGenericSignature(Ctx, PD->getRequirementSignature().getRequirements(),
-                                 Canonical);
+    SmallVector<Requirement, 2> reqs;
+    SmallVector<InverseRequirement, 2> inverses;
+    PD->getRequirementSignature().getRequirementsWithInverses(PD, reqs, inverses);
+    return printGenericSignature(Ctx, reqs, inverses, Canonical);
   }
   PrintOptions Opts = getTypePrintOpts(Ctx.getOpts());
   if (auto *GC = D->getAsGenericContext()) {
@@ -1269,7 +1290,7 @@ static StringRef printGenericSignature(SDKContext &Ctx, Decl *D, bool Canonical)
 
 static
 StringRef printGenericSignature(SDKContext &Ctx, ProtocolConformance *Conf, bool Canonical) {
-  return printGenericSignature(Ctx, Conf->getConditionalRequirements(), Canonical);
+  return printGenericSignature(Ctx, Conf->getConditionalRequirements(), {}, Canonical);
 }
 
 static std::optional<uint8_t>

lib/AST/ASTPrinter.cpp

@@ -7424,6 +7424,13 @@ void Requirement::print(ASTPrinter &printer, const PrintOptions &opts) const {
   PrintAST(printer, opts).printRequirement(*this);
 }
 
+void InverseRequirement::print(raw_ostream &os,
+                          const PrintOptions &opts,
+                          bool forInherited) const {
+  StreamPrinter printer(os);
+  PrintAST(printer, opts).printRequirement(*this, forInherited);
+}
+
 std::string GenericSignatureImpl::getAsString() const {
   return GenericSignature(const_cast<GenericSignatureImpl *>(this))
       .getAsString();
@@ -7727,17 +7734,15 @@ static void getSyntacticInheritanceClause(const ProtocolDecl *proto,
   InvertibleProtocolSet inverses = InvertibleProtocolSet::full();
 
   for (auto *inherited : proto->getInheritedProtocols()) {
-    if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
-      if (auto ip = inherited->getInvertibleProtocolKind()) {
-        inverses.remove(*ip);
-        continue;
-      }
+    if (auto ip = inherited->getInvertibleProtocolKind()) {
+      inverses.remove(*ip);
+      continue;
+    }
 
-      for (auto ip : InvertibleProtocolSet::full()) {
-        auto *proto = ctx.getProtocol(getKnownProtocolKind(ip));
-        if (inherited->inheritsFrom(proto))
-          inverses.remove(ip);
-      }
+    for (auto ip : InvertibleProtocolSet::full()) {
+      auto *proto = ctx.getProtocol(getKnownProtocolKind(ip));
+      if (inherited->inheritsFrom(proto))
+        inverses.remove(ip);
     }
 
     Results.emplace_back(TypeLoc::withoutLoc(inherited->getDeclaredInterfaceType()),
@@ -7746,19 +7751,17 @@ static void getSyntacticInheritanceClause(const ProtocolDecl *proto,
                          /*isPreconcurrency=*/false);
   }
 
-  if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
-    for (auto ip : inverses) {
-      InvertibleProtocolSet singleton;
-      singleton.insert(ip);
+  for (auto ip : inverses) {
+    InvertibleProtocolSet singleton;
+    singleton.insert(ip);
 
-      auto inverseTy = ProtocolCompositionType::get(
-          ctx, ArrayRef<Type>(), singleton,
-          /*hasExplicitAnyObject=*/false);
-      Results.emplace_back(TypeLoc::withoutLoc(inverseTy),
-                           /*isUnchecked=*/false,
-                           /*isRetroactive=*/false,
-                           /*isPreconcurrency=*/false);
-    }
+    auto inverseTy = ProtocolCompositionType::get(
+        ctx, ArrayRef<Type>(), singleton,
+        /*hasExplicitAnyObject=*/false);
+    Results.emplace_back(TypeLoc::withoutLoc(inverseTy),
+                         /*isUnchecked=*/false,
+                         /*isRetroactive=*/false,
+                         /*isPreconcurrency=*/false);
   }
 }
 

lib/AST/Builtins.cpp

@@ -296,12 +296,6 @@ struct CollectGenericParams {
     auto protocolType = synthesizeType(SC, conf.Protocol);
     Requirement req = {RequirementKind::Conformance, type, protocolType};
 
-    // If it's an invertible protocol and NoncopyableGenerics is disabled
-    // then skip the requirement.
-    if (req.getProtocolDecl()->getInvertibleProtocolKind())
-      if (!SC.Context.LangOpts.hasFeature(Feature::NoncopyableGenerics))
-        return;
-
     AddedRequirements.push_back(req);
   }
 
@@ -736,13 +730,6 @@ namespace {
       Requirement req(RequirementKind::Conformance,
                       generator.build(*this),
                       proto->getDeclaredInterfaceType());
-
-      // If it's an invertible protocol and NoncopyableGenerics is disabled
-      // then skip the requirement.
-      if (req.getProtocolDecl()->getInvertibleProtocolKind())
-        if (!Context.LangOpts.hasFeature(Feature::NoncopyableGenerics))
-          return;
-
       addedRequirements.push_back(req);
     }