ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/lean4/src/lean/lake/Lake/Util/Message.lean

full_name: Lake.mkParserErrorMessage
code: def mkParserErrorMessage (ictx : InputContext) (s : ParserState) (e : Parser.Error) : Message 
goal: Lean.Message

full_name: Lake.mkExceptionMessage
code: def mkExceptionMessage (ictx : InputContext) (e : Exception) : Message 
goal: Lean.Message

full_name: Lake.mkMessageNoPos
code: def mkMessageNoPos (ictx : InputContext) (data : MessageData) (severity := MessageSeverity.error) : Message 
goal: Lean.Message

full_name: Lake.mkMessageStringCore
code: def mkMessageStringCore
  (severity : MessageSeverity)
  (fileName caption body : String)
  (pos : Position) (endPos? : Option Position := none)
  (infoWithPos := false)
: String 
goal: String

full_name: Lake.mkMessageString
code: def mkMessageString (msg : Message) (includeEndPos := false) (infoWithPos := false) : BaseIO String 
goal: BaseIO String

full_name: Lake.mkMessageLogString
code: def mkMessageLogString (log : MessageLog) : BaseIO String 
goal: BaseIO String
File: .lake/packages/lean4/src/lean/lake/Lake/Util/JsonObject.lean

full_name: Lake.JsonObject
code: /-- A JSON object (`Json.obj` data). -/
abbrev JsonObject 
goal: Type

full_name: Lake.JsonObject.mk
code: @[inline] def mk (val : RBNode String (fun _ => Json)) : JsonObject 
goal: Lake.JsonObject

full_name: Lake.JsonObject.toJson
code: @[inline] protected def toJson (obj : JsonObject) : Json 
goal: Lean.Json

full_name: Lake.JsonObject.instCoeJson
code: instance : Coe JsonObject Json 
goal: Coe Lake.JsonObject Lean.Json

full_name: Lake.JsonObject.instToJson
code: instance : ToJson JsonObject 
goal: Lean.ToJson Lake.JsonObject

full_name: Lake.JsonObject.fromJson?
code: @[inline] protected def fromJson? (json : Json) : Except String JsonObject 
goal: Except String Lake.JsonObject

full_name: Lake.JsonObject.instFromJson
code: instance : FromJson JsonObject 
goal: Lean.FromJson Lake.JsonObject

full_name: Lake.JsonObject.insert
code: @[inline] nonrec def insert [ToJson α] (obj : JsonObject) (prop : String) (val : α) : JsonObject 
goal: Lake.JsonObject

full_name: Lake.JsonObject.insertSome
code: @[inline] def insertSome [ToJson α] (obj : JsonObject) (prop : String) (val? : Option α) : JsonObject 
goal: Lake.JsonObject

full_name: Lake.JsonObject.erase
code: nonrec def erase (obj : JsonObject) (prop : String) : JsonObject 
goal: Lake.JsonObject

full_name: Lake.JsonObject.getJson?
code: @[inline] def getJson? (obj : JsonObject) (prop : String) : Option Json 
goal: Option Lean.Json

full_name: Lake.JsonObject.get
code: @[inline] def get [FromJson α] (obj : JsonObject) (prop : String) : Except String α 
goal: Except String α

full_name: Lake.JsonObject.get?
code: @[inline] def get? [FromJson α] (obj : JsonObject) (prop : String) : Except String (Option α) 
goal: Except String (Option α)

full_name: Lake.JsonObject.getD
code: @[macro_inline] def getD [FromJson α] (obj : JsonObject) (prop : String) (default : α) : Except String α 
goal: Except String α
File: .lake/packages/lean4/src/lean/lake/Lake/Util/Task.lean

full_name: Lake.«instMonadTask_.lake»
code: instance : Monad Task 
goal: Monad Task

full_name: Lake.ETask
code: abbrev ETask ε 
goal: Type u_1

full_name: Lake.OptionTask
code: abbrev OptionTask 
goal: Type u_1

full_name: Lake.BaseIOTask
code: def BaseIOTask 
goal: Type u_1

full_name: Lake.instMonadBaseIOTask
code: instance : Monad BaseIOTask 
goal: Monad Lake.BaseIOTask

