Convert between computed properties and zero-parameters functions

[SwiftIfConfig] Add a new library for evaluating `#if` conditions.

Building on top of the parser and operator-precedence parsing library,
introduce a new library that evaluates `#if` conditions against a
particular build configuration. The build configuration is described
by the aptly named `BuildConfiguration` protocol, which has queries
for various build settings (e.g., configuration flags), compiler
capabilities (features and attributes), and target information (OS,
architecture, endianness, etc.).

At present, the only user-facing operation is the `IfConfigState`
initializer, which takes in an expression (the `#if` condition) and a
build configuration, then evaluates that expression against the build
condition to determine whether code covered by that condition is
active, inactive, or completely unparsed. This is a fairly low-level
API, meant to be a building block for more useful higher-level APIs
that query which `#if` clause is active and whether a particular syntax
node is active.

Add higher-level APIs for querying active code state

`IfConfigDeclSyntax.activeClause(in:)` determines which clause is
active within an `#if` syntax node.

`SyntaxProtocol.isActive(in:)` determines whether a given syntax node
is active in the program, based on the nested stack of `#if`
configurations.

Add support for evaluating `swift` and `compiler` conditionals

These were introduced by SE-0212.

Implement support for archaic `_compiler_version("X.Y.Z.W.V")` check

Add support for `canImport` configuration checks.

This is the last kind of check! Remove the `default` fallthrough from
the main evaluation function.

Improve documentation for `#if` configuration functions

Add `ActiveSyntax(Any)Visitor` visitor classes.

The `ActiveSyntax(Any)Visitor` visitor classes provide visitors that
only visit the regions of a syntax tree that are active according to
a particular build configuration, meaning that those nodes would be
included in a program that is built with that configuration.

Add/cleanup some TODO comments

Add an API to rewrite a syntax tree by removing inactive regions.

The operation `SyntaxProtocol.removingInactive(in:)` returns a syntax
tree derived from `self` that has removed all inactive syntax nodes based
on the provided configuration.

Implement inactive clause rewriting support for postfix `#if`

Postfix `#if` expressions have a different syntactic form than
other `#if` clauses because they don't fit into a list-like position in
the grammar. Implement a separate, recursive folding algorithm to handle
these clauses.

Add overview documentation for the SwiftIfConfig library

Add CMake build system for SwiftIfConfig

Format source

Improve documentation for BuildConfiguration

Improve documentation for internal `IfConfigFunctions`.

Address a number of review comments (thanks, Alex!)

[Build configuration] Drop optionality from protocol requirement result types

The optional return was used to mean "don't know", but was always
treated as false. Instead, make all of the result types non-optional,
and allow these operations to throw to indicate failure.

While here, drop the "syntax" parameters to all of these functions. We
shouldn't be working with syntax inside the build configuration.

Simplify `isActive(in:)` using Alex Hoppen's suggestion

Use preconditionFailure

Use editor placeholder for placeholder expression

Minor cleanups

Minor cleanups to the #if rewriter

Rework use of deprecated APIs

Teach active-clause visitors to handle diagnostics

