blob: 91b6059fff714bc338cc5513ccfa23e178fe0ffe [file]
/-
Copyright (c) 2021 Microsoft Corporation. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Wojciech Nawrocki
-/
module
prelude
public import Lean.Widget.Basic
public import Lean.Widget.InteractiveCode
public import Lean.Widget.InteractiveGoal
public import Lean.Widget.InteractiveDiagnostic
public import Lean.Server.Rpc.RequestHandling
public import Lean.Server.FileWorker.RequestHandling
import Lean.PrettyPrinter.Delaborator.Builtins
public section
/-! Registers all widget-related RPC procedures. -/
namespace Lean.Widget
open Server Lean.Elab
structure MsgToInteractive where
msg : WithRpcRef MessageData
indent : Nat
deriving Inhabited, RpcEncodable
builtin_initialize
registerBuiltinRpcProcedure
`Lean.Widget.InteractiveDiagnostics.msgToInteractive
MsgToInteractive
InteractiveMessage
fun ⟨m, i⟩ => RequestM.pureTask do msgToInteractive m.val i (hasWidgets := true)
/-- The information that the infoview uses to render a popup
for when the user hovers over an expression.
-/
structure InfoPopup where
type : Option CodeWithInfos
/-- Show the term with the implicit arguments. -/
exprExplicit : Option CodeWithInfos
/-- Docstring. In markdown. -/
doc : Option String
deriving Inhabited, RpcEncodable
open PrettyPrinter.Delaborator in
/-- Given elaborator info for a particular subexpression. Produce the `InfoPopup`.
The intended usage of this is for the infoview to pass the `InfoWithCtx` which
was stored for a particular `SubexprInfo` tag in a `TaggedText` generated with `ppExprTagged`.
-/
def makePopup : WithRpcRef InfoWithCtx → RequestM (RequestTask InfoPopup)
| i => RequestM.pureTask do
let i := i.val
i.ctx.runMetaM i.info.lctx do
let type? ← match (← i.info.type?) with
| some type => some <$> ppExprTagged type
| none => pure none
let exprExplicit? ← match i.info with
| Elab.Info.ofTermInfo ti =>
some <$> ppExprForPopup ti.expr (explicit := true)
| Elab.Info.ofDelabTermInfo { toTermInfo := ti, explicit, ..} =>
some <$> ppExprForPopup ti.expr (explicit := explicit)
| Elab.Info.ofFieldInfo fi => pure <| some <| TaggedText.text fi.fieldName.toString
| _ => pure none
return {
type := type?
exprExplicit := exprExplicit?
doc := ← i.info.docString? : InfoPopup
}
where
maybeWithoutTopLevelHighlight : Bool → CodeWithInfos → CodeWithInfos
| true, .tag _ tt => tt
| _, tt => tt
ppExprForPopup (e : Expr) (explicit : Bool := false) : MetaM CodeWithInfos := do
let mut e := e
-- When hovering over a metavariable, we want to see its value, even if `pp.instantiateMVars` is false.
if explicit && e.isMVar then
if let some e' ← getExprMVarAssignment? e.mvarId! then
e := e'
-- When `explicit` is false, keep the top-level tag so that users can also see the explicit version of the term on an additional hover.
maybeWithoutTopLevelHighlight explicit <$> ppExprTagged e do
if explicit then
withOptionAtCurrPos pp.tagAppFns.name true do
withOptionAtCurrPos pp.explicit.name true do
withOptionAtCurrPos pp.mvars.anonymous.name true do
delabApp
else
withOptionAtCurrPos pp.proofs.name true do
withOptionAtCurrPos pp.sorrySource.name true do
delab
builtin_initialize
registerBuiltinRpcProcedure
`Lean.Widget.InteractiveDiagnostics.infoToInteractive
(WithRpcRef InfoWithCtx)
InfoPopup
makePopup
builtin_initialize
registerBuiltinRpcProcedure
`Lean.Widget.getInteractiveGoals
Lsp.PlainGoalParams
(Option InteractiveGoals)
FileWorker.getInteractiveGoals
builtin_initialize
registerBuiltinRpcProcedure
`Lean.Widget.getInteractiveTermGoal
Lsp.PlainTermGoalParams
(Option InteractiveTermGoal)
FileWorker.getInteractiveTermGoal
structure GetInteractiveDiagnosticsParams where
/-- Return diagnostics for these lines only if present,
otherwise return all diagnostics. -/
lineRange? : Option Lsp.LineRange
deriving Inhabited, FromJson, ToJson
structure GetGoToLocationParams where
kind : GoToKind
info : WithRpcRef InfoWithCtx
deriving RpcEncodable
builtin_initialize
registerBuiltinRpcProcedure
`Lean.Widget.getGoToLocation
GetGoToLocationParams
(Array Lsp.LocationLink)
fun ⟨kind, i⟩ => RequestM.pureTask do
let i := i.val
let rc ← read
let ls ← locationLinksOfInfo rc.doc.meta kind i
let ls := ls.map (·.toLocationLink)
if !ls.isEmpty then return ls
-- TODO(WN): unify handling of delab'd (infoview) and elab'd (editor) applications
let .ofTermInfo ti := i.info | return #[]
let .app _ _ := ti.expr | return #[]
let some nm := ti.expr.getAppFn.constName? | return #[]
let ctx : GoToContext := {
doc := rc.doc.meta
kind
infoTree? := none
originInfo? := none
children := PersistentArray.empty
}
GoToM.run ctx i.ctx ti.lctx do
let ls ← locationLinksFromDecl nm
return ls.map (·.toLocationLink)
def lazyTraceChildrenToInteractive (children : WithRpcRef LazyTraceChildren) :
RequestM (RequestTask (Array InteractiveMessage)) :=
RequestM.pureTask do
let ⟨indent, children⟩ := children.val
children.mapM fun child => do
msgToInteractive child.val (hasWidgets := true) (indent := indent)
builtin_initialize registerBuiltinRpcProcedure ``lazyTraceChildrenToInteractive _ _ lazyTraceChildrenToInteractive
private def kmpSearch (query text : String) : Array String.Pos := Id.run do
if query.isEmpty then
return #[]
let query := query.toUTF8
let text := text.toUTF8
let table := buildKMPTable query
let mut r := #[]
let mut qi : Int := 0
for h:ti in *...text.size do
while qi >= 0 && text[ti] != query[qi.toNat]! do
qi := table[qi.toNat]!
qi := qi + 1
if qi == query.size then
r := r.push <| (ti + 1) - query.size
qi := table[qi.toNat]!
return r.map (⟨·⟩)
where
buildKMPTable (w : ByteArray) : Array Int := Id.run do
let mut t := Array.emptyWithCapacity w.size
let mut n := -1
t := t.push n
for h:i in *...w.size do
while n >= 0 && w[n.toNat]! != w[i] do
n := t[n.toNat]!
n := n + 1
t := t.push n
return t
private def contains (query text : String) : Bool :=
! (kmpSearch query text).isEmpty
private def matchEndPos (query : String) (startPos : String.Pos) : String.Pos :=
startPos + ⟨query.utf8ByteSize⟩
@[specialize]
private def hightlightStringMatches? (query text : String) (matchPositions : Array String.Pos)
(highlight : α) (offset : String.Pos := ⟨0⟩) (mapIdx : Nat → Nat := id) :
Option (TaggedText α) := Id.run do
if query.isEmpty || text.isEmpty || matchPositions.isEmpty then
return none
let mut anyMatch : Bool := false
let mut r : Array (TaggedText α) := #[]
let mut p : String.Pos := ⟨0⟩
for i in 0...matchPositions.size do
if p >= text.endPos then
break
let i := mapIdx i
let globalMatchPos := matchPositions[i]!
let matchPos := globalMatchPos - offset
if matchPos >= text.endPos then
break
if let some nonMatch := nonMatch? p matchPos then
r := r.push nonMatch
let globalMatchEndPos := matchEndPos query globalMatchPos
let matchEndPos := globalMatchEndPos - offset
let «match» := text.extract matchPos matchEndPos
r := r.push <| .tag highlight (.text «match»)
p := matchEndPos
anyMatch := true
if let some nonMatch := nonMatch? p text.endPos then
r := r.push nonMatch
if ! anyMatch then
return none
if h : r.size = 1 then
return some r[0]
return some (.append r)
where
nonMatch? (p matchPosition : String.Pos) : Option (TaggedText α) := do
guard <| p < matchPosition
let nonMatch := text.extract p matchPosition
return .text nonMatch
private def findTaggedTextMatches (query : String) (tt : TaggedText α) (toText : α → String) :
Array String.Pos :=
let tt : TaggedText Empty := tt.rewrite fun t _ => .text (toText t)
kmpSearch query tt.stripTags
private structure TaggedTextHighlightState where
query : String
ms : Array String.Pos
p : String.Pos
anyHighlight : Bool
private def advanceTaggedTextHighlightState (text : String) (highlighted : α) :
StateM TaggedTextHighlightState (TaggedText α) := do
let query := (← get).query
let p := (← get).p
let ms := (← get).ms
let highlighted? := hightlightStringMatches? query text ms highlighted (offset := p)
(mapIdx := fun i => ms.size - i - 1)
updateState text highlighted?.isSome
return highlighted?.getD (.text text)
where
updateState (text : String) (isHighlighted : Bool) : StateM TaggedTextHighlightState Unit :=
modify fun s =>
let p : String.Pos := s.p + ⟨text.utf8ByteSize⟩
let ms := updateMatches s.query s.ms p
let anyHighlight := s.anyHighlight || isHighlighted
{ s with p, ms, anyHighlight }
updateMatches (query : String) (ms : Array String.Pos) (p : String.Pos) : Array String.Pos := Id.run do
let n := ms.size
let mut ms := ms
for i in 0...n do
if p >= matchEndPos query ms[n - i - 1]! then
ms := ms.pop
return ms
@[specialize]
private partial def highlightTaggedText (query : String) (tt : TaggedText α) (highlighted : β)
(toText : (t : α) → String)
(highlightTag :
(t : α) →
(highlightTaggedText :
TaggedText α →
StateM TaggedTextHighlightState (TaggedText β)) →
StateM TaggedTextHighlightState β) :
TaggedText β × Bool :=
let ms := findTaggedTextMatches query tt toText
let (tt, s) := go tt |>.run { query, p := ⟨0⟩, ms := ms.reverse, anyHighlight := false }
(tt, s.anyHighlight)
where
go (tt : TaggedText α) : StateM TaggedTextHighlightState (TaggedText β) := do
match tt with
| .text s =>
advanceTaggedTextHighlightState s highlighted
| .append a =>
return .append (← a.mapM go)
| .tag t a =>
let t ← highlightTag t go
let a ← go a
return .tag t a
inductive HighlightedSubexprInfo where
| subexpr (info : SubexprInfo)
| highlighted
instance : RpcEncodable HighlightedSubexprInfo where
rpcEncode
| .subexpr info => rpcEncode info
| .highlighted => pure "highlighted"
rpcDecode
| .str "highlighted" => pure .highlighted
| j => do
return .subexpr (← rpcDecode j)
abbrev HighlightedCodeWithInfos := TaggedText HighlightedSubexprInfo
private def HighlightedCodeWithInfos.ofCodeWithInfos (c : CodeWithInfos) :
HighlightedCodeWithInfos :=
c.map .subexpr
private partial def highlightCodeWithInfos (query : String) (c : CodeWithInfos) :
HighlightedCodeWithInfos × Bool :=
highlightTaggedText query c .highlighted (fun _ => "") fun i _ => pure <| .subexpr i
inductive HighlightedMsgEmbed where
| expr : HighlightedCodeWithInfos → HighlightedMsgEmbed
| goal : InteractiveGoal → HighlightedMsgEmbed
| widget (wi : Widget.WidgetInstance) (alt : TaggedText HighlightedMsgEmbed)
| trace (indent : Nat) (cls : Name) (msg : TaggedText HighlightedMsgEmbed) (collapsed : Bool)
(children : StrictOrLazy
(Array (TaggedText HighlightedMsgEmbed))
(WithRpcRef LazyTraceChildren))
| highlighted
deriving Inhabited, RpcEncodable
mutual
private partial def HighlightedMsgEmbed.traceChildrenOfMsgEmbed :
StrictOrLazy
(Array (TaggedText MsgEmbed))
(WithRpcRef LazyTraceChildren) →
StrictOrLazy
(Array (TaggedText HighlightedMsgEmbed))
(WithRpcRef LazyTraceChildren)
| .strict cs => .strict <| cs.map fun c => c.map (.ofMsgEmbed ·)
| .lazy cs => .lazy cs
private partial def HighlightedMsgEmbed.ofMsgEmbed : MsgEmbed → HighlightedMsgEmbed
| .expr c => .expr (.ofCodeWithInfos c)
| .goal g => .goal g
| .widget wi alt => .widget wi <| alt.map (.ofMsgEmbed ·)
| .trace indent cls msg collapsed children =>
let msg := msg.map (.ofMsgEmbed ·)
let children := traceChildrenOfMsgEmbed children
.trace indent cls msg collapsed children
end
abbrev HighlightedInteractiveMessage := TaggedText HighlightedMsgEmbed
private def HighlightedInteractiveMessage.ofInteractiveMessage (msg : InteractiveMessage) :
HighlightedInteractiveMessage :=
msg.map (.ofMsgEmbed ·)
private def highlightInteractiveMessageWithExprs (query : String) (msg : InteractiveMessage) :
HighlightedInteractiveMessage × Bool :=
highlightTaggedText query msg .highlighted toText go
where
toText : MsgEmbed → String
| .expr tt => tt.stripTags
| _ => ""
go e _ := do
match e with
| .expr tt =>
let tt ← highlightTaggedText.go (tt := tt) .highlighted fun i _ => pure <| .subexpr i
return .expr tt
| e =>
pure <| .ofMsgEmbed e
variable (query : String) (indent : Nat) in
private partial def unfoldMessageDataTracesContaining (msg : MessageData) (nctx : NamingContext) (ctx? : Option MessageDataContext) : BaseIO (MessageData × Bool) := do
-- We currently only support `.trace` trees.
match msg with
| .trace data traceMsg children =>
let unfolded ← children.mapM (unfoldMessageDataTracesContaining · nctx ctx?)
let children := unfolded.map (·.1)
let anyUnfolded := unfolded.any (·.2)
if anyUnfolded then
return (.trace { data with collapsed := false } traceMsg children, true)
let fmt ← traceMsg.formatAux nctx ctx?
let s := fmt.pretty (indent := indent)
if contains query s then
return (.trace { data with collapsed := false } traceMsg children, true)
return (.trace data traceMsg children, false)
| .withContext ctx msg =>
let (msg, unfolded) ← unfoldMessageDataTracesContaining msg nctx ctx
return (.withContext ctx msg, unfolded)
| .withNamingContext nctx msg =>
let (msg, unfolded) ← unfoldMessageDataTracesContaining msg nctx ctx?
return (.withNamingContext nctx msg, unfolded)
| .tagged tag msg =>
let (msg, unfolded) ← unfoldMessageDataTracesContaining msg nctx ctx?
return (.tagged tag msg, unfolded)
| _ =>
return (msg, false)
private structure Highlighted where
msg : HighlightedInteractiveMessage
isHighlighted : Bool
isTrace : Bool
variable (query : String) in
private partial def highlightMatchesAux (msg : InteractiveMessage) :
IO Highlighted := do
match msg with
| .tag (.trace indent cls msg collapsed children) a => do
let a : HighlightedInteractiveMessage := .ofInteractiveMessage a
let (msg, isMsgHighlighted) := highlightInteractiveMessageWithExprs query msg
let unchangedChildren := Thunk.mk fun _ =>
let children := HighlightedMsgEmbed.traceChildrenOfMsgEmbed children
let trace := .trace indent cls msg collapsed children
{ msg := .tag trace a, isHighlighted := isMsgHighlighted, isTrace := true }
let expandedChildren children :=
let trace := .trace indent cls msg false (.strict children)
{ msg := .tag trace a, isHighlighted := true, isTrace := true }
match children with
| .strict children =>
let highlighted ← children.mapM (highlightMatchesAux ·)
let anyHighlighted := highlighted.any (·.2)
let children := highlighted.map (·.1)
if ! anyHighlighted then
return unchangedChildren.get
return expandedChildren children
| .lazy c => do
let indent := c.val.indent
let unfolded ← c.val.children.mapM fun childRef =>
let child := childRef.val
let nctx := { currNamespace := Name.anonymous, openDecls := [] }
unfoldMessageDataTracesContaining query indent child nctx none
let anyUnfolded := unfolded.any (·.2)
let children := unfolded.map (·.1)
if ! anyUnfolded then
return unchangedChildren.get
let children ← children.mapM (msgToInteractive · true indent)
let highlighted ← children.mapM highlightMatchesAux
let children := highlighted.map (·.1)
return expandedChildren children
| .append as =>
let highlighted ← as.mapM highlightMatchesAux
let anyHighlighted := highlighted.any (·.isHighlighted)
let anyTrace := highlighted.any (·.isTrace)
let as := highlighted.map (·.msg)
if ! anyTrace then
let (msg, isHighlighted) := highlightInteractiveMessageWithExprs query msg
return { msg, isHighlighted, isTrace := false }
return { msg := .append as, isHighlighted := anyHighlighted, isTrace := true }
| msg =>
let (msg, isHighlighted) := highlightInteractiveMessageWithExprs query msg
return { msg, isHighlighted, isTrace := false }
structure HighlightMatchesParams where
query : String
msg : InteractiveMessage
deriving RpcEncodable
def highlightMatches (params : HighlightMatchesParams) : RequestM (RequestTask HighlightedInteractiveMessage) :=
RequestM.pureTask do
let r ← highlightMatchesAux params.query params.msg
return r.msg
builtin_initialize registerBuiltinRpcProcedure ``highlightMatches _ _ highlightMatches
end Lean.Widget