File: .lake/packages/lean4/src/lean/Lean/Elab/Quotation.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.floatOutAntiquotTerms
code: /-- `C[$(e)]` ~> `let a := e; C[$a]`. Used in the implementation of antiquot splices. -/
private partial def floatOutAntiquotTerms (stx : Syntax) : StateT (Syntax → TermElabM Syntax) TermElabM Syntax 
goal: StateT (Lean.Syntax → Lean.Elab.TermElabM Lean.Syntax) Lean.Elab.TermElabM Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.getSepFromSplice
code: private def getSepFromSplice (splice : Syntax) : String 
goal: String

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.getSepStxFromSplice
code: private def getSepStxFromSplice (splice : Syntax) : Syntax 
goal: Lean.Syntax

full_name: Lean.Elab.Term.Quotation.mkTuple
code: partial def mkTuple : Array Syntax → TermElabM Syntax
  
goal: Array Lean.Syntax → Lean.Elab.TermElabM Lean.Syntax

full_name: Lean.Elab.Term.Quotation.resolveSectionVariable.loop
code: def resolveSectionVariable (sectionVars : NameMap Name) (id : Name) : List (Name × List String) 
goal: Lean.Name → List String → List (Lean.Name × List String)

full_name: Lean.Elab.Term.Quotation.resolveSectionVariable
code: def resolveSectionVariable (sectionVars : NameMap Name) (id : Name) : List (Name × List String) 
goal: List (Lean.Name × List String)

full_name: Lean.Elab.Term.Quotation.ArrayStxBuilder
code: /-- Transform sequence of pushes and appends into acceptable code -/
def ArrayStxBuilder 
goal: Type

full_name: Lean.Elab.Term.Quotation.ArrayStxBuilder.empty
code: def empty : ArrayStxBuilder 
goal: Lean.Elab.Term.Quotation.ArrayStxBuilder

full_name: Lean.Elab.Term.Quotation.ArrayStxBuilder.build
code: def build : ArrayStxBuilder → Term
  
goal: Lean.Elab.Term.Quotation.ArrayStxBuilder → Lean.Term

full_name: Lean.Elab.Term.Quotation.ArrayStxBuilder.push
code: def push (b : ArrayStxBuilder) (elem : Syntax) : ArrayStxBuilder 
goal: Lean.Elab.Term.Quotation.ArrayStxBuilder

full_name: Lean.Elab.Term.Quotation.ArrayStxBuilder.append
code: def append (b : ArrayStxBuilder) (arr : Syntax) (appendName := ``Array.append) : ArrayStxBuilder 
goal: Lean.Elab.Term.Quotation.ArrayStxBuilder

full_name: Lean.Elab.Term.Quotation.ArrayStxBuilder.mkNode
code: def mkNode (b : ArrayStxBuilder) (k : SyntaxNodeKind) : TermElabM Term 
goal: Lean.Elab.TermElabM Lean.Term

full_name: Lean.Elab.Term.Quotation.tryAddSyntaxNodeKindInfo
code: def tryAddSyntaxNodeKindInfo (stx : Syntax) (k : SyntaxNodeKind) : TermElabM Unit 
goal: Lean.Elab.TermElabM Unit

full_name: Lean.Elab.Term.Quotation.«instQuotePreresolvedMkStr1_.lake»
code: instance : Quote Syntax.Preresolved 
goal: Lean.Quote Lean.Syntax.Preresolved

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.quoteSyntax
code: /-- Elaborate the content of a syntax quotation term -/
private partial def quoteSyntax : Syntax → TermElabM Term
  
goal: Lean.Syntax → Lean.Elab.TermElabM Lean.Term

full_name: Lean.Elab.Term.Quotation.addNamedQuotInfo
code: def addNamedQuotInfo (stx : Syntax) (k : SyntaxNodeKind) : TermElabM SyntaxNodeKind 
goal: Lean.Elab.TermElabM Lean.SyntaxNodeKind

full_name: Lean.Elab.Term.Quotation.getQuotKind
code: def getQuotKind (stx : Syntax) : TermElabM SyntaxNodeKind 
goal: Lean.Elab.TermElabM Lean.SyntaxNodeKind

