Merge pull request #75937 from DougGregor/astgen-swiftifconfig

Author: DougGregor

include/swift/AST/ASTBridging.h

@@ -246,6 +246,9 @@ SWIFT_NAME("BridgedASTContext.langOptsGetCompilerVersion(self:_:)")
 SwiftInt BridgedASTContext_langOptsGetCompilerVersion(BridgedASTContext cContext,
                                                       SwiftInt* _Nullable * _Nonnull cComponents);
 
+/* Deallocate an array of Swift int values that was allocated in C++. */
+void deallocateIntBuffer(SwiftInt * _Nullable cComponents);
+
 enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedCanImportVersion : size_t {
   CanImportUnversioned,
   CanImportVersion,

include/swift/Bridging/ASTGen.h

@@ -48,6 +48,7 @@ int swift_ASTGen_roundTripCheck(void *_Nonnull sourceFile);
 /// Emit parser diagnostics for given source file.. Returns non-zero if any
 /// diagnostics were emitted.
 int swift_ASTGen_emitParserDiagnostics(
+    BridgedASTContext astContext,
     void *_Nonnull diagEngine, void *_Nonnull sourceFile, int emitOnlyErrors,
     int downgradePlaceholderErrorsToWarnings);
 

lib/AST/ASTBridging.cpp

@@ -195,6 +195,10 @@ namespace {
   }
 }
 
+void deallocateIntBuffer(SwiftInt * _Nullable cComponents) {
+  free(cComponents);
+}
+
 SwiftInt BridgedASTContext_langOptsGetLanguageVersion(BridgedASTContext cContext,
                                                       SwiftInt** cComponents) {
   auto theVersion = cContext.unbridged().LangOpts.EffectiveLanguageVersion;

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,77 @@
+//===--- 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.
+    var buildConfiguration = self.buildConfiguration
+    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

@@ -20,7 +20,12 @@ import SwiftSyntax
 /// queries.
 struct 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
@@ -118,7 +123,7 @@ struct CompilerBuildConfiguration: BuildConfiguration {
     var bitWidthsBuf: UnsafeMutablePointer<SwiftInt>? = nil
     let count = ctx.langOptsGetTargetAtomicBitWidths(&bitWidthsBuf)
     let bitWidths = Array(UnsafeMutableBufferPointer(start: bitWidthsBuf, count: count))
-    bitWidthsBuf?.deallocate()
+    deallocateIntBuffer(bitWidthsBuf);
     return bitWidths
   }
 
@@ -135,7 +140,7 @@ struct CompilerBuildConfiguration: BuildConfiguration {
     let version = VersionTuple(
       components: Array(UnsafeMutableBufferPointer(start: componentsBuf, count: count))
     )
-    componentsBuf?.deallocate()
+    deallocateIntBuffer(componentsBuf);
     return version
   }
 
@@ -145,7 +150,7 @@ struct CompilerBuildConfiguration: BuildConfiguration {
     let version = VersionTuple(
       components: Array(UnsafeMutableBufferPointer(start: componentsBuf, count: count))
     )
-    componentsBuf?.deallocate()
+    deallocateIntBuffer(componentsBuf);
     return version
   }
 }

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/SourceFile.swift

@@ -12,6 +12,7 @@
 
 import ASTBridging
 import SwiftDiagnostics
+import SwiftIfConfig
 @_spi(ExperimentalLanguageFeatures) import SwiftParser
 import SwiftParserDiagnostics
 import SwiftSyntax
@@ -142,20 +143,10 @@ public func roundTripCheck(
   }
 }
 
-extension Syntax {
-  /// Whether this syntax node is or is enclosed within a #if.
-  fileprivate var isInIfConfig: Bool {
-    if self.is(IfConfigDeclSyntax.self) {
-      return true
-    }
-
-    return parent?.isInIfConfig ?? false
-  }
-}
-
 /// Emit diagnostics within the given source file.
 @_cdecl("swift_ASTGen_emitParserDiagnostics")
 public func emitParserDiagnostics(
+  ctx: BridgedASTContext,
   diagEnginePtr: UnsafeMutableRawPointer,
   sourceFilePtr: UnsafeMutablePointer<UInt8>,
   emitOnlyErrors: CInt,
@@ -172,11 +163,18 @@ public func emitParserDiagnostics(
     )
 
     let diagnosticEngine = BridgedDiagnosticEngine(raw: diagEnginePtr)
+    let buildConfiguration = CompilerBuildConfiguration(
+      ctx: ctx,
+      conditionLoc:
+        BridgedSourceLoc(
+        at: AbsolutePosition(utf8Offset: 0),
+        in: sourceFile.pointee.buffer
+      )
+    )
+
     for diag in diags {
-      // Skip over diagnostics within #if, because we don't know whether
-      // we are in an active region or not.
-      // FIXME: This heuristic could be improved.
-      if diag.node.isInIfConfig {
+      // If the diagnostic is in an unparsed #if region, don't emit it.
+      if diag.node.isActive(in: buildConfiguration).state == .unparsed {
         continue
       }
 

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)