DiagnosticsTests.swift

import SwiftParser
import SwiftSyntax
import Testing

@testable import BridgeJSCore
@testable import BridgeJSSkeleton

@Suite struct DiagnosticsTests {
    /// Returns the first parameter's type node from a function in the source (the first `@JS func`-like decl), for pinpointing diagnostics.
    private func firstParameterTypeNode(source: String) -> TypeSyntax? {
        let tree = Parser.parse(source: source)
        for stmt in tree.statements {
            if let funcDecl = stmt.item.as(FunctionDeclSyntax.self),
                let firstParam = funcDecl.signature.parameterClause.parameters.first
            {
                return firstParam.type
            }
        }
        return nil
    }

    @Test
    func diagnosticIncludesLocationSourceAndHint() throws {
        let source = "@JS func foo(_ bar: A<X>) {}\n"
        let typeNode = try #require(firstParameterTypeNode(source: source))
        let diagnostic = DiagnosticError(
            node: typeNode,
            message: "Unsupported type 'A<X>'.",
            hint: "Only primitive types and types defined in the same module are allowed"
        )
        let description = diagnostic.formattedDescription(fileName: "-", colorize: false)
        let expectedPrefix = """
            <stdin>:1:21: error: Unsupported type 'A<X>'.
              1 | @JS func foo(_ bar: A<X>) {}
                |                     `- error: Unsupported type 'A<X>'.
              2 |
            """.trimmingCharacters(in: .whitespacesAndNewlines)
        #expect(description.hasPrefix(expectedPrefix))
        #expect(description.contains("Hint: Only primitive types and types defined in the same module are allowed"))
    }

    @Test
    func diagnosticOmitsHintWhenNotProvided() throws {
        let source = "@JS static func foo() {}\n"
        let tree = Parser.parse(source: source)
        let diagnostic = DiagnosticError(
            node: tree,
            message: "Top-level functions cannot be static",
            hint: nil
        )
        let description = diagnostic.formattedDescription(fileName: "-", colorize: false)
        let expectedPrefix = """
            <stdin>:1:1: error: Top-level functions cannot be static
              1 | @JS static func foo() {}
                | `- error: Top-level functions cannot be static
              2 |
            """.trimmingCharacters(in: .whitespacesAndNewlines)
        #expect(description.hasPrefix(expectedPrefix))
        #expect(!description.contains("Hint:"))
    }

    @Test
    func diagnosticUsesGivenFileNameNotStdin() throws {
        let source = "@JS func foo(_ bar: A<X>) {}\n"
        let typeNode = try #require(firstParameterTypeNode(source: source))
        let diagnostic = DiagnosticError(
            node: typeNode,
            message: "Unsupported type 'A<X>'.",
            hint: nil
        )
        let description = diagnostic.formattedDescription(fileName: "Sources/Foo.swift", colorize: false)
        #expect(description.hasPrefix("Sources/Foo.swift:1:21: error: Unsupported type 'A<X>'."))
    }

    @Test
    func diagnosticWithColorizeTrueIncludesANSISequences() throws {
        let source = "@JS func foo(_ bar: A<X>) {}\n"
        let typeNode = try #require(firstParameterTypeNode(source: source))
        let diagnostic = DiagnosticError(
            node: typeNode,
            message: "Unsupported type 'A<X>'.",
            hint: nil
        )
        let description = diagnostic.formattedDescription(fileName: "-", colorize: true)
        let esc = "\u{001B}"
        let boldRed = "\(esc)[1;31m"
        let boldDefault = "\(esc)[1;39m"
        let reset = "\(esc)[0;0m"
        let cyan = "\(esc)[0;36m"
        let underline = "\(esc)[4;39m"
        let expected =
            "<stdin>:1:21: \(boldRed)error: \(boldDefault)Unsupported type 'A<X>'.\(reset)\n"
            + "\(cyan)  1\(reset) | @JS func foo(_ bar: \(underline)A<X>\(reset)) {}\n"
            + "    |                     `- \(boldRed)error: \(boldDefault)Unsupported type 'A<X>'.\(reset)\n"
            + "\(cyan)  2\(reset) | "
        #expect(description == expected)
    }

    // MARK: - Context source lines

