use new noncopyable types infrastructure

The infrastructure underpinning the new feature NoncopyableGenerics is
mature enough to be used.

(cherry picked from commit 149c052)

Author: kavon

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/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/AST/ASTPrinter.cpp

@@ -7770,17 +7770,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()),
@@ -7789,19 +7787,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);
     }
 

lib/AST/ConformanceLookup.cpp

@@ -398,18 +398,6 @@ static ProtocolConformanceRef getBuiltinMetaTypeTypeConformance(
     Type type, const AnyMetatypeType *metatypeType, ProtocolDecl *protocol) {
   ASTContext &ctx = protocol->getASTContext();
 
-  if (!ctx.LangOpts.hasFeature(swift::Feature::NoncopyableGenerics) &&
-      protocol->isSpecificProtocol(KnownProtocolKind::Copyable)) {
-    // Only metatypes of Copyable types are Copyable.
-    if (metatypeType->getInstanceType()->isNoncopyable()) {
-      return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
-    } else {
-      return ProtocolConformanceRef(
-          ctx.getBuiltinConformance(type, protocol,
-                                    BuiltinConformanceKind::Synthesized));
-    }
-  }
-
   // All metatypes are Sendable, Copyable, Escapable, and BitwiseCopyable.
   if (auto kp = protocol->getKnownProtocolKind()) {
     switch (*kp) {
@@ -843,26 +831,6 @@ bool TypeBase::isSendableType() {
 /// Copyable and Escapable checking utilities
 ///
 
-/// Returns true if this type is _always_ Copyable using the legacy check
-/// that does not rely on conformances.
-static bool alwaysNoncopyable(Type ty) {
-  if (auto *nominal = ty->getNominalOrBoundGenericNominal())
-    return !nominal->canBeCopyable();
-
-  if (auto *expansion = ty->getAs<PackExpansionType>()) {
-    return alwaysNoncopyable(expansion->getPatternType());
-  }
-
-  // if any components of the tuple are move-only, then the tuple is move-only.
-  if (auto *tupl = ty->getCanonicalType()->getAs<TupleType>()) {
-    for (auto eltTy : tupl->getElementTypes())
-      if (alwaysNoncopyable(eltTy))
-        return true;
-  }
-
-  return false; // otherwise, the conservative assumption is it's copyable.
-}
-
 /// Preprocesses a type before querying whether it conforms to an invertible.
 static CanType preprocessTypeForInvertibleQuery(Type orig) {
   Type type = orig;
@@ -912,26 +880,10 @@ static bool conformsToInvertible(CanType type, InvertibleProtocolKind ip) {
 /// \returns true iff this type lacks conformance to Copyable.
 bool TypeBase::isNoncopyable() {
   auto canType = preprocessTypeForInvertibleQuery(this);
-  auto &ctx = canType->getASTContext();
-
-  // for legacy-mode queries that are not dependent on conformances to Copyable
-  if (!ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics))
-    return alwaysNoncopyable(canType);
-
   return !conformsToInvertible(canType, InvertibleProtocolKind::Copyable);
 }
 
 bool TypeBase::isEscapable() {
   auto canType = preprocessTypeForInvertibleQuery(this);
-  auto &ctx = canType->getASTContext();
-
-  // for legacy-mode queries that are not dependent on conformances to Escapable
-  if (!ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
-    if (auto nom = canType.getAnyNominal())
-      return nom->canBeEscapable();
-    else
-      return true;
-  }
-
   return conformsToInvertible(canType, InvertibleProtocolKind::Escapable);
 }

lib/AST/ConformanceLookupTable.cpp

@@ -552,9 +552,8 @@ void ConformanceLookupTable::expandImpliedConformances(NominalTypeDecl *nominal,
     for (auto *inherited : conformingProtocol->getInheritedProtocols()) {
       // Conforming a ~Copyable nominal to a protocol that inherits Copyable
       // should not imply a Copyable conformance on the nominal.
-      if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics))
-        if (inherited->getInvertibleProtocolKind())
-          continue;
+      if (inherited->getInvertibleProtocolKind())
+        continue;
 
       addProtocol(inherited, SourceLoc(), source);
     }