ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Tactic/TryThis.lean

full_name: Mathlib.Tactic._aux_Mathlib_Tactic_TryThis___elabRules_Mathlib_Tactic_tacticTry_this__1
code: /-- Produces the text `Try this: <tac>` with the given tactic, and then executes it. -/
elab tk:"try_this" tac:tactic : tactic => do
  Elab.Tactic.evalTactic tac
  Meta.Tactic.TryThis.addSuggestion tk tac (origSpan? := ← getRef)
goal: Lean.Elab.Tactic.Tactic

full_name: Mathlib.Tactic.tacticTry_this_
code: /-- Produces the text `Try this: <tac>` with the given tactic, and then executes it. -/
elab tk:"try_this" tac:tactic : tactic => do
  Elab.Tactic.evalTactic tac
  Meta.Tactic.TryThis.addSuggestion tk tac (origSpan? := ← getRef)
goal: Lean.ParserDescr

full_name: Mathlib.Tactic._aux_Mathlib_Tactic_TryThis___elabRules_Mathlib_Tactic_convTry_this__1
code: /-- Produces the text `Try this: <tac>` with the given conv tactic, and then executes it. -/
elab tk:"try_this" tac:conv : conv => do
  Elab.Tactic.evalTactic tac
  Meta.Tactic.TryThis.addSuggestion tk tac (origSpan? := ← getRef)
goal: Lean.Elab.Tactic.Tactic

full_name: Mathlib.Tactic.convTry_this_
code: /-- Produces the text `Try this: <tac>` with the given conv tactic, and then executes it. -/
elab tk:"try_this" tac:conv : conv => do
  Elab.Tactic.evalTactic tac
  Meta.Tactic.TryThis.addSuggestion tk tac (origSpan? := ← getRef)
goal: Lean.ParserDescr
File: Mathlib/Tactic/ArithMult.lean

full_name: ArithmeticFunction.attrArith_mult
code: macro "arith_mult" : attr =>
  `(attr|aesop safe apply (rule_sets := [$(Lean.mkIdent `IsMultiplicative):ident]))
goal: Lean.ParserDescr

full_name: ArithmeticFunction._aux_Mathlib_Tactic_ArithMult___macroRules_ArithmeticFunction_attrArith_mult_1
code: macro "arith_mult" : attr =>
  `(attr|aesop safe apply (rule_sets := [$(Lean.mkIdent `IsMultiplicative):ident]))
goal: Lean.Macro

full_name: ArithmeticFunction._aux_Mathlib_Tactic_ArithMult___macroRules_ArithmeticFunction_arith_mult_1
code: macro (name := arith_mult) "arith_mult" c:Aesop.tactic_clause* : tactic =>
`(tactic|
  { aesop $c* (config :=
    { destructProductsTransparency := .reducible,
      applyHypsTransparency := .default,
      introsTransparency? := some .reducible,
      enableSimp := false } )
  (rule_sets := [$(Lean.mkIdent `IsMultiplicative):ident])})
goal: Lean.Macro

full_name: ArithmeticFunction.arith_mult
code: macro (name := arith_mult) "arith_mult" c:Aesop.tactic_clause* : tactic =>
`(tactic|
  { aesop $c* (config :=
    { destructProductsTransparency := .reducible,
      applyHypsTransparency := .default,
      introsTransparency? := some .reducible,
      enableSimp := false } )
  (rule_sets := [$(Lean.mkIdent `IsMultiplicative):ident])})
goal: Lean.ParserDescr

full_name: ArithmeticFunction._aux_Mathlib_Tactic_ArithMult___macroRules_ArithmeticFunction_arith_mult?_1
code: macro (name := arith_mult?) "arith_mult?" c:Aesop.tactic_clause* : tactic =>
`(tactic|
  { show_term { arith_mult $c* } })
goal: Lean.Macro

full_name: ArithmeticFunction.arith_mult?
code: macro (name := arith_mult?) "arith_mult?" c:Aesop.tactic_clause* : tactic =>
`(tactic|
  { show_term { arith_mult $c* } })
