Merge pull request #401 from tayloraswift/custom-conditions

implement a way to pass custom defines from SSGC.CompileCommand down to SSGC.Linker.Tables

Author: tayloraswift

Package.resolved

@@ -95,7 +95,7 @@ let package:Package = .init(
         .package(url: "https://github.com/tayloraswift/swift-png", .upToNextMinor(
             from: "4.4.9")),
         .package(url: "https://github.com/tayloraswift/swift-ucf", .upToNextMinor(
-            from: "0.1.0")),
+            from: "0.2.0")),
         .package(url: "https://github.com/tayloraswift/swift-unixtime", .upToNextMinor(
             from: "0.2.0")),
 

Package.swift

@@ -0,0 +1,25 @@
+import UCF
+
+extension UCF
+{
+    @frozen @usableFromInline
+    enum ConditionError:Error
+    {
+        case value(Condition, String)
+        case valueExpected(Condition)
+    }
+}
+extension UCF.ConditionError:CustomStringConvertible
+{
+    @usableFromInline
+    var description:String
+    {
+        switch self
+        {
+        case .value(let condition, let value):
+            "value '\(value)' is invalid for condition '\(condition)'"
+        case .valueExpected(let condition):
+            "value expected for condition '\(condition)'"
+        }
+    }
+}

Sources/LinkResolution/Codelinks/UCF.ConditionFilter (ext).swift

@@ -0,0 +1,44 @@
+import UCF
+
+extension UCF.ConditionFilter
+{
+    @inlinable public
+    func value<T>(as _:T.Type = T.self) throws -> T where T:LosslessStringConvertible
+    {
+        guard
+        let value:String = self.value
+        else
+        {
+            throw UCF.ConditionError.valueExpected(self.label)
+        }
+
+        guard
+        let result:T = .init(value)
+        else
+        {
+            throw UCF.ConditionError.value(self.label, value)
+        }
+
+        return result
+    }
+
+    func callAsFunction<T>(as _:T.Type = T.self,
+        default:T) throws -> (UCF.Condition, T) where T:LosslessStringConvertible
+    {
+        guard
+        let value:String = self.value
+        else
+        {
+            return (self.label, `default`)
+        }
+
+        guard
+        let result:T = .init(value)
+        else
+        {
+            throw UCF.ConditionError.value(self.label, value)
+        }
+
+        return (self.label, result)
+    }
+}

Sources/LinkResolution/UCF.ConditionError.swift

@@ -14,111 +14,22 @@ extension UCF
         public
         let kinks:Phylum.Decl.Kinks
         public
+        let async:Bool
+        public
         let hash:FNV24
 
         @inlinable public
         init(autograph:Autograph?,
             phylum:Phylum.Decl,
             kinks:Phylum.Decl.Kinks,
+            async:Bool,
             hash:FNV24)
         {
             self.autograph = autograph
             self.phylum = phylum
             self.kinks = kinks
+            self.async = async
             self.hash = hash
         }
     }
 }
-extension UCF.DisambiguationTraits
-{
-    static func ~= (predicate:UCF.Predicate, self:Self) -> Bool
-    {
-        if  case nil = predicate.seal
-        {
-            //  Macros are currently the only kind of declaration that *must* be spelled with
-            //  trailing parentheses.
-            switch self.phylum
-            {
-            case .actor:                    break
-            case .associatedtype:           break
-            case .case:                     break
-            case .class:                    break
-            case .deinitializer:            break
-            case .enum:                     break
-            case .func:                     break
-            case .initializer:              break
-            case .macro:                    return false
-            case .operator:                 break
-            case .protocol:                 break
-            case .struct:                   break
-            case .subscript:                break
-            case .typealias:                break
-            case .var:                      break
-            }
-        }
-        else
-        {
-            switch self.phylum
-            {
-            case .actor:                    return false
-            case .associatedtype:           return false
-            case .case:                     break
-            case .class:                    return false
-            case .deinitializer:            return false
-            case .enum:                     return false
-            case .func:                     break
-            case .initializer:              break
-            case .macro:                    break
-            case .operator:                 break
-            case .protocol:                 return false
-            case .struct:                   return false
-            case .subscript:                break
-            case .typealias:                return false
-            case .var:                      return false
-            }
-        }
-
-        guard
-        let suffix:UCF.Selector.Suffix = predicate.suffix
-        else
-        {
-            return true
-        }
-
-        switch suffix
-        {
-        case .unidoc(let filter):
-            if  let signature:UCF.SignatureFilter = filter.signature
-            {
-                //  If a signature filter is present, the declaration must have an autograph.
-                guard
-                let autograph:UCF.Autograph = self.autograph, signature ~= autograph
-                else
-                {
-                    return false
-                }
-            }
-
-            let decl:(Phylum.Decl, Phylum.Decl.Kinks) = (self.phylum, self.kinks)
-            for condition:UCF.ConditionFilter in filter.conditions
-            {
-                guard condition ~= decl
-                else
-                {
-                    return false
-                }
-            }
-
-            return true
-
-        case .legacy(let filter, nil):
-            return filter ~= self.phylum
-
-        case .legacy(_, let hash?):
-            return hash == self.hash
-
-        case .hash(let hash):
-            return hash == self.hash
-        }
-    }
-}