Merge pull request #2832 from DougGregor/extract-inlinable-text

Implementation of the compiler's "extract inlinable text"

Author: DougGregor

Sources/SwiftIfConfig/ActiveSyntaxRewriter.swift

@@ -18,15 +18,39 @@ extension SyntaxProtocol {
   /// are inactive according to the given build configuration, leaving only
   /// the code that is active within that build configuration.
   ///
-  /// Returns the syntax node with all inactive regions removed, along with an
-  /// array containing any diagnostics produced along the way.
-  ///
   /// If there are errors in the conditions of any configuration
   /// clauses, e.g., `#if FOO > 10`, then the condition will be
   /// considered to have failed and the clauses's elements will be
   /// removed.
+  /// - Parameters:
+  ///   - configuration: the configuration to apply.
+  /// - Returns: the syntax node with all inactive regions removed, along with
+  ///   an array containing any diagnostics produced along the way.
   public func removingInactive(
     in configuration: some BuildConfiguration
+  ) -> (result: Syntax, diagnostics: [Diagnostic]) {
+    return removingInactive(in: configuration, retainFeatureCheckIfConfigs: false)
+  }
+
+  /// Produce a copy of this syntax node that removes all syntax regions that
+  /// are inactive according to the given build configuration, leaving only
+  /// the code that is active within that build configuration.
+  ///
+  /// If there are errors in the conditions of any configuration
+  /// clauses, e.g., `#if FOO > 10`, then the condition will be
+  /// considered to have failed and the clauses's elements will be
+  /// removed.
+  /// - Parameters:
+  ///   - configuration: the configuration to apply.
+  ///   - retainFeatureCheckIfConfigs: whether to retain `#if` blocks involving
+  ///     compiler version checks (e.g., `compiler(>=6.0)`) and `$`-based
+  ///     feature checks.
+  /// - Returns: the syntax node with all inactive regions removed, along with
+  ///   an array containing any diagnostics produced along the way.
+  @_spi(Compiler)
+  public func removingInactive(
+    in configuration: some BuildConfiguration,
+    retainFeatureCheckIfConfigs: Bool
   ) -> (result: Syntax, diagnostics: [Diagnostic]) {
     // First pass: Find all of the active clauses for the #ifs we need to
     // visit, along with any diagnostics produced along the way. This process
@@ -41,7 +65,10 @@ extension SyntaxProtocol {
 
     // Second pass: Rewrite the syntax tree by removing the inactive clauses
     // from each #if (along with the #ifs themselves).
-    let rewriter = ActiveSyntaxRewriter(configuration: configuration)
+    let rewriter = ActiveSyntaxRewriter(
+      configuration: configuration,
+      retainFeatureCheckIfConfigs: retainFeatureCheckIfConfigs
+    )
     return (
       rewriter.rewrite(Syntax(self)),
       visitor.diagnostics
@@ -83,8 +110,12 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
   let configuration: Configuration
   var diagnostics: [Diagnostic] = []
 
-  init(configuration: Configuration) {
+  /// Whether to retain `#if` blocks containing compiler and feature checks.
+  var retainFeatureCheckIfConfigs: Bool
+
+  init(configuration: Configuration, retainFeatureCheckIfConfigs: Bool) {
     self.configuration = configuration
+    self.retainFeatureCheckIfConfigs = retainFeatureCheckIfConfigs
   }
 
   private func dropInactive<List: SyntaxCollection>(
@@ -97,7 +128,9 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
       let element = node[elementIndex]
 
       // Find #ifs within the list.
-      if let ifConfigDecl = elementAsIfConfig(element) {
+      if let ifConfigDecl = elementAsIfConfig(element),
+        (!retainFeatureCheckIfConfigs || !ifConfigDecl.containsFeatureCheck)
+      {
         // Retrieve the active `#if` clause
         let (activeClause, localDiagnostics) = ifConfigDecl.activeClause(in: configuration)
 
@@ -262,6 +295,12 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
     outerBase: ExprSyntax?,
     postfixIfConfig: PostfixIfConfigExprSyntax
   ) -> ExprSyntax {
+    // If we're supposed to retain #if configs that are feature checks, and
+    // this configuration has one, do so.
+    if retainFeatureCheckIfConfigs && postfixIfConfig.config.containsFeatureCheck {
+      return ExprSyntax(postfixIfConfig)
+    }
+
     // Retrieve the active `if` clause.
     let (activeClause, localDiagnostics) = postfixIfConfig.config.activeClause(in: configuration)
 
@@ -307,3 +346,104 @@ class ActiveSyntaxRewriter<Configuration: BuildConfiguration>: SyntaxRewriter {
     return visit(rewrittenNode)
   }
 }
+
+/// Helper class to find a feature or compiler check.
+fileprivate class FindFeatureCheckVisitor: SyntaxVisitor {
+  var foundFeatureCheck = false
+
+  override func visit(_ node: DeclReferenceExprSyntax) -> SyntaxVisitorContinueKind {
+    // Checks that start with $ are feature checks that should be retained.
+    if let identifier = node.simpleIdentifier,
+      let initialChar = identifier.name.first,
+      initialChar == "$"
+    {
+      foundFeatureCheck = true
+      return .skipChildren
+    }
+
+    return .visitChildren
+  }
+
+  override func visit(_ node: FunctionCallExprSyntax) -> SyntaxVisitorContinueKind {
+    if let calleeDeclRef = node.calledExpression.as(DeclReferenceExprSyntax.self),
+      let calleeName = calleeDeclRef.simpleIdentifier?.name,
+      (calleeName == "compiler" || calleeName == "_compiler_version")
+    {
+      foundFeatureCheck = true
+    }
+
+    return .skipChildren
+  }
+}
+
+extension ExprSyntaxProtocol {
+  /// Whether any of the nodes in this expression involve compiler or feature
+  /// checks.
+  fileprivate var containsFeatureCheck: Bool {
+    let visitor = FindFeatureCheckVisitor(viewMode: .fixedUp)
+    visitor.walk(self)
+    return visitor.foundFeatureCheck
+  }
+}
+
+extension IfConfigDeclSyntax {
+  /// Whether any of the clauses in this #if contain a feature check.
+  var containsFeatureCheck: Bool {
+    return clauses.contains { clause in
+      if let condition = clause.condition {
+        return condition.containsFeatureCheck
+      } else {
+        return false
+      }
+    }
+  }
+}
+
+extension SyntaxProtocol {
+  // Produce the source code for this syntax node with all of the comments
+  // and #sourceLocations removed. Each comment will be replaced with either
+  // a newline or a space, depending on whether the comment involved a newline.
+  @_spi(Compiler)
+  public var descriptionWithoutCommentsAndSourceLocations: String {
+    var result = ""
+    var skipUntilRParen = false
+    for token in tokens(viewMode: .sourceAccurate) {
+      // Skip #sourceLocation(...).
+      if token.tokenKind == .poundSourceLocation {
+        skipUntilRParen = true
+        continue
+      }
+
+      if skipUntilRParen {
+        if token.tokenKind == .rightParen {
+          skipUntilRParen = false
+        }
+        continue
+      }
+
+      token.leadingTrivia.writeWithoutComments(to: &result)
+      token.text.write(to: &result)
+      token.trailingTrivia.writeWithoutComments(to: &result)
+    }
+    return result
+  }
+}
+
+extension Trivia {
+  fileprivate func writeWithoutComments(to stream: inout some TextOutputStream) {
+    for piece in pieces {
+      switch piece {
+      case .backslashes, .carriageReturnLineFeeds, .carriageReturns, .formfeeds, .newlines, .pounds, .spaces, .tabs,
+        .unexpectedText, .verticalTabs:
+        piece.write(to: &stream)
+
+      case .blockComment(let text), .docBlockComment(let text), .docLineComment(let text), .lineComment(let text):
+        if text.contains(where: \.isNewline) {
+          stream.write("\n")
+        } else {
+          stream.write(" ")
+        }
+      }
+    }
+  }
+}

Tests/SwiftIfConfigTest/VisitorTests.swift

@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 import SwiftDiagnostics
-import SwiftIfConfig
+@_spi(Compiler) import SwiftIfConfig
 import SwiftParser
 import SwiftSyntax
 @_spi(XCTestFailureLocation) @_spi(Testing) import SwiftSyntaxMacrosGenericTestSupport
@@ -253,13 +253,96 @@ public class VisitorTests: XCTestCase {
         """
     )
   }
+
+  func testRemoveInactiveRetainingFeatureChecks() {
+    assertRemoveInactive(
+      """
+      public func hasIfCompilerCheck(_ x: () -> Bool = {
+      #if compiler(>=5.3)
+        return true
+      #else
+        return false
+      #endif
+
+      #if $Blah
+        return 0
+      #else
+        return 1
+      #endif
+
+      #if NOT_SET
+        return 3.14159
+      #else
+        return 2.71828
+      #endif
+        }) {
+      }
+      """,
+      configuration: linuxBuildConfig,
+      retainFeatureCheckIfConfigs: true,
+      expectedSource: """
+        public func hasIfCompilerCheck(_ x: () -> Bool = {
+        #if compiler(>=5.3)
+          return true
+        #else
+          return false
+        #endif
+
+        #if $Blah
+          return 0
+        #else
+          return 1
+        #endif
+          return 2.71828
+          }) {
+        }
+        """
+    )
+  }
+
+  func testRemoveCommentsAndSourceLocations() {
+    let original: SourceFileSyntax = """
+
+      /// This is a documentation comment
+      func f() { }
+
+      #sourceLocation(file: "if-configs.swift", line: 200)
+      /** Another documentation comment
+          that is split across
+          multiple lines */
+      func g() { }
+
+      func h() {
+        x +/*comment*/y
+        // foo
+      }
+      """
+
+    assertStringsEqualWithDiff(
+      original.descriptionWithoutCommentsAndSourceLocations,
+      """
+
+       
+      func f() { }
+
+
+      func g() { }
+
+      func h() {
+        x + y
+         
+      }
+      """
+    )
+  }
 }
 
 /// Assert that applying the given build configuration to the source code
 /// returns the expected source and diagnostics.
 fileprivate func assertRemoveInactive(
   _ source: String,
   configuration: some BuildConfiguration,
+  retainFeatureCheckIfConfigs: Bool = false,
   diagnostics expectedDiagnostics: [DiagnosticSpec] = [],
   expectedSource: String,
   file: StaticString = #filePath,
@@ -268,7 +351,10 @@ fileprivate func assertRemoveInactive(
   var parser = Parser(source)
   let tree = SourceFileSyntax.parse(from: &parser)
 
-  let (treeWithoutInactive, actualDiagnostics) = tree.removingInactive(in: configuration)
+  let (treeWithoutInactive, actualDiagnostics) = tree.removingInactive(
+    in: configuration,
+    retainFeatureCheckIfConfigs: retainFeatureCheckIfConfigs
+  )
 
   // Check the resulting tree.
   assertStringsEqualWithDiff(