Use the SwiftIfConfig library for evaluating #if conditions.

Replace the C++ implementation of #if condition operator folding,
validation, and evaluation with the corresponding facilities in the
SwiftIfConfig library.

Leave the C++ implementation in place for now to permit the compiler
to continue building without swift-syntax.

Author: DougGregor

lib/ASTGen/Sources/ASTGen/CompilerBuildConfiguration.swift

@@ -98,6 +98,13 @@ struct CompilerBuildConfiguration: BuildConfiguration {
 
   func isActiveTargetRuntime(name: String) throws -> Bool {
     var name = name
+
+    // Complain if the provided runtime isn't one of the known values.
+    switch name {
+    case "_Native", "_ObjC", "_multithreaded": break
+    default: throw IfConfigError.unexpectedRuntimeCondition
+    }
+
     return name.withBridgedString { nameRef in
       ctx.langOptsIsActiveTargetRuntime(nameRef)
     }
@@ -150,6 +157,18 @@ struct CompilerBuildConfiguration: BuildConfiguration {
   }
 }
 
+enum IfConfigError: Error, CustomStringConvertible {
+  case unexpectedRuntimeCondition
+
+  var description: String {
+    switch self {
+      case .unexpectedRuntimeCondition:
+        return "unexpected argument for the '_runtime' condition; expected '_Native' or '_ObjC'"
+    }
+  }
+}
+
+
 /// Extract the #if clause range information for the given source file.
 @_cdecl("swift_ASTGen_configuredRegions")
 public func configuredRegions(
@@ -290,3 +309,53 @@ public func freeConfiguredRegions(
 ) {
   UnsafeMutableBufferPointer(start: regions, count: numRegions).deallocate()
 }
+
+/// Evaluate the #if condition at ifClauseLocationPtr.
+@_cdecl("swift_ASTGen_evaluatePoundIfCondition")
+public func evaluatePoundIfCondition(
+  astContext: BridgedASTContext,
+  diagEnginePtr: UnsafeMutableRawPointer,
+  sourceFileBuffer: BridgedStringRef,
+  ifConditionText: BridgedStringRef,
+  shouldEvaluate: Bool
+) -> Int {
+  // Retrieve the #if condition that we're evaluating here.
+  // FIXME: Use 'ExportedSourceFile' when C++ parser is replaced.
+  let textBuffer = UnsafeBufferPointer<UInt8>(start: ifConditionText.data, count: ifConditionText.count)
+  var parser = Parser(textBuffer)
+  let conditionExpr = ExprSyntax.parse(from: &parser)
+
+  let isActive: Bool
+  let syntaxErrorsAllowed: Bool
+  let diagnostics: [Diagnostic]
+  if shouldEvaluate {
+    // Evaluate the condition against the compiler's build configuration.
+    let configuration = CompilerBuildConfiguration(
+      ctx: astContext,
+      conditionLoc: BridgedSourceLoc(raw: ifConditionText.data)
+    )
+
+    let state: IfConfigRegionState
+    (state, syntaxErrorsAllowed, diagnostics) = IfConfigRegionState.evaluating(conditionExpr, in: configuration)
+    isActive = (state == .active)
+  } else {
+    // Don't evaluate the condition, because we know it's inactive. Determine
+    // whether syntax errors are permitted within this region according to the
+    // condition.
+    isActive = false
+    (syntaxErrorsAllowed, diagnostics) = IfConfigClauseSyntax.syntaxErrorsAllowed(conditionExpr)
+  }
+
+  // Render the diagnostics.
+  for diagnostic in diagnostics {
+    emitDiagnostic(
+      diagnosticEngine: BridgedDiagnosticEngine(raw: diagEnginePtr),
+      sourceFileBuffer: UnsafeBufferPointer(start: sourceFileBuffer.data, count: sourceFileBuffer.count),
+      sourceFileBufferOffset: ifConditionText.data! - sourceFileBuffer.data!,
+      diagnostic: diagnostic,
+      diagnosticSeverity: diagnostic.diagMessage.severity
+    )
+  }
+
+  return (isActive ? 0x1 : 0) | (syntaxErrorsAllowed ? 0x2 : 0)
+}

lib/Parse/ParseIfConfig.cpp

@@ -16,6 +16,7 @@
 
 #include "swift/Parse/Parser.h"
 
+#include "swift/AST/ASTBridging.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/DiagnosticSuppression.h"
 #include "swift/Basic/Assertions.h"
@@ -766,6 +767,44 @@ static Expr *findAnyLikelySimulatorEnvironmentTest(Expr *Condition) {
 
 } // end anonymous namespace
 
+extern "C" intptr_t swift_ASTGen_evaluatePoundIfCondition(
+                        BridgedASTContext astContext,
+                        void *_Nonnull diagEngine,
+                        BridgedStringRef sourceFileBuffer,
+                        BridgedStringRef conditionText,
+                        bool);
+
+/// Call into the Swift implementation of #if condition evaluation.
+///
+/// \returns std::nullopt if the Swift implementation is not available, or
+/// a pair (isActive, allowSyntaxErrors) describing whether the evaluated
+/// condition indicates that the region is active and whether, if inactive,
+/// the code in that region is allowed to have syntax errors.
+static std::optional<std::pair<bool, bool>> evaluateWithSwiftIfConfig(
+    Parser &parser,
+    SourceRange conditionRange,
+    bool shouldEvaluate
+) {
+#if SWIFT_BUILD_SWIFT_SYNTAX
+  // FIXME: When we migrate to SwiftParser, use the parsed syntax tree.
+  auto &sourceMgr = parser.Context.SourceMgr;
+  StringRef sourceFileText =
+      sourceMgr.getEntireTextForBuffer(*parser.SF.getBufferID());
+  StringRef conditionText =
+      sourceMgr.extractText(Lexer::getCharSourceRangeFromSourceRange(
+          sourceMgr, conditionRange));
+  intptr_t evalResult = swift_ASTGen_evaluatePoundIfCondition(
+      parser.Context, &parser.Context.Diags, sourceFileText, conditionText,
+      shouldEvaluate
+  );
+
+  bool isActive = (evalResult & 0x01) != 0;
+  bool allowSyntaxErrors = (evalResult & 0x02) != 0;
+  return std::pair(isActive, allowSyntaxErrors);
+#else
+  return std::nullopt;
+#endif
+}
 
 /// Parse and populate a #if ... #endif directive.
 /// Delegate callback function to parse elements in the blocks.
@@ -842,7 +881,15 @@ Result Parser::parseIfConfigRaw(
       if (result.isNull())
         return makeParserError();
       Condition = result.get();
-      if (validateIfConfigCondition(Condition, Context, Diags)) {
+      if (std::optional<std::pair<bool, bool>> evalResult =
+              evaluateWithSwiftIfConfig(*this,
+                                        Condition->getSourceRange(),
+                                        shouldEvaluate)) {
+        if (!foundActive) {
+          isActive = evalResult->first;
+          isVersionCondition = evalResult->second;
+        }
+      } else if (validateIfConfigCondition(Condition, Context, Diags)) {
         // Error in the condition;
         isActive = false;
         isVersionCondition = false;