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

Package.swift

@@ -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")),
 

Sources/LinkResolution/UCF.ConditionError.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/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.DisambiguationTraits.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
- }
- }
-}