Merge pull request swiftlang#69164 from atrick/nonescapable_attr

atrick · web-flow · commit 681a2b72e0f3 · 2023-10-17T21:39:10.000-07:00
Add a temporary @_nonEscapable and @_hasUnsafeNonEscapableResult attribute
diff --git a/SwiftCompilerSources/Sources/SIL/Function.swift b/SwiftCompilerSources/Sources/SIL/Function.swift
@@ -116,6 +116,10 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
     }
   }
 
+  public var hasUnsafeNonEscapableResult: Bool {
+    return bridged.hasUnsafeNonEscapableResult()
+  }
+
   /// True if the callee function is annotated with @_semantics("programtermination_point").
   /// This means that the function terminates the program.
   public var isProgramTerminationPoint: Bool { hasSemanticsAttribute("programtermination_point") }
diff --git a/SwiftCompilerSources/Sources/SIL/Type.swift b/SwiftCompilerSources/Sources/SIL/Type.swift
@@ -58,6 +58,7 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
   public var isMetatype: Bool { bridged.isMetatype() }
   public var isNoEscapeFunction: Bool { bridged.isNoEscapeFunction() }
   public var isAsyncFunction: Bool { bridged.isAsyncFunction() }
+  public var isEscapable: Bool { bridged.isEscapable() }
 
   public var canBeClass: BridgedType.TraitResult { bridged.canBeClass() }
 
diff --git a/docs/ReferenceGuides/UnderscoredAttributes.md b/docs/ReferenceGuides/UnderscoredAttributes.md
@@ -625,6 +625,15 @@ This is the default behavior, unless the type annotated is an aggregate that
 consists entirely of `@_eagerMove` or trivial values, in which case the
 attribute overrides the inferred type-level annotation.
 
+## `@_nonEscapable`
+
+Indicates that a type is non-escapable. All instances of this type are
+non-escaping values. A non-escaping value's lifetime must be confined
+to another "parent" lifetime.
+
+This is temporary until ~Escapable syntax is supported, which will
+also work as a generic type constraint.
+
 ## `@_marker`
 
 Indicates that a protocol is a marker protocol. Marker protocols represent some
