Merge branch 'main' into wip-generic-reqs-from-actor-da-for-accessor

Author: ktoso

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LetPropertyLowering.swift

@@ -135,8 +135,8 @@ private func constructLetInitRegion(
   // root-class initializer).
   initRegion.insert(markUninitialized)
 
-  var beginBorrows = Stack<BeginBorrowInst>(context)
-  defer { beginBorrows.deinitialize() }
+  var borrows = Stack<BorrowIntroducingInstruction>(context)
+  defer { borrows.deinitialize() }
 
   for inst in markUninitialized.parentFunction.instructions {
     switch inst {
@@ -161,8 +161,13 @@ private func constructLetInitRegion(
       // Include let-field partial de-initializations in the region.
       initRegion.insert(inst)
 
-    case let beginBorrow as BeginBorrowInst:
-      beginBorrows.append(beginBorrow)
+    case let beginBorrow as BeginBorrowInst
+         where beginBorrow.borrowedValue.referenceRoot == markUninitialized:
+      borrows.append(beginBorrow)
+
+    case let storeBorrow as StoreBorrowInst
+         where storeBorrow.source.referenceRoot == markUninitialized:
+      borrows.append(storeBorrow)
 
     default:
       break
@@ -171,8 +176,8 @@ private func constructLetInitRegion(
 
   // Extend the region to whole borrow scopes to avoid that we insert an `end_init_let_ref` in the
   // middle of a borrow scope.
-  for beginBorrow in beginBorrows where initRegion.contains(beginBorrow) {
-    initRegion.insert(contentsOf: beginBorrow.endBorrows)
+  for borrow in borrows where initRegion.contains(borrow) {
+    initRegion.insert(borrowScopeOf: borrow, context)
   }
 }
 

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -532,3 +532,25 @@ extension GlobalVariable {
     }
   }
 }
+
+extension InstructionRange {
+  /// Adds the instruction range of a borrow-scope by transitively visiting all (potential) re-borrows.
+  mutating func insert(borrowScopeOf borrow: BorrowIntroducingInstruction, _ context: some Context) {
+    var worklist = ValueWorklist(context)
+    defer { worklist.deinitialize() }
+
+    worklist.pushIfNotVisited(borrow)
+    while let value = worklist.pop() {
+      for use in value.uses {
+        switch use.instruction {
+        case let endBorrow as EndBorrowInst:
+          self.insert(endBorrow)
+        case let branch as BranchInst:
+          worklist.pushIfNotVisited(branch.getArgument(for: use))
+        default:
+          break
+        }
+      }
+    }
+  }
+}

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -234,7 +234,7 @@ extension UnaryInstruction {
 final public class UnimplementedInstruction : Instruction {
 }
 
-public protocol StoringInstruction : AnyObject {
+public protocol StoringInstruction : Instruction {
   var operands: OperandArray { get }
 }
 
@@ -270,6 +270,8 @@ final public class StoreInst : Instruction, StoringInstruction {
 final public class StoreWeakInst : Instruction, StoringInstruction { }
 final public class StoreUnownedInst : Instruction, StoringInstruction { }
 
+final public class StoreBorrowInst : SingleValueInstruction, StoringInstruction, BorrowIntroducingInstruction { }
+
 final public class AssignInst : Instruction, StoringInstruction {
   // must match with enum class swift::AssignOwnershipQualifier
   public enum AssignOwnership: Int {
@@ -495,6 +497,9 @@ extension LoadInstruction {
   public var address: Value { operand.value }
 }
 
+/// Instructions, beginning a borrow-scope which must be ended by `end_borrow`.
+public protocol BorrowIntroducingInstruction : SingleValueInstruction {}
+
 final public class LoadInst : SingleValueInstruction, LoadInstruction {
   // must match with enum class LoadOwnershipQualifier
   public enum LoadOwnership: Int {
@@ -507,7 +512,7 @@ final public class LoadInst : SingleValueInstruction, LoadInstruction {
 
 final public class LoadWeakInst : SingleValueInstruction, LoadInstruction {}
 final public class LoadUnownedInst : SingleValueInstruction, LoadInstruction {}
-final public class LoadBorrowInst : SingleValueInstruction, LoadInstruction {}
+final public class LoadBorrowInst : SingleValueInstruction, LoadInstruction, BorrowIntroducingInstruction {}
 
 final public class BuiltinInst : SingleValueInstruction {
   public typealias ID = BridgedInstruction.BuiltinValueKind
@@ -872,16 +877,9 @@ extension BeginAccessInst : ScopedInstruction {
   }
 }
 
-final public class BeginBorrowInst : SingleValueInstruction, UnaryInstruction {
+final public class BeginBorrowInst : SingleValueInstruction, UnaryInstruction, BorrowIntroducingInstruction {
   public var borrowedValue: Value { operand.value }
 
-  public typealias EndBorrowSequence = LazyMapSequence<LazyFilterSequence<LazyMapSequence<UseList, EndBorrowInst?>>,
-                                                       EndBorrowInst>
-
-  public var endBorrows: EndBorrowSequence {
-    uses.lazy.compactMap({ $0.instruction as? EndBorrowInst })
-  }
-
   public var isLexical: Bool { bridged.BeginBorrow_isLexical() }
   public var hasPointerEscape: Bool { bridged.BeginBorrow_hasPointerEscape() }
 }

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -41,6 +41,7 @@ public func registerSILClasses() {
   register(StoreInst.self)
   register(StoreWeakInst.self)
   register(StoreUnownedInst.self)
+  register(StoreBorrowInst.self)
   register(AssignInst.self)
   register(CopyAddrInst.self)
   register(EndAccessInst.self)

include/swift/AST/Attr.def

@@ -530,6 +530,9 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(actor, Actor,
 CONTEXTUAL_SIMPLE_DECL_ATTR(_resultDependsOnSelf, ResultDependsOnSelf,
   OnFunc | DeclModifier | UserInaccessible | ABIBreakingToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
   150)
+SIMPLE_DECL_ATTR(_staticExclusiveOnly, StaticExclusiveOnly,
+  OnStruct | UserInaccessible | ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
+  151)
 
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS

include/swift/AST/DiagnosticsSema.def

@@ -1917,6 +1917,20 @@ WARNING(extern_c_maybe_invalid_name, none,
         "C name '%0' may be invalid; explicitly specify the name in @_extern(c) to suppress this warning",
         (StringRef))
 
+// @_staticExclusiveOnly
+ERROR(attr_static_exclusive_only_disabled,none,
+      "attribute requires '-enable-experimental feature StaticExclusiveOnly'", ())
+ERROR(attr_static_exclusive_only_noncopyable,none,
+      "@_staticExclusiveOnly can only be applied to noncopyable types", ())
+ERROR(attr_static_exclusive_only_let_only,none,
+      "variable of type %0 must be declared with a 'let'", (Type))
+NOTE(attr_static_exclusive_only_type_nonmutating,none,
+     "%0 is a non-mutable type", (Type))
+ERROR(attr_static_exclusive_only_let_only_param,none,
+      "parameter of type %0 must be declared as either 'borrowing' or 'consuming'", (Type))
+ERROR(attr_static_exclusive_only_mutating,none,
+      "type %0 cannot have mutating function %1", (Type, ValueDecl *))
+
 ERROR(c_func_variadic, none,
       "cannot declare variadic argument %0 in %kind1",
       (DeclName, const ValueDecl *))

include/swift/Basic/Features.def

@@ -259,6 +259,9 @@ EXPERIMENTAL_FEATURE(Extern, true)
 // global functions and key paths.
 EXPERIMENTAL_FEATURE(InferSendableFromCaptures, false)
 
+/// Enable the `@_staticExclusiveOnly` attribute.
+EXPERIMENTAL_FEATURE(StaticExclusiveOnly, true)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

include/swift/SILOptimizer/Utils/ConstantFolding.h

@@ -31,10 +31,16 @@ class SILOptFunctionBuilder;
 /// The \p ID must be the ID of a binary bit-operation builtin.
 APInt constantFoldBitOperation(APInt lhs, APInt rhs, BuiltinValueKind ID);
 
+/// Evaluates the constant result of a floating point comparison.
+///
+/// The \p ID must be the ID of a floating point builtin operation.
+APInt constantFoldComparisonFloat(APFloat lhs, APFloat rhs,
+                                  BuiltinValueKind ID);
+
 /// Evaluates the constant result of an integer comparison.
 ///
 /// The \p ID must be the ID of an integer builtin operation.
-APInt constantFoldComparison(APInt lhs, APInt rhs, BuiltinValueKind ID);
+APInt constantFoldComparisonInt(APInt lhs, APInt rhs, BuiltinValueKind ID);
 
 /// Evaluates the constant result of a binary operation with overflow.
 ///

lib/AST/ASTPrinter.cpp

@@ -3640,6 +3640,10 @@ static bool usesFeatureExtern(Decl *decl) {
   return decl->getAttrs().hasAttribute<ExternAttr>();
 }
 
+static bool usesFeatureStaticExclusiveOnly(Decl *decl) {
+  return decl->getAttrs().hasAttribute<StaticExclusiveOnlyAttr>();
+}
+
 /// Suppress the printing of a particular feature.
 static void suppressingFeature(PrintOptions &options, Feature feature,
                                llvm::function_ref<void()> action) {

lib/SILGen/SILGen.cpp

@@ -1802,7 +1802,7 @@ void SILGenModule::visitVarDecl(VarDecl *vd) {
   if (vd->hasStorage())
     addGlobalVariable(vd);
 
-  vd->visitEmittedAccessors([&](AccessorDecl *accessor) {
+  visitEmittedAccessors(vd, [&](AccessorDecl *accessor) {
     emitFunction(accessor);
   });
 
@@ -1825,6 +1825,16 @@ void SILGenModule::visitMacroExpansionDecl(MacroExpansionDecl *d) {
   // Expansion already visited as auxiliary decls.
 }
 
+void SILGenModule::visitEmittedAccessors(
+    AbstractStorageDecl *D, llvm::function_ref<void(AccessorDecl *)> callback) {
+  D->visitEmittedAccessors([&](AccessorDecl *accessor) {
+    if (shouldSkipDecl(accessor))
+      return;
+
+    callback(accessor);
+  });
+}
+
 bool
 SILGenModule::canStorageUseStoredKeyPathComponent(AbstractStorageDecl *decl,
                                                   ResilienceExpansion expansion) {

lib/SILGen/SILGen.h

@@ -301,6 +301,11 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   void visitMacroDecl(MacroDecl *d);
   void visitMacroExpansionDecl(MacroExpansionDecl *d);
 
+  // Same as AbstractStorageDecl::visitEmittedAccessors, but skips over skipped
+  // (unavailable) decls.
+  void visitEmittedAccessors(AbstractStorageDecl *D,
+                             llvm::function_ref<void(AccessorDecl *)>);
+
   void emitEntryPoint(SourceFile *SF);
   void emitEntryPoint(SourceFile *SF, SILFunction *TopLevel);
 

lib/SILGen/SILGenDecl.cpp

@@ -1628,7 +1628,7 @@ void SILGenFunction::visitVarDecl(VarDecl *D) {
   });
 
   // Emit the variable's accessors.
-  D->visitEmittedAccessors([&](AccessorDecl *accessor) {
+  SGM.visitEmittedAccessors(D, [&](AccessorDecl *accessor) {
     SGM.emitFunction(accessor);
   });
 }

lib/SILGen/SILGenTopLevel.cpp

@@ -257,7 +257,7 @@ void SILGenTopLevel::visitAbstractFunctionDecl(AbstractFunctionDecl *AFD) {
 }
 
 void SILGenTopLevel::visitAbstractStorageDecl(AbstractStorageDecl *ASD) {
-  ASD->visitEmittedAccessors(
+  SGF.SGM.visitEmittedAccessors(ASD,
       [this](AccessorDecl *Accessor) { visitAbstractFunctionDecl(Accessor); });
 }
 
@@ -338,7 +338,7 @@ void SILGenTopLevel::TypeVisitor::visitAbstractFunctionDecl(
 
 void SILGenTopLevel::TypeVisitor::visitAbstractStorageDecl(
     AbstractStorageDecl *ASD) {
-  ASD->visitEmittedAccessors(
+  SGF.SGM.visitEmittedAccessors(ASD,
       [this](AccessorDecl *Accessor) { visitAbstractFunctionDecl(Accessor); });
 }
 

lib/SILGen/SILGenType.cpp

@@ -1242,7 +1242,7 @@ class SILGenType : public TypeMemberVisitor<SILGenType> {
   }
 
   void visitAccessors(AbstractStorageDecl *asd) {
-    asd->visitEmittedAccessors([&](AccessorDecl *accessor) {
+    SGM.visitEmittedAccessors(asd, [&](AccessorDecl *accessor) {
       visitFuncDecl(accessor);
     });
   }
@@ -1422,7 +1422,7 @@ class SILGenExtension : public TypeMemberVisitor<SILGenExtension> {
   }
 
   void visitAccessors(AbstractStorageDecl *asd) {
-    asd->visitEmittedAccessors([&](AccessorDecl *accessor) {
+    SGM.visitEmittedAccessors(asd, [&](AccessorDecl *accessor) {
       visitFuncDecl(accessor);
     });
   }