[Sema] "Noncopyable" means no Copyable conformance

Author: kavon

include/swift/AST/Decl.h

@@ -3110,13 +3110,13 @@ class TypeDecl : public ValueDecl {
   ArrayRef<InheritedEntry> Inherited;
 
   struct {
-    /// Whether the "isNoncopyable" bit has been computed yet.
-    unsigned isNoncopyableComputed : 1;
+    /// Whether the "hasNoncopyableAnnotation" bit has been computed yet.
+    unsigned isNoncopyableAnnotationComputed : 1;
 
-    /// Whether this declaration supports copying.
-    unsigned isNoncopyable : 1;
+    /// Whether this declaration had a noncopyable inverse written somewhere.
+    unsigned hasNoncopyableAnnotation : 1;
   } LazySemanticInfo = { };
-  friend class IsNoncopyableRequest;
+  friend class HasNoncopyableAnnotationRequest;
 
 protected:
   TypeDecl(DeclKind K, llvm::PointerUnion<DeclContext *, ASTContext *> context,

include/swift/AST/DiagnosticsSema.def

@@ -7452,6 +7452,25 @@ ERROR(accessor_macro_not_single_var, none,
 ERROR(noncopyable_class, none,
       "classes cannot be noncopyable",
       ())
+ERROR(noncopyable_type_member_in_copyable,none,
+      "%select{stored property %2|associated value %2}1 of "
+      "'Copyable'-conforming %kind3 has noncopyable type %0",
+      (Type, bool, DeclName, const ValueDecl *))
+NOTE(add_inverse_for_containment,none,
+     "consider removing implicit '%1' conformance from %kind0",
+     (const ValueDecl *, StringRef))
+NOTE(remove_inverse_on_generic_parameter_for_conformance,none,
+     "consider removing '~%1' from generic parameter %0 so it conforms to the '%1' protocol",
+     (Type, StringRef))
+NOTE(remove_inverse_on_nominal_for_conformance,none,
+     "consider removing '~%1' from %kind0 so it conforms to the '%1' protocol",
+     (const ValueDecl *, StringRef))
+NOTE(add_explicit_protocol_for_conformance,none,
+     "consider making %kind0 explicitly conform to the '%1' protocol",
+     (const ValueDecl *, StringRef))
+
+// -- older ones below --
+
 ERROR(noncopyable_within_copyable, none,
       "%kind0 cannot contain a noncopyable type without also being noncopyable",
       (const ValueDecl *))

include/swift/AST/TypeCheckRequests.h

@@ -407,9 +407,10 @@ class IsFinalRequest :
   void cacheResult(bool value) const;
 };
 
-/// Determine whether the given declaration is noncopyable
-class IsNoncopyableRequest
-    : public SimpleRequest<IsNoncopyableRequest, bool(TypeDecl *),
+/// Determine whether the given declaration has any markings that would cause it
+/// to not have an implicit, unconditional conformance to Copyable.
+class HasNoncopyableAnnotationRequest
+    : public SimpleRequest<HasNoncopyableAnnotationRequest, bool(TypeDecl *),
                            RequestFlags::SeparatelyCached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -427,6 +428,24 @@ class IsNoncopyableRequest
   void cacheResult(bool value) const;
 };
 
+/// Determine whether the given type is noncopyable. Assumes type parameters
+/// have become archetypes.
+class IsNoncopyableRequest
+    : public SimpleRequest<IsNoncopyableRequest, bool(CanType),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  bool evaluate(Evaluator &evaluator, CanType type) const;
+
+public:
+  // Caching.
+  bool isCached() const { return true; }
+};
 
 /// Determine whether the given declaration is escapable.
 class IsEscapableRequest
@@ -448,6 +467,46 @@ class IsEscapableRequest
   void cacheResult(bool value) const;
 };
 