diff --git a/include/swift/AST/Attr.def b/include/swift/AST/Attr.def
@@ -423,6 +423,12 @@ DECL_ATTR(_rawLayout, RawLayout,
 DECL_ATTR(_extern, Extern,
   OnFunc | ABIStableToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove,
   147)
+SIMPLE_DECL_ATTR(_nonEscapable, NonEscapable,
+  OnNominalType | UserInaccessible | ABIBreakingToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
+  148)
+SIMPLE_DECL_ATTR(_unsafeNonEscapableResult, UnsafeNonEscapableResult,
+  OnAbstractFunction | OnSubscript | UserInaccessible | ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIBreakingToRemove,
+  149)
 CONTEXTUAL_SIMPLE_DECL_ATTR(final, Final,
   OnClass | OnFunc | OnAccessor | OnVar | OnSubscript | DeclModifier | ABIBreakingToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove,
   2)
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -2611,13 +2611,20 @@ class ValueDecl : public Decl {
 
     /// Whether this declaration can not be copied and thus is move only.
     unsigned isMoveOnly : 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 IsMoveOnlyRequest;
+  friend class IsEscapableRequest;
   friend class IsDynamicRequest;
   friend class IsImplicitlyUnwrappedOptionalRequest;
   friend class InterfaceTypeRequest;
@@ -2923,6 +2930,9 @@ class ValueDecl : public Decl {
   /// Is this declaration 'moveOnly'?
   bool isMoveOnly() const;
 
+  /// Is this declaration escapable?
+  bool isEscapable() const;
+
   /// Is this declaration marked with 'dynamic'?
   bool isDynamic() const;
 
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -7539,6 +7539,9 @@ ERROR(noncopyable_cannot_have_read_set_accessor,none,
       "noncopyable %select{variable|subscript}0 cannot provide a read and set accessor",
       (unsigned))
 
+ERROR(nonescapable_types_attr_disabled,none,
+      "attribute requires '-enable-experimental-feature NonEscapableTypes'", ())
+
 //------------------------------------------------------------------------------
 // MARK: Init accessors
 //------------------------------------------------------------------------------
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -427,6 +427,27 @@ class IsMoveOnlyRequest
   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 declaration is 'dynamic''.
 class IsDynamicRequest :
     public SimpleRequest<IsDynamicRequest,
diff --git a/include/swift/AST/TypeCheckerTypeIDZone.def b/include/swift/AST/TypeCheckerTypeIDZone.def
@@ -212,6 +212,8 @@ SWIFT_REQUEST(TypeChecker, IsFinalRequest, bool(ValueDecl *), SeparatelyCached,
               NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsMoveOnlyRequest, bool(ValueDecl *), SeparatelyCached,
               NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, IsEscapableRequest, bool(ValueDecl *),
+              SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsGetterMutatingRequest, bool(AbstractStorageDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsImplicitlyUnwrappedOptionalRequest,
diff --git a/include/swift/Basic/Features.def b/include/swift/Basic/Features.def
@@ -252,6 +252,10 @@ EXPERIMENTAL_FEATURE(TypedThrows, true)
 /// Allow destructuring stored `let` bindings in structs.
 EXPERIMENTAL_FEATURE(StructLetDestructuring, true)
 
+/// Enable non-escapable type attributes and function attributes that support
+/// lifetime-dependent results.
+EXPERIMENTAL_FEATURE(NonEscapableTypes, false)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE
diff --git a/include/swift/SIL/SILBridging.h b/include/swift/SIL/SILBridging.h
@@ -110,6 +110,7 @@ struct BridgedType {
   BRIDGED_INLINE bool isAsyncFunction() const;
   BRIDGED_INLINE TraitResult canBeClass() const;
   BRIDGED_INLINE bool isMoveOnly() const;
+  BRIDGED_INLINE bool isEscapable() const;
   BRIDGED_INLINE bool isOrContainsObjectiveCClass() const;
   BRIDGED_INLINE bool isBuiltinInteger() const;
   BRIDGED_INLINE bool isBuiltinFloat() const;
@@ -328,6 +329,7 @@ struct BridgedFunction {
   BRIDGED_INLINE bool isDestructor() const;
   BRIDGED_INLINE bool isGenericFunction() const;
   BRIDGED_INLINE bool hasSemanticsAttr(BridgedStringRef attrName) const;
+  BRIDGED_INLINE bool hasUnsafeNonEscapableResult() const;
   BRIDGED_INLINE EffectsKind getEffectAttribute() const;
   BRIDGED_INLINE PerformanceConstraints getPerformanceConstraints() const;
   BRIDGED_INLINE InlineStrategy getInlineStrategy() const;
diff --git a/include/swift/SIL/SILBridgingImpl.h b/include/swift/SIL/SILBridgingImpl.h
@@ -140,6 +140,10 @@ bool BridgedType::isMoveOnly() const {
   return get().isMoveOnly();
 }
 
+bool BridgedType::isEscapable() const {
+  return get().isEscapable();
+}
+
 bool BridgedType::isOrContainsObjectiveCClass() const {
   return get().isOrContainsObjectiveCClass();
 }
@@ -494,6 +498,10 @@ bool BridgedFunction::hasSemanticsAttr(BridgedStringRef attrName) const {
   return getFunction()->hasSemanticsAttr(attrName.get());
 }
 
+bool BridgedFunction::hasUnsafeNonEscapableResult() const {
+  return getFunction()->hasUnsafeNonEscapableResult();
+}
+
 BridgedFunction::EffectsKind BridgedFunction::getEffectAttribute() const {
   return (EffectsKind)getFunction()->getEffectsKind();
 }
diff --git a/include/swift/SIL/SILFunction.h b/include/swift/SIL/SILFunction.h
@@ -434,6 +434,10 @@ class SILFunction
   /// from running with pack metadata markers in place.
   unsigned UseStackForPackMetadata : 1;
 
+  /// If true, the function returns a non-escapable value without any
+  /// lifetime-dependence on an argument.
+  unsigned HasUnsafeNonEscapableResult : 1;
+
   static void
   validateSubclassScope(SubclassScope scope, IsThunk_t isThunk,
                         const GenericSpecializationInformation *genericInfo) {
@@ -716,6 +720,14 @@ class SILFunction
     UseStackForPackMetadata = value;
   }
 
+  bool hasUnsafeNonEscapableResult() const {
+    return HasUnsafeNonEscapableResult;
+  }
+
+  void setHasUnsafeNonEscapableResult(bool value) {
+    HasUnsafeNonEscapableResult = value;
+  }
+
   /// Returns true if this is a reabstraction thunk of escaping function type
   /// whose single argument is a potentially non-escaping closure. i.e. the
   /// thunks' function argument may itself have @inout_aliasable parameters.
diff --git a/include/swift/SIL/SILType.h b/include/swift/SIL/SILType.h
@@ -881,6 +881,10 @@ class SILType {
   ProtocolConformanceRef conformsToProtocol(SILFunction *fn,
                                             ProtocolDecl *protocol) const;
 
+  /// False if SILValues of this type cannot be used outside the scope of their
+  /// lifetime dependence.
+  bool isEscapable() const;
+
   //
   // Accessors for types used in SIL instructions:
   //
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -3508,6 +3508,11 @@ static bool usesFeatureStructLetDestructuring(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureNonEscapableTypes(Decl *decl) {
+  return decl->getAttrs().hasAttribute<NonEscapableAttr>()
+    || decl->getAttrs().hasAttribute<UnsafeNonEscapableResultAttr>();
+}
+
 static bool hasParameterPacks(Decl *decl) {
   if (auto genericContext = decl->getAsGenericContext()) {
     auto sig = genericContext->getGenericSignature();
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -3562,6 +3562,12 @@ bool ValueDecl::isMoveOnly() const {
                            getAttrs().hasAttribute<MoveOnlyAttr>());
 }
 
+bool ValueDecl::isEscapable() const {
+  return evaluateOrDefault(getASTContext().evaluator,
+                           IsEscapableRequest{const_cast<ValueDecl *>(this)},
+                           !getAttrs().hasAttribute<NonEscapableAttr>());
+}
+
 bool ValueDecl::isDynamic() const {
   ASTContext &ctx = getASTContext();
   return evaluateOrDefault(ctx.evaluator,
diff --git a/lib/AST/TypeCheckRequests.cpp b/lib/AST/TypeCheckRequests.cpp
@@ -336,6 +336,29 @@ void IsMoveOnlyRequest::cacheResult(bool value) const {
                              MoveOnlyAttr(/*Implicit=*/true));
 }
 
+//----------------------------------------------------------------------------//
+// isEscapable computation.
+//----------------------------------------------------------------------------//
+
+llvm::Optional<bool> IsEscapableRequest::getCachedResult() const {
+  auto decl = std::get<0>(getStorage());
+  if (decl->LazySemanticInfo.isEscapableComputed)
+    return decl->LazySemanticInfo.isEscapable;
+
+  return llvm::None;
+}
+
+void IsEscapableRequest::cacheResult(bool value) const {
+  auto decl = std::get<0>(getStorage());
+  decl->LazySemanticInfo.isEscapableComputed = true;
+  decl->LazySemanticInfo.isEscapable = value;
+
+  // Add an attribute for printing
+  if (!value && !decl->getAttrs().hasAttribute<NonEscapableAttr>())
+    decl->getAttrs().add(new (decl->getASTContext())
+                             NonEscapableAttr(/*Implicit=*/true));
+}
+
 //----------------------------------------------------------------------------//
 // isDynamic computation.
 //----------------------------------------------------------------------------//
diff --git a/lib/SIL/IR/SILFunction.cpp b/lib/SIL/IR/SILFunction.cpp
@@ -208,6 +208,7 @@ void SILFunction::init(
   this->IsRuntimeAccessible = isRuntimeAccessible;
   this->ForceEnableLexicalLifetimes = DoNotForceEnableLexicalLifetimes;
   this->UseStackForPackMetadata = DoUseStackForPackMetadata;
+  this->HasUnsafeNonEscapableResult = false;
   this->stackProtection = false;
   this->Inlined = false;
   this->Zombie = false;
diff --git a/lib/SIL/IR/SILFunctionBuilder.cpp b/lib/SIL/IR/SILFunctionBuilder.cpp
@@ -197,6 +197,10 @@ void SILFunctionBuilder::addFunctionAttributes(
     F->setForceEnableLexicalLifetimes(DoForceEnableLexicalLifetimes);
   }
 
+  if (Attrs.hasAttribute<UnsafeNonEscapableResultAttr>()) {
+    F->setHasUnsafeNonEscapableResult(true);
+  }
+
   // Validate `@differentiable` attributes by calling `getParameterIndices`.
   // This is important for:
   // - Skipping invalid `@differentiable` attributes in non-primary files.
diff --git a/lib/SIL/IR/SILPrinter.cpp b/lib/SIL/IR/SILPrinter.cpp
@@ -3245,6 +3245,9 @@ void SILFunction::print(SILPrintContext &PrintCtx) const {
   if (!useStackForPackMetadata()) {
     OS << "[no_onstack_pack_metadata] ";
   }
+  if (hasUnsafeNonEscapableResult()) {
+    OS << "[unsafe_nonescapable_result] ";
+  }
 
   if (isExactSelfClass()) {
     OS << "[exact_self_class] ";
diff --git a/lib/SIL/IR/SILType.cpp b/lib/SIL/IR/SILType.cpp
@@ -1130,6 +1130,13 @@ bool SILType::isMarkedAsImmortal() const {
   return false;
 }
 
+bool SILType::isEscapable() const {
+  if (auto *nom = getASTType().getAnyNominal())
+    return nom->isEscapable();
+
+  return true;
+}
+
 intptr_t SILType::getFieldIdxOfNominalType(StringRef fieldName) const {
   auto *nominal = getNominalOrBoundGenericNominal();
   if (!nominal)
diff --git a/lib/SIL/IR/TypeLowering.cpp b/lib/SIL/IR/TypeLowering.cpp
@@ -2411,7 +2411,9 @@ namespace {
         return new (TC) MoveOnlyLoadableStructTypeLowering(
             structType, properties, Expansion);
       }
-
+      if (!D->isEscapable()) {
+        properties.setNonTrivial();
+      }
       return handleAggregateByProperties<LoadableStructTypeLowering>(structType,
                                                                     properties);
     }
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
diff --git a/lib/Sema/TypeCheckDeclOverride.cpp b/lib/Sema/TypeCheckDeclOverride.cpp
diff --git a/test/SIL/Parser/attributes.sil b/test/SIL/Parser/attributes.sil
diff --git a/test/attr/attr_nonEscapable.swift b/test/attr/attr_nonEscapable.swift

Original file line number	Diff line number	Diff line change
`@@ -116,6 +116,10 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`
	`119`	`+ public var hasUnsafeNonEscapableResult: Bool {`
	`120`	`+ return bridged.hasUnsafeNonEscapableResult()`
	`121`	`+ }`
	`122`	`+`
`119`	`123`	`/// True if the callee function is annotated with @_semantics("programtermination_point").`
`120`	`124`	`/// This means that the function terminates the program.`
`121`	`125`	`public var isProgramTerminationPoint: Bool { hasSemanticsAttribute("programtermination_point") }`