Merge pull request #70866 from kavon/ncgenerics-stdlib-building-v4

Build Stdlib with Noncopyable Generics (Part 4)

Author: kavon

CMakeLists.txt

@@ -639,6 +639,10 @@ option(SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED
   "Enable experimental distributed actors and functions"
   FALSE)
 
+option(SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS
+  "Enable experimental NoncopyableGenerics"
+  FALSE)
+
 option(SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING
   "Enable experimental string processing"
   FALSE)
@@ -1230,6 +1234,7 @@ if(SWIFT_BUILD_STDLIB OR SWIFT_BUILD_SDK_OVERLAY)
   message(STATUS "Differentiable Programming Support: ${SWIFT_ENABLE_EXPERIMENTAL_DIFFERENTIABLE_PROGRAMMING}")
   message(STATUS "Concurrency Support:                ${SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY}")
   message(STATUS "Distributed Support:                ${SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED}")
+  message(STATUS "NoncopyableGenerics Support:        ${SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS}")
   message(STATUS "String Processing Support:          ${SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING}")
   message(STATUS "Backtracing Support:                ${SWIFT_ENABLE_BACKTRACING}")
   message(STATUS "Unicode Support:                    ${SWIFT_STDLIB_ENABLE_UNICODE_DATA}")

include/swift/AST/Decl.h

@@ -3191,13 +3191,35 @@ class TypeDecl : public ValueDecl {
 
   void setInherited(ArrayRef<InheritedEntry> i) { Inherited = i; }
 
-  /// Is it possible for this type to lack a Copyable constraint?
+  struct CanBeInvertible {
+    /// Indicates how "strongly" a TypeDecl will conform to an invertible
+    /// protocol. Supports inequality comparisons and casts to bool.
+    enum Result : unsigned {
+      Never = 0,            // Never conforms.
+      Conditionally = 1,    // Conditionally conforms.
+      Always = 2,           // Always conforms.
+    };
+  };
+
+  /// "Does a conformance for Copyable exist for this type declaration?"
+  ///
+  /// This doesn't mean that all instance of this type are Copyable, because
+  /// if a conditional conformance to Copyable exists, this method will return
+  /// true.
+  ///
   /// If you need a more precise answer, ask this Decl's corresponding
-  /// Type if it `isNoncopyable` instead of using this.
-  bool canBeNoncopyable() const;
+  /// Type if it `isCopyable` instead of using this.
+  CanBeInvertible::Result canBeCopyable() const;
 
-  /// Is this declaration escapable?
-  bool isEscapable() const;
+  /// "Does a conformance for Escapable exist for this type declaration?"
+  ///
+  /// This doesn't mean that all instance of this type are Escapable, because
+  /// if a conditional conformance to Escapable exists, this method will return
+  /// true.
+  ///
+  /// If you need a more precise answer, ask this Decl's corresponding
+  /// Type if it `isEscapable` instead of using this.
+  CanBeInvertible::Result canBeEscapable() const;
 
   /// Determine how the given invertible protocol was written on this TypeDecl,
   /// if at all.

include/swift/AST/DiagnosticsSema.def

@@ -863,6 +863,9 @@ ERROR(serialization_target_too_new_repl,none,
       "deployment target of %0 %3: %4",
       (StringRef, llvm::VersionTuple, Identifier, llvm::VersionTuple,
        StringRef))
+ERROR(serialization_noncopyable_generics_mismatch,none,
+      "module %0 was not compiled with NoncopyableGenerics",
+      (Identifier))
 
 ERROR(serialization_fatal,Fatal,
       "fatal error encountered while reading from module '%0'; "

include/swift/AST/Types.h

@@ -651,21 +651,12 @@ class alignas(1 << TypeAlignInBits) TypeBase
 
   bool isPlaceholder();
 
-  /// Returns true if this type lacks conformance to Copyable in the context,
-  /// if provided.
-  bool isNoncopyable(GenericEnvironment *env = nullptr);
-  bool isNoncopyable(const DeclContext *dc) {
-    assert(dc);
-    return isNoncopyable(dc->getGenericEnvironmentOfContext());
-  };
+  /// Returns true if this contextual type does not satisfy a conformance to
+  /// Copyable.
+  bool isNoncopyable();
 
-  /// Returns true if this type conforms to Escapable in the context,
-  /// if provided.
-  bool isEscapable(GenericEnvironment *env = nullptr);
-  bool isEscapable(const DeclContext *dc) {
-    assert(dc);
-    return isEscapable(dc->getGenericEnvironmentOfContext());
-  };
+  /// Returns true if this contextual type satisfies a conformance to Escapable.
+  bool isEscapable();
 
   /// Does the type have outer parenthesis?
   bool hasParenSugar() const { return getKind() == TypeKind::Paren; }
@@ -5574,7 +5565,9 @@ class SILMoveOnlyWrappedType final : public TypeBase,
       : TypeBase(TypeKind::SILMoveOnlyWrapped, &innerType->getASTContext(),
                  innerType->getRecursiveProperties()),
         innerType(innerType) {
-    assert(!innerType->isNoncopyable() && "Inner type must be copyable");
+    // If it has a type parameter, we can't check whether it's copyable.
+    assert(innerType->hasTypeParameter() ||
+           !innerType->isNoncopyable() && "Inner type must be copyable");
   }
 
 public:

include/swift/Config.h.in

@@ -14,6 +14,8 @@
 
 #cmakedefine01 SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED
 
+#cmakedefine01 SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS
+
 #cmakedefine01 SWIFT_ENABLE_GLOBAL_ISEL_ARM64
 
 #endif // SWIFT_CONFIG_H

include/swift/Frontend/ModuleInterfaceLoader.h

@@ -487,6 +487,19 @@ 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;
@@ -495,22 +508,26 @@ 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)
+                                StringRef prebuiltCacheDir,
+                                StringRef BackupInterfaceDir,
+                                ModuleInterfaceLoaderOptions opts,
+                                RequireOSSAModules_t requiresOSSAModules,
+                                RequireNoncopyableGenerics_t requireNCGenerics)
       : Ctx(Ctx), CacheDir(cacheDir), PrebuiltCacheDir(prebuiltCacheDir),
         BackupInterfaceDir(BackupInterfaceDir),