    @Test
    func showsOnePreviousLineWhenErrorNotOnFirstLine() throws {
        let source = """
            preamble
            @JS func foo(_ bar: A<X>) {}
            """
        let typeNode = try #require(firstParameterTypeNode(source: source))
        let diagnostic = DiagnosticError(node: typeNode, message: "Unsupported type 'A<X>'.", hint: nil)
        let description = diagnostic.formattedDescription(fileName: "-", colorize: false)
        #expect(description.contains("  1 | preamble"))
        #expect(description.contains("  2 | @JS func foo(_ bar: A<X>) {}"))
        #expect(description.contains("<stdin>:2:"))
    }

    @Test
    func showsThreePreviousLinesWhenAvailable() throws {
        let source = """
            first
            second
            third
            @JS func foo(_ bar: A<X>) {}
            """
        let typeNode = try #require(firstParameterTypeNode(source: source))
        let diagnostic = DiagnosticError(node: typeNode, message: "Unsupported type 'A<X>'.", hint: nil)
        let description = diagnostic.formattedDescription(fileName: "-", colorize: false)
        #expect(description.contains("  1 | first"))
        #expect(description.contains("  2 | second"))
        #expect(description.contains("  3 | third"))
        #expect(description.contains("  4 | @JS func foo(_ bar: A<X>) {}"))
        #expect(description.contains("<stdin>:4:"))
    }

    @Test
    func capsContextAtThreePreviousLines() throws {
        let source = """
            line0
            line1
            line2
            line3
            @JS func foo(_ bar: A<X>) {}
            """
        let typeNode = try #require(firstParameterTypeNode(source: source))
        let diagnostic = DiagnosticError(node: typeNode, message: "Unsupported type 'A<X>'.", hint: nil)
        let description = diagnostic.formattedDescription(fileName: "-", colorize: false)
        #expect(!description.contains("  1 | line0"))
        #expect(description.contains("  2 | line1"))
        #expect(description.contains("  3 | line2"))
        #expect(description.contains("  4 | line3"))
        #expect(description.contains("  5 | @JS func foo(_ bar: A<X>) {}"))
        #expect(description.contains("<stdin>:5:"))
    }

    @Test
    func includesNextLineAfterErrorLine() throws {
        let source = """
            @JS func foo(
              _ bar: A<X>
            ) {}
            """
        let typeNode = try #require(firstParameterTypeNode(source: source))
        let diagnostic = DiagnosticError(node: typeNode, message: "Unsupported type 'A<X>'.", hint: nil)
        let description = diagnostic.formattedDescription(fileName: "-", colorize: false)
        #expect(description.contains("  1 | @JS func foo("))
        #expect(description.contains("  2 |   _ bar: A<X>"))
        #expect(description.contains("  3 | ) {}"))
        #expect(description.contains("<stdin>:2:"))
    }

    // MARK: - Nested type validation

    @Test
    func nestedStructInsideClassSucceeds() throws {
        let source = """
            @JS class User {
                @JS struct Stats {
                    var health: Int
                }
            }
            """
        let swiftAPI = SwiftToSkeleton(
            progress: .silent,
            moduleName: "TestModule",
            exposeToGlobal: false,
            externalModuleIndex: .empty
        )
        swiftAPI.addSourceFile(Parser.parse(source: source), inputFilePath: "test.swift")
        let skeleton = try swiftAPI.finalize()
        #expect(skeleton.exported != nil)
        let structs = skeleton.exported?.structs ?? []
        #expect(structs.count == 1)
        #expect(structs.first?.swiftCallName == "User.Stats")
    }

    @Test
    func nestedClassInsideStructSucceeds() throws {
        let source = """
            @JS struct Container {
                var value: Int
                @JS class Inner {
                }
            }
            """
        let swiftAPI = SwiftToSkeleton(
            progress: .silent,
            moduleName: "TestModule",
            exposeToGlobal: false,
            externalModuleIndex: .empty
        )
        swiftAPI.addSourceFile(Parser.parse(source: source), inputFilePath: "test.swift")
        let skeleton = try swiftAPI.finalize()
        #expect(skeleton.exported != nil)
        let classes = skeleton.exported?.classes ?? []
        #expect(classes.count == 1)
        #expect(classes.first?.swiftCallName == "Container.Inner")
    }

    @Test
    func structInsideEnumNamespaceSucceeds() throws {
        let source = """
            @JS enum API {
                @JS struct Point {
                    var x: Double
                    var y: Double
                }
            }
            """
        let swiftAPI = SwiftToSkeleton(
            progress: .silent,
            moduleName: "TestModule",
            exposeToGlobal: false,
            externalModuleIndex: .empty
        )
        swiftAPI.addSourceFile(Parser.parse(source: source), inputFilePath: "test.swift")
        let skeleton = try swiftAPI.finalize()
        #expect(skeleton.exported != nil)
    }