full_name: Lake.instInhabitedBaseIOTask
code: instance [Inhabited α] : Inhabited (BaseIOTask α) 
goal: Inhabited (Lake.BaseIOTask α)

full_name: Lake.EIOTask
code: abbrev EIOTask ε 
goal: Type u_1

full_name: Lake.OptionIOTask
code: abbrev OptionIOTask 
goal: Type u_1

full_name: Lake.instInhabitedOptionIOTask
code: instance : Inhabited (OptionIOTask α) 
goal: Inhabited (Lake.OptionIOTask α)
File: .lake/packages/lean4/src/lean/lake/Lake/Util/Lock.lean

full_name: Lake.busyAcquireLockFile
code: @[inline] partial def busyAcquireLockFile (lockFile : FilePath) : IO PUnit 
goal: IO PUnit

full_name: Lake.busyAcquireLockFile.busyLoop
code: @[inline] partial def busyAcquireLockFile (lockFile : FilePath) : IO PUnit 
goal: IO PUnit

full_name: Lake.withLockFile
code: /-- Busy wait to acquire the lock of `lockFile`, run `act`, and then release the lock. -/
@[inline] def withLockFile [Monad m] [MonadFinally m] [MonadLiftT IO m] (lockFile : FilePath) (act : m α) : m α 
goal: m α
File: .lake/packages/lean4/src/lean/lake/Lake/Util/Sugar.lean

full_name: Lake.«_aux_.lake_packages_lean4_src_lean_lake_Lake_Util_Sugar___macroRules_Lake_termTry_Else__1»
code: macro "try " x:term " else " y:term : term =>
  ``($x <|> $y)
goal: Lean.Macro

full_name: Lake.termTry_Else_
code: macro "try " x:term " else " y:term : term =>
  ``($x <|> $y)
goal: Lean.ParserDescr

full_name: Lake.doElemTry_Else_
code: macro "try " x:doSeq " else " y:doSeq : doElem =>
  `(doElem| (do $x) <|> (do $y))
goal: Lean.ParserDescr

full_name: Lake.«_aux_.lake_packages_lean4_src_lean_lake_Lake_Util_Sugar___macroRules_Lake_doElemTry_Else__1»
code: macro "try " x:doSeq " else " y:doSeq : doElem =>
  `(doElem| (do $x) <|> (do $y))
goal: Lean.Macro
File: .lake/packages/lean4/src/lean/lake/Lake/Util/Opaque.lean

