# Swift Compiler Project

Swift is a high-performance system programming language with a clean, modern syntax that offers seamless access to existing C and Objective-C code while being memory-safe by default. As a complete and independent language, Swift packages core features like flow control, data structures, and functions with high-level constructs including objects, protocols, closures, and generics. The language embraces a module-based architecture, eliminating header files and the code duplication they entail. Modern Swift features include a powerful macro system for compile-time metaprogramming, distributed actors for scalable concurrent systems, observation framework for reactive programming, and advanced C++ interoperability.

The Swift compiler toolchain is a comprehensive system comprising multiple components: a driver that orchestrates compilation, a frontend for parsing and type-checking, SILGen for intermediate representation generation, optimization passes, and IRGen for LLVM IR emission. The project includes extensive libraries for AST manipulation, semantic analysis, serialization, refactoring, and IDE support. Notably, the compiler is undergoing a major architectural evolution with core components being rewritten in Swift itself (SwiftCompilerSources) alongside the traditional C++ implementation. The toolchain supports cross-platform development on macOS, Linux, Windows, and embedded systems, with sophisticated incremental compilation and dependency tracking capabilities. A plugin system enables extensibility through macro processors and custom diagnostics, while tools like swift-inspect provide deep runtime introspection capabilities.

## Build System

### Building the Swift Toolchain

The primary build system uses `build-script`, a Python-based tool that orchestrates compilation of the entire Swift toolchain including the compiler, standard library, and runtime.

```bash
# Clone the Swift repository and dependencies
git clone https://github.com/swiftlang/swift.git swift
cd swift
utils/update-checkout --clone

# Build the toolchain with debug assertions (development mode)
utils/build-script --debug-swift --assertions

# Build optimized release configuration
utils/build-script --release

# Build and run tests
utils/build-script --test

# Build with specific options
utils/build-script \
  --release \
  --assertions \
  --test \
  --validation-test \
  --lit-args=-v

# Incremental build (after making changes)
utils/build-script --debug-swift --skip-build-benchmarks

# Build for specific platform
utils/build-script --release --ios --tvos --watchos
```

### Creating Custom Toolchains

Build distributable toolchain packages using `build-toolchain` for local development or distribution.

```bash
# Build a development toolchain
./utils/build-toolchain com.example

# This creates: swift-LOCAL-YYYY-MM-DD-a-osx.tar.gz
# Bundle identifier: com.example.YYYYMMDD

# Build with testing enabled
./utils/build-toolchain com.example --test

# Build with distributed compilation
./utils/build-toolchain com.example --distcc

# Build with build caching
./utils/build-toolchain com.example --sccache

# Dry run to see what would be built
./utils/build-toolchain com.example --dry-run

# Install into Xcode (macOS)
sudo tar -xzf swift-LOCAL-YYYY-MM-DD-a-osx.tar.gz -C /
# Or user-local installation
tar -xzf swift-LOCAL-YYYY-MM-DD-a-osx.tar.gz -C ~/

# Install debug symbols
sudo tar -xzf swift-LOCAL-YYYY-MM-DD-a-osx-symbols.tar.gz -C /
```

## Compiler Driver

### Basic Compilation

The Swift driver (`swiftc`) orchestrates the compilation process, managing frontend jobs, module merging, and linking.

```bash
# Compile single file to executable
swiftc hello.swift -o hello

# Compile multiple files in one module
swiftc main.swift utils.swift helpers.swift -o myapp

# Emit object files without linking
swiftc -c file1.swift file2.swift

# Emit assembly
swiftc -S hello.swift -o hello.s

# Emit LLVM IR
swiftc -emit-ir hello.swift -o hello.ll

# Emit SIL (Swift Intermediate Language)
swiftc -emit-sil hello.swift -o hello.sil

# Emit SILGen output (raw SIL)
swiftc -emit-silgen hello.swift -o hello.silgen

# Show compilation pipeline
swiftc -### hello.swift

# Verbose output showing all commands
swiftc -v hello.swift
```

### Module Compilation

Swift modules are the fundamental unit of code distribution, requiring specific compilation patterns.

```bash
# Build a module with multiple files
swiftc -module-name MyLibrary \
  -emit-module \
  -emit-library \
  lib.swift utils.swift \
  -o libMyLibrary.dylib

# Build framework (macOS/iOS)
swiftc -module-name MyFramework \
  -emit-module \
  -emit-library \
  -Xlinker -install_name \
  -Xlinker @rpath/MyFramework.framework/MyFramework \
  source1.swift source2.swift \
  -o MyFramework

# Use custom module paths
swiftc -I /path/to/modules \
  -L /path/to/libraries \
  main.swift \
  -o myapp

# Cross-module optimization
swiftc -O -wmo \
  -module-name MyModule \
  file1.swift file2.swift file3.swift

# Generate module interface (textual API)
swiftc -emit-module-interface \
  -emit-module \
  -module-name MyLib \
  lib.swift
# Produces: MyLib.swiftinterface
```

### Output File Maps