    // MARK: - Struct init order validation

    @Test
    func structInitMismatchedOrderProducesDiagnostic() throws {
        let source = """
            @JS struct Animal {
                var size: Double
                var age: Int

                @JS init(age: Int, size: Double) {
                    self.age = age
                    self.size = size
                }
            }
            """
        let swiftAPI = SwiftToSkeleton(
            progress: .silent,
            moduleName: "TestModule",
            exposeToGlobal: false,
            externalModuleIndex: .empty
        )
        swiftAPI.addSourceFile(Parser.parse(source: source), inputFilePath: "test.swift")
        #expect(throws: BridgeJSCoreDiagnosticError.self) {
            _ = try swiftAPI.finalize()
        }
    }

    @Test
    func structInitMatchingOrderSucceeds() throws {
        let source = """
            @JS struct Point {
                var x: Double
                var y: Double

                @JS init(x: Double, y: Double) {
                    self.x = x
                    self.y = y
                }
            }
            """
        let swiftAPI = SwiftToSkeleton(
            progress: .silent,
            moduleName: "TestModule",
            exposeToGlobal: false,
            externalModuleIndex: .empty
        )
        swiftAPI.addSourceFile(Parser.parse(source: source), inputFilePath: "test.swift")
        let skeleton = try swiftAPI.finalize()
        #expect(skeleton.exported != nil)
    }

    @Test
    func structWithoutExplicitInitSucceeds() throws {
        let source = """
            @JS struct Point {
                var x: Double
                var y: Double
            }
            """
        let swiftAPI = SwiftToSkeleton(
            progress: .silent,
            moduleName: "TestModule",
            exposeToGlobal: false,
            externalModuleIndex: .empty
        )
        swiftAPI.addSourceFile(Parser.parse(source: source), inputFilePath: "test.swift")
        let skeleton = try swiftAPI.finalize()
        #expect(skeleton.exported != nil)
    }

    // MARK: - Async return validation

    @Test
    func asyncReturnOfUnsupportedTypeIsDiagnosed() throws {
        // Protocol existentials still can't be lowered through the imported-parameter ABI, so
        // an async return of one must still be diagnosed.
        let source = """
            @JS protocol PayloadDelegate {
                func notify()
            }
            @JS func loadPayload() async -> PayloadDelegate {
                fatalError()
            }
            """
        let swiftAPI = SwiftToSkeleton(
            progress: .silent,
            moduleName: "TestModule",
            exposeToGlobal: false,
            externalModuleIndex: .empty
        )
        swiftAPI.addSourceFile(Parser.parse(source: source), inputFilePath: "test.swift")
        let skeleton = try swiftAPI.finalize()
        let exported = try #require(skeleton.exported)
        let exportSwift = ExportSwift(progress: .silent, moduleName: skeleton.moduleName, skeleton: exported)
        #expect(throws: BridgeJSCoreError.self) {
            _ = try exportSwift.finalize()
        }
    }

    @Test
    func asyncReturnOfConvertibleTypeSucceeds() throws {
        let source = """
            @JS func loadCount() async -> Int {
                1
            }
            """
        let swiftAPI = SwiftToSkeleton(
            progress: .silent,
            moduleName: "TestModule",
            exposeToGlobal: false,
            externalModuleIndex: .empty
        )
        swiftAPI.addSourceFile(Parser.parse(source: source), inputFilePath: "test.swift")
        let skeleton = try swiftAPI.finalize()
        let exported = try #require(skeleton.exported)
        let exportSwift = ExportSwift(progress: .silent, moduleName: skeleton.moduleName, skeleton: exported)
        #expect(try exportSwift.finalize() != nil)
    }

    @Test
    func omitsNextLineWhenErrorIsOnLastLine() throws {
        let source = """
            preamble
            @JS func foo(_ bar: A<X>)
            """
        let typeNode = try #require(firstParameterTypeNode(source: source))
        let diagnostic = DiagnosticError(node: typeNode, message: "Unsupported type 'A<X>'.", hint: nil)
        let description = diagnostic.formattedDescription(fileName: "-", colorize: false)
        #expect(description.contains("  2 | @JS func foo(_ bar: A<X>)"))
        #expect(description.contains("<stdin>:2:"))
        // No line 3 in source, so output must not show a "  3 |" context line after the pointer
        #expect(!description.contains("  3 |"))
    }
}