opaque Lean.diagnostics : Lean.Option Bool

opaque Lean.diagnostics.threshold : Lean.Option Nat

opaque Lean.maxHeartbeats : Lean.Option Nat

opaque Lean.Elab.async : Lean.Option Bool

opaque Lean.Elab.inServer : Lean.Option Bool

opaque Lean.internal.cmdlineSnapshots : Lean.Option Bool

Performance option used by cmdline driver.

def Lean.useDiagnosticMsg : MessageData

If the diagnostics option is not already set, gives a message explaining this option. Begins with a \n\n, so an error message can look like m!"some error occurred{useDiagnosticMsg}". The double newline gives better visual separation from the main error message

structure Lean.DeclNameGenerator : Type

Name generator that creates user-accessible names.

• namePrefix : Name
• idx : Nat
• parentIdxs : List Nat

def Lean.instInhabitedDeclNameGenerator.default : DeclNameGenerator

instance Lean.instInhabitedDeclNameGenerator : Inhabited DeclNameGenerator

def Lean.DeclNameGenerator.ofPrefix (namePrefix : Name) : DeclNameGenerator

def Lean.DeclNameGenerator.next (g : DeclNameGenerator) : DeclNameGenerator

def Lean.DeclNameGenerator.mkUniqueName (env : Environment) (g : DeclNameGenerator) («infix» : Name) : Name × DeclNameGenerator

Creates a user-accessible unique name of the following structure:

<name prefix>.<infix>_<numeric components>_...

Uniqueness is guaranteed for the current branch of elaboration. When entering parallelism and other branching elaboration steps, mkChild must be used (automatically done in wrapAsync*).

def Lean.DeclNameGenerator.mkChild (g : DeclNameGenerator) : DeclNameGenerator × DeclNameGenerator

class Lean.MonadDeclNameGenerator (m : Type → Type) : Type

• getDeclNGen : m DeclNameGenerator
• setDeclNGen : DeclNameGenerator → m Unit

instance Lean.instMonadDeclNameGeneratorOfMonadLift {m n : Type → Type} [MonadLift m n] [MonadDeclNameGenerator m] : MonadDeclNameGenerator n

