Merge pull request #73282 from nate-chandler/cherrypick/release/6.0/bitwise-copyable/enable

6.0: [BitwiseCopyable] Promote to feature.

Author: nate-chandler

include/swift/AST/DiagnosticsSema.def

@@ -7694,7 +7694,7 @@ ERROR(non_bitwise_copyable_type_cxx_nontrivial,none,
 ERROR(non_bitwise_copyable_c_type_nontrivial,none,
       "type with unrepresentable fields cannot derive conformance to 'BitwiseCopyable'", ())
 NOTE(note_non_bitwise_copyable_c_type_add_attr,none,
-     "annotate the type __attribute__((__swift_attr__(\"_BitwiseCopyable\")))",())
+     "annotate the type __attribute__((__swift_attr__(\"BitwiseCopyable\")))",())
 ERROR(non_bitwise_copyable_type_member,none,
       "%select{stored property %2|associated value %2}1 of "
       "'BitwiseCopyable'-conforming %kind3 has non-bitwise-copyable type %0",

include/swift/AST/KnownProtocols.def

@@ -150,7 +150,7 @@ PROTOCOL(FloatingPoint)
     INVERTIBLE_PROTOCOL_WITH_NAME(Name, #Name)
 #include "swift/ABI/InvertibleProtocols.def"
 
-REPRESSIBLE_PROTOCOL_(BitwiseCopyable)
+REPRESSIBLE_PROTOCOL(BitwiseCopyable)
 
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByArrayLiteral, "Array", false)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByBooleanLiteral, "BooleanLiteralType", true)

include/swift/Basic/Features.def

@@ -176,6 +176,9 @@ LANGUAGE_FEATURE(BuiltinStoreRaw, 0, "Builtin.storeRaw")
 LANGUAGE_FEATURE(BuiltinCreateTask, 0, "Builtin.createTask and Builtin.createDiscardingTask")
 SUPPRESSIBLE_LANGUAGE_FEATURE(AssociatedTypeImplements, 0, "@_implements on associated types")
 LANGUAGE_FEATURE(MoveOnlyPartialConsumption, 429, "Partial consumption of noncopyable values")
+/// Enable bitwise-copyable feature.
+LANGUAGE_FEATURE(BitwiseCopyable, 426, "BitwiseCopyable protocol")
+SUPPRESSIBLE_LANGUAGE_FEATURE(ConformanceSuppression, 426, "Suppressible inferred conformances")
 
 // Swift 6
 UPCOMING_FEATURE(ConciseMagicFile, 274, 6)
@@ -339,12 +342,6 @@ EXPERIMENTAL_FEATURE(StaticExclusiveOnly, true)
 /// Enable the @extractConstantsFromMembers attribute.
 EXPERIMENTAL_FEATURE(ExtractConstantsFromMembers, false)
 
-/// Enable bitwise-copyable feature.
-EXPERIMENTAL_FEATURE(BitwiseCopyable, true)
-
-/// Enable the suppression of inferred, non-invertible, protocols via ~.
-SUPPRESSIBLE_EXPERIMENTAL_FEATURE(ConformanceSuppression, true)
-
 /// Enables the FixedArray data type.
 EXPERIMENTAL_FEATURE(FixedArrays, true)
 

lib/AST/ProtocolConformance.cpp

@@ -1284,10 +1284,7 @@ static SmallVector<ProtocolConformance *, 2> findSynthesizedConformances(
     for (auto ip : InvertibleProtocolSet::allKnown())
       trySynthesize(getKnownProtocolKind(ip));
 
-    if (nominal->getASTContext().LangOpts.hasFeature(
-            Feature::BitwiseCopyable)) {
-      trySynthesize(KnownProtocolKind::BitwiseCopyable);
-    }
+    trySynthesize(KnownProtocolKind::BitwiseCopyable);
   }
 
   /// Distributed actors can synthesize Encodable/Decodable, so look for those

lib/ClangImporter/ImportDecl.cpp

@@ -8020,9 +8020,7 @@ ClangImporter::Implementation::importSwiftAttrAttributes(Decl *MappedDecl) {
         continue;
       }
 