+
+/// Determine whether the given declaration is escapable.
+class IsEscapableRequest
+    : public SimpleRequest<IsEscapableRequest, bool(ValueDecl *),
+                           RequestFlags::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  bool evaluate(Evaluator &evaluator, ValueDecl *decl) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+  llvm::Optional<bool> getCachedResult() const;
+  void cacheResult(bool value) const;
+};
+
+/// Determine whether the given type is noncopyable. Assumes type parameters
+/// have become archetypes.
+class IsNoncopyableRequest
+    : public SimpleRequest<IsNoncopyableRequest, bool(CanType),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  bool evaluate(Evaluator &evaluator, CanType type) const;
+
+public:
+  // Caching.
+  bool isCached() const { return true; }
+};
+
 /// Determine whether the given declaration is 'dynamic''.
 class IsDynamicRequest :
     public SimpleRequest<IsDynamicRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -210,8 +210,11 @@ SWIFT_REQUEST(TypeChecker, IsDynamicRequest, bool(ValueDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsFinalRequest, bool(ValueDecl *), SeparatelyCached,
               NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, IsNoncopyableRequest, bool(TypeDecl *), SeparatelyCached,
+SWIFT_REQUEST(TypeChecker, HasNoncopyableAnnotationRequest, bool(TypeDecl *), SeparatelyCached,
               NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, IsNoncopyableRequest,
+              bool (CanType),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsEscapableRequest, bool(ValueDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsGetterMutatingRequest, bool(AbstractStorageDecl *),

include/swift/AST/Types.h

@@ -100,6 +100,7 @@ class ProtocolConformance;
 enum PointerTypeKind : unsigned;
 struct ValueOwnershipKind;
 class ErrorExpr;
+enum class KnownProtocolKind : uint8_t;
 
 typedef CanTypeWrapper<SILFunctionType> CanSILFunctionType;
 
@@ -636,9 +637,12 @@ class alignas(1 << TypeAlignInBits) TypeBase
 
   bool isPlaceholder();
 
-  /// Returns true if this is a noncopyable type.
+  /// DEPRECIATED: Returns true if this is a noncopyable type.
   bool isNoncopyable();
 
+  /// Returns true if this type lacks conformance to Copyable in the context.
+  bool isNoncopyable(const DeclContext *dc);
+
   /// Does the type have outer parenthesis?
   bool hasParenSugar() const { return getKind() == TypeKind::Paren; }
 

lib/AST/ConformanceLookupTable.cpp

@@ -810,7 +810,7 @@ bool ConformanceLookupTable::resolveConformances(ProtocolDecl *protocol) {
   return anySuperseded;
 }
 
-DeclContext *ConformanceLookupTable::getConformingContext(
+DeclContext *ConformanceLookupTable:: getConformingContext(
                NominalTypeDecl *nominal,
                ConformanceEntry *entry) {
   ProtocolDecl *protocol = entry->getProtocol();
@@ -848,7 +848,8 @@ DeclContext *ConformanceLookupTable::getConformingContext(
     const auto &superclassConformances =
         superclassDecl->ConformanceTable->Conformances[protocol];
     if (superclassConformances.empty()) {
-      assert(protocol->isSpecificProtocol(KnownProtocolKind::Sendable));
+      assert(protocol->isSpecificProtocol(KnownProtocolKind::Sendable) ||
+             protocol->isSpecificProtocol(KnownProtocolKind::Copyable));
 
       // Go dig for a superclass that does conform to Sendable.
       // FIXME: This is a hack because the inherited conformances aren't

lib/AST/Decl.cpp

@@ -4836,11 +4836,10 @@ GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(
 }
 
 bool TypeDecl::isNoncopyable() const {
-  assert(!getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)
-  && "TypeDecl::isNoncopyable() is not compatible with NoncopyableGenerics");
-
+  // NOTE: must answer true iff it is unconditionally noncopyable.
   return evaluateOrDefault(getASTContext().evaluator,
-                           IsNoncopyableRequest{const_cast<TypeDecl *>(this)},
+                           HasNoncopyableAnnotationRequest{
+                               const_cast<TypeDecl *>(this)},
                            true); // default to true for safety
 }
 

lib/AST/Module.cpp

@@ -1795,16 +1795,21 @@ static ProtocolConformanceRef getBuiltinMetaTypeTypeConformance(
     Type type, const AnyMetatypeType *metatypeType, ProtocolDecl *protocol) {
   ASTContext &ctx = protocol->getASTContext();
 
-  // Only metatypes of Copyable types are Copyable.
-  if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable) &&
-      !metatypeType->getInstanceType()->isNoncopyable()) {
-    return ProtocolConformanceRef(
-        ctx.getBuiltinConformance(type, protocol,
-                                  BuiltinConformanceKind::Synthesized));
+  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
-  if (protocol->isSpecificProtocol(KnownProtocolKind::Sendable)) {
+  // All metatypes are Sendable and Copyable
+  if (protocol->isSpecificProtocol(KnownProtocolKind::Sendable) ||
+      protocol->isSpecificProtocol(KnownProtocolKind::Copyable)) {
     return ProtocolConformanceRef(
         ctx.getBuiltinConformance(type, protocol,
                                   BuiltinConformanceKind::Synthesized));
@@ -1876,9 +1881,10 @@ LookupConformanceInModuleRequest::evaluate(
   // constraint and the superclass conforms to the protocol.
   if (auto archetype = type->getAs<ArchetypeType>()) {
 
-    // All archetypes conform to Copyable since they represent a generic.
-    if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable))
-      return ProtocolConformanceRef(protocol);
+    // Without noncopyable generics, all archetypes are Copyable
+    if (!ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics))
+      if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable))
+        return ProtocolConformanceRef(protocol);
 
     // The generic signature builder drops conformance requirements that are made
     // redundant by a superclass requirement, so check for a concrete
@@ -2002,6 +2008,18 @@ LookupConformanceInModuleRequest::evaluate(
         return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
       }
     } else if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable)) {
+
+      if (!ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
+        // Return an abstract conformance to maintain legacy compatability.
+        // We only need to do this until we are properly dealing with or
+        // omitting Copyable conformances in modules/interfaces.
+
+        if (nominal->isNoncopyable())
+          return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
+        else
+          return ProtocolConformanceRef(protocol);
+      }
+
       // Try to infer Copyable conformance.
       ImplicitKnownProtocolConformanceRequest
           cvRequest{nominal, KnownProtocolKind::Copyable};

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -784,7 +784,7 @@ void swift::rewriting::realizeInheritedRequirements(
     // associated type or generic type param.
     for (auto kp : defaults) {
       ProtocolDecl *decl = ctx.getProtocol(kp);
-      assert(decl && "couldn't load protocol??");
+      if (!decl) llvm_unreachable("missing known protocol!");
 
       SourceLoc loc = decl->getLoc();
       Type protocolType = decl->getDeclaredInterfaceType();

lib/AST/Type.cpp

@@ -157,25 +157,73 @@ bool TypeBase::isMarkerExistential() {
   return true;
 }
 
-bool TypeBase::isNoncopyable() {
-  assert(!getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)
-  && "TypeBase::isNoncopyable() is not compatible with NoncopyableGenerics");
-
-  if (auto *nom = getAnyNominal())
-    return nom->isNoncopyable();
+/// 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->isNoncopyable();
 
-  if (auto *expansion = getAs<PackExpansionType>()) {
-    return expansion->getPatternType()->isNoncopyable();
+  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 = getCanonicalType()->getAs<TupleType>()) {
+  if (auto *tupl = ty->getCanonicalType()->getAs<TupleType>()) {
     for (auto eltTy : tupl->getElementTypes())
-      if (eltTy->isNoncopyable())
+      if (alwaysNoncopyable(eltTy))
         return true;
   }
 
-  return false;
+  return false; // otherwise, the conservative assumption is it's copyable.
+}
+
+/// \returns true iff this type lacks conformance to Copyable, using the given
+/// context to substitute unbound types.
+bool TypeBase::isNoncopyable(const DeclContext *dc) {
+  assert(dc);
+
+  /** FIXME: seems this is busted :(
+  // Fast-path for type parameters; ask the generic signature directly and
+  // cache that answer.
+  if (isTypeParameter()) {
+    auto canType = getCanonicalType();
+    auto &ctx = canType->getASTContext();
+    IsNoncopyableRequest req {canType};
+
+    if (ctx.evaluator.hasCachedResult(req))
+      return evaluateOrDefault(ctx.evaluator, req, true);
+
+    auto *copyableProto = ctx.getProtocol(KnownProtocolKind::Copyable);
+    if (!copyableProto)
+      llvm_unreachable("missing Copyable protocol!");
+
+    auto sig = dc->getGenericSignatureOfContext();
+    bool isNoncopyable = !sig->requiresProtocol(canType, copyableProto);
+    ctx.evaluator.cacheOutput(req, isNoncopyable == true);
+
+    return isNoncopyable;
+  }
+  */
+
+  if (!hasArchetype() || hasOpenedExistential())
+  // TODO: the need for the following test is suspicious.
+    if (dc->getGenericEnvironmentOfContext() || !hasTypeParameter())
+      return dc->mapTypeIntoContext(this)->isNoncopyable();
+
+  return isNoncopyable();
+}
+
+/// \returns true iff this type lacks conformance to Copyable.
+bool TypeBase::isNoncopyable() {
+  auto canType = getCanonicalType();
+  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);
+
+  IsNoncopyableRequest request{canType};
+  return evaluateOrDefault(ctx.evaluator, request, /*default=*/true);
 }
 
 bool TypeBase::isPlaceholder() {

lib/AST/TypeCheckRequests.cpp

@@ -314,21 +314,21 @@ void IsFinalRequest::cacheResult(bool value) const {
 }
 
 //----------------------------------------------------------------------------//
-// isNoncopyable computation.
+// hasNoncopyableAnnotation computation.
 //----------------------------------------------------------------------------//
 
-llvm::Optional<bool> IsNoncopyableRequest::getCachedResult() const {
+llvm::Optional<bool> HasNoncopyableAnnotationRequest::getCachedResult() const {
   auto decl = std::get<0>(getStorage());
-  if (decl->LazySemanticInfo.isNoncopyableComputed)
-    return decl->LazySemanticInfo.isNoncopyable;
+  if (decl->LazySemanticInfo.isNoncopyableAnnotationComputed)
+    return decl->LazySemanticInfo.hasNoncopyableAnnotation;
 
   return llvm::None;
 }
 
-void IsNoncopyableRequest::cacheResult(bool value) const {
+void HasNoncopyableAnnotationRequest::cacheResult(bool value) const {
   auto decl = std::get<0>(getStorage());
-  decl->LazySemanticInfo.isNoncopyableComputed = true;
-  decl->LazySemanticInfo.isNoncopyable = value;
+  decl->LazySemanticInfo.isNoncopyableAnnotationComputed = true;
+  decl->LazySemanticInfo.hasNoncopyableAnnotation = value;
 
   if (!decl->getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
     // Add an attribute for printing