Reimplement inlay hints using CollectVariableType

Query VariableTypeInfos from sourcekitd and return inlay hints for all
variable declarations without an explicit type annotation.

Author: fwcd

Sources/SourceKitD/SKDResponseDictionary.swift

@@ -32,6 +32,9 @@ public final class SKDResponseDictionary {
   public subscript(key: sourcekitd_uid_t?) -> Int? {
     return Int(sourcekitd.api.variant_dictionary_get_int64(dict, key))
   }
+  public subscript(key: sourcekitd_uid_t?) -> Bool? {
+    return sourcekitd.api.variant_dictionary_get_bool(dict, key)
+  }
   public subscript(key: sourcekitd_uid_t?) -> sourcekitd_uid_t? {
     return sourcekitd.api.variant_dictionary_get_uid(dict, key)
   }

Sources/SourceKitLSP/Swift/SwiftLanguageServer.swift

@@ -1055,77 +1055,33 @@ extension SwiftLanguageServer {
   }
 
   public func inlayHints(_ req: Request<InlayHintsRequest>) {
-    // TODO: Introduce a new SourceKit request for inlay hints
-    // instead of computing them from document symbols here.
-
     guard req.params.only?.contains(.type) ?? true else {
       req.reply([])
       return
     }
 
     let uri = req.params.textDocument.uri
-    documentSymbols(uri) { symbolsResult in
+    variableTypeInfos(uri) { infosResult in
       do {
-        /// Filters all the document symbols for which inlay type hints
-        /// should be displayed, i.e. variable bindings, fields and properties.
-        func bindings(_ symbols: [DocumentSymbol]) -> [DocumentSymbol] {
-          symbols
-            .flatMap { bindings($0.children ?? []) + ([.variable, .field, .property].contains($0.kind) ? [$0] : []) }
-        }
-
-        let symbols = try symbolsResult.get()
-        let bindingPositions = Set(bindings(symbols).map { $0.range.upperBound })
-
-        self.expressionTypeInfos(uri) { infosResult in
-          do {
-            let infos = try infosResult.get()
-
-            // The unfiltered infos may contain multiple infos for a single position
-            // as the ending position does not necessarily identify an expression uniquely.
-            // Consider the following example:
-            //
-            //    var x = "abc" + "def"
-            //
-            // Both `"abc" + "def"` and `"def"` are matching expressions. Since we are only
-            // interested in the first expression, i.e. the one that corresponds to the
-            // bound expression, we have to do some pre-processing here. Note that this
-            // mechanism currently relies on the outermost expression being reported first.
-
-            var visitedPositions: Set<Position> = []
-            var processedInfos: [ExpressionTypeInfo] = []
-
-            // TODO: Compute inlay hints only for the requested range/categories
-            // instead of filtering them afterwards.
-
-            for info in infos {
-              let pos = info.range.upperBound
-              if (req.params.range?.contains(pos) ?? true)
-                && bindingPositions.contains(pos)
-                && !visitedPositions.contains(pos) {
-                processedInfos.append(info)
-                visitedPositions.insert(pos)
-              }
-            }
-
-            let hints = processedInfos
-              .lazy
-              .map { info in
-                InlayHint(
-                  position: info.range.upperBound,
-                  category: .type,
-                  label: info.printedType
-                )
-              }
-
-            req.reply(.success(Array(hints)))
-          } catch {
-            let message = "expression types for inlay hints failed for \(uri): \(error)"
-            log(message, level: .warning)
-            req.reply(.failure(.unknown(message)))
+        let infos = try infosResult.get()
+        let hints = infos
+          .lazy
+          .filter { info in
+            // TODO: Include range in CollectVariableType request directly
+            (req.params.range?.contains(info.range.upperBound) ?? true)
+            && !info.hasExplicitType
           }
-        }
+          .map { info in
+            InlayHint(
+              position: info.range.upperBound,
+              category: .type,
+              label: info.printedType
+            )
+          }
+
+        req.reply(.success(Array(hints)))
       } catch {
-        let message = "document symbols for inlay hints failed for \(uri): \(error)"
+        let message = "variable types for inlay hints failed for \(uri): \(error)"
         log(message, level: .warning)
         req.reply(.failure(.unknown(message)))
       }

Sources/SourceKitLSP/Swift/VariableTypeInfo.swift

@@ -20,6 +20,8 @@ struct VariableTypeInfo {
   var range: Range<Position>
   /// The printed type of the variable.
   var printedType: String
+  /// Whether the variable has an explicit type annotation in the source file.
+  var hasExplicitType: Bool
 
   init?(_ dict: SKDResponseDictionary, in snapshot: DocumentSnapshot) {
     let keys = dict.sourcekitd.keys
@@ -28,12 +30,14 @@ struct VariableTypeInfo {
           let length: Int = dict[keys.variable_length],
           let startIndex = snapshot.positionOf(utf8Offset: offset),
           let endIndex = snapshot.positionOf(utf8Offset: offset + length),
-          let printedType: String = dict[keys.variable_type] else {
+          let printedType: String = dict[keys.variable_type],
+          let hasExplicitType: Bool = dict[keys.variable_type_explicit] else {
       return nil
     }
 
     self.range = startIndex..<endIndex
     self.printedType = printedType
+    self.hasExplicitType = hasExplicitType
   }
 }