goal: Lean.ParserDescr
File: Mathlib/Tactic/GCongr.lean

full_name: _aux_Mathlib_Tactic_GCongr___macroRules_Mathlib_Tactic_GCongr_tacticGcongr_discharger_1
code: macro_rules | `(tactic| gcongr_discharger) => `(tactic| positivity)
goal: Lean.Macro
File: Mathlib/Tactic/RSuffices.lean

full_name: rsuffices
code: /--
The `rsuffices` tactic is an alternative version of `suffices`, that allows the usage
of any syntax that would be valid in an `obtain` block. This tactic just calls `obtain`
on the expression, and then `rotate_left`.
-/
syntax (name := rsuffices) "rsuffices"
  (ppSpace Lean.Parser.Tactic.rcasesPatMed)? (" : " term)? (" := " term,+)? : tactic
goal: Lean.ParserDescr

full_name: _aux_Mathlib_Tactic_RSuffices___macroRules_rsuffices_1
code: macro_rules
| `(tactic| rsuffices $[$pred]? $[: $foo]? $[:= $bar]?) =>
`(tactic | (obtain $[$pred]? $[: $foo]? $[:= $bar]?; rotate_left))
goal: Lean.Macro
File: Mathlib/Tactic/ClearExclamation.lean

full_name: Mathlib.Tactic.clear!
code: /-- A variant of `clear` which clears not only the given hypotheses but also any other hypotheses
    depending on them -/
elab (name := clear!) "clear!" hs:(ppSpace colGt ident)* : tactic => do
  let fvarIds ← getFVarIds hs
  liftMetaTactic1 fun goal ↦ do
    goal.tryClearMany <| (← collectForwardDeps (fvarIds.map .fvar) true).map (·.fvarId!)
goal: Lean.ParserDescr

full_name: Mathlib.Tactic._aux_Mathlib_Tactic_ClearExclamation___elabRules_Mathlib_Tactic_clear!_1
code: /-- A variant of `clear` which clears not only the given hypotheses but also any other hypotheses
    depending on them -/
elab (name := clear!) "clear!" hs:(ppSpace colGt ident)* : tactic => do
  let fvarIds ← getFVarIds hs
  liftMetaTactic1 fun goal ↦ do
    goal.tryClearMany <| (← collectForwardDeps (fvarIds.map .fvar) true).map (·.fvarId!)
goal: Lean.Elab.Tactic.Tactic
File: Mathlib/Tactic/ToExpr.lean

full_name: Lean.instToExprOptionOfToLevel
code: ToExpr
goal: {α : Type u} → [inst : Lean.ToExpr α] → [inst : Lean.ToLevel.{u}] → Lean.ToExpr (Option α)

full_name: Lean.instToExprListOfToLevel
code: ToExpr
goal: {α : Type u} → [inst : Lean.ToExpr α] → [inst : Lean.ToLevel.{u}] → Lean.ToExpr (List α)

full_name: Lean.instToExprArrayOfToLevel
code: instance {α : Type u} [ToExpr α] [ToLevel.{u}] : ToExpr (Array α) 
goal: Lean.ToExpr (Array α)

full_name: Lean.instToExprProdOfToLevel
code: ToExpr
goal: {α : Type u} →
  {β : Type v} →
    [inst : Lean.ToExpr α] →
      [inst : Lean.ToExpr β] → [inst : Lean.ToLevel.{u}] → [inst : Lean.ToLevel.{v}] → Lean.ToExpr (α × β)

full_name: Lean.instToExprFilePath_mathlib
code: ToExpr
goal: Lean.ToExpr System.FilePath

full_name: Mathlib.instToExprInt_mathlib
code: ToExpr
goal: Lean.ToExpr Int

