Merge remote-tracking branch 'origin/main' into 20231019-merge-main

Conflicts:
  - `lib/AST/TypeCheckRequests.cpp` renamed `isMoveOnly` which requires
    a static_cast on rebranch because `Optional` is now a `std::optional`.

Author: bnbarham

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/DeadStoreElimination.swift

@@ -53,6 +53,10 @@ import SIL
 let deadStoreElimination = FunctionPass(name: "dead-store-elimination") {
   (function: Function, context: FunctionPassContext) in
 
+  // Avoid quadratic complexity by limiting the number of visited instructions.
+  // This limit is sufficient for most "real-world" functions, by far.
+  var complexityBudget = 10_000
+
   for block in function.blocks {
 
     // We cannot use for-in iteration here because if the store is split, the new
@@ -63,26 +67,26 @@ let deadStoreElimination = FunctionPass(name: "dead-store-elimination") {
         if !context.continueWithNextSubpassRun(for: store) {
           return
         }
-        tryEliminate(store: store, context)
+        tryEliminate(store: store, complexityBudget: &complexityBudget, context)
       }
       inst = i.next
     }
   }
 }
 
-private func tryEliminate(store: StoreInst, _ context: FunctionPassContext) {
+private func tryEliminate(store: StoreInst, complexityBudget: inout Int, _ context: FunctionPassContext) {
   if !store.hasValidOwnershipForDeadStoreElimination {
     return
   }
 
-  switch store.isDead(context) {
+  switch store.isDead(complexityBudget: &complexityBudget, context) {
     case .alive:
       break
     case .dead:
       context.erase(instruction: store)
     case .maybePartiallyDead(let subPath):
       // Check if the a partial store would really be dead to avoid unnecessary splitting.
-      switch store.isDead(at: subPath, context) {
+      switch store.isDead(at: subPath, complexityBudget: &complexityBudget, context) {
         case .alive, .maybePartiallyDead:
           break
         case .dead:
@@ -109,15 +113,15 @@ private extension StoreInst {
     }
   }
 
-  func isDead( _ context: FunctionPassContext) -> DataflowResult {
-    return isDead(at: destination.accessPath, context)
+  func isDead(complexityBudget: inout Int, _ context: FunctionPassContext) -> DataflowResult {
+    return isDead(at: destination.accessPath, complexityBudget: &complexityBudget, context)
   }
 
-  func isDead(at accessPath: AccessPath, _ context: FunctionPassContext) -> DataflowResult {
+  func isDead(at accessPath: AccessPath, complexityBudget: inout Int, _ context: FunctionPassContext) -> DataflowResult {
     var scanner = InstructionScanner(storePath: accessPath, storeAddress: self.destination, context.aliasAnalysis)
     let storageDefBlock = accessPath.base.reference?.referenceRoot.parentBlock
 
-    switch scanner.scan(instructions: InstructionList(first: self.next)) {
+    switch scanner.scan(instructions: InstructionList(first: self.next), complexityBudget: &complexityBudget) {
     case .dead:
       return .dead
 
@@ -145,7 +149,7 @@ private extension StoreInst {
         if let storageDefBlock = storageDefBlock, block == storageDefBlock {
           return DataflowResult(aliveWith: scanner.potentiallyDeadSubpath)
         }
-        switch scanner.scan(instructions: block.instructions) {
+        switch scanner.scan(instructions: block.instructions, complexityBudget: &complexityBudget) {
         case .transparent:
           worklist.pushIfNotVisited(contentsOf: block.successors)
         case .dead:
@@ -177,10 +181,6 @@ private struct InstructionScanner {
 
   private(set) var potentiallyDeadSubpath: AccessPath? = nil
 
-  // Avoid quadratic complexity by limiting the number of visited instructions for each store.
-  // The limit of 1000 instructions is not reached by far in "real-world" functions.
-  private var budget = 1000
-
   init(storePath: AccessPath, storeAddress: Value, _ aliasAnalysis: AliasAnalysis) {
     self.storePath = storePath
     self.storeAddress = storeAddress
@@ -193,7 +193,7 @@ private struct InstructionScanner {
     case transparent
   }
 
-  mutating func scan(instructions: InstructionList) -> Result {
+  mutating func scan(instructions: InstructionList, complexityBudget: inout Int) -> Result {
     for inst in instructions {
       switch inst {
       case let successiveStore as StoreInst:
@@ -226,8 +226,8 @@ private struct InstructionScanner {
         }
         fallthrough
       default:
-        budget -= 1
-        if budget == 0 {
+        complexityBudget -= 1
+        if complexityBudget <= 0 {
           return .alive
         }
         if inst.mayRead(fromAddress: storeAddress, aliasAnalysis) {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/RedundantLoadElimination.swift

@@ -74,6 +74,11 @@ let earlyRedundantLoadElimination = FunctionPass(name: "early-redundant-load-eli
 }
 
 private func eliminateRedundantLoads(in function: Function, ignoreArrays: Bool, _ context: FunctionPassContext) {
+
+  // Avoid quadratic complexity by limiting the number of visited instructions.
+  // This limit is sufficient for most "real-world" functions, by far.
+  var complexityBudget = 50_000
+
   for block in function.blocks.reversed() {
 
     // We cannot use for-in iteration here because if the load is split, the new
@@ -89,21 +94,21 @@ private func eliminateRedundantLoads(in function: Function, ignoreArrays: Bool,
         if ignoreArrays && load.type.isNominal && load.type.nominal == context.swiftArrayDecl {
           continue
         }
-        tryEliminate(load: load, context)
+        tryEliminate(load: load, complexityBudget: &complexityBudget, context)
       }
     }
   }
 }
 
-private func tryEliminate(load: LoadInst, _ context: FunctionPassContext) {
-  switch load.isRedundant(context) {
+private func tryEliminate(load: LoadInst, complexityBudget: inout Int, _ context: FunctionPassContext) {
+  switch load.isRedundant(complexityBudget: &complexityBudget, context) {
   case .notRedundant:
     break
   case .redundant(let availableValues):
     replace(load: load, with: availableValues, context)
   case .maybePartiallyRedundant(let subPath):
     // Check if the a partial load would really be redundant to avoid unnecessary splitting.
-    switch load.isRedundant(at: subPath, context) {
+    switch load.isRedundant(at: subPath, complexityBudget: &complexityBudget, context) {
       case .notRedundant, .maybePartiallyRedundant:
         break
       case .redundant:
@@ -130,25 +135,29 @@ private extension LoadInst {
     }
   }
 
-  func isRedundant(_ context: FunctionPassContext) -> DataflowResult {
-    return isRedundant(at: address.accessPath, context)
+  func isRedundant(complexityBudget: inout Int, _ context: FunctionPassContext) -> DataflowResult {
+    return isRedundant(at: address.accessPath, complexityBudget: &complexityBudget, context)
   }
 
-  func isRedundant(at accessPath: AccessPath, _ context: FunctionPassContext) -> DataflowResult {
+  func isRedundant(at accessPath: AccessPath, complexityBudget: inout Int, _ context: FunctionPassContext) -> DataflowResult {
     var scanner = InstructionScanner(load: self, accessPath: accessPath, context.aliasAnalysis)
 
-    switch scanner.scan(instructions: ReverseInstructionList(first: self.previous), in: parentBlock) {
+    switch scanner.scan(instructions: ReverseInstructionList(first: self.previous),
+                        in: parentBlock,
+                        complexityBudget: &complexityBudget)
+    {
     case .overwritten:
       return DataflowResult(notRedundantWith: scanner.potentiallyRedundantSubpath)
     case .available:
       return .redundant(scanner.availableValues)
     case .transparent:
-      return self.isRedundantInPredecessorBlocks(scanner: &scanner, context)
+      return self.isRedundantInPredecessorBlocks(scanner: &scanner, complexityBudget: &complexityBudget, context)
     }
   }
 
   private func isRedundantInPredecessorBlocks(
     scanner: inout InstructionScanner,
+    complexityBudget: inout Int,
     _ context: FunctionPassContext
   ) -> DataflowResult {
 
@@ -157,7 +166,10 @@ private extension LoadInst {
     liferange.pushPredecessors(of: self.parentBlock)
 
     while let block = liferange.pop() {
-      switch scanner.scan(instructions: block.instructions.reversed(), in: block) {
+      switch scanner.scan(instructions: block.instructions.reversed(),
+                          in: block,
+                          complexityBudget: &complexityBudget)
+      {
       case .overwritten:
         return DataflowResult(notRedundantWith: scanner.potentiallyRedundantSubpath)
       case .available:
@@ -402,10 +414,6 @@ private struct InstructionScanner {
   private(set) var potentiallyRedundantSubpath: AccessPath? = nil
   private(set) var availableValues = Array<AvailableValue>()
 
-  // Avoid quadratic complexity by limiting the number of visited instructions for each store.
-  // The limit of 1000 instructions is not reached by far in "real-world" functions.
-  private var budget = 1000
-
   init(load: LoadInst, accessPath: AccessPath, _ aliasAnalysis: AliasAnalysis) {
     self.load = load
     self.accessPath = accessPath
@@ -419,8 +427,16 @@ private struct InstructionScanner {
     case transparent
   }
 
-  mutating func scan(instructions: ReverseInstructionList, in block: BasicBlock) -> ScanResult {
+  mutating func scan(instructions: ReverseInstructionList,
+                     in block: BasicBlock,
+                     complexityBudget: inout Int) -> ScanResult
+  {
     for inst in instructions {
+      complexityBudget -= 1
+      if complexityBudget <= 0 {
+        return .overwritten
+      }
+
       switch visit(instruction: inst) {
         case .available:   return .available
         case .overwritten: return .overwritten
@@ -490,10 +506,6 @@ private struct InstructionScanner {
     default:
       break
     }
-    budget -= 1
-    if budget == 0 {
-      return .overwritten
-    }
     if load.loadOwnership == .take {
       // In case of `take`, don't allow reading instructions in the liferange.
       // Otherwise we cannot shrink the memory liferange afterwards.

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") }

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() }
 

cmake/caches/Windows-x86_64.cmake

@@ -152,6 +152,7 @@ set(SWIFT_INSTALL_COMPONENTS
       sourcekit-inproc
       swift-remote-mirror
       swift-remote-mirror-headers
+      swift-syntax-lib
     CACHE STRING "")
 
 set(LLVM_DISTRIBUTION_COMPONENTS

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

include/swift-c/DependencyScan/DependencyScan.h

@@ -180,6 +180,10 @@ SWIFTSCAN_PUBLIC swiftscan_string_ref_t
 swiftscan_swift_binary_detail_get_module_source_info_path(
     swiftscan_module_details_t details);
 
+SWIFTSCAN_PUBLIC swiftscan_string_set_t *
+swiftscan_swift_binary_detail_get_swift_overlay_dependencies(
+    swiftscan_module_details_t details);
+
 SWIFTSCAN_PUBLIC swiftscan_string_set_t *
 swiftscan_swift_binary_detail_get_header_dependencies(
     swiftscan_module_details_t details);

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)

include/swift/AST/Decl.h

@@ -1596,6 +1596,9 @@ class InheritedTypes {
   size_t size() const { return Entries.size(); }
   IntRange<size_t> const getIndices() { return indices(Entries); }
 
+  /// Returns the ASTContext associated with the wrapped declaration.
+  ASTContext &getASTContext() const;
+
   /// Returns the `TypeRepr *` for the entry of the inheritance clause at the
   /// given index.
   TypeRepr *getTypeRepr(unsigned i) const { return Entries[i].getTypeRepr(); }
@@ -1615,6 +1618,10 @@ class InheritedTypes {
   /// NOTE: The `Type` associated with the entry may not be resolved yet.
   const InheritedEntry &getEntry(unsigned i) const { return Entries[i]; }
 
+  // Retrieve the location of the colon character introducing the inheritance
+  // clause.
+  SourceLoc getColonLoc() const;
+
   /// Returns the source location of the beginning of the inheritance clause.
   SourceLoc getStartLoc() const {
     return getEntries().front().getSourceRange().Start;
@@ -1624,6 +1631,10 @@ class InheritedTypes {
   SourceLoc getEndLoc() const {
     return getEntries().back().getSourceRange().End;
   }
+
+  /// Compute the SourceRange to be used when removing entry \c i from the
+  /// inheritance clause. Accounts for commas and colons as-needed.
+  SourceRange getRemovalRange(unsigned i) const;
 };
 
 /// ExtensionDecl - This represents a type extension containing methods
@@ -2606,18 +2617,18 @@ class ValueDecl : public Decl {
     /// optional result.
     unsigned isIUO : 1;
 
-    /// Whether the "isMoveOnly" bit has been computed yet.
-    unsigned isMoveOnlyComputed : 1;
+    /// Whether the "isEscapable" bit has been computed yet.
+    unsigned isEscapable : 1;
 
-    /// Whether this declaration can not be copied and thus is move only.
-    unsigned isMoveOnly : 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;
@@ -2920,8 +2931,8 @@ class ValueDecl : public Decl {
   /// Is this declaration 'final'?
   bool isFinal() const;
 
-  /// Is this declaration 'moveOnly'?
-  bool isMoveOnly() const;
+  /// Is this declaration escapable?
+  bool isEscapable() const;
 
   /// Is this declaration marked with 'dynamic'?
   bool isDynamic() const;
@@ -3095,8 +3106,18 @@ class ValueDecl : public Decl {
 
 /// This is a common base class for declarations which declare a type.
 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,
@@ -3124,6 +3145,10 @@ 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;
+
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_TypeDecl &&
            D->getKind() <= DeclKind::Last_TypeDecl;