-      if (swiftAttr->getAttribute() == "_BitwiseCopyable") {
-        if (!SwiftContext.LangOpts.hasFeature(Feature::BitwiseCopyable))
-          continue;
+      if (swiftAttr->getAttribute() == "BitwiseCopyable") {
         auto *protocol =
             SwiftContext.getProtocol(KnownProtocolKind::BitwiseCopyable);
         auto *nominal = dyn_cast<NominalTypeDecl>(MappedDecl);

lib/SIL/IR/TypeLowering.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/DiagnosticEngine.h"
 #include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/Expr.h"
+#include "swift/AST/FileUnit.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
@@ -28,6 +29,7 @@
 #include "swift/AST/Pattern.h"
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/PropertyWrappers.h"
+#include "swift/AST/SourceFile.h"
 #include "swift/AST/TypeDifferenceVisitor.h"
 #include "swift/AST/Types.h"
 #include "swift/ClangImporter/ClangModule.h"
@@ -3034,8 +3036,6 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
                                           AbstractionPattern origType,
                                           CanType substType,
                                           TypeExpansionContext forExpansion) {
-  if (!Context.LangOpts.hasFeature(Feature::BitwiseCopyable))
-    return;
   auto *bitwiseCopyableProtocol =
       Context.getProtocol(KnownProtocolKind::BitwiseCopyable);
   if (!bitwiseCopyableProtocol)
@@ -3050,10 +3050,20 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
 
   if (auto *nominal = substType.getAnyNominal()) {
     auto *module = nominal->getModuleContext();
-    if (module && module->isBuiltFromInterface()) {
-      // Don't verify for types in modules built from interfaces; the feature
-      // may not have been enabled in them.
-      return;
+    if (module) {
+      if (module->isBuiltFromInterface()) {
+        // Don't verify for types in modules built from interfaces; the feature
+        // may not have been enabled in them.
+        return;
+      }
+      auto *file = dyn_cast_or_null<FileUnit>(module->getModuleScopeContext());
+      if (file && file->getKind() == FileUnitKind::Source) {
+        auto sourceFile = nominal->getParentSourceFile();
+        if (sourceFile && sourceFile->Kind == SourceFileKind::SIL) {
+          // Don't verify for types in SIL files.
+          return;
+        }
+      }
     }
   }
 
@@ -3079,6 +3089,7 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
     //     unconditionally but does in this case
     // (8) being or containing the error type
     // (9) explicitly suppressing conformance
+    // (10) a layout constrained archetype
     bool hasNoNonconformingNode = visitAggregateLeaves(
         origType, substType, forExpansion,
         /*isLeafAggregate=*/
@@ -3148,7 +3159,7 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
 
           // ModuleTypes are trivial but don't warrant being given a
           // conformance to BitwiseCopyable (case (3)).
-          if (isa<ModuleType, SILTokenType>(ty)) {
+          if (isa<ModuleType>(ty) || isa<SILTokenType>(ty)) {
             // These types should never appear within aggregates.
             assert(isTopLevel && "aggregate containing marker type!?");
             // If they did, though, they would not justify the aggregate's
@@ -3167,13 +3178,21 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
             return !isTopLevel;
           }
 
+          // Case (10): a layout-constrained archetype.
+          if (auto archetype = dyn_cast<ArchetypeType>(ty)) {
+            auto constraint = archetype->getLayoutConstraint();
+            if (constraint && constraint->isTrivial()) {
+              return false;
+            }
+          }
+
           auto *nominal = ty.getAnyNominal();
 
           // Non-nominal types (besides case (3) handled above) are trivial iff
           // conforming.
           if (!nominal) {
             llvm::errs()
-                << "Non-nominal type without conformance to _BitwiseCopyable:\n"
+                << "Non-nominal type without conformance to BitwiseCopyable:\n"
                 << ty << "\n"
                 << "within " << substType << "\n"
                 << "of " << origType << "\n";
@@ -3284,7 +3303,7 @@ void TypeConverter::verifyTrivialLowering(const TypeLowering &lowering,
           return true;
         });
     if (hasNoConformingArchetypeNode) {
-      llvm::errs() << "Non-trivial type with _BitwiseCopyable conformance!?:\n"
+      llvm::errs() << "Non-trivial type with BitwiseCopyable conformance!?:\n"
                    << substType << "\n";
       conformance.print(llvm::errs());
       llvm::errs() << "\n"

lib/Sema/LifetimeDependence.cpp

@@ -205,14 +205,12 @@ LifetimeDependenceInfo::fromTypeRepr(AbstractFunctionDecl *afd) {
     // error.
     // TODO: Diagnose ~Escapable types are always non-trivial in SIL.
     if (paramType->isEscapable()) {
-      if (ctx.LangOpts.hasFeature(Feature::BitwiseCopyable)) {
-        auto *bitwiseCopyableProtocol =
-            ctx.getProtocol(KnownProtocolKind::BitwiseCopyable);
-        if (bitwiseCopyableProtocol &&
-            mod->checkConformance(paramType, bitwiseCopyableProtocol)) {
-          diags.diagnose(loc, diag::lifetime_dependence_on_bitwise_copyable);
-          return true;
-        }
+      auto *bitwiseCopyableProtocol =
+          ctx.getProtocol(KnownProtocolKind::BitwiseCopyable);
+      if (bitwiseCopyableProtocol &&
+          mod->checkConformance(paramType, bitwiseCopyableProtocol)) {
+        diags.diagnose(loc, diag::lifetime_dependence_on_bitwise_copyable);
+        return true;
       }
     }
 
@@ -425,16 +423,14 @@ LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd) {
   if (!cd && afd->hasImplicitSelfDecl()) {
     Type selfTypeInContext = dc->getSelfTypeInContext();
     if (selfTypeInContext->isEscapable()) {
-      if (ctx.LangOpts.hasFeature(Feature::BitwiseCopyable)) {
-        auto *bitwiseCopyableProtocol =
-            ctx.getProtocol(KnownProtocolKind::BitwiseCopyable);
-        if (bitwiseCopyableProtocol &&
-            mod->checkConformance(selfTypeInContext, bitwiseCopyableProtocol)) {
-          diags.diagnose(
-              returnLoc,
-              diag::lifetime_dependence_method_escapable_bitwisecopyable_self);
-          return std::nullopt;
-        }
+      auto *bitwiseCopyableProtocol =
+          ctx.getProtocol(KnownProtocolKind::BitwiseCopyable);
+      if (bitwiseCopyableProtocol &&
+          mod->checkConformance(selfTypeInContext, bitwiseCopyableProtocol)) {
+        diags.diagnose(
+            returnLoc,
+            diag::lifetime_dependence_method_escapable_bitwisecopyable_self);
+        return std::nullopt;
       }
     }
     auto kind = getLifetimeDependenceKindFromType(selfTypeInContext);

lib/Sema/TypeCheckDecl.cpp

@@ -682,9 +682,9 @@ ExistentialConformsToSelfRequest::evaluate(Evaluator &evaluator,
                                            ProtocolDecl *decl) const {
   // Marker protocols always self-conform.
   if (decl->isMarkerProtocol()) {
-    // Except for BitwiseCopyable an existential of which is non-trivial.
-    if (decl->getASTContext().LangOpts.hasFeature(Feature::BitwiseCopyable) &&
-        decl->getKnownProtocolKind() == KnownProtocolKind::BitwiseCopyable) {
+    // Except for BitwiseCopyable an existential of which is not bitwise
+    // copyable.
+    if (decl->getKnownProtocolKind() == KnownProtocolKind::BitwiseCopyable) {
       return false;
     }
     return true;

lib/Sema/TypeCheckProtocol.cpp

@@ -6117,11 +6117,9 @@ void TypeChecker::checkConformancesInContext(IterableDeclContext *idc) {
         break;
       }
       case KnownProtocolKind::BitwiseCopyable: {
-        if (Context.LangOpts.hasFeature(Feature::BitwiseCopyable)) {
-          checkBitwiseCopyableConformance(
-              conformance, /*isImplicit=*/conformance->getSourceKind() ==
-                               ConformanceEntryKind::Synthesized);
-        }
+        checkBitwiseCopyableConformance(
+            conformance, /*isImplicit=*/conformance->getSourceKind() ==
+                             ConformanceEntryKind::Synthesized);
         break;
       }
       default:

stdlib/public/core/CMakeLists.txt

@@ -315,9 +315,7 @@ list(APPEND swift_stdlib_compile_flags "-Xfrontend" "-enable-experimental-concis
 list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "Macros")
 list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "FreestandingMacros")
 list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "Extern")
-list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "BitwiseCopyable")
 list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "BorrowingSwitch")
-list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "ConformanceSuppression")
 
 if("${SWIFT_NATIVE_SWIFT_TOOLS_PATH}" STREQUAL "")
   set(swift_bin_dir "${CMAKE_BINARY_DIR}/bin")