full_name: Lake.«_aux_.lake_packages_lean4_src_lean_lake_Lake_Util_Opaque___macroRules_Lake_declareOpaqueType_1»
code: macro (name := declareOpaqueType)
doc?:optional(docComment)  "declare_opaque_type " id:ident bs:binder* : command => do
  let (bs, args) ← expandBinders bs
  let nonemptyTypeId := id.getId.modifyBase (· ++ `nonemptyType)
  let nonemptyType := mkIdentFrom id nonemptyTypeId
  let nonemptyTypeApp := Syntax.mkApp nonemptyType args
  `(
  opaque $nonemptyType $[$bs]* : NonemptyType.{0}
  $[$doc?:docComment]? def $id $[$bs]* : Type := $nonemptyTypeApp |>.type
  instance : Nonempty $(Syntax.mkApp id args) :=  $nonemptyTypeApp |>.property
  )
goal: Lean.Macro

full_name: Lake.declareOpaqueType
code: macro (name := declareOpaqueType)
doc?:optional(docComment)  "declare_opaque_type " id:ident bs:binder* : command => do
  let (bs, args) ← expandBinders bs
  let nonemptyTypeId := id.getId.modifyBase (· ++ `nonemptyType)
  let nonemptyType := mkIdentFrom id nonemptyTypeId
  let nonemptyTypeApp := Syntax.mkApp nonemptyType args
  `(
  opaque $nonemptyType $[$bs]* : NonemptyType.{0}
  $[$doc?:docComment]? def $id $[$bs]* : Type := $nonemptyTypeApp |>.type
  instance : Nonempty $(Syntax.mkApp id args) :=  $nonemptyTypeApp |>.property
  )
goal: Lean.ParserDescr

full_name: Lake.hydrateOpaqueType
code: macro (name := hydrateOpaqueType)
"hydrate_opaque_type " oty:ident ty:ident args:ident* : command =>
  let mk := mkIdent `mk
  let unsafeMk := mkIdent `unsafeMk
  let get := mkIdent `get
  let unsafeGet := mkIdent `unsafeGet
  `(
  namespace $oty
  unsafe def $unsafeMk : $ty $args* → $oty $args* := unsafeCast
  @[implemented_by $unsafeMk] opaque $mk : $ty $args* → $oty $args*
  instance : Coe ($ty $args*) ($oty $args*) := ⟨$mk⟩

  unsafe def $unsafeGet : $oty $args* → $ty $args* := unsafeCast
  @[implemented_by $unsafeGet] opaque $get $[{$args}]* : $oty $args* → $ty $args*
  instance : Coe ($oty $args*) ($ty $args*) := ⟨$get⟩

  instance [Inhabited ($ty $args*)] : Inhabited ($oty $args*) := ⟨$mk default⟩
  end $oty
  )
goal: Lean.ParserDescr

full_name: Lake.«_aux_.lake_packages_lean4_src_lean_lake_Lake_Util_Opaque___macroRules_Lake_hydrateOpaqueType_1»
code: macro (name := hydrateOpaqueType)
"hydrate_opaque_type " oty:ident ty:ident args:ident* : command =>
  let mk := mkIdent `mk
  let unsafeMk := mkIdent `unsafeMk
  let get := mkIdent `get
  let unsafeGet := mkIdent `unsafeGet
  `(
  namespace $oty
  unsafe def $unsafeMk : $ty $args* → $oty $args* := unsafeCast
  @[implemented_by $unsafeMk] opaque $mk : $ty $args* → $oty $args*
  instance : Coe ($ty $args*) ($oty $args*) := ⟨$mk⟩

  unsafe def $unsafeGet : $oty $args* → $ty $args* := unsafeCast
  @[implemented_by $unsafeGet] opaque $get $[{$args}]* : $oty $args* → $ty $args*
  instance : Coe ($oty $args*) ($ty $args*) := ⟨$get⟩

  instance [Inhabited ($ty $args*)] : Inhabited ($oty $args*) := ⟨$mk default⟩
  end $oty
  )
goal: Lean.Macro
File: .lake/packages/lean4/src/lean/lake/Lake/Util/Error.lean

full_name: Lake.MonadError.error
code: class MonadError (m : Type u → Type v) where
  error {α : Type u} : String → m α
goal: String → m α

full_name: Lake.MonadError
code: class MonadError (m : Type u → Type v) where
  error {α : Type u} : String → m α
goal: Type (max (u + 1) v)

full_name: Lake.instMonadErrorOfMonadLift
code: instance [MonadLift m n] [MonadError m] : MonadError n 
goal: Lake.MonadError n

full_name: Lake.instMonadErrorIO
code: instance : MonadError IO 
goal: Lake.MonadError IO

full_name: Lake.instMonadErrorEIOString
code: instance : MonadError (EIO String) 
goal: Lake.MonadError (EIO String)

full_name: Lake.instMonadErrorExceptString
code: instance : MonadError (Except String) 
goal: Lake.MonadError (Except String)

full_name: Lake.MonadError.runEIO
code: /--
Perform an EIO action.
If it throws an error, invoke `error` with its string representation.
-/
@[inline] protected def MonadError.runEIO [Monad m]
[MonadError m] [MonadLiftT BaseIO m] [ToString ε] (x : EIO ε α) : m α 
goal: m α

full_name: Lake.MonadError.runIO
code: /--
Perform an IO action.
If it throws an error, invoke `error` with its string representation.
-/
@[inline] protected def MonadError.runIO
[Monad m] [MonadError m] [MonadLiftT BaseIO m] (x : IO α) : m α 
goal: m α
File: .lake/packages/lean4/src/lean/lake/Lake/Util/Lift.lean

full_name: Lake.«instMonadLiftTOfMonadLift_.lake»
code: /-- Ensure direct lifts are preferred over indirect ones. -/
instance (priority := high) [MonadLift α β] : MonadLiftT α β 
goal: MonadLiftT α β

full_name: Lake.«instMonadLiftTIdOfPure_.lake»
code: instance [Pure m] : MonadLiftT Id m 
goal: MonadLiftT Id m

full_name: Lake.«instMonadLiftTOptionOfAlternative_.lake»
code: instance [Alternative m] : MonadLiftT Option m 
goal: MonadLiftT Option m

full_name: Lake.«instMonadLiftTExceptOfPureOfMonadExceptOf_.lake»
code: instance [Pure m] [MonadExceptOf ε m] : MonadLiftT (Except ε) m 
goal: MonadLiftT (Except ε) m

full_name: Lake.«instMonadLiftTReaderTOfBindOfMonadReaderOf_.lake»
code: instance [Bind m] [MonadReaderOf ρ m] [MonadLiftT n m] : MonadLiftT (ReaderT ρ n) m 
goal: MonadLiftT (ReaderT ρ n) m

full_name: Lake.«instMonadLiftTStateTOfMonadOfMonadStateOf_.lake»
code: instance [Monad m] [MonadStateOf σ m] [MonadLiftT n m] : MonadLiftT (StateT σ n) m 
goal: MonadLiftT (StateT σ n) m

full_name: Lake.«instMonadLiftTOptionTOfMonadOfAlternative_.lake»
code: instance [Monad m] [Alternative m] [MonadLiftT n m] : MonadLiftT (OptionT n) m 
goal: MonadLiftT (OptionT n) m

full_name: Lake.«instMonadLiftTExceptTOfMonadOfMonadExceptOf_.lake»
code: instance [Monad m] [MonadExceptOf ε m] [MonadLiftT n m] : MonadLiftT (ExceptT ε n) m 
goal: MonadLiftT (ExceptT ε n) m

full_name: Lake.«instMonadLiftTEIOOfMonadOfMonadExceptOfOfBaseIO_.lake»
code: instance [Monad m] [MonadExceptOf ε m] [MonadLiftT BaseIO m] : MonadLiftT (EIO ε) m 
goal: MonadLiftT (EIO ε) m
File: .lake/packages/lean4/src/lean/lake/Lake/Util/StoreInsts.lean

full_name: Lake.«instMonadDStoreStateTDRBMapOfMonadOfEqOfCmpWrt_.lake»
code: instance [Monad m] [EqOfCmpWrt κ β cmp] : MonadDStore κ β (StateT (DRBMap κ β cmp) m) 
goal: Lake.MonadDStore κ β (StateT (Lake.DRBMap κ β cmp) m)

full_name: Lake.«instMonadStoreStateTRBMapOfMonad_.lake»
code: instance [Monad m] : MonadStore κ α (StateT (RBMap κ α cmp) m) 
goal: Lake.MonadStore κ α (StateT (Lean.RBMap κ α cmp) m)

full_name: Lake.«instMonadStoreStateTRBArrayOfMonad_.lake»
code: instance [Monad m] : MonadStore κ α (StateT (RBArray κ α cmp) m) 
goal: Lake.MonadStore κ α (StateT (Lake.RBArray κ α cmp) m)

full_name: Lake.«instMonadStoreNameStateTNameMapOfMonad_.lake»
code: instance [Monad m] : MonadStore Name α (StateT (NameMap α) m) 
goal: Lake.MonadStore Lean.Name α (StateT (Lean.NameMap α) m)

full_name: Lake.«instMonadStore1OfOfMonadDStoreOfFamilyOut_.lake»
code: @[inline] instance [MonadDStore κ β m] [t : FamilyOut β k α] : MonadStore1Of k α m 
goal: Lake.MonadStore1Of k α m
File: .lake/packages/lean4/src/lean/lake/Lake/Util/Name.lean

full_name: Lake.stringToLegalOrSimpleName
code: /--
First tries to convert a string into a legal name.
If that fails, defaults to making it a simple name (e.g., `Lean.Name.mkSimple`).
-/
def stringToLegalOrSimpleName (s : String) : Name 
goal: Lake.Name

full_name: Lake.NameMap.empty
code: @[inline] def NameMap.empty : NameMap α 
goal: Lake.NameMap α

full_name: Lake.«instForInNameMapProdName_.lake»
code: instance : ForIn m (NameMap α) (Name × α) 
goal: ForIn m (Lake.NameMap α) (Lake.Name × α)

full_name: Lake.«instCoeRBMapNameQuickCmpNameMap_.lake»
code: instance : Coe (RBMap Name α Name.quickCmp) (NameMap α) 
goal: Coe (Lean.RBMap Lake.Name α Lean.Name.quickCmp) (Lake.NameMap α)

full_name: Lake.OrdNameMap
code: abbrev OrdNameMap α 
goal: Type u_1

full_name: Lake.OrdNameMap.empty
code: @[inline] def OrdNameMap.empty : OrdNameMap α 
goal: Lake.OrdNameMap α

full_name: Lake.mkOrdNameMap
code: @[inline] def mkOrdNameMap (α : Type) : OrdNameMap α 
goal: Lake.OrdNameMap α

full_name: Lake.DNameMap
code: abbrev DNameMap α 
goal: Type u_1

full_name: Lake.DNameMap.empty
code: @[inline] def DNameMap.empty : DNameMap α 
goal: Lake.DNameMap α

full_name: Lake.«instToJsonNameMap_.lake»
code: instance [ToJson α] : ToJson (NameMap α) 
goal: Lean.ToJson (Lake.NameMap α)

full_name: Lake.«instFromJsonNameMap_.lake»
code: instance [FromJson α] : FromJson (NameMap α) 
goal: Lean.FromJson (Lake.NameMap α)

full_name: Lake.Name.beq_false
code: @[simp] protected theorem beq_false (m n : Name) : (m == n) = false ↔ ¬ (m = n) 
goal: (m == n) = false ↔ ¬m = n

full_name: Lake.Name.isPrefixOf_self
code: @[simp] theorem isPrefixOf_self {n : Name} : n.isPrefixOf n 
goal: n.isPrefixOf n = true

full_name: Lake.Name.isPrefixOf_append
code: @[simp] theorem isPrefixOf_append {n m : Name} : ¬ n.hasMacroScopes → ¬ m.hasMacroScopes → n.isPrefixOf (n ++ m) 
goal: ¬n.hasMacroScopes = true → ¬m.hasMacroScopes = true → n.isPrefixOf (n ++ m) = true

full_name: Lake.Name.quickCmpAux_iff_eq
code: @[simp] theorem quickCmpAux_iff_eq : ∀ {n n'}, quickCmpAux n n' = .eq ↔ n = n'

goal: n.quickCmpAux n' = Ordering.eq ↔ n = n'

full_name: Lake.Name.«instLawfulCmpEqNameQuickCmpAux_.lake»
code: instance : LawfulCmpEq Name quickCmpAux 
goal: Lake.LawfulCmpEq Lake.Name Lean.Name.quickCmpAux

full_name: Lake.Name.eq_of_quickCmp
code: theorem eq_of_quickCmp {n n' : Name} : n.quickCmp n' = .eq → n = n' 
goal: n.quickCmp n' = Ordering.eq → n = n'

full_name: Lake.Name.quickCmp_rfl
code: theorem quickCmp_rfl {n : Name} : n.quickCmp n = .eq 
goal: n.quickCmp n = Ordering.eq

full_name: Lake.Name.«instLawfulCmpEqNameQuickCmp_.lake»
code: instance : LawfulCmpEq Name Name.quickCmp 
goal: Lake.LawfulCmpEq Lake.Name Lean.Name.quickCmp

full_name: Lake.Name.quoteFrom
code: def quoteFrom (ref : Syntax) (n : Name) : Term 
goal: Lean.Term
File: .lake/packages/lean4/src/lean/lake/Lake/Load/Lean.lean

full_name: Lake.loadLeanConfig
code: /--
Elaborate a Lean configuration file into a `Package`.
The resulting package does not yet include any dependencies.
-/
def loadLeanConfig (cfg : LoadConfig)
: LogIO (Package × Environment) 
goal: Lake.LogIO (Lake.Package × Lean.Environment)
File: .lake/packages/lean4/src/lean/lake/Lake/Load/Package.lean

full_name: Lake.configFileExists
code: /--
Return whether a configuration file with the given name
and/or a supported extension exists.
-/
def configFileExists (cfgFile : FilePath) : BaseIO Bool 
goal: BaseIO Bool

full_name: Lake.loadPackageCore
code: /--
Loads a Lake package configuration (either Lean or TOML).
The resulting package does not yet include any dependencies.
-/
def loadPackageCore
  (name : String) (cfg : LoadConfig)
: LogIO (Package × Option Environment) 
goal: Lake.LogIO (Lake.Package × Option Lean.Environment)

full_name: Lake.loadPackage
code: /-- Loads a Lake package as a single independent object (without dependencies). -/
def loadPackage (config : LoadConfig) : LogIO Package 
goal: Lake.LogIO Lake.Package
File: .lake/packages/lean4/src/lean/lake/Lake/Load/Workspace.lean

full_name: Lake.loadWorkspaceRoot
code: /--
Load a `Workspace` for a Lake package by elaborating its configuration file.
Does not resolve dependencies.
-/
def loadWorkspaceRoot (config : LoadConfig) : LogIO Workspace 
goal: Lake.LogIO Lake.Workspace

full_name: Lake.loadWorkspace
code: /--
Load a `Workspace` for a Lake package by
elaborating its configuration file and resolving its dependencies.
If `updateDeps` is true, updates the manifest before resolving dependencies.
-/
def loadWorkspace (config : LoadConfig) (updateDeps := false) : LogIO Workspace 
goal: Lake.LogIO Lake.Workspace

full_name: Lake.updateManifest
code: /-- Updates the manifest for the loaded Lake workspace (see `updateAndMaterialize`). -/
def updateManifest (config : LoadConfig) (toUpdate : NameSet := {}) : LogIO Unit 
goal: Lake.LogIO Unit
File: .lake/packages/lean4/src/lean/lake/Lake/Load/Lean/Eval.lean

full_name: Lake.unsafeEvalConstCheck
code: /-- Unsafe implementation of `evalConstCheck`. -/
unsafe def unsafeEvalConstCheck (env : Environment) (opts : Options) (α) (type : Name) (const : Name) : Except String α 
goal: Except String α

full_name: Lake.unsafeEvalConstCheck.throwUnexpectedType
code: /-- Unsafe implementation of `evalConstCheck`. -/
unsafe def unsafeEvalConstCheck (env : Environment) (opts : Options) (α) (type : Name) (const : Name) : Except String α 
goal: Except String α

full_name: Lake.evalConstCheck
code: /-- Like `Lean.Environment.evalConstCheck`, but with plain universe-polymorphic `Except`. -/
@[implemented_by unsafeEvalConstCheck] opaque evalConstCheck
(env : Environment) (opts : Options) (α) (type : Name) (const : Name) : Except String α
goal: Except String α

full_name: Lake.mkTagMap
code: /-- Construct a `DNameMap` from the declarations tagged with `attr`. -/
def mkTagMap
(env : Environment) (attr : OrderedTagAttribute)
[Monad m] (f : (n : Name) → m (β n)) : m (DNameMap β) 
goal: m (Lake.DNameMap β)

full_name: Lake.mkOrdTagMap
code: /-- Construct a `OrdNameMap` from the declarations tagged with `attr`. -/
def mkOrdTagMap
(env : Environment) (attr : OrderedTagAttribute)
[Monad m] (f : (n : Name) → m β) : m (OrdNameMap β) 
goal: m (Lake.OrdNameMap β)

full_name: Lake.PackageConfig.loadFromEnv
code: /-- Load a `PackageConfig` from a configuration environment. -/
def PackageConfig.loadFromEnv
(env : Environment) (opts := Options.empty) : Except String PackageConfig 
goal: Except String Lake.PackageConfig

full_name: Lake.Package.loadFromEnv
code: /--
Load the optional elements of a `Package` from the Lean environment.
This is done after loading its core configuration but before resolving
its dependencies.
-/
def Package.loadFromEnv
  (self : Package) (env : Environment) (opts : Options)
: LogIO Package 
goal: Lake.LogIO Lake.Package

full_name: Lake.Workspace.addFacetsFromEnv
code: /--
Load module/package facets into a `Workspace` from a configuration environment.
-/
def Workspace.addFacetsFromEnv
(env : Environment) (opts : Options) (self : Workspace) : Except String Workspace 
goal: Except String Lake.Workspace
File: .lake/packages/lean4/src/lean/lake/Lake/DSL/Attributes.lean

full_name: Lake.initFn._@..lake.packages.lean4.src.lean.lake.Lake.DSL.Attributes._hyg.5
code: initialize
  registerBuiltinAttribute {
    ref             := by exact decl_name%
    name            := `test_runner
    descr           := testDriverAttr.attr.descr
    add             := fun decl stx attrKind => do
      logWarningAt stx "@[test_runner] has been deprecated, use @[test_driver] instead"
      testDriverAttr.attr.add decl stx attrKind
    applicationTime := testDriverAttr.attr.applicationTime
    erase           := fun decl => testDriverAttr.attr.erase decl
 }
goal: IO Unit
File: .lake/packages/lean4/src/lean/lake/Lake/DSL/Extensions.lean

full_name: Lake.initFn._@..lake.packages.lean4.src.lean.lake.Lake.DSL.Extensions._hyg.5
code: initialize dirExt : EnvExtension (Option System.FilePath) ←
  registerEnvExtension (pure none)
goal: IO (Lean.EnvExtension (Option System.FilePath))

full_name: Lake.dirExt
code: initialize dirExt : EnvExtension (Option System.FilePath) ←
  registerEnvExtension (pure none)
goal: Lean.EnvExtension (Option System.FilePath)

full_name: Lake.optsExt
code: initialize optsExt : EnvExtension (Option (NameMap String)) ←
  registerEnvExtension (pure none)
goal: Lean.EnvExtension (Option (Lean.NameMap String))

full_name: Lake.initFn._@..lake.packages.lean4.src.lean.lake.Lake.DSL.Extensions._hyg.37
code: initialize optsExt : EnvExtension (Option (NameMap String)) ←
  registerEnvExtension (pure none)
goal: IO (Lean.EnvExtension (Option (Lean.NameMap String)))
File: .lake/packages/lean4/src/lean/lake/Lake/DSL/Config.lean

full_name: Lake.DSL.dummyDir
code: /--
A dummy default constant for `__dir__` to make it type check
outside Lakefile elaboration (e.g., when editing).
-/
opaque dummyDir : System.FilePath
goal: System.FilePath

full_name: Lake.DSL.dummyGetConfig?
code: /--
A dummy default constant for `get_config` to make it type check
outside Lakefile elaboration (e.g., when editing).
-/
opaque dummyGetConfig? : Name → Option String
goal: Lean.Name → Option String

full_name: Lake.DSL.dirConst
code: /--
A macro that expands to the path of package's directory
during the Lakefile's elaboration.
-/
scoped syntax (name := dirConst) "__dir__" : term
goal: Lean.ParserDescr

full_name: Lake.DSL.elabDirConst
code: @[term_elab dirConst]
def elabDirConst : TermElab 
goal: Lean.Elab.Term.TermElab

full_name: Lake.DSL.getConfig
code: /--
A macro that expands to the specified configuration option (or `none`,
if the option has not been set) during the Lakefile's elaboration.

Configuration arguments are set either via the Lake CLI (by the `-K` option)
or via the `with` clause in a `require` statement.
-/
scoped syntax (name := getConfig) "get_config? " ident :term
goal: Lean.ParserDescr

full_name: Lake.DSL.elabGetConfig
code: @[term_elab getConfig]
def elabGetConfig : TermElab 
goal: Lean.Elab.Term.TermElab
File: .lake/packages/lean4/src/lean/lake/Lake/DSL/Script.lean

full_name: Lake.DSL.scriptDeclSpec
code: syntax scriptDeclSpec :=
  identOrStr (ppSpace simpleBinder)? (declValSimple <|> declValDo)
goal: Lean.ParserDescr

full_name: Lake.DSL.scriptDecl
code: /--
Define a new Lake script for the package.

**Example**

```
/-- Display a greeting -/
script «script-name» (args) do
  if h : 0 < args.length then
    IO.println s!"Hello, {args[0]'h}!"
  else
    IO.println "Hello, world!"
  return 0
```
-/
scoped syntax (name := scriptDecl)
(docComment)?  optional(Term.attributes) "script " scriptDeclSpec : command
goal: Lean.ParserDescr

full_name: Lake.DSL.expandScriptDecl
code: @[macro scriptDecl]
def expandScriptDecl : Macro

goal: Lean.Macro