For complex builds, output file maps specify where each compilation artifact should be placed.

```bash
# Create output file map (JSON format)
cat > output.json <<EOF
{
  "/src/foo.swift": {
    "object": "/build/foo.o",
    "dependencies": "/build/foo.d",
    "swift-dependencies": "/build/foo.swiftdeps",
    "diagnostics": "/build/foo.dia"
  },
  "/src/bar.swift": {
    "object": "/build/bar.o",
    "dependencies": "/build/bar.d",
    "swift-dependencies": "/build/bar.swiftdeps",
    "diagnostics": "/build/bar.dia"
  },
  "": {
    "swift-dependencies": "/build/main.swiftdeps"
  }
}
EOF

# Use output file map
swiftc -output-file-map output.json \
  -c /src/foo.swift /src/bar.swift

# Enable incremental compilation
swiftc -incremental \
  -output-file-map output.json \
  -c foo.swift bar.swift baz.swift
```

### Optimization Levels

```bash
# No optimization (fastest compilation)
swiftc -Onone main.swift

# Optimize for speed
swiftc -O main.swift

# Optimize for size
swiftc -Osize main.swift

# Whole module optimization
swiftc -O -whole-module-optimization \
  file1.swift file2.swift file3.swift

# Enable link-time optimization
swiftc -O -lto=llvm-full main.swift
```

## Swift Intermediate Language (SIL)

### Generating and Analyzing SIL

SIL is an SSA-form intermediate representation with high-level semantic information for optimization and analysis.

```bash
# Generate canonical SIL
swiftc -emit-sil -O source.swift -o optimized.sil

# Generate raw SIL (pre-optimization)
swiftc -emit-silgen source.swift -o raw.sil

# Parse and verify SIL file
swiftc -sil-verify-all input.sil

# Optimize SIL file
swiftc -emit-sil -O input.sil -o optimized.sil

# View specific SIL optimization passes
swiftc -emit-sil -Xllvm -sil-print-pass-name source.swift

# Debug SIL generation
swiftc -emit-silgen -Xllvm -sil-print-all source.swift
```

### SIL Structure Example

```sil
sil_stage canonical

import Swift

// Function declaration with ownership
sil @calculateSum : $@convention(thin) (Int, Int) -> Int {
bb0(%0 : $Int, %1 : $Int):
  %2 = builtin "add_Int64"(%0 : $Int, %1 : $Int) : $Int
  return %2 : $Int
}

// Class method with guaranteed ownership
sil @MyClass.method : $@convention(method) (@guaranteed MyClass) -> () {
bb0(%0 : @guaranteed $MyClass):
  %1 = ref_element_addr %0 : $MyClass, #MyClass.property
  %2 = load [copy] %1 : $*Int
  destroy_value %2 : $Int
  %3 = tuple ()
  return %3 : $()
}
```

## Testing

### Running Tests

The Swift test suite uses LLVM's lit testing framework for comprehensive validation.

```bash
# Run all tests during build
utils/build-script --test

# Run validation tests (more comprehensive)
utils/build-script --validation-test

# Run specific test directory
utils/run-test --build-dir build/Ninja-DebugAssert/swift-linux-x86_64 \
  test/Parse

# Run single test file
utils/run-test --build-dir build/Ninja-DebugAssert/swift-linux-x86_64 \
  test/Parse/errors.swift

# Use lit.py directly for more control
llvm/utils/lit/lit.py -sv \
  build/Ninja-DebugAssert/swift-macosx-x86_64/test-macosx-x86_64/Parse/

# Run tests with filter
llvm/utils/lit/lit.py -sv \
  --filter=generic \
  build/Ninja-DebugAssert/swift-linux-x86_64/test-linux-x86_64/

# Run long tests (skipped by default)
utils/build-script --test --long-test

# Run stress tests
utils/build-script --test --stress-test

# Run tests with specific configuration
llvm/utils/lit/lit.py -sv \
  --param swift_site_config=build/test-macosx-x86_64/lit.site.cfg \
  test/Parse/

# Verbose test output with timing
llvm/utils/lit/lit.py -sv --time-tests \
  build/Ninja-DebugAssert/swift-macosx-x86_64/test-macosx-x86_64/
```

### Writing Tests

```swift
// RUN: %target-swift-frontend -typecheck %s -verify

// Test type checking with expected diagnostics
func testFunction() {
  let x: Int = "string" // expected-error {{cannot convert value of type 'String' to specified type 'Int'}}

  var y: String
  y = 42 // expected-error {{cannot assign value of type 'Int' to type 'String'}}
}

// Test with multiple RUN lines
// RUN: %target-swift-frontend -emit-sil %s | %FileCheck %s
// CHECK-LABEL: sil @$testOptimization
// CHECK: builtin "add_Int64"
// CHECK: return
func testOptimization(a: Int, b: Int) -> Int {
  return a + b
}

// Test requiring specific features
// REQUIRES: asserts
// REQUIRES: objc_interop
// XFAIL: linux

import Foundation

func testObjCInterop() {
  let str = NSString(string: "test")
}
```