-        Opts(opts), RequiresOSSAModules(requiresOSSAModules) {}
+        Opts(opts), RequiresOSSAModules(requiresOSSAModules),
+        RequireNCGenerics(requireNCGenerics) {}
   explicit ModuleInterfaceCheckerImpl(ASTContext &Ctx, StringRef cacheDir,
-                                      StringRef prebuiltCacheDir,
-                                      ModuleInterfaceLoaderOptions opts,
-                                      RequireOSSAModules_t requiresOSSAModules):
+                                StringRef prebuiltCacheDir,
+                                ModuleInterfaceLoaderOptions opts,
+                                RequireOSSAModules_t requiresOSSAModules,
+                                RequireNoncopyableGenerics_t requireNCGenerics):
     ModuleInterfaceCheckerImpl(Ctx, cacheDir, prebuiltCacheDir, StringRef(),
-                               opts, requiresOSSAModules) {}
+                               opts, requiresOSSAModules, requireNCGenerics) {}
   std::vector<std::string>
   getCompiledModuleCandidatesForInterface(StringRef moduleName,
                                           StringRef interfacePath) override;
@@ -586,6 +603,7 @@ 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
@@ -640,7 +658,8 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
                                      const LangOptions &LangOpts,
                                      const ClangImporterOptions &clangImporterOpts,
                                      bool suppressRemarks,
