include more symbols in the lunr search, and deprioritize deprecated and @_spi symbols in search results

Author: tayloraswift

Assets/js/Main.js

@@ -0,0 +1,13 @@
+import JSON
+
+extension Unidoc.Linker.TreeMapper
+{
+    enum Flags:Int
+    {
+        case deprecated = 0
+        case spi = 1
+    }
+}
+extension Unidoc.Linker.TreeMapper.Flags:JSONEncodable, JSONDecodable
+{
+}

Assets/js/Main.js.map

@@ -44,18 +44,45 @@ extension Unidoc.Linker.TreeMapper
     {
         self.local[vertex.id] = (vertex.shoot, vertex.flags)
 
+        var flags:Flags?
+        {
+            if !vertex.signature.availability.isGenerallyRecommended
+            {
+                return .deprecated
+            }
+            else if case _? = vertex.signature.spis
+            {
+                return .spi
+            }
+            else
+            {
+                return nil
+            }
+        }
+
         switch vertex.phylum
         {
         case .actor, .class, .struct, .enum, .protocol, .macro(.attached):
             self.trees[vertex.culture, default: []].types[vertex.shoot] =
                 (.culture, vertex.flags)
 
-        case .func(nil), .var(nil), .macro(.freestanding):
-            //  Global procedures show up in search, but not in the type tree.
-            self.trees[vertex.culture, default: []].procs.append(vertex.shoot)
+        case .typealias:
+            //  Typealiases show up in search, but not in the type tree. Typealiases are often
+            //  deprecated, and disappear from signatures. That’s why people search for them.
+            fallthrough
+
+        case .associatedtype, .case, .func, .macro(.freestanding), .var:
+            //  Don’t include C declarations in search.
+            if  vertex.flags.cdecl
+            {
+                break
+            }
+
+            self.trees[vertex.culture, default: []].extra.append((vertex.shoot, flags))
 
-        case _:
-            return
+        case .operator, .deinitializer, .initializer, .subscript:
+            //  These all look the same, so they probably wouldn’t be very useful in search.
+            break
         }
     }
 }
@@ -206,12 +233,13 @@ extension Unidoc.Linker.TreeMapper
                                 $0["h"] = noun.shoot.hash?.value
                             }
                         }
-                        for shoot:Unidoc.Shoot in members.procs
+                        for (shoot, flags):(Unidoc.Shoot, Flags?) in members.extra
                         {
                             $0[+, Any.self]
                             {
                                 $0["s"] = shoot.stem.rawValue
                                 $0["h"] = shoot.hash?.value
+                                $0["f"] = flags
                             }
                         }
                     }

Sources/UnidocLinker/Sema/Unidoc.Linker.TreeMapper.Flags.swift

@@ -6,24 +6,24 @@ extension Unidoc.Linker
     struct TreeMembers
     {
         var articles:[Unidoc.Noun]
-        var procs:[Unidoc.Shoot]
         var types:[Unidoc.Shoot: (Unidoc.Citizenship, Phylum.DeclFlags)]
+        var extra:[(Unidoc.Shoot, TreeMapper.Flags?)]
 
         private
         init(articles:[Unidoc.Noun],
-            procs:[Unidoc.Shoot],
-            types:[Unidoc.Shoot: (Unidoc.Citizenship, Phylum.DeclFlags)])
+            types:[Unidoc.Shoot: (Unidoc.Citizenship, Phylum.DeclFlags)],
+            extra:[(Unidoc.Shoot, TreeMapper.Flags?)] = [])
         {
             self.articles = articles
-            self.procs = procs
             self.types = types
+            self.extra = extra
         }
     }
 }
 extension Unidoc.Linker.TreeMembers:ExpressibleByArrayLiteral
 {
     init(arrayLiteral:Never...)
     {
-        self.init(articles: [], procs: [], types: [:])
+        self.init(articles: [], types: [:], extra: [])
     }
 }

Sources/UnidocLinker/Sema/Unidoc.Linker.TreeMapper.swift

@@ -1,5 +1,6 @@
 export type ModularSymbol = {
     module: string;
+    weight: number;
     keywords: string[];
     display: string;
     uri: string;

Sources/UnidocLinker/Sema/Unidoc.Linker.TreeMembers.swift

@@ -1,4 +1,4 @@
 export interface NounMapCulture {
     c: string;
-    n: { s: string, h: number }[];
+    n: { s: string, h: number, f?: number }[];
 }

TypeScript/Sources/AnySymbol.ts

@@ -20,9 +20,9 @@ export class SearchRunner {
             for (let i = 0; i < symbols.length; i++) {
                 const symbol: AnySymbol = symbols[i];
                 if ('module' in symbol) {
-                    this.add({ i: i, mwords: symbol.keywords });
+                    this.add({ i: i, mwords: symbol.keywords }, { boost: symbol.weight });
                 } else {
-                    this.add({ i: i, pwords: symbol.keywords });
+                    this.add({ i: i, pwords: symbol.keywords }, { boost: 10 });
                 }
             }
         });

TypeScript/Sources/NounMapCulture.ts

@@ -100,10 +100,20 @@ export class Searchbar {
                                     .replaceAll(' ', '/')
                                     .toLowerCase();
 
+                                var weight: number = 10;
+                                if (noun.f == 0) {
+                                    //  Symbol is deprecated.
+                                    weight = 5;
+                                } else if (noun.f == 1) {
+                                    //  Symbol is @_spi.
+                                    weight = 1;
+                                }
+
                                 const stem: string[] = noun.s.split(/\s+/);
 
                                 symbols.push({
                                     module: module,
+                                    weight: weight,
                                     keywords: stem,
                                     display: stem.slice(1).join('.'),
                                     uri: uri