## Development Tools

### Debugging the Compiler

```bash
# Build with debug info
utils/build-script --debug-swift --assertions

# Run compiler under LLDB
lldb -- swiftc test.swift
(lldb) run
(lldb) bt

# Debug specific frontend invocation
lldb -- swift -frontend -c test.swift
(lldb) breakpoint set --name swift::TypeChecker::typeCheckDecl
(lldb) run

# Print AST during compilation
swiftc -dump-ast test.swift

# Print parsed AST (before type checking)
swiftc -dump-parse test.swift

# Print type-checked AST
swiftc -dump-type-checked test.swift

# Print SIL statistics
swiftc -emit-sil -Xllvm -sil-print-stats test.swift

# Debug type checking
swiftc -Xfrontend -debug-constraints test.swift

# Measure compilation time
swiftc -Xfrontend -debug-time-compilation test.swift

# Trace generic signature computation
swiftc -Xfrontend -debug-generic-signatures test.swift
```

### Code Analysis Tools

```bash
# Generate dependency graph
swiftc -emit-dependencies main.swift -o main.d

# Show incremental dependencies
swiftc -incremental \
  -emit-dependencies-path deps.d \
  -serialize-diagnostics-path diags.dia \
  -c main.swift

# Run static analyzer
swiftc -Xfrontend -analyze main.swift

# Check for undefined behavior
swiftc -sanitize=address main.swift
swiftc -sanitize=thread main.swift
swiftc -sanitize=undefined main.swift

# Profile-guided optimization
swiftc -profile-generate main.swift -o main
./main  # Generates default.profraw
xcrun llvm-profdata merge -output=default.profdata default.profraw
swiftc -profile-use=default.profdata -O main.swift -o main_optimized

# Code coverage
swiftc -profile-generate -profile-coverage-mapping main.swift -o main
./main
xcrun llvm-profdata merge -sparse default.profraw -o default.profdata
xcrun llvm-cov show main -instr-profile=default.profdata
```

## Refactoring Tools

### Swift Refactor

The `swift-refactor` tool provides IDE-like refactoring capabilities from the command line.

```bash
# List available refactoring actions
swift-refactor -dump-rewrite test.swift

# Extract function
swift-refactor -source-filename test.swift \
  -pos=10:5 \
  -end-pos=15:10 \
  -extract-function

# Rename symbol
swift-refactor -source-filename test.swift \
  -pos=5:10 \
  -rename "newName"

# Convert to computed property
swift-refactor -source-filename test.swift \
  -pos=8:5 \
  -convert-to-computed-property

# Localize string
swift-refactor -source-filename test.swift \
  -pos=12:15 \
  -localize-string

# Fill protocol stub
swift-refactor -source-filename test.swift \
  -pos=20:7 \
  -fill-protocol-stub

# Expand switch cases
swift-refactor -source-filename test.swift \
  -pos=25:3 \
  -expand-switch-cases

# Add Codable implementation
swift-refactor -source-filename test.swift \
  -pos=30:7 \
  -add-explicit-codable-implementation
```

## IDE Support Tools

### Swift IDE Test

```bash
# Code completion
swift-ide-test -code-completion \
  -source-filename test.swift \
  -pos=10:5

# Find USR (Unified Symbol Resolution)
swift-ide-test -print-usrs \
  -source-filename test.swift \
  -pos=5:10

# Print module interface
swift-ide-test -print-module \
  -module-to-print=Swift \
  -source-filename test.swift

# Find cursor info
swift-ide-test -cursor-info \
  -source-filename test.swift \
  -pos=8:12

# Print type tree
swift-ide-test -print-type-tree \
  -source-filename test.swift

# Reconstruct type from mangled name
swift-ide-test -reconstruct-type \
  -mangled='$s4Test9MyStructVD'

# Test semantic annotation
swift-ide-test -annotate \
  -source-filename test.swift \
  -pos=1:1
```

## Demangle and Symbol Tools

### Swift Demangle

```bash
# Demangle Swift symbols
echo '_$s4Test11MyNamespaceV6methodyyF' | swift-demangle
# Output: Test.MyNamespace.method() -> ()

# Demangle from file
swift-demangle < symbols.txt > demangled.txt

# Compact demangling
echo '_$s4Test6PersonV4nameSSvp' | swift-demangle -compact
# Output: Test.Person.name : Swift.String

# Tree format
echo '_$s4Test6PersonVACycfC' | swift-demangle -tree

# Batch processing
nm myapp | swift-demangle

# Demangle with types expanded
swift-demangle -expand '_$s4Test6PersonV'
```

### Swift Reflection Dump

```bash
# Dump reflection metadata
swift-reflection-dump myapp

# Dump specific sections
swift-reflection-dump -reflect-only myapp

# Examine binary metadata
swift-reflection-dump -section=__swift5_types myapp

# Show field descriptors
swift-reflection-dump -section=__swift5_fieldmd myapp

# Display type metadata
swift-reflection-dump -section=__swift5_typeref myapp
```