-                                     RequireOSSAModules_t requireOSSAModules);
+                                     RequireOSSAModules_t requireOSSAModules,
+                                     RequireNoncopyableGenerics_t requireNCGenerics);
   bool extractSwiftInterfaceVersionAndArgs(CompilerInvocation &subInvocation,
                                            SwiftInterfaceInfo &interfaceInfo,
                                            StringRef interfacePath,
@@ -654,7 +673,8 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
       StringRef moduleCachePath, StringRef prebuiltCachePath,
       StringRef backupModuleInterfaceDir,
       bool serializeDependencyHashes, bool trackSystemDependencies,
-      RequireOSSAModules_t requireOSSAModules);
+      RequireOSSAModules_t requireOSSAModules,
+      RequireNoncopyableGenerics_t requireNCGenerics);
 
   template<typename ...ArgTypes>
   static InFlightDiagnostic diagnose(StringRef interfacePath,

include/swift/SIL/SILType.h

@@ -763,9 +763,13 @@ class SILType {
   /// Returns true if this is the AnyObject SILType;
   bool isAnyObject() const { return getASTType()->isAnyObject(); }
 
-  /// Returns true if this type is a first class move only type or a move only
-  /// wrapped type.
-  bool isMoveOnly() const;
+  /// Returns true if this type is a noncopyable type. Otherwise, if the type
+  /// satisfies \c isMoveOnlyWrapped(), then it returns true iff \c orWrapped
+  /// is true. That is,
+  ///
+  /// orWrapped == false -->  isNoncopyable
+  /// orWrapped == true  -->  isNoncopyable || isMoveOnlyWrapped
+  bool isMoveOnly(bool orWrapped=true) const;
 
   /// Return true if this is a value type (struct/enum) that requires
   /// deinitialization beyond destruction of its members.

include/swift/Serialization/SerializedModuleLoader.h

@@ -176,6 +176,7 @@ class SerializedModuleLoaderBase : public ModuleLoader {
                      ModuleLoadingBehavior transitiveBehavior,
                      bool isFramework,
                      bool isRequiredOSSAModules,
+                     bool isRequiredNoncopyableGenerics,
                      StringRef SDKName,
                      StringRef packageName,
                      llvm::vfs::FileSystem *fileSystem,
@@ -205,6 +206,7 @@ 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

@@ -82,7 +82,11 @@ enum class Status {
 
   /// The module file was built with a different SDK than the one in use
   /// to build the client.
-  SDKMismatch
+  SDKMismatch,
+
+  /// The module file was not built with support for NoncopyableGenerics,
+  /// yet that is required to by this compiler.
+  NotUsingNoncopyableGenerics,
 };
 
 /// Returns the string for the Status enum.
@@ -249,6 +253,8 @@ 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
@@ -257,7 +263,8 @@ 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, StringRef requiredSDK,
+    StringRef data, bool requiresOSSAModules, bool requiresNoncopyableGenerics,
+    StringRef requiredSDK,
     ExtendedValidationInfo *extendedInfo = nullptr,
     SmallVectorImpl<SerializationOptions::FileDependency> *dependencies =
         nullptr,

lib/AST/ASTMangler.cpp

@@ -1141,6 +1141,15 @@ void ASTMangler::appendExistentialLayout(
   bool DroppedRequiresClass = false;
   bool SawRequiresClass = false;
   for (auto proto : layout.getProtocols()) {
+    // Skip invertible protocols
+    //
+    // TODO: reconsituteInverses so the absence of such protocols gets mangled.
+    // I think here we need to see if any protocols inheritsFrom
+    // Copyable/Escapable, and if not, and none of those are found in the layout
+    // then it must have had an inverse.
+    if (proto->getInvertibleProtocolKind())
+      continue;
+
     // If we aren't allowed to emit marker protocols, suppress them here.
     if (!AllowMarkerProtocols && proto->isMarkerProtocol()) {
       if (proto->requiresClass())
@@ -2996,14 +3005,28 @@ void ASTMangler::appendTypeListElement(Identifier name, Type elementType,
     appendOperator("d");
 }
 
+/// Filters out requirements stating that a type conforms to one of the
+/// invertible protocols.
+/// TODO: reconsituteInverses so the absence of conformances gets mangled
+static void withoutInvertibleRequirements(ArrayRef<Requirement> requirements,
+                                          SmallVector<Requirement, 4> &output) {
+  for (auto req : requirements) {
+    // Skip conformance requirements for invertible protocols.
+    if (req.getKind() == RequirementKind::Conformance
+        && req.getProtocolDecl()->getInvertibleProtocolKind())
+      continue;
+
+    output.push_back(req);
+  }
+}
+
 bool ASTMangler::appendGenericSignature(GenericSignature sig,
                                         GenericSignature contextSig) {
   auto canSig = sig.getCanonicalSignature();
 
   unsigned initialParamDepth;
   ArrayRef<CanTypeWrapper<GenericTypeParamType>> genericParams;
-  ArrayRef<Requirement> requirements;
-  SmallVector<Requirement, 4> requirementsBuffer;
+  SmallVector<Requirement, 4> requirements;
   if (contextSig) {
     // If the signature is the same as the context signature, there's nothing
     // to do.
@@ -3033,16 +3056,16 @@ bool ASTMangler::appendGenericSignature(GenericSignature sig,
         contextSig.getRequirements().empty()) {
       initialParamDepth = 0;
       genericParams = canSig.getGenericParams();
-      requirements = canSig.getRequirements();
+      withoutInvertibleRequirements(canSig.getRequirements(), requirements);
     } else {
-      requirementsBuffer = canSig.requirementsNotSatisfiedBy(contextSig);
-      requirements = requirementsBuffer;
+      withoutInvertibleRequirements(
+          canSig.requirementsNotSatisfiedBy(contextSig), requirements);
     }
   } else {
     // Use the complete canonical signature.
     initialParamDepth = 0;
     genericParams = canSig.getGenericParams();
-    requirements = canSig.getRequirements();
+    withoutInvertibleRequirements(canSig.getRequirements(), requirements);
   }
 
   if (genericParams.empty() && requirements.empty())

lib/AST/ASTVerifier.cpp

@@ -3288,7 +3288,7 @@ class Verifier : public ASTWalker {
       PrettyStackTraceDecl debugStack("verifying DestructorDecl", DD);
 
       auto *ND = DD->getDeclContext()->getSelfNominalTypeDecl();
-      if (!isa<ClassDecl>(ND) && !ND->canBeNoncopyable() && !DD->isInvalid()) {
+      if (!isa<ClassDecl>(ND) && ND->canBeCopyable() && !DD->isInvalid()) {
         Out << "DestructorDecls outside classes/move only types should be "
                "marked invalid\n";
         abort();

lib/AST/ConformanceLookup.cpp

@@ -620,10 +620,10 @@ LookupConformanceInModuleRequest::evaluate(
         // We only need to do this until we are properly dealing with or
         // omitting Copyable conformances in modules/interfaces.
 
-        if (nominal->canBeNoncopyable())
-          return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
-        else
+        if (nominal->canBeCopyable())
           return ProtocolConformanceRef(protocol);
+        else
+          return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
       }
 
       // Try to infer the conformance.