implement a far more powerful signature pattern parser, that can handle complex type expressions

Author: tayloraswift

Sources/LinkResolution/UCF.Autograph.swift

@@ -20,9 +20,9 @@ extension UCF
 }
 extension UCF.Autograph
 {
-    static func ~= (predicate:UCF.PatternFilter, self:Self) -> Bool
+    static func ~= (filter:UCF.SignatureFilter, self:Self) -> Bool
     {
-        if  let inputs:[String?] = predicate.inputs
+        if  let inputs:[String?] = filter.inputs
         {
             guard self.inputs.count == inputs.count
             else
@@ -38,30 +38,14 @@ extension UCF.Autograph
             }
         }
 
-        switch predicate.output
+        if  let output:[String?] = filter.output
         {
-        case nil:
-            break
-
-        case .single(let output):
-            guard self.output.count == 1
-            else
-            {
-                return false
-            }
-
-            if  let output:String, output != self.output[0]
-            {
-                return false
-            }
-
-        case .tuple(let outputs):
-            guard self.output.count == outputs.count
+            guard self.output.count == output.count
             else
             {
                 return false
             }
-            for case (let required, let provided?) in zip(self.output, outputs)
+            for case (let required, let provided?) in zip(self.output, output)
             {
                 if  required != provided
                 {

Sources/LinkResolution/UCF.ResolvableOverload.swift

@@ -81,13 +81,13 @@ extension UCF.ResolvableOverload
         case .hash(let hash):
             return hash == self.hash
 
-        case .filter(let filter):
+        case .keywords(let filter):
             return filter ~= self.phylum
 
-        case .pattern(let pattern):
+        case .signature(let filter):
             if  let autograph:UCF.Autograph = self.autograph
             {
-                return pattern ~= autograph
+                return filter ~= autograph
             }
             else
             {

Sources/UCF/Codelinks/Grammar/UCF.ArrowRule.swift

@@ -0,0 +1,18 @@
+import Grammar
+
+extension UCF
+{
+    enum ArrowRule:ParsingRule
+    {
+        typealias Location = String.Index
+        typealias Terminal = Unicode.Scalar
+
+        static func parse<Source>(
+            _ input:inout ParsingInput<some ParsingDiagnostics<Source>>) throws
+            where Source:Collection<Terminal>, Source.Index == Location
+        {
+            try input.parse(as: UnicodeEncoding<Location, Terminal>.Hyphen.self)
+            try input.parse(as: UnicodeEncoding<Location, Terminal>.AngleRight.self)
+        }
+    }
+}

Sources/UCF/Codelinks/Grammar/UCF.BracketPatternRule.swift

@@ -0,0 +1,38 @@
+import Grammar
+
+extension UCF
+{
+    /// BracketPattern ::= '[' TypePattern ( ':' TypePattern ) ? ']'
+    enum BracketPatternRule:ParsingRule
+    {
+        typealias Location = String.Index
+        typealias Terminal = Unicode.Scalar
+
+        typealias Construction = (TypePattern, TypePattern?)
+
+        static func parse<Diagnostics>(
+            _ input:inout ParsingInput<Diagnostics>) throws -> Construction where
+            Diagnostics:ParsingDiagnostics,
+            Diagnostics.Source.Element == Terminal,
+            Diagnostics.Source.Index == Location
+        {
+            try input.parse(as: UnicodeEncoding<Location, Terminal>.BracketLeft.self)
+
+            let first:TypePattern = try input.parse(as: TypePatternRule.self)
+            let value:TypePattern?
+
+            if  case ()? = input.parse(as: UnicodeEncoding<Location, Terminal>.Colon?.self)
+            {
+                value = try input.parse(as: TypePatternRule.self)
+            }
+            else
+            {
+                value = nil
+            }
+
+            try input.parse(as: UnicodeEncoding<Location, Terminal>.BracketRight.self)
+
+            return (first, value)
+        }
+    }
+}

Sources/UCF/Codelinks/Grammar/UCF.FunctionPatternRule.swift

@@ -0,0 +1,31 @@
+import Grammar
+
+extension UCF
+{
+    /// FunctionPattern ::= TuplePattern ( '->' TypePattern ) ?
+    enum FunctionPatternRule:ParsingRule
+    {
+        typealias Location = String.Index
+        typealias Terminal = Unicode.Scalar
+
+        typealias Construction = ([TypePattern], TypePattern?)
+
+        static func parse<Diagnostics>(
+            _ input:inout ParsingInput<Diagnostics>) throws -> Construction where
+            Diagnostics:ParsingDiagnostics,
+            Diagnostics.Source.Element == Terminal,
+            Diagnostics.Source.Index == Location
+        {
+            let tuple:[TypePattern] = try input.parse(as: TuplePatternRule.self)
+
+            if  case ()? = input.parse(as: ArrowRule?.self)
+            {
+                return (tuple, try input.parse(as: TypePatternRule.self))
+            }
+            else
+            {
+                return (tuple, nil)
+            }
+        }
+    }
+}

Sources/UCF/Codelinks/Grammar/UCF.IdentifierError.swift

@@ -0,0 +1,7 @@
+extension UCF
+{
+    enum IdentifierError:Error
+    {
+        case reserved
+    }
+}

Sources/UCF/Codelinks/Grammar/UCF.IdentifierRule.FirstCodepoint.swift

@@ -0,0 +1,75 @@
+import Grammar
+
+extension UCF.IdentifierRule
+{
+    /// A parsing rule that matches a codepoint that can begin a Swift identifier.
+    enum FirstCodepoint:TerminalRule
+    {
+        typealias Location = String.Index
+        typealias Terminal = Unicode.Scalar
+        typealias Construction = Void
+
+        static func parse(terminal:Terminal) -> Void?
+        {
+            switch terminal
+            {
+            case    "a" ... "z",
+                    "A" ... "Z",
+                    "_",
+                    "\u{00A8}",
+                    "\u{00AA}",
+                    "\u{00AD}",
+                    "\u{00AF}",
+                    "\u{00B2}" ... "\u{00B5}",
+                    "\u{00B7}" ... "\u{00BA}",
+                    "\u{00BC}" ... "\u{00BE}",
+                    "\u{00C0}" ... "\u{00D6}",
+                    "\u{00D8}" ... "\u{00F6}",
+                    "\u{00F8}" ... "\u{00FF}",
+                    "\u{0100}" ... "\u{02FF}",
+                    "\u{0370}" ... "\u{167F}",
+                    "\u{1681}" ... "\u{180D}",
+                    "\u{180F}" ... "\u{1DBF}",
+                    "\u{1E00}" ... "\u{1FFF}",
+                    "\u{200B}" ... "\u{200D}",
+                    "\u{202A}" ... "\u{202E}",
+                    "\u{203F}" ... "\u{2040}",
+                    "\u{2054}",
+                    "\u{2060}" ... "\u{206F}",
+                    "\u{2070}" ... "\u{20CF}",
+                    "\u{2100}" ... "\u{218F}",
+                    "\u{2460}" ... "\u{24FF}",
+                    "\u{2776}" ... "\u{2793}",
+                    "\u{2C00}" ... "\u{2DFF}",
+                    "\u{2E80}" ... "\u{2FFF}",
+                    "\u{3004}" ... "\u{3007}",
+                    "\u{3021}" ... "\u{302F}",
+                    "\u{3031}" ... "\u{303F}",
+                    "\u{3040}" ... "\u{D7FF}",
+                    "\u{F900}" ... "\u{FD3D}",
+                    "\u{FD40}" ... "\u{FDCF}",
+                    "\u{FDF0}" ... "\u{FE1F}",
+                    "\u{FE30}" ... "\u{FE44}",
+                    "\u{FE47}" ... "\u{FFFD}",
+                    "\u{10000}" ... "\u{1FFFD}",
+                    "\u{20000}" ... "\u{2FFFD}",
+                    "\u{30000}" ... "\u{3FFFD}",
+                    "\u{40000}" ... "\u{4FFFD}",
+                    "\u{50000}" ... "\u{5FFFD}",
+                    "\u{60000}" ... "\u{6FFFD}",
+                    "\u{70000}" ... "\u{7FFFD}",
+                    "\u{80000}" ... "\u{8FFFD}",
+                    "\u{90000}" ... "\u{9FFFD}",
+                    "\u{A0000}" ... "\u{AFFFD}",
+                    "\u{B0000}" ... "\u{BFFFD}",
+                    "\u{C0000}" ... "\u{CFFFD}",
+                    "\u{D0000}" ... "\u{DFFFD}",
+                    "\u{E0000}" ... "\u{EFFFD}":
+                return ()
+
+            default:
+                return nil
+            }
+        }
+    }
+}

Sources/UCF/Codelinks/Grammar/UCF.IdentifierRule.NextCodepoint.swift

@@ -0,0 +1,29 @@
+import Grammar
+
+extension UCF.IdentifierRule
+{
+    /// A parsing rule that matches a codepoint that can occur in a Swift identifier, as long
+    /// as it is not the first codepoint.
+    enum NextCodepoint:TerminalRule
+    {
+        typealias Location = String.Index
+        typealias Terminal = Unicode.Scalar
+        typealias Construction = Void
+
+        static func parse(terminal:Terminal) -> Void?
+        {
+            switch terminal
+            {
+            case    "0" ... "9",
+                    "\u{0300}" ... "\u{036F}",
+                    "\u{1DC0}" ... "\u{1DFF}",
+                    "\u{20D0}" ... "\u{20FF}",
+                    "\u{FE20}" ... "\u{FE2F}":
+                return ()
+
+            default:
+                return UCF.IdentifierRule.FirstCodepoint.parse(terminal: terminal)
+            }
+        }
+    }
+}

Sources/UCF/Codelinks/Grammar/UCF.IdentifierRule.RawCodepoint.swift

@@ -0,0 +1,17 @@
+import Grammar
+
+extension UCF.IdentifierRule
+{
+    /// Matches any terminal that is not a backtick (`` ` ``).
+    enum RawCodepoint:TerminalRule
+    {
+        typealias Location = String.Index
+        typealias Terminal = Unicode.Scalar
+        typealias Construction = Void
+
+        static func parse(terminal:Terminal) -> Void?
+        {
+            terminal != "`" ? () : nil
+        }
+    }
+}

Sources/UCF/Codelinks/Grammar/UCF.IdentifierRule.swift

@@ -0,0 +1,42 @@
+import Grammar
+
+extension UCF
+{
+    /// Identifier ::= ( ``FirstCodepoint`` ``NextCodepoint`` * ) - 'Type' | '`' '`' ^ '`'
+    enum IdentifierRule:ParsingRule
+    {
+        typealias Location = String.Index
+        typealias Terminal = Unicode.Scalar
+
+        static func parse<Diagnostics>(
+            _ input:inout ParsingInput<Diagnostics>) throws -> Range<Location> where
+            Diagnostics:ParsingDiagnostics,
+            Diagnostics.Source.Element == Terminal,
+            Diagnostics.Source.Index == Location
+        {
+            let start:Location = input.index
+
+            if  case ()? = input.parse(as: FirstCodepoint?.self)
+            {
+                input.parse(as: NextCodepoint.self, in: Void.self)
+            }
+            else
+            {
+                try input.parse(as: UnicodeEncoding<Location, Terminal>.Backtick.self)
+                input.parse(as: RawCodepoint.self, in: Void.self)
+                try input.parse(as: UnicodeEncoding<Location, Terminal>.Backtick.self)
+            }
+
+            let end:Location = input.index
+
+            if  input[start ..< end].elementsEqual(["T", "y", "p", "e"])
+            {
+                throw IdentifierError.reserved
+            }
+            else
+            {
+                return start ..< end
+            }
+        }
+    }
+}