## Cross-Compilation

### Building for Different Platforms

```bash
# Cross-compile for Linux from macOS
swiftc -target x86_64-unknown-linux-gnu \
  -sdk /path/to/linux/sdk \
  main.swift

# Cross-compile for Windows
swiftc -target x86_64-unknown-windows-msvc \
  -sdk /path/to/windows/sdk \
  main.swift

# Cross-compile for ARM64
swiftc -target arm64-apple-macosx \
  main.swift

# Specify deployment target
swiftc -target x86_64-apple-macosx10.15 \
  main.swift

# Build universal binary (macOS)
swiftc -target x86_64-apple-macosx \
  main.swift -o main_x86_64
swiftc -target arm64-apple-macosx \
  main.swift -o main_arm64
lipo -create main_x86_64 main_arm64 -output main_universal

# Cross-compile SDK
utils/build-script \
  --cross-compile-hosts=android-armv7 \
  --android-ndk=/path/to/ndk \
  --android-api-level=21
```

## C++ Interoperability

### Using C++ from Swift

```bash
# Enable C++ interop
swiftc -cxx-interoperability-mode=default \
  -I /path/to/cpp/headers \
  main.swift cppcode.cpp

# Generate bridging header
swiftc -cxx-interoperability-mode=default \
  -import-objc-header bridge.h \
  main.swift

# Use C++ standard library
swiftc -cxx-interoperability-mode=default \
  -Xcc -std=c++17 \
  main.swift
```

Example interop:

```swift
// Using C++ types in Swift
import CxxStdlib

func processCppVector() {
  var vec = std.vector<Int32>()
  vec.push_back(1)
  vec.push_back(2)
  vec.push_back(3)

  for i in 0..<vec.size() {
    print(vec[Int(i)])
  }
}

// Calling C++ functions
import MyCppLibrary

func useCppAPI() {
  let result = MyCppLibrary.computeValue(42)
  let obj = MyCppLibrary.MyClass()
  obj.doSomething()
}
```

## Swift Macros System

### Overview

Swift macros enable compile-time metaprogramming by transforming source code during compilation. Macros are implemented as separate programs that communicate with the compiler via the plugin server infrastructure.

### Using Built-in Macros

```swift
// Observable macro for reactive programming
import Observation

@Observable
class Person {
  var name: String = ""
  var age: Int = 0
}

// Usage with SwiftUI or other observation clients
let person = Person()
withObservationTracking {
  print(person.name)
} onChange: {
  print("Name changed!")
}

// OptionSet macro for enum-like option sets
@OptionSet<UInt8>
struct ShippingOptions {
  private enum Options: Int {
    case nextDay
    case secondDay
    case priority
    case standard
  }
}

let options: ShippingOptions = [.nextDay, .priority]
```

### Building Macro Plugins

```bash
# Create a macro package
mkdir MyMacros
cd MyMacros

# Package.swift structure for macro plugin
cat > Package.swift <<EOF
// swift-tools-version: 5.9
import PackageDescription
import CompilerPluginSupport

let package = Package(
  name: "MyMacros",
  platforms: [.macOS(.v10_15)],
  products: [
    .library(name: "MyMacros", targets: ["MyMacros"]),
  ],
  dependencies: [
    .package(url: "https://github.com/apple/swift-syntax.git", from: "509.0.0"),
  ],
  targets: [
    .macro(
      name: "MyMacrosPlugin",
      dependencies: [
        .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
        .product(name: "SwiftCompilerPlugin", package: "swift-syntax")
      ]
    ),
    .target(name: "MyMacros", dependencies: ["MyMacrosPlugin"]),
  ]
)
EOF

# Build macro plugin
swift build

# Test macro expansion
swiftc -load-plugin-library .build/debug/libMyMacrosPlugin.dylib \
  -parse-as-library \
  test.swift
```

### Implementing a Custom Macro

```swift
// MyMacrosPlugin/MyMacro.swift
import SwiftSyntax
import SwiftSyntaxMacros
import SwiftCompilerPlugin

@main
struct MyMacrosPlugin: CompilerPlugin {
  let providingMacros: [Macro.Type] = [
    StringifyMacro.self,
  ]
}

public struct StringifyMacro: ExpressionMacro {
  public static func expansion(
    of node: some FreestandingMacroExpansionSyntax,
    in context: some MacroExpansionContext
  ) throws -> ExprSyntax {
    guard let argument = node.argumentList.first?.expression else {
      throw MacroError.missingArgument
    }

    let argString = argument.description
    return "(\(argument), \(literal: argString))"
  }
}

// Usage in client code
let result = #stringify(1 + 2)  // Expands to: (1 + 2, "1 + 2")
```

### Testing Macro Expansion

```bash
# View macro expansion
swiftc -Xfrontend -dump-macro-expansions test.swift

# Debug macro expansion
swiftc -Xfrontend -load-plugin-library \
  -Xfrontend .build/debug/libMyMacrosPlugin.dylib \
  -Xfrontend -dump-macro-expansions \
  test.swift

# Test macro plugin server communication
swift-plugin-server --help
```

