Merge branch 'main' into inline-array

Author: benrimmington

.github/CODEOWNERS

@@ -269,7 +269,7 @@
 /unittests/AST/                           @hborla @slavapestov @xedin
 /unittests/AST/*Evaluator*                @CodaFi @slavapestov
 /unittests/DependencyScan/                @artemcm @cachemeifyoucan
-/unittests/FrontendTool/                  @artemcm @tshortli
+/unittests/Frontend*/                     @artemcm @tshortli
 /unittests/Parse/                         @ahoppen @bnbarham @CodaFi @DougGregor @hamishknight @rintaro
 /unittests/Reflection/                    @slavapestov
 /unittests/SIL/                           @jckarter

Runtimes/Core/cmake/modules/CompilerSettings.cmake

@@ -49,6 +49,8 @@ if(NOT HAVE_SWIFT_ASYNC_CALL)
 endif()
 
 check_compiler_flag(CXX "-mcx16" HAVE_CXX_MCX16)
-if(HAVE_CXX_MCX16)
+if(HAVE_CXX_MCX16 AND
+    (CMAKE_CXX_COMPILER_ARCHITECTURE_ID MATCHES "(X86)|(X64)" OR
+     CMAKE_SYSTEM_PROCESSOR MATCHES "(i[3-6]86)|(x86_64)|(amd64)|(AMD64)"))
   add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-mcx16>)
 endif()

Runtimes/Readme.md

@@ -20,6 +20,11 @@ Once the migration is completed, we will be deleting this script. It
 is a temporary workaround to avoid trying to keep multiple sets of files in
 sync.
 
+> [!NOTE]
+> This script does not add new files to any CMakeLists.txt. Any new files
+> that are copied over will need to be added manually to ensure that
+> they will be built by CMake.
+
 ## Layering
 
 ```

SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift

@@ -53,6 +53,8 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
     self.inExclusiveRange.insert(beginInst)
   }
 
+  // Note: 'ends' are simply the instructions to insert in the range. 'self.ends' might not return the same sequence
+  // as this 'ends' argument because 'self.ends' will not include block exits.
   init<S: Sequence>(begin beginInst: Instruction, ends: S, _ context: some Context) where S.Element: Instruction {
     self = InstructionRange(begin: beginInst, context)
     insert(contentsOf: ends)

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CopyToBorrowOptimization.swift

@@ -124,10 +124,6 @@ private struct Uses {
   // E.g. the none-case of a switch_enum of an Optional.
   private(set) var nonDestroyingLiverangeExits: Stack<Instruction>
 
-  var allLifetimeEndingInstructions: [Instruction] {
-    Array(destroys.lazy.map { $0 }) + Array(nonDestroyingLiverangeExits)
-  }
-
   private(set) var usersInDeadEndBlocks: Stack<Instruction>
 
   init(_ context: FunctionPassContext) {
@@ -323,7 +319,16 @@ private func createEndBorrows(for beginBorrow: Value, atEndOf liverange: Instruc
   //   destroy_value %2
   //   destroy_value %3  // The final destroy. Here we need to create the `end_borrow`(s)
   //
-  for endInst in collectedUses.allLifetimeEndingInstructions {
+
+  var allLifetimeEndingInstructions = InstructionWorklist(context)
+  allLifetimeEndingInstructions.pushIfNotVisited(contentsOf: collectedUses.destroys.lazy.map { $0 })
+  allLifetimeEndingInstructions.pushIfNotVisited(contentsOf: collectedUses.nonDestroyingLiverangeExits)
+
+  defer {
+    allLifetimeEndingInstructions.deinitialize()
+  }
+
+  while let endInst = allLifetimeEndingInstructions.pop() {
     if !liverange.contains(endInst) {
       let builder = Builder(before: endInst, context)
       builder.createEndBorrow(of: beginBorrow)

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceScopeFixup.swift

@@ -350,6 +350,8 @@ extension LifetimeDependence.Scope {
       self = .initialized(.yield(result))
       return
     }
+    // @inout arguments belong to the coroutine because they are valid for the duration of the yield, and, if local
+    // mutation or reassignment were relevant, then the dependence would be on an access scope instead.
     self = .yield(result)
   }
 }

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -1333,6 +1333,8 @@ final public class AllocExistentialBoxInst : SingleValueInstruction, Allocation
 /// scope ending instruction such as `begin_access` (ending with `end_access`) and `begin_borrow` (ending with
 /// `end_borrow`).
 public protocol ScopedInstruction {
+  var instruction: Instruction { get }
+
   var endOperands: LazyFilterSequence<UseList> { get }
 
   var endInstructions: EndInstructions { get }
@@ -1349,7 +1351,12 @@ extension Instruction {
 }
 
 /// Instructions beginning a borrow-scope which must be ended by `end_borrow`.
-public protocol BorrowIntroducingInstruction : SingleValueInstruction, ScopedInstruction {}
+public protocol BorrowIntroducingInstruction : SingleValueInstruction, ScopedInstruction {
+}
+
+extension BorrowIntroducingInstruction {
+  public var instruction: Instruction { get { self } }
+}
 
 final public class EndBorrowInst : Instruction, UnaryInstruction {
   public var borrow: Value { operand.value }
@@ -1428,6 +1435,8 @@ final public class EndAccessInst : Instruction, UnaryInstruction {
 }
 
 extension BeginAccessInst : ScopedInstruction {
+  public var instruction: Instruction { get { self } }
+
   public var endOperands: LazyFilterSequence<UseList> {
     return uses.lazy.filter { $0.instruction is EndAccessInst }
   }
@@ -1462,6 +1471,8 @@ final public class AbortApplyInst : Instruction, UnaryInstruction {
 }
 
 extension BeginApplyInst : ScopedInstruction {
+  public var instruction: Instruction { get { self } }
+
   public var endOperands: LazyFilterSequence<UseList> {
     return token.uses.lazy.filter { $0.isScopeEndingUse }
   }

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -219,6 +219,26 @@ passing the flag `-Xfrontend -debug-constraints`:
     $ swift repl -Xfrontend -debug-constraints
     1> let foo = 1
 
+### Debugging Evaluator Cycles
+
+When triggering code in the type checker, one can by mistake cause a cycle in
+the request evaluator. The error looks as follows:
+
+```
+<unknown>:0: error: circular reference
+file.swift:18:22: note: through reference here
+16 | 
+17 | extension MyType {
+18 |   public static func test() -> MyType { ... }
+   |                      `- note: through reference here
+19 | }
+20 | 
+```
+
+To determine the actual circular request that is occuring, one can pass in the
+flag `-debug-cycles` to the compiler which will cause the compiler to dump out
+the linear chain of requests that led to the cycle.
+
 ## Debugging on SIL Level
 
 ### Options for Dumping the SIL

docs/DebuggingTheCompiler.md

@@ -711,6 +711,14 @@ class TrailingGenericContextObjects<TargetSelf<Runtime>,
             getGenericValueDescriptors().data()};
   }
 
+  static size_t trailingTypeCount() {
+    return TrailingObjects::trailingTypeCount();
+  }
+
+  size_t sizeWithTrailingTypeCount(size_t n) const {
+    return TrailingObjects::sizeWithTrailingTypeCount(n);
+  }
+
 protected:
   size_t numTrailingObjects(OverloadToken<GenericContextHeaderType>) const {
     return asSelf()->isGeneric() ? 1 : 0;