Properly translate import path expressions to an import path

My old hack of taking the text of the whole expression and splitting it on
a period was showing its age by failing to reject invalid code. Perform
the proper translation, throwing errors if the import path doesn't
match the proper A.B.C form.

Author: DougGregor

Sources/SwiftIfConfig/IfConfigError.swift

@@ -33,6 +33,7 @@ enum IfConfigError: Error, CustomStringConvertible {
   case likelySimulatorPlatform(syntax: ExprSyntax)
   case endiannessDoesNotMatch(syntax: ExprSyntax, argument: String)
   case macabiIsMacCatalyst(syntax: ExprSyntax)
+  case expectedModuleName(syntax: ExprSyntax)
 
   var description: String {
     switch self {
@@ -89,6 +90,9 @@ enum IfConfigError: Error, CustomStringConvertible {
 
     case .endiannessDoesNotMatch:
       return "unknown endianness for build configuration '_endian' (must be 'big' or 'little')"
+
+    case .expectedModuleName:
+      return "expected module name"
     }
   }
 
@@ -110,7 +114,8 @@ enum IfConfigError: Error, CustomStringConvertible {
       .integerLiteralCondition(syntax: let syntax, replacement: _),
       .likelySimulatorPlatform(syntax: let syntax),
       .endiannessDoesNotMatch(syntax: let syntax, argument: _),
-      .macabiIsMacCatalyst(syntax: let syntax):
+      .macabiIsMacCatalyst(syntax: let syntax),
+      .expectedModuleName(syntax: let syntax):
       return Syntax(syntax)
 
     case .unsupportedVersionOperator(name: _, operator: let op):

Sources/SwiftIfConfig/IfConfigEvaluation.swift

@@ -405,9 +405,13 @@ func evaluateIfConfig(
         return recordError(.canImportTwoParameters(syntax: ExprSyntax(call)))
       }
 
-      // FIXME: This is a gross hack. Actually look at the sequence of
-      // `MemberAccessExprSyntax` nodes and pull out the identifiers.
-      let importPath = firstArg.expression.trimmedDescription.split(separator: ".")
+      // Extract the import path.
+      let importPath: [String]
+      do {
+        importPath = try extractImportPath(firstArg.expression)
+      } catch {
+        return recordError(error, at: firstArg.expression)
+      }
 
       // If there is a second argument, it shall have the label _version or
       // _underlyingVersion.
@@ -473,6 +477,40 @@ func evaluateIfConfig(
   return recordError(.unknownExpression(condition))
 }
 
+/// Given an expression with the expected form A.B.C, extract the import path
+/// ["A", "B", "C"] from it. Throws an error if the expression doesn't match
+/// this form.
+private func extractImportPath(_ expression: some ExprSyntaxProtocol) throws -> [String] {
+  // Member access.
+  if let memberAccess = expression.as(MemberAccessExprSyntax.self),
+    let base = memberAccess.base,
+    let memberName = memberAccess.declName.simpleIdentifier
+  {
+    return try extractImportPath(base) + [memberName]
+  }
+
+  // Declaration reference.
+  if let declRef = expression.as(DeclReferenceExprSyntax.self),
+    let name = declRef.simpleIdentifier
+  {
+    return [name]
+  }
+
+  throw IfConfigError.expectedModuleName(syntax: ExprSyntax(expression))
+}
+
+extension DeclReferenceExprSyntax {
+  /// If this declaration reference is a simple identifier, return that
+  /// string.
+  fileprivate var simpleIdentifier: String? {
+    guard argumentNames == nil else {
+      return nil
+    }
+
+    return baseName.text
+  }
+}
+
 /// Determine whether the given condition only involves disjunctions that
 /// check the given config function against one of the provided values.
 ///

Tests/SwiftIfConfigTest/EvaluateTests.swift

@@ -345,6 +345,19 @@ public class EvaluateTests: XCTestCase {
         )
       ]
     )
+
+    assertIfConfig(
+      "canImport(A(b: 1, c: 2).B.C)",
+      .unparsed,
+      diagnostics: [
+        DiagnosticSpec(
+          message: "expected module name",
+          line: 1,
+          column: 11,
+          severity: .error
+        )
+      ]
+    )
   }
 
   func testLikelySimulatorEnvironment() throws {