Merge pull request #69590 from kavon/check-if-copyable-inferred

[NoncopyableGenerics] Synthesize conditional conformances

Author: kavon

include/swift/AST/Decl.h

@@ -94,6 +94,7 @@ namespace swift {
   class NamedPattern;
   class EnumCaseDecl;
   class EnumElementDecl;
+  struct InverseMarking;
   class ParameterList;
   class ParameterTypeFlags;
   class Pattern;
@@ -3117,15 +3118,6 @@ class TypeDecl : public ValueDecl {
 private:
   ArrayRef<InheritedEntry> Inherited;
 
-  struct {
-    /// Whether the "hasNoncopyableAnnotation" bit has been computed yet.
-    unsigned isNoncopyableAnnotationComputed : 1;
-
-    /// Whether this declaration had a noncopyable inverse written somewhere.
-    unsigned hasNoncopyableAnnotation : 1;
-  } LazySemanticInfo = { };
-  friend class HasNoncopyableAnnotationRequest;
-
 protected:
   TypeDecl(DeclKind K, llvm::PointerUnion<DeclContext *, ASTContext *> context,
            Identifier name, SourceLoc NameLoc,
@@ -3153,9 +3145,13 @@ class TypeDecl : public ValueDecl {
 
   void setInherited(ArrayRef<InheritedEntry> i) { Inherited = i; }
 
-  /// Is this type _always_ noncopyable? Will answer 'false' if the type is
-  /// conditionally copyable.
-  bool isNoncopyable() const;
+  /// Is it possible for this type to lack a Copyable constraint?
+  /// If you need a more precise answer, ask this Decl's corresponding
+  /// Type if it `isNoncopyable` instead of using this.
+  bool canBeNoncopyable() const;
+
+  /// Determine how the ~Copyable was applied to this TypeDecl, if at all.
+  InverseMarking getNoncopyableMarking() const;
 
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_TypeDecl &&

include/swift/AST/DiagnosticsParse.def

@@ -429,8 +429,6 @@ ERROR(destructor_decl_outside_class_or_noncopyable,none,
       "deinitializers may only be declared within a class, actor, or noncopyable type", ())
 ERROR(destructor_decl_on_noncopyable_enum,none,
       "deinitializers are not yet supported on noncopyable enums", ())
-ERROR(destructor_decl_on_objc_enum,none,
-      "deinitializers cannot be declared on an @objc enum type", ())
 ERROR(expected_lbrace_destructor,PointsToFirstBadToken,
       "expected '{' for deinitializer", ())
 ERROR(destructor_has_name,PointsToFirstBadToken,

include/swift/AST/DiagnosticsSema.def

@@ -3170,7 +3170,7 @@ ERROR(recursive_superclass_constraint,none,
 ERROR(requires_same_concrete_type,none,
       "generic signature requires types %0 and %1 to be the same", (Type, Type))
 WARNING(redundant_conformance_constraint,none,
-        "redundant conformance constraint %0 : %1", (Type, ProtocolDecl *))
+        "redundant conformance constraint %0 : %1", (Type, Type))
 
 WARNING(missing_protocol_refinement, none,
         "protocol %0 should be declared to refine %1 due to a same-type constraint on 'Self'",
@@ -7533,22 +7533,34 @@ ERROR(accessor_macro_not_single_var, none,
 //------------------------------------------------------------------------------
 // MARK: Noncopyable Types Diagnostics
 //------------------------------------------------------------------------------
-
+ERROR(noncopyable_but_copyable, none,
+      "%kind0 required to be 'Copyable' but is marked with '~Copyable'",
+      (const ValueDecl *))
 ERROR(noncopyable_class, none,
       "classes cannot be noncopyable",
       ())
+ERROR(inverse_extension, none,
+      "cannot apply inverse %0 to extension",
+      (Type))
+ERROR(copyable_illegal_deinit, none,
+      "deinitializer cannot be declared in %kind0 that conforms to 'Copyable'",
+      (const ValueDecl *))
 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",
+NOTE(add_inverse,none,
+     "consider adding '~%1' to %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",
+NOTE(note_inverse_preventing_conformance,none,
+     "%0 has '~%1' constraint preventing implicit '%1' conformance",
      (Type, StringRef))
-NOTE(remove_inverse_on_nominal_for_conformance,none,
-     "consider removing '~%1' from %kind0 so it conforms to the '%1' protocol",
+NOTE(note_inverse_preventing_conformance_implicit,none,
+     "%kind0 has '~%1' constraint on a generic parameter, "
+     "making its '%1' conformance conditional",
+     (const ValueDecl *, StringRef))
+NOTE(note_inverse_preventing_conformance_explicit,none,
+     "%kind0 has '~%1' constraint preventing '%1' conformance",
      (const ValueDecl *, StringRef))
 NOTE(add_explicit_protocol_for_conformance,none,
      "consider making %kind0 explicitly conform to the '%1' protocol",

include/swift/AST/InverseMarking.h

@@ -0,0 +1,110 @@
+//===- InverseMarking.h - Utilities for tracking inverse types -*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_LIB_SEMA_INVERSEMARKING_H
+#define SWIFT_LIB_SEMA_INVERSEMARKING_H
+
+#include "swift/AST/KnownProtocols.h"
+#include "swift/Basic/SourceLoc.h"
+#include "swift/Basic/OptionalEnum.h"
+
+namespace swift {
+
+/// Describes the way an inverse and its corresponding positive contraint
+/// appears on a TypeDecl, i.e., the way it was marked.
+struct InverseMarking {
+  enum class Kind : uint8_t {
+    None,            // No inverse marking is present
+    Inferred,        // Inverse is inferred based on generic parameters.
+    Explicit,        // Inverse is explicitly present.
+
+    LAST = Explicit
+  };
+
+  // Describes what kind of mark was found, if any.
+  struct Mark {
+  private:
+    OptionalEnum<Kind> kind;
+    SourceLoc loc;
+  public:
+    // Creates an empty mark.
+    Mark() {};
+
+    // Creates a mark.
+    Mark(Kind k, SourceLoc l = SourceLoc())
+      : kind(k), loc(l) {};
+
+    // Is there an inferred or explicit marking?
+    bool isPresent() const {
+      return getKind() != Kind::None;
+    }
+    operator bool() { return isPresent(); }
+
+    Kind getKind() const {
+      return kind.getValueOr(Kind::None);
+    }
+
+    SourceLoc getLoc() const { return loc; }
+
+    void set(Kind k, SourceLoc l = SourceLoc()) {
+      assert(!kind.hasValue());
+      kind = k;
+      loc = l;
+    }
+
+    void setIfUnset(Kind k, SourceLoc l = SourceLoc()) {
+      if (kind.hasValue())
+        return;
+      set(k, l);
+    }
+
+    void setIfUnset(Mark other) {
+      if (kind.hasValue())
+        return;
+      kind = other.kind;
+      loc = other.loc;
+    }
+
+    Mark with(Kind k) {
+      kind = k;
+      return *this;
+    }
+  };
+
+private:
+  Mark inverse;
+  Mark positive;
+public:
+
+  // Creates an empty marking.
+  InverseMarking() {}
+
+  Mark &getInverse() { return inverse; }
+  Mark &getPositive() { return positive; }
+
+  // Merge the results of another marking into this one.
+  void merge(InverseMarking other) const {
+    other.inverse.setIfUnset(other.inverse);
+    other.positive.setIfUnset(other.positive);
+  }
+
+  static InverseMarking forInverse(Kind kind, SourceLoc loc = SourceLoc()) {
+    InverseMarking marking;
+    marking.inverse.set(kind, loc);
+    marking.positive.set(Kind::None);
+    return marking;
+  }
+};
+
+}
+
+#endif //SWIFT_LIB_SEMA_INVERSEMARKING_H

include/swift/AST/TypeCheckRequests.h

@@ -427,25 +427,23 @@ class IsFinalRequest :
   void cacheResult(bool value) const;
 };
 
-/// 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> {
+/// Determine the kind of noncopyable marking present for this declaration.
+class NoncopyableAnnotationRequest
+    : public SimpleRequest<NoncopyableAnnotationRequest,
+                           InverseMarking(TypeDecl *),
+                           RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
   // Evaluation.
-  bool evaluate(Evaluator &evaluator, TypeDecl *decl) const;
+  InverseMarking evaluate(Evaluator &evaluator, TypeDecl *decl) const;
 
 public:
-  // Separate caching.
+  // Caching.
   bool isCached() const { return true; }
-  llvm::Optional<bool> getCachedResult() const;
-  void cacheResult(bool value) const;
 };
 
 /// Determine whether the given declaration is escapable.

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -210,8 +210,9 @@ SWIFT_REQUEST(TypeChecker, IsDynamicRequest, bool(ValueDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsFinalRequest, bool(ValueDecl *), SeparatelyCached,
               NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, HasNoncopyableAnnotationRequest, bool(TypeDecl *), SeparatelyCached,
-              NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, NoncopyableAnnotationRequest,
+              InverseMarking(TypeDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsNoncopyableRequest,
               bool (CanType),
               Cached, NoLocationInfo)

lib/AST/ASTPrinter.cpp

@@ -3324,12 +3324,12 @@ static bool usesFeatureFlowSensitiveConcurrencyCaptures(Decl *decl) {
 static bool usesFeatureMoveOnly(Decl *decl) {
   if (auto *extension = dyn_cast<ExtensionDecl>(decl)) {
     if (auto *nominal = extension->getSelfNominalTypeDecl())
-      if (nominal->isNoncopyable())
+      if (nominal->canBeNoncopyable())
         return true;
   }
 
   if (auto typeDecl = dyn_cast<TypeDecl>(decl)) {
-    if (typeDecl->isNoncopyable())
+    if (typeDecl->canBeNoncopyable())
       return true;
   }
 

lib/AST/ASTVerifier.cpp

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

lib/AST/Decl.cpp

@@ -31,6 +31,7 @@
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/Initializer.h"
+#include "swift/AST/InverseMarking.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/MacroDefinition.h"
 #include "swift/AST/MacroDiscriminatorContext.h"
@@ -4876,12 +4877,16 @@ GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(
                                         llvm::None);
 }
 
-bool TypeDecl::isNoncopyable() const {
-  // NOTE: must answer true iff it is unconditionally noncopyable.
-  return evaluateOrDefault(getASTContext().evaluator,
-                           HasNoncopyableAnnotationRequest{
-                               const_cast<TypeDecl *>(this)},
-                           true); // default to true for safety
+InverseMarking TypeDecl::getNoncopyableMarking() const {
+  return evaluateOrDefault(
+      getASTContext().evaluator,
+      NoncopyableAnnotationRequest{const_cast<TypeDecl *>(this)},
+      InverseMarking::forInverse(InverseMarking::Kind::None)
+  );
+}
+
+bool TypeDecl::canBeNoncopyable() const {
+  return getNoncopyableMarking().getInverse().isPresent();
 }
 
 Type TypeDecl::getDeclaredInterfaceType() const {

lib/AST/Module.cpp

@@ -2019,7 +2019,7 @@ LookupConformanceInModuleRequest::evaluate(
         // We only need to do this until we are properly dealing with or
         // omitting Copyable conformances in modules/interfaces.
 
-        if (nominal->isNoncopyable())
+        if (nominal->canBeNoncopyable())
           return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
         else
           return ProtocolConformanceRef(protocol);

lib/AST/ProtocolConformance.cpp

@@ -1047,7 +1047,7 @@ void NominalTypeDecl::prepareConformanceTable() const {
       return;
 
     // No synthesized conformances for move-only nominals.
-    if (isNoncopyable()) {
+    if (canBeNoncopyable()) {
       // assumption is Sendable gets synthesized elsewhere.
       assert(!proto->isSpecificProtocol(KnownProtocolKind::Sendable));
       return;

lib/AST/RequirementMachine/Diagnostics.cpp

@@ -227,7 +227,7 @@ bool swift::rewriting::diagnoseRequirementErrors(
       case RequirementKind::Conformance:
         ctx.Diags.diagnose(loc, diag::redundant_conformance_constraint,
                            requirement.getFirstType(),
-                           requirement.getProtocolDecl());
+                           requirement.getSecondType());
         break;
       case RequirementKind::Superclass:
         ctx.Diags.diagnose(loc, diag::redundant_superclass_constraint,

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -823,8 +823,19 @@ void swift::rewriting::expandDefaultRequirements(ASTContext &ctx,
       return true;
     }
 
+    auto currentDefaults = defaults[subject];
+    auto inverseKind = inverse->getInverseKind();
+
+    // Check if this inverse is redundant.
+    if (!currentDefaults.contains(inverseKind)) {
+      errors.push_back(
+          RequirementError::forRedundantRequirement(req, structReq.loc));
+      return true;
+    }
+
     // Apply the inverse to the subject's defaults.
-    defaults[subject].remove(inverse->getInverseKind());
+    currentDefaults.remove(inverseKind);
+    defaults[subject] = currentDefaults;
 
     // Remove this inverse conformance requirement.
     return true;

lib/AST/SwiftNameTranslation.cpp

@@ -234,7 +234,7 @@ swift::cxx_translation::getDeclRepresentation(const ValueDecl *VD) {
     if (isa<ProtocolDecl>(typeDecl))
       return {Unsupported, UnrepresentableProtocol};
     // Swift's consume semantics are not yet supported in C++.
-    if (typeDecl->isNoncopyable())
+    if (typeDecl->canBeNoncopyable())
       return {Unsupported, UnrepresentableMoveOnly};
     if (typeDecl->isGeneric()) {
       if (isa<ClassDecl>(VD))

lib/AST/Type.cpp

@@ -161,7 +161,7 @@ bool TypeBase::isMarkerExistential() {
 /// that does not rely on conformances.
 static bool alwaysNoncopyable(Type ty) {
   if (auto *nominal = ty->getNominalOrBoundGenericNominal())
-    return nominal->isNoncopyable();
+    return nominal->canBeNoncopyable();
 
   if (auto *expansion = ty->getAs<PackExpansionType>()) {
     return alwaysNoncopyable(expansion->getPatternType());