Merge pull request #1816 from DougGregor/if-config

SwiftIfConfig: A library to evaluate `#if` conditionals within a Swift syntax tree.

Author: DougGregor

.spi.yml

@@ -12,6 +12,7 @@ builder:
       - SwiftCompilerPlugin
       - SwiftDiagnostics
       - SwiftIDEUtils
+      - SwiftIfConfig
       - SwiftLexicalLookup
       - SwiftOperators
       - SwiftParser

Package.swift

@@ -17,6 +17,7 @@ let package = Package(
     .library(name: "SwiftCompilerPlugin", targets: ["SwiftCompilerPlugin"]),
     .library(name: "SwiftDiagnostics", targets: ["SwiftDiagnostics"]),
     .library(name: "SwiftIDEUtils", targets: ["SwiftIDEUtils"]),
+    .library(name: "SwiftIfConfig", targets: ["SwiftIfConfig"]),
     .library(name: "SwiftLexicalLookup", targets: ["SwiftLexicalLookup"]),
     .library(name: "SwiftOperators", targets: ["SwiftOperators"]),
     .library(name: "SwiftParser", targets: ["SwiftParser"]),
@@ -138,6 +139,24 @@ let package = Package(
       dependencies: ["_SwiftSyntaxTestSupport", "SwiftIDEUtils", "SwiftParser", "SwiftSyntax"]
     ),
 
+    // MARK: SwiftIfConfig
+
+    .target(
+      name: "SwiftIfConfig",
+      dependencies: ["SwiftSyntax", "SwiftOperators"],
+      exclude: ["CMakeLists.txt"]
+    ),
+
+    .testTarget(
+      name: "SwiftIfConfigTest",
+      dependencies: [
+        "_SwiftSyntaxTestSupport",
+        "SwiftIfConfig",
+        "SwiftParser",
+        "SwiftSyntaxMacrosGenericTestSupport",
+      ]
+    ),
+
     // MARK: SwiftLexicalLookup
 
     .target(

Release Notes/600.md

@@ -133,7 +133,7 @@
   - Pull request: https://github.com/swiftlang/swift-syntax/pull/2433
 
 - `CanImportExprSyntax` and `CanImportVersionInfoSyntax`
-  - Description: Instead of parsing `canImport` inside `#if` directives as a special expression node, parse it as a functionc call expression. This is in-line with how the `swift(>=6.0)` and `compiler(>=6.0)` directives are parsed.
+  - Description: Instead of parsing `canImport` inside `#if` directives as a special expression node, parse it as a function call expression. This is in-line with how the `swift(>=6.0)` and `compiler(>=6.0)` directives are parsed.
   - Pull request: https://github.com/swiftlang/swift-syntax/pull/2025
 
 - `SyntaxClassifiedRange.offset`, `length` and `endOffset`

Release Notes/601.md

@@ -11,6 +11,10 @@
   - Description: Returns the node or the first ancestor that satisfies `condition`.
   - Pull Request: https://github.com/swiftlang/swift-syntax/pull/2696
 
+- `Error` protocol now has an `asDiagnostics(at:)` method.
+  - Description: This method translates an error into one or more diagnostics, recognizing `DiagnosticsError` and `DiagnosticMessage` instances or providing its own `Diagnostic` as needed.
+  - Pull Request: https://github.com/swiftlang/swift-syntax/pull/1816
+
 ## API Behavior Changes
 
 - `SyntaxProtocol.trimmed` detaches the node

Sources/CMakeLists.txt

@@ -16,6 +16,7 @@ add_subdirectory(SwiftParser)
 add_subdirectory(SwiftParserDiagnostics)
 add_subdirectory(SwiftRefactor)
 add_subdirectory(SwiftOperators)
+add_subdirectory(SwiftIfConfig)
 add_subdirectory(SwiftSyntaxBuilder)
 add_subdirectory(SwiftSyntaxMacros)
 add_subdirectory(SwiftSyntaxMacroExpansion)

Sources/SwiftDiagnostics/Diagnostic.swift

@@ -92,3 +92,38 @@ public struct DiagnosticsError: Error, Sendable {
     )
   }
 }
+
+/// Diagnostic message used for thrown errors.
+private struct DiagnosticFromError: DiagnosticMessage {
+  let error: Error
+  let severity: DiagnosticSeverity = .error
+
+  var message: String {
+    return String(describing: error)
+  }
+
+  var diagnosticID: MessageID {
+    .init(domain: "SwiftDiagnostics", id: "\(type(of: error))")
+  }
+}
+
+extension Error {
+  /// Given an error, produce an array of diagnostics reporting the error,
+  /// using the given syntax node as the location if it wasn't otherwise known.
+  ///
+  /// This operation will look for diagnostics of known type, such as
+  /// `DiagnosticsError` and `DiagnosticMessage` to retain information. If
+  /// none of those apply, it will produce an `error` diagnostic whose message
+  /// comes from rendering the error as a string.
+  public func asDiagnostics(at node: some SyntaxProtocol) -> [Diagnostic] {
+    if let diagnosticsError = self as? DiagnosticsError {
+      return diagnosticsError.diagnostics
+    }
+
+    if let message = self as? DiagnosticMessage {
+      return [Diagnostic(node: Syntax(node), message: message)]
+    }
+
+    return [Diagnostic(node: Syntax(node), message: DiagnosticFromError(error: self))]
+  }
+}