Add OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED support

Author: Kyle-Ye

Package.swift

@@ -31,22 +31,22 @@ let includePath = SDKPath.appending("/usr/lib/swift")
 
 // MARK: - C/CXX Settings
 
-// Source: https://github.com/swiftlang/swift/blob/main/SwiftCompilerSources/Package.swift
-// To successfully build, you'll need to create a couple of symlinks to an
-// existing Ninja build:
+// Modified from: https://github.com/swiftlang/swift/blob/main/SwiftCompilerSources/Package.swift
 //
-// cd $OPENGRAPH_SWIFT_TOOLCHAIN_PATH
-// mkdir -p build/Default
-// ln -s build/<Ninja-Build>/llvm-<os+arch> build/Default/llvm
-// ln -s build/<Ninja-Build>/swift-<os+arch> build/Default/swift
+// Create a couple of symlinks to an existing Ninja build:
 //
-// where <project-root> is the parent directory of the swift repository.
+//     ```shell
+//     cd $OPENGRAPH_SWIFT_TOOLCHAIN_PATH
+//     mkdir -p build/Default
+//     ln -s build/<Ninja-Build>/llvm-<os+arch> build/Default/llvm
+//     ln -s build/<Ninja-Build>/swift-<os+arch> build/Default/swift
+//     ```
 //
-// FIXME: We may want to consider generating Package.swift as a part of the
-// build.
+// where <$OPENGRAPH_SWIFT_TOOLCHAIN_PATH> is the parent directory of the swift repository.
 
-let swiftToolchainVersion = Context.environment["OPENGRAPH_SWIFT_TOOLCHAIN_VERSION"] ?? ""
-let swiftToolchainPath = Context.environment["OPENGRAPH_SWIFT_TOOLCHAIN_PATH"] ?? ""
+let swiftToolchainVersion = Context.environment["OPENGRAPH_SWIFT_TOOLCHAIN_VERSION"] ?? (development ? "6.0.2" : "")
+let swiftToolchainPath = Context.environment["OPENGRAPH_SWIFT_TOOLCHAIN_PATH"] ?? (development ? "/Volumes/BuildMachine/swift-project" : "")
+let swiftToolchainSupported = envEnable("OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED", default: !swiftToolchainVersion.isEmpty)
 
 var sharedCSettings: [CSetting] = [
     .unsafeFlags(["-I", includePath], .when(platforms: .nonDarwinPlatforms)),
@@ -68,6 +68,7 @@ if !swiftToolchainPath.isEmpty {
                 "-I\(swiftToolchainPath)/build/Default/swift/include",
                 "-I\(swiftToolchainPath)/build/Default/llvm/include",
                 "-I\(swiftToolchainPath)/build/Default/llvm/tools/clang/include",
+                "-DLLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING", // Required to fix LLVM link issue
             ]
         )
     )
@@ -79,6 +80,12 @@ if !swiftToolchainVersion.isEmpty {
     )
 }
 
