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

full_name: Lean.Elab.Term.elabProp
code: @[builtin_term_elab «prop»] def elabProp : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.BuiltinTerm.0.Lean.Elab.Term.elabOptLevel
code: private def elabOptLevel (stx : Syntax) : TermElabM Level 
goal: Lean.Elab.TermElabM Lean.Level

full_name: Lean.Elab.Term.elabSort
code: @[builtin_term_elab «sort»] def elabSort : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabTypeStx
code: @[builtin_term_elab «type»] def elabTypeStx : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabPipeCompletion
code: @[builtin_term_elab «pipeCompletion»] def elabPipeCompletion : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabCompletion
code: @[builtin_term_elab «completion»] def elabCompletion : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabHole
code: @[builtin_term_elab «hole»] def elabHole : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabSyntheticHole
code: @[builtin_term_elab «syntheticHole»] def elabSyntheticHole : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabOmission
code: @[builtin_term_elab Lean.Parser.Term.omission] def elabOmission : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabLetMVar
code: @[builtin_term_elab «letMVar»] def elabLetMVar : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.BuiltinTerm.0.Lean.Elab.Term.getMVarFromUserName
code: private def getMVarFromUserName (ident : Syntax) : MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: Lean.Elab.Term.elabWaitIfTypeMVar
code: @[builtin_term_elab «waitIfTypeMVar»] def elabWaitIfTypeMVar : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabWaitIfTypeContainsMVar
code: @[builtin_term_elab «waitIfTypeContainsMVar»] def elabWaitIfTypeContainsMVar : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabWaitIfContainsMVar
code: @[builtin_term_elab «waitIfContainsMVar»] def elabWaitIfContainsMVar : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.BuiltinTerm.0.Lean.Elab.Term.mkTacticMVar
code: private def mkTacticMVar (type : Expr) (tacticCode : Syntax) : TermElabM Expr 
goal: Lean.Elab.TermElabM Lean.Expr

full_name: Lean.Elab.Term.debug.byAsSorry
code: register_builtin_option debug.byAsSorry : Bool := {
  defValue := false
  group    := "debug"
  descr    := "replace `by ..` blocks with `sorry` IF the expected type is a proposition"
}
goal: Lean.Option Bool

full_name: Lean.Elab.Term.initFn._@..lake.packages.lean4.src.lean.Lean.Elab.BuiltinTerm._hyg.2259
code: register_builtin_option debug.byAsSorry : Bool := {
  defValue := false
  group    := "debug"
  descr    := "replace `by ..` blocks with `sorry` IF the expected type is a proposition"
}
goal: IO (Lean.Option Bool)

full_name: Lean.Elab.Term.elabByTactic
code: @[builtin_term_elab byTactic] def elabByTactic : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabNoImplicitLambda
code: @[builtin_term_elab noImplicitLambda] def elabNoImplicitLambda : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabBadCDot
code: @[builtin_term_elab Lean.Parser.Term.cdot] def elabBadCDot : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabStrLit
code: @[builtin_term_elab str] def elabStrLit : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.BuiltinTerm.0.Lean.Elab.Term.mkFreshTypeMVarFor
code: private def mkFreshTypeMVarFor (expectedType? : Option Expr) : TermElabM Expr 
goal: Lean.Elab.TermElabM Lean.Expr

full_name: Lean.Elab.Term.elabNumLit
code: @[builtin_term_elab num] def elabNumLit : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabRawNatLit
code: @[builtin_term_elab rawNatLit] def elabRawNatLit : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabScientificLit
code: @[builtin_term_elab scientific]
def elabScientificLit : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabCharLit
code: @[builtin_term_elab char] def elabCharLit : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabQuotedName
code: @[builtin_term_elab quotedName] def elabQuotedName : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabDoubleQuotedName
code: @[builtin_term_elab doubleQuotedName] def elabDoubleQuotedName : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabDeclName
code: @[builtin_term_elab declName] def elabDeclName : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabWithDeclName
code: @[builtin_term_elab Parser.Term.withDeclName] def elabWithDeclName : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabTypeOf
code: @[builtin_term_elab typeOf] def elabTypeOf : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.BuiltinTerm.0.Lean.Elab.Term.mkSilentAnnotationIfHole
code: /--
  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 
goal: Lean.Elab.TermElabM Lean.Expr

full_name: Lean.Elab.Term.elabEnsureTypeOf
code: @[builtin_term_elab ensureTypeOf] def elabEnsureTypeOf : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabEnsureExpectedType
code: @[builtin_term_elab ensureExpectedType] def elabEnsureExpectedType : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabClear
code: @[builtin_term_elab clear] def elabClear : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabOpen
code: @[builtin_term_elab «open»] def elabOpen : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabSetOption
code: @[builtin_term_elab «set_option»] def elabSetOption : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lean.Elab.Term.elabWithAnnotateTerm
code: @[builtin_term_elab withAnnotateTerm] def elabWithAnnotateTerm : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.BuiltinTerm.0.Lean.Elab.Term.evalFilePathUnsafe
code: private unsafe def evalFilePathUnsafe (stx : Syntax) : TermElabM System.FilePath 
goal: Lean.Elab.TermElabM System.FilePath

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.BuiltinTerm.0.Lean.Elab.Term.evalFilePath
code: @[implemented_by evalFilePathUnsafe]
private opaque evalFilePath (stx : Syntax) : TermElabM System.FilePath
goal: Lean.Elab.TermElabM System.FilePath

full_name: Lean.Elab.Term.elabIncludeStr
code: @[builtin_term_elab includeStr] def elabIncludeStr : TermElab
  
goal: Lean.Elab.Term.TermElab