[Sema] overhaul NoncopyableAnnotationRequest

We need to know whether the noncopyable annotation is inferred from its
generic parameters. This allows us to synthesize the conditional
conformance.

Author: kavon

Diff for: 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,16 +3118,6 @@ class TypeDecl : public ValueDecl {
 private:
   ArrayRef<InheritedEntry> Inherited;
 
-  struct {
-    /// Whether the "noncopyableAnnotationKind" field has been computed yet.
-    unsigned isNoncopyableAnnotationComputed : 1;
-
-    unsigned noncopyableAnnotationKind : 2;
-    static_assert((unsigned)InverseMarkingKind::LAST < 4);
-
-  } LazySemanticInfo = { };
-  friend class NoncopyableAnnotationRequest;
-
 protected:
   TypeDecl(DeclKind K, llvm::PointerUnion<DeclContext *, ASTContext *> context,
            Identifier name, SourceLoc NameLoc,
@@ -3157,12 +3148,10 @@ class TypeDecl : public ValueDecl {
   /// 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 {
-    return getNoncopyableMarking() != InverseMarkingKind::None;
-  }
+  bool canBeNoncopyable() const;
 
   /// Determine how the ~Copyable was applied to this TypeDecl, if at all.
-  InverseMarkingKind getNoncopyableMarking() const;
+  InverseMarking getNoncopyableMarking() const;
 
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_TypeDecl &&

Diff for: include/swift/AST/DiagnosticsSema.def

@@ -7533,22 +7533,28 @@ 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(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",

Diff for: 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

Diff for: include/swift/AST/KnownProtocols.h

@@ -73,15 +73,6 @@ llvm::Optional<InvertibleProtocolKind>
 /// Returns the KnownProtocolKind corresponding to an InvertibleProtocolKind.
 KnownProtocolKind getKnownProtocolKind(InvertibleProtocolKind ip);
 
-/// Describes the way an inverse was applied to a TypeDecl.
-enum class InverseMarkingKind: uint8_t {
-  None,            // No inverse marking is present
-  Inferred,        // Inverse is inferred based on generic parameters.
-  Explicit,        // Inverse is explicitly present.
-
-  LAST = Explicit
-};
-
 } // end namespace swift
 
 #endif

Diff for: include/swift/AST/TypeCheckRequests.h

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

Diff for: include/swift/AST/TypeCheckerTypeIDZone.def

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

Diff for: 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,11 +4877,16 @@ GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(
                                         llvm::None);
 }
 
-InverseMarkingKind TypeDecl::getNoncopyableMarking() const {
-  return evaluateOrDefault(getASTContext().evaluator,
-                           NoncopyableAnnotationRequest{
-                               const_cast<TypeDecl *>(this)},
-                           InverseMarkingKind::Explicit);
+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 {

Diff for: lib/AST/TypeCheckRequests.cpp

@@ -313,35 +313,6 @@ void IsFinalRequest::cacheResult(bool value) const {
     decl->getAttrs().add(new (decl->getASTContext()) FinalAttr(/*Implicit=*/true));
 }
 
-//----------------------------------------------------------------------------//
-// NoncopyableAnnotationRequest computation.
-//----------------------------------------------------------------------------//
-
-llvm::Optional<InverseMarkingKind>
-NoncopyableAnnotationRequest::getCachedResult() const {
-  auto decl = std::get<0>(getStorage());
-  if (decl->LazySemanticInfo.isNoncopyableAnnotationComputed)
-    return static_cast<InverseMarkingKind>(
-              decl->LazySemanticInfo.noncopyableAnnotationKind);
-
-  return llvm::None;
-}
-
-void NoncopyableAnnotationRequest::cacheResult(InverseMarkingKind value) const {
-  auto decl = std::get<0>(getStorage());
-  decl->LazySemanticInfo.isNoncopyableAnnotationComputed = true;
-  decl->LazySemanticInfo.noncopyableAnnotationKind =
-      static_cast<unsigned>(value);
-
-  if (!decl->getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
-    // Add an attribute for printing
-    if (value == InverseMarkingKind::Explicit
-        && !decl->getAttrs().hasAttribute<MoveOnlyAttr>())
-      decl->getAttrs().add(new(decl->getASTContext())
-                               MoveOnlyAttr(/*Implicit=*/true));
-  }
-}
-
 //----------------------------------------------------------------------------//
 // isEscapable computation.
 //----------------------------------------------------------------------------//