full_name: Lean.Elab.Term.Quotation.mkSyntaxQuotation
code: def mkSyntaxQuotation (stx : Syntax) (kind : Name) : TermElabM Syntax 
goal: Lean.Elab.TermElabM Lean.Syntax

full_name: Lean.Elab.Term.Quotation.stxQuot.expand
code: def stxQuot.expand (stx : Syntax) : TermElabM Syntax 
goal: Lean.Elab.TermElabM Lean.Syntax

full_name: Lean.Elab.Term.Quotation.commandElab_stx_quot_
code: macro "elab_stx_quot" kind:ident : command =>
  `(@[builtin_term_elab $kind:ident] def elabQuot : TermElab := adaptExpander stxQuot.expand)
goal: Lean.ParserDescr

full_name: Lean.Elab.Term.Quotation.«_aux_.lake_packages_lean4_src_lean_Lean_Elab_Quotation___macroRules_Lean_Elab_Term_Quotation_commandElab_stx_quot__1»
code: macro "elab_stx_quot" kind:ident : command =>
  `(@[builtin_term_elab $kind:ident] def elabQuot : TermElab := adaptExpander stxQuot.expand)
goal: Lean.Macro

full_name: Lean.Elab.Term.Quotation.elabQuot._@..lake.packages.lean4.src.lean.Lean.Elab.Quotation._hyg.6421
code: elab_stx_quot Parser.Term.quot
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.Quotation.elabQuot._@..lake.packages.lean4.src.lean.Lean.Elab.Quotation._hyg.6428
code: elab_stx_quot Parser.Tactic.quot
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.Quotation.elabQuot._@..lake.packages.lean4.src.lean.Lean.Elab.Quotation._hyg.6435
code: elab_stx_quot Parser.Tactic.quotSeq
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.Quotation.elabQuot._@..lake.packages.lean4.src.lean.Lean.Elab.Quotation._hyg.6442
code: elab_stx_quot Parser.Term.dynamicQuot
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.Quotation.elabQuot._@..lake.packages.lean4.src.lean.Lean.Elab.Quotation._hyg.6449
code: elab_stx_quot Parser.Command.quot
goal: Lean.Elab.Term.TermElab

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.Alt
code: /-- an "alternative" of patterns plus right-hand side -/
private abbrev Alt 
goal: Type

full_name: Lean.Elab.Term.Quotation.HeadCheck
code: /--
  In a single match step, we match the first discriminant against the "head" of the first pattern of the first
  alternative. This datatype describes what kind of check this involves, which helps other patterns decide if
  they are covered by the same check and don't have to be checked again (see also `MatchResult`). -/
inductive HeadCheck where
  /-- match step that always succeeds: _, x, `($x), ... -/
  | unconditional
  /-- match step based on kind and, optionally, arity of discriminant
  If `arity` is given, that number of new discriminants is introduced. `covered` patterns should then introduce the
  same number of new patterns.
  We actually check the arity at run time only in the case of `null` nodes since it should otherwise by implied by
  the node kind.
  without arity: `($x:k)
  with arity: any quotation without an antiquotation head pattern -/
  | shape (k : List SyntaxNodeKind) (arity : Option Nat)
  /-- Match step that succeeds on `null` nodes of arity at least `numPrefix + numSuffix`, introducing discriminants
  for the first `numPrefix` children, one `null` node for those in between, and for the `numSuffix` last children.
  example: `([$x, $xs,*, $y]) is `slice 2 2` -/
  | slice (numPrefix numSuffix : Nat)
  /-- other, complicated match step that will probably only cover identical patterns
  example: antiquotation splices `($[...]*) -/
  | other (pat : Syntax)
goal: Type

full_name: Lean.Elab.Term.Quotation.HeadCheck.other
code: /--
  In a single match step, we match the first discriminant against the "head" of the first pattern of the first
  alternative. This datatype describes what kind of check this involves, which helps other patterns decide if
  they are covered by the same check and don't have to be checked again (see also `MatchResult`). -/