full_name: Mathlib.instToExprULiftOfToLevel
code: ToExpr
goal: {α : Type s} → [inst : Lean.ToExpr α] → [inst : Lean.ToLevel.{r}] → [inst : Lean.ToLevel.{s}] → Lean.ToExpr (ULift α)

full_name: Mathlib.instToExprPUnitOfToLevel
code: /-- Hand-written instance since `PUnit` is a `Sort` rather than a `Type`. -/
instance [ToLevel.{u}] : ToExpr PUnit.{u+1} 
goal: Lean.ToExpr PUnit

full_name: Mathlib.instToExprPos_mathlib
code: ToExpr
goal: Lean.ToExpr String.Pos

full_name: Mathlib.instToExprSubstring_mathlib
code: ToExpr
goal: Lean.ToExpr Substring

full_name: Mathlib.instToExprSourceInfo_mathlib
code: ToExpr
goal: Lean.ToExpr Lean.SourceInfo

full_name: Mathlib.instToExprPreresolved_mathlib
code: ToExpr
goal: Lean.ToExpr Lean.Syntax.Preresolved

full_name: Mathlib.instToExprSyntax_mathlib
code: ToExpr
goal: Lean.ToExpr Lean.Syntax

full_name: _private.Mathlib.Tactic.ToExpr.0.Mathlib.toExprMData
code: /-- Core of a hand-written `ToExpr` handler for `MData`.
Uses the `KVMap.set*` functions rather than going into the internals
of the `KVMap` data structure. -/
private def toExprMData (md : MData) : Expr 
goal: Lean.Expr

full_name: Mathlib.instToExprMData_mathlib
code: instance : ToExpr MData 
goal: Lean.ToExpr Lean.MData

full_name: Mathlib.instToExprFVarId_mathlib
code: ToExpr
goal: Lean.ToExpr Lean.FVarId

full_name: Mathlib.instToExprMVarId_mathlib
code: ToExpr
goal: Lean.ToExpr Lean.MVarId

full_name: Mathlib.instToExprLevelMVarId_mathlib
code: ToExpr
goal: Lean.ToExpr Lean.LevelMVarId

full_name: Mathlib.instToExprLevel_mathlib
code: ToExpr
goal: Lean.ToExpr Lean.Level

full_name: Mathlib.instToExprBinderInfo_mathlib
code: ToExpr
goal: Lean.ToExpr Lean.BinderInfo

full_name: Mathlib.instToExprLiteral_mathlib
code: ToExpr
goal: Lean.ToExpr Lean.Literal

full_name: Mathlib.instToExprExpr_mathlib
code: ToExpr
goal: Lean.ToExpr Lean.Expr
File: Mathlib/Tactic/ExtendDoc.lean