## Distributed Actors Framework

### Overview

Distributed actors extend Swift's actor model to enable distributed computing across process and machine boundaries with location transparency.

### Basic Distributed Actor Usage

```swift
import Distributed

distributed actor Calculator {
  distributed func add(_ a: Int, _ b: Int) -> Int {
    return a + b
  }

  distributed func multiply(_ a: Int, _ b: Int) -> Int {
    return a * b
  }
}

// Using distributed actors with an actor system
func performDistributedCalculation() async throws {
  let system = LocalTestingDistributedActorSystem()

  let calc = Calculator(actorSystem: system)
  let result = try await calc.add(5, 3)
  print("Result: \(result)")

  // Can be called from remote nodes
  let remoteCalc = try Calculator.resolve(id: someID, using: system)
  let remoteResult = try await remoteCalc.multiply(4, 7)
}
```

### Implementing a Custom Actor System

```swift
import Distributed

struct MyDistributedActorSystem: DistributedActorSystem {
  typealias ActorID = String
  typealias InvocationEncoder = MyEncoder
  typealias InvocationDecoder = MyDecoder
  typealias SerializationRequirement = Codable

  func resolve<Act>(id: ActorID, as actorType: Act.Type) throws -> Act?
    where Act: DistributedActor {
    // Resolve actor by ID from registry or network
    return resolveFromNetwork(id: id, type: actorType)
  }

  func assignID<Act>(_ actorType: Act.Type) -> ActorID
    where Act: DistributedActor {
    // Generate unique ID for new actor
    return UUID().uuidString
  }

  func actorReady<Act>(_ actor: Act) where Act: DistributedActor {
    // Register actor in system
    register(actor)
  }

  func resignID(_ id: ActorID) {
    // Cleanup when actor terminates
    unregister(id)
  }
}
```

### Building Distributed Systems

```bash
# Compile distributed actor code
swiftc -emit-executable \
  -module-name DistributedApp \
  -import-distributed \
  main.swift calculator.swift

# Run with distributed actor system
./DistributedApp --node-id=worker1 --port=8080

# View distributed actor metadata
swift-reflection-dump --distributed-actors myapp
```

## Observation Framework

### Using the Observation Framework

The `@Observable` macro provides automatic observation tracking for property changes in classes.

```swift
import Observation

@Observable
class ShoppingCart {
  var items: [String] = []
  var totalPrice: Double = 0.0

  func addItem(_ item: String, price: Double) {
    items.append(item)
    totalPrice += price
  }
}

// Observe changes to properties
let cart = ShoppingCart()

withObservationTracking {
  // Access observed properties
  print("Items: \(cart.items.count)")
  print("Total: $\(cart.totalPrice)")
} onChange: {
  // Called when any accessed property changes
  print("Cart updated!")
}

// Integrate with async sequences
for await _ in ObservationStream(of: cart) {
  print("Cart changed: \(cart.items.count) items")
}
```

### SwiftUI Integration

```swift
import SwiftUI
import Observation

@Observable
class AppState {
  var isLoading = false
  var userData: UserData?
  var errorMessage: String?
}

struct ContentView: View {
  @State private var state = AppState()

  var body: some View {
    VStack {
      if state.isLoading {
        ProgressView()
      } else if let user = state.userData {
        Text("Hello, \(user.name)")
      }
    }
    .task {
      await loadUserData()
    }
  }

  func loadUserData() async {
    state.isLoading = true
    // Load data...
    state.isLoading = false
  }
}
```

### Manual Observation Registration

```swift
import Observation

class DataModel {
  @ObservationTracked var value: Int = 0

  // Manually control observation
  private let _$observationRegistrar = ObservationRegistrar()

  internal nonisolated func access<Member>(
    keyPath: KeyPath<DataModel, Member>
  ) {
    _$observationRegistrar.access(self, keyPath: keyPath)
  }

  internal nonisolated func withMutation<Member, T>(
    keyPath: KeyPath<DataModel, Member>,
    _ mutation: () throws -> T
  ) rethrows -> T {
    try _$observationRegistrar.withMutation(of: self, keyPath: keyPath, mutation)
  }
}
```

## Plugin System

### Swift Plugin Server

The plugin server enables compiler extensibility through macro processors, custom diagnostics, and code generation.

```bash
# Start plugin server manually
swift-plugin-server

# Query plugin capabilities
swift-plugin-server --query-capabilities

# Load and test a plugin
swift-plugin-server \
  --plugin-path=.build/debug/libMyPlugin.dylib \
  --test-message='{"macro": "stringify", "args": ["1 + 2"]}'
```

### Creating Diagnostic Plugins