inductive HeadCheck where
  /-- match step that always succeeds: _, x, `($x), ... -/
  | unconditional
  /-- match step based on kind and, optionally, arity of discriminant
  If `arity` is given, that number of new discriminants is introduced. `covered` patterns should then introduce the
  same number of new patterns.
  We actually check the arity at run time only in the case of `null` nodes since it should otherwise by implied by
  the node kind.
  without arity: `($x:k)
  with arity: any quotation without an antiquotation head pattern -/
  | shape (k : List SyntaxNodeKind) (arity : Option Nat)
  /-- Match step that succeeds on `null` nodes of arity at least `numPrefix + numSuffix`, introducing discriminants
  for the first `numPrefix` children, one `null` node for those in between, and for the `numSuffix` last children.
  example: `([$x, $xs,*, $y]) is `slice 2 2` -/
  | slice (numPrefix numSuffix : Nat)
  /-- other, complicated match step that will probably only cover identical patterns
  example: antiquotation splices `($[...]*) -/
  | other (pat : Syntax)
goal: Lean.Elab.Term.Quotation.HeadCheck

full_name: Lean.Elab.Term.Quotation.HeadCheck.shape
code: /--
  In a single match step, we match the first discriminant against the "head" of the first pattern of the first
  alternative. This datatype describes what kind of check this involves, which helps other patterns decide if
  they are covered by the same check and don't have to be checked again (see also `MatchResult`). -/
inductive HeadCheck where
  /-- match step that always succeeds: _, x, `($x), ... -/
  | unconditional
  /-- match step based on kind and, optionally, arity of discriminant
  If `arity` is given, that number of new discriminants is introduced. `covered` patterns should then introduce the
  same number of new patterns.
  We actually check the arity at run time only in the case of `null` nodes since it should otherwise by implied by
  the node kind.
  without arity: `($x:k)
  with arity: any quotation without an antiquotation head pattern -/
  | shape (k : List SyntaxNodeKind) (arity : Option Nat)
  /-- Match step that succeeds on `null` nodes of arity at least `numPrefix + numSuffix`, introducing discriminants
  for the first `numPrefix` children, one `null` node for those in between, and for the `numSuffix` last children.
  example: `([$x, $xs,*, $y]) is `slice 2 2` -/
  | slice (numPrefix numSuffix : Nat)
  /-- other, complicated match step that will probably only cover identical patterns
  example: antiquotation splices `($[...]*) -/
  | other (pat : Syntax)
goal: Lean.Elab.Term.Quotation.HeadCheck

full_name: Lean.Elab.Term.Quotation.HeadCheck.unconditional
code: /--
  In a single match step, we match the first discriminant against the "head" of the first pattern of the first
  alternative. This datatype describes what kind of check this involves, which helps other patterns decide if
  they are covered by the same check and don't have to be checked again (see also `MatchResult`). -/
inductive HeadCheck where
  /-- match step that always succeeds: _, x, `($x), ... -/
  | unconditional
  /-- match step based on kind and, optionally, arity of discriminant
  If `arity` is given, that number of new discriminants is introduced. `covered` patterns should then introduce the
  same number of new patterns.
  We actually check the arity at run time only in the case of `null` nodes since it should otherwise by implied by
  the node kind.
  without arity: `($x:k)
  with arity: any quotation without an antiquotation head pattern -/
  | shape (k : List SyntaxNodeKind) (arity : Option Nat)
  /-- Match step that succeeds on `null` nodes of arity at least `numPrefix + numSuffix`, introducing discriminants
  for the first `numPrefix` children, one `null` node for those in between, and for the `numSuffix` last children.
  example: `([$x, $xs,*, $y]) is `slice 2 2` -/
  | slice (numPrefix numSuffix : Nat)
  /-- other, complicated match step that will probably only cover identical patterns
  example: antiquotation splices `($[...]*) -/
  | other (pat : Syntax)
goal: Lean.Elab.Term.Quotation.HeadCheck

