[ASTGen] Implement #if config handling using the SwiftIfConfig library

Wherever there is a syntax collection in the syntax tree that can involve
an `#if` clause, evaluate the `#if` conditions to find the active clause,
then recurse into the active clause (if one exists) to "flatten" the
translated collection to only contain active elements.

Note that this does not yet handle #if for postfix expressions.

Author: DougGregor

lib/ASTGen/CMakeLists.txt

@@ -20,6 +20,7 @@ endif()
 
 add_pure_swift_host_library(swiftASTGen STATIC
   Sources/ASTGen/ASTGen.swift
+  Sources/ASTGen/ASTGen+CompilerBuildConfiguration.swift
   Sources/ASTGen/Bridge.swift
   Sources/ASTGen/CompilerBuildConfiguration.swift
   Sources/ASTGen/DeclAttrs.swift

lib/ASTGen/Sources/ASTGen/ASTGen+CompilerBuildConfiguration.swift

@@ -0,0 +1,76 @@
+//===--- ASTGen+CompilerBuildConfiguration.swift --------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024-2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftDiagnostics
+import SwiftIfConfig
+import SwiftSyntax
+
+/// Enumeration that separates an #if config decl from the underlying element.
+enum IfConfigOrUnderlying<Element> {
+  case ifConfigDecl(IfConfigDeclSyntax)
+  case underlying(Element)
+}
+
+extension ASTGenVisitor {
+  /// Determine the active clause for the given #if, emitting any diagnostics
+  /// produced due to the evaluation.
+  func activeClause(in node: IfConfigDeclSyntax) -> IfConfigClauseSyntax? {
+    // Determine the active clause.
+    buildConfiguration.conditionLoc = generateSourceLoc(node)
+    let (activeClause, diagnostics) = node.activeClause(in: buildConfiguration)
+    diagnoseAll(diagnostics)
+
+    return activeClause
+  }
+
+  /// Visit a collection of elements that may contain #if clauses within it
+  /// within it, recursing into the active clauses and to ensure that every
+  /// active element is visited.
+  /// - Parameters:
+  ///   - elements: A syntax collection that can config `IfConfigDeclSyntax`
+  ///     nodes in it.
+  ///   - flatElementType: The element type within the syntax collection for the
+  ///     non-#if case.
+  ///   - split: Splits an element in elements into the two cases: #if config
+  ///     or a flat element.
+  ///   - body: The body that handles each syntax node of type FlatElement.
+  func visitIfConfigElements<Elements, FlatElement>(
+    _ elements: Elements,
+    of flatElementType: FlatElement.Type,
+    split: (Elements.Element) -> IfConfigOrUnderlying<FlatElement>,
+    body: (FlatElement) -> Void
+  ) where Elements: SyntaxCollection, FlatElement: SyntaxProtocol {
+    for element in elements {
+      switch split(element) {
+      case .ifConfigDecl(let ifConfigDecl):
+        if let activeClause = self.activeClause(in: ifConfigDecl),
+           let activeElements = activeClause.elements {
+          guard let activeElements = activeElements._syntaxNode.as(Elements.self) else {
+            fatalError("Parser produced invalid nesting of #if decls")
+          }
+
+          visitIfConfigElements(
+            activeElements,
+            of: FlatElement.self,
+            split: split,
+            body: body
+          )
+        }
+
+      case .underlying(let element):
+        body(element)
+    }
+    }
+  }
+}
+
+

lib/ASTGen/Sources/ASTGen/ASTGen.swift

@@ -76,6 +76,8 @@ struct ASTGenVisitor {
 
   let ctx: BridgedASTContext
 
+  let buildConfiguration: CompilerBuildConfiguration
+
   fileprivate let allocator: SwiftSyntax.BumpPtrAllocator = .init(initialSlabSize: 256)
 
   /// Fallback legacy parser used when ASTGen doesn't have the generate(_:)
@@ -94,12 +96,20 @@ struct ASTGenVisitor {
     self.declContext = declContext
     self.ctx = astContext
     self.legacyParse = legacyParser
+    self.buildConfiguration = CompilerBuildConfiguration(
+      ctx: ctx,
+      conditionLoc: BridgedSourceLoc(at: AbsolutePosition(utf8Offset: 0), in: sourceBuffer)
+    )
   }
 
   func generate(sourceFile node: SourceFileSyntax) -> [BridgedDecl] {
     var out = [BridgedDecl]()
 
-    for element in node.statements {
+    visitIfConfigElements(
+      node.statements,
+      of: CodeBlockItemSyntax.self,
+      split: Self.splitCodeBlockItemIfConfig
+    ) { element in
       let loc = self.generateSourceLoc(element)
       let swiftASTNodes = generate(codeBlockItem: element)
       switch swiftASTNodes {
@@ -260,6 +270,11 @@ extension ASTGenVisitor {
       diagnosticSeverity: diagnostic.diagMessage.severity
     )
   }
+
+  /// Emits the given diagnostics via the C++ diagnostic engine.
+  func diagnoseAll(_ diagnostics: [Diagnostic]) {
+    diagnostics.forEach(diagnose)
+  }
 }
 
 // Forwarding overloads that take optional syntax nodes. These are defined on demand to achieve a consistent

lib/ASTGen/Sources/ASTGen/CompilerBuildConfiguration.swift

@@ -18,9 +18,14 @@ import SwiftSyntax
 
 /// A build configuration that uses the compiler's ASTContext to answer
 /// queries.
-struct CompilerBuildConfiguration: BuildConfiguration {
+final class CompilerBuildConfiguration: BuildConfiguration {
   let ctx: BridgedASTContext
-  let conditionLoc: BridgedSourceLoc
+  var conditionLoc: BridgedSourceLoc
+
+  init(ctx: BridgedASTContext, conditionLoc: BridgedSourceLoc) {
+    self.ctx = ctx
+    self.conditionLoc = conditionLoc
+  }
 
   func isCustomConditionSet(name: String) throws -> Bool {
     var name = name

lib/ASTGen/Sources/ASTGen/DeclAttrs.swift

@@ -13,6 +13,8 @@
 import ASTBridging
 import BasicBridging
 import SwiftDiagnostics
+import SwiftIfConfig
+
 @_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) import SwiftSyntax
 
 extension ASTGenVisitor {
@@ -52,17 +54,15 @@ extension ASTGenVisitor {
     }
 
     // '@' attributes.
-    for node in node.attributes {
-      switch node {
-      case .attribute(let node):
-        addAttribute(self.generateDeclAttribute(attribute: node))
-      case .ifConfigDecl:
-        fatalError("unimplemented")
-#if RESILIENT_SWIFT_SYNTAX
-      @unknown default:
-        fatalError()
-#endif
+    visitIfConfigElements(node.attributes, of: AttributeSyntax.self) { element in
+      switch element {
+      case .ifConfigDecl(let ifConfigDecl):
+        return .ifConfigDecl(ifConfigDecl)
+      case .attribute(let attribute):
+        return .underlying(attribute)
       }
+    } body: { attribute in
+      addAttribute(self.generateDeclAttribute(attribute: attribute))
     }
 
     func genStatic(node: DeclModifierSyntax, spelling: BridgedStaticSpelling) {

lib/ASTGen/Sources/ASTGen/Decls.swift

@@ -41,7 +41,7 @@ extension ASTGenVisitor {
     case .functionDecl(let node):
       return self.generate(functionDecl: node).asDecl
     case .ifConfigDecl:
-      break
+      fatalError("Should have been handled by the caller")
     case .importDecl(let node):
       return self.generate(importDecl: node).asDecl
     case .initializerDecl(let node):
@@ -838,7 +838,19 @@ extension ASTGenVisitor {
 extension ASTGenVisitor {
   @inline(__always)
   func generate(memberBlockItemList node: MemberBlockItemListSyntax) -> BridgedArrayRef {
-    node.lazy.map(self.generate).bridgedArray(in: self)
+    var allBridged: [BridgedDecl] = []
+    visitIfConfigElements(node, of: MemberBlockItemSyntax.self) { element in
+      if let ifConfigDecl = element.decl.as(IfConfigDeclSyntax.self) {
+        return .ifConfigDecl(ifConfigDecl)
+      }
+
+      return .underlying(element)
+    } body: { member in
+      // TODO: Set semicolon loc.
+      allBridged.append(self.generate(decl: member.decl))
+    }
+
+    return allBridged.lazy.bridgedArray(in: self)
   }
 
   @inline(__always)

lib/ASTGen/Sources/ASTGen/Stmts.swift

@@ -77,7 +77,28 @@ extension ASTGenVisitor {
 
   @inline(__always)
   func generate(codeBlockItemList node: CodeBlockItemListSyntax) -> BridgedArrayRef {
-    node.lazy.map { self.generate(codeBlockItem: $0).bridged }.bridgedArray(in: self)
+    var allItems: [BridgedASTNode] = []
+    visitIfConfigElements(
+      node,
+      of: CodeBlockItemSyntax.self,
+      split: Self.splitCodeBlockItemIfConfig
+    ) { codeBlockItem in
+      allItems.append(self.generate(codeBlockItem: codeBlockItem).bridged)
+    }
+
+    return allItems.lazy.bridgedArray(in: self)
+  }
+
+  /// Function that splits a code block item into either an #if or the item.
+  static func splitCodeBlockItemIfConfig(
+    _ element: CodeBlockItemSyntax
+  ) -> IfConfigOrUnderlying<CodeBlockItemSyntax> {
+    if case .decl(let decl) = element.item,
+       let ifConfigDecl = decl.as(IfConfigDeclSyntax.self) {
+      return .ifConfigDecl(ifConfigDecl)
+    }
+
+    return .underlying(element)
   }
 
   func generate(codeBlock node: CodeBlockSyntax) -> BridgedBraceStmt {
@@ -461,18 +482,21 @@ extension ASTGenVisitor {
   }
 
   func generate(switchCaseList node: SwitchCaseListSyntax) -> BridgedArrayRef {
-    return node.lazy.map({ node -> BridgedASTNode in
-      switch node {
-      case .switchCase(let node):
-        return ASTNode.stmt(self.generate(switchCase: node).asStmt).bridged
-      case .ifConfigDecl(_):
-        fatalError("unimplemented")
-#if RESILIENT_SWIFT_SYNTAX
-      @unknown default:
-        fatalError()
-#endif
+    var allBridgedCases: [BridgedASTNode] = []
+    visitIfConfigElements(node, of: SwitchCaseSyntax.self) { element in
+      switch element {
+      case .ifConfigDecl(let ifConfigDecl):
+        return .ifConfigDecl(ifConfigDecl)
+      case .switchCase(let switchCase):
+        return .underlying(switchCase)
       }
-    }).bridgedArray(in: self)
+    } body: { caseNode in
+      allBridgedCases.append(
+        ASTNode.stmt(self.generate(switchCase: caseNode).asStmt).bridged
+      )
+    }
+
+    return allBridgedCases.lazy.bridgedArray(in: self)
   }
 
   func generateSwitchStmt(switchExpr node: SwitchExprSyntax, labelInfo: BridgedLabeledStmtInfo = nil)

lib/ASTGen/Sources/ASTGen/TypeAttrs.swift

@@ -22,19 +22,16 @@ extension ASTGenVisitor {
     }
 
     let attrs = BridgedTypeAttributes.new()
-    for node in node.attributes {
-      switch node {
-      case .attribute(let node):
-        guard let attr = self.generateTypeAttribute(attribute: node) else {
-          continue
-        }
-        attrs.add(attr);
-      case .ifConfigDecl:
-        fatalError("unimplemented")
-#if RESILIENT_SWIFT_SYNTAX
-      @unknown default:
-        fatalError()
-#endif
+    visitIfConfigElements(node.attributes, of: AttributeSyntax.self) { element in
+      switch element {
+      case .ifConfigDecl(let ifConfigDecl):
+        return .ifConfigDecl(ifConfigDecl)
+      case .attribute(let attribute):
+        return .underlying(attribute)
+      }
+    } body: { attribute in
+      if let attr = self.generateTypeAttribute(attribute: attribute) {
+        attrs.add(attr)
       }
     }
 

test/ASTGen/if_config.swift

@@ -0,0 +1,70 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-feature ParserASTGen -DDISCARDABLE -DNONSENDABLE -swift-version 6
+/// -enable-experimental-feature requires an asserts build
+// REQUIRES: asserts
+
+#if NOT_SET
+func f { } // FIXME: Error once the parser diagnostics generator knows to
+           // evaluate the active clause.
+#endif
+
+#if compiler(>=10.0)
+bad code is not diagnosed
+#endif
+
+#if canImport(NoSuchModule)
+func g() { }
+#else
+func h() { }
+#endif
+
+
+func testH() {
+  h()
+}
+
+// Declaration attributes
+#if DISCARDABLE
+@discardableResult
+#endif
+func ignorable() -> Int { 5 }
+
+
+func testIgnorable() {
+  ignorable() // no warning
+}
+
+// Type attributes
+// FIXME: Something isn't getting converted properly when I try to put an #if
+// within the type attributes.
+typealias CallbackType = () -> Void
+
+func acceptMaybeSendable(body: CallbackType) { }
+
+func testMaybeSendable() {
+  var x = 10
+  acceptMaybeSendable {
+    x += 1
+  }
+  print(x)
+}
+
+// Switch cases
+enum SafetyError: Error {
+case unsafe
+
+#if NONSENDABLE
+case nonSendable
+#endif
+}
+
+extension SafetyError {
+  var description: String {
+    switch self {
+    case .unsafe: "unsafe"
+
+#if NONSENDABLE
+    case .nonSendable: "non-sendable"
+#endif
+    }
+  }
+}