[BitwiseCopyable] Infer and check constraint.

When the BitwiseCopyable experimental feature is enabled, infer types to
conform to `_BitwiseCopyable`.  The `_BitwiseCopyable` inference broadly
follows the approach taken to infer `Sendable`.

(1) Special types are conformed:
- function types if trivial
- metatypes
- builtin types if trivial

(2) TheTupleType is conditionally conformed.

(3) Nominal types are conformed if:
- non-public or public+fixed-layout
- enum or struct (non-class)
- every field conforms to _BitwiseCopyable

Additionally, check that nominal types which are explicitly conformed to
`_BitwiseCopyable` satisfy the latter two conditions of (3).

For a public, non-fixed-layout type to conform to `_BitwiseCopyable`,
the user must conform the type explicitly.

Finally, verify that conformances correspond to TypeLowering's notion of
triviality to the appropriate extent:
- if a type isn't trivial, it doesn't conform to `_BitwiseCopyable`
  unless it's an archetype
- if a type is trivial, it conforms to `_BitwiseCopyable` unless some
  field in its layout doesn't conform to `_BitwiseCopyable`, which is
  only permitted under certain circumstances (the type has generic
  parameters, the type is public non-fixed-layout, the type is a
  reference but has ReferenceStorage::Unmanaged, the type is a
  ModuleType, etc.)

Author: nate-chandler

include/swift/AST/DiagnosticsSema.def

@@ -7576,6 +7576,24 @@ NOTE(add_explicit_protocol_for_conformance,none,
 ERROR(escapable_requires_feature_flag,none,
       "type '~Escapable' requires -enable-experimental-feature NonescapableTypes",
       ())
+ERROR(non_bitwise_copyable_type_class,none,
+      "class cannot conform to '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",
+      (Type, bool, DeclName, const ValueDecl *))
+NOTE(non_bitwise_copyable_nominal,none,
+     "%kind0 does not conform to the 'BitwiseCopyable' protocol",
+      (const ValueDecl *))
+NOTE(non_bitwise_copyable_function_type,none,
+      "a function type must be marked '@convention(thin)' or '@convention(c)' to be bitwise copyable",
+      ())
+NOTE(add_nominal_bitwise_copyable_conformance,none,
+     "consider making %kind0 conform to the 'BitwiseCopyable' protocol",
+     (const ValueDecl *))
+NOTE(add_generic_parameter_non_bitwise_copyable_conformance,none,
+     "consider making generic parameter %0 conform to the 'BitwiseCopyable' protocol",
+     (Type))
 
 // -- older ones below --
 

include/swift/AST/Types.h

@@ -1640,6 +1640,7 @@ class BuiltinType : public TypeBase {
                         bool prependBuiltinNamespace = true) const;
 
   BuiltinTypeKind getBuiltinTypeKind() const;
+  bool isBitwiseCopyable() const;
 };
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinType, Type)
 

include/swift/SIL/TypeLowering.h