full_name: Mathlib.Tactic.ExtendDocs.commandExtend_docs__Before__After_
code: /-- `extend_docs <declName> before <prefix_string> after <suffix_string>` extends the
docs of `<declName>` by adding `<prefix_string>` before and `<suffix_string>` after. -/
syntax "extend_docs" ident (colGt &"before" str)? (colGt &"after" str)? : command
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.ExtendDocs._aux_Mathlib_Tactic_ExtendDoc___elabRules_Mathlib_Tactic_ExtendDocs_commandExtend_docs__Before__After__1
code: elab_rules : command
  | `(command| extend_docs $na:ident $[before $bef:str]? $[after $aft:str]?) => do
    if bef.isNone && aft.isNone then throwError "expected at least one of 'before' or 'after'"
    let declName ← liftCoreM <| Elab.realizeGlobalConstNoOverloadWithInfo na
    let bef := if bef.isNone then "" else (bef.get!).getString ++ "\n\n"
    let aft := if aft.isNone then "" else "\n\n" ++ (aft.get!).getString
    let oldDoc := (← findDocString? (← getEnv) declName).getD ""
    addDocString declName <| bef ++ oldDoc ++ aft
goal: Lean.Elab.Command.CommandElab
File: Mathlib/Tactic/Lemma.lean

full_name: lemma
code: /-- `lemma` means the same as `theorem`. It is used to denote "less important" theorems -/
syntax (name := lemma) declModifiers
  group("lemma " declId ppIndent(declSig) declVal) : command
goal: Lean.ParserDescr

full_name: expandLemma
code: /-- Implementation of the `lemma` command, by macro expansion to `theorem`. -/
@[macro «lemma»] def expandLemma : Macro 
goal: Lean.Macro
File: Mathlib/Tactic/FailIfNoProgress.lean

full_name: Mathlib.Tactic.failIfNoProgress
code: /-- `fail_if_no_progress tacs` evaluates `tacs`, and fails if no progress is made on the main goal
or the local context at reducible transparency. -/
syntax (name := failIfNoProgress) "fail_if_no_progress " tacticSeq : tactic
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.lctxIsDefEq
code: /-- `lctxIsDefEq l₁ l₂` compares two lists of `Option LocalDecl`s (as returned from e.g.
`(← (← getMainGoal).getDecl).lctx.decls.toList`). It returns `true` if they have the same
local declarations in the same order (up to defeq, without setting mvars), and `false` otherwise.

Assumption: this function is run with one of the local contexts as the current `MetaM` local
context, and one of the two lists consists of the `LocalDecl`s of that context. -/
def lctxIsDefEq : (l₁ l₂ : List (Option LocalDecl)) → MetaM Bool
  
goal: Lean.MetaM Bool

full_name: Mathlib.Tactic.runAndFailIfNoProgress
code: /-- Run `tacs : TacticM Unit` on `goal`, and fail if no progress is made. -/
def runAndFailIfNoProgress (goal : MVarId) (tacs : TacticM Unit) : TacticM (List MVarId) 
goal: Lean.Elab.Tactic.TacticM (List Lean.MVarId)

full_name: Mathlib.Tactic._aux_Mathlib_Tactic_FailIfNoProgress___elabRules_Mathlib_Tactic_failIfNoProgress_1
code: elab_rules : tactic
| `(tactic| fail_if_no_progress $tacs) => do
  let goal ← getMainGoal
  let l ← runAndFailIfNoProgress goal (evalTactic tacs)
  replaceMainGoal l
goal: Lean.Elab.Tactic.Tactic
File: Mathlib/Tactic/ReduceModChar/Ext.lean

full_name: initFn._@.Mathlib.Tactic.ReduceModChar.Ext._hyg.5
code: /-- `@[reduce_mod_char]` is an attribute that tags lemmas for preprocessing and cleanup in the
`reduce_mod_char` tactic -/
initialize reduceModCharExt : SimpExtension ←
  registerSimpAttr `reduce_mod_char
    "lemmas for preprocessing and cleanup in the `reduce_mod_char` tactic"
goal: IO Lean.Meta.SimpExtension

full_name: reduceModCharExt
code: /-- `@[reduce_mod_char]` is an attribute that tags lemmas for preprocessing and cleanup in the
`reduce_mod_char` tactic -/
initialize reduceModCharExt : SimpExtension ←
  registerSimpAttr `reduce_mod_char
    "lemmas for preprocessing and cleanup in the `reduce_mod_char` tactic"
goal: Lean.Meta.SimpExtension
File: Mathlib/Tactic/ExtractLets.lean

full_name: Lean.MVarId.extractLetsAt.process
code: /-- Given a local hypothesis whose type is a `let` expression, then lift the `let` bindings to be
a new local definition. -/
def Lean.MVarId.extractLetsAt (mvarId : MVarId) (fvarId : FVarId) (names : Array Name) :
    MetaM (Array FVarId × MVarId) 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.extractLetsAt
code: /-- Given a local hypothesis whose type is a `let` expression, then lift the `let` bindings to be
a new local definition. -/
def Lean.MVarId.extractLetsAt (mvarId : MVarId) (fvarId : FVarId) (names : Array Name) :
    MetaM (Array FVarId × MVarId) 