full_name: Lean.Elab.Term.Quotation.HeadCheck.slice
code: /--
  In a single match step, we match the first discriminant against the "head" of the first pattern of the first
  alternative. This datatype describes what kind of check this involves, which helps other patterns decide if
  they are covered by the same check and don't have to be checked again (see also `MatchResult`). -/
inductive HeadCheck where
  /-- match step that always succeeds: _, x, `($x), ... -/
  | unconditional
  /-- match step based on kind and, optionally, arity of discriminant
  If `arity` is given, that number of new discriminants is introduced. `covered` patterns should then introduce the
  same number of new patterns.
  We actually check the arity at run time only in the case of `null` nodes since it should otherwise by implied by
  the node kind.
  without arity: `($x:k)
  with arity: any quotation without an antiquotation head pattern -/
  | shape (k : List SyntaxNodeKind) (arity : Option Nat)
  /-- Match step that succeeds on `null` nodes of arity at least `numPrefix + numSuffix`, introducing discriminants
  for the first `numPrefix` children, one `null` node for those in between, and for the `numSuffix` last children.
  example: `([$x, $xs,*, $y]) is `slice 2 2` -/
  | slice (numPrefix numSuffix : Nat)
  /-- other, complicated match step that will probably only cover identical patterns
  example: antiquotation splices `($[...]*) -/
  | other (pat : Syntax)
goal: Lean.Elab.Term.Quotation.HeadCheck

full_name: Lean.Elab.Term.Quotation.MatchResult.undecided
code: /-- Describe whether a pattern is covered by a head check (induced by the pattern itself or a different pattern). -/
inductive MatchResult where
  /-- Pattern agrees with head check, remove and transform remaining alternative.
  If `exhaustive` is `false`, *also* include unchanged alternative in the "no" branch. -/
  | covered (f : Alt → TermElabM Alt) (exhaustive : Bool)
  /-- Pattern disagrees with head check, include in "no" branch only -/
  | uncovered
  /-- Pattern is not quite sure yet; include unchanged in both branches -/
  | undecided
goal: Lean.Elab.Term.Quotation.MatchResult

full_name: Lean.Elab.Term.Quotation.MatchResult
code: /-- Describe whether a pattern is covered by a head check (induced by the pattern itself or a different pattern). -/
inductive MatchResult where
  /-- Pattern agrees with head check, remove and transform remaining alternative.
  If `exhaustive` is `false`, *also* include unchanged alternative in the "no" branch. -/
  | covered (f : Alt → TermElabM Alt) (exhaustive : Bool)
  /-- Pattern disagrees with head check, include in "no" branch only -/
  | uncovered
  /-- Pattern is not quite sure yet; include unchanged in both branches -/
  | undecided
goal: Type

full_name: Lean.Elab.Term.Quotation.MatchResult.uncovered
code: /-- Describe whether a pattern is covered by a head check (induced by the pattern itself or a different pattern). -/
inductive MatchResult where
  /-- Pattern agrees with head check, remove and transform remaining alternative.
  If `exhaustive` is `false`, *also* include unchanged alternative in the "no" branch. -/
  | covered (f : Alt → TermElabM Alt) (exhaustive : Bool)
  /-- Pattern disagrees with head check, include in "no" branch only -/
  | uncovered
  /-- Pattern is not quite sure yet; include unchanged in both branches -/
  | undecided
goal: Lean.Elab.Term.Quotation.MatchResult

full_name: Lean.Elab.Term.Quotation.MatchResult.covered
code: /-- Describe whether a pattern is covered by a head check (induced by the pattern itself or a different pattern). -/
inductive MatchResult where
  /-- Pattern agrees with head check, remove and transform remaining alternative.
  If `exhaustive` is `false`, *also* include unchanged alternative in the "no" branch. -/
  | covered (f : Alt → TermElabM Alt) (exhaustive : Bool)
  /-- Pattern disagrees with head check, include in "no" branch only -/
  | uncovered
  /-- Pattern is not quite sure yet; include unchanged in both branches -/
  | undecided
goal: Lean.Elab.Term.Quotation.MatchResult

full_name: Lean.Elab.Term.Quotation.instReprMatchResult
code: instance : Repr MatchResult 
goal: Repr Lean.Elab.Term.Quotation.MatchResult