```swift
import SwiftDiagnostics
import SwiftSyntax
import SwiftSyntaxBuilder

struct CustomDiagnostic: DiagnosticMessage {
  let message: String
  let diagnosticID: MessageID
  let severity: DiagnosticSeverity

  init(message: String, severity: DiagnosticSeverity = .warning) {
    self.message = message
    self.severity = severity
    self.diagnosticID = MessageID(domain: "CustomPlugin", id: "custom")
  }
}

struct DiagnosticPlugin: CompilerPlugin {
  func analyze(syntax: SourceFileSyntax) -> [Diagnostic] {
    var diagnostics: [Diagnostic] = []

    // Analyze syntax tree and generate diagnostics
    for node in syntax.statements {
      if let problem = checkForProblem(node) {
        let diagnostic = Diagnostic(
          node: Syntax(node),
          message: CustomDiagnostic(message: problem)
        )
        diagnostics.append(diagnostic)
      }
    }

    return diagnostics
  }
}
```

### Plugin Development Workflow

```bash
# Build plugin with debugging
swift build -c debug --product MyPlugin

# Test plugin with compiler
swiftc -load-plugin-library .build/debug/libMyPlugin.dylib \
  -Xfrontend -plugin-path \
  -Xfrontend .build/debug \
  test.swift

# Debug plugin execution
lldb -- swift-plugin-server \
  --plugin-path=.build/debug/libMyPlugin.dylib
(lldb) b MyPlugin.swift:42
(lldb) run

# Install plugin for system-wide use
cp .build/release/libMyPlugin.dylib \
  /usr/local/lib/swift/host/plugins/
```

## Swift Inspect Tool

### Runtime Inspection

The `swift-inspect` tool provides deep runtime introspection for debugging Swift programs.

```bash
# Inspect running process
swift-inspect --pid=12345

# Dump object at memory address
swift-inspect --pid=12345 --address=0x7fff5fc0a0b0

# Inspect all objects of a type
swift-inspect --pid=12345 --type="MyApp.User"

# Show class hierarchy
swift-inspect --pid=12345 --class-hierarchy

# Dump heap snapshot
swift-inspect --pid=12345 --heap-snapshot --output=heap.json

# Query specific property values
swift-inspect --pid=12345 \
  --address=0x7fff5fc0a0b0 \
  --property=name

# Inspect distributed actor state
swift-inspect --pid=12345 --distributed-actors
```

### Remote Debugging

```bash
# Attach to remote process
swift-inspect --remote-host=10.0.1.5 \
  --remote-pid=9876 \
  --remote-port=8022

# Inspect iOS device process
swift-inspect --device-id=<udid> \
  --bundle-id=com.example.myapp \
  --inspect-memory

# View actor states in distributed system
swift-inspect --pid=12345 \
  --show-actors \
  --filter-type=distributed
```

### Integration with LLDB

```bash
# Use within LLDB session
(lldb) process attach --pid 12345
(lldb) command script import lldb.swift-inspect
(lldb) swift-inspect --current-frame

# Inspect variables
(lldb) swift-inspect variable myObject
# Show metadata
(lldb) swift-inspect metadata MyClass

# Debug Swift Concurrency
(lldb) swift-inspect --show-tasks
(lldb) swift-inspect --task-dump=all
```

## Standard Library Extensions

### Synchronization Primitives

```swift
import Synchronization

// Atomic values
let counter = Atomic<Int>(0)
counter.wrappingAdd(1, ordering: .sequentiallyConsistent)
let value = counter.load(ordering: .acquiring)

// Mutex for thread-safe access
let mutex = Mutex<[String]>([])
mutex.withLock { array in
  array.append("item")
}

// Condition variables
let condition = ConditionLock<Bool>(false)
condition.withLock { ready in
  while !ready {
    condition.wait()
  }
}
```

### Regular Expressions

```swift
import RegexBuilder

// Regex builder DSL
let emailRegex = Regex {
  OneOrMore(.word)
  "@"
  OneOrMore(.word)
  "."
  Repeat(2...3) { .word }
}

// Pattern matching
let text = "Contact: user@example.com"
if let match = text.firstMatch(of: emailRegex) {
  print("Found email: \(match.0)")
}

// Complex patterns with capture groups
let logPattern = Regex {
  Capture { OneOrMore(.digit) }  // Timestamp
  " "
  Capture { ChoiceOf {
    "ERROR"
    "WARN"
    "INFO"
  }}
  " "
  Capture { OneOrMore(.any) }  // Message
}
```

### String Processing

```swift
import StringProcessing

let text = "Hello, World! Swift is awesome."

// Advanced string algorithms
let words = text.split(separator: " ")
let filtered = text.filter { $0.isLetter }

// Unicode handling
for scalar in text.unicodeScalars {
  print("\(scalar): \(scalar.properties.isEmoji)")
}

// String localization
import Foundation
let localized = String(localized: "greeting.hello",
                       defaultValue: "Hello")
```

### Concurrency Enhancements

```bash
# Build with concurrency checking
swiftc -Xfrontend -strict-concurrency=complete main.swift

# Enable actor data-race safety
swiftc -Xfrontend -enable-actor-data-race-checks main.swift
```