def Lean.mkAuxDeclName {m : Type → Type} [Monad m] [MonadEnv m] [MonadDeclNameGenerator m] (kind : Name := `_aux) : m Name

Creates a new name for use as an auxiliary declaration that can be assumed to be globally unique.

Uniqueness is guaranteed for the current branch of elaboration. When entering parallelism and other branching elaboration steps, mkChild must be used (automatically done in wrapAsync*).

def Lean.withDeclNameForAuxNaming {m : Type → Type} {α : Type} [Monad m] [MonadFinally m] [MonadDeclNameGenerator m] (name : Name) (x : m α) : m α

Adjusts the namePrefix of getDeclNGen to the given name and resets the nested counter.

def Lean.Core.getMaxHeartbeats (opts : Options) : Nat

@[reducible, inline]

abbrev Lean.Core.InstantiateLevelCache : Type

structure Lean.Core.Cache : Type

Cache for the CoreM monad

• instLevelType : InstantiateLevelCache
• instLevelValue : InstantiateLevelCache

instance Lean.Core.instInhabitedCache : Inhabited Cache

def Lean.Core.instInhabitedCache.default : Cache

structure Lean.Core.State : Type

State for the CoreM monad.

• env : Environment

  Current environment.

• nextMacroScope : MacroScope

  Next macro scope. We use macro scopes to avoid accidental name capture.

• ngen : NameGenerator

  Name generator for producing unique FVarIds, MVarIds, and LMVarIds

• auxDeclNGen : DeclNameGenerator

  Name generator for creating persistent auxiliary declarations. Separate from ngen to keep numbers smaller and create user-accessible names.

• traceState : TraceState

  Trace messages

• cache : Cache

  Cache for instantiating universe polymorphic declarations.

• messages : MessageLog

  Message log.

• infoState : Elab.InfoState

  Info tree. We have the info tree here because we want to update it while adding attributes.

• snapshotTasks : Array (Language.SnapshotTask Language.SnapshotTree)

  Snapshot trees of asynchronous subtasks. As these are untyped and reported only at the end of the command's main elaboration thread, they are only useful for basic message log reporting; for incremental reporting and reuse within a long-running elaboration thread, types rooted in CommandParsedSnapshot need to be adjusted.

instance Lean.Core.instNonemptyState : Nonempty State

structure Lean.Core.Context : Type

Context for the CoreM monad.

• fileName : String

  Name of the file being compiled.

• fileMap : FileMap

  Auxiliary datastructure for converting String.Pos into Line/Column number.

• options : Options
• currRecDepth : Nat
• maxRecDepth : Nat
• ref : Syntax
• currNamespace : Name
• openDecls : List OpenDecl
• initHeartbeats : Nat
• maxHeartbeats : Nat
• quotContext : Name
• currMacroScope : MacroScope
• diag : Bool

  If diag := true, different parts of the system collect diagnostics. Use the set_option diag true to set it to true.

• cancelTk? : Option IO.CancelToken

  If set, used to cancel elaboration from outside when results are not needed anymore.

• suppressElabErrors : Bool

  If set (when showPartialSyntaxErrors is not set and parsing failed), suppresses most elaboration errors; see also logMessage below.

• inheritedTraceOptions : Std.HashSet Name

  Cache of Lean.inheritedTraceOptions.

instance Lean.Core.instNonemptyContext : Nonempty Context

@[reducible, inline]

abbrev Lean.Core.CoreM (α : Type) : Type

CoreM is a monad for manipulating the Lean environment. It is the base monad for MetaM. The main features it provides are:

• name generator state
• environment state
• Lean options context
• the current open namespace

@[always_inline]

instance Lean.Core.instMonadCoreM : Monad CoreM

instance Lean.Core.instInhabitedCoreM {α : Type} : Inhabited (CoreM α)

instance Lean.Core.instMonadRefCoreM : MonadRef CoreM

instance Lean.Core.instMonadEnvCoreM : MonadEnv CoreM

instance Lean.Core.instMonadOptionsCoreM : MonadOptions CoreM

instance Lean.Core.instMonadWithOptionsCoreM : MonadWithOptions CoreM

instance Lean.Core.instAddMessageContextCoreM : AddMessageContext CoreM

instance Lean.Core.instMonadNameGeneratorCoreM : MonadNameGenerator CoreM

instance Lean.Core.instMonadDeclNameGeneratorCoreM : MonadDeclNameGenerator CoreM

instance Lean.Core.instMonadRecDepthCoreM : MonadRecDepth CoreM

instance Lean.Core.instMonadResolveNameCoreM : MonadResolveName CoreM

def Lean.Core.withFreshMacroScope {α : Type} (x : CoreM α) : CoreM α

instance Lean.Core.instMonadQuotationCoreM : MonadQuotation CoreM

instance Lean.Core.instMonadInfoTreeCoreM : Elab.MonadInfoTree CoreM

@[inline]

def Lean.Core.modifyCache (f : Cache → Cache) : CoreM Unit

@[inline]

def Lean.Core.modifyInstLevelTypeCache (f : InstantiateLevelCache → InstantiateLevelCache) : CoreM Unit

@[inline]

def Lean.Core.modifyInstLevelValueCache (f : InstantiateLevelCache → InstantiateLevelCache) : CoreM Unit

def Lean.Core.instantiateTypeLevelParams (c : ConstantVal) (us : List Level) : CoreM Expr

def Lean.Core.instantiateValueLevelParams (c : ConstantInfo) (us : List Level) : CoreM Expr

@[inline]

def Lean.Core.liftIOCore {α : Type} (x : IO α) : CoreM α

instance Lean.Core.instMonadLiftIOCoreM : MonadLift IO CoreM

instance Lean.Core.instMonadTraceCoreM : MonadTrace CoreM

structure Lean.Core.SavedStateextends Lean.Core.State : Type

• env : Environment
• nextMacroScope : MacroScope
• ngen : NameGenerator
• auxDeclNGen : DeclNameGenerator
• traceState : TraceState
• cache : Cache
• messages : MessageLog
• infoState : Elab.InfoState
• snapshotTasks : Array (Language.SnapshotTask Language.SnapshotTree)
• passedHeartbeats : Nat

  Number of heartbeats passed inside withRestoreOrSaveFull, not used otherwise.

instance Lean.Core.instNonemptySavedState : Nonempty SavedState

def Lean.Core.saveState : CoreM SavedState

@[specialize #[]]

def Lean.Core.withRestoreOrSaveFull {α : Type} (reusableResult? : Option (α × SavedState)) (act : CoreM α) : CoreM (α × SavedState)

Incremental reuse primitive: if reusableResult? is none, runs act and returns its result together with the saved monadic state after act including the heartbeats used by it. If reusableResult? on the other hand is some (a, state), restores full state including heartbeats used and returns (a, state).

The intention is for steps that support incremental reuse to initially pass none as reusableResult? and store the result and state in a snapshot. In a further run, if reuse is possible, reusableResult? should be set to the previous result and state, ensuring that the state after running withRestoreOrSaveFull is identical in both runs. Note however that necessarily this is only an approximation in the case of heartbeats as heartbeats used by withRestoreOrSaveFull itself after calling act as well as by reuse-handling code such as the one supplying reusableResult? are not accounted for.

def Lean.Core.SavedState.restore (b : SavedState) : CoreM Unit

Restore backtrackable parts of the state.

def Lean.Core.mkFreshUserName (n : Name) : CoreM Name

Creates a name from n that is guaranteed to be unique. This is intended to be used for creating inaccessible user names for free variables and constants.

It works by adding a fresh macro scope to n. Applying Lean.Name.eraseMacroScopes to the resulting name yields n.

See also Lean.LocalContext.getUnusedName (for creating a new accessible user name that is unused in the local context) and Lean.Meta.mkFreshBinderNameForTactic (for creating names that are conditionally inaccessible, depending on the current value of the tactic.hygiene option).

@[inline]

def Lean.Core.CoreM.run {α : Type} (x : CoreM α) (ctx : Context) (s : State) : EIO Exception (α × State)

@[inline]

def Lean.Core.CoreM.run' {α : Type} (x : CoreM α) (ctx : Context) (s : State) : EIO Exception α

@[inline]

def Lean.Core.CoreM.toIO {α : Type} (x : CoreM α) (ctx : Context) (s : State) : IO (α × State)

@[inline]

def Lean.Core.CoreM.toIO' {α : Type} (x : CoreM α) (ctx : Context) (s : State) : IO α

def Lean.Core.withIncRecDepth {m : Type → Type u_1} {α : Type} [Monad m] [MonadControlT CoreM m] (x : m α) : m α

@[inline]

def Lean.Core.checkInterrupted : CoreM Unit

Throws an internal interrupt exception if cancellation has been requested. The exception is not caught by try catch but is intended to be caught by Command.withLoggingExceptions at the top level of elaboration. In particular, we want to skip producing further incremental snapshots after the exception has been thrown.

opaque Lean.Core.debug.moduleNameAtTimeout : Lean.Option Bool

def Lean.Core.throwMaxHeartbeat (moduleName optionName : Name) (max : Nat) : CoreM Unit

def Lean.Core.checkMaxHeartbeatsCore (moduleName : String) (optionName : Name) (max : Nat) : CoreM Unit

def Lean.Core.checkMaxHeartbeats (moduleName : String) : CoreM Unit

def Lean.Core.checkSystem (moduleName : String) : CoreM Unit

def Lean.Core.withCurrHeartbeats {m : Type → Type u_1} {α : Type} [Monad m] [MonadControlT CoreM m] (x : m α) : m α

def Lean.Core.setMessageLog (messages : MessageLog) : CoreM Unit

def Lean.Core.resetMessageLog : CoreM Unit

def Lean.Core.getMessageLog : CoreM MessageLog

def Lean.Core.getAndEmptyMessageLog : CoreM MessageLog

Returns the current log and then resets its messages while adjusting MessageLog.hadErrors. Used for incremental reporting during elaboration of a single command.

def Lean.Core.getAndEmptySnapshotTasks : CoreM (Array (Language.SnapshotTask Language.SnapshotTree))

Returns the current set of tasks added by logSnapshotTask and then resets it. When saving/restoring state of an action that may have logged such tasks during incremental reuse, this function must be used to store them in the corresponding snapshot tree; otherwise, they will leak outside and may be cancelled by a later step, potentially leading to inconsistent state being reused.

instance Lean.Core.instMonadLogCoreM : MonadLog CoreM

def Lean.Core.logSnapshotTask (task : Language.SnapshotTask Language.SnapshotTree) : CoreM Unit

Includes a given task (such as from wrapAsyncAsSnapshot) in the overall snapshot tree for this command's elaboration, making its result available to reporting and the language server. The reporter will not know about this snapshot tree node until the main elaboration thread for this command has finished so this function is not useful for incremental reporting within a longer elaboration thread but only for tasks that outlive it such as background kernel checking or proof elaboration.

def Lean.Core.wrapAsync {β α : Type} (act : α → CoreM β) (cancelTk? : Option IO.CancelToken) : CoreM (α → EIO Exception β)

Wraps the given action for use in EIO.asTask etc., discarding its final monadic state.

opaque Lean.Core.stderrAsMessages : Lean.Option Bool

Option for capturing output to stderr during elaboration.

def Lean.Core.mkSnapshot? (output : String) (ctx : Context) (st : State) (desc : String := by exact decl_name%.toString) : BaseIO (Option Language.SnapshotTree)

Creates snapshot reporting given withIsolatedStreams output and diagnostics and traces from the given state.

def Lean.Core.wrapAsyncAsSnapshot {α : Type} (act : α → CoreM Unit) (cancelTk? : Option IO.CancelToken) (desc : String := by exact decl_name%.toString) : CoreM (α → BaseIO Language.SnapshotTree)

Wraps the given action for use in BaseIO.asTask etc., discarding its final state except for logSnapshotTask tasks, which are reported as part of the returned tree. The given cancellation token, if any, should be stored in a SnapshotTask for the server to trigger it when the result is no longer needed.

@[inline]

def Lean.withAtLeastMaxRecDepth {m : Type → Type u_1} {α : Type} [MonadFunctorT CoreM m] (max : Nat) : m α → m α

@[inline]

def Lean.catchInternalId {m : Type u_1 → Type u_2} {α : Type u_1} [Monad m] [MonadExcept Exception m] (id : InternalExceptionId) (x : m α) (h : Exception → m α) : m α

@[inline]

def Lean.catchInternalIds {m : Type u_1 → Type u_2} {α : Type u_1} [Monad m] [MonadExcept Exception m] (ids : List InternalExceptionId) (x : m α) (h : Exception → m α) : m α

def Lean.Exception.isMaxHeartbeat (ex : Exception) : Bool

Return true if ex was generated by throwMaxHeartbeat. This function is a bit hackish. The heartbeat exception should probably be an internal exception. We used a similar hack at Exception.isMaxRecDepth

def Lean.mkArrow (d b : Expr) : CoreM Expr

Creates the expression d → b

def Lean.mkArrowN (ds : Array Expr) (e : Expr) : CoreM Expr

Iterated mkArrow, creates the expression a₁ → a₂ → … → aₙ → b. Also see arrowDomainsN.

def Lean.traceBlock {α : Type} (tag : String) (t : Task α) : CoreM α

If t has not finished yet, waits for it under an Elab.block trace node. Returns t's result.

opaque Lean.compileDeclsRef : IO.Ref (Array Name → CoreM Unit)

This ref exists to break a linking cycle that goes as follows:

• We start in Environment.lean, there we have functions referencing the compiler such as evalConst
• This pulls in the entire compiler transitively as well as all of its dependents
• The compiler relies on things like WHNF to inspect types
• WHNF in turn imports Environment

On Windows this causes a large amount of symbols to be included in one DLL as everything that imports the Environment instantly requires a large chunk of the Meta stack to be linked. This ref breaks the cycle by making compileDeclsImpl a "dynamic" call through the ref that is not visible to the linker. In the compiler there is a matching builtin_initialize to set this ref to the actual implementation of compileDeclsRef.

def Lean.compileDeclsImpl (declNames : Array Name) : CoreM Unit

def Lean.compileDecls (decls : Array Name) (logErrors : Bool := true) : CoreM Unit

def Lean.compileDecl (decl : Declaration) (logErrors : Bool := true) : CoreM Unit

def Lean.getDiag (opts : Options) : Bool

def Lean.isDiagnosticsEnabled : CoreM Bool

Return true if diagnostic information collection is enabled.

def Lean.ImportM.runCoreM {α : Type} (x : CoreM α) : ImportM α

def Lean.Exception.isRuntime (ex : Exception) : Bool

Return true if the exception was generated by one of our resource limits.

@[inline]

def Lean.Core.tryCatch {α : Type} (x : CoreM α) (h : Exception → CoreM α) : CoreM α

Custom try-catch for all monads based on CoreM. We usually don't want to catch "runtime exceptions" these monads, but on CommandElabM or, in specific cases, using tryCatchRuntimeEx. See issues #2775 and #2744 as well as MonadAlwaysExcept. Also, we never want to catch interrupt exceptions inside the elaborator.

@[inline]

def Lean.Core.tryCatchRuntimeEx {α : Type} (x : CoreM α) (h : Exception → CoreM α) : CoreM α

A variant of tryCatch that also catches runtime exception (see also tryCatch documentation). Like tryCatch, this function does not catch interrupt exceptions, which are not considered runtime exceptions.

instance Lean.instMonadExceptOfExceptionCoreM : MonadExceptOf Exception CoreM

class Lean.MonadRuntimeException (m : Type → Type) : Type 1

• tryCatchRuntimeEx {α : Type} (body : m α) (handler : Exception → m α) : m α

instance Lean.instMonadRuntimeExceptionCoreM : MonadRuntimeException CoreM

@[inline]

instance Lean.instMonadRuntimeExceptionReaderT {m : Type → Type} {ρ : Type} [MonadRuntimeException m] : MonadRuntimeException (ReaderT ρ m)

@[inline]

instance Lean.instMonadRuntimeExceptionStateRefT' {m : Type → Type} {ω σ : Type} [MonadRuntimeException m] : MonadRuntimeException (StateRefT' ω σ m)

@[inline]

def Lean.mapCoreM {m : Type → Type u_1} [MonadControlT CoreM m] [Monad m] (f : {α : Type} → CoreM α → CoreM α) {α : Type} (x : m α) : m α

def Lean.logMessageKind (kind : Name) : CoreM Bool

Returns true if the given message kind has not been reported in the message log, and then mark it as logged. Otherwise, returns false. We use this API to ensure we don't log the same kind of warning multiple times.

def Lean.enableRealizationsForConst (n : Name) : CoreM Unit

Allows realizeConst calls for the given declaration in all derived environment branches. Realizations will run using the given environment and options to ensure deterministic results. Note that while we check that the function isn't called before the declaration is actually added to the environment, we cannot automatically check that it isn't otherwise called too early in the sense that helper declarations and environment extension state that may be relevant to realizations may not have been added yet. We do check that we are not calling it from a different branch than c was added on, which would be definitely too late. Thus, this function should generally be called in elaborators calling addDecl (when that declaration is a plausible target for realization) at the latest possible point, i.e. at the very end of the elaborator or just before a first realization may be triggered if any.