full_name: Lean.Elab.Term.Quotation.HeadInfo.onMatch
code: /-- All necessary information on a pattern head. -/
structure HeadInfo where
  /-- check induced by the pattern -/
  check : HeadCheck
  /-- compute compatibility of pattern with given head check -/
  onMatch (taken : HeadCheck) : MatchResult
  /-- actually run the specified head check, with the discriminant bound to `__discr` -/
  doMatch (yes : (newDiscrs : List Term) → TermElabM Term) (no : TermElabM Term) : TermElabM Term
goal: Lean.Elab.Term.Quotation.MatchResult

full_name: Lean.Elab.Term.Quotation.HeadInfo.check
code: /-- All necessary information on a pattern head. -/
structure HeadInfo where
  /-- check induced by the pattern -/
  check : HeadCheck
  /-- compute compatibility of pattern with given head check -/
  onMatch (taken : HeadCheck) : MatchResult
  /-- actually run the specified head check, with the discriminant bound to `__discr` -/
  doMatch (yes : (newDiscrs : List Term) → TermElabM Term) (no : TermElabM Term) : TermElabM Term
goal: Lean.Elab.Term.Quotation.HeadCheck

full_name: Lean.Elab.Term.Quotation.HeadInfo
code: /-- All necessary information on a pattern head. -/
structure HeadInfo where
  /-- check induced by the pattern -/
  check : HeadCheck
  /-- compute compatibility of pattern with given head check -/
  onMatch (taken : HeadCheck) : MatchResult
  /-- actually run the specified head check, with the discriminant bound to `__discr` -/
  doMatch (yes : (newDiscrs : List Term) → TermElabM Term) (no : TermElabM Term) : TermElabM Term
goal: Type

full_name: Lean.Elab.Term.Quotation.HeadInfo.doMatch
code: /-- All necessary information on a pattern head. -/
structure HeadInfo where
  /-- check induced by the pattern -/
  check : HeadCheck
  /-- compute compatibility of pattern with given head check -/
  onMatch (taken : HeadCheck) : MatchResult
  /-- actually run the specified head check, with the discriminant bound to `__discr` -/
  doMatch (yes : (newDiscrs : List Term) → TermElabM Term) (no : TermElabM Term) : TermElabM Term
goal: Lean.Elab.TermElabM Lean.Term

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.noOpMatchAdaptPats
code: /-- Adapt alternatives that do not introduce new discriminants in `doMatch`, but are covered by those that do so. -/
private def noOpMatchAdaptPats : HeadCheck → Alt → Alt
  
goal: Lean.Elab.Term.Quotation.HeadCheck → Lean.Elab.Term.Quotation.Alt → Lean.Elab.Term.Quotation.Alt

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.adaptRhs
code: private def adaptRhs (fn : Term → TermElabM Term) : Alt → TermElabM Alt
  
goal: Lean.Elab.Term.Quotation.Alt → Lean.Elab.TermElabM Lean.Elab.Term.Quotation.Alt

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.getHeadInfo
code: private partial def getHeadInfo (alt : Alt) : TermElabM HeadInfo 
goal: Lean.Elab.TermElabM Lean.Elab.Term.Quotation.HeadInfo

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.deduplicate
code: /-- Bind right-hand side to new `let_delayed` decl in order to prevent code duplication -/
private def deduplicate (floatedLetDecls : Array Syntax) : Alt → TermElabM (Array Syntax × Alt)
  -- NOTE: new macro scope so that introduced bindings do not collide
  
goal: Lean.Elab.Term.Quotation.Alt → Lean.Elab.TermElabM (Array Lean.Syntax × Lean.Elab.Term.Quotation.Alt)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.compileStxMatch
code: private partial def compileStxMatch (discrs : List Term) (alts : List Alt) : TermElabM Syntax 
goal: Lean.Elab.TermElabM Lean.Syntax

full_name: Lean.Elab.Term.Quotation.IdxSet
code: abbrev IdxSet 
goal: Type

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.hasNoErrorIfUnused
code: private partial def hasNoErrorIfUnused : Syntax → Bool
  
