Generated

import Foundation
import Testing

let r = /ab(\d)+c/
let x = 5

let a = "test \n \r \\ \' \""



/// A comprehensive syntax test for Swift
public class SyntaxManifest<T: Codable> where T: Equatable {
    
    // MARK: - Properties
    public let id: UUID = UUID()
    private(set) var value: T?
    static var version: String { "1.0.0" }
    
    // MARK: - Initialization
    public init(value: T?) {
        self.value = value
    }
}

// MARK: - Protocols & Extensions
protocol Actionable: AnyObject {
    associatedtype Element
    func perform(_ action: Element) async throws -> Bool
}

extension SyntaxManifest: Actionable where T == String {
    typealias Element = String
    
    /// Exercises Concurrency and Error Handling
    func perform(_ action: String) async throws -> Bool {
        guard !action.isEmpty else { throw GeneralError.empty }
        
        let task = Task {
            print("Processing: \(action)")
            return true
        }
        
        return try await task.value
    }
}

// MARK: - Enums & Pattern Matching
enum GeneralError: Error {
    case empty
    case unknown(code: Int)
}

func testPatternMatching(error: GeneralError) {
    switch error {
    case .empty:
        print("Empty")
    case .unknown(let code) where code > 500:
        print("Server Error: \(code)")
    default:
        break
    }
}

// MARK: - Advanced Features
@resultBuilder
struct ListBuilder {
    static func buildBlock(_ parts: String...) -> String {
        parts.joined(separator: ", ")
    }
}

func createList(@ListBuilder _ content: () -> String) {
    print(content())
}

// MARK: - Macros & Interpolation
func demonstrateSyntax() {
    let rawString = #"This is a "raw" string with \no escapes required."#
    let multiLine = """
        Line 1
        Line 2 \(1 + 1)
        """
    
    // Keypath and Function Pointer
    let keyPath = \SyntaxManifest<String>.id
    let fn = testPatternMatching(error:)
    
    // Testing Operator Overloading
    let combined = [1, 2] + [3]
    
    #if DEBUG
    print("Debug mode active")
    #endif
}

// MARK: - Defer and Scope
func scopeTest() {
    defer { print("Cleanup") }
    for i in 0..<10 where i % 2 == 0 {
        print(i)
    }
}

/// MARK: - Semantic Token Stress Test

// Semantic distinction: Class (Type) vs. Actor (Type)
final class DataManager {
    // static let shared = DataManager()
    var count: Int = 0
}

actor Coordinator {
    // LSP distinction: 'nonisolated' modifier and 'async' context
    nonisolated let id = UUID()
    
    // Semantic token: property (member)
    var state: String = "Idle"
}

// MARK: - Protocols and Associated Types
protocol Contextualizable {
    associatedtype Context
    // Semantic token: function (member) inside protocol
    func apply(context: Context)
}

// MARK: - Generic Structure with Shadowing
struct Processor<Element: Numeric> {
    
    // Semantic distinction: Variable 'value' vs. Parameter 'value'
    var value: Element
    
    init(value: Element) {
        // SourceKit-LSP identifies 'self.value' as a property
        // and 'value' as a local parameter.
        self.value = value
    }
    
    // MARK: - Method Overloading
    func process(_ input: Element) -> Element {
        let multiplier: Element = 2 // Local variable
        return input * multiplier
    }
    
    func process(_ input: [Element]) -> [Element] {
        // Highlighting 'map' as a function/method
        return input.map(process) 
    }
}

// MARK: - Global Scope & Operators
let globalConstant = 42

// Custom Operator: Semantic token 'operator'
infix operator <->: MultiplicationPrecedence

func <-> (lhs: Int, rhs: Int) -> Int {
    return (lhs * rhs) - globalConstant
}

// MARK: - Usage & Call Sites
func execute() async {
    // LSP Token: 'Processor' (Type), '<Int>' (Type Argument)
    let processor = Processor(value: 10)
    
    // Semantic distinction: Method call vs Property access
    let result = processor.process(5)
    print(processor.value)
    
    // Token: 'MainActor' (Global Actor attribute)
    await MainActor.run {
        print("UI Update with \(result)")
    }

    let test1 = 5 <-> 3
    let test2 = 5 + 3

    
    // KeyPath Semantic Tokens
    let path = \Processor<Int>.value
}

// MARK: - Macro Expansion
// Macros generate specific semantic tokens for the '#' identifier
#sourceLocation(file: "test.swift", line: 100)

#if DEBUG
let y = 3
#else 
let y = 5
#endif

func test(x xL: Int, y yL: Int) -> Int { return 0 }

let z = test(x: 5, y: 3)

@freestanding(expression)
public macro testMacro<T: ExpressibleByIntegerLiteral>() -> T = #externalMacro(module: "ter", type: "dfgdfg")

@Test
func testExpect() {
    #expect(z == x)
}