goal: Lean.MetaM (Array Lean.FVarId × Lean.MVarId)

full_name: Lean.MVarId.extractLets
code: /-- A more limited version of `Lean.MVarId.introN` that ensures the goal is a
nested `let` expression. -/
def Lean.MVarId.extractLets (mvarId : MVarId) (names : Array Name) :
    MetaM (Array FVarId × MVarId) 
goal: Lean.MetaM (Array Lean.FVarId × Lean.MVarId)

full_name: Mathlib.extractLets
code: /-- The `extract_lets at h` tactic takes a local hypothesis of the form `h : let x := v; b`
and introduces a new local definition `x := v` while changing `h` to be `h : b`.  It can be thought
of as being a `cases` tactic for `let` expressions. It can also be thought of as being like
`intros at h` for `let` expressions.

For example, if `h : let x := 1; x = x`, then `extract_lets x at h` introduces `x : Nat := 1` and
changes `h` to `h : x = x`.

Just like `intros`, the `extract_lets` tactic either takes a list of names, in which case
that specifies the number of `let` bindings that must be extracted, or it takes no names, in which
case all the `let` bindings are extracted.

The tactic `extract_lets` (without `at`) or `extract_lets at h ⊢` acts as a weaker
form of `intros` on the goal that only introduces obvious `let`s. -/
syntax (name := extractLets) "extract_lets " (colGt (ident <|> hole))* (ppSpace location)? : tactic
goal: Lean.ParserDescr

full_name: Mathlib.evalExtractLets
code: @[tactic Mathlib.extractLets, inherit_doc extractLets]
def evalExtractLets : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: Mathlib.evalExtractLets.setupNames
code: @[tactic Mathlib.extractLets, inherit_doc extractLets]
def evalExtractLets : Tactic 
goal: Lean.MetaM (Array Lean.Name)

full_name: Mathlib.evalExtractLets.doExtract
code: @[tactic Mathlib.extractLets, inherit_doc extractLets]
def evalExtractLets : Tactic 
goal: Lean.Elab.Tactic.TacticM Unit
File: Mathlib/Tactic/Linter/OldObtain.lean

full_name: Mathlib.Linter.Style.is_obtain_without_proof
code: /-- Whether a syntax element is an `obtain` tactic call without a provided proof. -/
def is_obtain_without_proof : Syntax → Bool
  -- Using the `obtain` tactic without a proof requires proving a type;
  -- a pattern is optional.
  
goal: Lean.Syntax → Bool

full_name: Mathlib.Linter.Style.initFn._@.Mathlib.Tactic.Linter.OldObtain._hyg.312
code: /-- The `oldObtain` linter emits a warning upon uses of the "stream-of-conciousness" variants
of the `obtain` tactic, i.e. with the proof postponed. -/
register_option linter.oldObtain : Bool := {
  defValue := true
  descr := "enable the `oldObtain` linter"
}
goal: IO (Lean.Option Bool)

full_name: Mathlib.Linter.Style.linter.oldObtain
code: /-- The `oldObtain` linter emits a warning upon uses of the "stream-of-conciousness" variants
of the `obtain` tactic, i.e. with the proof postponed. -/
register_option linter.oldObtain : Bool := {
  defValue := true
  descr := "enable the `oldObtain` linter"
}
goal: Lean.Option Bool

full_name: Mathlib.Linter.Style.getLinterHash
code: /-- Gets the value of the `linter.oldObtain` option. -/
def getLinterHash (o : Options) : Bool 
goal: Bool

full_name: Mathlib.Linter.Style.oldObtainLinter
code: /-- The `oldObtain` linter: see docstring above -/
def oldObtainLinter : Linter 
goal: Lean.Linter

full_name: Mathlib.Linter.Style.initFn._@.Mathlib.Tactic.Linter.OldObtain._hyg.540
code: initialize addLinter oldObtainLinter
goal: IO Unit
File: Mathlib/Tactic/GCongr/ForwardAttr.lean

