support detection of the async keyword, and filtering overloads on asyncness

Author: tayloraswift

Sources/LinkResolution/UCF.DisambiguationTraits.swift

@@ -14,17 +14,21 @@ 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
         }
     }

Sources/LinkResolution/UCF.Predicate.swift

@@ -235,6 +235,7 @@ extension UCF.Predicate
             case (_,                        .class_var):        given = false
             case (_,                        .static_var):       given = false
 
+            case (_,                        .async):            given = traits.async
             case (_,                        .requirement):      given = kinks[is: .required]
             default:                                            continue
             }

Sources/MarkdownPluginSwift/Signatures/Signature.Expanded (ext).swift

@@ -123,18 +123,6 @@ extension Signature.Expanded
                         default:                break
                         }
                     }
-                    if  case .keyword = color
-                    {
-                        //  The `actor` and `async` keywords are contextual; there is no
-                        //  other way to detect them besides inspecting token text!
-                        switch String.init(decoding: utf8[range], as: Unicode.UTF8.self)
-                        {
-                        case "actor":           landmarks.keywords.actor = true
-                        case "class":           landmarks.keywords.class = true
-                        case "final":           landmarks.keywords.final = true
-                        default:                break
-                        }
-                    }
 
                     fallthrough
 

Sources/MarkdownPluginSwift/Signatures/SignatureLandmarks.InterestingKeywords.swift

@@ -8,6 +8,8 @@ extension SignatureLandmarks
         public
         var actor:Bool
         public
+        var async:Bool
+        public
         var attached:Bool
         public
         var `class`:Bool
@@ -17,13 +19,16 @@ extension SignatureLandmarks
         var freestanding:Bool
 
         @inlinable