@@ -1285,6 +1285,9 @@ class TypeConverter {
   void verifyLexicalLowering(const TypeLowering &, AbstractionPattern origType,
                              CanType origSubstType,
                              TypeExpansionContext forExpansion);
+  void verifyTrivialLowering(const TypeLowering &, AbstractionPattern origType,
+                             CanType origSubstType,
+                             TypeExpansionContext forExpansion);
   bool visitAggregateLeaves(
       Lowering::AbstractionPattern origType, CanType substType,
       TypeExpansionContext context,

lib/AST/ASTContext.cpp

@@ -6295,6 +6295,9 @@ BuiltinTupleDecl *ASTContext::getBuiltinTupleDecl() {
   if (auto *proto = getProtocol(KnownProtocolKind::Escapable))
     buildFakeExtension(proto);
 
+  if (auto *proto = getProtocol(KnownProtocolKind::BitwiseCopyable))
+    buildFakeExtension(proto);
+
   return result;
 }
 

lib/AST/Builtins.cpp

@@ -3092,6 +3092,27 @@ BuiltinTypeKind BuiltinType::getBuiltinTypeKind() const {
   return BuiltinTypeKind(std::underlying_type<TypeKind>::type(getKind()));
 }
 
+bool BuiltinType::isBitwiseCopyable() const {
+  switch (getBuiltinTypeKind()) {
+  case BuiltinTypeKind::BuiltinInteger:
+  case BuiltinTypeKind::BuiltinIntegerLiteral:
+  case BuiltinTypeKind::BuiltinFloat:
+  case BuiltinTypeKind::BuiltinPackIndex:
+  case BuiltinTypeKind::BuiltinRawPointer:
+  case BuiltinTypeKind::BuiltinVector:
+  case BuiltinTypeKind::BuiltinExecutor:
+  case BuiltinTypeKind::BuiltinJob:
+  case BuiltinTypeKind::BuiltinRawUnsafeContinuation:
+    return true;
+  case BuiltinTypeKind::BuiltinNativeObject:
+  case BuiltinTypeKind::BuiltinBridgeObject:
+  case BuiltinTypeKind::BuiltinUnsafeValueBuffer:
+  case BuiltinTypeKind::BuiltinDefaultActorStorage:
+  case BuiltinTypeKind::BuiltinNonDefaultDistributedActorStorage:
+    return false;
+  }
+}
+
 StringRef BuiltinType::getTypeName(SmallVectorImpl<char> &result,
                                    bool prependBuiltinNamespace) const {
 #ifdef MAYBE_GET_NAMESPACED_BUILTIN

lib/AST/Module.cpp

@@ -1808,6 +1808,34 @@ static bool isEscapableFunctionType(EitherFunctionType eitherFnTy) {
   return !functionType->isNoEscape();
 }
 
+static bool isBitwiseCopyableFunctionType(EitherFunctionType eitherFnTy) {
+  SILFunctionTypeRepresentation representation;
+  if (auto silFnTy = eitherFnTy.dyn_cast<const SILFunctionType *>()) {
+    representation = silFnTy->getRepresentation();
+  } else {
+    auto fnTy = eitherFnTy.get<const FunctionType *>();
+    representation = convertRepresentation(fnTy->getRepresentation());
+  }
+
+  switch (representation) {
+  case SILFunctionTypeRepresentation::Thick:
+  case SILFunctionTypeRepresentation::Block:
+    return false;
+  case SILFunctionTypeRepresentation::Thin:
+  case SILFunctionTypeRepresentation::CXXMethod:
+  case SILFunctionTypeRepresentation::CFunctionPointer:
+  case SILFunctionTypeRepresentation::Method:
+  case SILFunctionTypeRepresentation::ObjCMethod:
+  case SILFunctionTypeRepresentation::WitnessMethod:
+  case SILFunctionTypeRepresentation::Closure:
+  case SILFunctionTypeRepresentation::KeyPathAccessorGetter:
+  case SILFunctionTypeRepresentation::KeyPathAccessorSetter:
+  case SILFunctionTypeRepresentation::KeyPathAccessorEquals:
+  case SILFunctionTypeRepresentation::KeyPathAccessorHash:
+    return true;
+  }
+}
+
 /// Synthesize a builtin function type conformance to the given protocol, if
 /// appropriate.
 static ProtocolConformanceRef getBuiltinFunctionTypeConformance(
@@ -1835,6 +1863,10 @@ static ProtocolConformanceRef getBuiltinFunctionTypeConformance(
       // Functions cannot permanently destroy a move-only var/let
       // that they capture, so it's safe to copy functions, like classes.
       return synthesizeConformance();
+    case KnownProtocolKind::BitwiseCopyable:
+      if (isBitwiseCopyableFunctionType(functionType))
+        return synthesizeConformance();
+      break;
     default:
       break;
     }
@@ -1861,12 +1893,13 @@ static ProtocolConformanceRef getBuiltinMetaTypeTypeConformance(
     }
   }
 
-  // All metatypes are Sendable, Copyable, and Escapable.
+  // All metatypes are Sendable, Copyable, Escapable, and BitwiseCopyable.
   if (auto kp = protocol->getKnownProtocolKind()) {
     switch (*kp) {
     case KnownProtocolKind::Sendable:
     case KnownProtocolKind::Copyable:
     case KnownProtocolKind::Escapable:
+    case KnownProtocolKind::BitwiseCopyable:
       return ProtocolConformanceRef(
           ctx.getBuiltinConformance(type, protocol,
                                     BuiltinConformanceKind::Synthesized));
@@ -1880,11 +1913,12 @@ static ProtocolConformanceRef getBuiltinMetaTypeTypeConformance(
 
 /// Synthesize a builtin type conformance to the given protocol, if
 /// appropriate.
-static ProtocolConformanceRef getBuiltinBuiltinTypeConformance(
-    Type type, const BuiltinType *builtinType, ProtocolDecl *protocol) {
-  // All builtin are Sendable, Copyable, and Escapable
+static ProtocolConformanceRef
+getBuiltinBuiltinTypeConformance(Type type, const BuiltinType *builtinType,
+                                 ProtocolDecl *protocol) {
   if (auto kp = protocol->getKnownProtocolKind()) {
     switch (*kp) {
+    // All builtin types are Sendable, Copyable, and Escapable.
     case KnownProtocolKind::Sendable:
     case KnownProtocolKind::Copyable:
     case KnownProtocolKind::Escapable: {
@@ -1893,6 +1927,15 @@ static ProtocolConformanceRef getBuiltinBuiltinTypeConformance(
           ctx.getBuiltinConformance(type, protocol,
                                   BuiltinConformanceKind::Synthesized));
     }
+    // Some builtin types are BitwiseCopyable.
+    case KnownProtocolKind::BitwiseCopyable: {
+      if (builtinType->isBitwiseCopyable()) {
+        ASTContext &ctx = protocol->getASTContext();
+        return ProtocolConformanceRef(ctx.getBuiltinConformance(
+            type, protocol, BuiltinConformanceKind::Synthesized));
+      }
+      break;
+    }
     default:
       break;
     }
@@ -2116,6 +2159,18 @@ LookupConformanceInModuleRequest::evaluate(
       } else {
         return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
       }
+    } else if (protocol->isSpecificProtocol(
+                   KnownProtocolKind::BitwiseCopyable)) {
+      // Try to infer BitwiseCopyable conformance.
+      ImplicitKnownProtocolConformanceRequest request{
+          nominal, KnownProtocolKind::BitwiseCopyable};
+      if (auto conformance =
+              evaluateOrDefault(ctx.evaluator, request, nullptr)) {
+        conformances.clear();
+        conformances.push_back(conformance);
+      } else {
+        return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
+      }
     } else {
       // Was unable to infer the missing conformance.
       return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);

lib/AST/ProtocolConformance.cpp

@@ -1258,6 +1258,11 @@ static SmallVector<ProtocolConformance *, 2> findSynthesizedConformances(
       trySynthesize(KnownProtocolKind::Copyable);
       trySynthesize(KnownProtocolKind::Escapable);
     }
+
+    if (nominal->getASTContext().LangOpts.hasFeature(
+            Feature::BitwiseCopyable)) {
+      trySynthesize(KnownProtocolKind::BitwiseCopyable);
+    }
   }
 
   /// Distributed actors can synthesize Encodable/Decodable, so look for those

lib/SIL/IR/TypeLowering.cpp

@@ -2942,6 +2942,7 @@ void TypeConverter::verifyLowering(const TypeLowering &lowering,
                                    CanType substType,
                                    TypeExpansionContext forExpansion) {
   verifyLexicalLowering(lowering, origType, substType, forExpansion);
+  verifyTrivialLowering(lowering, origType, substType, forExpansion);
 }
 
 void TypeConverter::verifyLexicalLowering(const TypeLowering &lowering,
@@ -3014,6 +3015,148 @@ void TypeConverter::verifyLexicalLowering(const TypeLowering &lowering,
            "Found non-trivial lexical leaf in non-trivial non-lexical type?!");
   }
 }
+
+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)
+    return;
+
+  auto conformance = M.conformsToProtocol(substType, bitwiseCopyableProtocol);
+
+  if (lowering.isTrivial() && !conformance) {
+    // A trivial type can only lack a conformance if one of its leaves is a
+    // public type that doesn't conform.
+    bool hasNoNonconformingNode = visitAggregateLeaves(
+        origType, substType, forExpansion,
+        /*isLeaf=*/
+        [&](auto ty, auto origTy, auto *field, auto index) -> bool {
+          // The field's type is an aggregate.  Treat it as a leaf if it is
+          // public.
+          auto *nominal = ty.getAnyNominal();
+          // Non-nominal types are public iff their components are; visit the
+          // components.
+          if (!nominal)
+            return false;
+
+          // Nominals with generic parameters must be explicitly conformed to
+          // BitwiseCopyable.
+          auto *generic = ty.getAnyGeneric();
+          if (generic && generic->isGenericContext()) {
+            return true;
+          }
+
+          return nominal
+              ->getFormalAccessScope(/*useDC=*/nullptr,
+                                     /*treatUsableFromInlineAsPublic=*/true)
+              .isPublic();
+        },
+        /*visit=*/
+        [&](auto ty, auto origTy, auto *field, auto index) -> bool {
+          // Return false to indicate seeing a leaf which justifies the type
+          // being trivial but not conforming to BitwiseCopyable.
+
+          // A BitwiseCopyable conformer appearing within its layout doesn't
+          // explain why substType doesn't itself conform.
+          if (M.conformsToProtocol(ty, bitwiseCopyableProtocol))
+            return true;
+
+          // ModuleTypes are trivial but don't warrant being given a conformance
+          // to BitwiseCopyable.
+          if (auto mt = dyn_cast<ModuleType>(ty)) {
+            // If one were to appear within a type, its lack of conformance
+            // wouldn't result in the type's failure to conform.  Conversely, if
+            // substType itself is the ModuleType, it is trivial and
+            // non-conformant; return false to indicate its the leaf which
+            // justifies substType being non-conformant.
+            return field;
+          }
+
+          // Given a non-bitwise-copyable C, unowned(unsafe) C is still
+          // BitwiseCopyable.
+          auto rst = dyn_cast<ReferenceStorageType>(ty);
+          if (rst && rst->getOwnership() == ReferenceOwnership::Unmanaged) {
+            // If a ReferenceStorageType appears as a component of an aggregate,
+            // that shouldn't stop the aggregate from being BitwiseCopyable.  If
+            // the whole type is the ReferenceStorageType, however, it does not
+            // conform.
+            return field;
+          }
+
+          auto *nominal = ty.getAnyNominal();
+
+          // Non-nominal types are trivial iff conforming.
+          if (!nominal) {
+            llvm::errs()
+                << "Non-nominal type without conformance to _BitwiseCopyable:\n"
+                << ty << "\n"
+                << "within " << substType << "\n"
+                << "of " << origType << "\n";
+            assert(false);
+            return true;
+          }
+
+          /// A non-conforming generic nominal type justifies substType not
+          /// conforming.
+          auto *generic = ty.getAnyGeneric();
+          if (generic && generic->isGenericContext()) {
+            return false;
+          }
+
+          // The field is trivial and the whole type is nonconforming.  That's
+          // legal iff the type is public.
+          return !nominal
+                      ->getFormalAccessScope(
+                          /*useDC=*/nullptr,
+                          /*treatUsableFromInlineAsPublic=*/true)
+                      .isPublic();
+        });
+    if (hasNoNonconformingNode) {
+      llvm::errs() << "Trivial type without a BitwiseCopyable conformance!?:\n"
+                   << substType << "\n"
+                   << "of " << origType << "\n";
+      assert(false);
+    }
+  }
+
+  if (!lowering.isTrivial() && conformance) {
+    // A non-trivial type can only conform if at least one of its leaves is a
+    // type parameter that conforms.
+    bool hasNoConformingArchetypeNode = visitAggregateLeaves(
+        origType, substType, forExpansion,
+        /*isLeaf=*/
+        [&](auto ty, auto origTy, auto *field, auto index) -> bool {
+          // Walk into every aggregate.
+          return false;
+        },
+        /*visit=*/
+        [&](auto ty, auto origTy, auto *field, auto index) -> bool {
+          // Return false to indicate visiting a type parameter.
+
+          if (origTy.isTypeParameter())
+            return false;
+
+          // Unfortunately, the type parameter's conformance may not be visible
+          // here.
+          assert(M.conformsToProtocol(ty, bitwiseCopyableProtocol) &&
+                 "leaf of non-trivial BitwiseCopyable type that doesn't "
+                 "conform to BitwiseCopyable!?");
+
+          return true;
+        });
+    if (hasNoConformingArchetypeNode) {
+      llvm::errs() << "Non-trivial type with _BitwiseCopyable conformance!?:\n"
+                   << substType << "\n";
+      conformance.print(llvm::errs());
+      assert(false);
+    }
+  }
+}
 #endif
 
 CanType

lib/Sema/CMakeLists.txt

@@ -45,6 +45,7 @@ add_swift_host_library(swiftSema STATIC
   TypeCheckAccess.cpp
   TypeCheckAttr.cpp
   TypeCheckAvailability.cpp
+  TypeCheckBitwise.cpp
   TypeCheckCaptures.cpp
   TypeCheckCircularity.cpp
   TypeCheckCodeCompletion.cpp