full_name: Mathlib.Tactic.GCongr.ForwardExt.eval
code: /-- An extension for `gcongr_forward`. -/
structure ForwardExt where
  eval (h : Expr) (goal : MVarId) : MetaM Unit
goal: Lean.MetaM Unit

full_name: Mathlib.Tactic.GCongr.ForwardExt
code: /-- An extension for `gcongr_forward`. -/
structure ForwardExt where
  eval (h : Expr) (goal : MVarId) : MetaM Unit
goal: Type

full_name: Mathlib.Tactic.GCongr.mkForwardExt
code: /-- Read a `gcongr_forward` extension from a declaration of the right type. -/
def mkForwardExt (n : Name) : ImportM ForwardExt 
goal: Lean.ImportM Mathlib.Tactic.GCongr.ForwardExt

full_name: Mathlib.Tactic.GCongr.initFn._@.Mathlib.Tactic.GCongr.ForwardAttr._hyg.83
code: /-- Environment extensions for `gcongrForward` declarations -/
initialize forwardExt : PersistentEnvExtension Name (Name × ForwardExt)
    (List Name × List (Name × ForwardExt)) ←
  registerPersistentEnvExtension {
    mkInitial := pure ([], {})
    addImportedFn := fun s => do
      let dt ← s.foldlM (init := {}) fun dt s => s.foldlM (init := dt) fun dt n => do
        return (n, ← mkForwardExt n) :: dt
      pure ([], dt)
    addEntryFn := fun (entries, s) (n, ext) => (n :: entries, (n, ext) :: s)
    exportEntriesFn := fun s => s.1.reverse.toArray
  }
goal: IO
  (Lean.PersistentEnvExtension Lean.Name (Lean.Name × Mathlib.Tactic.GCongr.ForwardExt)
    (List Lean.Name × List (Lean.Name × Mathlib.Tactic.GCongr.ForwardExt)))

full_name: Mathlib.Tactic.GCongr.forwardExt
code: /-- Environment extensions for `gcongrForward` declarations -/
initialize forwardExt : PersistentEnvExtension Name (Name × ForwardExt)
    (List Name × List (Name × ForwardExt)) ←
  registerPersistentEnvExtension {
    mkInitial := pure ([], {})
    addImportedFn := fun s => do
      let dt ← s.foldlM (init := {}) fun dt s => s.foldlM (init := dt) fun dt n => do
        return (n, ← mkForwardExt n) :: dt
      pure ([], dt)
    addEntryFn := fun (entries, s) (n, ext) => (n :: entries, (n, ext) :: s)
    exportEntriesFn := fun s => s.1.reverse.toArray
  }
goal: Lean.PersistentEnvExtension Lean.Name (Lean.Name × Mathlib.Tactic.GCongr.ForwardExt)
  (List Lean.Name × List (Lean.Name × Mathlib.Tactic.GCongr.ForwardExt))

full_name: Mathlib.Tactic.GCongr.initFn._@.Mathlib.Tactic.GCongr.ForwardAttr._hyg.321
code: initialize registerBuiltinAttribute {
  name := `gcongr_forward
  descr := "adds a gcongr_forward extension"
  applicationTime := .afterCompilation
  add := fun declName stx kind => match stx with
    | `(attr| gcongr_forward) => do
      unless kind == AttributeKind.global do
        throwError "invalid attribute 'gcongr_forward', must be global"
      let env ← getEnv
      unless (env.getModuleIdxFor? declName).isNone do
        throwError "invalid attribute 'gcongr_forward', declaration is in an imported module"
      if (IR.getSorryDep env declName).isSome then return -- ignore in progress definitions
      let ext ← mkForwardExt declName
      setEnv <| forwardExt.addEntry env (declName, ext)
    | _ => throwUnsupportedSyntax
}
goal: IO Unit
File: Mathlib/Tactic/ContinuousFunctionalCalculus.lean