-        init(actor:Bool = false,
+        init(
+            actor:Bool = false,
+            async:Bool = false,
             attached:Bool = false,
             `class`:Bool = false,
             final:Bool = false,
             freestanding:Bool = false)
         {
             self.actor = actor
+            self.async = async
             self.attached = attached
             self.class = `class`
             self.final = final

Sources/MarkdownPluginSwift/Signatures/SignatureSyntax.Builder.swift

@@ -52,28 +52,57 @@ extension SignatureSyntax.Builder<SignatureSyntax.ExpandedVisitor>
     {
         //  It’s easier to detect the return type this way, since we don’t inject any
         //  indentation markers into its syntax.
-        if  let decl:FunctionDeclSyntax = decl.as(FunctionDeclSyntax.self),
-            let returns:ReturnClauseSyntax = decl.signature.returnClause
+        if  let decl:InitializerDeclSyntax = decl.as(InitializerDeclSyntax.self)
         {
-            self.visitor.register(returns: returns.type)
+            self.visitor.mark(with: decl.modifiers)
+            self.visitor.mark(with: decl.signature.effectSpecifiers)
+        }
+        else if
+            let decl:FunctionDeclSyntax = decl.as(FunctionDeclSyntax.self)
+        {
+            self.visitor.mark(with: decl.modifiers)
+            self.visitor.mark(with: decl.signature.effectSpecifiers)
+            if  let returns:ReturnClauseSyntax = decl.signature.returnClause
+            {
+                self.visitor.register(returns: returns.type)
+            }
         }
         else if
             let decl:SubscriptDeclSyntax = decl.as(SubscriptDeclSyntax.self)
         {
+            self.visitor.mark(with: decl.modifiers)
+            self.visitor.mark(with: decl.accessorBlock)
+
             self.visitor.register(returns: decl.returnClause.type)
         }
         else if
             let decl:VariableDeclSyntax = decl.as(VariableDeclSyntax.self),
-            let type:TypeSyntax = decl.bindings.first?.typeAnnotation?.type
+            let binding:PatternBindingSyntax = decl.bindings.first
+        {
+            self.visitor.mark(with: decl.modifiers)
+            self.visitor.mark(with: binding.accessorBlock)
+            if  let type:TypeSyntax = binding.typeAnnotation?.type
+            {
+                self.visitor.register(returns: type)
+            }
+        }
+        else if
+            let decl:ActorDeclSyntax = decl.as(ActorDeclSyntax.self)
+        {
+            self.visitor.mark(with: decl.modifiers)
+            self.visitor.actor = true
+        }
+        else if
+            let decl:ClassDeclSyntax = decl.as(ClassDeclSyntax.self)
         {
-            self.visitor.register(returns: type)
+            self.visitor.mark(with: decl.modifiers)
         }
 
         for region:Syntax in decl.children(viewMode: .sourceAccurate)
         {
             if  let region:TokenSyntax = region.as(TokenSyntax.self)
             {
-                //  Allows us to detect phylum keywords.
+                //  Do we still need this?
                 self.encoder[at: .toplevel] += region
             }
             else if
@@ -84,7 +113,7 @@ extension SignatureSyntax.Builder<SignatureSyntax.ExpandedVisitor>
             else if
                 let region:DeclModifierListSyntax = region.as(DeclModifierListSyntax.self)
             {
-                //  Allows us to detect `class` modifier keywords.
+                //  Do we still need this?
                 self.encoder[at: .toplevel] += region
             }
             else if

Sources/MarkdownPluginSwift/Signatures/SignatureSyntax.ExpandedVisitor.swift

@@ -7,6 +7,14 @@ extension SignatureSyntax
     {
         let sugarMap:SugarMap
 
+        var actor:Bool
+        private(set)
+        var async:Bool
+        private(set)
+        var `class`:Bool
+        private(set)
+        var final:Bool
+
         private(set)
         var inputs:[String]
         private(set)
@@ -16,11 +24,16 @@ extension SignatureSyntax
         init(sugaring sugarMap:SugarMap)
         {
             self.sugarMap = sugarMap
+            self.actor = false
+            self.async = false
+            self.class = false
+            self.final = false
             self.inputs = []
             self.output = []
         }
     }
 }
+
 extension SignatureSyntax.ExpandedVisitor:SignatureVisitor
 {
     mutating
@@ -35,6 +48,48 @@ extension SignatureSyntax.ExpandedVisitor:SignatureVisitor
     }
 }
 extension SignatureSyntax.ExpandedVisitor
+{
+    mutating
+    func mark(with modifiers:DeclModifierListSyntax)
+    {
+        for modifier:DeclModifierSyntax in modifiers
+        {
+            switch modifier.name.tokenKind
+            {
+            case .keyword(.class):  self.class = true
+            case .keyword(.final):  self.final = true
+            default:                continue
+            }
+        }
+    }
+
+    mutating
+    func mark(with effects:FunctionEffectSpecifiersSyntax?)
+    {
+        if  case .keyword(.async)? = effects?.asyncSpecifier?.tokenKind
+        {
+            self.async = true
+        }
+    }
+
+    mutating
+    func mark(with accessorBlock:AccessorBlockSyntax?)
+    {
+        if  case .accessors(let accessors)? = accessorBlock?.accessors
+        {
+            for accessor:AccessorDeclSyntax in accessors
+            {
+                if  let effects:AccessorEffectSpecifiersSyntax = accessor.effectSpecifiers,
+                    case .keyword(.get) = accessor.accessorSpecifier.tokenKind,
+                    case .keyword(.async)? = effects.asyncSpecifier?.tokenKind
+                {
+                    self.async = true
+                }
+            }
+        }
+    }
+}
+extension SignatureSyntax.ExpandedVisitor
 {
     mutating
     func register(returns:TypeSyntax)

Sources/MarkdownPluginSwift/Signatures/SignatureSyntax.swift

@@ -86,6 +86,11 @@ extension SignatureSyntax
 
         builder.encode(decl: .parse(from: &parser))
 
+        landmarks.keywords.actor = builder.visitor.actor
+        landmarks.keywords.async = builder.visitor.async
+        landmarks.keywords.class = builder.visitor.class
+        landmarks.keywords.final = builder.visitor.final
+
         landmarks.inputs = builder.visitor.inputs
         landmarks.output = builder.visitor.output
 

Sources/MarkdownPluginSwiftTests/InterestingKeywords.swift

@@ -26,6 +26,63 @@ struct InterestingKeywords
         #expect("\(signature.bytecode.safe)" == decl)
         #expect(self.landmarks.keywords.actor)
     }
+
+    @Test mutating
+    func Async1()
+    {
+        let decl:String = "func f() async"
+
+        let signature:Signature<Never>.Expanded = .init(decl,
+            landmarks: &self.landmarks)
+
+        #expect("\(signature.bytecode.safe)" == decl)
+        #expect(self.landmarks.keywords.async)
+    }
+    @Test mutating
+    func Async2()
+    {
+        let decl:String = "func async(async: Int)"
+
+        let signature:Signature<Never>.Expanded = .init(decl,
+            landmarks: &self.landmarks)
+
+        #expect("\(signature.bytecode.safe)" == decl)
+        #expect(!self.landmarks.keywords.async)
+    }
+    @Test mutating
+    func Async3()
+    {
+        let decl:String = "func f(_: (Int) async -> ())"
+
+        let signature:Signature<Never>.Expanded = .init(decl,
+            landmarks: &self.landmarks)
+
+        #expect("\(signature.bytecode.safe)" == decl)
+        #expect(!self.landmarks.keywords.async)
+    }
+    @Test mutating
+    func Async4()
+    {
+        let decl:String = "subscript(i: Int) { get async throws set }"
+
+        let signature:Signature<Never>.Expanded = .init(decl,
+            landmarks: &self.landmarks)
+
+        #expect("\(signature.bytecode.safe)" == decl)
+        #expect(self.landmarks.keywords.async)
+    }
+    @Test mutating
+    func Async5()
+    {
+        let decl:String = "var x: Int { get async set }"
+
+        let signature:Signature<Never>.Expanded = .init(decl,
+            landmarks: &self.landmarks)
+
+        #expect("\(signature.bytecode.safe)" == decl)
+        #expect(self.landmarks.keywords.async)
+    }
+
     @Test mutating
     func Final()
     {

Sources/SymbolGraphCompiler/Declarations/SSGC.Decl.swift

@@ -26,6 +26,8 @@ extension SSGC
         public
         let phylum:Phylum.Decl
         public
+        let async:Bool
+        public
         let path:UnqualifiedPath
 
         /// Protocol requirements.
@@ -67,6 +69,7 @@ extension SSGC
             phylum:Phylum.Decl,
             path:UnqualifiedPath,
             kinks:Phylum.Decl.Kinks,
+            async:Bool,
             comment:DocumentationComment?)
         {
             self.id = id
@@ -75,6 +78,7 @@ extension SSGC
             self.autograph = autograph
             self.location = location
             self.phylum = phylum
+            self.async = async
             self.path = path
 
             self.requirements = []
@@ -96,6 +100,7 @@ extension SSGC.Decl
             autograph: self.autograph,
             phylum: self.phylum,
             kinks: self.kinks,
+            async: self.async,
             hash: .decl(self.id))
     }
 
@@ -106,6 +111,7 @@ extension SSGC.Decl
             autograph: self.autograph,
             phylum: self.phylum,
             kinks: self.kinks,
+            async: self.async,
             hash: .decl(.init(self.id, self: heir)))
     }
 }