When the active-clause visitors encounter an error during evaluation of
the `#if` conditions, translate the errors into diagnostics and and
visit all of the clauses (because we don't know which is active). This
behavior is configurable by ActiveSyntax(Any)Visitor subclasses.

Add SwiftIfConfig to the set of documentation targets

Fix typo in the release notes

Adapt to optionality changes on main

Add a method `Error.asDiagnostics(at:)` to unpack errors into diagnostics

This is a useful convenience function to handle cases where we have a
thrown error from some API and we want to translate it into a
diagnostic that we need to emit at a particular location.

Handle errors while removing inactive regions

When removing inactive regions via a visitor, accumulate any diagnostics
produced during this process so they can be reported. Introduce a test
harness so we can test these diagnostics more easily.

Handle diagnostics through #if condition evaluation

Allow #if condition evaluation to produce proper diagnostics, including
warnings, while performing the evaluation. This covers both
warnings/errors directly coming from #if handling and also those
thrown as errors by the build configuration.

Introduce assertion functions to make it a lot easier to properly test
the tests with calls to these assertions.

Add the remaining diagnostics that were FIXME'd because we couldn't
report them properly before.

Teach #if condition evaluation to reason about "versioned" checks

When a check is "versioned" and fails, we allow the failed #if block to
have syntactic errors in it. Start to reflect this distinction when
determining the `IfConfigState` for a particular condition, so that we
finally use the "unparsed" case.

Rework `isActive(in: configuration)` to distinguish inactive vs. unparsed

Update the interface of this function to return an `IfConfigState` rather
than just a `Bool`. Then, check the enclosing versioned conditions to
distinguish between inactive vs. unparsed. Finally, add a marker-based
assertion function that makes it easy to test the active state of any
location in the source code. Use the new test to flush out an obvious
bug in my original implementation of `isActive(in: configuration)`.

NFC: Split out IfConfigError and the VersionTuple parsing into their own files

Clarify documentation a little bit

Update CMake build for SwiftIfConfig changes

Add a new API to compute the "configured regions" of a syntax tree

This API produces information similar to the "active regions" API used
within the compiler and by SourceKit, a sorted array that indicates the #if
clauses that are active or inactive (including distinguishing inactive
vs. unparsed). When this array has already been computed for a syntax tree,
one can then use the new `SyntaxProtocol.isActive(inConfiguredRegions:)`
function to determine whether a given node is active. This can be more
efficient than the existing `SyntaxProtocol.isActive(in:)` when querying
for many nodes.

Test the new functionality by cross-checking the two `isActive`
implementations against each other on existing tests.

DocC cleanups

Test active code regions with postfix #if

Rename IfConfigState -> ConfiguredRegionState

The new name better describes that we're talking about regions that
have to do with the build configuration.

Handle invalid `#if` conditions as "unparsed" regions consistently

When determining active regions, treat clauses with invalid conditions
as "unparsed" regions, but don't abort the computation by throwing. This
provides behavior that is more consistent with the compiler, and is also
generally easy for most clients. Those clients that want to report
diagnostics can certainly do so, but are not forced to work with
throwing APIs for invalid code.

While here, improve the active syntax rewriting operation by making it
a two-pass operation. The first pass emits diagnostics and determines
whether there is any rewriting to do, and the second pass performs the
rewriting. This fixes an existing bug where the diagnostic locations
were wrong because we were emitting them against partially-rewritten
trees.

Reshuffle and rename some source files in SwiftIfConfig

Rename source files in SwiftIfConfig to better reflect what they do, move
the public APIs up to the tops of files, and split the massive
IfConfigEvaluation.swift into several files. The file itself defines the
core logic for doing the evaluation (which is internal to the library),
and other source files provide public APIs on top of it.

Add support for _hasAtomicBitWidth to evaluation

Declare rules_swift max_compatibility_version = 2, set rules_swift to 1.18.0 (swiftlang#2725)

Add an article about using `SWIFTSYNTAX_ENABLE_RAWSYNTAX_VALIDATION`

[MacroExamples] Update invalid URL example

Workaround for a Foundation bug that can return non-nil URL for
"https://not a url.com".

[Syntax] Mark the parameter of casting initializers '__shared'

Initializer parameters are "+1" in caller site, but these casting
initializers only uses the ._syntaxNode and don't store the parameter itself.

CONTRIBUTING.md: Update for new Swift.org section about release branch PRs

Code action to convert between computed property and stored property

improve diagnostic for unnamed closure parameters

- instead of treating as unrecognized, try to parse the remaining tokens as a type even if the preceding colon is missing

cc

Author: antigluten

.spi.yml

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

CONTRIBUTING.md

@@ -84,22 +84,9 @@ Once you've pushed your branch, you should see an option on this repository's pa
 
 ## Opening a PR for Release Branch
 
-In order for a pull request to be considered for inclusion in a release branch (e.g. `release/6.0`) after it has been cut, it must meet the following requirements:
+See the [dedicated section][section] on the Swift project website.
 
-1. The title of the PR should start with the tag `[{swift version number}]`. For example, `[6.0]` for the Swift 6.0 release branch.
-
-1. [This][form] should be filled out in the description of the PR.
-   To use this template when creating a PR, append the `template=release.md`
-   query parameter to the current URL and refresh.
-   For example:
-   ```diff
-   -https://github.com/swiftlang/swift-syntax/compare/main...my-branch?quick_pull=1
-   +https://github.com/swiftlang/swift-syntax/compare/main...my-branch?quick_pull=1&template=release.md
-   ```
-
-All changes going into a release branch must go through pull requests that are approved and merged by the corresponding release manager.
-
-[form]: https://github.com/swiftlang/.github/blob/main/PULL_REQUEST_TEMPLATE/release.md?plain=1
+[section]: https://www.swift.org/contributing/#release-branch-pull-requests
 
 ## Review and CI Testing
 

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SwiftSyntaxDoccIndexTemplate.md

@@ -18,6 +18,7 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 
 - <doc:Working-with-SwiftSyntax>
 - <doc:Macro-Versioning>
+- <doc:RawSyntaxValidation>
 - <doc:Glossary>
 
 ### Tutorials

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift

@@ -183,7 +183,7 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       DeclSyntax(
         """
         /// Create a \(raw: node.kind.doccLink) node from a specialized syntax node.
-        public init(_ syntax: some \(node.kind.protocolType)) {
+        public init(_ syntax: __shared some \(node.kind.protocolType)) {
           // We know this cast is going to succeed. Go through init(_: SyntaxData)
           // to do a sanity check and verify the kind matches in debug builds and get
           // maximum performance in release builds.
@@ -195,7 +195,7 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       DeclSyntax(
         """
         /// Create a \(raw: node.kind.doccLink) node from a specialized optional syntax node.
-        public init?(_ syntax: (some \(node.kind.protocolType))?) {
+        public init?(_ syntax: __shared (some \(node.kind.protocolType))?) {
           guard let syntax = syntax else { return nil }
           self.init(syntax)
         }
@@ -204,7 +204,7 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
       DeclSyntax(
         """
-        public init(fromProtocol syntax: \(node.kind.protocolType)) {
+        public init(fromProtocol syntax: __shared \(node.kind.protocolType)) {
           // We know this cast is going to succeed. Go through init(_: SyntaxData)
           // to do a sanity check and verify the kind matches in debug builds and get
           // maximum performance in release builds.
@@ -216,14 +216,14 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       DeclSyntax(
         """
         /// Create a \(raw: node.kind.doccLink) node from a specialized optional syntax node.
-        public init?(fromProtocol syntax: \(node.kind.protocolType)?) {
+        public init?(fromProtocol syntax: __shared \(node.kind.protocolType)?) {
           guard let syntax = syntax else { return nil }
           self.init(fromProtocol: syntax)
         }
         """
       )
 
-      try InitializerDeclSyntax("public init?(_ node: some SyntaxProtocol)") {
+      try InitializerDeclSyntax("public init?(_ node: __shared some SyntaxProtocol)") {
         try SwitchExprSyntax("switch node.raw.kind") {
           SwitchCaseListSyntax {
             SwitchCaseSyntax(

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift

@@ -47,7 +47,7 @@ func syntaxNode(nodesStartingWith: [Character]) -> SourceFileSyntax {
 
         DeclSyntax(
           """
-          public init?(_ node: some SyntaxProtocol) {
+          public init?(_ node: __shared some SyntaxProtocol) {
             guard node.raw.kind == .\(node.varOrCaseName) else { return nil }
             self._syntaxNode = node._syntaxNode
           }
@@ -256,7 +256,7 @@ private func generateSyntaxChildChoices(for child: Child) throws -> EnumDeclSynt
       }
     }
 
-    try! InitializerDeclSyntax("public init?(_ node: some SyntaxProtocol)") {
+    try! InitializerDeclSyntax("public init?(_ node: __shared some SyntaxProtocol)") {
       for choice in choices {
         StmtSyntax(
           """

Examples/Sources/MacroExamples/Playground/ExpressionMacrosPlayground.swift

@@ -47,7 +47,7 @@ func runExpressionMacrosPlayground() {
 
   //  let domain = "domain.com"
   //print(#URL("https://\(domain)/api/path")) // error: #URL requires a static string literal
-  //print(#URL("https://not a url.com")) // error: Malformed url
+  //print(#URL("https://not a url.com:invalid-port/")) // error: Malformed url
 
   // MARK: - Warning
 

Examples/Tests/MacroExamples/Implementation/Expression/URLMacroTests.swift

@@ -21,13 +21,18 @@ final class URLMacroTests: XCTestCase {
   func testExpansionWithMalformedURLEmitsError() {
     assertMacroExpansion(
       """
-      let invalid = #URL("https://not a url.com")
+      let invalid = #URL("https://not a url.com:invalid-port/")
       """,
       expandedSource: """
-        let invalid = #URL("https://not a url.com")
+        let invalid = #URL("https://not a url.com:invalid-port/")
         """,
       diagnostics: [
-        DiagnosticSpec(message: #"malformed url: "https://not a url.com""#, line: 1, column: 15, severity: .error)
+        DiagnosticSpec(
+          message: #"malformed url: "https://not a url.com:invalid-port/""#,
+          line: 1,
+          column: 15,
+          severity: .error
+        )
       ],
       macros: macros,
       indentationWidth: .spaces(2)

MODULE.bazel

@@ -6,4 +6,4 @@ module(
 
 bazel_dep(name = "apple_support", version = "1.13.0", repo_name = "build_bazel_apple_support")
 bazel_dep(name = "rules_apple", version = "3.3.0", repo_name = "build_bazel_rules_apple")
-bazel_dep(name = "rules_swift", version = "1.16.0", repo_name = "build_bazel_rules_swift")
+bazel_dep(name = "rules_swift", version = "1.18.0", max_compatibility_level = 2, repo_name = "build_bazel_rules_swift")

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))]
+  }
+}