full_name: cfcTac
code: /-- A tactic used to automatically discharge goals relating to the continuous functional calculus,
specifically whether the element satisfies the predicate. -/
syntax (name := cfcTac) "cfc_tac" : tactic
goal: Lean.ParserDescr

full_name: _aux_Mathlib_Tactic_ContinuousFunctionalCalculus___macroRules_cfcTac_1
code: macro_rules
  | `(tactic| cfc_tac) => `(tactic| (try (first | assumption | infer_instance | aesop)))
goal: Lean.Macro

full_name: cfcContTac
code: /-- A tactic used to automatically discharge goals relating to the continuous functional calculus,
specifically concerning continuity of the functions involved. -/
syntax (name := cfcContTac) "cfc_cont_tac" : tactic
goal: Lean.ParserDescr

full_name: _aux_Mathlib_Tactic_ContinuousFunctionalCalculus___macroRules_cfcContTac_1
code: macro_rules
  | `(tactic| cfc_cont_tac) => `(tactic| try (first | fun_prop (disch := aesop) | assumption))
goal: Lean.Macro

full_name: cfcZeroTac
code: /-- A tactic used to automatically discharge goals relating to the non-unital continuous functional
calculus, specifically concerning whether `f 0 = 0`. -/
syntax (name := cfcZeroTac) "cfc_zero_tac" : tactic
goal: Lean.ParserDescr

full_name: _aux_Mathlib_Tactic_ContinuousFunctionalCalculus___macroRules_cfcZeroTac_1
code: macro_rules
  | `(tactic| cfc_zero_tac) => `(tactic| try (first | aesop | assumption))
goal: Lean.Macro
File: Mathlib/Tactic/Linter/Style.lean

full_name: Mathlib.Linter.linter.setOption
code: /-- The `setOption` linter emits a warning on a `set_option` command, term or tactic
which sets a `pp`, `profiler` or `trace` option. -/
register_option linter.setOption : Bool := {
  defValue := true
  descr := "enable the `setOption` linter"
}
goal: Lean.Option Bool

full_name: Mathlib.Linter.initFn._@.Mathlib.Tactic.Linter.Style._hyg.8
code: /-- The `setOption` linter emits a warning on a `set_option` command, term or tactic
which sets a `pp`, `profiler` or `trace` option. -/
register_option linter.setOption : Bool := {
  defValue := true
  descr := "enable the `setOption` linter"
}
goal: IO (Lean.Option Bool)

full_name: Mathlib.Linter.Style.SetOption.parse_set_option
code: /-- Whether a syntax element is a `set_option` command, tactic or term:
Return the name of the option being set, if any. -/
def parse_set_option : Syntax → Option Name
  -- This handles all four possibilities of `_val`: a string, number, `true` and `false`.
  
goal: Lean.Syntax → Option Lean.Name

full_name: Mathlib.Linter.Style.SetOption.is_set_option
code: /-- Whether a given piece of syntax is a `set_option` command, tactic or term. -/
def is_set_option : Syntax → Bool 
goal: Lean.Syntax → Bool

full_name: Mathlib.Linter.Style.SetOption.getLinterHash
code: /-- Gets the value of the `linter.setOption` option. -/
def getLinterHash (o : Options) : Bool 
goal: Bool

full_name: Mathlib.Linter.Style.SetOption.setOptionLinter
code: /-- The `setOption` linter: this lints any `set_option` command, term or tactic
which sets a `pp`, `profiler` or `trace` option.

**Why is this bad?** These options are good for debugging, but should not be
used in production code.
**How to fix this?** Remove these options: usually, they are not necessary for production code.
(Some tests will intentionally use one of these options; in this case, simply allow the linter.)
-/
def setOptionLinter : Linter 
goal: Lean.Linter

full_name: Mathlib.Linter.Style.SetOption.initFn._@.Mathlib.Tactic.Linter.Style._hyg.970
code: initialize addLinter setOptionLinter
goal: IO Unit