Sources/SymbolGraphCompiler/Declarations/SSGC.DeclAlias.swift

@@ -16,19 +16,23 @@ extension SSGC
         public
         let kinks:Phylum.Decl.Kinks
         public
+        let async:Bool
+        public
         let path:UnqualifiedPath
         public
         let documented:Bool
 
         init(autograph:UCF.Autograph?,
             phylum:Phylum.Decl,
             kinks:Phylum.Decl.Kinks,
+            async:Bool,
             path:UnqualifiedPath,
             documented:Bool)
         {
             self.autograph = autograph
             self.phylum = phylum
             self.kinks = kinks
+            self.async = async
             self.path = path
             self.documented = documented
         }
@@ -42,6 +46,7 @@ extension SSGC.DeclAlias
             autograph: decl.autograph,
             phylum: decl.phylum,
             kinks: decl.kinks,
+            async: decl.async,
             path: decl.path,
             documented: decl.comment != nil)
     }

Sources/SymbolGraphCompiler/Declarations/SSGC.Declarations.swift

@@ -85,6 +85,7 @@ extension SSGC.Declarations
                     phylum: phylum,
                     path: vertex.path,
                     kinks: kinks,
+                    async: vertex.async,
                     comment: vertex.doccomment.map { .init($0.text, at: $0.start) } ?? nil))
 
             $0 = decl

Sources/SymbolGraphLinker/SSGC.Linker.swift

@@ -337,6 +337,7 @@ extension SSGC.Linker
                         autograph: feature.autograph,
                         phylum: feature.phylum,
                         kinks: feature.kinks,
+                        async: feature.async,
                         hash: .decl(.init(id, self: $0.extendee.id))),
                     decl: f,
                     heir: extendee,