Add files using upload-large-folder tool

.gitattributes

@@ -4432,3 +4432,30 @@ backend/core/leanprover--lean4---v4.22.0/lib/lean/Std/Sat/AIG/RelabelNat.olean f
 backend/core/leanprover--lean4---v4.22.0/lib/lean/Std/Do/PostCond.olean filter=lfs diff=lfs merge=lfs -text
 external/alphageometry/.venv-ag/Lib/site-packages/scipy/fftpack/tests/fftw_double_ref.npz filter=lfs diff=lfs merge=lfs -text
 external/alphageometry/.venv-ag/Lib/site-packages/scipy/fftpack/tests/fftw_longdouble_ref.npz filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/.venv-ag/Scripts/f2py.exe filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/.venv-ag/Scripts/fonttools.exe filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/.venv-ag/Scripts/numpy-config.exe filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/.venv-ag/Scripts/pip.exe filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/.venv-ag/Scripts/pip3.10.exe filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/.venv-ag/Scripts/pip3.exe filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/.venv-ag/Scripts/pyftmerge.exe filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/.venv-ag/Scripts/pyftsubset.exe filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/.venv-ag/Scripts/python.exe filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/.venv-ag/Scripts/pythonw.exe filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/.venv-ag/Scripts/ttx.exe filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/.venv-ag/Scripts/wheel.exe filter=lfs diff=lfs merge=lfs -text
+backend/core/leanprover--lean4---v4.22.0/lib/lean/Std/Internal/UV/System.olean filter=lfs diff=lfs merge=lfs -text
+backend/core/leanprover--lean4---v4.22.0/lib/lean/Std/Time/DateTime/PlainDateTime.olean filter=lfs diff=lfs merge=lfs -text
+backend/core/leanprover--lean4---v4.22.0/lib/lean/Std/Do/WP/Basic.olean filter=lfs diff=lfs merge=lfs -text
+backend/core/leanprover--lean4---v4.22.0/lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Replicate.olean filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/meliad_lib/meliad/transformer/vocabs/pg19train_bpe_1000.model filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/meliad_lib/meliad/transformer/vocabs/pg19train_bpe_128000.model filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/meliad_lib/meliad/transformer/vocabs/pg19train_bpe_32000.model filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/meliad_lib/meliad/transformer/vocabs/pg19train_bpe_4000.model filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/meliad_lib/meliad/transformer/vocabs/pg19train_bpe_512.model filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/meliad_lib/meliad/transformer/vocabs/pg19train_bpe_64000.model filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/meliad_lib/meliad/transformer/vocabs/pg19train_bpe_8000.model filter=lfs diff=lfs merge=lfs -text
+external/alphageometry/meliad_lib/meliad/transformer/vocabs/pg19train_bpe_96000.model filter=lfs diff=lfs merge=lfs -text
+frontend/file_00000000bcfc624381c37949ccd77bc9.png filter=lfs diff=lfs merge=lfs -text
+frontend/file_00000000cf6462469688bc5199fed92b.png filter=lfs diff=lfs merge=lfs -text
+frontend/IMG_20250618_170452.jpg filter=lfs diff=lfs merge=lfs -text

backend/core/leanprover--lean4---v4.22.0/lib/lean/Std/Do/WP/Basic.olean

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9ec7a91d4d492bea4023c88138e4274ad0fd17c51385ffb706b56b7dd945576
+size 301128

backend/core/leanprover--lean4---v4.22.0/lib/lean/Std/Internal/UV/System.olean

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d18b1027d6e9c1432697fa689cc21ba16dc92f429e56e440f58a319cce295c74
+size 736624

backend/core/leanprover--lean4---v4.22.0/lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Replicate.olean

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea58b608189883e9ec75733caae606328846567f9444b65e130f6f56a7c95dd6
+size 324992

backend/core/leanprover--lean4---v4.22.0/lib/lean/Std/Time/DateTime/PlainDateTime.olean

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45800e87fb690735a4ea0044e72e1c7b31b1a4e05854b3d0d66b1e28c04eaab0
+size 704216

backend/core/leanprover--lean4---v4.22.0/src/lean/Init/Grind/Ordered/Order.lean

@@ -0,0 +1,118 @@
+/-
+Copyright (c) 2025 Lean FRO, LLC. or its affiliates. All Rights Reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Kim Morrison
+-/
+module
+
+prelude
+public import Init.Data.Int.Order
+
+public section
+
+namespace Lean.Grind
+
+/-- A preorder is a reflexive, transitive relation `≤` with `a < b` defined in the obvious way. -/
+class Preorder (α : Type u) extends LE α, LT α where
+  /-- The less-than-or-equal relation is reflexive. -/
+  le_refl : ∀ a : α, a ≤ a
+  /-- The less-than-or-equal relation is transitive. -/
+  le_trans : ∀ {a b c : α}, a ≤ b → b ≤ c → a ≤ c
+  lt := fun a b => a ≤ b ∧ ¬b ≤ a
+  /-- The less-than relation is determined by the less-than-or-equal relation. -/
+  lt_iff_le_not_le : ∀ {a b : α}, a < b ↔ a ≤ b ∧ ¬b ≤ a := by intros; rfl
+
+namespace Preorder
+
+variable {α : Type u} [Preorder α]
+
+theorem le_of_lt {a b : α} (h : a < b) : a ≤ b := (lt_iff_le_not_le.mp h).1
+
+theorem lt_of_lt_of_le {a b c : α} (h₁ : a < b) (h₂ : b ≤ c) : a < c := by
+  simp [lt_iff_le_not_le] at h₁ ⊢
+  exact ⟨le_trans h₁.1 h₂, fun h => h₁.2 (le_trans h₂ h)⟩
+
+theorem lt_of_le_of_lt {a b c : α} (h₁ : a ≤ b) (h₂ : b < c) : a < c := by
+  simp [lt_iff_le_not_le] at h₂ ⊢
+  exact ⟨le_trans h₁ h₂.1, fun h => h₂.2 (le_trans h h₁)⟩
+
+theorem lt_trans {a b c : α} (h₁ : a < b) (h₂ : b < c) : a < c :=
+  lt_of_lt_of_le h₁ (le_of_lt h₂)
+
+theorem lt_irrefl (a : α) : ¬ (a < a) := by
+  intro h
+  simp [lt_iff_le_not_le] at h
+
+theorem ne_of_lt {a b : α} (h : a < b) : a ≠ b :=
+  fun w => lt_irrefl a (w.symm ▸ h)
+
+theorem ne_of_gt {a b : α} (h : a > b) : a ≠ b :=
+  fun w => lt_irrefl b (w.symm ▸ h)
+
+theorem not_ge_of_lt {a b : α} (h : a < b) : ¬b ≤ a :=
+  fun w => lt_irrefl a (lt_of_lt_of_le h w)
+
+theorem not_gt_of_lt {a b : α} (h : a < b) : ¬a > b :=
+  fun w => lt_irrefl a (lt_trans h w)
+
+end Preorder
+
+/-- A partial order is a preorder with the additional property that `a ≤ b` and `b ≤ a` implies `a = b`. -/
+class PartialOrder (α : Type u) extends Preorder α where
+  /-- The less-than-or-equal relation is antisymmetric. -/
+  le_antisymm : ∀ {a b : α}, a ≤ b → b ≤ a → a = b
+
+namespace PartialOrder
+
+variable {α : Type u} [PartialOrder α]
+
+theorem le_iff_lt_or_eq {a b : α} : a ≤ b ↔ a < b ∨ a = b := by
+  constructor
+  · intro h
+    rw [Preorder.lt_iff_le_not_le, Classical.or_iff_not_imp_right]
+    exact fun w => ⟨h, fun w' => w (le_antisymm h w')⟩
+  · intro h
+    cases h with
+    | inl h => exact Preorder.le_of_lt h
+    | inr h => subst h; exact Preorder.le_refl a
+
+end PartialOrder
+
+/-- A linear order is a partial order with the additional property that every pair of elements is comparable. -/
+class LinearOrder (α : Type u) extends PartialOrder α where
+  /-- For every two elements `a` and `b`, either `a ≤ b` or `b ≤ a`. -/
+  le_total : ∀ a b : α, a ≤ b ∨ b ≤ a
+
+namespace LinearOrder
+
+variable {α : Type u} [LinearOrder α]
+
+theorem trichotomy (a b : α) : a < b ∨ a = b ∨ b < a := by
+  cases LinearOrder.le_total a b with
+  | inl h =>
+    rw [PartialOrder.le_iff_lt_or_eq] at h
+    cases h with
+    | inl h => left; exact h
+    | inr h => right; left; exact h
+  | inr h =>
+    rw [PartialOrder.le_iff_lt_or_eq] at h
+    cases h with
+    | inl h => right; right; exact h
+    | inr h => right; left; exact h.symm
+
+theorem le_of_not_lt {α} [LinearOrder α] {a b : α} (h : ¬ a < b) : b ≤ a := by
+  cases LinearOrder.trichotomy a b
+  next => contradiction
+  next h => apply PartialOrder.le_iff_lt_or_eq.mpr; cases h <;> simp [*]
+
+theorem lt_of_not_le {α} [LinearOrder α] {a b : α} (h : ¬ a ≤ b) : b < a := by
+  cases LinearOrder.trichotomy a b
+  next h₁ h₂ => have := Preorder.lt_iff_le_not_le.mp h₂; simp [h] at this
+  next h =>
+    cases h
+    next h => subst a; exact False.elim <| h (Preorder.le_refl b)
+    next => assumption
+
+end LinearOrder
+
+end Lean.Grind

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Data/Lsp/Utf16.lean

@@ -0,0 +1,120 @@
+/-
+Copyright (c) 2020 Marc Huisinga. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+
+Authors: Marc Huisinga, Wojciech Nawrocki
+-/
+prelude
+import Init.Data.String
+import Lean.Data.Lsp.Basic
+import Lean.Data.Position
+import Lean.DeclarationRange
+
+/-! LSP uses UTF-16 for indexing, so we need to provide some primitives
+to interact with Lean strings using UTF-16 indices. -/
+
+namespace Char
+
+/-- Returns the number of bytes required to encode this `Char` in UTF-16. -/
+def utf16Size (c : Char) : UInt32 :=
+  if c.val ≤ 0xFFFF then 1 else 2
+
+end Char
+
+namespace String
+
+private def csize16 (c : Char) : Nat :=
+  c.utf16Size.toNat
+
+def utf16Length (s : String) : Nat :=
+  s.foldr (fun c acc => csize16 c + acc) 0
+
+private def codepointPosToUtf16PosFromAux (s : String) : Nat → Pos → Nat → Nat
+  | 0,    _,       utf16pos => utf16pos
+  | cp+1, utf8pos, utf16pos => codepointPosToUtf16PosFromAux s cp (s.next utf8pos) (utf16pos + csize16 (s.get utf8pos))
+
+/-- Computes the UTF-16 offset of the `n`-th Unicode codepoint
+in the substring of `s` starting at UTF-8 offset `off`.
+Yes, this is actually useful.-/
+def codepointPosToUtf16PosFrom (s : String) (n : Nat) (off : Pos) : Nat :=
+  codepointPosToUtf16PosFromAux s n off 0
+
+def codepointPosToUtf16Pos (s : String) (pos : Nat) : Nat :=
+  codepointPosToUtf16PosFrom s pos 0
+
+private partial def utf16PosToCodepointPosFromAux (s : String) : Nat → Pos → Nat → Nat
+  | 0,        _,       cp => cp
+  | utf16pos, utf8pos, cp => utf16PosToCodepointPosFromAux s (utf16pos - csize16 (s.get utf8pos)) (s.next utf8pos) (cp + 1)
+
+/-- Computes the position of the Unicode codepoint at UTF-16 offset
+`utf16pos` in the substring of `s` starting at UTF-8 offset `off`. -/
+def utf16PosToCodepointPosFrom (s : String) (utf16pos : Nat) (off : Pos) : Nat :=
+  utf16PosToCodepointPosFromAux s utf16pos off 0
+
+def utf16PosToCodepointPos (s : String) (pos : Nat) : Nat :=
+  utf16PosToCodepointPosFrom s pos 0
+
+/-- Starting at `utf8pos`, finds the UTF-8 offset of the `p`-th codepoint. -/
+def codepointPosToUtf8PosFrom (s : String) : String.Pos → Nat → String.Pos
+  | utf8pos, 0 => utf8pos
+  | utf8pos, p+1 => codepointPosToUtf8PosFrom s (s.next utf8pos) p
+
+end String
+
+namespace Lean
+namespace FileMap
+
+private def lineStartPos (text : FileMap) (line : Nat) : String.Pos :=
+  if h : line < text.positions.size then
+    text.positions[line]
+  else if text.positions.isEmpty then
+    0
+  else
+    text.positions.back!
+
+/-- Computes an UTF-8 offset into `text.source`
+from an LSP-style 0-indexed (ln, col) position. -/
+def lspPosToUtf8Pos (text : FileMap) (pos : Lsp.Position) : String.Pos :=
+  let lineStartPos := lineStartPos text pos.line
+  let chr := text.source.utf16PosToCodepointPosFrom pos.character lineStartPos
+  text.source.codepointPosToUtf8PosFrom lineStartPos chr
+
+def leanPosToLspPos (text : FileMap) : Lean.Position → Lsp.Position
+  | ⟨line, col⟩ =>
+    ⟨line - 1, text.source.codepointPosToUtf16PosFrom col (lineStartPos text (line - 1))⟩
+
+def utf8PosToLspPos (text : FileMap) (pos : String.Pos) : Lsp.Position :=
+  text.leanPosToLspPos (text.toPosition pos)
+
+/-- Gets the LSP range from a `String.Range`. -/
+def utf8RangeToLspRange (text : FileMap) (range : String.Range) : Lsp.Range :=
+  { start := text.utf8PosToLspPos range.start, «end» := text.utf8PosToLspPos range.stop }
+
+def lspRangeToUtf8Range (text : FileMap) (range : Lsp.Range) : String.Range :=
+  { start := text.lspPosToUtf8Pos range.start, stop := text.lspPosToUtf8Pos range.end }
+
+end FileMap
+
+def DeclarationRange.ofFilePositions (text : FileMap) (pos : Position) (endPos : Position)
+    : DeclarationRange := {
+  pos,
+  charUtf16 := text.leanPosToLspPos pos |>.character
+  endPos,
+  endCharUtf16 := text.leanPosToLspPos endPos |>.character
+}
+
+def DeclarationRange.ofStringPositions (text : FileMap) (pos : String.Pos) (endPos : String.Pos)
+    : DeclarationRange :=
+  .ofFilePositions text (text.toPosition pos) (text.toPosition endPos)
+
+/--
+Convert the Lean `DeclarationRange` to an LSP `Range` by turning the 1-indexed line numbering into a
+0-indexed line numbering and converting the character offset within the line to a UTF-16 indexed
+offset.
+-/
+def DeclarationRange.toLspRange (r : DeclarationRange) : Lsp.Range := {
+  start := ⟨r.pos.line - 1, r.charUtf16⟩
+  «end» := ⟨r.endPos.line - 1, r.endCharUtf16⟩
+}
+
+end Lean

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Data/Lsp/Window.lean

@@ -0,0 +1,48 @@
+/-
+Copyright (c) 2024 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Marc Huisinga
+-/
+prelude
+import Lean.Data.Json
+
+open Lean
+
+inductive MessageType where
+  | error
+  | warning
+  | info
+  | log
+
+instance : FromJson MessageType where
+  fromJson?
+    | (1 : Nat) => .ok .error
+    | (2 : Nat) => .ok .warning
+    | (3 : Nat) => .ok .info
+    | (4 : Nat) => .ok .log
+    | _         => .error "Unknown MessageType ID"
+
+instance : ToJson MessageType where
+  toJson
+    | .error   => 1
+    | .warning => 2
+    | .info    => 3
+    | .log     => 4
+
+structure ShowMessageParams where
+  type    : MessageType
+  message : String
+  deriving FromJson, ToJson
+
+structure MessageActionItem where
+  title : String
+  deriving FromJson, ToJson
+
+structure ShowMessageRequestParams where
+  type     : MessageType
+  message  : String
+  actions? : Option (Array MessageActionItem)
+  deriving FromJson, ToJson
+
+def ShowMessageResponse := Option MessageActionItem
+  deriving FromJson, ToJson

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Data/Lsp/Workspace.lean

@@ -0,0 +1,73 @@
+/-
+Copyright (c) 2020 Wojciech Nawrocki. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+
+Authors: Wojciech Nawrocki
+-/
+prelude
+import Lean.Data.Lsp.Basic
+import Lean.Data.Json
+
+namespace Lean
+namespace Lsp
+
+open Json
+
+structure WorkspaceFolder where
+  uri : DocumentUri
+  name : String
+  deriving ToJson, FromJson
+
+-- TODO(WN):
+-- WorkspaceFoldersServerCapabilities,
+-- DidChangeWorkspaceFoldersParams,
+-- WorkspaceFoldersChangeEvent
+
+structure FileSystemWatcher where
+  globPattern : String
+  kind : Option Nat := none
+  deriving FromJson, ToJson
+
+namespace FileSystemWatcher
+
+-- Bit flags for `FileSystemWatcher.kind`
+def create := 1
+def change := 2
+def delete := 4
+
+end FileSystemWatcher
+
+structure DidChangeWatchedFilesRegistrationOptions where
+  watchers : Array FileSystemWatcher
+  deriving FromJson, ToJson
+
+inductive FileChangeType
+  | Created
+  | Changed
+  | Deleted
+
+instance : FromJson FileChangeType where
+  fromJson? j := do
+    match (← fromJson? j : Nat) with
+      | 1 => return FileChangeType.Created
+      | 2 => return FileChangeType.Changed
+      | 3 => return FileChangeType.Deleted
+      | _ => throw s!"expected 1, 2, or 3, got {j}"
+
+instance : ToJson FileChangeType where
+  toJson
+    | FileChangeType.Created => toJson 1
+    | FileChangeType.Changed => toJson 2
+    | FileChangeType.Deleted => toJson 3
+
+structure FileEvent where
+  uri : DocumentUri
+  type : FileChangeType
+  deriving FromJson, ToJson
+
+structure DidChangeWatchedFilesParams where
+  changes : Array FileEvent
+  deriving FromJson, ToJson
+
+end Lsp
+end Lean

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Data/Xml/Basic.lean

@@ -0,0 +1,41 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Author: Dany Fabian
+-/
+prelude
+import Lean.Data.RBMap
+import Init.Data.ToString.Macro
+
+namespace Lean
+namespace Xml
+
+def Attributes := RBMap String String compare
+instance : ToString Attributes := ⟨λ as => as.fold (λ s n v => s ++ s!" {n}=\"{v}\"") ""⟩
+
+mutual
+inductive Element
+| Element
+  (name : String)
+  (attributes : Attributes)
+  (content : Array Content)
+
+inductive Content
+| Element (element : Element)
+| Comment (comment : String)
+| Character (content : String)
+deriving Inhabited
+end
+
+mutual
+private partial def eToString : Element → String
+| Element.Element n a c => s!"<{n}{a}>{c.map cToString |>.foldl (· ++ ·) ""}</{n}>"
+
+private partial def cToString : Content → String
+| Content.Element e => eToString e
+| Content.Comment c => s!"<!--{c}-->"
+| Content.Character c => c
+
+end
+instance : ToString Element := ⟨eToString⟩
+instance : ToString Content := ⟨cToString⟩

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Data/Xml/Parser.lean

@@ -0,0 +1,487 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Author: Dany Fabian
+-/
+prelude
+import Std.Internal.Parsec
+import Lean.Data.Xml.Basic
+
+open System
+open Lean
+
+namespace Lean
+namespace Xml
+
+open Std.Internal.Parsec
+open Std.Internal.Parsec.String
+
+namespace Parser
+
+abbrev LeanChar := Char
+
+/-- consume a newline character sequence pretending, that we read '\n'. As per spec:
+  https://www.w3.org/TR/xml/#sec-line-ends -/
+def endl : Parser LeanChar := (skipString "\r\n" <|> skipChar '\r' <|> skipChar '\n') *> pure '\n'
+
+def quote (p : Parser α) : Parser α :=
+  skipChar '\'' *> p <* skipChar '\''
+  <|> skipChar '"' *> p <* skipChar '"'
+
+/-- https://www.w3.org/TR/xml/#NT-Char -/
+def Char : Parser LeanChar :=
+  (attempt do
+  let c ← any
+  let cNat := c.toNat
+  if (0x20 ≤ cNat ∧ cNat ≤ 0xD7FF)
+   ∨ (0xE000 ≤ cNat ∧ cNat ≤ 0xFFFD)
+   ∨ (0x10000 ≤ cNat ∧ cNat ≤ 0x10FFFF) then pure c else fail "expected xml char")
+  <|> pchar '\t' <|> endl
+
+/-- https://www.w3.org/TR/xml/#NT-S -/
+def S : Parser String :=
+  many1Chars (pchar ' ' <|> endl <|> pchar '\t')
+
+/-- https://www.w3.org/TR/xml/#NT-Eq -/
+def Eq : Parser Unit :=
+  optional S *> skipChar '=' <* optional S
+
+private def nameStartCharRanges : Array (Nat × Nat) :=
+  #[(0xC0, 0xD6),
+    (0xD8, 0xF6),
+    (0xF8, 0x2FF),
+    (0x370, 0x37D),
+    (0x37F, 0x1FFF),
+    (0x200C, 0x200D),
+    (0x2070, 0x218F),
+    (0x2C00, 0x2FEF),
+    (0x3001, 0xD7FF),
+    (0xF900, 0xFDCF),
+    (0xFDF0, 0xFFFD),
+    (0x10000, 0xEFFFF)]
+
+/-- https://www.w3.org/TR/xml/#NT-NameStartChar -/
+def NameStartChar : Parser LeanChar := attempt do
+  let c ← any
+  if ('A' ≤ c ∧ c ≤ 'Z') ∨ ('a' ≤ c ∧ c ≤ 'z') then pure c
+  else if c = ':' ∨ c = '_' then pure c
+  else
+    let cNum := c.toNat
+    if nameStartCharRanges.any (fun (lo, hi) => lo ≤ cNum ∧ cNum ≤ hi) then pure c
+    else fail "expected a name character"
+
+/-- https://www.w3.org/TR/xml/#NT-NameChar -/
+def NameChar : Parser LeanChar :=
+  NameStartChar <|> digit <|> pchar '-' <|> pchar '.' <|> pchar '\xB7'
+  <|> satisfy (λ c => ('\u0300' ≤ c ∧ c ≤ '\u036F') ∨ ('\u203F' ≤ c ∧ c ≤ '\u2040'))
+
+/-- https://www.w3.org/TR/xml/#NT-Name -/
+def Name : Parser String := do
+  let x ← NameStartChar
+  manyCharsCore NameChar x.toString
+
+/-- https://www.w3.org/TR/xml/#NT-VersionNum -/
+def VersionNum : Parser Unit :=
+  skipString "1." <* (many1 digit)
+
+/-- https://www.w3.org/TR/xml/#NT-VersionInfo -/
+def VersionInfo : Parser Unit := do
+  S *>
+  skipString "version"
+  Eq
+  quote VersionNum
+
+/-- https://www.w3.org/TR/xml/#NT-EncName -/
+def EncName : Parser String := do
+  let x ← asciiLetter
+  manyCharsCore (asciiLetter <|> digit <|> pchar '-' <|> pchar '_' <|> pchar '.') x.toString
+
+/-- https://www.w3.org/TR/xml/#NT-EncodingDecl -/
+def EncodingDecl : Parser String := do
+  S *>
+  skipString "encoding"
+  Eq
+  quote EncName
+
+/-- https://www.w3.org/TR/xml/#NT-SDDecl -/
+def SDDecl : Parser String := do
+  S *> skipString "standalone" *> Eq *> quote (pstring "yes" <|> pstring "no")
+
+/-- https://www.w3.org/TR/xml/#NT-XMLDecl -/
+def XMLdecl : Parser Unit := do
+  skipString "<?xml"
+  VersionInfo
+  optional EncodingDecl *>
+  optional SDDecl *>
+  optional S *>
+  skipString "?>"
+
+/-- https://www.w3.org/TR/xml/#NT-Comment -/
+def Comment : Parser String :=
+  let notDash := Char.toString <$> satisfy (λ c => c ≠ '-')
+  skipString "<!--" *>
+  Array.foldl String.append "" <$> many (attempt <| notDash <|> (do
+    let d ← pchar '-'
+    let c ← notDash
+    pure $ d.toString ++ c))
+  <* skipString "-->"
+
+/-- https://www.w3.org/TR/xml/#NT-PITarget -/
+def PITarget : Parser String :=
+  Name <* (skipChar 'X' <|> skipChar 'x') <* (skipChar 'M' <|> skipChar 'm') <* (skipChar 'L' <|> skipChar 'l')
+
+/-- https://www.w3.org/TR/xml/#NT-PI -/
+def PI : Parser Unit := do
+  skipString "<?"
+  <* PITarget <*
+  optional (S *> manyChars (notFollowedBy (skipString "?>") *> Char))
+  skipString "?>"
+
+/-- https://www.w3.org/TR/xml/#NT-Misc -/
+def Misc : Parser Unit :=
+  Comment *> pure () <|> PI <|> S *> pure ()
+
+/-- https://www.w3.org/TR/xml/#NT-SystemLiteral -/
+def SystemLiteral : Parser String :=
+  pchar '"' *> manyChars (satisfy λ c => c ≠ '"') <* pchar '"'
+  <|> pchar '\'' *> manyChars (satisfy λ c => c ≠ '\'') <* pure '\''
+
+/-- https://www.w3.org/TR/xml/#NT-PubidChar -/
+def PubidChar : Parser LeanChar :=
+  asciiLetter <|> digit <|> endl <|> attempt do
+  let c ← any
+  if "-'()+,./:=?;!*#@$_%".contains c then pure c else fail "PublidChar expected"
+
+/-- https://www.w3.org/TR/xml/#NT-PubidLiteral -/
+def PubidLiteral : Parser String :=
+  pchar '"' *> manyChars PubidChar <* pchar '"'
+  <|> pchar '\'' *> manyChars (attempt do
+    let c ← PubidChar
+    if c = '\'' then fail "'\\'' not expected" else pure c) <* pchar '\''
+
+/-- https://www.w3.org/TR/xml/#NT-ExternalID -/
+def ExternalID : Parser Unit :=
+  skipString "SYSTEM" *> S *> SystemLiteral *> pure ()
+  <|> skipString "PUBLIC" *> S *> PubidLiteral *> S *> SystemLiteral *> pure ()
+
+/-- https://www.w3.org/TR/xml/#NT-Mixed -/
+def Mixed : Parser Unit :=
+  (do
+    skipChar '('
+    optional S *>
+    skipString "#PCDATA" *>
+    many (optional S *> skipChar '|' *> optional S *> Name) *>
+    optional S *>
+    skipString ")*")
+  <|> skipChar '(' *> (optional S) *> skipString "#PCDATA" <* (optional S) <* skipChar ')'
+
+mutual
+  /-- https://www.w3.org/TR/xml/#NT-cp -/
+  partial def cp : Parser Unit :=
+    (Name *> pure () <|> choice <|> seq) <* optional (skipChar '?' <|> skipChar '*' <|> skipChar '+')
+
+  /-- https://www.w3.org/TR/xml/#NT-choice -/
+  partial def choice : Parser Unit := do
+    skipChar '('
+    optional S *>
+    cp
+    many1 (optional S *> skipChar '|' *> optional S *> cp) *>
+    optional S *>
+    skipChar ')'
+
+  /-- https://www.w3.org/TR/xml/#NT-seq -/
+  partial def seq : Parser Unit := do
+    skipChar '('
+    optional S *>
+    cp
+    many (optional S *> skipChar ',' *> optional S *> cp) *>
+    optional S *>
+    skipChar ')'
+end
+
+/-- https://www.w3.org/TR/xml/#NT-children -/
+def children : Parser Unit :=
+  (choice <|> seq) <* optional (skipChar '?' <|> skipChar '*' <|> skipChar '+')
+
+/-- https://www.w3.org/TR/xml/#NT-contentspec -/
+def contentspec : Parser Unit := do
+  skipString "EMPTY" <|> skipString "ANY" <|> Mixed <|> children
+
+/-- https://www.w3.org/TR/xml/#NT-elementdecl -/
+def elementDecl : Parser Unit := do
+  skipString "<!ELEMENT"
+  S *>
+  Name *>
+  contentspec *>
+  optional S *>
+  skipChar '>'
+
+/-- https://www.w3.org/TR/xml/#NT-StringType -/
+def StringType : Parser Unit :=
+  skipString "CDATA"
+
+/-- https://www.w3.org/TR/xml/#NT-TokenizedType -/
+def TokenizedType : Parser Unit :=
+  skipString "ID"
+  <|> skipString "IDREF"
+  <|> skipString "IDREFS"
+  <|> skipString "ENTITY"
+  <|> skipString "ENTITIES"
+  <|> skipString "NMTOKEN"
+  <|> skipString "NMTOKENS"
+
+/-- https://www.w3.org/TR/xml/#NT-NotationType -/
+def NotationType : Parser Unit := do
+  skipString "NOTATION"
+  S *>
+  skipChar '(' <*
+  optional S
+  Name *> many (optional S *> skipChar '|' *> optional S *> Name) *>
+  optional S *>
+  skipChar ')'
+
+/-- https://www.w3.org/TR/xml/#NT-Nmtoken -/
+def Nmtoken : Parser String := do
+  many1Chars NameChar
+
+/-- https://www.w3.org/TR/xml/#NT-Enumeration -/
+def Enumeration : Parser Unit := do
+  skipChar '('
+  optional S *>
+  Nmtoken *> many (optional S *> skipChar '|' *> optional S *> Nmtoken) *>
+  optional S *>
+  skipChar ')'
+
+/-- https://www.w3.org/TR/xml/#NT-EnumeratedType -/
+def EnumeratedType : Parser Unit :=
+  NotationType <|> Enumeration
+
+/-- https://www.w3.org/TR/xml/#NT-AttType -/
+def AttType : Parser Unit :=
+  StringType <|> TokenizedType <|> EnumeratedType
+
+def predefinedEntityToChar : String → Option LeanChar
+| "lt" => some '<'
+| "gt" => some '>'
+| "amp" => some '&'
+| "apos" => some '\''
+| "quot" => some '"'
+| _ => none
+
+/-- https://www.w3.org/TR/xml/#NT-EntityRef -/
+def EntityRef : Parser $ Option LeanChar := attempt $
+  skipChar '&' *> predefinedEntityToChar <$> Name <* skipChar ';'
+
+@[inline]
+def hexDigitToNat (c : LeanChar) : Nat :=
+  if '0' ≤ c ∧ c ≤ '9' then c.toNat - '0'.toNat
+  else if 'a' ≤ c ∧ c ≤ 'f' then c.toNat - 'a'.toNat + 10
+  else c.toNat - 'A'.toNat + 10
+
+def digitsToNat (base : Nat) (digits : Array Nat) : Nat :=
+  digits.foldl (λ r d => r * base + d) 0
+
+/-- https://www.w3.org/TR/xml/#NT-CharRef -/
+def CharRef : Parser LeanChar := do
+  skipString "&#"
+  let charCode ←
+    digitsToNat 10 <$> many1 (hexDigitToNat <$> digit)
+    <|> skipChar 'x' *> digitsToNat 16 <$> many1 (hexDigitToNat <$> hexDigit)
+  skipChar ';'
+  return Char.ofNat charCode
+
+/-- https://www.w3.org/TR/xml/#NT-Reference -/
+def Reference : Parser $ Option LeanChar :=
+  EntityRef <|> some <$> CharRef
+
+/-- https://www.w3.org/TR/xml/#NT-AttValue -/
+def AttValue : Parser String := do
+  let chars ←
+  (do
+    skipChar '"'
+    many (some <$> satisfy (λ c => c ≠ '<' ∧ c ≠ '&' ∧ c ≠ '"') <|> Reference) <*
+    skipChar '"')
+  <|> (do
+    skipChar '\''
+    many (some <$> satisfy (λ c => c ≠ '<' ∧ c ≠ '&' ∧ c ≠ '\'') <|> Reference) <*
+    skipChar '\'')
+  return chars.foldl (λ s c => if let some c := c then s.push c else s) ""
+
+/-- https://www.w3.org/TR/xml/#NT-DefaultDecl -/
+def DefaultDecl : Parser Unit :=
+  skipString "#REQUIRED"
+  <|> skipString "#IMPLIED"
+  <|> optional (skipString "#FIXED" <* S) *> AttValue *> pure ()
+
+/-- https://www.w3.org/TR/xml/#NT-AttDef -/
+def AttDef : Parser Unit :=
+  S *> Name *> S *> AttType *> S *> DefaultDecl
+
+/-- https://www.w3.org/TR/xml/#NT-AttlistDecl -/
+def AttlistDecl : Parser Unit :=
+  skipString "<!ATTLIST" *> S *> Name *> many AttDef *> optional S *> skipChar '>'
+
+/-- https://www.w3.org/TR/xml/#NT-PEReference -/
+def PEReference : Parser Unit :=
+  skipChar '%' *> Name *> skipChar ';'
+
+/-- https://www.w3.org/TR/xml/#NT-EntityValue -/
+def EntityValue : Parser String := do
+  let chars ←
+  (do
+    skipChar '"'
+    many (some <$> satisfy (λ c => c ≠ '%' ∧ c ≠ '&' ∧ c ≠ '"') <|> PEReference *> pure none <|> Reference) <*
+    skipChar '"')
+  <|> (do
+    skipChar '\''
+    many (some <$> satisfy (λ c => c ≠ '%' ∧ c ≠ '&' ∧ c ≠ '\'') <|> PEReference *> pure none <|> Reference) <*
+    skipChar '\'')
+  return chars.foldl (λ s c => if let some c := c then s.push c else s) ""
+
+
+/-- https://www.w3.org/TR/xml/#NT-NDataDecl -/
+def NDataDecl : Parser Unit :=
+  S *> skipString "NDATA" <* S <* Name
+
+/-- https://www.w3.org/TR/xml/#NT-EntityDef -/
+def EntityDef : Parser Unit :=
+  EntityValue *> pure () <|> (ExternalID <* optional NDataDecl)
+
+/-- https://www.w3.org/TR/xml/#NT-GEDecl -/
+def GEDecl : Parser Unit :=
+  skipString "<!ENTITY" *> S *> Name *> S *> EntityDef *> optional S *> skipChar '>'
+
+/-- https://www.w3.org/TR/xml/#NT-PEDef -/
+def PEDef : Parser Unit :=
+  EntityValue *> pure () <|> ExternalID
+
+/-- https://www.w3.org/TR/xml/#NT-PEDecl -/
+def PEDecl : Parser Unit :=
+  skipString "<!ENTITY" *> S *> skipChar '%' *> S *> Name *> PEDef *> optional S *> skipChar '>'
+
+/-- https://www.w3.org/TR/xml/#NT-EntityDecl -/
+def EntityDecl : Parser Unit :=
+  GEDecl <|> PEDecl
+
+/-- https://www.w3.org/TR/xml/#NT-PublicID -/
+def PublicID : Parser Unit :=
+  skipString "PUBLIC" <* S <* PubidLiteral
+
+/-- https://www.w3.org/TR/xml/#NT-NotationDecl -/
+def NotationDecl : Parser Unit :=
+  skipString "<!NOTATION" *> S *> Name *> (ExternalID <|> PublicID) *> optional S *> skipChar '>'
+
+/-- https://www.w3.org/TR/xml/#NT-markupdecl -/
+def markupDecl : Parser Unit :=
+  elementDecl <|> AttlistDecl <|> EntityDecl <|> NotationDecl <|> PI <|> (Comment *> pure ())
+
+/-- https://www.w3.org/TR/xml/#NT-DeclSep -/
+def DeclSep : Parser Unit :=
+  PEReference <|> S *> pure ()
+
+/-- https://www.w3.org/TR/xml/#NT-intSubset -/
+def intSubset : Parser Unit :=
+  many (markupDecl <|> DeclSep) *> pure ()
+
+/-- https://www.w3.org/TR/xml/#NT-doctypedecl -/
+def doctypedecl : Parser Unit := do
+  skipString "<!DOCTYPE"
+  S *>
+  Name *>
+  optional (S *> ExternalID) *> pure ()
+  <* optional S
+  optional (skipChar '[' *> intSubset <* skipChar ']' <* optional S) *>
+  skipChar '>'
+
+/-- https://www.w3.org/TR/xml/#NT-prolog -/
+def prolog : Parser Unit :=
+  optional XMLdecl *>
+  many Misc *>
+  optional (doctypedecl <* many Misc) *> pure ()
+
+/-- https://www.w3.org/TR/xml/#NT-Attribute -/
+def Attribute : Parser (String × String) := do
+  let name ← Name
+  Eq
+  let value ← AttValue
+  return (name, value)
+
+protected def elementPrefix : Parser (Array Content → Element) := do
+  skipChar '<'
+  let name ← Name
+  let attributes ← many (attempt <| S *> Attribute)
+  optional S *> pure ()
+  return Element.Element name (RBMap.fromList attributes.toList compare)
+
+/-- https://www.w3.org/TR/xml/#NT-EmptyElemTag -/
+def EmptyElemTag (elem : Array Content → Element) : Parser Element := do
+  skipString "/>" *> pure (elem #[])
+
+/-- https://www.w3.org/TR/xml/#NT-STag -/
+def STag (elem : Array Content → Element) : Parser (Array Content → Element) := do
+  skipChar '>' *> pure elem
+
+/-- https://www.w3.org/TR/xml/#NT-ETag -/
+def ETag : Parser Unit :=
+  skipString "</" *> Name *> optional S *> skipChar '>'
+
+/-- https://www.w3.org/TR/xml/#NT-CDStart -/
+def CDStart : Parser Unit :=
+  skipString "<![CDATA["
+
+/-- https://www.w3.org/TR/xml/#NT-CDEnd -/
+def CDEnd : Parser Unit :=
+  skipString "]]>"
+
+/-- https://www.w3.org/TR/xml/#NT-CData -/
+def CData : Parser String :=
+  manyChars (notFollowedBy (skipString "]]>") *> any)
+
+/-- https://www.w3.org/TR/xml/#NT-CDSect -/
+def CDSect : Parser String :=
+  CDStart *> CData <* CDEnd
+
+/-- https://www.w3.org/TR/xml/#NT-CharData -/
+def CharData : Parser String :=
+  notFollowedBy (skipString "]]>") *> manyChars (satisfy λ c => c ≠ '<' ∧ c ≠ '&')
+
+mutual
+  /-- https://www.w3.org/TR/xml/#NT-content -/
+  partial def content : Parser (Array Content) := do
+    let x ← optional (Content.Character <$> CharData)
+    let xs ← many do
+      let y ←
+        attempt (some <$> Content.Element <$> element)
+        <|> (do let c ← Reference; pure <| c.map (Content.Character ∘ Char.toString))
+        <|> some <$> Content.Character <$> CDSect
+        <|> PI *> pure none
+        <|> some <$> Content.Comment <$> Comment
+
+      let z ← optional (Content.Character <$> CharData)
+      pure #[y, z]
+    let xs := #[x] ++ xs.flatMap id |>.filterMap id
+    let mut res := #[]
+    for x in xs do
+      if res.size > 0 then
+        match res.back!, x with
+        | Content.Character x, Content.Character y => res := res.set! (res.size - 1) (Content.Character $ x ++ y)
+        | _, x => res := res.push x
+      else res := res.push x
+    return res
+
+  /-- https://www.w3.org/TR/xml/#NT-element -/
+  partial def element : Parser Element := do
+    let elem ← Parser.elementPrefix
+    EmptyElemTag elem <|> STag elem <*> content <* ETag
+
+end
+
+/-- https://www.w3.org/TR/xml/#NT-document -/
+def document : Parser Element := prolog *> element <* many Misc <* eof
+
+end Parser
+
+def parse (s : String) : Except String Element :=
+  Parser.run Xml.Parser.document s
+
+end Xml

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/DocString/Add.lean

@@ -0,0 +1,61 @@
+/-
+Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: David Thrane Christiansen
+-/
+
+prelude
+import Lean.Environment
+import Lean.Exception
+import Lean.Log
+import Lean.DocString.Extension
+import Lean.DocString.Links
+
+set_option linter.missingDocs true
+
+namespace Lean
+
+/--
+Validates all links to the Lean reference manual in `docstring`.
+
+This is intended to be used before saving a docstring that is later subject to rewriting with
+`rewriteManualLinks`.
+-/
+def validateDocComment
+    [Monad m] [MonadLog m] [AddMessageContext m] [MonadOptions m] [MonadLiftT IO m]
+    (docstring : TSyntax `Lean.Parser.Command.docComment) :
+    m Unit := do
+  let str := docstring.getDocString
+  let pos? := docstring.raw[1].getHeadInfo? >>= (·.getPos?)
+
+  let (errs, out) ← (rewriteManualLinksCore str : IO _)
+
+  for (⟨start, stop⟩, err) in errs do
+    -- Report errors at their actual location if possible
+    if let some pos := pos? then
+      let urlStx : Syntax := .atom (.synthetic (pos + start) (pos + stop)) (str.extract start stop)
+      logErrorAt urlStx err
+    else
+      logError err
+
+/--
+Adds a docstring to the environment, validating documentation links.
+-/
+def addDocString
+    [Monad m] [MonadError m] [MonadEnv m] [MonadLog m] [AddMessageContext m] [MonadOptions m] [MonadLiftT IO m]
+    (declName : Name) (docComment : TSyntax `Lean.Parser.Command.docComment) : m Unit := do
+  unless (← getEnv).getModuleIdxFor? declName |>.isNone do
+    throwError s!"invalid doc string, declaration '{declName}' is in an imported module"
+  validateDocComment docComment
+  let docString : String ← getDocStringText docComment
+  modifyEnv fun env => docStringExt.insert env declName docString.removeLeadingSpaces
+
+/--
+Adds a docstring to the environment, validating documentation links.
+-/
+def addDocString'
+    [Monad m] [MonadError m] [MonadEnv m] [MonadLog m] [AddMessageContext m] [MonadOptions m] [MonadLiftT IO m]
+    (declName : Name) (docString? : Option (TSyntax `Lean.Parser.Command.docComment)) : m Unit :=
+  match docString? with
+  | some docString => addDocString declName docString
+  | none => return ()

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/DocString/Extension.lean

@@ -0,0 +1,81 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.DeclarationRange
+import Lean.DocString.Links
+import Lean.MonadEnv
+import Init.Data.String.Extra
+
+-- This module contains the underlying data for docstrings, with as few imports as possible, so that
+-- docstrings can be saved in as much of the compiler as possible.
+-- The module `Lean.DocString` contains the query interface, which needs to look at additional data
+-- to construct user-visible docstrings.
+
+namespace Lean
+
+private builtin_initialize builtinDocStrings : IO.Ref (NameMap String) ← IO.mkRef {}
+builtin_initialize docStringExt : MapDeclarationExtension String ← mkMapDeclarationExtension
+
+/--
+Adds a builtin docstring to the compiler.
+
+Links to the Lean manual aren't validated.
+-/
+-- See the test `lean/run/docstringRewrites.lean` for the validation of builtin docstring links
+def addBuiltinDocString (declName : Name) (docString : String) : IO Unit := do
+  builtinDocStrings.modify (·.insert declName docString.removeLeadingSpaces)
+
+def addDocStringCore [Monad m] [MonadError m] [MonadEnv m] (declName : Name) (docString : String) : m Unit := do
+  unless (← getEnv).getModuleIdxFor? declName |>.isNone do
+    throwError s!"invalid doc string, declaration '{declName}' is in an imported module"
+  modifyEnv fun env => docStringExt.insert env declName docString.removeLeadingSpaces
+
+def addDocStringCore' [Monad m] [MonadError m] [MonadEnv m] (declName : Name) (docString? : Option String) : m Unit :=
+  match docString? with
+  | some docString => addDocStringCore declName docString
+  | none => return ()
+
+/--
+Finds a docstring without performing any alias resolution or enrichment with extra metadata.
+
+Docstrings to be shown to a user should be looked up with `Lean.findDocString?` instead.
+-/
+def findSimpleDocString? (env : Environment) (declName : Name) (includeBuiltin := true) : IO (Option String) :=
+  if let some docStr := docStringExt.find? env declName then
+    return some docStr
+  else if includeBuiltin then
+    return (← builtinDocStrings.get).find? declName
+  else
+    return none
+
+structure ModuleDoc where
+  doc : String
+  declarationRange : DeclarationRange
+
+private builtin_initialize moduleDocExt : SimplePersistentEnvExtension ModuleDoc (PersistentArray ModuleDoc) ← registerSimplePersistentEnvExtension {
+  addImportedFn := fun _ => {}
+  addEntryFn    := fun s e => s.push e
+  exportEntriesFnEx? := some fun _ _ es level =>
+    if level < .server then
+      #[]
+    else
+      es.toArray
+}
+
+def addMainModuleDoc (env : Environment) (doc : ModuleDoc) : Environment :=
+  moduleDocExt.addEntry env doc
+
+def getMainModuleDoc (env : Environment) : PersistentArray ModuleDoc :=
+  moduleDocExt.getState env
+
+def getModuleDoc? (env : Environment) (moduleName : Name) : Option (Array ModuleDoc) :=
+  env.getModuleIdx? moduleName |>.map fun modIdx =>
+    moduleDocExt.getModuleEntries (level := .server) env modIdx
+
+def getDocStringText [Monad m] [MonadError m] (stx : TSyntax `Lean.Parser.Command.docComment) : m String :=
+  match stx.raw[1] with
+  | Syntax.atom _ val => return val.extract 0 (val.endPos - ⟨2⟩)
+  | _                 => throwErrorAt stx "unexpected doc string{indentD stx.raw[1]}"

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/DocString/Links.lean

@@ -0,0 +1,171 @@
+/-
+Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: David Thrane Christiansen
+-/
+
+prelude
+import Lean.Syntax
+
+set_option linter.missingDocs true
+
+namespace Lean
+
+@[extern "lean_manual_get_root"]
+private opaque getManualRoot : Unit → String
+
+private def fallbackManualRoot := "https://lean-lang.org/doc/reference/latest/"
+
+/--
+Computes the root of the Lean reference manual that should be used for targets.
+
+If the environment variable `LEAN_MANUAL_ROOT` is set, it is used as the root. If not, but a manual
+root is pre-configured for the current Lean executable (typically true for releases), then it is
+used. If neither are true, then `https://lean-lang.org/doc/reference/latest/` is used.
+-/
+builtin_initialize manualRoot : String ←
+  let r ←
+    if let some root := (← IO.getEnv "LEAN_MANUAL_ROOT") then
+      pure root
+    else
+      let root := getManualRoot ()
+      if root.isEmpty then
+        pure fallbackManualRoot
+      else
+        pure root
+  return if r.endsWith "/" then r else r ++ "/"
+
+/--
+The manual domain for error explanations.
+
+We expose this because it is used to populate the URL of the error message description widget.
+-/
+def errorExplanationManualDomain :=
+  "Manual.errorExplanation"
+
+-- TODO: we may wish to make this more general for domains that require additional arguments
+/-- Maps `lean-manual` URL paths to their corresponding manual domains. -/
+private def domainMap : Std.HashMap String String :=
+  Std.HashMap.ofList [
+    ("section", "Verso.Genre.Manual.section"),
+    ("errorExplanation", errorExplanationManualDomain)
+  ]
+
+/--
+Rewrites links from the internal Lean manual syntax to the correct URL. This rewriting is an
+overapproximation: any parentheses containing the internal syntax of a Lean manual URL is rewritten.
+
+The internal syntax is the URL scheme `lean-manual` followed by the path `/KIND/MORE...`, where
+`KIND` is a kind of content being linked to. Presently, the only valid kind is `section`, and it
+requires that the remainder of the path consists of one element, which is a section or part identifier.
+
+The correct URL is based on a manual root URL, which is determined by the `LEAN_MANUAL_ROOT`
+environment variable. If this environment variable is not set, a manual root provided when Lean was
+built is used (typically this is the version corresponding to the current release). If no such root
+is available, the latest version of the manual is used.
+-/
+def rewriteManualLinksCore (s : String) : BaseIO (Array (String.Range × String) × String) := do
+  let scheme := "lean-manual://"
+  let mut out := ""
+  let mut errors := #[]
+  let mut iter := s.iter
+  while h : iter.hasNext do
+    let c := iter.curr' h
+    iter := iter.next' h
+
+    if !lookingAt scheme iter.prev then
+      out := out.push c
+      continue
+
+    let start := iter.prev.forward scheme.length
+    let mut iter' := start
+    while h' : iter'.hasNext do
+      let c' := iter'.curr' h'
+      iter' := iter'.next' h'
+      if urlChar c' && !iter'.atEnd then
+        continue
+      match rw (start.extract iter'.prev) with
+      | .error err =>
+        errors := errors.push (⟨iter.prev.i, iter'.prev.i⟩, err)
+        out := out.push c
+        break
+      | .ok path =>
+        out := out ++ manualRoot ++ path
+        out := out.push c'
+        iter := iter'
+        break
+
+  pure (errors, out)
+
+where
+  /--
+  Returns `true` if the character is one of those allowed in RFC 3986 sections 2.2 and 2.3. other
+  than '(' or')'.
+  -/
+  urlChar (c : Char) : Bool :=
+    -- unreserved
+    c.isAlphanum || c == '-' || c == '.' || c == '_' || c == '~' ||
+    -- gen-delims
+    c == ':' || c == '/' || c == '?' || c == '#' || c == '[' || c == ']' || c == '@' ||
+    -- sub-delims
+    -- ( and ) are excluded due to Markdown's link syntax
+    c == '!' || c == '$' || c == '&' || c == '\'' || /- c == '(' || c == ')' || -/ c == '*' ||
+    c == '+' || c == ',' || c == ';' || c == '='
+
+  /--
+  Returns `true` if `goal` is a prefix of the string at the position pointed to by `iter`.
+  -/
+  lookingAt (goal : String) (iter : String.Iterator) : Bool :=
+    iter.s.substrEq iter.i goal 0 goal.endPos.byteIdx
+
+  rw (path : String) : Except String String := do
+    match path.splitOn "/" with
+    | [] | [""] =>
+      throw "Missing documentation type"
+    | kind :: args =>
+      if let some domain := domainMap.get? kind then
+        if let [s] := args then
+          if s.isEmpty then
+            throw s!"Empty {kind} ID"
+          return s!"find/?domain={domain}&name={s}"
+        else
+          throw s!"Expected one item after `{kind}`, but got {args}"
+      else
+        let acceptableKinds := ", ".intercalate <| domainMap.toList.map fun (k, _) => s!"`{k}`"
+        throw s!"Unknown documentation type `{kind}`. Expected one of the following: {acceptableKinds}"
+
+
+/--
+Rewrites Lean reference manual links in `docstring` to point at the reference manual.
+
+This assumes that all such links have already been validated by `validateDocComment`.
+-/
+def rewriteManualLinks (docString : String) : BaseIO String := do
+  let (errs, str) ← rewriteManualLinksCore docString
+  if !errs.isEmpty then
+    let errReport :=
+      r#"**❌ Syntax Errors in Lean Language Reference Links**
+
+The `lean-manual` URL scheme is used to link to the version of the Lean reference manual that
+corresponds to this version of Lean. Errors occurred while processing the links in this documentation
+comment:
+"# ++
+      String.join (errs.toList.map (fun (⟨s, e⟩, msg) => s!" * ```{docString.extract s e}```: {msg}\n\n"))
+    return str ++ "\n\n" ++ errReport
+  return str
+
+
+/--
+Validates all links to the Lean reference manual in `docstring`, printing an error message if any
+are invalid. Returns `true` if all links are valid.
+
+This is intended to be used before saving a docstring that is later subject to rewriting with
+`rewriteManualLinks`, in contexts where the imports needed to produce better error messages in
+`validateDocComment` are not yet available.
+-/
+def validateBuiltinDocString (docString : String) : IO Unit := do
+  let (errs, _) ← rewriteManualLinksCore docString
+  if !errs.isEmpty then
+    throw <| IO.userError <|
+      s!"Errors in builtin documentation comment:\n" ++
+      String.join (errs.toList.map fun (⟨s, e⟩, msg) => s!" * {repr <| docString.extract s e}:\n    {msg}\n")

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/App.lean

@@ -0,0 +1,1854 @@
+/-
+Copyright (c) 2019 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.Util.FindMVar
+import Lean.Util.CollectFVars
+import Lean.Parser.Term
+import Lean.Meta.KAbstract
+import Lean.Meta.Tactic.ElimInfo
+import Lean.Elab.Term
+import Lean.Elab.Binders
+import Lean.Elab.SyntheticMVars
+import Lean.Elab.Arg
+import Lean.Elab.RecAppSyntax
+
+namespace Lean.Elab.Term
+open Meta
+
+/--
+Instructs the elaborator to elaborate applications of the given declaration without an expected
+type. This may prevent the elaborator from incorrectly inferring implicit arguments.
+-/
+@[builtin_doc]
+builtin_initialize elabWithoutExpectedTypeAttr : TagAttribute ←
+  registerTagAttribute `elab_without_expected_type "mark that applications of the given declaration should be elaborated without the expected type"
+
+def hasElabWithoutExpectedType (env : Environment) (declName : Name) : Bool :=
+  elabWithoutExpectedTypeAttr.hasTag env declName
+
+instance : ToString Arg where
+  toString
+    | .stx  val => toString val
+    | .expr val => toString val
+
+instance : ToString NamedArg where
+  toString s := "(" ++ toString s.name ++ " := " ++ toString s.val ++ ")"
+
+def throwInvalidNamedArg (namedArg : NamedArg) (fn? : Option Name) : TermElabM α :=
+  withRef namedArg.ref <| match fn? with
+    | some fn => throwError "invalid argument name '{namedArg.name}' for function '{fn}'"
+    | none    => throwError "invalid argument name '{namedArg.name}' for function"
+
+private def ensureArgType (f : Expr) (arg : Expr) (expectedType : Expr) : TermElabM Expr := do
+  try
+    ensureHasType expectedType arg none f
+  catch
+    | ex@(.error ..) =>
+      if (← read).errToSorry then
+        exceptionToSorry ex expectedType
+      else
+        throw ex
+    | ex => throw ex
+
+private def mkProjAndCheck (structName : Name) (idx : Nat) (e : Expr) : MetaM Expr := do
+  let r := mkProj structName idx e
+  let eType ← inferType e
+  if (← isProp eType) then
+    let rType ← inferType r
+    if !(← isProp rType) then
+      throwError "Invalid projection: Cannot project a value of non-propositional type{indentExpr rType}\
+        \nfrom the expression{indentExpr e}\nwhich has propositional type{indentExpr eType}"
+  return r
+
+def synthesizeAppInstMVars (instMVars : Array MVarId) (app : Expr) : TermElabM Unit :=
+  for mvarId in instMVars do
+    unless (← synthesizeInstMVarCore mvarId) do
+      registerSyntheticMVarWithCurrRef mvarId (.typeClass none)
+      registerMVarErrorImplicitArgInfo mvarId (← getRef) app
+
+/-- Return `some namedArg` if `namedArgs` contains an entry for `binderName`. -/
+private def findBinderName? (namedArgs : List NamedArg) (binderName : Name) : Option NamedArg :=
+  namedArgs.find? fun namedArg => namedArg.name == binderName
+
+/-- Erase entry for `binderName` from `namedArgs`. -/
+def eraseNamedArg (namedArgs : List NamedArg) (binderName : Name) : List NamedArg :=
+  namedArgs.filter (·.name != binderName)
+
+/-- Return true if the given type contains `OptParam` or `AutoParams` -/
+private def hasOptAutoParams (type : Expr) : MetaM Bool := do
+  forallTelescopeReducing type fun xs _ =>
+    xs.anyM fun x => do
+      let xType ← inferType x
+      return xType.getOptParamDefault?.isSome || xType.getAutoParamTactic?.isSome
+
+
+/-! # Default application elaborator -/
+namespace ElabAppArgs
+
+structure Context where
+  /--
+   `true` if `..` was used
+  -/
+  ellipsis      : Bool  --
+  /--
+   `true` if `@` modifier was used
+  -/
+  explicit      : Bool
+  /--
+    If the result type of an application is the `outParam` of some local instance, then special support may be needed
+    because type class resolution interacts poorly with coercions in this kind of situation.
+    This flag enables the special support.
+
+    The idea is quite simple, if the result type is the `outParam` of some local instance, we simply
+    execute `synthesizeSyntheticMVarsUsingDefault`. We added this feature to make sure examples as follows
+    are correctly elaborated.
+    ```lean
+    class GetElem (Cont : Type u) (Idx : Type v) (Elem : outParam (Type w)) where
+      getElem (xs : Cont) (i : Idx) : Elem
+
+    export GetElem (getElem)
+
+    instance : GetElem (Array α) Nat α where
+      getElem xs i := xs.get ⟨i, sorry⟩
+
+    opaque f : Option Bool → Bool
+    opaque g : Bool → Bool
+
+    def bad (xs : Array Bool) : Bool :=
+      let x := getElem xs 0
+      f x && g x
+    ```
+    Without the special support, Lean fails at `g x` saying `x` has type `Option Bool` but is expected to have type `Bool`.
+    From the user's point of view this is a bug, since `let x := getElem xs 0` clearly constrains `x` to be `Bool`, but
+    we only obtain this information after we apply the `OfNat` default instance for `0`.
+
+    Before converging to this solution, we have tried to create a "coercion placeholder" when `resultIsOutParamSupport = true`,
+    but it did not work well in practice. For example, it failed in the example above.
+  -/
+  resultIsOutParamSupport : Bool
+
+/-- Auxiliary structure for elaborating the application `f args namedArgs`. -/
+structure State where
+  f                    : Expr
+  fType                : Expr
+  /-- Remaining regular arguments. -/
+  args                 : List Arg
+  /-- remaining named arguments to be processed. -/
+  namedArgs            : List NamedArg
+  expectedType?        : Option Expr
+  /--
+    When named arguments are provided and explicit arguments occurring before them are missing,
+    the elaborator eta-expands the declaration. For example,
+    ```
+    def f (x y : Nat) := x + y
+    #check f (y := 5)
+    -- fun x => f x 5
+    ```
+    `etaArgs` stores the fresh free variables for implementing the eta-expansion.
+    When `..` is used, eta-expansion is disabled, and missing arguments are treated as `_`.
+  -/
+  etaArgs              : Array Expr   := #[]
+  /-- Metavariables that we need to set the error context using the application being built. -/
+  toSetErrorCtx        : Array MVarId := #[]
+  /-- Metavariables for the instance implicit arguments that have already been processed. -/
+  instMVars            : Array MVarId := #[]
+  /--
+    The following field is used to implement the `propagateExpectedType` heuristic.
+    It is set to `true` true when `expectedType` still has to be propagated.
+  -/
+  propagateExpected    : Bool
+  /--
+    If the result type may be the `outParam` of some local instance.
+    See comment at `Context.resultIsOutParamSupport`
+   -/
+  resultTypeOutParam?  : Option MVarId := none
+
+abbrev M := ReaderT Context (StateRefT State TermElabM)
+
+/-- Add the given metavariable to the collection of metavariables associated with instance-implicit arguments. -/
+private def addInstMVar (mvarId : MVarId) : M Unit :=
+  modify fun s => { s with instMVars := s.instMVars.push mvarId }
+
+/--
+  Try to synthesize metavariables are `instMVars` using type class resolution.
+  The ones that cannot be synthesized yet stay in the `instMVars` list.
+  Remark: we use this method
+    - before trying to apply coercions to function,
+    - before unifying the expected type.
+-/
+def trySynthesizeAppInstMVars : M Unit := do
+  let instMVars ← (← get).instMVars.filterM fun instMVar => do
+    unless (← instantiateMVars (← inferType (.mvar instMVar))).isMVar do try
+      if (← synthesizeInstMVarCore instMVar) then
+        return false
+      catch _ => pure ()
+    return true
+  modify ({ · with instMVars })
+
+/--
+  Try to synthesize metavariables are `instMVars` using type class resolution.
+  The ones that cannot be synthesized yet are registered.
+-/
+def synthesizeAppInstMVars : M Unit := do
+  Term.synthesizeAppInstMVars (← get).instMVars (← get).f
+  modify ({ · with instMVars := #[] })
+
+/-- fType may become a forallE after we synthesize pending metavariables. -/
+private def synthesizePendingAndNormalizeFunType : M Unit := do
+  trySynthesizeAppInstMVars
+  synthesizeSyntheticMVars
+  let s ← get
+  let fType ← whnfForall s.fType
+  if fType.isForall then
+    modify fun s => { s with fType }
+  else
+    if let some f ← coerceToFunction? s.f then
+      let fType ← inferType f
+      modify fun s => { s with f, fType }
+    else
+      for namedArg in s.namedArgs do
+        let f := s.f.getAppFn
+        if f.isConst then
+          throwInvalidNamedArg namedArg f.constName!
+        else
+          throwInvalidNamedArg namedArg none
+      -- Help users see if this is actually due to an indentation mismatch/other parsing mishaps:
+      let extra := if let some (arg : Arg) := s.args[0]? then
+        .note m!"Expected a function because this term is being applied to the argument\
+          {indentD <| toMessageData arg}"
+      else .nil
+      throwError "Function expected at{indentExpr s.f}\nbut this term has type{indentExpr fType}{extra}"
+
+/-- Normalize and return the function type. -/
+private def normalizeFunType : M Expr := do
+  let s ← get
+  let fType ← whnfForall s.fType
+  modify fun s => { s with fType }
+  return fType
+
+/-- Return the binder name at `fType`. This method assumes `fType` is a function type. -/
+private def getBindingName : M Name := return (← get).fType.bindingName!
+
+/-- Return the next argument expected type. This method assumes `fType` is a function type. -/
+private def getArgExpectedType : M Expr := return (← get).fType.bindingDomain!
+
+/-- Remove named argument with name `binderName` from `namedArgs`. -/
+def eraseNamedArg (binderName : Name) : M Unit :=
+  modify fun s => { s with namedArgs := Term.eraseNamedArg s.namedArgs binderName }
+
+/--
+  Add a new argument to the result. That is, `f := f arg`, update `fType`.
+  This method assumes `fType` is a function type. -/
+private def addNewArg (argName : Name) (arg : Expr) : M Unit := do
+  modify fun s => { s with f := mkApp s.f arg, fType := s.fType.bindingBody!.instantiate1 arg }
+  if arg.isMVar then
+    registerMVarArgName arg.mvarId! argName
+
+/--
+  Elaborate the given `Arg` and add it to the result. See `addNewArg`.
+  Recall that, `Arg` may be wrapping an already elaborated `Expr`. -/
+private def elabAndAddNewArg (argName : Name) (arg : Arg) : M Unit := do
+  let s ← get
+  let expectedType := (← getArgExpectedType).consumeTypeAnnotations
+  match arg with
+  | Arg.expr val =>
+    let arg ← ensureArgType s.f val expectedType
+    addNewArg argName arg
+  | Arg.stx stx  =>
+    let val ← elabTerm stx expectedType
+    let arg ← withRef stx <| ensureArgType s.f val expectedType
+    addNewArg argName arg
+
+/-- Return true if `fType` contains `OptParam` or `AutoParams` -/
+private def fTypeHasOptAutoParams : M Bool := do
+  hasOptAutoParams (← get).fType
+
+/--
+   Auxiliary function for retrieving the resulting type of a function application.
+   See `propagateExpectedType`.
+   Remark: `(explicit : Bool) == true` when `@` modifier is used. -/
+private partial def getForallBody (explicit : Bool) : Nat → List NamedArg → Expr → Option Expr
+  | i, namedArgs, type@(.forallE n d b bi) =>
+    match findBinderName? namedArgs n with
+    | some _ => getForallBody explicit i (Term.eraseNamedArg namedArgs n) b
+    | none =>
+      if !explicit && !bi.isExplicit then
+        getForallBody explicit i namedArgs b
+      else if i > 0 then
+        getForallBody explicit (i-1) namedArgs b
+      else if d.isAutoParam || d.isOptParam then
+        getForallBody explicit i namedArgs b
+      else
+        some type
+  | 0, [], type => some type
+  | _, _,  _    => none
+
+private def shouldPropagateExpectedTypeFor (nextArg : Arg) : Bool :=
+  match nextArg with
+  | .expr _  => false -- it has already been elaborated
+  | .stx stx =>
+    -- TODO: make this configurable?
+    stx.getKind != ``Lean.Parser.Term.hole &&
+    stx.getKind != ``Lean.Parser.Term.syntheticHole &&
+    stx.getKind != ``Lean.Parser.Term.byTactic
+
+/--
+  Auxiliary method for propagating the expected type. We call it as soon as we find the first explicit
+  argument. The goal is to propagate the expected type in applications of functions such as
+  ```lean
+  Add.add {α : Type u} : α → α → α
+  List.cons {α : Type u} : α → List α → List α
+  ```
+  This is particularly useful when there applicable coercions. For example,
+  assume we have a coercion from `Nat` to `Int`, and we have
+  `(x : Nat)` and the expected type is `List Int`. Then, if we don't use this function,
+  the elaborator will fail to elaborate
+  ```
+  List.cons x []
+  ```
+  First, the elaborator creates a new metavariable `?α` for the implicit argument `{α : Type u}`.
+  Then, when it processes `x`, it assigns `?α := Nat`, and then obtains the
+  resultant type `List Nat` which is **not** definitionally equal to `List Int`.
+  We solve the problem by executing this method before we elaborate the first explicit argument (`x` in this example).
+  This method infers that the resultant type is `List ?α` and unifies it with `List Int`.
+  Then, when we elaborate `x`, the elaborate realizes the coercion from `Nat` to `Int` must be used, and the
+  term
+  ```
+  @List.cons Int (coe x) (@List.nil Int)
+  ```
+  is produced.
+
+  The method will do nothing if
+  1- The resultant type depends on the remaining arguments (i.e., `!eTypeBody.hasLooseBVars`).
+  2- The resultant type contains optional/auto params.
+
+  We have considered adding the following extra conditions
+    a) The resultant type does not contain any type metavariable.
+    b) The resultant type contains a nontype metavariable.
+
+  These two conditions would restrict the method to simple functions that are "morally" in
+  the Hindley&Milner fragment.
+  If users need to disable expected type propagation, we can add an attribute `[elab_without_expected_type]`.
+-/
+private def propagateExpectedType (arg : Arg) : M Unit := do
+  if shouldPropagateExpectedTypeFor arg then
+    let s ← get
+    -- TODO: handle s.etaArgs.size > 0
+    unless !s.etaArgs.isEmpty || !s.propagateExpected do
+      match s.expectedType? with
+      | none              => pure ()
+      | some expectedType =>
+        /- We don't propagate `Prop` because we often use `Prop` as a more general "Bool" (e.g., `if-then-else`).
+           If we propagate `expectedType == Prop` in the following examples, the elaborator would fail
+           ```
+           def f1 (s : Nat × Bool) : Bool := if s.2 then false else true
+
+           def f2 (s : List Bool) : Bool := if s.head! then false else true
+
+           def f3 (s : List Bool) : Bool := if List.head! (s.map not) then false else true
+           ```
+           They would all fail for the same reason. So, let's focus on the first one.
+           We would elaborate `s.2` with `expectedType == Prop`.
+           Before we elaborate `s`, this method would be invoked, and `s.fType` is `?α × ?β → ?β` and after
+           propagation we would have `?α × Prop → Prop`. Then, when we would try to elaborate `s`, and
+           get a type error because `?α × Prop` cannot be unified with `Nat × Bool`.
+           Most users would have a hard time trying to understand why these examples failed.
+
+           Here is a possible alternative workaround. We give up the idea of using `Prop` at `if-then-else`.
+           Drawback: users use `if-then-else` with conditions that are not Decidable.
+           So, users would have to embrace `propDecidable` and `choice`.
+           This may not be that bad since the developers and users don't seem to care about constructivism.
+
+           We currently use a different workaround, we just don't propagate the expected type when it is `Prop`. -/
+        if expectedType.isProp then
+          modify fun s => { s with propagateExpected := false }
+        else
+          let numRemainingArgs := s.args.length
+          trace[Elab.app.propagateExpectedType] "etaArgs.size: {s.etaArgs.size}, numRemainingArgs: {numRemainingArgs}, fType: {s.fType}"
+          match getForallBody (← read).explicit numRemainingArgs s.namedArgs s.fType with
+          | none           => pure ()
+          | some fTypeBody =>
+            unless fTypeBody.hasLooseBVars do
+              unless (← hasOptAutoParams fTypeBody) do
+                trySynthesizeAppInstMVars
+                trace[Elab.app.propagateExpectedType] "{expectedType} =?= {fTypeBody}"
+                if (← isDefEq expectedType fTypeBody) then
+                  /- Note that we only set `propagateExpected := false` when propagation has succeeded. -/
+                  modify fun s => { s with propagateExpected := false }
+
+/-- This method executes after all application arguments have been processed. -/
+private def finalize : M Expr := do
+  let s ← get
+  let mut e := s.f
+  -- all user explicit arguments have been consumed
+  trace[Elab.app.finalize] e
+  let ref ← getRef
+  -- Register the error context of implicits
+  for mvarId in s.toSetErrorCtx do
+    registerMVarErrorImplicitArgInfo mvarId ref e
+  if !s.etaArgs.isEmpty then
+    e ← mkLambdaFVars s.etaArgs e
+  /-
+    Remark: we should not use `s.fType` as `eType` even when
+    `s.etaArgs.isEmpty`. Reason: it may have been unfolded.
+  -/
+  let eType ← inferType e
+  trace[Elab.app.finalize] "after etaArgs, {e} : {eType}"
+  /- Recall that `resultTypeOutParam? = some mvarId` if the function result type is the output parameter
+     of a local instance. The value of this parameter may be inferable using other arguments. For example,
+     suppose we have
+     ```lean
+     def add_one {X} [Trait X] [One (Trait.R X)] [HAdd X (Trait.R X) X] (x : X) : X := x + (One.one : (Trait.R X))
+     ```
+     from test `948.lean`. There are multiple ways to infer `X`, and we don't want to mark it as `syntheticOpaque`.
+  -/
+  if let some outParamMVarId := s.resultTypeOutParam? then
+    synthesizeAppInstMVars
+    /- If `eType != mkMVar outParamMVarId`, then the
+       function is partially applied, and we do not apply default instances. -/
+    if !(← outParamMVarId.isAssigned) && eType.isMVar && eType.mvarId! == outParamMVarId then
+      synthesizeSyntheticMVarsUsingDefault
+      return e
+    else
+      return e
+  if let some expectedType := s.expectedType? then
+    trySynthesizeAppInstMVars
+    -- Try to propagate expected type. Ignore if types are not definitionally equal, caller must handle it.
+    trace[Elab.app.finalize] "expected type: {expectedType}"
+    discard <| isDefEq expectedType eType
+  synthesizeAppInstMVars
+  return e
+
+/--
+Returns a named argument that depends on the next argument, otherwise `none`.
+-/
+private def findNamedArgDependsOnCurrent? : M (Option NamedArg) := do
+  let s ← get
+  if s.namedArgs.isEmpty then
+    return none
+  else
+    forallTelescopeReducing s.fType fun xs _ => do
+      let curr := xs[0]!
+      for h : i in [1:xs.size] do
+        let xDecl ← xs[i].fvarId!.getDecl
+        if let some arg := s.namedArgs.find? fun arg => arg.name == xDecl.userName then
+          /- Remark: a default value at `optParam` does not count as a dependency -/
+          if (← exprDependsOn xDecl.type.cleanupAnnotations curr.fvarId!) then
+            return arg
+      return none
+
+
+/-- Return `true` if there are regular or named arguments to be processed. -/
+private def hasArgsToProcess : M Bool := do
+  let s ← get
+  return !s.args.isEmpty || !s.namedArgs.isEmpty
+
+/--
+Returns the argument syntax if the next argument at `args` is of the form `_`.
+-/
+private def nextArgHole? : M (Option Syntax) := do
+  match (← get).args with
+  | Arg.stx stx@(Syntax.node _ ``Lean.Parser.Term.hole _) :: _ => pure stx
+  | _ => pure none
+
+/--
+  Return `true` if the next argument to be processed is the outparam of a local instance, and it the result type
+  of the function.
+
+  For example, suppose we have the class
+  ```lean
+  class Get (Cont : Type u) (Idx : Type v) (Elem : outParam (Type w)) where
+    get (xs : Cont) (i : Idx) : Elem
+  ```
+  And the current value of `fType` is
+  ```
+  {Cont : Type u_1} → {Idx : Type u_2} → {Elem : Type u_3} → [self : Get Cont Idx Elem] → Cont → Idx → Elem
+  ```
+  then the result returned by this method is `false` since `Cont` is not the output param of any local instance.
+  Now assume `fType` is
+  ```
+  {Elem : Type u_3} → [self : Get Cont Idx Elem] → Cont → Idx → Elem
+  ```
+  then, the method returns `true` because `Elem` is an output parameter for the local instance `[self : Get Cont Idx Elem]`.
+
+  Remark: if `resultIsOutParamSupport` is `false`, this method returns `false`.
+-/
+private partial def isNextOutParamOfLocalInstanceAndResult : M Bool := do
+  if !(← read).resultIsOutParamSupport then
+    return false
+  let type := (← get).fType.bindingBody!
+  unless isResultType type 0 do
+    return false
+  if (← hasLocalInstaceWithOutParams type) then
+    let x := mkFVar (← mkFreshFVarId)
+    isOutParamOfLocalInstance x (type.instantiate1 x)
+  else
+    return false
+where
+  isResultType (type : Expr) (i : Nat) : Bool :=
+    match type with
+    | .forallE _ _ b _ => isResultType b (i + 1)
+    | .bvar idx        => idx == i
+    | _                => false
+
+  /-- (quick filter) Return true if `type` contains a binder `[C ...]` where `C` is a class containing outparams. -/
+  hasLocalInstaceWithOutParams (type : Expr) : CoreM Bool := do
+    let .forallE _ d b bi := type | return false
+    if bi.isInstImplicit then
+      if let .const declName .. := d.getAppFn then
+        if hasOutParams (← getEnv) declName then
+          return true
+    hasLocalInstaceWithOutParams b
+
+  isOutParamOfLocalInstance (x : Expr) (type : Expr) : MetaM Bool := do
+    let .forallE _ d b bi := type | return false
+    if bi.isInstImplicit then
+      if let .const declName .. := d.getAppFn then
+        if hasOutParams (← getEnv) declName then
+          let cType ← inferType d.getAppFn
+          if (← isOutParamOf x 0 d.getAppArgs cType) then
+            return true
+    isOutParamOfLocalInstance x b
+
+  isOutParamOf (x : Expr) (i : Nat) (args : Array Expr) (cType : Expr) : MetaM Bool := do
+    if h : i < args.size then
+      match (← whnf cType) with
+      | .forallE _ d b _ =>
+        if args[i] == x && d.isOutParam then
+          return true
+        isOutParamOf x (i+1) args b
+      | _ => return false
+    else
+      return false
+
+mutual
+  /--
+  Create a fresh local variable with the current binder name and argument type, add it to `etaArgs` and `f`,
+  and then execute the main loop.
+  -/
+  private partial def addEtaArg (argName : Name) : M Expr := do
+    let n    ← getBindingName
+    let type ← getArgExpectedType
+    withLocalDeclD n type fun x => do
+      modify fun s => { s with etaArgs := s.etaArgs.push x }
+      addNewArg argName x
+      main
+
+  /--
+  Create a fresh metavariable for the implicit argument, add it to `f`, and then execute the main loop.
+  -/
+  private partial def addImplicitArg (argName : Name) : M Expr := do
+    let argType ← getArgExpectedType
+    let arg ← if (← isNextOutParamOfLocalInstanceAndResult) then
+      let arg ← mkFreshExprMVar argType
+      /- When the result type is an output parameter, we don't want to propagate the expected type.
+         So, we just mark `propagateExpected := false` to disable it.
+         At `finalize`, we check whether `arg` is still unassigned, if it is, we apply default instances,
+         and try to synthesize pending mvars. -/
+      modify fun s => { s with resultTypeOutParam? := some arg.mvarId!, propagateExpected := false }
+      pure arg
+    else
+      mkFreshExprMVar argType
+    modify fun s => { s with toSetErrorCtx := s.toSetErrorCtx.push arg.mvarId! }
+    addNewArg argName arg
+    main
+
+  /--
+  Process a `fType` of the form `(x : A) → B x`.
+  This method assume `fType` is a function type.
+  -/
+  private partial def processExplicitArg (argName : Name) : M Expr := do
+    match (← get).args with
+    | arg::args =>
+      -- Note: currently the following test never succeeds in explicit mode since `@x.f` notation does not exist.
+      if let some true := NamedArg.suppressDeps <$> (← findNamedArgDependsOnCurrent?) then
+        /-
+        We treat the explicit argument `argName` as implicit
+        if we have a named arguments that depends on it whose `suppressDeps` flag set to `true`.
+        The motivation for this is class projections (issue #1851).
+        In some cases, class projections can have explicit parameters. For example, in
+        ```
+        class Approx {α : Type} (a : α) (X : Type) : Type where
+          val : X
+        ```
+        the type of `Approx.val` is `{α : Type} → (a : α) → {X : Type} → [self : Approx a X] → X`.
+        Note that the parameter `a` is explicit since there is no way to infer it from the expected
+        type or from the types of other explicit parameters.
+        Being a parameter of the class, `a` is determined by the type of `self`.
+
+        Consider
+        ```
+        variable {α β X Y : Type} {f' : α → β} {x' : α} [f : Approx f' (X → Y)]
+        ```
+        Recall that `f.val` is, to first approximation, sugar for `Approx.val (self := f)`.
+        Without further refinement, this would expand to `fun f'' : α → β => Approx.val f'' f`,
+        which is a type error, since `f''` must be defeq to `f'`.
+        Furthermore, with projection notation, users expect all structure parameters
+        to be uniformly implicit; after all, they are determined by `self`.
+        To handle this, the `(self := f)` named argument is annotated with the `suppressDeps` flag.
+        This causes the `a` parameter to become implicit, and `f.val` instead expands to `Approx.val f' f`.
+
+        This feature previously was enabled for *all* explicit arguments, which confused users
+        and was frequently reported as a bug (issue #1867).
+        Now it is only enabled for the `self` argument in structure projections.
+
+        We used to do this only when `(← get).args` was empty,
+        but it created an asymmetry because `f.val` worked as expected,
+        yet one would have to write `f.val _ x` when there are further arguments.
+        -/
+        return (← addImplicitArg argName)
+      propagateExpectedType arg
+      modify fun s => { s with args }
+      elabAndAddNewArg argName arg
+      main
+    | _ =>
+      if (← read).ellipsis && (← readThe Term.Context).inPattern then
+        /-
+        In patterns, ellipsis should always be an implicit argument, even if it is an optparam or autoparam.
+        This prevents examples such as the one in #4555 from failing:
+        ```lean
+        match e with
+        | .internal .. => sorry
+        | .error .. => sorry
+        ```
+        The `internal` has an optparam (`| internal (id : InternalExceptionId) (extra : KVMap := {})`).
+
+        We may consider having ellipsis suppress optparams and autoparams in general.
+        We avoid doing so for now since it's possible to opt-out of them (for example with `.internal (extra := _) ..`)
+        but it's not possible to opt-in.
+        -/
+        return ← addImplicitArg argName
+      let argType ← getArgExpectedType
+      match (← read).explicit, argType.getOptParamDefault?, argType.getAutoParamTactic? with
+      | false, some defVal, _  => addNewArg argName defVal; main
+      | false, _, some (.const tacticDecl _) =>
+        let env ← getEnv
+        let opts ← getOptions
+        match evalSyntaxConstant env opts tacticDecl with
+        | Except.error err       => throwError err
+        | Except.ok tacticSyntax =>
+          let tacticBlock ← `(by $(⟨tacticSyntax⟩))
+          /-
+          We insert position information from the current ref into `stx` everywhere, simulating this being
+          a tactic script inserted by the user, which ensures error messages and logging will always be attributed
+          to this application rather than sometimes being placed at position (1,0) in the file.
+          Placing position information on `by` syntax alone is not sufficient since incrementality
+          (in particular, `Lean.Elab.Term.withReuseContext`) controls the ref to avoid leakage of outside data.
+          Note that `tacticSyntax` contains no position information itself, since it is erased by `Lean.Elab.Term.quoteAutoTactic`.
+          -/
+          let info := (← getRef).getHeadInfo.nonCanonicalSynthetic
+          let tacticBlock := tacticBlock.raw.rewriteBottomUp (·.setInfo info)
+          let mvar ← mkTacticMVar argType.consumeTypeAnnotations tacticBlock (.autoParam argName)
+          -- Note(kmill): We are adding terminfo to simulate a previous implementation that elaborated `tacticBlock`.
+          -- We should look into removing this since terminfo for synthetic syntax is suspect,
+          -- but we noted it was necessary to preserve the behavior of the unused variable linter.
+          addTermInfo' tacticBlock mvar
+          let argNew := Arg.expr mvar
+          propagateExpectedType argNew
+          elabAndAddNewArg argName argNew
+          main
+      | false, _, some _ =>
+        throwError "invalid autoParam, argument must be a constant"
+      | _, _, _ =>
+        if (← read).ellipsis then
+          addImplicitArg argName
+        else if !(← get).namedArgs.isEmpty then
+          if let some _ ← findNamedArgDependsOnCurrent? then
+            /-
+            Dependencies of named arguments cannot be turned into eta arguments
+            since they are determined by the named arguments.
+            Instead we can turn them into implicit arguments.
+            -/
+            addImplicitArg argName
+          else
+            addEtaArg argName
+        else if !(← read).explicit then
+          if (← fTypeHasOptAutoParams) then
+            addEtaArg argName
+          else
+            finalize
+        else
+          finalize
+
+  /--
+    Process a `fType` of the form `{x : A} → B x`.
+    This method assume `fType` is a function type -/
+  private partial def processImplicitArg (argName : Name) : M Expr := do
+    if (← read).explicit then
+      processExplicitArg argName
+    else
+      addImplicitArg argName
+
+  /--
+    Process a `fType` of the form `{{x : A}} → B x`.
+    This method assume `fType` is a function type -/
+  private partial def processStrictImplicitArg (argName : Name) : M Expr := do
+    if (← read).explicit then
+      processExplicitArg argName
+    else if (← hasArgsToProcess) then
+      addImplicitArg argName
+    else
+      finalize
+
+  /--
+  Process a `fType` of the form `[x : A] → B x`.
+  This method assume `fType` is a function type.
+  -/
+  private partial def processInstImplicitArg (argName : Name) : M Expr := do
+    if (← read).explicit then
+      if let some stx ← nextArgHole? then
+        -- We still use typeclass resolution for `_` arguments.
+        -- This behavior can be suppressed with `(_)`.
+        let ty ← getArgExpectedType
+        let arg ← mkInstMVar ty
+        addTermInfo' stx arg ty
+        modify fun s => { s with args := s.args.tail! }
+        main
+      else
+        processExplicitArg argName
+    else
+      discard <| mkInstMVar (← getArgExpectedType)
+      main
+  where
+    mkInstMVar (ty : Expr) : M Expr := do
+      let arg ← mkFreshExprMVar ty MetavarKind.synthetic
+      addInstMVar arg.mvarId!
+      addNewArg argName arg
+      return arg
+
+  /-- Elaborate function application arguments. -/
+  partial def main : M Expr := do
+    let fType ← normalizeFunType
+    if fType.isForall then
+      let binderName := fType.bindingName!
+      let binfo := fType.bindingInfo!
+      let s ← get
+      match findBinderName? s.namedArgs binderName with
+      | some namedArg =>
+        propagateExpectedType namedArg.val
+        eraseNamedArg binderName
+        elabAndAddNewArg binderName namedArg.val
+        main
+      | none          =>
+        match binfo with
+        | .implicit       => processImplicitArg binderName
+        | .instImplicit   => processInstImplicitArg binderName
+        | .strictImplicit => processStrictImplicitArg binderName
+        | _               => processExplicitArg binderName
+    else if (← hasArgsToProcess) then
+      synthesizePendingAndNormalizeFunType
+      main
+    else
+      finalize
+
+end
+
+end ElabAppArgs
+
+
+/-! # Eliminator-like function application elaborator -/
+
+/--
+Information about an eliminator used by the elab-as-elim elaborator.
+This is not to be confused with `Lean.Meta.ElimInfo`, which is for `induction` and `cases`.
+The elab-as-elim routine is less restrictive in what counts as an eliminator, and it doesn't need
+to have a strict notion of what is a "target" — all it cares about are
+1. that the return type of a function is of the form `m ...` where `m` is a parameter
+   (unlike `induction` and `cases` eliminators, the arguments to `m`, known as "discriminants",
+   can be any expressions, not just parameters), and
+2. which arguments should be eagerly elaborated, to make discriminants be as elaborated as
+   possible for the expected type generalization procedure,
+   and which should be postponed (since they are the "minor premises").
+
+Note that the routine isn't doing induction/cases *on* particular expressions.
+The purpose of elab-as-elim is to successfully solve the higher-order unification problem
+between the return type of the function and the expected type.
+-/
+structure ElabElimInfo where
+  /-- The eliminator. -/
+  elimExpr   : Expr
+  /-- The type of the eliminator. -/
+  elimType   : Expr
+  /-- The position of the motive parameter. -/
+  motivePos  : Nat
+  /--
+  Positions of "major" parameters (those that should be eagerly elaborated
+  because they can contribute to the motive inference procedure).
+  All parameters that are neither the motive nor a major parameter are "minor" parameters.
+  The major parameters include all of the parameters that transitively appear in the motive's arguments,
+  as well as "first-order" arguments that include such parameters,
+  since they too can help with elaborating discriminants.
+
+  For example, in the following theorem the argument `h : a = b`
+  should be elaborated eagerly because it contains `b`, which occurs in `motive b`.
+  ```
+  theorem Eq.subst' {α} {motive : α → Prop} {a b : α} (h : a = b) : motive a → motive b
+  ```
+  For another example, the term `isEmptyElim (α := α)` is an underapplied eliminator, and it needs
+  argument `α` to be elaborated eagerly to create a type-correct motive.
+  ```
+  def isEmptyElim [IsEmpty α] {p : α → Sort _} (a : α) : p a := ...
+  example {α : Type _} [IsEmpty α] : id (α → False) := isEmptyElim (α := α)
+  ```
+  -/
+  majorsPos : Array Nat := #[]
+  deriving Repr, Inhabited
+
+def getElabElimExprInfo (elimExpr : Expr) : MetaM ElabElimInfo := do
+  let elimType ← inferType elimExpr
+  trace[Elab.app.elab_as_elim] "eliminator {indentExpr elimExpr}\nhas type{indentExpr elimType}"
+  forallTelescopeReducing elimType fun xs type => do
+    let motive  := type.getAppFn
+    let motiveArgs := type.getAppArgs
+    unless motive.isFVar && motiveArgs.size > 0 do
+      throwError "unexpected eliminator resulting type{indentExpr type}"
+    let motiveType ← inferType motive
+    forallTelescopeReducing motiveType fun motiveParams motiveResultType => do
+      unless motiveParams.size == motiveArgs.size do
+        throwError "unexpected number of arguments at motive type{indentExpr motiveType}"
+      unless motiveResultType.isSort do
+        throwError "motive result type must be a sort{indentExpr motiveType}"
+    let some motivePos := xs.idxOf? motive |
+      throwError "unexpected eliminator type{indentExpr elimType}"
+    /-
+    Compute transitive closure of fvars appearing in arguments to the motive.
+    These are the primary set of major parameters.
+    -/
+    let initMotiveFVars : CollectFVars.State := motiveArgs.foldl (init := {}) collectFVars
+    let motiveFVars ← xs.size.foldRevM (init := initMotiveFVars) fun i _ s => do
+      let x := xs[i]
+      if s.fvarSet.contains x.fvarId! then
+        return collectFVars s (← inferType x)
+      else
+        return s
+    /- Collect the major parameter positions -/
+    let mut majorsPos := #[]
+    for h : i in [:xs.size] do
+      let x := xs[i]
+      unless motivePos == i do
+        let xType ← x.fvarId!.getType
+        /-
+        We also consider "first-order" types because we can reliably "extract" information from them.
+        We say a term is "first-order" if all applications are of the form `f ...` where `f` is a constant.
+        -/
+        let isFirstOrder (e : Expr) : Bool := Option.isNone <| e.find? fun e => e.isApp && !e.getAppFn.isConst
+        if motiveFVars.fvarSet.contains x.fvarId!
+            || (isFirstOrder xType
+                && Option.isSome (xType.find? fun e => e.isFVar && motiveFVars.fvarSet.contains e.fvarId!)) then
+          majorsPos := majorsPos.push i
+    trace[Elab.app.elab_as_elim] "motivePos: {motivePos}"
+    trace[Elab.app.elab_as_elim] "majorsPos: {majorsPos}"
+    return { elimExpr, elimType, motivePos, majorsPos }
+
+def getElabElimInfo (elimName : Name) : MetaM ElabElimInfo := do
+  getElabElimExprInfo (← mkConstWithFreshMVarLevels elimName)
+
+
+/--
+Instructs the elaborator that applications of this function should be elaborated like an eliminator.
+
+An eliminator is a function that returns an application of a "motive" which is a parameter of the
+form `_ → ... → Sort _`, i.e. a function that takes in a certain amount of arguments (referred to
+as major premises) and returns a type in some universe. The `rec` and `casesOn` functions of
+inductive types are automatically treated as eliminators, for other functions this attribute needs
+to be used.
+
+Eliminator elaboration can be compared to the `induction` tactic: The expected type is used as the
+return value of the motive, with occurrences of the major premises replaced with the arguments.
+When more arguments are specified than necessary, the remaining arguments are reverted into the
+expected type.
+
+Examples:
+```lean example
+@[elab_as_elim]
+def evenOddRecOn {motive : Nat → Sort u}
+    (even : ∀ n, motive (n * 2)) (odd : ∀ n, motive (n * 2 + 1))
+    (n : Nat) : motive n := ...
+
+-- simple usage
+example (a : Nat) : (a * a) % 2 = a % 2 :=
+  evenOddRec _ _ a
+  /-
+  1. basic motive is `fun n => (a + 2) % 2 = a % 2`
+  2. major premise `a` substituted: `fun n => (n + 2) % 2 = n % 2`
+  3. now elaborate the other parameters as usual:
+    "even" (first hole): expected type `∀ n, ((n * 2) * (n * 2)) % 2 = (n * 2) % 2`,
+    "odd" (second hole): expected type `∀ n, ((n * 2 + 1) * (n * 2 + 1)) % 2 = (n * 2 + 1) % 2`
+  -/
+
+-- complex substitution
+example (a : Nat) (f : Nat → Nat) : (f a + 1) % 2 ≠ f a :=
+  evenOddRec _ _ (f a)
+  /-
+  Similar to before, except `f a` is substituted: `motive := fun n => (n + 1) % 2 ≠ n`.
+  Now the first hole has expected type `∀ n, (n * 2 + 1) % 2 ≠ n * 2`.
+  Now the second hole has expected type `∀ n, (n * 2 + 1 + 1) % 2 ≠ n * 2 + 1`.
+  -/
+
+-- more parameters
+example (a : Nat) (h : a % 2 = 1) : (a + 1) % 2 = 0 :=
+  evenOddRec _ _ a h
+  /-
+  Before substitution, `a % 2 = 1` is reverted: `motive := fun n => a % 2 = 0 → (a + 1) % 2 = 0`.
+  Substitution: `motive := fun n => n % 2 = 1 → (n + 1) % 2 = 0`
+  Now the first hole has expected type `∀ n, n * 2 % 2 = 1 → (n * 2) % 2 = 0`.
+  Now the second hole has expected type `∀ n, (n * 2 + 1) % 2 = 1 → (n * 2 + 1) % 2 = 0`.
+  -/
+```
+
+See also `@[induction_eliminator]` and `@[cases_eliminator]` for registering default eliminators.
+-/
+@[builtin_doc]
+builtin_initialize elabAsElim : TagAttribute ←
+  registerTagAttribute `elab_as_elim
+    "instructs elaborator that the arguments of the function application should be elaborated as were an eliminator"
+    /-
+    We apply `elab_as_elim` after compilation because this kind of attribute is not applied to auxiliary declarations
+    created by the `WF` and `Structural` modules. This is an "indirect" fix for issue #1900. We should consider
+    having an explicit flag in attributes to indicate whether they should be copied to auxiliary declarations or not.
+    -/
+    (applicationTime := .afterCompilation)
+    fun declName => do
+      let go : MetaM Unit := do
+        let info ← getConstInfo declName
+        if (← hasOptAutoParams info.type) then
+          throwError "[elab_as_elim] attribute cannot be used in declarations containing optional and auto parameters"
+        discard <| getElabElimInfo declName
+      go.run' {} {}
+
+namespace ElabElim
+
+/-- Context of the `elab_as_elim` elaboration procedure. -/
+structure Context where
+  elimInfo : ElabElimInfo
+  expectedType : Expr
+
+/-- State of the `elab_as_elim` elaboration procedure. -/
+structure State where
+  /-- The resultant expression being built. -/
+  f            : Expr
+  /-- `f : fType -/
+  fType        : Expr
+  /-- User-provided named arguments that still have to be processed. -/
+  namedArgs    : List NamedArg
+  /-- User-provided arguments that still have to be processed. -/
+  args         : List Arg
+  /-- Instance implicit arguments collected so far. -/
+  instMVars    : Array MVarId := #[]
+  /-- Position of the next argument to be processed. We use it to decide whether the argument is the motive or a discriminant. -/
+  idx          : Nat := 0
+  /-- Store the metavariable used to represent the motive that will be computed at `finalize`. -/
+  motive?      : Option Expr := none
+
+abbrev M := ReaderT Context $ StateRefT State TermElabM
+
+/-- Infer the `motive` using the expected type by `kabstract`ing the discriminants. -/
+def mkMotive (discrs : Array Expr) (expectedType : Expr) : MetaM Expr := do
+  discrs.foldrM (init := expectedType) fun discr motive => do
+    let discr ← instantiateMVars discr
+    let motiveBody ← kabstract motive discr
+    /- We use `transform (usedLetOnly := true)` to eliminate unnecessary let-expressions. -/
+    let discrType ← transform (usedLetOnly := true) (← instantiateMVars (← inferType discr))
+    return Lean.mkLambda (← mkFreshBinderName) BinderInfo.default discrType motiveBody
+
+/--
+If the eliminator is over-applied, we "revert" the extra arguments.
+Returns the function with the reverted arguments applied and the new generalized expected type.
+-/
+def revertArgs (args : List Arg) (f : Expr) (expectedType : Expr) : TermElabM (Expr × Expr) := do
+  let (xs, expectedType) ← args.foldrM (init := ([], expectedType)) fun arg (xs, expectedType) => do
+    let val ←
+      match arg with
+      | .expr val => pure val
+      | .stx stx => elabTerm stx none
+    let val ← instantiateMVars val
+    let expectedTypeBody ← kabstract expectedType val
+    /- We use `transform (usedLetOnly := true)` to eliminate unnecessary let-expressions. -/
+    let valType ← transform (usedLetOnly := true) (← instantiateMVars (← inferType val))
+    return (val :: xs, mkForall (← mkFreshBinderName) BinderInfo.default valType expectedTypeBody)
+  return (xs.foldl .app f, expectedType)
+
+/--
+Construct the resulting application after all discriminants have been elaborated, and we have
+consumed as many given arguments as possible.
+-/
+def finalize : M Expr := do
+  unless (← get).namedArgs.isEmpty do
+    throwError "failed to elaborate eliminator, unused named arguments: {(← get).namedArgs.map (·.name)}"
+  let some motive := (← get).motive?
+    | throwError "failed to elaborate eliminator, insufficient number of arguments"
+  trace[Elab.app.elab_as_elim] "motive: {motive}"
+  forallTelescope (← get).fType fun xs fType => do
+    trace[Elab.app.elab_as_elim] "xs: {xs}"
+    let mut expectedType := (← read).expectedType
+    trace[Elab.app.elab_as_elim] "expectedType:{indentD expectedType}"
+    let throwInsufficient := do
+      throwError "failed to elaborate eliminator, insufficient number of arguments, expected type:{indentExpr expectedType}"
+    let mut f := (← get).f
+    if xs.size > 0 then
+      -- under-application, specialize the expected type using `xs`
+      -- Note: if we ever wanted to support optParams and autoParams, this is where it could be.
+      assert! (← get).args.isEmpty
+      for x in xs do
+        let .forallE _ t b _ ← whnf expectedType | throwInsufficient
+        unless ← fullApproxDefEq <| isDefEq t (← inferType x) do
+          -- We can't assume that these binding domains were supposed to line up, so report insufficient arguments
+          throwInsufficient
+        expectedType := b.instantiate1 x
+      trace[Elab.app.elab_as_elim] "xs after specialization of expected type: {xs}"
+    else
+      -- over-application, simulate `revert` while generalizing the values of these arguments in the expected type
+      (f, expectedType) ← revertArgs (← get).args f expectedType
+      unless ← isTypeCorrect expectedType do
+        throwError "failed to elaborate eliminator, after generalizing over-applied arguments, expected type is type incorrect:{indentExpr expectedType}"
+    trace[Elab.app.elab_as_elim] "expectedType after processing:{indentD expectedType}"
+    let result := mkAppN f xs
+    trace[Elab.app.elab_as_elim] "result:{indentD result}"
+    unless fType.getAppFn == (← get).motive? do
+      throwError "Internal error, eliminator target type isn't an application of the motive"
+    let discrs := fType.getAppArgs
+    trace[Elab.app.elab_as_elim] "discrs: {discrs}"
+    let motiveVal ← mkMotive discrs expectedType
+    unless (← isTypeCorrect motiveVal) do
+      throwError "failed to elaborate eliminator, motive is not type correct:{indentD motiveVal}"
+    unless (← isDefEq motive motiveVal) do
+      throwError "failed to elaborate eliminator, invalid motive{indentExpr motiveVal}"
+    synthesizeAppInstMVars (← get).instMVars result
+    trace[Elab.app.elab_as_elim] "completed motive:{indentD motive}"
+    let result ← mkLambdaFVars xs (← instantiateMVars result)
+    return result
+
+/--
+Return the next argument to be processed.
+The result is `.none` if it is an implicit argument which was not provided using a named argument.
+The result is `.undef` if `args` is empty and `namedArgs` does contain an entry for `binderName`.
+-/
+def getNextArg? (binderName : Name) (binderInfo : BinderInfo) : M (LOption Arg) := do
+  match findBinderName? (← get).namedArgs binderName with
+  | some namedArg =>
+    modify fun s => { s with namedArgs := eraseNamedArg s.namedArgs binderName }
+    return .some namedArg.val
+  | none =>
+    if binderInfo.isExplicit then
+      match (← get).args with
+      | [] => return .undef
+      | arg :: args =>
+        modify fun s => { s with args }
+        return .some arg
+    else
+      return .none
+
+/-- Set the `motive` field in the state. -/
+def setMotive (motive : Expr) : M Unit :=
+  modify fun s => { s with motive? := motive }
+
+/-- Elaborate the given argument with the given expected type. -/
+private def elabArg (arg : Arg) (argExpectedType : Expr) : M Expr := do
+  match arg with
+  | Arg.expr val => ensureArgType (← get).f val argExpectedType
+  | Arg.stx stx  =>
+    let val ← elabTerm stx argExpectedType
+    withRef stx <| ensureArgType (← get).f val argExpectedType
+
+/-- Save information for producing error messages. -/
+def saveArgInfo (arg : Expr) (binderName : Name) : M Unit := do
+  if arg.isMVar then
+    registerMVarArgName arg.mvarId! binderName
+
+/-- Create an implicit argument using the given `BinderInfo`. -/
+def mkImplicitArg (argExpectedType : Expr) (bi : BinderInfo) : M Expr := do
+  let arg ← mkFreshExprMVar argExpectedType (if bi.isInstImplicit then .synthetic else .natural)
+  if bi.isInstImplicit then
+    modify fun s => { s with instMVars := s.instMVars.push arg.mvarId! }
+  return arg
+
+/-- Main loop of the `elimAsElab` procedure. -/
+partial def main : M Expr := do
+  let .forallE binderName binderType body binderInfo ← whnfForall (← get).fType |
+    finalize
+  let addArgAndContinue (arg : Expr) : M Expr := do
+    modify fun s => { s with idx := s.idx + 1, f := mkApp s.f arg, fType := body.instantiate1 arg }
+    saveArgInfo arg binderName
+    main
+  let idx := (← get).idx
+  if (← read).elimInfo.motivePos == idx then
+    let motive ←
+      match (← getNextArg? binderName binderInfo) with
+      | .some arg =>
+        /- Due to `Lean.Elab.Term.elabAppArgs.elabAsElim?`, this must be a positional argument that is the syntax `_`. -/
+        elabArg arg binderType
+      | .none | .undef =>
+        /- Note: undef occurs when the motive is explicit but missing.
+           In this case, we treat it as if it were an implicit argument
+           to support writing `h.rec` when `h : False`, rather than requiring `h.rec _`. -/
+        mkImplicitArg binderType binderInfo
+    setMotive motive
+    addArgAndContinue motive
+  else if (← read).elimInfo.majorsPos.contains idx then
+    match (← getNextArg? binderName binderInfo) with
+    | .some arg => let discr ← elabArg arg binderType; addArgAndContinue discr
+    | .undef => finalize
+    | .none => let discr ← mkImplicitArg binderType binderInfo; addArgAndContinue discr
+  else match (← getNextArg? binderName binderInfo) with
+    | .some (.stx stx) => addArgAndContinue (← postponeElabTerm stx binderType)
+    | .some (.expr val) => addArgAndContinue (← ensureArgType (← get).f val binderType)
+    | .undef => finalize
+    | .none => addArgAndContinue (← mkImplicitArg binderType binderInfo)
+
+end ElabElim
+
+/-- Return `true` if `declName` is a candidate for `ElabElim.main` elaboration. -/
+private def shouldElabAsElim (declName : Name) : CoreM Bool := do
+  if (← isRec declName) then return true
+  let env ← getEnv
+  if isCasesOnRecursor env declName then return true
+  if isBRecOnRecursor env declName then return true
+  if isRecOnRecursor env declName then return true
+  return elabAsElim.hasTag env declName
+
+private def propagateExpectedTypeFor (f : Expr) : TermElabM Bool :=
+  match f.getAppFn.constName? with
+  | some declName => return !hasElabWithoutExpectedType (← getEnv) declName
+  | _ => return true
+
+/-! # Function application elaboration -/
+
+/--
+Elaborate a `f`-application using `namedArgs` and `args` as the arguments.
+- `expectedType?` the expected type if available. It is used to propagate typing information only. This method does **not** ensure the result has this type.
+- `explicit = true` when notation `@` is used, and implicit arguments are assumed to be provided at `namedArgs` and `args`.
+- `ellipsis = true` when notation `..` is used. That is, we add `_` for missing arguments.
+- `resultIsOutParamSupport` is used to control whether special support is used when processing applications of functions that return
+   output parameter of some local instance. Example:
+   ```
+   GetElem.getElem : {Cont : Type u_1} → {Idx : Type u_2} → {elem : Type u_3} → {dom : cont → idx → Prop} → [self : GetElem cont idx elem dom] → (xs : cont) → (i : idx) → dom xs i → elem
+   ```
+   The result type `elem` is the output parameter of the local instance `self`.
+   When this parameter is set to `true`, we execute `synthesizeSyntheticMVarsUsingDefault`. For additional details, see comment at
+   `ElabAppArgs.resultIsOutParam`.
+-/
+def elabAppArgs (f : Expr) (namedArgs : Array NamedArg) (args : Array Arg)
+    (expectedType? : Option Expr) (explicit ellipsis : Bool) (resultIsOutParamSupport := true) : TermElabM Expr := do
+  -- Coercions must be available to use this flag.
+  -- If `@` is used (i.e., `explicit = true`), we disable `resultIsOutParamSupport`.
+  let resultIsOutParamSupport := ((← getEnv).contains ``Lean.Internal.coeM) && resultIsOutParamSupport && !explicit
+  let fType ← inferType f
+  let fType ← instantiateMVars fType
+  unless namedArgs.isEmpty && args.isEmpty do
+    tryPostponeIfMVar fType
+  trace[Elab.app.args] "explicit: {explicit}, ellipsis: {ellipsis}, {f} : {fType}"
+  trace[Elab.app.args] "namedArgs: {namedArgs}"
+  trace[Elab.app.args] "args: {args}"
+  if let some elimInfo ← elabAsElim? then
+    tryPostponeIfNoneOrMVar expectedType?
+    let some expectedType := expectedType? | throwError "failed to elaborate eliminator, expected type is not available"
+    let expectedType ← instantiateMVars expectedType
+    if expectedType.getAppFn.isMVar then throwError "failed to elaborate eliminator, expected type is not available"
+    ElabElim.main.run { elimInfo, expectedType } |>.run' {
+      f, fType
+      args := args.toList
+      namedArgs := namedArgs.toList
+    }
+  else
+    ElabAppArgs.main.run { explicit, ellipsis, resultIsOutParamSupport } |>.run' {
+      args := args.toList
+      expectedType?, f, fType
+      namedArgs := namedArgs.toList
+      propagateExpected := (← propagateExpectedTypeFor f)
+    }
+where
+  /-- Return `some info` if we should elaborate as an eliminator. -/
+  elabAsElim? : TermElabM (Option ElabElimInfo) := do
+    unless (← read).heedElabAsElim do return none
+    if explicit || ellipsis then return none
+    let .const declName _ := f | return none
+    unless (← shouldElabAsElim declName) do return none
+    let elimInfo ← getElabElimInfo declName
+    forallTelescopeReducing (← inferType f) fun xs _ => do
+      /- Process arguments similar to `Lean.Elab.Term.ElabElim.main` to see if the motive has been
+         provided, in which case we use the standard app elaborator.
+         If the motive is explicit (like for `False.rec`), then a positional `_` counts as "not provided". -/
+      let mut args := args.toList
+      let mut namedArgs := namedArgs.toList
+      for x in xs[*...elimInfo.motivePos] do
+        let localDecl ← x.fvarId!.getDecl
+        match findBinderName? namedArgs localDecl.userName with
+        | some _ => namedArgs := eraseNamedArg namedArgs localDecl.userName
+        | none   => if localDecl.binderInfo.isExplicit then args := args.tailD []
+      -- Invariant: `elimInfo.motivePos < xs.size` due to construction of `elimInfo`.
+      let some x := xs[elimInfo.motivePos]? | unreachable!
+      let localDecl ← x.fvarId!.getDecl
+      if findBinderName? namedArgs localDecl.userName matches some _ then
+        -- motive has been explicitly provided, so we should use standard app elaborator
+        return none
+      else
+        match localDecl.binderInfo.isExplicit, args with
+        | true, .expr _ :: _  =>
+          -- motive has been explicitly provided, so we should use standard app elaborator
+          return none
+        | true, .stx arg :: _ =>
+          if arg.isOfKind ``Lean.Parser.Term.hole then
+            return some elimInfo
+          else
+            -- positional motive is not `_`, so we should use standard app elaborator
+            return none
+        | _, _ => return some elimInfo
+
+
+/-- Auxiliary inductive datatype that represents the resolution of an `LVal`. -/
+inductive LValResolution where
+  /-- When applied to `f`, effectively expands to `BaseStruct.fieldName (self := Struct.toBase f)`.
+  This is a special named argument where it suppresses any explicit arguments depending on it so that type parameters don't need to be supplied. -/
+  | projFn   (baseStructName : Name) (structName : Name) (fieldName : Name)
+  /-- Similar to `projFn`, but for extracting field indexed by `idx`. Works for structure-like inductive types in general. -/
+  | projIdx  (structName : Name) (idx : Nat)
+  /-- When applied to `f`, effectively expands to `constName ... (Struct.toBase f)`, with the argument placed in the correct
+  positional argument if possible, or otherwise as a named argument. The `Struct.toBase` is not present if `baseStructName == structName`,
+  in which case these do not need to be structures. Supports generalized field notation. -/
+  | const    (baseStructName : Name) (structName : Name) (constName : Name)
+  /-- Like `const`, but with `fvar` instead of `constName`.
+  The `fullName` is the name of the recursive function, and `baseName` is the base name of the type to search for in the parameter list. -/
+  | localRec (baseName : Name) (fullName : Name) (fvar : Expr)
+
+private def throwLValErrorAt (ref : Syntax) (e : Expr) (eType : Expr) (msg : MessageData) : TermElabM α :=
+  throwErrorAt ref "{msg}{indentExpr e}\nhas type{indentExpr eType}"
+
+private def throwLValError (e : Expr) (eType : Expr) (msg : MessageData) : TermElabM α := do
+  throwLValErrorAt (← getRef) e eType msg
+
+/--
+`findMethod? S fName` tries the for each namespace `S'` in the resolution order for `S` to resolve the name `S'.fname`.
+If it resolves to `name`, returns `(S', name)`.
+-/
+private partial def findMethod? (structName fieldName : Name) : MetaM (Option (Name × Name)) := do
+  let env ← getEnv
+  let find? structName' : MetaM (Option (Name × Name)) := do
+    let fullName := structName' ++ fieldName
+    -- We do not want to make use of the current namespace for resolution.
+    let candidates := ResolveName.resolveGlobalName (← getEnv) Name.anonymous (← getOpenDecls) fullName
+      |>.filter (fun (_, fieldList) => fieldList.isEmpty)
+      |>.map Prod.fst
+    match candidates with
+    | []          => return none
+    | [fullName'] => return some (structName', fullName')
+    | _ =>
+      let candidates := MessageData.joinSep (candidates.map (m!"`{.ofConstName ·}`")) ", "
+      throwError "Field name `{fieldName}` is ambiguous: `{fullName}` has possible interpretations {candidates}"
+  -- Optimization: the first element of the resolution order is `structName`,
+  -- so we can skip computing the resolution order in the common case
+  -- of the name resolving in the `structName` namespace.
+  find? structName <||> do
+    let resolutionOrder ← if isStructure env structName then getStructureResolutionOrder structName else pure #[structName]
+    for ns in resolutionOrder[1...resolutionOrder.size] do
+      if let some res ← find? ns then
+        return res
+    return none
+
+private def throwInvalidFieldNotation (e eType : Expr) : TermElabM α :=
+  throwLValError e eType "Invalid field notation: Type is not of the form `C ...` where C is a constant"
+
+private def resolveLValAux (e : Expr) (eType : Expr) (lval : LVal) : TermElabM LValResolution := do
+  if eType.isForall then
+    match lval with
+    | LVal.fieldName _ fieldName suffix? fullRef =>
+      let fullName := Name.str `Function fieldName
+      if (← getEnv).contains fullName then
+        return LValResolution.const `Function `Function fullName
+      else if suffix?.isNone then
+        /- If there's no suffix, this could only have been a field in the `Function` namespace, so
+           we needn't wait to check if this is actually a constant. If `suffix?` is non-`none`, we
+           prefer to throw the "unknown constant" error (because of monad namespaces like `IO` and
+           auxiliary declarations like `mutual_induct`) -/
+        throwLValErrorAt fullRef e eType <| mkUnknownIdentifierMessage m!"Invalid field `{fieldName}`: \
+          The environment does not contain `{Name.str `Function fieldName}`"
+    | .fieldIdx .. =>
+      throwLValError e eType "Invalid projection: Projections cannot be used on functions"
+  else if eType.getAppFn.isMVar then
+    let (kind, name) :=
+      match lval with
+      |  .fieldName _ fieldName _ _ => (m!"field notation", m!"field `{fieldName}`")
+      | .fieldIdx _ i => (m!"projection", m!"projection `{i}`")
+    throwError "Invalid {kind}: Type of{indentExpr e}\nis not known; cannot resolve {name}"
+  match eType.getAppFn.constName?, lval with
+  | some structName, LVal.fieldIdx _ idx =>
+    if idx == 0 then
+      throwError "Invalid projection: Index must be greater than 0"
+    let env ← getEnv
+    let failK _ := throwLValError e eType "Invalid projection: Expected a value whose type is a structure"
+    matchConstStructure eType.getAppFn failK fun _ _ ctorVal => do
+      let numFields := ctorVal.numFields
+      if idx - 1 < numFields then
+        if isStructure env structName then
+          let fieldNames := getStructureFields env structName
+          return LValResolution.projFn structName structName fieldNames[idx - 1]!
+        else
+          /- `structName` was declared using `inductive` command.
+            So, we don't projection functions for it. Thus, we use `Expr.proj` -/
+          return LValResolution.projIdx structName (idx - 1)
+      else
+        let (fields, bounds) := if numFields == 1 then
+          (m!"field", m!"the only valid index is 1")
+        else
+          (m!"fields", m!"it must be between 1 and {numFields}")
+        throwError m!"Invalid projection: Index `{idx}` is invalid for this structure; {bounds}"
+          ++ .note m!"The expression{inlineExpr e}has type{inlineExpr eType}which has only {numFields} {fields}"
+  | some structName, LVal.fieldName _ fieldName _ fullRef =>
+    let env ← getEnv
+    if isStructure env structName then
+      if let some baseStructName := findField? env structName (Name.mkSimple fieldName) then
+        return LValResolution.projFn baseStructName structName (Name.mkSimple fieldName)
+    -- Search the local context first
+    let fullName := Name.mkStr structName fieldName
+    for localDecl in (← getLCtx) do
+      if localDecl.isAuxDecl then
+        if let some localDeclFullName := (← getLCtx).auxDeclToFullName.find? localDecl.fvarId then
+          if fullName == (privateToUserName? localDeclFullName).getD localDeclFullName then
+            /- LVal notation is being used to make a "local" recursive call. -/
+            return LValResolution.localRec structName fullName localDecl.toExpr
+    -- Then search the environment
+    if let some (baseStructName, fullName) ← findMethod? structName (.mkSimple fieldName) then
+      return LValResolution.const baseStructName structName fullName
+    let msg := mkUnknownIdentifierMessage m!"Invalid field `{fieldName}`: The environment does not contain `{Name.mkStr structName fieldName}`"
+    throwLValErrorAt fullRef e eType msg
+  | none, LVal.fieldName _ _ (some suffix) fullRef =>
+    -- This may be a function constant whose implicit arguments have already been filled in:
+    let c := e.getAppFn
+    if c.isConst then
+      throwUnknownConstantAt fullRef (c.constName! ++ suffix)
+    else
+      throwInvalidFieldNotation e eType
+  | _, _ => throwInvalidFieldNotation e eType
+
+/-- whnfCore + implicit consumption.
+   Example: given `e` with `eType := {α : Type} → (fun β => List β) α `, it produces `(e ?m, List ?m)` where `?m` is fresh metavariable. -/
+private partial def consumeImplicits (stx : Syntax) (e eType : Expr) (hasArgs : Bool) : TermElabM (Expr × Expr) := do
+  let eType ← whnfCore eType
+  match eType with
+  | .forallE _ d b bi =>
+    if bi.isImplicit || (hasArgs && bi.isStrictImplicit) then
+      let mvar ← mkFreshExprMVar d
+      registerMVarErrorHoleInfo mvar.mvarId! stx
+      consumeImplicits stx (mkApp e mvar) (b.instantiate1 mvar) hasArgs
+    else if bi.isInstImplicit then
+      let mvar ← mkInstMVar d
+      let r := mkApp e mvar
+      registerMVarErrorImplicitArgInfo mvar.mvarId! stx r
+      consumeImplicits stx r (b.instantiate1 mvar) hasArgs
+    else match d.getOptParamDefault? with
+      | some defVal => consumeImplicits stx (mkApp e defVal) (b.instantiate1 defVal) hasArgs
+      -- TODO: we do not handle autoParams here.
+      | _ => return (e, eType)
+  | _ => return (e, eType)
+
+private partial def resolveLValLoop (lval : LVal) (e eType : Expr) (previousExceptions : Array Exception) (hasArgs : Bool) : TermElabM (Expr × LValResolution) := do
+  let (e, eType) ← consumeImplicits lval.getRef e eType hasArgs
+  tryPostponeIfMVar eType
+  /- If `eType` is still a metavariable application, we try to apply default instances to "unblock" it. -/
+  if (← isMVarApp eType) then
+    synthesizeSyntheticMVarsUsingDefault
+  let eType ← instantiateMVars eType
+  try
+    let lvalRes ← resolveLValAux e eType lval
+    return (e, lvalRes)
+  catch
+    | ex@(Exception.error _ _) =>
+      let eType? ← unfoldDefinition? eType
+      match eType? with
+      | some eType => resolveLValLoop lval e eType (previousExceptions.push ex) hasArgs
+      | none       =>
+        previousExceptions.forM fun ex => logException ex
+        throw ex
+    | ex@(Exception.internal _ _) => throw ex
+
+private def resolveLVal (e : Expr) (lval : LVal) (hasArgs : Bool) : TermElabM (Expr × LValResolution) := do
+  let eType ← inferType e
+  resolveLValLoop lval e eType #[] hasArgs
+
+private partial def mkBaseProjections (baseStructName : Name) (structName : Name) (e : Expr) : TermElabM Expr := do
+  let env ← getEnv
+  match getPathToBaseStructure? env baseStructName structName with
+  | none => throwError "Internal error: Failed to access field in parent structure"
+  | some path =>
+    let mut e := e
+    for projFunName in path do
+      let projFn ← mkConst projFunName
+      e ← elabAppArgs projFn #[{ name := `self, val := Arg.expr e, suppressDeps := true }] (args := #[]) (expectedType? := none) (explicit := false) (ellipsis := false)
+    return e
+
+private partial def typeMatchesBaseName (type : Expr) (baseName : Name) : MetaM Bool :=
+  withReducibleAndInstances do
+    if baseName == `Function then
+      return (← whnf type).isForall
+    else if type.cleanupAnnotations.isAppOf baseName then
+      return true
+    else
+      let type ← whnfCore type
+      if type.isAppOf baseName then
+        return true
+      else
+        match ← unfoldDefinition? type with
+        | some type' => typeMatchesBaseName type' baseName
+        | none => return false
+
+/--
+Auxiliary method for field notation. Tries to add `e` as a new argument to `args` or `namedArgs`.
+This method first finds the parameter with a type of the form `(baseName ...)`.
+When the parameter is found, if it an explicit one and `args` is big enough, we add `e` to `args`.
+Otherwise, if there isn't another parameter with the same name, we add `e` to `namedArgs`.
+
+Remark: `fullName` is the name of the resolved "field" access function. It is used for reporting errors
+-/
+private partial def addLValArg (baseName : Name) (fullName : Name) (e : Expr) (args : Array Arg) (namedArgs : Array NamedArg) (f : Expr) (explicit : Bool) :
+    MetaM (Array Arg × Array NamedArg) := do
+  withoutModifyingState <| go f (← inferType f) 0 namedArgs (namedArgs.map (·.name)) true
+where
+  /--
+  * `argIdx` is the position into `args` for the next place an explicit argument can be inserted.
+  * `remainingNamedArgs` keeps track of named arguments that haven't been visited yet,
+    for handling the case where multiple parameters have the same name.
+  * `unusableNamedArgs` keeps track of names that can't be used as named arguments. This is initialized with user-provided named arguments.
+  * `allowNamed` is whether or not to allow using named arguments.
+    Disabled after using `CoeFun` since those parameter names unlikely to be meaningful,
+    and otherwise whether dot notation works or not could feel random.
+  -/
+  go (f fType : Expr) (argIdx : Nat) (remainingNamedArgs : Array NamedArg) (unusableNamedArgs : Array Name) (allowNamed : Bool) := withIncRecDepth do
+    /- Use metavariables (rather than `forallTelescope`) to prevent `coerceToFunction?` from succeeding when multiple instances could apply -/
+    let (xs, bInfos, fType') ← forallMetaTelescope fType
+    let mut argIdx := argIdx
+    let mut remainingNamedArgs := remainingNamedArgs
+    let mut unusableNamedArgs := unusableNamedArgs
+    for x in xs, bInfo in bInfos do
+      let xDecl ← x.mvarId!.getDecl
+      if let some idx := remainingNamedArgs.findFinIdx? (·.name == xDecl.userName) then
+        /- If there is named argument with name `xDecl.userName`, then it is accounted for and we can't make use of it. -/
+        remainingNamedArgs := remainingNamedArgs.eraseIdx idx
+      else
+        if ← typeMatchesBaseName xDecl.type baseName then
+          /- We found a type of the form (baseName ...), or we found the first explicit argument in useFirstExplicit mode.
+             First, we check if the current argument is one that can be used positionally,
+             and if the current explicit position "fits" at `args` (i.e., it must be ≤ arg.size) -/
+          if h : argIdx ≤ args.size ∧ (explicit || bInfo.isExplicit) then
+            /- We can insert `e` as an explicit argument -/
+            return (args.insertIdx argIdx (Arg.expr e), namedArgs)
+          else
+            /- If we can't add `e` to `args`, we try to add it using a named argument, but this is only possible
+               if there isn't an argument with the same name occurring before it. -/
+            if !allowNamed || unusableNamedArgs.contains xDecl.userName then
+              throwUnusableParameter allowNamed xDecl
+            else
+              return (args, namedArgs.push { name := xDecl.userName, val := Arg.expr e })
+        /- Advance `argIdx` and update seen named arguments. -/
+        if explicit || bInfo.isExplicit then
+          argIdx := argIdx + 1
+        unusableNamedArgs := unusableNamedArgs.push xDecl.userName
+    /- If named arguments aren't allowed, then it must still be possible to pass the value as an explicit argument.
+       Otherwise, we can abort now. -/
+    if allowNamed || argIdx ≤ args.size then
+      if let fType'@(.forallE ..) ← whnf fType' then
+        return ← go (mkAppN f xs) fType' argIdx remainingNamedArgs unusableNamedArgs allowNamed
+      if let some f' ← coerceToFunction? (mkAppN f xs) then
+        return ← go f' (← inferType f') argIdx remainingNamedArgs unusableNamedArgs false
+    let tyCtorMsg := MessageData.ofLazyM do
+      let some decl := (← getEnv).find? baseName | return .ofConstName baseName
+      if decl.type.isForall then
+        return m!"{.ofConstName baseName} ..."
+      else
+        return .ofConstName baseName
+    throwError m!"Invalid field notation: Function `{.ofConstName fullName}` does not have a usable \
+      parameter of type `{tyCtorMsg}` for which to substitute{inlineExprTrailing e}"
+      ++ .note m!"Such a parameter must be explicit, or implicit with a unique name, to be used by field notation"
+
+  throwUnusableParameter (allowNamed : Bool) (xDecl : MetavarDecl) :=
+    let note : MessageData := if !allowNamed && !xDecl.userName.hasMacroScopes then
+      .note m!"Field notation cannot refer to parameter `{xDecl.userName}` of `{.ofConstName fullName}` \
+        by name because that constant was coerced to a function"
+    else if allowNamed then
+      let param := if xDecl.userName.hasMacroScopes then .nil else m!" `{xDecl.userName}`"
+      .note m!"The parameter{param} of `{.ofConstName fullName}` cannot be referred to by name \
+         because that function has a preceding parameter of the same name"
+    else .nil
+    -- Transforming field notation into direct application is too involved to offer a confident
+    -- concrete edit suggestion here
+    let hint := MessageData.hint' <|
+      m!"Consider rewriting this application without field notation (e.g., `C.f x` instead of `x.f`)" ++
+      if allowNamed then
+        m!" or changing the parameter names of `{.ofConstName fullName}` to avoid this conflict"
+      else .nil
+    throwError m!"Invalid field notation: `{.ofConstName fullName}` has a parameter with \
+      expected type{indentExpr xDecl.type}\nbut it cannot be used" ++ note ++ hint
+
+/-- Adds the `TermInfo` for the field of a projection. See `Lean.Parser.Term.identProjKind`. -/
+private def addProjTermInfo
+    (stx            : Syntax)
+    (e              : Expr)
+    (expectedType?  : Option Expr := none)
+    (lctx?          : Option LocalContext := none)
+    (elaborator     : Name := Name.anonymous)
+    (isBinder force : Bool := false)
+    : TermElabM Expr :=
+  addTermInfo (Syntax.node .none Parser.Term.identProjKind #[stx]) e expectedType? lctx? elaborator isBinder force
+
+private def elabAppLValsAux (namedArgs : Array NamedArg) (args : Array Arg) (expectedType? : Option Expr) (explicit ellipsis : Bool)
+    (f : Expr) (lvals : List LVal) : TermElabM Expr :=
+  let rec loop : Expr → List LVal → TermElabM Expr
+  | f, []          => elabAppArgs f namedArgs args expectedType? explicit ellipsis
+  | f, lval::lvals => do
+    if let LVal.fieldName (ref := ref) .. := lval then
+      addDotCompletionInfo ref f expectedType?
+    let hasArgs := !namedArgs.isEmpty || !args.isEmpty
+    let (f, lvalRes) ← resolveLVal f lval hasArgs
+    match lvalRes with
+    | LValResolution.projIdx structName idx =>
+      let f ← mkProjAndCheck structName idx f
+      let f ← addTermInfo lval.getRef f
+      loop f lvals
+    | LValResolution.projFn baseStructName structName fieldName =>
+      let f ← mkBaseProjections baseStructName structName f
+      let some info := getFieldInfo? (← getEnv) baseStructName fieldName | unreachable!
+      if isPrivateNameFromImportedModule (← getEnv) info.projFn then
+        throwError "Field `{fieldName}` from structure `{structName}` is private"
+      let projFn ← mkConst info.projFn
+      let projFn ← addProjTermInfo lval.getRef projFn
+      if lvals.isEmpty then
+        let namedArgs ← addNamedArg namedArgs { name := `self, val := Arg.expr f, suppressDeps := true }
+        elabAppArgs projFn namedArgs args expectedType? explicit ellipsis
+      else
+        let f ← elabAppArgs projFn #[{ name := `self, val := Arg.expr f, suppressDeps := true }] #[] (expectedType? := none) (explicit := false) (ellipsis := false)
+        loop f lvals
+    | LValResolution.const baseStructName structName constName =>
+      let f ← if baseStructName != structName then mkBaseProjections baseStructName structName f else pure f
+      let projFn ← mkConst constName
+      let projFn ← addProjTermInfo lval.getRef projFn
+      if lvals.isEmpty then
+        let (args, namedArgs) ← addLValArg baseStructName constName f args namedArgs projFn explicit
+        elabAppArgs projFn namedArgs args expectedType? explicit ellipsis
+      else
+        let (args, namedArgs) ← addLValArg baseStructName constName f #[] #[] projFn (explicit := false)
+        let f ← elabAppArgs projFn namedArgs args (expectedType? := none) (explicit := false) (ellipsis := false)
+        loop f lvals
+    | LValResolution.localRec baseName fullName fvar =>
+      let fvar ← addProjTermInfo lval.getRef fvar
+      if lvals.isEmpty then
+        let (args, namedArgs) ← addLValArg baseName fullName f args namedArgs fvar explicit
+        elabAppArgs fvar namedArgs args expectedType? explicit ellipsis
+      else
+        let (args, namedArgs) ← addLValArg baseName fullName f #[] #[] fvar (explicit := false)
+        let f ← elabAppArgs fvar namedArgs args (expectedType? := none) (explicit := false) (ellipsis := false)
+        loop f lvals
+  loop f lvals
+
+private def elabAppLVals (f : Expr) (lvals : List LVal) (namedArgs : Array NamedArg) (args : Array Arg)
+    (expectedType? : Option Expr) (explicit ellipsis : Bool) : TermElabM Expr := do
+  elabAppLValsAux namedArgs args expectedType? explicit ellipsis f lvals
+
+def elabExplicitUnivs (lvls : Array Syntax) : TermElabM (List Level) := do
+  lvls.foldrM (init := []) fun stx lvls => return (← elabLevel stx)::lvls
+
+/-!
+# Interaction between `errToSorry` and `observing`.
+
+- The method `elabTerm` catches exceptions, logs them, and returns a synthetic sorry (IF `ctx.errToSorry` == true).
+
+- When we elaborate choice nodes (and overloaded identifiers), we track multiple results using the `observing x` combinator.
+  The `observing x` executes `x` and returns a `TermElabResult`.
+
+`observing x` does not check for synthetic sorry's, just an exception. Thus, it may think `x` worked when it didn't
+if a synthetic sorry was introduced. We decided that checking for synthetic sorrys at `observing` is not a good solution
+because it would not be clear to decide what the "main" error message for the alternative is. When the result contains
+a synthetic `sorry`, it is not clear which error message corresponds to the `sorry`. Moreover, while executing `x`, many
+error messages may have been logged. Recall that we need an error per alternative at `mergeFailures`.
+
+Thus, we decided to set `errToSorry` to `false` whenever processing choice nodes and overloaded symbols.
+
+Important: we rely on the property that after `errToSorry` is set to
+false, no elaboration function executed by `x` will reset it to
+`true`.
+-/
+
+private partial def elabAppFnId (fIdent : Syntax) (fExplicitUnivs : List Level) (lvals : List LVal)
+    (namedArgs : Array NamedArg) (args : Array Arg) (expectedType? : Option Expr) (explicit ellipsis overloaded : Bool) (acc : Array (TermElabResult Expr))
+    : TermElabM (Array (TermElabResult Expr)) := do
+  let funLVals ← withRef fIdent <| resolveName' fIdent fExplicitUnivs expectedType?
+  let overloaded := overloaded || funLVals.length > 1
+  -- Set `errToSorry` to `false` if `funLVals` > 1. See comment above about the interaction between `errToSorry` and `observing`.
+  withReader (fun ctx => { ctx with errToSorry := funLVals.length == 1 && ctx.errToSorry }) do
+    funLVals.foldlM (init := acc) fun acc (f, fIdent, fields) => do
+      let lvals' := toLVals fields (first := true)
+      let s ← observing do
+        checkDeprecated fIdent f
+        let f ← addTermInfo fIdent f expectedType?
+        let e ← elabAppLVals f (lvals' ++ lvals) namedArgs args expectedType? explicit ellipsis
+        if overloaded then ensureHasType expectedType? e else return e
+      return acc.push s
+where
+  toName (fields : List Syntax) : Name :=
+    let rec go
+      | []              => .anonymous
+      | field :: fields => .mkStr (go fields) field.getId.toString
+    go fields.reverse
+
+  toLVals : List Syntax → (first : Bool) → List LVal
+    | [],            _     => []
+    | field::fields, true  => .fieldName field field.getId.getString! (toName (field::fields)) fIdent :: toLVals fields false
+    | field::fields, false => .fieldName field field.getId.getString! none fIdent :: toLVals fields false
+
+/-- Resolve `(.$id:ident)` using the expected type to infer namespace. -/
+private partial def resolveDotName (id : Syntax) (expectedType? : Option Expr) : TermElabM Expr := do
+  tryPostponeIfNoneOrMVar expectedType?
+  let some expectedType := expectedType?
+    | throwError "Invalid dotted identifier notation: Could not determine the expected type of `.{id}`"
+  withForallBody expectedType fun resultType => do
+    go resultType expectedType #[]
+where
+  /-- A weak version of forallTelescopeReducing that only uses whnfCore, to avoid unfolding definitions except by `unfoldDefinition?` below. -/
+  withForallBody {α} (type : Expr) (k : Expr → TermElabM α) : TermElabM α :=
+    forallTelescope type fun _ body => do
+      let body ← whnfCore body
+      if body.isForall then
+        withForallBody body k
+      else
+        k body
+  go (resultType : Expr) (expectedType : Expr) (previousExceptions : Array Exception) : TermElabM Expr := do
+    let resultType ← instantiateMVars resultType
+    let resultTypeFn := resultType.cleanupAnnotations.getAppFn
+    try
+      tryPostponeIfMVar resultTypeFn
+      match resultTypeFn.cleanupAnnotations with
+      | .const declName .. =>
+        let idNew := declName ++ id.getId.eraseMacroScopes
+        if (← getEnv).contains idNew then
+          mkConst idNew
+        else if let some (fvar, []) ← resolveLocalName idNew then
+          return fvar
+        else
+          throwUnknownIdentifierAt id <| m!"Unknown identifier `{idNew}`"
+            ++ .note m!"Inferred this identifier from the expected type of `.{id}`:{indentExpr expectedType}"
+      | .sort .. =>
+        throwNamedError lean.invalidDottedIdent "Invalid dotted identifier notation: Not supported on type universe{indentExpr resultTypeFn}"
+      | _ =>
+        if expectedType.getAppFn.isMVar then
+          throwNamedError lean.invalidDottedIdent "Invalid dotted identifier notation: The expected type of `.{id}` could not be determined"
+        else
+          throwNamedError lean.invalidDottedIdent "Invalid dotted identifier notation: The expected type of `.{id}`{indentExpr expectedType}\n\
+            is not of the form `C ...` or `... → C ...` where C is a constant"
+    catch
+      | ex@(.error ..) =>
+        match (← unfoldDefinition? resultType) with
+        | some resultType =>
+          withForallBody resultType fun resultType => do
+            go resultType expectedType (previousExceptions.push ex)
+        | none =>
+          previousExceptions.forM fun ex => logException ex
+          throw ex
+      | ex@(.internal _ _) => throw ex
+
+private partial def elabAppFn (f : Syntax) (lvals : List LVal) (namedArgs : Array NamedArg) (args : Array Arg)
+    (expectedType? : Option Expr) (explicit ellipsis overloaded : Bool) (acc : Array (TermElabResult Expr)) : TermElabM (Array (TermElabResult Expr)) := do
+  if f.getKind == choiceKind then
+    -- Set `errToSorry` to `false` when processing choice nodes. See comment above about the interaction between `errToSorry` and `observing`.
+    withReader (fun ctx => { ctx with errToSorry := false }) do
+      f.getArgs.foldlM (init := acc) fun acc f => elabAppFn f lvals namedArgs args expectedType? explicit ellipsis true acc
+  else
+    let elabFieldName (e field : Syntax) (explicit : Bool) := do
+      let newLVals := field.identComponents.map fun comp =>
+        -- We use `none` in `suffix?` since `field` can't be part of a composite name
+        LVal.fieldName comp comp.getId.getString! none f
+      elabAppFn e (newLVals ++ lvals) namedArgs args expectedType? explicit ellipsis overloaded acc
+    let elabFieldIdx (e idxStx : Syntax) (explicit : Bool) := do
+      let some idx := idxStx.isFieldIdx?
+        | throwError "Internal error: Unexpected field index syntax `{idxStx}`"
+      elabAppFn e (LVal.fieldIdx idxStx idx :: lvals) namedArgs args expectedType? explicit ellipsis overloaded acc
+    match f with
+    | `($(e).$idx:fieldIdx) => elabFieldIdx e idx explicit
+    | `($e |>.$idx:fieldIdx) => elabFieldIdx e idx explicit
+    | `($(e).$field:ident) => elabFieldName e field explicit
+    | `($e |>.$field:ident) => elabFieldName e field explicit
+    | `(@$(e).$idx:fieldIdx) => elabFieldIdx e idx (explicit := true)
+    | `(@$(e).$field:ident) => elabFieldName e field (explicit := true)
+    | `($_:ident@$_:term) =>
+      throwError m!"Expected a function, but found the named pattern{indentD f}"
+        ++ .note m!"Named patterns `<identifier>@<term>` can only be used when pattern-matching"
+    | `($id:ident) => do
+      elabAppFnId id [] lvals namedArgs args expectedType? explicit ellipsis overloaded acc
+    | `($id:ident.{$us,*}) => do
+      let us ← elabExplicitUnivs us
+      elabAppFnId id us lvals namedArgs args expectedType? explicit ellipsis overloaded acc
+    | `(@$id:ident) =>
+      elabAppFn id lvals namedArgs args expectedType? (explicit := true) ellipsis overloaded acc
+    | `(@$_:ident.{$_us,*}) =>
+      elabAppFn (f.getArg 1) lvals namedArgs args expectedType? (explicit := true) ellipsis overloaded acc
+    | `(@$_)     => throwUnsupportedSyntax -- invalid occurrence of `@`
+    | `(_)       => throwError "A placeholder `_` cannot be used where a function is expected"
+    | `(.$id:ident) =>
+        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
+          let fConst ← addTermInfo f fConst expectedType? (force := true)
+          let e ← elabAppLVals fConst lvals namedArgs args expectedType? explicit ellipsis
+          if overloaded then ensureHasType expectedType? e else return e
+        return acc.push s
+    | _ => do
+      let catchPostpone := !overloaded
+      /- If we are processing a choice node, then we should use `catchPostpone == false` when elaborating terms.
+        Recall that `observing` does not catch `postponeExceptionId`. -/
+      if lvals.isEmpty && namedArgs.isEmpty && args.isEmpty then
+        /- Recall that elabAppFn is used for elaborating atomics terms **and** choice nodes that may contain
+          arbitrary terms. If they are not being used as a function, we should elaborate using the expectedType. -/
+        let s ← observing do
+          if overloaded then
+            elabTermEnsuringType f expectedType? catchPostpone
+          else
+            elabTerm f expectedType?
+        return acc.push s
+      else
+        let s ← observing do
+          let f ← elabTerm f none catchPostpone
+          let e ← elabAppLVals f lvals namedArgs args expectedType? explicit ellipsis
+          if overloaded then ensureHasType expectedType? e else return e
+        return acc.push s
+
+/-- Return the successful candidates. Recall we have Syntax `choice` nodes and overloaded symbols when we open multiple namespaces. -/
+private def getSuccesses (candidates : Array (TermElabResult Expr)) : TermElabM (Array (TermElabResult Expr)) := do
+  let r₁ := candidates.filter fun | EStateM.Result.ok .. => true | _ => false
+  if r₁.size ≤ 1 then return r₁
+  let r₂ ← candidates.filterM fun
+    | .ok e s => do
+      if e.isMVar then
+        /- Make sure `e` is not a delayed coercion.
+           Recall that coercion insertion may be delayed when the type and expected type contains
+           metavariables that block TC resolution.
+           When processing overloaded notation, we disallow delayed coercions at `e`. -/
+        try
+          s.restore
+          synthesizeSyntheticMVars -- Tries to process pending coercions (and elaboration tasks)
+          let e ← instantiateMVars e
+          if e.isMVar then
+          /- If `e` is still a metavariable, and its `SyntheticMVarDecl` is a coercion, we discard this solution -/
+            if let some synDecl ← getSyntheticMVarDecl? e.mvarId! then
+              if synDecl.kind matches SyntheticMVarKind.coe .. then
+                return false
+        catch _ =>
+          -- If `synthesizeSyntheticMVars` failed, we just eliminate the candidate.
+          return false
+      return true
+    | _ => return false
+  if r₂.size == 0 then
+    return r₁
+  if r₂.size == 1 then
+    return r₂
+  /-
+  If there are still more than one solution, discard solutions that have pending metavariables.
+  We added this extra filter to address regressions introduced after fixing
+  `isDefEqStuckEx` behavior at `ExprDefEq.lean`.
+  -/
+  let r₂ ← candidates.filterM fun
+    | .ok _ s => do
+      try
+        s.restore
+        synthesizeSyntheticMVars (postpone := .no)
+        return true
+      catch _ =>
+        return false
+    | _ => return false
+  if r₂.size == 0 then
+    return r₁
+  return r₂
+/--
+  Throw an error message that describes why each possible interpretation for the overloaded notation and symbols did not work.
+  We use a nested error message to aggregate the exceptions produced by each failure.
+-/
+private def mergeFailures (failures : Array (TermElabResult Expr)) : TermElabM α := do
+  let exs := failures.map fun | .error ex _ => ex | _ => unreachable!
+  let trees := failures.map (fun | .error _ s => s.meta.core.infoState.trees | _ => unreachable!)
+    |>.filterMap (·[0]?)
+  -- Retain partial `InfoTree` subtrees in an `.ofChoiceInfo` node in case of multiple failures.
+  -- This ensures that the language server still has `Info` to work with when multiple overloaded
+  -- elaborators fail.
+  withInfoContext (mkInfo := pure <| .ofChoiceInfo { elaborator := .anonymous, stx := ← getRef }) do
+    for tree in trees do
+      pushInfoTree tree
+  throwErrorWithNestedErrors "overloaded" exs
+
+private def elabAppAux (f : Syntax) (namedArgs : Array NamedArg) (args : Array Arg) (ellipsis : Bool) (expectedType? : Option Expr) : TermElabM Expr := do
+  let candidates ← elabAppFn f [] namedArgs args expectedType? (explicit := false) (ellipsis := ellipsis) (overloaded := false) #[]
+  if h : candidates.size = 1 then
+    have : 0 < candidates.size := by rw [h]; decide
+    applyResult candidates[0]
+  else
+    let successes ← getSuccesses candidates
+    if h : successes.size = 1 then
+      have : 0 < successes.size := by rw [h]; decide
+      applyResult successes[0]
+    else if successes.size > 1 then
+      let msgs : Array MessageData ← successes.mapM fun success => do
+        match success with
+        | .ok e s => withMCtx s.meta.meta.mctx <| withEnv s.meta.core.env do addMessageContext m!"{e} : {← inferType e}"
+        | _       => unreachable!
+      throwErrorAt f "Ambiguous term{indentD f}\nPossible interpretations:{toMessageList msgs}"
+    else
+      withRef f <| mergeFailures candidates
+
+/--
+  We annotate recursive applications with their `Syntax` node to make sure we can produce error messages with
+  correct position information at `WF` and `Structural`.
+-/
+-- TODO: It is overkill to store the whole `Syntax` object, and we have to make sure we erase it later.
+-- We should store only the position information in the future.
+-- Recall that we will need to have a compact way of storing position information in the future anyway, if we
+-- want to support debugging information
+private def annotateIfRec (stx : Syntax) (e : Expr) : TermElabM Expr := do
+  if (← read).saveRecAppSyntax then
+    let resultFn := e.getAppFn
+    if resultFn.isFVar then
+      let localDecl ← resultFn.fvarId!.getDecl
+      if localDecl.isAuxDecl then
+        return mkRecAppWithSyntax e stx
+  return e
+
+@[builtin_term_elab app] def elabApp : TermElab := fun stx expectedType? =>
+  universeConstraintsCheckpoint do
+    let (f, namedArgs, args, ellipsis) ← expandApp stx
+    annotateIfRec stx (← elabAppAux f namedArgs args (ellipsis := ellipsis) expectedType?)
+
+private def elabAtom : TermElab := fun stx expectedType? => do
+  annotateIfRec stx (← elabAppAux stx #[] #[] (ellipsis := false) expectedType?)
+
+@[builtin_term_elab ident] def elabIdent : TermElab := elabAtom
+@[builtin_term_elab namedPattern] def elabNamedPattern : TermElab := elabAtom
+@[builtin_term_elab dotIdent] def elabDotIdent : TermElab := elabAtom
+@[builtin_term_elab explicitUniv] def elabExplicitUniv : TermElab := elabAtom
+@[builtin_term_elab pipeProj] def elabPipeProj : TermElab
+  | `($e |>.%$tk$f $args*), expectedType? =>
+    universeConstraintsCheckpoint do
+      let (namedArgs, args, ellipsis) ← expandArgs args
+      let mut stx ← `($e |>.%$tk$f)
+      if let (some startPos, some stopPos) := (e.raw.getPos?, f.raw.getTailPos?) then
+        stx := ⟨stx.raw.setInfo <| .synthetic (canonical := true) startPos stopPos⟩
+      elabAppAux stx namedArgs args (ellipsis := ellipsis) expectedType?
+  | _, _ => throwUnsupportedSyntax
+
+@[builtin_term_elab explicit] def elabExplicit : TermElab := fun stx expectedType? =>
+  match stx with
+  | `(@$_:ident)          => elabAtom stx expectedType?  -- Recall that `elabApp` also has support for `@`
+  | `(@$_:ident.{$_us,*}) => elabAtom stx expectedType?
+  | `(@$(_).$_:fieldIdx)  => elabAtom stx expectedType?
+  | `(@$(_).$_:ident)     => elabAtom stx expectedType?
+  | `(@($t))             => elabTerm t expectedType? (implicitLambda := false)    -- `@` is being used just to disable implicit lambdas
+  | `(@$t)               => elabTerm t expectedType? (implicitLambda := false)   -- `@` is being used just to disable implicit lambdas
+  | _                    => throwUnsupportedSyntax
+
+@[builtin_term_elab choice] def elabChoice : TermElab := elabAtom
+@[builtin_term_elab proj] def elabProj : TermElab := elabAtom
+
+builtin_initialize
+  registerTraceClass `Elab.app
+  registerTraceClass `Elab.app.args (inherited := true)
+  registerTraceClass `Elab.app.propagateExpectedType (inherited := true)
+  registerTraceClass `Elab.app.finalize (inherited := true)
+  registerTraceClass `Elab.app.elab_as_elim (inherited := true)
+
+end Lean.Elab.Term

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/Arg.lean

@@ -0,0 +1,68 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.Elab.Term
+
+namespace Lean.Elab.Term
+
+/--
+Auxiliary inductive datatype for combining unelaborated syntax
+and already elaborated expressions. It is used to elaborate applications.
+-/
+inductive Arg where
+  | stx  (val : Syntax)
+  | expr (val : Expr)
+  deriving Inhabited
+
+/-- Named arguments created using the notation `(x := val)`. -/
+structure NamedArg where
+  ref  : Syntax := Syntax.missing
+  name : Name
+  val  : Arg
+  /-- If `true`, then make all parameters that depend on this one become implicit.
+  This is used for projection notation, since structure parameters might be explicit for classes. -/
+  suppressDeps : Bool := false
+  deriving Inhabited
+
+instance : ToMessageData Arg where
+  toMessageData
+  | .stx stx => toMessageData stx
+  | .expr e  => toMessageData e
+
+/--
+  Add a new named argument to `namedArgs`, and throw an error if it already contains a named argument
+  with the same name. -/
+def addNamedArg (namedArgs : Array NamedArg) (namedArg : NamedArg) : MetaM (Array NamedArg) := do
+  if namedArgs.any (namedArg.name == ·.name) then
+    throwError "argument '{namedArg.name}' was already set"
+  return namedArgs.push namedArg
+
+partial def expandArgs (args : Array Syntax) : MetaM (Array NamedArg × Array Arg × Bool) := do
+  let (args, ellipsis) :=
+    if args.isEmpty then
+      (args, false)
+    else if args.back!.isOfKind ``Lean.Parser.Term.ellipsis then
+      (args.pop, true)
+    else
+      (args, false)
+  let (namedArgs, args) ← args.foldlM (init := (#[], #[])) fun (namedArgs, args) stx => do
+    if stx.getKind == ``Lean.Parser.Term.namedArgument then
+      -- trailing_tparser try ("(" >> ident >> " := ") >> termParser >> ")"
+      let name := stx[1].getId.eraseMacroScopes
+      let val  := stx[3]
+      let namedArgs ← addNamedArg namedArgs { ref := stx, name := name, val := Arg.stx val }
+      return (namedArgs, args)
+    else if stx.getKind == ``Lean.Parser.Term.ellipsis then
+      throwErrorAt stx "unexpected '..'"
+    else
+      return (namedArgs, args.push $ Arg.stx stx)
+  return (namedArgs, args, ellipsis)
+
+def expandApp (stx : Syntax) : MetaM (Syntax × Array NamedArg × Array Arg × Bool) := do
+  let (namedArgs, args, ellipsis) ← expandArgs stx[1].getArgs
+  return (stx[0], namedArgs, args, ellipsis)
+
+end Lean.Elab.Term

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/Attributes.lean

@@ -0,0 +1,71 @@
+/-
+Copyright (c) 2020 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura, Sebastian Ullrich
+-/
+prelude
+import Lean.Elab.Util
+namespace Lean.Elab
+
+structure Attribute where
+  kind  : AttributeKind := AttributeKind.global
+  name  : Name
+  stx   : Syntax := Syntax.missing
+  deriving Inhabited
+
+instance : ToFormat Attribute where
+  format attr :=
+   let kindStr := match attr.kind with
+     | AttributeKind.global => ""
+     | AttributeKind.local  => "local "
+     | AttributeKind.scoped => "scoped "
+   Format.bracket "@[" f!"{kindStr}{attr.name}{toString attr.stx}" "]"
+
+/--
+  ```
+  attrKind := leading_parser optional («scoped» <|> «local»)
+  ```
+-/
+def toAttributeKind (attrKindStx : Syntax) : MacroM AttributeKind := do
+  if attrKindStx[0].isNone then
+    return AttributeKind.global
+  else if attrKindStx[0][0].getKind == ``Lean.Parser.Term.scoped then
+    if (← Macro.getCurrNamespace).isAnonymous then
+      throw <| Macro.Exception.error (← getRef) "scoped attributes must be used inside namespaces"
+    return AttributeKind.scoped
+  else
+    return AttributeKind.local
+
+def mkAttrKindGlobal : Syntax :=
+  mkNode ``Lean.Parser.Term.attrKind #[mkNullNode]
+
+def elabAttr [Monad m] [MonadEnv m] [MonadResolveName m] [MonadError m] [MonadMacroAdapter m] [MonadRecDepth m] [MonadTrace m] [MonadOptions m] [AddMessageContext m] [MonadLiftT IO m] (attrInstance : Syntax) : m Attribute := do
+  /- attrInstance     := ppGroup $ leading_parser attrKind >> attrParser -/
+  let attrKind ← liftMacroM <| toAttributeKind attrInstance[0]
+  let attr := attrInstance[1]
+  let attr ← liftMacroM <| expandMacros attr
+  let attrName ← if attr.getKind == ``Parser.Attr.simple then
+    pure attr[0].getId.eraseMacroScopes
+  else match attr.getKind with
+    | .str _ s => pure <| Name.mkSimple s
+    | _ => throwErrorAt attr  "unknown attribute"
+  let .ok _impl := getAttributeImpl (← getEnv) attrName
+    | throwError "unknown attribute [{attrName}]"
+  /- The `AttrM` does not have sufficient information for expanding macros in `args`.
+     So, we expand them before here before we invoke the attributer handlers implemented using `AttrM`. -/
+  return { kind := attrKind, name := attrName, stx := attr }
+
+def elabAttrs [Monad m] [MonadEnv m] [MonadResolveName m] [MonadError m] [MonadMacroAdapter m] [MonadRecDepth m] [MonadTrace m] [MonadOptions m] [AddMessageContext m] [MonadLog m] [MonadLiftT IO m] (attrInstances : Array Syntax) : m (Array Attribute) := do
+  let mut attrs := #[]
+  for attr in attrInstances do
+    try
+      attrs := attrs.push (← withRef attr do elabAttr attr)
+    catch ex =>
+      logException ex
+  return attrs
+
+-- leading_parser "@[" >> sepBy1 attrInstance ", " >> "]"
+def elabDeclAttrs [Monad m] [MonadEnv m] [MonadResolveName m] [MonadError m] [MonadMacroAdapter m] [MonadRecDepth m] [MonadTrace m] [MonadOptions m] [AddMessageContext m] [MonadLog m] [MonadLiftT IO m] (stx : Syntax) : m (Array Attribute) :=
+  elabAttrs stx[1].getSepArgs
+
+end Lean.Elab

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/AutoBound.lean

@@ -0,0 +1,51 @@
+/-
+Copyright (c) 2020 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.Data.Options
+
+/-! # Basic support for auto bound implicit local names -/
+
+namespace Lean.Elab
+
+register_builtin_option autoImplicit : Bool := {
+    defValue := true
+    descr    := "Unbound local variables in declaration headers become implicit arguments. In \"relaxed\" mode (default), any atomic identifier is eligible, otherwise only single character followed by numeric digits are eligible. For example, `def f (x : Vector α n) : Vector α n :=` automatically introduces the implicit variables {α n}."
+  }
+
+register_builtin_option relaxedAutoImplicit : Bool := {
+    defValue := true
+    descr    := "When \"relaxed\" mode is enabled, any atomic nonempty identifier is eligible for auto bound implicit locals (see option `autoImplicit`)."
+  }
+
+
+private def isValidAutoBoundSuffix (s : String) : Bool :=
+  s.toSubstring.drop 1 |>.all fun c => c.isDigit || isSubScriptAlnum c || c == '_' || c == '\''
+
+/-!
+Remark: Issue #255 exposed a nasty interaction between macro scopes and auto-bound-implicit names.
+```
+local notation "A" => id x
+theorem test : A = A := sorry
+```
+We used to use `n.eraseMacroScopes` at `isValidAutoBoundImplicitName` and `isValidAutoBoundLevelName`.
+Thus, in the example above, when `A` is expanded, a `x` with a fresh macro scope is created.
+`x`+macros-scope is not in scope and is a valid auto-bound implicit name after macro scopes are erased.
+So, an auto-bound exception would be thrown, and `x`+macro-scope would be added as a new implicit.
+When, we try again, a `x` with a new macro scope is created and this process keeps repeating.
+Therefore, we do consider identifier with macro scopes anymore.
+-/
+
+def isValidAutoBoundImplicitName (n : Name) (relaxed : Bool) : Bool :=
+  match n with
+  | .str .anonymous s => s.length > 0 && (relaxed || isValidAutoBoundSuffix s)
+  | _ => false
+
+def isValidAutoBoundLevelName (n : Name) (relaxed : Bool) : Bool :=
+  match n with
+  | .str .anonymous s => s.length > 0 && (relaxed || (s.front.isLower && isValidAutoBoundSuffix s))
+  | _ => false
+
+end Lean.Elab

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/AuxDef.lean

@@ -0,0 +1,36 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Gabriel Ebner
+-/
+prelude
+import Lean.Elab.Command
+
+namespace Lean.Elab.Command
+open Lean.Parser.Command
+open Lean.Parser.Term
+
+/--
+Declares an auxiliary definition with an automatically generated name.
+For example, `aux_def foo : Nat := 42` creates a definition
+with an internal, unused name based on the suggestion `foo`.
+-/
+scoped syntax (name := aux_def) docComment ? attributes ? "aux_def" ident+ ":" term ":=" term : command
+
+@[builtin_command_elab «aux_def»]
+def elabAuxDef : CommandElab
+  | `($[$doc?:docComment]? $[$attrs?:attributes]? aux_def $suggestion* : $ty := $body) => do
+    let id := suggestion.map (·.getId.eraseMacroScopes) |>.foldl (· ++ ·) Name.anonymous
+    let id := `_aux ++ (← getMainModule) ++ `_ ++ id
+    let id := String.intercalate "_" <| id.components.map (·.toString (escape := false))
+    let ns ← getCurrNamespace
+    -- We use a new generator here because we want more control over the name; the default would
+    -- create a private name that then breaks the macro below. We assume that `aux_def` is not used
+    -- with the same arguments in parallel contexts.
+    let env := (← getEnv).setExporting true
+    let (id, _) := { namePrefix := ns : DeclNameGenerator }.mkUniqueName env («infix» := Name.mkSimple id)
+    let id := id.replacePrefix ns Name.anonymous -- TODO: replace with def _root_.id
+    elabCommand <|
+      ← `($[$doc?:docComment]? $[$attrs?:attributes]?
+          meta def $(mkIdentFrom (mkNullNode suggestion) id (canonical := true)):ident : $ty := $body)
+  | _ => throwUnsupportedSyntax

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/BinderPredicates.lean

@@ -0,0 +1,43 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Gabriel Ebner
+-/
+prelude
+import Init.BinderPredicates
+import Lean.Parser.Syntax
+import Lean.Elab.MacroArgUtil
+import Lean.Linter.MissingDocs
+
+namespace Lean.Elab.Command
+
+@[builtin_command_elab binderPredicate] def elabBinderPred : CommandElab := fun stx => do
+  match stx with
+  | `($[$doc?:docComment]? $[@[$attrs?,*]]? $attrKind:attrKind binder_predicate%$tk
+      $[(name := $name?)]? $[(priority := $prio?)]? $x $args:macroArg* => $rhs) => do
+    let prio ← liftMacroM do evalOptPrio prio?
+    let (stxParts, patArgs) := (← args.mapM expandMacroArg).unzip
+    let name ← match name? with
+      | some name => pure name.getId
+      | none => liftMacroM do mkNameFromParserSyntax `binderTerm (mkNullNode stxParts)
+    let nameTk := name?.getD (mkIdentFrom tk name)
+    /- The command `syntax [<kind>] ...` adds the current namespace to the syntax node kind.
+    So, we must include current namespace when we create a pattern for the following
+    `macro_rules` commands. -/
+    let pat : TSyntax `binderPred := ⟨(mkNode ((← getCurrNamespace) ++ name) patArgs).1⟩
+    elabCommand <|<-
+    `($[$doc?:docComment]? $[@[$attrs?,*]]? $attrKind:attrKind syntax%$tk
+        (name := $nameTk) (priority := $(quote prio)) $[$stxParts]* : binderPred
+      $[$doc?:docComment]? macro_rules%$tk
+        | `(satisfies_binder_pred% $$($x):term $pat:binderPred) => $rhs)
+  | _ => throwUnsupportedSyntax
+
+open Linter.MissingDocs Parser Term in
+/-- Missing docs handler for `binder_predicate` -/
+@[builtin_missing_docs_handler Lean.Parser.Command.binderPredicate]
+def checkBinderPredicate : SimpleHandler := fun stx => do
+  if stx[0].isNone && stx[2][0][0].getKind != ``«local» then
+    if stx[4].isNone then lint stx[3] "binder predicate"
+    else lintNamed stx[4][0][3] "binder predicate"
+
+end Lean.Elab.Command

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/Binders.lean

@@ -0,0 +1,957 @@
+/-
+Copyright (c) 2019 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.Elab.Quotation.Precheck
+import Lean.Elab.Term
+import Lean.Elab.BindersUtil
+import Lean.Elab.SyntheticMVars
+import Lean.Elab.PreDefinition.TerminationHint
+import Lean.Elab.Match
+import Lean.Compiler.MetaAttr
+
+namespace Lean.Elab.Term
+open Meta
+open Lean.Parser.Term
+open TSyntax.Compat
+
+/--
+  Given syntax of the forms
+    a) (`:` term)?
+    b) `:` term
+  return `term` if it is present, or a hole if not. -/
+private def expandBinderType (ref : Syntax) (stx : Syntax) : Syntax :=
+  if stx.getNumArgs == 0 then
+    mkHole ref
+  else
+    stx[1]
+
+/-- Given syntax of the form `ident <|> hole`, return `ident`. If `hole`, then we create a new anonymous name. -/
+private def expandBinderIdent (stx : Syntax) : TermElabM Syntax :=
+  match stx with
+  | `(_) => mkFreshIdent stx (canonical := true)
+  | _    => pure stx
+
+/-- Given syntax of the form `(ident >> " : ")?`, return `ident`, or a new instance name. -/
+private def expandOptIdent (stx : Syntax) : TermElabM Syntax := do
+  if stx.isNone then
+    let id ← withFreshMacroScope <| MonadQuotation.addMacroScope `inst
+    return mkIdentFrom stx id
+  else
+    return stx[0]
+
+/-- Auxiliary datatype for elaborating binders. -/
+structure BinderView where
+  /--
+  Position information provider for the Info Tree.
+  We currently do not track binder "macro expansion" steps in the info tree.
+  For example, suppose we expand a `_` into a fresh identifier. The fresh identifier
+  has synthetic position since it was not written by the user, and we would not get
+  hover information for the `_` because we also don't have this macro expansion step
+  stored in the info tree. Thus, we store the original `Syntax` in `ref`, and use
+  it when storing the binder information in the info tree.
+
+  Potential better solution: add a binder syntax category, an extensible `elabBinder`
+  (like we have `elabTerm`), and perform all macro expansion steps at `elabBinder` and
+  record them in the infro tree.
+  -/
+  ref  : Syntax
+  id   : Syntax
+  type : Syntax
+  bi   : BinderInfo
+
+/--
+Determines the local declaration kind depending on the variable name.
+
+The `__x` in `let __x := 42; body` gets kind `.implDetail`.
+-/
+def kindOfBinderName (binderName : Name) : LocalDeclKind :=
+  if binderName.isImplementationDetail then
+    .implDetail
+  else
+    .default
+
+partial def quoteAutoTactic : Syntax → CoreM Expr
+  | .ident _ _ val preresolved =>
+    return mkApp4 (.const ``Syntax.ident [])
+      (.const ``SourceInfo.none [])
+      (.app (.const ``String.toSubstring []) (mkStrLit (toString val)))
+      (toExpr val)
+      (toExpr preresolved)
+  | stx@(.node _ k args) => do
+    if stx.isAntiquot then
+      throwErrorAt stx "invalid auto tactic, antiquotation is not allowed"
+    else
+      let ty := .const ``Syntax []
+      let mut quotedArgs := mkApp (.const ``Array.empty [.zero]) ty
+      for arg in args do
+        if k == nullKind && (arg.isAntiquotSuffixSplice || arg.isAntiquotSplice) then
+          throwErrorAt arg "invalid auto tactic, antiquotation is not allowed"
+        else
+          let quotedArg ← quoteAutoTactic arg
+          quotedArgs := mkApp3 (.const ``Array.push [.zero]) ty quotedArgs quotedArg
+      return mkApp3 (.const ``Syntax.node []) (.const ``SourceInfo.none []) (toExpr k) quotedArgs
+  | .atom _ val => return .app (.const ``mkAtom []) (toExpr val)
+  | .missing    => throwError "invalid auto tactic, tactic is missing"
+
+/--
+Adds a declaration whose value is a Syntax expression representing `tactic`.
+If `name?` is provided, it is used for the declaration name, and otherwise a fresh name is generated.
+Returns the declaration name.
+-/
+def declareTacticSyntax (tactic : Syntax) (name? : Option Name := none) : TermElabM Name :=
+  withFreshMacroScope do
+    let name ← name?.getDM do MonadQuotation.addMacroScope ((← getEnv).asyncPrefix?.getD .anonymous ++ `_auto)
+    let type := Lean.mkConst `Lean.Syntax
+    let value ← quoteAutoTactic tactic
+    trace[Elab.autoParam] value
+    let decl := Declaration.defnDecl { name, levelParams := [], type, value, hints := .opaque,
+                                       safety := DefinitionSafety.safe }
+    addDecl decl
+    modifyEnv (addMeta · name)
+    compileDecl decl
+    return name
+
+/--
+Expand `optional (binderTactic <|> binderDefault)`
+```
+def binderTactic  := leading_parser " := " >> " by " >> tacticParser
+def binderDefault := leading_parser " := " >> termParser
+```
+-/
+private def expandBinderModifier (type : Syntax) (optBinderModifier : Syntax) : TermElabM Syntax := do
+  if optBinderModifier.isNone then
+    return type
+  else
+    let modifier := optBinderModifier[0]
+    let kind     := modifier.getKind
+    if kind == `Lean.Parser.Term.binderDefault then
+      let defaultVal := modifier[1]
+      `(optParam $type $defaultVal)
+    else if kind == `Lean.Parser.Term.binderTactic then
+      let tac := modifier[2]
+      let name ← declareTacticSyntax tac
+      `(autoParam $type $(mkIdentFrom tac name))
+    else
+      throwUnsupportedSyntax
+
+private def getBinderIds (ids : Syntax) : TermElabM (Array Syntax) :=
+  ids.getArgs.mapM fun id =>
+    let k := id.getKind
+    if k == identKind || k == `Lean.Parser.Term.hole then
+      return id
+    else
+      throwErrorAt id "identifier or `_` expected"
+
+/--
+Convert `stx` into an array of `BinderView`s.
+`stx` must be an identifier, `_`, `explicitBinder`, `implicitBinder`, `strictImplicitBinder`, or `instBinder`.
+-/
+private def toBinderViews (stx : Syntax) : TermElabM (Array BinderView) := do
+  let k := stx.getKind
+  if stx.isIdent || k == ``hole then
+    -- binderIdent
+    return #[{ ref := stx, id := (← expandBinderIdent stx), type := mkHole stx, bi := .default }]
+  else if k == ``Lean.Parser.Term.explicitBinder then
+    -- `(` binderIdent+ binderType (binderDefault <|> binderTactic)? `)`
+    let ids ← getBinderIds stx[1]
+    let type        := stx[2]
+    let optModifier := stx[3]
+    ids.mapM fun id => do pure { ref := id, id := (← expandBinderIdent id), type := (← expandBinderModifier (expandBinderType id type) optModifier), bi := .default }
+  else if k == ``Lean.Parser.Term.implicitBinder then
+    -- `{` binderIdent+ binderType `}`
+    let ids ← getBinderIds stx[1]
+    let type := stx[2]
+    ids.mapM fun id => do pure { ref := id, id := (← expandBinderIdent id), type := expandBinderType id type, bi := .implicit }
+  else if k == ``Lean.Parser.Term.strictImplicitBinder then
+    -- `⦃` binderIdent+ binderType `⦄`
+    let ids ← getBinderIds stx[1]
+    let type := stx[2]
+    ids.mapM fun id => do pure { ref := id, id := (← expandBinderIdent id), type := expandBinderType id type, bi := .strictImplicit }
+  else if k == ``Lean.Parser.Term.instBinder then
+    -- `[` optIdent type `]`
+    let id ← expandOptIdent stx[1]
+    let type := stx[2]
+    return #[ { ref := id, id := id, type := type, bi := .instImplicit } ]
+  else
+    throwUnsupportedSyntax
+
+private def registerFailedToInferBinderTypeInfo (type : Expr) (ref : Syntax) : TermElabM Unit := do
+  registerCustomErrorIfMVar type ref "failed to infer binder type"
+  registerLevelMVarErrorExprInfo type ref m!"failed to infer universe levels in binder type"
+
+def addLocalVarInfo (stx : Syntax) (fvar : Expr) : TermElabM Unit :=
+  addTermInfo' (isBinder := true) stx fvar
+
+private def ensureAtomicBinderName (binderView : BinderView) : TermElabM Unit :=
+  let n := binderView.id.getId.eraseMacroScopes
+  unless n.isAtomic do
+    throwErrorAt binderView.id "invalid binder name '{n}', it must be atomic"
+
+register_builtin_option checkBinderAnnotations : Bool := {
+  defValue := true
+  descr    := "check whether type is a class instance whenever the binder annotation `[...]` is used"
+}
+
+/-- Throw an error if `type` is not a valid local instance. -/
+private partial def checkLocalInstanceParameters (type : Expr) : TermElabM Unit := do
+  let .forallE n d b bi ← whnf type | return ()
+  -- We allow instance arguments so that local instances of the form
+  -- `variable [∀ (a : α) [P a], Q a]`
+  -- are accepted, per https://github.com/leanprover/lean4/issues/2311
+  if bi != .instImplicit && !b.hasLooseBVar 0 then
+    throwError "invalid parametric local instance, parameter with type{indentExpr d}\ndoes not have forward dependencies, type class resolution cannot use this kind of local instance because it will not be able to infer a value for this parameter."
+  withLocalDecl n bi d fun x => checkLocalInstanceParameters (b.instantiate1 x)
+
+private partial def elabBinderViews (binderViews : Array BinderView) (fvars : Array (Syntax × Expr)) (k : Array (Syntax × Expr) → TermElabM α)
+    : TermElabM α :=
+  let rec loop (i : Nat) (fvars : Array (Syntax × Expr)) : TermElabM α := do
+    if h : i < binderViews.size then
+      let binderView := binderViews[i]
+      ensureAtomicBinderName binderView
+      let type ← elabType binderView.type
+      registerFailedToInferBinderTypeInfo type binderView.type
+      if binderView.bi.isInstImplicit && checkBinderAnnotations.get (← getOptions) then
+        unless (← isClass? type).isSome do
+          throwErrorAt binderView.type (m!"invalid binder annotation, type is not a class instance{indentExpr type}" ++ .note "Use the command `set_option checkBinderAnnotations false` to disable the check")
+        withRef binderView.type <| checkLocalInstanceParameters type
+      let id := binderView.id.getId
+      let kind := kindOfBinderName id
+      withLocalDecl id binderView.bi type (kind := kind) fun fvar => do
+        addLocalVarInfo binderView.ref fvar
+        loop (i+1) (fvars.push (binderView.id, fvar))
+    else
+      k fvars
+  loop 0 fvars
+
+private partial def elabBindersAux (binders : Array Syntax) (k : Array (Syntax × Expr) → TermElabM α) : TermElabM α :=
+  let rec loop (i : Nat) (fvars : Array (Syntax × Expr)) : TermElabM α := do
+    if h : i < binders.size then
+      let binderViews ← toBinderViews binders[i]
+      elabBinderViews binderViews fvars <| loop (i+1)
+    else
+      k fvars
+  loop 0 #[]
+
+/--
+  Like `elabBinders`, but also pass syntax node per binder.
+  `elabBinders(Ex)` automatically adds binder info nodes for the produced fvars, but storing the syntax nodes
+  might be necessary when later adding the same binders back to the local context so that info nodes can
+  manually be added for the new fvars; see `MutualDef` for an example. -/
+def elabBindersEx (binders : Array Syntax) (k : Array (Syntax × Expr) → TermElabM α) : TermElabM α :=
+  universeConstraintsCheckpoint do
+    if binders.isEmpty then
+      k #[]
+    else
+      elabBindersAux binders k
+
+/--
+  Elaborate the given binders (i.e., `Syntax` objects for `bracketedBinder`),
+  update the local context, set of local instances, reset instance cache (if needed), and then
+  execute `k` with the updated context.
+  The local context will only be included inside `k`.
+
+  For example, suppose you have binders `[(a : α), (b : β a)]`, then the elaborator will
+  create two new free variables `a` and `b`, push these to the context and pass to `k #[a,b]`.
+  -/
+def elabBinders (binders : Array Syntax) (k : Array Expr → TermElabM α) : TermElabM α :=
+  elabBindersEx binders (fun fvars => k (fvars.map (·.2)))
+
+/-- Same as `elabBinder` with a single binder.-/
+def elabBinder (binder : Syntax) (x : Expr → TermElabM α) : TermElabM α :=
+  elabBinders #[binder] fun fvars => x fvars[0]!
+
+/-- If `binder` is a `_` or an identifier, return a `bracketedBinder` using `type` otherwise throw an exception. -/
+def expandSimpleBinderWithType (type : Term) (binder : Syntax) : MacroM Syntax :=
+  if binder.isOfKind ``hole || binder.isIdent then
+    `(bracketedBinderF| ($binder : $type))
+  else
+    Macro.throwErrorAt type "unexpected type ascription"
+
+@[builtin_macro Lean.Parser.Term.forall] def expandForall : Macro
+  | `(forall $binders* : $ty, $term) => do
+    let binders ← binders.mapM (expandSimpleBinderWithType ty)
+    `(forall $binders*, $term)
+  | _ => Macro.throwUnsupported
+
+@[builtin_term_elab «forall»] def elabForall : TermElab := fun stx _ =>
+  match stx with
+  | `(forall $binders*, $term) =>
+    elabBinders binders fun xs => do
+      let e ← elabType term
+      mkForallFVars xs e
+  | _ => throwUnsupportedSyntax
+
+open Lean.Elab.Term.Quotation in
+@[builtin_quot_precheck Lean.Parser.Term.arrow] def precheckArrow : Precheck
+  | `($dom:term -> $rng) => do
+    precheck dom
+    precheck rng
+  | _ => throwUnsupportedSyntax
+
+@[builtin_term_elab arrow] def elabArrow : TermElab := fun stx _ =>
+  match stx with
+  | `($dom:term -> $rng) => do
+    -- elaborate independently from each other
+    let dom ← elabType dom
+    let rng ← elabType rng
+    return mkForall (← MonadQuotation.addMacroScope `a) BinderInfo.default dom rng
+  | _                    => throwUnsupportedSyntax
+
+/--
+The dependent arrow. `(x : α) → β` is equivalent to `∀ x : α, β`, but we usually
+reserve the latter for propositions. Also written as `Π x : α, β` (the "Pi-type")
+in the literature. -/
+@[builtin_term_elab depArrow] def elabDepArrow : TermElab := fun stx _ =>
+  -- bracketedBinder `->` term
+  let binder := stx[0]
+  let term   := stx[2]
+  elabBinders #[binder] fun xs => do
+    mkForallFVars xs (← elabType term)
+
+/--
+  Auxiliary functions for converting `id_1 ... id_n` application into `#[id_1, ..., id_m]`
+  It is used at `expandFunBinders`. -/
+private partial def getFunBinderIds? (stx : Syntax) : OptionT MacroM (Array Syntax) :=
+  let convertElem (stx : Term) : OptionT MacroM Syntax :=
+    match stx with
+    | `(_) =>
+      /-
+      We used to use `mkFreshIdent` here,
+      but it prevented us from obtaining hover info for `_` because the
+      fresh identifier would have a synthetic position, and synthetic positions
+      are ignored by the LSP server.
+      See comment at `BinderView.ref` for additional details.
+      -/
+      return stx
+    | `($_:ident) => return stx
+    | _ => failure
+  match stx with
+  | `($f $args*) => do
+     let mut acc := #[].push (← convertElem f)
+     for arg in args do
+       acc := acc.push (← convertElem arg)
+     return acc
+  | _ =>
+    return #[].push (← convertElem stx)
+
+/--
+  Auxiliary function for expanding `fun` notation binders. Recall that `fun` parser is defined as
+  ```
+  def funBinder : Parser := implicitBinder <|> instBinder <|> termParser maxPrec
+  leading_parser unicodeSymbol "λ" "fun" >> many1 funBinder >> "=>" >> termParser
+  ```
+  to allow notation such as `fun (a, b) => a + b`, where `(a, b)` should be treated as a pattern.
+  The result is a pair `(explicitBinders, newBody)`, where `explicitBinders` is syntax of the form
+  ```
+  `(` ident `:` term `)`
+  ```
+  which can be elaborated using `elabBinders`, and `newBody` is the updated `body` syntax.
+  We update the `body` syntax when expanding the pattern notation.
+  Example: `fun (a, b) => a + b` expands into `fun _a_1 => match _a_1 with | (a, b) => a + b`.
+  See local function `processAsPattern` at `expandFunBindersAux`.
+
+  The resulting `Bool` is true if a pattern was found. We use it "mark" a macro expansion. -/
+partial def expandFunBinders (binders : Array Syntax) (body : Syntax) : MacroM (Array Syntax × Syntax × Bool) :=
+  let rec loop (body : Syntax) (i : Nat) (newBinders : Array Syntax) := do
+    if h : i < binders.size then
+      let binder := binders[i]
+      let processAsPattern : Unit → MacroM (Array Syntax × Syntax × Bool) := fun _ => do
+        let pattern := binder
+        let major ← mkFreshIdent binder
+        let (binders, newBody, _) ← loop body (i+1) (newBinders.push $ mkExplicitBinder major (mkHole binder))
+        let newBody ← `(match $major:ident with | $pattern => $newBody)
+        pure (binders, newBody, true)
+      match binder.getKind with
+      | ``Lean.Parser.Term.implicitBinder
+      | ``Lean.Parser.Term.strictImplicitBinder
+      | ``Lean.Parser.Term.instBinder
+      | ``Lean.Parser.Term.explicitBinder
+      | ``Lean.Parser.Term.hole | `ident => loop body (i+1) (newBinders.push binder)
+      | ``Lean.Parser.Term.paren =>
+        let term := binder[1]
+        match (← getFunBinderIds? term) with
+        | some idents =>
+          -- `fun (x ...) ...` ~> `fun (x : _) ...`
+          -- Interpret `(x ...)` as sequence of binders instead of pattern only if none of the idents
+          -- are defined in the global scope. Technically, it would be sufficient to only check the
+          -- first ident to be sure that the syntax cannot possibly be a valid pattern. However, for
+          -- consistency we apply the same check to all idents so that the possibility of shadowing
+          -- a global decl is identical for all of them.
+          if (← idents.allM fun ident => return List.isEmpty (← Macro.resolveGlobalName ident.getId)) then
+            loop body (i+1) (newBinders ++ idents.map (mkExplicitBinder · (mkHole binder)))
+          else
+            processAsPattern ()
+        | none => processAsPattern ()
+      | ``Lean.Parser.Term.typeAscription =>
+        let term := binder[1]
+        let type := binder[3].getOptional?.getD (mkHole binder)
+        match (← getFunBinderIds? term) with
+        | some idents => loop body (i+1) (newBinders ++ idents.map (fun ident => mkExplicitBinder ident type))
+        | none        => processAsPattern ()
+      | _ => processAsPattern ()
+    else
+      pure (newBinders, body, false)
+  loop body 0 #[]
+
+namespace FunBinders
+
+structure State where
+  fvars         : Array Expr := #[]
+  lctx          : LocalContext
+  localInsts    : LocalInstances
+  expectedType? : Option Expr := none
+
+private def propagateExpectedType (fvar : Expr) (fvarType : Expr) (s : State) : TermElabM State := do
+  match s.expectedType? with
+  | none              => pure s
+  | some expectedType =>
+    let expectedType ← whnfForall expectedType
+    match expectedType with
+    | .forallE _ d b _ =>
+      discard <| isDefEq fvarType d
+      let b := b.instantiate1 fvar
+      return { s with expectedType? := some b }
+    | _ =>
+      return { s with expectedType? := none }
+
+private partial def elabFunBinderViews (binderViews : Array BinderView) (i : Nat) (s : State) : TermElabM State := do
+  if h : i < binderViews.size then
+    let binderView := binderViews[i]
+    ensureAtomicBinderName binderView
+    withRef binderView.type <| withLCtx s.lctx s.localInsts do
+      let type ← elabType binderView.type
+      registerFailedToInferBinderTypeInfo type binderView.type
+      let fvarId ← mkFreshFVarId
+      let fvar  := mkFVar fvarId
+      let s     := { s with fvars := s.fvars.push fvar }
+      let id    := binderView.id.getId
+      let kind  := kindOfBinderName id
+      /-
+        We do **not** want to support default and auto arguments in lambda abstractions.
+        Example: `fun (x : Nat := 10) => x+1`.
+        We do not believe this is an useful feature, and it would complicate the logic here.
+      -/
+      let lctx  := s.lctx.mkLocalDecl fvarId id type binderView.bi kind
+      addTermInfo' (lctx? := some lctx) (isBinder := true) binderView.ref fvar
+      let s ← withRef binderView.id <| propagateExpectedType fvar type s
+      let s := { s with lctx }
+      match ← isClass? type, kind with
+      | some className, .default =>
+        let localInsts := s.localInsts.push { className, fvar := mkFVar fvarId }
+        elabFunBinderViews binderViews (i+1) { s with localInsts }
+      | _, _ => elabFunBinderViews binderViews (i+1) s
+  else
+    pure s
+
+partial def elabFunBindersAux (binders : Array Syntax) (i : Nat) (s : State) : TermElabM State := do
+  if h : i < binders.size then
+    let binderViews ← toBinderViews binders[i]
+    let s ← elabFunBinderViews binderViews 0 s
+    elabFunBindersAux binders (i+1) s
+  else
+    pure s
+
+end FunBinders
+
+def elabFunBinders (binders : Array Syntax) (expectedType? : Option Expr) (x : Array Expr → Option Expr → TermElabM ��) : TermElabM α :=
+  if binders.isEmpty then
+    x #[] expectedType?
+  else do
+    let lctx ← getLCtx
+    let localInsts ← getLocalInstances
+    let s ← FunBinders.elabFunBindersAux binders 0 { lctx, localInsts, expectedType? }
+    withLCtx s.lctx s.localInsts do
+      x s.fvars s.expectedType?
+
+def expandWhereDecls (whereDecls : Syntax) (body : Syntax) : MacroM Syntax :=
+  match whereDecls with
+  | `(whereDecls|where $[$_:whereFinally]?) => `($body)
+  | `(whereDecls|where $[$decls:letRecDecl];* $[$_:whereFinally]?) => `(let rec $decls:letRecDecl,*; $body)
+  | _ => Macro.throwUnsupported
+
+def expandWhereDeclsOpt (whereDeclsOpt : Syntax) (body : Syntax) : MacroM Syntax :=
+  if whereDeclsOpt.isNone then
+    return body
+  else
+    expandWhereDecls whereDeclsOpt[0] body
+
+/--
+ Helper function for `expandMatchAltsIntoMatch`.
+-/
+private def expandMatchAltsIntoMatchAux (matchAlts : Syntax) (isTactic : Bool) (useExplicit : Bool) : Nat → Array Syntax → Array Ident → MacroM Syntax
+  | 0,   discrs, xs => do
+    if isTactic then
+      `(tactic|match $[$discrs:term],* with $matchAlts:matchAlts)
+    else
+      let stx ← `(match $[$discrs:term],* with $matchAlts:matchAlts)
+      clearInMatch stx xs
+  | n+1, discrs, xs => withFreshMacroScope do
+    let x ← `(x) -- If this were implementation-detail, the `contradiction` tactic used by match would not find it.
+    let d ← `(@$x:ident)
+    let body ← expandMatchAltsIntoMatchAux matchAlts isTactic useExplicit n (discrs.push d) (xs.push x)
+    if isTactic then
+      `(tactic| intro $x:term; $body:tactic)
+    else if useExplicit then
+      `(@fun $x => $body)
+    else
+      `(fun $x => $body)
+
+/--
+  Expand `matchAlts` syntax into a full `match`-expression.
+  Example:
+  ```
+  | 0, true => alt_1
+  | i, _    => alt_2
+  ```
+  expands into (for tactic == false)
+  ```
+  fun x_1 x_2 =>
+  match @x_1, @x_2 with
+  | 0, true => alt_1
+  | i, _    => alt_2
+  ```
+  and (for tactic == true)
+  ```
+  intro x_1; intro x_2;
+  match @x_1, @x_2 with
+  | 0, true => alt_1
+  | i, _    => alt_2
+  ```
+
+  If `useExplicit = true`, we add a `@` before `fun` to disable implicit lambdas. We disable them when processing `let` and `let rec` declarations
+  to make sure the behavior is consistent with top-level declarations where we can write
+  ```
+  def f : {α : Type} → α → α
+    | _, a => a
+  ```
+  We use `useExplicit = false` when we are elaborating the `fun | ... => ... | ...` notation. See issue #1132.
+  If `@fun` is used with this notation, the we set `useExplicit = true`.
+  We also use `useExplicit = false` when processing `instance ... where` notation declarations. The motivation is to have compact declarations such as
+  ```
+  instance [Alternative m] : MonadLiftT Option m where
+  monadLift -- We don't want to provide the implicit arguments of `monadLift` here. One should use `monadLift := @fun ...` if they want to provide them.
+    | some a => pure a
+    | none => failure
+  ```
+
+  Remark: we add `@` at discriminants to make sure we don't consume implicit arguments, and to make the behavior consistent with `fun`.
+  Example:
+  ```
+  inductive T : Type 1 :=
+  | mkT : (forall {a : Type}, a -> a) -> T
+
+  def makeT (f : forall {a : Type}, a -> a) : T :=
+    mkT f
+
+  def makeT' : (forall {a : Type}, a -> a) -> T
+  | f => mkT f
+  ```
+  The two definitions should be elaborated without errors and be equivalent.
+ -/
+def expandMatchAltsIntoMatch (ref : Syntax) (matchAlts : Syntax) (useExplicit := true) : MacroM Syntax :=
+  withRef ref <| expandMatchAltsIntoMatchAux matchAlts (isTactic := false) (useExplicit := useExplicit) (getMatchAltsNumPatterns matchAlts) #[] #[]
+
+def expandMatchAltsIntoMatchTactic (ref : Syntax) (matchAlts : Syntax) : MacroM Syntax :=
+  withRef ref <| expandMatchAltsIntoMatchAux matchAlts (isTactic := true) (useExplicit := false) (getMatchAltsNumPatterns matchAlts) #[] #[]
+
+/--
+Sanity-checks the number of patterns in each alternative of a definition by pattern matching.
+Specifically, verifies that all alternatives have the same number of patterns and that the number
+of patterns is upper-bounded by the number of (dependent) arrows in the expected type.
+
+Note: This function assumes that the number of patterns in the first alternative will be equal to
+`numDiscrs` (since we use the first alternative to infer the arity of the generated matcher in
+`getMatchAltsNumPatterns`).
+-/
+private def checkMatchAltPatternCounts (matchAlts : Syntax) (numDiscrs : Nat) (expectedType : Expr)
+    : MetaM Unit := do
+  let sepPats (pats : List Syntax) := MessageData.joinSep (pats.map toMessageData) ", "
+  let maxDiscrs? ← forallTelescopeReducing expectedType fun xs e =>
+    if e.getAppFn.isMVar then pure none else pure (some xs.size)
+  let matchAltViews := matchAlts[0].getArgs.filterMap getMatchAlt
+  let numPatternsStr (n : Nat) := s!"{n} {if n == 1 then "pattern" else "patterns"}"
+  if h : matchAltViews.size > 0 then
+    if let some maxDiscrs := maxDiscrs? then
+      if numDiscrs > maxDiscrs then
+        if maxDiscrs == 0 then
+          throwErrorAt matchAltViews[0].lhs m!"Cannot define a value of type{indentExpr expectedType}\n\
+            by pattern matching because it is not a function type"
+        else
+          throwErrorAt matchAltViews[0].lhs m!"Too many patterns in match alternative: \
+            At most {numPatternsStr maxDiscrs} expected in a definition of type {indentExpr expectedType}\n\
+            but found {numDiscrs}:{indentD <| sepPats matchAltViews[0].patterns.toList}"
+    -- Catch inconsistencies between pattern counts here so that we can report them as "inconsistent"
+    -- rather than as "too many" or "too few" (as the `match` elaborator does)
+    for view in matchAltViews do
+      let numPats := view.patterns.size
+      if numPats != numDiscrs then
+        let origPats := sepPats matchAltViews[0].patterns.toList
+        let pats := sepPats view.patterns.toList
+        throwErrorAt view.lhs m!"Inconsistent number of patterns in match alternatives: This \
+          alternative contains {numPatternsStr numPats}:{indentD pats}\n\
+          but a preceding alternative contains {numDiscrs}:{indentD origPats}"
+
+/--
+  Similar to `expandMatchAltsIntoMatch`, but supports an optional `where` clause.
+
+  Expand `matchAltsWhereDecls` into `let rec` + `match`-expression.
+  Example
+  ```
+  | 0, true => ... f 0 ...
+  | i, _    => ... f i + g i ...
+  where
+    f x := g x + 1
+
+    g : Nat → Nat
+      | 0   => 1
+      | x+1 => f x
+  ```
+  expands into
+  ```
+  fux x_1 x_2 =>
+    let rec
+      f x := g x + 1,
+      g : Nat → Nat
+        | 0   => 1
+        | x+1 => f x
+    match x_1, x_2 with
+    | 0, true => ... f 0 ...
+    | i, _    => ... f i + g i ...
+  ```
+-/
+def expandMatchAltsWhereDecls (matchAltsWhereDecls : Syntax) (expectedType : Expr) : TermElabM Syntax :=
+  let matchAlts     := matchAltsWhereDecls[0]
+  -- matchAltsWhereDecls[1] is the termination hints, collected elsewhere
+  let whereDeclsOpt := matchAltsWhereDecls[2]
+  let rec loop (i : Nat) (discrs : Array Syntax) : TermElabM Syntax :=
+    match i with
+    | 0   => do
+      checkMatchAltPatternCounts matchAlts discrs.size expectedType
+      let matchStx ← `(match $[@$discrs:term],* with $matchAlts:matchAlts)
+      liftMacroM do
+        let matchStx ← clearInMatch matchStx discrs
+        if whereDeclsOpt.isNone then
+          return matchStx
+        else
+          expandWhereDeclsOpt whereDeclsOpt matchStx
+    | n+1 => withFreshMacroScope do
+      let body ← loop n (discrs.push (← `(x)))
+      `(@fun x => $body)
+  loop (getMatchAltsNumPatterns matchAlts) #[]
+
+@[builtin_macro Parser.Term.fun] partial def expandFun : Macro
+  | `(fun $binders* : $ty => $body) => do
+    let binders ← binders.mapM (expandSimpleBinderWithType ty)
+    `(fun $binders* => $body)
+  | `(fun $binders* => $body) => do  -- if there is a type ascription, we assume all binders are already simple
+    let (binders, body, expandedPattern) ← expandFunBinders binders body
+    if expandedPattern then
+      `(fun $binders* => $body)
+    else
+      Macro.throwUnsupported
+  | stx@`(fun $m:matchAlts) => expandMatchAltsIntoMatch stx m (useExplicit := false)
+  | _ => Macro.throwUnsupported
+
+@[builtin_macro Parser.Term.explicit] partial def expandExplicitFun : Macro := fun stx =>
+  match stx with
+  | `(@fun $m:matchAlts) => expandMatchAltsIntoMatch stx[1] m (useExplicit := true)
+  | _ => Macro.throwUnsupported
+
+open Lean.Elab.Term.Quotation in
+@[builtin_quot_precheck Lean.Parser.Term.fun] def precheckFun : Precheck
+  | `(fun $binders* $[: $ty?]? => $body) => do
+    let (binders, body, _) ← liftMacroM <| expandFunBinders binders body
+    let mut ids := #[]
+    for b in binders do
+      for v in ← toBinderViews b do
+        Quotation.withNewLocals ids <| precheck v.type
+        ids := ids.push v.id.getId
+    Quotation.withNewLocals ids <| precheck body
+  | _ => throwUnsupportedSyntax
+
+@[builtin_term_elab «fun»] partial def elabFun : TermElab := fun stx expectedType? =>
+  match stx with
+  | `(fun $binders* => $body) => do
+    -- We can assume all `match` binders have been iteratively expanded by the above macro here, though
+    -- we still need to call `expandFunBinders` once to obtain `binders` in a normal form
+    -- expected by `elabFunBinder`.
+    let (binders, body, _) ← liftMacroM <| expandFunBinders binders body
+    elabFunBinders binders expectedType? fun xs expectedType? => do
+      /- We ensure the expectedType here since it will force coercions to be applied if needed.
+          If we just use `elabTerm`, then we will need to a coercion `Coe (α → β) (α → δ)` whenever there is a coercion `Coe β δ`,
+          and another instance for the dependent version. -/
+      let e ← elabTermEnsuringType body expectedType?
+      mkLambdaFVars xs e
+  | _ => throwUnsupportedSyntax
+
+/--
+Configuration for `let` elaboration.
+-/
+structure LetConfig where
+  /-- Elaborate as a nondependent `let` (a `have`). -/
+  nondep : Bool := false
+  /-- Eliminate the `let` if it is unused by the body. -/
+  usedOnly : Bool := false
+  /-- Zeta reduces (inlines) the `let`. -/
+  zeta : Bool := false
+  /-- Postpone elaboration of the value until after the body is elaborated. -/
+  postponeValue : Bool := false
+  /-- Generalize the value from the expected type when elaborating the body. -/
+  generalize : Bool := false
+  /-- For `let x := v; b`, adds `eq : x = v` to the context. -/
+  eq? : Option Ident := none
+
+def LetConfig.setFrom (config : LetConfig) (key : Syntax) (val : Bool) : LetConfig :=
+  if key.isOfKind ``Parser.Term.letOptNondep then
+    { config with nondep := val }
+  else if key.isOfKind ``Parser.Term.letOptUsedOnly then
+    { config with usedOnly := val }
+  else if key.isOfKind ``Parser.Term.letOptZeta then
+    { config with zeta := val }
+  else if key.isOfKind ``Parser.Term.letOptPostponeValue then
+    { config with postponeValue := val }
+  else if key.isOfKind ``Parser.Term.letOptGeneralize then
+    { config with generalize := val }
+  else
+    config
+
+/--
+Interprets a `Parser.Term.letConfig`.
+-/
+def mkLetConfig (letConfig : Syntax) (initConfig : LetConfig) : TermElabM LetConfig := do
+  let mut config := initConfig
+  unless letConfig.isOfKind ``Parser.Term.letConfig do
+    return config
+  for item in letConfig[0].getArgs do
+    match item with
+    | `(letPosOpt| +$opt:letOpts) => config := config.setFrom opt.raw[0] true
+    | `(letNegOpt| -$opt:letOpts) => config := config.setFrom opt.raw[0] false
+    | `(letOptEq| (eq := $n:ident)) => config := { config with eq? := n }
+    | `(letOptEq| (eq := $b)) => config := { config with eq? := mkIdentFrom b (canonical := true) (← mkFreshBinderNameForTactic `h) }
+    | _ => pure ()
+  return config
+
+/--
+The default elaboration order is `binders`, `typeStx`, `valStx`, and `body`.
+If `config.postponeValue == true`, then we use the order `binders`, `typeStx`, `body`, and `valStx`.
+If `config.generalize == true`, then the value is abstracted from the expected type when elaborating the body.
+-/
+def elabLetDeclAux (id : Syntax) (binders : Array Syntax) (typeStx : Syntax) (valStx : Syntax) (body : Syntax)
+    (expectedType? : Option Expr) (config : LetConfig) : TermElabM Expr := do
+  if config.generalize then
+    if config.postponeValue then
+      throwError "`+postponeValue` and `+generalize` are incompatible"
+    tryPostponeIfNoneOrMVar expectedType?
+  let (type, val, binders) ← elabBindersEx binders fun xs => do
+    let (binders, fvars) := xs.unzip
+    /-
+    We use `withSynthesize` to ensure that any postponed elaboration problem
+    and nested tactics in `type` are resolved before elaborating `val`.
+    Resolved: we want to avoid synthetic opaque metavariables in `type`.
+    Recall that this kind of metavariable is non-assignable, and `isDefEq`
+    may waste a lot of time unfolding declarations before failing.
+    See issue #4051 for an example.
+
+    Here is the analysis for issue #4051.
+    - Given `have x : type := value; body`, we were previously elaborating `value` even
+      if `type` contained postponed elaboration problems.
+    - Moreover, the metavariables in `type` corresponding to postponed elaboration
+      problems cannot be assigned by `isDefEq` since the elaborator is supposed to assign them.
+    - Then, when checking whether type of `value` is definitionally equal to `type`,
+      a very long-time was spent unfolding a bunch of declarations before it failed.
+      In #4051, it was unfolding `Array.swaps` which is defined by well-founded recursion.
+      After the failure, the elaborator inserted a postponed coercion
+      that would be resolved later as soon as the types don't have unassigned metavariables.
+
+    We use `postpone := .partial` to allow type class (TC) resolution problems to be postponed
+    Recall that TC resolution does **not** produce synthetic opaque metavariables.
+    -/
+    let type ← withSynthesize (postpone := .partial) <| elabType typeStx
+    let letMsg := if config.nondep then "have" else "let"
+    registerCustomErrorIfMVar type typeStx m!"failed to infer '{letMsg}' declaration type"
+    registerLevelMVarErrorExprInfo type typeStx m!"failed to infer universe levels in '{letMsg}' declaration type"
+    if config.postponeValue then
+      let type ← mkForallFVars fvars type
+      let val  ← mkFreshExprMVar type
+      pure (type, val, binders)
+    else
+      let val  ← elabTermEnsuringType valStx type
+      let type ← mkForallFVars fvars type
+      /- By default `mkLambdaFVars` and `mkLetFVars` create binders only for let-declarations that are actually used
+         in the body. This generates counterintuitive behavior in the elaborator since users will not be notified
+         about holes such as
+         ```
+          def ex : Nat :=
+            let x := _
+            42
+         ```
+       -/
+      let val  ← mkLambdaFVars fvars val (usedLetOnly := false)
+      pure (type, val, binders)
+  let kind := kindOfBinderName id.getId
+  trace[Elab.let.decl] "{id.getId} : {type} := {val}"
+  let result ←
+    withLetDecl id.getId (kind := kind) type val (nondep := config.nondep) fun x => do
+      let elabBody : TermElabM Expr := do
+        let mut expectedType? := expectedType?
+        if config.generalize then
+          let throwNoType := throwError "failed to elaborate with `+generalize`, expected type is not available"
+          let some expectedType := expectedType? | throwNoType
+          let expectedType ← instantiateMVars expectedType
+          if expectedType.getAppFn.isMVar then throwNoType
+          let motiveBody ← kabstract expectedType (← instantiateMVars val)
+          let motive := motiveBody.instantiate1 x
+          -- When `config.nondep` is false, then `motive` will be definitionally equal to `expectedType`.
+          -- Type correctness only needs to be checked in the `nondep` case:
+          if config.nondep then
+            unless (← isTypeCorrect motive) do
+              throwError "failed to elaborate with `+generalize`, generalized expected type is not type correct:{indentD motive}"
+          expectedType? := motive
+        elabTermEnsuringType body expectedType? >>= instantiateMVars
+      addLocalVarInfo id x
+      match config.eq? with
+      | none =>
+        let body ← elabBody
+        if config.zeta then
+          pure <| (← body.abstractM #[x]).instantiate1 val
+        else
+          mkLetFVars #[x] body (usedLetOnly := config.usedOnly) (generalizeNondepLet := false)
+      | some h =>
+        let hTy ← mkEq x val
+        withLetDecl h.getId hTy (← mkEqRefl x) (nondep := true) fun h' => do
+          addLocalVarInfo h h'
+          let body ← elabBody
+          if config.zeta then
+            pure <| (← body.abstractM #[x, h']).instantiateRev #[val, ← mkEqRefl val]
+          else if config.nondep then
+            -- TODO(kmill): Think more about how to encode this case.
+            -- Currently we produce `(fun (x : α) (h : x = val) => b) val rfl`.
+            -- N.B. the nondep lets become lambdas here.
+            let f ← mkLambdaFVars #[x, h'] body
+            return mkApp2 f val (← mkEqRefl val)
+          else
+            mkLetFVars #[x, h'] body (usedLetOnly := config.usedOnly) (generalizeNondepLet := false)
+  if config.postponeValue then
+    forallBoundedTelescope type binders.size fun xs type => do
+      -- the original `fvars` from above are gone, so add back info manually
+      for b in binders, x in xs do
+        addLocalVarInfo b x
+      let valResult ← elabTermEnsuringType valStx type
+      let valResult ← mkLambdaFVars xs valResult (usedLetOnly := false)
+      unless (← isDefEq val valResult) do
+        throwError "unexpected error when elaborating 'let'"
+  pure result
+
+structure LetIdDeclView where
+  id      : Syntax
+  binders : Array Syntax
+  type    : Syntax
+  value   : Syntax
+
+def mkLetIdDeclView (letIdDecl : Syntax) : LetIdDeclView :=
+  /-
+  def letId := leading_parser binderIdent <|> hygieneInfo
+  def letIdBinder := binderIdent <|> bracketedBinder
+  def letIdLhs := letId >> many letIdBinder >> optType
+  def letIdDecl := leading_parser letIdLhs >> " := " >> termParser
+  -/
+  let letId := letIdDecl[0]
+  let id :=
+    if letId[0].isOfKind hygieneInfoKind then
+      HygieneInfo.mkIdent letId[0] `this (canonical := true)
+    else
+      -- Assumed to be binderIdent
+      letId[0]
+  let binders := letIdDecl[1].getArgs
+  let optType := letIdDecl[2]
+  let type    := expandOptType id optType
+  let value   := letIdDecl[4]
+  { id, binders, type, value }
+
+def expandLetEqnsDecl (letDecl : Syntax) (useExplicit := true) : MacroM Syntax := do
+  let ref       := letDecl
+  let matchAlts := letDecl[3]
+  let val ← expandMatchAltsIntoMatch ref matchAlts (useExplicit := useExplicit)
+  return mkNode `Lean.Parser.Term.letIdDecl #[letDecl[0], letDecl[1], letDecl[2], mkAtomFrom ref " := ", val]
+
+def elabLetDeclCore (stx : Syntax) (expectedType? : Option Expr) (initConfig : LetConfig) : TermElabM Expr := do
+  let (config, declIdx) ← if stx[1].isOfKind ``Parser.Term.letConfig then
+    pure (← mkLetConfig stx[1] initConfig, 2)
+  else
+    pure (initConfig, 1)
+  let letDecl   := stx[declIdx][0]
+  let body      := stx[declIdx + 2]
+  if letDecl.getKind == ``Lean.Parser.Term.letIdDecl then
+    let { id, binders, type, value } := mkLetIdDeclView letDecl
+    let id ← if id.isIdent then pure id else mkFreshIdent id (canonical := true)
+    elabLetDeclAux id binders type value body expectedType? config
+  else if letDecl.getKind == ``Lean.Parser.Term.letPatDecl then
+    -- node `Lean.Parser.Term.letPatDecl  $ try (termParser >> pushNone >> optType >> " := ") >> termParser
+    let pat     := letDecl[0]
+    let optType := letDecl[2]
+    let val     := letDecl[4]
+    if pat.getKind == ``Parser.Term.hole then
+      -- `let _ := ...` should be treated as a `letIdDecl`
+      let id   ← mkFreshIdent pat (canonical := true)
+      let type := expandOptType id optType
+      elabLetDeclAux id #[] type val body expectedType? config
+    else
+      if config.postponeValue then
+        throwError "`+deferValue` with patterns is not allowed"
+      if config.usedOnly then
+        throwError "`+usedOnly` with patterns is not allowed"
+      if config.zeta then
+        throwError "`+zeta` with patterns is not allowed"
+      -- We are currently ignore `config.nondep` when patterns are used.
+      -- We are also currently ignoring `config.generalize`.
+      let val ← if optType.isNone then
+        `($val:term)
+      else
+        let type := optType[0][1]
+        `(($val:term : $type))
+      let stxNew ← if let some h := config.eq? then
+        `(match $h:ident : $val:term with | $pat => $body)
+      else
+        `(match $val:term with | $pat => $body)
+      withMacroExpansion stx stxNew <| elabTerm stxNew expectedType?
+  else if letDecl.getKind == ``Lean.Parser.Term.letEqnsDecl then
+    let letDeclIdNew ← liftMacroM <| expandLetEqnsDecl letDecl
+    let declNew := stx[declIdx].setArg 0 letDeclIdNew
+    let stxNew  := stx.setArg declIdx declNew
+    withMacroExpansion stx stxNew <| elabTerm stxNew expectedType?
+  else
+    throwUnsupportedSyntax
+
+@[builtin_term_elab «let»] def elabLetDecl : TermElab :=
+  fun stx expectedType? => elabLetDeclCore stx expectedType? {}
+
+@[builtin_term_elab «have»] def elabHaveDecl : TermElab :=
+  fun stx expectedType? => elabLetDeclCore stx expectedType? { nondep := true }
+
+@[builtin_term_elab «let_fun»] def elabLetFunDecl : TermElab :=
+  fun stx expectedType? => do
+    withRef stx <| Linter.logLintIf Linter.linter.deprecated stx[0]
+      "`let_fun` has been deprecated in favor of `have`"
+    elabLetDeclCore stx expectedType? { nondep := true }
+
+@[builtin_term_elab «let_delayed»] def elabLetDelayedDecl : TermElab :=
+  fun stx expectedType? => elabLetDeclCore stx expectedType? { postponeValue := true }
+
+@[builtin_term_elab «let_tmp»] def elabLetTmpDecl : TermElab :=
+  fun stx expectedType? => elabLetDeclCore stx expectedType? { usedOnly := true }
+
+@[builtin_term_elab «letI»] def elabLetIDecl : TermElab :=
+  fun stx expectedType? => elabLetDeclCore stx expectedType? { zeta := true }
+
+@[builtin_term_elab «haveI»] def elabHaveIDecl : TermElab :=
+  fun stx expectedType? => elabLetDeclCore stx expectedType? { zeta := true, nondep := true }
+
+builtin_initialize
+  registerTraceClass `Elab.let
+  registerTraceClass `Elab.let.decl
+  registerTraceClass `Elab.autoParam
+
+end Lean.Elab.Term

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/BindersUtil.lean

@@ -0,0 +1,73 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.Parser.Term
+
+namespace Lean.Elab.Term
+/--
+  Recall that
+  ```
+  def typeSpec := leading_parser " : " >> termParser
+  def optType : Parser := optional typeSpec
+  ```
+-/
+def expandOptType (ref : Syntax) (optType : Syntax) : Syntax :=
+  if optType.isNone then
+    mkHole ref
+  else
+    optType[0][1]
+
+open Lean.Parser.Term
+
+/-- Helper function for `expandEqnsIntoMatch` -/
+def getMatchAltsNumPatterns (matchAlts : Syntax) : Nat :=
+  let alt0 := matchAlts[0][0]
+  let pats := alt0[1][0].getSepArgs
+  pats.size
+
+/--
+  Expand a match alternative such as `| 0 | 1 => rhs` to an array containing `| 0 => rhs` and `| 1 => rhs`.
+-/
+def expandMatchAlt (stx : TSyntax ``matchAlt) : MacroM (Array (TSyntax ``matchAlt)) :=
+  match stx with
+  | `(matchAltExpr| | $[$patss,*]|* => $rhs) =>
+     if patss.size ≤ 1 then
+       return #[stx]
+     else
+       patss.mapM fun pats => `(matchAltExpr| | $pats,* => $rhs)
+  | _ => return #[stx]
+
+def shouldExpandMatchAlt : TSyntax ``matchAlt → Bool
+  | `(matchAltExpr| | $[$patss,*]|* => $_) => patss.size > 1
+  | _ => false
+
+def expandMatchAlts? (stx : Syntax) : MacroM (Option Syntax) := do
+  match stx with
+  | `(match $[$gen]? $[$motive]? $discrs,* with $alts:matchAlt*) =>
+    if alts.any shouldExpandMatchAlt then
+      let alts ← alts.foldlM (init := #[]) fun alts alt => return alts ++ (← expandMatchAlt alt)
+      `(match $[$gen]? $[$motive]? $discrs,* with $alts:matchAlt*)
+    else
+      return none
+  | _ => return none
+
+open TSyntax.Compat in
+def clearInMatchAlt (stx : TSyntax ``matchAlt) (vars : Array Ident) : TSyntax ``matchAlt :=
+  stx.1.modifyArg 3 fun rhs => Unhygienic.run do
+    let mut rhs := rhs
+    for v in vars do
+      rhs ← `(clear% $v; $rhs)
+    return rhs
+
+def clearInMatch (stx : Syntax) (vars : Array Ident) : MacroM Syntax := do
+  if vars.isEmpty then return stx
+  match stx with
+  | `(match $[$gen]? $[$motive]? $discrs,* with $alts:matchAlt*) =>
+    let alts := alts.map (clearInMatchAlt · vars)
+    `(match $[$gen]? $[$motive]? $discrs,* with $alts:matchAlt*)
+  | _ => return stx
+
+end Lean.Elab.Term

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/BuiltinCommand.lean

@@ -0,0 +1,676 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.Util.CollectLevelParams
+import Lean.Util.CollectAxioms
+import Lean.Meta.Reduce
+import Lean.Elab.DeclarationRange
+import Lean.Elab.Eval
+import Lean.Elab.Command
+import Lean.Elab.Open
+import Lean.Elab.SetOption
+import Init.System.Platform
+import Lean.Meta.Hint
+
+namespace Lean.Elab.Command
+
+@[builtin_command_elab moduleDoc] def elabModuleDoc : CommandElab := fun stx => do
+  match stx[1] with
+  | Syntax.atom _ val =>
+    let doc := val.extract 0 (val.endPos - ⟨2⟩)
+    let some range ← Elab.getDeclarationRange? stx
+      | return  -- must be from partial syntax, ignore
+    modifyEnv fun env => addMainModuleDoc env ⟨doc, range⟩
+  | _ => throwErrorAt stx "unexpected module doc string{indentD stx[1]}"
+
+private def addScope (isNewNamespace : Bool) (header : String) (newNamespace : Name)
+    (isNoncomputable isPublic : Bool := false) (attrs : List (TSyntax ``Parser.Term.attrInstance) := []) :
+    CommandElabM Unit := do
+  modify fun s => { s with
+    env    := s.env.registerNamespace newNamespace,
+    scopes := { s.scopes.head! with
+      header := header, currNamespace := newNamespace
+      isNoncomputable := s.scopes.head!.isNoncomputable || isNoncomputable
+      isPublic := s.scopes.head!.isPublic || isPublic
+      attrs := s.scopes.head!.attrs ++ attrs
+    } :: s.scopes
+  }
+  pushScope
+  if isNewNamespace then
+    activateScoped newNamespace
+
+private def addScopes (header : Name) (isNewNamespace : Bool) (isNoncomputable isPublic : Bool := false)
+    (attrs : List (TSyntax ``Parser.Term.attrInstance) := []) : CommandElabM Unit :=
+  go header
+where go
+  | .anonymous => pure ()
+  | .str p header => do
+    go p
+    let currNamespace ← getCurrNamespace
+    addScope isNewNamespace header (if isNewNamespace then Name.mkStr currNamespace header else currNamespace) isNoncomputable isPublic attrs
+  | _ => throwError "invalid scope"
+
+private def addNamespace (header : Name) : CommandElabM Unit :=
+  addScopes (isNewNamespace := true) (isNoncomputable := false) (attrs := []) header
+
+def withNamespace {α} (ns : Name) (elabFn : CommandElabM α) : CommandElabM α := do
+  addNamespace ns
+  let a ← elabFn
+  modify fun s => { s with scopes := s.scopes.drop ns.getNumParts }
+  pure a
+
+private def popScopes (numScopes : Nat) : CommandElabM Unit :=
+  for _ in [0:numScopes] do
+    popScope
+
+private def innermostScopeName? : List Scope → Option Name
+  | { header := "", .. } :: _ => none
+  | { header := h, .. }  :: _ => some <| .mkSimple h
+  | _                         => some .anonymous -- should not happen
+
+private def checkEndHeader : Name → List Scope → Option Name
+  | .anonymous, _ => none
+  | .str p s, { header := h, .. } :: scopes =>
+    if h == s then
+      (.str · s) <$> checkEndHeader p scopes
+    else
+      some <| .mkSimple h
+  | _, _ => some .anonymous -- should not happen
+
+@[builtin_command_elab «namespace»] def elabNamespace : CommandElab := fun stx =>
+  match stx with
+  | `(namespace $n) => addNamespace n.getId
+  | _               => throwUnsupportedSyntax
+
+@[builtin_command_elab «section»] def elabSection : CommandElab := fun stx => do
+  match stx with
+  | `(Parser.Command.section| $[public%$publicTk]? $[@[expose%$expTk]]? $[noncomputable%$ncTk]? section $(header?)?) =>
+    -- TODO: allow more attributes?
+    let attrs ← if expTk.isSome then
+      pure [← `(Parser.Term.attrInstance| expose)]
+    else
+      pure []
+    if let some header := header? then
+      addScopes (isNewNamespace := false) (isNoncomputable := ncTk.isSome) (isPublic := publicTk.isSome) (attrs := attrs) header.getId
+    else
+      addScope (isNewNamespace := false) (isNoncomputable := ncTk.isSome) (isPublic := publicTk.isSome) (attrs := attrs) "" (← getCurrNamespace)
+  | _                        => throwUnsupportedSyntax
+
+/--
+Produces a `Name` composed of the names of at most the innermost `n` scopes in `ss`, truncating if an
+empty scope is reached (so that we do not suggest names like `Foo.«».Bar`).
+
+If `n` is not specified, will use all scopes in `ss`.
+-/
+private def nameOfScopes : (ss : List Scope) → (n : Nat := ss.length) → Name
+  | _, 0 => .anonymous
+  | [], _ => .anonymous
+  | s :: ss, n + 1 =>
+    if s.header == "" then
+      .anonymous
+    else
+    .str (nameOfScopes ss n) s.header
+
+/--
+Returns the first suffix of `base` that begins with `seg`, if one exists.
+
+Note: this uses a naive, O(m*n) implementation for simplicity; we assume repeated partial overlap of
+name components to be relatively uncommon, so that practical performance is closer to linear.
+-/
+private def findSuffixWithPrefix (base : Name) (seg : Name) : Option Name :=
+  findSuffixMatch base seg true
+where
+  /--
+  Helper for `findSuffixWithPrefix`. If `allowOffset` is `false`, then `seg` must be a suffix of
+  `base`, not just a prefix of a suffix.
+  -/
+  findSuffixMatch : (base : Name) → (seg : Name) → (allowOffset : Bool) → Option Name
+  | _, .anonymous, _ => some .anonymous
+  | .anonymous, _, _ => none
+  | .num p n, seg@(.num p' n'), allowOffset => do
+    if n == n' then
+      if let some nm := findSuffixMatch p p' (allowOffset := false) then
+        return .num nm n
+    if allowOffset then
+      return .num (← findSuffixMatch p seg allowOffset) n
+    else
+      none
+  | .str p s, seg@(.str p' s'), allowOffset => do
+    if s == s' then
+      if let some nm := findSuffixMatch p p' (allowOffset := false) then
+        return .str nm s
+    if allowOffset then
+      return .str (← findSuffixMatch p seg allowOffset) s
+    else
+      none
+  | .str p s, seg, allowOffset =>
+    if allowOffset then
+      return .str (← findSuffixMatch p seg allowOffset) s
+    else
+      none
+  | .num p n, seg, allowOffset =>
+    if allowOffset then
+      return .num (← findSuffixMatch p seg allowOffset) n
+    else
+      none
+
+private def throwNoScope : CommandElabM Unit :=
+  throwError m!"Invalid `end`: There is no current scope to end"
+    ++ .note m!"Scopes are introduced using `namespace` and `section`"
+
+private def throwMissingName (name : Name) : CommandElabM Unit := do
+  let hint ← liftCoreM <| MessageData.hint m!"To end the current scope `{name}`, specify its name:"
+    #[← `(end $(mkIdent name))] (codeActionPrefix? := "Add scope name: ")
+  throwError "Missing name after `end`: Expected the current scope name `{name}`{hint}"
+
+/--
+Produces a hint message with a suggestion to replace the name following `end` at the current ref
+with the name given by `scopes` if there is only one active scope; otherwise, returns `none`.
+
+Rationale: When there is only one active scope, only one valid `end` command is possible, so we
+suggest it; if there are multiple, then it is harder to determine with confidence which the user
+intended to end.
+-/
+private def mkSingleScopeReplacementHint? (scopes : List Scope) := do
+  -- Recall that there is always an anonymous topmost scope, so `scopes.length = 2` when there is
+  -- only one active scope:
+  if scopes.length == 2 then
+    let name := nameOfScopes scopes
+    some <$> MessageData.hint m!"Use current scope name `{name}`:" #[(← `(end $(mkIdent name)))]
+      (codeActionPrefix? := "Replace scope name: ")
+  else
+    return none
+
+private def throwTooManyScopeComponents (header : Name) (scopes : List Scope) : CommandElabM Unit := do
+  let hint ← liftCoreM do
+    if let some hint ← mkSingleScopeReplacementHint? scopes then
+      pure hint
+    else
+      let scopesName := nameOfScopes scopes
+      pure <| MessageData.hint' m!"The name after `end` must be `{scopesName}` or some suffix thereof"
+  throwError m!"Invalid name after `end`: `{header}` contains too many components" ++ hint
+
+private def throwScopeNameMismatch (header : Name) (scopes : List Scope) (endSize : Nat)
+    : CommandElabM Unit := do
+  let correspondingScopes := nameOfScopes scopes endSize
+  let allScopes := nameOfScopes scopes
+  let help ← liftCoreM do
+    if let some hint ← mkSingleScopeReplacementHint? scopes then
+      pure hint
+    else if let some suffix := findSuffixWithPrefix allScopes header then
+      let hintMsg := m!"If you meant to end the outer scope(s) `{header}`, you must end all the \
+        intervening scopes `{suffix}`:"
+      MessageData.hint hintMsg #[← `(end $(mkIdent suffix))]
+        (codeActionPrefix? := "Add intervening scopes: ")
+    else if correspondingScopes != allScopes then
+      pure <| .note m!"The current scopes are `{allScopes}`"
+    else pure .nil
+  throwError m!"Invalid name after `end`: Expected `{correspondingScopes}`, but found `{header}`" ++ help
+
+private def throwUnnecessaryScopeName (header : Name) : CommandElabM Unit := do
+  let hintMsg := m!"Delete the name `{header}` to end the current unnamed scope; outer named scopes \
+    can then be closed using additional `end` command(s):"
+  let hint ← liftCoreM <| MessageData.hint hintMsg #[← `(end)] (codeActionPrefix? := "Delete name: ")
+  throwError m!"Unexpected name `{header}` after `end`: The current section is unnamed" ++ hint
+
+@[builtin_command_elab «end»] def elabEnd : CommandElab := fun stx => do
+  let header? := (stx.getArg 1).getOptionalIdent?
+  let endSize : Nat := match header? with
+    | none   => 1
+    | some n => n.getNumParts
+  let scopes ← getScopes
+  let numScopes := scopes.length
+  if numScopes == 1 then
+    throwNoScope
+  match header? with
+  | none        =>
+    if let some name := innermostScopeName? scopes then
+      throwMissingName name
+  | some header =>
+    if endSize >= numScopes then
+      throwTooManyScopeComponents header scopes
+    else
+      let scopesName := nameOfScopes scopes endSize
+      if scopesName != header then
+        if scopesName == .anonymous then
+          throwUnnecessaryScopeName header
+        else
+          throwScopeNameMismatch header scopes endSize
+  modify fun s => {s with scopes := s.scopes.drop endSize }
+  popScopes endSize
+
+private partial def elabChoiceAux (cmds : Array Syntax) (i : Nat) : CommandElabM Unit :=
+  if h : i < cmds.size then
+    catchInternalId unsupportedSyntaxExceptionId
+      (elabCommand cmds[i])
+      (fun _ => elabChoiceAux cmds (i+1))
+  else
+    throwUnsupportedSyntax
+
+@[builtin_command_elab choice] def elabChoice : CommandElab := fun stx =>
+  elabChoiceAux stx.getArgs 0
+
+@[builtin_command_elab «universe»] def elabUniverse : CommandElab := fun n => do
+  n[1].forArgsM addUnivLevel
+
+@[builtin_command_elab «init_quot»] def elabInitQuot : CommandElab := fun _ => do
+  liftCoreM <| addDecl Declaration.quotDecl
+
+@[builtin_command_elab «export»] def elabExport : CommandElab := fun stx => do
+  let `(export $ns ($ids*)) := stx | throwUnsupportedSyntax
+  let nss ← resolveNamespace ns
+  let currNamespace ← getCurrNamespace
+  if nss == [currNamespace] then throwError "invalid 'export', self export"
+  let mut aliases := #[]
+  for idStx in ids do
+    let id := idStx.getId
+    let declName ← resolveNameUsingNamespaces nss idStx
+    if (← getInfoState).enabled then
+      addConstInfo idStx declName
+    aliases := aliases.push (currNamespace ++ id, declName)
+  modify fun s => { s with env := aliases.foldl (init := s.env) fun env p => addAlias env p.1 p.2 }
+
+@[builtin_command_elab «open»] def elabOpen : CommandElab
+  | `(open $decl:openDecl) => do
+    let openDecls ← elabOpenDecl decl
+    modifyScope fun scope => { scope with openDecls := openDecls }
+  | _ => throwUnsupportedSyntax
+
+open Lean.Parser.Term
+
+private def typelessBinder? : Syntax → Option (Array (TSyntax [`ident, `Lean.Parser.Term.hole]) × BinderInfo)
+  | `(bracketedBinderF|($ids*))     => some (ids, .default)
+  | `(bracketedBinderF|{$ids*})     => some (ids, .implicit)
+  | `(bracketedBinderF|⦃$ids*⦄)     => some (ids, .strictImplicit)
+  | `(bracketedBinderF|[$id:ident]) => some (#[id], .instImplicit)
+  | _                               => none
+
+/--  If `id` is an identifier, return true if `ids` contains `id`. -/
+private def containsId (ids : Array (TSyntax [`ident, ``Parser.Term.hole])) (id : TSyntax [`ident, ``Parser.Term.hole]) : Bool :=
+  id.raw.isIdent && ids.any fun id' => id'.raw.getId == id.raw.getId
+
+/--
+  Auxiliary method for processing binder annotation update commands:
+  `variable (α)`, `variable {α}`, `variable ⦃α⦄`, and `variable [α]`.
+  The argument `binder` is the binder of the `variable` command.
+  The method returns an array containing the "residue", that is, variables that do not correspond to updates.
+  Recall that a `bracketedBinder` can be of the form `(x y)`.
+  ```
+  variable {α β : Type}
+  variable (α γ)
+  ```
+  The second `variable` command updates the binder annotation for `α`, and returns "residue" `γ`.
+-/
+private def replaceBinderAnnotation (binder : TSyntax ``Parser.Term.bracketedBinder) : CommandElabM (Array (TSyntax ``Parser.Term.bracketedBinder)) := do
+  let some (binderIds, binderInfo) := typelessBinder? binder | return #[binder]
+  let varDecls := (← getScope).varDecls
+  let mut varDeclsNew := #[]
+  let mut binderIds := binderIds
+  let mut binderIdsIniSize := binderIds.size
+  let mut modifiedVarDecls := false
+  -- Go through declarations in reverse to respect shadowing
+  for varDecl in varDecls.reverse do
+    let (ids, ty?, binderInfo') ← match varDecl with
+      | `(bracketedBinderF|($ids* $[: $ty?]? $(annot?)?)) =>
+        if annot?.isSome then
+          for binderId in binderIds do
+            if containsId ids binderId then
+              throwErrorAt binderId "cannot update binder annotation of variables with default values/tactics"
+        pure (ids, ty?, .default)
+      | `(bracketedBinderF|{$ids* $[: $ty?]?}) =>
+        pure (ids, ty?, .implicit)
+      | `(bracketedBinderF|⦃$ids* $[: $ty?]?⦄) =>
+        pure (ids, ty?, .strictImplicit)
+      | `(bracketedBinderF|[$id : $ty]) =>
+        pure (#[⟨id⟩], some ty, .instImplicit)
+      | _ =>
+        varDeclsNew := varDeclsNew.push varDecl; continue
+    if binderInfo == binderInfo' then
+      -- no update, ensure we don't have redundant annotations.
+      for binderId in binderIds do
+        if containsId ids binderId then
+          throwErrorAt binderId "redundant binder annotation update"
+      varDeclsNew := varDeclsNew.push varDecl
+    else if binderIds.all fun binderId => !containsId ids binderId then
+      -- `binderIds` and `ids` are disjoint
+      varDeclsNew := varDeclsNew.push varDecl
+    else
+      let mkBinder (id : TSyntax [`ident, ``Parser.Term.hole]) (binderInfo : BinderInfo) : CommandElabM (TSyntax ``Parser.Term.bracketedBinder) :=
+        match binderInfo with
+        | .default => `(bracketedBinderF| ($id $[: $ty?]?))
+        | .implicit => `(bracketedBinderF| {$id $[: $ty?]?})
+        | .strictImplicit => `(bracketedBinderF| {{$id $[: $ty?]?}})
+        | .instImplicit => do
+          let some ty := ty?
+            | throwErrorAt binder "cannot update binder annotation of variable '{id}' to instance implicit:\n\
+                variable was originally declared without an explicit type"
+          `(bracketedBinderF| [$(⟨id⟩) : $ty])
+      for id in ids.reverse do
+        if let some idx := binderIds.findFinIdx? fun binderId => binderId.raw.isIdent && binderId.raw.getId == id.raw.getId then
+          binderIds := binderIds.eraseIdx idx
+          modifiedVarDecls := true
+          let newBinder ← mkBinder id binderInfo
+          if binderInfo.isInstImplicit then
+            -- We elaborate the new binder to make sure it's valid as instance implicit
+            try
+              runTermElabM fun _ => Term.withSynthesize <| Term.withAutoBoundImplicit <|
+                Term.elabBinder newBinder fun _ => pure ()
+            catch e =>
+              throwErrorAt binder m!"cannot update binder annotation of variable '{id}' to instance implicit:\n\
+                {e.toMessageData}"
+          varDeclsNew := varDeclsNew.push (← mkBinder id binderInfo)
+        else
+          varDeclsNew := varDeclsNew.push (← mkBinder id binderInfo')
+  if modifiedVarDecls then
+    modifyScope fun scope => { scope with varDecls := varDeclsNew.reverse }
+  if binderIds.size != binderIdsIniSize then
+    binderIds.mapM fun binderId =>
+      match binderInfo with
+        | .default => `(bracketedBinderF| ($binderId))
+        | .implicit => `(bracketedBinderF| {$binderId})
+        | .strictImplicit => `(bracketedBinderF| {{$binderId}})
+        | .instImplicit => throwUnsupportedSyntax
+  else
+    return #[binder]
+
+@[builtin_command_elab «variable»] def elabVariable : CommandElab
+  | `(variable%$tk $binders*) => do
+    let binders ← binders.flatMapM replaceBinderAnnotation
+    -- Try to elaborate `binders` for sanity checking
+    runTermElabM fun _ => Term.withSynthesize <| Term.withAutoBoundImplicit <|
+      Term.elabBinders binders fun xs => do
+        -- Determine the set of auto-implicits for this variable command and add an inlay hint
+        -- for them. We will only actually add the auto-implicits to a type when the variables
+        -- declared here are used in some other declaration, but this is nonetheless the right
+        -- place to display the inlay hint.
+        let _ ← Term.addAutoBoundImplicits xs (tk.getTailPos? (canonicalOnly := true))
+    -- Remark: if we want to produce error messages when variables shadow existing ones, here is the place to do it.
+    for binder in binders do
+      let varUIds ← (← getBracketedBinderIds binder) |>.mapM (withFreshMacroScope ∘ MonadQuotation.addMacroScope)
+      modifyScope fun scope => { scope with varDecls := scope.varDecls.push binder, varUIds := scope.varUIds ++ varUIds }
+  | _ => throwUnsupportedSyntax
+
+open Meta
+
+def elabCheckCore (ignoreStuckTC : Bool) : CommandElab
+  | `(#check%$tk $term) => withoutModifyingEnv <| runTermElabM fun _ => Term.withDeclName `_check do
+    -- show signature for `#check id`/`#check @id`
+    if let `($id:ident) := term then
+      try
+        for c in (← realizeGlobalConstWithInfos term) do
+          addCompletionInfo <| .id term id.getId (danglingDot := false) {} none
+          logInfoAt tk <| .signature c
+          return
+      catch _ => pure ()  -- identifier might not be a constant but constant + projection
+    let e ← Term.elabTerm term none
+    Term.synthesizeSyntheticMVarsNoPostponing (ignoreStuckTC := ignoreStuckTC)
+    -- Users might be testing out buggy elaborators. Let's typecheck before proceeding:
+    withRef tk <| Meta.check e
+    let e ← Term.levelMVarToParam (← instantiateMVars e)
+    if e.isSyntheticSorry then
+      return
+    let type ← inferType e
+    logInfoAt tk m!"{e} : {type}"
+  | _ => throwUnsupportedSyntax
+
+@[builtin_command_elab Lean.Parser.Command.check] def elabCheck : CommandElab := elabCheckCore (ignoreStuckTC := true)
+
+@[builtin_command_elab Lean.reduceCmd] def elabReduce : CommandElab
+  | `(#reduce%$tk $term) => go tk term
+  | `(#reduce%$tk (proofs := true) $term) => go tk term (skipProofs := false)
+  | `(#reduce%$tk (types := true) $term) => go tk term (skipTypes := false)
+  | `(#reduce%$tk (proofs := true) (types := true) $term) => go tk term (skipProofs := false) (skipTypes := false)
+  | _ => throwUnsupportedSyntax
+where
+  go (tk : Syntax) (term : Syntax) (skipProofs := true) (skipTypes := true) : CommandElabM Unit :=
+    withoutModifyingEnv <| runTermElabM fun _ => Term.withDeclName `_reduce do
+      let e ← Term.elabTerm term none
+      Term.synthesizeSyntheticMVarsNoPostponing
+      -- Users might be testing out buggy elaborators. Let's typecheck before proceeding:
+      withRef tk <| Meta.check e
+      let e ← Term.levelMVarToParam (← instantiateMVars e)
+      -- TODO: add options or notation for setting the following parameters
+      withTheReader Core.Context (fun ctx => { ctx with options := ctx.options.setBool `smartUnfolding false }) do
+        let e ← withTransparency (mode := TransparencyMode.all) <| reduce e (skipProofs := skipProofs) (skipTypes := skipTypes)
+        logInfoAt tk e
+
+def hasNoErrorMessages : CommandElabM Bool := do
+  return !(← get).messages.hasErrors
+
+def failIfSucceeds (x : CommandElabM Unit) : CommandElabM Unit := do
+  let resetMessages : CommandElabM MessageLog := do
+    let s ← get
+    let messages := s.messages;
+    modify fun s => { s with messages := {} };
+    pure messages
+  let restoreMessages (prevMessages : MessageLog) : CommandElabM Unit := do
+    modify fun s => { s with messages := prevMessages ++ s.messages.errorsToInfos }
+  let prevMessages ← resetMessages
+  let succeeded ← try
+    x
+    hasNoErrorMessages
+  catch
+    | ex@(Exception.error _ _) => do logException ex; pure false
+    | Exception.internal id _  => do logError (← id.getName); pure false
+  finally
+    restoreMessages prevMessages
+  if succeeded then
+    throwError "unexpected success"
+
+@[builtin_command_elab «check_failure»] def elabCheckFailure : CommandElab
+  | `(#check_failure $term) => do
+    failIfSucceeds <| elabCheckCore (ignoreStuckTC := false) (← `(#check $term))
+  | _ => throwUnsupportedSyntax
+
+@[builtin_command_elab «synth»] def elabSynth : CommandElab := fun stx => do
+  let term := stx[1]
+  withoutModifyingEnv <| runTermElabM fun _ => Term.withDeclName `_synth_cmd do
+    let inst ← Term.elabTerm term none
+    Term.synthesizeSyntheticMVarsNoPostponing
+    let inst ← instantiateMVars inst
+    let val  ← synthInstance inst
+    logInfo val
+    pure ()
+
+@[builtin_command_elab «set_option»] def elabSetOption : CommandElab := fun stx => do
+  let options ← Elab.elabSetOption stx[1] stx[3]
+  modify fun s => { s with maxRecDepth := maxRecDepth.get options }
+  modifyScope fun scope => { scope with opts := options }
+
+@[builtin_macro Lean.Parser.Command.«in»] def expandInCmd : Macro
+  | `($cmd₁ in%$tk $cmd₂) =>
+    -- Limit ref variability for incrementality; see Note [Incremental Macros]
+    withRef tk `(section $cmd₁:command $cmd₂ end)
+  | _                 => Macro.throwUnsupported
+
+@[builtin_command_elab Parser.Command.addDocString] def elabAddDeclDoc : CommandElab := fun stx => do
+  match stx with
+  | `($doc:docComment add_decl_doc $id) =>
+    let declName ← liftCoreM <| realizeGlobalConstNoOverloadWithInfo id
+    unless ((← getEnv).getModuleIdxFor? declName).isNone do
+      throwError "invalid 'add_decl_doc', declaration is in an imported module"
+    if let .none ← findDeclarationRangesCore? declName then
+      -- this is only relevant for declarations added without a declaration range
+      -- in particular `Quot.mk` et al which are added by `init_quot`
+      addDeclarationRangesFromSyntax declName stx id
+    addDocString declName doc
+  | _ => throwUnsupportedSyntax
+
+@[builtin_command_elab Lean.Parser.Command.include] def elabInclude : CommandElab
+  | `(Lean.Parser.Command.include| include $ids*) => do
+    let sc ← getScope
+    let vars ← sc.varDecls.flatMapM getBracketedBinderIds
+    let mut uids := #[]
+    for id in ids do
+      if let some idx := vars.findIdx? (· == id.getId) then
+        uids := uids.push sc.varUIds[idx]!
+      else
+        throwError "invalid 'include', variable '{id}' has not been declared in the current scope"
+    modifyScope fun sc => { sc with
+      includedVars := sc.includedVars ++ uids.toList
+      omittedVars := sc.omittedVars.filter (!uids.contains ·) }
+  | _ => throwUnsupportedSyntax
+
+@[builtin_command_elab Lean.Parser.Command.omit] def elabOmit : CommandElab
+  | `(Lean.Parser.Command.omit| omit $omits*) => do
+    -- TODO: this really shouldn't have to re-elaborate section vars... they should come
+    -- pre-elaborated
+    let omittedVars ← runTermElabM fun vars => do
+      Term.synthesizeSyntheticMVarsNoPostponing
+      -- We don't want to store messages produced when elaborating `(getVarDecls s)` because they have already been saved when we elaborated the `variable`(s) command.
+      -- So, we use `Core.resetMessageLog`.
+      Core.resetMessageLog
+      -- resolve each omit to variable user name or type pattern
+      let elaboratedOmits : Array (Sum Name Expr) ← omits.mapM fun
+        | `(ident| $id:ident) => pure <| Sum.inl id.getId
+        | `(Lean.Parser.Term.instBinder| [$id : $_]) => pure <| Sum.inl id.getId
+        | `(Lean.Parser.Term.instBinder| [$ty]) =>
+          Sum.inr <$> Term.withoutErrToSorry (Term.elabTermAndSynthesize ty none)
+        | _ => throwUnsupportedSyntax
+      -- check that each omit is actually used in the end
+      let mut omitsUsed := omits.map fun _ => false
+      let mut omittedVars := #[]
+      let mut revSectionFVars : Std.HashMap FVarId Name := {}
+      for (uid, var) in (← read).sectionFVars do
+        revSectionFVars := revSectionFVars.insert var.fvarId! uid
+      for var in vars do
+        let ldecl ← var.fvarId!.getDecl
+        if let some idx := (← elaboratedOmits.findIdxM? fun
+            | .inl id => return ldecl.userName == id
+            | .inr ty => do
+              let mctx ← getMCtx
+              isDefEq ty ldecl.type <* setMCtx mctx) then
+          if let some uid := revSectionFVars[var.fvarId!]? then
+            omittedVars := omittedVars.push uid
+            omitsUsed := omitsUsed.set! idx true
+          else
+            throwError "invalid 'omit', '{ldecl.userName}' has not been declared in the current scope"
+      for o in omits, used in omitsUsed do
+        unless used do
+          throwError "'{o}' did not match any variables in the current scope"
+      return omittedVars
+    modifyScope fun sc => { sc with
+      omittedVars := sc.omittedVars ++ omittedVars.toList
+      includedVars := sc.includedVars.filter (!omittedVars.contains ·) }
+  | _ => throwUnsupportedSyntax
+
+@[builtin_command_elab version] def elabVersion : CommandElab := fun _ => do
+  let mut target := System.Platform.target
+  if target.isEmpty then target := "unknown"
+  -- Only one should be set, but good to know if multiple are set in error.
+  let platforms :=
+    (if System.Platform.isWindows then [" Windows"] else [])
+    ++ (if System.Platform.isOSX then [" macOS"] else [])
+    ++ (if System.Platform.isEmscripten then [" Emscripten"] else [])
+  logInfo m!"Lean {Lean.versionString}\nTarget: {target}{String.join platforms}"
+
+@[builtin_command_elab Parser.Command.exit] def elabExit : CommandElab := fun _ =>
+  logWarning "using 'exit' to interrupt Lean"
+
+@[builtin_command_elab Parser.Command.import] def elabImport : CommandElab := fun _ =>
+  throwError "invalid 'import' command, it must be used in the beginning of the file"
+
+@[builtin_command_elab Parser.Command.eoi] def elabEoi : CommandElab := fun _ =>
+  return
+
+@[builtin_command_elab Parser.Command.where] def elabWhere : CommandElab := fun _ => do
+  let scope ← getScope
+  let mut msg : Array MessageData := #[]
+  -- Noncomputable
+  if scope.isNoncomputable then
+    msg := msg.push <| ← `(Parser.Command.section| noncomputable section)
+  -- Namespace
+  if !scope.currNamespace.isAnonymous then
+    msg := msg.push <| ← `(command| namespace $(mkIdent scope.currNamespace))
+  -- Open namespaces
+  if let some openMsg ← describeOpenDecls scope.openDecls.reverse then
+    msg := msg.push openMsg
+  -- Universe levels
+  if !scope.levelNames.isEmpty then
+    let levels := scope.levelNames.reverse.map mkIdent
+    msg := msg.push <| ← `(command| universe $levels.toArray*)
+  -- Variables
+  if !scope.varDecls.isEmpty then
+    let varDecls : Array (TSyntax `Lean.Parser.Term.bracketedBinder) := scope.varDecls.map (⟨·.raw.unsetTrailing⟩)
+    msg := msg.push <| ← `(command| variable $varDecls*)
+  -- Included variables
+  if !scope.includedVars.isEmpty then
+    msg := msg.push <| ← `(command| include $(scope.includedVars.toArray.map (mkIdent ·.eraseMacroScopes))*)
+  -- Options
+  if let some optionsMsg ← describeOptions scope.opts then
+    msg := msg.push optionsMsg
+  if msg.isEmpty then
+    logInfo m!"-- In root namespace with initial scope"
+  else
+    logInfo <| MessageData.joinSep msg.toList "\n\n"
+where
+  /--
+  'Delaborate' open declarations.
+  Current limitations:
+  - does not check whether or not successive namespaces need `_root_`
+  - does not combine commands with `renaming` clauses into a single command
+  -/
+  describeOpenDecls (ds : List OpenDecl) : CommandElabM (Option MessageData) := do
+    let mut lines : Array MessageData := #[]
+    let mut simple : Array Name := #[]
+    let flush (lines : Array MessageData) (simple : Array Name) : CommandElabM (Array MessageData × Array Name) := do
+      if simple.isEmpty then
+        return (lines, simple)
+      else
+        return (lines.push <| ← `(command| open $(simple.map mkIdent)*), #[])
+    for d in ds do
+      match d with
+      | .explicit id decl =>
+        (lines, simple) ← flush lines simple
+        let ns := decl.getPrefix
+        let «from» := Name.mkSimple decl.getString!
+        lines := lines.push <| ← `(command| open $(mkIdent ns) renaming $(mkIdent «from») → $(mkIdent id))
+      | .simple ns ex =>
+        if ex == [] then
+          simple := simple.push ns
+        else
+          (lines, simple) ← flush lines simple
+          lines := lines.push <| ← `(command| open $(mkIdent ns) hiding $[$(ex.toArray.map mkIdent)]*)
+    (lines, _) ← flush lines simple
+    return if lines.isEmpty then none else MessageData.joinSep lines.toList "\n"
+
+  describeOptions (opts : Options) : CommandElabM (Option MessageData) := do
+    let mut lines : Array MessageData := #[]
+    let decls ← getOptionDecls
+    for (name, val) in opts do
+      -- `#guard_msgs` sets this option internally, we don't want it to end up in its output
+      if name == `Elab.async then
+        continue
+      let (isSet, isUnknown) :=
+        match decls.find? name with
+        | some decl => (decl.defValue != val, false)
+        | none      => (true, true)
+      if isSet then
+        let cmd : TSyntax `command ←
+          match val with
+          | .ofBool true  => `(set_option $(mkIdent name) true)
+          | .ofBool false => `(set_option $(mkIdent name) false)
+          | .ofString str => `(set_option $(mkIdent name) $(Syntax.mkStrLit str))
+          | .ofNat n      => `(set_option $(mkIdent name) $(Syntax.mkNatLit n))
+          | _             => `(set_option $(mkIdent name) 0 /- unrepresentable value -/)
+        if isUnknown then
+          lines := lines.push m!"-- {cmd} -- unknown option"
+        else
+          lines := lines.push cmd
+    return if lines.isEmpty then none else MessageData.joinSep lines.toList "\n"
+
+@[builtin_command_elab Parser.Command.withExporting] def elabWithExporting : CommandElab
+  | `(Parser.Command.withExporting| #with_exporting $cmd) =>
+    withExporting do
+      elabCommand cmd
+  | _ => throwUnsupportedSyntax
+
+@[builtin_command_elab Parser.Command.dumpAsyncEnvState] def elabDumpAsyncEnvState : CommandElab :=
+  fun _ => do
+    let env ← getEnv
+    IO.eprintln (← env.dbgFormatAsyncState)
+
+end Lean.Elab.Command

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/BuiltinEvalCommand.lean

@@ -0,0 +1,277 @@
+/-
+Copyright (c) 2024 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Kyle Miller
+-/
+prelude
+import Lean.Util.CollectAxioms
+import Lean.Elab.Deriving.Basic
+import Lean.Elab.MutualDef
+
+/-!
+# Implementation of `#eval` command
+-/
+
+namespace Lean.Elab.Command
+open Meta
+
+register_builtin_option eval.pp : Bool := {
+  defValue := true
+  descr    := "('#eval' command) enables using 'ToExpr' instances to pretty print the result, \
+               otherwise uses 'Repr' or 'ToString' instances"
+}
+
+register_builtin_option eval.type : Bool := {
+  defValue := false -- TODO: set to 'true'
+  descr    := "('#eval' command) enables pretty printing the type of the result"
+}
+
+register_builtin_option eval.derive.repr : Bool := {
+  defValue := true
+  descr    := "('#eval' command) enables auto-deriving 'Repr' instances as a fallback"
+}
+
+builtin_initialize
+  registerTraceClass `Elab.eval
+
+/--
+Elaborates the term, ensuring the result has no expression metavariables.
+If there would be unsolved-for metavariables, tries hinting that the resulting type
+is a monadic value with the `CommandElabM`, `TermElabM`, or `IO` monads.
+Throws errors if the term is a proof or a type, but lifts props to `Bool` using `mkDecide`.
+-/
+private def elabTermForEval (term : Syntax) (expectedType? : Option Expr) : TermElabM Expr := do
+  let ty ← expectedType?.getDM mkFreshTypeMVar
+  let e ← Term.elabTermEnsuringType term ty
+  synthesizeWithHinting ty
+  let e ← instantiateMVars e
+  if (← Term.logUnassignedUsingErrorInfos (← getMVars e)) then throwAbortTerm
+  if ← isProof e then
+    throwError m!"cannot evaluate, proofs are not computationally relevant"
+  let e ← if (← isProp e) then mkDecide e else pure e
+  if ← isType e then
+    throwError m!"cannot evaluate, types are not computationally relevant"
+  trace[Elab.eval] "elaborated term:{indentExpr e}"
+  return e
+where
+  /-- Try different strategies to make `Term.synthesizeSyntheticMVarsNoPostponing` succeed. -/
+  synthesizeWithHinting (ty : Expr) : TermElabM Unit := do
+    Term.synthesizeSyntheticMVarsUsingDefault
+    let s ← saveState
+    try
+      Term.synthesizeSyntheticMVarsNoPostponing
+    catch ex =>
+      let exS ← saveState
+      -- Try hinting that `ty` is a monad application.
+      for m in #[``CommandElabM, ``TermElabM, ``IO] do
+        s.restore true
+        try
+          if ← isDefEq ty (← mkFreshMonadApp m) then
+            Term.synthesizeSyntheticMVarsNoPostponing
+            return
+        catch _ => pure ()
+      -- None of the hints worked, so throw the original error.
+      exS.restore true
+      throw ex
+  mkFreshMonadApp (n : Name) : MetaM Expr := do
+    let m ← mkConstWithFreshMVarLevels n
+    let (args, _, _) ← forallMetaBoundedTelescope (← inferType m) 1
+    return mkAppN m args
+
+private def addAndCompileExprForEval (declName : Name) (value : Expr) (allowSorry := false) : TermElabM Unit := do
+  -- Use the `elabMutualDef` machinery to be able to support `let rec`.
+  -- Hack: since we are using the `TermElabM` version, we can insert the `value` as a metavariable via `exprToSyntax`.
+  -- An alternative design would be to make `elabTermForEval` into a term elaborator and elaborate the command all at once
+  -- with `unsafe def _eval := term_for_eval% $t`, which we did try, but unwanted error messages
+  -- such as "failed to infer definition type" can surface.
+  let defView := mkDefViewOfDef { isUnsafe := true }
+    (← `(Parser.Command.definition|
+          def $(mkIdent <| `_root_ ++ declName) := $(← Term.exprToSyntax value)))
+  Term.elabMutualDef #[] { header := "" } #[defView]
+  unless allowSorry do
+    let axioms ← collectAxioms declName
+    if axioms.contains ``sorryAx then
+      throwError "\
+        aborting evaluation since the expression depends on the 'sorry' axiom, \
+        which can lead to runtime instability and crashes.\n\n\
+        To attempt to evaluate anyway despite the risks, use the '#eval!' command."
+
+/--
+Try to make a `@projFn ty inst e` application, even if it takes unfolding the type `ty` of `e` to synthesize the instance `inst`.
+-/
+private partial def mkDeltaInstProj (inst projFn : Name) (e : Expr) (ty? : Option Expr := none) (tryReduce : Bool := true) : MetaM Expr := do
+  let ty ← ty?.getDM (inferType e)
+  if let .some inst ← trySynthInstance (← mkAppM inst #[ty]) then
+    mkAppOptM projFn #[ty, inst, e]
+  else
+    let ty ← whnfCore ty
+    let some ty ← unfoldDefinition? ty
+      | guard tryReduce
+        -- Reducing the type is a strategy `#eval` used before the refactor of #5627.
+        -- The test lean/run/hlistOverload.lean depends on it, so we preserve the behavior.
+        let ty ← reduce (skipTypes := false) ty
+        mkDeltaInstProj inst projFn e ty (tryReduce := false)
+    mkDeltaInstProj inst projFn e ty tryReduce
+
+/-- Try to make a `toString e` application, even if it takes unfolding the type of `e` to find a `ToString` instance. -/
+private def mkToString (e : Expr) (ty? : Option Expr := none) : MetaM Expr := do
+  mkDeltaInstProj ``ToString ``toString e ty?
+
+/-- Try to make a `repr e` application, even if it takes unfolding the type of `e` to find a `Repr` instance. -/
+private def mkRepr (e : Expr) (ty? : Option Expr := none) : MetaM Expr := do
+  mkDeltaInstProj ``Repr ``repr e ty?
+
+/-- Try to make a `toExpr e` application, even if it takes unfolding the type of `e` to find a `ToExpr` instance. -/
+private def mkToExpr (e : Expr) (ty? : Option Expr := none) : MetaM Expr := do
+  mkDeltaInstProj ``ToExpr ``toExpr e ty?
+
+/--
+Returns a representation of `e` using `Format`, or else fails.
+If the `eval.derive.repr` option is true, then tries automatically deriving a `Repr` instance first.
+Currently auto-derivation does not attempt to derive recursively.
+-/
+private def mkFormat (e : Expr) : MetaM Expr := do
+  mkRepr e <|> (do mkAppM ``Std.Format.text #[← mkToString e])
+  <|> do
+    if eval.derive.repr.get (← getOptions) then
+      if let .const name _ := (← whnf (← inferType e)).getAppFn then
+        try
+          trace[Elab.eval] "Attempting to derive a 'Repr' instance for '{.ofConstName name}'"
+          liftCommandElabM do applyDerivingHandlers ``Repr #[name]
+          resetSynthInstanceCache
+          return ← mkRepr e
+        catch ex =>
+          trace[Elab.eval] "Failed to use derived 'Repr' instance. Exception: {ex.toMessageData}"
+    throwError m!"could not synthesize a 'Repr' or 'ToString' instance for type{indentExpr (← inferType e)}"
+
+/--
+Returns a representation of `e` using `MessageData`, or else fails.
+Tries `mkFormat` if a `ToExpr` instance can't be synthesized.
+-/
+private def mkMessageData (e : Expr) : MetaM Expr := do
+  (do guard <| eval.pp.get (← getOptions); mkAppM ``MessageData.ofExpr #[← mkToExpr e])
+  <|> (return mkApp (mkConst ``MessageData.ofFormat) (← mkFormat e))
+  <|> do throwError m!"could not synthesize a 'ToExpr', 'Repr', or 'ToString' instance for type{indentExpr (← inferType e)}"
+
+private structure EvalAction where
+  eval : CommandElabM MessageData
+  /-- Whether to print the result of evaluation.
+  If `some`, the expression is what type to use for the type ascription when `pp.type` is true. -/
+  printVal : Option Expr
+
+unsafe def elabEvalCoreUnsafe (bang : Bool) (tk term : Syntax) (expectedType? : Option Expr) : CommandElabM Unit := withRef tk do
+  let declName := `_eval
+  -- `t` is either `MessageData` or `Format`, and `mkT` is for synthesizing an expression that yields a `t`.
+  -- The `toMessageData` function adapts `t` to `MessageData`.
+  let mkAct {t : Type} [Inhabited t] (toMessageData : t → MessageData) (mkT : Expr → MetaM Expr) (e : Expr) : TermElabM EvalAction := do
+    -- Create a monadic action given the name of the monad `mc`, the monad `m` itself,
+    -- and an expression `e` to evaluate in this monad.
+    -- A trick here is that `mkMAct?` makes use of `MonadEval` instances are currently available in this stage,
+    -- and we do not need them to be available in the target environment.
+    let mkMAct? (mc : Name) (m : Type → Type) [Monad m] [MonadEvalT m CommandElabM] (e : Expr) : TermElabM (Option EvalAction) := do
+      let some e ← observing? (mkAppOptM ``MonadEvalT.monadEval #[none, mkConst mc, none, none, e])
+        | return none
+      let eType := e.appFn!.appArg!
+      if ← isDefEq eType (mkConst ``Unit) then
+        addAndCompileExprForEval declName e (allowSorry := bang)
+        let mf : m Unit ← evalConst (m Unit) declName
+        return some { eval := do MonadEvalT.monadEval mf; pure "", printVal := none }
+      else
+        let rf ← withLocalDeclD `x eType fun x => do mkLambdaFVars #[x] (← mkT x)
+        let r ← mkAppM ``Functor.map #[rf, e]
+        addAndCompileExprForEval declName r (allowSorry := bang)
+        let mf : m t ← evalConst (m t) declName
+        return some { eval := toMessageData <$> MonadEvalT.monadEval mf, printVal := some eType }
+    if let some act ← mkMAct? ``CommandElabM CommandElabM e
+                    -- Fallbacks in case we are in the Lean package but don't have `CommandElabM` yet
+                    <||> mkMAct? ``TermElabM TermElabM e <||> mkMAct? ``MetaM MetaM e <||> mkMAct? ``CoreM CoreM e
+                    -- Fallback in case nothing is imported
+                    <||> mkMAct? ``IO IO e then
+      return act
+    else
+      -- Otherwise, assume this is a pure value.
+      -- There is no need to adapt pure values to `CommandElabM`.
+      -- This enables `#eval` to work on pure values even when `CommandElabM` is not available.
+      let r ← try mkT e catch ex => do
+        -- Diagnose whether the value is monadic for a representable value, since it's better to mention `MonadEval` in that case.
+        try
+          let some (m, ty) ← isTypeApp? (← inferType e) | failure
+          guard <| (← isMonad? m).isSome
+          -- Verify that there is a way to form some representation:
+          discard <| withLocalDeclD `x ty fun x => mkT x
+        catch _ =>
+          throw ex
+        throwError m!"unable to synthesize '{.ofConstName ``MonadEval}' instance \
+          to adapt{indentExpr (← inferType e)}\n\
+          to '{.ofConstName ``IO}' or '{.ofConstName ``CommandElabM}'."
+      addAndCompileExprForEval declName r (allowSorry := bang)
+      -- `evalConst` may emit IO, but this is collected by `withIsolatedStreams` below.
+      let r ← toMessageData <$> evalConst t declName (checkMeta := !Elab.inServer.get (← getOptions))
+      return { eval := pure r, printVal := some (← inferType e) }
+  let (output, exOrRes) ← IO.FS.withIsolatedStreams (isolateStderr := Core.stderrAsMessages.get (← getOptions)) do
+    try
+      -- Generate an action without executing it. We use `withoutModifyingEnv` to ensure
+      -- we don't pollute the environment with auxiliary declarations.
+      let act : EvalAction ← liftTermElabM do Term.withDeclName declName do withoutModifyingEnv do
+        let e ← elabTermForEval term expectedType?
+        -- If there is an elaboration error, don't evaluate!
+        if e.hasSyntheticSorry then throwAbortTerm
+        -- We want `#eval` to work even in the core library, so if `ofFormat` isn't available,
+        -- we fall back on a `Format`-based approach.
+        if (← getEnv).contains ``Lean.MessageData.ofFormat then
+          mkAct id (mkMessageData ·) e
+        else
+          mkAct Lean.MessageData.ofFormat (mkFormat ·) e
+      let res ← act.eval
+      return Sum.inr (res, act.printVal)
+    catch ex =>
+      return Sum.inl ex
+  if !output.isEmpty then logInfoAt tk output
+  match exOrRes with
+  | .inl ex => logException ex
+  | .inr (_, none) => pure ()
+  | .inr (res, some type) =>
+    if eval.type.get (← getOptions) then
+      logInfo m!"{res} : {type}"
+    else
+      logInfo res
+
+@[implemented_by elabEvalCoreUnsafe]
+opaque elabEvalCore (bang : Bool) (tk term : Syntax) (expectedType? : Option Expr) : CommandElabM Unit
+
+@[builtin_command_elab «eval»]
+def elabEval : CommandElab
+  | `(#eval%$tk $term) => elabEvalCore false tk term none
+  | _ => throwUnsupportedSyntax
+
+@[builtin_command_elab evalBang]
+def elabEvalBang : CommandElab
+  | `(#eval!%$tk $term) => elabEvalCore true tk term none
+  | _ => throwUnsupportedSyntax
+
+@[builtin_command_elab runCmd]
+def elabRunCmd : CommandElab
+  | `(run_cmd%$tk $elems:doSeq) => do
+    unless (← getEnv).contains ``CommandElabM do
+      throwError "to use this command, include `import Lean.Elab.Command`"
+    elabEvalCore false tk (← `(discard do $elems)) (mkApp (mkConst ``CommandElabM) (mkConst ``Unit))
+  | _ => throwUnsupportedSyntax
+
+@[builtin_command_elab runElab]
+def elabRunElab : CommandElab
+  | `(run_elab%$tk $elems:doSeq) => do
+    unless (← getEnv).contains ``TermElabM do
+      throwError "to use this command, include `import Lean.Elab.Term`"
+    elabEvalCore false tk (← `(discard do $elems)) (mkApp (mkConst ``TermElabM) (mkConst ``Unit))
+  | _ => throwUnsupportedSyntax
+
+@[builtin_command_elab runMeta]
+def elabRunMeta : CommandElab := fun stx =>
+  match stx with
+  | `(run_meta%$tk $elems:doSeq) => do
+    unless (← getEnv).contains ``MetaM do
+      throwError "to use this command, include `import Lean.Meta.Basic`"
+    elabEvalCore false tk (← `(discard do $elems)) (mkApp (mkConst ``MetaM) (mkConst ``Unit))
+  | _ => throwUnsupportedSyntax
+
+end Lean.Elab.Command

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/BuiltinNotation.lean

@@ -0,0 +1,534 @@
+/-
+Copyright (c) 2019 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura, Gabriel Ebner
+-/
+prelude
+import Lean.Compiler.BorrowedAnnotation
+import Lean.Meta.KAbstract
+import Lean.Meta.Closure
+import Lean.Meta.MatchUtil
+import Lean.Compiler.ImplementedByAttr
+import Lean.Elab.SyntheticMVars
+import Lean.Elab.Eval
+import Lean.Elab.Binders
+
+namespace Lean.Elab.Term
+open Meta
+
+@[builtin_term_elab coeNotation] def elabCoe : TermElab := fun stx expectedType? => do
+  let stx := stx[1]
+  tryPostponeIfNoneOrMVar expectedType?
+  let e ← elabTerm stx none
+  if expectedType?.isNone then
+    throwError "invalid coercion notation, expected type is not known"
+  ensureHasType expectedType? e
+
+@[builtin_term_elab coeFunNotation] def elabCoeFunNotation : TermElab := fun stx _ => do
+  let x ← elabTerm stx[1] none
+  if let some ty ← coerceToFunction? x then
+    return ty
+  else
+    throwError "cannot coerce to function{indentExpr x}"
+
+@[builtin_term_elab coeSortNotation] def elabCoeSortNotation : TermElab := fun stx _ => do
+  let x ← elabTerm stx[1] none
+  if let some ty ← coerceToSort? x then
+    return ty
+  else
+    throwError "cannot coerce to sort{indentExpr x}"
+
+@[builtin_term_elab anonymousCtor] def elabAnonymousCtor : TermElab := fun stx expectedType? =>
+  match stx with
+  | `(⟨$args,*⟩) => do
+    tryPostponeIfNoneOrMVar expectedType?
+    match expectedType? with
+    | some expectedType =>
+      let expectedType ← whnf expectedType
+      matchConstInduct expectedType.getAppFn
+        (fun _ => throwError "invalid constructor ⟨...⟩, expected type must be an inductive type {indentExpr expectedType}")
+        (fun ival _ => do
+          match ival.ctors with
+          | [ctor] =>
+            if isPrivateNameFromImportedModule (← getEnv) ctor then
+              throwError "invalid ⟨...⟩ notation, constructor for `{ival.name}` is marked as private"
+            let cinfo ← getConstInfoCtor ctor
+            let numExplicitFields ← forallTelescopeReducing cinfo.type fun xs _ => do
+              let mut n := 0
+              for h : i in [cinfo.numParams:xs.size] do
+                if (← getFVarLocalDecl xs[i]).binderInfo.isExplicit then
+                  n := n + 1
+              return n
+            let args := args.getElems
+            if args.size < numExplicitFields then
+              throwError "invalid constructor ⟨...⟩, insufficient number of arguments, constructs '{ctor}' has #{numExplicitFields} explicit fields, but only #{args.size} provided"
+            let newStx ← if args.size == numExplicitFields then
+              `($(mkCIdentFrom stx ctor (canonical := true)) $(args)*)
+            else if numExplicitFields == 0 then
+              throwError "invalid constructor ⟨...⟩, insufficient number of arguments, constructs '{ctor}' does not have explicit fields, but #{args.size} provided"
+            else
+              let extra := args[(numExplicitFields-1)...args.size]
+              let newLast ← `(⟨$[$extra],*⟩)
+              let newArgs := args[*...(numExplicitFields-1)].toArray.push newLast
+              `($(mkCIdentFrom stx ctor (canonical := true)) $(newArgs)*)
+            withMacroExpansion stx newStx $ elabTerm newStx expectedType?
+          | _ => throwError "invalid constructor ⟨...⟩, expected type must be an inductive type with only one constructor {indentExpr expectedType}")
+    | none => throwError "invalid constructor ⟨...⟩, expected type must be known"
+  | _ => throwUnsupportedSyntax
+
+@[builtin_term_elab borrowed] def elabBorrowed : TermElab := fun stx expectedType? =>
+  match stx with
+  | `(@& $e) => return markBorrowed (← elabTerm e expectedType?)
+  | _ => throwUnsupportedSyntax
+
+@[builtin_macro Lean.Parser.Term.show] def expandShow : Macro := fun stx =>
+  match stx with
+  | `(show $type by%$b $tac) => `(show $type from by%$b $tac)
+  | _                        => Macro.throwUnsupported
+
+@[builtin_term_elab Lean.Parser.Term.show] def elabShow : TermElab := fun stx expectedType? => do
+  match stx with
+  | `(show $type from $val)  =>
+    /-
+    We first elaborate the type and try to unify it with the expected type if available.
+    Note that, we should not throw an error if the types do not unify. Recall that we have coercions and
+    the following is supported in Lean 3 and 4.
+    ```
+    example : Int :=
+      show Nat from 0
+    ```
+    -/
+    let type ← withSynthesize (postpone := .yes) do
+      let type ← elabType type
+      if let some expectedType := expectedType? then
+        -- Recall that a similar approach is used when elaborating applications
+        discard <| isDefEq expectedType type
+      return type
+    /-
+    Recall that we do not use the same approach used to elaborate type ascriptions.
+    For the `($val : $type)` notation, we just elaborate `val` using `type` and
+    ensure it has type `type`. This approach only ensure the type resulting expression
+    is definitionally equal to `type`. For the `show` notation we use `have` to ensure the type
+    of the resulting expression is *structurally equal* `type`. Structural equality is important,
+    for example, if the resulting expression is a `simp`/`rw` parameter. Here is an example:
+    ```
+    example (x : Nat) : (x + 0) + y = x + y := by
+      rw [show x + 0 = x from rfl]
+    ```
+    -/
+    let thisId := mkIdentFrom stx `this
+    let valNew ← `(have $thisId:ident : $(← exprToSyntax type) := $val; $thisId)
+    elabTerm valNew expectedType?
+  | _ => throwUnsupportedSyntax
+
+@[builtin_macro Lean.Parser.Term.suffices] def expandSuffices : Macro
+  | `(suffices%$tk $x:ident      : $type from $val; $body)   => `(have%$tk $x:ident : $type := $body; $val)
+  | `(suffices%$tk _%$x          : $type from $val; $body)   => `(have%$tk _%$x : $type := $body; $val)
+  | `(suffices%$tk $hy:hygieneInfo $type from $val; $body)   => `(have%$tk $hy:hygieneInfo : $type := $body; $val)
+  | `(suffices%$tk $x:ident      : $type $b:byTactic'; $body) =>
+    -- Pass on `SourceInfo` of `b` to `have`. This is necessary to display the goal state in the
+    -- trailing whitespace of `by` and sound since `byTactic` and `byTactic'` are identical.
+    let b := ⟨b.raw.setKind `Lean.Parser.Term.byTactic⟩
+    `(have%$tk $x:ident : $type := $body; $b:byTactic)
+  | `(suffices%$tk _%$x          : $type $b:byTactic'; $body) =>
+    let b := ⟨b.raw.setKind `Lean.Parser.Term.byTactic⟩
+    `(have%$tk _%$x : $type := $body; $b:byTactic)
+  | `(suffices%$tk $hy:hygieneInfo $type $b:byTactic'; $body) =>
+    let b := ⟨b.raw.setKind `Lean.Parser.Term.byTactic⟩
+    `(have%$tk $hy:hygieneInfo : $type := $body; $b:byTactic)
+  | _ => Macro.throwUnsupported
+
+open Lean.Parser in
+private def elabParserMacroAux (prec e : Term) (withAnonymousAntiquot : Bool) : TermElabM Syntax := do
+  let (some declName) ← getDeclName?
+    | throwError "invalid `leading_parser` macro, it must be used in definitions"
+  match extractMacroScopes declName with
+  | { name := .str _ s, .. } =>
+    let kind := quote declName
+    let mut p ← ``(withAntiquot
+      (mkAntiquot $(quote s) $kind $(quote withAnonymousAntiquot))
+      (leadingNode $kind $prec $e))
+    -- cache only unparameterized parsers
+    if (← getLCtx).all (·.isAuxDecl) then
+      p ← ``(withCache $kind $p)
+    return p
+  | _  => throwError "invalid `leading_parser` macro, unexpected declaration name"
+
+@[builtin_term_elab «leading_parser»] def elabLeadingParserMacro : TermElab :=
+  adaptExpander fun
+    | `(leading_parser $[: $prec?]? $[(withAnonymousAntiquot := $anon?)]? $e) =>
+        elabParserMacroAux (prec?.getD (quote Parser.maxPrec)) e (anon?.all (·.raw.isOfKind ``Parser.Term.trueVal))
+    | _ => throwUnsupportedSyntax
+
+private def elabTParserMacroAux (prec lhsPrec e : Term) : TermElabM Syntax := do
+  let declName? ← getDeclName?
+  match declName? with
+  | some declName => let kind := quote declName; ``(Lean.Parser.trailingNode $kind $prec $lhsPrec $e)
+  | none          => throwError "invalid `trailing_parser` macro, it must be used in definitions"
+
+@[builtin_term_elab «trailing_parser»] def elabTrailingParserMacro : TermElab :=
+  adaptExpander fun stx => match stx with
+  | `(trailing_parser$[:$prec?]?$[:$lhsPrec?]? $e) =>
+    elabTParserMacroAux (prec?.getD <| quote Parser.maxPrec) (lhsPrec?.getD <| quote 0) e
+  | _ => throwUnsupportedSyntax
+
+@[builtin_term_elab Lean.Parser.Term.panic] def elabPanic : TermElab := fun stx expectedType? => do
+  match stx with
+  | `(panic! $arg) =>
+    let pos ← getRefPosition
+    let env ← getEnv
+    let stxNew ← match (← getDeclName?) with
+    | some declName => `(panicWithPosWithDecl $(quote (toString env.mainModule)) $(quote (toString declName)) $(quote pos.line) $(quote pos.column) $arg)
+    | none => `(panicWithPos $(quote (toString env.mainModule)) $(quote pos.line) $(quote pos.column) $arg)
+    withMacroExpansion stx stxNew $ elabTerm stxNew expectedType?
+  | _ => throwUnsupportedSyntax
+
+@[builtin_macro Lean.Parser.Term.unreachable]  def expandUnreachable : Macro := fun _ =>
+  `(panic! "unreachable code has been reached")
+
+@[builtin_macro Lean.Parser.Term.assert]  def expandAssert : Macro
+  | `(assert! $cond; $body) =>
+    match cond.raw.reprint with
+    | some code => `(if $cond then $body else panic! ("assertion violation: " ++ $(quote code)))
+    | none => `(if $cond then $body else panic! ("assertion violation"))
+  | _ => Macro.throwUnsupported
+
+register_builtin_option debugAssertions : Bool := {
+  defValue := false
+  descr := "enable `debug_assert!` statements\
+    \n\
+    \nDefaults to `false` unless the Lake `buildType` is `debug`."
+}
+
+@[builtin_term_elab Lean.Parser.Term.debugAssert]  def elabDebugAssert : TermElab :=
+  adaptExpander fun
+    | `(Parser.Term.debugAssert| debug_assert! $cond; $body) => do
+      if debugAssertions.get (← getOptions) then
+        `(assert! $cond; $body)
+      else
+        return body
+    | _ => throwUnsupportedSyntax
+
+@[builtin_macro Lean.Parser.Term.dbgTrace]  def expandDbgTrace : Macro
+  | `(dbg_trace $arg:interpolatedStr; $body) => `(dbgTrace (s! $arg) fun _ => $body)
+  | `(dbg_trace $arg:term; $body)            => `(dbgTrace (toString $arg) fun _ => $body)
+  | _                                        => Macro.throwUnsupported
+
+@[builtin_term_elab «sorry»] def elabSorry : TermElab := fun _ expectedType? => do
+  let type ← expectedType?.getDM mkFreshTypeMVar
+  mkLabeledSorry type (synthetic := false) (unique := true)
+
+/-- Return syntax `Prod.mk elems[0] (Prod.mk elems[1] ... (Prod.mk elems[elems.size - 2] elems[elems.size - 1])))` -/
+partial def mkPairs (elems : Array Term) : MacroM Term :=
+  let rec loop (i : Nat) (acc : Term) := do
+    if i > 0 then
+      let i    := i - 1
+      let elem := elems[i]!
+      let acc ← `(Prod.mk $elem $acc)
+      loop i acc
+    else
+      pure acc
+  loop (elems.size - 1) elems.back!
+
+/-- Return syntax `PProd.mk elems[0] (PProd.mk elems[1] ... (PProd.mk elems[elems.size - 2] elems[elems.size - 1])))` -/
+partial def mkPPairs (elems : Array Term) : MacroM Term :=
+  let rec loop (i : Nat) (acc : Term) := do
+    if i > 0 then
+      let i    := i - 1
+      let elem := elems[i]!
+      let acc ← `(PProd.mk $elem $acc)
+      loop i acc
+    else
+      pure acc
+  loop (elems.size - 1) elems.back!
+
+/-- Return syntax `MProd.mk elems[0] (MProd.mk elems[1] ... (MProd.mk elems[elems.size - 2] elems[elems.size - 1])))` -/
+partial def mkMPairs (elems : Array Term) : MacroM Term :=
+  let rec loop (i : Nat) (acc : Term) := do
+    if i > 0 then
+      let i    := i - 1
+      let elem := elems[i]!
+      let acc ← `(MProd.mk $elem $acc)
+      loop i acc
+    else
+      pure acc
+  loop (elems.size - 1) elems.back!
+
+
+open Parser in
+partial def hasCDot : Syntax → Bool
+  | Syntax.node _ k args =>
+    if k == ``Term.paren || k == ``Term.typeAscription || k == ``Term.tuple then false
+    else if k == ``Term.cdot then true
+    else args.any hasCDot
+  | _ => false
+
+/--
+  Return `some` if succeeded expanding `·` notation occurring in
+  the given syntax. Otherwise, return `none`.
+  Examples:
+  - `· + 1` => `fun x => x + 1`
+  - `f · · b` => `fun x1 x2 => f x1 x2 b` -/
+partial def expandCDot? (stx : Term) : MacroM (Option Term) := do
+  if hasCDot stx then
+    withFreshMacroScope do
+      let mut (newStx, binders) ← (go stx).run #[]
+      if binders.size == 1 then
+        -- It is nicer using `x` over `x1` if there's only a single binder.
+        let x1 := binders[0]!
+        let x := mkIdentFrom x1 (← MonadQuotation.addMacroScope `x) (canonical := true)
+        binders := binders.set! 0 x
+        newStx ← newStx.replaceM fun s => pure (if s == x1 then x else none)
+      `(fun $binders* => $(⟨newStx⟩))
+  else
+    pure none
+where
+  /--
+  Auxiliary function for expanding the `·` notation.
+  The extra state `Array Syntax` contains the new binder names.
+  If `stx` is a `·`, we create a fresh identifier, store it in the
+  extra state, and return it. Otherwise, we just return `stx`.
+  -/
+  go : Syntax → StateT (Array Ident) MacroM Syntax
+  | stx@`(($(_))) => pure stx
+  | stx@`(·) => do
+    let name ← MonadQuotation.addMacroScope <| Name.mkSimple s!"x{(← get).size + 1}"
+    let id := mkIdentFrom stx name (canonical := true)
+    modify (fun s => s.push id)
+    pure id
+  | stx => match stx with
+    | .node _ k args => do
+      let args ←
+        if k == choiceKind then
+          if args.isEmpty then
+            return stx
+          let s ← get
+          let args' ← args.mapM (fun arg => go arg |>.run s)
+          let s' := args'[0]!.2
+          unless args'.all (fun (_, s'') => s''.size == s'.size) do
+            Macro.throwErrorAt stx "Ambiguous notation in cdot function has different numbers of '·' arguments in each alternative."
+          set s'
+          pure <| args'.map Prod.fst
+        else
+          args.mapM go
+      return .node (.fromRef stx (canonical := true)) k args
+    | _ => pure stx
+
+/--
+  Helper method for elaborating terms such as `(.+.)` where a constant name is expected.
+  This method is usually used to implement tactics that take function names as arguments
+  (e.g., `simp`).
+-/
+def elabCDotFunctionAlias? (stx : Term) : TermElabM (Option Expr) := do
+  let some stx ← liftMacroM <| expandCDotArg? stx | pure none
+  let stx ← liftMacroM <| expandMacros stx
+  match stx with
+  | `(fun $binders* => $f $args*) =>
+    if binders.raw.toList.isPerm args.raw.toList then
+      try Term.resolveId? f catch _ => return none
+    else
+      return none
+  | `(fun $binders* => binop% $f $a $b)
+  | `(fun $binders* => binop_lazy% $f $a $b)
+  | `(fun $binders* => leftact% $f $a $b)
+  | `(fun $binders* => rightact% $f $a $b)
+  | `(fun $binders* => binrel% $f $a $b)
+  | `(fun $binders* => binrel_no_prop% $f $a $b) =>
+    if binders == #[a, b] || binders == #[b, a] then
+      try Term.resolveId? f catch _ => return none
+    else
+      return none
+  | `(fun $binders* => unop% $f $a) =>
+    if binders == #[a] then
+      try Term.resolveId? f catch _ => return none
+    else
+      return none
+  | _ => return none
+where
+  expandCDotArg? (stx : Term) : MacroM (Option Term) :=
+    match stx with
+    | `(($e)) => Term.expandCDot? e
+    | _ => Term.expandCDot? stx
+
+@[builtin_macro Lean.Parser.Term.paren] def expandParen : Macro
+  | `(($e)) => return (← expandCDot? e).getD e
+  | _       => Macro.throwUnsupported
+
+@[builtin_macro Lean.Parser.Term.tuple] def expandTuple : Macro
+  | `(()) => ``(Unit.unit)
+  | `(($e, $es,*)) => do
+    let pairs ← mkPairs (#[e] ++ es)
+    return (← expandCDot? pairs).getD pairs
+  | _ => Macro.throwUnsupported
+
+@[builtin_macro Lean.Parser.Term.typeAscription] def expandTypeAscription : Macro
+  | `(($e : $(type)?)) => do
+    match (← expandCDot? e) with
+    | some e => `(($e : $(type)?))
+    | none   => Macro.throwUnsupported
+  | _ => Macro.throwUnsupported
+
+@[builtin_term_elab typeAscription] def elabTypeAscription : TermElab
+  | `(($e : $type)), _ => do
+    let type ← withSynthesize (postpone := .yes) <| elabType type
+    let e ← elabTerm e type
+    ensureHasType type e
+  | `(($e :)), expectedType? => do
+    let e ← withSynthesize (postpone := .no) <| elabTerm e none
+    ensureHasType expectedType? e
+  | _, _ => throwUnsupportedSyntax
+
+/-- Return `true` if `lhs` is a free variable and `rhs` does not depend on it. -/
+private def isSubstCandidate (lhs rhs : Expr) : MetaM Bool :=
+  if lhs.isFVar then
+    return !(← dependsOn rhs lhs.fvarId!)
+  else
+    return false
+
+/--
+  Given an expression `e` that is the elaboration of `stx`, if `e` is a free variable, then return `k stx`.
+  Otherwise, return `(fun x => k x) e`
+-/
+private def withLocalIdentFor (stx : Term) (e : Expr) (k : Term → TermElabM Expr) : TermElabM Expr := do
+  if e.isFVar then
+    k stx
+  else
+    let id ← mkFreshUserName `h
+    let aux ← withLocalDeclD id (← inferType e) fun x => do mkLambdaFVars #[x] (← k (mkIdentFrom stx id))
+    return mkApp aux e
+
+@[builtin_term_elab subst] def elabSubst : TermElab := fun stx expectedType? => do
+  let expectedType? ← tryPostponeIfHasMVars? expectedType?
+  match stx with
+  | `($heqStx ▸ $hStx) => do
+     synthesizeSyntheticMVars
+     let mut heq ← withSynthesize <| elabTerm heqStx none
+     let heqType ← inferType heq
+     let heqType ← instantiateMVars heqType
+     match (← Meta.matchEq? heqType) with
+     | none => throwError "invalid `▸` notation, argument{indentExpr heq}\nhas type{indentExpr heqType}\nequality expected"
+     | some (α, lhs, rhs) =>
+       let mut lhs := lhs
+       let mut rhs := rhs
+       let mkMotive (lhs typeWithLooseBVar : Expr) := do
+         withLocalDeclD (← mkFreshUserName `x) α fun x => do
+           withLocalDeclD (← mkFreshUserName `h) (← mkEq lhs x) fun h => do
+             mkLambdaFVars #[x, h] $ typeWithLooseBVar.instantiate1 x
+       match expectedType? with
+       | some expectedType =>
+         let mut expectedAbst ← kabstract expectedType rhs
+         unless expectedAbst.hasLooseBVars do
+           expectedAbst ← kabstract expectedType lhs
+           unless expectedAbst.hasLooseBVars do
+             throwError "invalid `▸` notation, expected result type of cast is {indentExpr expectedType}\nhowever, the equality {indentExpr heq}\nof type {indentExpr heqType}\ndoes not contain the expected result type on either the left or the right hand side"
+           heq ← mkEqSymm heq
+           (lhs, rhs) := (rhs, lhs)
+         let hExpectedType := expectedAbst.instantiate1 lhs
+         let (h, badMotive?) ← withRef hStx do
+           let h ← elabTerm hStx hExpectedType
+           try
+             return (← ensureHasType hExpectedType h, none)
+           catch ex =>
+             -- if `rhs` occurs in `hType`, we try to apply `heq` to `h` too
+             let hType ← inferType h
+             let hTypeAbst ← kabstract hType rhs
+             unless hTypeAbst.hasLooseBVars do
+               throw ex
+             let hTypeNew := hTypeAbst.instantiate1 lhs
+             unless (← isDefEq hExpectedType hTypeNew) do
+               throw ex
+             let motive ← mkMotive rhs hTypeAbst
+             if !(← isTypeCorrect motive) then
+               return (h, some motive)
+             else
+               return (← mkEqRec motive h (← mkEqSymm heq), none)
+         let motive ← mkMotive lhs expectedAbst
+         if badMotive?.isSome || !(← isTypeCorrect motive) then
+           -- Before failing try to use `subst`
+           if ← (isSubstCandidate lhs rhs <||> isSubstCandidate rhs lhs) then
+             withLocalIdentFor heqStx heq fun heqStx => do
+               let h ← instantiateMVars h
+               if h.hasMVar then
+                 -- If `h` has metavariables, we try to elaborate `hStx` again after we substitute `heqStx`
+                 -- Remark: re-elaborating `hStx` may be problematic if `hStx` contains the `lhs` of `heqStx` which will be eliminated by `subst`
+                 let stxNew ← `(by subst $heqStx; exact $hStx)
+                 withMacroExpansion stx stxNew (elabTerm stxNew expectedType)
+               else
+                 withLocalIdentFor hStx h fun hStx => do
+                   let stxNew ← `(by subst $heqStx; exact $hStx)
+                   withMacroExpansion stx stxNew (elabTerm stxNew expectedType)
+           else
+             throwError "invalid `▸` notation, failed to compute motive for the substitution"
+         else
+           mkEqRec motive h heq
+       | none =>
+         let h ← elabTerm hStx none
+         let hType ← inferType h
+         let mut hTypeAbst ← kabstract hType lhs
+         unless hTypeAbst.hasLooseBVars do
+           hTypeAbst ← kabstract hType rhs
+           unless hTypeAbst.hasLooseBVars do
+             throwError "invalid `▸` notation, the equality{indentExpr heq}\nhas type {indentExpr heqType}\nbut neither side of the equality is mentioned in the type{indentExpr hType}"
+           heq ← mkEqSymm heq
+           (lhs, rhs) := (rhs, lhs)
+         let motive ← mkMotive lhs hTypeAbst
+         unless (← isTypeCorrect motive) do
+           throwError "invalid `▸` notation, failed to compute motive for the substitution"
+         mkEqRec motive h heq
+  | _ => throwUnsupportedSyntax
+
+@[builtin_term_elab stateRefT] def elabStateRefT : TermElab := fun stx _ => do
+  let σ ← elabType stx[1]
+  let mut mStx := stx[2]
+  if mStx.getKind == ``Lean.Parser.Term.macroDollarArg then
+    mStx := mStx[1]
+  let m ← elabTerm mStx (← mkArrow (mkSort levelOne) (mkSort levelOne))
+  let ω ← mkFreshExprMVar (mkSort levelOne)
+  let stWorld ← mkAppM ``STWorld #[ω, m]
+  discard <| mkInstMVar stWorld
+  mkAppM ``StateRefT' #[ω, σ, m]
+
+@[builtin_term_elab noindex] def elabNoindex : TermElab := fun stx expectedType? => do
+  let e ← elabTerm stx[1] expectedType?
+  return DiscrTree.mkNoindexAnnotation e
+
+@[builtin_term_elab «unsafe»]
+def elabUnsafe : TermElab := fun stx expectedType? =>
+  match stx with
+  | `(unsafe $t) => do
+    let t ← elabTermAndSynthesize t expectedType?
+    if (← logUnassignedUsingErrorInfos (← getMVars t)) then
+      throwAbortTerm
+    let t ← mkAuxDefinitionFor (← mkAuxName `unsafe) t
+    let .const unsafeFn unsafeLvls .. := t.getAppFn | unreachable!
+    let .defnInfo unsafeDefn ← getConstInfo unsafeFn | unreachable!
+    let implName ← mkAuxName `unsafe_impl
+    addDecl <| Declaration.defnDecl {
+      name        := implName
+      type        := unsafeDefn.type
+      levelParams := unsafeDefn.levelParams
+      value       := (← mkOfNonempty unsafeDefn.type)
+      hints       := .opaque
+      safety      := .safe
+    }
+    setImplementedBy implName unsafeFn
+    return mkAppN (Lean.mkConst implName unsafeLvls) t.getAppArgs
+  | _ => throwUnsupportedSyntax
+
+/-- Elaborator for `by_elab`. -/
+@[builtin_term_elab byElab] def elabRunElab : TermElab := fun stx expectedType? =>
+  match stx with
+  | `(by_elab $cmds:doSeq) => do
+    if let `(Lean.Parser.Term.doSeq| $e:term) := cmds then
+      if e matches `(Lean.Parser.Term.doSeq| fun $[$_args]* => $_) then
+        let tac ← unsafe evalTerm
+          (Option Expr → TermElabM Expr)
+          (Lean.mkForall `x .default
+            (mkApp (Lean.mkConst ``Option) (Lean.mkConst ``Expr))
+            (mkApp (Lean.mkConst ``TermElabM) (Lean.mkConst ``Expr))) e
+        return ← tac expectedType?
+    (← unsafe evalTerm (TermElabM Expr) (mkApp (Lean.mkConst ``TermElabM) (Lean.mkConst ``Expr))
+      (← `(do $cmds)))
+  | _ => throwUnsupportedSyntax
+
+end Lean.Elab.Term

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/BuiltinTerm.lean

@@ -0,0 +1,386 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.Meta.Closure
+import Lean.Meta.Diagnostics
+import Lean.Elab.Open
+import Lean.Elab.SetOption
+import Lean.Elab.Eval
+
+namespace Lean.Elab.Term
+open Meta
+
+@[builtin_term_elab «prop»] def elabProp : TermElab := fun _ _ =>
+  return mkSort levelZero
+
+private def elabOptLevel (stx : Syntax) : TermElabM Level :=
+  if stx.isNone then
+    pure levelZero
+  else
+    elabLevel stx[0]
+
+@[builtin_term_elab «sort»] def elabSort : TermElab := fun stx _ =>
+  return mkSort (← elabOptLevel stx[1])
+
+@[builtin_term_elab «type»] def elabTypeStx : TermElab := fun stx _ =>
+  return mkSort (mkLevelSucc (← elabOptLevel stx[1]))
+
+/-!
+ the method `resolveName` adds a completion point for it using the given
+    expected type. Thus, we propagate the expected type if `stx[0]` is an identifier.
+    It doesn't "hurt" if the identifier can be resolved because the expected type is not used in this case.
+    Recall that if the name resolution fails a synthetic sorry is returned.-/
+
+@[builtin_term_elab «pipeCompletion»] def elabPipeCompletion : TermElab := fun stx expectedType? => do
+  let e ← elabTerm stx[0] none
+  unless e.isSorry do
+    addDotCompletionInfo stx e expectedType?
+  throwErrorAt stx[1] "invalid field notation, identifier or numeral expected"
+
+@[builtin_term_elab «completion»] def elabCompletion : TermElab := fun stx expectedType? => do
+  /- `ident.` is ambiguous in Lean, we may try to be completing a declaration name or access a "field". -/
+  if stx[0].isIdent then
+    -- Add both an `id` and a `dot` `CompletionInfo` and have the language server figure out which
+    -- one to use.
+    addCompletionInfo <| CompletionInfo.id stx stx[0].getId (danglingDot := true) (← getLCtx) expectedType?
+    let s ← saveState
+    try
+      let e ← elabTerm stx[0] none
+      addDotCompletionInfo stx e expectedType?
+    catch _ =>
+      s.restore
+    throwErrorAt stx[1] "invalid field notation, identifier or numeral expected"
+  else
+    elabPipeCompletion stx expectedType?
+
+@[builtin_term_elab «hole»] def elabHole : TermElab := fun stx expectedType? => do
+  let kind := if (← read).inPattern || !(← read).holesAsSyntheticOpaque then MetavarKind.natural else MetavarKind.syntheticOpaque
+  let mvar ← mkFreshExprMVar expectedType? kind
+  registerMVarErrorHoleInfo mvar.mvarId! stx
+  pure mvar
+
+@[builtin_term_elab «syntheticHole»] def elabSyntheticHole : TermElab := fun stx expectedType? => do
+  let arg  := stx[1]
+  let userName := if arg.isIdent then arg.getId else Name.anonymous
+  let mkNewHole : Unit → TermElabM Expr := fun _ => do
+    let kind := if (← read).inPattern then MetavarKind.natural else MetavarKind.syntheticOpaque
+    let mvar ← mkFreshExprMVar expectedType? kind userName
+    registerMVarErrorHoleInfo mvar.mvarId! stx
+    return mvar
+  if userName.isAnonymous || (← read).inPattern then
+    mkNewHole ()
+  else
+    match (← getMCtx).findUserName? userName with
+    | none => mkNewHole ()
+    | some mvarId =>
+      let mvar := mkMVar mvarId
+      let mvarDecl ← getMVarDecl mvarId
+      let lctx ← getLCtx
+      if mvarDecl.lctx.isSubPrefixOf lctx then
+        return mvar
+      else match (← getExprMVarAssignment? mvarId) with
+      | some val =>
+        let val ← instantiateMVars val
+        if (← MetavarContext.isWellFormed lctx val) then
+          return val
+        else
+          withLCtx mvarDecl.lctx mvarDecl.localInstances do
+            throwError "synthetic hole has already been defined and assigned to value incompatible with the current context{indentExpr val}"
+      | none =>
+        if (← mvarId.isDelayedAssigned) then
+          -- We can try to improve this case if needed.
+          throwError "synthetic hole has already beend defined and delayed assigned with an incompatible local context"
+        else if lctx.isSubPrefixOf mvarDecl.lctx then
+          let mvarNew ← mkNewHole ()
+          mvarId.assign mvarNew
+          return mvarNew
+        else
+          throwError "synthetic hole has already been defined with an incompatible local context"
+
+@[builtin_term_elab Lean.Parser.Term.omission] def elabOmission : TermElab := fun stx expectedType? => do
+  logWarning m!"\
+    The '⋯' token is used by the pretty printer to indicate omitted terms, and it should not be used directly. \
+    It logs this warning and then elaborates like '_'.\
+    \n\n\
+    The presence of '⋯' in pretty printing output is controlled by the 'pp.maxSteps', 'pp.deepTerms' and 'pp.proofs' options. \
+    These options can be further adjusted using 'pp.deepTerms.threshold' and 'pp.proofs.threshold'. \
+    If this '⋯' was copied from the Infoview, the hover there for the original '⋯' explains which of these options led to the omission."
+  elabHole stx expectedType?
+
+@[builtin_term_elab «letMVar»] def elabLetMVar : TermElab := fun stx expectedType? => do
+  match stx with
+  | `(let_mvar% ? $n := $e; $b) =>
+     match (← getMCtx).findUserName? n.getId with
+     | some _ => throwError "invalid 'let_mvar%', metavariable '?{n.getId}' has already been used"
+     | none =>
+       let e ← elabTerm e none
+       let mvar ← mkFreshExprMVar (← inferType e) MetavarKind.syntheticOpaque n.getId
+       mvar.mvarId!.assign e
+       -- We use `mkSaveInfoAnnotation` to make sure the info trees for `e` are saved even if `b` is a metavariable.
+       return mkSaveInfoAnnotation (← elabTerm b expectedType?)
+  | _ => throwUnsupportedSyntax
+
+private def getMVarFromUserName (ident : Syntax) : MetaM Expr := do
+  match (← getMCtx).findUserName? ident.getId with
+  | none => throwError "unknown metavariable '?{ident.getId}'"
+  | some mvarId => instantiateMVars (mkMVar mvarId)
+
+
+@[builtin_term_elab «waitIfTypeMVar»] def elabWaitIfTypeMVar : TermElab := fun stx expectedType? => do
+  match stx with
+  | `(wait_if_type_mvar% ? $n; $b) =>
+    tryPostponeIfMVar (← inferType (← getMVarFromUserName n))
+    elabTerm b expectedType?
+  | _ => throwUnsupportedSyntax
+
+@[builtin_term_elab «waitIfTypeContainsMVar»] def elabWaitIfTypeContainsMVar : TermElab := fun stx expectedType? => do
+  match stx with
+  | `(wait_if_type_contains_mvar% ? $n; $b) =>
+    if (← instantiateMVars (← inferType (← getMVarFromUserName n))).hasExprMVar then
+      tryPostpone
+    elabTerm b expectedType?
+  | _ => throwUnsupportedSyntax
+
+@[builtin_term_elab «waitIfContainsMVar»] def elabWaitIfContainsMVar : TermElab := fun stx expectedType? => do
+  match stx with
+  | `(wait_if_contains_mvar% ? $n; $b) =>
+    if (← getMVarFromUserName n).hasExprMVar then
+      tryPostpone
+    elabTerm b expectedType?
+  | _ => throwUnsupportedSyntax
+
+@[builtin_term_elab byTactic] def elabByTactic : TermElab := fun stx expectedType? => do
+  match expectedType? with
+  | some expectedType =>
+    -- `by` switches from an exported to a private context, so we must disallow unassigned
+    -- metavariables in the goal in this case as they could otherwise leak private data back into
+    -- the exported context.
+    mkTacticMVar expectedType stx .term (delayOnMVars := (← getEnv).isExporting)
+  | none =>
+    tryPostpone
+    throwError ("invalid 'by' tactic, expected type has not been provided")
+
+@[builtin_term_elab noImplicitLambda] def elabNoImplicitLambda : TermElab := fun stx expectedType? =>
+  elabTerm stx[1] (mkNoImplicitLambdaAnnotation <$> expectedType?)
+
+@[builtin_term_elab Lean.Parser.Term.cdot] def elabBadCDot : TermElab := fun stx expectedType? => do
+  if stx[0].getAtomVal == "." then
+    -- Users may input bad cdots because they are trying to auto-complete them using the expected type
+    addCompletionInfo <| CompletionInfo.dotId stx .anonymous (← getLCtx) expectedType?
+  throwError "invalid occurrence of `·` notation, it must be surrounded by parentheses (e.g. `(· + 1)`)"
+
+@[builtin_term_elab str] def elabStrLit : TermElab := fun stx _ => do
+  match stx.isStrLit? with
+  | some val => pure $ mkStrLit val
+  | none     => throwIllFormedSyntax
+
+private def mkFreshTypeMVarFor (expectedType? : Option Expr) : TermElabM Expr := do
+  let typeMVar ← mkFreshTypeMVar MetavarKind.synthetic
+  match expectedType? with
+  | some expectedType => discard <| isDefEq expectedType typeMVar
+  | _                 => pure ()
+  return typeMVar
+
+@[builtin_term_elab num] def elabNumLit : TermElab := fun stx expectedType? => do
+  let val ← match stx.isNatLit? with
+    | some val => pure val
+    | none     => throwIllFormedSyntax
+  let typeMVar ← mkFreshTypeMVarFor expectedType?
+  let u ← try
+    getDecLevel typeMVar
+  catch ex =>
+    match expectedType? with
+    | some expectedType =>
+      if (← isProp expectedType) then
+        throwError m!"numerals are data in Lean, but the expected type is a proposition{indentExpr expectedType} : Prop"
+      else
+        throwError m!"numerals are data in Lean, but the expected type is universe polymorphic and may be a proposition{indentExpr expectedType} : {← inferType expectedType}"
+    | none => throw ex
+  let extraMsg := m!"numerals are polymorphic in Lean, but the numeral `{val}` cannot be used in a context where the expected type is{indentExpr typeMVar}\ndue to the absence of the instance above"
+  let mvar ← mkInstMVar (mkApp2 (Lean.mkConst ``OfNat [u]) typeMVar (mkRawNatLit val)) extraMsg
+  let r := mkApp3 (Lean.mkConst ``OfNat.ofNat [u]) typeMVar (mkRawNatLit val) mvar
+  registerMVarErrorImplicitArgInfo mvar.mvarId! stx r
+  return r
+
+@[builtin_term_elab rawNatLit] def elabRawNatLit : TermElab :=  fun stx _ => do
+  match stx[1].isNatLit? with
+  | some val => return mkRawNatLit val
+  | none     => throwIllFormedSyntax
+
+@[builtin_term_elab scientific]
+def elabScientificLit : TermElab := fun stx expectedType? => do
+  match stx.isScientificLit? with
+  | none        => throwIllFormedSyntax
+  | some (m, sign, e) =>
+    let typeMVar ← mkFreshTypeMVarFor expectedType?
+    let u ← getDecLevel typeMVar
+    let mvar ← mkInstMVar (mkApp (Lean.mkConst ``OfScientific [u]) typeMVar)
+    let r := mkApp5 (Lean.mkConst ``OfScientific.ofScientific [u]) typeMVar mvar (mkRawNatLit m) (toExpr sign) (mkRawNatLit e)
+    registerMVarErrorImplicitArgInfo mvar.mvarId! stx r
+    return r
+
+@[builtin_term_elab char] def elabCharLit : TermElab := fun stx _ => do
+  match stx.isCharLit? with
+  | some val => return mkApp (Lean.mkConst ``Char.ofNat) (mkRawNatLit val.toNat)
+  | none     => throwIllFormedSyntax
+
+@[builtin_term_elab quotedName] def elabQuotedName : TermElab := fun stx _ =>
+  match stx[0].isNameLit? with
+  | some val => pure $ toExpr val
+  | none     => throwIllFormedSyntax
+
+@[builtin_term_elab doubleQuotedName] def elabDoubleQuotedName : TermElab := fun stx _ =>
+  return toExpr (← realizeGlobalConstNoOverloadWithInfo stx[2])
+
+@[builtin_term_elab declName] def elabDeclName : TermElab := adaptExpander fun _ => do
+  let some declName ← getDeclName?
+    | throwError "invalid `decl_name%` macro, the declaration name is not available"
+  return (quote declName : Term)
+
+@[builtin_term_elab Parser.Term.withDeclName] def elabWithDeclName : TermElab := fun stx expectedType? => do
+  let id := stx[2].getId
+  let id ← if stx[1].isNone then pure id else pure <| (← getCurrNamespace) ++ id
+  let e := stx[3]
+  withMacroExpansion stx e <| withDeclName id <| elabTerm e expectedType?
+
+@[builtin_term_elab typeOf] def elabTypeOf : TermElab := fun stx _ => do
+  inferType (← elabTerm stx[1] none)
+
+/--
+  Recall that `mkTermInfo` does not create an `ofTermInfo` node in the info tree
+  if `e` corresponds to a hole that is going to be filled "later" by executing a tactic or resuming elaboration.
+  This behavior is problematic for auxiliary elaboration steps that are "almost" no-ops.
+  For example, consider the elaborator for
+  ```
+  ensure_type_of% s msg e
+  ```
+  It elaborates `s`, infers its type `t`, and then elaborates `e` ensuring the resulting type is `t`.
+  If the elaboration of `e` is postponed, then the result is just a metavariable, and an `ofTermInfo` would not be created.
+  This happens because `ensure_type_of%` is almost a no-op. The elaboration of `s` does not directly contribute to the
+  final result, just its type.
+  To make sure, we don't miss any information in the `InfoTree`, we can just create a "silent" annotation to force
+  `mTermInfo` to create a node for the `ensure_type_of% s msg e` even if `e` has been postponed.
+
+  Another possible solution is to elaborate `ensure_type_of% s msg e` as `ensureType s e` where `ensureType` has type
+  ```
+  ensureType (s e : α) := e
+  ```
+  We decided to use the silent notation because `ensure_type_of%` is heavily used in the `Do` elaborator, and the extra
+  overhead could be significant.
+-/
+private def mkSilentAnnotationIfHole (e : Expr) : TermElabM Expr := do
+  if (← isTacticOrPostponedHole? e).isSome then
+    return mkAnnotation `_silent e
+  else
+    return e
+
+@[builtin_term_elab ensureTypeOf] def elabEnsureTypeOf : TermElab := fun stx _ =>
+  match stx[2].isStrLit? with
+  | none     => throwIllFormedSyntax
+  | some msg => do
+    let refTerm ← elabTerm stx[1] none
+    let refTermType ← inferType refTerm
+    -- See comment at `mkSilentAnnotationIfHole`
+    mkSilentAnnotationIfHole (← elabTermEnsuringType stx[3] refTermType (errorMsgHeader? := msg))
+
+@[builtin_term_elab ensureExpectedType] def elabEnsureExpectedType : TermElab := fun stx expectedType? =>
+  match stx[1].isStrLit? with
+  | none     => throwIllFormedSyntax
+  | some msg => elabTermEnsuringType stx[2] expectedType? (errorMsgHeader? := msg)
+
+@[builtin_term_elab valueOf] def elabValueOf : TermElab := fun stx _ => do
+  let ident := stx[1]
+  let some e ← Term.resolveId? stx[1] (withInfo := true)
+    | throwUnknownConstantAt ident ident.getId
+  match e with
+  | .const c us => do
+    let cinfo ← getConstInfo c
+    unless cinfo.hasValue do throwErrorAt ident "Constant has no value."
+    return cinfo.instantiateValueLevelParams! us
+  | .fvar fvarId => do
+    let some val ← fvarId.getValue? | throwErrorAt ident "Local declaration has no value."
+    return val
+  | _ => panic! "resolveId? returned an unexpected expression"
+
+@[builtin_term_elab clear] def elabClear : TermElab := fun stx expectedType? => do
+  let some (.fvar fvarId) ← isLocalIdent? stx[1]
+    | throwErrorAt stx[1] "not in scope"
+  let body := stx[3]
+  let canClear ← id do
+    if let some expectedType := expectedType? then
+      if ← dependsOn expectedType fvarId then
+        return false
+    for ldecl in ← getLCtx do
+      if ldecl.fvarId != fvarId then
+        if ← localDeclDependsOn ldecl fvarId then
+          return false
+    return true
+  if canClear then
+    withErasedFVars #[fvarId] do elabTerm body expectedType?
+  else
+    elabTerm body expectedType?
+
+@[builtin_term_elab «open»] def elabOpen : TermElab := fun stx expectedType? => do
+  let `(open $decl in $e) := stx | throwUnsupportedSyntax
+  try
+    pushScope
+    let openDecls ← elabOpenDecl decl
+    withTheReader Core.Context (fun ctx => { ctx with openDecls := openDecls }) do
+      elabTerm e expectedType?
+  finally
+    popScope
+
+@[builtin_term_elab «set_option»] def elabSetOption : TermElab := fun stx expectedType? => do
+  let options ← Elab.elabSetOption stx[1] stx[3]
+  withOptions (fun _ => options) do
+    try
+      elabTerm stx[5] expectedType?
+    finally
+      if stx[1].getId == `diagnostics then
+        reportDiag
+
+@[builtin_term_elab withAnnotateTerm] def elabWithAnnotateTerm : TermElab := fun stx expectedType? => do
+  match stx with
+  | `(with_annotate_term $stx $e) =>
+    withTermInfoContext' .anonymous stx (expectedType? := expectedType?) (elabTerm e expectedType?)
+  | _ => throwUnsupportedSyntax
+
+private unsafe def evalFilePathUnsafe (stx : Syntax) : TermElabM System.FilePath :=
+  evalTerm System.FilePath (Lean.mkConst ``System.FilePath) stx
+
+@[implemented_by evalFilePathUnsafe]
+private opaque evalFilePath (stx : Syntax) : TermElabM System.FilePath
+
+@[builtin_term_elab includeStr] def elabIncludeStr : TermElab
+  | `(include_str $path:term), _ => do
+    let path ← evalFilePath path
+    let ctx ← readThe Lean.Core.Context
+    let srcPath := System.FilePath.mk ctx.fileName
+    let some srcDir := srcPath.parent
+      | throwError "cannot compute parent directory of '{srcPath}'"
+    let path := srcDir / path
+    mkStrLit <$> IO.FS.readFile path
+  | _, _ => throwUnsupportedSyntax
+
+@[builtin_term_elab Lean.Parser.Term.namedPattern] def elabNamedPatternErr : TermElab := fun stx _ =>
+  throwError "`<identifier>@<term>` is a named pattern and can only be used in pattern matching contexts{indentD stx}"
+
+@[builtin_term_elab «privateDecl»] def elabPrivateDecl : TermElab := fun stx expectedType? => do
+  match stx with
+  | `(Parser.Term.privateDecl| private_decl% $e) =>
+    if (← getEnv).isExporting then
+      let name ← mkAuxDeclName `_private
+      withoutExporting do
+        let e ← elabTerm e expectedType?
+        -- Inline as changing visibility should not affect run time.
+        -- Eventually we would like to be more conscious about inlining of instance fields,
+        -- irrespective of `private` use.
+        mkAuxDefinitionFor name e <* setInlineAttribute name
+    else
+      elabTerm e expectedType?
+  | _ => throwUnsupportedSyntax
+
+end Lean.Elab.Term

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/Calc.lean

@@ -0,0 +1,174 @@
+/-
+Copyright (c) 2022 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.Elab.App
+
+namespace Lean.Elab.Term
+open Meta
+
+/--
+Decompose `e` into `(r, a, b)`.
+
+Remark: it assumes the last two arguments are explicit.
+-/
+def getCalcRelation? (e : Expr) : MetaM (Option (Expr × Expr × Expr)) := do
+  if e.getAppNumArgs < 2 then
+    return none
+  else
+    return some (e.appFn!.appFn!, e.appFn!.appArg!, e.appArg!)
+
+private def getRelUniv (r : Expr) : MetaM Level := do
+  let rType ← inferType r
+  forallTelescopeReducing rType fun _ sort => do
+    let .sort u ← whnf sort | throwError "unexpected relation type{indentExpr rType}"
+    return u
+
+def mkCalcTrans (result resultType step stepType : Expr) : MetaM (Expr × Expr) := do
+  let some (r, a, b) ← getCalcRelation? resultType | unreachable!
+  let some (s, _, c) ← getCalcRelation? (← instantiateMVars stepType) | unreachable!
+  let u ← getRelUniv r
+  let v ← getRelUniv s
+  let (α, β, γ)       := (← inferType a, ← inferType b, ← inferType c)
+  let (u_1, u_2, u_3) := (← getLevel α, ← getLevel β, ← getLevel γ)
+  let w ← mkFreshLevelMVar
+  let t ← mkFreshExprMVar (← mkArrow α (← mkArrow γ (mkSort w)))
+  let selfType := mkAppN (Lean.mkConst ``Trans [u, v, w, u_1, u_2, u_3]) #[α, β, γ, r, s, t]
+  match (← trySynthInstance selfType) with
+  | .some self =>
+    let result := mkAppN (Lean.mkConst ``Trans.trans [u, v, w, u_1, u_2, u_3]) #[α, β, γ, r, s, t, self, a, b, c, result, step]
+    let resultType := (← instantiateMVars (← inferType result)).headBeta
+    unless (← getCalcRelation? resultType).isSome do
+      throwError "invalid 'calc' step, step result is not a relation{indentExpr resultType}"
+    return (result, resultType)
+  | _ => throwError "invalid 'calc' step, failed to synthesize `Trans` instance{indentExpr selfType}{useDiagnosticMsg}"
+
+/--
+Adds a type annotation to a hole that occurs immediately at the beginning of the term.
+This is so that coercions can trigger when elaborating the term.
+See https://github.com/leanprover/lean4/issues/2040 for further rationale.
+
+- `_ < 3` is annotated
+- `(_) < 3` is not, because it occurs after an atom
+- in `_ < _` only the first one is annotated
+- `_ + 2 < 3` is annotated (not the best heuristic, ideally we'd like to annotate `_ + 2`)
+- `lt _ 3` is not, because it occurs after an identifier
+-/
+partial def annotateFirstHoleWithType (t : Term) (type : Expr) : TermElabM Term :=
+  -- The state is true if we should annotate the immediately next hole with the type.
+  return ⟨← StateT.run' (go t) true⟩
+where
+  go (t : Syntax) := do
+    unless ← get do return t
+    match t with
+    | .node _ ``Lean.Parser.Term.hole _ =>
+      set false
+      `(($(⟨t⟩) : $(← exprToSyntax type)))
+    | .node i k as => return .node i k (← as.mapM go)
+    | _ => set false; return t
+
+/-- View of a `calcStep`. -/
+structure CalcStepView where
+  ref : Syntax
+  /-- A relation term like `a ≤ b` -/
+  term : Term
+  /-- A proof of `term` -/
+  proof : Term
+  deriving Inhabited
+
+def mkCalcFirstStepView (step0 : TSyntax ``calcFirstStep) : TermElabM CalcStepView :=
+  withRef step0 do
+  match step0  with
+  | `(calcFirstStep| $term:term)      => return { ref := step0, term := ← `($term = _), proof := ← ``(rfl)}
+  | `(calcFirstStep| $term := $proof) => return { ref := step0, term, proof}
+  | _ => throwUnsupportedSyntax
+
+def mkCalcStepViews (steps : TSyntax ``calcSteps) : TermElabM (Array CalcStepView) :=
+  match steps with
+  | `(calcSteps|
+        $step0:calcFirstStep
+        $rest*) => do
+    let mut steps := #[← mkCalcFirstStepView step0]
+    for step in rest do
+      let `(calcStep| $term := $proof) := step | throwUnsupportedSyntax
+      steps := steps.push { ref := step, term, proof }
+    return steps
+  | _ => throwUnsupportedSyntax
+
+def elabCalcSteps (steps : Array CalcStepView) : TermElabM (Expr × Expr) := do
+  let mut result? := none
+  let mut prevRhs? := none
+  for step in steps do
+    let type ← elabType <| ← do
+      if let some prevRhs := prevRhs? then
+        annotateFirstHoleWithType step.term (← inferType prevRhs)
+      else
+        pure step.term
+    let some (_, lhs, rhs) ← getCalcRelation? type |
+      throwErrorAt step.term "invalid 'calc' step, relation expected{indentExpr type}"
+    if let some prevRhs := prevRhs? then
+      unless (← isDefEqGuarded lhs prevRhs) do
+        throwErrorAt step.term "\
+          invalid 'calc' step, left-hand side is{indentD m!"{lhs} : {← inferType lhs}"}\n\
+          but previous right-hand side is{indentD m!"{prevRhs} : {← inferType prevRhs}"}"
+    let proof ← withFreshMacroScope do elabTermEnsuringType step.proof type
+    result? := some <| ← do
+      if let some (result, resultType) := result? then
+        synthesizeSyntheticMVarsUsingDefault
+        withRef step.term do mkCalcTrans result resultType proof type
+      else
+        pure (proof, type)
+    prevRhs? := rhs
+  synthesizeSyntheticMVarsUsingDefault
+  return result?.get!
+
+def throwCalcFailure (steps : Array CalcStepView) (expectedType result : Expr) : MetaM α := do
+  let resultType := (← instantiateMVars (← inferType result)).headBeta
+  let some (r, lhs, rhs) ← getCalcRelation? resultType | unreachable!
+  if let some (er, elhs, erhs) ← getCalcRelation? expectedType then
+    if ← isDefEqGuarded r er then
+      let mut failed := false
+      unless ← isDefEqGuarded lhs elhs do
+        let (lhs, elhs) ← addPPExplicitToExposeDiff lhs elhs
+        let (lhsTy, elhsTy) ← addPPExplicitToExposeDiff (← inferType lhs) (← inferType elhs)
+        logErrorAt steps[0]!.term m!"\
+          invalid 'calc' step, left-hand side is{indentD m!"{lhs} : {lhsTy}"}\n\
+          but is expected to be{indentD m!"{elhs} : {elhsTy}"}"
+        failed := true
+      unless ← isDefEqGuarded rhs erhs do
+        let (rhs, erhs) ← addPPExplicitToExposeDiff rhs erhs
+        let (rhsTy, erhsTy) ← addPPExplicitToExposeDiff (← inferType rhs) (← inferType erhs)
+        logErrorAt steps.back!.term m!"\
+          invalid 'calc' step, right-hand side is{indentD m!"{rhs} : {rhsTy}"}\n\
+          but is expected to be{indentD m!"{erhs} : {erhsTy}"}"
+        failed := true
+      if failed then
+        throwAbortTerm
+  throwTypeMismatchError "'calc' expression" expectedType resultType result
+
+/-!
+Warning! It is *very* tempting to try to improve `calc` so that it makes use of the expected type
+to unify with the LHS and RHS.
+Two people have already re-implemented `elabCalcSteps` trying to do so and then reverted the changes,
+not being aware of examples like https://github.com/leanprover/lean4/issues/2073
+
+The problem is that the expected type might need to be unfolded to get an accurate LHS and RHS.
+(Consider `≤` vs `≥`. Users expect to be able to use `calc` to prove `≥` using chained `≤`!)
+Furthermore, the types of the LHS and RHS do not need to be the same (consider `x ∈ S` as a relation),
+so we also cannot use the expected LHS and RHS as type hints.
+-/
+
+/-- Elaborator for the `calc` term mode variant. -/
+@[builtin_term_elab Lean.calc]
+def elabCalc : TermElab
+  | `(calc%$tk $steps:calcSteps), expectedType? => withRef tk do
+    let steps ← mkCalcStepViews steps
+    let (result, _) ← elabCalcSteps steps
+    ensureHasTypeWithErrorMsgs expectedType? result
+      (mkImmedErrorMsg := fun _ => throwCalcFailure steps)
+      (mkErrorMsg := fun _ => throwCalcFailure steps)
+  | _, _ => throwUnsupportedSyntax
+
+end Lean.Elab.Term

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/CheckTactic.lean

@@ -0,0 +1,86 @@
+/-
+Copyright (c) 2024 Lean FRO. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joe Hendrix
+-/
+prelude
+import Lean.Elab.Tactic.ElabTerm
+import Lean.Elab.Command
+import Lean.Elab.Tactic.Meta
+import Lean.Meta.CheckTactic
+
+/-!
+Commands to validate tactic results.
+-/
+
+namespace Lean.Elab.CheckTactic
+
+open Lean.Meta CheckTactic
+open Lean.Elab.Tactic
+open Lean.Elab.Term
+open Lean.Elab.Command
+
+@[builtin_command_elab Lean.Parser.checkTactic]
+def elabCheckTactic : CommandElab := fun stx => do
+  let `(#check_tactic $t ~> $result by $tac) := stx | throwUnsupportedSyntax
+  withoutModifyingEnv $ do
+    runTermElabM $ fun _vars => do
+      let u ← withSynthesize (postpone := .no) <| Lean.Elab.Term.elabTerm t none
+      let type ← inferType u
+      let checkGoalType ← mkCheckGoalType u type
+      let mvar ← mkFreshExprMVar (.some checkGoalType)
+      let expTerm ← Lean.Elab.Term.elabTerm result (.some type)
+      let (goals, _) ← Lean.Elab.runTactic mvar.mvarId! tac.raw
+      match goals with
+      | [] =>
+        throwErrorAt stx
+          m!"{tac} closed goal, but is expected to reduce to {indentExpr expTerm}."
+      | [next] => do
+        let (val, _, _) ← matchCheckGoalType stx (←next.getType)
+        if !(← Meta.withReducible <| isDefEq val expTerm) then
+          let (val, expTerm) ← addPPExplicitToExposeDiff val expTerm
+          throwErrorAt stx
+            m!"Term reduces to{indentExpr val}\nbut is expected to reduce to {indentExpr expTerm}"
+      | _ => do
+        throwErrorAt stx
+          m!"{tac} produced multiple goals, but is expected to reduce to {indentExpr expTerm}."
+
+@[builtin_command_elab Lean.Parser.checkTacticFailure]
+def elabCheckTacticFailure : CommandElab := fun stx => do
+  let `(#check_tactic_failure $t by $tactic) := stx | throwUnsupportedSyntax
+  withoutModifyingEnv $ do
+    runTermElabM $ fun _vars => do
+      let val ← Lean.Elab.Term.elabTerm t none
+      let type ← inferType val
+      let checkGoalType ← mkCheckGoalType val type
+      let mvar ← mkFreshExprMVar (.some checkGoalType)
+      let act := Lean.Elab.runTactic mvar.mvarId! tactic.raw
+      match ← try (Term.withoutErrToSorry (some <$> act)) catch _ => pure none with
+        | none =>
+          pure ()
+        | some (gls, _) =>
+          let ppGoal (g : MVarId) := do
+                let (val, _type, _u) ← matchCheckGoalType stx (← g.getType)
+                pure m!"{indentExpr val}"
+          let msg ←
+            match gls with
+              | [] => pure m!"{tactic} expected to fail on {t}, but closed goal."
+              | [g] =>
+                pure <| m!"{tactic} expected to fail on {t}, but returned: {←ppGoal g}"
+              | gls =>
+                let app m g := do pure <| m ++ (←ppGoal g)
+                let init := m!"{tactic} expected to fail on {t}, but returned goals:"
+                gls.foldlM (init := init) app
+          throwErrorAt stx msg
+
+@[builtin_macro Lean.Parser.checkSimp]
+def expandCheckSimp : Macro := fun stx => do
+  let `(#check_simp $t ~> $exp) := stx | Macro.throwUnsupported
+  `(command|#check_tactic $t ~> $exp by simp)
+
+@[builtin_macro Lean.Parser.checkSimpFailure]
+def expandCheckSimpFailure : Macro := fun stx => do
+  let `(#check_simp $t !~>) := stx | Macro.throwUnsupported
+  `(command|#check_tactic_failure $t by simp)
+
+end Lean.Elab.CheckTactic

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/Command.lean

@@ -0,0 +1,891 @@
+/-
+Copyright (c) 2019 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura, Gabriel Ebner
+-/
+prelude
+import Lean.Meta.Diagnostics
+import Lean.Elab.Binders
+import Lean.Elab.SyntheticMVars
+import Lean.Elab.SetOption
+import Lean.Language.Basic
+import Lean.Meta.ForEachExpr
+
+namespace Lean.Elab.Command
+
+/--
+A `Scope` records the part of the `CommandElabM` state that respects scoping,
+such as the data for `universe`, `open`, and `variable` declarations, the current namespace,
+and currently enabled options.
+The `CommandElabM` state contains a stack of scopes, and only the top `Scope`
+on the stack is read from or modified. There is always at least one `Scope` on the stack,
+even outside any `section` or `namespace`, and each new pushed `Scope`
+starts as a modified copy of the previous top scope.
+-/
+structure Scope where
+  /--
+  The component of the `namespace` or `section` that this scope is associated to.
+  For example, `section a.b.c` and `namespace a.b.c` each create three scopes with headers
+  named `a`, `b`, and `c`.
+  This is used for checking the `end` command. The "base scope" has `""` as its header.
+  -/
+  header        : String
+  /--
+  The current state of all set options at this point in the scope. Note that this is the
+  full current set of options and does *not* simply contain the options set
+  while this scope has been active.
+  -/
+  opts          : Options := {}
+  /-- The current namespace. The top-level namespace is represented by `Name.anonymous`. -/
+  currNamespace : Name := Name.anonymous
+  /-- All currently `open`ed namespaces and names. -/
+  openDecls     : List OpenDecl := []
+  /-- The current list of names for universe level variables to use for new declarations. This is managed by the `universe` command. -/
+  levelNames    : List Name := []
+  /--
+  The current list of binders to use for new declarations.
+  This is managed by the `variable` command.
+  Each binder is represented in `Syntax` form, and it is re-elaborated
+  within each command that uses this information.
+
+  This is also used by commands, such as `#check`, to create an initial local context,
+  even if they do not work with binders per se.
+  -/
+  varDecls      : Array (TSyntax ``Parser.Term.bracketedBinder) := #[]
+  /--
+  Globally unique internal identifiers for the `varDecls`.
+  There is one identifier per variable introduced by the binders
+  (recall that a binder such as `(a b c : Ty)` can produce more than one variable),
+  and each identifier is the user-provided variable name with a macro scope.
+  This is used by `TermElabM` in `Lean.Elab.Term.Context` to help with processing macros
+  that capture these variables.
+  -/
+  varUIds       : Array Name := #[]
+  /-- `include`d section variable names (from `varUIds`) -/
+  includedVars  : List Name := []
+  /-- `omit`ted section variable names (from `varUIds`) -/
+  omittedVars  : List Name := []
+  /--
+  If true (default: false), all declarations that fail to compile
+  automatically receive the `noncomputable` modifier.
+  A scope with this flag set is created by `noncomputable section`.
+
+  Recall that a new scope inherits all values from its parent scope,
+  so all sections and namespaces nested within a `noncomputable` section also have this flag set.
+  -/
+  isNoncomputable : Bool := false
+  isPublic : Bool := false
+  /--
+  Attributes that should be applied to all matching declaration in the section. Inherited from
+  parent scopes.
+  -/
+  attrs : List (TSyntax ``Parser.Term.attrInstance) := []
+  deriving Inhabited
+
+structure State where
+  env            : Environment
+  messages       : MessageLog := {}
+  scopes         : List Scope := [{ header := "" }]
+  nextMacroScope : Nat := firstFrontendMacroScope + 1
+  maxRecDepth    : Nat
+  ngen           : NameGenerator := {}
+  auxDeclNGen    : DeclNameGenerator := {}
+  infoState      : InfoState := {}
+  traceState     : TraceState := {}
+  snapshotTasks  : Array (Language.SnapshotTask Language.SnapshotTree) := #[]
+  deriving Nonempty
+
+structure Context where
+  fileName       : String
+  fileMap        : FileMap
+  currRecDepth   : Nat := 0
+  cmdPos         : String.Pos := 0
+  macroStack     : MacroStack := []
+  currMacroScope : MacroScope := firstFrontendMacroScope
+  ref            : Syntax := Syntax.missing
+  /--
+  Snapshot for incremental reuse and reporting of command elaboration. Currently only used for
+  (mutual) defs and contained tactics, in which case the `DynamicSnapshot` is a
+  `HeadersParsedSnapshot`.
+
+  Definitely resolved in `Lean.Elab.Command.elabCommandTopLevel`.
+
+  Invariant: if the bundle's `old?` is set, the context and state at the beginning of current and
+  old elaboration are identical.
+  -/
+  snap?          : Option (Language.SnapshotBundle Language.DynamicSnapshot)
+  /-- Cancellation token forwarded to `Core.cancelTk?`. -/
+  cancelTk?      : Option IO.CancelToken
+  /--
+  If set (when `showPartialSyntaxErrors` is not set and parsing failed), suppresses most elaboration
+  errors; see also `logMessage` below.
+  -/
+  suppressElabErrors : Bool := false
+
+abbrev CommandElabM := ReaderT Context $ StateRefT State $ EIO Exception
+abbrev CommandElab  := Syntax → CommandElabM Unit
+structure Linter where
+  run : Syntax → CommandElabM Unit
+  name : Name := by exact decl_name%
+
+/-
+Make the compiler generate specialized `pure`/`bind` so we do not have to optimize through the
+whole monad stack at every use site. May eventually be covered by `deriving`.
+
+Remark: see comment at TermElabM
+-/
+@[always_inline]
+instance : Monad CommandElabM := let i := inferInstanceAs (Monad CommandElabM); { pure := i.pure, bind := i.bind }
+
+/--
+Like `Core.tryCatchRuntimeEx`; runtime errors are generally used to abort term elaboration, so we do
+want to catch and process them at the command level.
+-/
+@[inline] protected def tryCatch (x : CommandElabM α) (h : Exception → CommandElabM α) :
+    CommandElabM α := do
+  try
+    x
+  catch ex =>
+    if ex.isInterrupt then
+      throw ex
+    else
+      h ex
+
+instance : MonadExceptOf Exception CommandElabM where
+  throw    := throw
+  tryCatch := Command.tryCatch
+
+def mkState (env : Environment) (messages : MessageLog := {}) (opts : Options := {}) : State := {
+  env         := env
+  messages    := messages
+  scopes      := [{ header := "", opts }]
+  maxRecDepth := maxRecDepth.get opts
+  -- Outside of declarations, fall back to a module-specific prefix
+  auxDeclNGen := { namePrefix := mkPrivateName env .anonymous }
+}
+
+/- Linters should be loadable as plugins, so store in a global IO ref instead of an attribute managed by the
+    environment (which only contains `import`ed objects). -/
+builtin_initialize lintersRef : IO.Ref (Array Linter) ← IO.mkRef #[]
+builtin_initialize registerTraceClass `Elab.lint
+
+def addLinter (l : Linter) : IO Unit := do
+  let ls ← lintersRef.get
+  lintersRef.set (ls.push l)
+
+instance : MonadInfoTree CommandElabM where
+  getInfoState      := return (← get).infoState
+  modifyInfoState f := modify fun s => { s with infoState := f s.infoState }
+
+instance : MonadEnv CommandElabM where
+  getEnv := do pure (← get).env
+  modifyEnv f := modify fun s => { s with env := f s.env }
+
+@[always_inline]
+instance : MonadOptions CommandElabM where
+  getOptions := do pure (← get).scopes.head!.opts
+
+protected def getRef : CommandElabM Syntax :=
+  return (← read).ref
+
+instance : AddMessageContext CommandElabM where
+  addMessageContext := addMessageContextPartial
+
+instance : MonadRef CommandElabM where
+  getRef := Command.getRef
+  withRef ref x := withReader (fun ctx => { ctx with ref := ref }) x
+
+instance : MonadTrace CommandElabM where
+  getTraceState := return (← get).traceState
+  modifyTraceState f := modify fun s => { s with traceState := f s.traceState }
+
+instance : AddErrorMessageContext CommandElabM where
+  add ref msg := do
+    let ctx ← read
+    let ref := getBetterRef ref ctx.macroStack
+    let msg ← addMessageContext msg
+    let msg ← addMacroStack msg ctx.macroStack
+    return (ref, msg)
+
+instance : MonadDeclNameGenerator CommandElabM where
+  getDeclNGen := return (← get).auxDeclNGen
+  setDeclNGen ngen := modify fun s => { s with auxDeclNGen := ngen }
+
+private def runCore (x : CoreM α) : CommandElabM α := do
+  let s ← get
+  let ctx ← read
+  let heartbeats ← IO.getNumHeartbeats
+  let env := Kernel.resetDiag s.env
+  let scope := s.scopes.head!
+  let coreCtx : Core.Context := {
+    fileName           := ctx.fileName
+    fileMap            := ctx.fileMap
+    currRecDepth       := ctx.currRecDepth
+    maxRecDepth        := s.maxRecDepth
+    ref                := ctx.ref
+    currNamespace      := scope.currNamespace
+    openDecls          := scope.openDecls
+    initHeartbeats     := heartbeats
+    currMacroScope     := ctx.currMacroScope
+    options            := scope.opts
+    cancelTk?          := ctx.cancelTk?
+    suppressElabErrors := ctx.suppressElabErrors }
+  let x : EIO _ _ := x.run coreCtx {
+    env
+    ngen := s.ngen
+    auxDeclNGen := s.auxDeclNGen
+    nextMacroScope := s.nextMacroScope
+    infoState.enabled := s.infoState.enabled
+    traceState := s.traceState
+    snapshotTasks := s.snapshotTasks
+  }
+  let (ea, coreS) ← liftM x
+  modify fun s => { s with
+    env                      := coreS.env
+    nextMacroScope           := coreS.nextMacroScope
+    ngen                     := coreS.ngen
+    auxDeclNGen              := coreS.auxDeclNGen
+    infoState.trees          := s.infoState.trees.append coreS.infoState.trees
+    -- we assume substitution of `assignment` has already happened, but for lazy assignments we only
+    -- do it at the very end
+    infoState.lazyAssignment := coreS.infoState.lazyAssignment
+    traceState.traces        := coreS.traceState.traces.map fun t => { t with ref := replaceRef t.ref ctx.ref }
+    snapshotTasks            := coreS.snapshotTasks
+    messages                 := s.messages ++ coreS.messages
+  }
+  return ea
+
+def liftCoreM (x : CoreM α) : CommandElabM α := do
+  MonadExcept.ofExcept (← runCore (observing x))
+
+@[inline] def liftIO {α} (x : IO α) : CommandElabM α := do
+  let ctx ← read
+  IO.toEIO (fun (ex : IO.Error) => Exception.error ctx.ref ex.toString) x
+
+instance : MonadLiftT IO CommandElabM where
+  monadLift := liftIO
+
+/-- Return the current scope. -/
+def getScope : CommandElabM Scope := do pure (← get).scopes.head!
+
+instance : MonadResolveName CommandElabM where
+  getCurrNamespace := return (← getScope).currNamespace
+  getOpenDecls     := return (← getScope).openDecls
+
+instance : MonadLog CommandElabM where
+  getRef      := getRef
+  getFileMap  := return (← read).fileMap
+  getFileName := return (← read).fileName
+  hasErrors   := return (← get).messages.hasErrors
+  logMessage msg := do
+    if (← read).suppressElabErrors then
+      -- discard elaboration errors on parse error
+      unless msg.data.hasTag (· matches `trace) do
+        return
+    let currNamespace ← getCurrNamespace
+    let openDecls ← getOpenDecls
+    let msg := { msg with data := MessageData.withNamingContext { currNamespace := currNamespace, openDecls := openDecls } msg.data }
+    modify fun s => { s with messages := s.messages.add msg }
+
+def runLinters (stx : Syntax) : CommandElabM Unit := do
+  profileitM Exception "linting" (← getOptions) do
+    withTraceNode `Elab.lint (fun _ => return m!"running linters") do
+      let linters ← lintersRef.get
+      unless linters.isEmpty do
+        for linter in linters do
+          withTraceNode `Elab.lint (fun _ => return m!"running linter: {.ofConstName linter.name}")
+              (tag := linter.name.toString) do
+            let savedState ← get
+            try
+              linter.run stx
+            catch ex =>
+              match ex with
+              | Exception.error ref msg =>
+                logException (.error ref m!"linter {.ofConstName linter.name} failed: {msg}")
+              | Exception.internal _ _ =>
+                logException ex
+            finally
+              -- TODO: it would be good to preserve even more state (#4363) but preserving info
+              -- trees currently breaks from linters adding context-less info nodes
+              modify fun s => { savedState with messages := s.messages, traceState := s.traceState }
+
+/--
+Catches and logs exceptions occurring in `x`. Unlike `try catch` in `CommandElabM`, this function
+catches interrupt exceptions as well and thus is intended for use at the top level of elaboration.
+Interrupt and abort exceptions are caught but not logged.
+-/
+@[inline] def withLoggingExceptions (x : CommandElabM Unit) : CommandElabM Unit := fun ctx ref =>
+  EIO.catchExceptions (withLogging x ctx ref) (fun _ => pure ())
+
+@[inherit_doc Core.wrapAsync]
+def wrapAsync {α β : Type} (act : α → CommandElabM β) (cancelTk? : Option IO.CancelToken) :
+    CommandElabM (α → EIO Exception β) := do
+  let ctx ← read
+  let ctx := { ctx with cancelTk? }
+  let (childNGen, parentNGen) := (← getDeclNGen).mkChild
+  setDeclNGen parentNGen
+  let st ← get
+  let st := { st with auxDeclNGen := childNGen }
+  return (act · |>.run ctx |>.run' st)
+
+open Language in
+@[inherit_doc Core.wrapAsyncAsSnapshot]
+-- `CoreM` and `CommandElabM` are too different to meaningfully share this code
+def wrapAsyncAsSnapshot {α : Type} (act : α → CommandElabM Unit) (cancelTk? : Option IO.CancelToken)
+    (desc : String := by exact decl_name%.toString) :
+    CommandElabM (α → BaseIO SnapshotTree) := do
+  let f ← wrapAsync (cancelTk? := cancelTk?) fun a => do
+    IO.FS.withIsolatedStreams (isolateStderr := Core.stderrAsMessages.get (← getOptions)) do
+      let tid ← IO.getTID
+      -- reset trace state and message log so as not to report them twice
+      modify fun st => { st with
+        messages := st.messages.markAllReported
+        traceState := { tid }
+        snapshotTasks := #[]
+      }
+      try
+        withTraceNode `Elab.async (fun _ => return desc) do
+          act a
+      catch e =>
+        logError e.toMessageData
+      finally
+        addTraceAsMessages
+      get
+  let ctx ← read
+  return fun a => do
+    match (← (f a).toBaseIO) with
+    | .ok (output, st) =>
+      let mut msgs := st.messages
+      if !output.isEmpty then
+        msgs := msgs.add {
+          fileName := ctx.fileName
+          severity := MessageSeverity.information
+          pos      := ctx.fileMap.toPosition <| ctx.ref.getPos?.getD 0
+          data     := output
+        }
+      return .mk {
+        desc
+        diagnostics := (← Language.Snapshot.Diagnostics.ofMessageLog msgs)
+        traces := st.traceState
+      } st.snapshotTasks
+    -- interrupt or abort exception as `try catch` above should have caught any others
+    | .error _ => default
+
+@[inherit_doc Core.logSnapshotTask]
+def logSnapshotTask (task : Language.SnapshotTask Language.SnapshotTree) : CommandElabM Unit :=
+  modify fun s => { s with snapshotTasks := s.snapshotTasks.push task }
+
+open Language in
+def runLintersAsync (stx : Syntax) : CommandElabM Unit := do
+  if !Elab.async.get (← getOptions) then
+    withoutModifyingEnv do
+      runLinters stx
+    return
+
+  -- linters should have access to the complete info tree and message log
+  let mut snaps := (← get).snapshotTasks
+  if let some elabSnap := (← read).snap? then
+    snaps := snaps.push { stx? := none, cancelTk? := none, task := elabSnap.new.result!.map (sync := true) toSnapshotTree }
+  let tree := SnapshotTree.mk { diagnostics := .empty } snaps
+  let treeTask ← tree.waitAll
+
+  -- We only start one task for all linters for now as most linters are fast and we simply want
+  -- to unblock elaboration of the next command
+  let cancelTk ← IO.CancelToken.new
+  let lintAct ← wrapAsyncAsSnapshot (cancelTk? := cancelTk) fun infoSt => do
+    let messages := tree.getAll.map (·.diagnostics.msgLog) |>.foldl (· ++ ·) .empty
+    -- do not double-report
+    let messages := messages.markAllReported
+    modify fun st => { st with messages := st.messages ++ messages }
+    modifyInfoState fun _ => infoSt
+    runLinters stx
+
+  let task ← BaseIO.bindTask (sync := true) (t := (← getInfoState).substituteLazy) fun infoSt =>
+    BaseIO.mapTask (t := treeTask) fun _ =>
+      lintAct infoSt
+  logSnapshotTask { stx? := none, task, cancelTk? := cancelTk }
+
+protected def getCurrMacroScope : CommandElabM Nat  := do pure (← read).currMacroScope
+protected def getMainModule     : CommandElabM Name := do pure (← getEnv).mainModule
+
+protected def withFreshMacroScope {α} (x : CommandElabM α) : CommandElabM α := do
+  let fresh ← modifyGet (fun st => (st.nextMacroScope, { st with nextMacroScope := st.nextMacroScope + 1 }))
+  withReader (fun ctx => { ctx with currMacroScope := fresh }) x
+
+instance : MonadQuotation CommandElabM where
+  getCurrMacroScope   := Command.getCurrMacroScope
+  getMainModule       := Command.getMainModule
+  withFreshMacroScope := Command.withFreshMacroScope
+
+/--
+Registers a command elaborator for the given syntax node kind.
+
+A command elaborator should have type `Lean.Elab.Command.CommandElab` (which is
+`Lean.Syntax → Lean.Elab.Term.CommandElabM Unit`), i.e. should take syntax of the given syntax
+node kind as a parameter and perform an action.
+
+The `elab_rules` and `elab` commands should usually be preferred over using this attribute
+directly.
+-/
+@[builtin_doc]
+unsafe builtin_initialize commandElabAttribute : KeyedDeclsAttribute CommandElab ←
+  mkElabAttribute CommandElab `builtin_command_elab `command_elab `Lean.Parser.Command `Lean.Elab.Command.CommandElab "command"
+
+private def mkInfoTree (elaborator : Name) (stx : Syntax) (trees : PersistentArray InfoTree) : CommandElabM InfoTree := do
+  let ctx ← read
+  let s ← get
+  let scope := s.scopes.head!
+  let tree := InfoTree.node (Info.ofCommandInfo { elaborator, stx }) trees
+  let ctx := PartialContextInfo.commandCtx {
+    env := s.env, fileMap := ctx.fileMap, mctx := {}, currNamespace := scope.currNamespace,
+    openDecls := scope.openDecls, options := scope.opts, ngen := s.ngen
+  }
+  return InfoTree.context ctx tree
+
+/--
+Disables incremental command reuse *and* reporting for `act` if `cond` is true by setting
+`Context.snap?` to `none`.
+-/
+def withoutCommandIncrementality (cond : Bool) (act : CommandElabM α) : CommandElabM α := do
+  let opts ← getOptions
+  withReader (fun ctx => { ctx with snap? := ctx.snap?.filter fun snap => Id.run do
+    if let some old := snap.old? then
+      if cond && opts.getBool `trace.Elab.reuse then
+        dbg_trace "reuse stopped: guard failed at {old.stx}"
+    return !cond
+  }) act
+
+private def elabCommandUsing (s : State) (stx : Syntax) : List (KeyedDeclsAttribute.AttributeEntry CommandElab) → CommandElabM Unit
+  | []                => withInfoTreeContext (mkInfoTree := mkInfoTree `no_elab stx) <| throwError "unexpected syntax{indentD stx}"
+  | (elabFn::elabFns) =>
+    catchInternalId unsupportedSyntaxExceptionId
+      (do
+        -- prevent unsupported commands from accidentally accessing `Context.snap?` (e.g. by nested
+        -- supported commands)
+        withoutCommandIncrementality (!(← isIncrementalElab elabFn.declName)) do
+        withInfoTreeContext (mkInfoTree := mkInfoTree elabFn.declName stx) do
+         elabFn.value stx)
+      (fun _ => do set s; elabCommandUsing s stx elabFns)
+
+/-- Elaborate `x` with `stx` on the macro stack -/
+def withMacroExpansion (beforeStx afterStx : Syntax) (x : CommandElabM α) : CommandElabM α :=
+  withInfoContext (mkInfo := pure <| .ofMacroExpansionInfo { stx := beforeStx, output := afterStx, lctx := .empty }) do
+    withReader (fun ctx => { ctx with macroStack := { before := beforeStx, after := afterStx } :: ctx.macroStack }) x
+
+instance : MonadMacroAdapter CommandElabM where
+  getCurrMacroScope := getCurrMacroScope
+  getNextMacroScope := return (← get).nextMacroScope
+  setNextMacroScope next := modify fun s => { s with nextMacroScope := next }
+
+instance : MonadRecDepth CommandElabM where
+  withRecDepth d x := withReader (fun ctx => { ctx with currRecDepth := d }) x
+  getRecDepth      := return (← read).currRecDepth
+  getMaxRecDepth   := return (← get).maxRecDepth
+
+builtin_initialize registerTraceClass `Elab.command
+
+open Language in
+/-- Snapshot after macro expansion of a command. -/
+structure MacroExpandedSnapshot extends Snapshot where
+  /-- The declaration name of the macro. -/
+  macroDecl : Name
+  /-- The expanded syntax tree. -/
+  newStx    : Syntax
+  /-- `State.nextMacroScope` after expansion. -/
+  newNextMacroScope : Nat
+  /-- Whether any traces were present after expansion. -/
+  hasTraces : Bool
+  /--
+  Follow-up elaboration snapshots, one per command if `newStx` is a sequence of commands.
+  -/
+  next : Array (SnapshotTask DynamicSnapshot)
+deriving TypeName
+open Language in
+instance : ToSnapshotTree MacroExpandedSnapshot where
+  toSnapshotTree s := ⟨s.toSnapshot, s.next.map (·.map (sync := true) toSnapshotTree)⟩
+
+partial def elabCommand (stx : Syntax) : CommandElabM Unit :=
+  try
+    go
+  finally
+    addTraceAsMessages
+where go := do
+  withLogging <| withRef stx <| withIncRecDepth <| withFreshMacroScope do
+    match stx with
+    | Syntax.node _ k args =>
+      if k == nullKind then
+        -- list of commands => elaborate in order
+        -- The parser will only ever return a single command at a time, but syntax quotations can return multiple ones
+        -- Incrementality is currently limited to the common case where the sequence is the direct
+        -- output of a macro, see below.
+        withoutCommandIncrementality true do
+          args.forM elabCommand
+      else withTraceNode `Elab.command (fun _ => return stx) (tag :=
+        -- special case: show actual declaration kind for `declaration` commands
+        (if stx.isOfKind ``Parser.Command.declaration then stx[1] else stx).getKind.toString) do
+        let s ← get
+        match (← liftMacroM <| expandMacroImpl? s.env stx) with
+        | some (decl, stxNew?) =>
+          withInfoTreeContext (mkInfoTree := mkInfoTree decl stx) do
+            let stxNew ← liftMacroM <| liftExcept stxNew?
+            withMacroExpansion stx stxNew do
+              -- Support incrementality; see also Note [Incremental Macros]
+              if let some snap := (←read).snap? then
+                -- Unpack nested commands; see `MacroExpandedSnapshot.next`
+                let cmds := if stxNew.isOfKind nullKind then stxNew.getArgs else #[stxNew]
+                let nextMacroScope := (← get).nextMacroScope
+                let hasTraces := (← getTraceState).traces.size > 0
+                let oldSnap? := do
+                  let oldSnap ← snap.old?
+                  let oldSnap ← oldSnap.val.get.toTyped? MacroExpandedSnapshot
+                  guard <| oldSnap.macroDecl == decl && oldSnap.newNextMacroScope == nextMacroScope
+                  -- check absence of traces; see Note [Incremental Macros]
+                  guard <| !oldSnap.hasTraces && !hasTraces
+                  return oldSnap
+                if snap.old?.isSome && oldSnap?.isNone then
+                  snap.old?.forM (·.val.cancelRec)
+                let oldCmds? := oldSnap?.map fun old =>
+                  if old.newStx.isOfKind nullKind then old.newStx.getArgs else #[old.newStx]
+                let cmdPromises ← cmds.mapM fun _ => IO.Promise.new
+                let cancelTk? := (← read).cancelTk?
+                snap.new.resolve <| .ofTyped {
+                  diagnostics := .empty
+                  macroDecl := decl
+                  newStx := stxNew
+                  newNextMacroScope := nextMacroScope
+                  hasTraces
+                  next := Array.zipWith (fun cmdPromise cmd =>
+                    { stx? := some cmd, task := cmdPromise.resultD default, cancelTk? }) cmdPromises cmds
+                  : MacroExpandedSnapshot
+                }
+                -- After the first command whose syntax tree changed, we must disable
+                -- incremental reuse
+                let mut reusedCmds := true
+                let opts ← getOptions
+                -- For each command, associate it with new promise and old snapshot, if any, and
+                -- elaborate recursively
+                for cmd in cmds, cmdPromise in cmdPromises, i in [0:cmds.size] do
+                  let oldCmd? := oldCmds?.bind (·[i]?)
+                  withReader ({ · with snap? := some {
+                    new := cmdPromise
+                    old? := do
+                      guard reusedCmds
+                      let old ← oldSnap?
+                      return { stx := (← oldCmd?), val := (← old.next[i]?) }
+                  } }) do
+                    if oldSnap?.isSome && (← read).snap?.isNone then
+                      oldSnap?.bind (·.next[i]?) |>.forM (·.cancelRec)
+                    elabCommand cmd
+                    -- Resolve promise for commands not supporting incrementality; waiting for
+                    -- `withAlwaysResolvedPromises` to do this could block reporting by later
+                    -- commands
+                    cmdPromise.resolve default
+                  reusedCmds := reusedCmds && oldCmd?.any (·.eqWithInfoAndTraceReuse opts cmd)
+              else
+                elabCommand stxNew
+        | _ =>
+          match commandElabAttribute.getEntries s.env k with
+          | []      =>
+            withInfoTreeContext (mkInfoTree := mkInfoTree `no_elab stx) <|
+              throwError "elaboration function for '{k}' has not been implemented"
+          | elabFns => elabCommandUsing s stx elabFns
+    | _ =>
+      withInfoTreeContext (mkInfoTree := mkInfoTree `no_elab stx) <|
+        throwError "unexpected command"
+
+builtin_initialize registerTraceClass `Elab.input
+
+/-- Option for showing elaboration errors from partial syntax errors. -/
+register_builtin_option showPartialSyntaxErrors : Bool := {
+  defValue := false
+  descr    := "show elaboration errors from partial syntax trees (i.e. after parser recovery)"
+}
+
+builtin_initialize
+  registerTraceClass `Elab.info
+  registerTraceClass `Elab.snapshotTree
+
+/--
+`elabCommand` wrapper that should be used for the initial invocation, not for recursive calls after
+macro expansion etc.
+-/
+def elabCommandTopLevel (stx : Syntax) : CommandElabM Unit := withRef stx do profileitM Exception "elaboration" (← getOptions) do
+  withReader ({ · with suppressElabErrors :=
+    stx.hasMissing && !showPartialSyntaxErrors.get (← getOptions) }) do
+  let initMsgs ← modifyGet fun st => (st.messages, { st with messages := {} })
+  let initInfoTrees ← getResetInfoTrees
+  try
+    try
+      -- We should *not* factor out `elabCommand`'s `withLogging` to here since it would make its error
+      -- recovery more coarse. In particular, if `c` in `set_option ... in $c` fails, the remaining
+      -- `end` command of the `in` macro would be skipped and the option would be leaked to the outside!
+      elabCommand stx
+    finally
+      -- Make sure `snap?` is definitely resolved; we do not use it for reporting as `#guard_msgs` may
+      -- be the caller of this function and add new messages and info trees
+      if let some snap := (← read).snap? then
+        snap.new.resolve default
+
+    -- Run the linters, unless `#guard_msgs` is present, which is special and runs `elabCommandTopLevel` itself,
+    -- so it is a "super-top-level" command. This is the only command that does this, so we just special case it here
+    -- rather than engineer a general solution.
+    unless (stx.find? (·.isOfKind ``Lean.guardMsgsCmd)).isSome do
+      withLogging do
+        runLintersAsync stx
+  finally
+    let msgs := (← get).messages
+    modify fun st => { st with
+      messages := initMsgs ++ msgs
+      infoState := { st.infoState with trees := initInfoTrees ++ st.infoState.trees }
+    }
+
+/-- Adapt a syntax transformation to a regular, command-producing elaborator. -/
+def adaptExpander (exp : Syntax → CommandElabM Syntax) : CommandElab := fun stx => do
+  let stx' ← exp stx
+  withMacroExpansion stx stx' <| elabCommand stx'
+
+private def getVarDecls (s : State) : Array Syntax :=
+  s.scopes.head!.varDecls
+
+instance {α} : Inhabited (CommandElabM α) where
+  default := throw default
+
+/--
+The environment linter framework needs to be able to run linters with the same context
+as `liftTermElabM`, so we expose that context as a public function here.
+-/
+def mkMetaContext : Meta.Context := {
+  config := { foApprox := true, ctxApprox := true, quasiPatternApprox := true }
+}
+
+open Lean.Parser.Term in
+/-- Return identifier names in the given bracketed binder. -/
+def getBracketedBinderIds : Syntax → CommandElabM (Array Name)
+  | `(bracketedBinderF|($ids* $[: $ty?]? $(_annot?)?)) => return ids.map Syntax.getId
+  | `(bracketedBinderF|{$ids* $[: $ty?]?})             => return ids.map Syntax.getId
+  | `(bracketedBinderF|⦃$ids* : $_⦄)                   => return ids.map Syntax.getId
+  | `(bracketedBinderF|[$id : $_])                     => return #[id.getId]
+  | `(bracketedBinderF|[$_])                           => return #[Name.anonymous]
+  | _                                                  => throwUnsupportedSyntax
+
+private def mkTermContext (ctx : Context) (s : State) : CommandElabM Term.Context := do
+  let scope      := s.scopes.head!
+  let mut sectionVars := {}
+  for id in (← scope.varDecls.flatMapM getBracketedBinderIds), uid in scope.varUIds do
+    sectionVars := sectionVars.insert id uid
+  return {
+    macroStack             := ctx.macroStack
+    sectionVars            := sectionVars
+    isNoncomputableSection := scope.isNoncomputable }
+
+/--
+Lift the `TermElabM` monadic action `x` into a `CommandElabM` monadic action.
+
+Note that `x` is executed with an empty message log. Thus, `x` cannot modify/view messages produced by
+previous commands.
+
+If you need to access the free variables corresponding to the ones declared using the `variable` command,
+consider using `runTermElabM`.
+
+Recall that `TermElabM` actions can automatically lift `MetaM` and `CoreM` actions.
+Example:
+```
+import Lean
+
+open Lean Elab Command Meta
+
+def printExpr (e : Expr) : MetaM Unit := do
+  IO.println s!"{← ppExpr e} : {← ppExpr (← inferType e)}"
+
+#eval
+  liftTermElabM do
+    printExpr (mkConst ``Nat)
+```
+-/
+def liftTermElabM (x : TermElabM α) : CommandElabM α := do
+  let ctx ← read
+  let s   ← get
+  -- dbg_trace "heartbeats: {heartbeats}"
+  let scope := s.scopes.head!
+  -- We execute `x` with an empty message log. Thus, `x` cannot modify/view messages produced by previous commands.
+  -- This is useful for implementing `runTermElabM` where we use `Term.resetMessageLog`
+  let x : TermElabM _  := withSaveInfoContext x
+  -- make sure `observing` below also catches runtime exceptions (like we do by default in
+  -- `CommandElabM`)
+  let _ := MonadAlwaysExcept.except (m := TermElabM)
+  let x : MetaM _ := (observing (try x finally Meta.reportDiag)).run (← mkTermContext ctx s) { levelNames := scope.levelNames }
+  let x : CoreM _ := x.run mkMetaContext {}
+  let ((ea, _), _) ← runCore x
+  MonadExcept.ofExcept ea
+
+instance : MonadEval TermElabM CommandElabM where
+  monadEval := liftTermElabM
+
+/--
+Execute the monadic action `elabFn xs` as a `CommandElabM` monadic action, where `xs` are free variables
+corresponding to all active scoped variables declared using the `variable` command.
+
+This method is similar to `liftTermElabM`, but it elaborates all scoped variables declared using the `variable`
+command.
+
+Example:
+```
+import Lean
+
+open Lean Elab Command Meta
+
+variable {α : Type u} {f : α → α}
+variable (n : Nat)
+
+#eval
+  runTermElabM fun xs => do
+    for x in xs do
+      IO.println s!"{← ppExpr x} : {← ppExpr (← inferType x)}"
+```
+-/
+def runTermElabM (elabFn : Array Expr → TermElabM α) : CommandElabM α := do
+  let scope ← getScope
+  liftTermElabM <|
+    Term.withAutoBoundImplicit <|
+      Term.elabBinders scope.varDecls fun xs => do
+        -- We need to synthesize postponed terms because this is a checkpoint for the auto-bound implicit feature
+        -- If we don't use this checkpoint here, then auto-bound implicits in the postponed terms will not be handled correctly.
+        Term.synthesizeSyntheticMVarsNoPostponing
+        let mut sectionFVars := {}
+        for uid in scope.varUIds, x in xs do
+          sectionFVars := sectionFVars.insert uid x
+        withReader ({ · with sectionFVars := sectionFVars }) do
+          -- We don't want to store messages produced when elaborating `(getVarDecls s)` because they have already been saved when we elaborated the `variable`(s) command.
+          -- So, we use `Core.resetMessageLog`.
+          Core.resetMessageLog
+          let xs ← Term.addAutoBoundImplicits xs none
+          if xs.all (·.isFVar) then
+            Term.withoutAutoBoundImplicit <| elabFn xs
+          else
+            -- Abstract any mvars that appear in `xs` using `mkForallFVars` (the type `mkSort levelZero` is an arbitrary placeholder)
+            -- and then rebuild the local context from scratch.
+            -- Resetting prevents the local context from including the original fvars from `xs`.
+            let ctxType ← Meta.mkForallFVars' xs (mkSort levelZero)
+            Meta.withLCtx {} {} <| Meta.forallBoundedTelescope ctxType xs.size fun xs _ =>
+              Term.withoutAutoBoundImplicit <| elabFn xs
+
+private def liftAttrM {α} (x : AttrM α) : CommandElabM α := do
+  liftCoreM x
+
+/--
+Return the stack of all currently active scopes:
+the base scope always comes last; new scopes are prepended in the front.
+In particular, the current scope is always the first element.
+-/
+def getScopes : CommandElabM (List Scope) := do
+  pure (← get).scopes
+
+def modifyScope (f : Scope → Scope) : CommandElabM Unit :=
+  modify fun s => { s with
+    scopes := match s.scopes with
+      | h::t => f h :: t
+      | []   => unreachable!
+  }
+
+def withScope (f : Scope → Scope) (x : CommandElabM α) : CommandElabM α := do
+  match (← get).scopes with
+  | [] => x
+  | h :: t =>
+    try
+      modify fun s => { s with scopes := f h :: t }
+      x
+    finally
+      modify fun s => { s with scopes := h :: t }
+
+def getLevelNames : CommandElabM (List Name) :=
+  return (← getScope).levelNames
+
+def addUnivLevel (idStx : Syntax) : CommandElabM Unit := withRef idStx do
+  let id := idStx.getId
+  let levelNames ← getLevelNames
+  if levelNames.elem id then
+    throwAlreadyDeclaredUniverseLevel id
+  else
+    modifyScope fun scope => { scope with levelNames := id :: scope.levelNames }
+
+end Elab.Command
+
+open Elab Command MonadRecDepth
+
+private def liftCommandElabMCore (cmd : CommandElabM α) (throwOnError : Bool) : CoreM α := do
+  let s : Core.State ← get
+  let ctx : Core.Context ← read
+  let (a, commandState) ←
+    cmd.run {
+      fileName := ctx.fileName
+      fileMap := ctx.fileMap
+      currRecDepth := ctx.currRecDepth
+      currMacroScope := ctx.currMacroScope
+      ref := ctx.ref
+      snap? := none
+      cancelTk? := ctx.cancelTk?
+      suppressElabErrors := ctx.suppressElabErrors
+    } |>.run {
+      env := s.env
+      nextMacroScope := s.nextMacroScope
+      maxRecDepth := ctx.maxRecDepth
+      ngen := s.ngen
+      auxDeclNGen := s.auxDeclNGen
+      scopes := [{ header := "", opts := ctx.options }]
+      infoState.enabled := s.infoState.enabled
+    }
+  modify fun coreState => { coreState with
+    env := commandState.env
+    nextMacroScope := commandState.nextMacroScope
+    ngen := commandState.ngen
+    auxDeclNGen := commandState.auxDeclNGen
+    traceState.traces := coreState.traceState.traces ++ commandState.traceState.traces
+  }
+  if throwOnError then
+    if let some err := commandState.messages.toArray.find? (·.severity matches .error) then
+      throwError err.data
+  modify fun coreState => { coreState with
+    infoState.trees := coreState.infoState.trees.append commandState.infoState.trees
+    messages := coreState.messages ++ commandState.messages
+  }
+  return a
+
+/--
+Lifts an action in `CommandElabM` into `CoreM`, updating the environment,
+messages, info trees, traces, the name generator, and macro scopes.
+The action is run in a context with an empty message log, empty trace state, and empty info trees.
+
+If `throwOnError` is true, then if the command produces an error message, it is converted into an exception.
+In this case, info trees and messages are not carried over.
+
+Commands that modify the processing of subsequent commands,
+such as `open` and `namespace` commands,
+only have an effect for the remainder of the `CommandElabM` computation passed here,
+and do not affect subsequent commands.
+
+*Warning:* when using this from `MetaM` monads, the caches are *not* reset.
+If the command defines new instances for example, you should use `Lean.Meta.resetSynthInstanceCache`
+to reset the instance cache.
+While the `modifyEnv` function for `MetaM` clears its caches entirely,
+`liftCommandElabM` has no way to reset these caches.
+-/
+def liftCommandElabM (cmd : CommandElabM α) (throwOnError : Bool := true) : CoreM α := do
+  -- `observing` ensures that if `cmd` throws an exception we still thread state back to `CoreM`.
+  MonadExcept.ofExcept (← liftCommandElabMCore (observing cmd) throwOnError)
+
+/--
+Given a command elaborator `cmd`, returns a new command elaborator that
+first evaluates any local `set_option ... in ...` clauses and then invokes `cmd` on what remains.
+-/
+partial def withSetOptionIn (cmd : CommandElab) : CommandElab := fun stx => do
+  if stx.getKind == ``Lean.Parser.Command.in &&
+     stx[0].getKind == ``Lean.Parser.Command.set_option then
+      let opts ← Elab.elabSetOption stx[0][1] stx[0][3]
+      Command.withScope (fun scope => { scope with opts }) do
+        withSetOptionIn cmd stx[2]
+  else
+    cmd stx
+
+export Elab.Command (Linter addLinter)
+
+end Lean

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/ComputedFields.lean

@@ -0,0 +1,246 @@
+/-
+Copyright (c) 2022 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Gabriel Ebner
+-/
+prelude
+import Lean.Meta.Constructions.CasesOn
+import Lean.Compiler.ImplementedByAttr
+import Lean.Elab.PreDefinition.WF.Eqns
+
+/-!
+# Computed fields
+
+Inductives can have computed fields which are recursive functions whose value
+is stored in the constructors, and can be accessed in constant time.
+
+```lean
+inductive Exp
+  | hole
+  | app (x y : Exp)
+with
+  f : Exp → Nat
+    | .hole => 42
+    | .app x y => f x + f y
+
+-- `Exp.f x` runs in constant time, even if `x` is a dag-like value
+```
+
+This file implements the computed fields feature by simulating it via
+`implemented_by`.  The main function is `setComputedFields`.
+-/
+
+namespace Lean.Elab.ComputedFields
+open Meta
+
+/--
+Marks a function as a computed field of an inductive.
+
+Computed fields are specified in the with-block of an inductive type declaration. They can be used
+to allow certain values to be computed only once at the time of construction and then later be
+accessed immediately.
+
+Example:
+```
+inductive NatList where
+  | nil
+  | cons : Nat → NatList → NatList
+with
+  @[computed_field] sum : NatList → Nat
+  | .nil => 0
+  | .cons x l => x + l.sum
+  @[computed_field] length : NatList → Nat
+  | .nil => 0
+  | .cons _ l => l.length + 1
+```
+-/
+@[builtin_doc]
+builtin_initialize computedFieldAttr : TagAttribute ←
+  registerTagAttribute `computed_field "Marks a function as a computed field of an inductive" fun _ => do
+    unless (← getOptions).getBool `elaboratingComputedFields do
+      throwError "The @[computed_field] attribute can only be used in the with-block of an inductive"
+
+def mkUnsafeCastTo (expectedType : Expr) (e : Expr) : MetaM Expr :=
+  mkAppOptM ``unsafeCast #[none, expectedType, e]
+
+def isScalarField (ctor : Name) : CoreM Bool :=
+  return (← getConstInfoCtor ctor).numFields == 0 -- TODO
+
+structure Context extends InductiveVal where
+  lparams : List Level
+  params : Array Expr
+  compFields : Array Name
+  compFieldVars : Array Expr
+  indices : Array Expr
+  val : Expr
+
+abbrev M := ReaderT Context MetaM
+
+-- TODO: doesn't work if match contains patterns like `.app (.app a b) c`
+def getComputedFieldValue (computedField : Name) (ctorTerm : Expr) : MetaM Expr := do
+  let ctorName := ctorTerm.getAppFn.constName!
+  let ind ← getConstInfoInduct (← getConstInfoCtor ctorName).induct
+  let val ← mkAppOptM computedField (.replicate (ind.numParams+ind.numIndices) none ++ #[some ctorTerm])
+  let val ←
+    if let some wfEqn := WF.eqnInfoExt.find? (← getEnv) computedField then
+      pure <| mkAppN (wfEqn.value.instantiateLevelParams wfEqn.levelParams val.getAppFn.constLevels!) val.getAppArgs
+    else
+      unfoldDefinition val
+  let val ← whnfHeadPred val (return ctorTerm.occurs ·)
+  if !ctorTerm.occurs val then return val
+  throwError "computed field {computedField} does not reduce for constructor {ctorName}"
+
+def validateComputedFields : M Unit := do
+  let {compFieldVars, indices, val ..} ← read
+  for cf in compFieldVars do
+    let ty ← inferType cf
+    if ty.containsFVar val.fvarId! then
+      throwError "computed field {cf}'s type must not depend on value{indentExpr ty}"
+    if indices.any (ty.containsFVar ·.fvarId!) then
+      throwError "computed field {cf}'s type must not depend on indices{indentExpr ty}"
+
+def mkImplType : M Unit := do
+  let {name, isUnsafe, type, ctors, levelParams, numParams, lparams, params, compFieldVars, ..} ← read
+  addDecl <| .inductDecl levelParams numParams
+    (isUnsafe := isUnsafe) -- Note: inlining is disabled with unsafe inductives
+    [{ name := name ++ `_impl, type,
+       ctors := ← ctors.mapM fun ctor => do
+         forallTelescope (← inferType (mkAppN (mkConst ctor lparams) params)) fun fields retTy => do
+           let retTy := mkAppN (mkConst (name ++ `_impl) lparams) retTy.getAppArgs
+           let type ← mkForallFVars (params ++ (if ← isScalarField ctor then #[] else compFieldVars) ++ fields) retTy
+           return { name := ctor ++ `_impl, type } }]
+
+def overrideCasesOn : M Unit := do
+  let {name, numIndices, ctors, lparams, params, compFieldVars, ..} ← read
+  let casesOn ← getConstInfoDefn (mkCasesOnName name)
+  mkCasesOn (name ++ `_impl)
+  let value ←
+    forallTelescope (← instantiateForall casesOn.type params) fun xs constMotive => do
+      let (indices, major, minors) := (xs[1...=numIndices].toArray,
+        xs[numIndices+1]!, xs[(numIndices+2)...*].toArray)
+      let majorImplTy := mkAppN (mkConst (name ++ `_impl) lparams) (params ++ indices)
+      mkLambdaFVars (params ++ xs) <|
+        mkAppN (mkConst (mkCasesOnName (name ++ `_impl))
+            (casesOn.levelParams.map mkLevelParam)) <|
+        params ++
+        #[← withLocalDeclD `a majorImplTy fun majorImpl => do
+          withLetDecl `m (← inferType constMotive) constMotive fun m => do
+          mkLambdaFVars (#[m] ++ indices ++ #[majorImpl]) m] ++
+        indices ++ #[← mkUnsafeCastTo majorImplTy major] ++
+        (← (minors.zip ctors.toArray).mapM fun (minor, ctor) => do
+          forallTelescope (← inferType minor) fun args _ => do
+            mkLambdaFVars ((if ← isScalarField ctor then #[] else compFieldVars) ++ args)
+              (← mkUnsafeCastTo constMotive (mkAppN minor args)))
+  let nameOverride := mkCasesOnName name ++ `_override
+  addDecl <| .defnDecl { casesOn with
+    name := nameOverride
+    all  := [nameOverride]
+    value
+    hints  := .opaque
+    safety := .unsafe
+  }
+  setInlineAttribute (mkCasesOnName name ++ `_override)
+  setImplementedBy (mkCasesOnName name) (mkCasesOnName name ++ `_override)
+
+def overrideConstructors : M Unit := do
+  let {ctors, levelParams, lparams, params, compFields, ..} ← read
+  for ctor in ctors do
+    forallTelescope (← inferType (mkAppN (mkConst ctor lparams) params)) fun fields retTy => do
+    let ctorTerm := mkAppN (mkConst ctor lparams) (params ++ fields)
+    let computedFieldVals ←
+      -- elaborating a non-exposed def body
+      withoutExporting do
+        if ← isScalarField ctor then pure #[] else
+          compFields.mapM (getComputedFieldValue · ctorTerm)
+    addDecl <| .defnDecl {
+      name := ctor ++ `_override
+      levelParams
+      type := ← inferType (mkConst ctor lparams)
+      value := ← mkLambdaFVars (params ++ fields) <| ← mkUnsafeCastTo retTy <|
+        mkAppN (mkConst (ctor ++ `_impl) lparams) (params ++ computedFieldVals ++ fields)
+      hints := .opaque
+      safety := .unsafe
+    }
+    setImplementedBy ctor (ctor ++ `_override)
+    if ← isScalarField ctor then setInlineAttribute (ctor ++ `_override)
+
+def overrideComputedFields : M Unit := do
+  let {name, levelParams, ctors, compFields, compFieldVars, lparams, params, indices, val ..} ← read
+  withLocalDeclD `x (mkAppN (mkConst (name ++ `_impl) lparams) (params ++ indices)) fun xImpl => do
+  for cfn in compFields, cf in compFieldVars do
+    if isExtern (← getEnv) cfn then
+      compileDecls [cfn]
+      continue
+    let cases ←
+      -- elaborating a non-exposed def body
+      withoutExporting do
+        ctors.toArray.mapM fun ctor => do
+          forallTelescope (← inferType (mkAppN (mkConst ctor lparams) params)) fun fields _ => do
+            if ← isScalarField ctor then
+              mkLambdaFVars fields <|
+                ← getComputedFieldValue cfn (mkAppN (mkConst ctor lparams) (params ++ fields))
+            else
+              mkLambdaFVars (compFieldVars ++ fields) cf
+    addDecl <| .defnDecl {
+      name := cfn ++ `_override
+      levelParams
+      type := ← mkForallFVars (params ++ indices ++ #[val]) (← inferType cf)
+      value := ← mkLambdaFVars (params ++ indices ++ #[val]) <|
+        ← mkAppOptM (mkCasesOnName (name ++ `_impl))
+          ((params ++ #[← mkLambdaFVars (indices.push xImpl) (← inferType cf)] ++ indices ++
+            #[← mkUnsafeCastTo (← inferType xImpl) val] ++ cases).map some)
+      safety := .unsafe
+      hints := .opaque
+    }
+    setImplementedBy cfn (cfn ++ `_override)
+
+def mkComputedFieldOverrides (declName : Name) (compFields : Array Name) : MetaM Unit := do
+  let ind ← getConstInfoInduct declName
+  if ind.ctors.length < 2 then
+    throwError "computed fields require at least two constructors"
+  let lparams := ind.levelParams.map mkLevelParam
+  forallTelescope ind.type fun paramsIndices _ => do
+  withLocalDeclD `x (mkAppN (mkConst ind.name lparams) paramsIndices) fun val => do
+    let params := paramsIndices[*...ind.numParams].toArray
+    let indices := paramsIndices[ind.numParams...*].toArray
+    let compFieldVars := compFields.map fun fieldDeclName =>
+      (fieldDeclName.updatePrefix .anonymous,
+        fun _ => do inferType (← mkAppM fieldDeclName (params ++ indices ++ #[val])))
+    withLocalDeclsD compFieldVars fun compFieldVars => do
+      let ctx := { ind with lparams, params, compFields, compFieldVars, indices, val }
+      ReaderT.run (r := ctx) do
+        validateComputedFields
+        mkImplType
+        overrideCasesOn
+        overrideConstructors
+        overrideComputedFields
+
+/--
+Sets the computed fields for a block of mutual inductives,
+adding the implementation via `implemented_by`.
+
+The `computedFields` argument contains a pair
+for every inductive in the mutual block,
+consisting of the name of the inductive
+and the names of the associated computed fields.
+-/
+def setComputedFields (computedFields : Array (Name × Array Name)) : MetaM Unit := do
+  for (indName, computedFieldNames) in computedFields do
+    for computedFieldName in computedFieldNames do
+      unless computedFieldAttr.hasTag (← getEnv) computedFieldName do
+        logError m!"'{computedFieldName}' must be tagged with @[computed_field]"
+    mkComputedFieldOverrides indName computedFieldNames
+
+  -- Once all the implemented_by infrastructure is set up, compile everything.
+  compileDecls <| computedFields.toList.map fun (indName, _) =>
+    mkCasesOnName indName ++ `_override
+
+  let mut toCompile := #[]
+  for (declName, computedFields) in computedFields do
+    let ind ← getConstInfoInduct declName
+    for ctor in ind.ctors do
+      toCompile := toCompile.push (ctor ++ `_override)
+    for fieldName in computedFields do
+      unless isExtern (← getEnv) fieldName do
+        toCompile := toCompile.push <| fieldName ++ `_override
+  compileDecls toCompile.toList

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/Config.lean

@@ -0,0 +1,61 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.Meta.Basic
+
+namespace Lean.Elab.Term
+
+/--
+  Set `isDefEq` configuration for the elaborator.
+  Note that we enable all approximations but `quasiPatternApprox`
+
+  In Lean3 and Lean 4, we used to use the quasi-pattern approximation during elaboration.
+  The example:
+  ```
+  def ex : StateT δ (StateT σ Id) σ :=
+  monadLift (get : StateT σ Id σ)
+  ```
+  demonstrates why it produces counterintuitive behavior.
+  We have the `Monad-lift` application:
+  ```
+  @monadLift ?m ?n ?c ?α (get : StateT σ id σ) : ?n ?α
+  ```
+  It produces the following unification problem when we process the expected type:
+  ```
+  ?n ?α =?= StateT δ (StateT σ id) σ
+  ==> (approximate using first-order unification)
+  ?n := StateT δ (StateT σ id)
+  ?α := σ
+  ```
+  Then, we need to solve:
+  ```
+  ?m ?α =?= StateT σ id σ
+  ==> instantiate metavars
+  ?m σ =?= StateT σ id σ
+  ==> (approximate since it is a quasi-pattern unification constraint)
+  ?m := fun σ => StateT σ id σ
+  ```
+  Note that the constraint is not a Milner pattern because σ is in
+  the local context of `?m`. We are ignoring the other possible solutions:
+  ```
+  ?m := fun σ' => StateT σ id σ
+  ?m := fun σ' => StateT σ' id σ
+  ?m := fun σ' => StateT σ id σ'
+  ```
+
+  We need the quasi-pattern approximation for elaborating recursor-like expressions (e.g., dependent `match with` expressions).
+
+  If we had use first-order unification, then we would have produced
+  the right answer: `?m := StateT σ id`
+
+  Haskell would work on this example since it always uses
+  first-order unification.
+-/
+def setElabConfig (cfg : Meta.Config) : Meta.Config :=
+  { cfg with foApprox := true, ctxApprox := true, constApprox := false, quasiPatternApprox := false }
+
+
+end Lean.Elab.Term

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/DeclModifiers.lean

@@ -0,0 +1,306 @@
+/-
+Copyright (c) 2020 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura, Sebastian Ullrich
+-/
+prelude
+import Lean.Structure
+import Lean.Elab.Attributes
+import Lean.DocString.Add
+
+namespace Lean.Elab
+
+/--
+Ensure the environment does not contain a declaration with name `declName`.
+Recall that a private declaration cannot shadow a non-private one and vice-versa, although
+they internally have different names.
+-/
+def checkNotAlreadyDeclared {m} [Monad m] [MonadEnv m] [MonadError m] [MonadInfoTree m] (declName : Name) : m Unit := do
+  let env ← getEnv
+  let addInfo declName := do
+    pushInfoLeaf <| .ofTermInfo {
+      elaborator := .anonymous, lctx := {}, expectedType? := none
+      stx := (← getRef)
+      expr := (← mkConstWithLevelParams declName)
+    }
+  if env.contains declName then
+    addInfo declName
+    match privateToUserName? declName with
+    | none          => throwError "'{.ofConstName declName true}' has already been declared"
+    | some declName => throwError "private declaration '{.ofConstName declName true}' has already been declared"
+  if isReservedName env (privateToUserName declName) || isReservedName env (mkPrivateName (← getEnv) declName) then
+    throwError "'{declName}' is a reserved name"
+  if env.contains (mkPrivateName env declName) then
+    addInfo (mkPrivateName env declName)
+    throwError "a private declaration '{.ofConstName declName true}' has already been declared"
+  match privateToUserName? declName with
+  | none => pure ()
+  | some declName =>
+    if env.contains declName then
+      addInfo declName
+      throwError "a non-private declaration '{.ofConstName declName true}' has already been declared"
+
+/-- Declaration visibility modifier. That is, whether a declaration is regular, protected or private. -/
+inductive Visibility where
+  | regular | «protected» | «private» | «public»
+  deriving Inhabited
+
+instance : ToString Visibility where
+  toString
+    | .regular   => "regular"
+    | .private   => "private"
+    | .protected => "protected"
+    | .public    => "public"
+
+def Visibility.isPrivate : Visibility → Bool
+  | .private   => true
+  | _          => false
+
+def Visibility.isProtected : Visibility → Bool
+  | .protected => true
+  | _          => false
+
+def Visibility.isPublic : Visibility → Bool
+  | .public    => true
+  | _          => false
+
+def Visibility.isInferredPublic (env : Environment) (v : Visibility) : Bool :=
+  if env.isExporting || !env.header.isModule then !v.isPrivate else v.isPublic
+
+/-- Whether a declaration is default, partial or nonrec. -/
+inductive RecKind where
+  | «partial» | «nonrec» | default
+  deriving Inhabited
+
+/-- Codegen-relevant modifiers. -/
+inductive ComputeKind where
+  | regular | «meta» | «noncomputable»
+  deriving Inhabited
+
+/-- Flags and data added to declarations (eg docstrings, attributes, `private`, `unsafe`, `partial`, ...). -/
+structure Modifiers where
+  /-- Input syntax, used for adjusting declaration range (unless missing) -/
+  stx             : TSyntax ``Parser.Command.declModifiers := ⟨.missing⟩
+  docString?      : Option (TSyntax ``Parser.Command.docComment) := none
+  visibility      : Visibility := Visibility.regular
+  computeKind     : ComputeKind := .regular
+  recKind         : RecKind := RecKind.default
+  isUnsafe        : Bool := false
+  attrs           : Array Attribute := #[]
+  deriving Inhabited
+
+def Modifiers.isPrivate (m : Modifiers) : Bool := m.visibility.isPrivate
+def Modifiers.isProtected (m : Modifiers) : Bool := m.visibility.isProtected
+def Modifiers.isPublic (m : Modifiers) : Bool := m.visibility.isPublic
+def Modifiers.isInferredPublic (env : Environment) (m : Modifiers) : Bool :=
+  m.visibility.isInferredPublic env
+
+def Modifiers.isPartial : Modifiers → Bool
+  | { recKind := .partial, .. }  => true
+  | _                            => false
+
+/--
+Whether the declaration is explicitly `partial` or should be considered as such via `meta`. In the
+latter case, elaborators should not produce an error if partialty is unnecessary.
+-/
+def Modifiers.isInferredPartial : Modifiers → Bool
+  | { recKind := .partial, .. }  => true
+  | { computeKind := .meta, .. } => true
+  | _                            => false
+
+def Modifiers.isNonrec : Modifiers → Bool
+  | { recKind := .nonrec, .. } => true
+  | _                          => false
+
+def Modifiers.isMeta (m : Modifiers) : Bool :=
+  m.computeKind matches .meta
+
+def Modifiers.isNoncomputable (m : Modifiers) : Bool :=
+  m.computeKind matches .noncomputable
+
+/-- Adds attribute `attr` in `modifiers` -/
+def Modifiers.addAttr (modifiers : Modifiers) (attr : Attribute) : Modifiers :=
+  { modifiers with attrs := modifiers.attrs.push attr }
+
+/-- Adds attribute `attr` in `modifiers`, at the beginning -/
+def Modifiers.addFirstAttr (modifiers : Modifiers) (attr : Attribute) : Modifiers :=
+  { modifiers with attrs := #[attr] ++ modifiers.attrs }
+
+/-- Filters attributes using `p` -/
+def Modifiers.filterAttrs (modifiers : Modifiers) (p : Attribute → Bool) : Modifiers :=
+  { modifiers with attrs := modifiers.attrs.filter p }
+
+instance : ToFormat Modifiers := ⟨fun m =>
+  let components : List Format :=
+    (match m.docString? with
+     | some str => [f!"/--{str}-/"]
+     | none     => [])
+    ++ (match m.visibility with
+     | .regular   => []
+     | .private   => [f!"private"]
+     | .protected => [f!"protected"]
+     | .public    => [f!"public"])
+    ++ (match m.computeKind with | .regular => [] | .meta => [f!"meta"] | .noncomputable => [f!"noncomputable"])
+    ++ (match m.recKind with | RecKind.partial => [f!"partial"] | RecKind.nonrec => [f!"nonrec"] | _ => [])
+    ++ (if m.isUnsafe then [f!"unsafe"] else [])
+    ++ m.attrs.toList.map (fun attr => format attr)
+  Format.bracket "{" (Format.joinSep components ("," ++ Format.line)) "}"⟩
+
+instance : ToString Modifiers := ⟨toString ∘ format⟩
+
+/--
+Retrieve doc string from `stx` of the form `(docComment)?`.
+-/
+def expandOptDocComment? [Monad m] [MonadError m] (optDocComment : Syntax) : m (Option String) :=
+  match optDocComment.getOptional? with
+  | none   => return none
+  | some s => match s[1] with
+    | .atom _ val => return some (val.extract 0 (val.endPos - ⟨2⟩))
+    | _           => throwErrorAt s "unexpected doc string{indentD s[1]}"
+
+section Methods
+
+variable [Monad m] [MonadEnv m] [MonadResolveName m] [MonadError m] [MonadMacroAdapter m] [MonadRecDepth m] [MonadTrace m] [MonadOptions m] [AddMessageContext m] [MonadLog m] [MonadInfoTree m] [MonadLiftT IO m]
+
+/-- Elaborate declaration modifiers (i.e., attributes, `partial`, `private`, `protected`, `unsafe`, `meta`, `noncomputable`, doc string)-/
+def elabModifiers (stx : TSyntax ``Parser.Command.declModifiers) : m Modifiers := do
+  let docCommentStx := stx.raw[0]
+  let attrsStx      := stx.raw[1]
+  let visibilityStx := stx.raw[2]
+  let computeKind   :=
+    if stx.raw[3].isNone then
+      .regular
+    else if stx.raw[3][0].getKind == ``Parser.Command.meta then
+      .meta
+    else
+      .noncomputable
+  let unsafeStx     := stx.raw[4]
+  let recKind       :=
+    if stx.raw[5].isNone then
+      RecKind.default
+    else if stx.raw[5][0].getKind == ``Parser.Command.partial then
+      RecKind.partial
+    else
+      RecKind.nonrec
+  let docString? := docCommentStx.getOptional?.map TSyntax.mk
+  let visibility ← match visibilityStx.getOptional? with
+    | none   => pure .regular
+    | some v =>
+      match v with
+      | `(Parser.Command.visibility| private) => pure .private
+      | `(Parser.Command.visibility| protected) => pure .protected
+      | `(Parser.Command.visibility| public) => pure .public
+      | _ => throwErrorAt v "unexpected visibility modifier"
+  let attrs ← match attrsStx.getOptional? with
+    | none       => pure #[]
+    | some attrs => elabDeclAttrs attrs
+  return {
+    stx, docString?, visibility, computeKind, recKind, attrs,
+    isUnsafe        := !unsafeStx.isNone
+  }
+
+/--
+Ensure the function has not already been declared, and apply the given visibility setting to `declName`.
+If `private`, return the updated name using our internal encoding for private names.
+If `protected`, register `declName` as protected in the environment.
+-/
+def applyVisibility (visibility : Visibility) (declName : Name) : m Name := do
+  let mut declName := declName
+  if !visibility.isInferredPublic (← getEnv) then
+    declName := mkPrivateName (← getEnv) declName
+  checkNotAlreadyDeclared declName
+  if visibility matches .protected then
+    modifyEnv fun env => addProtected env declName
+  pure declName
+
+def checkIfShadowingStructureField (declName : Name) : m Unit := do
+  match declName with
+  | Name.str pre .. =>
+    if isStructure (← getEnv) pre then
+      let fieldNames := getStructureFieldsFlattened (← getEnv) pre
+      for fieldName in fieldNames do
+        if pre ++ fieldName == declName then
+          throwError "invalid declaration name '{declName}', structure '{pre}' has field '{fieldName}'"
+  | _ => pure ()
+
+def mkDeclName (currNamespace : Name) (modifiers : Modifiers) (shortName : Name) : m (Name × Name) := do
+  let mut shortName := shortName
+  let mut currNamespace := currNamespace
+  let view := extractMacroScopes shortName
+  let name := view.name
+  let isRootName := (`_root_).isPrefixOf name
+  if name == `_root_ then
+    throwError "invalid declaration name `_root_`, `_root_` is a prefix used to refer to the 'root' namespace"
+  let declName := if isRootName then { view with name := name.replacePrefix `_root_ Name.anonymous }.review else currNamespace ++ shortName
+  if isRootName then
+    let .str p s := name | throwError "invalid declaration name '{name}'"
+    shortName := Name.mkSimple s
+    currNamespace := p.replacePrefix `_root_ Name.anonymous
+  checkIfShadowingStructureField declName
+  let declName ← applyVisibility modifiers.visibility declName
+  match modifiers.visibility with
+  | Visibility.protected =>
+    match currNamespace with
+    | .str _ s => return (declName, Name.mkSimple s ++ shortName)
+    | _ =>
+      if shortName.isAtomic then
+        throwError "protected declarations must be in a namespace"
+      return (declName, shortName)
+  | _ => return (declName, shortName)
+
+/--
+  `declId` is of the form
+  ```
+  leading_parser ident >> optional (".{" >> sepBy1 ident ", " >> "}")
+  ```
+  but we also accept a single identifier to users to make macro writing more convenient .
+-/
+def expandDeclIdCore (declId : Syntax) : Name × Syntax :=
+  if declId.isIdent then
+    (declId.getId, mkNullNode)
+  else
+    let id             := declId[0].getId
+    let optUnivDeclStx := declId[1]
+    (id, optUnivDeclStx)
+
+/-- `expandDeclId` resulting type. -/
+structure ExpandDeclIdResult where
+  /-- Short name for recursively referring to the declaration. -/
+  shortName  : Name
+  /-- Fully qualified name that will be used to name the declaration in the kernel. -/
+  declName   : Name
+  /-- Universe parameter names provided using the `universe` command and `.{...}` notation. -/
+  levelNames : List Name
+
+/--
+Given a declaration identifier (e.g., `ident (".{" ident,+ "}")?`) that may contain explicit universe parameters
+- Ensure the new universe parameters do not shadow universe parameters declared using `universe` command.
+- Create the fully qualified named for the declaration using the current namespace, and given `modifiers`
+- Create a short version for recursively referring to the declaration. Recall that the `protected` modifier affects the generation of the short name.
+
+The result also contains the universe parameters provided using `universe` command, and the `.{...}` notation.
+
+This commands also stores the doc string stored in `modifiers`.
+-/
+def expandDeclId (currNamespace : Name) (currLevelNames : List Name) (declId : Syntax) (modifiers : Modifiers) : m ExpandDeclIdResult := do
+  -- ident >> optional (".{" >> sepBy1 ident ", " >> "}")
+  let (shortName, optUnivDeclStx) := expandDeclIdCore declId
+  let levelNames ← if optUnivDeclStx.isNone then
+    pure currLevelNames
+  else
+    let extraLevels := optUnivDeclStx[1].getArgs.getEvenElems
+    extraLevels.foldlM
+      (fun levelNames idStx =>
+        let id := idStx.getId
+        if levelNames.elem id then
+          withRef idStx <| throwAlreadyDeclaredUniverseLevel id
+        else
+          pure (id :: levelNames))
+      currLevelNames
+  let (declName, shortName) ← withRef declId <| mkDeclName currNamespace modifiers shortName
+  addDocString' declName modifiers.docString?
+  return { shortName := shortName, declName := declName, levelNames := levelNames }
+
+end Methods
+
+end Lean.Elab

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/DeclNameGen.lean

@@ -0,0 +1,264 @@
+/-
+Copyright (c) 2024 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Kyle Miller
+-/
+prelude
+import Lean.Elab.Command
+
+/-!
+# Name generator for declarations
+
+This module provides functionality to generate a name for a declaration using its binders and its type.
+This is used to generate names for anonymous instances.
+
+It uses heuristics to generate an informative but terse name given its namespace, supplied binders, and type.
+It tries to make these relatively unique,
+and it uses suffixes derived from the module to ensure cross-project uniqueness
+when the instance doesn't refer to anything defined in the current project.
+
+The name generator can be thought of as a kind of pretty printer, rendering an expression in textual form.
+The general structure of this generator is
+1. `Lean.Elab.Command.NameGen.winnowExpr` takes an expression and re-uses `Expr` as a data structure
+   to record the "Syntax"-like structure.
+2. `Lean.Elab.Command.NameGen.mkBaseNameCore` formats the result of that as a string.
+   It actually does a bit more computation than that, since it further removes duplicate expressions,
+   reporting only the first occurrence of each subexpression.
+-/
+
+namespace Lean.Elab.Command
+
+open Meta
+
+namespace NameGen
+
+/--
+If `e` is an application of a projection to a parent structure, returns the term being projected.
+-/
+private def getParentProjArg (e : Expr) : MetaM (Option Expr) := do
+  let .const c@(.str _ field) _ := e.getAppFn | return none
+  let env ← getEnv
+  let some info := env.getProjectionFnInfo? c | return none
+  unless e.getAppNumArgs == info.numParams + 1 do return none
+  let some (.ctorInfo cVal) := env.find? info.ctorName | return none
+  if isSubobjectField? env cVal.induct (Name.mkSimple field) |>.isNone then return none
+  return e.appArg!
+
+/--
+Strips out universes and arguments we decide are unnecessary for naming.
+The resulting expression can have loose fvars and be mangled in other ways.
+Expressions can also be replaced by `.bvar 0` if they shouldn't be mentioned.
+-/
+private partial def winnowExpr (e : Expr) : MetaM Expr := do
+  let rec visit (e : Expr) : MonadCacheT Expr Expr MetaM Expr := checkCache e fun _ => do
+    if ← isProof e then
+      return .bvar 0
+    match e with
+    | .app .. =>
+      if let some e' ← getParentProjArg e then
+        return (← visit e')
+      e.withApp fun f args => do
+        -- Visit only the explicit arguments to `f` and also its type (and type family) arguments.
+        -- The reason we visit type arguments is so that, for example, `Decidable (_ < _)` has
+        -- a chance to insert type information. Type families are for reporting things such as type constructors and monads.
+        let mut fty ← inferType f
+        let mut j := 0
+        let mut e' ← visit f
+        for h : i in [0:args.size] do
+          unless fty.isForall do
+            fty ← withTransparency .all <| whnf <| fty.instantiateRevRange j i args
+            j := i
+          let .forallE _ _ fty' bi := fty | failure
+          fty := fty'
+          let arg := args[i]
+          if ← pure bi.isExplicit <||> (pure !arg.isSort <&&> isTypeFormer arg) then
+            unless (← isProof arg) do
+              e' := .app e' (← visit arg)
+        return e'
+    | .forallE n ty body bi =>
+      withLocalDecl n bi ty fun arg => do
+        -- In a dependent forall the body implies `ty`, so we won't mention it.
+        let ty' ← if body.hasLooseBVars then pure (.bvar 0) else visit ty
+        return .forallE n ty' (← visit (body.instantiate1 arg)) bi
+    | .lam n ty body bi =>
+      if let some e := Expr.etaExpandedStrict? e then
+        visit e
+      else
+        withLocalDecl n bi ty fun arg => do
+          -- Don't record the `.lam` since `ty` should be recorded elsewhere in the expression.
+          visit (body.instantiate1 arg)
+    | .letE _n _t v b _ => visit (b.instantiate1 v)
+    | .sort .. =>
+      if e.isProp then return .sort levelZero
+      else if e.isType then return .sort levelOne
+      else return .sort (.param `u)
+    | .const name .. => return .const name []
+    | .mdata _ e' => visit e'
+    | _ => return .bvar 0
+  visit e |>.run
+
+/--
+State for name generation.
+-/
+private structure MkNameState where
+  /-- Keeps track of expressions already visited so that we do not include them again. -/
+  seen : ExprSet := {}
+  /-- Keeps track of constants that appear in the generated name. -/
+  consts : NameSet := {}
+
+/--
+Monad for name generation.
+-/
+private abbrev MkNameM := StateRefT MkNameState MetaM
+
+/--
+Core algorithm for generating a name. The provided expression should be a winnowed expression.
+
+- `omitTopForall` if true causes "Forall" to not be included if the binding type results in an empty string.
+-/
+private def mkBaseNameCore (e : Expr) (omitTopForall : Bool := false) : MkNameM String :=
+  visit e omitTopForall
+where
+  visit (e : Expr) (omitTopForall : Bool := false) : MkNameM String := do
+    if (← get).seen.contains e then
+      return ""
+    else
+      let s ← visit' e omitTopForall
+      modify fun st => {st with seen := st.seen.insert e}
+      return s
+  visit' (e : Expr) (omitTopForall : Bool) : MkNameM String := do
+    match e with
+    | .const name .. =>
+      modify (fun st => {st with consts := st.consts.insert name})
+      return match name.eraseMacroScopes with
+              | .str _ str => str.capitalize
+              | _ => ""
+    | .app f x => (· ++ ·) <$> visit f <*> visit x
+    | .forallE _ ty body _ =>
+      let sty ← visit ty
+      if omitTopForall && sty == "" then
+        visit body true
+      else
+        ("Forall" ++ sty ++ ·) <$> visit body
+    | .sort .zero => return "Prop"
+    | .sort (.succ _) => return "Type"
+    | .sort _ => return "Sort"
+    | _ => return ""
+
+/--
+Generate a name, while naming the top-level foralls using "Of".
+The provided expression should be a winnowed expression.
+-/
+private partial def mkBaseNameAux (e : Expr) : MkNameM String := do
+  let (foralls, sb) ← visit e
+  return sb ++ String.join foralls
+where
+  visit (e : Expr) : MkNameM (List String × String) := do
+    match e with
+    | .forallE _ ty body _ =>
+      let (foralls, sb) ← visit body
+      let st ← mkBaseNameCore ty (omitTopForall := true)
+      if st == "" then
+        return (foralls, sb)
+      else
+        return (("Of" ++ st) :: foralls, sb)
+    | _ => return ([], ← mkBaseNameCore e)
+
+/--
+Adds all prefixes of `ns` as seen constants.
+-/
+private def visitNamespace (ns : Name) : MkNameM Unit := do
+  match ns with
+  | .anonymous => pure ()
+  | .num ns' _ => visitNamespace ns'
+  | .str ns' _ =>
+    let env ← getEnv
+    if env.contains ns then
+      modify fun st => {st with seen := st.seen.insert (.const ns []), consts := st.consts.insert ns}
+    visitNamespace ns'
+
+/--
+Given an expression, generates a "base name" for a declaration.
+The top-level foralls in `e` are treated as being binders, so use the `...Of...` naming convention.
+The current namespace is used to seed the seen expressions with each prefix of the namespace that's a global constant.
+
+Collects all constants that contribute to the name in the `MkInstM` state.
+This can be used to decide whether to further transform the generated name;
+in particular, this enables checking whether the generated name mentions declarations
+from the current module or project.
+-/
+def mkBaseName (e : Expr) : MkNameM String := do
+  let e ← instantiateMVars e
+  visitNamespace (← getCurrNamespace)
+  mkBaseNameAux (← winnowExpr e)
+
+/--
+Converts a module name into a suffix. Includes a leading `_`,
+so for example `Lean.Elab.DefView` becomes `_lean_elab_defView`.
+-/
+private def moduleToSuffix : Name → String
+  | .anonymous => ""
+  | .num n _ => moduleToSuffix n
+  | .str n s => moduleToSuffix n ++ "_" ++ s.decapitalize
+
+/--
+Uses heuristics to generate an informative but terse base name for a term of the given type, using `mkBaseName`.
+Makes use of the current namespace.
+It tries to make these names relatively unique ecosystem-wide,
+and it adds suffixes using the current module if the resulting name doesn't refer to anything defined in this module.
+
+If any constant in `type` has a name with macro scopes, then the result will be a name with fresh macro scopes.
+While in this case we could skip the naming heuristics, we still want informative names for debugging purposes.
+-/
+def mkBaseNameWithSuffix (pre : String) (type : Expr) : MetaM Name := do
+  let (name, st) ← mkBaseName type |>.run {}
+  let name := pre ++ name
+  let project := (← getMainModule).getRoot
+  -- Collect the modules for each constant that appeared.
+  let modules ← st.consts.foldM (init := Array.mkEmpty st.consts.size) fun mods name => return mods.push (← findModuleOf? name)
+  -- We can avoid adding the suffix if the instance refers to module-local names.
+  let isModuleLocal := modules.any Option.isNone
+  -- We can also avoid adding the full module suffix if the instance refers to "project"-local names.
+  let isProjectLocal := isModuleLocal || modules.any fun mod? => mod?.map (·.getRoot) == project
+  let name := Name.mkSimple <|
+    if !isProjectLocal then
+      s!"{name}{moduleToSuffix project}"
+    else
+      name
+  if Option.isSome <| type.find? (fun e => if let .const n _ := e then n.hasMacroScopes else false) then
+    mkFreshUserName name
+  else
+    return name
+
+/--
+Elaborates the binders and type and then uses `mkBaseNameWithSuffix` to generate a name.
+Furthermore, uses `mkUnusedBaseName` on the result.
+-/
+def mkBaseNameWithSuffix' (pre : String) (binders : Array Syntax) (type : Syntax) : TermElabM Name := do
+  let name ←
+    try
+      Term.withAutoBoundImplicit <| Term.elabBinders binders fun binds => Term.withoutErrToSorry do
+        let ty ← mkForallFVars binds (← Term.elabType type)
+        mkBaseNameWithSuffix pre ty
+    catch _ =>
+      mkFreshUserName <| Name.mkSimple pre
+  liftMacroM <| mkUnusedBaseName name
+
+end NameGen
+
+/--
+Generates an instance name for a declaration that has the given binders and type.
+It tries to make these names relatively unique ecosystem-wide.
+
+Note that this elaborates the binders and the type.
+This means that when elaborating an instance declaration, we elaborate these twice.
+-/
+def mkInstanceName (binders : Array Syntax) (type : Syntax) : CommandElabM Name := do
+  let savedState ← get
+  try
+    -- Unfortunately we can't include any of the binders from `runTermElabM` since, without
+    -- elaborating the body of the instance, we have no idea which of these binders are
+    -- actually used.
+    runTermElabM fun _ => NameGen.mkBaseNameWithSuffix' "inst" binders type
+  finally
+    set savedState

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/DeclUtil.lean

@@ -0,0 +1,86 @@
+/-
+Copyright (c) 2020 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura, Sebastian Ullrich
+-/
+prelude
+import Lean.Meta.Basic
+import Lean.Meta.Check
+
+namespace Lean.Meta
+
+def forallTelescopeCompatibleAux (k : Array Expr → Expr → Expr → MetaM α) : Nat → Expr → Expr → Array Expr → MetaM α
+  | 0, type₁, type₂, xs   => k xs type₁ type₂
+  | i+1, type₁, type₂, xs => do
+    let type₁ ← whnf type₁
+    let type₂ ← whnf type₂
+    match type₁, type₂ with
+    | .forallE n₁ d₁ b₁ c₁, .forallE n₂ d₂ b₂ c₂ =>
+      -- Remark: we use `mkIdent` to ensure macroscopes do not leak into error messages
+      unless c₁ == c₂ do
+        throwError "binder annotation mismatch at parameter '{mkIdent n₁}'"
+      /-
+      Remark: recall that users may suppress parameter names for instance implicit arguments.
+      A fresh name (with macro scopes) is generated in this case. Thus, we allow the names
+      to be different in this case. See issue #4310.
+      -/
+      unless n₁ == n₂ || (c₁.isInstImplicit && n₁.hasMacroScopes && n₂.hasMacroScopes) do
+        throwError "parameter name mismatch '{mkIdent n₁}', expected '{mkIdent n₂}'"
+      unless (← isDefEq d₁ d₂) do
+        throwError "parameter '{mkIdent n₁}' {← mkHasTypeButIsExpectedMsg d₁ d₂}"
+      withLocalDecl n₁ c₁ d₁ fun x =>
+        let type₁ := b₁.instantiate1 x
+        let type₂ := b₂.instantiate1 x
+        forallTelescopeCompatibleAux k i type₁ type₂ (xs.push x)
+    | _, _ => throwError "unexpected number of parameters"
+
+/-- Given two forall-expressions `type₁` and `type₂`, ensure the first `numParams` parameters are compatible, and
+    then execute `k` with the parameters and remaining types. -/
+def forallTelescopeCompatible [Monad m] [MonadControlT MetaM m] (type₁ type₂ : Expr) (numParams : Nat) (k : Array Expr → Expr → Expr → m α) : m α :=
+  controlAt MetaM fun runInBase =>
+    forallTelescopeCompatibleAux (fun xs type₁ type₂ => runInBase $ k xs type₁ type₂) numParams type₁ type₂ #[]
+
+end Meta
+
+namespace Elab
+
+def expandOptDeclSig (stx : Syntax) : Syntax × Option Syntax :=
+  -- many Term.bracketedBinder >> Term.optType
+  let binders := stx[0]
+  let optType := stx[1] -- optional (leading_parser " : " >> termParser)
+  if optType.isNone then
+    (binders, none)
+  else
+    let typeSpec := optType[0]
+    (binders, some typeSpec[1])
+
+def expandDeclSig (stx : Syntax) : Syntax × Syntax :=
+  -- many Term.bracketedBinder >> Term.typeSpec
+  let binders  := stx[0]
+  let typeSpec := stx[1]
+  (binders, typeSpec[1])
+
+/--
+Sort the given list of `usedParams` using the following order:
+- If it is an explicit level in `allUserParams`, then use user-given order.
+- All other levels come in lexicographic order after these.
+
+Remark: `scopeParams` are the universe params introduced using the `universe` command. `allUserParams` contains
+the universe params introduced using the `universe` command *and* the `.{...}` notation.
+
+Remark: this function return an exception if there is an `u` not in `usedParams`, that is in `allUserParams` but not in `scopeParams`.
+
+Remark: `scopeParams` and `allUserParams` are in reverse declaration order. That is, the head is the last declared parameter.
+-/
+def sortDeclLevelParams (scopeParams : List Name) (allUserParams : List Name) (usedParams : Array Name) : Except String (List Name) :=
+  match allUserParams.find? fun u => !usedParams.contains u && !scopeParams.elem u with
+  | some u => throw s!"unused universe parameter '{u}'"
+  | none   =>
+    -- Recall that `allUserParams` (like `scopeParams`) are in reverse order. That is, the last declared universe is the first element of the list.
+    -- The following `foldl` will reverse the elements and produce a list of universe levels using the user given order.
+    let result := allUserParams.foldl (fun result levelName => if usedParams.elem levelName then levelName :: result else result) []
+    let remaining := usedParams.filter (fun levelParam => !allUserParams.elem levelParam)
+    let remaining := remaining.qsort Name.lt
+    return result ++ remaining.toList
+
+end Lean.Elab

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/Declaration.lean

@@ -0,0 +1,347 @@
+/-
+Copyright (c) 2020 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura, Sebastian Ullrich
+-/
+prelude
+import Lean.Util.CollectLevelParams
+import Lean.Elab.DeclUtil
+import Lean.Elab.DefView
+import Lean.Elab.MutualDef
+import Lean.Elab.MutualInductive
+import Lean.Elab.DeclarationRange
+namespace Lean.Elab.Command
+
+open Meta
+
+private def ensureValidNamespace (name : Name) : MacroM Unit := do
+  match name with
+  | .str p s =>
+    if s == "_root_" then
+      Macro.throwError s!"invalid namespace '{name}', '_root_' is a reserved namespace"
+    ensureValidNamespace p
+  | .num .. => Macro.throwError s!"invalid namespace '{name}', it must not contain numeric parts"
+  | .anonymous => return ()
+
+private def setDeclIdName (declId : Syntax) (nameNew : Name) : Syntax :=
+  let (id, _) := expandDeclIdCore declId
+  -- We should not update the name of `def _root_.` declarations
+  assert! !(`_root_).isPrefixOf id
+  let idStx := mkIdent nameNew |>.raw.setInfo declId.getHeadInfo
+  if declId.isIdent then
+    idStx
+  else
+    declId.setArg 0 idStx
+
+/-- Return `true` if `stx` is a `Command.declaration`, and it is a definition that always has a name. -/
+private def isNamedDef (stx : Syntax) : Bool :=
+  if !stx.isOfKind ``Lean.Parser.Command.declaration then
+    false
+  else
+    let decl := stx[1]
+    let k := decl.getKind
+    k == ``Lean.Parser.Command.abbrev ||
+    k == ``Lean.Parser.Command.definition ||
+    k == ``Lean.Parser.Command.theorem ||
+    k == ``Lean.Parser.Command.opaque ||
+    k == ``Lean.Parser.Command.axiom ||
+    k == ``Lean.Parser.Command.inductive ||
+    k == ``Lean.Parser.Command.classInductive ||
+    k == ``Lean.Parser.Command.structure
+
+/-- Return `true` if `stx` is an `instance` declaration command -/
+private def isInstanceDef (stx : Syntax) : Bool :=
+  stx.isOfKind ``Lean.Parser.Command.declaration &&
+  stx[1].getKind == ``Lean.Parser.Command.instance
+
+/-- Return `some name` if `stx` is a definition named `name` -/
+private def getDefName? (stx : Syntax) : Option Name := do
+  if isNamedDef stx then
+    let (id, _) := expandDeclIdCore stx[1][1]
+    some id
+  else if isInstanceDef stx then
+    let optDeclId := stx[1][3]
+    if optDeclId.isNone then none
+    else
+      let (id, _) := expandDeclIdCore optDeclId[0]
+      some id
+  else
+    none
+
+/--
+Update the name of the given definition.
+This function assumes `stx` is not a nameless instance.
+-/
+private def setDefName (stx : Syntax) (name : Name) : Syntax :=
+  if isNamedDef stx then
+    stx.setArg 1 <| stx[1].setArg 1 <| setDeclIdName stx[1][1] name
+  else if isInstanceDef stx then
+    -- We never set the name of nameless instance declarations
+    assert! !stx[1][3].isNone
+    stx.setArg 1 <| stx[1].setArg 3 <| stx[1][3].setArg 0 <| setDeclIdName stx[1][3][0] name
+  else
+    stx
+
+/--
+  Given declarations such as `@[...] def Foo.Bla.f ...` return `some (Foo.Bla, @[...] def f ...)`
+  Remark: if the id starts with `_root_`, we return `none`.
+-/
+private def expandDeclNamespace? (stx : Syntax) : MacroM (Option (Name × Syntax)) := do
+  let some name := getDefName? stx | return none
+  if (`_root_).isPrefixOf name then
+    ensureValidNamespace (name.replacePrefix `_root_ Name.anonymous)
+    return none
+  let scpView := extractMacroScopes name
+  match scpView.name with
+  | .str .anonymous _ => return none
+  | .str pre shortName => return some (pre, setDefName stx { scpView with name := .mkSimple shortName }.review)
+  | _ => return none
+
+def elabAxiom (modifiers : Modifiers) (stx : Syntax) : CommandElabM Unit := do
+  -- leading_parser "axiom " >> declId >> declSig
+  let declId             := stx[1]
+  let (binders, typeStx) := expandDeclSig stx[2]
+  runTermElabM fun vars => do
+    let scopeLevelNames ← Term.getLevelNames
+    let ⟨shortName, declName, allUserLevelNames⟩ ← Term.expandDeclId (← getCurrNamespace) scopeLevelNames declId modifiers
+    addDeclarationRangesForBuiltin declName modifiers.stx stx
+    Term.withAutoBoundImplicit do
+    Term.withAutoBoundImplicitForbiddenPred (fun n => shortName == n) do
+    Term.withDeclName declName <| Term.withLevelNames allUserLevelNames <| Term.elabBinders binders.getArgs fun xs => do
+      Term.applyAttributesAt declName modifiers.attrs AttributeApplicationTime.beforeElaboration
+      let type ← Term.elabType typeStx
+      Term.synthesizeSyntheticMVarsNoPostponing
+      let xs ← Term.addAutoBoundImplicits xs (declId.getTailPos? (canonicalOnly := true))
+      let type ← instantiateMVars type
+      let type ← mkForallFVars xs type
+      let type ← mkForallFVars vars type (usedOnly := true)
+      let type ← Term.levelMVarToParam type
+      let usedParams  := collectLevelParams {} type |>.params
+      match sortDeclLevelParams scopeLevelNames allUserLevelNames usedParams with
+      | Except.error msg      => throwErrorAt stx msg
+      | Except.ok levelParams =>
+        let type ← instantiateMVars type
+        let decl := Declaration.axiomDecl {
+          name        := declName,
+          levelParams := levelParams,
+          type        := type,
+          isUnsafe    := modifiers.isUnsafe
+        }
+        trace[Elab.axiom] "{declName} : {type}"
+        Term.ensureNoUnassignedMVars decl
+        addDecl decl
+        withSaveInfoContext do  -- save new env
+          Term.addTermInfo' declId (← mkConstWithLevelParams declName) (isBinder := true)
+        Term.applyAttributesAt declName modifiers.attrs AttributeApplicationTime.afterTypeChecking
+        if isExtern (← getEnv) declName then
+          compileDecl decl
+        Term.applyAttributesAt declName modifiers.attrs AttributeApplicationTime.afterCompilation
+
+/--
+Macro that expands a declaration with a complex name into an explicit `namespace` block.
+Implementing this step as a macro means that reuse checking is handled by `elabCommand`.
+ -/
+@[builtin_macro Lean.Parser.Command.declaration]
+def expandNamespacedDeclaration : Macro := fun stx => do
+  match (← expandDeclNamespace? stx) with
+  | some (ns, newStx) => do
+    -- Limit ref variability for incrementality; see Note [Incremental Macros]
+    let declTk := stx[1][0]
+    let ns := mkIdentFrom declTk ns
+    withRef declTk `(namespace $ns $(⟨newStx⟩) end $ns)
+  | none => Macro.throwUnsupported
+
+@[builtin_command_elab declaration, builtin_incremental]
+def elabDeclaration : CommandElab := fun stx => do
+  withExporting (isExporting := (← getScope).isPublic) do
+  let modifiers : TSyntax ``Parser.Command.declModifiers := ⟨stx[0]⟩
+  let decl     := stx[1]
+  let declKind := decl.getKind
+  if isDefLike decl then
+    -- only case implementing incrementality currently
+    elabMutualDef #[stx]
+  else withoutCommandIncrementality true do
+    let modifiers ← elabModifiers modifiers
+    withExporting (isExporting := modifiers.isInferredPublic (← getEnv)) do
+      if declKind == ``Lean.Parser.Command.«axiom» then
+        elabAxiom modifiers decl
+      else if declKind == ``Lean.Parser.Command.«inductive»
+          || declKind == ``Lean.Parser.Command.classInductive
+          || declKind == ``Lean.Parser.Command.«structure» then
+        elabInductive modifiers decl
+      else
+        throwError "unexpected declaration"
+
+/-- Return true if all elements of the mutual-block are definitions/theorems/abbrevs. -/
+private def isMutualDef (stx : Syntax) : Bool :=
+  stx[1].getArgs.all fun elem =>
+    let decl := elem[1]
+    isDefLike decl
+
+private def isMutualPreambleCommand (stx : Syntax) : Bool :=
+  let k := stx.getKind
+  k == ``Lean.Parser.Command.variable ||
+  k == ``Lean.Parser.Command.universe ||
+  k == ``Lean.Parser.Command.check ||
+  k == ``Lean.Parser.Command.set_option ||
+  k == ``Lean.Parser.Command.open
+
+private partial def splitMutualPreamble (elems : Array Syntax) : Option (Array Syntax × Array Syntax) :=
+  let rec loop (i : Nat) : Option (Array Syntax × Array Syntax) :=
+    if h : i < elems.size then
+      if isMutualPreambleCommand elems[i] then
+        loop (i+1)
+      else if i == 0 then
+        none -- `mutual` block does not contain any preamble commands
+      else
+        some (elems[*...i], elems[i...elems.size])
+    else
+      none -- a `mutual` block containing only preamble commands is not a valid `mutual` block
+  loop 0
+
+/--
+Find the common namespace for the given names.
+Example:
+```
+findCommonPrefix [`Lean.Elab.eval, `Lean.mkConst, `Lean.Elab.Tactic.evalTactic]
+-- `Lean
+```
+-/
+def findCommonPrefix (ns : List Name) : Name :=
+  match ns with
+  | [] => .anonymous
+  | n :: ns => go n ns
+where
+  go (n : Name) (ns : List Name) : Name :=
+    match n with
+    | .anonymous => .anonymous
+    | _ => match ns with
+      | [] => n
+      | n' :: ns => go (findCommon n.components n'.components) ns
+  findCommon (as bs : List Name) : Name :=
+    match as, bs with
+    | a :: as, b :: bs => if a == b then a ++ findCommon as bs else .anonymous
+    | _, _ => .anonymous
+
+
+@[builtin_macro Lean.Parser.Command.mutual]
+def expandMutualNamespace : Macro := fun stx => do
+  let mut nss := #[]
+  for elem in stx[1].getArgs do
+    match (← expandDeclNamespace? elem) with
+    | none        => Macro.throwUnsupported
+    | some (n, _) => nss := nss.push n
+  let common := findCommonPrefix nss.toList
+  if common.isAnonymous then Macro.throwUnsupported
+  let elemsNew ← stx[1].getArgs.mapM fun elem => do
+    let some name := getDefName? elem | unreachable!
+    let view := extractMacroScopes name
+    let nameNew := { view with name := view.name.replacePrefix common .anonymous }.review
+    return setDefName elem nameNew
+  let ns := mkIdentFrom stx common
+  let stxNew := stx.setArg 1 (mkNullNode elemsNew)
+  `(namespace $ns $(⟨stxNew⟩) end $ns)
+
+@[builtin_macro Lean.Parser.Command.mutual]
+def expandMutualElement : Macro := fun stx => do
+  let mut elemsNew := #[]
+  let mut modified := false
+  for elem in stx[1].getArgs do
+    -- Don't trigger the `expandNamespacedDecl` macro, the namespace is handled by the mutual def
+    -- elaborator directly instead
+    if elem.isOfKind ``Parser.Command.declaration then
+      continue
+    match (← expandMacro? elem) with
+    | some elemNew => elemsNew := elemsNew.push elemNew; modified := true
+    | none         => elemsNew := elemsNew.push elem
+  if modified then
+    return stx.setArg 1 (mkNullNode elemsNew)
+  else
+    Macro.throwUnsupported
+
+@[builtin_macro Lean.Parser.Command.mutual]
+def expandMutualPreamble : Macro := fun stx =>
+  match splitMutualPreamble stx[1].getArgs with
+  | none => Macro.throwUnsupported
+  | some (preamble, rest) => do
+    let secCmd    ← `(section)
+    let newMutual := stx.setArg 1 (mkNullNode rest)
+    let endCmd    ← `(end)
+    return mkNullNode (#[secCmd] ++ preamble ++ #[newMutual] ++ #[endCmd])
+
+@[builtin_command_elab «mutual», builtin_incremental]
+def elabMutual : CommandElab := fun stx => do
+  withExporting (isExporting := (← getScope).isPublic) do
+  if isMutualDef stx then
+    -- only case implementing incrementality currently
+    elabMutualDef stx[1].getArgs
+  else withoutCommandIncrementality true do
+    if ← isMutualInductive stx then
+      elabMutualInductive stx[1].getArgs
+    else
+      throwError "invalid mutual block: either all elements of the block must be inductive/structure declarations, or they must all be definitions/theorems/abbrevs"
+
+/- leading_parser "attribute " >> "[" >> sepBy1 (eraseAttr <|> Term.attrInstance) ", " >> "]" >> many1 ident -/
+@[builtin_command_elab «attribute»] def elabAttr : CommandElab := fun stx => do
+  let mut attrInsts := #[]
+  let mut toErase := #[]
+  for attrKindStx in stx[2].getSepArgs do
+    if attrKindStx.getKind == ``Lean.Parser.Command.eraseAttr then
+      let attrName := attrKindStx[1].getId.eraseMacroScopes
+      if isAttribute (← getEnv) attrName then
+        toErase := toErase.push attrName
+      else
+        logErrorAt attrKindStx m!"unknown attribute [{attrName}]"
+    else
+      attrInsts := attrInsts.push attrKindStx
+  let attrs ← elabAttrs attrInsts
+  let idents := stx[4].getArgs
+  for ident in idents do withRef ident <| liftTermElabM do
+    /-
+    HACK to allow `attribute` command to disable builtin simprocs.
+    TODO: find a better solution. Example: have some "fake" declaration
+    for builtin simprocs.
+    -/
+    let declNames ←
+      try
+        realizeGlobalConstWithInfos ident
+      catch _ =>
+        let name := ident.getId.eraseMacroScopes
+        if (← Simp.isBuiltinSimproc name) then
+          pure [name]
+        else
+          throwUnknownConstantAt ident name
+    let declName ← ensureNonAmbiguous ident declNames
+    Term.applyAttributes declName attrs
+    for attrName in toErase do
+      Attribute.erase declName attrName
+
+@[builtin_command_elab Lean.Parser.Command.«initialize»] def elabInitialize : CommandElab
+  | stx@`($declModifiers:declModifiers $kw:initializeKeyword $[$id? : $type? ←]? $doSeq) => do
+    let attrId := mkIdentFrom stx <| if kw.raw[0].isToken "initialize" then `init else `builtin_init
+    if let (some id, some type) := (id?, type?) then
+      let `(Parser.Command.declModifiersT| $[$doc?:docComment]? $[@[$attrs?,*]]? $(vis?)? $[unsafe%$unsafe?]?) := stx[0]
+        | throwErrorAt declModifiers "invalid initialization command, unexpected modifiers"
+      let defStx ← `($[$doc?:docComment]? @[$attrId:ident initFn, $(attrs?.getD ∅),*] $(vis?)? opaque $id : $type)
+      let mut fullId := (← getCurrNamespace) ++ id.getId
+      if vis?.any (·.raw.isOfKind ``Parser.Command.private) then
+        fullId := mkPrivateName (← getEnv) fullId
+      -- We need to add `id`'s ranges *before* elaborating `initFn` (and then `id` itself) as
+      -- otherwise the info context created by `with_decl_name` will be incomplete and break the
+      -- call hierarchy
+      addDeclarationRangesForBuiltin fullId ⟨defStx.raw[0]⟩ defStx.raw[1]
+      elabCommand (← `(
+        $[unsafe%$unsafe?]? def initFn : IO $type := with_decl_name% $(mkIdent fullId) do $doSeq
+        $defStx:command))
+    else
+      let `(Parser.Command.declModifiersT| $[$doc?:docComment]? $[@[$attrs?,*]]? $(_)? $[unsafe%$unsafe?]?) := declModifiers
+        | throwErrorAt declModifiers "invalid initialization command, unexpected modifiers"
+      let attrs := (attrs?.map (·.getElems)).getD #[]
+      let attrs := attrs.push (← `(Lean.Parser.Term.attrInstance| $attrId:ident))
+      elabCommand (← `($[$doc?:docComment]? @[$[$attrs],*] $[unsafe%$unsafe?]? def initFn : IO Unit := do $doSeq))
+  | _ => throwUnsupportedSyntax
+
+builtin_initialize
+  registerTraceClass `Elab.axiom
+
+end Lean.Elab.Command

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/DeclarationRange.lean

@@ -0,0 +1,71 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.Log
+import Lean.Parser.Command
+import Lean.DeclarationRange
+import Lean.Data.Lsp.Utf16
+
+namespace Lean.Elab
+
+def getDeclarationRange? [Monad m] [MonadFileMap m] (stx : Syntax) : m (Option DeclarationRange) := do
+  let some range := stx.getRange?
+    | return none
+  let fileMap ← getFileMap
+  return some <| .ofStringPositions fileMap range.start range.stop
+
+/--
+  For most builtin declarations, the selection range is just its name, which is stored in the second position.
+  Example:
+  ```
+  "def " >> declId >> optDeclSig >> declVal
+  ```
+  If the declaration name is absent, we use the keyword instead.
+  This function converts the given `Syntax` into one that represents its "selection range".
+-/
+def getDeclarationSelectionRef (stx : Syntax) : Syntax :=
+  if stx.isOfKind ``Lean.Parser.Command.instance then
+    -- must skip `attrKind` and `optPrio` for `instance`
+    if !stx[3].isNone then
+      stx[3][0]
+    else
+      stx[1]
+  else
+    if stx[1][0].isIdent then
+      stx[1][0]  -- `declId`
+    else if stx[1].isIdent then
+      stx[1]  -- raw `ident`
+    else
+      stx[0]
+
+/--
+Derives and adds declaration ranges from given syntax trees. If `rangeStx` does not have a range,
+nothing is added. If `selectionRangeStx` does not have a range, it is defaulted to that of
+`rangeStx`.
+-/
+def addDeclarationRangesFromSyntax [Monad m] [MonadEnv m] [MonadFileMap m] (declName : Name)
+    (rangeStx : Syntax) (selectionRangeStx : Syntax := .missing) : m Unit := do
+  -- may fail on partial syntax, ignore in that case
+  let some range ← getDeclarationRange? rangeStx | return
+  let selectionRange ← (·.getD range) <$> getDeclarationRange? selectionRangeStx
+  Lean.addDeclarationRanges declName { range, selectionRange }
+
+/--
+Stores the `range` and `selectionRange` for `declName` where `modsStx` is the modifier part and
+`cmdStx` the remaining part of the syntax tree for `declName`.
+
+This method is for the builtin declarations only. User-defined commands should use
+`Lean.Elab.addDeclarationRangesFromSyntax` or `Lean.addDeclarationRanges` to store this information
+for their commands.
+-/
+def addDeclarationRangesForBuiltin [Monad m] [MonadEnv m] [MonadFileMap m] (declName : Name)
+    (modsStx : TSyntax ``Parser.Command.declModifiers) (declStx : Syntax) : m Unit := do
+  if declStx.getKind == ``Parser.Command.«example» then
+    return ()
+  let stx := mkNullNode #[modsStx, declStx]
+  addDeclarationRangesFromSyntax declName stx (getDeclarationSelectionRef declStx)
+
+end Lean.Elab

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/DefView.lean

@@ -0,0 +1,232 @@
+/-
+Copyright (c) 2020 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura, Sebastian Ullrich
+-/
+prelude
+import Lean.Elab.Command
+import Lean.Elab.DeclNameGen
+import Lean.Elab.DeclUtil
+
+namespace Lean.Elab
+
+inductive DefKind where
+  | def | instance | theorem | example | opaque | abbrev
+  deriving Inhabited, BEq
+
+def DefKind.isTheorem : DefKind → Bool
+  | .theorem => true
+  | _        => false
+
+def DefKind.isExample : DefKind → Bool
+  | .example => true
+  | _        => false
+
+/-- Header elaboration data of a `DefView`. -/
+structure DefViewElabHeaderData where
+  /--
+    Short name. Recall that all declarations in Lean 4 are potentially recursive. We use `shortDeclName` to refer
+    to them at `valueStx`, and other declarations in the same mutual block. -/
+  shortDeclName : Name
+  /-- Full name for this declaration. This is the name that will be added to the `Environment`. -/
+  declName      : Name
+  /-- Universe level parameter names explicitly provided by the user. -/
+  levelNames    : List Name
+  /-- Syntax objects for the binders occurring before `:`, we use them to populate the `InfoTree` when elaborating `valueStx`. -/
+  binderIds     : Array Syntax
+  /-- Number of parameters before `:`, it also includes auto-implicit parameters automatically added by Lean. -/
+  numParams     : Nat
+  /-- Type including parameters. -/
+  type          : Expr
+deriving Inhabited
+
+section Snapshots
+open Language
+
+/-- Snapshot after processing of a definition body.  -/
+structure BodyProcessedSnapshot extends Language.Snapshot where
+  /-- State after elaboration. -/
+  state : Term.SavedState
+  /-- Elaboration result. -/
+  value : Expr
+  /-- Untyped snapshots from `logSnapshotTask`, saved at this level for cancellation. -/
+  moreSnaps : Array (SnapshotTask SnapshotTree)
+deriving Nonempty
+instance : Language.ToSnapshotTree BodyProcessedSnapshot where
+  toSnapshotTree s := ⟨s.toSnapshot, s.moreSnaps⟩
+
+/-- Snapshot after elaboration of a definition header. -/
+structure HeaderProcessedSnapshot extends Language.Snapshot where
+  /-- Elaboration results. -/
+  view : DefViewElabHeaderData
+  /-- Resulting elaboration state, including any environment additions. -/
+  state : Term.SavedState
+  /-- Syntax of top-level tactic block if any, for checking reuse of `tacSnap?`. -/
+  tacStx? : Option Syntax
+  /-- Incremental execution of main tactic block, if any. -/
+  tacSnap? : Option (SnapshotTask Tactic.TacticParsedSnapshot)
+  /-- Syntax of definition body, for checking reuse of `bodySnap`. -/
+  bodyStx : Syntax
+  /-- Result of body elaboration. -/
+  bodySnap : SnapshotTask (Option BodyProcessedSnapshot)
+  /-- Untyped snapshots from `logSnapshotTask`, saved at this level for cancellation. -/
+  moreSnaps : Array (SnapshotTask SnapshotTree)
+deriving Nonempty
+instance : Language.ToSnapshotTree HeaderProcessedSnapshot where
+  toSnapshotTree s := ⟨s.toSnapshot,
+    (match s.tacSnap? with
+      | some tac => #[tac.map (sync := true) toSnapshotTree]
+      | none     => #[]) ++
+    #[s.bodySnap.map (sync := true) toSnapshotTree] ++ s.moreSnaps⟩
+
+/-- State before elaboration of a mutual definition. -/
+structure DefParsed where
+  /--
+  Unstructured syntax object comprising the full "header" of the definition from the modifiers
+  (incl. docstring) up to the value, used for determining header elaboration reuse.
+  -/
+  fullHeaderRef : Syntax
+  /-- Elaboration result, unless fatal exception occurred. -/
+  headerProcessedSnap : SnapshotTask (Option HeaderProcessedSnapshot)
+deriving Nonempty
+
+/-- Snapshot after syntax tree has been split into separate mutual def headers. -/
+structure DefsParsedSnapshot extends Language.Snapshot where
+  /-- Definitions of this mutual block. -/
+  defs : Array DefParsed
+deriving Nonempty, TypeName
+instance : Language.ToSnapshotTree DefsParsedSnapshot where
+  toSnapshotTree s := ⟨s.toSnapshot,
+    s.defs.map (·.headerProcessedSnap.map (sync := true) toSnapshotTree)⟩
+
+end Snapshots
+
+structure DefView where
+  kind          : DefKind
+  ref           : Syntax
+  /--
+  An unstructured syntax object that comprises the "header" of the definition, i.e. everything up
+  to the value. Used as a more specific ref for header elaboration.
+  -/
+  headerRef     : Syntax
+  modifiers     : Modifiers
+  declId        : Syntax
+  binders       : Syntax
+  type?         : Option Syntax
+  value         : Syntax
+  /--
+  Snapshot for incremental processing of this definition.
+
+  Invariant: If the bundle's `old?` is set, then elaboration of the header is guaranteed to result
+  in the same elaboration result and state, i.e. reuse is possible.
+  -/
+  headerSnap?   : Option (Language.SnapshotBundle (Option HeaderProcessedSnapshot)) := none
+  deriving?     : Option (Array Syntax) := none
+  deriving Inhabited
+
+def DefView.isInstance (view : DefView) : Bool :=
+  view.modifiers.attrs.any fun attr => attr.name == `instance
+
+/-- Prepends the `defeq` attribute, removing existing ones if there are any -/
+def DefView.markDefEq (view : DefView) : DefView :=
+  { view with modifiers :=
+      view.modifiers.filterAttrs (·.name != `defeq) |>.addFirstAttr { name := `defeq } }
+
+namespace Command
+open Meta
+
+def mkDefViewOfAbbrev (modifiers : Modifiers) (stx : Syntax) : DefView :=
+  -- leading_parser "abbrev " >> declId >> optDeclSig >> declVal
+  let (binders, type) := expandOptDeclSig stx[2]
+  let modifiers       := modifiers.addAttr { name := `inline }
+  let modifiers       := modifiers.addAttr { name := `reducible }
+  { ref := stx, headerRef := mkNullNode stx.getArgs[*...3], kind := DefKind.abbrev, modifiers,
+    declId := stx[1], binders, type? := type, value := stx[3] }
+
+def mkDefViewOfDef (modifiers : Modifiers) (stx : Syntax) : DefView :=
+  -- leading_parser "def " >> declId >> optDeclSig >> declVal >> optDefDeriving
+  let (binders, type) := expandOptDeclSig stx[2]
+  let deriving? := if stx[4].isNone then none else some stx[4][1].getSepArgs
+  { ref := stx, headerRef := mkNullNode stx.getArgs[*...3], kind := DefKind.def, modifiers,
+    declId := stx[1], binders, type? := type, value := stx[3], deriving? }
+
+def mkDefViewOfTheorem (modifiers : Modifiers) (stx : Syntax) : DefView :=
+  -- leading_parser "theorem " >> declId >> declSig >> declVal
+  let (binders, type) := expandDeclSig stx[2]
+  { ref := stx, headerRef := mkNullNode stx.getArgs[*...3], kind := DefKind.theorem, modifiers,
+    declId := stx[1], binders, type? := some type, value := stx[3] }
+
+def mkDefViewOfInstance (modifiers : Modifiers) (stx : Syntax) : CommandElabM DefView := do
+  -- leading_parser Term.attrKind >> "instance " >> optNamedPrio >> optional declId >> declSig >> declVal
+  let attrKind        ← liftMacroM <| toAttributeKind stx[0]
+  let prio            ← liftMacroM <| expandOptNamedPrio stx[2]
+  let attrStx         ← `(attr| instance $(quote prio):num)
+  let (binders, type) := expandDeclSig stx[4]
+  let modifiers       := modifiers.addAttr { kind := attrKind, name := `instance, stx := attrStx }
+  let declId ← match stx[3].getOptional? with
+    | some declId =>
+      if ← isTracingEnabledFor `Elab.instance.mkInstanceName then
+        let id ← mkInstanceName binders.getArgs type
+        trace[Elab.instance.mkInstanceName] "generated {(← getCurrNamespace) ++ id} for {declId}"
+      pure declId
+    | none        =>
+      let id ← mkInstanceName binders.getArgs type
+      trace[Elab.instance.mkInstanceName] "generated {(← getCurrNamespace) ++ id}"
+      pure <| mkNode ``Parser.Command.declId #[mkIdentFrom stx[1] id (canonical := true), mkNullNode]
+  return {
+    ref := stx, headerRef := mkNullNode stx.getArgs[*...5], kind := DefKind.instance, modifiers := modifiers,
+    declId := declId, binders := binders, type? := type, value := stx[5]
+  }
+
+def mkDefViewOfOpaque (modifiers : Modifiers) (stx : Syntax) : CommandElabM DefView := do
+  -- leading_parser "opaque " >> declId >> declSig >> optional declValSimple
+  let (binders, type) := expandDeclSig stx[2]
+  let val ← match stx[3].getOptional? with
+    | some val => pure val
+    | none     =>
+      let val ← if modifiers.isUnsafe then `(default_or_ofNonempty% unsafe) else `(default_or_ofNonempty%)
+      `(Parser.Command.declValSimple| := $val)
+  return {
+    ref := stx, headerRef := mkNullNode stx.getArgs[*...3], kind := DefKind.opaque, modifiers := modifiers,
+    declId := stx[1], binders := binders, type? := some type, value := val
+  }
+
+def mkDefViewOfExample (modifiers : Modifiers) (stx : Syntax) : DefView :=
+  -- leading_parser "example " >> declSig >> declVal
+  let (binders, type) := expandOptDeclSig stx[1]
+  let id              := mkIdentFrom stx[0] `_example (canonical := true)
+  let declId          := mkNode ``Parser.Command.declId #[id, mkNullNode]
+  { ref := stx, headerRef := mkNullNode stx.getArgs[*...2], kind := DefKind.example, modifiers := modifiers,
+    declId := declId, binders := binders, type? := type, value := stx[2] }
+
+def isDefLike (stx : Syntax) : Bool :=
+  let declKind := stx.getKind
+  declKind == ``Parser.Command.abbrev ||
+  declKind == ``Parser.Command.definition ||
+  declKind == ``Parser.Command.theorem ||
+  declKind == ``Parser.Command.opaque ||
+  declKind == ``Parser.Command.instance ||
+  declKind == ``Parser.Command.example
+
+def mkDefView (modifiers : Modifiers) (stx : Syntax) : CommandElabM DefView :=
+  let declKind := stx.getKind
+  if declKind == ``Parser.Command.«abbrev» then
+    return mkDefViewOfAbbrev modifiers stx
+  else if declKind == ``Parser.Command.definition then
+    return mkDefViewOfDef modifiers stx
+  else if declKind == ``Parser.Command.theorem then
+    return mkDefViewOfTheorem modifiers stx
+  else if declKind == ``Parser.Command.opaque then
+    mkDefViewOfOpaque modifiers stx
+  else if declKind == ``Parser.Command.instance then
+    mkDefViewOfInstance modifiers stx
+  else if declKind == ``Parser.Command.example then
+    return mkDefViewOfExample modifiers stx
+  else
+    throwError "unexpected kind of definition"
+
+builtin_initialize registerTraceClass `Elab.definition
+builtin_initialize registerTraceClass `Elab.instance.mkInstanceName
+
+end Command
+end Lean.Elab

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/Deriving.lean

@@ -0,0 +1,19 @@
+/-
+Copyright (c) 2020 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.Elab.Deriving.Basic
+import Lean.Elab.Deriving.Util
+import Lean.Elab.Deriving.Inhabited
+import Lean.Elab.Deriving.Nonempty
+import Lean.Elab.Deriving.TypeName
+import Lean.Elab.Deriving.BEq
+import Lean.Elab.Deriving.DecEq
+import Lean.Elab.Deriving.Repr
+import Lean.Elab.Deriving.FromToJson
+import Lean.Elab.Deriving.SizeOf
+import Lean.Elab.Deriving.Hashable
+import Lean.Elab.Deriving.Ord
+import Lean.Elab.Deriving.ToExpr

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/Do.lean

@@ -0,0 +1,1827 @@
+/-
+Copyright (c) 2020 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.Elab.Term
+import Lean.Elab.BindersUtil
+import Lean.Elab.PatternVar
+import Lean.Elab.Quotation.Util
+import Lean.Parser.Do
+
+-- HACK: avoid code explosion until heuristics are improved
+set_option compiler.reuse false
+
+namespace Lean.Elab.Term
+open Lean.Parser.Term
+open Meta
+open TSyntax.Compat
+
+private def getDoSeqElems (doSeq : Syntax) : List Syntax :=
+  if doSeq.getKind == ``Parser.Term.doSeqBracketed then
+    doSeq[1].getArgs.toList.map fun arg => arg[0]
+  else if doSeq.getKind == ``Parser.Term.doSeqIndent then
+    doSeq[0].getArgs.toList.map fun arg => arg[0]
+  else
+    []
+
+private def getDoSeq (doStx : Syntax) : Syntax :=
+  doStx[1]
+
+@[builtin_term_elab liftMethod] def elabLiftMethod : TermElab := fun stx _ =>
+  throwErrorAt stx "invalid use of `(<- ...)`, must be nested inside a 'do' expression"
+
+/-- Return true if we should not lift `(<- ...)` actions nested in the syntax nodes with the given kind. -/
+private def liftMethodDelimiter (k : SyntaxNodeKind) : Bool :=
+  k == ``Parser.Term.do ||
+  k == ``Parser.Term.doSeqIndent ||
+  k == ``Parser.Term.doSeqBracketed ||
+  k == ``Parser.Term.termReturn ||
+  k == ``Parser.Term.termUnless ||
+  k == ``Parser.Term.termTry ||
+  k == ``Parser.Term.termFor
+
+/-- Given `stx` which is a `letPatDecl`, `letEqnsDecl`, or `letIdDecl`, return true if it has binders. -/
+private def letDeclArgHasBinders (letDeclArg : Syntax) : Bool :=
+  let k := letDeclArg.getKind
+  if k == ``Parser.Term.letPatDecl then
+    false
+  else if k == ``Parser.Term.letEqnsDecl then
+    true
+  else if k == ``Parser.Term.letIdDecl then
+    -- letIdLhs := binderIdent >> checkWsBefore "expected space before binders" >> many (ppSpace >> letIdBinder)) >> optType
+    let binders := letDeclArg[1]
+    binders.getNumArgs > 0
+  else
+    false
+
+/-- Return `true` if the given `letDecl` contains binders. -/
+private def letDeclHasBinders (letDecl : Syntax) : Bool :=
+  letDeclArgHasBinders letDecl[0]
+
+/-- Return true if we should generate an error message when lifting a method over this kind of syntax. -/
+private def liftMethodForbiddenBinder (stx : Syntax) : Bool :=
+  let k := stx.getKind
+  -- TODO: make this extensible in the future.
+  if k == ``Parser.Term.fun || k == ``Parser.Term.matchAlts ||
+     k == ``Parser.Term.doLetRec || k == ``Parser.Term.letrec then
+     -- It is never ok to lift over this kind of binder
+    true
+  -- The following kinds of `let`-expressions require extra checks to decide whether they contain binders or not
+  else if k == ``Parser.Term.let then
+    letDeclHasBinders stx[1]
+  else if k == ``Parser.Term.doLet then
+    letDeclHasBinders stx[2]
+  else if k == ``Parser.Term.doLetArrow then
+    letDeclArgHasBinders stx[2]
+  else
+    false
+
+-- TODO: we must track whether we are inside a quotation or not.
+private partial def hasLiftMethod : Syntax → Bool
+  | Syntax.node _ k args =>
+    if liftMethodDelimiter k then false
+    -- NOTE: We don't check for lifts in quotations here, which doesn't break anything but merely makes this rare case a
+    -- bit slower
+    else if k == ``Parser.Term.liftMethod then true
+    -- For `pure` if-then-else, we only lift `(<- ...)` occurring in the condition.
+    else if k == ``termDepIfThenElse || k == ``termIfThenElse then args.size >= 2 && hasLiftMethod args[1]!
+    else args.any hasLiftMethod
+  | _ => false
+
+structure ExtractMonadResult where
+  m            : Expr
+  returnType   : Expr
+  expectedType : Expr
+
+private def mkUnknownMonadResult : MetaM ExtractMonadResult := do
+  let u ← mkFreshLevelMVar
+  let v ← mkFreshLevelMVar
+  let m ← mkFreshExprMVar (← mkArrow (mkSort (mkLevelSucc u)) (mkSort (mkLevelSucc v)))
+  let returnType ← mkFreshExprMVar (mkSort (mkLevelSucc u))
+  return { m, returnType, expectedType := mkApp m returnType }
+
+private partial def extractBind (expectedType? : Option Expr) : TermElabM ExtractMonadResult := do
+  let some expectedType := expectedType? | mkUnknownMonadResult
+  let extractStep? (type : Expr) : MetaM (Option ExtractMonadResult) := do
+    let .app m returnType := type | return none
+    try
+      let bindInstType ← mkAppM ``Bind #[m]
+      discard <| Meta.synthInstance bindInstType
+      return some { m, returnType, expectedType }
+    catch _ =>
+      return none
+  let rec extract? (type : Expr) : MetaM (Option ExtractMonadResult) := do
+    match (← extractStep? type) with
+    | some r => return r
+    | none =>
+      let typeNew ← whnfCore type
+      if typeNew != type then
+        extract? typeNew
+      else
+        if typeNew.getAppFn.isMVar then
+          mkUnknownMonadResult
+        else match (← unfoldDefinition? typeNew) with
+          | some typeNew => extract? typeNew
+          | none => return none
+  match (← extract? expectedType) with
+  | some r => return r
+  | none   => throwError "invalid `do` notation, expected type is not a monad application{indentExpr expectedType}\nYou can use the `do` notation in pure code by writing `Id.run do` instead of `do`, where `Id` is the identity monad."
+
+namespace Do
+
+abbrev Var := Syntax  -- TODO: should be `Ident`
+
+/-- A `doMatch` alternative. `vars` is the array of variables declared by `patterns`. -/
+structure Alt (σ : Type) where
+  ref      : Syntax
+  vars     : Array Var
+  patterns : Syntax
+  rhs      : σ
+  deriving Inhabited
+
+/-- A `doMatchExpr` alternative. -/
+structure AltExpr (σ : Type) where
+  ref     : Syntax
+  var?    : Option Var
+  funName : Syntax
+  pvars   : Array Syntax
+  rhs     : σ
+  deriving Inhabited
+
+def AltExpr.vars (alt : AltExpr σ) : Array Var := Id.run do
+  let mut vars := #[]
+  if let some var := alt.var? then
+    vars := vars.push var
+  for pvar in alt.pvars do
+    match pvar with
+    | `(_) => pure ()
+    | _ => vars := vars.push pvar
+  return vars
+
+/--
+  Auxiliary datastructure for representing a `do` code block, and compiling "reassignments" (e.g., `x := x + 1`).
+  We convert `Code` into a `Syntax` term representing the:
+  - `do`-block, or
+  - the visitor argument for the `forIn` combinator.
+
+  We say the following constructors are terminals:
+  - `break`:    for interrupting a `for x in s`
+  - `continue`: for interrupting the current iteration of a `for x in s`
+  - `return e`: for returning `e` as the result for the whole `do` computation block
+  - `action a`: for executing action `a` as a terminal
+  - `ite`:      if-then-else
+  - `match`:    pattern matching
+  - `jmp`       a goto to a join-point
+
+  We say the terminals `break`, `continue`, `action`, and `return` are "exit points"
+
+  Note that, `return e` is not equivalent to `action (pure e)`. Here is an example:
+  ```
+  def f (x : Nat) : IO Unit := do
+  if x == 0 then
+     return ()
+  IO.println "hello"
+  ```
+  Executing `#eval f 0` will not print "hello". Now, consider
+  ```
+  def g (x : Nat) : IO Unit := do
+  if x == 0 then
+     pure ()
+  IO.println "hello"
+  ```
+  The `if` statement is essentially a noop, and "hello" is printed when we execute `g 0`.
+
+  - `decl` represents all declaration-like `doElem`s (e.g., `let`, `have`, `let rec`).
+    The field `stx` is the actual `doElem`,
+    `vars` is the array of variables declared by it, and `cont` is the next instruction in the `do` code block.
+    `vars` is an array since we have declarations such as `let (a, b) := s`.
+
+  - `reassign` is an reassignment-like `doElem` (e.g., `x := x + 1`).
+
+  - `joinpoint` is a join point declaration: an auxiliary `let`-declaration used to represent the control-flow.
+
+  - `seq a k` executes action `a`, ignores its result, and then executes `k`.
+    We also store the do-elements `dbg_trace` and `assert!` as actions in a `seq`.
+
+  A code block `C` is well-formed if
+  - For every `jmp ref j as` in `C`, there is a `joinpoint j ps b k` and `jmp ref j as` is in `k`, and
+    `ps.size == as.size` -/
+inductive Code where
+  | decl         (xs : Array Var) (doElem : Syntax) (k : Code)
+  | reassign     (xs : Array Var) (doElem : Syntax) (k : Code)
+  /-- The Boolean value in `params` indicates whether we should use `(x : typeof! x)` when generating term Syntax or not -/
+  | joinpoint    (name : Name) (params : Array (Var × Bool)) (body : Code) (k : Code)
+  | seq          (action : Syntax) (k : Code)
+  | action       (action : Syntax)
+  | break        (ref : Syntax)
+  | continue     (ref : Syntax)
+  | return       (ref : Syntax) (val : Syntax)
+  /-- Recall that an if-then-else may declare a variable using `optIdent` for the branches `thenBranch` and `elseBranch`. We store the variable name at `var?`. -/
+  | ite          (ref : Syntax) (h? : Option Var) (optIdent : Syntax) (cond : Syntax) (thenBranch : Code) (elseBranch : Code)
+  | match        (ref : Syntax) (gen : Syntax) (discrs : Syntax) (optMotive : Syntax) (alts : Array (Alt Code))
+  | matchExpr    (ref : Syntax) («meta» : Bool) (discr : Syntax) (alts : Array (AltExpr Code)) (elseBranch : Code)
+  | jmp          (ref : Syntax) (jpName : Name) (args : Array Syntax)
+  deriving Inhabited
+
+def Code.getRef? : Code → Option Syntax
+  | .decl _ doElem _     => doElem
+  | .reassign _ doElem _ => doElem
+  | .joinpoint ..        => none
+  | .seq a _             => a
+  | .action a            => a
+  | .break ref           => ref
+  | .continue ref        => ref
+  | .return ref _        => ref
+  | .ite ref ..          => ref
+  | .match ref ..        => ref
+  | .matchExpr ref ..    => ref
+  | .jmp ref ..          => ref
+
+abbrev VarSet := RBMap Name Syntax Name.cmp
+
+/-- A code block, and the collection of variables updated by it. -/
+structure CodeBlock where
+  code  : Code
+  uvars : VarSet := {} -- set of variables updated by `code`
+
+private def varSetToArray (s : VarSet) : Array Var :=
+  s.fold (fun xs _ x => xs.push x) #[]
+
+private def varsToMessageData (vars : Array Var) : MessageData :=
+  MessageData.joinSep (vars.toList.map fun n => MessageData.ofName (n.getId.simpMacroScopes)) " "
+
+partial def CodeBlocl.toMessageData (codeBlock : CodeBlock) : MessageData :=
+  let us := MessageData.ofList <| (varSetToArray codeBlock.uvars).toList.map MessageData.ofSyntax
+  let rec loop : Code → MessageData
+    | .decl xs _ k           => m!"let {varsToMessageData xs} := ...\n{loop k}"
+    | .reassign xs _ k       => m!"{varsToMessageData xs} := ...\n{loop k}"
+    | .joinpoint n ps body k => m!"let {n.simpMacroScopes} {varsToMessageData (ps.map Prod.fst)} := {indentD (loop body)}\n{loop k}"
+    | .seq e k               => m!"{e}\n{loop k}"
+    | .action e              => e
+    | .ite _ _ _ c t e       => m!"if {c} then {indentD (loop t)}\nelse{loop e}"
+    | .jmp _ j xs            => m!"jmp {j.simpMacroScopes} {xs.toList}"
+    | .break _               => m!"break {us}"
+    | .continue _            => m!"continue {us}"
+    | .return _ v            => m!"return {v} {us}"
+    | .match _ _ ds _ alts   =>
+      m!"match {ds} with"
+      ++ alts.foldl (init := m!"") fun acc alt => acc ++ m!"\n| {alt.patterns} => {loop alt.rhs}"
+    | .matchExpr _ «meta» d alts elseCode =>
+      let r := m!"match_expr {if «meta» then "" else "(meta := false)"} {d} with"
+      let r := r ++ alts.foldl (init := m!"") fun acc alt =>
+            let acc := acc ++ m!"\n| {if let some var := alt.var? then m!"{var}@" else ""}"
+            let acc := acc ++ m!"{alt.funName}"
+            let acc := acc ++ alt.pvars.foldl (init := m!"") fun acc pvar => acc ++ m!" {pvar}"
+            acc ++ m!" => {loop alt.rhs}"
+      r ++ m!"| _ => {loop elseCode}"
+  loop codeBlock.code
+
+/-- Return true if the give code contains an exit point that satisfies `p` -/
+partial def hasExitPointPred (c : Code) (p : Code → Bool) : Bool :=
+  let rec loop : Code → Bool
+    | .decl _ _ k             => loop k
+    | .reassign _ _ k         => loop k
+    | .joinpoint _ _ b k      => loop b || loop k
+    | .seq _ k                => loop k
+    | .ite _ _ _ _ t e        => loop t || loop e
+    | .match _ _ _ _ alts     => alts.any (loop ·.rhs)
+    | .matchExpr _ _ _ alts e => alts.any (loop ·.rhs) || loop e
+    | .jmp ..                 => false
+    | c                       => p c
+  loop c
+
+def hasExitPoint (c : Code) : Bool :=
+  hasExitPointPred c fun _ => true
+
+def hasReturn (c : Code) : Bool :=
+  hasExitPointPred c fun
+    | .return .. => true
+    | _ => false
+
+def hasTerminalAction (c : Code) : Bool :=
+  hasExitPointPred c fun
+    | .action _ => true
+    | _ => false
+
+def hasBreakContinue (c : Code) : Bool :=
+  hasExitPointPred c fun
+    | .break _    => true
+    | .continue _ => true
+    | _ => false
+
+def hasBreakContinueReturn (c : Code) : Bool :=
+  hasExitPointPred c fun
+    | .break _    => true
+    | .continue _ => true
+    | .return _ _ => true
+    | _ => false
+
+def mkAuxDeclFor {m} [Monad m] [MonadQuotation m] (e : Syntax) (mkCont : Syntax → m Code) : m Code := withRef e <| withFreshMacroScope do
+  let y ← `(y)
+  let doElem ← `(doElem| let y ← $e:term)
+  -- Add elaboration hint for producing sane error message
+  let y ← `(ensure_expected_type% "type mismatch, result value" $y)
+  let k ← mkCont y
+  return .decl #[y] doElem k
+
+/-- Convert `action _ e` instructions in `c` into `let y ← e; jmp _ jp (xs y)`. -/
+partial def convertTerminalActionIntoJmp (code : Code) (jp : Name) (xs : Array Var) : MacroM Code :=
+  let rec loop : Code → MacroM Code
+    | .decl xs stx k         => return .decl xs stx (← loop k)
+    | .reassign xs stx k     => return .reassign xs stx (← loop k)
+    | .joinpoint n ps b k    => return .joinpoint n ps (← loop b) (← loop k)
+    | .seq e k               => return .seq e (← loop k)
+    | .ite ref x? h c t e    => return .ite ref x? h c (← loop t) (← loop e)
+    | .action e              => mkAuxDeclFor e fun y =>
+      let ref := e
+      -- We jump to `jp` with xs **and** y
+      let jmpArgs := xs.push y
+      return Code.jmp ref jp jmpArgs
+    | .match ref g ds t alts =>
+      return .match ref g ds t (← alts.mapM fun alt => do pure { alt with rhs := (← loop alt.rhs) })
+    | .matchExpr ref «meta» d alts e => do
+      let alts ← alts.mapM fun alt => do pure { alt with rhs := (← loop alt.rhs) }
+      let e ← loop e
+      return .matchExpr ref «meta» d alts e
+    | c => return c
+  loop code
+
+structure JPDecl where
+  name : Name
+  params : Array (Var × Bool)
+  body : Code
+
+def attachJP (jpDecl : JPDecl) (k : Code) : Code :=
+  Code.joinpoint jpDecl.name jpDecl.params jpDecl.body k
+
+def attachJPs (jpDecls : Array JPDecl) (k : Code) : Code :=
+  jpDecls.foldr attachJP k
+
+def mkFreshJP (ps : Array (Var × Bool)) (body : Code) : TermElabM JPDecl := do
+  let ps ← if ps.isEmpty then
+    let y ← `(y)
+    pure #[(y.raw, false)]
+  else
+    pure ps
+  -- Remark: the compiler frontend implemented in C++ currently detects jointpoints created by
+  -- the "do" notation by testing the name. See hack at method `visit_let` at `lcnf.cpp`
+  -- We will remove this hack when we re-implement the compiler frontend in Lean.
+  let name ← mkFreshUserName `__do_jp
+  pure { name := name, params := ps, body := body }
+
+def addFreshJP (ps : Array (Var × Bool)) (body : Code) : StateRefT (Array JPDecl) TermElabM Name := do
+  let jp ← mkFreshJP ps body
+  modify fun (jps : Array JPDecl) => jps.push jp
+  pure jp.name
+
+def insertVars (rs : VarSet) (xs : Array Var) : VarSet :=
+  xs.foldl (fun rs x => rs.insert x.getId x) rs
+
+def eraseVars (rs : VarSet) (xs : Array Var) : VarSet :=
+  xs.foldl (·.erase ·.getId) rs
+
+def eraseOptVar (rs : VarSet) (x? : Option Var) : VarSet :=
+  match x? with
+  | none   => rs
+  | some x => rs.insert x.getId x
+
+/-- Create a new jointpoint for `c`, and jump to it with the variables `rs` -/
+def mkSimpleJmp (ref : Syntax) (rs : VarSet) (c : Code) : StateRefT (Array JPDecl) TermElabM Code := do
+  let xs := varSetToArray rs
+  let jp ← addFreshJP (xs.map fun x => (x, true)) c
+  if xs.isEmpty then
+    let unit ← ``(Unit.unit)
+    return Code.jmp ref jp #[unit]
+  else
+    return Code.jmp ref jp xs
+
+/-- Create a new joinpoint that takes `rs` and `val` as arguments. `val` must be syntax representing a pure value.
+   The body of the joinpoint is created using `mkJPBody yFresh`, where `yFresh`
+   is a fresh variable created by this method. -/
+def mkJmp (ref : Syntax) (rs : VarSet) (val : Syntax) (mkJPBody : Syntax → MacroM Code) : StateRefT (Array JPDecl) TermElabM Code := do
+  let xs := varSetToArray rs
+  let args := xs.push val
+  let yFresh ← withRef ref `(y)
+  let ps := xs.map fun x => (x, true)
+  let ps := ps.push (yFresh, false)
+  let jpBody ← liftMacroM <| mkJPBody yFresh
+  let jp ← addFreshJP ps jpBody
+  return Code.jmp ref jp args
+
+/-- `pullExitPointsAux rs c` auxiliary method for `pullExitPoints`, `rs` is the set of update variable in the current path.  -/
+partial def pullExitPointsAux (rs : VarSet) (c : Code) : StateRefT (Array JPDecl) TermElabM Code := do
+  match c with
+  | .decl xs stx k         => return .decl xs stx (← pullExitPointsAux (eraseVars rs xs) k)
+  | .reassign xs stx k     => return .reassign xs stx (← pullExitPointsAux (insertVars rs xs) k)
+  | .joinpoint j ps b k    => return .joinpoint j ps (← pullExitPointsAux rs b) (← pullExitPointsAux rs k)
+  | .seq e k               => return .seq e (← pullExitPointsAux rs k)
+  | .ite ref x? o c t e    => return .ite ref x? o c (← pullExitPointsAux (eraseOptVar rs x?) t) (← pullExitPointsAux (eraseOptVar rs x?) e)
+  | .jmp ..                => return  c
+  | .break ref             => mkSimpleJmp ref rs (.break ref)
+  | .continue ref          => mkSimpleJmp ref rs (.continue ref)
+  | .return ref val        => mkJmp ref rs val (fun y => return .return ref y)
+  | .action e              =>
+    -- We use `mkAuxDeclFor` because `e` is not pure.
+    mkAuxDeclFor e fun y =>
+      let ref := e
+      mkJmp ref rs y (fun yFresh => return .action (← ``(Pure.pure $yFresh)))
+  | .match ref g ds t alts =>
+    let alts ← alts.mapM fun alt => do pure { alt with rhs := (← pullExitPointsAux (eraseVars rs alt.vars) alt.rhs) }
+    return .match ref g ds t alts
+  | .matchExpr ref «meta» d alts e =>
+    let alts ← alts.mapM fun alt => do pure { alt with rhs := (← pullExitPointsAux (eraseVars rs alt.vars) alt.rhs) }
+    let e ← pullExitPointsAux rs e
+    return .matchExpr ref «meta» d alts e
+
+/--
+Auxiliary operation for adding new variables to the collection of updated variables in a CodeBlock.
+When a new variable is not already in the collection, but is shadowed by some declaration in `c`,
+we create auxiliary join points to make sure we preserve the semantics of the code block.
+Example: suppose we have the code block `print x; let x := 10; return x`. And we want to extend it
+with the reassignment `x := x + 1`. We first use `pullExitPoints` to create
+```
+let jp (x!1) :=  return x!1;
+print x;
+let x := 10;
+jmp jp x
+```
+and then we add the reassignment
+```
+x := x + 1
+let jp (x!1) := return x!1;
+print x;
+let x := 10;
+jmp jp x
+```
+Note that we created a fresh variable `x!1` to avoid accidental name capture.
+As another example, consider
+```
+print x;
+let x := 10
+y := y + 1;
+return x;
+```
+We transform it into
+```
+let jp (y x!1) := return x!1;
+print x;
+let x := 10
+y := y + 1;
+jmp jp y x
+```
+and then we add the reassignment as in the previous example.
+We need to include `y` in the jump, because each exit point is implicitly returning the set of
+update variables.
+
+We implement the method as follows. Let `us` be `c.uvars`, then
+1- for each `return _ y` in `c`, we create a join point
+  `let j (us y!1) := return y!1`
+   and replace the `return _ y` with `jmp us y`
+2- for each `break`, we create a join point
+  `let j (us) := break`
+   and replace the `break` with `jmp us`.
+3- Same as 2 for `continue`.
+-/
+def pullExitPoints (c : Code) : TermElabM Code := do
+  if hasExitPoint c then
+    let (c, jpDecls) ← (pullExitPointsAux {} c).run #[]
+    return attachJPs jpDecls c
+  else
+    return c
+
+partial def extendUpdatedVarsAux (c : Code) (ws : VarSet) : TermElabM Code :=
+  let rec update (c : Code) : TermElabM Code := do
+    match c with
+    | .joinpoint j ps b k    => return .joinpoint j ps (← update b) (← update k)
+    | .seq e k               => return .seq e (← update k)
+    | .match ref g ds t alts =>
+      if alts.any fun alt => alt.vars.any fun x => ws.contains x.getId then
+        -- If a pattern variable is shadowing a variable in ws, we `pullExitPoints`
+        pullExitPoints c
+      else
+        return .match ref g ds t (← alts.mapM fun alt => do pure { alt with rhs := (← update alt.rhs) })
+    | .matchExpr ref «meta» d alts e =>
+      if alts.any fun alt => alt.vars.any fun x => ws.contains x.getId then
+        -- If a pattern variable is shadowing a variable in ws, we `pullExitPoints`
+        pullExitPoints c
+      else
+        let alts ← alts.mapM fun alt => do pure { alt with rhs := (← update alt.rhs) }
+        let e ← update e
+        return .matchExpr ref «meta» d alts e
+    | .ite ref none o c t e => return .ite ref none o c (← update t) (← update e)
+    | .ite ref (some h) o cond t e =>
+      if ws.contains h.getId then
+        -- if the `h` at `if h : c then t else e` shadows a variable in `ws`, we `pullExitPoints`
+        pullExitPoints c
+      else
+        return Code.ite ref (some h) o cond (← update t) (← update e)
+    | .reassign xs stx k => return .reassign xs stx (← update k)
+    | .decl xs stx k => do
+      if xs.any fun x => ws.contains x.getId then
+        -- One the declared variables is shadowing a variable in `ws`
+        pullExitPoints c
+      else
+        return .decl xs stx (← update k)
+    | c => return  c
+  update c
+
+/--
+Extend the set of updated variables. It assumes `ws` is a super set of `c.uvars`.
+We **cannot** simply update the field `c.uvars`, because `c` may have shadowed some variable in `ws`.
+See discussion at `pullExitPoints`.
+-/
+partial def extendUpdatedVars (c : CodeBlock) (ws : VarSet) : TermElabM CodeBlock := do
+  if ws.any fun x _ => !c.uvars.contains x then
+    -- `ws` contains a variable that is not in `c.uvars`, but in `c.dvars` (i.e., it has been shadowed)
+    pure { code := (← extendUpdatedVarsAux c.code ws), uvars := ws }
+  else
+    pure { c with uvars := ws }
+
+private def union (s₁ s₂ : VarSet) : VarSet :=
+  s₁.fold (·.insert ·) s₂
+
+/--
+Given two code blocks `c₁` and `c₂`, make sure they have the same set of updated variables.
+Let `ws` the union of the updated variables in `c₁‵ and ‵c₂`.
+We use `extendUpdatedVars c₁ ws` and `extendUpdatedVars c₂ ws`
+-/
+def homogenize (c₁ c₂ : CodeBlock) : TermElabM (CodeBlock × CodeBlock) := do
+  let ws := union c₁.uvars c₂.uvars
+  let c₁ ← extendUpdatedVars c₁ ws
+  let c₂ ← extendUpdatedVars c₂ ws
+  pure (c₁, c₂)
+
+/--
+Extending code blocks with variable declarations: `let x : t := v` and `let x : t ← v`.
+We remove `x` from the collection of updated variables.
+Remark: `stx` is the syntax for the declaration (e.g., `letDecl`), and `xs` are the variables
+declared by it. It is an array because we have let-declarations that declare multiple variables.
+Example: `let (x, y) := t`
+-/
+def mkVarDeclCore (xs : Array Var) (stx : Syntax) (c : CodeBlock) : CodeBlock := {
+  code := Code.decl xs stx c.code,
+  uvars := eraseVars c.uvars xs
+}
+
+/--
+Extending code blocks with reassignments: `x : t := v` and `x : t ← v`.
+Remark: `stx` is the syntax for the declaration (e.g., `letDecl`), and `xs` are the variables
+declared by it. It is an array because we have let-declarations that declare multiple variables.
+Example: `(x, y) ← t`
+-/
+def mkReassignCore (xs : Array Var) (stx : Syntax) (c : CodeBlock) : TermElabM CodeBlock := do
+  let us := c.uvars
+  let ws := insertVars us xs
+  -- If `xs` contains a new updated variable, then we must use `extendUpdatedVars`.
+  -- See discussion at `pullExitPoints`
+  let code ← if xs.any fun x => !us.contains x.getId then extendUpdatedVarsAux c.code ws else pure c.code
+  pure { code := .reassign xs stx code, uvars := ws }
+
+def mkSeq (action : Syntax) (c : CodeBlock) : CodeBlock :=
+  { c with code := .seq action c.code }
+
+def mkTerminalAction (action : Syntax) : CodeBlock :=
+  { code := .action action }
+
+def mkReturn (ref : Syntax) (val : Syntax) : CodeBlock :=
+  { code := .return ref val }
+
+def mkBreak (ref : Syntax) : CodeBlock :=
+  { code := .break ref }
+
+def mkContinue (ref : Syntax) : CodeBlock :=
+  { code := .continue ref }
+
+def mkIte (ref : Syntax) (optIdent : Syntax) (cond : Syntax) (thenBranch : CodeBlock) (elseBranch : CodeBlock) : TermElabM CodeBlock := do
+  let x? := optIdent.getOptional?
+  let (thenBranch, elseBranch) ← homogenize thenBranch elseBranch
+  return {
+    code  := .ite ref x? optIdent cond thenBranch.code elseBranch.code,
+    uvars := thenBranch.uvars,
+  }
+
+private def mkUnit : MacroM Syntax :=
+  ``((⟨⟩ : PUnit))
+
+private def mkPureUnit : MacroM Syntax :=
+  ``(pure PUnit.unit)
+
+def mkPureUnitAction : MacroM CodeBlock := do
+  return mkTerminalAction (← mkPureUnit)
+
+def mkUnless (cond : Syntax) (c : CodeBlock) : MacroM CodeBlock := do
+  let thenBranch ← mkPureUnitAction
+  return { c with code := .ite (← getRef) none mkNullNode cond thenBranch.code c.code }
+
+def mkMatch (ref : Syntax) (genParam : Syntax) (discrs : Syntax) (optMotive : Syntax) (alts : Array (Alt CodeBlock)) : TermElabM CodeBlock := do
+  -- nary version of homogenize
+  let ws := alts.foldl (union · ·.rhs.uvars) {}
+  let alts ← alts.mapM fun alt => do
+    let rhs ← extendUpdatedVars alt.rhs ws
+    return { ref := alt.ref, vars := alt.vars, patterns := alt.patterns, rhs := rhs.code : Alt Code }
+  return { code := .match ref genParam discrs optMotive alts, uvars := ws }
+
+def mkMatchExpr (ref : Syntax) («meta» : Bool) (discr : Syntax) (alts : Array (AltExpr CodeBlock)) (elseBranch : CodeBlock) : TermElabM CodeBlock := do
+  -- nary version of homogenize
+  let ws := alts.foldl (union · ·.rhs.uvars) {}
+  let ws := union ws elseBranch.uvars
+  let alts ← alts.mapM fun alt => do
+    let rhs ← extendUpdatedVars alt.rhs ws
+    return { alt with rhs := rhs.code : AltExpr Code }
+  let elseBranch ← extendUpdatedVars elseBranch ws
+  return { code := .matchExpr ref «meta» discr alts elseBranch.code, uvars := ws }
+
+/-- Return a code block that executes `terminal` and then `k` with the value produced by `terminal`.
+   This method assumes `terminal` is a terminal -/
+def concat (terminal : CodeBlock) (kRef : Syntax) (y? : Option Var) (k : CodeBlock) : TermElabM CodeBlock := do
+  unless hasTerminalAction terminal.code do
+    throwErrorAt kRef "`do` element is unreachable"
+  let (terminal, k) ← homogenize terminal k
+  let xs := varSetToArray k.uvars
+  let y ← match y? with | some y => pure y | none => `(y)
+  let ps := xs.map fun x => (x, true)
+  let ps := ps.push (y, false)
+  let jpDecl ← mkFreshJP ps k.code
+  let jp := jpDecl.name
+  let terminal ← liftMacroM <| convertTerminalActionIntoJmp terminal.code jp xs
+  return { code  := attachJP jpDecl terminal, uvars := k.uvars }
+
+def getLetIdVars (letId : Syntax) : Array Var :=
+  assert! letId.isOfKind ``Parser.Term.letId
+  -- def letId := leading_parser binderIdent <|> hygieneInfo
+  if letId[0].isIdent then
+    #[letId[0]]
+  else if letId[0].isOfKind hygieneInfoKind then
+    #[HygieneInfo.mkIdent letId[0] `this (canonical := true)]
+  else
+    #[]
+
+def getLetIdDeclVars (letIdDecl : Syntax) : Array Var :=
+  assert! letIdDecl.isOfKind ``Parser.Term.letIdDecl
+  -- def letIdLhs : Parser := letId >> many (ppSpace >> letIdBinder) >> optType
+  -- def letIdDecl := leading_parser letIdLhs >> " := " >> termParser
+  getLetIdVars letIdDecl[0]
+
+-- support both regular and syntax match
+def getPatternVarsEx (pattern : Syntax) : TermElabM (Array Var) :=
+  getPatternVars pattern <|>
+  Quotation.getPatternVars pattern
+
+def getPatternsVarsEx (patterns : Array Syntax) : TermElabM (Array Var) :=
+  getPatternsVars patterns <|>
+  Quotation.getPatternsVars patterns
+
+def getLetPatDeclVars (letPatDecl : Syntax) : TermElabM (Array Var) := do
+  -- def letPatDecl := leading_parser termParser >> pushNone >> optType >> " := " >> termParser
+  let pattern := letPatDecl[0]
+  getPatternVarsEx pattern
+
+def getLetEqnsDeclVars (letEqnsDecl : Syntax) : Array Var :=
+  assert! letEqnsDecl.isOfKind ``Parser.Term.letEqnsDecl
+  -- def letIdLhs : Parser := letId >> many (ppSpace >> letIdBinder) >> optType
+  -- def letEqnsDecl := leading_parser letIdLhs >> matchAlts
+  getLetIdVars letEqnsDecl[0]
+
+def getLetDeclVars (letDecl : Syntax) : TermElabM (Array Var) := do
+  -- def letDecl := leading_parser letIdDecl <|> letPatDecl <|> letEqnsDecl
+  let arg := letDecl[0]
+  if arg.getKind == ``Parser.Term.letIdDecl then
+    return getLetIdDeclVars arg
+  else if arg.getKind == ``Parser.Term.letPatDecl then
+    getLetPatDeclVars arg
+  else if arg.getKind == ``Parser.Term.letEqnsDecl then
+    return getLetEqnsDeclVars arg
+  else
+    throwError "unexpected kind of let declaration"
+
+def getDoLetVars (doLet : Syntax) : TermElabM (Array Var) :=
+  -- leading_parser "let " >> optional "mut " >> letDecl
+  getLetDeclVars doLet[2]
+
+def getDoHaveVars (doHave : Syntax) : TermElabM (Array Var) :=
+  -- leading_parser "have" >> letDecl
+  getLetDeclVars doHave[1]
+
+def getDoLetRecVars (doLetRec : Syntax) : TermElabM (Array Var) := do
+  -- letRecDecls is an array of `(group (optional attributes >> letDecl))`
+  let letRecDecls := doLetRec[1][0].getSepArgs
+  let letDecls := letRecDecls.map fun p => p[2]
+  let mut allVars := #[]
+  for letDecl in letDecls do
+    let vars ← getLetDeclVars letDecl
+    allVars := allVars ++ vars
+  return allVars
+
+-- ident >> optType >> leftArrow >> termParser
+def getDoIdDeclVar (doIdDecl : Syntax) : Var :=
+  doIdDecl[0]
+
+-- termParser >> leftArrow >> termParser >> optional (" | " >> termParser)
+def getDoPatDeclVars (doPatDecl : Syntax) : TermElabM (Array Var) := do
+  let pattern := doPatDecl[0]
+  getPatternVarsEx pattern
+
+-- leading_parser "let " >> optional "mut " >> (doIdDecl <|> doPatDecl)
+def getDoLetArrowVars (doLetArrow : Syntax) : TermElabM (Array Var) := do
+  let decl := doLetArrow[2]
+  if decl.getKind == ``Parser.Term.doIdDecl then
+    return #[getDoIdDeclVar decl]
+  else if decl.getKind == ``Parser.Term.doPatDecl then
+    getDoPatDeclVars decl
+  else
+    throwError "unexpected kind of `do` declaration"
+
+def getDoReassignVars (doReassign : Syntax) : TermElabM (Array Var) := do
+  let arg := doReassign[0]
+  if arg.getKind == ``Parser.Term.letIdDecl then
+    return getLetIdDeclVars arg
+  else if arg.getKind == ``Parser.Term.letPatDecl then
+    getLetPatDeclVars arg
+  else
+    throwError "unexpected kind of reassignment"
+
+def mkDoSeq (doElems : Array Syntax) : Syntax :=
+  mkNode `Lean.Parser.Term.doSeqIndent #[mkNullNode <| doElems.map fun doElem => mkNullNode #[doElem, mkNullNode]]
+
+/--
+  If the given syntax is a `doIf`, return an equivalent `doIf` that has an `else` but no `else if`s or `if let`s.  -/
+private def expandDoIf? (stx : Syntax) : MacroM (Option Syntax) := match stx with
+  | `(doElem|if $_:doIfProp then $_ else $_) => pure none
+  | `(doElem|if $cond:doIfCond then $t $[else if $conds:doIfCond then $ts]* $[else $e?]?) => withRef stx do
+    let mut e      := e?.getD (← `(doSeq|pure PUnit.unit))
+    let mut eIsSeq := true
+    for (cond, t) in Array.zip (conds.reverse.push cond) (ts.reverse.push t) do
+      e ← if eIsSeq then pure e else `(doSeq|$e:doElem)
+      e ← match cond with
+        | `(doIfCond|let $pat := $d) => `(doElem| match $d:term with | $pat:term => $t | _ => $e)
+        | `(doIfCond|let $pat ← $d)  => `(doElem| match ← $d    with | $pat:term => $t | _ => $e)
+        | `(doIfCond|$cond:doIfProp) => `(doElem| if $cond:doIfProp then $t else $e)
+        | _                          => `(doElem| if $(Syntax.missing) then $t else $e)
+      eIsSeq := false
+    return some e
+  | _ => pure none
+
+/--
+  If the given syntax is a `doLetExpr` or `doLetMetaExpr`, return an equivalent `doIf` that has an `else` but no `else if`s or `if let`s.  -/
+private def expandDoLetExpr? (stx : Syntax) (doElems : List Syntax) : MacroM (Option Syntax) := match stx with
+  | `(doElem| let_expr $pat:matchExprPat := $discr:term | $elseBranch:doSeq) =>
+    return some (← `(doElem| match_expr (meta := false) $discr:term with
+                             | $pat:matchExprPat => $(mkDoSeq doElems.toArray)
+                             | _ => $elseBranch))
+  | `(doElem| let_expr $pat:matchExprPat ← $discr:term | $elseBranch:doSeq) =>
+    return some (← `(doElem| match_expr $discr:term with
+                             | $pat:matchExprPat => $(mkDoSeq doElems.toArray)
+                             | _ => $elseBranch))
+  | _ => return none
+
+structure DoIfView where
+  ref        : Syntax
+  optIdent   : Syntax
+  cond       : Syntax
+  thenBranch : Syntax
+  elseBranch : Syntax
+
+/-- This method assumes `expandDoIf?` is not applicable. -/
+private def mkDoIfView (doIf : Syntax) : DoIfView := {
+  ref        := doIf
+  optIdent   := doIf[1][0]
+  cond       := doIf[1][1]
+  thenBranch := doIf[3]
+  elseBranch := doIf[5][1]
+}
+
+/--
+We use `MProd` instead of `Prod` to group values when expanding the
+`do` notation. `MProd` is a universe monomorphic product.
+The motivation is to generate simpler universe constraints in code
+that was not written by the user.
+Note that we are not restricting the macro power since the
+`Bind.bind` combinator already forces values computed by monadic
+actions to be in the same universe.
+-/
+private def mkTuple (elems : Array Syntax) : MacroM Syntax := do
+  if elems.size = 0 then
+    mkUnit
+  else if h : elems.size = 1 then
+    return elems[0]
+  else
+    elems.extract 0 (elems.size - 1) |>.foldrM (init := elems.back!) fun elem tuple =>
+      ``(MProd.mk $elem $tuple)
+
+/-- Return `some action` if `doElem` is a `doExpr <action>`-/
+def isDoExpr? (doElem : Syntax) : Option Syntax :=
+  if doElem.getKind == ``Parser.Term.doExpr then
+    some doElem[0]
+  else
+    none
+
+/--
+  Given `uvars := #[a_1, ..., a_n, a_{n+1}]` construct term
+  ```
+  let a_1     := x.1
+  let x       := x.2
+  let a_2     := x.1
+  let x       := x.2
+  ...
+  let a_n     := x.1
+  let a_{n+1} := x.2
+  body
+  ```
+  Special cases
+  - `uvars := #[]` => `body`
+  - `uvars := #[a]` => `let a := x; body`
+
+
+  We use this method when expanding the `for-in` notation.
+-/
+private def destructTuple (uvars : Array Var) (x : Syntax) (body : Syntax) : MacroM Syntax := do
+  if uvars.size = 0 then
+    return body
+  else if h : uvars.size = 1 then
+    `(let $(uvars[0]):ident := $x; $body)
+  else
+    destruct uvars.toList x body
+where
+  destruct (as : List Var) (x : Syntax) (body : Syntax) : MacroM Syntax := do
+    match as with
+      | [a, b]  => `(let $a:ident := $x.1; let $b:ident := $x.2; $body)
+      | a :: as => withFreshMacroScope do
+        let rest ← destruct as (← `(x)) body
+        `(let $a:ident := $x.1; let x := $x.2; $rest)
+      | _ => unreachable!
+
+/-!
+The procedure `ToTerm.run` converts a `CodeBlock` into a `Syntax` term.
+We use this method to convert
+1- The `CodeBlock` for a root `do ...` term into a `Syntax` term. This kind of
+   `CodeBlock` never contains `break` nor `continue`. Moreover, the collection
+   of updated variables is not packed into the result.
+   Thus, we have two kinds of exit points
+     - `Code.action e` which is converted into `e`
+     - `Code.return _ e` which is converted into `pure e`
+
+   We use `Kind.regular` for this case.
+
+2- The `CodeBlock` for `b` at `for x in xs do b`. In this case, we need to generate
+   a `Syntax` term representing a function for the `xs.forIn` combinator.
+
+   a) If `b` contain a `Code.return _ a` exit point. The generated `Syntax` term
+      has type `m (ForInStep (Option α × σ))`, where `a : α`, and the `σ` is the type
+      of the tuple of variables reassigned by `b`.
+      We use `Kind.forInWithReturn` for this case
+
+   b) If `b` does not contain a `Code.return _ a` exit point. Then, the generated
+      `Syntax` term has type `m (ForInStep σ)`.
+      We use `Kind.forIn` for this case.
+
+3- The `CodeBlock` `c` for a `do` sequence nested in a monadic combinator (e.g., `MonadExcept.tryCatch`).
+
+   The generated `Syntax` term for `c` must inform whether `c` "exited" using `Code.action`, `Code.return`,
+   `Code.break` or `Code.continue`. We use the auxiliary types `DoResult`s for storing this information.
+   For example, the auxiliary type `DoResultPBC α σ` is used for a code block that exits with `Code.action`,
+   **and** `Code.break`/`Code.continue`, `α` is the type of values produced by the exit `action`, and
+   `σ` is the type of the tuple of reassigned variables.
+   The type `DoResult α β σ` is usedf for code blocks that exit with
+   `Code.action`, `Code.return`, **and** `Code.break`/`Code.continue`, `β` is the type of the returned values.
+   We don't use `DoResult α β σ` for all cases because:
+
+      a) The elaborator would not be able to infer all type parameters without extra annotations. For example,
+         if the code block does not contain `Code.return _ _`, the elaborator will not be able to infer `β`.
+
+      b) We need to pattern match on the result produced by the combinator (e.g., `MonadExcept.tryCatch`),
+         but we don't want to consider "unreachable" cases.
+
+   We do not distinguish between cases that contain `break`, but not `continue`, and vice versa.
+
+   When listing all cases, we use `a` to indicate the code block contains `Code.action _`, `r` for `Code.return _ _`,
+   and `b/c` for a code block that contains `Code.break _` or `Code.continue _`.
+
+   - `a`: `Kind.regular`, type `m (α × σ)`
+
+   - `r`: `Kind.regular`, type `m (α × σ)`
+           Note that the code that pattern matches on the result will behave differently in this case.
+           It produces `return a` for this case, and `pure a` for the previous one.
+
+   - `b/c`: `Kind.nestedBC`, type `m (DoResultBC σ)`
+
+   - `a` and `r`:   `Kind.nestedPR`, type `m (DoResultPR α β σ)`
+
+   - `a` and `bc`:  `Kind.nestedSBC`, type `m (DoResultSBC α σ)`
+
+   - `r` and `bc`:  `Kind.nestedSBC`, type `m (DoResultSBC α σ)`
+         Again the code that pattern matches on the result will behave differently in this case and
+         the previous one. It produces `return a` for the constructor `DoResultSPR.pureReturn a u` for
+         this case, and `pure a` for the previous case.
+
+   - `a`, `r`, `b/c`: `Kind.nestedPRBC`, type type `m (DoResultPRBC α β σ)`
+
+Here is the recipe for adding new combinators with nested `do`s.
+Example: suppose we want to support `repeat doSeq`. Assuming we have `repeat : m α → m α`
+1- Convert `doSeq` into `codeBlock : CodeBlock`
+2- Create term `term` using `mkNestedTerm code m uvars a r bc` where
+   `code` is `codeBlock.code`, `uvars` is an array containing `codeBlock.uvars`,
+   `m` is a `Syntax` representing the Monad, and
+   `a` is true if `code` contains `Code.action _`,
+   `r` is true if `code` contains `Code.return _ _`,
+   `bc` is true if `code` contains `Code.break _` or `Code.continue _`.
+
+   Remark: for combinators such as `repeat` that take a single `doSeq`, all
+   arguments, but `m`, are extracted from `codeBlock`.
+3- Create the term `repeat $term`
+4- and then, convert it into a `doSeq` using `matchNestedTermResult ref (repeat $term) uvsar a r bc`
+
+-/
+
+/--
+Helper method for annotating `term` with the raw syntax `ref`.
+We use this method to implement finer-grained term infos for `do`-blocks.
+
+We use `withRef term` to make sure the synthetic position for the `with_annotate_term` is equal
+to the one for `term`. This is important for producing error messages when there is a type mismatch.
+Consider the following example:
+```
+opaque f : IO Nat
+
+def g : IO String := do
+  f
+```
+There is at type mismatch at `f`, but it is detected when elaborating the expanded term
+containing the `with_annotate_term .. f`. The current `getRef` when this `annotate` is invoked
+is not necessarily `f`. Actually, it is the whole `do`-block. By using `withRef` we ensure
+the synthetic position for the `with_annotate_term ..` is equal to `term`.
+Recall that synthetic positions are used when generating error messages.
+-/
+def annotate [Monad m] [MonadRef m] [MonadQuotation m] (ref : Syntax) (term : Syntax) : m Syntax :=
+  withRef term <| `(with_annotate_term $ref $term)
+
+namespace ToTerm
+
+inductive Kind where
+  | regular
+  | forIn
+  | forInWithReturn
+  | nestedBC
+  | nestedPR
+  | nestedSBC
+  | nestedPRBC
+
+instance : Inhabited Kind := ⟨Kind.regular⟩
+
+def Kind.isRegular : Kind → Bool
+  | .regular => true
+  | _        => false
+
+structure Context where
+  /-- Syntax to reference the monad associated with the do notation. -/
+  m          : Syntax
+  /-- Syntax to reference the result of the monadic computation performed by the do notation. -/
+  returnType : Syntax
+  uvars      : Array Var
+  kind       : Kind
+
+abbrev M := ReaderT Context MacroM
+
+def mkUVarTuple : M Syntax := do
+  let ctx ← read
+  mkTuple ctx.uvars
+
+def returnToTerm (val : Syntax) : M Syntax := do
+  let ctx ← read
+  let u ← mkUVarTuple
+  match ctx.kind with
+  | .regular         => if ctx.uvars.isEmpty then ``(Pure.pure $val) else ``(Pure.pure (MProd.mk $val $u))
+  | .forIn           => ``(Pure.pure (ForInStep.done $u))
+  | .forInWithReturn => ``(Pure.pure (ForInStep.done (MProd.mk (some $val) $u)))
+  | .nestedBC        => unreachable!
+  | .nestedPR        => ``(Pure.pure (DoResultPR.«return» $val $u))
+  | .nestedSBC       => ``(Pure.pure (DoResultSBC.«pureReturn» $val $u))
+  | .nestedPRBC      => ``(Pure.pure (DoResultPRBC.«return» $val $u))
+
+def continueToTerm : M Syntax := do
+  let ctx ← read
+  let u ← mkUVarTuple
+  match ctx.kind with
+  | .regular         => unreachable!
+  | .forIn           => ``(Pure.pure (ForInStep.yield $u))
+  | .forInWithReturn => ``(Pure.pure (ForInStep.yield (MProd.mk none $u)))
+  | .nestedBC        => ``(Pure.pure (DoResultBC.«continue» $u))
+  | .nestedPR        => unreachable!
+  | .nestedSBC       => ``(Pure.pure (DoResultSBC.«continue» $u))
+  | .nestedPRBC      => ``(Pure.pure (DoResultPRBC.«continue» $u))
+
+def breakToTerm : M Syntax := do
+  let ctx ← read
+  let u ← mkUVarTuple
+  match ctx.kind with
+  | .regular         => unreachable!
+  | .forIn           => ``(Pure.pure (ForInStep.done $u))
+  | .forInWithReturn => ``(Pure.pure (ForInStep.done (MProd.mk none $u)))
+  | .nestedBC        => ``(Pure.pure (DoResultBC.«break» $u))
+  | .nestedPR        => unreachable!
+  | .nestedSBC       => ``(Pure.pure (DoResultSBC.«break» $u))
+  | .nestedPRBC      => ``(Pure.pure (DoResultPRBC.«break» $u))
+
+def actionTerminalToTerm (action : Syntax) : M Syntax := withRef action <| withFreshMacroScope do
+  let ctx ← read
+  let u ← mkUVarTuple
+  match ctx.kind with
+  | .regular         => if ctx.uvars.isEmpty then pure action else ``(Bind.bind $action fun y => Pure.pure (MProd.mk y $u))
+  | .forIn           => ``(Bind.bind $action fun (_ : PUnit) => Pure.pure (ForInStep.yield $u))
+  | .forInWithReturn => ``(Bind.bind $action fun (_ : PUnit) => Pure.pure (ForInStep.yield (MProd.mk none $u)))
+  | .nestedBC        => unreachable!
+  | .nestedPR        => ``(Bind.bind $action fun y => (Pure.pure (DoResultPR.«pure» y $u)))
+  | .nestedSBC       => ``(Bind.bind $action fun y => (Pure.pure (DoResultSBC.«pureReturn» y $u)))
+  | .nestedPRBC      => ``(Bind.bind $action fun y => (Pure.pure (DoResultPRBC.«pure» y $u)))
+
+def seqToTerm (action : Syntax) (k : Syntax) : M Syntax := withRef action <| withFreshMacroScope do
+  if action.getKind == ``Parser.Term.doDbgTrace then
+    let msg := action[1]
+    `(dbg_trace $msg; $k)
+  else if action.getKind == ``Parser.Term.doAssert then
+    let cond := action[1]
+    `(assert! $cond; $k)
+  else if action.getKind == ``Parser.Term.doDebugAssert then
+    let cond := action[1]
+    `(debugAssert| debug_assert! $cond; $k)
+  else
+    let action ← withRef action ``(($action : $((←read).m) PUnit))
+    ``(Bind.bind $action (fun (_ : PUnit) => $k))
+
+def declToTerm (decl : Syntax) (k : Syntax) : M Syntax := withRef decl <| withFreshMacroScope do
+  let kind := decl.getKind
+  if kind == ``Parser.Term.doLet then
+    let letDecl := decl[2]
+    `(let $letDecl:letDecl; $k)
+  else if kind == ``Parser.Term.doLetRec then
+    let letRecToken := decl[0]
+    let letRecDecls := decl[1]
+    return mkNode ``Parser.Term.letrec #[letRecToken, letRecDecls, mkNullNode, k]
+  else if kind == ``Parser.Term.doLetArrow then
+    let arg := decl[2]
+    if arg.getKind == ``Parser.Term.doIdDecl then
+      let id     := arg[0]
+      let type   := expandOptType id arg[1]
+      let doElem := arg[3]
+      -- `doElem` must be a `doExpr action`. See `doLetArrowToCode`
+      match isDoExpr? doElem with
+      | some action =>
+        let action ← withRef action `(($action : $((← read).m) $type))
+        ``(Bind.bind $action (fun ($id:ident : $type) => $k))
+      | none        => Macro.throwErrorAt decl "unexpected kind of `do` declaration"
+    else
+      Macro.throwErrorAt decl "unexpected kind of `do` declaration"
+  else if kind == ``Parser.Term.doHave then
+    -- The `have` term is of the form  `"have " >> letDecl >> optSemicolon termParser`
+    let args := decl.getArgs
+    let args := args ++ #[mkNullNode /- optional ';' -/, k]
+    return mkNode `Lean.Parser.Term.«have» args
+  else
+    Macro.throwErrorAt decl "unexpected kind of `do` declaration"
+
+def reassignToTerm (reassign : Syntax) (k : Syntax) : MacroM Syntax := withRef reassign <| withFreshMacroScope do
+  match reassign with
+  | `(doElem| $x:ident := $rhs) => `(let $x:ident := ensure_type_of% $x $(quote "invalid reassignment, value") $rhs; $k)
+  | `(doElem| $e:term  := $rhs) => `(let $e:term  := ensure_type_of% $e $(quote "invalid reassignment, value") $rhs; $k)
+  | _ =>
+    -- Note that `doReassignArrow` is expanded by `doReassignArrowToCode
+    Macro.throwErrorAt reassign "unexpected kind of `do` reassignment"
+
+def mkIte (optIdent : Syntax) (cond : Syntax) (thenBranch : Syntax) (elseBranch : Syntax) : MacroM Syntax := do
+  if optIdent.isNone then
+    ``(if $cond then $thenBranch else $elseBranch)
+  else
+    let h := optIdent[0]
+    ``(if $h:ident : $cond then $thenBranch else $elseBranch)
+
+def mkJoinPoint (j : Name) (ps : Array (Syntax × Bool)) (body : Syntax) (k : Syntax) : M Syntax := withRef body <| withFreshMacroScope do
+  let pTypes ← ps.mapM fun ⟨id, useTypeOf⟩ => do if useTypeOf then `(type_of% $id) else `(_)
+  let ps     := ps.map (·.1)
+  /-
+  We use `let_delayed` instead of `let` for joinpoints to make sure `$k` is elaborated before `$body`.
+  By elaborating `$k` first, we "learn" more about `$body`'s type.
+  For example, consider the following example `do` expression
+  ```
+  def f (x : Nat) : IO Unit := do
+  if x > 0 then
+    IO.println "x is not zero" -- Error is here
+  IO.mkRef true
+  ```
+  it is expanded into
+  ```
+  def f (x : Nat) : IO Unit := do
+  let jp (u : Unit) : IO _ :=
+    IO.mkRef true;
+  if x > 0 then
+    IO.println "not zero"
+    jp ()
+  else
+    jp ()
+  ```
+  If we use the regular `let` instead of `let_delayed`, the joinpoint `jp` will be elaborated and its type will be inferred to be `Unit → IO (IO.Ref Bool)`.
+  Then, we get a typing error at `jp ()`. By using `let_delayed`, we first elaborate `if x > 0 ...` and learn that `jp` has type `Unit → IO Unit`.
+  Then, we get the expected type mismatch error at `IO.mkRef true`. -/
+  `(let_delayed $(← mkIdentFromRef j):ident $[($ps : $pTypes)]* : $((← read).m) _ := $body; $k)
+
+def mkJmp (ref : Syntax) (j : Name) (args : Array Syntax) : Syntax :=
+  Syntax.mkApp (mkIdentFrom ref j) args
+
+partial def toTerm (c : Code) : M Syntax := do
+  let term ← go c
+  if let some ref := c.getRef? then
+    annotate ref term
+  else
+    return term
+where
+  go (c : Code) : M Syntax := do
+    match c with
+    | .return ref val     => withRef ref <| returnToTerm val
+    | .continue ref       => withRef ref continueToTerm
+    | .break ref          => withRef ref breakToTerm
+    | .action e           => actionTerminalToTerm e
+    | .joinpoint j ps b k => mkJoinPoint j ps (← toTerm b) (← toTerm k)
+    | .jmp ref j args     => return mkJmp ref j args
+    | .decl _ stx k       => declToTerm stx (← toTerm k)
+    | .reassign _ stx k   => reassignToTerm stx (← toTerm k)
+    | .seq stx k          => seqToTerm stx (← toTerm k)
+    | .ite ref _ o c t e  => withRef ref <| do mkIte o c (← toTerm t) (← toTerm e)
+    | .match ref genParam discrs optMotive alts =>
+      let mut termAlts := #[]
+      for alt in alts do
+        let rhs ← toTerm alt.rhs
+        let termAlt := mkNode ``Parser.Term.matchAlt #[mkAtomFrom alt.ref "|", mkNullNode #[alt.patterns], mkAtomFrom alt.ref "=>", rhs]
+        termAlts := termAlts.push termAlt
+      let termMatchAlts := mkNode ``Parser.Term.matchAlts #[mkNullNode termAlts]
+      return mkNode ``Parser.Term.«match» #[mkAtomFrom ref "match", genParam, optMotive, discrs, mkAtomFrom ref "with", termMatchAlts]
+    | .matchExpr ref «meta» d alts elseBranch => withFreshMacroScope do
+      let d' ← `(discr)
+      let mut termAlts := #[]
+      for alt in alts do
+        let rhs ← `(($(← toTerm alt.rhs) : $((← read).m) _))
+        let optVar := if let some var := alt.var? then mkNullNode #[var, mkAtomFrom var "@"] else mkNullNode #[]
+        let pat := mkNode ``Parser.Term.matchExprPat #[optVar, alt.funName, mkNullNode alt.pvars]
+        let termAlt := mkNode ``Parser.Term.matchExprAlt #[mkAtomFrom alt.ref "|", pat, mkAtomFrom alt.ref "=>", rhs]
+        termAlts := termAlts.push termAlt
+      let elseBranch := mkNode ``Parser.Term.matchExprElseAlt #[mkAtomFrom ref "|", mkHole ref, mkAtomFrom ref "=>", (← toTerm elseBranch)]
+      let termMatchExprAlts := mkNode ``Parser.Term.matchExprAlts #[mkNullNode termAlts, elseBranch]
+      let body := mkNode ``Parser.Term.matchExpr #[mkAtomFrom ref "match_expr", d', mkAtomFrom ref "with", termMatchExprAlts]
+      if «meta» then
+        `(Bind.bind (instantiateMVarsIfMVarApp $d) fun discr => $body)
+      else
+        `(let discr := $d; $body)
+
+def run (code : Code) (m : Syntax) (returnType : Syntax) (uvars : Array Var := #[]) (kind := Kind.regular) : MacroM Syntax :=
+  toTerm code { m, returnType, kind, uvars }
+
+/-- Given
+   - `a` is true if the code block has a `Code.action _` exit point
+   - `r` is true if the code block has a `Code.return _ _` exit point
+   - `bc` is true if the code block has a `Code.break _` or `Code.continue _` exit point
+
+   generate Kind. See comment at the beginning of the `ToTerm` namespace. -/
+def mkNestedKind (a r bc : Bool) : Kind :=
+  match a, r, bc with
+  | true,  false, false => .regular
+  | false, true,  false => .regular
+  | false, false, true  => .nestedBC
+  | true,  true,  false => .nestedPR
+  | true,  false, true  => .nestedSBC
+  | false, true,  true  => .nestedSBC
+  | true,  true,  true  => .nestedPRBC
+  | false, false, false => unreachable!
+
+def mkNestedTerm (code : Code) (m : Syntax) (returnType : Syntax) (uvars : Array Var) (a r bc : Bool) : MacroM Syntax := do
+  ToTerm.run code m returnType uvars (mkNestedKind a r bc)
+
+/-- Given a term `term` produced by `ToTerm.run`, pattern match on its result.
+   See comment at the beginning of the `ToTerm` namespace.
+
+   - `a` is true if the code block has a `Code.action _` exit point
+   - `r` is true if the code block has a `Code.return _ _` exit point
+   - `bc` is true if the code block has a `Code.break _` or `Code.continue _` exit point
+
+   The result is a sequence of `doElem` -/
+def matchNestedTermResult (term : Syntax) (uvars : Array Var) (a r bc : Bool) : MacroM (List Syntax) := do
+  let toDoElems (auxDo : Syntax) : List Syntax := getDoSeqElems (getDoSeq auxDo)
+  let u ← mkTuple uvars
+  match a, r, bc with
+  | true, false, false =>
+    if uvars.isEmpty then
+      return toDoElems (← `(do $term:term))
+    else
+      return toDoElems (← `(do let r ← $term:term; $u:term := r.2; pure r.1))
+  | false, true, false =>
+    if uvars.isEmpty then
+      return toDoElems (← `(do let r ← $term:term; return r))
+    else
+      return toDoElems (← `(do let r ← $term:term; $u:term := r.2; return r.1))
+  | false, false, true => toDoElems <$>
+    `(do let r ← $term:term;
+         match r with
+         | .break u => $u:term := u; break
+         | .continue u => $u:term := u; continue)
+  | true, true, false => toDoElems <$>
+    `(do let r ← $term:term;
+         match r with
+         | .pure a u => $u:term := u; pure a
+         | .return b u => $u:term := u; return b)
+  | true, false, true => toDoElems <$>
+    `(do let r ← $term:term;
+         match r with
+         | .pureReturn a u => $u:term := u; pure a
+         | .break u => $u:term := u; break
+         | .continue u => $u:term := u; continue)
+  | false, true, true => toDoElems <$>
+    `(do let r ← $term:term;
+         match r with
+         | .pureReturn a u => $u:term := u; return a
+         | .break u => $u:term := u; break
+         | .continue u => $u:term := u; continue)
+  | true, true, true => toDoElems <$>
+    `(do let r ← $term:term;
+         match r with
+         | .pure a u => $u:term := u; pure a
+         | .return a u => $u:term := u; return a
+         | .break u => $u:term := u; break
+         | .continue u => $u:term := u; continue)
+  | false, false, false => unreachable!
+
+end ToTerm
+
+def isMutableLet (doElem : Syntax) : Bool :=
+  let kind := doElem.getKind
+  (kind == ``doLetArrow || kind == ``doLet || kind == ``doLetElse)
+  &&
+  !doElem[1].isNone
+
+namespace ToCodeBlock
+
+structure Context where
+  ref         : Syntax
+  /-- Syntax representing the monad associated with the do notation. -/
+  m           : Syntax
+  /-- Syntax to reference the result of the monadic computation performed by the do notation. -/
+  returnType  : Syntax
+  mutableVars : VarSet := {}
+  insideFor   : Bool := false
+
+abbrev M := ReaderT Context TermElabM
+
+def withNewMutableVars {α} (newVars : Array Var) (mutable : Bool) (x : M α) : M α :=
+  withReader (fun ctx => if mutable then { ctx with mutableVars := insertVars ctx.mutableVars newVars } else ctx) x
+
+def checkReassignable (xs : Array Var) : M Unit := do
+  let throwInvalidReassignment (x : Name) : M Unit :=
+    throwError "`{x.simpMacroScopes}` cannot be mutated, only variables declared using `let mut` can be mutated. If you did not intend to mutate but define `{x.simpMacroScopes}`, consider using `let {x.simpMacroScopes}` instead"
+  let ctx ← read
+  for x in xs do
+    unless ctx.mutableVars.contains x.getId do
+      throwInvalidReassignment x.getId
+
+def checkNotShadowingMutable (xs : Array Var) : M Unit := do
+  let throwInvalidShadowing (x : Name) : M Unit :=
+    throwError "mutable variable `{x.simpMacroScopes}` cannot be shadowed"
+  let ctx ← read
+  for x in xs do
+    if ctx.mutableVars.contains x.getId then
+      withRef x <| throwInvalidShadowing x.getId
+
+def withFor {α} (x : M α) : M α :=
+  withReader (fun ctx => { ctx with insideFor := true }) x
+
+structure ToForInTermResult where
+  uvars      : Array Var
+  term       : Syntax
+
+def mkForInBody  (_ : Syntax) (forInBody : CodeBlock) : M ToForInTermResult := do
+  let ctx ← read
+  let uvars := forInBody.uvars
+  let uvars := varSetToArray uvars
+  let term ← liftMacroM <| ToTerm.run forInBody.code ctx.m ctx.returnType uvars (if hasReturn forInBody.code then ToTerm.Kind.forInWithReturn else ToTerm.Kind.forIn)
+  return ⟨uvars, term⟩
+
+def ensureInsideFor : M Unit :=
+  unless (← read).insideFor do
+    throwError "invalid `do` element, it must be inside `for`"
+
+def ensureEOS (doElems : List Syntax) : M Unit :=
+  unless doElems.isEmpty do
+    throwError "must be last element in a `do` sequence"
+
+variable (baseId : Name) in
+private partial def expandLiftMethodAux (inQuot : Bool) (inBinder : Bool) : Syntax → StateT (List Syntax) M Syntax
+  | stx@(Syntax.node i k args) =>
+    if k == choiceKind then do
+      -- choice node: check that lifts are consistent
+      let alts ← stx.getArgs.mapM (expandLiftMethodAux inQuot inBinder · |>.run [])
+      let (_, lifts) := alts[0]!
+      unless alts.all (·.2 == lifts) do
+        throwErrorAt stx "cannot lift `(<- ...)` over inconsistent syntax variants, consider lifting out the binding manually"
+      modify (· ++ lifts)
+      return .node i k (alts.map (·.1))
+    else if liftMethodDelimiter k then
+      return stx
+    -- For `pure` if-then-else, we only lift `(<- ...)` occurring in the condition.
+    else if h : args.size >= 2 ∧ (k == ``termDepIfThenElse || k == ``termIfThenElse) then do
+      let inAntiquot := stx.isAntiquot && !stx.isEscapedAntiquot
+      let arg1 ← expandLiftMethodAux (inQuot && !inAntiquot || stx.isQuot) inBinder args[1]
+      let args := args.set! 1 arg1
+      return Syntax.node i k args
+    else if k == ``Parser.Term.liftMethod && !inQuot then withFreshMacroScope do
+      if inBinder then
+        throwErrorAt stx "cannot lift `(<- ...)` over a binder, this error usually happens when you are trying to lift a method nested in a `fun`, `let`, or `match`-alternative, and it can often be fixed by adding a missing `do`"
+      let term := args[1]!
+      let term ← expandLiftMethodAux inQuot inBinder term
+      -- keep name deterministic across choice branches
+      let id ← mkIdentFromRef (.num baseId (← get).length)
+      let auxDoElem : Syntax ← `(doElem| let $id:ident ← $term:term)
+      modify fun s => s ++ [auxDoElem]
+      return id
+    else do
+      let inAntiquot := stx.isAntiquot && !stx.isEscapedAntiquot
+      let inBinder   := inBinder || (!inQuot && liftMethodForbiddenBinder stx)
+      let args ← args.mapM (expandLiftMethodAux (inQuot && !inAntiquot || stx.isQuot) inBinder)
+      return Syntax.node i k args
+  | stx => return stx
+
+def expandLiftMethod (doElem : Syntax) : M (List Syntax × Syntax) := do
+  if !hasLiftMethod doElem then
+    return ([], doElem)
+  else
+    let baseId ← withFreshMacroScope (MonadQuotation.addMacroScope `__do_lift)
+    let (doElem, doElemsNew) ← (expandLiftMethodAux baseId false false doElem).run []
+    return (doElemsNew, doElem)
+
+def checkLetArrowRHS (doElem : Syntax) : M Unit := do
+  let kind := doElem.getKind
+  if kind == ``Parser.Term.doLetArrow ||
+     kind == ``Parser.Term.doLet ||
+     kind == ``Parser.Term.doLetRec ||
+     kind == ``Parser.Term.doHave ||
+     kind == ``Parser.Term.doReassign ||
+     kind == ``Parser.Term.doReassignArrow then
+    throwErrorAt doElem "invalid kind of value `{kind}` in an assignment"
+
+/-- Generate `CodeBlock` for `doReturn` which is of the form
+   ```
+   "return " >> optional termParser
+   ```
+   `doElems` is only used for sanity checking. -/
+def doReturnToCode (doReturn : Syntax) (doElems: List Syntax) : M CodeBlock := withRef doReturn do
+  ensureEOS doElems
+  let argOpt := doReturn[1]
+  let arg ← if argOpt.isNone then liftMacroM mkUnit else pure argOpt[0]
+  return mkReturn (← getRef) arg
+
+structure Catch where
+  x         : Syntax
+  optType   : Syntax
+  codeBlock : CodeBlock
+
+def getTryCatchUpdatedVars (tryCode : CodeBlock) (catches : Array Catch) (finallyCode? : Option CodeBlock) : VarSet :=
+  let ws := tryCode.uvars
+  let ws := catches.foldl (init := ws) fun ws alt => union alt.codeBlock.uvars ws
+  let ws := match finallyCode? with
+    | none   => ws
+    | some c => union c.uvars ws
+  ws
+
+def tryCatchPred (tryCode : CodeBlock) (catches : Array Catch) (finallyCode? : Option CodeBlock) (p : Code → Bool) : Bool :=
+  p tryCode.code ||
+  catches.any (fun «catch» => p «catch».codeBlock.code) ||
+  match finallyCode? with
+  | none => false
+  | some finallyCode => p finallyCode.code
+
+mutual
+  /-- "Concatenate" `c` with `doSeqToCode doElems` -/
+  partial def concatWith (c : CodeBlock) (doElems : List Syntax) : M CodeBlock :=
+    match doElems with
+    | [] => pure c
+    | nextDoElem :: _  => do
+      let k ← doSeqToCode doElems
+      let ref := nextDoElem
+      concat c ref none k
+
+  /-- Generate `CodeBlock` for `doLetArrow; doElems`
+     `doLetArrow` is of the form
+     ```
+     "let " >> optional "mut " >> (doIdDecl <|> doPatDecl)
+     ```
+     where
+     ```
+     def doIdDecl   := leading_parser ident >> optType >> leftArrow >> doElemParser
+     def doPatDecl  := leading_parser termParser >> leftArrow >> doElemParser >> optional (" | " >> doSeq)
+     ```
+  -/
+  partial def doLetArrowToCode (doLetArrow : Syntax) (doElems : List Syntax) : M CodeBlock := do
+    let decl    := doLetArrow[2]
+    if decl.getKind == ``Parser.Term.doIdDecl then
+      let y := decl[0]
+      checkNotShadowingMutable #[y]
+      let doElem := decl[3]
+      let k ← withNewMutableVars #[y] (isMutableLet doLetArrow) (doSeqToCode doElems)
+      match isDoExpr? doElem with
+      | some _      => return mkVarDeclCore #[y] doLetArrow k
+      | none =>
+        checkLetArrowRHS doElem
+        let c ← doSeqToCode [doElem]
+        match doElems with
+        | []       => pure c
+        | kRef::_  => concat c kRef y k
+    else if decl.getKind == ``Parser.Term.doPatDecl then
+      let pattern := decl[0]
+      let doElem  := decl[2]
+      let optElse := decl[3]
+      if optElse.isNone then withFreshMacroScope do
+        let auxDo ← if isMutableLet doLetArrow then
+          `(do let%$doLetArrow __discr ← $doElem; let%$doLetArrow mut $pattern:term := __discr)
+        else
+          `(do let%$doLetArrow __discr ← $doElem; let%$doLetArrow $pattern:term := __discr)
+        doSeqToCode <| getDoSeqElems (getDoSeq auxDo) ++ doElems
+      else
+        let contSeq ← if isMutableLet doLetArrow then
+          let vars ← (← getPatternVarsEx pattern).mapM fun var => `(doElem| let mut $var := $var)
+          pure (vars ++ doElems.toArray)
+        else
+          pure doElems.toArray
+        let contSeq := mkDoSeq contSeq
+        let elseSeq := optElse[1]
+        let auxDo ← `(do let%$doLetArrow __discr ← $doElem; match%$doLetArrow __discr with | $pattern:term => $contSeq | _ => $elseSeq)
+        doSeqToCode <| getDoSeqElems (getDoSeq auxDo)
+    else
+      throwError "unexpected kind of `do` declaration"
+
+  partial def doLetElseToCode (doLetElse : Syntax) (doElems : List Syntax) : M CodeBlock := do
+    -- "let " >> optional "mut " >> termParser >> " := " >> termParser >> checkColGt >> " | " >> doSeq
+    let pattern := doLetElse[2]
+    let val     := doLetElse[4]
+    let elseSeq := doLetElse[6]
+    let contSeq ← if isMutableLet doLetElse then
+      let vars ← (← getPatternVarsEx pattern).mapM fun var => `(doElem| let mut $var := $var)
+      pure (vars ++ doElems.toArray)
+    else
+      pure doElems.toArray
+    let contSeq := mkDoSeq contSeq
+    let auxDo ← `(do match $val:term with | $pattern:term => $contSeq | _ => $elseSeq)
+    doSeqToCode <| getDoSeqElems (getDoSeq auxDo)
+
+  /-- Generate `CodeBlock` for `doReassignArrow; doElems`
+     `doReassignArrow` is of the form
+     ```
+     (doIdDecl <|> doPatDecl)
+     ```
+  -/
+  partial def doReassignArrowToCode (doReassignArrow : Syntax) (doElems : List Syntax) : M CodeBlock := do
+    let decl := doReassignArrow[0]
+    if decl.getKind == ``Parser.Term.doIdDecl then
+      let doElem := decl[3]
+      let y      := decl[0]
+      let auxDo ← `(do let r ← $doElem; $y:ident := r)
+      doSeqToCode <| getDoSeqElems (getDoSeq auxDo) ++ doElems
+    else if decl.getKind == ``Parser.Term.doPatDecl then
+      let pattern := decl[0]
+      let doElem  := decl[2]
+      let optElse := decl[3]
+      if optElse.isNone then withFreshMacroScope do
+        let auxDo ← `(do let __discr ← $doElem; $pattern:term := __discr)
+        doSeqToCode <| getDoSeqElems (getDoSeq auxDo) ++ doElems
+      else
+        throwError "reassignment with `|` (i.e., \"else clause\") is not currently supported"
+    else
+      throwError "unexpected kind of `do` reassignment"
+
+  /-- Generate `CodeBlock` for `doIf; doElems`
+     `doIf` is of the form
+     ```
+     "if " >> optIdent >> termParser >> " then " >> doSeq
+      >> many (group (try (group (" else " >> " if ")) >> optIdent >> termParser >> " then " >> doSeq))
+      >> optional (" else " >> doSeq)
+     ```  -/
+  partial def doIfToCode (doIf : Syntax) (doElems : List Syntax) : M CodeBlock := do
+    let view := mkDoIfView doIf
+    let thenBranch ← doSeqToCode (getDoSeqElems view.thenBranch)
+    let elseBranch ← doSeqToCode (getDoSeqElems view.elseBranch)
+    let ite ← mkIte view.ref view.optIdent view.cond thenBranch elseBranch
+    concatWith ite doElems
+
+  /-- Generate `CodeBlock` for `doUnless; doElems`
+     `doUnless` is of the form
+     ```
+     "unless " >> termParser >> "do " >> doSeq
+     ```  -/
+  partial def doUnlessToCode (doUnless : Syntax) (doElems : List Syntax) : M CodeBlock := withRef doUnless do
+    let cond  := doUnless[1]
+    let doSeq := doUnless[3]
+    let body ← doSeqToCode (getDoSeqElems doSeq)
+    let unlessCode ← liftMacroM <| mkUnless cond body
+    concatWith unlessCode doElems
+
+  /-- Generate `CodeBlock` for `doFor; doElems`
+     `doFor` is of the form
+     ```
+     def doForDecl := leading_parser termParser >> " in " >> withForbidden "do" termParser
+     def doFor := leading_parser "for " >> sepBy1 doForDecl ", " >> "do " >> doSeq
+     ```
+  -/
+  partial def doForToCode (doFor : Syntax) (doElems : List Syntax) : M CodeBlock := do
+    let doForDecls := doFor[1].getSepArgs
+    if h : doForDecls.size > 1 then
+      /-
+        Expand
+        ```
+        for x in xs, y in ys do
+          body
+        ```
+        into
+        ```
+        let s := toStream ys
+        for x in xs do
+          match Stream.next? s with
+          | none => break
+          | some (y, s') =>
+            s := s'
+            body
+        ```
+      -/
+      -- Extract second element
+      let doForDecl := doForDecls[1]!
+      unless doForDecl[0].isNone do
+        throwErrorAt doForDecl[0] "the proof annotation here has not been implemented yet"
+      let y  := doForDecl[1]
+      let ys := doForDecl[3]
+      let doForDecls := doForDecls.eraseIdx 1
+      let body := doFor[3]
+      withFreshMacroScope do
+        /- Recall that `@` (explicit) disables `coeAtOutParam`.
+           We used `@` at `Stream` functions to make sure `resultIsOutParamSupport` is not used. -/
+        let toStreamApp ← withRef ys `(@toStream _ _ _ $ys)
+        let auxDo ←
+          `(do let mut s := $toStreamApp:term
+               for $doForDecls:doForDecl,* do
+                 match @Stream.next? _ _ _ s with
+                 | none => break
+                 | some ($y, s') =>
+                   s := s'
+                   do $body)
+        doSeqToCode (getDoSeqElems (getDoSeq auxDo) ++ doElems)
+    else withRef doFor do
+      let h?        := if doForDecls[0]![0].isNone then none else some doForDecls[0]![0][0]
+      let x         := doForDecls[0]![1]
+      withRef x <| checkNotShadowingMutable (← getPatternVarsEx x)
+      let xs        := doForDecls[0]![3]
+      let forElems  := getDoSeqElems doFor[3]
+      let forInBodyCodeBlock ← withFor (doSeqToCode forElems)
+      let ⟨uvars, forInBody⟩ ← mkForInBody x forInBodyCodeBlock
+      let ctx ← read
+      -- semantic no-op that replaces the `uvars`' position information (which all point inside the loop)
+      -- with that of the respective mutable declarations outside the loop, which allows the language
+      -- server to identify them as conceptually identical variables
+      let uvars := uvars.map fun v => ctx.mutableVars.findD v.getId v
+      let uvarsTuple ← liftMacroM do mkTuple uvars
+      if hasReturn forInBodyCodeBlock.code then
+        let forInBody ← liftMacroM <| destructTuple uvars (← `(r)) forInBody
+        let optType ← `(Option $((← read).returnType))
+        let forInTerm ← if let some h := h? then
+          annotate doFor
+            (← `(for_in'% $(xs) (MProd.mk (none : $optType) $uvarsTuple) fun $x $h (r : MProd $optType _) => let r := r.2; $forInBody))
+        else
+          annotate doFor
+            (← `(for_in% $(xs) (MProd.mk (none : $optType) $uvarsTuple) fun $x (r : MProd $optType _) => let r := r.2; $forInBody))
+        let auxDo ← `(do let r ← $forInTerm:term;
+                         $uvarsTuple:term := r.2;
+                         match r.1 with
+                         | none => Pure.pure (ensure_expected_type% "type mismatch, `for`" PUnit.unit)
+                         | some a => return ensure_expected_type% "type mismatch, `for`" a)
+        doSeqToCode (getDoSeqElems (getDoSeq auxDo) ++ doElems)
+      else
+        let forInBody ← liftMacroM <| destructTuple uvars (← `(r)) forInBody
+        let forInTerm ← if let some h := h? then
+          annotate doFor (← `(for_in'% $(xs) $uvarsTuple fun $x $h r => $forInBody))
+        else
+          annotate doFor (← `(for_in% $(xs) $uvarsTuple fun $x r => $forInBody))
+        if doElems.isEmpty then
+          let auxDo ← `(do let r ← $forInTerm:term;
+                           $uvarsTuple:term := r;
+                           Pure.pure (ensure_expected_type% "type mismatch, `for`" PUnit.unit))
+          doSeqToCode <| getDoSeqElems (getDoSeq auxDo)
+        else
+          let auxDo ← `(do let r ← $forInTerm:term; $uvarsTuple:term := r)
+          doSeqToCode <| getDoSeqElems (getDoSeq auxDo) ++ doElems
+
+  /-- Generate `CodeBlock` for `doMatch; doElems` -/
+  partial def doMatchToCode (doMatch : Syntax) (doElems: List Syntax) : M CodeBlock := do
+    let ref       := doMatch
+    let genParam  := doMatch[1]
+    let optMotive := doMatch[2]
+    let discrs    := doMatch[3]
+    let matchAlts := doMatch[5][0].getArgs -- Array of `doMatchAlt`
+    let matchAlts ← matchAlts.foldlM (init := #[]) fun result matchAlt => return result ++ (← liftMacroM <| expandMatchAlt matchAlt)
+    let alts ←  matchAlts.mapM fun matchAlt => do
+      let patterns := matchAlt[1][0]
+      let vars ← getPatternsVarsEx patterns.getSepArgs
+      withRef patterns <| checkNotShadowingMutable vars
+      let rhs  := matchAlt[3]
+      let rhs ← doSeqToCode (getDoSeqElems rhs)
+      pure { ref := matchAlt, vars := vars, patterns := patterns, rhs := rhs : Alt CodeBlock }
+    let matchCode ← mkMatch ref genParam discrs optMotive alts
+    concatWith matchCode doElems
+
+  /-- Generate `CodeBlock` for `doMatchExpr; doElems` -/
+  partial def doMatchExprToCode (doMatchExpr : Syntax) (doElems: List Syntax) : M CodeBlock := do
+    let ref       := doMatchExpr
+    let «meta»    := doMatchExpr[1].isNone
+    let discr     := doMatchExpr[2]
+    let alts      := doMatchExpr[4][0].getArgs -- Array of `doMatchExprAlt`
+    let alts ← alts.mapM fun alt => do
+      let pat      := alt[1]
+      let var?     := if pat[0].isNone then none else some pat[0][0]
+      let funName  := pat[1]
+      let pvars    := pat[2].getArgs
+      let rhs      := alt[3]
+      let rhs ← doSeqToCode (getDoSeqElems rhs)
+      pure { ref, var?, funName, pvars, rhs }
+    let elseBranch ← doSeqToCode (getDoSeqElems doMatchExpr[4][1][3])
+    let matchCode ← mkMatchExpr ref «meta» discr alts elseBranch
+    concatWith matchCode doElems
+
+  /--
+    Generate `CodeBlock` for `doTry; doElems`
+    ```
+    def doTry := leading_parser "try " >> doSeq >> many (doCatch <|> doCatchMatch) >> optional doFinally
+    def doCatch      := leading_parser "catch " >> binderIdent >> optional (":" >> termParser) >> darrow >> doSeq
+    def doCatchMatch := leading_parser "catch " >> doMatchAlts
+    def doFinally    := leading_parser "finally " >> doSeq
+    ```
+  -/
+  partial def doTryToCode (doTry : Syntax) (doElems: List Syntax) : M CodeBlock := do
+    let tryCode ← doSeqToCode (getDoSeqElems doTry[1])
+    let optFinally := doTry[3]
+    let catches ← doTry[2].getArgs.mapM fun catchStx : Syntax => do
+      if catchStx.getKind == ``Parser.Term.doCatch then
+        let x       := catchStx[1]
+        if x.isIdent then
+          withRef x <| checkNotShadowingMutable #[x]
+        let optType := catchStx[2]
+        let c ← doSeqToCode (getDoSeqElems catchStx[4])
+        return { x := x, optType := optType, codeBlock := c : Catch }
+      else if catchStx.getKind == ``Parser.Term.doCatchMatch then
+        let matchAlts := catchStx[1]
+        let x ← `(ex)
+        let auxDo ← `(do match ex with $matchAlts)
+        let c ← doSeqToCode (getDoSeqElems (getDoSeq auxDo))
+        return { x := x, codeBlock := c, optType := mkNullNode : Catch }
+      else
+        throwError "unexpected kind of `catch`"
+    let finallyCode? ← if optFinally.isNone then pure none else some <$> doSeqToCode (getDoSeqElems optFinally[0][1])
+    if catches.isEmpty && finallyCode?.isNone then
+      throwError "invalid `try`, it must have a `catch` or `finally`"
+    let ctx ← read
+    let ws    := getTryCatchUpdatedVars tryCode catches finallyCode?
+    let uvars := varSetToArray ws
+    let a     := tryCatchPred tryCode catches finallyCode? hasTerminalAction
+    let r     := tryCatchPred tryCode catches finallyCode? hasReturn
+    let bc    := tryCatchPred tryCode catches finallyCode? hasBreakContinue
+    let toTerm (codeBlock : CodeBlock) : M Syntax := do
+      let codeBlock ← liftM $ extendUpdatedVars codeBlock ws
+      liftMacroM <| ToTerm.mkNestedTerm codeBlock.code ctx.m ctx.returnType uvars a r bc
+    let term ← toTerm tryCode
+    let term ← catches.foldlM (init := term) fun term «catch» => do
+      let catchTerm ← toTerm «catch».codeBlock
+      if catch.optType.isNone then
+        annotate doTry (← ``(MonadExcept.tryCatch $term (fun $(«catch».x):ident => $catchTerm)))
+      else
+        let type := «catch».optType[1]
+        annotate doTry (← ``(tryCatchThe $type $term (fun $(«catch».x):ident => $catchTerm)))
+    let term ← match finallyCode? with
+      | none             => pure term
+      | some finallyCode => withRef optFinally do
+        unless finallyCode.uvars.isEmpty do
+          throwError "`finally` currently does not support reassignments"
+        if hasBreakContinueReturn finallyCode.code then
+          throwError "`finally` currently does `return`, `break`, nor `continue`"
+        let finallyTerm ← liftMacroM <| ToTerm.run finallyCode.code ctx.m ctx.returnType {} ToTerm.Kind.regular
+        annotate doTry (← ``(tryFinally $term $finallyTerm))
+    let doElemsNew ← liftMacroM <| ToTerm.matchNestedTermResult term uvars a r bc
+    doSeqToCode (doElemsNew ++ doElems)
+
+  partial def doSeqToCode : List Syntax → M CodeBlock
+    | [] => do liftMacroM mkPureUnitAction
+    | doElem::doElems => withIncRecDepth <| withRef doElem do
+      checkSystem "`do`-expander"
+      match (← liftMacroM <| expandMacro? doElem) with
+      | some doElem => doSeqToCode (doElem::doElems)
+      | none =>
+      match (← liftMacroM <| expandDoIf? doElem) with
+      | some doElem => doSeqToCode (doElem::doElems)
+      | none =>
+      match (← liftMacroM <| expandDoLetExpr? doElem doElems) with
+      | some doElem => doSeqToCode [doElem]
+      | none =>
+        let (liftedDoElems, doElem) ← expandLiftMethod doElem
+        if !liftedDoElems.isEmpty then
+          doSeqToCode (liftedDoElems ++ [doElem] ++ doElems)
+        else
+          let ref := doElem
+          let k := doElem.getKind
+          if k == ``Parser.Term.doLet then
+            let vars ← getDoLetVars doElem
+            checkNotShadowingMutable vars
+            mkVarDeclCore vars doElem <$> withNewMutableVars vars (isMutableLet doElem) (doSeqToCode doElems)
+          else if k == ``Parser.Term.doHave then
+            let vars ← getDoHaveVars doElem
+            checkNotShadowingMutable vars
+            mkVarDeclCore vars doElem <$> (doSeqToCode doElems)
+          else if k == ``Parser.Term.doLetRec then
+            let vars ← getDoLetRecVars doElem
+            checkNotShadowingMutable vars
+            mkVarDeclCore vars doElem <$> (doSeqToCode doElems)
+          else if k == ``Parser.Term.doReassign then
+            let vars ← getDoReassignVars doElem
+            checkReassignable vars
+            let k ← doSeqToCode doElems
+            mkReassignCore vars doElem k
+          else if k == ``Parser.Term.doLetArrow then
+            doLetArrowToCode doElem doElems
+          else if k == ``Parser.Term.doLetElse then
+            doLetElseToCode doElem doElems
+          else if k == ``Parser.Term.doReassignArrow then
+            doReassignArrowToCode doElem doElems
+          else if k == ``Parser.Term.doIf then
+            doIfToCode doElem doElems
+          else if k == ``Parser.Term.doUnless then
+            doUnlessToCode doElem doElems
+          else if k == ``Parser.Term.doFor then withFreshMacroScope do
+            doForToCode doElem doElems
+          else if k == ``Parser.Term.doMatch then
+            doMatchToCode doElem doElems
+          else if k == ``Parser.Term.doMatchExpr then
+            doMatchExprToCode doElem doElems
+          else if k == ``Parser.Term.doTry then
+            doTryToCode doElem doElems
+          else if k == ``Parser.Term.doBreak then
+            ensureInsideFor
+            ensureEOS doElems
+            return mkBreak ref
+          else if k == ``Parser.Term.doContinue then
+            ensureInsideFor
+            ensureEOS doElems
+            return mkContinue ref
+          else if k == ``Parser.Term.doReturn then
+            doReturnToCode doElem doElems
+          else if k == ``Parser.Term.doDbgTrace then
+            return mkSeq doElem (← doSeqToCode doElems)
+          else if k == ``Parser.Term.doAssert then
+            return mkSeq doElem (← doSeqToCode doElems)
+          else if k == ``Parser.Term.doDebugAssert then
+            return mkSeq doElem (← doSeqToCode doElems)
+          else if k == ``Parser.Term.doNested then
+            let nestedDoSeq := doElem[1]
+            doSeqToCode (getDoSeqElems nestedDoSeq ++ doElems)
+          else if k == ``Parser.Term.doExpr then
+            let term := doElem[0]
+            if doElems.isEmpty then
+              return mkTerminalAction term
+            else
+              return mkSeq term (← doSeqToCode doElems)
+          else
+            throwError "unexpected do-element of kind {doElem.getKind}:\n{doElem}"
+end
+
+def run (doStx : Syntax) (m : Syntax) (returnType : Syntax) : TermElabM CodeBlock :=
+  (doSeqToCode <| getDoSeqElems <| getDoSeq doStx).run { ref := doStx, m, returnType }
+
+end ToCodeBlock
+
+@[builtin_term_elab «do»] def elabDo : TermElab := fun stx expectedType? => do
+  tryPostponeIfNoneOrMVar expectedType?
+  let bindInfo ← extractBind expectedType?
+  let m ← Term.exprToSyntax bindInfo.m
+  let returnType ← Term.exprToSyntax bindInfo.returnType
+  let codeBlock ← ToCodeBlock.run stx m returnType
+  let stxNew ← liftMacroM <| ToTerm.run codeBlock.code m returnType
+  trace[Elab.do] stxNew
+  withMacroExpansion stx stxNew <| elabTermEnsuringType stxNew bindInfo.expectedType
+
+end Do
+
+builtin_initialize registerTraceClass `Elab.do
+
+private def toDoElem (newKind : SyntaxNodeKind) : Macro := fun stx => do
+  let stx := stx.setKind newKind
+  withRef stx `(do $stx:doElem)
+
+@[builtin_macro Lean.Parser.Term.termFor]
+def expandTermFor : Macro := toDoElem ``Parser.Term.doFor
+
+@[builtin_macro Lean.Parser.Term.termTry]
+def expandTermTry : Macro := toDoElem ``Parser.Term.doTry
+
+@[builtin_macro Lean.Parser.Term.termUnless]
+def expandTermUnless : Macro := toDoElem ``Parser.Term.doUnless
+
+@[builtin_macro Lean.Parser.Term.termReturn]
+def expandTermReturn : Macro := toDoElem ``Parser.Term.doReturn
+
+end Lean.Elab.Term

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/ElabRules.lean

@@ -0,0 +1,102 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.Elab.MacroArgUtil
+import Lean.Elab.AuxDef
+
+namespace Lean.Elab.Command
+open Lean.Syntax
+open Lean.Parser.Term hiding macroArg
+open Lean.Parser.Command
+
+def elabElabRulesAux (doc? : Option (TSyntax ``docComment))
+    (attrs? : Option (TSepArray ``attrInstance ",")) (attrKind : TSyntax ``attrKind)
+    (k : SyntaxNodeKind) (cat? expty? : Option (Ident)) (alts : Array (TSyntax ``matchAlt)) :
+    CommandElabM Syntax := do
+  let alts ← alts.mapM fun (alt : TSyntax ``matchAlt) => match alt with
+    | `(matchAltExpr| | $pats,* => $rhs) => do
+      let pat := pats.elemsAndSeps[0]!
+      if !pat.isQuot then
+        throwUnsupportedSyntax
+      let quoted := getQuotContent pat
+      let k' := quoted.getKind
+      if checkRuleKind k' k then
+        pure alt
+      else if k' == choiceKind then
+         match quoted.getArgs.find? fun quotAlt => checkRuleKind quotAlt.getKind k with
+         | none        => throwErrorAt alt "invalid elab_rules alternative, expected syntax node kind '{k}'"
+         | some quoted =>
+           let pat := pat.setArg 1 quoted
+           let pats := ⟨pats.elemsAndSeps.set! 0 pat⟩
+           `(matchAltExpr| | $pats,* => $rhs)
+      else
+        throwErrorAt alt "invalid elab_rules alternative, unexpected syntax node kind '{k'}'"
+    | _ => throwUnsupportedSyntax
+  let catName ← match cat?, expty? with
+    | some cat, _ => pure cat.getId
+    | _, some _   => pure `term
+    -- TODO: infer category from quotation kind, possibly even kind of quoted syntax?
+    | _, _        => throwError "invalid elab_rules command, specify category using `elab_rules : <cat> ...`"
+  let mkAttrs (kind : Name) : CommandElabM (TSyntaxArray ``attrInstance) := do
+    let attr ← `(attrInstance| $attrKind:attrKind $(mkIdent kind):ident $(← mkIdentFromRef k):ident)
+    pure <| match attrs? with
+      | some attrs => attrs.getElems.push attr
+      | none => #[attr]
+  if let some expId := expty? then
+    if catName == `term then
+      `($[$doc?:docComment]? @[$(← mkAttrs `term_elab),*]
+        aux_def elabRules $(mkIdent k) : Lean.Elab.Term.TermElab :=
+        fun stx expectedType? => Lean.Elab.Term.withExpectedType expectedType? fun $expId => match stx with
+          $alts:matchAlt* | _ => no_error_if_unused% throwUnsupportedSyntax)
+    else
+      throwErrorAt expId "syntax category '{catName}' does not support expected type specification"
+  else if catName == `term then
+    `($[$doc?:docComment]? @[$(← mkAttrs `term_elab),*]
+      aux_def elabRules $(mkIdent k) : Lean.Elab.Term.TermElab :=
+      fun stx _ => match stx with
+        $alts:matchAlt* | _ => no_error_if_unused% throwUnsupportedSyntax)
+  else if catName == `command then
+    `($[$doc?:docComment]? @[$(← mkAttrs `command_elab),*]
+      aux_def elabRules $(mkIdent k) : Lean.Elab.Command.CommandElab :=
+      fun $alts:matchAlt* | _ => no_error_if_unused% throwUnsupportedSyntax)
+  else if catName == `tactic || catName == `conv then
+    `($[$doc?:docComment]? @[$(← mkAttrs `tactic),*]
+      aux_def elabRules $(mkIdent k) : Lean.Elab.Tactic.Tactic :=
+      fun $alts:matchAlt* | _ => no_error_if_unused% throwUnsupportedSyntax)
+  else
+    -- We considered making the command extensible and support new user-defined categories. We think it is unnecessary.
+    -- If users want this feature, they add their own `elab_rules` macro that uses this one as a fallback.
+    throwError "unsupported syntax category '{catName}'"
+
+@[builtin_command_elab «elab_rules»] def elabElabRules : CommandElab :=
+  adaptExpander fun stx => match stx with
+  | `($[$doc?:docComment]? $[@[$attrs?,*]]? $attrKind:attrKind elab_rules $[: $cat?]? $[<= $expty?]? $alts:matchAlt*) =>
+    expandNoKindMacroRulesAux alts "elab_rules" fun kind? alts =>
+      `($[$doc?:docComment]? $[@[$attrs?,*]]? $attrKind:attrKind elab_rules $[(kind := $(mkIdent <$> kind?))]? $[: $cat?]? $[<= $expty?]? $alts:matchAlt*)
+  | `($[$doc?:docComment]? $[@[$attrs?,*]]? $attrKind:attrKind elab_rules (kind := $kind) $[: $cat?]? $[<= $expty?]? $alts:matchAlt*) =>
+    do elabElabRulesAux doc? attrs? attrKind (← resolveSyntaxKind kind.getId) cat? expty? alts
+  | _  => throwUnsupportedSyntax
+
+@[builtin_command_elab Lean.Parser.Command.elab]
+def elabElab : CommandElab
+  | `($[$doc?:docComment]? $[@[$attrs?,*]]? $attrKind:attrKind
+    elab%$tk$[:$prec?]? $[(name := $name?)]? $[(priority := $prio?)]? $args:macroArg* :
+      $cat $[<= $expectedType?]? => $rhs) => do
+    let prio    ← liftMacroM <| evalOptPrio prio?
+    let (stxParts, patArgs) := (← args.mapM expandMacroArg).unzip
+    -- name
+    let name ← match name? with
+      | some name => pure name.getId
+      | none => addMacroScopeIfLocal (← liftMacroM <| mkNameFromParserSyntax cat.getId (mkNullNode stxParts)) attrKind
+    let nameId := name?.getD (mkIdentFrom tk name (canonical := true))
+    let pat := ⟨mkNode ((← getCurrNamespace) ++ name) patArgs⟩
+    elabCommand <|← `(
+      $[$doc?:docComment]? $[@[$attrs?,*]]? $attrKind:attrKind
+      syntax%$tk$[:$prec?]? (name := $nameId) (priority := $(quote prio):num) $[$stxParts]* : $cat
+      $[$doc?:docComment]? elab_rules : $cat $[<= $expectedType?]? | `($pat) => $rhs)
+  | _ => throwUnsupportedSyntax
+
+end Lean.Elab.Command

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/ErrorExplanation.lean

@@ -0,0 +1,138 @@
+/-
+Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joseph Rotella
+-/
+prelude
+import Lean.ErrorExplanation
+import Lean.Meta.Eval
+import Lean.Elab.Term
+import Lean.Elab.Command
+import Lean.Widget.UserWidget
+
+namespace Lean.Elab.ErrorExplanation
+
+open Meta Parser Term
+
+-- We cannot import the definitions needed for this attribute in `Lean.Log`, so we instead add it
+-- here
+attribute [builtin_widget_module] Lean.errorDescriptionWidget
+
+def expandNamedErrorMacro : Macro
+  | `(throwNamedErrorMacro| throwNamedError $id:ident $msg:interpolatedStr) =>
+    ``(Lean.throwNamedError $(quote id.getId) m! $msg)
+  | `(throwNamedErrorMacro| throwNamedError $id $msg:term) =>
+    ``(Lean.throwNamedError $(quote id.getId) $msg)
+  | `(throwNamedErrorAtMacro| throwNamedErrorAt $ref $id $msg:interpolatedStr) =>
+    ``(Lean.throwNamedErrorAt $ref $(quote id.getId) m! $msg)
+  | `(throwNamedErrorAtMacro| throwNamedErrorAt $ref $id $msg:term) =>
+    ``(Lean.throwNamedErrorAt $ref $(quote id.getId) $msg)
+  | `(logNamedErrorMacro| logNamedError $id $msg:interpolatedStr) =>
+    ``(Lean.logNamedError $(quote id.getId) m! $msg)
+  | `(logNamedErrorMacro| logNamedError $id $msg:term) =>
+    ``(Lean.logNamedError $(quote id.getId) $msg)
+  | `(logNamedErrorAtMacro| logNamedErrorAt $ref $id $msg:interpolatedStr) =>
+    ``(Lean.logNamedErrorAt $ref $(quote id.getId) m! $msg)
+  | `(logNamedErrorAtMacro| logNamedErrorAt $ref $id $msg:term) =>
+    ``(Lean.logNamedErrorAt $ref $(quote id.getId) $msg)
+  | `(logNamedWarningMacro| logNamedWarning $id $msg:interpolatedStr) =>
+    ``(Lean.logNamedWarning $(quote id.getId) m! $msg)
+  | `(logNamedWarningMacro| logNamedWarning $id $msg:term) =>
+    ``(Lean.logNamedWarning $(quote id.getId) $msg)
+  | `(logNamedWarningAtMacro| logNamedWarningAt $ref $id $msg:interpolatedStr) =>
+    ``(Lean.logNamedWarningAt $ref $(quote id.getId) m! $msg)
+  | `(logNamedWarningAtMacro| logNamedWarningAt $ref $id $msg:term) =>
+    ``(Lean.logNamedWarningAt $ref $(quote id.getId) $msg)
+  | _ => Macro.throwUnsupported
+
+/--
+Maps macro syntax categories to a pair of the module containing the declaration on which the macro
+depends and the name of that declaration.
+-/
+private def macroDeclMap :=
+  Std.HashMap.ofList
+    [(``throwNamedErrorMacro, (`Lean.Exception, ``Lean.throwNamedError)),
+     (``throwNamedErrorAtMacro, (`Lean.Exception, ``Lean.throwNamedErrorAt)),
+     (``logNamedErrorMacro, (`Lean.Log, ``Lean.logNamedError)),
+     (``logNamedErrorAtMacro, (`Lean.Log, ``Lean.logNamedErrorAt)),
+     (``logNamedWarningMacro, (`Lean.Log, ``Lean.logNamedWarning)),
+     (``logNamedWarningAtMacro, (`Lean.Log, ``Lean.logNamedWarningAt))]
+
+@[builtin_term_elab throwNamedErrorMacro, builtin_term_elab throwNamedErrorAtMacro,
+  builtin_term_elab logNamedErrorMacro, builtin_term_elab logNamedErrorAtMacro,
+  builtin_term_elab logNamedWarningMacro, builtin_term_elab logNamedWarningAtMacro]
+def elabCheckedNamedError : TermElab := fun stx expType? => do
+  if let some (module, decl) := macroDeclMap.get? stx.getKind then
+    if !(← getEnv).contains decl then
+      throwError m!"The constant `{decl}` has not been imported" ++
+        .hint' m!"Add `import {module}` to this file's header to use this macro"
+  let (id, numArgsExpected) :=
+    if stx.isOfKind ``throwNamedErrorAtMacro || stx.isOfKind ``logNamedErrorAtMacro
+        || stx.isOfKind ``logNamedWarningAtMacro then
+    (stx[2], 5)
+  else
+    (stx[1], 4)
+  -- Remove the message term from the span. If we have a trailing `.`, we fail to parse the message
+  -- term and so leave `stx` unchanged. The in-progress identifier will always be the penultimate
+  -- argument of `span`.
+  let span := if stx.getNumArgs == numArgsExpected then
+    stx.setArgs (stx.getArgs[*...(stx.getNumArgs - 1)])
+  else
+    stx
+  let partialId := span[span.getNumArgs - 2]
+  addCompletionInfo <| CompletionInfo.errorName span partialId
+  let name := id.getId.eraseMacroScopes
+  pushInfoLeaf <| .ofErrorNameInfo { stx := id, errorName := name }
+  if let some explan := getErrorExplanationRaw? (← getEnv) name then
+    if let some removedVersion := explan.metadata.removedVersion? then
+      logWarningAt id m!"The error name `{name}` was removed in Lean version {removedVersion} and \
+        should not be used."
+  else
+    logErrorAt id m!"There is no explanation associated with the name `{name}`. \
+      Add an explanation of this error to the `Lean.ErrorExplanations` module."
+  let stx' ← liftMacroM <| expandNamedErrorMacro stx
+  elabTerm stx' expType?
+
+open Command in
+@[builtin_command_elab registerErrorExplanationStx] def elabRegisterErrorExplanation : CommandElab
+| `(registerErrorExplanationStx| $docStx:docComment register_error_explanation%$cmd $id:ident $t:term) => withRef cmd do
+  unless (← getEnv).contains ``Lean.ErrorExplanation do
+    throwError "To use this command, add `import Lean.ErrorExplanation` to the header of this file"
+  let tp := mkConst ``ErrorExplanation.Metadata
+  let metadata ← runTermElabM <| fun _ => unsafe do
+    let e ← elabTerm t tp
+    if e.hasSyntheticSorry then throwAbortTerm
+    evalExpr ErrorExplanation.Metadata tp e
+  let name := id.getId
+  if name.isAnonymous then
+    throwErrorAt id "Invalid name for error explanation: `{id}`"
+  if name.hasMacroScopes then
+    -- Use `id` rather than `name` for nicer rendering
+    throwErrorAt id m!"Invalid name `{id}`: Error explanations cannot have inaccessible names. \
+      This error often occurs when an error explanation is generated using a macro."
+  if name.getNumParts != 2 then
+    throwErrorAt id m!"Invalid name `{name}`: Error explanation names must have two components"
+      ++ .note m!"The first component of an error explanation name identifies the package from \
+        which the error originates, and the second identifies the error itself."
+  validateDocComment docStx
+  let doc ← getDocStringText docStx
+  if errorExplanationExt.getState (← getEnv) |>.contains name then
+    throwErrorAt id m!"Cannot add explanation: An error explanation already exists for `{name}`"
+  if let .error (lineOffset, msg) := ErrorExplanation.processDoc doc then
+    let some range := docStx.raw[1].getRange? | throwError msg
+    let fileMap ← getFileMap
+    let ⟨startLine, _⟩ := fileMap.toPosition range.start
+    let errLine := startLine + lineOffset
+    let synth := Syntax.ofRange { start := fileMap.ofPosition ⟨errLine, 0⟩,
+                                  stop  := fileMap.ofPosition ⟨errLine + 1, 0⟩ }
+    throwErrorAt synth msg
+  let (declLoc? : Option DeclarationLocation) ← do
+    let map ← getFileMap
+    let start := id.raw.getPos?.getD 0
+    let fin := id.raw.getTailPos?.getD start
+    pure <| some {
+      module := (← getMainModule)
+      range := .ofStringPositions map start fin
+    }
+  modifyEnv (errorExplanationExt.addEntry · (name, { metadata, doc, declLoc? }))
+| _ => throwUnsupportedSyntax

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/Eval.lean

@@ -0,0 +1,20 @@
+/-
+Copyright (c) 2022 Sebastian Ullrich. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Sebastian Ullrich
+-/
+prelude
+import Lean.Meta.Eval
+import Lean.Elab.SyntheticMVars
+
+namespace Lean.Elab.Term
+open Meta
+
+unsafe def evalTerm (α) (type : Expr) (value : Syntax) (safety := DefinitionSafety.safe) : TermElabM α := withoutModifyingEnv do
+  let v ← elabTermEnsuringType value type
+  synthesizeSyntheticMVarsNoPostponing
+  let v ← instantiateMVars v
+  if (← logUnassignedUsingErrorInfos (← getMVars v)) then throwAbortTerm
+  evalExpr α type v safety
+
+end Lean.Elab.Term

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/Exception.lean

@@ -0,0 +1,68 @@
+/-
+Copyright (c) 2019 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.InternalExceptionId
+import Lean.Exception
+
+namespace Lean.Elab
+
+builtin_initialize postponeExceptionId : InternalExceptionId ← registerInternalExceptionId `postpone
+builtin_initialize unsupportedSyntaxExceptionId : InternalExceptionId ← registerInternalExceptionId `unsupportedSyntax
+builtin_initialize abortCommandExceptionId : InternalExceptionId ← registerInternalExceptionId `abortCommandElab
+builtin_initialize abortTermExceptionId : InternalExceptionId ← registerInternalExceptionId `abortTermElab
+builtin_initialize abortTacticExceptionId : InternalExceptionId ← registerInternalExceptionId `abortTactic
+builtin_initialize autoBoundImplicitExceptionId : InternalExceptionId ← registerInternalExceptionId `autoBoundImplicit
+
+def throwPostpone [MonadExceptOf Exception m] : m α :=
+  throw $ Exception.internal postponeExceptionId
+
+def throwUnsupportedSyntax [MonadExceptOf Exception m] : m α :=
+  throw $ Exception.internal unsupportedSyntaxExceptionId
+
+def throwIllFormedSyntax [Monad m] [MonadError m] : m α :=
+  throwError "ill-formed syntax"
+
+def throwAutoBoundImplicitLocal [MonadExceptOf Exception m] (n : Name) : m α :=
+  throw $ Exception.internal autoBoundImplicitExceptionId <| KVMap.empty.insert `localId n
+
+def isAutoBoundImplicitLocalException? (ex : Exception) : Option Name :=
+  match ex with
+  | Exception.internal id k =>
+    if id == autoBoundImplicitExceptionId then
+      some <| k.getName `localId `x
+    else
+      none
+  | _ => none
+
+def throwAlreadyDeclaredUniverseLevel [Monad m] [MonadError m] (u : Name) : m α :=
+  throwError "a universe level named '{u}' has already been declared"
+
+-- Throw exception to abort elaboration of the current command without producing any error message
+def throwAbortCommand {α m} [MonadExcept Exception m] : m α :=
+  throw <| Exception.internal abortCommandExceptionId
+
+-- Throw exception to abort elaboration of the current term without producing any error message
+def throwAbortTerm {α m} [MonadExcept Exception m] : m α :=
+  throw <| Exception.internal abortTermExceptionId
+
+-- Throw exception to abort evaluation of the current tactic without producing any error message
+def throwAbortTactic {α m} [MonadExcept Exception m] : m α :=
+  throw <| Exception.internal abortTacticExceptionId
+
+def isAbortTacticException (ex : Exception) : Bool :=
+  match ex with
+  | Exception.internal id .. => id == abortTacticExceptionId
+  | _ => false
+
+def isAbortExceptionId (id : InternalExceptionId) : Bool :=
+  id == abortCommandExceptionId || id == abortTermExceptionId || id == abortTacticExceptionId
+
+def mkMessageCore (fileName : String) (fileMap : FileMap) (data : MessageData) (severity : MessageSeverity) (pos : String.Pos) (endPos : String.Pos) : Message :=
+  let pos := fileMap.toPosition pos
+  let endPos := fileMap.toPosition endPos
+  { fileName, pos, endPos, data, severity }
+
+end Lean.Elab

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/Extra.lean

@@ -0,0 +1,588 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura, Kyle Miller, Sebastian Ullrich
+-/
+prelude
+import Lean.Elab.App
+import Lean.Elab.BuiltinNotation
+
+/-! # Auxiliary elaboration functions: AKA custom elaborators -/
+
+namespace Lean.Elab.Term
+open Meta
+
+private def getMonadForIn (expectedType? : Option Expr) : TermElabM Expr := do
+    match expectedType? with
+    | none => throwError "invalid 'for_in%' notation, expected type is not available"
+    | some expectedType =>
+      match (← isTypeApp? expectedType) with
+      | some (m, _) => return m
+      | none => throwError "invalid 'for_in%' notation, expected type is not of the form `M α`{indentExpr expectedType}"
+
+private def throwForInFailure (forInInstance : Expr) : TermElabM Expr :=
+  throwError "failed to synthesize instance for 'for_in%' notation{indentExpr forInInstance}"
+
+@[builtin_term_elab forInMacro] def elabForIn : TermElab :=  fun stx expectedType? => do
+  match stx with
+  | `(for_in% $col $init $body) =>
+        tryPostponeIfNoneOrMVar expectedType?
+        let colE ← elabTerm col none
+        let m ← getMonadForIn expectedType?
+        let colType ← inferType colE
+        let elemType ← mkFreshExprMVar (mkSort (mkLevelSucc (← mkFreshLevelMVar)))
+        let forInInstance ← try
+          mkAppM ``ForIn #[m, colType, elemType]
+        catch _ =>
+          tryPostpone; throwError "failed to construct 'ForIn' instance for collection{indentExpr colType}\nand monad{indentExpr m}"
+        match (← trySynthInstance forInInstance) with
+        | .some inst =>
+          let forInFn ← mkConst ``forIn
+          elabAppArgs forInFn
+            (namedArgs := #[{ name := `m, val := Arg.expr m}, { name := `α, val := Arg.expr elemType }, { name := `self, val := Arg.expr inst }])
+            (args := #[Arg.expr colE, Arg.stx init, Arg.stx body])
+            (expectedType? := expectedType?)
+            (explicit := false) (ellipsis := false) (resultIsOutParamSupport := false)
+        | .undef    => tryPostpone; throwForInFailure forInInstance
+        | .none     => throwForInFailure forInInstance
+  | _ => throwUnsupportedSyntax
+
+@[builtin_term_elab forInMacro'] def elabForIn' : TermElab :=  fun stx expectedType? => do
+  match stx with
+  | `(for_in'% $col $init $body) =>
+        tryPostponeIfNoneOrMVar expectedType?
+        let colE ← elabTerm col none
+        let m ← getMonadForIn expectedType?
+        let colType ← inferType colE
+        let elemType ← mkFreshExprMVar (mkSort (mkLevelSucc (← mkFreshLevelMVar)))
+        let forInInstance ←
+          try
+            let memType ← mkFreshExprMVar (← mkAppM ``Membership #[elemType, colType])
+            mkAppM ``ForIn' #[m, colType, elemType, memType]
+          catch _ =>
+            tryPostpone; throwError "failed to construct `ForIn'` instance for collection{indentExpr colType}\nand monad{indentExpr m}"
+        match (← trySynthInstance forInInstance) with
+        | .some inst  =>
+          let forInFn ← mkConst ``forIn'
+          elabAppArgs forInFn
+            (namedArgs := #[{ name := `m, val := Arg.expr m}, { name := `α, val := Arg.expr elemType}, { name := `self, val := Arg.expr inst }])
+            (args := #[Arg.expr colE, Arg.stx init, Arg.stx body])
+            (expectedType? := expectedType?)
+            (explicit := false) (ellipsis := false) (resultIsOutParamSupport := false)
+        | .undef    => tryPostpone; throwForInFailure forInInstance
+        | .none     => throwForInFailure forInInstance
+  | _ => throwUnsupportedSyntax
+
+namespace Op
+/-!
+
+The elaborator for expression trees of `binop%`, `binop_lazy%`, `leftact%`, `rightact%`, and `unop%` terms.
+
+At a high level, the elaborator tries to solve for a type that each of the operands in the expression tree
+can be coerced to, while taking into account the expected type for the entire expression tree.
+Once this type is computed (and if it exists), it inserts coercions where needed.
+
+Here are brief descriptions of each of the operator types:
+- `binop% f a b` elaborates `f a b` as a binary operator with two operands `a` and `b`,
+  and each operand participates in the protocol.
+- `binop_lazy% f a b` is like `binop%` but elaborates as `f a (fun () => b)`.
+- `unop% f a` elaborates `f a` as a unary operator with one operand `a`, which participates in the protocol.
+- `leftact% f a b` elaborates `f a b` as a left action (the `a` operand "acts upon" the `b` operand).
+  Only `b` participates in the protocol since `a` can have an unrelated type, for example scalar multiplication of vectors.
+- `rightact% f a b` elaborates `f a b` as a right action (the `b` operand "acts upon" the `a` operand).
+  Only `a` participates in the protocol since `b` can have an unrelated type.
+  This is used by `HPow` since, for example, there are both `Real -> Nat -> Real` and `Real -> Real -> Real`
+  exponentiation functions, and we prefer the former in the case of `x ^ 2`, but `binop%` would choose the latter. (#2854)
+- There are also `binrel%` and `binrel_no_prop%` (see the docstring for `elabBinRelCore`).
+
+The elaborator works as follows:
+
+1- Expand macros.
+2- Convert `Syntax` object corresponding to the `binop%/...` term into a `Tree`.
+   The `toTree` method visits nested `binop%/...` terms and parentheses.
+3- Synthesize pending metavariables without applying default instances and using the
+   `(mayPostpone := true)`.
+4- Tries to compute a maximal type for the tree computed at step 2.
+   We say a type α is smaller than type β if there is a (nondependent) coercion from α to β.
+   We are currently ignoring the case we may have cycles in the coercion graph.
+   If there are "uncomparable" types α and β in the tree, we skip the next step.
+   We say two types are "uncomparable" if there isn't a coercion between them.
+   Note that two types may be "uncomparable" because some typing information may still be missing.
+5- We traverse the tree and inject coercions to the "maximal" type when needed.
+
+Recall that the coercions are expanded eagerly by the elaborator.
+
+Properties:
+
+a) Given `n : Nat` and `i : Nat`, it can successfully elaborate `n + i` and `i + n`. Recall that Lean 3
+   fails on the former.
+
+b) The coercions are inserted in the "leaves" like in Lean 3.
+
+c) There are no coercions "hidden" inside instances, and we can elaborate
+```
+axiom Int.add_comm (i j : Int) : i + j = j + i
+
+example (n : Nat) (i : Int) : n + i = i + n := by
+  rw [Int.add_comm]
+```
+Recall that the `rw` tactic used to fail because our old `binop%` elaborator would hide
+coercions inside of a `HAdd` instance.
+
+Remarks:
+
+* In the new `binop%` and related elaborators the decision whether a coercion will be inserted or not
+  is made at `binop%` elaboration time. This was not the case in the old elaborator.
+  For example, an instance, such as `HAdd Int ?m ?n`, could be created when executing
+  the `binop%` elaborator, and only resolved much later. We try to minimize this problem
+  by synthesizing pending metavariables at step 3.
+
+* For types containing heterogeneous operators (e.g., matrix multiplication), step 4 will fail
+  and we will skip coercion insertion. For example, `x : Matrix Real 5 4` and `y : Matrix Real 4 8`,
+  there is no coercion `Matrix Real 5 4` from `Matrix Real 4 8` and vice-versa, but
+  `x * y` is elaborated successfully and has type `Matrix Real 5 8`.
+
+* The `leftact%` and `rightact%` elaborators are to handle binary operations where only one of
+  the arguments participates in the protocol. For example, in `2 ^ n + y` with `n : Nat` and `y : Real`,
+  we do not want to coerce `n` to be a real as well, but we do want to elaborate `2 : Real`.
+-/
+
+private inductive BinOpKind where
+  | regular   -- `binop%`
+  | lazy      -- `binop_lazy%`
+  | leftact   -- `leftact%`
+  | rightact  -- `rightact%`
+deriving BEq
+
+private inductive Tree where
+  /--
+  Leaf of the tree.
+  We store the `infoTrees` generated when elaborating `val`. These trees become
+  subtrees of the infotree nodes generated for `op` nodes.
+  -/
+  | term (ref : Syntax) (infoTrees : PersistentArray InfoTree) (val : Expr)
+  /--
+  `ref` is the original syntax that expanded into `binop%/...`.
+  -/
+  | binop (ref : Syntax) (kind : BinOpKind) (f : Expr) (lhs rhs : Tree)
+  /--
+  `ref` is the original syntax that expanded into `unop%`.
+  -/
+  | unop (ref : Syntax) (f : Expr) (arg : Tree)
+  /--
+  Used for assembling the info tree. We store this information
+  to make sure "go to definition" behaves similarly to notation defined without using `binop%` helper elaborator.
+  -/
+  | macroExpansion (macroName : Name) (stx stx' : Syntax) (nested : Tree)
+
+
+private partial def toTree (s : Syntax) : TermElabM Tree := do
+  /-
+  Remark: ew used to use `expandMacros` here, but this is a bad idiom
+  because we do not record the macro expansion information in the info tree.
+  We now manually expand the notation in the `go` function, and save
+  the macro declaration names in the `op` nodes.
+  -/
+  let result ← go s
+  synthesizeSyntheticMVars (postpone := .yes)
+  return result
+where
+  go (s : Syntax) := do
+    match s with
+    | `(binop% $f $lhs $rhs) => processBinOp s .regular f lhs rhs
+    | `(binop_lazy% $f $lhs $rhs) => processBinOp s .lazy f lhs rhs
+    | `(unop% $f $arg) => processUnOp s f arg
+    | `(leftact% $f $lhs $rhs) => processBinOp s .leftact f lhs rhs
+    | `(rightact% $f $lhs $rhs) => processBinOp s .rightact f lhs rhs
+    | `(($e)) =>
+      if hasCDot e then
+        processLeaf s
+      else
+        go e
+    | _ =>
+      withRef s do
+        match (← liftMacroM <| expandMacroImpl? (← getEnv) s) with
+        | some (macroName, s?) =>
+          let s' ← liftMacroM <| liftExcept s?
+          withPushMacroExpansionStack s s' do
+            return .macroExpansion macroName s s' (← go s')
+        | none => processLeaf s
+
+  processBinOp (ref : Syntax) (kind : BinOpKind) (f lhs rhs : Syntax) := do
+    let some f �� resolveId? f | throwUnknownConstantAt f f.getId
+    -- treat corresponding argument as leaf for `leftact/rightact`
+    let lhs ← if kind == .leftact then processLeaf lhs else go lhs
+    let rhs ← if kind == .rightact then processLeaf rhs else go rhs
+    return .binop ref kind f lhs rhs
+
+  processUnOp (ref : Syntax) (f arg : Syntax) := do
+    let some f ← resolveId? f | throwUnknownConstantAt f f.getId
+    return .unop ref f (← go arg)
+
+  processLeaf (s : Syntax) := do
+    let e ← elabTerm s none
+    let info ← getResetInfoTrees
+    return .term s info e
+
+-- Auxiliary function used at `analyze`
+private def hasCoe (fromType toType : Expr) : TermElabM Bool := do
+  if (← getEnv).contains ``CoeT then
+    withLocalDeclD `x fromType fun x => do
+    match ← coerceSimple? x toType with
+    | .some _ => return true
+    | .none   => return false
+    | .undef  => return false -- TODO: should we do something smarter here?
+  else
+    return false
+
+private structure AnalyzeResult where
+  max?            : Option Expr := none
+  /-- `true` if there are two types `α` and `β` where we don't have coercions in any direction. -/
+  hasUncomparable : Bool := false
+  /-- `true` if there are any leaf terms with an unknown type (according to `isUnknown`). -/
+  hasUnknown      : Bool := false
+
+private def isUnknown : Expr → Bool
+  | .mvar ..        => true
+  | .app f _        => isUnknown f
+  | .letE _ _ _ b _ => isUnknown b
+  | .mdata _ b      => isUnknown b
+  | _               => false
+
+private def analyze (t : Tree) (expectedType? : Option Expr) : TermElabM AnalyzeResult := do
+  let max? ←
+    match expectedType? with
+    | none => pure none
+    | some expectedType =>
+      let expectedType := (← instantiateMVars expectedType).cleanupAnnotations
+      if isUnknown expectedType then pure none else pure (some expectedType)
+  (go t *> get).run' { max? }
+where
+   go (t : Tree) : StateRefT AnalyzeResult TermElabM Unit := do
+     unless (← get).hasUncomparable do
+       match t with
+       | .macroExpansion _ _ _ nested => go nested
+       | .binop _ .leftact  _ _ rhs => go rhs
+       | .binop _ .rightact _ lhs _ => go lhs
+       | .binop _ _ _ lhs rhs => go lhs; go rhs
+       | .unop _ _ arg => go arg
+       | .term _ _ val =>
+         let type := (← instantiateMVars (← inferType val)).cleanupAnnotations
+         if isUnknown type then
+           modify fun s => { s with hasUnknown := true }
+         else
+           match (← get).max? with
+           | none     => modify fun s => { s with max? := type }
+           | some max =>
+             /-
+              Remark: Previously, we used `withNewMCtxDepth` to prevent metavariables in `max` and `type` from being assigned.
+
+              Reason: This is a heuristic procedure for introducing coercions in scenarios such as:
+              - Given `(n : Nat) (i : Int)`, elaborate `n = i`. The coercion must be inserted at `n`.
+                Consider the elaboration problem `(n + 0) + i`, where the type of term `0` is a metavariable.
+                We do not want it to be elaborated as `(Int.ofNat n + Int.ofNat (0 : Nat)) + i`; instead, we prefer the result to be `(Int.ofNat n + (0 : Int)) + i`.
+                Here is another example where we avoid assigning metavariables: `max := BitVec n` and `type := BitVec ?m`.
+
+              However, the combination `withNewMCtxDepth <| isDefEqGuarded max type` introduced performance issues in several
+              Mathlib files because `isDefEq` was spending a lot of time unfolding definitions in `max` and `type` before failing.
+
+              To address this issue, we allowed only reducible definitions to be unfolded during this check, using
+              `withNewMCtxDepth <| withReducible <| isDefEqGuarded max type`. This change fixed some performance issues but created new ones.
+              Lean was now spending time trying to use `hasCoe`, likely occurring in places where `withNewMCtxDepth <| isDefEqGuarded max type`
+              used to succeed but was now failing after we introduced `withReducible`.
+
+              We then considered using just `isDefEqGuarded max type` and changing the definition of `isUnknown`. In the new definition,
+              the else-case would be `| e => e.hasExprMVar` instead of `| _ => false`. However, we could not even compile this repo using
+              this configuration. The problem arises because some files require coercions even when `max` contains metavariables,
+              for example: `max := Option ?m` and `type := Name`.
+
+              As a result, rather than restricting reducibility, we decided to set `Meta.Config.isDefEqStuckEx := true`.
+              This means that if `isDefEq` encounters a subproblem `?m =?= a` where `?m` is non-assignable, it aborts the test
+              instead of unfolding definitions.
+             -/
+             unless (← withNewMCtxDepth <| withConfig (fun config => { config with isDefEqStuckEx := true }) <| isDefEqGuarded max type) do
+               if (← hasCoe type max) then
+                 return ()
+               else if (← hasCoe max type) then
+                 modify fun s => { s with max? := type }
+               else
+                 trace[Elab.binop] "uncomparable types: {max}, {type}"
+                 modify fun s => { s with hasUncomparable := true }
+
+private def mkBinOp (lazy : Bool) (f : Expr) (lhs rhs : Expr) : TermElabM Expr := do
+  let mut rhs := rhs
+  if lazy then
+    rhs ← mkFunUnit rhs
+  elabAppArgs f #[] #[Arg.expr lhs, Arg.expr rhs] (expectedType? := none) (explicit := false) (ellipsis := false) (resultIsOutParamSupport := false)
+
+private def mkUnOp (f : Expr) (arg : Expr) : TermElabM Expr := do
+  elabAppArgs f #[] #[Arg.expr arg] (expectedType? := none) (explicit := false) (ellipsis := false) (resultIsOutParamSupport := false)
+
+private def toExprCore (t : Tree) : TermElabM Expr := do
+  match t with
+  | .term _ trees e =>
+    modifyInfoState (fun s => { s with trees := s.trees ++ trees }); return e
+  | .binop ref kind f lhs rhs =>
+    withRef ref <|
+      withTermInfoContext' .anonymous ref do
+        mkBinOp (kind == .lazy) f (← toExprCore lhs) (← toExprCore rhs)
+  | .unop ref f arg =>
+    withRef ref <|
+      withTermInfoContext' .anonymous ref do
+        mkUnOp f (← toExprCore arg)
+  | .macroExpansion macroName stx stx' nested =>
+    withRef stx <|
+      withTermInfoContext' macroName stx <|
+        withMacroExpansion stx stx' <|
+          toExprCore nested
+
+/--
+  Auxiliary function to decide whether we should coerce `f`'s argument to `maxType` or not.
+  - `f` is a binary operator.
+  - `lhs == true` (`lhs == false`) if are trying to coerce the left-argument (right-argument).
+  This function assumes `f` is a heterogeneous operator (e.g., `HAdd.hAdd`, `HMul.hMul`, etc).
+  It returns true IF
+  - `f` is a constant of the form `Cls.op` where `Cls` is a class name, and
+  - `maxType` is of the form `C ...` where `C` is a constant, and
+  - There are more than one default instance. That is, it assumes the class `Cls` for the heterogeneous operator `f`, and
+    always has the monomorphic instance. (e.g., for `HAdd`, we have `instance [Add α] : HAdd α α α`), and
+  - If `lhs == true`, then there is a default instance of the form `Cls _ (C ..) _`, and
+  - If `lhs == false`, then there is a default instance of the form `Cls (C ..) _ _`.
+
+  The motivation is to support default instances such as
+  ```
+  @[default_instance high]
+  instance [Mul α] : HMul α (Array α) (Array α) where
+    hMul a as := as.map (a * ·)
+
+  #eval 2 * #[3, 4, 5]
+  ```
+  If the type of an argument is unknown we should not coerce it to `maxType` because it would prevent
+  the default instance above from being even tried.
+-/
+private def hasHeterogeneousDefaultInstances (f : Expr) (maxType : Expr) (lhs : Bool) : MetaM Bool := do
+  let .const fName .. := f | return false
+  let .const typeName .. := maxType.getAppFn | return false
+  let className := fName.getPrefix
+  let defInstances ← getDefaultInstances className
+  if defInstances.length ≤ 1 then return false
+  for (instName, _) in defInstances do
+    if let .app (.app (.app _heteroClass lhsType) rhsType) _resultType :=
+        (← getConstInfo instName).type.getForallBody then
+      if  lhs && rhsType.isAppOf typeName then return true
+      if !lhs && lhsType.isAppOf typeName then return true
+  return false
+
+/--
+  Return `true` if polymorphic function `f` has a homogeneous instance of `maxType`.
+  The coercions to `maxType` only makes sense if such instance exists.
+
+  For example, suppose `maxType` is `Int`, and `f` is `HPow.hPow`. Then,
+  adding coercions to `maxType` only make sense if we have an instance `HPow Int Int Int`.
+-/
+private def hasHomogeneousInstance (f : Expr) (maxType : Expr) : MetaM Bool := do
+  let .const fName .. := f | return false
+  let className := fName.getPrefix
+  try
+    let inst ← mkAppM className #[maxType, maxType, maxType]
+    return (← trySynthInstance inst) matches .some _
+  catch _ =>
+    return false
+
+mutual
+  /--
+    Try to coerce elements in the `t` to `maxType` when needed.
+    If the type of an element in `t` is unknown we only coerce it to `maxType` if `maxType` does not have heterogeneous
+    default instances. This extra check is approximated by `hasHeterogeneousDefaultInstances`.
+
+    Remark: If `maxType` does not implement heterogeneous default instances, we do want to assign unknown types `?m` to
+    `maxType` because it produces better type information propagation. Our test suite has many tests that would break if
+    we don't do this. For example, consider the term
+    ```
+    eq_of_isEqvAux a b hsz (i+1) (Nat.succ_le_of_lt h) heqv.2
+    ```
+    `Nat.succ_le_of_lt h` type depends on `i+1`, but `i+1` only reduces to `Nat.succ i` if we know that `1` is a `Nat`.
+    There are several other examples like that in our test suite, and one can find them by just replacing the
+    `← hasHeterogeneousDefaultInstances f maxType lhs` test with `true`
+
+
+    Remark: if `hasHeterogeneousDefaultInstances` implementation is not good enough we should refine it in the future.
+  -/
+  private partial def applyCoe (t : Tree) (maxType : Expr) (isPred : Bool) : TermElabM Tree := do
+    go t none false isPred
+  where
+    go (t : Tree) (f? : Option Expr) (lhs : Bool) (isPred : Bool) : TermElabM Tree := do
+      match t with
+      | .binop ref .leftact f lhs rhs =>
+        return .binop ref .leftact f lhs (← go rhs none false false)
+      | .binop ref .rightact f lhs rhs =>
+        return .binop ref .rightact f (← go lhs none false false) rhs
+      | .binop ref kind f lhs rhs =>
+        /-
+          We only keep applying coercions to `maxType` if `f` is predicate or
+          `f` has a homogeneous instance with `maxType`. See `hasHomogeneousInstance` for additional details.
+
+          Remark: We assume `binrel%` elaborator is only used with homogeneous predicates.
+        -/
+        if (← pure isPred <||> hasHomogeneousInstance f maxType) then
+          return .binop ref kind f (← go lhs f true false) (← go rhs f false false)
+        else
+          let r ← withRef ref do
+            mkBinOp (kind == .lazy) f (← toExpr lhs none) (← toExpr rhs none)
+          let infoTrees ← getResetInfoTrees
+          return .term ref infoTrees r
+      | .unop ref f arg =>
+        return .unop ref f (← go arg none false false)
+      | .term ref trees e =>
+        let type := (← instantiateMVars (← inferType e)).cleanupAnnotations
+        trace[Elab.binop] "visiting {e} : {type} =?= {maxType}"
+        if isUnknown type then
+          if let some f := f? then
+            if (← hasHeterogeneousDefaultInstances f maxType lhs) then
+              -- See comment at `hasHeterogeneousDefaultInstances`
+              return t
+        if (← isDefEqGuarded maxType type) then
+          return t
+        else
+          trace[Elab.binop] "added coercion: {e} : {type} => {maxType}"
+          withRef ref <| return .term ref trees (← mkCoe maxType e)
+      | .macroExpansion macroName stx stx' nested =>
+        withRef stx <| withPushMacroExpansionStack stx stx' do
+          return .macroExpansion macroName stx stx' (← go nested f? lhs isPred)
+
+  private partial def toExpr (tree : Tree) (expectedType? : Option Expr) : TermElabM Expr := do
+    let r ← analyze tree expectedType?
+    trace[Elab.binop] "hasUncomparable: {r.hasUncomparable}, hasUnknown: {r.hasUnknown}, maxType: {r.max?}"
+    if r.hasUncomparable || r.max?.isNone then
+      let result ← toExprCore tree
+      ensureHasType expectedType? result
+    else
+      let result ← toExprCore (← applyCoe tree r.max?.get! (isPred := false))
+      unless r.hasUnknown do
+        -- Record the resulting maxType calculation.
+        -- We can do this when all the types are known, since in this case `hasUncomparable` is valid.
+        -- If they're not known, recording maxType like this can lead to heterogeneous operations failing to elaborate.
+        discard <| isDefEqGuarded (← inferType result) r.max?.get!
+      trace[Elab.binop] "result: {result}"
+      ensureHasType expectedType? result
+
+end
+
+def elabOp : TermElab := fun stx expectedType? => do
+  toExpr (← toTree stx) expectedType?
+
+@[builtin_term_elab binop] def elabBinOp : TermElab := elabOp
+@[builtin_term_elab binop_lazy] def elabBinOpLazy : TermElab := elabOp
+@[builtin_term_elab leftact] def elabLeftact : TermElab := elabOp
+@[builtin_term_elab rightact] def elabRightact : TermElab := elabOp
+@[builtin_term_elab unop] def elabUnOp : TermElab := elabOp
+
+/--
+  Elaboration functions for `binrel%` and `binrel_no_prop%` notations.
+  We use the infrastructure for `binop%` to make sure we propagate information between the left and right hand sides
+  of a binary relation.
+
+  - `binrel% R x y` elaborates `R x y` using the `binop%/...` expression trees in both `x` and `y`.
+    It is similar to how `binop% R x y` elaborates but with a significant difference:
+    it does not use the expected type when computing the types of the operands.
+  - `binrel_no_prop% R x y` elaborates `R x y` like `binrel% R x y`, but if the resulting type for `x` and `y`
+    is `Prop` they are coerced to `Bool`.
+    This is used for relations such as `==` which do not support `Prop`, but we still want
+    to be able to write `(5 > 2) == (2 > 1)` for example.
+-/
+def elabBinRelCore (noProp : Bool) (stx : Syntax) (expectedType? : Option Expr) : TermElabM Expr :=  do
+  match (← resolveId? stx[1]) with
+  | some f => withSynthesizeLight do
+    /-
+    We used to use `withSynthesize (mayPostpone := true)` here instead of `withSynthesizeLight` here.
+    It seems too much to apply default instances at binary relations. For example, we cannot elaborate
+    ```
+    def as : List Int := [-1, 2, 0, -3, 4]
+    #eval as.map fun a => ite (a ≥ 0) [a] []
+    ```
+    The problem is that when elaborating `a ≥ 0` we don't know yet that `a` is an `Int`.
+    Then, by applying default instances, we apply the default instance to `0` that forces it to become an `Int`,
+    and Lean infers that `a` has type `Nat`.
+    Then, later we get a type error because `as` is `List Int` instead of `List Nat`.
+    This behavior is quite counterintuitive since if we avoid this elaborator by writing
+    ```
+    def as : List Int := [-1, 2, 0, -3, 4]
+    #eval as.map fun a => ite (GE.ge a 0) [a] []
+    ```
+    everything works.
+    However, there is a drawback of using `withSynthesizeLight` instead of `withSynthesize (mayPostpone := true)`.
+    The following cannot be elaborated
+    ```
+    have : (0 == 1) = false := rfl
+    ```
+    We get a type error at `rfl`. `0 == 1` only reduces to `false` after we have applied the default instances that force
+    the numeral to be `Nat`. We claim this is defensible behavior because the same happens if we do not use this elaborator.
+    ```
+    have : (BEq.beq 0 1) = false := rfl
+    ```
+    We can improve this failure in the future by applying default instances before reporting a type mismatch.
+    -/
+    let lhsStx := stx[2]
+    let rhsStx := stx[3]
+    let lhs ← withRef lhsStx <| toTree lhsStx
+    let rhs ← withRef rhsStx <| toTree rhsStx
+    let tree := .binop stx .regular f lhs rhs
+    let r ← analyze tree none
+    trace[Elab.binrel] "hasUncomparable: {r.hasUncomparable}, hasUnknown: {r.hasUnknown}, maxType: {r.max?}"
+    if r.hasUncomparable || r.max?.isNone then
+      -- Use default elaboration strategy + `toBoolIfNecessary`
+      let lhs ← toExprCore lhs
+      let rhs ← toExprCore rhs
+      let lhs ← withRef lhsStx <| toBoolIfNecessary lhs
+      let rhs ← withRef rhsStx <| toBoolIfNecessary rhs
+      let lhsType ← inferType lhs
+      let rhs ← withRef rhsStx <| ensureHasType lhsType rhs
+      elabAppArgs f #[] #[Arg.expr lhs, Arg.expr rhs] expectedType? (explicit := false) (ellipsis := false) (resultIsOutParamSupport := false)
+    else
+      let mut maxType := r.max?.get!
+      /- If `noProp == true` and `maxType` is `Prop`, then set `maxType := Bool`. `See toBoolIfNecessary` -/
+      if noProp then
+        if (← withNewMCtxDepth <| isDefEq maxType (mkSort levelZero)) then
+          maxType := Lean.mkConst ``Bool
+      let result ← toExprCore (← applyCoe tree maxType (isPred := true))
+      trace[Elab.binrel] "result: {result}"
+      return result
+  | none   => throwUnknownConstantAt stx[1] stx[1].getId
+where
+  /-- If `noProp == true` and `e` has type `Prop`, then coerce it to `Bool`. -/
+  toBoolIfNecessary (e : Expr) : TermElabM Expr := do
+    if noProp then
+      -- We use `withNewMCtxDepth` to make sure metavariables are not assigned
+      if (← withNewMCtxDepth <| isDefEq (← inferType e) (mkSort levelZero)) then
+        return (← ensureHasType (Lean.mkConst ``Bool) e)
+    return e
+
+@[builtin_term_elab binrel] def elabBinRel : TermElab := elabBinRelCore false
+
+@[builtin_term_elab binrel_no_prop] def elabBinRelNoProp : TermElab := elabBinRelCore true
+
+@[builtin_term_elab defaultOrOfNonempty]
+def elabDefaultOrNonempty : TermElab :=  fun stx expectedType? => do
+  tryPostponeIfNoneOrMVar expectedType?
+  match expectedType? with
+  | none => throwError "invalid 'default_or_ofNonempty%', expected type is not known"
+  | some expectedType =>
+    try
+      mkDefault expectedType
+    catch ex => try
+      mkOfNonempty expectedType
+    catch _ =>
+      if stx[1].isNone then
+        throw ex
+      else
+        -- It is in the context of an `unsafe` constant. We can use sorry instead.
+        -- Another option is to make a recursive application since it is unsafe.
+        mkLabeledSorry expectedType false (unique := true)
+
+builtin_initialize
+  registerTraceClass `Elab.binop
+  registerTraceClass `Elab.binrel
+
+end Op
+
+end Lean.Elab.Term

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/Frontend.lean

@@ -0,0 +1,218 @@
+/-
+Copyright (c) 2019 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura, Sebastian Ullrich
+-/
+prelude
+import Lean.Language.Lean
+import Lean.Util.Profile
+import Lean.Server.References
+import Lean.Util.Profiler
+
+namespace Lean.Elab.Frontend
+
+structure State where
+  commandState : Command.State
+  parserState  : Parser.ModuleParserState
+  cmdPos       : String.Pos
+  commands     : Array Syntax := #[]
+deriving Nonempty
+
+structure Context where
+  inputCtx : Parser.InputContext
+
+abbrev FrontendM := ReaderT Context $ StateRefT State IO
+
+def setCommandState (commandState : Command.State) : FrontendM Unit :=
+  modify fun s => { s with commandState := commandState }
+
+@[inline] def runCommandElabM (x : Command.CommandElabM α) : FrontendM α := do
+  let ctx ← read
+  let s ← get
+  let cmdCtx : Command.Context := {
+    cmdPos       := s.cmdPos
+    fileName     := ctx.inputCtx.fileName
+    fileMap      := ctx.inputCtx.fileMap
+    snap?        := none
+    cancelTk?    := none
+  }
+  match (← liftM <| EIO.toIO' <| (x cmdCtx).run s.commandState) with
+  | Except.error e      => throw <| IO.Error.userError s!"unexpected internal error: {← e.toMessageData.toString}"
+  | Except.ok (a, sNew) => setCommandState sNew; return a
+
+def elabCommandAtFrontend (stx : Syntax) : FrontendM Unit := do
+  runCommandElabM do
+    let initMsgs ← modifyGet fun st => (st.messages, { st with messages := {} })
+    Command.elabCommandTopLevel stx
+    let mut msgs := (← get).messages
+    modify ({ · with messages := initMsgs ++ msgs })
+
+def updateCmdPos : FrontendM Unit := do
+  modify fun s => { s with cmdPos := s.parserState.pos }
+
+def getParserState : FrontendM Parser.ModuleParserState := do pure (← get).parserState
+def getCommandState : FrontendM Command.State := do pure (← get).commandState
+def setParserState (ps : Parser.ModuleParserState) : FrontendM Unit := modify fun s => { s with parserState := ps }
+def setMessages (msgs : MessageLog) : FrontendM Unit := modify fun s => { s with commandState := { s.commandState with messages := msgs } }
+def getInputContext : FrontendM Parser.InputContext := do pure (← read).inputCtx
+
+def processCommand : FrontendM Bool := do
+  updateCmdPos
+  let cmdState ← getCommandState
+  let ictx ← getInputContext
+  let pstate ← getParserState
+  let scope := cmdState.scopes.head!
+  let pmctx := { env := cmdState.env, options := scope.opts, currNamespace := scope.currNamespace, openDecls := scope.openDecls }
+  match profileit "parsing" scope.opts fun _ => Parser.parseCommand ictx pmctx pstate cmdState.messages with
+  | (cmd, ps, messages) =>
+    modify fun s => { s with commands := s.commands.push cmd }
+    setParserState ps
+    setMessages messages
+    elabCommandAtFrontend cmd
+    pure (Parser.isTerminalCommand cmd)
+
+partial def processCommands : FrontendM Unit := do
+  let done ← processCommand
+  unless done do
+    processCommands
+
+end Frontend
+
+open Frontend
+
+structure IncrementalState extends State where
+  inputCtx    : Parser.InputContext
+  initialSnap : Language.Lean.CommandParsedSnapshot
+deriving Nonempty
+
+open Language in
+/--
+Variant of `IO.processCommands` that allows for potential incremental reuse. Pass in the result of a
+previous invocation done with the same state (but usually different input context) to allow for
+reuse.
+-/
+partial def IO.processCommandsIncrementally (inputCtx : Parser.InputContext)
+    (parserState : Parser.ModuleParserState) (commandState : Command.State)
+    (old? : Option IncrementalState) :
+    BaseIO IncrementalState := do
+  let task ← Language.Lean.processCommands inputCtx parserState commandState
+    (old?.map fun old => (old.inputCtx, old.initialSnap))
+  go task.get task #[]
+where
+  go initialSnap t commands :=
+    let snap := t.get
+    let commands := commands.push snap
+    if let some next := snap.nextCmdSnap? then
+      go initialSnap next.task commands
+    else
+      -- Opting into reuse also enables incremental reporting, so make sure to collect messages from
+      -- all snapshots
+      let messages := toSnapshotTree initialSnap
+        |>.getAll.map (·.diagnostics.msgLog)
+        |>.foldl (· ++ ·) {}
+      -- In contrast to messages, we should collect info trees only from the top-level command
+      -- snapshots as they subsume any info trees reported incrementally by their children.
+      let trees := commands.map (·.elabSnap.infoTreeSnap.get.infoTree?) |>.filterMap id |>.toPArray'
+      return {
+        commandState := { snap.elabSnap.resultSnap.get.cmdState with messages, infoState.trees := trees }
+        parserState := snap.parserState
+        cmdPos := snap.parserState.pos
+        commands := commands.map (·.stx)
+        inputCtx, initialSnap
+      }
+
+def IO.processCommands (inputCtx : Parser.InputContext) (parserState : Parser.ModuleParserState)
+    (commandState : Command.State) : IO State := do
+  let st ← IO.processCommandsIncrementally inputCtx parserState commandState none
+  return st.toState
+
+def process (input : String) (env : Environment) (opts : Options) (fileName : Option String := none) : IO (Environment × MessageLog) := do
+  let fileName   := fileName.getD "<input>"
+  let inputCtx   := Parser.mkInputContext input fileName
+  let s ← IO.processCommands inputCtx { : Parser.ModuleParserState } (Command.mkState env {} opts)
+  pure (s.commandState.env, s.commandState.messages)
+
+def runFrontend
+    (input : String)
+    (opts : Options)
+    (fileName : String)
+    (mainModuleName : Name)
+    (trustLevel : UInt32 := 0)
+    (oleanFileName? : Option System.FilePath := none)
+    (ileanFileName? : Option System.FilePath := none)
+    (jsonOutput : Bool := false)
+    (errorOnKinds : Array Name := #[])
+    (plugins : Array System.FilePath := #[])
+    (printStats : Bool := false)
+    (setup? : Option ModuleSetup := none)
+    : IO (Option Environment) := do
+  let startTime := (← IO.monoNanosNow).toFloat / 1000000000
+  let inputCtx := Parser.mkInputContext input fileName
+  let opts := Lean.internal.cmdlineSnapshots.setIfNotSet opts true
+  -- default to async elaboration; see also `Elab.async` docs
+  let opts := Elab.async.setIfNotSet opts true
+  let ctx := { inputCtx with }
+  let setup stx := do
+    if let some setup := setup? then
+      liftM <| setup.dynlibs.forM Lean.loadDynlib
+      return .ok {
+        trustLevel
+        mainModuleName := setup.name
+        isModule := strictOr setup.isModule stx.isModule
+        imports := setup.imports?.getD stx.imports
+        plugins := plugins ++ setup.plugins
+        importArts := setup.importArts
+        -- override cmdline options with setup options
+        opts := opts.mergeBy (fun _ _ hOpt => hOpt) setup.options.toOptions
+      }
+    else
+      return .ok {
+        imports := stx.imports
+        isModule := stx.isModule
+        mainModuleName, opts, trustLevel, plugins
+      }
+  let processor := Language.Lean.process
+  let snap ← processor setup none ctx
+  let snaps := Language.toSnapshotTree snap
+  let severityOverrides := errorOnKinds.foldl (·.insert · .error) {}
+
+  -- reporting should be done before any early exit from the function
+  let hasErrors ← snaps.runAndReport opts jsonOutput severityOverrides
+
+  let some cmdState := Language.Lean.waitForFinalCmdState? snap
+    | return none
+  let env := cmdState.env
+  let finalOpts := cmdState.scopes[0]!.opts
+
+  -- stats should be displayed even if there are (non-import) errors
+  if printStats then
+    env.displayStats
+
+  if hasErrors then
+    return none
+
+  if let some oleanFileName := oleanFileName? then
+    profileitIO ".olean serialization" finalOpts do
+      writeModule env oleanFileName
+
+  if let some ileanFileName := ileanFileName? then
+    let trees := snaps.getAll.flatMap (match ·.infoTree? with | some t => #[t] | _ => #[])
+    let references := Lean.Server.findModuleRefs inputCtx.fileMap trees (localVars := false)
+    let ilean := {
+      module        := mainModuleName
+      directImports := Server.collectImports ⟨snap.stx⟩
+      references    := ← references.toLspModuleRefs
+      : Lean.Server.Ilean
+    }
+    IO.FS.writeFile ileanFileName $ Json.compress $ toJson ilean
+
+  if let some out := trace.profiler.output.get? opts then
+    let traceStates := snaps.getAll.map (·.traces)
+    let profile ← Firefox.Profile.export mainModuleName.toString startTime traceStates opts
+    IO.FS.writeFile ⟨out⟩ <| Json.compress <| toJson profile
+
+  -- no point in freeing the snapshot graph and all referenced data this close to process exit
+  Runtime.forget snaps
+  return some env
+
+end Lean.Elab

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/GenInjective.lean

@@ -0,0 +1,17 @@
+/-
+Copyright (c) 2021 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Lean.Elab.Command
+import Lean.Meta.Injective
+
+namespace Lean.Elab.Command
+
+@[builtin_command_elab genInjectiveTheorems] def elabGenInjectiveTheorems : CommandElab := fun stx => do
+  liftTermElabM do
+    let declName ← realizeGlobalConstNoOverloadWithInfo stx[1]
+    Meta.mkInjectiveTheorems declName
+
+end Lean.Elab.Command

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/GuardMsgs.lean

@@ -0,0 +1,235 @@
+/-
+Copyright (c) 2023 Kyle Miller. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Kyle Miller
+-/
+prelude
+import Lean.Elab.Notation
+import Lean.Util.Diff
+import Lean.Server.CodeActions.Attr
+
+/-! `#guard_msgs` command for testing commands
+
+This module defines a command to test that another command produces the expected messages.
+See the docstring on the `#guard_msgs` command.
+-/
+
+open Lean Parser.Tactic Elab Command
+
+register_builtin_option guard_msgs.diff : Bool := {
+  defValue := true
+  descr := "When true, show a diff between expected and actual messages if they don't match. "
+}
+
+
+namespace Lean.Elab.Tactic.GuardMsgs
+
+/-- Gives a string representation of a message without source position information.
+Ensures the message ends with a '\n'. -/
+private def messageToStringWithoutPos (msg : Message) : BaseIO String := do
+  let mut str ← msg.data.toString
+  unless msg.caption == "" do
+    str := msg.caption ++ ":\n" ++ str
+  if !("\n".isPrefixOf str) then str := " " ++ str
+  if msg.isTrace then
+    str := "trace:" ++ str
+  else
+    match msg.severity with
+    | MessageSeverity.information => str := "info:" ++ str
+    | MessageSeverity.warning     => str := "warning:" ++ str
+    | MessageSeverity.error       => str := "error:" ++ str
+  if str.isEmpty || str.back != '\n' then
+    str := str ++ "\n"
+  return str
+
+/-- The decision made by a specification for a message. -/
+inductive SpecResult
+  /-- Capture the message and check it matches the docstring. -/
+  | check
+  /-- Drop the message and delete it. -/
+  | drop
+  /-- Do not capture the message. -/
+  | pass
+
+/-- The method to use when normalizing whitespace, after trimming. -/
+inductive WhitespaceMode
+  /-- Exact equality. -/
+  | exact
+  /-- Equality after normalizing newlines into spaces. -/
+  | normalized
+  /-- Equality after collapsing whitespace into single spaces. -/
+  | lax
+
+/-- Method to use when combining multiple messages. -/
+inductive MessageOrdering
+  /-- Use the exact ordering of the produced messages. -/
+  | exact
+  /-- Sort the produced messages. -/
+  | sorted
+
+def parseGuardMsgsFilterAction (action? : Option (TSyntax ``guardMsgsFilterAction)) :
+    CommandElabM SpecResult := do
+  if let some action := action? then
+    match action with
+    | `(guardMsgsFilterAction| check) => pure .check
+    | `(guardMsgsFilterAction| drop)  => pure .drop
+    | `(guardMsgsFilterAction| pass)  => pure .pass
+    | _ => throwUnsupportedSyntax
+  else
+    pure .check
+
+def parseGuardMsgsFilterSeverity : TSyntax ``guardMsgsFilterSeverity → CommandElabM (Message → Bool)
+  | `(guardMsgsFilterSeverity| trace) => pure fun msg => msg.isTrace
+  | `(guardMsgsFilterSeverity| info)  => pure fun msg => !msg.isTrace && msg.severity == .information
+  | `(guardMsgsFilterSeverity| warning) => pure fun msg => !msg.isTrace && msg.severity == .warning
+  | `(guardMsgsFilterSeverity| error) => pure fun msg => !msg.isTrace && msg.severity == .error
+  | `(guardMsgsFilterSeverity| all)   => pure fun _ => true
+  | _ => throwUnsupportedSyntax
+
+/-- Parses a `guardMsgsSpec`.
+- No specification: check everything.
+- With a specification: interpret the spec, and if nothing applies pass it through. -/
+def parseGuardMsgsSpec (spec? : Option (TSyntax ``guardMsgsSpec)) :
+    CommandElabM (WhitespaceMode × MessageOrdering × (Message → SpecResult)) := do
+  let elts ←
+    if let some spec := spec? then
+      match spec with
+      | `(guardMsgsSpec| ($[$elts:guardMsgsSpecElt],*)) => pure elts
+      | _ => throwUnsupportedSyntax
+    else
+      pure #[]
+  let mut whitespace : WhitespaceMode := .normalized
+  let mut ordering : MessageOrdering := .exact
+  let mut p? : Option (Message → SpecResult) := none
+  let pushP (action : SpecResult) (msgP : Message → Bool) (p? : Option (Message → SpecResult))
+      (msg : Message) : SpecResult :=
+    if msgP msg then
+      action
+    else
+      (p?.getD fun _ => .pass) msg
+  for elt in elts.reverse do
+    match elt with
+    | `(guardMsgsSpecElt| $[$action?]? $sev)        => p? := pushP (← parseGuardMsgsFilterAction action?) (← parseGuardMsgsFilterSeverity sev) p?
+    | `(guardMsgsSpecElt| whitespace := exact)      => whitespace := .exact
+    | `(guardMsgsSpecElt| whitespace := normalized) => whitespace := .normalized
+    | `(guardMsgsSpecElt| whitespace := lax)        => whitespace := .lax
+    | `(guardMsgsSpecElt| ordering := exact)        => ordering := .exact
+    | `(guardMsgsSpecElt| ordering := sorted)       => ordering := .sorted
+    | _ => throwUnsupportedSyntax
+  let defaultP := fun _ => .check
+  return (whitespace, ordering, p?.getD defaultP)
+
+/-- An info tree node corresponding to a failed `#guard_msgs` invocation,
+used for code action support. -/
+structure GuardMsgFailure where
+  /-- The result of the nested command -/
+  res : String
+deriving TypeName
+
+/--
+Makes trailing whitespace visible and protectes them against trimming by the editor, by appending
+the symbol ⏎ to such a line (and also to any line that ends with such a symbol, to avoid
+ambiguities in the case the message already had that symbol).
+-/
+def revealTrailingWhitespace (s : String) : String :=
+  s.replace "⏎\n" "⏎⏎\n" |>.replace "\t\n" "\t⏎\n" |>.replace " \n" " ⏎\n"
+
+/- The inverse of `revealTrailingWhitespace` -/
+def removeTrailingWhitespaceMarker (s : String) : String :=
+  s.replace "⏎\n" "\n"
+
+/--
+Applies a whitespace normalization mode.
+-/
+def WhitespaceMode.apply (mode : WhitespaceMode) (s : String) : String :=
+  match mode with
+  | .exact => s
+  | .normalized => s.replace "\n" " "
+  | .lax => String.intercalate " " <| (s.split Char.isWhitespace).filter (!·.isEmpty)
+
+/--
+Applies a message ordering mode.
+-/
+def MessageOrdering.apply (mode : MessageOrdering) (msgs : List String) : List String :=
+  match mode with
+  | .exact => msgs
+  | .sorted => msgs |>.toArray.qsort (· < ·) |>.toList
+
+@[builtin_command_elab Lean.guardMsgsCmd] def elabGuardMsgs : CommandElab
+  | `(command| $[$dc?:docComment]? #guard_msgs%$tk $(spec?)? in $cmd) => do
+    let expected : String := (← dc?.mapM (getDocStringText ·)).getD ""
+        |>.trim |> removeTrailingWhitespaceMarker
+    let (whitespace, ordering, specFn) ← parseGuardMsgsSpec spec?
+    let initMsgs ← modifyGet fun st => (st.messages, { st with messages := {} })
+    -- do not forward snapshot as we don't want messages assigned to it to leak outside
+    withReader ({ · with snap? := none }) do
+      -- The `#guard_msgs` command is special-cased in `elabCommandTopLevel` to ensure linters only run once.
+      elabCommandTopLevel cmd
+    -- collect sync and async messages
+    let msgs := (← get).messages ++
+      (← get).snapshotTasks.foldl (· ++ ·.get.getAll.foldl (· ++ ·.diagnostics.msgLog) {}) {}
+    -- clear async messages as we don't want them to leak outside
+    modify ({ · with snapshotTasks := #[] })
+    let mut toCheck : MessageLog := .empty
+    let mut toPassthrough : MessageLog := .empty
+    for msg in msgs.toList do
+      if msg.isSilent then
+        continue
+      match specFn msg with
+      | .check       => toCheck := toCheck.add msg
+      | .drop        => pure ()
+      | pass => toPassthrough := toPassthrough.add msg
+    let strings ← toCheck.toList.mapM (messageToStringWithoutPos ·)
+    let strings := ordering.apply strings
+    let res := "---\n".intercalate strings |>.trim
+    if whitespace.apply expected == whitespace.apply res then
+      -- Passed. Only put toPassthrough messages back on the message log
+      modify fun st => { st with messages := initMsgs ++ toPassthrough }
+    else
+      -- Failed. Put all the messages back on the message log and add an error
+      modify fun st => { st with messages := initMsgs ++ msgs }
+      let feedback :=
+        if guard_msgs.diff.get (← getOptions) then
+          let diff := Diff.diff (expected.split (· == '\n')).toArray (res.split (· == '\n')).toArray
+          Diff.linesToString diff
+        else res
+      logErrorAt tk m!"❌️ Docstring on `#guard_msgs` does not match generated message:\n\n{feedback}"
+      pushInfoLeaf (.ofCustomInfo { stx := ← getRef, value := Dynamic.mk (GuardMsgFailure.mk res) })
+  | _ => throwUnsupportedSyntax
+
+open CodeAction Server RequestM in
+/-- A code action which will update the doc comment on a `#guard_msgs` invocation. -/
+@[builtin_command_code_action guardMsgsCmd]
+def guardMsgsCodeAction : CommandCodeAction := fun _ _ _ node => do
+  let .node _ ts := node | return #[]
+  let res := ts.findSome? fun
+    | .node (.ofCustomInfo { stx, value }) _ => return (stx, (← value.get? GuardMsgFailure).res)
+    | _ => none
+  let some (stx, res) := res | return #[]
+  let doc ← readDoc
+  let eager := {
+    title := "Update #guard_msgs with tactic output"
+    kind? := "quickfix"
+    isPreferred? := true
+  }
+  pure #[{
+    eager
+    lazy? := some do
+      let some start := stx.getPos? true | return eager
+      let some tail := stx.setArg 0 mkNullNode |>.getPos? true | return eager
+      let res := revealTrailingWhitespace res
+      let newText := if res.isEmpty then
+        ""
+      else if res.length ≤ 100-7 && !res.contains '\n' then -- TODO: configurable line length?
+        s!"/-- {res} -/\n"
+      else
+        s!"/--\n{res}\n-/\n"
+      pure { eager with
+        edit? := some <|.ofTextEdit doc.versionedIdentifier {
+          range := doc.meta.text.utf8RangeToLspRange ⟨start, tail⟩
+          newText
+        }
+      }
+  }]
+
+end Lean.Elab.Tactic.GuardMsgs

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/Import.lean

@@ -0,0 +1,101 @@
+/-
+Copyright (c) 2019 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura, Sebastian Ullrich
+-/
+prelude
+import Lean.Parser.Module
+import Lean.CoreM
+
+namespace Lean.Elab
+
+abbrev HeaderSyntax := TSyntax ``Parser.Module.header
+
+def HeaderSyntax.startPos (header : HeaderSyntax) : String.Pos :=
+  header.raw.getPos?.getD 0
+
+def HeaderSyntax.isModule (header : HeaderSyntax) : Bool :=
+  !header.raw[0].isNone
+
+def HeaderSyntax.imports (stx : HeaderSyntax) (includeInit : Bool := true) : Array Import :=
+  match stx with
+  | `(Parser.Module.header| $[module%$moduleTk]? $[prelude%$preludeTk]? $importsStx*) =>
+    let imports := if preludeTk.isNone && includeInit then #[{ module := `Init : Import }] else #[]
+    imports ++ importsStx.map fun
+      | `(Parser.Module.import| $[public%$publicTk]? $[meta%$metaTk]? import $[all%$allTk]? $n) =>
+        { module := n.getId, importAll := allTk.isSome
+          isExported := publicTk.isSome || moduleTk.isNone
+          isMeta := metaTk.isSome }
+      | _ => unreachable!
+  | _ => unreachable!
+
+def HeaderSyntax.toModuleHeader (stx : HeaderSyntax) : ModuleHeader where
+  isModule := stx.isModule
+  imports := stx.imports
+
+abbrev headerToImports := @HeaderSyntax.imports
+
+def processHeaderCore
+    (startPos : String.Pos) (imports : Array Import) (isModule : Bool)
+    (opts : Options) (messages : MessageLog) (inputCtx : Parser.InputContext)
+    (trustLevel : UInt32 := 0) (plugins : Array System.FilePath := #[]) (leakEnv := false)
+    (mainModule := Name.anonymous) (arts : NameMap ImportArtifacts := {})
+    : IO (Environment × MessageLog) := do
+  let level := if isModule then
+    if Elab.inServer.get opts then
+      .server
+    else
+      .exported
+  else
+    .private
+  let (env, messages) ← try
+    for i in imports do
+      if !isModule && i.importAll then
+        throw <| .userError "cannot use `import all` without `module`"
+      if i.importAll && mainModule.getRoot != i.module.getRoot then
+        throw <| .userError "cannot use `import all` across module path roots"
+    let env ←
+      importModules (leakEnv := leakEnv) (loadExts := true) (level := level)
+        imports opts trustLevel plugins arts
+    pure (env, messages)
+  catch e =>
+    let env ← mkEmptyEnvironment
+    let pos := inputCtx.fileMap.toPosition startPos
+    pure (env, messages.add { fileName := inputCtx.fileName, data := toString e, pos := pos })
+  return (env.setMainModule mainModule, messages)
+
+/--
+Elaborates the given header syntax into an environment.
+
+If `mainModule` is not given, `Environment.setMainModule` should be called manually. This is a
+backwards compatibility measure not compatible with the module system.
+-/
+@[inline] def processHeader
+    (header : HeaderSyntax)
+    (opts : Options) (messages : MessageLog) (inputCtx : Parser.InputContext)
+    (trustLevel : UInt32 := 0) (plugins : Array System.FilePath := #[]) (leakEnv := false)
+    (mainModule := Name.anonymous)
+    : IO (Environment × MessageLog) := do
+  processHeaderCore header.startPos header.imports header.isModule
+    opts messages inputCtx trustLevel plugins leakEnv mainModule
+
+def parseImports (input : String) (fileName : Option String := none) : IO (Array Import × Position × MessageLog) := do
+  let fileName := fileName.getD "<input>"
+  let inputCtx := Parser.mkInputContext input fileName
+  let (header, parserState, messages) ← Parser.parseHeader inputCtx
+  pure (headerToImports header, inputCtx.fileMap.toPosition parserState.pos, messages)
+
+def printImports (input : String) (fileName : Option String) : IO Unit := do
+  let (deps, _, _) ← parseImports input fileName
+  for dep in deps do
+    let fname ← findOLean dep.module
+    IO.println fname
+
+def printImportSrcs (input : String) (fileName : Option String) : IO Unit := do
+  let sp ← getSrcSearchPath
+  let (deps, _, _) ← parseImports input fileName
+  for dep in deps do
+    let fname ← findLean sp dep.module
+    IO.println fname
+
+end Lean.Elab

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/Inductive.lean

@@ -0,0 +1,301 @@
+/-
+Copyright (c) 2020 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura, Kyle Miller
+-/
+prelude
+import Lean.Elab.MutualInductive
+
+namespace Lean.Elab.Command
+open Meta
+
+/-
+```
+def Lean.Parser.Command.«inductive» :=
+  leading_parser "inductive " >> declId >> optDeclSig >> optional ("where" <|> ":=") >> many ctor
+
+def Lean.Parser.Command.classInductive :=
+  leading_parser atomic (group ("class " >> "inductive ")) >> declId >> optDeclSig >> optional ("where" <|> ":=") >> many ctor >> optDeriving
+```
+-/
+private def inductiveSyntaxToView (modifiers : Modifiers) (decl : Syntax) : TermElabM InductiveView := do
+  let isClass := decl.isOfKind ``Parser.Command.classInductive
+  let modifiers := if isClass then modifiers.addAttr { name := `class } else modifiers
+  let (binders, type?) := expandOptDeclSig decl[2]
+  let declId           := decl[1]
+  let ⟨name, declName, levelNames⟩ ← Term.expandDeclId (← getCurrNamespace) (← Term.getLevelNames) declId modifiers
+  addDeclarationRangesForBuiltin declName modifiers.stx decl
+  let ctors      ← decl[4].getArgs.mapM fun ctor => withRef ctor do
+    /-
+    ```
+    def ctor := leading_parser optional docComment >> "\n| " >> declModifiers >> rawIdent >> optDeclSig
+    ```
+    -/
+    let mut ctorModifiers ← elabModifiers ⟨ctor[2]⟩
+    if let some leadingDocComment := ctor[0].getOptional? then
+      if ctorModifiers.docString?.isSome then
+        logErrorAt leadingDocComment "duplicate doc string"
+      ctorModifiers := { ctorModifiers with docString? := some ⟨leadingDocComment⟩ }
+    if ctorModifiers.isPrivate && modifiers.isPrivate then
+      throwError "invalid 'private' constructor in a 'private' inductive datatype"
+    if ctorModifiers.isProtected && modifiers.isPrivate then
+      throwError "invalid 'protected' constructor in a 'private' inductive datatype"
+    checkValidCtorModifier ctorModifiers
+    let ctorName := ctor.getIdAt 3
+    let ctorName := declName ++ ctorName
+    let ctorName ← withRef ctor[3] <| applyVisibility ctorModifiers.visibility ctorName
+    let (binders, type?) := expandOptDeclSig ctor[4]
+    addDocString' ctorName ctorModifiers.docString?
+    addDeclarationRangesFromSyntax ctorName ctor ctor[3]
+    return { ref := ctor, declId := ctor[3], modifiers := ctorModifiers, declName := ctorName, binders := binders, type? := type? : CtorView }
+  let computedFields ← (decl[5].getOptional?.map (·[1].getArgs) |>.getD #[]).mapM fun cf => withRef cf do
+    return { ref := cf, modifiers := cf[0], fieldId := cf[1].getId, type := ⟨cf[3]⟩, matchAlts := ⟨cf[4]⟩ }
+  let classes ← getOptDerivingClasses decl[6]
+  if decl[3][0].isToken ":=" then
+    -- https://github.com/leanprover/lean4/issues/5236
+    withRef decl[0] <| Linter.logLintIf Linter.linter.deprecated decl[3]
+      "'inductive ... :=' has been deprecated in favor of 'inductive ... where'."
+  return {
+    ref             := decl
+    shortDeclName   := name
+    derivingClasses := classes
+    allowIndices    := true
+    allowSortPolymorphism := true
+    declId, modifiers, isClass, declName, levelNames
+    binders, type?, ctors
+    computedFields
+  }
+
+private def isInductiveFamily (numParams : Nat) (indFVar : Expr) : TermElabM Bool := do
+  let indFVarType ← inferType indFVar
+  forallTelescopeReducing indFVarType fun xs _ =>
+    return xs.size > numParams
+
+private def getArrowBinderNames (type : Expr) : Array Name :=
+  go type #[]
+where
+  go (type : Expr) (acc : Array Name) : Array Name :=
+    match type with
+    | .forallE n _ b _ => go b (acc.push n)
+    | .mdata _ b       => go b acc
+    | _ => acc
+
+/--
+Replaces binder names in `type` with `newNames`.
+Remark: we only replace the names for binder containing macroscopes.
+-/
+private def replaceArrowBinderNames (type : Expr) (newNames : Array Name) : Expr :=
+  go type 0
+where
+  go (type : Expr) (i : Nat) : Expr :=
+    if h : i < newNames.size then
+      match type with
+      | .forallE n d b bi =>
+        if n.hasMacroScopes then
+          mkForall newNames[i] bi d (go b (i+1))
+        else
+          mkForall n bi d (go b (i+1))
+      | _ => type
+    else
+      type
+
+/--
+Reorders constructor arguments to improve the effectiveness of the `fixedIndicesToParams` method.
+
+The idea is quite simple. Given a constructor type of the form
+```
+(a₁ : A₁) → ... → (aₙ : Aₙ) → C b₁ ... bₘ
+```
+We try to find the longest prefix `b₁ ... bᵢ`, `i ≤ m` s.t.
+- each `bₖ` is in `{a₁, ..., aₙ}`
+- each `bₖ` only depends on variables in `{b₁, ..., bₖ₋₁}`
+
+Then, it moves this prefix `b₁ ... bᵢ` to the front.
+
+Remark: We only reorder implicit arguments that have macroscopes. See issue #1156.
+The macroscope test is an approximation, we could have restricted ourselves to auto-implicit arguments.
+-/
+private def reorderCtorArgs (ctorType : Expr) : MetaM Expr := do
+  forallTelescopeReducing ctorType fun as type => do
+    /- `type` is of the form `C ...` where `C` is the inductive datatype being defined. -/
+    let bs := type.getAppArgs
+    let mut as  := as
+    let mut bsPrefix := #[]
+    for b in bs do
+      unless b.isFVar && as.contains b do
+        break
+      let localDecl ← getFVarLocalDecl b
+      if localDecl.binderInfo.isExplicit then
+        break
+      unless localDecl.userName.hasMacroScopes do
+        break
+      if (← localDeclDependsOnPred localDecl fun fvarId => as.any fun p => p.fvarId! == fvarId) then
+        break
+      bsPrefix := bsPrefix.push b
+      as := as.erase b
+    if bsPrefix.isEmpty then
+      return ctorType
+    else
+      let r ← mkForallFVars (bsPrefix ++ as) type
+      /- `r` already contains the resulting type.
+         To be able to produce better error messages, we copy the first `bsPrefix.size` binder names from `C` to `r`.
+         This is important when some of constructor parameters were inferred using the auto-bound implicit feature.
+         For example, in the following declaration.
+         ```
+          inductive Member : α → List α → Type u
+            | head : Member a (a::as)
+            | tail : Member a bs → Member a (b::bs)
+         ```
+         if we do not copy the binder names
+         ```
+         #check @Member.head
+         ```
+         produces `@Member.head : {x : Type u_1} → {a : x} → {as : List x} → Member a (a :: as)`
+         which is correct, but a bit confusing. By copying the binder names, we obtain
+         `@Member.head : {α : Type u_1} → {a : α} → {as : List α} → Member a (a :: as)`
+       -/
+      let C := type.getAppFn
+      let binderNames := getArrowBinderNames (← instantiateMVars (← inferType C))
+      return replaceArrowBinderNames r binderNames[*...bsPrefix.size]
+
+/--
+  Elaborate constructor types.
+
+  Remark: we check whether the resulting type is correct, and the parameter occurrences are consistent, but
+  we currently do not check for:
+  - Positivity (it is a rare failure, and the kernel already checks for it).
+  - Universe constraints (the kernel checks for it).
+-/
+private def elabCtors (indFVars : Array Expr) (params : Array Expr) (r : ElabHeaderResult) : TermElabM (List Constructor) :=
+  withRef r.view.ref do
+  withExplicitToImplicit params do
+  let indFVar := r.indFVar
+  let indFamily ← isInductiveFamily params.size indFVar
+  r.view.ctors.toList.mapM fun ctorView =>
+    Term.withAutoBoundImplicit <| Term.elabBinders ctorView.binders.getArgs fun ctorParams =>
+      withRef ctorView.ref do
+        let elabCtorType : TermElabM Expr := do
+          match ctorView.type? with
+          | none          =>
+            if indFamily then
+              throwError "Missing resulting type for constructor '{ctorView.declName}': \
+                Its resulting type must be specified because it is part of an inductive family declaration"
+            return mkAppN indFVar params
+          | some ctorType =>
+            let type ← Term.elabType ctorType
+            trace[Elab.inductive] "elabType {ctorView.declName} : {type} "
+            Term.synthesizeSyntheticMVars (postpone := .yes)
+            let type ← instantiateMVars type
+            let type ← checkParamOccs type
+            forallTelescopeReducing type fun _ resultingType => do
+              unless resultingType.getAppFn == indFVar do
+                throwUnexpectedResultingTypeMismatch resultingType indFVar ctorView.declName ctorType
+              unless (← isType resultingType) do
+                throwUnexpectedResultingTypeNotType resultingType ctorView.declName ctorType
+            return type
+        let type ← elabCtorType
+        Term.synthesizeSyntheticMVarsNoPostponing
+        let ctorParams ← Term.addAutoBoundImplicits ctorParams (ctorView.declId.getTailPos? (canonicalOnly := true))
+        let except (mvarId : MVarId) := ctorParams.any fun ctorParam => ctorParam.isMVar && ctorParam.mvarId! == mvarId
+        /-
+          We convert metavariables in the resulting type into extra parameters. Otherwise, we would not be able to elaborate
+          declarations such as
+          ```
+          inductive Palindrome : List α → Prop where
+            | nil      : Palindrome [] -- We would get an error here saying "failed to synthesize implicit argument" at `@List.nil ?m`
+            | single   : (a : α) → Palindrome [a]
+            | sandwich : (a : α) → Palindrome as → Palindrome ([a] ++ as ++ [a])
+          ```
+          We used to also collect unassigned metavariables on `ctorParams`, but it produced counterintuitive behavior.
+          For example, the following declaration used to be accepted.
+          ```
+          inductive Foo
+          | bar (x)
+
+          #check Foo.bar
+          -- @Foo.bar : {x : Sort u_1} → x → Foo
+          ```
+          which is also inconsistent with the behavior of auto implicits in definitions. For example, the following example was never accepted.
+          ```
+          def bar (x) := 1
+          ```
+        -/
+        let extraCtorParams ← Term.collectUnassignedMVars (← instantiateMVars type) #[] except
+        trace[Elab.inductive] "extraCtorParams: {extraCtorParams}"
+        /- We must abstract `extraCtorParams` and `ctorParams` simultaneously to make
+            sure we do not create auxiliary metavariables. -/
+        let type ← mkForallFVars (extraCtorParams ++ ctorParams) type
+        let type ← reorderCtorArgs type
+        let type ← mkForallFVars params type
+        trace[Elab.inductive] "{ctorView.declName} : {type}"
+        return { name := ctorView.declName, type }
+where
+  /--
+  Ensures that the arguments to recursive occurrences of the type family being defined match the
+  parameters from the inductive definition.
+  -/
+  checkParamOccs (ctorType : Expr) : MetaM Expr :=
+    let visit (e : Expr) : StateT (List Expr) MetaM TransformStep := do
+      let f := e.getAppFn
+      if indFVars.contains f then
+        let mut args := e.getAppArgs
+        -- Prefer throwing an "argument mismatch" error rather than a "missing parameter" one
+        for i in [:min args.size params.size] do
+          let param := params[i]!
+          let arg := args[i]!
+          unless (← isDefEq param arg) do
+            let (arg, param) ← addPPExplicitToExposeDiff arg param
+            let msg := m!"Mismatched inductive type parameter in{indentExpr e}\nThe provided argument\
+              {indentExpr arg}\nis not definitionally equal to the expected parameter{indentExpr param}"
+            let noteMsg := m!"The value of parameter '{param}' must be fixed throughout the inductive \
+              declaration. Consider making this parameter an index if it must vary."
+            throwNamedError lean.inductiveParamMismatch (msg ++ .note noteMsg)
+          args := args.set! i param
+        unless args.size ≥ params.size do
+          let expected := mkAppN f params
+          let containingExprMsg := (← get).head?.map toMessageData |>.getD m!"<missing>"
+          let msg :=
+            m!"Missing parameter(s) in occurrence of inductive type: In the expression{indentD containingExprMsg}\n\
+               found{indentExpr e}\nbut expected all parameters to be specified:{indentExpr expected}"
+          let noteMsg :=
+            m!"All occurrences of an inductive type in the types of its constructors must specify its \
+              fixed parameters. Only indices can be omitted in a partial application of the type constructor."
+          throwNamedError lean.inductiveParamMissing (msg ++ .note noteMsg)
+        return TransformStep.done (mkAppN f args)
+      else
+        modify fun es => e :: es
+        return .continue
+    let popContainingExpr (e : Expr) : StateT (List Expr) MetaM TransformStep := do
+      modify fun es => es.drop 1
+      return .done e
+    transform ctorType (pre := visit) (post := popContainingExpr) |>.run' [ctorType]
+
+  throwUnexpectedResultingTypeMismatch (resultingType indFVar : Expr) (declName : Name) (ctorType : Syntax) := do
+    let lazyAppMsg := MessageData.ofLazyM do
+      if let some fvarId := indFVar.fvarId? then
+        if let some decl := (← getLCtx).find? fvarId then
+          if (← whnfD decl.type).isForall then
+            return m!" an application of"
+      return m!""
+    throwNamedErrorAt ctorType lean.ctorResultingTypeMismatch "Unexpected resulting type for constructor '{declName}': \
+      Expected{lazyAppMsg}{indentExpr indFVar}\nbut found{indentExpr resultingType}"
+
+  throwUnexpectedResultingTypeNotType (resultingType : Expr) (declName : Name) (ctorType : Syntax) := do
+    let lazyMsg := MessageData.ofLazyM do
+      let resultingTypeType ← inferType resultingType
+      return indentExpr resultingTypeType
+    throwNamedErrorAt ctorType lean.ctorResultingTypeMismatch "Unexpected resulting type for constructor '{declName}': \
+      Expected a type, but found{indentExpr resultingType}\nof type{lazyMsg}"
+
+@[builtin_inductive_elab Lean.Parser.Command.inductive, builtin_inductive_elab Lean.Parser.Command.classInductive]
+def elabInductiveCommand : InductiveElabDescr where
+  mkInductiveView (modifiers : Modifiers) (stx : Syntax) := do
+    let view ← inductiveSyntaxToView modifiers stx
+    return {
+      view
+      elabCtors := fun rs r params => do
+        let ctors ← elabCtors (rs.map (·.indFVar)) params r
+        return { ctors }
+    }
+
+end Lean.Elab.Command

backend/core/leanprover--lean4---v4.22.0/src/lean/Lean/Elab/InfoTree.lean

@@ -0,0 +1,9 @@
+/-
+Copyright (c) 2020 Wojciech Nawrocki. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+
+Authors: Wojciech Nawrocki, Leonardo de Moura, Sebastian Ullrich
+-/
+prelude
+import Lean.Elab.InfoTree.Types
+import Lean.Elab.InfoTree.Main