```swift
import _Concurrency

// Task local values
enum RequestID {
  @TaskLocal static var current: String?
}

func handleRequest() async {
  RequestID.$current.withValue("req-123") {
    await processRequest()
  }
}

// Async sequences
for await value in AsyncStream<Int> { continuation in
  Task {
    for i in 1...10 {
      continuation.yield(i)
      try await Task.sleep(for: .milliseconds(100))
    }
    continuation.finish()
  }
}
```

## Runtime Module and Backtrace Support

### Runtime Backtrace Capture

Swift 6.2 introduces the Runtime module with backtrace capture capabilities for error diagnostics and debugging.

```swift
import Runtime

// Capture backtrace at runtime
func captureStackTrace() {
  let backtrace = Backtrace.capture()

  // Print formatted backtrace
  print(backtrace)

  // Access individual frames
  for frame in backtrace.frames {
    if let symbol = frame.symbol {
      print("Function: \(symbol)")
    }
    if let location = frame.sourceLocation {
      print("Location: \(location.file):\(location.line)")
    }
  }
}

// Automatic backtrace on errors
func processData() throws {
  guard let data = loadData() else {
    let context = Backtrace.capture()
    throw DataError.notFound(backtrace: context)
  }
}

// Custom error with backtrace
struct DetailedError: Error {
  let message: String
  let backtrace: Backtrace

  init(_ message: String, captureBacktrace: Bool = true) {
    self.message = message
    self.backtrace = captureBacktrace ? Backtrace.capture() : .empty
  }
}
```

### Backtrace Configuration

```bash
# Build with backtrace support
swiftc -Xfrontend -enable-backtrace-on-crash main.swift

# Configure backtrace depth
swiftc -Xfrontend -backtrace-limit=50 main.swift

# Debug with enhanced backtrace info
swiftc -g -Xfrontend -enable-backtrace-on-crash main.swift
```

## Embedded Swift

### Developing for Embedded Systems

Swift supports embedded systems development with minimal runtime requirements and direct hardware access.

```bash
# Build for embedded target
swiftc -target armv7em-none-none-eabi \
  -enable-experimental-feature Embedded \
  -wmo \
  main.swift

# Build with no standard library
swiftc -target armv7em-none-none-eabi \
  -enable-experimental-feature Embedded \
  -parse-as-library \
  -wmo \
  -Xfrontend -disable-stack-protector \
  embedded.swift

# Optimize for size (embedded)
swiftc -target armv7em-none-none-eabi \
  -enable-experimental-feature Embedded \
  -Osize \
  -wmo \
  main.swift
```

### Embedded Swift Example

```swift
// Minimal embedded Swift program
@_silgen_name("main")
func main() -> Int32 {
  // Direct hardware access
  let GPIO_BASE: UInt32 = 0x4000_0000
  let gpio = UnsafeMutablePointer<UInt32>(bitPattern: UInt(GPIO_BASE))

  // Toggle LED
  gpio?.pointee |= 1 << 5

  return 0
}

// No heap allocations in embedded mode
struct EmbeddedController {
  var state: UInt8

  mutating func update() {
    // Stack-only operations
    state = (state + 1) & 0xFF
  }
}
```

## Advanced Concurrency Features

### Task Priority and Execution Control

Swift 6.2 introduces enhanced concurrency control with immediate task execution and priority escalation.

```swift
import _Concurrency

// Immediate task execution (SE-0472)
await Task.immediate {
  // Runs synchronously if possible, avoiding suspension
  await quickOperation()
}

// Named tasks for debugging (SE-0469)
Task(name: "DataFetcher") {
  await fetchUserData()
}

// Query task name
if let name = Task.currentName {
  print("Running task: \(name)")
}

// Priority escalation handler (SE-0462)
actor PriorityManager {
  var tasks: [Task<Void, Never>] = []

  func registerEscalation() {
    Task.onPriorityEscalation { oldPriority, newPriority in
      print("Priority escalated from \(oldPriority) to \(newPriority)")
      // Respond to priority changes
    }
  }
}

// Nonisolated(nonsending) execution (SE-0461)
actor DataStore {
  var data: [String: Int] = [:]

  nonisolated(nonsending) func readValue(key: String) -> Int? {
    // Can be called without awaiting, but restricted to non-sending types
    return data[key]
  }
}

// Isolated deinit (SE-0471)
actor ResourceManager {
  var resources: [Resource]

  isolated deinit {
    // Cleanup runs on actor's executor
    for resource in resources {
      resource.close()
    }
  }
}
```

### Actor-Isolated Protocol Conformances

```swift
// SE-0470: Actor-isolated protocol conformances
protocol DataSource {
  func fetchData() async -> Data
}

actor RemoteDataSource: DataSource {
  // Automatically actor-isolated
  func fetchData() async -> Data {
    // Implementation runs on actor
    return await networkFetch()
  }
}

// Use with type-safe isolation
func processSource<T: DataSource>(_ source: T) async {
  let data = await source.fetchData()
  process(data)
}
```

### Strict Memory Safety Mode

```bash
# Enable strict memory safety (SE-0458)
swiftc -strict-memory-safety main.swift

# Diagnose potential memory safety issues
swiftc -Xfrontend -warn-memory-safety main.swift

# Full checking with sanitizers
swiftc -strict-memory-safety \
  -sanitize=address,thread \
  main.swift
```

