For general server architecture, see README.md. For details of IPC communication, see Watchdog.lean. This module implements per-file worker processes.

File processing and requests+notifications against a file should be concurrent for two reasons:

• By the LSP standard, requests should be cancellable.
• Since Lean allows arbitrary user code to be executed during elaboration via the tactic framework, elaboration can be extremely slow and even not halt in some cases. Users should be able to work with the file while this is happening, e.g. make new changes to the file or send requests.

To achieve these goals, elaboration is executed in a chain of tasks, where each task corresponds to the elaboration of one command. When the elaboration of one command is done, the next task is spawned. On didChange notifications, we search for the task in which the change occured. If we stumble across a task that has not yet finished before finding the task we're looking for, we terminate it and start the elaboration there, otherwise we start the elaboration at the task where the change occured.

Requests iterate over tasks until they find the command that they need to answer the request. In order to not block the main thread, this is done in a request task. If a task that the request task waits for is terminated, a change occured somewhere before the command that the request is looking for and the request sends a "content changed" error.

structure Lean.Server.FileWorker.WorkerContext : Type

• hIn : IO.FS.Stream
• hOut : IO.FS.Stream
• hLog : IO.FS.Stream
• headerTask : Task (Except IO.Error (Lean.Server.Snapshots.Snapshot × Lean.SearchPath))
• initParams : Lean.Lsp.InitializeParams
• clientHasWidgets : Bool

Asynchronous snapshot elaboration

structure Lean.Server.FileWorker.AsyncElabState : Type

• snaps : Array Lean.Server.Snapshots.Snapshot

@[inline, reducible]

abbrev Lean.Server.FileWorker.AsyncElabM (α : Type) : Type

def Lean.Server.FileWorker.unfoldCmdSnaps (m : Lean.Server.DocumentMeta) (snaps : Array Lean.Server.Snapshots.Snapshot) (cancelTk : Lean.Server.FileWorker.CancelToken) (startAfterMs : UInt32) : ReaderT Lean.Server.FileWorker.WorkerContext IO (IO.AsyncList Lean.Server.FileWorker.ElabTaskError Lean.Server.Snapshots.Snapshot)

Elaborates all commands after the last snap (at least the header snap is assumed to exist), emitting the diagnostics into hOut.

@[inline, reducible]

abbrev Lean.Server.FileWorker.PendingRequestMap : Type

structure Lean.Server.FileWorker.WorkerState : Type

• doc : Lean.Server.FileWorker.EditableDocument
• initHeaderStx : Lean.Syntax
• pendingRequests : Lean.Server.FileWorker.PendingRequestMap
• rpcSessions : Lean.RBMap UInt64 (IO.Ref Lean.Server.FileWorker.RpcSession) compare

  A map of RPC session IDs. We allow asynchronous elab tasks and request handlers to modify sessions. A single Ref ensures atomic transactions.

@[inline, reducible]

abbrev Lean.Server.FileWorker.WorkerM (α : Type) : Type

def Lean.Server.FileWorker.lakeSetupSearchPath (lakePath : Lake.FilePath) (m : Lean.Server.DocumentMeta) (imports : Array Lean.Import) (hOut : IO.FS.Stream) : IO Lean.SearchPath

Use lake print-paths to compile dependencies on the fly and add them to LEAN_PATH. Compilation progress is reported to hOut via LSP notifications. Return the search path for source files.

partial def Lean.Server.FileWorker.lakeSetupSearchPath.processStderr (lakePath : Lake.FilePath) (m : Lean.Server.DocumentMeta) (hOut : IO.FS.Stream) (args : Array String) (lakeProc : IO.Process.Child { toStdioConfig := { stdin := IO.Process.Stdio.null, stdout := IO.Process.Stdio.piped, stderr := IO.Process.Stdio.piped }, cmd := lakePath.toString, args := args, cwd := none, env := #[], setsid := false }.toStdioConfig) (acc : String) : IO String

def Lean.Server.FileWorker.compileHeader (m : Lean.Server.DocumentMeta) (hOut : IO.FS.Stream) (opts : Lean.Options) (hasWidgets : Bool) : IO (Lean.Syntax × Task (Except IO.Error (Lean.Server.Snapshots.Snapshot × Lean.SearchPath)))

def Lean.Server.FileWorker.initializeWorker (meta : Lean.Server.DocumentMeta) (i : IO.FS.Stream) (o : IO.FS.Stream) (e : IO.FS.Stream) (initParams : Lean.Lsp.InitializeParams) (opts : Lean.Options) : IO (Lean.Server.FileWorker.WorkerContext × Lean.Server.FileWorker.WorkerState)

def Lean.Server.FileWorker.updatePendingRequests (map : Lean.Server.FileWorker.PendingRequestMap → Lean.Server.FileWorker.PendingRequestMap) : Lean.Server.FileWorker.WorkerM Unit

def Lean.Server.FileWorker.updateDocument (newMeta : Lean.Server.DocumentMeta) : Lean.Server.FileWorker.WorkerM Unit

Given the new document, updates editable doc state.

def Lean.Server.FileWorker.handleDidChange (p : Lean.Lsp.DidChangeTextDocumentParams) : Lean.Server.FileWorker.WorkerM Unit

def Lean.Server.FileWorker.handleCancelRequest (p : Lean.Lsp.CancelParams) : Lean.Server.FileWorker.WorkerM Unit

def Lean.Server.FileWorker.handleRpcRelease (p : Lean.Lsp.RpcReleaseParams) : Lean.Server.FileWorker.WorkerM Unit

def Lean.Server.FileWorker.handleRpcKeepAlive (p : Lean.Lsp.RpcKeepAliveParams) : Lean.Server.FileWorker.WorkerM Unit

Requests here are handled synchronously rather than in the asynchronous RequestM.

def Lean.Server.FileWorker.handleRpcConnect : Lean.Lsp.RpcConnectParams → Lean.Server.FileWorker.WorkerM Lean.Lsp.RpcConnected

def Lean.Server.FileWorker.parseParams (paramType : Type) [Lean.FromJson paramType] (params : Lean.Json) : Lean.Server.FileWorker.WorkerM paramType

def Lean.Server.FileWorker.handleNotification (method : String) (params : Lean.Json) : Lean.Server.FileWorker.WorkerM Unit

def Lean.Server.FileWorker.queueRequest (id : Lean.JsonRpc.RequestID) (requestTask : Task (Except IO.Error Unit)) : Lean.Server.FileWorker.WorkerM Unit

def Lean.Server.FileWorker.handleRequest (id : Lean.JsonRpc.RequestID) (method : String) (params : Lean.Json) : Lean.Server.FileWorker.WorkerM Unit

partial def Lean.Server.FileWorker.mainLoop : Lean.Server.FileWorker.WorkerM Unit

def Lean.Server.FileWorker.initAndRunWorker (i : IO.FS.Stream) (o : IO.FS.Stream) (e : IO.FS.Stream) (opts : Lean.Options) : IO UInt32

@[export lean_server_worker_main]

def Lean.Server.FileWorker.workerMain (opts : Lean.Options) : IO UInt32