goal: Lean.Syntax → Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.markRhss
code: /--
Given `rhss` the right-hand-sides of a `match`-syntax notation,
We tag them with with fresh identifiers `alt_idx`. We use them to detect whether an alternative
has been used or not.
The result is a triple `(altIdxMap, ignoreIfUnused, rhssNew)` where
- `altIdxMap` is a mapping from the `alt_idx` identifiers to right-hand-side indices.
  That is, the map contains the entry `alt_idx ↦ i` if `alt_idx` was used to mark `rhss[i]`.
- `i ∈ ignoreIfUnused` if `rhss[i]` is marked with `no_error_if_unused%`
- `rhssNew` is the updated array of right-hand-sides.
-/
private def markRhss (rhss : Array Term) : TermElabM (NameMap Nat × IdxSet × Array Term) 
goal: Lean.Elab.TermElabM (Lean.NameMap Nat × Lean.Elab.Term.Quotation.IdxSet × Array Lean.Term)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.findUsedAlts.go
code: /--
Given the mapping `idxMap` built using `markRhss`, and `stx` the resulting syntax after expanding `match`-syntax,
return the pair `(stxNew, usedSet)`, where `stxNew` is `stx` after removing the `alt_idx` markers in `idxMap`,
and `i ∈ usedSet` if `stx` contains an `alt_idx` s.t. `alt_idx ↦ i` is in `idxMap`.
That is, `usedSet` contains the index of the used match-syntax right-hand-sides.
-/
private partial def findUsedAlts (stx : Syntax) (altIdxMap : NameMap Nat) : TermElabM (Syntax × IdxSet) 
goal: StateRefT' IO.RealWorld Lean.Elab.Term.Quotation.IdxSet Lean.Elab.TermElabM Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.findUsedAlts
code: /--
Given the mapping `idxMap` built using `markRhss`, and `stx` the resulting syntax after expanding `match`-syntax,
return the pair `(stxNew, usedSet)`, where `stxNew` is `stx` after removing the `alt_idx` markers in `idxMap`,
and `i ∈ usedSet` if `stx` contains an `alt_idx` s.t. `alt_idx ↦ i` is in `idxMap`.
That is, `usedSet` contains the index of the used match-syntax right-hand-sides.
-/
private partial def findUsedAlts (stx : Syntax) (altIdxMap : NameMap Nat) : TermElabM (Syntax × IdxSet) 
goal: Lean.Elab.TermElabM (Lean.Syntax × Lean.Elab.Term.Quotation.IdxSet)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.checkUnusedAlts
code: /--
Check whether `stx` has unused alternatives, and remove the auxiliary `alt_idx` markers from it (see `markRhss`).
The parameter `alts` provides position information for alternatives.
`altIdxMap` and `ignoreIfUnused` are the map and set built using `markRhss`.
-/
private def checkUnusedAlts (stx : Syntax) (alts : Array Syntax) (altIdxMap : NameMap Nat) (ignoreIfUnused : IdxSet) : TermElabM Syntax 
goal: Lean.Elab.TermElabM Lean.Syntax

full_name: Lean.Elab.Term.Quotation.match_syntax.expand
code: def match_syntax.expand (stx : Syntax) : TermElabM Syntax 
goal: Lean.Elab.TermElabM Lean.Syntax

full_name: Lean.Elab.Term.Quotation.elabMatchSyntax
code: @[builtin_term_elab «match»] def elabMatchSyntax : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.Quotation.elabNoErrorIfUnused
code: @[builtin_term_elab noErrorIfUnused] def elabNoErrorIfUnused : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.Quotation.initFn._@..lake.packages.lean4.src.lean.Lean.Elab.Quotation._hyg.16968
code: builtin_initialize
  registerTraceClass `Elab.match_syntax
  registerTraceClass `Elab.match_syntax.alt (inherited := true)
  registerTraceClass `Elab.match_syntax.result (inherited := true)
  registerTraceClass `Elab.match_syntax.onMatch
goal: IO Unit