feat: 'unknown identifier' code actions (leanprover#7665)

This PR adds support for code actions that resolve 'unknown identifier'
errors by either importing the missing declaration or by changing the
identifier to one from the environment.

<details>
<summary>Demo (Click to open)</summary>


![Demo](https://github.com/user-attachments/assets/ba575860-b76d-4213-8cd7-a5525cd60287)
</details>

Specifically, the following kinds of code actions are added by this PR,
all of which are triggered on 'unknown identifier' errors:
- A code action to import the module containing the identifier at the
text cursor position.
- A code action to change the identifier at the text cursor position to
one from the environment.
- A source action to import the modules for all unambiguous identifiers
in the file.

### Details
When clicking on an identifier with an 'unknown identifier' diagnostic,
after a debounce delay of 1000ms, the language server looks up the
(potentially partial) identifier at the position of the cursor in the
global reference data structure by fuzzy-matching against all
identifiers and collects the 10 closest matching entries. This search
accounts for open namespaces at the position of the cursor, including
the namespace of the type / expected type when using dot notation. The
10 closest matching entries are then offered to the user as code
actions:
- If the suggested identifier is not contained in the environment, a
code action that imports the module that the identifier is contained in
and changes the identifier to the suggested one is offered. The
suggestion is inserted in a "minimal" manner, i.e. by accounting for
open namespaces.
- If the suggested identifier is contained in the environment, a code
action that only changes the identifier to the suggested one is offered.
- If the suggested identifier is not contained in the environment and
the suggested identifier is a perfectly unambiguous match, a source
action to import all unambiguous in the file is offered.

The source action to import all unambiguous identifiers can also always
be triggered by right-clicking in the document and selecting the 'Source
Action...' entry.

At the moment, for large projects, the search for closely matching
identifiers in the global reference data structure is still a bit slow.
I hope to optimize it next quarter.

### Implementation notes
- Since the global reference data structure is in the watchdog process,
whereas the elaboration information is in the file worker process, this
PR implements support for file worker -> watchdog requests, including a
new `$/lean/queryModule` request that can be used by the file worker to
request global identifier information.
- To identify 'unknown identifier' errors, several 'unknown identifier'
errors in the elaborator are tagged with a new tag.
- The debounce delay of 1000ms is necessary because VS Code will
re-request code actions while editing an unknown identifier and also
while hovering over the identifier.
- We also implement cancellation for these 'unknown identifier' code
actions. Once the file worker responds to the request as having been
cancelled, the watchdog cancels its computation of all corresponding
file worker -> watchdog requests, too.
- Aliases (i.e. `export`) are currently not accounted for. I've found
that we currently don't handle them correctly in auto-completion, too,
so we will likely add support for this later when fixing the
corresponding auto-completion issue.
- The new code actions added by this request support incrementality.

Author: mhuisi

src/Lean/Data/Lsp/Diagnostics.lean

@@ -145,34 +145,12 @@ structure DiagnosticWith (α : Type) where
   /-- An array of related diagnostic information, e.g. when symbol-names within a scope collide all definitions can be marked via this property. -/
   relatedInformation? : Option (Array DiagnosticRelatedInformation) := none
   /-- A data entry field that is preserved between a `textDocument/publishDiagnostics` notification and `textDocument/codeAction` request. -/
-  data?: Option Json := none
+  data? : Option Json := none
   deriving Inhabited, BEq, ToJson, FromJson
 
 def DiagnosticWith.fullRange (d : DiagnosticWith α) : Range :=
   d.fullRange?.getD d.range
 
-attribute [local instance] Ord.arrayOrd in
-/-- Restriction of `DiagnosticWith` to properties that are displayed to users in the InfoView. -/
-private structure DiagnosticWith.UserVisible (α : Type) where
-  range               : Range
-  fullRange?          : Option Range
-  severity?           : Option DiagnosticSeverity
-  code?               : Option DiagnosticCode
-  source?             : Option String
-  message             : α
-  tags?               : Option (Array DiagnosticTag)
-  relatedInformation? : Option (Array DiagnosticRelatedInformation)
-  deriving Ord
-
-/-- Extracts user-visible properties from the given `DiagnosticWith`. -/
-private def DiagnosticWith.UserVisible.ofDiagnostic (d : DiagnosticWith α)
-    : DiagnosticWith.UserVisible α :=
-  { d with }
-
-/-- Compares `DiagnosticWith` instances modulo non-user-facing properties. -/
-def compareByUserVisible [Ord α] (a b : DiagnosticWith α) : Ordering :=
-  compare (DiagnosticWith.UserVisible.ofDiagnostic a) (DiagnosticWith.UserVisible.ofDiagnostic b)
-
 abbrev Diagnostic := DiagnosticWith String
 
 /-- Parameters for the [`textDocument/publishDiagnostics` notification](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_publishDiagnostics). -/

src/Lean/Data/Lsp/Internal.lean

@@ -7,6 +7,7 @@ Authors: Joscha Mennicken
 prelude
 import Lean.Expr
 import Lean.Data.Lsp.Basic
+import Lean.Data.JsonRpc
 import Std.Data.TreeMap
 
 set_option linter.missingDocs true -- keep it documented
@@ -201,4 +202,62 @@ structure LeanStaleDependencyParams where
   staleDependency : DocumentUri
   deriving FromJson, ToJson
 
+/-- LSP type for `Lean.OpenDecl`. -/
+inductive OpenNamespace
+  /-- All declarations in `«namespace»` are opened, except for `exceptions`. -/
+  | allExcept («namespace» : Name) (exceptions : Array Name)
+  /-- The declaration `«from»` is renamed to `to`. -/
+  | renamed («from» : Name) (to : Name)
+  deriving FromJson, ToJson
+
+/-- Query in the `$/lean/queryModule` watchdog <- worker request. -/
+structure LeanModuleQuery where
+  /-- Identifier (potentially partial) to query. -/
+  identifier : String
+  /--
+  Namespaces that are open at the position of `identifier`.
+  Used for accurately matching declarations against `identifier` in context.
+  -/
+  openNamespaces : Array OpenNamespace
+  deriving FromJson, ToJson
+
+/--
+Used in the `$/lean/queryModule` watchdog <- worker request, which is used by the worker to
+extract information from the .ilean information in the watchdog.
+-/
+structure LeanQueryModuleParams where
+  /--
+  The request ID in the context of which this worker -> watchdog request was emitted.
+  Used for cancelling this request in the watchdog.
+  -/
+  sourceRequestID : JsonRpc.RequestID
+  /-- Module queries for extracting .ilean information in the watchdog. -/
+  queries : Array LeanModuleQuery
+  deriving FromJson, ToJson
+
+/-- Result entry of a module query. -/
+structure LeanIdentifier where
+  /-- Module that `decl` is defined in. -/
+  module : Name
+  /-- Full name of the declaration that matches the query. -/
+  decl : Name
+  /-- Whether this `decl` matched the query exactly. -/
+  isExactMatch : Bool
+  deriving FromJson, ToJson
+
+/--
+Result for a single module query.
+Identifiers in the response are sorted descendingly by how well they match the query.
+-/
+abbrev LeanQueriedModule := Array LeanIdentifier
+
+/-- Response for the `$/lean/queryModule` watchdog <- worker request. -/
+structure LeanQueryModuleResponse where
+  /--
+  Results for each query in `LeanQueryModuleParams`.
+  Positions correspond to `queries` in the parameter of the request.
+  -/
+  queryResults : Array LeanQueriedModule
+  deriving FromJson, ToJson, Inhabited
+
 end Lean.Lsp

src/Lean/Elab/App.lean

@@ -1222,8 +1222,8 @@ private def resolveLValAux (e : Expr) (eType : Expr) (lval : LVal) : TermElabM L
     -- Then search the environment
     if let some (baseStructName, fullName) ← findMethod? structName (.mkSimple fieldName) then
       return LValResolution.const baseStructName structName fullName
-    throwLValError e eType
-      m!"invalid field '{fieldName}', the environment does not contain '{Name.mkStr structName fieldName}'"
+    let msg := mkUnknownIdentifierMessage m!"invalid field '{fieldName}', the environment does not contain '{Name.mkStr structName fieldName}'"
+    throwLValError e eType msg
   | none, LVal.fieldName _ _ (some suffix) _ =>
     if e.isConst then
       throwUnknownConstant (e.constName! ++ suffix)
@@ -1502,7 +1502,7 @@ where
       else if let some (fvar, []) ← resolveLocalName idNew then
         return fvar
       else
-        throwError "invalid dotted identifier notation, unknown identifier `{idNew}` from expected type{indentExpr expectedType}"
+        throwUnknownIdentifier m!"invalid dotted identifier notation, unknown identifier `{idNew}` from expected type{indentExpr expectedType}"
     catch
       | ex@(.error ..) =>
         match (← unfoldDefinition? resultType) with
@@ -1550,7 +1550,7 @@ private partial def elabAppFn (f : Syntax) (lvals : List LVal) (namedArgs : Arra
     | `(@$_)     => throwUnsupportedSyntax -- invalid occurrence of `@`
     | `(_)       => throwError "placeholders '_' cannot be used where a function is expected"
     | `(.$id:ident) =>
-        addCompletionInfo <| CompletionInfo.dotId f id.getId (← getLCtx) expectedType?
+        addCompletionInfo <| CompletionInfo.dotId id id.getId (← getLCtx) expectedType?
         let fConst ← resolveDotName id expectedType?
         let s ← observing do
           -- Use (force := true) because we want to record the result of .ident resolution even in patterns

src/Lean/Elab/Term.lean

@@ -1971,7 +1971,7 @@ where
            isValidAutoBoundImplicitName n (relaxedAutoImplicit.get (← getOptions)) then
         throwAutoBoundImplicitLocal n
       else
-        throwError "unknown identifier '{Lean.mkConst n}'"
+        throwUnknownIdentifier m!"unknown identifier '{Lean.mkConst n}'"
     mkConsts candidates explicitLevels
 
 /--

src/Lean/Exception.lean

@@ -69,9 +69,31 @@ protected def throwError [Monad m] [MonadError m] (msg : MessageData) : m α :=
   let (ref, msg) ← AddErrorMessageContext.add ref msg
   throw <| Exception.error ref msg
 
+/--
+Tag used for `unknown identifier` messages.
+This tag is used by the 'import unknown identifier' code action to detect messages that should
+prompt the code action.
+-/
+def unknownIdentifierMessageTag : Name := `unknownIdentifier
+
+/--
+Creates a `MessageData` that is tagged with `unknownIdentifierMessageTag`.
+This tag is used by the 'import unknown identifier' code action to detect messages that should
+prompt the code action.
+-/
+def mkUnknownIdentifierMessage (msg : MessageData) : MessageData :=
+  MessageData.tagged unknownIdentifierMessageTag msg
+
+/--
+Throw an unknown identifier error message that is tagged with `unknownIdentifierMessageTag`.
+See also `mkUnknownIdentifierMessage`.
+-/
+def throwUnknownIdentifier [Monad m] [MonadError m] (msg : MessageData) : m α :=
+  Lean.throwError <| mkUnknownIdentifierMessage msg
+
 /-- Throw an unknown constant error message. -/
 def throwUnknownConstant [Monad m] [MonadError m] (constName : Name) : m α :=
-  Lean.throwError m!"unknown constant '{.ofConstName constName}'"
+  throwUnknownIdentifier m!"unknown constant '{.ofConstName constName}'"
 
 /-- Throw an error exception using the given message data and reference syntax. -/
 protected def throwErrorAt [Monad m] [MonadError m] (ref : Syntax) (msg : MessageData) : m α := do

src/Lean/Server/AsyncList.lean

@@ -80,7 +80,7 @@ partial def getFinishedPrefix : AsyncList ε α → BaseIO (List α × Option ε
     else pure ⟨[], none, false⟩
 
 partial def getFinishedPrefixWithTimeout (xs : AsyncList ε α) (timeoutMs : UInt32)
-    (cancelTk? : Option (ServerTask Unit) := none) : BaseIO (List α × Option ε × Bool) := do
+    (cancelTks : List (ServerTask Unit) := []) : BaseIO (List α × Option ε × Bool) := do
   let timeoutTask : ServerTask (Unit ⊕ Except ε (AsyncList ε α)) ←
     if timeoutMs == 0 then
       pure <| ServerTask.pure (Sum.inl ())
@@ -100,21 +100,17 @@ where
     | delayed tl =>
       let tl : ServerTask (Except ε (AsyncList ε α)) := tl
       let tl := tl.mapCheap .inr
-      let cancelTk? := do return (← cancelTk?).mapCheap .inl
-      let tasks : { t : List _ // t.length > 0 } :=
-        match cancelTk? with
-        | none => ⟨[tl, timeoutTask], by exact Nat.zero_lt_succ _⟩
-        | some cancelTk => ⟨[tl, cancelTk, timeoutTask], by exact Nat.zero_lt_succ _⟩
-      let r ← ServerTask.waitAny tasks.val (h := tasks.property)
+      let cancelTks := cancelTks.map (·.mapCheap .inl)
+      let r ← ServerTask.waitAny (tl :: cancelTks ++ [timeoutTask])
       match r with
       | .inl _ => return ⟨[], none, false⟩ -- Timeout or cancellation - stop waiting
       | .inr (.ok tl) => go timeoutTask tl
       | .inr (.error e) => return ⟨[], some e, true⟩
 
 partial def getFinishedPrefixWithConsistentLatency (xs : AsyncList ε α) (latencyMs : UInt32)
-    (cancelTk? : Option (ServerTask Unit) := none) : BaseIO (List α × Option ε × Bool) := do
+    (cancelTks : List (ServerTask Unit) := []) : BaseIO (List α × Option ε × Bool) := do
   let timestamp ← IO.monoMsNow
-  let r ← xs.getFinishedPrefixWithTimeout latencyMs cancelTk?
+  let r ← xs.getFinishedPrefixWithTimeout latencyMs cancelTks
   let passedTimeMs := (← IO.monoMsNow) - timestamp
   let remainingLatencyMs := (latencyMs.toNat - passedTimeMs).toUInt32
   sleepWithCancellation remainingLatencyMs
@@ -123,14 +119,14 @@ where
   sleepWithCancellation (sleepDurationMs : UInt32) : BaseIO Unit := do
     if sleepDurationMs == 0 then
       return
-    let some cancelTk := cancelTk?
-      | IO.sleep sleepDurationMs
-        return
-    if ← cancelTk.hasFinished then
+    if cancelTks.isEmpty then
+      IO.sleep sleepDurationMs
+      return
+    if ← cancelTks.anyM (·.hasFinished) then
       return
     let sleepTask ← Lean.Server.ServerTask.BaseIO.asTask do
       IO.sleep sleepDurationMs
-    ServerTask.waitAny [sleepTask, cancelTk]
+    ServerTask.waitAny <| sleepTask :: cancelTks
 
 end AsyncList
 

src/Lean/Server/CodeActions/Basic.lean

@@ -147,7 +147,7 @@ def handleCodeActionResolve (param : CodeAction) : RequestM (RequestTask CodeAct
   let doc ← readDoc
   let some data := param.data?
     | throw (RequestError.invalidParams "Expected a data field on CodeAction.")
-  let data : CodeActionResolveData ← liftExcept <| Except.mapError RequestError.invalidParams <| fromJson? data
+  let data ← RequestM.parseRequestParams CodeActionResolveData data
   let pos := doc.meta.text.lspPosToUtf8Pos data.params.range.end
   withWaitFindSnap doc (fun s => s.endPos ≥ pos)
     (notFoundX := throw <| RequestError.internalError "snapshot not found")