+if swiftToolchainSupported {
+    sharedCSettings.append(
+        .define("OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED")
+    )
+}
+
 // MARK: - Swift Settings
 
 var sharedSwiftSettings: [SwiftSetting] = [
@@ -87,6 +94,12 @@ var sharedSwiftSettings: [SwiftSetting] = [
     .swiftLanguageMode(.v5),
 ]
 
+if swiftToolchainSupported {
+    sharedSwiftSettings.append(
+        .define("OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED")
+    )
+}
+
 if releaseVersion >= 2021 {
     for year in 2021 ... releaseVersion {
         sharedSwiftSettings.append(.define("OPENGRAPH_SUPPORT_\(year)_API"))

Sources/OpenGraphShims/GraphShims.swift

@@ -27,7 +27,13 @@ public typealias OGValue = AGValue
 public typealias OGValueOptions = AGValueOptions
 public typealias OGValueState = AGValueState
 public let attributeGraphEnabled = true
+public let swiftToolchainSupported = true
 #else
 @_exported import OpenGraph
 public let attributeGraphEnabled = false
+#if OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
+public let swiftToolchainSupported = true
+#else
+public let swiftToolchainSupported = false
+#endif
 #endif

Sources/OpenGraph_SPI/Runtime/OGTypeID.cpp

@@ -7,12 +7,12 @@
 
 #include "OGTypeID.h"
 
-#ifdef OPENGRAPH_SWIFT_TOOLCHAIN_VERSION
+#ifdef OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
 #include <swift/Runtime/Metadata.h>
 #endif
 
 OGTypeKind OGTypeGetKind(OGTypeID typeID) {
-    #ifdef OPENGRAPH_SWIFT_TOOLCHAIN_VERSION
+    #ifdef OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
     const swift::Metadata *type = reinterpret_cast<const swift::Metadata *>(typeID);
     switch (type->getKind()) {
         case swift::MetadataKind::Class:

Tests/OpenGraphCompatibilityTests/GraphShims.swift

@@ -1,8 +1,6 @@
 //
 //  GraphShims.swift
-//
-//
-//
+//  OpenGraphCompatibilityTests
 
 #if OPENGRAPH_COMPATIBILITY_TEST
 @_exported public import AttributeGraph
@@ -29,8 +27,14 @@ public typealias OGUniqueID = AGUniqueID
 public typealias OGValue = AGValue
 public typealias OGValueOptions = AGValueOptions
 public typealias OGValueState = AGValueState
-let compatibilityTestEnabled = true
+public let compatibilityTestEnabled = true
+public let swiftToolchainSupported = true
 #else
 @_exported import OpenGraph
 let compatibilityTestEnabled = false
+#if OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
+public let swiftToolchainSupported = true
+#else
+public let swiftToolchainSupported = false
+#endif
 #endif

Tests/OpenGraphCompatibilityTests/Runtime/MetadataTests.swift

@@ -4,9 +4,37 @@
 
 import Testing
 
-@Suite(.disabled(if: !compatibilityTestEnabled, "Metadata is not implemented"))
 struct MetadataTests {
-    @Test
+    @Test(.enabled(if: swiftToolchainSupported))
+    func kindCases() throws {
+        class T1 {}
+        struct T2 {}
+        enum T3 {}
+        protocol P {}
+        
+        #expect(Metadata(T1.self).kind == .class)
+        #expect(Metadata(T2.self).kind == .struct)
+        #expect(Metadata(T3.self).kind == .enum)
+        
+        #expect(Metadata(Void?.self).kind == .optional)
+        #expect(Metadata(Int?.self).kind == .optional)
+        #expect(Metadata(T1?.self).kind == .optional)
+        #expect(Metadata((T1, T2)?.self).kind == .optional)
+
+        #expect(Metadata(Void.self).kind == .tuple)
+        #expect(Metadata((Int, Double?).self).kind == .tuple)
+        #expect(Metadata((T1, T2, T3).self).kind == .tuple)
+        
+        #expect(Metadata((() -> Void).self).kind == .function)
+        
+        #expect(Metadata(P.self).kind == .existential)
+        #expect(Metadata((any P).self).kind == .existential)
+        
+        #expect(Metadata(P.Protocol.self).kind == .metatype)
+        #expect(Metadata(type(of: Int.self)).kind == .metatype)
+    }
+    
+    @Test(.disabled(if: !compatibilityTestEnabled, "Metadata is not implemented"))
     func descriptor() throws {
         let n1 = try #require(Metadata(Int.self).nominalDescriptor)
         let n2 = try #require(Metadata(String.self).nominalDescriptor)
@@ -30,14 +58,14 @@ struct MetadataTests {
         case a, b
     }
 
-    @Test
+    @Test(.disabled(if: !compatibilityTestEnabled, "Metadata is not implemented"))
     func description() {
         #expect(Metadata(T1.self).description == "MetadataTests.T1")
         #expect(Metadata(T2.self).description == "MetadataTests.T2")
         #expect(Metadata(T3.self).description == "MetadataTests.T3")
     }
 
-    @Test
+    @Test(.disabled(if: !compatibilityTestEnabled, "Metadata is not implemented"))
     func forEachField() throws {
         for options in [OGTypeApplyOptions._1] {
             let result = Metadata(T1.self).forEachField(options: options) { name, offset, type in

Tests/OpenGraphCompatibilityTests/Runtime/TypeKindTests.swift

@@ -6,35 +6,8 @@
 
 import Testing
 
-private protocol P {}
 
 @Suite(.disabled(if: !compatibilityTestEnabled, "Metadata.kind is not implemented"))
 struct TypeKindTests {
-    class T1 {}
-    struct T2 {}
-    enum T3 {}
-    
-    @Test
-    func kindCases() throws {
-        #expect(Metadata(T1.self).kind == .class)
-        #expect(Metadata(T2.self).kind == .struct)
-        #expect(Metadata(T3.self).kind == .enum)
-        
-        #expect(Metadata(Void?.self).kind == .optional)
-        #expect(Metadata(Int?.self).kind == .optional)
-        #expect(Metadata(T1?.self).kind == .optional)
-        #expect(Metadata((T1, T2)?.self).kind == .optional)
 
-        #expect(Metadata(Void.self).kind == .tuple)
-        #expect(Metadata((Int, Double?).self).kind == .tuple)
-        #expect(Metadata((T1, T2, T3).self).kind == .tuple)
-        
-        #expect(Metadata((() -> Void).self).kind == .function)
-        
-        #expect(Metadata(P.self).kind == .existential)
-        #expect(Metadata((any P).self).kind == .existential)
-        
-        #expect(Metadata(P.Protocol.self).kind == .metatype)
-        #expect(Metadata(type(of: Int.self)).kind == .metatype)
-    }
 }