Merge pull request #70277 from kavon/inverse-escapable

[NCGenerics] add `~Escapable`

Author: kavon

include/swift/AST/Decl.h

@@ -2680,19 +2680,12 @@ class ValueDecl : public Decl {
     /// Whether this declaration produces an implicitly unwrapped
     /// optional result.
     unsigned isIUO : 1;
-
-    /// Whether the "isEscapable" bit has been computed yet.
-    unsigned isEscapable : 1;
-
-    /// Whether this declaration is escapable.
-    unsigned isEscapableComputed : 1;
   } LazySemanticInfo = { };
 
   friend class DynamicallyReplacedDeclRequest;
   friend class OverriddenDeclsRequest;
   friend class IsObjCRequest;
   friend class IsFinalRequest;
-  friend class IsEscapableRequest;
   friend class IsDynamicRequest;
   friend class IsImplicitlyUnwrappedOptionalRequest;
   friend class InterfaceTypeRequest;
@@ -2980,9 +2973,6 @@ class ValueDecl : public Decl {
   /// Is this declaration 'final'?
   bool isFinal() const;
 
-  /// Is this declaration escapable?
-  bool isEscapable() const;
-
   /// Is this declaration marked with 'dynamic'?
   bool isDynamic() const;
 
@@ -3190,8 +3180,12 @@ class TypeDecl : public ValueDecl {
   /// 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;
+  /// Is this declaration escapable?
+  bool isEscapable() const;
+
+  /// Determine how the given invertible protocol was written on this TypeDecl,
+  /// if at all.
+  InverseMarking getMarking(InvertibleProtocolKind ip) const;
 
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_TypeDecl &&

include/swift/AST/DiagnosticsSema.def

@@ -7555,27 +7555,27 @@ 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_generic_but_copyable, none,
+ERROR(inverse_but_also_conforms, none,
+      "%kind0 required to be '%1' but is marked with '~%1'",
+      (const ValueDecl *, StringRef))
+ERROR(inverse_generic_but_also_conforms, none,
       "%0 required to be '%1' but is marked with '~%1'",
       (Type, StringRef))
 WARNING(redundant_inverse_constraint,none,
         "redundant constraint %0 : '~%1'", (Type, StringRef))
-ERROR(noncopyable_class, none,
-      "classes cannot be noncopyable",
-      ())
+ERROR(inverse_on_class, none,
+      "classes cannot be '~%0'",
+      (StringRef))
 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,
+ERROR(inverse_type_member_in_conforming_type,none,
       "%select{stored property %2|associated value %2}1 of "
-      "'Copyable'-conforming %kind3 has noncopyable type %0",
-      (Type, bool, DeclName, const ValueDecl *))
+      "'%4'-conforming %kind3 has non-%4 type %0",
+      (Type, bool, DeclName, const ValueDecl *, StringRef))
 NOTE(add_inverse,none,
      "consider adding '~%1' to %kind0",
      (const ValueDecl *, StringRef))
@@ -7592,6 +7592,9 @@ NOTE(note_inverse_preventing_conformance_explicit,none,
 NOTE(add_explicit_protocol_for_conformance,none,
      "consider making %kind0 explicitly conform to the '%1' protocol",
      (const ValueDecl *, StringRef))
+ERROR(escapable_requires_feature_flag,none,
+      "type '~Escapable' requires -enable-experimental-feature NonEscapableTypes",
+      ())
 
 // -- older ones below --
 

include/swift/AST/InverseMarking.h

@@ -19,7 +19,7 @@
 
 namespace swift {
 
-class NoncopyableAnnotationRequest;
+class InvertibleAnnotationRequest;
 
 /// Describes the way an inverse and its corresponding positive contraint
 /// appears on a TypeDecl, i.e., the way it was marked.
@@ -87,7 +87,7 @@ struct InverseMarking {
   Mark positive;
 
   // This friend initializes the marks.
-  friend NoncopyableAnnotationRequest;
+  friend InvertibleAnnotationRequest;
 public:
 
   // Creates an empty marking.

include/swift/AST/KnownProtocols.def

@@ -137,6 +137,7 @@ PROTOCOL(AsyncIteratorProtocol)
 PROTOCOL(FloatingPoint)
 
 INVERTIBLE_PROTOCOL_WITH_NAME(Copyable, "Copyable")
+INVERTIBLE_PROTOCOL_WITH_NAME(Escapable, "Escapable")
 PROTOCOL_(BitwiseCopyable)
 
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByArrayLiteral, "Array", false)

include/swift/AST/KnownProtocols.h

@@ -73,6 +73,9 @@ llvm::Optional<InvertibleProtocolKind>
 /// Returns the KnownProtocolKind corresponding to an InvertibleProtocolKind.
 KnownProtocolKind getKnownProtocolKind(InvertibleProtocolKind ip);
 
+void simple_display(llvm::raw_ostream &out,
+                    const InvertibleProtocolKind &value);
+
 } // end namespace swift
 
 #endif

include/swift/AST/TypeCheckRequests.h

@@ -428,10 +428,12 @@ class IsFinalRequest :
   void cacheResult(bool value) const;
 };
 
-/// Determine the kind of noncopyable marking present for this declaration.
-class NoncopyableAnnotationRequest
-    : public SimpleRequest<NoncopyableAnnotationRequest,
-                           InverseMarking(TypeDecl *),
+/// Determine the kind of invertible protocol markings for this declaration,
+/// for example, if a conformance to IP or ~IP was written on it in the
+/// inheritance clause and/or where clause.
+class InvertibleAnnotationRequest
+    : public SimpleRequest<InvertibleAnnotationRequest,
+                           InverseMarking(TypeDecl *, InvertibleProtocolKind),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -440,31 +442,30 @@ class NoncopyableAnnotationRequest
   friend SimpleRequest;
 
   // Evaluation.
-  InverseMarking evaluate(Evaluator &evaluator, TypeDecl *decl) const;
+  InverseMarking evaluate(Evaluator &evaluator,
+                          TypeDecl *decl, InvertibleProtocolKind ip) const;
 
 public:
   // Caching.
   bool isCached() const { return true; }
 };
 