## Module Selectors

### Using Module Selectors for Disambiguation

Module selectors allow you to specify which module Swift should look inside to find a named declaration, resolving ambiguities in multi-module projects.

```swift
// Qualify types with module selectors
import SwiftUI
import MyCustomUI

// Use SwiftUI's View, not MyCustomUI's View
struct MyView: SwiftUI::View {
  var body: some View {
    Text("Hello")
  }
}

// Qualify method calls with module selectors
import Foundation

let text = "example string"
// Call Foundation's data(using:) method specifically
let data = text.Foundation::data(using: .utf8)

// Qualify standard library types explicitly
func createTask() {
  Swift.Task {
    // Task from Swift standard library
    await performWork()
  }
}

// Use with Regex and other string processing
func match(_ pattern: Swift.Regex<(Substring)>) {
  // Regex from Swift standard library
}
```

### Module Selector Rules

```swift
// Module selectors skip enclosing scopes
struct Container {
  func method() {
    // Local declarations cannot be found with module selectors
    let local = 42
    // Swift::local // Error: cannot use module selector for local
  }
}

// Cannot use in where clauses for associated types
protocol MyProtocol {
  associatedtype Value
}

// func generic<T: MyProtocol>(value: T) where Swift::Value == Int {}
// Error: module selectors not allowed in where clauses
```

### Building with Module Selectors in Interfaces

```bash
# Enable module selectors in module interface files
swiftc -emit-module \
  -module-name MyLibrary \
  -enable-module-selectors-in-module-interface \
  source.swift

# This improves robustness when module name matches type name
swiftc -emit-module-interface \
  -enable-module-selectors-in-module-interface \
  -module-name User \
  User.swift
```

## SwiftCompilerSources Architecture

### Compiler Bootstrap Evolution

The Swift compiler is undergoing architectural evolution with core components being rewritten in Swift alongside the traditional C++ implementation.

```bash
# Build with Swift compiler sources
utils/build-script \
  --bootstrapping=off \
  --swift-compiler-sources

# Build with hosttools bootstrapping
utils/build-script \
  --bootstrapping=hosttools

# Full bootstrapping build
utils/build-script \
  --bootstrapping=bootstrapping

# Bootstrapping with host libraries
utils/build-script \
  --bootstrapping=bootstrapping-with-hostlibs
```

### Swift-Written Compiler Components

The SwiftCompilerSources directory contains:
- **SIL** - Swift Intermediate Language implementation in Swift
- **Optimizer** - Optimization passes written in Swift
- **AST** - Abstract syntax tree manipulation
- **Basic** - Fundamental compiler utilities

This enables:
- Faster compiler development cycles
- Better type safety in compiler code
- Improved compiler performance
- Easier contribution for Swift developers

## Summary and Integration

The Swift compiler toolchain provides a complete development environment for building high-performance, memory-safe applications across multiple platforms, from cloud-scale distributed systems to resource-constrained embedded devices. The build system supports incremental compilation with sophisticated dependency tracking, enabling fast edit-compile-debug cycles even in large codebases. The driver orchestrates parallel frontend jobs, module merging, and linking while the SIL optimizer applies aggressive optimizations guided by high-level language semantics. Testing infrastructure built on LLVM lit ensures compiler correctness through thousands of functional and regression tests. Modern features like the macro system enable powerful compile-time metaprogramming, distributed actors provide first-class support for building scalable distributed systems with location transparency, the new Runtime module offers comprehensive backtrace capture for enhanced error diagnostics, and module selectors provide precise control over symbol resolution in multi-module projects.

Integration patterns center around the modular architecture where `build-script` orchestrates CMake-based builds with optional Swift-based compiler bootstrapping through SwiftCompilerSources. The driver manages compilation units with output file maps for precise artifact control, and IDE tools provide language services through `swift-ide-test` and SourceKit. The plugin system enables compiler extensibility through custom macros and diagnostics processors, with `swift-plugin-server` managing plugin communication. Cross-compilation support enables building for diverse targets from a single development host, including embedded systems with minimal runtime requirements. Advanced C++ interoperability with PrintAsClang infrastructure allows seamless bidirectional integration with existing codebases. The observation framework provides reactive programming capabilities natively integrated with SwiftUI, while the standard library's synchronization primitives offer thread-safe concurrent programming patterns. Enhanced concurrency features in Swift 6.2 include immediate task execution, named tasks for debugging, priority escalation handlers, and actor-isolated protocol conformances with strict memory safety guarantees. Module selectors enable disambiguation of declarations in complex multi-module projects using the `::` syntax to explicitly specify the source module. Runtime introspection tools like `swift-inspect` enable deep debugging of memory layouts, actor states, and distributed systems, while refactoring tools enable safe code transformations at scale. This comprehensive toolchain supports everything from embedded systems programming to large-scale distributed application development with consistent tooling and optimization across all deployment targets.