Pantograph/Library.lean

@@ -138,23 +138,36 @@ def goalSerialize (state: GoalState) (options: @&Protocol.Options): CoreM (Array
   runMetaM <| state.serializeGoals (parent := .none) options
 
 @[export pantograph_goal_print_m]
-def goalPrint (state: GoalState) (extraMVars : Array String) (options: @&Protocol.Options): CoreM Protocol.GoalPrintResult :=
+def goalPrint (state: GoalState) (rootExpr: Bool) (parentExpr: Bool) (goals: Bool) (extraMVars : Array String) (options: @&Protocol.Options)
-  runMetaM do
+  : CoreM Protocol.GoalPrintResult := runMetaM do
-    state.restoreMetaM
+  state.restoreMetaM
-    return {
+
-      root? := ← state.rootExpr?.mapM λ expr =>
+  let root? ← if rootExpr then
-        state.withRootContext do
+      state.rootExpr?.mapM λ expr => state.withRootContext do
-          serializeExpression options (← instantiateAll expr),
+        serializeExpression options (← instantiateAll expr)
-      parent? := ← state.parentExpr?.mapM λ expr =>
+    else
-        state.withParentContext do
+      pure .none
-          serializeExpression options (← instantiateAll expr),
+  let parent? ← if parentExpr then
-      extraMVars := ← extraMVars.mapM λ mvarId => do
+      state.parentExpr?.mapM λ expr => state.withParentContext do
-        let mvarId: MVarId := { name := mvarId.toName }
+        serializeExpression options (← instantiateAll expr)
-        let .some _ ← mvarId.findDecl? | return {}
+    else
-        state.withContext mvarId do
+      pure .none
-          let .some expr ← getExprMVarAssignment? mvarId | return {}
+  let goals ← if goals then
-          serializeExpression options (← instantiateAll expr),
+      goalSerialize state options
-    }
+    else
+      pure #[]
+  let extraMVars ← extraMVars.mapM λ mvarId => do
+    let mvarId: MVarId := { name := mvarId.toName }
+    let .some _ ← mvarId.findDecl? | return {}
+    state.withContext mvarId do
+      let .some expr ← getExprMVarAssignment? mvarId | return {}
+      serializeExpression options (← instantiateAll expr)
+  return {
+    root?,
+    parent?,
+    goals,
+    extraMVars,
+  }
 
 @[export pantograph_goal_tactic_m]
 def goalTactic (state: GoalState) (goal:  MVarId) (tactic: String): CoreM TacticResult :=

Pantograph/Protocol.lean

@@ -271,15 +271,22 @@ structure GoalDeleteResult where
 
 structure GoalPrint where
   stateId: Nat
-  -- Print values of extra mvars
+
+  -- Print root?
+  rootExpr?: Option Bool := .some False
+  -- Print the parent expr?
+  parentExpr?: Option Bool := .some False
+  -- Print goals?
+  goals?: Option Bool := .some False
+  -- Print values of extra mvars?
   extraMVars?: Option (Array String) := .none
   deriving Lean.FromJson
 structure GoalPrintResult where
   -- The root expression
   root?: Option Expression := .none
   -- The filling expression of the parent goal
-  parent?: Option Expression
+  parent?: Option Expression := .none
-
+  goals: Array Goal := #[]
   extraMVars: Array Expression := #[]
   deriving Lean.ToJson
 

Repl.lean

@@ -223,8 +223,13 @@ def execute (command: Protocol.Command): MainM Lean.Json := do
     let state ← get
     let .some goalState := state.goalStates[args.stateId]? |
       return .error $ errorIndex s!"Invalid state index {args.stateId}"
-    let extraMVars := args.extraMVars?.getD #[]
+    let result ← runMetaInMainM <| goalPrint
-    let result ← runMetaInMainM <| goalPrint goalState extraMVars state.options
+        goalState
+        (rootExpr := args.rootExpr?.getD False)
+        (parentExpr := args.parentExpr?.getD False)
+        (goals := args.goals?.getD False)
+        (extraMVars := args.extraMVars?.getD #[])
+        (options := state.options)
     return .ok result
   goal_save (args: Protocol.GoalSave): MainM (CR Protocol.GoalSaveResult) := do
     let state ← get

Test/Integration.lean

@@ -72,7 +72,7 @@ def test_tactic : Test :=
      ({ stateId := 0, root := "_uniq.9" }: Protocol.GoalStartResult),
     step "goal.tactic" [("stateId", .num 0), ("goalId", .num 0), ("tactic", .str "intro x")]
      ({ nextStateId? := .some 1, goals? := #[goal1], }: Protocol.GoalTacticResult),
-    step "goal.print" [("stateId", .num 1)]
+    step "goal.print" [("stateId", .num 1), ("parentExpr", .bool true), ("rootExpr", .bool true)]
      ({ parent? := .some { pp? := .some "fun x => ?m.12 x" }, }: Protocol.GoalPrintResult),
     step "goal.tactic" [("stateId", .num 1), ("goalId", .num 0), ("tactic", .str "intro y")]
      ({ nextStateId? := .some 2, goals? := #[goal2], }: Protocol.GoalTacticResult),