-/// Determine whether the given declaration is escapable.
+/// Determine whether the given type is Escapable.
 class IsEscapableRequest
-    : public SimpleRequest<IsEscapableRequest, bool(ValueDecl *),
-                           RequestFlags::SeparatelyCached> {
+    : public SimpleRequest<IsEscapableRequest, bool(CanType),
+                           RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
   // Evaluation.
-  bool evaluate(Evaluator &evaluator, ValueDecl *decl) const;
+  bool evaluate(Evaluator &evaluator, CanType) const;
 
 public:
-  // Separate caching.
+  // 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

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -210,14 +210,15 @@ SWIFT_REQUEST(TypeChecker, IsDynamicRequest, bool(ValueDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsFinalRequest, bool(ValueDecl *), SeparatelyCached,
               NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, NoncopyableAnnotationRequest,
-              InverseMarking(TypeDecl *),
+SWIFT_REQUEST(TypeChecker, InvertibleAnnotationRequest,
+              InverseMarking(TypeDecl *, InvertibleProtocolKind),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsNoncopyableRequest,
               bool (CanType),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, IsEscapableRequest, bool(ValueDecl *),
-              SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, IsEscapableRequest,
+              bool (CanType),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsGetterMutatingRequest, bool(AbstractStorageDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsImplicitlyUnwrappedOptionalRequest,

include/swift/AST/Types.h

@@ -640,11 +640,13 @@ class alignas(1 << TypeAlignInBits) TypeBase
 
   bool isPlaceholder();
 
-  /// DEPRECIATED: Returns true if this is a noncopyable type.
-  bool isNoncopyable();
+  /// Returns true if this type lacks conformance to Copyable in the context,
+  /// if provided.
+  bool isNoncopyable(const DeclContext *dc = nullptr);
 
-  /// Returns true if this type lacks conformance to Copyable in the context.
-  bool isNoncopyable(const DeclContext *dc);
+  /// Returns true if this type conforms to Escapable in the context,
+  /// if provided.
+  bool isEscapable(const DeclContext *dc = nullptr);
 
   /// Does the type have outer parenthesis?
   bool hasParenSugar() const { return getKind() == TypeKind::Paren; }

lib/AST/ASTContext.cpp

@@ -122,6 +122,11 @@ KnownProtocolKind swift::getKnownProtocolKind(InvertibleProtocolKind ip) {
   }
 }
 
+void swift::simple_display(llvm::raw_ostream &out,
+                           const InvertibleProtocolKind &value) {
+  out << getProtocolName(getKnownProtocolKind(value));
+}
+
 namespace {
 enum class SearchPathKind : uint8_t {
   Import = 1 << 0,
@@ -6244,6 +6249,9 @@ BuiltinTupleDecl *ASTContext::getBuiltinTupleDecl() {
   if (auto *proto = getProtocol(KnownProtocolKind::Copyable))
     buildFakeExtension(proto);
 
+  if (auto *proto = getProtocol(KnownProtocolKind::Escapable))
+    buildFakeExtension(proto);
+
   return result;
 }
 

lib/AST/ASTDumper.cpp

@@ -4348,6 +4348,9 @@ namespace {
         case InvertibleProtocolKind::Copyable:
           printFlag("inverse_copyable");
           break;
+        case InvertibleProtocolKind::Escapable:
+          printFlag("inverse_escapable");
+          break;
         }
       }