[Sema] initial overhaul of isNoncopyable

kavon · kavon · commit d5f2d54ca76b · 2023-10-18T13:45:50.000-07:00
This implementation has the function execute a request to scan the
inheritance clause of non-protocol nominals for a `~Copyable`. For
protocols, we look in the requirement signature.

This isn't our final state, as the GenericEnvironment needs to be
queried in general to determine of a Type is noncopyable. So for now
checking for a `~Copyable` only makes sense for Decls.
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -3145,7 +3145,8 @@ class TypeDecl : public ValueDecl {
 
   void setInherited(ArrayRef<InheritedEntry> i) { Inherited = i; }
 
-  /// Is this declaration noncopyable?
+  /// Is this type _always_ noncopyable? Will answer 'false' if the type is
+  /// conditionally copyable.
   bool isNoncopyable() const;
 
   static bool classof(const Decl *D) {
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -2392,6 +2392,10 @@ ERROR(inferred_opaque_type,none,
 // Inverse Constraints
 ERROR(inverse_type_not_invertible,none,
       "type %0 is not invertible", (Type))
+ERROR(inverse_duplicate,none,
+      "duplicate inverse constraint", ())
+NOTE(inverse_duplicate_previous,none,
+      "previous inverse constraint here", ())
 
 // Extensions
 ERROR(non_nominal_extension,none,
@@ -7445,6 +7449,9 @@ ERROR(accessor_macro_not_single_var, none,
 // MARK: Noncopyable Types Diagnostics
 //------------------------------------------------------------------------------
 
+ERROR(noncopyable_class, none,
+      "classes cannot be noncopyable",
+      ())
 ERROR(noncopyable_within_copyable, none,
       "%kind0 cannot contain a noncopyable type without also being noncopyable",
       (const ValueDecl *))
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -3779,11 +3779,11 @@ class SynthesizeMainFunctionRequest
   bool isCached() const { return true; }
 };
 
-/// Retrieve the implicit conformance for the given nominal type to
-/// the Sendable protocol.
-class GetImplicitSendableRequest :
-    public SimpleRequest<GetImplicitSendableRequest,
-                         ProtocolConformance *(NominalTypeDecl *),
+/// Compute the implicit conformance for the given nominal type to
+/// an known protocol, if implicit conformances are permitted.
+class ImplicitKnownProtocolConformanceRequest :
+    public SimpleRequest<ImplicitKnownProtocolConformanceRequest,
+                         ProtocolConformance *(NominalTypeDecl *, KnownProtocolKind),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -3792,7 +3792,7 @@ class GetImplicitSendableRequest :
   friend SimpleRequest;
 
   ProtocolConformance *evaluate(
-      Evaluator &evaluator, NominalTypeDecl *nominal) const;
+      Evaluator &evaluator, NominalTypeDecl *nominal, KnownProtocolKind kp) const;
 
 public:
   // Caching
diff --git a/include/swift/AST/TypeCheckerTypeIDZone.def b/include/swift/AST/TypeCheckerTypeIDZone.def
@@ -426,8 +426,8 @@ SWIFT_REQUEST(TypeChecker, SimpleDidSetRequest,
               bool(AccessorDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, SynthesizeMainFunctionRequest,
               FuncDecl *(Decl *), Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, GetImplicitSendableRequest,
-              ProtocolConformance *(NominalTypeDecl *),
+SWIFT_REQUEST(TypeChecker, ImplicitKnownProtocolConformanceRequest,
+              ProtocolConformance *(NominalTypeDecl *, KnownProtocolKind),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, RenamedDeclRequest,
               ValueDecl *(const ValueDecl *, const AvailableAttr *),
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -928,6 +928,9 @@ class alignas(1 << TypeAlignInBits) TypeBase
     return getAnyBufferPointerElementType(Ignore);
   }
 
+  /// If this type is a known protocol, return its kind.
+  llvm::Optional<KnownProtocolKind> getKnownProtocol();
+
   /// Determine whether the given type is "specialized", meaning that
   /// it involves generic types for which generic arguments have been provided.
   /// For example, the types Vector<Int> and Vector<Int>.Element are both
@@ -7333,6 +7336,10 @@ inline GenericTypeDecl *TypeBase::getAnyGeneric() {
   return getCanonicalType().getAnyGeneric();
 }
 
+//inline TypeDecl *TypeBase::getAnyTypeDecl() {
+//  return getCanonicalType().getAnyTypeDecl();
+//}
+
 inline bool TypeBase::isBuiltinIntegerType(unsigned n) {
   if (auto intTy = dyn_cast<BuiltinIntegerType>(getCanonicalType()))
     return intTy->getWidth().isFixedWidth()
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -4838,7 +4838,7 @@ GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(
 bool TypeDecl::isNoncopyable() const {
   return evaluateOrDefault(getASTContext().evaluator,
                            IsNoncopyableRequest{const_cast<TypeDecl *>(this)},
-                           getAttrs().hasAttribute<MoveOnlyAttr>());
+                           true); // default to true for safety
 }
 
 Type TypeDecl::getDeclaredInterfaceType() const {
diff --git a/lib/AST/Module.cpp b/lib/AST/Module.cpp
@@ -1681,12 +1681,12 @@ ProtocolConformanceRef ModuleDecl::lookupConformance(Type type,
                                                      ProtocolDecl *protocol,
                                                      bool allowMissing) {
   // If we are recursively checking for implicit conformance of a nominal
-  // type to Sendable, fail without evaluating this request. This
+  // type to a KnownProtocol, fail without evaluating this request. This
   // squashes cycles.
   LookupConformanceInModuleRequest request{{this, type, protocol}};
-  if (protocol->isSpecificProtocol(KnownProtocolKind::Sendable)) {
+  if (auto kp = protocol->getKnownProtocolKind()) {
     if (auto nominal = type->getAnyNominal()) {
-      GetImplicitSendableRequest icvRequest{nominal};
+      ImplicitKnownProtocolConformanceRequest icvRequest{nominal, *kp};
       if (getASTContext().evaluator.hasActiveRequest(icvRequest) ||
           getASTContext().evaluator.hasActiveRequest(request))
         return ProtocolConformanceRef::forInvalid();
@@ -1972,7 +1972,8 @@ LookupConformanceInModuleRequest::evaluate(
   if (!nominal->lookupConformance(protocol, conformances)) {
     if (protocol->isSpecificProtocol(KnownProtocolKind::Sendable)) {
       // Try to infer Sendable conformance.
-      GetImplicitSendableRequest cvRequest{nominal};
+      ImplicitKnownProtocolConformanceRequest
+          cvRequest{nominal, KnownProtocolKind::Sendable};
       if (auto conformance = evaluateOrDefault(
               ctx.evaluator, cvRequest, nullptr)) {
         conformances.clear();
@@ -2001,16 +2002,15 @@ LookupConformanceInModuleRequest::evaluate(
         return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
       }
     } else if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable)) {
-      // Only move-only nominals are not Copyable
-      if (nominal->isNoncopyable()) {
-        return ProtocolConformanceRef::forInvalid();
+      // Try to infer Copyable conformance.
+      ImplicitKnownProtocolConformanceRequest
+          cvRequest{nominal, KnownProtocolKind::Copyable};
+      if (auto conformance = evaluateOrDefault(
+          ctx.evaluator, cvRequest, nullptr)) {
+        conformances.clear();
+        conformances.push_back(conformance);
       } else {
-        // Specifically do not create a concrete conformance to Copyable. At
-        // this stage, we don't even want Copyable to appear in swiftinterface
-        // files, which will happen for a marker protocol that's registered
-        // in a nominal type's conformance table. We can reconsider this
-        // decision later once there's a clearer picture of noncopyable generics
-        return ProtocolConformanceRef(protocol);
+        return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
       }
     } else {
       // Was unable to infer the missing conformance.
diff --git a/lib/AST/ProtocolConformance.cpp b/lib/AST/ProtocolConformance.cpp
@@ -1211,6 +1211,9 @@ static SmallVector<ProtocolConformance *, 2> findSynthesizedConformances(
   // Concrete types may synthesize some conformances
   if (!isa<ProtocolDecl>(nominal)) {
     trySynthesize(KnownProtocolKind::Sendable);
+
+    if (nominal->getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics))
+      trySynthesize(KnownProtocolKind::Copyable);
   }
 
   /// Distributed actors can synthesize Encodable/Decodable, so look for those
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -158,6 +158,7 @@ bool TypeBase::isMarkerExistential() {
 }
 
 bool TypeBase::isNoncopyable() {
+  // FIXME: we need to support the full spectrum of TypeDecls here.
   if (auto *nom = getAnyNominal())
     return nom->isNoncopyable();
 
@@ -471,6 +472,14 @@ bool TypeBase::isDistributedActor() {
   return false;
 }
 
+llvm::Optional<KnownProtocolKind> TypeBase::getKnownProtocol() {
+  if (auto protoTy = this->castTo<ProtocolType>())
+    if (auto protoDecl = protoTy->getDecl())
+      return protoDecl->getKnownProtocolKind();
+
+  return llvm::None;
+}
+
 bool TypeBase::isSpecialized() {
   Type t = getCanonicalType();
 
diff --git a/lib/Sema/CMakeLists.txt b/lib/Sema/CMakeLists.txt
@@ -59,6 +59,7 @@ add_swift_host_library(swiftSema STATIC
   TypeCheckExpr.cpp
   TypeCheckExprObjC.cpp
   TypeCheckGeneric.cpp
+  TypeCheckInvertible.cpp
   TypeCheckMacros.cpp
   TypeCheckNameLookup.cpp
   TypeCheckPattern.cpp
diff --git a/lib/Sema/TypeCheckConcurrency.cpp b/lib/Sema/TypeCheckConcurrency.cpp
@@ -5125,8 +5125,8 @@ static void addUnavailableAttrs(ExtensionDecl *ext, NominalTypeDecl *nominal) {
   ext->getAttrs().add(attr);
 }
 
-ProtocolConformance *GetImplicitSendableRequest::evaluate(
-    Evaluator &evaluator, NominalTypeDecl *nominal) const {
+ProtocolConformance *swift::deriveImplicitSendableConformance(
+    Evaluator &evaluator, NominalTypeDecl *nominal) {
   // Protocols never get implicit Sendable conformances.
   if (isa<ProtocolDecl>(nominal))
     return nullptr;
diff --git a/lib/Sema/TypeCheckConcurrency.h b/lib/Sema/TypeCheckConcurrency.h
@@ -506,6 +506,12 @@ isDispatchQueueOperationName(StringRef name);
 bool checkSendableConformance(
     ProtocolConformance *conformance, SendableCheck check);
 
+/// Derive an implicit conformance for the given nominal type to
+/// the Sendable protocol. You want to be using
+/// `ImplicitKnownProtocolConformanceRequest` instead of this.
+ProtocolConformance *deriveImplicitSendableConformance(Evaluator &evaluator,
+                                                       NominalTypeDecl *nominal);
+
 /// Check whether we are in an actor's initializer or deinitializer.
 /// \returns nullptr iff we are not in such a declaration. Otherwise,
 ///          returns a pointer to the declaration.
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -21,6 +21,7 @@
 #include "TypeCheckAccess.h"
 #include "TypeCheckAvailability.h"
 #include "TypeCheckConcurrency.h"
+#include "TypeCheckInvertible.h"
 #include "TypeCheckObjC.h"
 #include "TypeCheckType.h"
 #include "TypeChecker.h"
@@ -914,17 +915,80 @@ IsFinalRequest::evaluate(Evaluator &evaluator, ValueDecl *decl) const {
 }
 
 bool IsNoncopyableRequest::evaluate(Evaluator &evaluator, TypeDecl *decl) const {
-  // TODO: isNoncopyable and isNoncopyable and other checks are all spread out
-  // and need to be merged together.
+  assert(isa<NominalTypeDecl>(decl) && "todo: handle non-nominals");
+
+  // The legacy check.
   if (isa<ClassDecl>(decl) || isa<StructDecl>(decl) || isa<EnumDecl>(decl)) {
-      if (decl->getAttrs().hasAttribute<MoveOnlyAttr>()) {
-        if (!decl->getASTContext().supportsMoveOnlyTypes())
-            decl->diagnose(diag::moveOnly_requires_lexical_lifetimes);
+    if (decl->getAttrs().hasAttribute<MoveOnlyAttr>()) {
+      if (!decl->getASTContext().supportsMoveOnlyTypes())
+          decl->diagnose(diag::moveOnly_requires_lexical_lifetimes);
 
-        return true;
+      return true;
+    }
+  }
+
+  auto &ctx = decl->getASTContext();
+  if (!ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics))
+    return false;
+
+  // For protocols, inspect its requirement signature for a Copyable requirement
+  if (auto *proto = dyn_cast<ProtocolDecl>(decl)) {
+    auto reqs = proto->getRequirementSignature().getRequirements();
+    for (auto &req : reqs) {
+      if (req.getKind() == RequirementKind::Conformance)
+        if (auto kp = req.getSecondType()->getKnownProtocol())
+          if (*kp == KnownProtocolKind::Copyable)
+            return false; // found a Copyable requirement
+    }
+    return true;
+  }
+
+  // For all other nominals, we can simply check the inheritance clause.
+
+  // The set of defaults all types start with.
+  auto defaults = getInvertibleProtocols();
+  std::map<KnownProtocolKind, SourceLoc> lastInverse;
+
+  // Does correctness checking after inspecting the inheritance clause.
+  // TODO: we can probably move this to `checkInheritanceClause` instead.
+  auto foundInverse = [&](SourceLoc loc, KnownProtocolKind kind) {
+    // do we still have this default?
+    if (defaults.contains(kind)) {
+      defaults.remove(kind);
+      lastInverse.insert({kind, loc});
+
+      // Classes are always copyable.
+      if (isa<ClassDecl>(decl) && kind == KnownProtocolKind::Copyable) {
+        ctx.Diags.diagnose(loc, diag::noncopyable_class);
+        return;
       }
+
+      return;
+    }
+
+    // diagnose duplicate inverses
+    ctx.Diags.diagnose(loc, diag::inverse_duplicate);
+    ctx.Diags.diagnose(lastInverse[kind], diag::inverse_duplicate_previous);
+  };
+
+  // Check the inheritance clause for inverses.
+  auto inherited = decl->getInherited();
+  for (size_t i = 0; i < inherited.size(); i++) {
+    auto *repr = inherited.getTypeRepr(i);
+
+    if (!dyn_cast_or_null<InverseTypeRepr>(repr)) {
+      continue;
+    }
+
+    auto type = inherited.getResolvedType(i, TypeResolutionStage::Structural);
+    auto kp = type->getKnownProtocol();
+    if (!kp)
+      continue; // diagnosed elsewhere.
+
+    foundInverse(repr->getLoc(), *kp);
   }
-  return false;
+
+  return !defaults.contains(KnownProtocolKind::Copyable);
 }
 
 bool IsEscapableRequest::evaluate(Evaluator &evaluator, ValueDecl *decl) const {
@@ -3068,3 +3132,20 @@ ExtendedTypeRequest::evaluate(Evaluator &eval, ExtensionDecl *ext) const {
 
   return extendedType;
 }
+
+//----------------------------------------------------------------------------//
+// ImplicitKnownProtocolConformanceRequest
+//----------------------------------------------------------------------------//
+ProtocolConformance *
+ImplicitKnownProtocolConformanceRequest::evaluate(Evaluator &evaluator,
+                                                  NominalTypeDecl *nominal,
+                                                  KnownProtocolKind kp) const {
+  switch (kp) {
+  case KnownProtocolKind::Sendable:
+    return deriveImplicitSendableConformance(evaluator, nominal);
+  case KnownProtocolKind::Copyable:
+    return deriveConformanceForInvertible(evaluator, nominal, kp);
+  default:
+    llvm_unreachable("non-implicitly derived KnownProtocol");
+  }
+}
diff --git a/lib/Sema/TypeCheckDeclPrimary.cpp b/lib/Sema/TypeCheckDeclPrimary.cpp
@@ -2937,6 +2937,9 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
   }
 
   static void diagnoseIncompatibleProtocolsForMoveOnlyType(Decl *decl) {
+    if (decl->getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics))
+      return; // taken care of elsewhere.
+
     if (auto *nomDecl = dyn_cast<NominalTypeDecl>(decl)) {
       if (!nomDecl->isNoncopyable())
         return;
diff --git a/lib/Sema/TypeCheckInvertible.cpp b/lib/Sema/TypeCheckInvertible.cpp
diff --git a/lib/Sema/TypeCheckInvertible.h b/lib/Sema/TypeCheckInvertible.h
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
diff --git a/test/Generics/inverse_copyable_requirement.swift b/test/Generics/inverse_copyable_requirement.swift
diff --git a/test/Generics/inverse_protocols.swift b/test/Generics/inverse_protocols.swift
diff --git a/test/Generics/inverse_protocols_errors.swift b/test/Generics/inverse_protocols_errors.swift
diff --git a/test/Generics/inverse_signatures.swift b/test/Generics/inverse_signatures.swift

Original file line number	Diff line number	Diff line change
`@@ -4838,7 +4838,7 @@ GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(`
`4838`	`4838`	`bool TypeDecl::isNoncopyable() const {`
`4839`	`4839`	`return evaluateOrDefault(getASTContext().evaluator,`
`4840`	`4840`	`IsNoncopyableRequest{const_cast<TypeDecl *>(this)},`
`4841`		`- getAttrs().hasAttribute<MoveOnlyAttr>());`
	`4841`	`+ true); // default to true for safety`
`4842`	`4842`	`}`
`4843`	`4843`
`4844`	`4844`	`Type TypeDecl::getDeclaredInterfaceType() const {`
Original file line number	Diff line number	Diff line change
`@@ -1211,6 +1211,9 @@ static SmallVector<ProtocolConformance *, 2> findSynthesizedConformances(`
`1211`	`1211`	`// Concrete types may synthesize some conformances`
`1212`	`1212`	`if (!isa<ProtocolDecl>(nominal)) {`
`1213`	`1213`	`trySynthesize(KnownProtocolKind::Sendable);`
	`1214`	`+`
	`1215`	`+ if (nominal->getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics))`
	`1216`	`+ trySynthesize(KnownProtocolKind::Copyable);`
`1214`	`1217`	`}`
`1215`	`1218`
`1216`	`1219`	`/// Distributed actors can synthesize Encodable/Decodable, so look for those`