chore: update stage0

Previous commit affect `.olean` format.

stage0/src/Init/NotationExtra.lean

@@ -210,10 +210,6 @@ syntax (name := calcTactic) "calc" ppLine withPosition(calcStep) ppLine withPosi
   | `($_ $array $index) => `($array[$index]?)
   | _ => throw ()
 
-@[appUnexpander getElem'] def unexpandGetElem' : Lean.PrettyPrinter.Unexpander
-  | `($_ $array $index $h) => `($array[$index]'$h)
-  | _ => throw ()
-
 /--
 Apply function extensionality and introduce new hypotheses.
 The tactic `funext` will keep applying new the `funext` lemma until the goal target is not reducible to

stage0/src/Init/Tactics.lean

@@ -161,8 +161,7 @@ syntax caseArg := binderIdent binderIdent*
   with inaccessible names to the given names.
 * `case tag₁ | tag₂ => tac` is equivalent to `(case tag₁ => tac); (case tag₂ => tac)`.
 -/
-syntax (name := case) "case " binderIdent binderIdent* " => " tacticSeq : tactic
--- syntax (name := case) "case " sepBy1(caseArg, " | ") " => " tacticSeq : tactic
+syntax (name := case) "case " sepBy1(caseArg, " | ") " => " tacticSeq : tactic
 
 /--
 `case'` is similar to the `case tag => tac` tactic, but does not ensure the goal
@@ -170,8 +169,7 @@ has been solved after applying `tac`, nor admits the goal if `tac` failed.
 Recall that `case` closes the goal using `sorry` when `tac` fails, and
 the tactic execution is not interrupted.
 -/
-syntax (name := case') "case' " binderIdent binderIdent* " => " tacticSeq : tactic
--- syntax (name := case') "case' " sepBy1(caseArg, " | ") " => " tacticSeq : tactic
+syntax (name := case') "case' " sepBy1(caseArg, " | ") " => " tacticSeq : tactic
 
 /--
 `next => tac` focuses on the next goal and solves it using `tac`, or else fails.
@@ -398,7 +396,7 @@ syntax (name := injection) "injection " term (" with " (colGt (ident <|> hole))+
 (since `injection` can produce new hypotheses). Useful for destructing nested
 constructor equalities like `(a::b::c) = (d::e::f)`. -/
 -- TODO: add with
-syntax (name := injections) "injections" : tactic
+syntax (name := injections) "injections" (colGt (ident <|> hole))* : tactic
 
 /--
 The discharger clause of `simp` and related tactics.
@@ -835,9 +833,5 @@ macro "get_elem_tactic" : tactic =>
 @[inheritDoc getElem]
 macro:max x:term noWs "[" i:term "]" : term => `(getElem $x $i (by get_elem_tactic))
 
-/-- Helper declaration for the unexpander -/
-@[inline] def getElem' [GetElem cont idx elem dom] (xs : cont) (i : idx) (h : dom xs i) : elem :=
-  getElem xs i h
-
 @[inheritDoc getElem]
-macro x:term noWs "[" i:term "]'" h:term:max : term => `(getElem' $x $i $h)
+macro x:term noWs "[" i:term "]'" h:term:max : term => `(getElem $x $i $h)

stage0/src/Lean/Compiler/LCNF/CSE.lean

@@ -19,9 +19,12 @@ structure State where
 
 abbrev M := StateRefT State CompilerM
 
-instance : MonadFVarSubst M where
+instance : MonadFVarSubst M false where
   getSubst := return (← get).subst
 
+instance : MonadFVarSubstState M where
+  modifySubst f := modify fun s => { s with subst := f s.subst }
+
 @[inline] def getSubst : M FVarSubst :=
   return (← get).subst
 
@@ -34,11 +37,11 @@ instance : MonadFVarSubst M where
 
 def replaceLet (decl : LetDecl) (fvarId : FVarId) : M Unit := do
   eraseLetDecl decl
-  modify fun s => { s with subst := s.subst.insert decl.fvarId (.fvar fvarId) }
+  addFVarSubst decl.fvarId fvarId
 
 def replaceFun (decl : FunDecl) (fvarId : FVarId) : M Unit := do
   eraseFunDecl decl
-  modify fun s => { s with subst := s.subst.insert decl.fvarId (.fvar fvarId) }
+  addFVarSubst decl.fvarId fvarId
 
 partial def _root_.Lean.Compiler.LCNF.Code.cse (code : Code) : CompilerM Code :=
   go code |>.run' {}

stage0/src/Lean/Compiler/LCNF/CompilerM.lean

@@ -104,16 +104,34 @@ During the internalization process, we ensure all free variables in the LCNF cod
 at the `CompilerM` local context.
 Remark: in LCNF, (computationally relevant) data is in A-normal form, but this is not the case for types and type formers.
 So, when inlining we often want to replace a free variable with a type or type former.
+
+The substitution contains entries `fvarId ↦ e` s.t., `e` is a valid LCNF argument. That is,
+it is a free variable, a type (or type former), or `lcErased`.
+
+`Check.lean` contains a substitution validator.
 -/
 abbrev FVarSubst := Std.HashMap FVarId Expr
 
-private partial def normExprImp (s : FVarSubst) (e : Expr) : Expr :=
+/--
+Replace the free variables in `e` using the given substitution.
+
+If `translator = true`, then we assume the free variables occurring in the range of the substitution are in another
+local context. For example, `translator = true` during internalization where we are making sure all free variables
+in a given expression are replaced with new ones that do not collide with the ones in the current local context.
+
+If `translator = false`, we assume the substitution contains free variable replacements in the same local context,
+and given entries such as `x₁ ↦ x₂`, `x₂ ↦ x₃`, ..., `xₙ₋₁ ↦ xₙ`, and the expression `f x₁ x₂`, we want the resulting
+expression to be `f xₙ xₙ`. We use this setting, for example, in the simplifier.
+-/
+private partial def normExprImp (s : FVarSubst) (e : Expr) (translator : Bool) : Expr :=
   go e
 where
   go (e : Expr) : Expr :=
     if e.hasFVar then
       match e with
-      | .fvar fvarId => s.find? fvarId |>.getD e
+      | .fvar fvarId => match s.find? fvarId with
+        | some e => if translator then e else go e
+        | none => e
       | .lit .. | .const .. | .sort .. | .mvar .. | .bvar .. => e
       | .app f a => e.updateApp! (go f) (go a)
       | .mdata _ b => e.updateMData! (go b)
@@ -124,27 +142,68 @@ where
     else
       e
 
-private partial def normFVarImp (s : FVarSubst) (fvarId : FVarId) : FVarId :=
+/--
+Normalize the given free variable.
+See `normExprImp` for documentation on the `translator` parameter.
+This function is meant to be used in contexts where the input free-variable is computationally relevant.
+This function panics if the substitution is mapping `fvarId` to an expression that is not another free variable.
+That is, it is not a type (or type former), nor `lcErased`. Recall that a valid `FVarSubst` contains only
+expressions that are free variables, `lcErased`, or type formers.
+-/
+private partial def normFVarImp (s : FVarSubst) (fvarId : FVarId) (translator : Bool) : FVarId :=
   match s.find? fvarId with
-  | some (.fvar fvarId') => normFVarImp s fvarId'
-  | some _ => panic! "invalid LCNF substitution of free variable with expression"
+  | some (.fvar fvarId') =>
+    if translator then
+      fvarId'
+    else
+      normFVarImp s fvarId' translator
+  | some e => panic! s!"invalid LCNF substitution of free variable with expression {e}"
   | none => fvarId
 
-class MonadFVarSubst (m : Type → Type) where
+/--
+Interface for monads that have a free substitutions.
+-/
+class MonadFVarSubst (m : Type → Type) (translator : outParam Bool) where
   getSubst : m FVarSubst
 
 export MonadFVarSubst (getSubst)
 
-instance (m n) [MonadLift m n] [MonadFVarSubst m] : MonadFVarSubst n where
+instance (m n) [MonadLift m n] [MonadFVarSubst m t] : MonadFVarSubst n t where
   getSubst := liftM (getSubst : m _)
 
-@[inline] def normFVar [MonadFVarSubst m] [Monad m] (fvarId : FVarId) : m FVarId :=
-  return normFVarImp (← getSubst) fvarId
+class MonadFVarSubstState (m : Type → Type) where
+  modifySubst : (FVarSubst → FVarSubst) → m Unit
 
-@[inline] def normExpr [MonadFVarSubst m] [Monad m] (e : Expr) : m Expr :=
-  return normExprImp (← getSubst) e
+export MonadFVarSubstState (modifySubst)
 
-def normExprs [MonadFVarSubst m] [Monad m] (es : Array Expr) : m (Array Expr) :=
+instance (m n) [MonadLift m n] [MonadFVarSubstState m] : MonadFVarSubstState n where
+  modifySubst f := liftM (modifySubst f : m _)
+
+/--
+Add the entry `fvarId ↦ fvarId'` to the free variable substitution.
+-/
+@[inline] def addFVarSubst [MonadFVarSubstState m] (fvarId : FVarId) (fvarId' : FVarId) : m Unit :=
+  modifySubst fun s => s.insert fvarId (.fvar fvarId')
+
+/--
+Add the substitution `fvarId ↦ e`, `e` must be a valid LCNF argument.
+That is, it must be a free variable, type (or type former), or `lcErased`.
+
+See `Check.lean` for the free variable substitution checker.
+-/
+@[inline] def addSubst [MonadFVarSubstState m] (fvarId : FVarId) (e : Expr) : m Unit :=
+  modifySubst fun s => s.insert fvarId e
+
+@[inline, inheritDoc normFVarImp] def normFVar [MonadFVarSubst m t] [Monad m] (fvarId : FVarId) : m FVarId :=
+  return normFVarImp (← getSubst) fvarId t
+
+@[inline, inheritDoc normExprImp] def normExpr [MonadFVarSubst m t] [Monad m] (e : Expr) : m Expr :=
+  return normExprImp (← getSubst) e t
+
+/--
+Normalize the given expressions using the current substitution.
+-/
+def normExprs [MonadFVarSubst m t] [Monad m] (es : Array Expr) : m (Array Expr) :=
   es.mapMonoM normExpr
 
 def mkFreshBinderName (binderName := `_x): CompilerM Name := do
@@ -164,12 +223,22 @@ namespace Internalize
 
 abbrev InternalizeM := StateRefT FVarSubst CompilerM
 
-instance : MonadFVarSubst InternalizeM where
+/--
+The `InternalizeM` monad is a translator. It "translates" the free variables
+in the input expressions and `Code`, into new fresh free variables in the
+local context.
+-/
+instance : MonadFVarSubst InternalizeM true where
   getSubst := get
 
+instance : MonadFVarSubstState InternalizeM where
+  modifySubst := modify
+
+  -- modifySubst f := modify f
+
 private def mkNewFVarId (fvarId : FVarId) : InternalizeM FVarId := do
   let fvarId' ← Lean.mkFreshFVarId
-  modify fun s => s.insert fvarId (.fvar fvarId')
+  addFVarSubst fvarId fvarId'
   return fvarId'
 
 def internalizeParam (p : Param) : InternalizeM Param := do
@@ -303,26 +372,28 @@ abbrev FunDeclCore.update' (decl : FunDecl) (type : Expr) (value : Code) : Compi
 abbrev FunDeclCore.updateValue (decl : FunDecl) (value : Code) : CompilerM FunDecl :=
   decl.update decl.type decl.params value
 
-@[inline] def normParam [MonadLiftT CompilerM m] [Monad m] [MonadFVarSubst m] (p : Param) : m Param := do
+@[inline] def normParam [MonadLiftT CompilerM m] [Monad m] [MonadFVarSubst m t] (p : Param) : m Param := do
   p.update (← normExpr p.type)
 
-def normParams [MonadLiftT CompilerM m] [Monad m] [MonadFVarSubst m] (ps : Array Param) : m (Array Param) :=
+def normParams [MonadLiftT CompilerM m] [Monad m] [MonadFVarSubst m t] (ps : Array Param) : m (Array Param) :=
   ps.mapMonoM normParam
 
-def normLetDecl [MonadLiftT CompilerM m] [Monad m] [MonadFVarSubst m] (decl : LetDecl) : m LetDecl := do
+def normLetDecl [MonadLiftT CompilerM m] [Monad m] [MonadFVarSubst m t] (decl : LetDecl) : m LetDecl := do
   decl.update (← normExpr decl.type) (← normExpr decl.value)
 
-instance : MonadFVarSubst (ReaderT FVarSubst CompilerM) where
+abbrev NormalizerM (_translator : Bool) := ReaderT FVarSubst CompilerM
+
+instance : MonadFVarSubst (NormalizerM t) t where
   getSubst := read
 
 mutual
-  partial def normFunDeclImp (decl : FunDecl) : ReaderT FVarSubst CompilerM FunDecl := do
+  partial def normFunDeclImp (decl : FunDecl) : NormalizerM t FunDecl  := do
     let type ← normExpr decl.type
     let params ← normParams decl.params
     let value ← normCodeImp decl.value
     decl.update type params value
 
-  partial def normCodeImp (code : Code) : ReaderT FVarSubst CompilerM Code := do
+  partial def normCodeImp (code : Code) : NormalizerM t Code := do
     match code with
     | .let decl k => return code.updateLet! (← normLetDecl decl) (← normCodeImp k)
     | .fun decl k | .jp decl k => return code.updateFun! (← normFunDeclImp decl) (← normCodeImp k)
@@ -339,22 +410,18 @@ mutual
       return code.updateCases! resultType discr alts
 end
 
-@[inline] def normFunDecl [MonadLiftT CompilerM m] [Monad m] [MonadFVarSubst m] (decl : FunDecl) : m FunDecl := do
-  normFunDeclImp decl (← getSubst)
+@[inline] def normFunDecl [MonadLiftT CompilerM m] [Monad m] [MonadFVarSubst m t] (decl : FunDecl) : m FunDecl := do
+  normFunDeclImp (t := t) decl (← getSubst)
 
 /-- Similar to `internalize`, but does not refresh `FVarId`s. -/
-@[inline] def normCode [MonadLiftT CompilerM m] [Monad m] [MonadFVarSubst m] (code : Code) : m Code := do
-  normCodeImp code (← getSubst)
+@[inline] def normCode [MonadLiftT CompilerM m] [Monad m] [MonadFVarSubst m t] (code : Code) : m Code := do
+  normCodeImp (t := t) code (← getSubst)
 
-def replaceExprFVars (e : Expr) (s : FVarSubst) : CompilerM Expr :=
-  (normExpr e : ReaderT FVarSubst CompilerM Expr).run s
+def replaceExprFVars (e : Expr) (s : FVarSubst) (translator : Bool) : CompilerM Expr :=
+  (normExpr e : NormalizerM translator Expr).run s
 
-def replaceFVars (code : Code) (s : FVarSubst) : CompilerM Code :=
-  (normCode code : ReaderT FVarSubst CompilerM Code).run s
-
-def replaceFVar (code : Code) (fvarId fvarId' : FVarId) : CompilerM Code :=
-  let s : FVarSubst := {}
-  replaceFVars code (s.insert fvarId (.fvar fvarId'))
+def replaceFVars (code : Code) (s : FVarSubst) (translator : Bool) : CompilerM Code :=
+  (normCode code : NormalizerM translator Code).run s
 
 def mkFreshJpName : CompilerM Name := do
   mkFreshBinderName `_jp

stage0/src/Lean/Compiler/LCNF/Main.lean

@@ -56,7 +56,13 @@ def checkpoint (stepName : Name) (decls : Array Decl) : CompilerM Unit := do
 
 namespace PassManager
 
-def run (declNames : Array Name) : CompilerM (Array Decl) := do
+def run (declNames : Array Name) : CompilerM (Array Decl) := withAtLeastMaxRecDepth 8192 do
+  /-
+  Note: we need to increase the recursion depth because we currently do to save phase1
+  declarations in .olean files. Then, we have to recursively compile all dependencies,
+  and it often creates a very deep recursion.
+  Moreover, some declarations get very big during simplification.
+  -/
   let declNames ← declNames.filterM (shouldGenerateCode ·)
   if declNames.isEmpty then return #[]
   let mut decls ← declNames.mapM toDecl

stage0/src/Lean/Compiler/LCNF/PrettyPrinter.lean

@@ -42,7 +42,10 @@ def ppArg (e : Expr) : M Format := do
   if e.isFVar then
     ppFVar e.fvarId!
   else if pp.explicit.get (← getOptions) then
-    ppExpr e
+    if e.isConst || e.isProp || e.isType0 then
+      ppExpr e
+    else
+      return Format.paren (←  ppExpr e)
   else
     return "_"
 
@@ -112,4 +115,15 @@ def ppFunDecl (decl : FunDecl) : CompilerM Format :=
   PP.run do
     return f!"fun {decl.binderName}{← PP.ppParams decl.params} :={indentD (← PP.ppCode decl.value)}"
 
+/--
+Similar to `ppDecl`, but in `CoreM`, and it does not assume
+`decl` has already been internalized.
+-/
+def ppDecl' (decl : Decl) : CoreM Format := do
+  go |>.run {}
+where
+  go : CompilerM Format := do
+    let decl ← decl.internalize
+    ppDecl decl
+
 end Lean.Compiler.LCNF

stage0/src/Lean/Compiler/LCNF/Simp.lean

@@ -199,9 +199,12 @@ structure State where
 
 abbrev SimpM := ReaderT Context $ StateRefT State CompilerM
 
-instance : MonadFVarSubst SimpM where
+instance : MonadFVarSubst SimpM false where
   getSubst := return (← get).subst
 
+instance : MonadFVarSubstState SimpM where
+  modifySubst f := modify fun s => { s with subst := f s.subst }
+
 /--
 Use `findExpr`, and if the result is a free variable, check whether it is in the map `discrCtorMap`.
 We use this method when simplifying projections and cases-constructor.
@@ -323,12 +326,14 @@ Result of `inlineCandidate?`.
 It contains information for inlining local and global functions.
 -/
 structure InlineCandidateInfo where
-  isLocal : Bool
-  params  : Array Param
+  isLocal  : Bool
+  params   : Array Param
   /-- Value (lambda expression) of the function to be inlined. -/
-  value   : Code
-  f       : Expr
-  args    : Array Expr
+  value    : Code
+  f        : Expr
+  args     : Array Expr
+  /-- `ifReduce = true` if the declaration being inlined was tagged with `inlineIfReduce`. -/
+  ifReduce : Bool
 
 /-- The arity (aka number of parameters) of the function to be inlined. -/
 def InlineCandidateInfo.arity : InlineCandidateInfo → Nat
@@ -380,15 +385,16 @@ def inlineCandidate? (e : Expr) : SimpM (Option InlineCandidateInfo) := do
     if inlineIfReduce then
       let some paramIdx := isCasesOnParam? decl | return none
       unless paramIdx < numArgs do return none
-      let arg ← findCtor (e.getArg! paramIdx)
+      let arg ← findExpr (e.getArg! paramIdx)
       unless arg.isConstructorApp (← getEnv) do return none
     let params := decl.instantiateParamsLevelParams us
     let value := decl.instantiateValueLevelParams us
     incInline
     return some {
-      isLocal := false
-      f       := e.getAppFn
-      args    := e.getAppArgs
+      isLocal  := false
+      f        := e.getAppFn
+      args     := e.getAppArgs
+      ifReduce := inlineIfReduce
       params, value
     }
   else if let some decl ← findFunDecl? f then
@@ -398,22 +404,16 @@ def inlineCandidate? (e : Expr) : SimpM (Option InlineCandidateInfo) := do
     incInlineLocal
     modify fun s => { s with inlineLocal := s.inlineLocal + 1 }
     return some {
-      isLocal := true
-      f       := e.getAppFn
-      args    := e.getAppArgs
-      params  := decl.params
-      value   := decl.value
+      isLocal  := true
+      f        := e.getAppFn
+      args     := e.getAppArgs
+      params   := decl.params
+      value    := decl.value
+      ifReduce := false
     }
   else
     return none
 
-/--
-Add substitution `fvarId ↦ val`. `val` is a free variable, or
-it is a type, type former, or `lcErased`.
--/
-def addSubst (fvarId : FVarId) (val : Expr) : SimpM Unit :=
-  modify fun s => { s with subst := s.subst.insert fvarId val }
-
 /--
 Return `true` if `c` has only one exit point.
 This is a quick approximation. It does not check cases
@@ -428,7 +428,7 @@ where
     match c with
     | .let _ k | .fun _ k => go k
     -- Approximation, the cases may have many unreachable alternatives, and only reachable.
-    | .cases c => c.alts.size == 1 && c.alts.any fun alt => go alt.getCode
+    | .cases c => c.alts.size == 1 && go c.alts[0]!.getCode
     -- Approximation, we assume that any code containing join points have more than one exit point
     | .jp .. | .jmp .. => false
     | .return .. | .unreach .. => true
@@ -457,7 +457,7 @@ def specializePartialApp (info : InlineCandidateInfo) : SimpM FunDecl := do
     subst := subst.insert param.fvarId arg
   let mut paramsNew := #[]
   for param in info.params[info.args.size:] do
-    let type ← replaceExprFVars param.type subst
+    let type ← replaceExprFVars param.type subst (translator := true)
     let paramNew ← mkAuxParam type
     paramsNew := paramsNew.push paramNew
     subst := subst.insert param.fvarId (.fvar paramNew.fvarId)
@@ -465,56 +465,6 @@ def specializePartialApp (info : InlineCandidateInfo) : SimpM FunDecl := do
   updateFunDeclInfo code
   mkAuxFunDecl paramsNew code
 
-/--
-If the value of the given let-declaration is an application that can be inlined, inline it.
-
-`k` is the "continuation" for the let declaration.
--/
-partial def inlineApp? (letDecl : LetDecl) (k : Code) : SimpM (Option Code) := do
-  if k matches .unreach .. then return some k
-  let some info ← inlineCandidate? letDecl.value | return none
-  markSimplified
-  let numArgs := info.args.size
-  trace[Compiler.simp.inline] "inlining {letDecl.value}"
-  let fvarId := letDecl.fvarId
-  if numArgs < info.arity then
-    let funDecl ← specializePartialApp info
-    addSubst letDecl.fvarId (.fvar funDecl.fvarId)
-    return some (.fun funDecl k)
-  else
-    let code ← betaReduce info.params info.value info.args[:info.arity]
-    if k.isReturnOf fvarId && numArgs == info.arity then
-      /- Easy case, the continuation `k` is just returning the result of the application. -/
-      return code
-    else if oneExitPointQuick code then
-      /-
-      `code` has only one exit point, thus we can attach the continuation directly there,
-      and simplify the result.
-      -/
-      code.bind fun fvarId' => do
-        /- fvarId' is the result of the computation -/
-        if numArgs > info.arity then
-          let decl ← mkAuxLetDecl (mkAppN (.fvar fvarId') info.args[info.arity:])
-          let k ← replaceFVar k fvarId decl.fvarId
-          return .let decl k
-        else
-          replaceFVar k fvarId fvarId'
-    else
-      /-
-      `code` has multiple exit points, and the continuation is non-trivial
-      Thus, we create an auxiliary join point.
-      -/
-      let jpParam ← mkAuxParam (← inferType (mkAppN info.f info.args[:info.arity]))
-      let jpValue ← if numArgs > info.arity then
-        let decl ← mkAuxLetDecl (mkAppN (.fvar jpParam.fvarId) info.args[info.arity:])
-        let k ← replaceFVar k fvarId decl.fvarId
-        pure <| .let decl k
-      else
-        replaceFVar k fvarId jpParam.fvarId
-      let jpDecl ← mkAuxJpDecl #[jpParam] jpValue
-      let code ← code.bind fun fvarId => return .jmp jpDecl.fvarId #[.fvar fvarId]
-      return Code.jp jpDecl code
-
 /--
 Try to inline a join point.
 -/
@@ -865,11 +815,83 @@ def etaPolyApp? (letDecl : LetDecl) : OptionT SimpM FunDecl := do
   let value := mkAppN letDecl.value (params.map (.fvar ·.fvarId))
   let auxDecl ← mkAuxLetDecl value
   let funDecl ← mkAuxFunDecl params (.let auxDecl (.return auxDecl.fvarId))
-  addSubst letDecl.fvarId (.fvar funDecl.fvarId)
+  addFVarSubst letDecl.fvarId funDecl.fvarId
   eraseLetDecl letDecl
   return funDecl
 
+/--
+Similar to `Code.isReturnOf`, but taking the current substitution into account.
+-/
+def isReturnOf (c : Code) (fvarId : FVarId) : SimpM Bool := do
+  match c with
+  | .return fvarId' => return (← normFVar fvarId') == fvarId
+  | _ => return false
+
 mutual
+/--
+If the value of the given let-declaration is an application that can be inlined,
+inline it and simplify the result.
+
+`k` is the "continuation" for the let declaration, if the application is inlined,
+it will also be simplified.
+
+Note: `inlineApp?` did not use to be in this mutually recursive declaration.
+It used to be invoked by `simp`, and would return `Option Code` that would be
+then simplified by `simp`. However, this simpler architecture produced an
+exponential blowup in when processing functions such as `Lean.Elab.Deriving.Ord.mkMatch.mkAlts`.
+The key problem is that when inlining a declaration we often can reduce the number
+of exit points by simplified the inlined code, and then connecting the result to the
+continuation `k`. However, this optimization is only possible if we simplify the
+inlined code **before** we attach it to the continuation.
+-/
+partial def inlineApp? (letDecl : LetDecl) (k : Code) : SimpM (Option Code) := do
+  let some info ← inlineCandidate? letDecl.value | return none
+  let numArgs := info.args.size
+  trace[Compiler.simp.inline] "inlining {letDecl.value}"
+  let fvarId := letDecl.fvarId
+  if numArgs < info.arity then
+    let funDecl ← specializePartialApp info
+    addFVarSubst fvarId funDecl.fvarId
+    markSimplified
+    simp (.fun funDecl k)
+  else
+    let code ← betaReduce info.params info.value info.args[:info.arity]
+    if k.isReturnOf fvarId && numArgs == info.arity then
+      /- Easy case, the continuation `k` is just returning the result of the application. -/
+      markSimplified
+      simp code
+    else
+      let code ← simp code
+      if oneExitPointQuick code then
+        -- TODO: if `k` is small, we should also inline it here
+        markSimplified
+        code.bind fun fvarId' => do
+          markUsedFVar fvarId'
+          /- fvarId' is the result of the computation -/
+          if numArgs > info.arity then
+            let decl ← mkAuxLetDecl (mkAppN (.fvar fvarId') info.args[info.arity:])
+            addFVarSubst fvarId decl.fvarId
+            simp (.let decl k)
+          else
+            addFVarSubst fvarId fvarId'
+            simp k
+      -- else if info.ifReduce then
+      --  eraseCode code
+      --  return none
+      else
+        markSimplified
+        let jpParam ← mkAuxParam (← inferType (mkAppN info.f info.args[:info.arity]))
+        let jpValue ← if numArgs > info.arity then
+          let decl ← mkAuxLetDecl (mkAppN (.fvar jpParam.fvarId) info.args[info.arity:])
+          addFVarSubst fvarId decl.fvarId
+          simp (.let decl k)
+        else
+          addFVarSubst fvarId jpParam.fvarId
+          simp k
+        let jpDecl ← mkAuxJpDecl #[jpParam] jpValue
+        let code ← code.bind fun fvarId => return .jmp jpDecl.fvarId #[.fvar fvarId]
+        return Code.jp jpDecl code
+
 /--
 Simplify the given local function declaration.
 -/
@@ -901,11 +923,11 @@ partial def simpCasesOnCtor? (cases : Cases) : SimpM (Option Code) := do
       To make the code robust, we add auxiliary declarations whenever the `field` is not a free variable.
       -/
       if field.isFVar then
-        addSubst param.fvarId field
+        addFVarSubst param.fvarId field.fvarId!
       else
         let auxDecl ← mkAuxLetDecl field
         auxDecls := auxDecls.push (CodeDecl.let auxDecl)
-        addSubst param.fvarId (.fvar auxDecl.fvarId)
+        addFVarSubst param.fvarId auxDecl.fvarId
     let k ← simp k
     eraseParams params
     attachCodeDecls auxDecls k
@@ -924,14 +946,14 @@ partial def simp (code : Code) : SimpM Code := withIncRecDepth do
       simp (.fun funDecl k)
     else if decl.value.isFVar then
       /- Eliminate `let _x_i := _x_j;` -/
-      addSubst decl.fvarId decl.value
+      addFVarSubst decl.fvarId decl.value.fvarId!
       eraseLetDecl decl
       simp k
     else if let some code ← inlineApp? decl k then
       eraseLetDecl decl
-      simp code
+      return code
     else if let some (decls, fvarId) ← inlineProjInst? decl.value then
-      addSubst decl.fvarId (.fvar fvarId)
+      addFVarSubst decl.fvarId fvarId
       eraseLetDecl decl
       let k ← simp k
       attachCodeDecls decls k
@@ -956,7 +978,7 @@ partial def simp (code : Code) : SimpM Code := withIncRecDepth do
     else
       /-
       Note that functions in `decl` will be marked as used even if `decl` is not actually used.
-      They will only be deleted in the next pass.
+      They will only be deleted in the next pass. TODO: investigate whether this is a problem.
       -/
       if code.isFun then
         if decl.isEtaExpandCandidate then

stage0/src/Lean/Compiler/LCNF/ToLCNF.lean

@@ -113,7 +113,7 @@ where
                 let mut jpArgs := #[]
                 /- Remark: `funDecl.params.size` may be greater than `args.size`. -/
                 for param in funDecl.params[:args.size] do
-                  let type ← replaceExprFVars param.type subst
+                  let type ← replaceExprFVars param.type subst (translator := true)
                   let paramNew ← mkAuxParam type
                   jpParams := jpParams.push paramNew
                   let arg := .fvar paramNew.fvarId

stage0/src/Lean/Compiler/LCNF/Types.lean

@@ -268,8 +268,8 @@ Return `true` if `type` is a LCNF type former type.
 Remark: This is faster than `Lean.Meta.isTypeFormer`, as this
         assumes that the input `type` is an LCNF type.
 -/
-def isTypeFormerType (type : Expr) : Bool :=
-  match type with
+partial def isTypeFormerType (type : Expr) : Bool :=
+  match type.headBeta with
   | .sort .. => true
   | .forallE _ _ b _ => isTypeFormerType b
   | _ => false

stage0/src/Lean/Elab/Tactic/BuiltinTactic.lean

@@ -351,46 +351,33 @@ private def getCaseGoals (tag : TSyntax ``binderIdent) : TacticM (MVarId × List
   return (g, gs.erase g)
 
 @[builtinTactic «case»] def evalCase : Tactic
-  -- | stx@`(tactic| case $args|* =>%$arr $tac:tacticSeq) =>
-  | stx =>
-    let (args, arr, tac) := if stx[1].isOfKind ``binderIdent then
-      (#[mkNode ``caseArg #[stx[1], stx[2]]], stx[3], stx[4])
-    else
-      (stx[1].getArgs.map (⟨·⟩), stx[2], stx[3])
-    for arg in args do
-      match arg with
-      | `(caseArg| $tag $hs*) =>
-        let (g, gs) ← getCaseGoals tag
-        let g ← renameInaccessibles g hs
-        setGoals [g]
-        g.setTag Name.anonymous
-        withCaseRef arr tac do
-          closeUsingOrAdmit (withTacticInfoContext stx (evalTactic tac))
-        setGoals gs
-      | _ => throwUnsupportedSyntax
-  -- | _ => throwUnsupportedSyntax
+  | stx@`(tactic| case $[$tag $hs*]|* =>%$arr $tac:tacticSeq) =>
+    for tag in tag, hs in hs do
+      let (g, gs) ← getCaseGoals tag
+      let g ← renameInaccessibles g hs
+      setGoals [g]
+      g.setTag Name.anonymous
+      withCaseRef arr tac do
+        closeUsingOrAdmit (withTacticInfoContext stx (evalTactic tac))
+      setGoals gs
+  | _ => throwUnsupportedSyntax
 
 @[builtinTactic «case'»] def evalCase' : Tactic
-  -- | `(tactic| case' $args|* =>%$arr $tac:tacticSeq) =>
-  | stx =>
-    let (args, arr, tac) := if stx[1].isOfKind ``binderIdent then
-      (#[mkNode ``caseArg #[stx[1], stx[2]]], stx[3], stx[4])
-    else
-      (stx[1].getArgs.map (⟨·⟩), stx[2], stx[3])
-    for arg in args do
-      match arg with
-      | `(caseArg| $tag $hs*) =>
-        let (g, gs) ← getCaseGoals tag
-        let g ← renameInaccessibles g hs
-        let mvarTag ← g.getTag
-        setGoals [g]
-        withCaseRef arr tac (evalTactic tac)
-        let gs' ← getUnsolvedGoals
-        if let [g'] := gs' then
-          g'.setTag mvarTag
-        setGoals (gs' ++ gs)
-      | _ => throwUnsupportedSyntax
-  -- | _ => throwUnsupportedSyntax
+  | `(tactic| case' $[$tag $hs*]|* =>%$arr $tac:tacticSeq) => do
+    let mut acc := #[]
+    for tag in tag, hs in hs do
+      let (g, gs) ← getCaseGoals tag
+      let g ← renameInaccessibles g hs
+      let mvarTag ← g.getTag
+      setGoals [g]
+      withCaseRef arr tac (evalTactic tac)
+      let gs' ← getUnsolvedGoals
+      if let [g'] := gs' then
+        g'.setTag mvarTag
+      acc := acc ++ gs'
+      setGoals gs
+    setGoals (acc.toList ++ (← getGoals))
+  | _ => throwUnsupportedSyntax
 
 @[builtinTactic «renameI»] def evalRenameInaccessibles : Tactic
   | `(tactic| rename_i $hs*) => do replaceMainGoal [← renameInaccessibles (← getMainGoal) hs]

stage0/src/Lean/Elab/Tactic/Injection.lean

@@ -14,9 +14,9 @@ private def getInjectionNewIds (stx : Syntax) : List Name :=
   else
     stx[1].getArgs.toList.map getNameOfIdent'
 
-private def checkUnusedIds (mvarId : MVarId) (unusedIds : List Name) : MetaM Unit :=
+private def checkUnusedIds (tacticName : Name) (mvarId : MVarId) (unusedIds : List Name) : MetaM Unit :=
   unless unusedIds.isEmpty do
-    Meta.throwTacticEx `injection mvarId m!"too many identifiers provided, unused: {unusedIds}"
+    Meta.throwTacticEx tacticName mvarId m!"too many identifiers provided, unused: {unusedIds}"
 
 @[builtinTactic «injection»] def evalInjection : Tactic := fun stx => do
   -- leading_parser nonReservedSymbol "injection " >> termParser >> withIds
@@ -24,13 +24,14 @@ private def checkUnusedIds (mvarId : MVarId) (unusedIds : List Name) : MetaM Uni
   let ids := getInjectionNewIds stx[2]
   liftMetaTactic fun mvarId => do
     match (← Meta.injection mvarId fvarId ids) with
-    | Meta.InjectionResult.solved                      => checkUnusedIds mvarId ids; return []
-    | Meta.InjectionResult.subgoal mvarId' _ unusedIds => checkUnusedIds mvarId unusedIds; return [mvarId']
+    | .solved                      => checkUnusedIds `injection mvarId ids; return []
+    | .subgoal mvarId' _ unusedIds => checkUnusedIds `injection mvarId unusedIds; return [mvarId']
 
-@[builtinTactic «injections»] def evalInjections : Tactic := fun _ => do
+@[builtinTactic «injections»] def evalInjections : Tactic := fun stx => do
+  let ids := stx[1].getArgs.toList.map getNameOfIdent'
   liftMetaTactic fun mvarId => do
-    match (← Meta.injections mvarId) with
-    | none => return []
-    | some mvarId => return [mvarId]
+    match (← Meta.injections mvarId ids) with
+    | .solved                    => checkUnusedIds `injections mvarId ids; return []
+    | .subgoal mvarId' unusedIds => checkUnusedIds `injections mvarId unusedIds; return [mvarId']
 
 end Lean.Elab.Tactic

stage0/src/Lean/Environment.lean

@@ -52,9 +52,15 @@ instance : Nonempty EnvExtensionEntry := EnvExtensionEntrySpec.property
 /-- Content of a .olean file.
    We use `compact.cpp` to generate the image of this object in disk. -/
 structure ModuleData where
-  imports    : Array Import
-  constants  : Array ConstantInfo
-  entries    : Array (Name × Array EnvExtensionEntry)
+  imports         : Array Import
+  constants       : Array ConstantInfo
+  /--
+  Extra entries for the `const2ModIdx` map in the `Environment` object.
+  The code generator creates auxiliary declarations that are not in the
+  mapping `constants`, but we want to know in which module they were generated.
+  -/
+  extraConstNames : Array Name
+  entries         : Array (Name × Array EnvExtensionEntry)
   deriving Inhabited
 
 /-- Environment fields that are not used often. -/
@@ -116,6 +122,12 @@ structure Environment where
   Environment extensions. It also includes user-defined extensions.
   -/
   extensions   : Array EnvExtensionState
+  /--
+  Constant names to be saved in the field `extraConstNames` at `ModuleData`.
+  It contains auxiliary declaration names created by the code generator which are not in `constants`.
+  When importing modules, we want to insert them at `const2ModIdx`.
+  -/
+  extraConstNames : NameSet
   /-- The header contains additional information that is not updated often. -/
   header       : EnvironmentHeader := {}
   deriving Inhabited
@@ -125,6 +137,17 @@ namespace Environment
 def addAux (env : Environment) (cinfo : ConstantInfo) : Environment :=
   { env with constants := env.constants.insert cinfo.name cinfo }
 
+/--
+Save an extra constant name that is used to populate `const2ModIdx` when we import
+.olean files. We use this feature to save in which module an auxiliary declaration
+created by the code generator has been created.
+-/
+def addExtraName (env : Environment) (name : Name) : Environment :=
+  if env.constants.contains name then
+    env
+  else
+    { env with extraConstNames := env.extraConstNames.insert name }
+
 @[export lean_environment_find]
 def find? (env : Environment) (n : Name) : Option ConstantInfo :=
   /- It is safe to use `find'` because we never overwrite imported declarations. -/
@@ -197,12 +220,12 @@ end Environment
 
 /-- Interface for managing environment extensions. -/
 structure EnvExtensionInterface where
-  ext              : Type → Type
-  inhabitedExt {σ} : Inhabited σ → Inhabited (ext σ)
-  registerExt  {σ} (mkInitial : IO σ) : IO (ext σ)
-  setState     {σ} (e : ext σ) (env : Environment) : σ → Environment
-  modifyState  {σ} (e : ext σ) (env : Environment) : (σ → σ) → Environment
-  getState     {σ} [Inhabited σ] (e : ext σ) (env : Environment) : σ
+  ext          : Type → Type
+  inhabitedExt : Inhabited σ → Inhabited (ext σ)
+  registerExt  (mkInitial : IO σ) : IO (ext σ)
+  setState     (e : ext σ) (env : Environment) : σ → Environment
+  modifyState  (e : ext σ) (env : Environment) : (σ → σ) → Environment
+  getState     [Inhabited σ] (e : ext σ) (env : Environment) : σ
   mkInitialExtStates : IO (Array EnvExtensionState)
   ensureExtensionsSize : Environment → IO Environment
 
@@ -332,10 +355,11 @@ def mkEmptyEnvironment (trustLevel : UInt32 := 0) : IO Environment := do
   if initializing then throw (IO.userError "environment objects cannot be created during initialization")
   let exts ← mkInitialExtensionStates
   pure {
-    const2ModIdx := {},
-    constants    := {},
-    header       := { trustLevel := trustLevel },
-    extensions   := exts
+    const2ModIdx    := {}
+    constants       := {}
+    header          := { trustLevel := trustLevel }
+    extraConstNames := {}
+    extensions      := exts
   }
 
 structure PersistentEnvExtensionState (α : Type) (σ : Type) where
@@ -587,9 +611,10 @@ def mkModuleData (env : Environment) : IO ModuleData := do
       result.push (extName, exportEntriesFn state))
     #[]
   pure {
-    imports    := env.header.imports,
-    constants  := env.constants.foldStage2 (fun cs _ c => cs.push c) #[],
-    entries    := entries
+    imports         := env.header.imports
+    constants       := env.constants.foldStage2 (fun cs _ c => cs.push c) #[]
+    extraConstNames := env.extraConstNames.toArray
+    entries         := entries
   }
 
 @[export lean_write_module]
@@ -676,18 +701,21 @@ partial def importModules (imports : List Import) (opts : Options) (trustLevel :
         | (constantMap', replaced) =>
           constantMap := constantMap'
           if replaced then throw (IO.userError s!"import failed, environment already contains '{cinfo.name}'")
-       modIdx := modIdx + 1
+      for cname in mod.extraConstNames do
+        const2ModIdx := const2ModIdx.insert cname modIdx
+      modIdx := modIdx + 1
     let constants : ConstMap := SMap.fromHashMap constantMap false
     let exts ← mkInitialExtensionStates
     let env : Environment := {
-      const2ModIdx := const2ModIdx,
-      constants    := constants,
-      extensions   := exts,
-      header       := {
-        quotInit     := !imports.isEmpty, -- We assume `core.lean` initializes quotient module
-        trustLevel   := trustLevel,
-        imports      := imports.toArray,
-        regions      := s.regions,
+      const2ModIdx    := const2ModIdx
+      constants       := constants
+      extraConstNames := {}
+      extensions      := exts
+      header          := {
+        quotInit     := !imports.isEmpty -- We assume `core.lean` initializes quotient module
+        trustLevel   := trustLevel
+        imports      := imports.toArray
+        regions      := s.regions
         moduleNames  := s.moduleNames
         moduleData   := s.moduleData
       }
@@ -727,8 +755,8 @@ Environment extension for tracking all `namespace` declared by users.
 -/
 builtin_initialize namespacesExt : SimplePersistentEnvExtension Name NameSSet ←
   registerSimplePersistentEnvExtension {
-    name            := `namespaces,
-    addImportedFn   := fun as => mkStateFromImportedEntries NameSSet.insert NameSSet.empty as |>.switch,
+    name            := `namespaces
+    addImportedFn   := fun as => mkStateFromImportedEntries NameSSet.insert NameSSet.empty as |>.switch
     addEntryFn      := fun s n => s.insert n
   }
 

stage0/src/Lean/Expr.lean

@@ -291,36 +291,53 @@ instance : Inhabited (MVarIdMap α) where
   default := {}
 
 /--
-Lean expressions. This datastructure is used in the kernel and
+Lean expressions. This data structure is used in the kernel and
 elaborator. However, expressions sent to the kernel should not
 contain metavariables.
 
 Remark: we use the `E` suffix (short for `Expr`) to avoid collision with keywords.
-We considered using «...», but it is too inconvenient to use. -/
+We considered using «...», but it is too inconvenient to use.
+-/
 inductive Expr where
   /--
-  Bound variables. The natural number is the "de Bruijn" index
-  for the bound variable. See https://en.wikipedia.org/wiki/De_Bruijn_index for additional information.
-  Example, the expression `fun x : Nat => forall y : Nat, x = y`
+  The `bvar` constructor represents bound variables, i.e. occurrences
+  of a variable in the expression where there is a variable binder
+  above it (i.e. introduced by a `lam`, `forallE`, or `letE`).
+
+  The `deBruijnIndex` parameter is the *de-Bruijn* index for the bound
+  variable. See [here](https://en.wikipedia.org/wiki/De_Bruijn_index)
+  for additional information on de-Bruijn indexes.
+
+  For example, consider the expression `fun x : Nat => forall y : Nat, x = y`.
+  The `x` and `y` variables in the equality expression are constructed
+  using `bvar` and bound to the binders introduced by the earlier
+  `lam` and `forallE` constructors. Here is the corresponding `Expr` representation
+  for the same expression:
   ```lean
   .lam `x (.const `Nat [])
-    (.forall `y (.const `Nat [])
-      (.app (.app (.app (.const `Eq [.succ .zero])
-                  (.const `Nat [])) (.bvar 1))
-            (.bvar 0))
+    (.forallE `y (.const `Nat [])
+      (.app (.app (.app (.const `Eq [.succ .zero]) (.const `Nat [])) (.bvar 1)) (.bvar 0))
       .default)
     .default
   ```
   -/
   | bvar (deBruijnIndex : Nat)
+
   /--
-  Free variable. Lean uses the locally nameless approach.
-  See https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.365.2479&rep=rep1&type=pdf for additional details.
-  When "visiting" the body of a binding expression (`lam`, `forallE`, or `letE`), bound variables
-  are converted into free variables using a unique identifier, and their user-facing name, type,
-  value (for `LetE`), and binder annotation are stored in the `LocalContext`.
+  The `fvar` constructor represent free variables. These /free/ variable
+  occurrences are not bound by an earlier `lam`, `forallE`, or `letE`
+  contructor and its binder exists in a local context only.
+
+  Note that Lean uses the /locally nameless approach/. See [here](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.365.2479&rep=rep1&type=pdf)
+  for additional details.
+
+  When "visiting" the body of a binding expression (i.e. `lam`, `forallE`, or `letE`),
+  bound variables are converted into free variables using a unique identifier,
+  and their user-facing name, type, value (for `LetE`), and binder annotation
+  are stored in the `LocalContext`.
   -/
   | fvar (fvarId : FVarId)
+
   /--
   Metavariables are used to represent "holes" in expressions, and goals in the
   tactic framework. Metavariable declarations are stored in the `MetavarContext`.
@@ -328,89 +345,110 @@ inductive Expr where
   or in the code generator.
   -/
   | mvar (mvarId : MVarId)
+
   /--
-  `Type u`, `Sort u`, `Prop`.    -
+  Used for `Type u`, `Sort u`, and `Prop`:
   - `Prop` is represented as `.sort .zero`,
   - `Sort u` as ``.sort (.param `u)``, and
   - `Type u` as ``.sort (.succ (.param `u))``
   -/
   | sort (u : Level)
+
   /--
-  A (universe polymorphic) constant. For example,
-  `@Eq.{1}` is represented as ``.const `Eq [.succ .zero]``, and
-  `@Array.map.{0, 0}` is represented as ``.const `Array.map [.zero, .zero]``.
+  A (universe polymorphic) constant that has been defined earlier in the module or
+  by another imported module. For example, `@Eq.{1}` is represented
+  as ``Expr.const `Eq [.succ .zero]``, and `@Array.map.{0, 0}` is represented
+  as ``Expr.const `Array.map [.zero, .zero]``.
   -/
   | const (declName : Name) (us : List Level)
+
   /--
-  Function application. `Nat.succ Nat.zero` is represented as
-  ```
-  .app (.const `Nat.succ []) (.const .zero [])
-  ```
+  A function application.
+
+  For example, the natural number one, i.e. `Nat.succ Nat.zero` is represented as
+  `Expr.app (.const `Nat.succ []) (.const .zero [])`
+  Note that multiple arguments are represented using partial application.
+
+  For example, the two argument application `f x y` is represented as
+  `Expr.app (.app f x) y`.
   -/
   | app (fn : Expr) (arg : Expr)
+
   /--
-  Lambda abstraction (aka anonymous functions).
-  - `fun x : Nat => x` is represented as
+  A lambda abstraction (aka anonymous functions). It introduces a new binder for
+  variable `x` in scope for the lambda body.
+
+  For example, the expression `fun x : Nat => x` is represented as
   ```
-  .lam `x (.const `Nat []) (.bvar 0) .default
+  Expr.lam `x (.const `Nat []) (.bvar 0) .default
   ```
   -/
   | lam (binderName : Name) (binderType : Expr) (body : Expr) (binderInfo : BinderInfo)
+
   /--
-  A dependent arrow (aka forall-expression). It is also used to represent non-dependent arrows.
-  Examples:
-  - `forall x : Prop, x ∧ x` is represented as
+  A dependent arrow `(a : α) → β)` (aka forall-expression) where `β` may dependent
+  on `a`. Note that this constructor is also used to represent non-dependent arrows
+  where `β` does not depend on `a`.
+
+  For example:
+  - `forall x : Prop, x ∧ x`:
+  ```lean
+  Expr.forallE `x (.sort .zero)
+    (.app (.app (.const `And []) (.bvar 0)) (.bvar 0)) .default
   ```
-  .forallE `x
-     (.sort .zero)
-     (.app (.app (.const `And []) (.bvar 0)) (.bvar 0))
-     .default
-  ```
-  - `Nat → Bool` as
-  ```
-  .forallE `a (.const `Nat []) (.const `Bool []) .default
+  - `Nat → Bool`:
+  ```lean
+  Expr.forallE `a (.const `Nat [])
+    (.const `Bool []) .default
   ```
   -/
   | forallE (binderName : Name) (binderType : Expr) (body : Expr) (binderInfo : BinderInfo)
-  /--
-  Let-expressions. The field `nonDep` is not currently used, but will be used in the future
-  by the code generator (and possibly `simp`) to track whether a let-expression is non-dependent
-  or not.
 
-  **IMPORTANT**: This flag is for "local" use only. That is, a module should not "trust" its value for any purpose.
+  /--
+  Let-expressions.
+
+  **IMPORTANT**: The `nonDep` flag is for "local" use only. That is, a module should not "trust" its value for any purpose.
   In the intended use-case, the compiler will set this flag, and be responsible for maintaining it.
   Other modules may not preserve its value while applying transformations.
 
-  Given an environment, metavariable context, and local context, we say a let-expression
-  `let x : t := v; e` is non-dependent when it is equivalent to `(fun x : t => e) v`.
-  Here is an example of a dependent let-expression
-  `let n : Nat := 2; fun (a : Array Nat n) (b : Array Nat 2) => a = b` is type correct, but
-  `(fun (n : Nat) (a : Array Nat n) (b : Array Nat 2) => a = b) 2` is not.
+  Given an environment, a metavariable context, and a local context,
+  we say a let-expression `let x : t := v; e` is non-dependent when it is equivalent
+  to `(fun x : t => e) v`. Here is an example of a dependent let-expression
+  `let n : Nat := 2; fun (a : Array Nat n) (b : Array Nat 2) => a = b` is type correct,
+  but `(fun (n : Nat) (a : Array Nat n) (b : Array Nat 2) => a = b) 2` is not.
+
   The let-expression `let x : Nat := 2; Nat.succ x` is represented as
   ```
-  .letE `x (.const `Nat []) (.lit (.natVal 2)) (.bvar 0) true
+  Expr.letE `x (.const `Nat []) (.lit (.natVal 2)) (.bvar 0) true
   ```
   -/
   | letE (declName : Name) (type : Expr) (value : Expr) (body : Expr) (nonDep : Bool)
+
   /--
-  Natural number and string literal values. They are not really needed, but provide a more
-  compact representation in memory for these two kinds of literals, and are used to implement
-  efficient reduction in the elaborator and kernel.
-  The "raw" natural number `2` can be represented as `.lit (.natVal 2)`. Note that, it is
-  definitionally equal to
-  ```
-  .app (.const `Nat.succ []) (.app (.const `Nat.succ []) (.const `Nat.zero []))
+  Natural number and string literal values.
+
+  They are not really needed, but provide a more compact representation in memory
+  for these two kinds of literals, and are used to implement efficient reduction
+  in the elaborator and kernel. The "raw" natural number `2` can be represented
+  as `Expr.lit (.natVal 2)`. Note that, it is definitionally equal to:
+  ```lean
+  Expr.app (.const `Nat.succ []) (.app (.const `Nat.succ []) (.const `Nat.zero []))
   ```
   -/
-  | lit     : Literal → Expr
+  | lit : Literal → Expr
+
   /--
-  Metadata (aka annotations). We use annotations to provide hints to the pretty-printer,
+  Metadata (aka annotations).
+
+  We use annotations to provide hints to the pretty-printer,
   store references to `Syntax` nodes, position information, and save information for
   elaboration procedures (e.g., we use the `inaccessible` annotation during elaboration to
   mark `Expr`s that correspond to inaccessible patterns).
-  Note that `.mdata data e` is definitionally equal to `e`.
+
+  Note that `Expr.mdata data e` is definitionally equal to `e`.
   -/
   | mdata (data : MData) (expr : Expr)
+
   /--
   Projection-expressions. They are redundant, but are used to create more compact
   terms, speedup reduction, and implement eta for structures.
@@ -420,6 +458,7 @@ inductive Expr where
   is valid (i.e., it is smaller than the numbef of constructor fields).
   When exporting Lean developments to other systems, `proj` can be replaced with `typeName`.`rec`
   applications.
+
   Example, given `a : Nat x Bool`, `a.1` is represented as
   ```
   .proj `Prod 0 a
@@ -756,6 +795,11 @@ def isType : Expr → Bool
   | sort (.succ ..) => true
   | _ => false
 
+/-- Return `true` if the given expression is of the form `.sort (.succ .zero)`. -/
+def isType0 : Expr → Bool
+  | sort (.succ .zero) => true
+  | _ => false
+
 /-- Return `true` if the given expression is a `.sort .zero` -/
 def isProp : Expr → Bool
   | sort (.zero ..) => true

stage0/src/Lean/Meta/Match/MatchEqs.lean

@@ -188,8 +188,8 @@ partial def trySubstVarsAndContradiction (mvarId : MVarId) : MetaM Bool :=
   commitWhen do
     let mvarId ← substVars mvarId
     match (← injections mvarId) with
-    | none => return true -- closed goal
-    | some mvarId' =>
+    | .solved => return true -- closed goal
+    | .subgoal mvarId' _ =>
       if mvarId' == mvarId then
         contradiction mvarId
       else

stage0/src/Lean/Meta/Tactic/Injection.lean

@@ -89,30 +89,34 @@ def injectionIntro (mvarId : MVarId) (numEqs : Nat) (newNames : List Name) (tryT
 
 def injection (mvarId : MVarId) (fvarId : FVarId) (newNames : List Name := []) : MetaM InjectionResult := do
   match (← injectionCore mvarId fvarId) with
-  | InjectionResultCore.solved                => pure InjectionResult.solved
-  | InjectionResultCore.subgoal mvarId numEqs => injectionIntro mvarId numEqs newNames
+  | .solved                => pure .solved
+  | .subgoal mvarId numEqs => injectionIntro mvarId numEqs newNames
 
-partial def injections (mvarId : MVarId) (maxDepth : Nat := 5) : MetaM (Option MVarId) :=
+inductive InjectionsResult where
+  | solved
+  | subgoal (mvarId : MVarId) (remainingNames : List Name)
+
+partial def injections (mvarId : MVarId) (newNames : List Name := []) (maxDepth : Nat := 5) : MetaM InjectionsResult :=
   mvarId.withContext do
     let fvarIds := (← getLCtx).getFVarIds
-    go maxDepth fvarIds.toList mvarId
+    go maxDepth fvarIds.toList mvarId newNames
 where
-  go : Nat → List FVarId → MVarId → MetaM (Option MVarId)
-    | 0,   _,  _      => throwTacticEx `injections mvarId "recursion depth exceeded"
-    | _,   [], mvarId => return mvarId
-    | d+1, fvarId :: fvarIds, mvarId => do
+  go : Nat → List FVarId → MVarId → List Name → MetaM InjectionsResult
+    | 0,   _,  _,      _        => throwTacticEx `injections mvarId "recursion depth exceeded"
+    | _,   [], mvarId, newNames => return .subgoal mvarId newNames
+    | d+1, fvarId :: fvarIds, mvarId, newNames => do
       let cont := do
-        go (d+1) fvarIds mvarId
+        go (d+1) fvarIds mvarId newNames
       if let some (_, lhs, rhs) ← matchEqHEq? (← fvarId.getType) then
         let lhs ← whnf lhs
         let rhs ← whnf rhs
         if lhs.isNatLit && rhs.isNatLit then cont
         else
           try
-            match (← injection mvarId fvarId) with
-            | InjectionResult.solved  => return none
-            | InjectionResult.subgoal mvarId newEqs _ =>
-              mvarId.withContext <| go d (newEqs.toList ++ fvarIds) mvarId
+            match (← injection mvarId fvarId newNames) with
+            | .solved  => return .solved
+            | .subgoal mvarId newEqs remainingNames =>
+              mvarId.withContext <| go d (newEqs.toList ++ fvarIds) mvarId remainingNames
           catch _ => cont
       else cont
 

stage0/src/stdlib_flags.h

@@ -8,7 +8,7 @@ options get_default_options() {
     // switch to `true` for ABI-breaking changes affecting meta code
     opts = opts.update({"interpreter", "prefer_native"}, false);
     // switch to `true` for changing built-in parsers used in quotations
-    opts = opts.update({"internal", "parseQuotWithCurrentStage"}, true);
+    opts = opts.update({"internal", "parseQuotWithCurrentStage"}, false);
     opts = opts.update({"pp", "rawOnError"}, true);
 #endif
     return opts;

stage0/stdlib/Init/NotationExtra.c

@@ -165,13 +165,11 @@ static lean_object* l_Lean___aux__Init__NotationExtra______macroRules__Lean__ter
 uint8_t lean_name_eq(lean_object*, lean_object*);
 static lean_object* l_Lean___aux__Init__NotationExtra______macroRules__Lean__command____Unif__hint____Where___x7c_x2d_u22a2____1___lambda__2___closed__21;
 static lean_object* l_term_u03a3___x2c_____closed__5;
-static lean_object* l_unexpandGetElem_x27___closed__3;
 static lean_object* l_Lean_doElemRepeat__Until_____closed__6;
 static lean_object* l_Lean___aux__Init__NotationExtra______macroRules__Lean__command____Unif__hint____Where___x7c_x2d_u22a2____1___lambda__2___closed__23;
 static lean_object* l_tacticFunext_______closed__1;
 static lean_object* l_Lean_doElemWhile__Do_____closed__6;
 LEAN_EXPORT lean_object* l___aux__Init__NotationExtra______macroRules__Lean__Parser__Command__classAbbrev__1___lambda__2(lean_object*);
-static lean_object* l_unexpandGetElem_x27___closed__1;
 static lean_object* l_Lean_command____Unif__hint____Where___x7c_x2d_u22a2_____closed__1;
 LEAN_EXPORT lean_object* l_tactic_xb7_x2e_____x3b__;
 static lean_object* l___aux__Init__NotationExtra______macroRules__term_u2203___x2c____1___closed__1;
@@ -323,7 +321,6 @@ static lean_object* l_Lean_doElemRepeat_____closed__2;
 static lean_object* l_Lean___aux__Init__NotationExtra______macroRules__Lean__command____Unif__hint____Where___x7c_x2d_u22a2____1___lambda__2___closed__29;
 uint8_t l_Lean_Name_hasMacroScopes(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_expandBrackedBinders(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_unexpandGetElem_x27___closed__2;
 static lean_object* l_Lean_command____Unif__hint____Where___x7c_x2d_u22a2_____closed__13;
 static lean_object* l___aux__Init__NotationExtra______macroRules__term_x25_x5b___x7c___x5d__1___closed__11;
 LEAN_EXPORT lean_object* l_Lean_instForInLoopUnit___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -639,7 +636,6 @@ static lean_object* l_calc___closed__5;
 static lean_object* l_Lean___aux__Init__NotationExtra______macroRules__Lean__term__Matches___x7c__1___closed__4;
 static lean_object* l_solve___closed__14;
 static lean_object* l_Lean___aux__Init__NotationExtra______macroRules__Lean__term__Matches___x7c__1___closed__8;
-LEAN_EXPORT lean_object* l_unexpandGetElem_x27(lean_object*, lean_object*, lean_object*);
 static lean_object* l_calc___closed__14;
 static lean_object* l___aux__Init__NotationExtra______macroRules__term_x25_x5b___x7c___x5d__1___closed__6;
 static lean_object* l___aux__Init__NotationExtra______macroRules__tacticFunext______1___closed__2;
@@ -11682,163 +11678,6 @@ return x_60;
 }
 }
 }
-static lean_object* _init_l_unexpandGetElem_x27___closed__1() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string_from_bytes("term__[_]'_", 11);
-return x_1;
-}
-}
-static lean_object* _init_l_unexpandGetElem_x27___closed__2() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = lean_box(0);
-x_2 = l_unexpandGetElem_x27___closed__1;
-x_3 = l_Lean_Name_str___override(x_1, x_2);
-return x_3;
-}
-}
-static lean_object* _init_l_unexpandGetElem_x27___closed__3() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string_from_bytes("]'", 2);
-return x_1;
-}
-}
-LEAN_EXPORT lean_object* l_unexpandGetElem_x27(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; uint8_t x_5; 
-x_4 = l_Lean___aux__Init__NotationExtra______macroRules__Lean__termMacro_x2etrace_x5b___x5d____1___closed__6;
-lean_inc(x_1);
-x_5 = l_Lean_Syntax_isOfKind(x_1, x_4);
-if (x_5 == 0)
-{
-lean_object* x_6; lean_object* x_7; 
-lean_dec(x_2);
-lean_dec(x_1);
-x_6 = lean_box(0);
-x_7 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_7, 0, x_6);
-lean_ctor_set(x_7, 1, x_3);
-return x_7;
-}
-else
-{
-lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; 
-x_8 = lean_unsigned_to_nat(1u);
-x_9 = l_Lean_Syntax_getArg(x_1, x_8);
-lean_dec(x_1);
-x_10 = lean_unsigned_to_nat(3u);
-lean_inc(x_9);
-x_11 = l_Lean_Syntax_matchesNull(x_9, x_10);
-if (x_11 == 0)
-{
-lean_object* x_12; lean_object* x_13; 
-lean_dec(x_9);
-lean_dec(x_2);
-x_12 = lean_box(0);
-x_13 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_13, 0, x_12);
-lean_ctor_set(x_13, 1, x_3);
-return x_13;
-}
-else
-{
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_14 = lean_unsigned_to_nat(0u);
-x_15 = l_Lean_Syntax_getArg(x_9, x_14);
-x_16 = l_Lean_Syntax_getArg(x_9, x_8);
-x_17 = lean_unsigned_to_nat(2u);
-x_18 = l_Lean_Syntax_getArg(x_9, x_17);
-lean_dec(x_9);
-x_19 = l_Lean_MonadRef_mkInfoFromRefPos___at___aux__Init__Notation______unexpand__Function__comp__1___spec__1(x_2, x_3);
-x_20 = !lean_is_exclusive(x_19);
-if (x_20 == 0)
-{
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_21 = lean_ctor_get(x_19, 0);
-x_22 = l_unexpandGetElem___closed__4;
-x_23 = l_Lean___aux__Init__NotationExtra______macroRules__Lean__termMacro_x2etrace_x5b___x5d____1___closed__29;
-lean_inc(x_21);
-x_24 = lean_alloc_ctor(1, 3, 0);
-lean_ctor_set(x_24, 0, x_21);
-lean_ctor_set(x_24, 1, x_22);
-lean_ctor_set(x_24, 2, x_23);
-x_25 = l_unexpandListNil___rarg___closed__3;
-lean_inc(x_21);
-x_26 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_26, 0, x_21);
-lean_ctor_set(x_26, 1, x_25);
-x_27 = l_unexpandGetElem_x27___closed__3;
-lean_inc(x_21);
-x_28 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_28, 0, x_21);
-lean_ctor_set(x_28, 1, x_27);
-x_29 = l_Lean___aux__Init__NotationExtra______macroRules__Lean__command____Unif__hint____Where___x7c_x2d_u22a2____1___lambda__2___closed__20;
-x_30 = lean_array_push(x_29, x_15);
-x_31 = lean_array_push(x_30, x_24);
-x_32 = lean_array_push(x_31, x_26);
-x_33 = lean_array_push(x_32, x_16);
-x_34 = lean_array_push(x_33, x_28);
-x_35 = lean_array_push(x_34, x_18);
-x_36 = l_unexpandGetElem_x27___closed__2;
-x_37 = lean_alloc_ctor(1, 3, 0);
-lean_ctor_set(x_37, 0, x_21);
-lean_ctor_set(x_37, 1, x_36);
-lean_ctor_set(x_37, 2, x_35);
-lean_ctor_set(x_19, 0, x_37);
-return x_19;
-}
-else
-{
-lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-x_38 = lean_ctor_get(x_19, 0);
-x_39 = lean_ctor_get(x_19, 1);
-lean_inc(x_39);
-lean_inc(x_38);
-lean_dec(x_19);
-x_40 = l_unexpandGetElem___closed__4;
-x_41 = l_Lean___aux__Init__NotationExtra______macroRules__Lean__termMacro_x2etrace_x5b___x5d____1___closed__29;
-lean_inc(x_38);
-x_42 = lean_alloc_ctor(1, 3, 0);
-lean_ctor_set(x_42, 0, x_38);
-lean_ctor_set(x_42, 1, x_40);
-lean_ctor_set(x_42, 2, x_41);
-x_43 = l_unexpandListNil___rarg___closed__3;
-lean_inc(x_38);
-x_44 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_44, 0, x_38);
-lean_ctor_set(x_44, 1, x_43);
-x_45 = l_unexpandGetElem_x27___closed__3;
-lean_inc(x_38);
-x_46 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_46, 0, x_38);
-lean_ctor_set(x_46, 1, x_45);
-x_47 = l_Lean___aux__Init__NotationExtra______macroRules__Lean__command____Unif__hint____Where___x7c_x2d_u22a2____1___lambda__2___closed__20;
-x_48 = lean_array_push(x_47, x_15);
-x_49 = lean_array_push(x_48, x_42);
-x_50 = lean_array_push(x_49, x_44);
-x_51 = lean_array_push(x_50, x_16);
-x_52 = lean_array_push(x_51, x_46);
-x_53 = lean_array_push(x_52, x_18);
-x_54 = l_unexpandGetElem_x27___closed__2;
-x_55 = lean_alloc_ctor(1, 3, 0);
-lean_ctor_set(x_55, 0, x_38);
-lean_ctor_set(x_55, 1, x_54);
-lean_ctor_set(x_55, 2, x_53);
-x_56 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_56, 0, x_55);
-lean_ctor_set(x_56, 1, x_39);
-return x_56;
-}
-}
-}
-}
-}
 static lean_object* _init_l_tacticFunext_______closed__1() {
 _start:
 {
@@ -20365,12 +20204,6 @@ l_unexpandGetElem_x3f___closed__2 = _init_l_unexpandGetElem_x3f___closed__2();
 lean_mark_persistent(l_unexpandGetElem_x3f___closed__2);
 l_unexpandGetElem_x3f___closed__3 = _init_l_unexpandGetElem_x3f___closed__3();
 lean_mark_persistent(l_unexpandGetElem_x3f___closed__3);
-l_unexpandGetElem_x27___closed__1 = _init_l_unexpandGetElem_x27___closed__1();
-lean_mark_persistent(l_unexpandGetElem_x27___closed__1);
-l_unexpandGetElem_x27___closed__2 = _init_l_unexpandGetElem_x27___closed__2();
-lean_mark_persistent(l_unexpandGetElem_x27___closed__2);
-l_unexpandGetElem_x27___closed__3 = _init_l_unexpandGetElem_x27___closed__3();
-lean_mark_persistent(l_unexpandGetElem_x27___closed__3);
 l_tacticFunext_______closed__1 = _init_l_tacticFunext_______closed__1();
 lean_mark_persistent(l_tacticFunext_______closed__1);
 l_tacticFunext_______closed__2 = _init_l_tacticFunext_______closed__2();

stage0/stdlib/Lean/Attributes.c

@@ -33,6 +33,7 @@ LEAN_EXPORT lean_object* l_Lean_registerTagAttribute___lambda__8___boxed(lean_ob
 static lean_object* l___auto____x40_Lean_Attributes___hyg_97____closed__31;
 LEAN_EXPORT lean_object* l_Lean_instInhabitedTagAttribute___lambda__4___boxed(lean_object*);
 static lean_object* l_Lean_mkAttributeImplOfBuilder___closed__1;
+LEAN_EXPORT lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT uint8_t l_Std_AssocList_contains___at_Lean_registerAttributeImplBuilder___spec__2(lean_object*, lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_instInhabitedTagAttribute___lambda__1(lean_object*, lean_object*, lean_object*);
@@ -42,7 +43,6 @@ lean_object* l_Std_RBNode_insert___at_Lean_NameSet_insert___spec__1(lean_object*
 lean_object* l_Lean_PersistentEnvExtension_getModuleEntries___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Attribute_add___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlMAux___at_Lean_mkModuleData___spec__3___rarg(lean_object*, lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_registerParametricAttribute___rarg___lambda__7___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_NameSet_instInhabitedNameSet;
 LEAN_EXPORT lean_object* l_Std_RBNode_find___at_Lean_ParametricAttribute_getParam_x3f___spec__1(lean_object*);
@@ -98,6 +98,7 @@ static lean_object* l_Lean_isAttribute___closed__1;
 static lean_object* l_Lean_getAttrParamOptPrio___closed__1;
 LEAN_EXPORT lean_object* l_Lean_instMonadLiftImportMAttrM___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_name_eq(lean_object*, lean_object*);
+static lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1___closed__1;
 static lean_object* l___auto____x40_Lean_Attributes___hyg_97____closed__7;
 static lean_object* l_Lean_getBuiltinAttributeNames___closed__1;
 LEAN_EXPORT lean_object* l_Lean_registerParametricAttribute___rarg___lambda__2(lean_object*, lean_object*);
@@ -139,6 +140,7 @@ LEAN_EXPORT uint8_t l_Array_qsort_sort___at_Lean_registerParametricAttribute___s
 LEAN_EXPORT lean_object* l___auto____x40_Lean_Attributes___hyg_97_;
 LEAN_EXPORT lean_object* l___auto____x40_Lean_Attributes___hyg_1239_;
 LEAN_EXPORT lean_object* l___auto____x40_Lean_Attributes___hyg_2497_;
+LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_registerTagAttribute___lambda__6___closed__4;
 static lean_object* l___auto____x40_Lean_Attributes___hyg_97____closed__15;
 LEAN_EXPORT lean_object* l_Lean_ParametricAttributeImpl_afterSet___default___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -161,7 +163,6 @@ static lean_object* l_Lean_registerTagAttribute___lambda__4___closed__3;
 static lean_object* l___auto____x40_Lean_Attributes___hyg_97____closed__10;
 static lean_object* l___auto____x40_Lean_Attributes___hyg_97____closed__32;
 LEAN_EXPORT lean_object* l_List_mapTRAux___at_Lean_registerEnumAttributes___spec__3___rarg___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Std_RBNode_fold___at_Lean_registerTagAttribute___spec__1(lean_object*, lean_object*);
 static lean_object* l_Lean_AttributeImpl_erase___default___rarg___closed__2;
 static lean_object* l_Lean_initFn____x40_Lean_Attributes___hyg_3750____closed__6;
 LEAN_EXPORT lean_object* l_Std_RBNode_find___at_Lean_EnumAttributes_getValue___spec__1___rarg___boxed(lean_object*, lean_object*);
@@ -253,6 +254,7 @@ static lean_object* l_Lean_initFn____x40_Lean_Attributes___hyg_3750____closed__2
 LEAN_EXPORT lean_object* l_Lean_instInhabitedAttributeImpl___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_ParametricAttribute_setParam(lean_object*);
 static lean_object* l_Std_PersistentHashMap_insertAux___at_Lean_registerBuiltinAttribute___spec__2___closed__3;
+lean_object* l_Std_RBNode_fold___at_Lean_mkModuleData___spec__7(lean_object*, lean_object*);
 static lean_object* l___auto____x40_Lean_Attributes___hyg_97____closed__3;
 LEAN_EXPORT lean_object* l_Lean_instInhabitedTagAttribute;
 LEAN_EXPORT lean_object* l_Lean_AttributeImpl_erase___default(lean_object*);
@@ -299,6 +301,7 @@ lean_object* l_Std_RBNode_fold___at_Std_RBMap_size___spec__1___rarg(lean_object*
 LEAN_EXPORT uint8_t l_Lean_instInhabitedAttributeApplicationTime;
 LEAN_EXPORT lean_object* l_IO_ofExcept___at_Lean_mkAttributeImplOfBuilder___spec__3(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at___private_Lean_Attributes_0__Lean_AttributeExtension_addImported___spec__2(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 static uint32_t l_Lean_instInhabitedTagAttribute___lambda__1___closed__1;
 LEAN_EXPORT lean_object* l_Lean_instInhabitedTagAttribute___lambda__4(lean_object*);
 static lean_object* l_Lean_registerAttributeImplBuilder___closed__2;
@@ -319,19 +322,16 @@ size_t lean_usize_land(size_t, size_t);
 static lean_object* l_Lean_registerTagAttribute___lambda__4___closed__2;
 static lean_object* l_Lean_mkAttributeImplOfConstantUnsafe___closed__4;
 LEAN_EXPORT lean_object* l_Lean_ParametricAttribute_setParam___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Attribute_add(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_IO_ofExcept___at_Lean_mkAttributeImplOfBuilder___spec__3___boxed(lean_object*, lean_object*);
 static lean_object* l_Lean_Attribute_Builtin_getPrio___closed__1;
 LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Attribute_add___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___auto____x40_Lean_Attributes___hyg_97____closed__25;
-LEAN_EXPORT lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_instInhabitedExt___lambda__1(lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at___private_Lean_Attributes_0__Lean_AttributeExtension_addImported___spec__1(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_getAttributeImpl___boxed(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Std_PersistentHashMap_containsAtAux___at_Lean_registerBuiltinAttribute___spec__7___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_initFn____x40_Lean_Attributes___hyg_3750____lambda__2___boxed(lean_object*);
-LEAN_EXPORT lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Std_AssocList_replace___at_Lean_registerAttributeImplBuilder___spec__6(lean_object*, lean_object*, lean_object*);
 static lean_object* l___auto____x40_Lean_Attributes___hyg_97____closed__4;
 LEAN_EXPORT lean_object* l_Std_PersistentHashMap_foldlM___at_Lean_updateEnvAttributesImpl___spec__1(lean_object*, lean_object*, lean_object*);
@@ -346,7 +346,6 @@ static lean_object* l___auto____x40_Lean_Attributes___hyg_97____closed__27;
 static lean_object* l_Lean_registerEnumAttributes___rarg___lambda__3___closed__3;
 extern uint8_t l_instInhabitedBool;
 LEAN_EXPORT uint8_t l_Std_PersistentHashMap_contains___at_Lean_registerBuiltinAttribute___spec__5(lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_mkAttributeImplOfConstantUnsafe(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_instInhabitedAttributeImpl___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Std_PersistentHashMap_insertAtCollisionNodeAux___at_Lean_registerBuiltinAttribute___spec__4(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -497,6 +496,7 @@ static lean_object* l_Lean_registerBuiltinAttribute___closed__1;
 lean_object* l_Std_PersistentHashMap_mkCollisionNode___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_EnumAttributes_getValue(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_registerEnumAttributes___rarg(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Attribute_Builtin_getId(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -3874,32 +3874,7 @@ x_1 = l___auto____x40_Lean_Attributes___hyg_97____closed__33;
 return x_1;
 }
 }
-LEAN_EXPORT lean_object* l_Std_RBNode_fold___at_Lean_registerTagAttribute___spec__1(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-if (lean_obj_tag(x_2) == 0)
-{
-return x_1;
-}
-else
-{
-lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
-x_3 = lean_ctor_get(x_2, 0);
-lean_inc(x_3);
-x_4 = lean_ctor_get(x_2, 1);
-lean_inc(x_4);
-x_5 = lean_ctor_get(x_2, 3);
-lean_inc(x_5);
-lean_dec(x_2);
-x_6 = l_Std_RBNode_fold___at_Lean_registerTagAttribute___spec__1(x_1, x_3);
-x_7 = lean_array_push(x_6, x_4);
-x_1 = x_7;
-x_2 = x_5;
-goto _start;
-}
-}
-}
-static lean_object* _init_l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2___closed__1() {
+static lean_object* _init_l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -3910,7 +3885,7 @@ lean_ctor_set(x_2, 1, x_1);
 return x_2;
 }
 }
-LEAN_EXPORT lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+LEAN_EXPORT lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; 
@@ -3928,7 +3903,7 @@ x_9 = lean_ctor_get(x_6, 4);
 lean_dec(x_9);
 x_10 = lean_ctor_get(x_6, 0);
 lean_dec(x_10);
-x_11 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2___closed__1;
+x_11 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1___closed__1;
 lean_ctor_set(x_6, 4, x_11);
 lean_ctor_set(x_6, 0, x_1);
 x_12 = lean_st_ref_set(x_3, x_6, x_7);
@@ -3969,7 +3944,7 @@ lean_inc(x_21);
 lean_inc(x_20);
 lean_inc(x_19);
 lean_dec(x_6);
-x_24 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2___closed__1;
+x_24 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1___closed__1;
 x_25 = lean_alloc_ctor(0, 7, 0);
 lean_ctor_set(x_25, 0, x_1);
 lean_ctor_set(x_25, 1, x_19);
@@ -4001,7 +3976,7 @@ return x_30;
 }
 }
 }
-LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; lean_object* x_6; uint8_t x_7; 
@@ -4064,7 +4039,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
 x_2 = l___auto____x40_Lean_Attributes___hyg_97____closed__9;
-x_3 = l_Std_RBNode_fold___at_Lean_registerTagAttribute___spec__1(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Lean_mkModuleData___spec__7(x_2, x_1);
 x_4 = lean_array_get_size(x_3);
 x_5 = lean_unsigned_to_nat(1u);
 x_6 = lean_nat_sub(x_4, x_5);
@@ -4177,7 +4152,7 @@ x_13 = lean_ctor_get(x_11, 0);
 lean_inc(x_13);
 lean_dec(x_11);
 x_14 = l_Lean_PersistentEnvExtension_addEntry___rarg(x_3, x_13, x_2);
-x_15 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(x_14, x_5, x_6, x_12);
+x_15 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(x_14, x_5, x_6, x_12);
 lean_dec(x_6);
 lean_dec(x_5);
 return x_15;
@@ -4285,7 +4260,7 @@ x_19 = l_Lean_registerTagAttribute___lambda__6___closed__4;
 x_20 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_20, 0, x_18);
 lean_ctor_set(x_20, 1, x_19);
-x_21 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_20, x_6, x_7, x_11);
+x_21 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_20, x_6, x_7, x_11);
 lean_dec(x_7);
 lean_dec(x_6);
 x_22 = !lean_is_exclusive(x_21);
@@ -4357,7 +4332,7 @@ x_17 = l_Lean_registerTagAttribute___lambda__7___closed__2;
 x_18 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_18, 0, x_16);
 lean_ctor_set(x_18, 1, x_17);
-x_19 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_18, x_7, x_8, x_11);
+x_19 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_18, x_7, x_8, x_11);
 lean_dec(x_8);
 lean_dec(x_7);
 x_20 = !lean_is_exclusive(x_19);
@@ -4604,21 +4579,21 @@ return x_34;
 }
 }
 }
-LEAN_EXPORT lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+LEAN_EXPORT lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(x_1, x_2, x_3, x_4);
+x_5 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(x_1, x_2, x_3, x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 return x_5;
 }
 }
-LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_1, x_2, x_3, x_4);
+x_5 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_1, x_2, x_3, x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 return x_5;
@@ -5220,7 +5195,7 @@ lean_ctor_set(x_14, 0, x_2);
 lean_ctor_set(x_14, 1, x_12);
 lean_inc(x_5);
 x_15 = l_Lean_PersistentEnvExtension_addEntry___rarg(x_4, x_5, x_14);
-x_16 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(x_15, x_7, x_8, x_13);
+x_16 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(x_15, x_7, x_8, x_13);
 x_17 = lean_ctor_get(x_16, 1);
 lean_inc(x_17);
 lean_dec(x_16);
@@ -5243,7 +5218,7 @@ lean_object* x_20; lean_object* x_21;
 x_20 = lean_ctor_get(x_19, 1);
 lean_inc(x_20);
 lean_dec(x_19);
-x_21 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(x_5, x_7, x_8, x_20);
+x_21 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(x_5, x_7, x_8, x_20);
 lean_dec(x_8);
 lean_dec(x_7);
 return x_21;
@@ -5323,7 +5298,7 @@ x_20 = l_Lean_registerTagAttribute___lambda__6___closed__4;
 x_21 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_21, 0, x_19);
 lean_ctor_set(x_21, 1, x_20);
-x_22 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_21, x_7, x_8, x_12);
+x_22 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_21, x_7, x_8, x_12);
 lean_dec(x_8);
 lean_dec(x_7);
 x_23 = !lean_is_exclusive(x_22);
@@ -5370,7 +5345,7 @@ x_15 = l_Lean_registerTagAttribute___lambda__7___closed__2;
 x_16 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_16, 0, x_14);
 lean_ctor_set(x_16, 1, x_15);
-x_17 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_16, x_7, x_8, x_9);
+x_17 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_16, x_7, x_8, x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 x_18 = !lean_is_exclusive(x_17);
@@ -6483,7 +6458,7 @@ x_12 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_12, 0, x_2);
 lean_ctor_set(x_12, 1, x_3);
 x_13 = l_Lean_PersistentEnvExtension_addEntry___rarg(x_4, x_5, x_12);
-x_14 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(x_13, x_7, x_8, x_11);
+x_14 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(x_13, x_7, x_8, x_11);
 lean_dec(x_8);
 lean_dec(x_7);
 return x_14;
@@ -6562,7 +6537,7 @@ x_20 = l_Lean_registerTagAttribute___lambda__6___closed__4;
 x_21 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_21, 0, x_19);
 lean_ctor_set(x_21, 1, x_20);
-x_22 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_21, x_7, x_8, x_12);
+x_22 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_21, x_7, x_8, x_12);
 lean_dec(x_8);
 lean_dec(x_7);
 x_23 = !lean_is_exclusive(x_22);
@@ -6618,7 +6593,7 @@ x_18 = l_Lean_registerTagAttribute___lambda__7___closed__2;
 x_19 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_19, 0, x_17);
 lean_ctor_set(x_19, 1, x_18);
-x_20 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_19, x_8, x_9, x_12);
+x_20 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_19, x_8, x_9, x_12);
 lean_dec(x_9);
 lean_dec(x_8);
 x_21 = !lean_is_exclusive(x_20);
@@ -10604,8 +10579,8 @@ l_Lean_instInhabitedTagAttribute = _init_l_Lean_instInhabitedTagAttribute();
 lean_mark_persistent(l_Lean_instInhabitedTagAttribute);
 l___auto____x40_Lean_Attributes___hyg_1239_ = _init_l___auto____x40_Lean_Attributes___hyg_1239_();
 lean_mark_persistent(l___auto____x40_Lean_Attributes___hyg_1239_);
-l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2___closed__1 = _init_l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2___closed__1();
-lean_mark_persistent(l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2___closed__1);
+l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1___closed__1 = _init_l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1___closed__1();
+lean_mark_persistent(l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1___closed__1);
 l_Lean_registerTagAttribute___lambda__4___closed__1 = _init_l_Lean_registerTagAttribute___lambda__4___closed__1();
 lean_mark_persistent(l_Lean_registerTagAttribute___lambda__4___closed__1);
 l_Lean_registerTagAttribute___lambda__4___closed__2 = _init_l_Lean_registerTagAttribute___lambda__4___closed__2();

stage0/stdlib/Lean/Class.c

@@ -23,7 +23,6 @@ lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 LEAN_EXPORT lean_object* l_Std_HashMapImp_moveEntries___at_Lean_ClassState_addEntry___spec__9(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_str___override(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Class___hyg_78____spec__3(lean_object*, size_t, size_t, lean_object*);
-lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_ClassState_switch(lean_object*);
 LEAN_EXPORT lean_object* l_Std_PersistentHashMap_insert___at_Lean_ClassState_addEntry___spec__2(lean_object*, lean_object*, lean_object*);
 uint8_t lean_usize_dec_eq(size_t, size_t);
@@ -117,6 +116,7 @@ size_t lean_usize_mul(size_t, size_t);
 static lean_object* l_Lean_initFn____x40_Lean_Class___hyg_588____closed__17;
 LEAN_EXPORT lean_object* l_Lean_addClass___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_Class___hyg_78____spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Std_PersistentHashMap_findAtAux___at_Lean_getOutParamPositions_x3f___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_initFn____x40_Lean_Class___hyg_588____closed__13;
 size_t lean_usize_of_nat(lean_object*);
@@ -131,7 +131,6 @@ LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_initFn____x40_Lean_Class___
 LEAN_EXPORT lean_object* l_Std_AssocList_replace___at_Lean_ClassState_addEntry___spec__11(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_getOutParamPositions_x3f(lean_object*, lean_object*);
 static lean_object* l_Lean_initFn____x40_Lean_Class___hyg_588____closed__4;
-lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_fvar___override(lean_object*);
 LEAN_EXPORT lean_object* l_Std_HashMapImp_expand___at_Lean_ClassState_addEntry___spec__8(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Std_PersistentHashMap_findAtAux___at_Lean_getOutParamPositions_x3f___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -196,6 +195,7 @@ LEAN_EXPORT uint8_t l_Std_HashMapImp_contains___at_Lean_isClass___spec__2(lean_o
 static lean_object* l_Lean_initFn____x40_Lean_Class___hyg_588____lambda__3___closed__1;
 lean_object* l_Std_PersistentHashMap_mkCollisionNode___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_addClass___lambda__2___closed__4;
+lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_initFn____x40_Lean_Class___hyg_588____lambda__2(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT uint8_t l_Lean_ClassEntry_lt(lean_object* x_1, lean_object* x_2) {
@@ -2826,7 +2826,7 @@ lean_inc(x_9);
 x_10 = lean_ctor_get(x_8, 1);
 lean_inc(x_10);
 lean_dec(x_8);
-x_11 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(x_9, x_4, x_5, x_10);
+x_11 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(x_9, x_4, x_5, x_10);
 return x_11;
 }
 else
@@ -2900,7 +2900,7 @@ lean_object* x_15; lean_object* x_16; uint8_t x_17;
 lean_dec(x_10);
 lean_dec(x_1);
 x_15 = l_Lean_initFn____x40_Lean_Class___hyg_588____lambda__2___closed__2;
-x_16 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_15, x_4, x_5, x_12);
+x_16 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_15, x_4, x_5, x_12);
 lean_dec(x_5);
 lean_dec(x_4);
 x_17 = !lean_is_exclusive(x_16);

stage0/stdlib/Lean/Compiler/CSimpAttr.c

@@ -146,12 +146,12 @@ static lean_object* l_Lean_Compiler_CSimp_initFn____x40_Lean_Compiler_CSimpAttr_
 LEAN_EXPORT lean_object* l_Std_PersistentHashMap_insertAux_traverse___at_Lean_Compiler_CSimp_initFn____x40_Lean_Compiler_CSimpAttr___hyg_123____spec__4(size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_mul(lean_object*, lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_SMap_switch___at_Lean_initFn____x40_Lean_Environment___hyg_4911____spec__4(lean_object*);
 static lean_object* l_Lean_Compiler_CSimp_State_thmNames___default___closed__1;
 LEAN_EXPORT lean_object* l_Std_HashMapImp_moveEntries___at_Lean_Compiler_CSimp_initFn____x40_Lean_Compiler_CSimpAttr___hyg_123____spec__9(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_CSimp_initFn____x40_Lean_Compiler_CSimpAttr___hyg_437____closed__22;
 static lean_object* l_Lean_Compiler_CSimp_initFn____x40_Lean_Compiler_CSimpAttr___hyg_123____closed__3;
 lean_object* lean_mk_array(lean_object*, lean_object*);
+lean_object* l_Lean_SMap_switch___at_Lean_initFn____x40_Lean_Environment___hyg_5043____spec__4(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Compiler_CSimp_add___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_ScopedEnvExtension_addEntry___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Attribute_Builtin_ensureNoArgs(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -357,7 +357,7 @@ lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6;
 x_3 = lean_ctor_get(x_1, 0);
 x_4 = lean_ctor_get(x_1, 1);
 x_5 = l_Lean_SMap_switch___at_Lean_Compiler_CSimp_State_switch___spec__1(x_3);
-x_6 = l_Lean_SMap_switch___at_Lean_initFn____x40_Lean_Environment___hyg_4911____spec__4(x_4);
+x_6 = l_Lean_SMap_switch___at_Lean_initFn____x40_Lean_Environment___hyg_5043____spec__4(x_4);
 lean_ctor_set(x_1, 1, x_6);
 lean_ctor_set(x_1, 0, x_5);
 return x_1;
@@ -371,7 +371,7 @@ lean_inc(x_8);
 lean_inc(x_7);
 lean_dec(x_1);
 x_9 = l_Lean_SMap_switch___at_Lean_Compiler_CSimp_State_switch___spec__1(x_7);
-x_10 = l_Lean_SMap_switch___at_Lean_initFn____x40_Lean_Environment___hyg_4911____spec__4(x_8);
+x_10 = l_Lean_SMap_switch___at_Lean_initFn____x40_Lean_Environment___hyg_5043____spec__4(x_8);
 x_11 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_11, 0, x_9);
 lean_ctor_set(x_11, 1, x_10);

stage0/stdlib/Lean/Compiler/ExportAttr.c

@@ -19,7 +19,6 @@ LEAN_EXPORT lean_object* l_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_86_
 lean_object* l_Lean_stringToMessageData(lean_object*);
 lean_object* l_Lean_Name_str___override(lean_object*, lean_object*);
 static lean_object* l_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_86____closed__12;
-lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_86____closed__7;
 LEAN_EXPORT lean_object* l___private_Lean_Compiler_ExportAttr_0__Lean_isValidCppId___lambda__1___boxed(lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Compiler_ExportAttr_0__Lean_isValidCppName___boxed(lean_object*);
@@ -65,6 +64,7 @@ static lean_object* l_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_86____cl
 lean_object* l_Lean_registerParametricAttribute___rarg(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_86____closed__11;
 LEAN_EXPORT lean_object* l_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_86____lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Attribute_Builtin_getId(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT uint8_t l___private_Lean_Compiler_ExportAttr_0__Lean_isValidCppId___lambda__1(uint32_t x_1) {
 _start:
@@ -291,7 +291,7 @@ lean_object* x_11; lean_object* x_12; uint8_t x_13;
 lean_free_object(x_6);
 lean_dec(x_8);
 x_11 = l_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_86____lambda__2___closed__2;
-x_12 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_11, x_3, x_4, x_9);
+x_12 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_11, x_3, x_4, x_9);
 lean_dec(x_4);
 lean_dec(x_3);
 x_13 = !lean_is_exclusive(x_12);
@@ -335,7 +335,7 @@ if (x_19 == 0)
 lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
 lean_dec(x_17);
 x_20 = l_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_86____lambda__2___closed__2;
-x_21 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_20, x_3, x_4, x_18);
+x_21 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_20, x_3, x_4, x_18);
 lean_dec(x_4);
 lean_dec(x_3);
 x_22 = lean_ctor_get(x_21, 0);

stage0/stdlib/Lean/Compiler/ExternAttr.c

@@ -118,6 +118,7 @@ LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Compiler_E
 lean_object* l_String_Iterator_next(lean_object*);
 static lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternAttrData___spec__3___closed__3;
 LEAN_EXPORT lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternAttrData(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 size_t lean_usize_of_nat(lean_object*);
 lean_object* l_Lean_ConstantInfo_type(lean_object*);
 lean_object* l_instBEqProd___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -127,7 +128,6 @@ extern lean_object* l_Lean_projectionFnInfoExt;
 static lean_object* l_Lean_mkSimpleFnCall___closed__3;
 LEAN_EXPORT lean_object* l_Lean_isExternC___boxed(lean_object*, lean_object*);
 static lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_getExternConstArity___closed__11;
-lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_659____closed__2;
 uint8_t lean_uint32_dec_eq(uint32_t, uint32_t);
 LEAN_EXPORT lean_object* l_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_659_(lean_object*);
@@ -826,7 +826,7 @@ lean_inc(x_18);
 x_19 = lean_ctor_get(x_17, 1);
 lean_inc(x_19);
 lean_dec(x_17);
-x_20 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(x_18, x_3, x_4, x_19);
+x_20 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(x_18, x_3, x_4, x_19);
 return x_20;
 }
 else
@@ -867,7 +867,7 @@ lean_inc(x_27);
 x_28 = lean_ctor_get(x_26, 1);
 lean_inc(x_28);
 lean_dec(x_26);
-x_29 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(x_27, x_3, x_4, x_28);
+x_29 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(x_27, x_3, x_4, x_28);
 return x_29;
 }
 else
@@ -940,7 +940,7 @@ lean_inc(x_45);
 x_46 = lean_ctor_get(x_44, 1);
 lean_inc(x_46);
 lean_dec(x_44);
-x_47 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(x_45, x_3, x_4, x_46);
+x_47 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(x_45, x_3, x_4, x_46);
 return x_47;
 }
 else
@@ -982,7 +982,7 @@ lean_inc(x_54);
 x_55 = lean_ctor_get(x_53, 1);
 lean_inc(x_55);
 lean_dec(x_53);
-x_56 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(x_54, x_3, x_4, x_55);
+x_56 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(x_54, x_3, x_4, x_55);
 return x_56;
 }
 else

stage0/stdlib/Lean/Compiler/ImplementedByAttr.c

@@ -22,7 +22,6 @@ LEAN_EXPORT lean_object* l_Lean_Elab_pushInfoLeaf___at_Lean_Compiler_initFn____x
 lean_object* l_Lean_Name_str___override(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_4____spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_4____lambda__1___closed__2;
-lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_filterTRAux___at_Lean_resolveGlobalConstCore___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_setEnv___rarg(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_4____lambda__5(lean_object*, lean_object*, lean_object*);
@@ -143,6 +142,7 @@ static lean_object* l_Lean_resolveGlobalConstNoOverload___at_Lean_Compiler_initF
 lean_object* l_Lean_Syntax_formatStxAux(lean_object*, uint8_t, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_resolveGlobalConstCore___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_4____spec__8(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_resolveGlobalName___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_4____spec__9(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_4____spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -473,7 +473,7 @@ x_10 = l_Lean_getConstInfo___at_Lean_Compiler_initFn____x40_Lean_Compiler_Implem
 x_11 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_11, 0, x_9);
 lean_ctor_set(x_11, 1, x_10);
-x_12 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_11, x_2, x_3, x_4);
+x_12 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_11, x_2, x_3, x_4);
 return x_12;
 }
 }
@@ -1560,7 +1560,7 @@ x_15 = l_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_4____
 x_16 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_16, 0, x_14);
 lean_ctor_set(x_16, 1, x_15);
-x_17 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_16, x_5, x_6, x_7);
+x_17 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_16, x_5, x_6, x_7);
 x_18 = !lean_is_exclusive(x_17);
 if (x_18 == 0)
 {
@@ -1701,7 +1701,7 @@ x_32 = l_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_4____
 x_33 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_33, 0, x_31);
 lean_ctor_set(x_33, 1, x_32);
-x_34 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_33, x_6, x_7, x_8);
+x_34 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_33, x_6, x_7, x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 x_35 = !lean_is_exclusive(x_34);
@@ -1883,7 +1883,7 @@ x_46 = l_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_4____
 x_47 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_47, 0, x_45);
 lean_ctor_set(x_47, 1, x_46);
-x_48 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_47, x_3, x_4, x_18);
+x_48 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_47, x_3, x_4, x_18);
 lean_dec(x_4);
 lean_dec(x_3);
 x_49 = !lean_is_exclusive(x_48);

stage0/stdlib/Lean/Compiler/InitAttr.c

@@ -34,7 +34,6 @@ lean_object* l_Lean_Name_str___override(lean_object*, lean_object*);
 static lean_object* l_Lean_declareBuiltin___closed__6;
 static lean_object* l_Lean_getBuiltinInitFnNameFor_x3f___closed__1;
 LEAN_EXPORT lean_object* l_Lean_builtinInitAttr;
-lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_filterTRAux___at_Lean_resolveGlobalConstCore___spec__1(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_resolveGlobalConstCore___at_Lean_registerInitAttrUnsafe___spec__9___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_mkConstWithLevelParams___at_Lean_registerInitAttrUnsafe___spec__14___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -232,6 +231,7 @@ lean_object* l_Lean_Syntax_formatStxAux(lean_object*, uint8_t, lean_object*, lea
 static lean_object* l___auto____x40_Lean_Compiler_InitAttr___hyg_791____closed__12;
 static lean_object* l_Lean_registerInitAttrUnsafe___lambda__1___closed__4;
 static lean_object* l_Lean_setEnv___at_Lean_declareBuiltin___spec__3___closed__2;
+lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 static lean_object* _init_l___private_Lean_Compiler_InitAttr_0__Lean_getIOTypeArg___closed__1() {
@@ -797,7 +797,7 @@ x_10 = l_Lean_getConstInfo___at_Lean_registerInitAttrUnsafe___spec__1___closed__
 x_11 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_11, 0, x_9);
 lean_ctor_set(x_11, 1, x_10);
-x_12 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_11, x_2, x_3, x_4);
+x_12 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_11, x_2, x_3, x_4);
 return x_12;
 }
 }
@@ -2743,7 +2743,7 @@ x_21 = lean_array_get_size(x_2);
 x_22 = lean_unsigned_to_nat(0u);
 x_23 = l_Array_toSubarray___rarg(x_2, x_22, x_21);
 x_24 = lean_ctor_get(x_3, 0);
-x_25 = lean_ctor_get(x_24, 3);
+x_25 = lean_ctor_get(x_24, 4);
 x_26 = lean_ctor_get(x_25, 3);
 x_27 = lean_array_get_size(x_26);
 x_28 = lean_usize_of_nat(x_27);

stage0/stdlib/Lean/Compiler/InlineAttrs.c

@@ -21,7 +21,6 @@ lean_object* l_Lean_stringToMessageData(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_InlineAttributeKind_toCtorIdx___boxed(lean_object*);
 lean_object* l_Lean_Name_str___override(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_216____closed__11;
-lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_isValidMacroInline___lambda__2___closed__5;
 LEAN_EXPORT lean_object* l_Lean_ofExcept___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_216____spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_isValidMacroInline___lambda__2___closed__3;
@@ -127,6 +126,7 @@ static lean_object* l___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_isVal
 lean_object* l_Lean_Expr_constName_x21(lean_object*);
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_216____closed__22;
 lean_object* l_Lean_registerEnumAttributes___rarg(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_InlineAttributeKind_toCtorIdx(uint8_t x_1) {
 _start:
 {
@@ -858,7 +858,7 @@ x_6 = lean_alloc_ctor(2, 1, 0);
 lean_ctor_set(x_6, 0, x_5);
 x_7 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_7, 0, x_6);
-x_8 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_7, x_2, x_3, x_4);
+x_8 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_7, x_2, x_3, x_4);
 return x_8;
 }
 else

stage0/stdlib/Lean/Compiler/LCNF/Main.c

@@ -17,6 +17,7 @@ static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__13;
 lean_object* l_Lean_Compiler_LCNF_ppDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__23;
 lean_object* l_Lean_KVMap_setBool(lean_object*, lean_object*, uint8_t);
+static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__2;
 size_t lean_usize_add(size_t, size_t);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__21;
@@ -29,13 +30,12 @@ lean_object* l_Lean_Name_str___override(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_isMatcher___at_Lean_Compiler_LCNF_shouldGenerateCode___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_usize_dec_eq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
-static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__2;
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_PassManager_run___spec__5(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__4;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PassManager_run___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2___closed__6;
-static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__1;
 lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__4;
+static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__1;
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__17;
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__1___closed__1;
@@ -53,11 +53,12 @@ static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__8;
 lean_object* lean_string_append(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_PassManager_run___spec__3(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__2;
-static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__3;
+lean_object* l_Nat_max(lean_object*, lean_object*);
+static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__3;
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2___closed__5;
-static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__5;
 uint8_t lean_usize_dec_lt(size_t, size_t);
+static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__5;
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__19;
 LEAN_EXPORT lean_object* l_ReaderT_pure___at_Lean_Compiler_LCNF_PassManager_run___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_LCNF_PassInstaller_runFromDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -126,7 +127,7 @@ static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__10;
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2___closed__11;
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__7;
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_PassManager_run___spec__3___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198_(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200_(lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__3;
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -3168,108 +3169,262 @@ return x_76;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PassManager_run(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
-lean_object* x_6; lean_object* x_7; uint8_t x_8; lean_object* x_9; lean_object* x_10; 
+lean_object* x_6; lean_object* x_7; uint8_t x_8; uint8_t x_9; 
 x_6 = lean_array_get_size(x_1);
 x_7 = lean_unsigned_to_nat(0u);
 x_8 = lean_nat_dec_lt(x_7, x_6);
+x_9 = !lean_is_exclusive(x_3);
+if (x_9 == 0)
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; 
+x_10 = lean_ctor_get(x_3, 4);
+x_11 = lean_unsigned_to_nat(8192u);
+x_12 = l_Nat_max(x_11, x_10);
+lean_dec(x_10);
+lean_ctor_set(x_3, 4, x_12);
 if (x_8 == 0)
 {
-lean_object* x_18; 
+lean_object* x_22; 
 lean_dec(x_6);
 lean_dec(x_1);
-x_18 = l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
-x_9 = x_18;
-x_10 = x_5;
-goto block_17;
+x_22 = l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
+x_13 = x_22;
+x_14 = x_5;
+goto block_21;
 }
 else
 {
-uint8_t x_19; 
-x_19 = lean_nat_dec_le(x_6, x_6);
-if (x_19 == 0)
+uint8_t x_23; 
+x_23 = lean_nat_dec_le(x_6, x_6);
+if (x_23 == 0)
 {
-lean_object* x_20; 
+lean_object* x_24; 
 lean_dec(x_6);
 lean_dec(x_1);
-x_20 = l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
-x_9 = x_20;
-x_10 = x_5;
-goto block_17;
+x_24 = l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
+x_13 = x_24;
+x_14 = x_5;
+goto block_21;
 }
 else
 {
-size_t x_21; size_t x_22; lean_object* x_23; lean_object* x_24; 
-x_21 = 0;
-x_22 = lean_usize_of_nat(x_6);
+size_t x_25; size_t x_26; lean_object* x_27; lean_object* x_28; 
+x_25 = 0;
+x_26 = lean_usize_of_nat(x_6);
 lean_dec(x_6);
-x_23 = l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
+x_27 = l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
 lean_inc(x_4);
 lean_inc(x_3);
-x_24 = l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_PassManager_run___spec__7(x_1, x_21, x_22, x_23, x_2, x_3, x_4, x_5);
+x_28 = l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_PassManager_run___spec__7(x_1, x_25, x_26, x_27, x_2, x_3, x_4, x_5);
 lean_dec(x_1);
-if (lean_obj_tag(x_24) == 0)
+if (lean_obj_tag(x_28) == 0)
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = lean_ctor_get(x_24, 0);
-lean_inc(x_25);
-x_26 = lean_ctor_get(x_24, 1);
-lean_inc(x_26);
-lean_dec(x_24);
-x_9 = x_25;
-x_10 = x_26;
-goto block_17;
-}
-else
-{
-uint8_t x_27; 
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-x_27 = !lean_is_exclusive(x_24);
-if (x_27 == 0)
-{
-return x_24;
-}
-else
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-x_28 = lean_ctor_get(x_24, 0);
-x_29 = lean_ctor_get(x_24, 1);
+lean_object* x_29; lean_object* x_30; 
+x_29 = lean_ctor_get(x_28, 0);
 lean_inc(x_29);
-lean_inc(x_28);
-lean_dec(x_24);
-x_30 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_30, 0, x_28);
-lean_ctor_set(x_30, 1, x_29);
-return x_30;
-}
-}
-}
-}
-block_17:
-{
-uint8_t x_11; 
-x_11 = l_Array_isEmpty___rarg(x_9);
-if (x_11 == 0)
-{
-lean_object* x_12; lean_object* x_13; lean_object* x_14; 
-x_12 = l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
-x_13 = lean_box(0);
-x_14 = l_Lean_Compiler_LCNF_PassManager_run___lambda__2(x_9, x_12, x_13, x_2, x_3, x_4, x_10);
-return x_14;
+x_30 = lean_ctor_get(x_28, 1);
+lean_inc(x_30);
+lean_dec(x_28);
+x_13 = x_29;
+x_14 = x_30;
+goto block_21;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; 
-lean_dec(x_9);
-lean_dec(x_4);
+uint8_t x_31; 
 lean_dec(x_3);
+lean_dec(x_4);
 lean_dec(x_2);
-x_15 = l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
-x_16 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_16, 0, x_15);
-lean_ctor_set(x_16, 1, x_10);
-return x_16;
+x_31 = !lean_is_exclusive(x_28);
+if (x_31 == 0)
+{
+return x_28;
+}
+else
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+x_32 = lean_ctor_get(x_28, 0);
+x_33 = lean_ctor_get(x_28, 1);
+lean_inc(x_33);
+lean_inc(x_32);
+lean_dec(x_28);
+x_34 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_34, 0, x_32);
+lean_ctor_set(x_34, 1, x_33);
+return x_34;
+}
+}
+}
+}
+block_21:
+{
+uint8_t x_15; 
+x_15 = l_Array_isEmpty___rarg(x_13);
+if (x_15 == 0)
+{
+lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+x_16 = l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
+x_17 = lean_box(0);
+x_18 = l_Lean_Compiler_LCNF_PassManager_run___lambda__2(x_13, x_16, x_17, x_2, x_3, x_4, x_14);
+return x_18;
+}
+else
+{
+lean_object* x_19; lean_object* x_20; 
+lean_dec(x_13);
+lean_dec(x_3);
+lean_dec(x_4);
+lean_dec(x_2);
+x_19 = l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
+x_20 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_20, 0, x_19);
+lean_ctor_set(x_20, 1, x_14);
+return x_20;
+}
+}
+}
+else
+{
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+x_35 = lean_ctor_get(x_3, 0);
+x_36 = lean_ctor_get(x_3, 1);
+x_37 = lean_ctor_get(x_3, 2);
+x_38 = lean_ctor_get(x_3, 3);
+x_39 = lean_ctor_get(x_3, 4);
+x_40 = lean_ctor_get(x_3, 5);
+x_41 = lean_ctor_get(x_3, 6);
+x_42 = lean_ctor_get(x_3, 7);
+x_43 = lean_ctor_get(x_3, 8);
+x_44 = lean_ctor_get(x_3, 9);
+x_45 = lean_ctor_get(x_3, 10);
+lean_inc(x_45);
+lean_inc(x_44);
+lean_inc(x_43);
+lean_inc(x_42);
+lean_inc(x_41);
+lean_inc(x_40);
+lean_inc(x_39);
+lean_inc(x_38);
+lean_inc(x_37);
+lean_inc(x_36);
+lean_inc(x_35);
+lean_dec(x_3);
+x_46 = lean_unsigned_to_nat(8192u);
+x_47 = l_Nat_max(x_46, x_39);
+lean_dec(x_39);
+x_48 = lean_alloc_ctor(0, 11, 0);
+lean_ctor_set(x_48, 0, x_35);
+lean_ctor_set(x_48, 1, x_36);
+lean_ctor_set(x_48, 2, x_37);
+lean_ctor_set(x_48, 3, x_38);
+lean_ctor_set(x_48, 4, x_47);
+lean_ctor_set(x_48, 5, x_40);
+lean_ctor_set(x_48, 6, x_41);
+lean_ctor_set(x_48, 7, x_42);
+lean_ctor_set(x_48, 8, x_43);
+lean_ctor_set(x_48, 9, x_44);
+lean_ctor_set(x_48, 10, x_45);
+if (x_8 == 0)
+{
+lean_object* x_58; 
+lean_dec(x_6);
+lean_dec(x_1);
+x_58 = l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
+x_49 = x_58;
+x_50 = x_5;
+goto block_57;
+}
+else
+{
+uint8_t x_59; 
+x_59 = lean_nat_dec_le(x_6, x_6);
+if (x_59 == 0)
+{
+lean_object* x_60; 
+lean_dec(x_6);
+lean_dec(x_1);
+x_60 = l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
+x_49 = x_60;
+x_50 = x_5;
+goto block_57;
+}
+else
+{
+size_t x_61; size_t x_62; lean_object* x_63; lean_object* x_64; 
+x_61 = 0;
+x_62 = lean_usize_of_nat(x_6);
+lean_dec(x_6);
+x_63 = l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
+lean_inc(x_4);
+lean_inc(x_48);
+x_64 = l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_PassManager_run___spec__7(x_1, x_61, x_62, x_63, x_2, x_48, x_4, x_5);
+lean_dec(x_1);
+if (lean_obj_tag(x_64) == 0)
+{
+lean_object* x_65; lean_object* x_66; 
+x_65 = lean_ctor_get(x_64, 0);
+lean_inc(x_65);
+x_66 = lean_ctor_get(x_64, 1);
+lean_inc(x_66);
+lean_dec(x_64);
+x_49 = x_65;
+x_50 = x_66;
+goto block_57;
+}
+else
+{
+lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; 
+lean_dec(x_48);
+lean_dec(x_4);
+lean_dec(x_2);
+x_67 = lean_ctor_get(x_64, 0);
+lean_inc(x_67);
+x_68 = lean_ctor_get(x_64, 1);
+lean_inc(x_68);
+if (lean_is_exclusive(x_64)) {
+ lean_ctor_release(x_64, 0);
+ lean_ctor_release(x_64, 1);
+ x_69 = x_64;
+} else {
+ lean_dec_ref(x_64);
+ x_69 = lean_box(0);
+}
+if (lean_is_scalar(x_69)) {
+ x_70 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_70 = x_69;
+}
+lean_ctor_set(x_70, 0, x_67);
+lean_ctor_set(x_70, 1, x_68);
+return x_70;
+}
+}
+}
+block_57:
+{
+uint8_t x_51; 
+x_51 = l_Array_isEmpty___rarg(x_49);
+if (x_51 == 0)
+{
+lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+x_52 = l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
+x_53 = lean_box(0);
+x_54 = l_Lean_Compiler_LCNF_PassManager_run___lambda__2(x_49, x_52, x_53, x_2, x_48, x_4, x_50);
+return x_54;
+}
+else
+{
+lean_object* x_55; lean_object* x_56; 
+lean_dec(x_49);
+lean_dec(x_48);
+lean_dec(x_4);
+lean_dec(x_2);
+x_55 = l_Lean_Compiler_LCNF_shouldGenerateCode___closed__9;
+x_56 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_56, 0, x_55);
+lean_ctor_set(x_56, 1, x_50);
+return x_56;
+}
 }
 }
 }
@@ -3435,7 +3590,7 @@ x_7 = l_Lean_Compiler_LCNF_CompilerM_run___rarg(x_5, x_6, x_2, x_3, x_4);
 return x_7;
 }
 }
-static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__1() {
+static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -3445,7 +3600,7 @@ x_3 = l_Lean_Name_str___override(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__2() {
+static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__2() {
 _start:
 {
 lean_object* x_1; 
@@ -3453,17 +3608,17 @@ x_1 = lean_mk_string_from_bytes("test", 4);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__3() {
+static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___closed__2;
-x_2 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__2;
+x_2 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__2;
 x_3 = l_Lean_Name_str___override(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__4() {
+static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__4() {
 _start:
 {
 lean_object* x_1; 
@@ -3471,21 +3626,21 @@ x_1 = lean_mk_string_from_bytes("jp", 2);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__5() {
+static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___closed__2;
-x_2 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__4;
+x_2 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__4;
 x_3 = l_Lean_Name_str___override(x_1, x_2);
 return x_3;
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198_(lean_object* x_1) {
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; uint8_t x_3; lean_object* x_4; 
-x_2 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__1;
+x_2 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__1;
 x_3 = 1;
 x_4 = l_Lean_registerTraceClass(x_2, x_3, x_1);
 if (lean_obj_tag(x_4) == 0)
@@ -3494,7 +3649,7 @@ lean_object* x_5; lean_object* x_6; lean_object* x_7;
 x_5 = lean_ctor_get(x_4, 1);
 lean_inc(x_5);
 lean_dec(x_4);
-x_6 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__3;
+x_6 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__3;
 x_7 = l_Lean_registerTraceClass(x_6, x_3, x_5);
 if (lean_obj_tag(x_7) == 0)
 {
@@ -3510,7 +3665,7 @@ lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14;
 x_11 = lean_ctor_get(x_10, 1);
 lean_inc(x_11);
 lean_dec(x_10);
-x_12 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__5;
+x_12 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__5;
 x_13 = 0;
 x_14 = l_Lean_registerTraceClass(x_12, x_13, x_11);
 return x_14;
@@ -3738,17 +3893,17 @@ l_Lean_Compiler_LCNF_compileStage1Impl___closed__2 = _init_l_Lean_Compiler_LCNF_
 lean_mark_persistent(l_Lean_Compiler_LCNF_compileStage1Impl___closed__2);
 l_Lean_Compiler_LCNF_compileStage1Impl___closed__3 = _init_l_Lean_Compiler_LCNF_compileStage1Impl___closed__3();
 lean_mark_persistent(l_Lean_Compiler_LCNF_compileStage1Impl___closed__3);
-l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__1 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__1();
-lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__1);
-l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__2 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__2();
-lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__2);
-l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__3 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__3();
-lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__3);
-l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__4 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__4();
-lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__4);
-l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__5 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__5();
-lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198____closed__5);
-res = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1198_(lean_io_mk_world());
+l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__1 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__1();
+lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__1);
+l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__2 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__2();
+lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__2);
+l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__3 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__3();
+lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__3);
+l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__4 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__4();
+lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__4);
+l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__5 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__5();
+lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200____closed__5);
+res = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1200_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));

stage0/stdlib/Lean/Compiler/LCNF/PassManager.c

@@ -34,7 +34,6 @@ static lean_object* l_Lean_Compiler_LCNF_PassInstaller_installAfter___elambda__1
 static lean_object* l_Lean_Compiler_LCNF_PassInstaller_initFn____x40_Lean_Compiler_LCNF_PassManager___hyg_1339____lambda__3___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PassInstaller_withEachOccurrence___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Phase_instToStringPhase(uint8_t);
-lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PassInstaller_installAfter___elambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_PassInstaller_runFromDecl___closed__6;
 static lean_object* l_Lean_Compiler_LCNF_instInhabitedPass___lambda__1___closed__1;
@@ -244,6 +243,7 @@ LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Phase_instLEPhase;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Phase_instLTPhase;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PassInstaller_installBeforeEachOccurrence(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_instInhabitedPass___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_PassInstaller_runFromDecl___closed__14;
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
@@ -3085,7 +3085,7 @@ if (x_10 == 0)
 lean_object* x_11; lean_object* x_12; uint8_t x_13; 
 lean_dec(x_1);
 x_11 = l_Lean_Compiler_LCNF_PassInstaller_initFn____x40_Lean_Compiler_LCNF_PassManager___hyg_1339____lambda__2___closed__2;
-x_12 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_11, x_4, x_5, x_8);
+x_12 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_11, x_4, x_5, x_8);
 lean_dec(x_5);
 lean_dec(x_4);
 x_13 = !lean_is_exclusive(x_12);

stage0/stdlib/Lean/Compiler/LCNF/PrettyPrinter.c

@@ -13,6 +13,8 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+uint8_t l_Lean_Expr_isType0(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_ppDecl_x27_go(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_ppDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_pp_letVarTypes;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppExpr___closed__13;
@@ -20,10 +22,12 @@ LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PP_ppApp(lean_object*, lean_object
 size_t lean_usize_add(size_t, size_t);
 static lean_object* l_Lean_Compiler_LCNF_ppDecl___lambda__1___closed__1;
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
+static lean_object* l_Lean_Compiler_LCNF_PP_ppArg___closed__7;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppFunDecl___closed__2;
 lean_object* l_Std_Format_indentD(lean_object*);
 LEAN_EXPORT lean_object* l_ReaderT_bind___at_Lean_Compiler_LCNF_ppDecl___spec__1(lean_object*, lean_object*);
 lean_object* lean_array_uget(lean_object*, size_t);
+uint8_t l_Lean_Expr_isProp(lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_PP_ppLetDecl___closed__5;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppExpr___closed__2;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppFunDecl___closed__1;
@@ -39,6 +43,8 @@ lean_object* l_Array_toSubarray___rarg(lean_object*, lean_object*, lean_object*)
 lean_object* lean_array_get_size(lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PP_run(lean_object*);
+lean_object* l_Lean_Compiler_LCNF_Decl_internalize(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Compiler_LCNF_ppDecl_x27_go___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_ppFunDecl___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_PP_ppExpr___closed__6;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PP_ppFVar(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -46,9 +52,9 @@ static lean_object* l_Lean_Compiler_LCNF_PP_ppArg___closed__3;
 uint8_t lean_usize_dec_lt(size_t, size_t);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Compiler_LCNF_PrettyPrinter_0__Lean_Compiler_LCNF_PP_prefixJoin___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_PP_ppExpr___closed__12;
-static lean_object* l_Lean_Compiler_LCNF_PP_ppParam___closed__10;
 extern lean_object* l_Lean_levelZero;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PP_run___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Compiler_LCNF_PP_ppArg___closed__6;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PP_ppCode(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_PP_ppExpr___closed__19;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PP_ppAlt(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -60,23 +66,25 @@ lean_object* l___private_Lean_Expr_0__Lean_Expr_getAppArgsAux(lean_object*, lean
 lean_object* lean_array_fget(lean_object*, lean_object*);
 uint8_t l_Lean_Option_get___at_Lean_getSanitizeNames___spec__1(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_PP_ppExpr___closed__11;
-static lean_object* l_Lean_Compiler_LCNF_PP_ppParam___closed__7;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppParams___closed__1;
+static lean_object* l_Lean_Compiler_LCNF_PP_ppArg___closed__4;
 lean_object* lean_nat_sub(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_PP_ppCode___closed__6;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppArg___closed__1;
 lean_object* l_Lean_Name_toString(lean_object*, uint8_t);
 lean_object* l_Lean_Expr_fvarId_x21(lean_object*);
+lean_object* l_Std_mkHashMapImp___rarg(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PP_ppArg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Compiler_LCNF_PP_ppArg___closed__5;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppParam___closed__3;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppExpr___closed__10;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppArgs___closed__1;
 lean_object* l___private_Lean_Expr_0__Lean_Expr_getAppNumArgsAux(lean_object*, lean_object*);
 lean_object* l_Nat_repr(lean_object*);
 lean_object* lean_st_mk_ref(lean_object*, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_PP_ppParam___closed__5;
 extern lean_object* l_Lean_Expr_instHashableExpr;
 lean_object* l_Std_PersistentHashMap_mkEmptyEntriesArray(lean_object*, lean_object*);
+static lean_object* l_Lean_Compiler_LCNF_PP_ppArg___closed__8;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PP_ppExpr(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_sort___override(lean_object*);
 lean_object* l_Lean_Meta_InfoCacheKey_instHashableInfoCacheKey___boxed(lean_object*);
@@ -84,9 +92,11 @@ static lean_object* l_Lean_Compiler_LCNF_PP_ppExpr___closed__16;
 LEAN_EXPORT lean_object* l_ReaderT_bind___at_Lean_Compiler_LCNF_ppDecl___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PP_ppParams(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_PP_ppCode___closed__3;
+uint8_t l_Lean_Expr_isConst(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_ppCode(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Compiler_LCNF_PrettyPrinter_0__Lean_Compiler_LCNF_PP_prefixJoin___spec__1___rarg(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_PP_ppArg___closed__2;
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_ppDecl_x27(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_LCNF_getBinderName(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PP_ppParams___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PP_ppParam(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -95,15 +105,18 @@ size_t lean_usize_of_nat(lean_object*);
 extern lean_object* l_Lean_pp_explicit;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppCode___closed__10;
 lean_object* l_instBEqProd___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_PP_ppParam___closed__6;
+static lean_object* l_Lean_Compiler_LCNF_PP_ppArg___closed__9;
 extern lean_object* l_Lean_pp_funBinderTypes;
+static lean_object* l_Lean_Compiler_LCNF_ppDecl_x27___closed__2;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppCode___closed__7;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppAlt___closed__5;
+static lean_object* l_Lean_Compiler_LCNF_ppDecl_x27___closed__1;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppAlt___closed__3;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppAlt___closed__1;
 LEAN_EXPORT lean_object* l_Subarray_forInUnsafe_loop___at___private_Lean_Compiler_LCNF_PrettyPrinter_0__Lean_Compiler_LCNF_PP_join___spec__1(lean_object*);
 LEAN_EXPORT lean_object* l_Subarray_forInUnsafe_loop___at___private_Lean_Compiler_LCNF_PrettyPrinter_0__Lean_Compiler_LCNF_PP_join___spec__1___rarg(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_LCNF_LCtx_toLocalContext(lean_object*);
+lean_object* l_Lean_Compiler_LCNF_CompilerM_run___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PP_ppArg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_PP_ppAlt___closed__2;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppParam___closed__2;
@@ -119,7 +132,6 @@ static lean_object* l_Lean_Compiler_LCNF_PP_ppParam___closed__1;
 static lean_object* l_Lean_Compiler_LCNF_PP_run___rarg___closed__1;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppCode___closed__9;
 LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_PrettyPrinter_0__Lean_Compiler_LCNF_PP_prefixJoin(lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_PP_ppParam___closed__8;
 LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_PrettyPrinter_0__Lean_Compiler_LCNF_PP_prefixJoin___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_instHashableProd___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_mk_array(lean_object*, lean_object*);
@@ -128,7 +140,6 @@ static lean_object* l_Lean_Compiler_LCNF_PP_ppParam___closed__4;
 extern lean_object* l_Lean_Expr_instBEqExpr;
 LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_PrettyPrinter_0__Lean_Compiler_LCNF_PP_join___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PP_ppFVar___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_PP_ppParam___closed__9;
 lean_object* lean_string_length(lean_object*);
 static lean_object* l_Subarray_forInUnsafe_loop___at___private_Lean_Compiler_LCNF_PrettyPrinter_0__Lean_Compiler_LCNF_PP_join___spec__1___rarg___closed__1;
 static lean_object* l_Lean_Compiler_LCNF_PP_ppAlt___closed__6;
@@ -1112,6 +1123,60 @@ lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
+static lean_object* _init_l_Lean_Compiler_LCNF_PP_ppArg___closed__4() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string_from_bytes("(", 1);
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_Compiler_LCNF_PP_ppArg___closed__5() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Compiler_LCNF_PP_ppArg___closed__4;
+x_2 = lean_string_length(x_1);
+return x_2;
+}
+}
+static lean_object* _init_l_Lean_Compiler_LCNF_PP_ppArg___closed__6() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Compiler_LCNF_PP_ppArg___closed__5;
+x_2 = lean_nat_to_int(x_1);
+return x_2;
+}
+}
+static lean_object* _init_l_Lean_Compiler_LCNF_PP_ppArg___closed__7() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Compiler_LCNF_PP_ppArg___closed__4;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+static lean_object* _init_l_Lean_Compiler_LCNF_PP_ppArg___closed__8() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string_from_bytes(")", 1);
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_Compiler_LCNF_PP_ppArg___closed__9() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Compiler_LCNF_PP_ppArg___closed__8;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PP_ppArg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
@@ -1136,18 +1201,129 @@ return x_12;
 }
 else
 {
-lean_object* x_13; 
-x_13 = l_Lean_Compiler_LCNF_PP_ppExpr(x_1, x_2, x_3, x_4, x_5, x_6);
-return x_13;
+uint8_t x_13; 
+x_13 = l_Lean_Expr_isConst(x_1);
+if (x_13 == 0)
+{
+uint8_t x_14; 
+x_14 = l_Lean_Expr_isProp(x_1);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+x_15 = l_Lean_Expr_isType0(x_1);
+if (x_15 == 0)
+{
+lean_object* x_16; 
+x_16 = l_Lean_Compiler_LCNF_PP_ppExpr(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_16) == 0)
+{
+uint8_t x_17; 
+x_17 = !lean_is_exclusive(x_16);
+if (x_17 == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; lean_object* x_26; 
+x_18 = lean_ctor_get(x_16, 0);
+x_19 = l_Lean_Compiler_LCNF_PP_ppArg___closed__7;
+x_20 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_20, 0, x_19);
+lean_ctor_set(x_20, 1, x_18);
+x_21 = l_Lean_Compiler_LCNF_PP_ppArg___closed__9;
+x_22 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_21);
+x_23 = l_Lean_Compiler_LCNF_PP_ppArg___closed__6;
+x_24 = lean_alloc_ctor(3, 2, 0);
+lean_ctor_set(x_24, 0, x_23);
+lean_ctor_set(x_24, 1, x_22);
+x_25 = 0;
+x_26 = lean_alloc_ctor(5, 1, 1);
+lean_ctor_set(x_26, 0, x_24);
+lean_ctor_set_uint8(x_26, sizeof(void*)*1, x_25);
+lean_ctor_set(x_16, 0, x_26);
+return x_16;
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; uint8_t x_35; lean_object* x_36; lean_object* x_37; 
+x_27 = lean_ctor_get(x_16, 0);
+x_28 = lean_ctor_get(x_16, 1);
+lean_inc(x_28);
+lean_inc(x_27);
+lean_dec(x_16);
+x_29 = l_Lean_Compiler_LCNF_PP_ppArg___closed__7;
+x_30 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_30, 0, x_29);
+lean_ctor_set(x_30, 1, x_27);
+x_31 = l_Lean_Compiler_LCNF_PP_ppArg___closed__9;
+x_32 = lean_alloc_ctor(4, 2, 0);
+lean_ctor_set(x_32, 0, x_30);
+lean_ctor_set(x_32, 1, x_31);
+x_33 = l_Lean_Compiler_LCNF_PP_ppArg___closed__6;
+x_34 = lean_alloc_ctor(3, 2, 0);
+lean_ctor_set(x_34, 0, x_33);
+lean_ctor_set(x_34, 1, x_32);
+x_35 = 0;
+x_36 = lean_alloc_ctor(5, 1, 1);
+lean_ctor_set(x_36, 0, x_34);
+lean_ctor_set_uint8(x_36, sizeof(void*)*1, x_35);
+x_37 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_37, 0, x_36);
+lean_ctor_set(x_37, 1, x_28);
+return x_37;
 }
 }
 else
 {
-lean_object* x_14; lean_object* x_15; 
-x_14 = l_Lean_Expr_fvarId_x21(x_1);
-x_15 = l_Lean_Compiler_LCNF_PP_ppFVar(x_14, x_2, x_3, x_4, x_5, x_6);
+uint8_t x_38; 
+x_38 = !lean_is_exclusive(x_16);
+if (x_38 == 0)
+{
+return x_16;
+}
+else
+{
+lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+x_39 = lean_ctor_get(x_16, 0);
+x_40 = lean_ctor_get(x_16, 1);
+lean_inc(x_40);
+lean_inc(x_39);
+lean_dec(x_16);
+x_41 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_41, 0, x_39);
+lean_ctor_set(x_41, 1, x_40);
+return x_41;
+}
+}
+}
+else
+{
+lean_object* x_42; 
+x_42 = l_Lean_Compiler_LCNF_PP_ppExpr(x_1, x_2, x_3, x_4, x_5, x_6);
+return x_42;
+}
+}
+else
+{
+lean_object* x_43; 
+x_43 = l_Lean_Compiler_LCNF_PP_ppExpr(x_1, x_2, x_3, x_4, x_5, x_6);
+return x_43;
+}
+}
+else
+{
+lean_object* x_44; 
+x_44 = l_Lean_Compiler_LCNF_PP_ppExpr(x_1, x_2, x_3, x_4, x_5, x_6);
+return x_44;
+}
+}
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Lean_Expr_fvarId_x21(x_1);
+x_46 = l_Lean_Compiler_LCNF_PP_ppFVar(x_45, x_2, x_3, x_4, x_5, x_6);
 lean_dec(x_2);
-return x_15;
+return x_46;
 }
 }
 }
@@ -1498,60 +1674,6 @@ static lean_object* _init_l_Lean_Compiler_LCNF_PP_ppParam___closed__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_mk_string_from_bytes("(", 1);
-return x_1;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_PP_ppParam___closed__5() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Compiler_LCNF_PP_ppParam___closed__4;
-x_2 = lean_string_length(x_1);
-return x_2;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_PP_ppParam___closed__6() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Compiler_LCNF_PP_ppParam___closed__5;
-x_2 = lean_nat_to_int(x_1);
-return x_2;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_PP_ppParam___closed__7() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Compiler_LCNF_PP_ppParam___closed__4;
-x_2 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_2, 0, x_1);
-return x_2;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_PP_ppParam___closed__8() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string_from_bytes(")", 1);
-return x_1;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_PP_ppParam___closed__9() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Compiler_LCNF_PP_ppParam___closed__8;
-x_2 = lean_alloc_ctor(2, 1, 0);
-lean_ctor_set(x_2, 0, x_1);
-return x_2;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_PP_ppParam___closed__10() {
-_start:
-{
-lean_object* x_1; 
 x_1 = lean_mk_string_from_bytes("@&", 2);
 return x_1;
 }
@@ -1574,7 +1696,7 @@ goto block_75;
 else
 {
 lean_object* x_77; 
-x_77 = l_Lean_Compiler_LCNF_PP_ppParam___closed__10;
+x_77 = l_Lean_Compiler_LCNF_PP_ppParam___closed__4;
 x_11 = x_77;
 goto block_75;
 }
@@ -1646,15 +1768,15 @@ lean_ctor_set(x_37, 1, x_25);
 x_38 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_38, 0, x_37);
 lean_ctor_set(x_38, 1, x_30);
-x_39 = l_Lean_Compiler_LCNF_PP_ppParam___closed__7;
+x_39 = l_Lean_Compiler_LCNF_PP_ppArg___closed__7;
 x_40 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_40, 0, x_39);
 lean_ctor_set(x_40, 1, x_38);
-x_41 = l_Lean_Compiler_LCNF_PP_ppParam___closed__9;
+x_41 = l_Lean_Compiler_LCNF_PP_ppArg___closed__9;
 x_42 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_42, 0, x_40);
 lean_ctor_set(x_42, 1, x_41);
-x_43 = l_Lean_Compiler_LCNF_PP_ppParam___closed__6;
+x_43 = l_Lean_Compiler_LCNF_PP_ppArg___closed__6;
 x_44 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_44, 0, x_43);
 lean_ctor_set(x_44, 1, x_42);
@@ -1702,15 +1824,15 @@ lean_ctor_set(x_60, 1, x_47);
 x_61 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_61, 0, x_60);
 lean_ctor_set(x_61, 1, x_53);
-x_62 = l_Lean_Compiler_LCNF_PP_ppParam___closed__7;
+x_62 = l_Lean_Compiler_LCNF_PP_ppArg___closed__7;
 x_63 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_63, 0, x_62);
 lean_ctor_set(x_63, 1, x_61);
-x_64 = l_Lean_Compiler_LCNF_PP_ppParam___closed__9;
+x_64 = l_Lean_Compiler_LCNF_PP_ppArg___closed__9;
 x_65 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_65, 0, x_63);
 lean_ctor_set(x_65, 1, x_64);
-x_66 = l_Lean_Compiler_LCNF_PP_ppParam___closed__6;
+x_66 = l_Lean_Compiler_LCNF_PP_ppArg___closed__6;
 x_67 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_67, 0, x_66);
 lean_ctor_set(x_67, 1, x_65);
@@ -3699,6 +3821,65 @@ x_10 = l_Lean_Compiler_LCNF_PP_run___rarg(x_9, x_2, x_3, x_4, x_5);
 return x_10;
 }
 }
+static lean_object* _init_l_Lean_Compiler_LCNF_ppDecl_x27_go___closed__1() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = lean_unsigned_to_nat(0u);
+x_2 = l_Std_mkHashMapImp___rarg(x_1);
+return x_2;
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_ppDecl_x27_go(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+x_6 = l_Lean_Compiler_LCNF_ppDecl_x27_go___closed__1;
+x_7 = l_Lean_Compiler_LCNF_Decl_internalize(x_1, x_6, x_2, x_3, x_4, x_5);
+x_8 = lean_ctor_get(x_7, 0);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_7, 1);
+lean_inc(x_9);
+lean_dec(x_7);
+x_10 = l_Lean_Compiler_LCNF_ppDecl(x_8, x_2, x_3, x_4, x_9);
+return x_10;
+}
+}
+static lean_object* _init_l_Lean_Compiler_LCNF_ppDecl_x27___closed__1() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Compiler_LCNF_ppDecl_x27_go___closed__1;
+x_2 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_2, 0, x_1);
+lean_ctor_set(x_2, 1, x_1);
+lean_ctor_set(x_2, 2, x_1);
+return x_2;
+}
+}
+static lean_object* _init_l_Lean_Compiler_LCNF_ppDecl_x27___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Compiler_LCNF_ppDecl_x27___closed__1;
+x_2 = lean_unsigned_to_nat(1u);
+x_3 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_ppDecl_x27(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_5 = lean_alloc_closure((void*)(l_Lean_Compiler_LCNF_ppDecl_x27_go), 5, 1);
+lean_closure_set(x_5, 0, x_1);
+x_6 = l_Lean_Compiler_LCNF_ppDecl_x27___closed__2;
+x_7 = l_Lean_Compiler_LCNF_CompilerM_run___rarg(x_5, x_6, x_2, x_3, x_4);
+return x_7;
+}
+}
 lean_object* initialize_Init(uint8_t builtin, lean_object*);
 lean_object* initialize_Lean_PrettyPrinter(uint8_t builtin, lean_object*);
 lean_object* initialize_Lean_Compiler_LCNF_CompilerM(uint8_t builtin, lean_object*);
@@ -3770,6 +3951,18 @@ l_Lean_Compiler_LCNF_PP_ppArg___closed__2 = _init_l_Lean_Compiler_LCNF_PP_ppArg_
 lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppArg___closed__2);
 l_Lean_Compiler_LCNF_PP_ppArg___closed__3 = _init_l_Lean_Compiler_LCNF_PP_ppArg___closed__3();
 lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppArg___closed__3);
+l_Lean_Compiler_LCNF_PP_ppArg___closed__4 = _init_l_Lean_Compiler_LCNF_PP_ppArg___closed__4();
+lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppArg___closed__4);
+l_Lean_Compiler_LCNF_PP_ppArg___closed__5 = _init_l_Lean_Compiler_LCNF_PP_ppArg___closed__5();
+lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppArg___closed__5);
+l_Lean_Compiler_LCNF_PP_ppArg___closed__6 = _init_l_Lean_Compiler_LCNF_PP_ppArg___closed__6();
+lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppArg___closed__6);
+l_Lean_Compiler_LCNF_PP_ppArg___closed__7 = _init_l_Lean_Compiler_LCNF_PP_ppArg___closed__7();
+lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppArg___closed__7);
+l_Lean_Compiler_LCNF_PP_ppArg___closed__8 = _init_l_Lean_Compiler_LCNF_PP_ppArg___closed__8();
+lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppArg___closed__8);
+l_Lean_Compiler_LCNF_PP_ppArg___closed__9 = _init_l_Lean_Compiler_LCNF_PP_ppArg___closed__9();
+lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppArg___closed__9);
 l_Lean_Compiler_LCNF_PP_ppArgs___closed__1 = _init_l_Lean_Compiler_LCNF_PP_ppArgs___closed__1();
 lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppArgs___closed__1);
 l_Lean_Compiler_LCNF_PP_ppApp___closed__1 = _init_l_Lean_Compiler_LCNF_PP_ppApp___closed__1();
@@ -3786,18 +3979,6 @@ l_Lean_Compiler_LCNF_PP_ppParam___closed__3 = _init_l_Lean_Compiler_LCNF_PP_ppPa
 lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppParam___closed__3);
 l_Lean_Compiler_LCNF_PP_ppParam___closed__4 = _init_l_Lean_Compiler_LCNF_PP_ppParam___closed__4();
 lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppParam___closed__4);
-l_Lean_Compiler_LCNF_PP_ppParam___closed__5 = _init_l_Lean_Compiler_LCNF_PP_ppParam___closed__5();
-lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppParam___closed__5);
-l_Lean_Compiler_LCNF_PP_ppParam___closed__6 = _init_l_Lean_Compiler_LCNF_PP_ppParam___closed__6();
-lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppParam___closed__6);
-l_Lean_Compiler_LCNF_PP_ppParam___closed__7 = _init_l_Lean_Compiler_LCNF_PP_ppParam___closed__7();
-lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppParam___closed__7);
-l_Lean_Compiler_LCNF_PP_ppParam___closed__8 = _init_l_Lean_Compiler_LCNF_PP_ppParam___closed__8();
-lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppParam___closed__8);
-l_Lean_Compiler_LCNF_PP_ppParam___closed__9 = _init_l_Lean_Compiler_LCNF_PP_ppParam___closed__9();
-lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppParam___closed__9);
-l_Lean_Compiler_LCNF_PP_ppParam___closed__10 = _init_l_Lean_Compiler_LCNF_PP_ppParam___closed__10();
-lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppParam___closed__10);
 l_Lean_Compiler_LCNF_PP_ppParams___closed__1 = _init_l_Lean_Compiler_LCNF_PP_ppParams___closed__1();
 lean_mark_persistent(l_Lean_Compiler_LCNF_PP_ppParams___closed__1);
 l_Lean_Compiler_LCNF_PP_ppLetDecl___closed__1 = _init_l_Lean_Compiler_LCNF_PP_ppLetDecl___closed__1();
@@ -3854,6 +4035,12 @@ l_Lean_Compiler_LCNF_ppDecl___lambda__1___closed__1 = _init_l_Lean_Compiler_LCNF
 lean_mark_persistent(l_Lean_Compiler_LCNF_ppDecl___lambda__1___closed__1);
 l_Lean_Compiler_LCNF_ppDecl___lambda__1___closed__2 = _init_l_Lean_Compiler_LCNF_ppDecl___lambda__1___closed__2();
 lean_mark_persistent(l_Lean_Compiler_LCNF_ppDecl___lambda__1___closed__2);
+l_Lean_Compiler_LCNF_ppDecl_x27_go___closed__1 = _init_l_Lean_Compiler_LCNF_ppDecl_x27_go___closed__1();
+lean_mark_persistent(l_Lean_Compiler_LCNF_ppDecl_x27_go___closed__1);
+l_Lean_Compiler_LCNF_ppDecl_x27___closed__1 = _init_l_Lean_Compiler_LCNF_ppDecl_x27___closed__1();
+lean_mark_persistent(l_Lean_Compiler_LCNF_ppDecl_x27___closed__1);
+l_Lean_Compiler_LCNF_ppDecl_x27___closed__2 = _init_l_Lean_Compiler_LCNF_ppDecl_x27___closed__2();
+lean_mark_persistent(l_Lean_Compiler_LCNF_ppDecl_x27___closed__2);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus

stage0/stdlib/Lean/Compiler/LCNF/SpecInfo.c

@@ -2810,6 +2810,7 @@ x_64 = l___private_Lean_Compiler_LCNF_SpecInfo_0__Lean_Compiler_LCNF_isNoSpecTyp
 if (x_64 == 0)
 {
 uint8_t x_65; 
+lean_inc(x_41);
 x_65 = l_Lean_Compiler_LCNF_isTypeFormerType(x_41);
 if (x_65 == 0)
 {
@@ -2878,6 +2879,7 @@ x_78 = l___private_Lean_Compiler_LCNF_SpecInfo_0__Lean_Compiler_LCNF_isNoSpecTyp
 if (x_78 == 0)
 {
 uint8_t x_79; 
+lean_inc(x_41);
 x_79 = l_Lean_Compiler_LCNF_isTypeFormerType(x_41);
 if (x_79 == 0)
 {

stage0/stdlib/Lean/Compiler/LCNF/Specialize.c

@@ -143,6 +143,7 @@ LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Specialize_specializeApp_x3f___lam
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Specialize_Collector_State_decls___default;
 static lean_object* l_Lean_Compiler_LCNF_Specialize_Collector_collectFVar___closed__2;
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_Specialize_specializeApp_x3f___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_HashMap_insert___at_Lean_Compiler_LCNF_addFVarSubst___spec__1(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_specialize___closed__3;
 lean_object* l_List_mapTRAux___at_Lean_Compiler_LCNF_saveSpecParamInfo___spec__10(lean_object*, lean_object*);
 static lean_object* l_panic___at_Lean_Compiler_LCNF_Specialize_Collector_collectFVar___spec__1___closed__5;
@@ -243,7 +244,6 @@ LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Specialize_specializeApp_x3f___lam
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_Specialize_Collector_collectCode___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_Specialize_initFn____x40_Lean_Compiler_LCNF_Specialize___hyg_10____closed__3;
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_HashMap_insert___at___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_Internalize_mkNewFVarId___spec__3(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_Specialize_specializeApp_x3f___lambda__5___closed__8;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Specialize_mkSpecDecl___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Specialize_withFVar___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -275,7 +275,7 @@ lean_object* l_Lean_SMap_find_x3f___at_Lean_Compiler_LCNF_getSpecParamInfoCore_x
 lean_object* l_ReaderT_instMonadReaderT___rarg(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Specialize_Context_scope___default;
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Compiler_LCNF_Specialize_expandCodeDecls___spec__1(size_t, size_t, lean_object*);
-lean_object* l___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_normExprImp_go(lean_object*, lean_object*);
+lean_object* l___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_normExprImp_go(lean_object*, uint8_t, lean_object*);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_Specialize_shouldSpecialize___spec__1(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_addTrace___at_Lean_Compiler_LCNF_Specialize_specializeApp_x3f___spec__7___closed__1;
 static lean_object* l_Lean_Compiler_LCNF_Specialize_mkSpecDecl___closed__1;
@@ -7190,7 +7190,7 @@ goto block_23;
 }
 else
 {
-lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; 
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 
 x_60 = lean_ctor_get(x_36, 0);
 lean_inc(x_60);
 lean_dec(x_36);
@@ -7200,125 +7200,127 @@ lean_inc(x_62);
 x_63 = lean_ctor_get(x_61, 1);
 lean_inc(x_63);
 lean_dec(x_61);
-x_64 = l___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_normExprImp_go(x_62, x_60);
-x_65 = lean_st_ref_get(x_10, x_63);
-x_66 = lean_ctor_get(x_65, 1);
-lean_inc(x_66);
-lean_dec(x_65);
-x_67 = lean_st_ref_take(x_7, x_66);
-x_68 = lean_ctor_get(x_67, 0);
-lean_inc(x_68);
-x_69 = lean_ctor_get(x_67, 1);
+x_64 = 1;
+x_65 = l___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_normExprImp_go(x_62, x_64, x_60);
+x_66 = lean_st_ref_get(x_10, x_63);
+x_67 = lean_ctor_get(x_66, 1);
+lean_inc(x_67);
+lean_dec(x_66);
+x_68 = lean_st_ref_take(x_7, x_67);
+x_69 = lean_ctor_get(x_68, 0);
 lean_inc(x_69);
-lean_dec(x_67);
-x_70 = lean_ctor_get(x_14, 0);
+x_70 = lean_ctor_get(x_68, 1);
 lean_inc(x_70);
+lean_dec(x_68);
+x_71 = lean_ctor_get(x_14, 0);
+lean_inc(x_71);
 lean_dec(x_14);
-x_71 = l_Std_HashMap_insert___at___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_Internalize_mkNewFVarId___spec__3(x_68, x_70, x_64);
-x_72 = lean_st_ref_set(x_7, x_71, x_69);
-x_73 = lean_ctor_get(x_72, 1);
-lean_inc(x_73);
-lean_dec(x_72);
-x_74 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_74, 0, x_6);
-x_15 = x_74;
-x_16 = x_73;
+x_72 = l_Std_HashMap_insert___at_Lean_Compiler_LCNF_addFVarSubst___spec__1(x_69, x_71, x_65);
+x_73 = lean_st_ref_set(x_7, x_72, x_70);
+x_74 = lean_ctor_get(x_73, 1);
+lean_inc(x_74);
+lean_dec(x_73);
+x_75 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_75, 0, x_6);
+x_15 = x_75;
+x_16 = x_74;
 goto block_23;
 }
 }
 else
 {
-lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; 
+lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; 
 lean_dec(x_25);
-x_75 = lean_array_fget(x_27, x_28);
-x_76 = lean_unsigned_to_nat(1u);
-x_77 = lean_nat_add(x_28, x_76);
+x_76 = lean_array_fget(x_27, x_28);
+x_77 = lean_unsigned_to_nat(1u);
+x_78 = lean_nat_add(x_28, x_77);
 lean_dec(x_28);
-x_78 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_78, 0, x_27);
-lean_ctor_set(x_78, 1, x_77);
-lean_ctor_set(x_78, 2, x_29);
-if (lean_obj_tag(x_75) == 0)
+x_79 = lean_alloc_ctor(0, 3, 0);
+lean_ctor_set(x_79, 0, x_27);
+lean_ctor_set(x_79, 1, x_78);
+lean_ctor_set(x_79, 2, x_29);
+if (lean_obj_tag(x_76) == 0)
 {
-lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; 
-x_79 = lean_ctor_get(x_14, 0);
-lean_inc(x_79);
-x_80 = lean_ctor_get(x_14, 1);
+lean_object* x_80; lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; 
+x_80 = lean_ctor_get(x_14, 0);
 lean_inc(x_80);
-x_81 = lean_ctor_get(x_14, 2);
+x_81 = lean_ctor_get(x_14, 1);
 lean_inc(x_81);
-x_82 = lean_ctor_get_uint8(x_14, sizeof(void*)*3);
+x_82 = lean_ctor_get(x_14, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get_uint8(x_14, sizeof(void*)*3);
 if (lean_is_exclusive(x_14)) {
  lean_ctor_release(x_14, 0);
  lean_ctor_release(x_14, 1);
  lean_ctor_release(x_14, 2);
- x_83 = x_14;
+ x_84 = x_14;
 } else {
  lean_dec_ref(x_14);
- x_83 = lean_box(0);
+ x_84 = lean_box(0);
 }
-x_84 = lean_ctor_get(x_1, 1);
-x_85 = l_Lean_Expr_instantiateLevelParamsCore_visit___at_Lean_Expr_instantiateLevelParams___spec__1(x_84, x_2, x_81);
-if (lean_is_scalar(x_83)) {
- x_86 = lean_alloc_ctor(0, 3, 1);
+x_85 = lean_ctor_get(x_1, 1);
+x_86 = l_Lean_Expr_instantiateLevelParamsCore_visit___at_Lean_Expr_instantiateLevelParams___spec__1(x_85, x_2, x_82);
+if (lean_is_scalar(x_84)) {
+ x_87 = lean_alloc_ctor(0, 3, 1);
 } else {
- x_86 = x_83;
+ x_87 = x_84;
 }
-lean_ctor_set(x_86, 0, x_79);
-lean_ctor_set(x_86, 1, x_80);
-lean_ctor_set(x_86, 2, x_85);
-lean_ctor_set_uint8(x_86, sizeof(void*)*3, x_82);
-x_87 = l_Lean_Compiler_LCNF_Internalize_internalizeParam(x_86, x_7, x_8, x_9, x_10, x_11);
-x_88 = lean_ctor_get(x_87, 0);
-lean_inc(x_88);
-x_89 = lean_ctor_get(x_87, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_86);
+lean_ctor_set_uint8(x_87, sizeof(void*)*3, x_83);
+x_88 = l_Lean_Compiler_LCNF_Internalize_internalizeParam(x_87, x_7, x_8, x_9, x_10, x_11);
+x_89 = lean_ctor_get(x_88, 0);
 lean_inc(x_89);
-lean_dec(x_87);
-x_90 = lean_array_push(x_26, x_88);
-lean_ctor_set(x_6, 1, x_90);
-lean_ctor_set(x_6, 0, x_78);
-x_91 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_91, 0, x_6);
-x_15 = x_91;
-x_16 = x_89;
+x_90 = lean_ctor_get(x_88, 1);
+lean_inc(x_90);
+lean_dec(x_88);
+x_91 = lean_array_push(x_26, x_89);
+lean_ctor_set(x_6, 1, x_91);
+lean_ctor_set(x_6, 0, x_79);
+x_92 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_92, 0, x_6);
+x_15 = x_92;
+x_16 = x_90;
 goto block_23;
 }
 else
 {
-lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; 
-x_92 = lean_ctor_get(x_75, 0);
-lean_inc(x_92);
-lean_dec(x_75);
-x_93 = lean_st_ref_get(x_7, x_11);
-x_94 = lean_ctor_get(x_93, 0);
-lean_inc(x_94);
-x_95 = lean_ctor_get(x_93, 1);
+lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; uint8_t x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; 
+x_93 = lean_ctor_get(x_76, 0);
+lean_inc(x_93);
+lean_dec(x_76);
+x_94 = lean_st_ref_get(x_7, x_11);
+x_95 = lean_ctor_get(x_94, 0);
 lean_inc(x_95);
-lean_dec(x_93);
-x_96 = l___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_normExprImp_go(x_94, x_92);
-x_97 = lean_st_ref_get(x_10, x_95);
-x_98 = lean_ctor_get(x_97, 1);
-lean_inc(x_98);
-lean_dec(x_97);
-x_99 = lean_st_ref_take(x_7, x_98);
-x_100 = lean_ctor_get(x_99, 0);
+x_96 = lean_ctor_get(x_94, 1);
+lean_inc(x_96);
+lean_dec(x_94);
+x_97 = 1;
+x_98 = l___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_normExprImp_go(x_95, x_97, x_93);
+x_99 = lean_st_ref_get(x_10, x_96);
+x_100 = lean_ctor_get(x_99, 1);
 lean_inc(x_100);
-x_101 = lean_ctor_get(x_99, 1);
-lean_inc(x_101);
 lean_dec(x_99);
-x_102 = lean_ctor_get(x_14, 0);
+x_101 = lean_st_ref_take(x_7, x_100);
+x_102 = lean_ctor_get(x_101, 0);
 lean_inc(x_102);
+x_103 = lean_ctor_get(x_101, 1);
+lean_inc(x_103);
+lean_dec(x_101);
+x_104 = lean_ctor_get(x_14, 0);
+lean_inc(x_104);
 lean_dec(x_14);
-x_103 = l_Std_HashMap_insert___at___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_Internalize_mkNewFVarId___spec__3(x_100, x_102, x_96);
-x_104 = lean_st_ref_set(x_7, x_103, x_101);
-x_105 = lean_ctor_get(x_104, 1);
-lean_inc(x_105);
-lean_dec(x_104);
-lean_ctor_set(x_6, 0, x_78);
-x_106 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_106, 0, x_6);
-x_15 = x_106;
-x_16 = x_105;
+x_105 = l_Std_HashMap_insert___at_Lean_Compiler_LCNF_addFVarSubst___spec__1(x_102, x_104, x_98);
+x_106 = lean_st_ref_set(x_7, x_105, x_103);
+x_107 = lean_ctor_get(x_106, 1);
+lean_inc(x_107);
+lean_dec(x_106);
+lean_ctor_set(x_6, 0, x_79);
+x_108 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_108, 0, x_6);
+x_15 = x_108;
+x_16 = x_107;
 goto block_23;
 }
 }
@@ -7326,143 +7328,144 @@ goto block_23;
 }
 else
 {
-lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; uint8_t x_112; 
-x_107 = lean_ctor_get(x_6, 0);
-x_108 = lean_ctor_get(x_6, 1);
-lean_inc(x_108);
-lean_inc(x_107);
-lean_dec(x_6);
-x_109 = lean_ctor_get(x_107, 0);
-lean_inc(x_109);
-x_110 = lean_ctor_get(x_107, 1);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; uint8_t x_114; 
+x_109 = lean_ctor_get(x_6, 0);
+x_110 = lean_ctor_get(x_6, 1);
 lean_inc(x_110);
-x_111 = lean_ctor_get(x_107, 2);
+lean_inc(x_109);
+lean_dec(x_6);
+x_111 = lean_ctor_get(x_109, 0);
 lean_inc(x_111);
-x_112 = lean_nat_dec_lt(x_110, x_111);
-if (x_112 == 0)
+x_112 = lean_ctor_get(x_109, 1);
+lean_inc(x_112);
+x_113 = lean_ctor_get(x_109, 2);
+lean_inc(x_113);
+x_114 = lean_nat_dec_lt(x_112, x_113);
+if (x_114 == 0)
 {
-lean_object* x_113; lean_object* x_114; 
+lean_object* x_115; lean_object* x_116; 
+lean_dec(x_113);
+lean_dec(x_112);
 lean_dec(x_111);
-lean_dec(x_110);
-lean_dec(x_109);
 lean_dec(x_14);
-x_113 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_113, 0, x_107);
-lean_ctor_set(x_113, 1, x_108);
-x_114 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_114, 0, x_113);
-x_15 = x_114;
+x_115 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_115, 0, x_109);
+lean_ctor_set(x_115, 1, x_110);
+x_116 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_116, 0, x_115);
+x_15 = x_116;
 x_16 = x_11;
 goto block_23;
 }
 else
 {
-lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; 
-if (lean_is_exclusive(x_107)) {
- lean_ctor_release(x_107, 0);
- lean_ctor_release(x_107, 1);
- lean_ctor_release(x_107, 2);
- x_115 = x_107;
+lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; 
+if (lean_is_exclusive(x_109)) {
+ lean_ctor_release(x_109, 0);
+ lean_ctor_release(x_109, 1);
+ lean_ctor_release(x_109, 2);
+ x_117 = x_109;
 } else {
- lean_dec_ref(x_107);
- x_115 = lean_box(0);
+ lean_dec_ref(x_109);
+ x_117 = lean_box(0);
 }
-x_116 = lean_array_fget(x_109, x_110);
-x_117 = lean_unsigned_to_nat(1u);
-x_118 = lean_nat_add(x_110, x_117);
-lean_dec(x_110);
-if (lean_is_scalar(x_115)) {
- x_119 = lean_alloc_ctor(0, 3, 0);
+x_118 = lean_array_fget(x_111, x_112);
+x_119 = lean_unsigned_to_nat(1u);
+x_120 = lean_nat_add(x_112, x_119);
+lean_dec(x_112);
+if (lean_is_scalar(x_117)) {
+ x_121 = lean_alloc_ctor(0, 3, 0);
 } else {
- x_119 = x_115;
+ x_121 = x_117;
 }
-lean_ctor_set(x_119, 0, x_109);
-lean_ctor_set(x_119, 1, x_118);
-lean_ctor_set(x_119, 2, x_111);
-if (lean_obj_tag(x_116) == 0)
+lean_ctor_set(x_121, 0, x_111);
+lean_ctor_set(x_121, 1, x_120);
+lean_ctor_set(x_121, 2, x_113);
+if (lean_obj_tag(x_118) == 0)
 {
-lean_object* x_120; lean_object* x_121; lean_object* x_122; uint8_t x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_120 = lean_ctor_get(x_14, 0);
-lean_inc(x_120);
-x_121 = lean_ctor_get(x_14, 1);
-lean_inc(x_121);
-x_122 = lean_ctor_get(x_14, 2);
+lean_object* x_122; lean_object* x_123; lean_object* x_124; uint8_t x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; 
+x_122 = lean_ctor_get(x_14, 0);
 lean_inc(x_122);
-x_123 = lean_ctor_get_uint8(x_14, sizeof(void*)*3);
+x_123 = lean_ctor_get(x_14, 1);
+lean_inc(x_123);
+x_124 = lean_ctor_get(x_14, 2);
+lean_inc(x_124);
+x_125 = lean_ctor_get_uint8(x_14, sizeof(void*)*3);
 if (lean_is_exclusive(x_14)) {
  lean_ctor_release(x_14, 0);
  lean_ctor_release(x_14, 1);
  lean_ctor_release(x_14, 2);
- x_124 = x_14;
+ x_126 = x_14;
 } else {
  lean_dec_ref(x_14);
- x_124 = lean_box(0);
+ x_126 = lean_box(0);
 }
-x_125 = lean_ctor_get(x_1, 1);
-x_126 = l_Lean_Expr_instantiateLevelParamsCore_visit___at_Lean_Expr_instantiateLevelParams___spec__1(x_125, x_2, x_122);
-if (lean_is_scalar(x_124)) {
- x_127 = lean_alloc_ctor(0, 3, 1);
+x_127 = lean_ctor_get(x_1, 1);
+x_128 = l_Lean_Expr_instantiateLevelParamsCore_visit___at_Lean_Expr_instantiateLevelParams___spec__1(x_127, x_2, x_124);
+if (lean_is_scalar(x_126)) {
+ x_129 = lean_alloc_ctor(0, 3, 1);
 } else {
- x_127 = x_124;
+ x_129 = x_126;
 }
-lean_ctor_set(x_127, 0, x_120);
-lean_ctor_set(x_127, 1, x_121);
-lean_ctor_set(x_127, 2, x_126);
-lean_ctor_set_uint8(x_127, sizeof(void*)*3, x_123);
-x_128 = l_Lean_Compiler_LCNF_Internalize_internalizeParam(x_127, x_7, x_8, x_9, x_10, x_11);
-x_129 = lean_ctor_get(x_128, 0);
-lean_inc(x_129);
-x_130 = lean_ctor_get(x_128, 1);
-lean_inc(x_130);
-lean_dec(x_128);
-x_131 = lean_array_push(x_108, x_129);
-x_132 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_132, 0, x_119);
-lean_ctor_set(x_132, 1, x_131);
-x_133 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_133, 0, x_132);
-x_15 = x_133;
-x_16 = x_130;
+lean_ctor_set(x_129, 0, x_122);
+lean_ctor_set(x_129, 1, x_123);
+lean_ctor_set(x_129, 2, x_128);
+lean_ctor_set_uint8(x_129, sizeof(void*)*3, x_125);
+x_130 = l_Lean_Compiler_LCNF_Internalize_internalizeParam(x_129, x_7, x_8, x_9, x_10, x_11);
+x_131 = lean_ctor_get(x_130, 0);
+lean_inc(x_131);
+x_132 = lean_ctor_get(x_130, 1);
+lean_inc(x_132);
+lean_dec(x_130);
+x_133 = lean_array_push(x_110, x_131);
+x_134 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_134, 0, x_121);
+lean_ctor_set(x_134, 1, x_133);
+x_135 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_135, 0, x_134);
+x_15 = x_135;
+x_16 = x_132;
 goto block_23;
 }
 else
 {
-lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; 
-x_134 = lean_ctor_get(x_116, 0);
-lean_inc(x_134);
-lean_dec(x_116);
-x_135 = lean_st_ref_get(x_7, x_11);
-x_136 = lean_ctor_get(x_135, 0);
+lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; uint8_t x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
+x_136 = lean_ctor_get(x_118, 0);
 lean_inc(x_136);
-x_137 = lean_ctor_get(x_135, 1);
-lean_inc(x_137);
-lean_dec(x_135);
-x_138 = l___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_normExprImp_go(x_136, x_134);
-x_139 = lean_st_ref_get(x_10, x_137);
-x_140 = lean_ctor_get(x_139, 1);
-lean_inc(x_140);
-lean_dec(x_139);
-x_141 = lean_st_ref_take(x_7, x_140);
-x_142 = lean_ctor_get(x_141, 0);
-lean_inc(x_142);
-x_143 = lean_ctor_get(x_141, 1);
+lean_dec(x_118);
+x_137 = lean_st_ref_get(x_7, x_11);
+x_138 = lean_ctor_get(x_137, 0);
+lean_inc(x_138);
+x_139 = lean_ctor_get(x_137, 1);
+lean_inc(x_139);
+lean_dec(x_137);
+x_140 = 1;
+x_141 = l___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_normExprImp_go(x_138, x_140, x_136);
+x_142 = lean_st_ref_get(x_10, x_139);
+x_143 = lean_ctor_get(x_142, 1);
 lean_inc(x_143);
-lean_dec(x_141);
-x_144 = lean_ctor_get(x_14, 0);
-lean_inc(x_144);
-lean_dec(x_14);
-x_145 = l_Std_HashMap_insert___at___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_Internalize_mkNewFVarId___spec__3(x_142, x_144, x_138);
-x_146 = lean_st_ref_set(x_7, x_145, x_143);
-x_147 = lean_ctor_get(x_146, 1);
+lean_dec(x_142);
+x_144 = lean_st_ref_take(x_7, x_143);
+x_145 = lean_ctor_get(x_144, 0);
+lean_inc(x_145);
+x_146 = lean_ctor_get(x_144, 1);
+lean_inc(x_146);
+lean_dec(x_144);
+x_147 = lean_ctor_get(x_14, 0);
 lean_inc(x_147);
-lean_dec(x_146);
-x_148 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_148, 0, x_119);
-lean_ctor_set(x_148, 1, x_108);
-x_149 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_149, 0, x_148);
-x_15 = x_149;
-x_16 = x_147;
+lean_dec(x_14);
+x_148 = l_Std_HashMap_insert___at_Lean_Compiler_LCNF_addFVarSubst___spec__1(x_145, x_147, x_141);
+x_149 = lean_st_ref_set(x_7, x_148, x_146);
+x_150 = lean_ctor_get(x_149, 1);
+lean_inc(x_150);
+lean_dec(x_149);
+x_151 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_151, 0, x_121);
+lean_ctor_set(x_151, 1, x_110);
+x_152 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_152, 0, x_151);
+x_15 = x_152;
+x_16 = x_150;
 goto block_23;
 }
 }

stage0/stdlib/Lean/Compiler/LCNF/ToLCNF.c

@@ -180,7 +180,7 @@ LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_ToLCNF_State_isTypeFormerTypeCache
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_ToLCNF_toLCNF_visit___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static size_t l_Std_PersistentHashMap_insertAux___at_Lean_Compiler_LCNF_ToLCNF_toLCNF_visitCore___spec__2___closed__1;
 LEAN_EXPORT lean_object* l_Std_HashMap_insert___at___private_Lean_Compiler_LCNF_ToLCNF_0__Lean_Compiler_LCNF_ToLCNF_isTypeFormerType___spec__1(lean_object*, lean_object*, uint8_t);
-lean_object* l_Lean_Compiler_LCNF_replaceExprFVars(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Compiler_LCNF_replaceExprFVars(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_ToLCNF_bindCases_go___closed__11;
 LEAN_EXPORT lean_object* l_Lean_Meta_forallBoundedTelescope___at_Lean_Compiler_LCNF_ToLCNF_etaExpandN___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_instInhabitedProjectionFunctionInfo;
@@ -200,6 +200,7 @@ lean_object* l_Std_RBNode_appendTrees___rarg(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_ToLCNF_State_typeCache___default;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_ToLCNF_mkAuxLetDecl___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_panic___at_Lean_Expr_getRevArg_x21___spec__1(lean_object*);
+lean_object* l_Std_HashMap_insert___at_Lean_Compiler_LCNF_addFVarSubst___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_balRight___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_ToLCNF_toLCNF_visitApp___closed__9;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_ToLCNF_toCode___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -373,7 +374,6 @@ lean_object* lean_nat_mul(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Std_AssocList_contains___at___private_Lean_Compiler_LCNF_ToLCNF_0__Lean_Compiler_LCNF_ToLCNF_isTypeFormerType___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Name_getPrefix(lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_HashMap_insert___at___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_Internalize_mkNewFVarId___spec__3(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Expr_isFVar(lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_ToLCNF_instInhabitedElement___closed__5;
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
@@ -975,7 +975,7 @@ return x_11;
 }
 else
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; size_t x_34; size_t x_35; 
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; size_t x_35; size_t x_36; 
 x_12 = lean_ctor_get(x_1, 0);
 x_13 = lean_array_uget(x_12, x_3);
 x_14 = lean_ctor_get(x_4, 0);
@@ -990,43 +990,44 @@ lean_inc(x_17);
 lean_dec(x_15);
 x_18 = lean_ctor_get(x_13, 2);
 lean_inc(x_18);
+x_19 = 1;
 lean_inc(x_17);
-x_19 = l_Lean_Compiler_LCNF_replaceExprFVars(x_18, x_17, x_6, x_7, x_8, x_9);
-x_20 = lean_ctor_get(x_19, 0);
-lean_inc(x_20);
-x_21 = lean_ctor_get(x_19, 1);
+x_20 = l_Lean_Compiler_LCNF_replaceExprFVars(x_18, x_17, x_19, x_6, x_7, x_8, x_9);
+x_21 = lean_ctor_get(x_20, 0);
 lean_inc(x_21);
-lean_dec(x_19);
-x_22 = 0;
-x_23 = l_Lean_Compiler_LCNF_mkAuxParam(x_20, x_22, x_6, x_7, x_8, x_21);
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-x_25 = lean_ctor_get(x_23, 1);
+x_22 = lean_ctor_get(x_20, 1);
+lean_inc(x_22);
+lean_dec(x_20);
+x_23 = 0;
+x_24 = l_Lean_Compiler_LCNF_mkAuxParam(x_21, x_23, x_6, x_7, x_8, x_22);
+x_25 = lean_ctor_get(x_24, 0);
 lean_inc(x_25);
-lean_dec(x_23);
-lean_inc(x_24);
-x_26 = lean_array_push(x_16, x_24);
-x_27 = lean_ctor_get(x_24, 0);
-lean_inc(x_27);
+x_26 = lean_ctor_get(x_24, 1);
+lean_inc(x_26);
 lean_dec(x_24);
-x_28 = l_Lean_Expr_fvar___override(x_27);
-x_29 = lean_ctor_get(x_13, 0);
-lean_inc(x_29);
-lean_dec(x_13);
+lean_inc(x_25);
+x_27 = lean_array_push(x_16, x_25);
+x_28 = lean_ctor_get(x_25, 0);
 lean_inc(x_28);
-x_30 = l_Std_HashMap_insert___at___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_Internalize_mkNewFVarId___spec__3(x_17, x_29, x_28);
-x_31 = lean_array_push(x_14, x_28);
-x_32 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_32, 0, x_26);
-lean_ctor_set(x_32, 1, x_30);
+lean_dec(x_25);
+x_29 = l_Lean_Expr_fvar___override(x_28);
+x_30 = lean_ctor_get(x_13, 0);
+lean_inc(x_30);
+lean_dec(x_13);
+lean_inc(x_29);
+x_31 = l_Std_HashMap_insert___at_Lean_Compiler_LCNF_addFVarSubst___spec__1(x_17, x_30, x_29);
+x_32 = lean_array_push(x_14, x_29);
 x_33 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_33, 0, x_31);
-lean_ctor_set(x_33, 1, x_32);
-x_34 = 1;
-x_35 = lean_usize_add(x_3, x_34);
-x_3 = x_35;
-x_4 = x_33;
-x_9 = x_25;
+lean_ctor_set(x_33, 0, x_27);
+lean_ctor_set(x_33, 1, x_31);
+x_34 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_34, 0, x_32);
+lean_ctor_set(x_34, 1, x_33);
+x_35 = 1;
+x_36 = lean_usize_add(x_3, x_35);
+x_3 = x_36;
+x_4 = x_34;
+x_9 = x_26;
 goto _start;
 }
 }

stage0/stdlib/Lean/Compiler/LCNF/Types.c

@@ -4264,25 +4264,31 @@ return x_81;
 LEAN_EXPORT uint8_t l_Lean_Compiler_LCNF_isTypeFormerType(lean_object* x_1) {
 _start:
 {
-switch (lean_obj_tag(x_1)) {
+lean_object* x_2; 
+x_2 = l_Lean_Expr_headBeta(x_1);
+switch (lean_obj_tag(x_2)) {
 case 3:
 {
-uint8_t x_2; 
-x_2 = 1;
-return x_2;
+uint8_t x_3; 
+lean_dec(x_2);
+x_3 = 1;
+return x_3;
 }
 case 7:
 {
-lean_object* x_3; 
-x_3 = lean_ctor_get(x_1, 2);
-x_1 = x_3;
+lean_object* x_4; 
+x_4 = lean_ctor_get(x_2, 2);
+lean_inc(x_4);
+lean_dec(x_2);
+x_1 = x_4;
 goto _start;
 }
 default: 
 {
-uint8_t x_5; 
-x_5 = 0;
-return x_5;
+uint8_t x_6; 
+lean_dec(x_2);
+x_6 = 0;
+return x_6;
 }
 }
 }
@@ -4292,7 +4298,6 @@ _start:
 {
 uint8_t x_2; lean_object* x_3; 
 x_2 = l_Lean_Compiler_LCNF_isTypeFormerType(x_1);
-lean_dec(x_1);
 x_3 = lean_box(x_2);
 return x_3;
 }

stage0/stdlib/Lean/CoreM.c

@@ -229,6 +229,7 @@ LEAN_EXPORT lean_object* l_Lean_Core_instMonadCoreM___lambda__1(lean_object*, le
 LEAN_EXPORT lean_object* l_Lean_Core_instMetaEvalCoreM___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Core_instMonadQuotationCoreM;
 size_t lean_usize_of_nat(lean_object*);
+extern lean_object* l_Lean_NameSet_empty;
 LEAN_EXPORT lean_object* l_Lean_Core_withCurrHeartbeats(lean_object*, lean_object*);
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Std_PersistentHashMap_insertAux_traverse___at_Lean_Core_instantiateTypeLevelParams___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -735,17 +736,19 @@ return x_5;
 static lean_object* _init_l_Lean_Core_instInhabitedState___closed__6() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Core_instInhabitedState___closed__1;
 x_2 = l_Lean_Core_instInhabitedState___closed__2;
 x_3 = l_Lean_Core_instInhabitedState___closed__3;
-x_4 = l_Lean_Core_instInhabitedState___closed__5;
-x_5 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_4);
-return x_5;
+x_4 = l_Lean_NameSet_empty;
+x_5 = l_Lean_Core_instInhabitedState___closed__5;
+x_6 = lean_alloc_ctor(0, 5, 0);
+lean_ctor_set(x_6, 0, x_1);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set(x_6, 4, x_5);
+return x_6;
 }
 }
 static lean_object* _init_l_Lean_Core_instInhabitedState___closed__7() {

stage0/stdlib/Lean/Deprecated.c

@@ -21,7 +21,6 @@ lean_object* l_Lean_stringToMessageData(lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 lean_object* l_Lean_Name_str___override(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_initFn____x40_Lean_Deprecated___hyg_4____lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_filterTRAux___at_Lean_resolveGlobalConstCore___spec__1(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_deprecatedAttr;
 static lean_object* l_Lean_initFn____x40_Lean_Deprecated___hyg_4____closed__6;
@@ -134,6 +133,7 @@ LEAN_EXPORT lean_object* l_Lean_Elab_resolveGlobalConstNoOverloadWithInfo___at_L
 lean_object* l_Lean_Syntax_formatStxAux(lean_object*, uint8_t, lean_object*, lean_object*);
 static lean_object* l_Lean_initFn____x40_Lean_Deprecated___hyg_4____lambda__2___closed__2;
 LEAN_EXPORT uint8_t l_Lean_isDeprecated(lean_object*, lean_object*);
+lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_initFn____x40_Lean_Deprecated___hyg_4____spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -372,7 +372,7 @@ x_10 = l_Lean_throwUnknownConstant___at_Lean_initFn____x40_Lean_Deprecated___hyg
 x_11 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_11, 0, x_9);
 lean_ctor_set(x_11, 1, x_10);
-x_12 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_11, x_2, x_3, x_4);
+x_12 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_11, x_2, x_3, x_4);
 return x_12;
 }
 }

stage0/stdlib/Lean/Elab/Command.c

@@ -464,6 +464,7 @@ extern lean_object* l_Lean_warningAsError;
 size_t lean_usize_of_nat(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Command_withMacroExpansion(lean_object*);
 lean_object* l_Lean_InternalExceptionId_getName(lean_object*, lean_object*);
+extern lean_object* l_Lean_NameSet_empty;
 lean_object* l_Lean_Elab_expandDeclIdCore(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_profileitM___at_Lean_Elab_Command_runLinters___spec__5(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_mkDeclName___at_Lean_Elab_Command_expandDeclId___spec__2___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1146,17 +1147,19 @@ return x_5;
 static lean_object* _init_l_Lean_Elab_Command_instInhabitedState___closed__6() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Elab_Command_instInhabitedState___closed__1;
 x_2 = l_Lean_Elab_Command_instInhabitedState___closed__3;
 x_3 = l_Lean_Elab_Command_Scope_varDecls___default___closed__1;
-x_4 = l_Lean_Elab_Command_instInhabitedState___closed__5;
-x_5 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_4);
-return x_5;
+x_4 = l_Lean_NameSet_empty;
+x_5 = l_Lean_Elab_Command_instInhabitedState___closed__5;
+x_6 = lean_alloc_ctor(0, 5, 0);
+lean_ctor_set(x_6, 0, x_1);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set(x_6, 4, x_5);
+return x_6;
 }
 }
 static lean_object* _init_l_Lean_Elab_Command_instInhabitedState___closed__7() {

stage0/stdlib/Lean/Elab/InfoTree/Types.c

@@ -53,6 +53,7 @@ LEAN_EXPORT lean_object* l_Lean_Elab_ContextInfo_openDecls___default;
 static lean_object* l_Lean_Elab_instInhabitedTermInfo___closed__5;
 static lean_object* l_Lean_Elab_instInhabitedElabInfo___closed__1;
 lean_object* l_Lean_Expr_bvar___override(lean_object*);
+extern lean_object* l_Lean_NameSet_empty;
 LEAN_EXPORT lean_object* l_Lean_Elab_ContextInfo_currNamespace___default;
 static lean_object* l_Lean_Elab_InfoState_trees___default___closed__2;
 LEAN_EXPORT lean_object* l_Lean_Elab_instInhabitedCustomInfo;
@@ -251,17 +252,19 @@ return x_5;
 static lean_object* _init_l_Lean_Elab_instInhabitedContextInfo___closed__6() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Elab_instInhabitedContextInfo___closed__1;
 x_2 = l_Lean_Elab_instInhabitedContextInfo___closed__2;
 x_3 = l_Lean_Elab_instInhabitedContextInfo___closed__3;
-x_4 = l_Lean_Elab_instInhabitedContextInfo___closed__5;
-x_5 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_4);
-return x_5;
+x_4 = l_Lean_NameSet_empty;
+x_5 = l_Lean_Elab_instInhabitedContextInfo___closed__5;
+x_6 = lean_alloc_ctor(0, 5, 0);
+lean_ctor_set(x_6, 0, x_1);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set(x_6, 4, x_5);
+return x_6;
 }
 }
 static lean_object* _init_l_Lean_Elab_instInhabitedContextInfo___closed__7() {

stage0/stdlib/Lean/Elab/InheritDoc.c

@@ -20,7 +20,6 @@ LEAN_EXPORT lean_object* l_Lean_initFn____x40_Lean_Elab_InheritDoc___hyg_4____la
 static lean_object* l_Lean_initFn____x40_Lean_Elab_InheritDoc___hyg_4____lambda__2___closed__4;
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 lean_object* l_Lean_Name_str___override(lean_object*, lean_object*);
-lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_filterTRAux___at_Lean_resolveGlobalConstCore___spec__1(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_logAt___at_Lean_initFn____x40_Lean_Elab_InheritDoc___hyg_4____spec__17___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_logAt___at_Lean_initFn____x40_Lean_Elab_InheritDoc___hyg_4____spec__17___closed__1;
@@ -158,6 +157,7 @@ static lean_object* l_Lean_resolveGlobalConstNoOverload___at_Lean_initFn____x40_
 LEAN_EXPORT lean_object* l_Lean_Elab_pushInfoTree___at_Lean_initFn____x40_Lean_Elab_InheritDoc___hyg_4____spec__16(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_initFn____x40_Lean_Elab_InheritDoc___hyg_4____lambda__1___closed__1;
 static lean_object* l_Lean_addDocString___at_Lean_initFn____x40_Lean_Elab_InheritDoc___hyg_4____spec__18___closed__5;
+lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_initFn____x40_Lean_Elab_InheritDoc___hyg_4____spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -358,7 +358,7 @@ x_10 = l_Lean_throwUnknownConstant___at_Lean_initFn____x40_Lean_Elab_InheritDoc_
 x_11 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_11, 0, x_9);
 lean_ctor_set(x_11, 1, x_10);
-x_12 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_11, x_2, x_3, x_4);
+x_12 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_11, x_2, x_3, x_4);
 return x_12;
 }
 }
@@ -3066,7 +3066,7 @@ lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
 x_11 = l_Lean_initFn____x40_Lean_Elab_InheritDoc___hyg_4____lambda__4___closed__2;
-x_12 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_11, x_6, x_7, x_8);
+x_12 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_11, x_6, x_7, x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 x_13 = !lean_is_exclusive(x_12);

stage0/stdlib/Lean/Elab/Term.c

@@ -861,6 +861,7 @@ static lean_object* l_Lean_Elab_Term_mkCoe___closed__5;
 LEAN_EXPORT lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_elabTermAux___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Term_expandDeclId___spec__12___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_InternalExceptionId_getName(lean_object*, lean_object*);
+extern lean_object* l_Lean_NameSet_empty;
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Term_instMetaEvalTermElabM___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Term_LVal_getRef(lean_object*);
 lean_object* l_Lean_Elab_expandDeclIdCore(lean_object*);
@@ -1971,17 +1972,19 @@ return x_5;
 static lean_object* _init_l_Lean_Elab_Tactic_instInhabitedSnapshot___closed__6() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Elab_Tactic_instInhabitedSnapshot___closed__1;
 x_2 = l_Lean_Elab_Tactic_instInhabitedSnapshot___closed__3;
 x_3 = l_Lean_Elab_Term_instInhabitedLetRecToLift___closed__1;
-x_4 = l_Lean_Elab_Tactic_instInhabitedSnapshot___closed__5;
-x_5 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_4);
-return x_5;
+x_4 = l_Lean_NameSet_empty;
+x_5 = l_Lean_Elab_Tactic_instInhabitedSnapshot___closed__5;
+x_6 = lean_alloc_ctor(0, 5, 0);
+lean_ctor_set(x_6, 0, x_1);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set(x_6, 4, x_5);
+return x_6;
 }
 }
 static lean_object* _init_l_Lean_Elab_Tactic_instInhabitedSnapshot___closed__7() {

stage0/stdlib/Lean/Expr.c

@@ -17,6 +17,7 @@ lean_object* l_List_reverse___rarg(lean_object*);
 static lean_object* l___private_Lean_Expr_0__Lean_reprBinderInfo____x40_Lean_Expr___hyg_391____closed__20;
 LEAN_EXPORT lean_object* l_Lean_BinderInfo_isImplicit___boxed(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Expr_isBinding___boxed(lean_object*);
+LEAN_EXPORT uint8_t l_Lean_Expr_isType0(lean_object*);
 static lean_object* l_Lean_Expr_letName_x21___closed__2;
 static lean_object* l_Lean_Expr_ctorName___closed__7;
 static lean_object* l_Lean_mkNatLit___closed__8;
@@ -91,6 +92,7 @@ static lean_object* l_Lean_Expr_litValue_x21___closed__2;
 lean_object* lean_array_uget(lean_object*, size_t);
 static lean_object* l___private_Lean_Expr_0__Lean_reprExpr____x40_Lean_Expr___hyg_2880____closed__8;
 LEAN_EXPORT lean_object* l_Lean_Expr_replaceFVarId___boxed(lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Expr_isType0___boxed(lean_object*);
 static lean_object* l_Lean_mkSimpleThunkType___closed__3;
 LEAN_EXPORT uint8_t l_Lean_Expr_isProp(lean_object*);
 static lean_object* l_Lean_Expr_instHashableExpr___closed__1;
@@ -8475,6 +8477,55 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
+LEAN_EXPORT uint8_t l_Lean_Expr_isType0(lean_object* x_1) {
+_start:
+{
+if (lean_obj_tag(x_1) == 3)
+{
+lean_object* x_2; 
+x_2 = lean_ctor_get(x_1, 0);
+if (lean_obj_tag(x_2) == 1)
+{
+lean_object* x_3; 
+x_3 = lean_ctor_get(x_2, 0);
+if (lean_obj_tag(x_3) == 0)
+{
+uint8_t x_4; 
+x_4 = 1;
+return x_4;
+}
+else
+{
+uint8_t x_5; 
+x_5 = 0;
+return x_5;
+}
+}
+else
+{
+uint8_t x_6; 
+x_6 = 0;
+return x_6;
+}
+}
+else
+{
+uint8_t x_7; 
+x_7 = 0;
+return x_7;
+}
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Expr_isType0___boxed(lean_object* x_1) {
+_start:
+{
+uint8_t x_2; lean_object* x_3; 
+x_2 = l_Lean_Expr_isType0(x_1);
+lean_dec(x_1);
+x_3 = lean_box(x_2);
+return x_3;
+}
+}
 LEAN_EXPORT uint8_t l_Lean_Expr_isProp(lean_object* x_1) {
 _start:
 {
@@ -9387,7 +9438,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_getRevArg_x21___closed__1;
-x_3 = lean_unsigned_to_nat(922u);
+x_3 = lean_unsigned_to_nat(966u);
 x_4 = lean_unsigned_to_nat(20u);
 x_5 = l_Lean_Expr_getRevArg_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -9684,7 +9735,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_appFn_x21___closed__1;
-x_3 = lean_unsigned_to_nat(956u);
+x_3 = lean_unsigned_to_nat(1000u);
 x_4 = lean_unsigned_to_nat(15u);
 x_5 = l_Lean_Expr_appFn_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -9733,7 +9784,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_appArg_x21___closed__1;
-x_3 = lean_unsigned_to_nat(960u);
+x_3 = lean_unsigned_to_nat(1004u);
 x_4 = lean_unsigned_to_nat(15u);
 x_5 = l_Lean_Expr_appFn_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -9782,7 +9833,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_appFn_x21_x27___closed__1;
-x_3 = lean_unsigned_to_nat(965u);
+x_3 = lean_unsigned_to_nat(1009u);
 x_4 = lean_unsigned_to_nat(17u);
 x_5 = l_Lean_Expr_appFn_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -9840,7 +9891,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_appArg_x21_x27___closed__1;
-x_3 = lean_unsigned_to_nat(970u);
+x_3 = lean_unsigned_to_nat(1014u);
 x_4 = lean_unsigned_to_nat(17u);
 x_5 = l_Lean_Expr_appFn_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -9906,7 +9957,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_sortLevel_x21___closed__1;
-x_3 = lean_unsigned_to_nat(974u);
+x_3 = lean_unsigned_to_nat(1018u);
 x_4 = lean_unsigned_to_nat(14u);
 x_5 = l_Lean_Expr_sortLevel_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -9972,7 +10023,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_litValue_x21___closed__1;
-x_3 = lean_unsigned_to_nat(978u);
+x_3 = lean_unsigned_to_nat(1022u);
 x_4 = lean_unsigned_to_nat(13u);
 x_5 = l_Lean_Expr_litValue_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -10199,7 +10250,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_constName_x21___closed__1;
-x_3 = lean_unsigned_to_nat(997u);
+x_3 = lean_unsigned_to_nat(1041u);
 x_4 = lean_unsigned_to_nat(17u);
 x_5 = l_Lean_Expr_constName_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -10286,7 +10337,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_constLevels_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1005u);
+x_3 = lean_unsigned_to_nat(1049u);
 x_4 = lean_unsigned_to_nat(18u);
 x_5 = l_Lean_Expr_constName_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -10336,7 +10387,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_bvarIdx_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1009u);
+x_3 = lean_unsigned_to_nat(1053u);
 x_4 = lean_unsigned_to_nat(16u);
 x_5 = l_Lean_Expr_bvarIdx_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -10402,7 +10453,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_fvarId_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1013u);
+x_3 = lean_unsigned_to_nat(1057u);
 x_4 = lean_unsigned_to_nat(14u);
 x_5 = l_Lean_Expr_fvarId_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -10461,7 +10512,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_mvarId_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1017u);
+x_3 = lean_unsigned_to_nat(1061u);
 x_4 = lean_unsigned_to_nat(14u);
 x_5 = l_Lean_Expr_mvarId_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -10511,7 +10562,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_bindingName_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1022u);
+x_3 = lean_unsigned_to_nat(1066u);
 x_4 = lean_unsigned_to_nat(23u);
 x_5 = l_Lean_Expr_bindingName_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -10569,7 +10620,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_bindingDomain_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1027u);
+x_3 = lean_unsigned_to_nat(1071u);
 x_4 = lean_unsigned_to_nat(23u);
 x_5 = l_Lean_Expr_bindingName_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -10627,7 +10678,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_bindingBody_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1032u);
+x_3 = lean_unsigned_to_nat(1076u);
 x_4 = lean_unsigned_to_nat(23u);
 x_5 = l_Lean_Expr_bindingName_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -10695,7 +10746,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_bindingInfo_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1037u);
+x_3 = lean_unsigned_to_nat(1081u);
 x_4 = lean_unsigned_to_nat(24u);
 x_5 = l_Lean_Expr_bindingName_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -10755,7 +10806,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_letName_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1041u);
+x_3 = lean_unsigned_to_nat(1085u);
 x_4 = lean_unsigned_to_nat(17u);
 x_5 = l_Lean_Expr_letName_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -10804,7 +10855,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_letType_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1045u);
+x_3 = lean_unsigned_to_nat(1089u);
 x_4 = lean_unsigned_to_nat(19u);
 x_5 = l_Lean_Expr_letName_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -10853,7 +10904,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_letValue_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1049u);
+x_3 = lean_unsigned_to_nat(1093u);
 x_4 = lean_unsigned_to_nat(21u);
 x_5 = l_Lean_Expr_letName_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -10902,7 +10953,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_letBody_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1053u);
+x_3 = lean_unsigned_to_nat(1097u);
 x_4 = lean_unsigned_to_nat(23u);
 x_5 = l_Lean_Expr_letName_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -10985,7 +11036,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_mdataExpr_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1061u);
+x_3 = lean_unsigned_to_nat(1105u);
 x_4 = lean_unsigned_to_nat(17u);
 x_5 = l_Lean_Expr_mdataExpr_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -11042,7 +11093,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_projExpr_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1065u);
+x_3 = lean_unsigned_to_nat(1109u);
 x_4 = lean_unsigned_to_nat(18u);
 x_5 = l_Lean_Expr_projExpr_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -11091,7 +11142,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_projIdx_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1069u);
+x_3 = lean_unsigned_to_nat(1113u);
 x_4 = lean_unsigned_to_nat(18u);
 x_5 = l_Lean_Expr_projExpr_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -12950,7 +13001,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l___private_Lean_Expr_0__Lean_Expr_updateApp_x21Impl___closed__1;
-x_3 = lean_unsigned_to_nat(1419u);
+x_3 = lean_unsigned_to_nat(1463u);
 x_4 = lean_unsigned_to_nat(18u);
 x_5 = l_Lean_Expr_appFn_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13029,7 +13080,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l___private_Lean_Expr_0__Lean_Expr_updateConst_x21Impl___closed__1;
-x_3 = lean_unsigned_to_nat(1430u);
+x_3 = lean_unsigned_to_nat(1474u);
 x_4 = lean_unsigned_to_nat(18u);
 x_5 = l_Lean_Expr_constName_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13095,7 +13146,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l___private_Lean_Expr_0__Lean_Expr_updateSort_x21Impl___closed__1;
-x_3 = lean_unsigned_to_nat(1441u);
+x_3 = lean_unsigned_to_nat(1485u);
 x_4 = lean_unsigned_to_nat(14u);
 x_5 = l___private_Lean_Expr_0__Lean_Expr_updateSort_x21Impl___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13166,7 +13217,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l___private_Lean_Expr_0__Lean_Expr_updateMData_x21Impl___closed__1;
-x_3 = lean_unsigned_to_nat(1452u);
+x_3 = lean_unsigned_to_nat(1496u);
 x_4 = lean_unsigned_to_nat(17u);
 x_5 = l___private_Lean_Expr_0__Lean_Expr_updateMData_x21Impl___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13234,7 +13285,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l___private_Lean_Expr_0__Lean_Expr_updateProj_x21Impl___closed__1;
-x_3 = lean_unsigned_to_nat(1463u);
+x_3 = lean_unsigned_to_nat(1507u);
 x_4 = lean_unsigned_to_nat(18u);
 x_5 = l___private_Lean_Expr_0__Lean_Expr_updateProj_x21Impl___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13305,7 +13356,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l___private_Lean_Expr_0__Lean_Expr_updateForall_x21Impl___closed__1;
-x_3 = lean_unsigned_to_nat(1478u);
+x_3 = lean_unsigned_to_nat(1522u);
 x_4 = lean_unsigned_to_nat(23u);
 x_5 = l___private_Lean_Expr_0__Lean_Expr_updateForall_x21Impl___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13408,7 +13459,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_updateForallE_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1489u);
+x_3 = lean_unsigned_to_nat(1533u);
 x_4 = lean_unsigned_to_nat(24u);
 x_5 = l___private_Lean_Expr_0__Lean_Expr_updateForall_x21Impl___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13514,7 +13565,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l___private_Lean_Expr_0__Lean_Expr_updateLambda_x21Impl___closed__1;
-x_3 = lean_unsigned_to_nat(1498u);
+x_3 = lean_unsigned_to_nat(1542u);
 x_4 = lean_unsigned_to_nat(19u);
 x_5 = l___private_Lean_Expr_0__Lean_Expr_updateLambda_x21Impl___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13617,7 +13668,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l_Lean_Expr_updateLambdaE_x21___closed__1;
-x_3 = lean_unsigned_to_nat(1509u);
+x_3 = lean_unsigned_to_nat(1553u);
 x_4 = lean_unsigned_to_nat(20u);
 x_5 = l___private_Lean_Expr_0__Lean_Expr_updateLambda_x21Impl___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13715,7 +13766,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Expr_mkData___closed__5;
 x_2 = l___private_Lean_Expr_0__Lean_Expr_updateLet_x21Impl___closed__1;
-x_3 = lean_unsigned_to_nat(1518u);
+x_3 = lean_unsigned_to_nat(1562u);
 x_4 = lean_unsigned_to_nat(22u);
 x_5 = l_Lean_Expr_letName_x21___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

stage0/stdlib/Lean/KeyedDeclsAttribute.c

@@ -43,7 +43,6 @@ lean_object* l_Lean_Name_str___override(lean_object*, lean_object*);
 static lean_object* l_Lean_KeyedDeclsAttribute_init___rarg___lambda__9___closed__1;
 static lean_object* l_Lean_KeyedDeclsAttribute_init___rarg___lambda__9___closed__8;
 LEAN_EXPORT lean_object* l_Std_AssocList_find_x3f___at_Lean_KeyedDeclsAttribute_getEntries___spec__8(lean_object*);
-lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_KeyedDeclsAttribute_init___rarg___closed__4;
 LEAN_EXPORT uint8_t l_Std_PersistentHashMap_isEmpty___at_Lean_KeyedDeclsAttribute_getEntries___spec__11(lean_object*);
 uint8_t lean_usize_dec_eq(size_t, size_t);
@@ -339,6 +338,7 @@ LEAN_EXPORT lean_object* l_Std_AssocList_contains___at___private_Lean_KeyedDecls
 LEAN_EXPORT lean_object* l_Lean_KeyedDeclsAttribute_init___rarg___lambda__2(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Std_AssocList_replace___at___private_Lean_KeyedDeclsAttribute_0__Lean_KeyedDeclsAttribute_Table_insert___spec__32(lean_object*);
 lean_object* l_Std_PersistentHashMap_mkCollisionNode___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l_Lean_Attribute_Builtin_getId(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* _init_l_Lean_KeyedDeclsAttribute_Def_builtinName___default() {
@@ -5971,7 +5971,7 @@ x_17 = l_Lean_KeyedDeclsAttribute_init___rarg___lambda__10___closed__4;
 x_18 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_18, 0, x_16);
 lean_ctor_set(x_18, 1, x_17);
-x_19 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_18, x_9, x_10, x_11);
+x_19 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_18, x_9, x_10, x_11);
 lean_dec(x_10);
 lean_dec(x_9);
 x_20 = !lean_is_exclusive(x_19);

stage0/stdlib/Lean/Linter/MissingDocs.c

@@ -38,7 +38,6 @@ lean_object* l_Lean_Name_str___override(lean_object*, lean_object*);
 static lean_object* l_Lean_Linter_MissingDocs_mkHandlerUnsafe___closed__4;
 static lean_object* l_Lean_Linter_MissingDocs_declModifiersPubNoDoc___closed__3;
 static lean_object* l_Lean_Linter_MissingDocs_lintDeclHead___closed__14;
-lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Linter_MissingDocs_SimpleHandler_toHandler___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Linter_linter_missingDocs;
 static lean_object* l_Lean_Linter_MissingDocs_initFn____x40_Lean_Linter_MissingDocs___hyg_757____closed__16;
@@ -284,6 +283,7 @@ LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Linter_MissingDocs_c
 static lean_object* l_Lean_Linter_MissingDocs_initFn____x40_Lean_Linter_MissingDocs___hyg_757____closed__17;
 static lean_object* l___regBuiltin_Lean_Linter_MissingDocs_checkSimpLike___closed__6;
 static lean_object* l___regBuiltin_Lean_Linter_MissingDocs_checkClassAbbrev___closed__4;
+lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Linter_MissingDocs_lintDeclHead___closed__11;
 LEAN_EXPORT lean_object* l_Lean_Elab_elabSetOption___at_Lean_Linter_MissingDocs_handleIn___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Linter_MissingDocs_initFn____x40_Lean_Linter_MissingDocs___hyg_356____lambda__4(lean_object*, lean_object*);
@@ -325,7 +325,6 @@ static lean_object* l_Lean_Linter_MissingDocs_checkRegisterSimpAttr___closed__1;
 static lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_MissingDocs___hyg_8____closed__1;
 static lean_object* l_Array_anyMUnsafe_any___at_Lean_Linter_MissingDocs_hasInheritDoc___spec__1___closed__7;
 static lean_object* l_Lean_Linter_MissingDocs_initFn____x40_Lean_Linter_MissingDocs___hyg_757____lambda__4___closed__1;
-lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___regBuiltin_Lean_Linter_MissingDocs_checkInit(lean_object*);
 static lean_object* l___regBuiltin_Lean_Linter_MissingDocs_checkSyntaxAbbrev___closed__3;
 static lean_object* l_Lean_Linter_getLinterMissingDocs___closed__1;
@@ -484,6 +483,7 @@ LEAN_EXPORT lean_object* l_IO_ofExcept___at_Lean_Linter_MissingDocs_mkHandlerUns
 static lean_object* l_Lean_Linter_MissingDocs_initFn____x40_Lean_Linter_MissingDocs___hyg_757____closed__12;
 LEAN_EXPORT lean_object* l_Lean_Linter_MissingDocs_addBuiltinHandler(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_getBetterRef(lean_object*, lean_object*);
+lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Nat_decEq___boxed(lean_object*, lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
@@ -2360,7 +2360,7 @@ x_23 = l_Lean_Linter_MissingDocs_initFn____x40_Lean_Linter_MissingDocs___hyg_757
 x_24 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_24, 0, x_22);
 lean_ctor_set(x_24, 1, x_23);
-x_25 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_24, x_5, x_6, x_17);
+x_25 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_24, x_5, x_6, x_17);
 lean_dec(x_6);
 lean_dec(x_5);
 x_26 = !lean_is_exclusive(x_25);
@@ -2419,7 +2419,7 @@ x_43 = l_Lean_Linter_MissingDocs_initFn____x40_Lean_Linter_MissingDocs___hyg_757
 x_44 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_44, 0, x_42);
 lean_ctor_set(x_44, 1, x_43);
-x_45 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_44, x_5, x_6, x_17);
+x_45 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_44, x_5, x_6, x_17);
 lean_dec(x_6);
 lean_dec(x_5);
 x_46 = !lean_is_exclusive(x_45);
@@ -2616,7 +2616,7 @@ x_14 = l_Lean_Linter_MissingDocs_initFn____x40_Lean_Linter_MissingDocs___hyg_757
 x_15 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_15, 0, x_13);
 lean_ctor_set(x_15, 1, x_14);
-x_16 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_15, x_6, x_7, x_8);
+x_16 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_15, x_6, x_7, x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 x_17 = !lean_is_exclusive(x_16);
@@ -2711,7 +2711,7 @@ lean_ctor_set(x_19, 0, x_1);
 lean_ctor_set(x_19, 1, x_18);
 x_20 = l_Lean_Linter_MissingDocs_addHandler___closed__1;
 x_21 = l_Lean_PersistentEnvExtension_addEntry___rarg(x_20, x_3, x_19);
-x_22 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(x_21, x_5, x_6, x_17);
+x_22 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(x_21, x_5, x_6, x_17);
 return x_22;
 }
 else
@@ -2820,7 +2820,7 @@ x_24 = l_Lean_Linter_MissingDocs_initFn____x40_Lean_Linter_MissingDocs___hyg_757
 x_25 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_25, 0, x_23);
 lean_ctor_set(x_25, 1, x_24);
-x_26 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_25, x_6, x_7, x_18);
+x_26 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_25, x_6, x_7, x_18);
 lean_dec(x_7);
 lean_dec(x_6);
 x_27 = !lean_is_exclusive(x_26);
@@ -2878,7 +2878,7 @@ x_44 = l_Lean_Linter_MissingDocs_initFn____x40_Lean_Linter_MissingDocs___hyg_757
 x_45 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_45, 0, x_43);
 lean_ctor_set(x_45, 1, x_44);
-x_46 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_45, x_6, x_7, x_18);
+x_46 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_45, x_6, x_7, x_18);
 lean_dec(x_7);
 lean_dec(x_6);
 x_47 = !lean_is_exclusive(x_46);
@@ -3071,7 +3071,7 @@ x_19 = l_Lean_Linter_MissingDocs_initFn____x40_Lean_Linter_MissingDocs___hyg_757
 x_20 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_20, 0, x_18);
 lean_ctor_set(x_20, 1, x_19);
-x_21 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_20, x_6, x_7, x_11);
+x_21 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_20, x_6, x_7, x_11);
 lean_dec(x_7);
 lean_dec(x_6);
 x_22 = !lean_is_exclusive(x_21);
@@ -3117,7 +3117,7 @@ x_14 = l_Lean_Linter_MissingDocs_initFn____x40_Lean_Linter_MissingDocs___hyg_757
 x_15 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_15, 0, x_13);
 lean_ctor_set(x_15, 1, x_14);
-x_16 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_15, x_6, x_7, x_8);
+x_16 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_15, x_6, x_7, x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 x_17 = !lean_is_exclusive(x_16);

stage0/stdlib/Lean/Linter/UnusedVariables.c

@@ -37,7 +37,6 @@ LEAN_EXPORT lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables
 LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Linter_getUnusedVariablesIgnoreFnsImpl___spec__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_LocalDecl_userName(lean_object*);
 static lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hyg_463____lambda__1___closed__7;
-lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_InfoTree_hasSorry(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_InfoTree_visitM_go___at_Lean_Linter_unusedVariables___spec__24(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_usize_dec_eq(size_t, size_t);
@@ -300,6 +299,7 @@ static lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hy
 lean_object* l_List_filterMap___at_Lean_Linter_collectMacroExpansions_x3f_go___spec__1(lean_object*);
 LEAN_EXPORT lean_object* l_panic___at_Lean_Linter_unusedVariables___spec__25(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hyg_1713____lambda__1___closed__10;
+lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_List_forIn_loop___at_Lean_Linter_unusedVariables___spec__32___lambda__1___closed__5;
 lean_object* l_Lean_Linter_logLint(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hyg_381____lambda__1___closed__4;
@@ -331,7 +331,6 @@ static lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hy
 static lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hyg_1475____closed__1;
 static lean_object* l_Lean_Elab_InfoTree_visitM_go___at_Lean_Linter_unusedVariables___spec__24___closed__3;
 static lean_object* l_Array_foldrMUnsafe_fold___at_Lean_Linter_unusedVariables___spec__35___closed__1;
-lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hyg_293____lambda__1___closed__7;
 static lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hyg_225____lambda__1___closed__5;
 static lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hyg_1885____lambda__4___closed__2;
@@ -520,6 +519,7 @@ static lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hy
 static lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hyg_225____lambda__1___closed__12;
 static lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hyg_545____lambda__5___closed__10;
 lean_object* l_Lean_Elab_getBetterRef(lean_object*, lean_object*);
+lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hyg_71____closed__1;
 static lean_object* l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hyg_1885____closed__13;
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
@@ -4121,7 +4121,7 @@ lean_inc(x_9);
 lean_dec(x_7);
 x_10 = l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hyg_1885____lambda__1___closed__1;
 x_11 = l_Lean_PersistentEnvExtension_addEntry___rarg(x_10, x_9, x_1);
-x_12 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(x_11, x_3, x_4, x_8);
+x_12 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(x_11, x_3, x_4, x_8);
 return x_12;
 }
 }
@@ -4177,7 +4177,7 @@ if (x_13 == 0)
 lean_object* x_14; lean_object* x_15; uint8_t x_16; 
 lean_dec(x_1);
 x_14 = l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hyg_1885____lambda__2___closed__3;
-x_15 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_14, x_4, x_5, x_9);
+x_15 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_14, x_4, x_5, x_9);
 lean_dec(x_5);
 lean_dec(x_4);
 x_16 = !lean_is_exclusive(x_15);
@@ -4275,7 +4275,7 @@ lean_object* x_12; lean_object* x_13; uint8_t x_14;
 lean_dec(x_2);
 lean_dec(x_1);
 x_12 = l_Lean_Linter_initFn____x40_Lean_Linter_UnusedVariables___hyg_1885____lambda__3___closed__2;
-x_13 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_12, x_5, x_6, x_9);
+x_13 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_12, x_5, x_6, x_9);
 lean_dec(x_6);
 lean_dec(x_5);
 x_14 = !lean_is_exclusive(x_13);

stage0/stdlib/Lean/Meta/Basic.c

@@ -589,6 +589,7 @@ size_t lean_usize_of_nat(lean_object*);
 static lean_object* l_Lean_Meta_mkLevelStuckErrorMessage___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Meta_withLocalDecl___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_lambdaMetaTelescope_process___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_NameSet_empty;
 lean_object* l_Lean_ConstantInfo_type(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_setEnv___at_Lean_Meta_setInlineAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_instBEqProd___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1972,17 +1973,19 @@ return x_5;
 static lean_object* _init_l_Lean_Meta_instInhabitedSavedState___closed__5() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_instInhabitedSavedState___closed__1;
 x_2 = l_Lean_Meta_instInhabitedSavedState___closed__2;
 x_3 = l_Lean_Meta_ParamInfo_backDeps___default___closed__1;
-x_4 = l_Lean_Meta_instInhabitedSavedState___closed__4;
-x_5 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_4);
-return x_5;
+x_4 = l_Lean_NameSet_empty;
+x_5 = l_Lean_Meta_instInhabitedSavedState___closed__4;
+x_6 = lean_alloc_ctor(0, 5, 0);
+lean_ctor_set(x_6, 0, x_1);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set(x_6, 4, x_5);
+return x_6;
 }
 }
 static lean_object* _init_l_Lean_Meta_instInhabitedSavedState___closed__6() {

stage0/stdlib/Lean/Meta/Closure.c

@@ -3995,7 +3995,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_Closure_collectExprAux___closed__1;
 x_2 = l_Lean_Meta_Closure_collectExprAux___closed__2;
-x_3 = lean_unsigned_to_nat(1452u);
+x_3 = lean_unsigned_to_nat(1496u);
 x_4 = lean_unsigned_to_nat(17u);
 x_5 = l_Lean_Meta_Closure_collectExprAux___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -4024,7 +4024,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_Closure_collectExprAux___closed__1;
 x_2 = l_Lean_Meta_Closure_collectExprAux___closed__5;
-x_3 = lean_unsigned_to_nat(1463u);
+x_3 = lean_unsigned_to_nat(1507u);
 x_4 = lean_unsigned_to_nat(18u);
 x_5 = l_Lean_Meta_Closure_collectExprAux___closed__6;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -4053,7 +4053,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_Closure_collectExprAux___closed__1;
 x_2 = l_Lean_Meta_Closure_collectExprAux___closed__8;
-x_3 = lean_unsigned_to_nat(1419u);
+x_3 = lean_unsigned_to_nat(1463u);
 x_4 = lean_unsigned_to_nat(18u);
 x_5 = l_Lean_Meta_Closure_collectExprAux___closed__9;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -4082,7 +4082,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_Closure_collectExprAux___closed__1;
 x_2 = l_Lean_Meta_Closure_collectExprAux___closed__11;
-x_3 = lean_unsigned_to_nat(1509u);
+x_3 = lean_unsigned_to_nat(1553u);
 x_4 = lean_unsigned_to_nat(20u);
 x_5 = l_Lean_Meta_Closure_collectExprAux___closed__12;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -4111,7 +4111,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_Closure_collectExprAux___closed__1;
 x_2 = l_Lean_Meta_Closure_collectExprAux___closed__14;
-x_3 = lean_unsigned_to_nat(1489u);
+x_3 = lean_unsigned_to_nat(1533u);
 x_4 = lean_unsigned_to_nat(24u);
 x_5 = l_Lean_Meta_Closure_collectExprAux___closed__15;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -4140,7 +4140,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_Closure_collectExprAux___closed__1;
 x_2 = l_Lean_Meta_Closure_collectExprAux___closed__17;
-x_3 = lean_unsigned_to_nat(1518u);
+x_3 = lean_unsigned_to_nat(1562u);
 x_4 = lean_unsigned_to_nat(22u);
 x_5 = l_Lean_Meta_Closure_collectExprAux___closed__18;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

stage0/stdlib/Lean/Meta/ExprDefEq.c

@@ -16681,7 +16681,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_CheckAssignment_check___closed__1;
 x_2 = l_Lean_Meta_CheckAssignment_check___closed__2;
-x_3 = lean_unsigned_to_nat(1452u);
+x_3 = lean_unsigned_to_nat(1496u);
 x_4 = lean_unsigned_to_nat(17u);
 x_5 = l_Lean_Meta_CheckAssignment_check___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -16710,7 +16710,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_CheckAssignment_check___closed__1;
 x_2 = l_Lean_Meta_CheckAssignment_check___closed__5;
-x_3 = lean_unsigned_to_nat(1463u);
+x_3 = lean_unsigned_to_nat(1507u);
 x_4 = lean_unsigned_to_nat(18u);
 x_5 = l_Lean_Meta_CheckAssignment_check___closed__6;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -16739,7 +16739,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_CheckAssignment_check___closed__1;
 x_2 = l_Lean_Meta_CheckAssignment_check___closed__8;
-x_3 = lean_unsigned_to_nat(1509u);
+x_3 = lean_unsigned_to_nat(1553u);
 x_4 = lean_unsigned_to_nat(20u);
 x_5 = l_Lean_Meta_CheckAssignment_check___closed__9;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -16768,7 +16768,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_CheckAssignment_check___closed__1;
 x_2 = l_Lean_Meta_CheckAssignment_check___closed__11;
-x_3 = lean_unsigned_to_nat(1489u);
+x_3 = lean_unsigned_to_nat(1533u);
 x_4 = lean_unsigned_to_nat(24u);
 x_5 = l_Lean_Meta_CheckAssignment_check___closed__12;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -16797,7 +16797,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_CheckAssignment_check___closed__1;
 x_2 = l_Lean_Meta_CheckAssignment_check___closed__14;
-x_3 = lean_unsigned_to_nat(1518u);
+x_3 = lean_unsigned_to_nat(1562u);
 x_4 = lean_unsigned_to_nat(22u);
 x_5 = l_Lean_Meta_CheckAssignment_check___closed__15;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

stage0/stdlib/Lean/Meta/ExprLens.c

@@ -403,7 +403,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Meta_ExprLens_0__Lean_Meta_lensCoord___rarg___lambda__3___closed__1;
 x_2 = l___private_Lean_Meta_ExprLens_0__Lean_Meta_lensCoord___rarg___lambda__3___closed__2;
-x_3 = lean_unsigned_to_nat(1419u);
+x_3 = lean_unsigned_to_nat(1463u);
 x_4 = lean_unsigned_to_nat(18u);
 x_5 = l___private_Lean_Meta_ExprLens_0__Lean_Meta_lensCoord___rarg___lambda__3___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -581,7 +581,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Meta_ExprLens_0__Lean_Meta_lensCoord___rarg___lambda__3___closed__1;
 x_2 = l___private_Lean_Meta_ExprLens_0__Lean_Meta_lensCoord___rarg___lambda__8___closed__1;
-x_3 = lean_unsigned_to_nat(1518u);
+x_3 = lean_unsigned_to_nat(1562u);
 x_4 = lean_unsigned_to_nat(22u);
 x_5 = l___private_Lean_Meta_ExprLens_0__Lean_Meta_lensCoord___rarg___lambda__8___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -782,7 +782,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Meta_ExprLens_0__Lean_Meta_lensCoord___rarg___lambda__3___closed__1;
 x_2 = l___private_Lean_Meta_ExprLens_0__Lean_Meta_lensCoord___rarg___lambda__10___closed__1;
-x_3 = lean_unsigned_to_nat(1509u);
+x_3 = lean_unsigned_to_nat(1553u);
 x_4 = lean_unsigned_to_nat(20u);
 x_5 = l___private_Lean_Meta_ExprLens_0__Lean_Meta_lensCoord___rarg___lambda__10___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -906,7 +906,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Meta_ExprLens_0__Lean_Meta_lensCoord___rarg___lambda__3___closed__1;
 x_2 = l___private_Lean_Meta_ExprLens_0__Lean_Meta_lensCoord___rarg___lambda__11___closed__1;
-x_3 = lean_unsigned_to_nat(1489u);
+x_3 = lean_unsigned_to_nat(1533u);
 x_4 = lean_unsigned_to_nat(24u);
 x_5 = l___private_Lean_Meta_ExprLens_0__Lean_Meta_lensCoord___rarg___lambda__11___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

stage0/stdlib/Lean/Meta/Instances.c

@@ -34,7 +34,6 @@ LEAN_EXPORT lean_object* l_Lean_Meta_Instances_erase___at_Lean_Meta_initFn____x4
 LEAN_EXPORT uint8_t l_Array_contains___at_Lean_Meta_addInstanceEntry___spec__11(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Init_Data_Array_BinSearch_0__Array_binInsertAux___at_Lean_Meta_addInstanceEntry___spec__14___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Meta_Instances_discrTree___default___closed__1;
-lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Meta_setInlineAttribute___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Instances___hyg_308____closed__5;
 static lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Instances___hyg_500____closed__22;
@@ -337,6 +336,7 @@ lean_object* l_Lean_Meta_DiscrTree_instInhabitedTrie(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_isInstance(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_DiscrTree_empty(lean_object*);
 lean_object* l_Std_PersistentHashMap_mkCollisionNode___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_binInsertM___at_Lean_Meta_addInstanceEntry___spec__13___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Instances___hyg_1280____closed__7;
@@ -4092,7 +4092,7 @@ x_11 = l_Lean_Meta_Instances_erase___rarg___closed__4;
 x_12 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_12, 0, x_10);
 lean_ctor_set(x_12, 1, x_11);
-x_13 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_12, x_3, x_4, x_5);
+x_13 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_12, x_3, x_4, x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 x_14 = !lean_is_exclusive(x_13);
@@ -8301,7 +8301,7 @@ lean_object* x_14; lean_object* x_15; uint8_t x_16;
 lean_dec(x_10);
 lean_dec(x_1);
 x_14 = l_Lean_Meta_initFn____x40_Lean_Meta_Instances___hyg_1280____lambda__2___closed__2;
-x_15 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_14, x_4, x_5, x_11);
+x_15 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_14, x_4, x_5, x_11);
 lean_dec(x_5);
 lean_dec(x_4);
 x_16 = !lean_is_exclusive(x_15);

stage0/stdlib/Lean/Meta/Match/MatchEqs.c

@@ -172,7 +172,7 @@ LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match
 lean_object* l_Lean_Expr_appArg_x21(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_Match_forallAltTelescope(lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Meta_Match_forallAltTelescope_go___spec__1(lean_object*, lean_object*, size_t, size_t, lean_object*);
-lean_object* l_Lean_Meta_injections(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_injections(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_forallMetaBoundedTelescope(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_LocalContext_getFVars___spec__1(size_t, size_t, lean_object*);
 LEAN_EXPORT uint8_t l_Lean_Meta_Match_forallAltTelescope_isNamedPatternProof___lambda__1(lean_object*, lean_object*);
@@ -520,7 +520,7 @@ LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_M
 uint8_t lean_expr_eqv(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_withIncRecDepth___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__18(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_simpH_x3f___closed__3;
-LEAN_EXPORT lean_object* l_Lean_Meta_Match_initFn____x40_Lean_Meta_Match_MatchEqs___hyg_12690_(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Meta_Match_initFn____x40_Lean_Meta_Match_MatchEqs___hyg_12694_(lean_object*);
 static lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_proveSubgoalLoop___lambda__1___closed__3;
 LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertCastEqRec___spec__6___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_List_mapTRAux___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -6145,135 +6145,136 @@ lean_inc(x_2);
 x_7 = l_Lean_Meta_substVars(x_1, x_2, x_3, x_4, x_5, x_6);
 if (lean_obj_tag(x_7) == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
 x_8 = lean_ctor_get(x_7, 0);
 lean_inc(x_8);
 x_9 = lean_ctor_get(x_7, 1);
 lean_inc(x_9);
 lean_dec(x_7);
-x_10 = lean_unsigned_to_nat(5u);
+x_10 = lean_box(0);
+x_11 = lean_unsigned_to_nat(5u);
 lean_inc(x_5);
 lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
 lean_inc(x_8);
-x_11 = l_Lean_Meta_injections(x_8, x_10, x_2, x_3, x_4, x_5, x_9);
-if (lean_obj_tag(x_11) == 0)
-{
-lean_object* x_12; 
-x_12 = lean_ctor_get(x_11, 0);
-lean_inc(x_12);
+x_12 = l_Lean_Meta_injections(x_8, x_10, x_11, x_2, x_3, x_4, x_5, x_9);
 if (lean_obj_tag(x_12) == 0)
 {
-uint8_t x_13; 
+lean_object* x_13; 
+x_13 = lean_ctor_get(x_12, 0);
+lean_inc(x_13);
+if (lean_obj_tag(x_13) == 0)
+{
+uint8_t x_14; 
 lean_dec(x_8);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_13 = !lean_is_exclusive(x_11);
-if (x_13 == 0)
+x_14 = !lean_is_exclusive(x_12);
+if (x_14 == 0)
 {
-lean_object* x_14; uint8_t x_15; lean_object* x_16; 
-x_14 = lean_ctor_get(x_11, 0);
-lean_dec(x_14);
-x_15 = 1;
-x_16 = lean_box(x_15);
-lean_ctor_set(x_11, 0, x_16);
-return x_11;
+lean_object* x_15; uint8_t x_16; lean_object* x_17; 
+x_15 = lean_ctor_get(x_12, 0);
+lean_dec(x_15);
+x_16 = 1;
+x_17 = lean_box(x_16);
+lean_ctor_set(x_12, 0, x_17);
+return x_12;
 }
 else
 {
-lean_object* x_17; uint8_t x_18; lean_object* x_19; lean_object* x_20; 
-x_17 = lean_ctor_get(x_11, 1);
-lean_inc(x_17);
-lean_dec(x_11);
-x_18 = 1;
-x_19 = lean_box(x_18);
-x_20 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_20, 0, x_19);
-lean_ctor_set(x_20, 1, x_17);
-return x_20;
+lean_object* x_18; uint8_t x_19; lean_object* x_20; lean_object* x_21; 
+x_18 = lean_ctor_get(x_12, 1);
+lean_inc(x_18);
+lean_dec(x_12);
+x_19 = 1;
+x_20 = lean_box(x_19);
+x_21 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_21, 0, x_20);
+lean_ctor_set(x_21, 1, x_18);
+return x_21;
 }
 }
 else
 {
-lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_21 = lean_ctor_get(x_11, 1);
-lean_inc(x_21);
-lean_dec(x_11);
-x_22 = lean_ctor_get(x_12, 0);
+lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_22 = lean_ctor_get(x_12, 1);
 lean_inc(x_22);
 lean_dec(x_12);
-x_23 = lean_name_eq(x_22, x_8);
-if (x_23 == 0)
-{
-lean_object* x_24; 
-lean_dec(x_8);
-x_24 = l_Lean_Meta_Match_SimpH_trySubstVarsAndContradiction(x_22, x_2, x_3, x_4, x_5, x_21);
-return x_24;
-}
-else
+x_23 = lean_ctor_get(x_13, 0);
+lean_inc(x_23);
+lean_dec(x_13);
+x_24 = lean_name_eq(x_23, x_8);
+if (x_24 == 0)
 {
 lean_object* x_25; 
-lean_dec(x_22);
-x_25 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_SimpH_contradiction(x_8, x_2, x_3, x_4, x_5, x_21);
+lean_dec(x_8);
+x_25 = l_Lean_Meta_Match_SimpH_trySubstVarsAndContradiction(x_23, x_2, x_3, x_4, x_5, x_22);
 return x_25;
 }
+else
+{
+lean_object* x_26; 
+lean_dec(x_23);
+x_26 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_SimpH_contradiction(x_8, x_2, x_3, x_4, x_5, x_22);
+return x_26;
+}
 }
 }
 else
 {
-uint8_t x_26; 
+uint8_t x_27; 
 lean_dec(x_8);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_26 = !lean_is_exclusive(x_11);
-if (x_26 == 0)
+x_27 = !lean_is_exclusive(x_12);
+if (x_27 == 0)
 {
-return x_11;
+return x_12;
 }
 else
 {
-lean_object* x_27; lean_object* x_28; lean_object* x_29; 
-x_27 = lean_ctor_get(x_11, 0);
-x_28 = lean_ctor_get(x_11, 1);
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_28 = lean_ctor_get(x_12, 0);
+x_29 = lean_ctor_get(x_12, 1);
+lean_inc(x_29);
 lean_inc(x_28);
-lean_inc(x_27);
-lean_dec(x_11);
-x_29 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_29, 0, x_27);
-lean_ctor_set(x_29, 1, x_28);
-return x_29;
+lean_dec(x_12);
+x_30 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_30, 0, x_28);
+lean_ctor_set(x_30, 1, x_29);
+return x_30;
 }
 }
 }
 else
 {
-uint8_t x_30; 
+uint8_t x_31; 
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_30 = !lean_is_exclusive(x_7);
-if (x_30 == 0)
+x_31 = !lean_is_exclusive(x_7);
+if (x_31 == 0)
 {
 return x_7;
 }
 else
 {
-lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-x_31 = lean_ctor_get(x_7, 0);
-x_32 = lean_ctor_get(x_7, 1);
+lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+x_32 = lean_ctor_get(x_7, 0);
+x_33 = lean_ctor_get(x_7, 1);
+lean_inc(x_33);
 lean_inc(x_32);
-lean_inc(x_31);
 lean_dec(x_7);
-x_33 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_33, 0, x_31);
-lean_ctor_set(x_33, 1, x_32);
-return x_33;
+x_34 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_34, 0, x_32);
+lean_ctor_set(x_34, 1, x_33);
+return x_34;
 }
 }
 }
@@ -36925,7 +36926,7 @@ lean_dec(x_3);
 return x_5;
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Meta_Match_initFn____x40_Lean_Meta_Match_MatchEqs___hyg_12690_(lean_object* x_1) {
+LEAN_EXPORT lean_object* l_Lean_Meta_Match_initFn____x40_Lean_Meta_Match_MatchEqs___hyg_12694_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; uint8_t x_3; lean_object* x_4; 
@@ -37388,7 +37389,7 @@ l_Std_PersistentHashMap_findAux___at_Lean_Meta_Match_getEquationsForImpl___spec_
 l_Std_PersistentHashMap_findAux___at_Lean_Meta_Match_getEquationsForImpl___spec__2___closed__2 = _init_l_Std_PersistentHashMap_findAux___at_Lean_Meta_Match_getEquationsForImpl___spec__2___closed__2();
 l_Lean_Meta_Match_getEquationsForImpl___closed__1 = _init_l_Lean_Meta_Match_getEquationsForImpl___closed__1();
 lean_mark_persistent(l_Lean_Meta_Match_getEquationsForImpl___closed__1);
-res = l_Lean_Meta_Match_initFn____x40_Lean_Meta_Match_MatchEqs___hyg_12690_(lean_io_mk_world());
+res = l_Lean_Meta_Match_initFn____x40_Lean_Meta_Match_MatchEqs___hyg_12694_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));

stage0/stdlib/Lean/Meta/RecursorInfo.c

@@ -34,7 +34,6 @@ static lean_object* l_Lean_Meta_Attribute_Recursor_getMajorPos___closed__13;
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 lean_object* l_Lean_Name_str___override(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Expr_withAppAux___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoAux___spec__2___lambda__1___boxed(lean_object**);
-lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_getIdx_x3f___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim___spec__1___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Meta_setInlineAttribute___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2880____closed__6;
@@ -352,6 +351,7 @@ uint8_t l_Lean_Expr_isSort(lean_object*);
 static lean_object* l_Lean_Meta_RecursorInfo_instToStringRecursorInfo___closed__11;
 LEAN_EXPORT lean_object* l_Lean_Meta_RecursorInfo_numIndices___boxed(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_throwError___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_checkMotiveResultType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
@@ -9093,7 +9093,7 @@ x_7 = lean_ctor_get(x_3, 5);
 x_8 = l_Lean_replaceRef(x_1, x_7);
 lean_dec(x_7);
 lean_ctor_set(x_3, 5, x_8);
-x_9 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_2, x_3, x_4, x_5);
+x_9 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_2, x_3, x_4, x_5);
 lean_dec(x_3);
 return x_9;
 }
@@ -9137,7 +9137,7 @@ lean_ctor_set(x_22, 7, x_17);
 lean_ctor_set(x_22, 8, x_18);
 lean_ctor_set(x_22, 9, x_19);
 lean_ctor_set(x_22, 10, x_20);
-x_23 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_2, x_22, x_4, x_5);
+x_23 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_2, x_22, x_4, x_5);
 lean_dec(x_22);
 return x_23;
 }

stage0/stdlib/Lean/Meta/Tactic/Injection.c

@@ -32,7 +32,7 @@ LEAN_EXPORT lean_object* l_Lean_Meta_getCtorNumPropFields(lean_object*, lean_obj
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
 uint8_t lean_name_eq(lean_object*, lean_object*);
 static lean_object* l_Lean_Meta_injectionCore___lambda__1___closed__11;
-LEAN_EXPORT lean_object* l_Lean_Meta_injections___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Meta_injections___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_appFn_x21(lean_object*);
 lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
@@ -40,12 +40,12 @@ static lean_object* l_Lean_Meta_injections_go___closed__2;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Meta_getCtorNumPropFields___spec__1___closed__4;
 lean_object* l_Lean_MVarId_withContext___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_synthPendingImp___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_appArg_x21(lean_object*);
-LEAN_EXPORT lean_object* l_Lean_Meta_injections(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Meta_injections(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_injectionIntro_go___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Meta_getCtorNumPropFields___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Meta_injections_go___closed__4;
 static lean_object* l_Lean_Meta_injectionCore___lambda__1___closed__12;
-LEAN_EXPORT lean_object* l_Lean_Meta_injections_go(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Meta_injections_go(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Meta_injectionIntro(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_intro1Core(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -3170,162 +3170,163 @@ lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Meta_injections_go(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+LEAN_EXPORT lean_object* l_Lean_Meta_injections_go(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) {
 _start:
 {
-lean_object* x_10; uint8_t x_11; 
-x_10 = lean_unsigned_to_nat(0u);
-x_11 = lean_nat_dec_eq(x_2, x_10);
-if (x_11 == 0)
+lean_object* x_11; uint8_t x_12; 
+x_11 = lean_unsigned_to_nat(0u);
+x_12 = lean_nat_dec_eq(x_2, x_11);
+if (x_12 == 0)
 {
 if (lean_obj_tag(x_3) == 0)
 {
-lean_object* x_12; lean_object* x_13; 
+lean_object* x_13; lean_object* x_14; 
+lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
-lean_dec(x_5);
 lean_dec(x_2);
 lean_dec(x_1);
-x_12 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_12, 0, x_4);
-x_13 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_13, 0, x_12);
-lean_ctor_set(x_13, 1, x_9);
-return x_13;
+x_13 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_13, 0, x_4);
+lean_ctor_set(x_13, 1, x_5);
+x_14 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_14, 0, x_13);
+lean_ctor_set(x_14, 1, x_10);
+return x_14;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-x_14 = lean_ctor_get(x_3, 0);
-lean_inc(x_14);
-x_15 = lean_ctor_get(x_3, 1);
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_15 = lean_ctor_get(x_3, 0);
 lean_inc(x_15);
+x_16 = lean_ctor_get(x_3, 1);
+lean_inc(x_16);
 lean_dec(x_3);
-x_16 = lean_unsigned_to_nat(1u);
-x_17 = lean_nat_sub(x_2, x_16);
+x_17 = lean_unsigned_to_nat(1u);
+x_18 = lean_nat_sub(x_2, x_17);
 lean_dec(x_2);
-x_18 = lean_nat_add(x_17, x_16);
-lean_inc(x_5);
-lean_inc(x_14);
-x_19 = l_Lean_FVarId_getType(x_14, x_5, x_6, x_7, x_8, x_9);
-if (lean_obj_tag(x_19) == 0)
+x_19 = lean_nat_add(x_18, x_17);
+lean_inc(x_6);
+lean_inc(x_15);
+x_20 = l_Lean_FVarId_getType(x_15, x_6, x_7, x_8, x_9, x_10);
+if (lean_obj_tag(x_20) == 0)
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_20 = lean_ctor_get(x_19, 0);
-lean_inc(x_20);
-x_21 = lean_ctor_get(x_19, 1);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_21 = lean_ctor_get(x_20, 0);
 lean_inc(x_21);
-lean_dec(x_19);
+x_22 = lean_ctor_get(x_20, 1);
+lean_inc(x_22);
+lean_dec(x_20);
+lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
-lean_inc(x_5);
-x_22 = l_Lean_Meta_matchEqHEq_x3f(x_20, x_5, x_6, x_7, x_8, x_21);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; 
-x_23 = lean_ctor_get(x_22, 0);
-lean_inc(x_23);
+x_23 = l_Lean_Meta_matchEqHEq_x3f(x_21, x_6, x_7, x_8, x_9, x_22);
 if (lean_obj_tag(x_23) == 0)
 {
 lean_object* x_24; 
-lean_dec(x_17);
-lean_dec(x_14);
-x_24 = lean_ctor_get(x_22, 1);
+x_24 = lean_ctor_get(x_23, 0);
 lean_inc(x_24);
-lean_dec(x_22);
-x_2 = x_18;
-x_3 = x_15;
-x_9 = x_24;
-goto _start;
-}
-else
+if (lean_obj_tag(x_24) == 0)
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_26 = lean_ctor_get(x_23, 0);
-lean_inc(x_26);
+lean_object* x_25; 
+lean_dec(x_18);
+lean_dec(x_15);
+x_25 = lean_ctor_get(x_23, 1);
+lean_inc(x_25);
 lean_dec(x_23);
-x_27 = lean_ctor_get(x_26, 1);
+x_2 = x_19;
+x_3 = x_16;
+x_10 = x_25;
+goto _start;
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+x_27 = lean_ctor_get(x_24, 0);
 lean_inc(x_27);
-lean_dec(x_26);
-x_28 = lean_ctor_get(x_22, 1);
+lean_dec(x_24);
+x_28 = lean_ctor_get(x_27, 1);
 lean_inc(x_28);
-lean_dec(x_22);
-x_29 = lean_ctor_get(x_27, 0);
-lean_inc(x_29);
-x_30 = lean_ctor_get(x_27, 1);
-lean_inc(x_30);
 lean_dec(x_27);
+x_29 = lean_ctor_get(x_23, 1);
+lean_inc(x_29);
+lean_dec(x_23);
+x_30 = lean_ctor_get(x_28, 0);
+lean_inc(x_30);
+x_31 = lean_ctor_get(x_28, 1);
+lean_inc(x_31);
+lean_dec(x_28);
+lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
-lean_inc(x_5);
-x_31 = lean_whnf(x_29, x_5, x_6, x_7, x_8, x_28);
-if (lean_obj_tag(x_31) == 0)
+x_32 = lean_whnf(x_30, x_6, x_7, x_8, x_9, x_29);
+if (lean_obj_tag(x_32) == 0)
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-x_32 = lean_ctor_get(x_31, 0);
-lean_inc(x_32);
-x_33 = lean_ctor_get(x_31, 1);
+lean_object* x_33; lean_object* x_34; lean_object* x_35; 
+x_33 = lean_ctor_get(x_32, 0);
 lean_inc(x_33);
-lean_dec(x_31);
+x_34 = lean_ctor_get(x_32, 1);
+lean_inc(x_34);
+lean_dec(x_32);
+lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
-lean_inc(x_5);
-x_34 = lean_whnf(x_30, x_5, x_6, x_7, x_8, x_33);
-if (lean_obj_tag(x_34) == 0)
+x_35 = lean_whnf(x_31, x_6, x_7, x_8, x_9, x_34);
+if (lean_obj_tag(x_35) == 0)
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; uint8_t x_79; 
-x_35 = lean_ctor_get(x_34, 0);
-lean_inc(x_35);
-x_36 = lean_ctor_get(x_34, 1);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_80; 
+x_36 = lean_ctor_get(x_35, 0);
 lean_inc(x_36);
-lean_dec(x_34);
-x_79 = l_Lean_Expr_isNatLit(x_32);
-lean_dec(x_32);
-if (x_79 == 0)
-{
-lean_object* x_80; 
+x_37 = lean_ctor_get(x_35, 1);
+lean_inc(x_37);
 lean_dec(x_35);
-x_80 = lean_box(0);
-x_37 = x_80;
-goto block_78;
+x_80 = l_Lean_Expr_isNatLit(x_33);
+lean_dec(x_33);
+if (x_80 == 0)
+{
+lean_object* x_81; 
+lean_dec(x_36);
+x_81 = lean_box(0);
+x_38 = x_81;
+goto block_79;
 }
 else
 {
-uint8_t x_81; 
-x_81 = l_Lean_Expr_isNatLit(x_35);
-lean_dec(x_35);
-if (x_81 == 0)
+uint8_t x_82; 
+x_82 = l_Lean_Expr_isNatLit(x_36);
+lean_dec(x_36);
+if (x_82 == 0)
 {
-lean_object* x_82; 
-x_82 = lean_box(0);
-x_37 = x_82;
-goto block_78;
+lean_object* x_83; 
+x_83 = lean_box(0);
+x_38 = x_83;
+goto block_79;
 }
 else
 {
-lean_dec(x_17);
-lean_dec(x_14);
-x_2 = x_18;
-x_3 = x_15;
-x_9 = x_36;
+lean_dec(x_18);
+lean_dec(x_15);
+x_2 = x_19;
+x_3 = x_16;
+x_10 = x_37;
 goto _start;
 }
 }
-block_78:
+block_79:
 {
-lean_object* x_38; lean_object* x_39; 
-lean_dec(x_37);
-x_38 = lean_box(0);
+lean_object* x_39; 
+lean_dec(x_38);
+lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);
-x_39 = l_Lean_Meta_injection(x_4, x_14, x_38, x_5, x_6, x_7, x_8, x_36);
+x_39 = l_Lean_Meta_injection(x_4, x_15, x_5, x_6, x_7, x_8, x_9, x_37);
 if (lean_obj_tag(x_39) == 0)
 {
 lean_object* x_40; 
@@ -3334,9 +3335,10 @@ lean_inc(x_40);
 if (lean_obj_tag(x_40) == 0)
 {
 uint8_t x_41; 
+lean_dec(x_19);
 lean_dec(x_18);
-lean_dec(x_17);
-lean_dec(x_15);
+lean_dec(x_16);
+lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
@@ -3368,7 +3370,7 @@ return x_46;
 }
 else
 {
-lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
 x_47 = lean_ctor_get(x_39, 1);
 lean_inc(x_47);
 lean_dec(x_39);
@@ -3376,333 +3378,343 @@ x_48 = lean_ctor_get(x_40, 0);
 lean_inc(x_48);
 x_49 = lean_ctor_get(x_40, 1);
 lean_inc(x_49);
+x_50 = lean_ctor_get(x_40, 2);
+lean_inc(x_50);
 lean_dec(x_40);
-x_50 = lean_array_to_list(lean_box(0), x_49);
-lean_inc(x_15);
-x_51 = l_List_appendTR___rarg(x_50, x_15);
+x_51 = lean_array_to_list(lean_box(0), x_49);
+lean_inc(x_16);
+x_52 = l_List_appendTR___rarg(x_51, x_16);
 lean_inc(x_48);
 lean_inc(x_1);
-x_52 = lean_alloc_closure((void*)(l_Lean_Meta_injections_go), 9, 4);
-lean_closure_set(x_52, 0, x_1);
-lean_closure_set(x_52, 1, x_17);
-lean_closure_set(x_52, 2, x_51);
-lean_closure_set(x_52, 3, x_48);
+x_53 = lean_alloc_closure((void*)(l_Lean_Meta_injections_go), 10, 5);
+lean_closure_set(x_53, 0, x_1);
+lean_closure_set(x_53, 1, x_18);
+lean_closure_set(x_53, 2, x_52);
+lean_closure_set(x_53, 3, x_48);
+lean_closure_set(x_53, 4, x_50);
+lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
-lean_inc(x_5);
-x_53 = l_Lean_MVarId_withContext___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_synthPendingImp___spec__2___rarg(x_48, x_52, x_5, x_6, x_7, x_8, x_47);
-if (lean_obj_tag(x_53) == 0)
+x_54 = l_Lean_MVarId_withContext___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_synthPendingImp___spec__2___rarg(x_48, x_53, x_6, x_7, x_8, x_9, x_47);
+if (lean_obj_tag(x_54) == 0)
 {
-uint8_t x_54; 
-lean_dec(x_18);
-lean_dec(x_15);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_1);
-x_54 = !lean_is_exclusive(x_53);
-if (x_54 == 0)
-{
-return x_53;
-}
-else
-{
-lean_object* x_55; lean_object* x_56; lean_object* x_57; 
-x_55 = lean_ctor_get(x_53, 0);
-x_56 = lean_ctor_get(x_53, 1);
-lean_inc(x_56);
-lean_inc(x_55);
-lean_dec(x_53);
-x_57 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_57, 0, x_55);
-lean_ctor_set(x_57, 1, x_56);
-return x_57;
-}
-}
-else
-{
-lean_object* x_58; lean_object* x_59; 
-x_58 = lean_ctor_get(x_53, 1);
-lean_inc(x_58);
-lean_dec(x_53);
-x_59 = l_Lean_Meta_injections_go(x_1, x_18, x_15, x_4, x_5, x_6, x_7, x_8, x_58);
-if (lean_obj_tag(x_59) == 0)
-{
-uint8_t x_60; 
-x_60 = !lean_is_exclusive(x_59);
-if (x_60 == 0)
-{
-return x_59;
-}
-else
-{
-lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_61 = lean_ctor_get(x_59, 0);
-x_62 = lean_ctor_get(x_59, 1);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_59);
-x_63 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_63, 0, x_61);
-lean_ctor_set(x_63, 1, x_62);
-return x_63;
-}
-}
-else
-{
-uint8_t x_64; 
-x_64 = !lean_is_exclusive(x_59);
-if (x_64 == 0)
-{
-return x_59;
-}
-else
-{
-lean_object* x_65; lean_object* x_66; lean_object* x_67; 
-x_65 = lean_ctor_get(x_59, 0);
-x_66 = lean_ctor_get(x_59, 1);
-lean_inc(x_66);
-lean_inc(x_65);
-lean_dec(x_59);
-x_67 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_67, 0, x_65);
-lean_ctor_set(x_67, 1, x_66);
-return x_67;
-}
-}
-}
-}
-}
-else
-{
-lean_object* x_68; lean_object* x_69; 
-lean_dec(x_17);
-x_68 = lean_ctor_get(x_39, 1);
-lean_inc(x_68);
-lean_dec(x_39);
-x_69 = l_Lean_Meta_injections_go(x_1, x_18, x_15, x_4, x_5, x_6, x_7, x_8, x_68);
-if (lean_obj_tag(x_69) == 0)
-{
-uint8_t x_70; 
-x_70 = !lean_is_exclusive(x_69);
-if (x_70 == 0)
-{
-return x_69;
-}
-else
-{
-lean_object* x_71; lean_object* x_72; lean_object* x_73; 
-x_71 = lean_ctor_get(x_69, 0);
-x_72 = lean_ctor_get(x_69, 1);
-lean_inc(x_72);
-lean_inc(x_71);
-lean_dec(x_69);
-x_73 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_73, 0, x_71);
-lean_ctor_set(x_73, 1, x_72);
-return x_73;
-}
-}
-else
-{
-uint8_t x_74; 
-x_74 = !lean_is_exclusive(x_69);
-if (x_74 == 0)
-{
-return x_69;
-}
-else
-{
-lean_object* x_75; lean_object* x_76; lean_object* x_77; 
-x_75 = lean_ctor_get(x_69, 0);
-x_76 = lean_ctor_get(x_69, 1);
-lean_inc(x_76);
-lean_inc(x_75);
-lean_dec(x_69);
-x_77 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_77, 0, x_75);
-lean_ctor_set(x_77, 1, x_76);
-return x_77;
-}
-}
-}
-}
-}
-else
-{
-uint8_t x_84; 
-lean_dec(x_32);
-lean_dec(x_18);
-lean_dec(x_17);
-lean_dec(x_15);
-lean_dec(x_14);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_1);
-x_84 = !lean_is_exclusive(x_34);
-if (x_84 == 0)
-{
-return x_34;
-}
-else
-{
-lean_object* x_85; lean_object* x_86; lean_object* x_87; 
-x_85 = lean_ctor_get(x_34, 0);
-x_86 = lean_ctor_get(x_34, 1);
-lean_inc(x_86);
-lean_inc(x_85);
-lean_dec(x_34);
-x_87 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_87, 0, x_85);
-lean_ctor_set(x_87, 1, x_86);
-return x_87;
-}
-}
-}
-else
-{
-uint8_t x_88; 
-lean_dec(x_30);
-lean_dec(x_18);
-lean_dec(x_17);
-lean_dec(x_15);
-lean_dec(x_14);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_1);
-x_88 = !lean_is_exclusive(x_31);
-if (x_88 == 0)
-{
-return x_31;
-}
-else
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; 
-x_89 = lean_ctor_get(x_31, 0);
-x_90 = lean_ctor_get(x_31, 1);
-lean_inc(x_90);
-lean_inc(x_89);
-lean_dec(x_31);
-x_91 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_91, 0, x_89);
-lean_ctor_set(x_91, 1, x_90);
-return x_91;
-}
-}
-}
-}
-else
-{
-uint8_t x_92; 
-lean_dec(x_18);
-lean_dec(x_17);
-lean_dec(x_15);
-lean_dec(x_14);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_1);
-x_92 = !lean_is_exclusive(x_22);
-if (x_92 == 0)
-{
-return x_22;
-}
-else
-{
-lean_object* x_93; lean_object* x_94; lean_object* x_95; 
-x_93 = lean_ctor_get(x_22, 0);
-x_94 = lean_ctor_get(x_22, 1);
-lean_inc(x_94);
-lean_inc(x_93);
-lean_dec(x_22);
-x_95 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_95, 0, x_93);
-lean_ctor_set(x_95, 1, x_94);
-return x_95;
-}
-}
-}
-else
-{
-uint8_t x_96; 
-lean_dec(x_18);
-lean_dec(x_17);
-lean_dec(x_15);
-lean_dec(x_14);
-lean_dec(x_8);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_1);
-x_96 = !lean_is_exclusive(x_19);
-if (x_96 == 0)
-{
-return x_19;
-}
-else
-{
-lean_object* x_97; lean_object* x_98; lean_object* x_99; 
-x_97 = lean_ctor_get(x_19, 0);
-x_98 = lean_ctor_get(x_19, 1);
-lean_inc(x_98);
-lean_inc(x_97);
+uint8_t x_55; 
 lean_dec(x_19);
-x_99 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_99, 0, x_97);
-lean_ctor_set(x_99, 1, x_98);
-return x_99;
+lean_dec(x_16);
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+x_55 = !lean_is_exclusive(x_54);
+if (x_55 == 0)
+{
+return x_54;
+}
+else
+{
+lean_object* x_56; lean_object* x_57; lean_object* x_58; 
+x_56 = lean_ctor_get(x_54, 0);
+x_57 = lean_ctor_get(x_54, 1);
+lean_inc(x_57);
+lean_inc(x_56);
+lean_dec(x_54);
+x_58 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_58, 0, x_56);
+lean_ctor_set(x_58, 1, x_57);
+return x_58;
+}
+}
+else
+{
+lean_object* x_59; lean_object* x_60; 
+x_59 = lean_ctor_get(x_54, 1);
+lean_inc(x_59);
+lean_dec(x_54);
+x_60 = l_Lean_Meta_injections_go(x_1, x_19, x_16, x_4, x_5, x_6, x_7, x_8, x_9, x_59);
+if (lean_obj_tag(x_60) == 0)
+{
+uint8_t x_61; 
+x_61 = !lean_is_exclusive(x_60);
+if (x_61 == 0)
+{
+return x_60;
+}
+else
+{
+lean_object* x_62; lean_object* x_63; lean_object* x_64; 
+x_62 = lean_ctor_get(x_60, 0);
+x_63 = lean_ctor_get(x_60, 1);
+lean_inc(x_63);
+lean_inc(x_62);
+lean_dec(x_60);
+x_64 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_64, 0, x_62);
+lean_ctor_set(x_64, 1, x_63);
+return x_64;
+}
+}
+else
+{
+uint8_t x_65; 
+x_65 = !lean_is_exclusive(x_60);
+if (x_65 == 0)
+{
+return x_60;
+}
+else
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; 
+x_66 = lean_ctor_get(x_60, 0);
+x_67 = lean_ctor_get(x_60, 1);
+lean_inc(x_67);
+lean_inc(x_66);
+lean_dec(x_60);
+x_68 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_68, 0, x_66);
+lean_ctor_set(x_68, 1, x_67);
+return x_68;
+}
 }
 }
 }
 }
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; 
+lean_object* x_69; lean_object* x_70; 
+lean_dec(x_18);
+x_69 = lean_ctor_get(x_39, 1);
+lean_inc(x_69);
+lean_dec(x_39);
+x_70 = l_Lean_Meta_injections_go(x_1, x_19, x_16, x_4, x_5, x_6, x_7, x_8, x_9, x_69);
+if (lean_obj_tag(x_70) == 0)
+{
+uint8_t x_71; 
+x_71 = !lean_is_exclusive(x_70);
+if (x_71 == 0)
+{
+return x_70;
+}
+else
+{
+lean_object* x_72; lean_object* x_73; lean_object* x_74; 
+x_72 = lean_ctor_get(x_70, 0);
+x_73 = lean_ctor_get(x_70, 1);
+lean_inc(x_73);
+lean_inc(x_72);
+lean_dec(x_70);
+x_74 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_74, 0, x_72);
+lean_ctor_set(x_74, 1, x_73);
+return x_74;
+}
+}
+else
+{
+uint8_t x_75; 
+x_75 = !lean_is_exclusive(x_70);
+if (x_75 == 0)
+{
+return x_70;
+}
+else
+{
+lean_object* x_76; lean_object* x_77; lean_object* x_78; 
+x_76 = lean_ctor_get(x_70, 0);
+x_77 = lean_ctor_get(x_70, 1);
+lean_inc(x_77);
+lean_inc(x_76);
+lean_dec(x_70);
+x_78 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_78, 0, x_76);
+lean_ctor_set(x_78, 1, x_77);
+return x_78;
+}
+}
+}
+}
+}
+else
+{
+uint8_t x_85; 
+lean_dec(x_33);
+lean_dec(x_19);
+lean_dec(x_18);
+lean_dec(x_16);
+lean_dec(x_15);
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+x_85 = !lean_is_exclusive(x_35);
+if (x_85 == 0)
+{
+return x_35;
+}
+else
+{
+lean_object* x_86; lean_object* x_87; lean_object* x_88; 
+x_86 = lean_ctor_get(x_35, 0);
+x_87 = lean_ctor_get(x_35, 1);
+lean_inc(x_87);
+lean_inc(x_86);
+lean_dec(x_35);
+x_88 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_88, 0, x_86);
+lean_ctor_set(x_88, 1, x_87);
+return x_88;
+}
+}
+}
+else
+{
+uint8_t x_89; 
+lean_dec(x_31);
+lean_dec(x_19);
+lean_dec(x_18);
+lean_dec(x_16);
+lean_dec(x_15);
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+x_89 = !lean_is_exclusive(x_32);
+if (x_89 == 0)
+{
+return x_32;
+}
+else
+{
+lean_object* x_90; lean_object* x_91; lean_object* x_92; 
+x_90 = lean_ctor_get(x_32, 0);
+x_91 = lean_ctor_get(x_32, 1);
+lean_inc(x_91);
+lean_inc(x_90);
+lean_dec(x_32);
+x_92 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_92, 0, x_90);
+lean_ctor_set(x_92, 1, x_91);
+return x_92;
+}
+}
+}
+}
+else
+{
+uint8_t x_93; 
+lean_dec(x_19);
+lean_dec(x_18);
+lean_dec(x_16);
+lean_dec(x_15);
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+x_93 = !lean_is_exclusive(x_23);
+if (x_93 == 0)
+{
+return x_23;
+}
+else
+{
+lean_object* x_94; lean_object* x_95; lean_object* x_96; 
+x_94 = lean_ctor_get(x_23, 0);
+x_95 = lean_ctor_get(x_23, 1);
+lean_inc(x_95);
+lean_inc(x_94);
+lean_dec(x_23);
+x_96 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_96, 0, x_94);
+lean_ctor_set(x_96, 1, x_95);
+return x_96;
+}
+}
+}
+else
+{
+uint8_t x_97; 
+lean_dec(x_19);
+lean_dec(x_18);
+lean_dec(x_16);
+lean_dec(x_15);
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_1);
+x_97 = !lean_is_exclusive(x_20);
+if (x_97 == 0)
+{
+return x_20;
+}
+else
+{
+lean_object* x_98; lean_object* x_99; lean_object* x_100; 
+x_98 = lean_ctor_get(x_20, 0);
+x_99 = lean_ctor_get(x_20, 1);
+lean_inc(x_99);
+lean_inc(x_98);
+lean_dec(x_20);
+x_100 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_100, 0, x_98);
+lean_ctor_set(x_100, 1, x_99);
+return x_100;
+}
+}
+}
+}
+else
+{
+lean_object* x_101; lean_object* x_102; lean_object* x_103; 
+lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-x_100 = l_Lean_Meta_injections_go___closed__2;
-x_101 = l_Lean_Meta_injections_go___closed__5;
-x_102 = l_Lean_Meta_throwTacticEx___rarg(x_100, x_1, x_101, x_5, x_6, x_7, x_8, x_9);
-return x_102;
+x_101 = l_Lean_Meta_injections_go___closed__2;
+x_102 = l_Lean_Meta_injections_go___closed__5;
+x_103 = l_Lean_Meta_throwTacticEx___rarg(x_101, x_1, x_102, x_6, x_7, x_8, x_9, x_10);
+return x_103;
 }
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Meta_injections___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+LEAN_EXPORT lean_object* l_Lean_Meta_injections___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
 _start:
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_3, 1);
-lean_inc(x_8);
-x_9 = l_Lean_LocalContext_getFVarIds(x_8);
-x_10 = lean_array_to_list(lean_box(0), x_9);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_9 = lean_ctor_get(x_4, 1);
+lean_inc(x_9);
+x_10 = l_Lean_LocalContext_getFVarIds(x_9);
+x_11 = lean_array_to_list(lean_box(0), x_10);
 lean_inc(x_1);
-x_11 = l_Lean_Meta_injections_go(x_1, x_2, x_10, x_1, x_3, x_4, x_5, x_6, x_7);
-return x_11;
+x_12 = l_Lean_Meta_injections_go(x_1, x_2, x_11, x_1, x_3, x_4, x_5, x_6, x_7, x_8);
+return x_12;
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Meta_injections(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+LEAN_EXPORT lean_object* l_Lean_Meta_injections(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
 _start:
 {
-lean_object* x_8; lean_object* x_9; 
+lean_object* x_9; lean_object* x_10; 
 lean_inc(x_1);
-x_8 = lean_alloc_closure((void*)(l_Lean_Meta_injections___lambda__1), 7, 2);
-lean_closure_set(x_8, 0, x_1);
-lean_closure_set(x_8, 1, x_2);
-x_9 = l_Lean_MVarId_withContext___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_synthPendingImp___spec__2___rarg(x_1, x_8, x_3, x_4, x_5, x_6, x_7);
-return x_9;
+x_9 = lean_alloc_closure((void*)(l_Lean_Meta_injections___lambda__1), 8, 3);
+lean_closure_set(x_9, 0, x_1);
+lean_closure_set(x_9, 1, x_3);
+lean_closure_set(x_9, 2, x_2);
+x_10 = l_Lean_MVarId_withContext___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_synthPendingImp___spec__2___rarg(x_1, x_9, x_4, x_5, x_6, x_7, x_8);
+return x_10;
 }
 }
 lean_object* initialize_Init(uint8_t builtin, lean_object*);

stage0/stdlib/Lean/Meta/Tactic/Simp/Main.c

@@ -2017,7 +2017,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Meta_Tactic_Simp_Main_0__Lean_Meta_Simp_mkImpCongr___closed__1;
 x_2 = l___private_Lean_Meta_Tactic_Simp_Main_0__Lean_Meta_Simp_mkImpCongr___closed__2;
-x_3 = lean_unsigned_to_nat(1489u);
+x_3 = lean_unsigned_to_nat(1533u);
 x_4 = lean_unsigned_to_nat(24u);
 x_5 = l___private_Lean_Meta_Tactic_Simp_Main_0__Lean_Meta_Simp_mkImpCongr___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -37977,7 +37977,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Meta_Tactic_Simp_Main_0__Lean_Meta_Simp_mkImpCongr___closed__1;
 x_2 = l_Lean_Meta_Simp_simp_simpProj___lambda__1___closed__1;
-x_3 = lean_unsigned_to_nat(1463u);
+x_3 = lean_unsigned_to_nat(1507u);
 x_4 = lean_unsigned_to_nat(18u);
 x_5 = l_Lean_Meta_Simp_simp_simpProj___lambda__1___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

stage0/stdlib/Lean/Meta/Tactic/Simp/SimpTheorems.c

@@ -50,7 +50,6 @@ lean_object* l_Lean_Meta_mkForallFVars(lean_object*, lean_object*, uint8_t, uint
 static lean_object* l_Lean_Meta___aux__Lean__Meta__Tactic__Simp__SimpTheorems______macroRules__Lean__Meta____root____Lean__Parser__Command__registerSimpAttr__1___closed__25;
 static lean_object* l_Lean_Meta_SimpTheorems_erase___rarg___closed__4;
 lean_object* l_Lean_LocalDecl_userName(lean_object*);
-lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Meta___aux__Lean__Meta__Tactic__Simp__SimpTheorems______macroRules__Lean__Meta____root____Lean__Parser__Command__registerSimpAttr__1___closed__86;
 static lean_object* l_Lean_Meta___aux__Lean__Meta__Tactic__Simp__SimpTheorems______macroRules__Lean__Meta____root____Lean__Parser__Command__registerSimpAttr__1___closed__97;
 lean_object* l_Lean_throwError___at_Lean_Meta_setInlineAttribute___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -645,6 +644,7 @@ LEAN_EXPORT lean_object* l_Lean_Meta_SimpTheorem_levelParams___default;
 lean_object* l_Std_PersistentHashMap_mkCollisionNode___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Meta_DiscrTree_insertCore___at_Lean_Meta_addSimpTheoremEntry___spec__1___closed__8;
 static lean_object* l_Lean_Meta___aux__Lean__Meta__Tactic__Simp__SimpTheorems______macroRules__Lean__Meta____root____Lean__Parser__Command__registerSimpAttr__1___closed__37;
+lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_List_forIn_loop___at___private_Lean_Meta_Tactic_Simp_SimpTheorems_0__Lean_Meta_mkSimpTheoremsFromConst___spec__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Meta_instInhabitedSimpTheorem___closed__1;
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
@@ -11927,7 +11927,7 @@ x_13 = l_Lean_Meta_SimpTheorems_erase___rarg___closed__4;
 x_14 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_14, 0, x_12);
 lean_ctor_set(x_14, 1, x_13);
-x_15 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_14, x_3, x_4, x_5);
+x_15 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_14, x_3, x_4, x_5);
 lean_dec(x_4);
 lean_dec(x_3);
 x_16 = !lean_is_exclusive(x_15);
@@ -14040,7 +14040,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Meta_SimpTheorem_getValue___closed__1;
 x_2 = l_Lean_Meta_SimpTheorem_getValue___closed__2;
-x_3 = lean_unsigned_to_nat(1430u);
+x_3 = lean_unsigned_to_nat(1474u);
 x_4 = lean_unsigned_to_nat(18u);
 x_5 = l_Lean_Meta_SimpTheorem_getValue___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

stage0/stdlib/Lean/Meta/Transform.c

@@ -782,7 +782,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Core_transform_visit___rarg___lambda__2___closed__1;
 x_2 = l_Lean_Core_transform_visit___rarg___lambda__2___closed__2;
-x_3 = lean_unsigned_to_nat(1509u);
+x_3 = lean_unsigned_to_nat(1553u);
 x_4 = lean_unsigned_to_nat(20u);
 x_5 = l_Lean_Core_transform_visit___rarg___lambda__2___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -920,7 +920,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Core_transform_visit___rarg___lambda__2___closed__1;
 x_2 = l_Lean_Core_transform_visit___rarg___lambda__4___closed__1;
-x_3 = lean_unsigned_to_nat(1489u);
+x_3 = lean_unsigned_to_nat(1533u);
 x_4 = lean_unsigned_to_nat(24u);
 x_5 = l_Lean_Core_transform_visit___rarg___lambda__4___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -1058,7 +1058,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Core_transform_visit___rarg___lambda__2___closed__1;
 x_2 = l_Lean_Core_transform_visit___rarg___lambda__6___closed__1;
-x_3 = lean_unsigned_to_nat(1518u);
+x_3 = lean_unsigned_to_nat(1562u);
 x_4 = lean_unsigned_to_nat(22u);
 x_5 = l_Lean_Core_transform_visit___rarg___lambda__6___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -1230,7 +1230,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Core_transform_visit___rarg___lambda__2___closed__1;
 x_2 = l_Lean_Core_transform_visit___rarg___lambda__9___closed__1;
-x_3 = lean_unsigned_to_nat(1452u);
+x_3 = lean_unsigned_to_nat(1496u);
 x_4 = lean_unsigned_to_nat(17u);
 x_5 = l_Lean_Core_transform_visit___rarg___lambda__9___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -1302,7 +1302,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Core_transform_visit___rarg___lambda__2___closed__1;
 x_2 = l_Lean_Core_transform_visit___rarg___lambda__10___closed__1;
-x_3 = lean_unsigned_to_nat(1463u);
+x_3 = lean_unsigned_to_nat(1507u);
 x_4 = lean_unsigned_to_nat(18u);
 x_5 = l_Lean_Core_transform_visit___rarg___lambda__10___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

stage0/stdlib/Lean/MetavarContext.c

@@ -12763,7 +12763,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_instantiateExprMVars___rarg___lambda__9___closed__1;
 x_2 = l_Lean_instantiateExprMVars___rarg___lambda__9___closed__2;
-x_3 = lean_unsigned_to_nat(1441u);
+x_3 = lean_unsigned_to_nat(1485u);
 x_4 = lean_unsigned_to_nat(14u);
 x_5 = l_Lean_instantiateExprMVars___rarg___lambda__9___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -12844,7 +12844,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_instantiateExprMVars___rarg___lambda__9___closed__1;
 x_2 = l_Lean_instantiateExprMVars___rarg___lambda__10___closed__1;
-x_3 = lean_unsigned_to_nat(1430u);
+x_3 = lean_unsigned_to_nat(1474u);
 x_4 = lean_unsigned_to_nat(18u);
 x_5 = l_Lean_instantiateExprMVars___rarg___lambda__10___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -12926,7 +12926,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_instantiateExprMVars___rarg___lambda__9___closed__1;
 x_2 = l_Lean_instantiateExprMVars___rarg___lambda__11___closed__1;
-x_3 = lean_unsigned_to_nat(1509u);
+x_3 = lean_unsigned_to_nat(1553u);
 x_4 = lean_unsigned_to_nat(20u);
 x_5 = l_Lean_instantiateExprMVars___rarg___lambda__11___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13064,7 +13064,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_instantiateExprMVars___rarg___lambda__9___closed__1;
 x_2 = l_Lean_instantiateExprMVars___rarg___lambda__13___closed__1;
-x_3 = lean_unsigned_to_nat(1489u);
+x_3 = lean_unsigned_to_nat(1533u);
 x_4 = lean_unsigned_to_nat(24u);
 x_5 = l_Lean_instantiateExprMVars___rarg___lambda__13___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13202,7 +13202,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_instantiateExprMVars___rarg___lambda__9___closed__1;
 x_2 = l_Lean_instantiateExprMVars___rarg___lambda__15___closed__1;
-x_3 = lean_unsigned_to_nat(1518u);
+x_3 = lean_unsigned_to_nat(1562u);
 x_4 = lean_unsigned_to_nat(22u);
 x_5 = l_Lean_instantiateExprMVars___rarg___lambda__15___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13370,7 +13370,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_instantiateExprMVars___rarg___lambda__9___closed__1;
 x_2 = l_Lean_instantiateExprMVars___rarg___lambda__18___closed__1;
-x_3 = lean_unsigned_to_nat(1452u);
+x_3 = lean_unsigned_to_nat(1496u);
 x_4 = lean_unsigned_to_nat(17u);
 x_5 = l_Lean_instantiateExprMVars___rarg___lambda__18___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -13454,7 +13454,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_instantiateExprMVars___rarg___lambda__9___closed__1;
 x_2 = l_Lean_instantiateExprMVars___rarg___lambda__19___closed__1;
-x_3 = lean_unsigned_to_nat(1463u);
+x_3 = lean_unsigned_to_nat(1507u);
 x_4 = lean_unsigned_to_nat(18u);
 x_5 = l_Lean_instantiateExprMVars___rarg___lambda__19___closed__2;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

stage0/stdlib/Lean/Parser/Extension.c

@@ -48,7 +48,6 @@ LEAN_EXPORT lean_object* l_Std_PersistentHashMap_foldlMAux___at___private_Lean_P
 LEAN_EXPORT lean_object* l_Lean_Parser_parserOfStack___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Parser_Extension_0__Lean_Parser_addBuiltinParserCategory___closed__1;
 lean_object* l_Std_PersistentHashMap_foldlMAux___at_Lean_mkModuleData___spec__3___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Parser_ParserExtension_instInhabitedOLeanEntry___closed__1;
 static lean_object* l_Lean_Parser_initFn____x40_Lean_Parser_Extension___hyg_3903____closed__8;
 LEAN_EXPORT lean_object* l_Lean_Parser_instCoeParserParserAliasValue(lean_object*);
@@ -661,6 +660,7 @@ static lean_object* l_Lean_Parser_initFn____x40_Lean_Parser_Extension___hyg_3693
 static lean_object* l___private_Lean_Parser_Extension_0__Lean_Parser_BuiltinParserAttribute_add___lambda__2___closed__15;
 static lean_object* l___private_Lean_Parser_Extension_0__Lean_Parser_BuiltinParserAttribute_add___lambda__2___closed__18;
 lean_object* l_Std_PersistentHashMap_mkCollisionNode___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Std_RBNode_find___at_Lean_Parser_getAlias___spec__1(lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Parser_evalInsideQuot(lean_object*, lean_object*);
@@ -11171,7 +11171,7 @@ x_17 = l___private_Lean_Parser_Extension_0__Lean_Parser_BuiltinParserAttribute_a
 x_18 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_18, 0, x_16);
 lean_ctor_set(x_18, 1, x_17);
-x_19 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_18, x_6, x_7, x_11);
+x_19 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_18, x_6, x_7, x_11);
 lean_dec(x_7);
 lean_dec(x_6);
 x_20 = !lean_is_exclusive(x_19);
@@ -11661,7 +11661,7 @@ x_23 = l_List_forM___at___private_Lean_Parser_Extension_0__Lean_Parser_ParserAtt
 x_24 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_24, 0, x_22);
 lean_ctor_set(x_24, 1, x_23);
-x_25 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__3(x_24, x_4, x_5, x_15);
+x_25 = l_Lean_throwError___at_Lean_registerTagAttribute___spec__2(x_24, x_4, x_5, x_15);
 lean_dec(x_5);
 lean_dec(x_4);
 x_26 = !lean_is_exclusive(x_25);

stage0/stdlib/Lean/ParserCompiler/Attribute.c

@@ -78,6 +78,7 @@ lean_object* l_Std_RBNode_find___at___private_Lean_Hygiene_0__Lean_sanitizeSynta
 static lean_object* l_Lean_ParserCompiler_registerCombinatorAttribute___closed__7;
 lean_object* l_Lean_registerBuiltinAttribute(lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_AttributeImpl_erase___default___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_ParserCompiler_instInhabitedCombinatorAttribute___closed__3;
 size_t lean_usize_of_nat(lean_object*);
 lean_object* l_Lean_PersistentEnvExtension_addEntry___rarg(lean_object*, lean_object*, lean_object*);
@@ -85,7 +86,6 @@ lean_object* l_Lean_SimplePersistentEnvExtension_getState___rarg(lean_object*, l
 LEAN_EXPORT lean_object* l_Lean_ofExcept___at_Lean_ParserCompiler_CombinatorAttribute_runDeclFor___spec__3(lean_object*);
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_instInhabitedExt___lambda__1(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_ParserCompiler_instInhabitedCombinatorAttribute___lambda__4___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_list_to_array(lean_object*, lean_object*);
 static lean_object* l_Lean_ParserCompiler_instInhabitedCombinatorAttribute___closed__7;
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
@@ -597,7 +597,7 @@ x_17 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_17, 0, x_13);
 lean_ctor_set(x_17, 1, x_2);
 x_18 = l_Lean_PersistentEnvExtension_addEntry___rarg(x_1, x_11, x_17);
-x_19 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(x_18, x_5, x_6, x_16);
+x_19 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(x_18, x_5, x_6, x_16);
 lean_dec(x_6);
 lean_dec(x_5);
 return x_19;

stage0/stdlib/Lean/Server/References.c

@@ -259,6 +259,7 @@ size_t lean_usize_of_nat(lean_object*);
 LEAN_EXPORT lean_object* l_Std_AssocList_find_x3f___at_Lean_Server_dedupReferences___spec__3___boxed(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Std_HashMapImp_find_x3f___at_Lean_Server_dedupReferences___spec__2(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Lsp_RefInfo_merge(lean_object*, lean_object*);
+extern lean_object* l_Lean_NameSet_empty;
 lean_object* l_instBEqProd___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_List_foldl___at_Lean_Server_References_allRefs___spec__12(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_List_filterTRAux___at_Lean_Server_References_removeIlean___spec__4___boxed(lean_object*, lean_object*, lean_object*);
@@ -561,17 +562,19 @@ return x_5;
 static lean_object* _init_l_Lean_Server_instInhabitedReference___closed__11() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Server_instInhabitedReference___closed__4;
 x_2 = l_Lean_Server_instInhabitedReference___closed__8;
 x_3 = l_Lean_Server_Reference_aliases___default___closed__1;
-x_4 = l_Lean_Server_instInhabitedReference___closed__10;
-x_5 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_4);
-return x_5;
+x_4 = l_Lean_NameSet_empty;
+x_5 = l_Lean_Server_instInhabitedReference___closed__10;
+x_6 = lean_alloc_ctor(0, 5, 0);
+lean_ctor_set(x_6, 0, x_1);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set(x_6, 4, x_5);
+return x_6;
 }
 }
 static lean_object* _init_l_Lean_Server_instInhabitedReference___closed__12() {

stage0/stdlib/Lean/Server/Snapshots.c

@@ -90,6 +90,7 @@ LEAN_EXPORT lean_object* l_Lean_Server_Snapshots_initFn____x40_Lean_Server_Snaps
 LEAN_EXPORT lean_object* l_Lean_Server_Snapshots_initFn____x40_Lean_Server_Snapshots___hyg_6_(lean_object*);
 size_t lean_usize_of_nat(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Server_Snapshots_Snapshot_runCommandElabM(lean_object*);
+extern lean_object* l_Lean_NameSet_empty;
 lean_object* l_Lean_Widget_InteractiveDiagnostic_toDiagnostic(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Server_Snapshots_Snapshot_diagnostics(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Server_Snapshots_parseNextCmd(lean_object*, lean_object*, lean_object*);
@@ -310,17 +311,19 @@ return x_5;
 static lean_object* _init_l_Lean_Server_Snapshots_instInhabitedSnapshot___closed__8() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Server_Snapshots_instInhabitedSnapshot___closed__2;
 x_2 = l_Lean_Server_Snapshots_instInhabitedSnapshot___closed__4;
 x_3 = l_Lean_Server_Snapshots_instInhabitedSnapshot___closed__5;
-x_4 = l_Lean_Server_Snapshots_instInhabitedSnapshot___closed__7;
-x_5 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_4);
-return x_5;
+x_4 = l_Lean_NameSet_empty;
+x_5 = l_Lean_Server_Snapshots_instInhabitedSnapshot___closed__7;
+x_6 = lean_alloc_ctor(0, 5, 0);
+lean_ctor_set(x_6, 0, x_1);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set(x_6, 4, x_5);
+return x_6;
 }
 }
 static lean_object* _init_l_Lean_Server_Snapshots_instInhabitedSnapshot___closed__9() {

stage0/stdlib/Lean/Widget/Basic.c

@@ -43,6 +43,7 @@ static uint32_t l_Lean_Widget_instInhabitedInfoWithCtx___closed__7;
 static lean_object* l_Lean_Widget_instFromJsonFVarId___closed__5;
 LEAN_EXPORT lean_object* l_Lean_Widget_instImpl____x40_Lean_Widget_Basic___hyg_33_;
 LEAN_EXPORT lean_object* l_Lean_Widget_instImpl____x40_Lean_Widget_Basic___hyg_53_;
+extern lean_object* l_Lean_NameSet_empty;
 LEAN_EXPORT lean_object* l_Lean_Widget_instToJsonMVarId(lean_object*);
 static lean_object* l_Lean_Widget_instInhabitedInfoWithCtx___closed__16;
 static lean_object* l_Lean_Widget_instImpl____x40_Lean_Widget_Basic___hyg_33____closed__6;
@@ -159,17 +160,19 @@ return x_5;
 static lean_object* _init_l_Lean_Widget_instInhabitedInfoWithCtx___closed__9() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Widget_instInhabitedInfoWithCtx___closed__1;
 x_2 = l_Lean_Widget_instInhabitedInfoWithCtx___closed__5;
 x_3 = l_Lean_Widget_instInhabitedInfoWithCtx___closed__6;
-x_4 = l_Lean_Widget_instInhabitedInfoWithCtx___closed__8;
-x_5 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_4);
-return x_5;
+x_4 = l_Lean_NameSet_empty;
+x_5 = l_Lean_Widget_instInhabitedInfoWithCtx___closed__8;
+x_6 = lean_alloc_ctor(0, 5, 0);
+lean_ctor_set(x_6, 0, x_1);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set(x_6, 4, x_5);
+return x_6;
 }
 }
 static lean_object* _init_l_Lean_Widget_instInhabitedInfoWithCtx___closed__10() {

stage0/stdlib/Lean/Widget/InteractiveCode.c

@@ -72,6 +72,7 @@ LEAN_EXPORT lean_object* l_Lean_Widget_CodeWithInfos_pretty(lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Widget_InteractiveCode_0__Lean_Widget_toJsonRpcEncodablePacket____x40_Lean_Widget_InteractiveCode___hyg_113____boxed(lean_object*);
 static lean_object* l_Lean_Widget_instInhabitedSubexprInfo___closed__9;
 extern lean_object* l_Lean_pp_explicit;
+extern lean_object* l_Lean_NameSet_empty;
 static lean_object* l_Lean_Widget_instRpcEncodableSubexprInfo___closed__3;
 static lean_object* l_Lean_Widget_instInhabitedSubexprInfo___closed__3;
 static lean_object* l_Lean_Widget_instInhabitedSubexprInfo___closed__15;
@@ -195,17 +196,19 @@ return x_5;
 static lean_object* _init_l_Lean_Widget_instInhabitedSubexprInfo___closed__9() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Widget_instInhabitedSubexprInfo___closed__1;
 x_2 = l_Lean_Widget_instInhabitedSubexprInfo___closed__5;
 x_3 = l_Lean_Widget_instInhabitedSubexprInfo___closed__6;
-x_4 = l_Lean_Widget_instInhabitedSubexprInfo___closed__8;
-x_5 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_4);
-return x_5;
+x_4 = l_Lean_NameSet_empty;
+x_5 = l_Lean_Widget_instInhabitedSubexprInfo___closed__8;
+x_6 = lean_alloc_ctor(0, 5, 0);
+lean_ctor_set(x_6, 0, x_1);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set(x_6, 4, x_5);
+return x_6;
 }
 }
 static lean_object* _init_l_Lean_Widget_instInhabitedSubexprInfo___closed__10() {

stage0/stdlib/Lean/Widget/InteractiveDiagnostic.c

@@ -196,6 +196,7 @@ static lean_object* l_Lean_Widget_instRpcEncodableDiagnosticWith_dec____x40_Lean
 static lean_object* l___private_Lean_Widget_InteractiveDiagnostic_0__Lean_Widget_msgToInteractiveAux___closed__1;
 size_t lean_usize_of_nat(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Widget_msgToInteractive(lean_object*, uint8_t, lean_object*, lean_object*);
+extern lean_object* l_Lean_NameSet_empty;
 LEAN_EXPORT lean_object* l_Lean_Widget_InteractiveDiagnostic_toDiagnostic(lean_object*);
 static lean_object* l_Lean_Widget_instRpcEncodableDiagnosticWith_enc____x40_Lean_Widget_InteractiveDiagnostic___hyg_1523____rarg___closed__3;
 static lean_object* l___private_Lean_Widget_InteractiveDiagnostic_0__Lean_Widget_fromJsonRpcEncodablePacket____x40_Lean_Widget_InteractiveDiagnostic___hyg_1597____closed__5;
@@ -15577,17 +15578,19 @@ return x_5;
 static lean_object* _init_l_Lean_Widget_instInhabitedEmbedFmt___closed__9() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Widget_instInhabitedEmbedFmt___closed__1;
 x_2 = l_Lean_Widget_instInhabitedEmbedFmt___closed__5;
 x_3 = l_Lean_Widget_instInhabitedEmbedFmt___closed__6;
-x_4 = l_Lean_Widget_instInhabitedEmbedFmt___closed__8;
-x_5 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_4);
-return x_5;
+x_4 = l_Lean_NameSet_empty;
+x_5 = l_Lean_Widget_instInhabitedEmbedFmt___closed__8;
+x_6 = lean_alloc_ctor(0, 5, 0);
+lean_ctor_set(x_6, 0, x_1);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set(x_6, 4, x_5);
+return x_6;
 }
 }
 static lean_object* _init_l_Lean_Widget_instInhabitedEmbedFmt___closed__10() {

stage0/stdlib/Lean/Widget/UserWidget.c

@@ -186,6 +186,7 @@ LEAN_EXPORT lean_object* l_Lean_ofExcept___at___private_Lean_Widget_UserWidget_0
 static lean_object* l_Lean_Elab_pushInfoLeaf___at_Lean_Widget_elabWidgetCmd___spec__3___closed__2;
 static lean_object* l_Lean_Widget_widgetCmd___closed__2;
 static lean_object* l___private_Lean_Widget_UserWidget_0__Lean_Widget_attributeImpl___closed__6;
+lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Widget_instFromJsonGetWidgetSourceParams___closed__1;
 LEAN_EXPORT lean_object* l___private_Lean_Widget_UserWidget_0__Lean_Widget_fromJsonUserWidgetDefinition____x40_Lean_Widget_UserWidget___hyg_162_(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Server_wrapRpcProcedure___at_Lean_Widget_getWidgets___rpc__wrapped___spec__1(lean_object*, lean_object*);
@@ -202,7 +203,6 @@ LEAN_EXPORT lean_object* l_Lean_Elab_pushInfoLeaf___at_Lean_Widget_elabWidgetCmd
 static lean_object* l_Lean_Widget_getWidgetSource___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Widget_initFn____x40_Lean_Widget_UserWidget___hyg_423____lambda__2___boxed(lean_object*);
 static lean_object* l_Lean_Widget_instFromJsonGetWidgetsResponse___closed__1;
-lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Widget_initFn____x40_Lean_Widget_UserWidget___hyg_423____spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_mapMUnsafe_map___at_Lean_Widget_getWidgets___spec__2___closed__1;
 static lean_object* l_Lean_Widget_instFromJsonUserWidgetInstance___closed__1;
@@ -4022,7 +4022,7 @@ lean_ctor_set(x_21, 0, x_20);
 lean_ctor_set(x_21, 1, x_1);
 x_22 = l___private_Lean_Widget_UserWidget_0__Lean_Widget_attributeImpl___elambda__2___closed__2;
 x_23 = l_Lean_PersistentEnvExtension_addEntry___rarg(x_22, x_19, x_21);
-x_24 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__2(x_23, x_4, x_5, x_13);
+x_24 = l_Lean_setEnv___at_Lean_registerTagAttribute___spec__1(x_23, x_4, x_5, x_13);
 lean_dec(x_5);
 lean_dec(x_4);
 return x_24;