chore: update stage0

stage0/src/Init/Data/Array/Basic.lean

@@ -818,4 +818,39 @@ else
 @[inline] def partition {α : Type u} (p : α → Bool) (as : Array α) : Array α × Array α :=
 partitionAux p as 0 #[] #[]
 
+partial def isPrefixOfAux {α : Type u} [HasBeq α] (as bs : Array α) (hle : as.size ≤ bs.size) : Nat → Bool
+| i =>
+  if h : i < as.size then
+    let a := as.get ⟨i, h⟩;
+    let b := bs.get ⟨i, Nat.ltOfLtOfLe h hle⟩;
+    if a == b then
+      isPrefixOfAux (i+1)
+    else
+      false
+  else
+    true
+
+/- Return true iff `as` is a prefix of `bs` -/
+def isPrefixOf  {α : Type u} [HasBeq α] (as bs : Array α) : Bool :=
+if h : as.size ≤ bs.size then
+  isPrefixOfAux as bs h 0
+else
+  false
+
+private def allDiffAuxAux {α} [HasBeq α] (as : Array α) (a : α) : forall (i : Nat), i < as.size → Bool
+| 0,   h => true
+| i+1, h =>
+  have i < as.size from Nat.ltTrans (Nat.ltSuccSelf _) h;
+  a != as.get ⟨i, this⟩ && allDiffAuxAux i this
+
+private partial def allDiffAux {α} [HasBeq α] (as : Array α) : Nat → Bool
+| i =>
+  if h : i < as.size then
+    allDiffAuxAux as (as.get ⟨i, h⟩) i h && allDiffAux (i+1)
+  else
+    true
+
+def allDiff {α} [HasBeq α] (as : Array α) : Bool :=
+allDiffAux as 0
+
 end Array

stage0/src/Init/Data/FloatArray/Basic.lean

@@ -63,8 +63,8 @@ s.size == 0
 
 partial def toListAux (ds : FloatArray) : Nat → List Float → List Float
 | i, r =>
-  if i < ds.size then
-    toListAux (i+1) (ds.get! i :: r)
+  if h : i < ds.size then
+    toListAux (i+1) (ds.get ⟨i, h⟩ :: r)
   else
     r.reverse
 

stage0/src/Init/LeanInit.lean

@@ -327,6 +327,15 @@ private def eraseMacroScopesAux : Name → Name
 def Name.eraseMacroScopes (n : Name) : Name :=
 if n.hasMacroScopes then eraseMacroScopesAux n else n
 
+private def simpMacroScopesAux : Name → Name
+| Name.num p i _ => mkNameNum (simpMacroScopesAux p) i
+| n              => eraseMacroScopesAux n
+
+/- Helper function we use to create binder names that do not need to be unique. -/
+@[export lean_simp_macro_scopes]
+def Name.simpMacroScopes (n : Name) : Name :=
+if n.hasMacroScopes then simpMacroScopesAux n else n
+
 structure MacroScopesView :=
 (name       : Name)
 (imported   : Name)

stage0/src/Lean/Elab/App.lean

@@ -613,7 +613,7 @@ else
   else
     withRef f $ mergeFailures candidates
 
-private partial def expandApp (stx : Syntax) : TermElabM (Syntax × Array NamedArg × Array Arg) := do
+partial def expandApp (stx : Syntax) : TermElabM (Syntax × Array NamedArg × Array Arg) := do
 let f    := stx.getArg 0;
 (namedArgs, args) ← (stx.getArg 1).getArgs.foldlM
   (fun (acc : Array NamedArg × Array Arg) (stx : Syntax) => do

stage0/src/Lean/Elab/Binders.lean

@@ -17,9 +17,9 @@ open Meta
     a) (`:` term)?
     b) `:` term
   return `term` if it is present, or a hole if not. -/
-private def expandBinderType (stx : Syntax) : Syntax :=
+private def expandBinderType (ref : Syntax) (stx : Syntax) : Syntax :=
 if stx.getNumArgs == 0 then
-  mkHole stx
+  mkHole ref
 else
   stx.getArg 1
 
@@ -108,14 +108,14 @@ match stx with
   else if k == `Lean.Parser.Term.explicitBinder then do
     -- `(` binderIdent+ binderType (binderDefault <|> binderTactic)? `)`
     ids ← getBinderIds (args.get! 1);
-    let type        := expandBinderType (args.get! 2);
+    let type        := expandBinderType stx (args.get! 2);
     let optModifier := args.get! 3;
     type ← expandBinderModifier type optModifier;
     ids.mapM $ fun id => do id ← expandBinderIdent id; pure { id := id, type := type, bi := BinderInfo.default }
   else if k == `Lean.Parser.Term.implicitBinder then do
     -- `{` binderIdent+ binderType `}`
     ids ← getBinderIds (args.get! 1);
-    let type := expandBinderType (args.get! 2);
+    let type := expandBinderType stx (args.get! 2);
     ids.mapM $ fun id => do id ← expandBinderIdent id; pure { id := id, type := type, bi := BinderInfo.implicit }
   else if k == `Lean.Parser.Term.instBinder then do
     -- `[` optIdent type `]`
@@ -390,7 +390,7 @@ private def expandMatchAltsIntoMatchAux (ref : Syntax) (matchAlts : Syntax) (mat
   if matchTactic then
     `(tactic| intro $x:term; $body:tactic)
   else
-    `(fun $x => $body)
+    `(@fun $x => $body)
 
 /--
   Expand `matchAlts` syntax into a full `match`-expression.

stage0/src/Lean/Elab/Match.lean

@@ -6,6 +6,7 @@ Authors: Leonardo de Moura
 import Lean.Meta.Match.MatchPatternAttr
 import Lean.Meta.Match.Match
 import Lean.Elab.SyntheticMVars
+import Lean.Elab.App
 
 namespace Lean
 namespace Elab
@@ -144,7 +145,7 @@ fun stx expectedType? => do
   Patterns define new local variables.
   This module collect them and preprocess `_` occurring in patterns.
   Recall that an `_` may represent anonymous variables or inaccessible terms
-  that implied by typing constraints. Thus, we represent them with fresh named holes `?x`.
+  that are implied by typing constraints. Thus, we represent them with fresh named holes `?x`.
   After we elaborate the pattern, if the metavariable remains unassigned, we transform it into
   a regular pattern variable. Otherwise, it becomes an inaccessible term.
 
@@ -183,70 +184,176 @@ forallBoundedTelescope ctorVal.type ctorVal.nparams fun ps _ =>
 private def throwAmbiguous {α} (fs : List Expr) : M α :=
 throwError ("ambiguous pattern, use fully qualified name, possible interpretations " ++ fs)
 
-private def processVar (id : Name) (mustBeCtor : Bool := false) : M Unit := do
-when mustBeCtor $ throwCtorExpected;
-unless id.eraseMacroScopes.isAtomic $ throwError "invalid pattern variable, must be atomic";
-s ← get;
-when (s.found.contains id) $ throwError ("invalid pattern, variable '" ++ id ++ "' occurred more than once");
-modify fun s => { s with vars := s.vars.push (PatternVar.localVar id), found := s.found.insert id }
-
--- HACK: inlining this function crashes the compiler
--- It produces "unknown free variable: _kernel_fresh.<some idx>"  at step `csimp.cpp`
-def processIdAuxAux (stx : Syntax) (mustBeCtor : Bool) (env : Environment) (f : Expr) : M Nat :=
-match f with
-| Expr.const fName _ _ => do
-  match env.find? fName with
-  | some $ ConstantInfo.ctorInfo val => liftM $ getNumExplicitCtorParams val
-  | some $ info =>
-    if hasMatchPatternAttribute env fName then pure 0
-    else do processVar stx.getId mustBeCtor; pure 0
-  | none => throwCtorExpected
-| _ => do processVar stx.getId mustBeCtor; pure 0
-
-/- Check whether `stx` is a pattern variable or constructor-like (i.e., constructor or constant tagged with `[matchPattern]` attribute)
-   If `mustBeCtor == true`, then `stx` cannot be a pattern variable.
-
-   If `stx` is a constructor, then return the number of explicit arguments that are inductive type parameters. -/
-private def processIdAux (stx : Syntax) (mustBeCtor : Bool) : M Nat :=
-withRef stx do
-env ← getEnv;
+def resolveId? (stx : Syntax) : M (Option Expr) :=
 match stx with
 | Syntax.ident _ _ val preresolved => do
   rs ← liftM $ catch (resolveName val preresolved []) (fun _ => pure []);
   let rs := rs.filter fun ⟨f, projs⟩ => projs.isEmpty;
   let fs := rs.map fun ⟨f, _⟩ => f;
   match fs with
-  | []  => do processVar stx.getId mustBeCtor; pure 0
-  | [f] => processIdAuxAux stx mustBeCtor env f
+  | []  => pure none
+  | [f] => pure (some f)
   | _   => throwAmbiguous fs
-| _ =>
-  if stx.isOfKind `Lean.Parser.Term.explicit then
-    throwError "identifier expected, '@' is not allowed in patterns"
-  else
-    throwError "identifier expected"
-
-private def processCtor (stx : Syntax) : M Nat :=
-processIdAux stx true
-
-private def processId (stx : Syntax) : M Unit := do
-_ ← processIdAux stx false; pure ()
+| _ => throwError "identifier expected"
 
 private def throwInvalidPattern {α} : M α :=
 throwError "invalid pattern"
 
+namespace CtorApp
+
+/-
+An application in a pattern can be
+
+1- A constructor application
+   The elaborator assumes fields are accessible and inductive parameters are not accessible.
+
+2- A regular application `(f ...)` where `f` is tagged with `[matchPattern]`.
+   The elaborator assumes implicit arguments are not accessible and explicit ones are accessible.
+-/
+
+structure Context :=
+(funId         : Syntax)
+(ctorVal?      : Option ConstructorVal) -- It is `some`, if constructor application
+(explicit      : Bool)
+(paramDecls    : Array LocalDecl)
+(paramDeclIdx  : Nat := 0)
+(namedArgs     : Array NamedArg)
+(args          : List Arg)
+(newArgs       : Array Syntax := #[])
+
+instance Context.inhabited : Inhabited Context :=
+⟨⟨arbitrary _, none, true, #[], 0, #[], [], #[]⟩⟩
+
+private def isDone (ctx : Context) : Bool :=
+ctx.paramDeclIdx ≥ ctx.paramDecls.size
+
+private def finalize (ctx : Context) : M Syntax :=
+if ctx.namedArgs.isEmpty && ctx.args.isEmpty then do
+  fStx ← `(@$(ctx.funId):ident);
+  pure $ mkAppStx fStx ctx.newArgs
+else
+  throwError "too many arguments"
+
+private def isNextArgAccessible (ctx : Context) : Bool :=
+let i := ctx.paramDeclIdx;
+match ctx.ctorVal? with
+| some ctorVal => i ≥ ctorVal.nparams -- For constructor applications only fields are accessible
+| none =>
+  if h : i < ctx.paramDecls.size then
+    -- For `[matchPattern]` applications, only explicit parameters are accessible.
+    let d := ctx.paramDecls.get ⟨i, h⟩;
+    d.binderInfo.isExplicit
+  else
+    false
+
+private def getNextParam (ctx : Context) : LocalDecl × Context :=
+let i := ctx.paramDeclIdx;
+let d := ctx.paramDecls.get! i;
+(d, { ctx with paramDeclIdx := ctx.paramDeclIdx + 1 })
+
+private def pushNewArg (collect : Syntax → M Syntax) (accessible : Bool) (ctx : Context) (arg : Arg) : M Context :=
+match arg with
+| Arg.stx stx => do
+  stx ← if accessible then collect stx else pure stx;
+  pure { ctx with newArgs := ctx.newArgs.push stx }
+| _           => unreachable!
+
+private def processExplicitArg (collect : Syntax → M Syntax) (accessible : Bool) (ctx : Context) : M Context :=
+match ctx.args with
+| [] =>
+  -- TODO: add support for `..`
+  throwError ("explicit parameter is missing, unused named arguments " ++ toString (ctx.namedArgs.map $ fun narg => narg.name))
+| arg::args => do
+  let ctx := { ctx with args := args };
+  pushNewArg collect accessible ctx arg
+
+private def processImplicitArg (collect : Syntax → M Syntax) (accessible : Bool) (ctx : Context) : M Context :=
+if ctx.explicit then
+  processExplicitArg collect accessible ctx
+else do
+  hole ← `(_);
+  pushNewArg collect accessible ctx (Arg.stx hole)
+
+private partial def processCtorAppAux (collect : Syntax → M Syntax) : Context → M Syntax
+| ctx =>
+  if isDone ctx then finalize ctx
+  else
+    let accessible := isNextArgAccessible ctx;
+    let (d, ctx)   := getNextParam ctx;
+    match ctx.namedArgs.findIdx? (fun namedArg => namedArg.name == d.userName) with
+    | some idx => do
+      let arg := ctx.namedArgs.get! idx;
+      let ctx := { ctx with namedArgs := ctx.namedArgs.eraseIdx idx };
+      ctx ← pushNewArg collect accessible ctx arg.val;
+      processCtorAppAux ctx
+    | none => do
+      ctx ← match d.binderInfo with
+      | BinderInfo.implicit     => processImplicitArg collect accessible ctx
+      | BinderInfo.instImplicit => processImplicitArg collect accessible ctx
+      | _                       => processExplicitArg collect accessible ctx;
+      processCtorAppAux ctx
+
+def processCtorApp (collect : Syntax → M Syntax) (f : Syntax) (namedArgs : Array NamedArg) (args : Array Arg) : M Syntax := do
+let args := args.toList;
+(fId, explicit) ← match_syntax f with
+| `($fId:ident)  => pure (fId, false)
+| `(@$fId:ident) => pure (fId, true)
+| _              => throwError "identifier expected";
+some (Expr.const fName _ _) ← resolveId? fId | throwCtorExpected;
+fInfo ← getConstInfo fName;
+forallTelescopeReducing fInfo.type fun xs _ => do
+paramDecls ← xs.mapM getFVarLocalDecl;
+match fInfo with
+| ConstantInfo.ctorInfo val =>
+  processCtorAppAux collect { funId := fId, explicit := explicit, ctorVal? := val, paramDecls := paramDecls, namedArgs := namedArgs, args := args }
+| _ => do
+  env ← getEnv;
+  if hasMatchPatternAttribute env fName then
+    processCtorAppAux collect { funId := fId, explicit := explicit, ctorVal? := none, paramDecls := paramDecls, namedArgs := namedArgs, args := args }
+  else
+    throwCtorExpected
+
+end CtorApp
+
+def processCtorApp (collect : Syntax → M Syntax) (stx : Syntax) : M Syntax := do
+(f, namedArgs, args) ← liftM $ expandApp stx;
+CtorApp.processCtorApp collect f namedArgs args
+
+def processCtor (collect : Syntax → M Syntax) (stx : Syntax) : M Syntax := do
+CtorApp.processCtorApp collect stx #[] #[]
+
+private def processVar (idStx : Syntax) : M Syntax := do
+unless idStx.isIdent $
+  throwErrorAt idStx "identifier expected";
+let id := idStx.getId;
+unless id.eraseMacroScopes.isAtomic $ throwError "invalid pattern variable, must be atomic";
+s ← get;
+when (s.found.contains id) $ throwError ("invalid pattern, variable '" ++ id ++ "' occurred more than once");
+modify fun s => { s with vars := s.vars.push (PatternVar.localVar id), found := s.found.insert id };
+pure idStx
+
+/- Check whether `stx` is a pattern variable or constructor-like (i.e., constructor or constant tagged with `[matchPattern]` attribute) -/
+private def processId (collect : Syntax → M Syntax) (stx : Syntax) : M Syntax := do
+env ← getEnv;
+f? ← resolveId? stx;
+match f? with
+| none   => processVar stx
+| some f => match f with
+  | Expr.const fName _ _ => do
+    match env.find? fName with
+    | some (ConstantInfo.ctorInfo _) => processCtor collect stx
+    | some _ =>
+      if hasMatchPatternAttribute env fName then
+        processCtor collect stx
+      else
+        processVar stx
+    | none => throwCtorExpected
+  | _ => processVar stx
+
 private partial def collect : Syntax → M Syntax
 | stx@(Syntax.node k args) => withRef stx $ withFreshMacroScope $
   if k == `Lean.Parser.Term.app then do
-    let appFn   := args.get! 0;
-    let appArgs := (args.get! 1).getArgs;
-    appArgs.forM fun appArg =>
-      when (appArg.isOfKind `Lean.Parser.Term.namedPattern) $
-        throwErrorAt appArg "named parameters are not allowed in patterns";
-    /- We must skip explict inducitve datatype parameters since they are by defaul inaccessible.
-       Example: `A` is inaccessible term at `Sum.inl A b` -/
-    numArgsToSkip ← processCtor appFn;
-    appArgs ← appArgs.mapIdxM fun i arg => if i < numArgsToSkip then pure arg else collect arg;
-    pure $ Syntax.node k $ args.set! 1 (mkNullNode appArgs)
+    processCtorApp collect stx
   else if k == `Lean.Parser.Term.anonymousCtor then do
     elems ← (args.get! 1).getArgs.mapSepElemsM $ collect;
     pure $ Syntax.node k $ args.set! 1 $ mkNullNode elems
@@ -290,13 +397,12 @@ private partial def collect : Syntax → M Syntax
         let arg       := arg.setArg 1 s;
         pure $ Syntax.node k $ args.set! 1 arg
   else if k == `Lean.Parser.Term.explicitUniv then do
-    _ ← processCtor (stx.getArg 0);
-    pure stx
+    processCtor collect (stx.getArg 0)
   else if k == `Lean.Parser.Term.namedPattern then do
     /- Recall that
        def namedPattern := check... >> tparser! "@" >> termParser -/
     let id := stx.getArg 0;
-    processVar id.getId;
+    processVar id;
     let pat := stx.getArg 2;
     pat ← collect pat;
     `(namedPattern $id $pat)
@@ -312,9 +418,8 @@ private partial def collect : Syntax → M Syntax
     throwError "invalid pattern, notation is ambiguous"
   else
     throwInvalidPattern
-| stx@(Syntax.ident _ _ _ _) => do
-  processId stx;
-  pure stx
+| stx@(Syntax.ident _ _ _ _) =>
+  processId collect stx
 | stx =>
   throwInvalidPattern
 
@@ -353,7 +458,7 @@ private partial def withPatternVarsAux {α} (pVars : Array PatternVar) (k : Arra
         withPatternVarsAux (i+1) (decls.push (PatternVarDecl.localVar x.fvarId!))
   else do
     /- We must create the metavariables for `PatternVar.anonymousVar` AFTER we create the new local decls using `withLocalDecl`.
-       Reason: their scope must include the new local decls since some of them will be assigned by typing constraints. -/
+       Reason: their scope must include the new local decls since some of them are assigned by typing constraints. -/
     decls.forM fun decl => match decl with
       | PatternVarDecl.anonymousVar mvarId fvarId => do
         type ← inferType (mkFVar fvarId);
@@ -388,7 +493,7 @@ patternVarDecls.foldlM
       pure $ decls.push decl
     | PatternVarDecl.anonymousVar mvarId fvarId => do
       e ← instantiateMVars (mkMVar mvarId);
-      trace `Elab.match fun _ => "finalizePatternDecls: mvarId: " ++ mkMVar mvarId ++ " := " ++ e ++ ", fvarId: " ++ mkFVar fvarId;
+      trace `Elab.match fun _ => "finalizePatternDecls: mvarId: " ++ mvarId ++ " := " ++ e ++ ", fvarId: " ++ mkFVar fvarId;
       match e with
       | Expr.mvar newMVarId _ => do
         /- Metavariable was not assigned, or assigned to another metavariable. So,
@@ -422,14 +527,6 @@ modify $ fun s => { s with found := s.found.insert fvarId }
 private def throwInvalidPattern {α} (e : Expr) : M α :=
 throwError ("invalid pattern " ++ indentExpr e)
 
-private def getFieldsBinderInfoAux (ctorVal : ConstructorVal) : Nat → Expr → Array BinderInfo → Array BinderInfo
-| i, Expr.forallE _ d b c, bis =>
-  if i < ctorVal.nparams then
-    getFieldsBinderInfoAux (i+1) b bis
-  else
-    getFieldsBinderInfoAux (i+1) b (bis.push c.binderInfo)
-| _, _, bis => bis
-
 /- Create a new LocalDecl `x` for the metavariable `mvar`, and return `Pattern.var x` -/
 private def mkLocalDeclFor (mvar : Expr) : M Pattern := do
 let mvarId := mvar.mvarId!;
@@ -454,9 +551,6 @@ match val? with
       | some i => s.localDecls.insertAt i newDecl };
   pure $ Pattern.var fvarId
 
-private def getFieldsBinderInfo (ctorVal : ConstructorVal) : Array BinderInfo :=
-getFieldsBinderInfoAux ctorVal 0 ctorVal.type #[]
-
 partial def main : Expr → M Pattern
 | e =>
   let isLocalDecl (fvarId : FVarId) : M Bool := do {
@@ -507,14 +601,7 @@ partial def main : Expr → M Pattern
       unless (args.size == v.nparams + v.nfields) $ throwInvalidPattern e;
       let params := args.extract 0 v.nparams;
       let fields := args.extract v.nparams args.size;
-      let binderInfos := getFieldsBinderInfo v;
-      fields ← fields.mapIdxM fun i field => do {
-        let binderInfo := binderInfos.get! i;
-        if binderInfo.isExplicit then
-          main field
-        else
-          mkInaccessible field
-      };
+      fields ← fields.mapM main;
       pure $ Pattern.ctor v.name us params.toList fields.toList
 
 end ToDepElimPattern
@@ -546,7 +633,6 @@ withPatternVars patternVars fun patternVarDecls => do
     let xs := altLHS.fvarDecls.toArray.map LocalDecl.toExpr;
     rhs ← if xs.isEmpty then pure $ mkThunk rhs else mkLambdaFVars xs rhs;
     trace `Elab.match fun _ => "rhs: " ++ rhs;
-    -- TODO: we should promote `.(?m ...)` to pattern variables too. This can happen when users misuse `{}` in constructors
     -- TODO: check whether altLHS still has metavariables
     pure (altLHS, rhs)
 

stage0/src/Lean/Elab/MutualDef.lean

@@ -74,7 +74,7 @@ if h : 0 < prevHeaders.size then
 else
   pure ()
 
-private def elabFunType (xs : Array Expr) (view : DefView) : TermElabM Expr :=
+private def elabFunType (ref : Syntax) (xs : Array Expr) (view : DefView) : TermElabM Expr :=
 match view.type? with
 | some typeStx => do
   type ← elabType typeStx;
@@ -82,7 +82,8 @@ match view.type? with
   type ← instantiateMVars type;
   mkForallFVars xs type
 | none => do
-  type ← withRef view.binders $ mkFreshTypeMVar;
+  let hole := mkHole ref;
+  type ← elabType hole;
   mkForallFVars xs type
 
 private def elabHeaders (views : Array DefView) : TermElabM (Array DefViewElabHeader) :=
@@ -93,7 +94,8 @@ views.foldlM
     ⟨shortDeclName, declName, levelNames⟩ ← expandDeclId currNamespace currLevelNames view.declId view.modifiers;
     applyAttributes declName view.modifiers.attrs AttributeApplicationTime.beforeElaboration;
     withLevelNames levelNames $ elabBinders view.binders.getArgs fun xs => do
-      type ← elabFunType xs view;
+      let refForElabFunType := view.value;
+      type ← elabFunType refForElabFunType xs view;
       let newHeader : DefViewElabHeader := {
         ref           := view.ref,
         modifiers     := view.modifiers,
@@ -423,6 +425,7 @@ private partial def mkClosureForAux : Array FVarId → StateRefT ClosureState Te
   match pickMaxFVar? lctx toProcess with
   | none        => pure ()
   | some fvarId => do
+    trace `Elab.definition.mkClosure fun _ => "toProcess: " ++ (toProcess.map mkFVar) ++ ", maxVar: " ++ mkFVar fvarId;
     let toProcess := toProcess.erase fvarId;
     localDecl ← getLocalDecl fvarId;
     match localDecl with
@@ -448,6 +451,13 @@ private partial def mkClosureForAux : Array FVarId → StateRefT ClosureState Te
         };
         mkClosureForAux (pushNewVars toProcess (collectFVars (collectFVars {} type) val))
 
+private partial def mkClosureFor (freeVars : Array FVarId) (localDecls : Array LocalDecl) : TermElabM ClosureState := do
+(_, s) ← (mkClosureForAux freeVars).run { localDecls := localDecls };
+pure { s with
+  newLocalDecls := s.newLocalDecls.reverse,
+  newLetDecls   := s.newLetDecls.reverse,
+  exprArgs      := s.exprArgs.reverse }
+
 structure LetRecClosure :=
 (localDecls : Array LocalDecl)
 (closed     : Expr) -- expression used to replace occurrences of the let-rec FVarId
@@ -459,7 +469,7 @@ withLCtx lctx toLift.localInstances do
 lambdaTelescope toLift.val fun xs val => do
   type ← instantiateForall toLift.type xs;
   lctx ← getLCtx;
-  (_, s) ← (mkClosureForAux freeVars).run { localDecls := xs.map fun x => lctx.get! x.fvarId! };
+  s ← mkClosureFor freeVars $ xs.map fun x => lctx.get! x.fvarId!;
   let type := Closure.mkForall s.localDecls $ Closure.mkForall s.newLetDecls type;
   let val  := Closure.mkLambda s.localDecls $ Closure.mkLambda s.newLetDecls val;
   let c    := mkAppN (Lean.mkConst toLift.declName) s.exprArgs;

stage0/src/Lean/Elab/PreDefinition.lean

@@ -3,195 +3,6 @@ Copyright (c) 2020 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura
 -/
-import Lean.Util.SCC
-import Lean.Elab.MkInhabitant
-import Lean.Elab.Term
-import Lean.Elab.DefView
-
-namespace Lean
-namespace Elab
-open Meta
-open Term
-
-/-
-A (potentially recursive) definition.
-The elaborator converts it into Kernel definitions using many different strategies.
--/
-structure PreDefinition :=
-(kind      : DefKind)
-(lparams   : List Name)
-(modifiers : Modifiers)
-(declName  : Name)
-(type      : Expr)
-(value     : Expr)
-
-instance PreDefinition.inhabited : Inhabited PreDefinition :=
-⟨⟨DefKind.«def», [], {}, arbitrary _, arbitrary _, arbitrary _⟩⟩
-
-def instantiateMVarsAtPreDecls (preDefs : Array PreDefinition) : TermElabM (Array PreDefinition) :=
-preDefs.mapM fun preDef => do
-  type  ← instantiateMVars preDef.type;
-  value ← instantiateMVars preDef.value;
-  pure { preDef with type := type, value := value }
-
-private def levelMVarToParamExpr (e : Expr) : StateRefT Nat TermElabM Expr := do
-nextIdx ← get;
-(e, nextIdx) ← liftM $ levelMVarToParam e nextIdx;
-set nextIdx;
-pure e
-
-private def levelMVarToParamPreDeclsAux (preDefs : Array PreDefinition) : StateRefT Nat TermElabM (Array PreDefinition) :=
-preDefs.mapM fun preDef => do
-  type  ← levelMVarToParamExpr preDef.type;
-  value ← levelMVarToParamExpr preDef.value;
-  pure { preDef with type := type, value := value }
-
-def levelMVarToParamPreDecls (preDefs : Array PreDefinition) : TermElabM (Array PreDefinition) :=
-(levelMVarToParamPreDeclsAux preDefs).run' 1
-
-private def collectLevelParamsExpr (e : Expr) : StateM CollectLevelParams.State Unit := do
-modify fun s => collectLevelParams s e
-
-private def getLevelParamsPreDecls (preDefs : Array PreDefinition) (scopeLevelNames allUserLevelNames : List Name) : TermElabM (List Name) :=
-let (_, s) := StateT.run
-  (preDefs.forM fun preDef => do {
-    collectLevelParamsExpr preDef.type;
-    collectLevelParamsExpr preDef.value })
-  {};
-match sortDeclLevelParams scopeLevelNames allUserLevelNames s.params with
-| Except.error msg      => throwError msg
-| Except.ok levelParams => pure levelParams
-
-private def shareCommon (preDefs : Array PreDefinition) : Array PreDefinition :=
-let result : Std.ShareCommonM (Array PreDefinition) :=
-  preDefs.mapM fun preDef => do {
-    type  ← Std.withShareCommon preDef.type;
-    value ← Std.withShareCommon preDef.value;
-    pure { preDef with type := type, value := value }
-  };
-result.run
-
-def fixLevelParams (preDefs : Array PreDefinition) (scopeLevelNames allUserLevelNames : List Name) : TermElabM (Array PreDefinition) := do
-let preDefs := shareCommon preDefs;
-lparams ← getLevelParamsPreDecls preDefs scopeLevelNames allUserLevelNames;
-let us := lparams.map mkLevelParam;
-let fixExpr (e : Expr) : Expr :=
-  e.replace fun c => match c with
-    | Expr.const declName _ _ => if preDefs.any fun preDef => preDef.declName == declName then some $ Lean.mkConst declName us else none
-    | _ => none;
-pure $ preDefs.map fun preDef =>
-  { preDef with
-    type    := fixExpr preDef.type,
-    value   := fixExpr preDef.value,
-    lparams := lparams }
-
-private def applyAttributesOf (preDefs : Array PreDefinition) (applicationTime : AttributeApplicationTime) : TermElabM Unit := do
-preDefs.forM fun preDef => applyAttributes preDef.declName preDef.modifiers.attrs applicationTime
-
-private def addNonRecAux (preDef : PreDefinition) (compile : Bool) : TermElabM Unit := do
-env ← getEnv;
-let decl :=
-  match preDef.kind with
-  | DefKind.«example» => unreachable!
-  | DefKind.«theorem» =>
-    Declaration.thmDecl { name := preDef.declName, lparams := preDef.lparams, type := preDef.type, value := preDef.value }
-  | DefKind.«opaque»  =>
-    Declaration.opaqueDecl { name := preDef.declName, lparams := preDef.lparams, type := preDef.type, value := preDef.value,
-                             isUnsafe := preDef.modifiers.isUnsafe }
-  | DefKind.«abbrev»  =>
-    Declaration.defnDecl { name := preDef.declName, lparams := preDef.lparams, type := preDef.type, value := preDef.value,
-                           hints := ReducibilityHints.«abbrev», isUnsafe := preDef.modifiers.isUnsafe }
-  | DefKind.«def»  =>
-    Declaration.defnDecl { name := preDef.declName, lparams := preDef.lparams, type := preDef.type, value := preDef.value,
-                           hints := ReducibilityHints.regular (getMaxHeight env preDef.value + 1),
-                           isUnsafe := preDef.modifiers.isUnsafe };
-ensureNoUnassignedMVars decl;
-addDecl decl;
-applyAttributesOf #[preDef] AttributeApplicationTime.afterTypeChecking;
-when compile $
-  compileDecl decl;
-applyAttributesOf #[preDef] AttributeApplicationTime.afterCompilation;
-pure ()
-
-private def addAndCompileNonRec (preDef : PreDefinition) : TermElabM Unit := do
-addNonRecAux preDef true
-
-private def addNonRec (preDef : PreDefinition) : TermElabM Unit := do
-addNonRecAux preDef false
-
-private def addAndCompileUnsafe (preDefs : Array PreDefinition) : TermElabM Unit := do
-let decl := Declaration.mutualDefnDecl $ preDefs.toList.map fun preDef => {
-    name     := preDef.declName,
-    lparams  := preDef.lparams,
-    type     := preDef.type,
-    value    := preDef.value,
-    isUnsafe := true,
-    hints    := ReducibilityHints.opaque
-  };
-ensureNoUnassignedMVars decl;
-addDecl decl;
-applyAttributesOf preDefs AttributeApplicationTime.afterTypeChecking;
-compileDecl decl;
-applyAttributesOf preDefs AttributeApplicationTime.afterCompilation;
-pure ()
-
-private def addAndCompileUnsafeRec (preDefs : Array PreDefinition) : TermElabM Unit := do
-addAndCompileUnsafe $ preDefs.map fun preDef =>
-  { preDef with
-    declName  := Compiler.mkUnsafeRecName preDef.declName,
-    value     := preDef.value.replace fun e => match e with
-      | Expr.const declName us _ =>
-        if preDefs.any fun preDef => preDef.declName == declName then
-          some $ mkConst (Compiler.mkUnsafeRecName declName) us
-        else
-          none
-      | _ => none,
-    modifiers := {} }
-
-private def addAndCompilePartial (preDefs : Array PreDefinition) : TermElabM Unit := do
-preDefs.forM fun preDef =>
-  forallTelescopeReducing preDef.type fun xs type => do
-    inh ← liftM $ mkInhabitantFor preDef.declName xs type;
-    addNonRec { preDef with
-      kind  := DefKind.«opaque»,
-      value := inh };
-addAndCompileUnsafeRec preDefs
-
-private def isNonRecursive (preDef : PreDefinition) : Bool :=
-Option.isNone $ preDef.value.find? fun c => match c with
-  | Expr.const declName _ _ => preDef.declName == declName
-  | _ => false
-
-private def partitionPreDefs (preDefs : Array PreDefinition) : Array (Array PreDefinition) :=
-let getPreDef    := fun declName => (preDefs.find? fun preDef => preDef.declName == declName).get!;
-let vertices     := preDefs.toList.map fun preDef => preDef.declName;
-let successorsOf := fun declName => (getPreDef declName).value.foldConsts [] fun declName successors =>
-  if preDefs.any fun preDef => preDef.declName == declName then
-    declName :: successors
-  else
-    successors;
-let sccs := SCC.scc vertices successorsOf;
-sccs.toArray.map fun scc => scc.toArray.map getPreDef
-
-private def tryStructuralRecursion? (preDef : PreDefinition) : TermElabM (Option PreDefinition) := do
-trace `Elab.definition fun _ => preDef.declName ++ ":=\n" ++ preDef.value;
-throwError "WIP"
-
-def addPreDefinitions (preDefs : Array PreDefinition) : TermElabM Unit := do
-preDefs.forM fun preDef => trace `Elab.definition.body fun _ => preDef.declName ++ " : " ++ preDef.type ++ " :=" ++ Format.line ++ preDef.value;
-(partitionPreDefs preDefs).forM fun preDefs => do
-  if preDefs.size == 1 && isNonRecursive (preDefs.get! 0) then
-    addAndCompileNonRec (preDefs.get! 0)
-  else if preDefs.any fun preDef => preDef.modifiers.isUnsafe then
-    addAndCompileUnsafe preDefs
-  else if preDefs.any fun preDef => preDef.modifiers.isPartial then
-    addAndCompilePartial preDefs
-  else if preDefs.size == 1 then do
-    tryStructuralRecursion? (preDefs.get! 0);
-    pure ()
-  else
-    -- TODO
-    throwError "WIP"
-
-end Elab
-end Lean
+import Lean.Elab.PreDefinition.Basic
+import Lean.Elab.PreDefinition.Structural
+import Lean.Elab.PreDefinition.Main

stage0/src/Lean/Elab/PreDefinition/Basic.lean

@@ -0,0 +1,158 @@
+/-
+Copyright (c) 2020 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Util.SCC
+import Lean.Meta.AbstractNestedProofs
+import Lean.Elab.MkInhabitant
+import Lean.Elab.Term
+import Lean.Elab.DefView
+
+namespace Lean
+namespace Elab
+open Meta
+open Term
+
+/-
+A (potentially recursive) definition.
+The elaborator converts it into Kernel definitions using many different strategies.
+-/
+structure PreDefinition :=
+(kind      : DefKind)
+(lparams   : List Name)
+(modifiers : Modifiers)
+(declName  : Name)
+(type      : Expr)
+(value     : Expr)
+
+instance PreDefinition.inhabited : Inhabited PreDefinition :=
+⟨⟨DefKind.«def», [], {}, arbitrary _, arbitrary _, arbitrary _⟩⟩
+
+def instantiateMVarsAtPreDecls (preDefs : Array PreDefinition) : TermElabM (Array PreDefinition) :=
+preDefs.mapM fun preDef => do
+  type  ← instantiateMVars preDef.type;
+  value ← instantiateMVars preDef.value;
+  pure { preDef with type := type, value := value }
+
+private def levelMVarToParamExpr (e : Expr) : StateRefT Nat TermElabM Expr := do
+nextIdx ← get;
+(e, nextIdx) ← liftM $ levelMVarToParam e nextIdx;
+set nextIdx;
+pure e
+
+private def levelMVarToParamPreDeclsAux (preDefs : Array PreDefinition) : StateRefT Nat TermElabM (Array PreDefinition) :=
+preDefs.mapM fun preDef => do
+  type  ← levelMVarToParamExpr preDef.type;
+  value ← levelMVarToParamExpr preDef.value;
+  pure { preDef with type := type, value := value }
+
+def levelMVarToParamPreDecls (preDefs : Array PreDefinition) : TermElabM (Array PreDefinition) :=
+(levelMVarToParamPreDeclsAux preDefs).run' 1
+
+private def collectLevelParamsExpr (e : Expr) : StateM CollectLevelParams.State Unit := do
+modify fun s => collectLevelParams s e
+
+private def getLevelParamsPreDecls (preDefs : Array PreDefinition) (scopeLevelNames allUserLevelNames : List Name) : TermElabM (List Name) :=
+let (_, s) := StateT.run
+  (preDefs.forM fun preDef => do {
+    collectLevelParamsExpr preDef.type;
+    collectLevelParamsExpr preDef.value })
+  {};
+match sortDeclLevelParams scopeLevelNames allUserLevelNames s.params with
+| Except.error msg      => throwError msg
+| Except.ok levelParams => pure levelParams
+
+private def shareCommon (preDefs : Array PreDefinition) : Array PreDefinition :=
+let result : Std.ShareCommonM (Array PreDefinition) :=
+  preDefs.mapM fun preDef => do {
+    type  ← Std.withShareCommon preDef.type;
+    value ← Std.withShareCommon preDef.value;
+    pure { preDef with type := type, value := value }
+  };
+result.run
+
+def fixLevelParams (preDefs : Array PreDefinition) (scopeLevelNames allUserLevelNames : List Name) : TermElabM (Array PreDefinition) := do
+let preDefs := shareCommon preDefs;
+lparams ← getLevelParamsPreDecls preDefs scopeLevelNames allUserLevelNames;
+let us := lparams.map mkLevelParam;
+let fixExpr (e : Expr) : Expr :=
+  e.replace fun c => match c with
+    | Expr.const declName _ _ => if preDefs.any fun preDef => preDef.declName == declName then some $ Lean.mkConst declName us else none
+    | _ => none;
+pure $ preDefs.map fun preDef =>
+  { preDef with
+    type    := fixExpr preDef.type,
+    value   := fixExpr preDef.value,
+    lparams := lparams }
+
+def applyAttributesOf (preDefs : Array PreDefinition) (applicationTime : AttributeApplicationTime) : TermElabM Unit := do
+preDefs.forM fun preDef => applyAttributes preDef.declName preDef.modifiers.attrs applicationTime
+
+def abstractNestedProofs (preDef : PreDefinition) : MetaM PreDefinition :=
+if preDef.kind.isTheorem || preDef.kind.isExample then pure preDef
+else do
+  value ← Meta.abstractNestedProofs preDef.declName preDef.value;
+  pure { preDef with value := value }
+
+private def addNonRecAux (preDef : PreDefinition) (compile : Bool) : TermElabM Unit := do
+preDef ← liftM $ abstractNestedProofs preDef;
+env ← getEnv;
+let decl :=
+  match preDef.kind with
+  | DefKind.«example» => unreachable!
+  | DefKind.«theorem» =>
+    Declaration.thmDecl { name := preDef.declName, lparams := preDef.lparams, type := preDef.type, value := preDef.value }
+  | DefKind.«opaque»  =>
+    Declaration.opaqueDecl { name := preDef.declName, lparams := preDef.lparams, type := preDef.type, value := preDef.value,
+                             isUnsafe := preDef.modifiers.isUnsafe }
+  | DefKind.«abbrev»  =>
+    Declaration.defnDecl { name := preDef.declName, lparams := preDef.lparams, type := preDef.type, value := preDef.value,
+                           hints := ReducibilityHints.«abbrev», isUnsafe := preDef.modifiers.isUnsafe }
+  | DefKind.«def»  =>
+    Declaration.defnDecl { name := preDef.declName, lparams := preDef.lparams, type := preDef.type, value := preDef.value,
+                           hints := ReducibilityHints.regular (getMaxHeight env preDef.value + 1),
+                           isUnsafe := preDef.modifiers.isUnsafe };
+addDecl decl;
+applyAttributesOf #[preDef] AttributeApplicationTime.afterTypeChecking;
+when (compile && !preDef.kind.isTheorem) $
+  compileDecl decl;
+applyAttributesOf #[preDef] AttributeApplicationTime.afterCompilation;
+pure ()
+
+def addAndCompileNonRec (preDef : PreDefinition) : TermElabM Unit := do
+addNonRecAux preDef true
+
+def addNonRec (preDef : PreDefinition) : TermElabM Unit := do
+addNonRecAux preDef false
+
+def addAndCompileUnsafe (preDefs : Array PreDefinition) : TermElabM Unit := do
+let decl := Declaration.mutualDefnDecl $ preDefs.toList.map fun preDef => {
+    name     := preDef.declName,
+    lparams  := preDef.lparams,
+    type     := preDef.type,
+    value    := preDef.value,
+    isUnsafe := true,
+    hints    := ReducibilityHints.opaque
+  };
+addDecl decl;
+applyAttributesOf preDefs AttributeApplicationTime.afterTypeChecking;
+compileDecl decl;
+applyAttributesOf preDefs AttributeApplicationTime.afterCompilation;
+pure ()
+
+def addAndCompileUnsafeRec (preDefs : Array PreDefinition) : TermElabM Unit := do
+addAndCompileUnsafe $ preDefs.map fun preDef =>
+  { preDef with
+    declName  := Compiler.mkUnsafeRecName preDef.declName,
+    value     := preDef.value.replace fun e => match e with
+      | Expr.const declName us _ =>
+        if preDefs.any fun preDef => preDef.declName == declName then
+          some $ mkConst (Compiler.mkUnsafeRecName declName) us
+        else
+          none
+      | _ => none,
+    modifiers := {} }
+
+end Elab
+end Lean

stage0/src/Lean/Elab/PreDefinition/Main.lean

@@ -0,0 +1,67 @@
+/-
+Copyright (c) 2020 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Elab.PreDefinition.Basic
+import Lean.Elab.PreDefinition.Structural
+import Lean.Elab.PreDefinition.WF
+
+namespace Lean
+namespace Elab
+open Meta
+open Term
+
+private def addAndCompilePartial (preDefs : Array PreDefinition) : TermElabM Unit := do
+preDefs.forM fun preDef =>
+  forallTelescopeReducing preDef.type fun xs type => do
+    inh ← liftM $ mkInhabitantFor preDef.declName xs type;
+    addNonRec { preDef with
+      kind  := DefKind.«opaque»,
+      value := inh };
+addAndCompileUnsafeRec preDefs
+
+private def isNonRecursive (preDef : PreDefinition) : Bool :=
+Option.isNone $ preDef.value.find? fun c => match c with
+  | Expr.const declName _ _ => preDef.declName == declName
+  | _ => false
+
+private def partitionPreDefs (preDefs : Array PreDefinition) : Array (Array PreDefinition) :=
+let getPreDef    := fun declName => (preDefs.find? fun preDef => preDef.declName == declName).get!;
+let vertices     := preDefs.toList.map fun preDef => preDef.declName;
+let successorsOf := fun declName => (getPreDef declName).value.foldConsts [] fun declName successors =>
+  if preDefs.any fun preDef => preDef.declName == declName then
+    declName :: successors
+  else
+    successors;
+let sccs := SCC.scc vertices successorsOf;
+sccs.toArray.map fun scc => scc.toArray.map getPreDef
+
+private def collectMVarsAtPreDef (preDef : PreDefinition) : StateRefT CollectMVars.State MetaM Unit := do
+collectMVars preDef.value;
+collectMVars preDef.type
+
+private def getMVarsAtPreDef (preDef : PreDefinition) : MetaM (Array MVarId) := do
+(_, s) ← (collectMVarsAtPreDef preDef).run {};
+pure s.result
+
+private def ensureNoUnassignedMVarsAtPreDef (preDef : PreDefinition) : TermElabM Unit := do
+pendingMVarIds ← liftMetaM $ getMVarsAtPreDef preDef;
+foundError ← logUnassignedUsingErrorContext pendingMVarIds;
+when foundError throwAbort
+
+def addPreDefinitions (preDefs : Array PreDefinition) : TermElabM Unit := do
+preDefs.forM fun preDef => trace `Elab.definition.body fun _ => preDef.declName ++ " : " ++ preDef.type ++ " :=" ++ Format.line ++ preDef.value;
+preDefs.forM ensureNoUnassignedMVarsAtPreDef;
+(partitionPreDefs preDefs).forM fun preDefs => do
+  if preDefs.size == 1 && isNonRecursive (preDefs.get! 0) then
+    addAndCompileNonRec (preDefs.get! 0)
+  else if preDefs.any fun preDef => preDef.modifiers.isUnsafe then
+    addAndCompileUnsafe preDefs
+  else if preDefs.any fun preDef => preDef.modifiers.isPartial then
+    addAndCompilePartial preDefs
+  else unlessM (structuralRecursion preDefs) do
+    WFRecursion preDefs
+
+end Elab
+end Lean

stage0/src/Lean/Elab/PreDefinition/Structural.lean

@@ -0,0 +1,143 @@
+/-
+Copyright (c) 2020 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Util.ForEachExpr
+import Lean.Meta.RecursorInfo
+import Lean.Elab.PreDefinition.Basic
+
+namespace Lean
+namespace Elab
+open Meta
+
+private def getFixedPrefix (declName : Name) (xs : Array Expr) (value : Expr) : Nat :=
+let visitor {ω} : StateRefT Nat (ST ω) Unit :=
+  value.forEach' fun e =>
+    if e.isAppOf declName then do
+      let args := e.getAppArgs;
+      modify fun numFixed => if args.size < numFixed then args.size else numFixed;
+      -- we continue searching if the e's arguments are not a prefix of `xs`
+      pure !args.isPrefixOf xs
+    else
+      pure true;
+runST fun _ => do (_, numFixed) ← visitor.run xs.size; pure numFixed
+
+structure RecArgInfo :=
+/- `fixedParams ++ ys` are the arguments of the function we are trying to justify termination using structural recursion. -/
+(fixedParams : Array Expr)
+(ys          : Array Expr) -- recursion arguments
+(pos         : Nat)        -- position in `ys` of the argument we are recursing on
+(indicesPos  : Array Nat)  -- position in `ys` of the inductive datatype indices we are recursing on
+(reflexive   : Bool)       -- true if we are recursing over a reflexive inductive datatype
+
+private def getIndexMinPos (xs : Array Expr) (indices : Array Expr) : Nat :=
+indices.foldl
+  (fun minPos index => match xs.indexOf index with
+    | some pos => if pos.val < minPos then pos.val else minPos
+    | _        => minPos)
+  xs.size
+
+-- Indices can only depend on other indices
+private def hasBadIndexDep? (ys : Array Expr) (indices : Array Expr) : TermElabM (Option (Expr × Expr)) :=
+indices.findSomeM? fun index => do
+  indexType ← inferType index;
+  ys.findSomeM? fun y =>
+    if indices.contains y then pure none
+    else condM (dependsOn indexType y.fvarId!)
+      (pure (some (index, y)))
+      (pure none)
+
+-- Inductive datatype parameters cannot depend on ys
+private def hasBadParamDep? (ys : Array Expr) (indParams : Array Expr) : TermElabM (Option (Expr × Expr)) :=
+indParams.findSomeM? fun p => do
+  pType ← inferType p;
+  ys.findSomeM? fun y =>
+    condM (dependsOn pType y.fvarId!)
+      (pure (some (p, y)))
+      (pure none)
+
+private partial def findRecArgAux? {α} (numFixed : Nat) (xs : Array Expr) (k? : RecArgInfo → TermElabM (Option α)) : Nat → TermElabM (Option α)
+| i =>
+  if h : i < xs.size then do
+    let x := xs.get ⟨i, h⟩;
+    localDecl ← getFVarLocalDecl x;
+    if localDecl.isLet then pure none
+    else do
+      xType ← whnfD localDecl.type;
+      matchConstInduct xType.getAppFn (fun _ => findRecArgAux? (i+1)) fun indInfo us => do
+      condM (not <$> hasConst (mkBRecOnFor indInfo.name)) (findRecArgAux? (i+1)) do
+      condM (do hasBInductionOn ← hasConst (mkBInductionOnFor indInfo.name); pure $ indInfo.isReflexive && !hasBInductionOn) (findRecArgAux? (i+1)) do
+        let indArgs    := xType.getAppArgs;
+        let indParams  := indArgs.extract 0 indInfo.nparams;
+        let indIndices := indArgs.extract indInfo.nparams indArgs.size;
+        if !indIndices.all Expr.isFVar then do
+          trace `Elab.definition.structural fun _ =>
+            "argument #" ++ toString (i+1) ++ " was not used because its type is an inductive family and indices are not variables" ++ indentExpr xType;
+          findRecArgAux? (i+1)
+        else if !indIndices.allDiff then do
+          trace `Elab.definition.structural fun _ =>
+            "argument #" ++ toString (i+1) ++ " was not used because its type is an inductive family and indices are not pairwise distinct" ++ indentExpr xType;
+          findRecArgAux? (i+1)
+        else do
+          let indexMinPos := getIndexMinPos xs indIndices;
+          let numFixed    := if indexMinPos < numFixed then indexMinPos else numFixed;
+          let fixedParams := xs.extract 0 numFixed;
+          let ys          := xs.extract numFixed xs.size;
+          badDep? ← hasBadIndexDep? ys indIndices;
+          match badDep? with
+          | some (index, y) => do
+            trace `Elab.definition.structural fun _ =>
+              "argument #" ++ toString (i+1) ++ " was not used because its type is an inductive family" ++ indentExpr xType ++
+              Format.line ++ "and index" ++ indentExpr index ++
+              Format.line ++ "depends on the non index" ++ indentExpr y;
+            findRecArgAux? (i+1)
+          | none => do
+            badDep? ← hasBadParamDep? ys indParams;
+            match badDep? with
+            | some (indParam, y) => do
+              trace `Elab.definition.structural fun _ =>
+                "argument #" ++ toString (i+1) ++ " was not used because its type is an inductive datatype" ++ indentExpr xType ++
+                Format.line ++ "and parameter" ++ indentExpr indParam ++
+                Format.line ++ "depends on" ++ indentExpr y;
+              findRecArgAux? (i+1)
+            | none => do
+              let indicesPos := indIndices.map fun index => match ys.indexOf index with | some i => i.val | none => unreachable!;
+              a? ← k? { fixedParams := fixedParams, ys := ys, pos := i - fixedParams.size, indicesPos := indicesPos, reflexive := indInfo.isReflexive };
+              match a? with
+              | some a => pure a
+              | none   => findRecArgAux? (i+1)
+  else
+    pure none
+
+@[inline] private def findRecArg? {α} (numFixed : Nat) (xs : Array Expr) (k? : RecArgInfo → TermElabM (Option α)) : TermElabM (Option α) :=
+findRecArgAux? numFixed xs k? numFixed
+
+private def elimRecursion? (preDef : PreDefinition) : TermElabM (Option PreDefinition) :=
+lambdaLetTelescope preDef.value fun xs value => do
+  trace `Elab.definition.structural fun _ => preDef.declName ++ " " ++ xs ++ " :=\n" ++ value;
+  let numFixed := getFixedPrefix preDef.declName xs value;
+  findRecArg? numFixed xs fun argInfo => do
+    -- TODO
+    trace `Elab.definition.structural fun _ =>
+      "try " ++ argInfo.fixedParams ++ " " ++ argInfo.ys ++ " " ++ toString argInfo.pos ++ ", " ++ toString argInfo.indicesPos;
+    pure none
+
+def structuralRecursion (preDefs : Array PreDefinition) : TermElabM Bool :=
+if preDefs.size != 1 then
+  pure false
+else do
+  preDefNonRec? ← elimRecursion? (preDefs.get! 0);
+  match preDefNonRec? with
+  | none => pure false
+  | some preDefNonRec => do
+    addNonRec preDefNonRec;
+    addAndCompileUnsafeRec preDefs;
+    pure true
+
+@[init] private def regTraceClasses : IO Unit := do
+registerTraceClass `Elab.definition.structural;
+pure ()
+
+end Elab
+end Lean

stage0/src/Lean/Elab/PreDefinition/WF.lean

@@ -0,0 +1,16 @@
+/-
+Copyright (c) 2020 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Elab.PreDefinition.Basic
+
+namespace Lean
+namespace Elab
+open Meta
+
+def WFRecursion (preDefs : Array PreDefinition) : TermElabM Unit :=
+throwError "WIP"
+
+end Elab
+end Lean

stage0/src/Lean/Elab/Term.lean

@@ -939,20 +939,11 @@ u ← mkFreshLevelMVar;
 type ← elabTerm stx (mkSort u);
 withRef stx $ ensureType type
 
-private partial def mkAuxNameAux (env : Environment) (base : Name) : Nat → Name
-| i =>
-  let candidate := base.appendIndexAfter i;
-  if env.contains candidate then
-    mkAuxNameAux (i+1)
-  else
-    candidate
-
 def mkAuxName (suffix : Name) : TermElabM Name := do
-env ← getEnv;
 ctx ← read;
 match ctx.declName? with
 | none          => throwError "auxiliary declaration cannot be created when declaration name is not available"
-| some declName => pure $ mkAuxNameAux env (declName ++ suffix) 1
+| some declName => Lean.mkAuxName (declName ++ suffix) 1
 
 /- =======================================
        Builtin elaboration functions

stage0/src/Lean/Expr.lean

@@ -302,7 +302,7 @@ Expr.app f a $ mkData (mixHash 29 $ mixHash (hash f) (hash a))
   (f.hasLevelParam || a.hasLevelParam)
 
 def mkLambda (x : Name) (bi : BinderInfo) (t : Expr) (b : Expr) : Expr :=
-let x := x.eraseMacroScopes;
+-- let x := x.eraseMacroScopes;
 Expr.lam x t b $ mkDataForBinder (mixHash 31 $ mixHash (hash t) (hash b))
   (Nat.max t.looseBVarRange (b.looseBVarRange - 1))
   (t.hasFVar || b.hasFVar)
@@ -312,7 +312,7 @@ Expr.lam x t b $ mkDataForBinder (mixHash 31 $ mixHash (hash t) (hash b))
   bi
 
 def mkForall (x : Name) (bi : BinderInfo) (t : Expr) (b : Expr) : Expr :=
-let x := x.eraseMacroScopes;
+-- let x := x.eraseMacroScopes;
 Expr.forallE x t b $ mkDataForBinder (mixHash 37 $ mixHash (hash t) (hash b))
   (Nat.max t.looseBVarRange (b.looseBVarRange - 1))
   (t.hasFVar || b.hasFVar)
@@ -330,7 +330,7 @@ def mkThunk (type : Expr) : Expr :=
 mkLambda `_ BinderInfo.default (Lean.mkConst `Unit) type
 
 def mkLet (x : Name) (t : Expr) (v : Expr) (b : Expr) (nonDep : Bool := false) : Expr :=
-let x := x.eraseMacroScopes;
+-- let x := x.eraseMacroScopes;
 Expr.letE x t v b $ mkDataForLet (mixHash 41 $ mixHash (hash t) $ mixHash (hash v) (hash b))
   (Nat.max (Nat.max t.looseBVarRange v.looseBVarRange) (b.looseBVarRange - 1))
   (t.hasFVar || v.hasFVar || b.hasFVar)
@@ -680,6 +680,15 @@ instance : HasToString Expr :=
 instance : HasRepr Expr :=
 ⟨Expr.dbgToString⟩
 
+def isAtomic : Expr → Bool
+| Expr.const _ _ _ => true
+| Expr.sort _ _    => true
+| Expr.bvar _ _    => true
+| Expr.lit _ _     => true
+| Expr.mvar _ _    => true
+| Expr.fvar _ _    => true
+| _                => false
+
 end Expr
 
 def mkAppB (f a b : Expr) := mkApp (mkApp f a) b

stage0/src/Lean/LocalContext.lean

@@ -51,6 +51,10 @@ def type : LocalDecl → Expr
 | cdecl _ _ _ t _   => t
 | ldecl _ _ _ t _ _ => t
 
+def setType : LocalDecl → Expr → LocalDecl
+| cdecl idx id n _ bi, t   => cdecl idx id n t bi
+| ldecl idx id n _ v nd, t => ldecl idx id n t v nd
+
 def binderInfo : LocalDecl → BinderInfo
 | cdecl _ _ _ _ bi  => bi
 | ldecl _ _ _ _ _ _ => BinderInfo.default
@@ -63,6 +67,10 @@ def value : LocalDecl → Expr
 | cdecl _ _ _ _ _   => panic! "let declaration expected"
 | ldecl _ _ _ _ v _ => v
 
+def setValue : LocalDecl → Expr → LocalDecl
+| ldecl idx id n t _ nd, v => ldecl idx id n t v nd
+| d, _                     => d
+
 def updateUserName : LocalDecl → Name → LocalDecl
 | cdecl index id _ type bi,     userName => cdecl index id userName type bi
 | ldecl index id _ type val nd, userName => ldecl index id userName type val nd
@@ -214,16 +222,23 @@ match lctx with
     { fvarIdToDecl := map.insert decl.fvarId decl,
       decls        := decls.set decl.index decl }
 
-def updateBinderInfo (lctx : LocalContext) (fvarId : FVarId) (bi : BinderInfo) : LocalContext :=
+/--
+  Low-level function for updating the local context.
+  Assumptions about `f`, the resulting nested expressions must be definitionally equal to their original values,
+  the `index` nor `fvarId` are modified.  -/
+@[inline] def modifyLocalDecl (lctx : LocalContext) (fvarId : FVarId) (f : LocalDecl → LocalDecl) : LocalContext :=
 match lctx with
 | { fvarIdToDecl := map, decls := decls } =>
   match lctx.find? fvarId with
   | none      => lctx
   | some decl =>
-    let decl := decl.updateBinderInfo bi;
+    let decl := f decl;
     { fvarIdToDecl := map.insert decl.fvarId decl,
       decls        := decls.set decl.index decl }
 
+def updateBinderInfo (lctx : LocalContext) (fvarId : FVarId) (bi : BinderInfo) : LocalContext :=
+modifyLocalDecl lctx fvarId fun decl => decl.updateBinderInfo bi
+
 @[export lean_local_ctx_num_indices]
 def numIndices (lctx : LocalContext) : Nat :=
 lctx.decls.size

stage0/src/Lean/Meta.lean

@@ -22,3 +22,4 @@ import Lean.Meta.GeneralizeTelescope
 import Lean.Meta.Match
 import Lean.Meta.ReduceEval
 import Lean.Meta.Closure
+import Lean.Meta.AbstractNestedProofs

stage0/src/Lean/Meta/AbstractNestedProofs.lean

@@ -0,0 +1,67 @@
+/-
+Copyright (c) 2020 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Meta.Closure
+
+namespace Lean
+namespace Meta
+namespace AbstractNestedProofs
+
+def isNonTrivialProof (e : Expr) : MetaM Bool :=
+condM (not <$> isProof e) (pure false) $ e.withApp fun f args =>
+  pure $ !f.isAtomic || args.any fun arg => !arg.isAtomic
+
+structure Context :=
+(baseName : Name)
+
+structure State :=
+(nextIdx : Nat := 1)
+
+abbrev M := ReaderT Context $ MonadCacheT Expr Expr $ StateRefT State $ MetaM
+
+private def mkAuxLemma (e : Expr) : M Expr := do
+ctx ← read;
+s ← get;
+lemmaName ← mkAuxName (ctx.baseName ++ `proof) s.nextIdx;
+modify fun s => { s with nextIdx := s.nextIdx + 1 };
+mkAuxDefinitionFor lemmaName e
+
+partial def visit : Expr → M Expr
+| e =>
+  if e.isAtomic then pure e
+  else do
+    let visitBinders (xs : Array Expr) (k : M Expr) : M Expr := do {
+      localInstances ← getLocalInstances;
+      lctx ← getLCtx;
+      lctx ← xs.foldlM
+        (fun (lctx : LocalContext) x => do
+          let xFVarId := x.fvarId!;
+          localDecl ← getLocalDecl xFVarId;
+          type      ← visit localDecl.type;
+          let localDecl := localDecl.setType type;
+          localDecl ← match localDecl.value? with
+            | some value => do value ← visit value; pure $ localDecl.setValue value
+            | none       => pure localDecl;
+          pure $ lctx.modifyLocalDecl xFVarId fun _ => localDecl)
+        lctx;
+      withLCtx lctx localInstances k
+    };
+    checkCache e fun e => condM (liftM $ isNonTrivialProof e) (mkAuxLemma e) $ match e with
+    | Expr.lam _ _ _ _     => lambdaLetTelescope e fun xs b => visitBinders xs do b ← visit b; mkLambdaFVars xs b
+    | Expr.letE _ _ _ _ _  => lambdaLetTelescope e fun xs b => visitBinders xs do b ← visit b; mkLambdaFVars xs b
+    | Expr.forallE _ _ _ _ => forallTelescope e fun xs b => visitBinders xs do b ← visit b; mkForallFVars xs b
+    | Expr.mdata _ b _     => do b ← visit b; pure $ e.updateMData! b
+    | Expr.proj _ _ b _    => do b ← visit b; pure $ e.updateProj! b
+    | Expr.app _ _ _       => e.withApp fun f args => do args ← args.mapM visit; pure $ mkAppN f args
+    | _                    => pure e
+
+end AbstractNestedProofs
+
+/-- Replace proofs nested in `e` with new lemmas. The new lemmas have names of the form `mainDeclName.proof_<idx>` -/
+def abstractNestedProofs (mainDeclName : Name) (e : Expr) : MetaM Expr :=
+(((AbstractNestedProofs.visit e).run { baseName := mainDeclName }).run).run' { nextIdx := 1 }
+
+end Meta
+end Lean

stage0/src/Lean/Meta/Basic.lean

@@ -953,6 +953,11 @@ private partial def instantiateForallAux (ps : Array Expr) : Nat → Expr → Me
 def instantiateForall (e : Expr) (ps : Array Expr) : m Expr :=
 liftMetaM $ instantiateForallAux ps 0 e
 
+/-- Return true iff `e` depends on the free variable `fvarId` -/
+def dependsOn (e : Expr) (fvarId : FVarId) : m Bool := liftMetaM do
+mctx ← getMCtx;
+pure $ mctx.exprDependsOn e fvarId
+
 end Methods
 end Meta
 

stage0/src/Lean/Meta/RecursorInfo.lean

@@ -10,13 +10,15 @@ import Lean.Meta.ExprDefEq
 namespace Lean
 namespace Meta
 
-def casesOnSuffix := "casesOn"
-def recOnSuffix   := "recOn"
-def brecOnSuffix  := "brecOn"
+def casesOnSuffix       := "casesOn"
+def recOnSuffix         := "recOn"
+def brecOnSuffix        := "brecOn"
+def binductionOnSuffix  := "binductionOn"
 
 def mkCasesOnFor (indDeclName : Name) : Name := mkNameStr indDeclName casesOnSuffix
 def mkRecOnFor (indDeclName : Name) : Name   := mkNameStr indDeclName recOnSuffix
 def mkBRecOnFor (indDeclName : Name) : Name  := mkNameStr indDeclName brecOnSuffix
+def mkBInductionOnFor (indDeclName : Name) : Name  := mkNameStr indDeclName binductionOnSuffix
 
 inductive RecursorUnivLevelPos
 | motive                -- marks where the universe of the motive should go

stage0/src/Lean/MonadEnv.lean

@@ -43,7 +43,25 @@ matchConst e failK fun cinfo us =>
   | _                        => failK ()
 
 section
-variables [Monad m] [MonadError m]
+variables [Monad m]
+
+def hasConst (constName : Name) : m Bool := do
+env ← getEnv;
+pure $ env.contains constName
+
+private partial def mkAuxNameAux (env : Environment) (base : Name) : Nat → Name
+| i =>
+  let candidate := base.appendIndexAfter i;
+  if env.contains candidate then
+    mkAuxNameAux (i+1)
+  else
+    candidate
+
+def mkAuxName (baseName : Name) (idx : Nat) : m Name := do
+env ← getEnv;
+pure $ mkAuxNameAux env baseName idx
+
+variables [MonadError m]
 
 def getConstInfo (constName : Name) : m ConstantInfo := do
 env ← getEnv;

stage0/src/Lean/Parser/Term.lean

@@ -157,7 +157,8 @@ def bracketedDoSeq := parser! "{" >> doSeq >> "}"
 @[builtinTermParser] def uminus := parser!:65 "-" >> termParser 100
 
 def namedArgument  := parser! try ("(" >> ident >> " := ") >> termParser >> ")"
-@[builtinTermParser] def app      := tparser!:(maxPrec-1) many1 (checkWsBefore "expected space" >> (namedArgument <|> termParser maxPrec))
+def ellipsis       := parser! ".."
+@[builtinTermParser] def app      := tparser!:(maxPrec-1) many1 (checkWsBefore "expected space" >> (namedArgument <|> termParser maxPrec <|> ellipsis))
 
 @[builtinTermParser] def proj     := tparser! symbolNoWs "." >> (fieldIdx <|> ident)
 @[builtinTermParser] def arrow    := tparser! unicodeInfixR " → " " -> " 25

stage0/src/Lean/Util.lean

@@ -17,6 +17,7 @@ import Lean.Util.Sorry
 import Lean.Util.Trace
 import Lean.Util.FindExpr
 import Lean.Util.ReplaceExpr
+import Lean.Util.ForEachExpr
 import Lean.Util.ReplaceLevel
 import Lean.Util.FoldConsts
 import Lean.Util.Constructions

stage0/src/Lean/Util/ForEachExpr.lean

@@ -0,0 +1,39 @@
+/-
+Copyright (c) 2020 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Expr
+import Lean.Util.MonadCache
+
+namespace Lean
+/-
+Remark: we cannot use the caching trick used at `FindExpr` and `ReplaceExpr` because they
+may visit the same expression multiple times if they are stored in different memory
+addresses. Note that the following code is parametric in a monad `m`.
+-/
+
+variables {ω : Type} {m : Type → Type} [STWorld ω m] [MonadLiftT (ST ω) m] [Monad m]
+namespace ForEachExpr
+@[specialize] partial def visit (f : Expr → m Bool) : Expr → MonadCacheT Expr Unit m Unit
+| e => checkCache e fun e =>
+  condM (not <$> liftM (f e)) (pure ()) do
+    match e with
+    | Expr.forallE _ d b _   => do visit d; visit b
+    | Expr.lam _ d b _       => do visit d; visit b
+    | Expr.letE _ t v b _    => do visit t; visit v; visit b
+    | Expr.app f a _         => do visit f; visit a
+    | Expr.mdata _ b _       => visit b
+    | Expr.proj _ _ b _      => visit b
+    | _                      => pure ()
+
+end ForEachExpr
+
+/-- Apply `f` to each sub-expression of `e`. If `f t` return true, then t's children are not visited. -/
+@[inline] def Expr.forEach' (e : Expr) (f : Expr → m Bool) : m Unit :=
+(ForEachExpr.visit f e).run
+
+@[inline] def Expr.forEach (e : Expr) (f : Expr → m Unit) : m Unit :=
+e.forEach' fun e => do f e; pure true
+
+end Lean

stage0/src/Lean/Util/MonadCache.lean

@@ -52,6 +52,28 @@ instance {α β : Type} {m : Type → Type} [HasBeq α] [Hashable α] [Monad m]
 
 end MonadHashMapCacheAdapter
 
+def MonadCacheT {ω} (α β : Type) (m : Type → Type) [STWorld ω m] [HasBeq α] [Hashable α] := StateRefT (HashMap α β) m
+
+namespace MonadCacheT
+
+variables {ω α β : Type} {m : Type → Type} [STWorld ω m] [HasBeq α] [Hashable α] [MonadLiftT (ST ω) m] [Monad m]
+
+instance  : MonadHashMapCacheAdapter α β (MonadCacheT α β m) :=
+{ getCache    := (get : StateRefT _ _ _),
+  modifyCache := fun f => (modify f : StateRefT _ _ _) }
+
+@[inline] def run {σ} (x : MonadCacheT α β m σ) : m σ :=
+x.run' Std.mkHashMap
+
+instance : Monad (MonadCacheT α β m) := inferInstanceAs (Monad (StateRefT _ _))
+instance : MonadLift m (MonadCacheT α β m) := inferInstanceAs (MonadLift m (StateRefT _ _))
+instance [MonadIO m] : MonadIO (MonadCacheT α β m) := inferInstanceAs (MonadIO (StateRefT _ _))
+instance (ε) [MonadExceptOf ε m] : MonadExceptOf ε (MonadCacheT α β m) := inferInstanceAs (MonadExceptOf ε (StateRefT _ _))
+instance : MonadControl m (MonadCacheT α β m) := inferInstanceAs (MonadControl m (StateRefT _ _))
+instance [MonadFinally m] : MonadFinally (MonadCacheT α β m) := inferInstanceAs (MonadFinally (StateRefT _ _))
+
+end MonadCacheT
+
 /-- Auxiliary structure for "adding" a `HashMap` to a state object. -/
 structure WithHashMapCache (α β σ : Type) [HasBeq α] [Hashable α] :=
 (state : σ)

stage0/src/frontends/lean/pp.cpp

@@ -654,10 +654,18 @@ auto pretty_fn::pp_meta(expr const & e) -> result {
 */
 }
 
+
+extern "C" object * lean_simp_macro_scopes(object * n);
+
+name simp_macro_scopes(name const & n) {
+    return name(lean_simp_macro_scopes(n.to_obj_arg()));
+}
+
 auto pretty_fn::pp_fvar(expr const & e) -> result {
     if (optional<name> n0 = m_ctx.get_local_pp_name(e)) {
         name n = sanitize_if_fresh(*n0);
         n = sanitize_name_generator_name(n);
+        n = simp_macro_scopes(n);
         if (m_locals_full_names)
             return result(format("<") + format(n + local_name(e)) + format(">"));
         else
@@ -666,8 +674,12 @@ auto pretty_fn::pp_fvar(expr const & e) -> result {
     return format(fvar_name(e));
 }
 
+name s_local_pp_name(expr const & e) {
+    return simp_macro_scopes(local_pp_name(e));
+}
+
 auto pretty_fn::pp_local(expr const & e) -> result {
-    name n = sanitize_if_fresh(local_pp_name(e));
+    name n = sanitize_if_fresh(s_local_pp_name(e));
     n = sanitize_name_generator_name(n);
     if (m_locals_full_names)
         return result(format("<") + format(n + local_name(e)) + format(">"));
@@ -788,7 +800,7 @@ format pretty_fn::pp_binder(expr const & local) {
     auto bi = local_info(local);
     if (!is_default(bi))
         r += format(open_binder_string(bi, m_unicode));
-    r += escape(local_pp_name(local));
+    r += escape(s_local_pp_name(local));
     if (m_binder_types) {
         r += space();
         r += compose(format(":"), nest(m_indent, compose(line(), pp_child(local_type(local), 0).fmt())));
@@ -820,18 +832,18 @@ format pretty_fn::pp_binders(buffer<expr> const & locals) {
     expr local       = locals[0];
     expr   type      = local_type(local);
     binder_info bi   = local_info(local);
-    names.push_back(local_pp_name(local));
+    names.push_back(s_local_pp_name(local));
     format r;
     for (unsigned i = 1; i < num; i++) {
         expr local = locals[i];
         if (!is_inst_implicit(bi) && local_type(local) == type && local_info(local) == bi) {
-            names.push_back(local_pp_name(local));
+            names.push_back(s_local_pp_name(local));
         } else {
             r += group(compose(line(), pp_binder_block(names, type, bi)));
             names.clear();
             type = local_type(local);
             bi   = local_info(local);
-            names.push_back(local_pp_name(local));
+            names.push_back(s_local_pp_name(local));
         }
     }
     r += group(compose(line(), pp_binder_block(names, type, bi)));
@@ -897,7 +909,7 @@ auto pretty_fn::pp_have(expr const & e) -> result {
     auto p       = binding_body_fresh(binding, true);
     expr local   = p.second;
     expr body    = p.first;
-    name const & n = local_pp_name(local);
+    name const & n = s_local_pp_name(local);
     format type_fmt  = pp_child(local_type(local), 0).fmt();
     format proof_fmt = pp_child(proof, 0).fmt();
     format body_fmt  = pp_child(body, 0).fmt();
@@ -1052,7 +1064,7 @@ auto pretty_fn::pp_let(expr e) -> result {
     for (unsigned i = 0; i < sz; i++) {
         expr l, t, v;
         std::tie(l, t, v) = decls[i];
-        name const & n = local_pp_name(l);
+        name const & n = s_local_pp_name(l);
         format beg     = i == 0 ? space() : line();
         format sep     = i < sz - 1 ? format(",") : format();
         format entry   = format(n);
@@ -1480,7 +1492,7 @@ auto pretty_fn::pp_subtype(expr const & e) -> result {
     auto p     = binding_body_fresh(pred, true);
     expr body  = p.first;
     expr local = p.second;
-    format r   = bracket("{", format(local_pp_name(local)) + space() + format("//") + space() + pp_child(body, 0).fmt(), "}");
+    format r   = bracket("{", format(s_local_pp_name(local)) + space() + format("//") + space() + pp_child(body, 0).fmt(), "}");
     return result(r);
 }
 
@@ -1568,7 +1580,7 @@ auto pretty_fn::pp_sep(expr const & e) -> result {
     expr local = p.second;
     format in  = format(m_unicode ? "∈" : "in");
     format r   = bracket("{",
-                         format(local_pp_name(local)) + space() + in + space() +
+                         format(s_local_pp_name(local)) + space() + in + space() +
                          pp_child(s, 0).fmt() + space() + format("|") + space() +
                          pp_child(body, 0).fmt(), "}");
     return result(r);

stage0/stdlib/Init/Data/Array/Basic.c

@@ -23,6 +23,7 @@ lean_object* l_Array_anyRangeM___rarg(lean_object*, lean_object*, lean_object*,
 lean_object* lean_array_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_toListLitAux___main___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_getMax_x3f___rarg(lean_object*, lean_object*);
+lean_object* l_Array_isPrefixOf(lean_object*);
 lean_object* l_Array_foldl_u2082___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateM_u2082Aux___main(lean_object*, lean_object*);
 lean_object* l_Array_iterate_u2082(lean_object*, lean_object*, lean_object*);
@@ -51,6 +52,7 @@ lean_object* l_Array_anyRangeMAux___main___at_Array_allRangeM___spec__2(lean_obj
 lean_object* l_Array_findSome_x3f___rarg(lean_object*, lean_object*);
 lean_object* l_Array_mapIdxM(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Array_mapM___spec__1___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
+uint8_t l___private_Init_Data_Array_Basic_9__allDiffAux___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Array_anyRange___spec__2(lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Array_allM___spec__1___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t);
 lean_object* l_Array_toListLitAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -86,12 +88,14 @@ lean_object* l_Array_iterateMAux___main___at_Array_foldlFromM___spec__1___rarg(l
 lean_object* l___private_Init_Data_Array_Basic_4__foldrRangeMAux___main___at_Array_foldrRange___spec__2(lean_object*, lean_object*);
 lean_object* l_Array_extract___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Array_umapM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_isPrefixOfAux___main(lean_object*);
 lean_object* l_Array_findSomeMAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_filter(lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Array_foldr___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_1__swapAtPanic_x21___rarg___closed__3;
 lean_object* l_Array_insertAtAux___main(lean_object*);
 lean_object* l_Array_filterMapMAux___main___at_Array_filterMap___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Data_Array_Basic_8__allDiffAuxAux(lean_object*);
 lean_object* l_Array_findIdxM_x3f(lean_object*, lean_object*);
 lean_object* l_Array_iterateM_u2082Aux___main___at_Array_foldlM_u2082___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_empty___closed__1;
@@ -104,6 +108,7 @@ lean_object* l_Array_foldlStepMAux___main___at_Array_getEvenElems___spec__1___ra
 lean_object* l_Array_uget___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Array_foldlStep___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Array_foldlFrom___spec__1(lean_object*, lean_object*);
+lean_object* l___private_Init_Data_Array_Basic_9__allDiffAux___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlFrom(lean_object*, lean_object*);
 lean_object* l_Array_foldl___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t);
@@ -128,6 +133,7 @@ uint8_t l_Array_isEqvAux___rarg(lean_object*, lean_object*, lean_object*, lean_o
 lean_object* l_Array_findIdxMAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findRevMAux___main___at_Array_findRev_x3f___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findIdxAux___main___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Data_Array_Basic_8__allDiffAuxAux___main(lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Array_getEvenElems___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
@@ -212,6 +218,7 @@ lean_object* l_Array_indexOfAux___main(lean_object*);
 lean_object* l_Array_getLit___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_toListLitAux___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_getLit(lean_object*, lean_object*);
+uint8_t l_Array_isPrefixOf___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Array_foldlFrom___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_HasRepr___rarg___closed__1;
 uint8_t l_Array_anyRange___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -236,6 +243,7 @@ lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Arr
 lean_object* l_Array_iterateM_u2082Aux(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Array_toList___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_filterMapMAux(lean_object*);
+lean_object* l_Array_isPrefixOfAux___main___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_getMax_x3f___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_toArrayLit___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_sub(lean_object*, lean_object*);
@@ -254,6 +262,7 @@ lean_object* l_Array_findIdx_x3f___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Array_mapM___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_shrink___main___rarg(lean_object*, lean_object*);
 lean_object* l_Array_findRev_x3f(lean_object*);
+uint8_t l___private_Init_Data_Array_Basic_8__allDiffAuxAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_indexOfAux___main___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_indexOf(lean_object*);
 lean_object* l_Array_foldrRangeM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -264,6 +273,7 @@ lean_object* l_Array_iterateFrom___rarg___boxed(lean_object*, lean_object*, lean
 lean_object* l_Array_anyRangeMAux___main___at_Array_any___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_allM___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Array_foldlStep___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_allDiff(lean_object*);
 uint8_t l_Array_anyRangeMAux___main___at_Array_anyFrom___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_pop___boxed(lean_object*, lean_object*);
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
@@ -291,6 +301,7 @@ uint8_t l_Array_anyRangeMAux___main___at_Array_anyRange___spec__1___rarg(lean_ob
 lean_object* l___private_Init_Data_Array_Basic_4__foldrRangeMAux___main___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Nat_repr(lean_object*);
 lean_object* l_Array_umapMAux___main___at_Array_mapIdx___spec__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Data_Array_Basic_9__allDiffAux(lean_object*);
 lean_object* l_Array_erase___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_toArrayLit(lean_object*);
 lean_object* l_Array_shrink___rarg___boxed(lean_object*, lean_object*);
@@ -307,6 +318,7 @@ lean_object* l_Array_iterateM(lean_object*, lean_object*);
 lean_object* l_Array_iterateM_u2082Aux___main___at_Array_iterate_u2082___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_filterAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateM_u2082Aux___main___at_Array_foldlM_u2082___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_isPrefixOfAux___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_back___rarg(lean_object*, lean_object*);
 lean_object* l_Array_filterMap(lean_object*, lean_object*);
 lean_object* l_Array_findSomeM_x3f___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -331,12 +343,15 @@ lean_object* l_Array_iterateMAux___main___at_Array_iterate___spec__1___rarg___bo
 lean_object* l_Array_indexOfAux(lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Array_toList___spec__1(lean_object*);
 lean_object* l_Array_iterateM_u2082Aux___main___at_Array_foldl_u2082___spec__1(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Data_Array_Basic_8__allDiffAuxAux___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_append(lean_object*);
 lean_object* l_Array_umapIdxM(lean_object*, lean_object*);
 lean_object* l_Array_findSomeRevMAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findSomeRevMAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forMAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t l___private_Init_Data_Array_Basic_8__allDiffAuxAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findRevM_x3f(lean_object*, lean_object*);
+lean_object* l___private_Init_Data_Array_Basic_8__allDiffAuxAux___main___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Array_foldl___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_toListLitAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_toList___rarg___boxed(lean_object*);
@@ -354,12 +369,14 @@ lean_object* l_Array_HasEmptyc(lean_object*);
 lean_object* l_Array_findSomeMAux(lean_object*, lean_object*);
 lean_object* l_List_toArrayAux___main(lean_object*);
 lean_object* l_Array_foldlStepMAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t l_Array_isPrefixOfAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_redLength___main___rarg(lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Array_foldr___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_iterateM_u2082Aux___main___at_Array_foldl_u2082___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findIdxAux___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_isPrefixOfAux(lean_object*);
 lean_object* l_Array_foldr___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_mapIdxM___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forRevMAux___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -367,6 +384,7 @@ lean_object* l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(lean_
 lean_object* l_Array_anyRangeMAux(lean_object*, lean_object*);
 lean_object* l_Array_size___boxed(lean_object*, lean_object*);
 lean_object* l_Array_extract(lean_object*);
+lean_object* l_Array_allDiff___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Array_eraseIdx_x27(lean_object*);
 lean_object* l_Array_partitionAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlFromM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -470,6 +488,7 @@ lean_object* l___private_Init_Data_Array_Basic_1__swapAtPanic_x21___at_Array_swa
 lean_object* l_Array_eraseIdxAux(lean_object*);
 lean_object* l_Array_isEmpty___rarg___boxed(lean_object*);
 lean_object* l_Array_erase(lean_object*);
+lean_object* l_Array_isPrefixOf___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Array_all___spec__1(lean_object*);
 lean_object* l_Array_forFromM(lean_object*, lean_object*);
 lean_object* l_Array_findMAux(lean_object*, lean_object*);
@@ -498,6 +517,7 @@ lean_object* l_Array_iterateMAux___main___at_Array_mapM___spec__1(lean_object*,
 lean_object* l_Array_findMAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_4__foldrRangeMAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Array_allM___spec__1___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Data_Array_Basic_9__allDiffAux___main___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_1__swapAtPanic_x21___rarg___closed__2;
 lean_object* l_Array_findSomeRev_x3f___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Array_anyRangeM(lean_object*, lean_object*);
@@ -534,7 +554,9 @@ lean_object* l___private_Init_Data_Array_Basic_1__swapAtPanic_x21___rarg(lean_ob
 lean_object* l___private_Init_Data_Array_Basic_4__foldrRangeMAux___main___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_reverseAux___rarg(lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Array_anyRange___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Data_Array_Basic_9__allDiffAux___main(lean_object*);
 lean_object* l_Array_findSomeMAux___main(lean_object*, lean_object*);
+uint8_t l_Array_isPrefixOfAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findRevMAux___main___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t);
 lean_object* l_Array_filterMapM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findIdxAux___main___rarg___boxed(lean_object*, lean_object*, lean_object*);
@@ -554,6 +576,7 @@ lean_object* l_Array_findIdx_x21___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Array_findSomeRev_x21(lean_object*, lean_object*);
 lean_object* l_Array_partition___rarg(lean_object*, lean_object*);
 lean_object* l_Array_findIdx_x21___rarg___closed__1;
+uint8_t l___private_Init_Data_Array_Basic_9__allDiffAux___main___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forRevMAux(lean_object*, lean_object*);
 lean_object* l_Array_findIdxAux___main___at_Array_getIdx_x3f___spec__1(lean_object*);
 lean_object* l_Array_iterate(lean_object*, lean_object*);
@@ -585,6 +608,7 @@ lean_object* l_Array_filterM(lean_object*);
 lean_object* l_Array_empty(lean_object*);
 uint8_t l_Array_anyRangeMAux___main___at_Array_contains___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_filterAux(lean_object*);
+uint8_t l_Array_allDiff___rarg(lean_object*, lean_object*);
 lean_object* l_Array_isEqv___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findSome_x3f___rarg___boxed(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Array_foldrM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -8806,6 +8830,343 @@ lean_dec(x_2);
 return x_3;
 }
 }
+uint8_t l_Array_isPrefixOfAux___main___rarg(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; uint8_t x_7; 
+x_6 = lean_array_get_size(x_2);
+x_7 = lean_nat_dec_lt(x_5, x_6);
+lean_dec(x_6);
+if (x_7 == 0)
+{
+uint8_t x_8; 
+lean_dec(x_5);
+lean_dec(x_1);
+x_8 = 1;
+return x_8;
+}
+else
+{
+lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_9 = lean_array_fget(x_2, x_5);
+x_10 = lean_array_fget(x_3, x_5);
+lean_inc(x_1);
+x_11 = lean_apply_2(x_1, x_9, x_10);
+x_12 = lean_unbox(x_11);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+uint8_t x_13; 
+lean_dec(x_5);
+lean_dec(x_1);
+x_13 = 0;
+return x_13;
+}
+else
+{
+lean_object* x_14; lean_object* x_15; 
+x_14 = lean_unsigned_to_nat(1u);
+x_15 = lean_nat_add(x_5, x_14);
+lean_dec(x_5);
+x_4 = lean_box(0);
+x_5 = x_15;
+goto _start;
+}
+}
+}
+}
+lean_object* l_Array_isPrefixOfAux___main(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Array_isPrefixOfAux___main___rarg___boxed), 5, 0);
+return x_2;
+}
+}
+lean_object* l_Array_isPrefixOfAux___main___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+uint8_t x_6; lean_object* x_7; 
+x_6 = l_Array_isPrefixOfAux___main___rarg(x_1, x_2, x_3, x_4, x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+x_7 = lean_box(x_6);
+return x_7;
+}
+}
+uint8_t l_Array_isPrefixOfAux___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+uint8_t x_6; 
+x_6 = l_Array_isPrefixOfAux___main___rarg(x_1, x_2, x_3, lean_box(0), x_5);
+return x_6;
+}
+}
+lean_object* l_Array_isPrefixOfAux(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Array_isPrefixOfAux___rarg___boxed), 5, 0);
+return x_2;
+}
+}
+lean_object* l_Array_isPrefixOfAux___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+uint8_t x_6; lean_object* x_7; 
+x_6 = l_Array_isPrefixOfAux___rarg(x_1, x_2, x_3, x_4, x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+x_7 = lean_box(x_6);
+return x_7;
+}
+}
+uint8_t l_Array_isPrefixOf___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; lean_object* x_5; uint8_t x_6; 
+x_4 = lean_array_get_size(x_2);
+x_5 = lean_array_get_size(x_3);
+x_6 = lean_nat_dec_le(x_4, x_5);
+lean_dec(x_5);
+lean_dec(x_4);
+if (x_6 == 0)
+{
+uint8_t x_7; 
+lean_dec(x_1);
+x_7 = 0;
+return x_7;
+}
+else
+{
+lean_object* x_8; uint8_t x_9; 
+x_8 = lean_unsigned_to_nat(0u);
+x_9 = l_Array_isPrefixOfAux___main___rarg(x_1, x_2, x_3, lean_box(0), x_8);
+return x_9;
+}
+}
+}
+lean_object* l_Array_isPrefixOf(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Array_isPrefixOf___rarg___boxed), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Array_isPrefixOf___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+uint8_t x_4; lean_object* x_5; 
+x_4 = l_Array_isPrefixOf___rarg(x_1, x_2, x_3);
+lean_dec(x_3);
+lean_dec(x_2);
+x_5 = lean_box(x_4);
+return x_5;
+}
+}
+uint8_t l___private_Init_Data_Array_Basic_8__allDiffAuxAux___main___rarg(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; uint8_t x_7; 
+x_6 = lean_unsigned_to_nat(0u);
+x_7 = lean_nat_dec_eq(x_4, x_6);
+if (x_7 == 0)
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_8 = lean_unsigned_to_nat(1u);
+x_9 = lean_nat_sub(x_4, x_8);
+lean_dec(x_4);
+x_10 = lean_array_fget(x_2, x_9);
+lean_inc(x_1);
+lean_inc(x_3);
+x_11 = lean_apply_2(x_1, x_3, x_10);
+x_12 = lean_unbox(x_11);
+lean_dec(x_11);
+if (x_12 == 0)
+{
+x_4 = x_9;
+x_5 = lean_box(0);
+goto _start;
+}
+else
+{
+uint8_t x_14; 
+lean_dec(x_9);
+lean_dec(x_3);
+lean_dec(x_1);
+x_14 = 0;
+return x_14;
+}
+}
+else
+{
+uint8_t x_15; 
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+x_15 = 1;
+return x_15;
+}
+}
+}
+lean_object* l___private_Init_Data_Array_Basic_8__allDiffAuxAux___main(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l___private_Init_Data_Array_Basic_8__allDiffAuxAux___main___rarg___boxed), 5, 0);
+return x_2;
+}
+}
+lean_object* l___private_Init_Data_Array_Basic_8__allDiffAuxAux___main___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+uint8_t x_6; lean_object* x_7; 
+x_6 = l___private_Init_Data_Array_Basic_8__allDiffAuxAux___main___rarg(x_1, x_2, x_3, x_4, x_5);
+lean_dec(x_2);
+x_7 = lean_box(x_6);
+return x_7;
+}
+}
+uint8_t l___private_Init_Data_Array_Basic_8__allDiffAuxAux___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+uint8_t x_6; 
+x_6 = l___private_Init_Data_Array_Basic_8__allDiffAuxAux___main___rarg(x_1, x_2, x_3, x_4, lean_box(0));
+return x_6;
+}
+}
+lean_object* l___private_Init_Data_Array_Basic_8__allDiffAuxAux(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l___private_Init_Data_Array_Basic_8__allDiffAuxAux___rarg___boxed), 5, 0);
+return x_2;
+}
+}
+lean_object* l___private_Init_Data_Array_Basic_8__allDiffAuxAux___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+uint8_t x_6; lean_object* x_7; 
+x_6 = l___private_Init_Data_Array_Basic_8__allDiffAuxAux___rarg(x_1, x_2, x_3, x_4, x_5);
+lean_dec(x_2);
+x_7 = lean_box(x_6);
+return x_7;
+}
+}
+uint8_t l___private_Init_Data_Array_Basic_9__allDiffAux___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; uint8_t x_5; 
+x_4 = lean_array_get_size(x_2);
+x_5 = lean_nat_dec_lt(x_3, x_4);
+lean_dec(x_4);
+if (x_5 == 0)
+{
+uint8_t x_6; 
+lean_dec(x_3);
+lean_dec(x_1);
+x_6 = 1;
+return x_6;
+}
+else
+{
+lean_object* x_7; uint8_t x_8; 
+x_7 = lean_array_fget(x_2, x_3);
+lean_inc(x_3);
+lean_inc(x_1);
+x_8 = l___private_Init_Data_Array_Basic_8__allDiffAuxAux___main___rarg(x_1, x_2, x_7, x_3, lean_box(0));
+if (x_8 == 0)
+{
+uint8_t x_9; 
+lean_dec(x_3);
+lean_dec(x_1);
+x_9 = 0;
+return x_9;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; 
+x_10 = lean_unsigned_to_nat(1u);
+x_11 = lean_nat_add(x_3, x_10);
+lean_dec(x_3);
+x_3 = x_11;
+goto _start;
+}
+}
+}
+}
+lean_object* l___private_Init_Data_Array_Basic_9__allDiffAux___main(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l___private_Init_Data_Array_Basic_9__allDiffAux___main___rarg___boxed), 3, 0);
+return x_2;
+}
+}
+lean_object* l___private_Init_Data_Array_Basic_9__allDiffAux___main___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+uint8_t x_4; lean_object* x_5; 
+x_4 = l___private_Init_Data_Array_Basic_9__allDiffAux___main___rarg(x_1, x_2, x_3);
+lean_dec(x_2);
+x_5 = lean_box(x_4);
+return x_5;
+}
+}
+uint8_t l___private_Init_Data_Array_Basic_9__allDiffAux___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+uint8_t x_4; 
+x_4 = l___private_Init_Data_Array_Basic_9__allDiffAux___main___rarg(x_1, x_2, x_3);
+return x_4;
+}
+}
+lean_object* l___private_Init_Data_Array_Basic_9__allDiffAux(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l___private_Init_Data_Array_Basic_9__allDiffAux___rarg___boxed), 3, 0);
+return x_2;
+}
+}
+lean_object* l___private_Init_Data_Array_Basic_9__allDiffAux___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+uint8_t x_4; lean_object* x_5; 
+x_4 = l___private_Init_Data_Array_Basic_9__allDiffAux___rarg(x_1, x_2, x_3);
+lean_dec(x_2);
+x_5 = lean_box(x_4);
+return x_5;
+}
+}
+uint8_t l_Array_allDiff___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; uint8_t x_4; 
+x_3 = lean_unsigned_to_nat(0u);
+x_4 = l___private_Init_Data_Array_Basic_9__allDiffAux___main___rarg(x_1, x_2, x_3);
+return x_4;
+}
+}
+lean_object* l_Array_allDiff(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Array_allDiff___rarg___boxed), 2, 0);
+return x_2;
+}
+}
+lean_object* l_Array_allDiff___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = l_Array_allDiff___rarg(x_1, x_2);
+lean_dec(x_2);
+x_4 = lean_box(x_3);
+return x_4;
+}
+}
 lean_object* initialize_Init_Data_Nat_Basic(lean_object*);
 lean_object* initialize_Init_Data_Fin_Basic(lean_object*);
 lean_object* initialize_Init_Data_UInt(lean_object*);

stage0/stdlib/Init/Data/FloatArray/Basic.c

@@ -250,7 +250,7 @@ else
 lean_object* x_7; lean_object* x_8; double x_9; lean_object* x_10; lean_object* x_11; 
 x_7 = lean_unsigned_to_nat(1u);
 x_8 = lean_nat_add(x_2, x_7);
-x_9 = lean_float_array_get(x_1, x_2);
+x_9 = lean_float_array_fget(x_1, x_2);
 lean_dec(x_2);
 x_10 = lean_box_float(x_9);
 x_11 = lean_alloc_ctor(1, 2, 0);

stage0/stdlib/Lean/Elab/App.c

@@ -77,7 +77,6 @@ lean_object* l___regBuiltin_Lean_Elab_Term_elabApp___closed__1;
 lean_object* l_List_foldlM___main___at___private_Lean_Elab_App_21__elabAppFnId___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_14__resolveLValAux___closed__17;
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
-lean_object* l___private_Lean_Elab_App_27__expandApp(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l___private_Lean_Elab_App_9__nextArgIsHole(lean_object*);
 lean_object* l_List_append___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_12__throwLValError___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -126,6 +125,7 @@ lean_object* l___regBuiltin_Lean_Elab_Term_elabArrayRef(lean_object*);
 lean_object* l_Array_forMAux___main___at___private_Lean_Elab_App_10__elabAppArgsAux___main___spec__5(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___private_Lean_Elab_App_10__elabAppArgsAux___main___closed__6;
 lean_object* l_Array_forMAux___main___at___private_Lean_Elab_App_10__elabAppArgsAux___main___spec__13(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_Elab_Term_expandApp___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_NamedArg_inhabited;
 lean_object* l_Array_forMAux___main___at___private_Lean_Elab_App_10__elabAppArgsAux___main___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_Array_forMAux___main___at___private_Lean_Elab_App_10__elabAppArgsAux___main___spec__11___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -193,8 +193,6 @@ lean_object* l___private_Lean_Elab_App_4__tryCoeFun___closed__6;
 lean_object* l_Lean_Name_append___main(lean_object*, lean_object*);
 lean_object* l_Array_shrink___main___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at___private_Lean_Elab_App_21__elabAppFnId___spec__1___rarg(lean_object*);
-lean_object* l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___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*);
-lean_object* l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__1;
 lean_object* l___private_Lean_Elab_App_5__getForallBody___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_whnfForall___at_Lean_Elab_Term_useImplicitLambda_x3f___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_4__tryCoeFun___closed__5;
@@ -215,7 +213,6 @@ extern lean_object* l_Lean_getConstInfo___rarg___lambda__1___closed__5;
 lean_object* l_Lean_Elab_Term_NamedArg_inhabited___closed__1;
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at___private_Lean_Elab_App_21__elabAppFnId___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Arg_hasToString(lean_object*);
-lean_object* l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__2;
 lean_object* l___private_Lean_Elab_App_10__elabAppArgsAux___main___closed__8;
 extern lean_object* l_Std_PersistentArray_Stats_toString___closed__4;
 lean_object* l_Lean_Elab_Term_elabTermAux___main(lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -260,6 +257,7 @@ lean_object* l_Lean_Elab_Term_elabApp(lean_object*, lean_object*, lean_object*,
 lean_object* l_Lean_Elab_getRefPos___at___private_Lean_Elab_App_24__toMessageData___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getPathToBaseStructure_x3f(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_synthesizeAppInstMVars___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Elab_Term_expandApp(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_22__elabAppFn___main___closed__9;
 lean_object* l___private_Lean_Meta_WHNF_12__whnfEasyCases___main___at___private_Lean_Meta_WHNF_17__whnfCoreImp___main___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_4__tryCoeFun___closed__3;
@@ -280,7 +278,6 @@ lean_object* l___private_Lean_Elab_App_21__elabAppFnId___boxed(lean_object*, lea
 lean_object* l___private_Lean_Elab_App_4__tryCoeFun___closed__1;
 extern lean_object* l___private_Lean_Elab_Util_4__regTraceClasses___closed__1;
 extern lean_object* l_Lean_importModules___closed__1;
-lean_object* l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1(lean_object*, 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_formatEntry___closed__1;
 lean_object* l___private_Lean_Elab_App_16__resolveLVal(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -301,14 +298,13 @@ lean_object* l___private_Lean_Elab_App_19__elabAppLValsAux___boxed(lean_object*,
 lean_object* l___private_Lean_Elab_App_10__elabAppArgsAux___main___closed__19;
 lean_object* l_Lean_Elab_Term_mkConst(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_18__addLValArg___main(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_object*, lean_object*);
+lean_object* l___private_Lean_Elab_App_27__regTraceClasses(lean_object*);
 lean_object* l___private_Lean_Elab_App_26__elabAppAux___closed__3;
 extern lean_object* l_Lean_nullKind___closed__2;
-lean_object* l___private_Lean_Elab_App_28__regTraceClasses(lean_object*);
 lean_object* l_Lean_Elab_Term_elabProj(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MessageData_ofArray(lean_object*);
 extern lean_object* l_Lean_Elab_Term_termElabAttribute;
 lean_object* l_Array_forMAux___main___at___private_Lean_Elab_App_10__elabAppArgsAux___main___spec__21(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___private_Lean_Elab_App_27__expandApp___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_getRefPos___at___private_Lean_Elab_App_24__toMessageData___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_17__mkBaseProjections___closed__3;
 lean_object* l_Lean_Elab_Term_isDefEq(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -352,6 +348,7 @@ lean_object* l_Array_findIdxAux___main___at___private_Lean_Elab_App_10__elabAppA
 lean_object* lean_panic_fn(lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_Elab_Term_elabExplicit___closed__1;
 lean_object* l_Array_forMAux___main___at_Lean_Elab_Term_synthesizeAppInstMVars___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Std_PersistentHashMap_mkCollisionNode___rarg___closed__1;
 lean_object* l___private_Lean_Elab_App_14__resolveLValAux___closed__10;
 lean_object* l___private_Lean_Elab_App_10__elabAppArgsAux___main___closed__12;
@@ -384,6 +381,7 @@ extern lean_object* l_Lean_TraceState_Inhabited___closed__1;
 lean_object* l___private_Lean_Elab_App_18__addLValArg___main___closed__7;
 lean_object* l_Array_forMAux___main___at___private_Lean_Elab_App_10__elabAppArgsAux___main___spec__2___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___private_Lean_Elab_App_20__elabAppLVals___closed__1;
+lean_object* l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__1;
 lean_object* l_Lean_Meta_mkFreshLevelMVar___at_Lean_Elab_Term_ensureType___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Lean_Elab_Term_addNamedArg___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_consumeMData___main(lean_object*);
@@ -444,6 +442,7 @@ lean_object* l_Array_iterateMAux___main___at_Lean_mkAppN___spec__1(lean_object*,
 lean_object* l___private_Lean_Elab_App_18__addLValArg___main___closed__5;
 lean_object* l_Lean_Elab_Term_applyResult(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*);
+lean_object* l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__2;
 lean_object* l_List_map___main___at___private_Lean_Elab_App_22__elabAppFn___main___spec__1(lean_object*);
 lean_object* l_Lean_Elab_Term_elabRawIdent(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_11__elabAppArgs___closed__8;
@@ -485,6 +484,7 @@ lean_object* l___private_Lean_Elab_App_10__elabAppArgsAux___main___closed__7;
 lean_object* l_Lean_Exception_toMessageData(lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 lean_object* l_Array_forMAux___main___at___private_Lean_Elab_App_10__elabAppArgsAux___main___spec__6(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_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___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*);
 lean_object* l_Lean_Elab_Term_Arg_inhabited;
 lean_object* l_Array_forMAux___main___at_Lean_Elab_Term_synthesizeAppInstMVars___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
@@ -1077,7 +1077,6 @@ lean_object* x_12; uint8_t x_13; lean_object* x_14;
 x_12 = lean_ctor_get(x_10, 0);
 x_13 = 0;
 x_14 = l_Lean_mkForall(x_12, x_13, x_1, x_2);
-lean_dec(x_12);
 lean_ctor_set(x_10, 0, x_14);
 return x_10;
 }
@@ -1091,7 +1090,6 @@ lean_inc(x_15);
 lean_dec(x_10);
 x_17 = 0;
 x_18 = l_Lean_mkForall(x_15, x_17, x_1, x_2);
-lean_dec(x_15);
 x_19 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_19, 0, x_18);
 lean_ctor_set(x_19, 1, x_16);
@@ -29415,7 +29413,7 @@ return x_68;
 }
 }
 }
-lean_object* _init_l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__1() {
+lean_object* _init_l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -29423,17 +29421,17 @@ x_1 = lean_mk_string("namedArgument");
 return x_1;
 }
 }
-lean_object* _init_l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__2() {
+lean_object* _init_l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_mkAppStx___closed__6;
-x_2 = l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__1;
+x_2 = l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__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, lean_object* x_9, lean_object* x_10, lean_object* x_11) {
+lean_object* l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__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, lean_object* x_9, lean_object* x_10, lean_object* x_11) {
 _start:
 {
 lean_object* x_12; uint8_t x_13; 
@@ -29465,7 +29463,7 @@ x_19 = lean_ctor_get(x_4, 0);
 x_20 = lean_ctor_get(x_4, 1);
 lean_inc(x_15);
 x_21 = l_Lean_Syntax_getKind(x_15);
-x_22 = l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__2;
+x_22 = l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__2;
 x_23 = lean_name_eq(x_21, x_22);
 lean_dec(x_21);
 if (x_23 == 0)
@@ -29547,7 +29545,7 @@ lean_inc(x_42);
 lean_dec(x_4);
 lean_inc(x_15);
 x_44 = l_Lean_Syntax_getKind(x_15);
-x_45 = l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__2;
+x_45 = l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__2;
 x_46 = lean_name_eq(x_44, x_45);
 lean_dec(x_44);
 if (x_46 == 0)
@@ -29629,7 +29627,7 @@ return x_66;
 }
 }
 }
-lean_object* l___private_Lean_Elab_App_27__expandApp(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* l_Lean_Elab_Term_expandApp(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_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
@@ -29640,7 +29638,7 @@ x_12 = l_Lean_Syntax_getArg(x_1, x_11);
 x_13 = l_Lean_Syntax_getArgs(x_12);
 lean_dec(x_12);
 x_14 = l_Lean_importModules___closed__1;
-x_15 = l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1(x_1, x_13, x_9, x_14, x_2, x_3, x_4, x_5, x_6, x_7, x_8);
+x_15 = l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1(x_1, x_13, x_9, x_14, x_2, x_3, x_4, x_5, x_6, x_7, x_8);
 lean_dec(x_13);
 if (lean_obj_tag(x_15) == 0)
 {
@@ -29698,11 +29696,11 @@ return x_26;
 }
 }
 }
-lean_object* l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___boxed(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, lean_object* x_11) {
+lean_object* l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___boxed(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, lean_object* x_11) {
 _start:
 {
 lean_object* x_12; 
-x_12 = l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11);
+x_12 = l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11);
 lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
@@ -29713,11 +29711,11 @@ lean_dec(x_1);
 return x_12;
 }
 }
-lean_object* l___private_Lean_Elab_App_27__expandApp___boxed(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* l_Lean_Elab_Term_expandApp___boxed(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_9; 
-x_9 = l___private_Lean_Elab_App_27__expandApp(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8);
+x_9 = l_Lean_Elab_Term_expandApp(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
@@ -29732,7 +29730,7 @@ _start:
 {
 lean_object* x_10; 
 lean_inc(x_3);
-x_10 = l___private_Lean_Elab_App_27__expandApp(x_1, x_3, x_4, x_5, x_6, x_7, x_8, x_9);
+x_10 = l_Lean_Elab_Term_expandApp(x_1, x_3, x_4, x_5, x_6, x_7, x_8, x_9);
 if (lean_obj_tag(x_10) == 0)
 {
 lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
@@ -30278,7 +30276,7 @@ x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1);
 return x_5;
 }
 }
-lean_object* l___private_Lean_Elab_App_28__regTraceClasses(lean_object* x_1) {
+lean_object* l___private_Lean_Elab_App_27__regTraceClasses(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
@@ -30593,10 +30591,10 @@ l___private_Lean_Elab_App_26__elabAppAux___closed__2 = _init_l___private_Lean_El
 lean_mark_persistent(l___private_Lean_Elab_App_26__elabAppAux___closed__2);
 l___private_Lean_Elab_App_26__elabAppAux___closed__3 = _init_l___private_Lean_Elab_App_26__elabAppAux___closed__3();
 lean_mark_persistent(l___private_Lean_Elab_App_26__elabAppAux___closed__3);
-l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__1 = _init_l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__1();
-lean_mark_persistent(l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__1);
-l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__2 = _init_l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__2();
-lean_mark_persistent(l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__2);
+l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__1 = _init_l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__1();
+lean_mark_persistent(l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__1);
+l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__2 = _init_l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__2();
+lean_mark_persistent(l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__2);
 l___regBuiltin_Lean_Elab_Term_elabApp___closed__1 = _init_l___regBuiltin_Lean_Elab_Term_elabApp___closed__1();
 lean_mark_persistent(l___regBuiltin_Lean_Elab_Term_elabApp___closed__1);
 res = l___regBuiltin_Lean_Elab_Term_elabApp(lean_io_mk_world());
@@ -30642,7 +30640,7 @@ lean_mark_persistent(l___regBuiltin_Lean_Elab_Term_elabRawIdent___closed__1);
 res = l___regBuiltin_Lean_Elab_Term_elabRawIdent(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-res = l___private_Lean_Elab_App_28__regTraceClasses(lean_io_mk_world());
+res = l___private_Lean_Elab_App_27__regTraceClasses(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/Elab/Binders.c

@@ -128,6 +128,7 @@ lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_Binders_6__matchBi
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Elab_Term_elabParen___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Meta_Basic_6__liftMkBindingM___rarg___closed__3;
 lean_object* l_Lean_Elab_Term_quoteAutoTactic___main___closed__15;
+lean_object* l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__11;
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_Binders_6__matchBinder___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_restoreSynthInstanceCache(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__6;
@@ -360,6 +361,7 @@ lean_object* l_Lean_Elab_Term_elabBinders___rarg(lean_object*, lean_object*, lea
 lean_object* l_Lean_Elab_Term_mkLetIdDeclView(lean_object*);
 extern lean_object* l___private_Lean_Elab_Util_1__evalSyntaxConstantUnsafe___closed__2;
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Term_elabForall___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Elab_Term_MVarErrorContext_logError___closed__7;
 lean_object* l___private_Lean_Elab_Binders_4__expandBinderModifier___closed__10;
 lean_object* l_Lean_Meta_withLetDecl___at_Lean_Elab_Term_elabLetDeclAux___spec__1(lean_object*);
 lean_object* l___private_Lean_Elab_Binders_11__expandFunBindersAux___main___closed__9;
@@ -384,10 +386,12 @@ lean_object* l_Lean_Elab_Term_elabForall(lean_object*, lean_object*, lean_object
 lean_object* l___private_Lean_Elab_Binders_11__expandFunBindersAux___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Array_iterateMAux___main___at___private_Lean_Elab_Quotation_2__quoteSyntax___main___spec__1___closed__4;
 lean_object* l_Lean_Elab_Term_quoteAutoTactic___main___closed__14;
+lean_object* l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__12;
 lean_object* l_Lean_Elab_Term_elabArrow___lambda__1___closed__3;
+extern lean_object* l___private_Lean_Elab_Term_13__isExplicit___closed__2;
 lean_object* l_Lean_Elab_Term_elabLetDeclCore(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_quoteAutoTactic___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Elab_Binders_1__expandBinderType___boxed(lean_object*);
+lean_object* l___private_Lean_Elab_Binders_1__expandBinderType___boxed(lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_Binders_5__getBinderIds___spec__1___closed__3;
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_Binders_6__matchBinder___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Elab_Term_throwErrorIfErrors___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -396,7 +400,7 @@ lean_object* l_Lean_mkConst(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_elabLetDeclCore___closed__3;
 lean_object* l___private_Lean_Elab_Binders_17__expandLetEqnsDeclVal___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkForallFVars___at_Lean_Elab_Term_elabForall___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Elab_Binders_1__expandBinderType(lean_object*);
+lean_object* l___private_Lean_Elab_Binders_1__expandBinderType(lean_object*, lean_object*);
 lean_object* lean_name_mk_numeral(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Binders_11__expandFunBindersAux___main___closed__1;
 extern lean_object* l_Lean_mkAppStx___closed__1;
@@ -417,36 +421,37 @@ extern lean_object* l_Lean_Meta_AbstractMVars_abstractExprMVars___main___closed_
 lean_object* l_Lean_Elab_Term_elabBinder(lean_object*);
 lean_object* lean_add_decl(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Binders_17__expandLetEqnsDeclVal___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Elab_Binders_1__expandBinderType(lean_object* x_1) {
+lean_object* l___private_Lean_Elab_Binders_1__expandBinderType(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_2; lean_object* x_3; uint8_t x_4; 
-x_2 = l_Lean_Syntax_getNumArgs(x_1);
-x_3 = lean_unsigned_to_nat(0u);
-x_4 = lean_nat_dec_eq(x_2, x_3);
-lean_dec(x_2);
-if (x_4 == 0)
+lean_object* x_3; lean_object* x_4; uint8_t x_5; 
+x_3 = l_Lean_Syntax_getNumArgs(x_2);
+x_4 = lean_unsigned_to_nat(0u);
+x_5 = lean_nat_dec_eq(x_3, x_4);
+lean_dec(x_3);
+if (x_5 == 0)
 {
-lean_object* x_5; lean_object* x_6; 
-x_5 = lean_unsigned_to_nat(1u);
-x_6 = l_Lean_Syntax_getArg(x_1, x_5);
-return x_6;
+lean_object* x_6; lean_object* x_7; 
+x_6 = lean_unsigned_to_nat(1u);
+x_7 = l_Lean_Syntax_getArg(x_2, x_6);
+return x_7;
 }
 else
 {
-lean_object* x_7; 
-x_7 = l_Lean_mkHole(x_1);
-return x_7;
+lean_object* x_8; 
+x_8 = l_Lean_mkHole(x_1);
+return x_8;
 }
 }
 }
-lean_object* l___private_Lean_Elab_Binders_1__expandBinderType___boxed(lean_object* x_1) {
+lean_object* l___private_Lean_Elab_Binders_1__expandBinderType___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_2; 
-x_2 = l___private_Lean_Elab_Binders_1__expandBinderType(x_1);
+lean_object* x_3; 
+x_3 = l___private_Lean_Elab_Binders_1__expandBinderType(x_1, x_2);
+lean_dec(x_2);
 lean_dec(x_1);
-return x_2;
+return x_3;
 }
 }
 lean_object* l___private_Lean_Elab_Binders_2__expandBinderIdent(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) {
@@ -3839,7 +3844,7 @@ lean_inc(x_46);
 lean_dec(x_44);
 x_47 = lean_unsigned_to_nat(2u);
 x_48 = lean_array_get(x_41, x_10, x_47);
-x_49 = l___private_Lean_Elab_Binders_1__expandBinderType(x_48);
+x_49 = l___private_Lean_Elab_Binders_1__expandBinderType(x_1, x_48);
 lean_dec(x_48);
 x_50 = x_45;
 x_51 = lean_unsigned_to_nat(0u);
@@ -3905,7 +3910,7 @@ lean_inc(x_64);
 lean_dec(x_62);
 x_65 = lean_unsigned_to_nat(2u);
 x_66 = lean_array_get(x_59, x_10, x_65);
-x_67 = l___private_Lean_Elab_Binders_1__expandBinderType(x_66);
+x_67 = l___private_Lean_Elab_Binders_1__expandBinderType(x_1, x_66);
 lean_dec(x_66);
 x_68 = lean_unsigned_to_nat(3u);
 x_69 = lean_array_get(x_59, x_10, x_68);
@@ -15461,52 +15466,74 @@ return x_3;
 lean_object* _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__4() {
 _start:
 {
-lean_object* x_1; 
-x_1 = lean_mk_string("intro");
-return x_1;
-}
-}
-lean_object* _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__5() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l___regBuiltin_Lean_Elab_Term_Quotation_elabTacticQuot___closed__1;
-x_2 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__4;
-x_3 = lean_name_mk_string(x_1, x_2);
-return x_3;
-}
-}
-lean_object* _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__6() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_SourceInfo_inhabited___closed__1;
-x_2 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__4;
+x_2 = l_Lean_Elab_Term_MVarErrorContext_logError___closed__7;
 x_3 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
 return x_3;
 }
 }
-lean_object* _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__7() {
+lean_object* _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Array_empty___closed__1;
-x_2 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__6;
+x_2 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__4;
 x_3 = lean_array_push(x_1, x_2);
 return x_3;
 }
 }
+lean_object* _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__6() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("intro");
+return x_1;
+}
+}
+lean_object* _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__7() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l___regBuiltin_Lean_Elab_Term_Quotation_elabTacticQuot___closed__1;
+x_2 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__6;
+x_3 = lean_name_mk_string(x_1, x_2);
+return x_3;
+}
+}
 lean_object* _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__8() {
 _start:
 {
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_SourceInfo_inhabited___closed__1;
+x_2 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__6;
+x_3 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_3, 0, x_1);
+lean_ctor_set(x_3, 1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__9() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Array_empty___closed__1;
+x_2 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__8;
+x_3 = lean_array_push(x_1, x_2);
+return x_3;
+}
+}
+lean_object* _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__10() {
+_start:
+{
 lean_object* x_1; 
 x_1 = lean_mk_string("match ");
 return x_1;
 }
 }
-lean_object* _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__9() {
+lean_object* _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__11() {
 _start:
 {
 lean_object* x_1; 
@@ -15514,7 +15541,7 @@ x_1 = lean_mk_string(" with ");
 return x_1;
 }
 }
-lean_object* _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__10() {
+lean_object* _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__12() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -15566,19 +15593,19 @@ lean_ctor_set(x_26, 0, x_25);
 lean_ctor_set(x_26, 1, x_24);
 if (x_22 == 0)
 {
-lean_object* x_89; lean_object* x_90; lean_object* x_91; 
-x_89 = l_List_reprAux___main___rarg___closed__1;
-x_90 = l_Lean_mkAtomFrom(x_1, x_89);
-x_91 = lean_array_push(x_5, x_90);
-x_27 = x_91;
-goto block_88;
+lean_object* x_97; lean_object* x_98; lean_object* x_99; 
+x_97 = l_List_reprAux___main___rarg___closed__1;
+x_98 = l_Lean_mkAtomFrom(x_1, x_97);
+x_99 = lean_array_push(x_5, x_98);
+x_27 = x_99;
+goto block_96;
 }
 else
 {
 x_27 = x_5;
-goto block_88;
+goto block_96;
 }
-block_88:
+block_96:
 {
 lean_object* x_28; lean_object* x_29; 
 x_28 = lean_array_push(x_27, x_26);
@@ -15590,7 +15617,7 @@ uint8_t x_30;
 x_30 = !lean_is_exclusive(x_29);
 if (x_30 == 0)
 {
-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; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+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; 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; 
 x_31 = lean_ctor_get(x_29, 0);
 x_32 = l_Array_empty___closed__1;
 x_33 = lean_array_push(x_32, x_21);
@@ -15607,285 +15634,303 @@ x_41 = l_Lean_Elab_Term_expandCDot_x3f___closed__2;
 x_42 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_42, 0, x_41);
 lean_ctor_set(x_42, 1, x_40);
-lean_ctor_set(x_29, 0, x_42);
+x_43 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__5;
+x_44 = lean_array_push(x_43, x_42);
+x_45 = l___private_Lean_Elab_Term_13__isExplicit___closed__2;
+x_46 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_46, 0, x_45);
+lean_ctor_set(x_46, 1, x_44);
+lean_ctor_set(x_29, 0, x_46);
 return x_29;
 }
 else
 {
-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_43 = lean_ctor_get(x_29, 0);
-x_44 = lean_ctor_get(x_29, 1);
-lean_inc(x_44);
-lean_inc(x_43);
+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; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
+x_47 = lean_ctor_get(x_29, 0);
+x_48 = lean_ctor_get(x_29, 1);
+lean_inc(x_48);
+lean_inc(x_47);
 lean_dec(x_29);
-x_45 = l_Array_empty___closed__1;
-x_46 = lean_array_push(x_45, x_21);
-x_47 = l_Lean_nullKind___closed__2;
-x_48 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_48, 0, x_47);
-lean_ctor_set(x_48, 1, x_46);
-x_49 = l_Lean_Elab_Term_expandCDot_x3f___closed__4;
-x_50 = lean_array_push(x_49, x_48);
-x_51 = l_Lean_Elab_Term_expandCDot_x3f___closed__6;
-x_52 = lean_array_push(x_50, x_51);
-x_53 = lean_array_push(x_52, x_43);
-x_54 = l_Lean_Elab_Term_expandCDot_x3f___closed__2;
-x_55 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_55, 0, x_54);
-lean_ctor_set(x_55, 1, 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_44);
-return x_56;
+x_49 = l_Array_empty___closed__1;
+x_50 = lean_array_push(x_49, x_21);
+x_51 = l_Lean_nullKind___closed__2;
+x_52 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_52, 0, x_51);
+lean_ctor_set(x_52, 1, x_50);
+x_53 = l_Lean_Elab_Term_expandCDot_x3f___closed__4;
+x_54 = lean_array_push(x_53, x_52);
+x_55 = l_Lean_Elab_Term_expandCDot_x3f___closed__6;
+x_56 = lean_array_push(x_54, x_55);
+x_57 = lean_array_push(x_56, x_47);
+x_58 = l_Lean_Elab_Term_expandCDot_x3f___closed__2;
+x_59 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_59, 0, x_58);
+lean_ctor_set(x_59, 1, x_57);
+x_60 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__5;
+x_61 = lean_array_push(x_60, x_59);
+x_62 = l___private_Lean_Elab_Term_13__isExplicit___closed__2;
+x_63 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_63, 0, x_62);
+lean_ctor_set(x_63, 1, x_61);
+x_64 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_64, 0, x_63);
+lean_ctor_set(x_64, 1, x_48);
+return x_64;
 }
 }
 else
 {
-uint8_t x_57; 
-x_57 = !lean_is_exclusive(x_29);
-if (x_57 == 0)
+uint8_t x_65; 
+x_65 = !lean_is_exclusive(x_29);
+if (x_65 == 0)
 {
-lean_object* x_58; lean_object* x_59; 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; 
-x_58 = lean_ctor_get(x_29, 0);
-x_59 = l_Array_empty___closed__1;
-x_60 = lean_array_push(x_59, x_21);
-x_61 = l_Lean_nullKind___closed__2;
-x_62 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_62, 0, x_61);
-lean_ctor_set(x_62, 1, x_60);
-x_63 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__7;
-x_64 = lean_array_push(x_63, x_62);
-x_65 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__5;
-x_66 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_66, 0, x_65);
-lean_ctor_set(x_66, 1, x_64);
-x_67 = lean_array_push(x_59, x_66);
-x_68 = l___private_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__16;
-x_69 = lean_array_push(x_67, x_68);
-x_70 = lean_array_push(x_69, x_58);
-x_71 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_71, 0, x_61);
-lean_ctor_set(x_71, 1, x_70);
-lean_ctor_set(x_29, 0, x_71);
+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; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; 
+x_66 = lean_ctor_get(x_29, 0);
+x_67 = l_Array_empty___closed__1;
+x_68 = lean_array_push(x_67, x_21);
+x_69 = l_Lean_nullKind___closed__2;
+x_70 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_70, 0, x_69);
+lean_ctor_set(x_70, 1, x_68);
+x_71 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__9;
+x_72 = lean_array_push(x_71, x_70);
+x_73 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__7;
+x_74 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_74, 0, x_73);
+lean_ctor_set(x_74, 1, x_72);
+x_75 = lean_array_push(x_67, x_74);
+x_76 = l___private_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__16;
+x_77 = lean_array_push(x_75, x_76);
+x_78 = lean_array_push(x_77, x_66);
+x_79 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_79, 0, x_69);
+lean_ctor_set(x_79, 1, x_78);
+lean_ctor_set(x_29, 0, x_79);
 return x_29;
 }
 else
 {
-lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; 
-x_72 = lean_ctor_get(x_29, 0);
-x_73 = lean_ctor_get(x_29, 1);
-lean_inc(x_73);
-lean_inc(x_72);
+lean_object* x_80; lean_object* x_81; lean_object* 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; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; 
+x_80 = lean_ctor_get(x_29, 0);
+x_81 = lean_ctor_get(x_29, 1);
+lean_inc(x_81);
+lean_inc(x_80);
 lean_dec(x_29);
-x_74 = l_Array_empty___closed__1;
-x_75 = lean_array_push(x_74, x_21);
-x_76 = l_Lean_nullKind___closed__2;
-x_77 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_77, 0, x_76);
-lean_ctor_set(x_77, 1, x_75);
-x_78 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__7;
-x_79 = lean_array_push(x_78, x_77);
-x_80 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__5;
-x_81 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_81, 0, x_80);
-lean_ctor_set(x_81, 1, x_79);
-x_82 = lean_array_push(x_74, x_81);
-x_83 = l___private_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__16;
-x_84 = lean_array_push(x_82, x_83);
-x_85 = lean_array_push(x_84, x_72);
-x_86 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_86, 0, x_76);
-lean_ctor_set(x_86, 1, x_85);
-x_87 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_87, 0, x_86);
-lean_ctor_set(x_87, 1, x_73);
-return x_87;
+x_82 = l_Array_empty___closed__1;
+x_83 = lean_array_push(x_82, x_21);
+x_84 = l_Lean_nullKind___closed__2;
+x_85 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_85, 0, x_84);
+lean_ctor_set(x_85, 1, x_83);
+x_86 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__9;
+x_87 = lean_array_push(x_86, x_85);
+x_88 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__7;
+x_89 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_89, 0, x_88);
+lean_ctor_set(x_89, 1, x_87);
+x_90 = lean_array_push(x_82, x_89);
+x_91 = l___private_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__16;
+x_92 = lean_array_push(x_90, x_91);
+x_93 = lean_array_push(x_92, x_80);
+x_94 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_94, 0, x_84);
+lean_ctor_set(x_94, 1, x_93);
+x_95 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_95, 0, x_94);
+lean_ctor_set(x_95, 1, x_81);
+return x_95;
 }
 }
 }
 }
 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; uint8_t x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; 
-x_92 = lean_ctor_get(x_6, 0);
-x_93 = lean_ctor_get(x_6, 2);
-x_94 = lean_ctor_get(x_6, 3);
-lean_inc(x_94);
-lean_inc(x_93);
-lean_inc(x_92);
+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; lean_object* x_109; uint8_t x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; 
+x_100 = lean_ctor_get(x_6, 0);
+x_101 = lean_ctor_get(x_6, 2);
+x_102 = lean_ctor_get(x_6, 3);
+lean_inc(x_102);
+lean_inc(x_101);
+lean_inc(x_100);
 lean_dec(x_6);
 lean_inc(x_7);
-lean_inc(x_92);
-x_95 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_95, 0, x_92);
-lean_ctor_set(x_95, 1, x_7);
-lean_ctor_set(x_95, 2, x_93);
-lean_ctor_set(x_95, 3, x_94);
-x_96 = l_Lean_Meta_AbstractMVars_abstractExprMVars___main___closed__2;
-x_97 = l_Lean_addMacroScope(x_92, x_96, x_7);
-x_98 = lean_box(0);
-x_99 = l_Lean_SourceInfo_inhabited___closed__1;
-x_100 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__2;
-x_101 = lean_alloc_ctor(3, 4, 0);
-lean_ctor_set(x_101, 0, x_99);
-lean_ctor_set(x_101, 1, x_100);
-lean_ctor_set(x_101, 2, x_97);
-lean_ctor_set(x_101, 3, x_98);
-x_102 = l_Array_isEmpty___rarg(x_5);
-x_103 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__3;
-lean_inc(x_101);
-x_104 = lean_array_push(x_103, x_101);
-x_105 = l___private_Lean_Elab_Binders_11__expandFunBindersAux___main___closed__6;
-x_106 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_106, 0, x_105);
-lean_ctor_set(x_106, 1, x_104);
-if (x_102 == 0)
+lean_inc(x_100);
+x_103 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_103, 0, x_100);
+lean_ctor_set(x_103, 1, x_7);
+lean_ctor_set(x_103, 2, x_101);
+lean_ctor_set(x_103, 3, x_102);
+x_104 = l_Lean_Meta_AbstractMVars_abstractExprMVars___main___closed__2;
+x_105 = l_Lean_addMacroScope(x_100, x_104, x_7);
+x_106 = lean_box(0);
+x_107 = l_Lean_SourceInfo_inhabited___closed__1;
+x_108 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__2;
+x_109 = lean_alloc_ctor(3, 4, 0);
+lean_ctor_set(x_109, 0, x_107);
+lean_ctor_set(x_109, 1, x_108);
+lean_ctor_set(x_109, 2, x_105);
+lean_ctor_set(x_109, 3, x_106);
+x_110 = l_Array_isEmpty___rarg(x_5);
+x_111 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__3;
+lean_inc(x_109);
+x_112 = lean_array_push(x_111, x_109);
+x_113 = l___private_Lean_Elab_Binders_11__expandFunBindersAux___main___closed__6;
+x_114 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_114, 0, x_113);
+lean_ctor_set(x_114, 1, x_112);
+if (x_110 == 0)
 {
-lean_object* x_143; lean_object* x_144; lean_object* x_145; 
-x_143 = l_List_reprAux___main___rarg___closed__1;
-x_144 = l_Lean_mkAtomFrom(x_1, x_143);
-x_145 = lean_array_push(x_5, x_144);
-x_107 = x_145;
-goto block_142;
+lean_object* x_155; lean_object* x_156; lean_object* x_157; 
+x_155 = l_List_reprAux___main___rarg___closed__1;
+x_156 = l_Lean_mkAtomFrom(x_1, x_155);
+x_157 = lean_array_push(x_5, x_156);
+x_115 = x_157;
+goto block_154;
 }
 else
 {
-x_107 = x_5;
-goto block_142;
+x_115 = x_5;
+goto block_154;
 }
-block_142:
+block_154:
 {
-lean_object* x_108; lean_object* x_109; 
-x_108 = lean_array_push(x_107, x_106);
-x_109 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main(x_1, x_2, x_3, x_11, x_108, x_95, x_12);
+lean_object* x_116; lean_object* x_117; 
+x_116 = lean_array_push(x_115, x_114);
+x_117 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main(x_1, x_2, x_3, x_11, x_116, x_103, x_12);
 lean_dec(x_11);
 if (x_3 == 0)
 {
-lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; 
-x_110 = lean_ctor_get(x_109, 0);
-lean_inc(x_110);
-x_111 = lean_ctor_get(x_109, 1);
-lean_inc(x_111);
-if (lean_is_exclusive(x_109)) {
- lean_ctor_release(x_109, 0);
- lean_ctor_release(x_109, 1);
- x_112 = x_109;
+lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* 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; lean_object* x_134; lean_object* x_135; lean_object* x_136; 
+x_118 = lean_ctor_get(x_117, 0);
+lean_inc(x_118);
+x_119 = lean_ctor_get(x_117, 1);
+lean_inc(x_119);
+if (lean_is_exclusive(x_117)) {
+ lean_ctor_release(x_117, 0);
+ lean_ctor_release(x_117, 1);
+ x_120 = x_117;
 } else {
- lean_dec_ref(x_109);
- x_112 = lean_box(0);
-}
-x_113 = l_Array_empty___closed__1;
-x_114 = lean_array_push(x_113, x_101);
-x_115 = l_Lean_nullKind___closed__2;
-x_116 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_116, 0, x_115);
-lean_ctor_set(x_116, 1, x_114);
-x_117 = l_Lean_Elab_Term_expandCDot_x3f___closed__4;
-x_118 = lean_array_push(x_117, x_116);
-x_119 = l_Lean_Elab_Term_expandCDot_x3f___closed__6;
-x_120 = lean_array_push(x_118, x_119);
-x_121 = lean_array_push(x_120, x_110);
-x_122 = l_Lean_Elab_Term_expandCDot_x3f___closed__2;
-x_123 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_123, 0, x_122);
-lean_ctor_set(x_123, 1, x_121);
-if (lean_is_scalar(x_112)) {
- x_124 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_124 = x_112;
+ lean_dec_ref(x_117);
+ x_120 = lean_box(0);
 }
+x_121 = l_Array_empty___closed__1;
+x_122 = lean_array_push(x_121, x_109);
+x_123 = l_Lean_nullKind___closed__2;
+x_124 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_124, 0, x_123);
-lean_ctor_set(x_124, 1, x_111);
-return x_124;
-}
-else
-{
-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; 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; 
-x_125 = lean_ctor_get(x_109, 0);
-lean_inc(x_125);
-x_126 = lean_ctor_get(x_109, 1);
-lean_inc(x_126);
-if (lean_is_exclusive(x_109)) {
- lean_ctor_release(x_109, 0);
- lean_ctor_release(x_109, 1);
- x_127 = x_109;
-} else {
- lean_dec_ref(x_109);
- x_127 = lean_box(0);
-}
-x_128 = l_Array_empty___closed__1;
-x_129 = lean_array_push(x_128, x_101);
-x_130 = l_Lean_nullKind___closed__2;
+lean_ctor_set(x_124, 1, x_122);
+x_125 = l_Lean_Elab_Term_expandCDot_x3f___closed__4;
+x_126 = lean_array_push(x_125, x_124);
+x_127 = l_Lean_Elab_Term_expandCDot_x3f___closed__6;
+x_128 = lean_array_push(x_126, x_127);
+x_129 = lean_array_push(x_128, x_118);
+x_130 = l_Lean_Elab_Term_expandCDot_x3f___closed__2;
 x_131 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_131, 0, x_130);
 lean_ctor_set(x_131, 1, x_129);
-x_132 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__7;
+x_132 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__5;
 x_133 = lean_array_push(x_132, x_131);
-x_134 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__5;
+x_134 = l___private_Lean_Elab_Term_13__isExplicit___closed__2;
 x_135 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_135, 0, x_134);
 lean_ctor_set(x_135, 1, x_133);
-x_136 = lean_array_push(x_128, x_135);
-x_137 = l___private_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__16;
-x_138 = lean_array_push(x_136, x_137);
-x_139 = lean_array_push(x_138, x_125);
-x_140 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_140, 0, x_130);
-lean_ctor_set(x_140, 1, x_139);
-if (lean_is_scalar(x_127)) {
- x_141 = lean_alloc_ctor(0, 2, 0);
+if (lean_is_scalar(x_120)) {
+ x_136 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_141 = x_127;
+ x_136 = x_120;
 }
-lean_ctor_set(x_141, 0, x_140);
-lean_ctor_set(x_141, 1, x_126);
-return x_141;
+lean_ctor_set(x_136, 0, x_135);
+lean_ctor_set(x_136, 1, x_119);
+return x_136;
+}
+else
+{
+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; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; 
+x_137 = lean_ctor_get(x_117, 0);
+lean_inc(x_137);
+x_138 = lean_ctor_get(x_117, 1);
+lean_inc(x_138);
+if (lean_is_exclusive(x_117)) {
+ lean_ctor_release(x_117, 0);
+ lean_ctor_release(x_117, 1);
+ x_139 = x_117;
+} else {
+ lean_dec_ref(x_117);
+ x_139 = lean_box(0);
+}
+x_140 = l_Array_empty___closed__1;
+x_141 = lean_array_push(x_140, x_109);
+x_142 = l_Lean_nullKind___closed__2;
+x_143 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_143, 0, x_142);
+lean_ctor_set(x_143, 1, x_141);
+x_144 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__9;
+x_145 = lean_array_push(x_144, x_143);
+x_146 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__7;
+x_147 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_147, 0, x_146);
+lean_ctor_set(x_147, 1, x_145);
+x_148 = lean_array_push(x_140, x_147);
+x_149 = l___private_Lean_Elab_Quotation_4__getHeadInfo___elambda__3___closed__16;
+x_150 = lean_array_push(x_148, x_149);
+x_151 = lean_array_push(x_150, x_137);
+x_152 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_152, 0, x_142);
+lean_ctor_set(x_152, 1, x_151);
+if (lean_is_scalar(x_139)) {
+ x_153 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_153 = x_139;
+}
+lean_ctor_set(x_153, 0, x_152);
+lean_ctor_set(x_153, 1, x_138);
+return x_153;
 }
 }
 }
 }
 else
 {
-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; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; 
+lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; 
 lean_dec(x_6);
-x_146 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__8;
-x_147 = l_Lean_mkAtomFrom(x_1, x_146);
-x_148 = l_Lean_nullKind;
-x_149 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_149, 0, x_148);
-lean_ctor_set(x_149, 1, x_5);
-x_150 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__9;
-x_151 = l_Lean_mkAtomFrom(x_1, x_150);
-x_152 = l_Lean_Elab_Term_mkExplicitBinder___closed__7;
-x_153 = lean_array_push(x_152, x_147);
-x_154 = lean_array_push(x_153, x_149);
-x_155 = l_Lean_mkOptionalNode___closed__1;
-x_156 = lean_array_push(x_154, x_155);
-x_157 = lean_array_push(x_156, x_151);
-x_158 = lean_array_push(x_157, x_2);
+x_158 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__10;
+x_159 = l_Lean_mkAtomFrom(x_1, x_158);
+x_160 = l_Lean_nullKind;
+x_161 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_161, 0, x_160);
+lean_ctor_set(x_161, 1, x_5);
+x_162 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__11;
+x_163 = l_Lean_mkAtomFrom(x_1, x_162);
+x_164 = l_Lean_Elab_Term_mkExplicitBinder___closed__7;
+x_165 = lean_array_push(x_164, x_159);
+x_166 = lean_array_push(x_165, x_161);
+x_167 = l_Lean_mkOptionalNode___closed__1;
+x_168 = lean_array_push(x_166, x_167);
+x_169 = lean_array_push(x_168, x_163);
+x_170 = lean_array_push(x_169, x_2);
 if (x_3 == 0)
 {
-lean_object* x_159; lean_object* x_160; lean_object* x_161; 
-x_159 = l___private_Lean_Elab_Binders_11__expandFunBindersAux___main___closed__2;
-x_160 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_160, 0, x_159);
-lean_ctor_set(x_160, 1, x_158);
-x_161 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_161, 0, x_160);
-lean_ctor_set(x_161, 1, x_7);
-return x_161;
+lean_object* x_171; lean_object* x_172; lean_object* x_173; 
+x_171 = l___private_Lean_Elab_Binders_11__expandFunBindersAux___main___closed__2;
+x_172 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_172, 0, x_171);
+lean_ctor_set(x_172, 1, x_170);
+x_173 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_173, 0, x_172);
+lean_ctor_set(x_173, 1, x_7);
+return x_173;
 }
 else
 {
-lean_object* x_162; lean_object* x_163; lean_object* x_164; 
-x_162 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__10;
-x_163 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_163, 0, x_162);
-lean_ctor_set(x_163, 1, x_158);
-x_164 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_164, 0, x_163);
-lean_ctor_set(x_164, 1, x_7);
-return x_164;
+lean_object* x_174; lean_object* x_175; lean_object* x_176; 
+x_174 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__12;
+x_175 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_175, 0, x_174);
+lean_ctor_set(x_175, 1, x_170);
+x_176 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_176, 0, x_175);
+lean_ctor_set(x_176, 1, x_7);
+return x_176;
 }
 }
 }
@@ -17226,13 +17271,13 @@ else
 {
 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; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; 
 lean_dec(x_5);
-x_139 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__8;
+x_139 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__10;
 x_140 = l_Lean_mkAtomFrom(x_1, x_139);
 x_141 = l_Lean_nullKind;
 x_142 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_142, 0, x_141);
 lean_ctor_set(x_142, 1, x_4);
-x_143 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__9;
+x_143 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__11;
 x_144 = l_Lean_mkAtomFrom(x_1, x_143);
 x_145 = l_Lean_Elab_Term_mkExplicitBinder___closed__7;
 x_146 = lean_array_push(x_145, x_140);
@@ -18247,6 +18292,10 @@ l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__9
 lean_mark_persistent(l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__9);
 l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__10 = _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__10();
 lean_mark_persistent(l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__10);
+l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__11 = _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__11();
+lean_mark_persistent(l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__11);
+l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__12 = _init_l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__12();
+lean_mark_persistent(l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__12);
 l___regBuiltin_Lean_Elab_Term_elabFun___closed__1 = _init_l___regBuiltin_Lean_Elab_Term_elabFun___closed__1();
 lean_mark_persistent(l___regBuiltin_Lean_Elab_Term_elabFun___closed__1);
 res = l___regBuiltin_Lean_Elab_Term_elabFun(lean_io_mk_world());

stage0/stdlib/Lean/Elab/Declaration.c

@@ -19,7 +19,6 @@ lean_object* l_Lean_Elab_applyVisibility___at_Lean_Elab_Command_expandDeclId___s
 lean_object* l_Lean_extractMacroScopes(lean_object*);
 lean_object* l_Lean_Elab_expandOptDeclSig(lean_object*);
 lean_object* l___private_Lean_Elab_Declaration_8__expandMutualPreamble_x3f___closed__5;
-lean_object* l___private_Lean_Elab_Declaration_9__expandMutualElement_x3f___closed__1;
 lean_object* l_Lean_Elab_Command_elabAxiom___lambda__2___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_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Declaration_9__expandMutualElement_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Declaration_8__expandMutualPreamble_x3f___closed__3;
@@ -94,6 +93,7 @@ lean_object* l_Lean_Elab_elabModifiers___at_Lean_Elab_Command_elabMutualDef___sp
 lean_object* l_Lean_replaceRef(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabInductiveViews(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*);
+extern lean_object* l___private_Lean_Elab_PreDefinition_Basic_4__getLevelParamsPreDecls___closed__1;
 lean_object* l_Lean_Elab_Command_elabAxiom___lambda__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*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at___private_Lean_Elab_Declaration_9__expandMutualElement_x3f___spec__1(lean_object*, lean_object*);
 extern lean_object* l___regBuiltin_Lean_Elab_Command_elabOpen___closed__2;
@@ -102,6 +102,7 @@ extern lean_object* l___regBuiltin_Lean_Elab_Command_elabVariables___closed__2;
 extern lean_object* l_Lean_Elab_elabModifiers___rarg___lambda__3___closed__2;
 lean_object* l_Lean_Elab_Command_elabClassInductive(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
+extern lean_object* l___private_Lean_Meta_RecursorInfo_10__getProduceMotiveAndRecursive___closed__1;
 extern lean_object* l_Lean_Elab_Command_isDefLike___closed__9;
 extern lean_object* l___private_Lean_Elab_Quotation_2__quoteSyntax___main___closed__44;
 lean_object* l_Lean_Elab_Command_elabCommand___main(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -142,7 +143,6 @@ lean_object* l_Lean_Elab_Command_expandDeclNamespace_x3f___closed__8;
 lean_object* l_Lean_Elab_Command_getCurrMacroScope(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_Declaration_1__inductiveSyntaxToView___spec__1___closed__4;
 extern lean_object* l_Lean_SourceInfo_inhabited___closed__1;
-extern lean_object* l___private_Lean_Elab_PreDefinition_4__getLevelParamsPreDecls___closed__1;
 lean_object* l_Lean_Syntax_getArgs(lean_object*);
 lean_object* l_Lean_Syntax_getKind(lean_object*);
 lean_object* l_Lean_MacroScopesView_review(lean_object*);
@@ -1883,7 +1883,7 @@ lean_dec(x_39);
 x_42 = lean_ctor_get(x_40, 0);
 lean_inc(x_42);
 lean_dec(x_40);
-x_43 = l___private_Lean_Elab_PreDefinition_4__getLevelParamsPreDecls___closed__1;
+x_43 = l___private_Lean_Elab_PreDefinition_Basic_4__getLevelParamsPreDecls___closed__1;
 lean_inc(x_42);
 x_44 = l_Lean_CollectLevelParams_main___main(x_42, x_43);
 x_45 = lean_ctor_get(x_44, 2);
@@ -4678,19 +4678,6 @@ return x_146;
 }
 }
 }
-lean_object* _init_l___private_Lean_Elab_Declaration_9__expandMutualElement_x3f___closed__1() {
-_start:
-{
-lean_object* x_1; uint8_t x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Array_empty___closed__1;
-x_2 = 0;
-x_3 = lean_box(x_2);
-x_4 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_4, 0, x_1);
-lean_ctor_set(x_4, 1, x_3);
-return x_4;
-}
-}
 lean_object* l___private_Lean_Elab_Declaration_9__expandMutualElement_x3f(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -4709,7 +4696,7 @@ x_10 = l_Lean_Syntax_getArg(x_1, x_9);
 x_11 = l_Lean_Syntax_getArgs(x_10);
 lean_dec(x_10);
 x_12 = lean_unsigned_to_nat(0u);
-x_13 = l___private_Lean_Elab_Declaration_9__expandMutualElement_x3f___closed__1;
+x_13 = l___private_Lean_Meta_RecursorInfo_10__getProduceMotiveAndRecursive___closed__1;
 x_14 = l_Array_iterateMAux___main___at___private_Lean_Elab_Declaration_9__expandMutualElement_x3f___spec__2(x_1, x_8, x_11, x_12, x_13, x_2, x_3, x_7);
 lean_dec(x_11);
 lean_dec(x_8);
@@ -6126,8 +6113,6 @@ l___private_Lean_Elab_Declaration_8__expandMutualPreamble_x3f___closed__5 = _ini
 lean_mark_persistent(l___private_Lean_Elab_Declaration_8__expandMutualPreamble_x3f___closed__5);
 l___private_Lean_Elab_Declaration_8__expandMutualPreamble_x3f___closed__6 = _init_l___private_Lean_Elab_Declaration_8__expandMutualPreamble_x3f___closed__6();
 lean_mark_persistent(l___private_Lean_Elab_Declaration_8__expandMutualPreamble_x3f___closed__6);
-l___private_Lean_Elab_Declaration_9__expandMutualElement_x3f___closed__1 = _init_l___private_Lean_Elab_Declaration_9__expandMutualElement_x3f___closed__1();
-lean_mark_persistent(l___private_Lean_Elab_Declaration_9__expandMutualElement_x3f___closed__1);
 l_Array_iterateMAux___main___at___private_Lean_Elab_Declaration_10__expandMutualNamespace_x3f___spec__1___closed__1 = _init_l_Array_iterateMAux___main___at___private_Lean_Elab_Declaration_10__expandMutualNamespace_x3f___spec__1___closed__1();
 lean_mark_persistent(l_Array_iterateMAux___main___at___private_Lean_Elab_Declaration_10__expandMutualNamespace_x3f___spec__1___closed__1);
 l_Array_iterateMAux___main___at___private_Lean_Elab_Declaration_10__expandMutualNamespace_x3f___spec__1___closed__2 = _init_l_Array_iterateMAux___main___at___private_Lean_Elab_Declaration_10__expandMutualNamespace_x3f___spec__1___closed__2();

stage0/stdlib/Lean/Elab/DoNotation.c

@@ -76,7 +76,6 @@ lean_object* l_Lean_Elab_Term_tryPostponeIfNoneOrMVar(lean_object*, lean_object*
 lean_object* l_Lean_Elab_logTrace___at_Lean_Elab_Term_traceAtCmdPos___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_elabTermEnsuringType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
-lean_object* l_Lean_Elab_throwUnsupportedSyntax___at___private_Lean_Elab_Term_20__elabCDot___spec__1___rarg(lean_object*);
 extern lean_object* l_Lean_Expr_Inhabited___closed__1;
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* lean_st_ref_take(lean_object*, lean_object*);
@@ -106,6 +105,7 @@ lean_object* l___private_Lean_Elab_DoNotation_11__processDoElemsAux___main(lean_
 lean_object* l___private_Lean_Elab_DoNotation_13__regTraceClasses(lean_object*);
 lean_object* l___private_Lean_Elab_DoNotation_4__hasLiftMethod___main___closed__3;
 lean_object* l___private_Lean_Elab_DoNotation_9__extractTypeFormerAppArg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Elab_throwUnsupportedSyntax___at___private_Lean_Elab_Term_19__elabCDot___spec__1___rarg(lean_object*);
 uint8_t l_Array_isEmpty___rarg(lean_object*);
 lean_object* l___private_Lean_Elab_DoNotation_8__expandDoElems(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_DoNotation_4__hasLiftMethod___boxed(lean_object*);
@@ -5556,7 +5556,7 @@ lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_3);
-x_167 = l_Lean_Elab_throwUnsupportedSyntax___at___private_Lean_Elab_Term_20__elabCDot___spec__1___rarg(x_130);
+x_167 = l_Lean_Elab_throwUnsupportedSyntax___at___private_Lean_Elab_Term_19__elabCDot___spec__1___rarg(x_130);
 x_168 = !lean_is_exclusive(x_167);
 if (x_168 == 0)
 {

stage0/stdlib/Lean/Elab/Inductive.c

@@ -133,7 +133,6 @@ lean_object* l_Array_forMAux___main___at_Lean_Elab_applyAttributesImp___spec__1(
 lean_object* l___private_Lean_Elab_Inductive_15__isInductiveFamily(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_mk_ibelow(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Inductive_35__mkInductiveDecl___lambda__1___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_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__1;
 lean_object* l___private_Lean_Elab_Inductive_29__collectLevelParamsInInductive(lean_object*);
 lean_object* l___private_Lean_Elab_Inductive_20__collectUniversesFromCtorTypeAux___main___lambda__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*, lean_object*);
 lean_object* l___private_Lean_Elab_Inductive_7__getResultingType___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -191,6 +190,7 @@ lean_object* l_Array_contains___at_Lean_Elab_Command_accLevelAtCtor___main___spe
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabInductiveViews(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Std_PersistentHashMap_find_x21___rarg___closed__2;
+extern lean_object* l_Lean_MonadCacheT_MonadLift___closed__1;
 lean_object* l___private_Lean_Elab_Inductive_1__elabHeaderAux___main___lambda__1___closed__2;
 lean_object* l___private_Lean_Elab_Inductive_11__checkHeaders___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___private_Lean_Elab_Inductive_26__removeUnused___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -13206,7 +13206,7 @@ x_37 = l___private_Lean_Elab_Inductive_34__mkAuxConstructions(x_4, x_10, x_11, x
 x_38 = lean_ctor_get(x_37, 1);
 lean_inc(x_38);
 lean_dec(x_37);
-x_39 = l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__1;
+x_39 = l_Lean_MonadCacheT_MonadLift___closed__1;
 x_40 = l_ReaderT_MonadLift___closed__1;
 x_41 = lean_unsigned_to_nat(0u);
 x_42 = l_Array_forMAux___main___at___private_Lean_Elab_Inductive_35__mkInductiveDecl___spec__3(x_39, x_40, x_39, x_40, x_4, x_41, x_10, x_11, x_12, x_13, x_14, x_15, x_38);

stage0/stdlib/Lean/Elab/PreDefinition/WF.c

@@ -0,0 +1,114 @@
+// Lean compiler output
+// Module: Lean.Elab.PreDefinition.WF
+// Imports: Init Lean.Elab.PreDefinition.Basic
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* l_Lean_Elab_WFRecursion(lean_object*);
+lean_object* l_Lean_Elab_WFRecursion___boxed(lean_object*);
+lean_object* l_Lean_Elab_WFRecursion___rarg___closed__3;
+lean_object* l_Lean_Elab_WFRecursion___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Elab_WFRecursion___rarg___closed__1;
+lean_object* l_Lean_Elab_WFRecursion___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Elab_WFRecursion___rarg___closed__2;
+lean_object* l_Lean_throwError___at_Lean_Elab_Term_throwErrorIfErrors___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* _init_l_Lean_Elab_WFRecursion___rarg___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("WIP");
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Elab_WFRecursion___rarg___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Elab_WFRecursion___rarg___closed__1;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+lean_object* _init_l_Lean_Elab_WFRecursion___rarg___closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Elab_WFRecursion___rarg___closed__2;
+x_2 = lean_alloc_ctor(0, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
+lean_object* l_Lean_Elab_WFRecursion___rarg(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) {
+_start:
+{
+lean_object* x_8; lean_object* x_9; 
+x_8 = l_Lean_Elab_WFRecursion___rarg___closed__3;
+x_9 = l_Lean_throwError___at_Lean_Elab_Term_throwErrorIfErrors___spec__1___rarg(x_8, x_1, x_2, x_3, x_4, x_5, x_6, x_7);
+return x_9;
+}
+}
+lean_object* l_Lean_Elab_WFRecursion(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Elab_WFRecursion___rarg___boxed), 7, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Elab_WFRecursion___rarg___boxed(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) {
+_start:
+{
+lean_object* x_8; 
+x_8 = l_Lean_Elab_WFRecursion___rarg(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_8;
+}
+}
+lean_object* l_Lean_Elab_WFRecursion___boxed(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_Lean_Elab_WFRecursion(x_1);
+lean_dec(x_1);
+return x_2;
+}
+}
+lean_object* initialize_Init(lean_object*);
+lean_object* initialize_Lean_Elab_PreDefinition_Basic(lean_object*);
+static bool _G_initialized = false;
+lean_object* initialize_Lean_Elab_PreDefinition_WF(lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Lean_Elab_PreDefinition_Basic(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+l_Lean_Elab_WFRecursion___rarg___closed__1 = _init_l_Lean_Elab_WFRecursion___rarg___closed__1();
+lean_mark_persistent(l_Lean_Elab_WFRecursion___rarg___closed__1);
+l_Lean_Elab_WFRecursion___rarg___closed__2 = _init_l_Lean_Elab_WFRecursion___rarg___closed__2();
+lean_mark_persistent(l_Lean_Elab_WFRecursion___rarg___closed__2);
+l_Lean_Elab_WFRecursion___rarg___closed__3 = _init_l_Lean_Elab_WFRecursion___rarg___closed__3();
+lean_mark_persistent(l_Lean_Elab_WFRecursion___rarg___closed__3);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

stage0/stdlib/Lean/Elab/StructInst.c

@@ -182,6 +182,7 @@ lean_object* l_Lean_Elab_Term_StructInst_Struct_structName(lean_object*);
 extern lean_object* l___private_Lean_Elab_Term_5__hasCDot___main___closed__1;
 lean_object* l_Lean_Expr_getAppNumArgsAux___main(lean_object*, lean_object*);
 uint8_t lean_metavar_ctx_is_expr_assigned(lean_object*, lean_object*);
+extern lean_object* l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__11;
 lean_object* l_Lean_Elab_Term_StructInst_defaultMissing_x3f___boxed(lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_mkDefaultValueAux_x3f___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_25__elabStructInstAux___closed__2;
@@ -246,7 +247,6 @@ lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_StructInst_Field_toSynt
 lean_object* l___private_Lean_Elab_StructInst_4__elabModifyOp___closed__20;
 lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_propagateLoop___main___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_object* l_Lean_Elab_Term_StructInst_DefaultFields_getFieldName___boxed(lean_object*);
-extern lean_object* l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__2;
 lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_getHierarchyDepth(lean_object*);
 extern lean_object* l_Std_PersistentArray_Stats_toString___closed__4;
 lean_object* l_List_head_x21___at___private_Lean_Elab_StructInst_19__expandStruct___main___spec__3(lean_object*);
@@ -375,7 +375,6 @@ lean_object* l_Lean_Elab_Term_StructInst_throwFailedToElabField___rarg___closed_
 lean_object* l_Std_AssocList_find_x3f___main___at___private_Lean_Elab_StructInst_12__mkFieldMap___spec__2___boxed(lean_object*, lean_object*);
 lean_object* lean_environment_main_module(lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_4__elabModifyOp___closed__22;
-extern lean_object* l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__9;
 extern lean_object* l___private_Lean_Elab_App_22__elabAppFn___main___closed__13;
 uint8_t l_Lean_Expr_isMVar(lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at___private_Lean_Elab_StructInst_3__isModifyOp_x3f___spec__1___closed__5;
@@ -515,6 +514,7 @@ lean_object* l_Array_iterateMAux___main___at_Lean_mkAppN___spec__1(lean_object*,
 extern lean_object* l_Lean_arrayToExpr___rarg___closed__2;
 lean_object* l___private_Lean_Elab_StructInst_4__elabModifyOp___closed__8;
 lean_object* l_Lean_Elab_Term_StructInst_Field_hasFormat;
+extern lean_object* l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__2;
 lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefaultAux___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_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at___private_Lean_Elab_StructInst_19__expandStruct___main___spec__8(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_6__toFieldLHS(lean_object*);
@@ -2600,7 +2600,7 @@ x_81 = lean_array_push(x_79, x_80);
 x_82 = lean_array_push(x_81, x_53);
 x_83 = l___private_Lean_Elab_Quotation_2__quoteSyntax___main___closed__45;
 x_84 = lean_array_push(x_82, x_83);
-x_85 = l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__2;
+x_85 = l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__2;
 x_86 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_86, 0, x_85);
 lean_ctor_set(x_86, 1, x_84);
@@ -2866,7 +2866,7 @@ x_218 = lean_array_push(x_216, x_217);
 x_219 = lean_array_push(x_218, x_188);
 x_220 = l___private_Lean_Elab_Quotation_2__quoteSyntax___main___closed__45;
 x_221 = lean_array_push(x_219, x_220);
-x_222 = l_Array_iterateMAux___main___at___private_Lean_Elab_App_27__expandApp___spec__1___closed__2;
+x_222 = l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__2;
 x_223 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_223, 0, x_222);
 lean_ctor_set(x_223, 1, x_221);
@@ -9341,7 +9341,7 @@ lean_object* _init_l_Lean_Elab_Term_StructInst_formatStruct___main___closed__5()
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__9;
+x_1 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__11;
 x_2 = lean_alloc_ctor(2, 1, 0);
 lean_ctor_set(x_2, 0, x_1);
 return x_2;

stage0/stdlib/Lean/Elab/Structure.c

@@ -16114,7 +16114,6 @@ x_29 = l_Lean_LocalDecl_binderInfo(x_19);
 x_30 = l_Lean_LocalDecl_type(x_19);
 lean_dec(x_19);
 x_31 = l_Lean_mkForall(x_28, x_29, x_30, x_26);
-lean_dec(x_28);
 x_2 = x_14;
 x_3 = x_31;
 x_10 = x_23;
@@ -16143,7 +16142,6 @@ x_39 = l_Lean_LocalDecl_binderInfo(x_19);
 x_40 = l_Lean_LocalDecl_type(x_19);
 lean_dec(x_19);
 x_41 = l_Lean_mkForall(x_38, x_39, x_40, x_26);
-lean_dec(x_38);
 x_2 = x_14;
 x_3 = x_41;
 x_10 = x_23;

stage0/stdlib/Lean/Elab/Tactic/Basic.c

@@ -332,7 +332,6 @@ lean_object* l_Lean_Elab_Tactic_saveAllState___boxed(lean_object*);
 lean_object* l_Lean_Elab_Tactic_State_inhabited;
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at___private_Lean_Elab_Tactic_Basic_5__sortFVarIds___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__10;
 lean_object* l_Std_mkHashMap___at_Lean_Elab_Tactic_tacticElabAttribute___spec__2(lean_object*);
 lean_object* l_Lean_Meta_isExprMVarAssigned___at_Lean_Elab_Tactic_pruneSolvedGoals___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_AssocList_find_x3f___main___at_Lean_Elab_Tactic_evalTactic___main___spec__7(lean_object*, lean_object*);
@@ -377,6 +376,7 @@ lean_object* l_Lean_Elab_Tactic_evalTactic___main___closed__1;
 lean_object* l___regBuiltin_Lean_Elab_Tactic_evalNestedTacticBlock(lean_object*);
 lean_object* l_Lean_Elab_Tactic_liftTermElabM___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_environment_main_module(lean_object*);
+extern lean_object* l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__9;
 lean_object* l___regBuiltin_Lean_Elab_Tactic_evalTraceState___closed__1;
 lean_object* l_Lean_Elab_Tactic_evalSubst___closed__2;
 lean_object* l___private_Lean_Elab_Tactic_Basic_2__expandTacticMacroFns___main___closed__3;
@@ -450,7 +450,6 @@ lean_object* l_Lean_Elab_Tactic_adaptExpander(lean_object*, lean_object*, lean_o
 lean_object* l_Lean_Elab_Tactic_evalTraceState___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Tactic_focusAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Tactic_getFVarIds(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__5;
 lean_object* l_Lean_Meta_getMVars___at_Lean_Elab_Tactic_ensureHasNoMVars___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_Elab_Tactic_evalSeq___closed__3;
 lean_object* l_Lean_Meta_intro1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -515,6 +514,7 @@ lean_object* lean_usize_to_nat(size_t);
 extern lean_object* l_Lean_Elab_mkMacroAttribute___closed__2;
 lean_object* l_Lean_Elab_Tactic_orelse___rarg(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_Elab_Tactic_getCurrMacroScope(lean_object*, lean_object*);
+extern lean_object* l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__12;
 lean_object* l_Array_umapMAux___main___at_Lean_Elab_Tactic_getFVarIds___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* l_Lean_Elab_Tactic_getMainModule(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_findAux___main___at_Lean_Elab_Tactic_evalTactic___main___spec__4(lean_object*, size_t, lean_object*);
@@ -9725,7 +9725,7 @@ lean_object* l_Lean_Elab_Tactic_evalIntro(lean_object* x_1, lean_object* x_2, le
 _start:
 {
 uint8_t x_11; lean_object* x_190; uint8_t x_191; 
-x_190 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__5;
+x_190 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__7;
 lean_inc(x_1);
 x_191 = l_Lean_Syntax_isOfKind(x_1, x_190);
 if (x_191 == 0)
@@ -9819,9 +9819,9 @@ x_28 = l_Lean_nullKind___closed__2;
 x_29 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_29, 0, x_28);
 lean_ctor_set(x_29, 1, x_27);
-x_30 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__7;
+x_30 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__9;
 x_31 = lean_array_push(x_30, x_29);
-x_32 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__5;
+x_32 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__7;
 x_33 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_33, 0, x_32);
 lean_ctor_set(x_33, 1, x_31);
@@ -9970,10 +9970,10 @@ x_82 = l_Lean_nullKind___closed__2;
 x_83 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_83, 0, x_82);
 lean_ctor_set(x_83, 1, x_81);
-x_84 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__7;
+x_84 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__9;
 lean_inc(x_83);
 x_85 = lean_array_push(x_84, x_83);
-x_86 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__5;
+x_86 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__7;
 x_87 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_87, 0, x_86);
 lean_ctor_set(x_87, 1, x_85);
@@ -10019,7 +10019,7 @@ x_116 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_116, 0, x_82);
 lean_ctor_set(x_116, 1, x_115);
 x_117 = lean_array_push(x_102, x_116);
-x_118 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__10;
+x_118 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__12;
 x_119 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_119, 0, x_118);
 lean_ctor_set(x_119, 1, x_117);
@@ -10228,7 +10228,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_2 = l_Lean_Elab_Tactic_tacticElabAttribute;
-x_3 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__5;
+x_3 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__7;
 x_4 = l___regBuiltin_Lean_Elab_Tactic_evalIntro___closed__1;
 x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1);
 return x_5;

stage0/stdlib/Lean/Elab/Tactic/Generalize.c

@@ -13,7 +13,6 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-lean_object* l___private_Lean_Elab_Tactic_Generalize_5__evalGeneralizeFallback___lambda__1___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_Expr_eq_x3f___closed__2;
 lean_object* l_Lean_Expr_mvarId_x21(lean_object*);
 lean_object* l_Lean_Meta_introN(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -33,7 +32,6 @@ lean_object* l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(lean_object*, lean_obj
 extern lean_object* l_Lean_Elab_Tactic_liftMetaTactic___closed__1;
 lean_object* l___private_Lean_Elab_Tactic_Generalize_5__evalGeneralizeFallback(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_object* l___private_Lean_Elab_Tactic_Generalize_2__getVarName___boxed(lean_object*);
-lean_object* l___private_Lean_Elab_Tactic_Generalize_4__evalGeneralizeWithEq___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Tactic_Generalize_4__evalGeneralizeWithEq___lambda__1___closed__1;
 lean_object* l_Lean_Meta_getMVarType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
@@ -471,6 +469,8 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_2);
 lean_dec(x_1);
 x_39 = !lean_is_exclusive(x_23);
 if (x_39 == 0)
@@ -501,6 +501,8 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_2);
 lean_dec(x_1);
 x_43 = !lean_is_exclusive(x_20);
 if (x_43 == 0)
@@ -530,6 +532,8 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_2);
 lean_dec(x_1);
 x_47 = !lean_is_exclusive(x_16);
 if (x_47 == 0)
@@ -556,6 +560,8 @@ else
 lean_object* x_51; lean_object* x_52; lean_object* x_53; 
 lean_dec(x_12);
 lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
 lean_dec(x_1);
 x_51 = lean_ctor_get(x_10, 1);
 lean_inc(x_51);
@@ -577,6 +583,8 @@ lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
 lean_dec(x_1);
 x_54 = !lean_is_exclusive(x_10);
 if (x_54 == 0)
@@ -625,7 +633,7 @@ x_18 = lean_alloc_closure((void*)(l_Lean_Meta_generalize), 8, 3);
 lean_closure_set(x_18, 0, x_16);
 lean_closure_set(x_18, 1, x_2);
 lean_closure_set(x_18, 2, x_3);
-x_19 = lean_alloc_closure((void*)(l___private_Lean_Elab_Tactic_Generalize_4__evalGeneralizeWithEq___lambda__1___boxed), 9, 3);
+x_19 = lean_alloc_closure((void*)(l___private_Lean_Elab_Tactic_Generalize_4__evalGeneralizeWithEq___lambda__1), 9, 3);
 lean_closure_set(x_19, 0, x_2);
 lean_closure_set(x_19, 1, x_1);
 lean_closure_set(x_19, 2, x_3);
@@ -681,16 +689,6 @@ return x_30;
 }
 }
 }
-lean_object* l___private_Lean_Elab_Tactic_Generalize_4__evalGeneralizeWithEq___lambda__1___boxed(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) {
-_start:
-{
-lean_object* x_10; 
-x_10 = l___private_Lean_Elab_Tactic_Generalize_4__evalGeneralizeWithEq___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9);
-lean_dec(x_3);
-lean_dec(x_2);
-return x_10;
-}
-}
 lean_object* l___private_Lean_Elab_Tactic_Generalize_5__evalGeneralizeFallback___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, lean_object* x_9, lean_object* x_10) {
 _start:
 {
@@ -744,6 +742,8 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
 x_27 = !lean_is_exclusive(x_14);
@@ -774,6 +774,8 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
 x_31 = !lean_is_exclusive(x_11);
@@ -820,7 +822,7 @@ lean_inc(x_2);
 x_18 = lean_alloc_closure((void*)(l_Lean_Meta_inferType___at___private_Lean_Meta_InferType_1__inferAppType___spec__1), 6, 1);
 lean_closure_set(x_18, 0, x_2);
 lean_inc(x_16);
-x_19 = lean_alloc_closure((void*)(l___private_Lean_Elab_Tactic_Generalize_5__evalGeneralizeFallback___lambda__1___boxed), 10, 4);
+x_19 = lean_alloc_closure((void*)(l___private_Lean_Elab_Tactic_Generalize_5__evalGeneralizeFallback___lambda__1), 10, 4);
 lean_closure_set(x_19, 0, x_16);
 lean_closure_set(x_19, 1, x_2);
 lean_closure_set(x_19, 2, x_1);
@@ -877,16 +879,6 @@ return x_30;
 }
 }
 }
-lean_object* l___private_Lean_Elab_Tactic_Generalize_5__evalGeneralizeFallback___lambda__1___boxed(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_11; 
-x_11 = l___private_Lean_Elab_Tactic_Generalize_5__evalGeneralizeFallback___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10);
-lean_dec(x_4);
-lean_dec(x_3);
-return x_11;
-}
-}
 lean_object* l_Lean_Elab_Tactic_evalGeneralizeAux___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:
 {

stage0/stdlib/Lean/Elab/Tactic/Match.c

@@ -20,7 +20,6 @@ extern lean_object* l___private_Lean_Elab_Quotation_8__letBindRhss___main___clos
 lean_object* l_Lean_Elab_Tactic_evalMatch___closed__2;
 lean_object* l_Lean_Elab_Tactic_mkTacticSeq___boxed(lean_object*, lean_object*);
 extern lean_object* l_Lean_nullKind;
-lean_object* l___private_Init_LeanInit_14__mapSepElemsMAux___main___at___private_Lean_Elab_Tactic_Match_1__mkAuxiliaryMatchTermAux___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Tactic_Match_1__mkAuxiliaryMatchTermAux___lambda__1___closed__4;
 extern lean_object* l_Lean_Elab_throwUnsupportedSyntax___rarg___closed__1;
 lean_object* l___private_Lean_Elab_Tactic_Match_1__mkAuxiliaryMatchTermAux___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -39,7 +38,6 @@ lean_object* l_Lean_Elab_Tactic_mkTacticSeq(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Tactic_getCurrMacroScope___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
-extern lean_object* l___private_Lean_Elab_Match_32__elabMatchAux___closed__2;
 lean_object* l___private_Lean_Elab_Tactic_Match_2__mkAuxiliaryMatchTerm___closed__1;
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Tactic_evalMatch___spec__1___rarg(lean_object*);
 extern lean_object* l_Lean_Elab_Tactic_evalCase___closed__4;
@@ -57,16 +55,16 @@ lean_object* l___private_Lean_Elab_Tactic_Match_1__mkAuxiliaryMatchTermAux(lean_
 extern lean_object* l_Lean_Parser_Error_toString___closed__2;
 lean_object* l___regBuiltin_Lean_Elab_Tactic_evalMatch___closed__1;
 lean_object* l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_LeanInit_15__mapSepElemsMAux___main___at___private_Lean_Elab_Tactic_Match_1__mkAuxiliaryMatchTermAux___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_FirstTokens_toStr___closed__3;
 extern lean_object* l_Lean_Elab_Tactic_tacticElabAttribute;
+extern lean_object* l___private_Lean_Elab_Match_36__elabMatchAux___closed__2;
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
-extern lean_object* l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__10;
 lean_object* l_Lean_mkSepStx(lean_object*, lean_object*);
 lean_object* l_Lean_mkAtomFrom(lean_object*, lean_object*);
 extern lean_object* l_Lean_Elab_Tactic_evalRefine___closed__1;
 lean_object* l_Lean_Syntax_setArg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_environment_main_module(lean_object*);
-lean_object* l___private_Init_LeanInit_14__mapSepElemsMAux___main___at___private_Lean_Elab_Tactic_Match_1__mkAuxiliaryMatchTermAux___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_SourceInfo_inhabited___closed__1;
 lean_object* l_Lean_Elab_Tactic_evalTactic___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getArgs(lean_object*);
@@ -78,15 +76,17 @@ lean_object* l_Lean_throwErrorAt___at___private_Lean_Elab_Tactic_Basic_1__evalTa
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Tactic_evalMatch___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Elab_Binders_11__expandFunBindersAux___main___closed__2;
 uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*);
+lean_object* l___private_Init_LeanInit_15__mapSepElemsMAux___main___at___private_Lean_Elab_Tactic_Match_1__mkAuxiliaryMatchTermAux___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_mkHole___closed__2;
 lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*);
 extern lean_object* l_Lean_mkOptionalNode___closed__2;
 lean_object* lean_nat_mod(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Tactic_Match_2__mkAuxiliaryMatchTerm(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l___regBuiltin_Lean_Elab_Term_elabSyntheticHole___closed__2;
+extern lean_object* l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__12;
 lean_object* l_Lean_Elab_Tactic_evalMatch___closed__1;
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
-lean_object* l___private_Init_LeanInit_14__mapSepElemsMAux___main___at___private_Lean_Elab_Tactic_Match_1__mkAuxiliaryMatchTermAux___spec__2(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* l___private_Init_LeanInit_15__mapSepElemsMAux___main___at___private_Lean_Elab_Tactic_Match_1__mkAuxiliaryMatchTermAux___spec__2(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) {
 _start:
 {
 lean_object* x_8; uint8_t x_9; 
@@ -192,7 +192,7 @@ _start:
 lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_6 = lean_unsigned_to_nat(0u);
 x_7 = l_Array_empty___closed__1;
-x_8 = l___private_Init_LeanInit_14__mapSepElemsMAux___main___at___private_Lean_Elab_Tactic_Match_1__mkAuxiliaryMatchTermAux___spec__2(x_1, x_2, x_6, x_7, x_3, x_4, x_5);
+x_8 = l___private_Init_LeanInit_15__mapSepElemsMAux___main___at___private_Lean_Elab_Tactic_Match_1__mkAuxiliaryMatchTermAux___spec__2(x_1, x_2, x_6, x_7, x_3, x_4, x_5);
 return x_8;
 }
 }
@@ -335,7 +335,7 @@ if (x_45 == 0)
 {
 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; lean_object* x_57; lean_object* x_58; 
 x_46 = lean_ctor_get(x_3, 0);
-x_47 = l___private_Lean_Elab_Match_32__elabMatchAux___closed__2;
+x_47 = l___private_Lean_Elab_Match_36__elabMatchAux___closed__2;
 lean_inc(x_46);
 x_48 = l_Lean_Name_appendIndexAfter(x_47, x_46);
 x_49 = l_Lean_Name_append___main(x_1, x_48);
@@ -367,7 +367,7 @@ x_60 = lean_ctor_get(x_3, 1);
 lean_inc(x_60);
 lean_inc(x_59);
 lean_dec(x_3);
-x_61 = l___private_Lean_Elab_Match_32__elabMatchAux___closed__2;
+x_61 = l___private_Lean_Elab_Match_36__elabMatchAux___closed__2;
 lean_inc(x_59);
 x_62 = l_Lean_Name_appendIndexAfter(x_61, x_59);
 x_63 = l_Lean_Name_append___main(x_1, x_62);
@@ -538,11 +538,11 @@ return x_48;
 }
 }
 }
-lean_object* l___private_Init_LeanInit_14__mapSepElemsMAux___main___at___private_Lean_Elab_Tactic_Match_1__mkAuxiliaryMatchTermAux___spec__2___boxed(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* l___private_Init_LeanInit_15__mapSepElemsMAux___main___at___private_Lean_Elab_Tactic_Match_1__mkAuxiliaryMatchTermAux___spec__2___boxed(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) {
 _start:
 {
 lean_object* x_8; 
-x_8 = l___private_Init_LeanInit_14__mapSepElemsMAux___main___at___private_Lean_Elab_Tactic_Match_1__mkAuxiliaryMatchTermAux___spec__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
+x_8 = l___private_Init_LeanInit_15__mapSepElemsMAux___main___at___private_Lean_Elab_Tactic_Match_1__mkAuxiliaryMatchTermAux___spec__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
 lean_dec(x_1);
 return x_8;
 }
@@ -1086,7 +1086,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_2 = l_Lean_Elab_Tactic_tacticElabAttribute;
-x_3 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__10;
+x_3 = l___private_Lean_Elab_Binders_16__expandMatchAltsIntoMatchAux___main___closed__12;
 x_4 = l___regBuiltin_Lean_Elab_Tactic_evalMatch___closed__1;
 x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1);
 return x_5;

stage0/stdlib/Lean/LocalContext.c

@@ -83,6 +83,7 @@ lean_object* l_Lean_LocalContext_get_x21(lean_object*, lean_object*);
 lean_object* l_Std_PersistentArray_foldlFromM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_replaceFVarIdAtLocalDecl___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_LocalDecl_binderInfo___boxed(lean_object*);
+lean_object* l_Lean_LocalContext_modifyLocalDecl(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_LocalContext_containsFVar(lean_object*, lean_object*);
 lean_object* l_Std_PersistentArray_findSomeM_x3f___at_Lean_LocalContext_findDecl_x3f___spec__2___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_LocalDecl_index___boxed(lean_object*);
@@ -185,6 +186,7 @@ lean_object* l_Array_anyRangeMAux___main___at_Lean_LocalContext_anyM___spec__5__
 lean_object* l_Lean_Name_appendIndexAfter(lean_object*, lean_object*);
 lean_object* l_Lean_LocalContext_findDeclRev_x3f___rarg(lean_object*, lean_object*);
 lean_object* l_Std_PersistentArray_set___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_LocalDecl_setValue(lean_object*, lean_object*);
 lean_object* l_Array_indexOfAux___main___at_Lean_LocalContext_erase___spec__3___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Lean_LocalContext_allM___spec__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_mk_empty_local_ctx(lean_object*);
@@ -355,6 +357,7 @@ lean_object* l_Lean_LocalContext_getFVars___boxed(lean_object*);
 lean_object* l_Lean_LocalContext_findDeclM_x3f___at_Lean_LocalContext_findDecl_x3f___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_LocalContext_foldl___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentArray_foldlM___at_Lean_LocalContext_foldl___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_LocalDecl_setType(lean_object*, lean_object*);
 uint8_t l_Std_PersistentArray_anyM___at_Lean_LocalContext_all___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Lean_LocalContext_allM___spec__3(lean_object*);
 lean_object* l_Lean_LocalContext_findDeclM_x3f___at_Lean_LocalContext_findDecl_x3f___spec__1___rarg___boxed(lean_object*, lean_object*);
@@ -664,6 +667,78 @@ lean_dec(x_1);
 return x_2;
 }
 }
+lean_object* l_Lean_LocalDecl_setType(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+uint8_t x_3; 
+x_3 = !lean_is_exclusive(x_1);
+if (x_3 == 0)
+{
+lean_object* x_4; 
+x_4 = lean_ctor_get(x_1, 3);
+lean_dec(x_4);
+lean_ctor_set(x_1, 3, x_2);
+return x_1;
+}
+else
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; lean_object* x_9; 
+x_5 = lean_ctor_get(x_1, 0);
+x_6 = lean_ctor_get(x_1, 1);
+x_7 = lean_ctor_get(x_1, 2);
+x_8 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+lean_inc(x_7);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_dec(x_1);
+x_9 = lean_alloc_ctor(0, 4, 1);
+lean_ctor_set(x_9, 0, x_5);
+lean_ctor_set(x_9, 1, x_6);
+lean_ctor_set(x_9, 2, x_7);
+lean_ctor_set(x_9, 3, x_2);
+lean_ctor_set_uint8(x_9, sizeof(void*)*4, x_8);
+return x_9;
+}
+}
+else
+{
+uint8_t x_10; 
+x_10 = !lean_is_exclusive(x_1);
+if (x_10 == 0)
+{
+lean_object* x_11; 
+x_11 = lean_ctor_get(x_1, 3);
+lean_dec(x_11);
+lean_ctor_set(x_1, 3, x_2);
+return x_1;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; 
+x_12 = lean_ctor_get(x_1, 0);
+x_13 = lean_ctor_get(x_1, 1);
+x_14 = lean_ctor_get(x_1, 2);
+x_15 = lean_ctor_get(x_1, 4);
+x_16 = lean_ctor_get_uint8(x_1, sizeof(void*)*5);
+lean_inc(x_15);
+lean_inc(x_14);
+lean_inc(x_13);
+lean_inc(x_12);
+lean_dec(x_1);
+x_17 = lean_alloc_ctor(1, 5, 1);
+lean_ctor_set(x_17, 0, x_12);
+lean_ctor_set(x_17, 1, x_13);
+lean_ctor_set(x_17, 2, x_14);
+lean_ctor_set(x_17, 3, x_2);
+lean_ctor_set(x_17, 4, x_15);
+lean_ctor_set_uint8(x_17, sizeof(void*)*5, x_16);
+return x_17;
+}
+}
+}
+}
 uint8_t l_Lean_LocalDecl_binderInfo(lean_object* x_1) {
 _start:
 {
@@ -741,7 +816,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_1 = l_Lean_LocalDecl_value___closed__1;
-x_2 = lean_unsigned_to_nat(63u);
+x_2 = lean_unsigned_to_nat(67u);
 x_3 = lean_unsigned_to_nat(23u);
 x_4 = l_Lean_LocalDecl_value___closed__2;
 x_5 = l___private_Init_Util_1__mkPanicMessage(x_1, x_2, x_3, x_4);
@@ -777,6 +852,51 @@ lean_dec(x_1);
 return x_2;
 }
 }
+lean_object* l_Lean_LocalDecl_setValue(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_dec(x_2);
+return x_1;
+}
+else
+{
+uint8_t x_3; 
+x_3 = !lean_is_exclusive(x_1);
+if (x_3 == 0)
+{
+lean_object* x_4; 
+x_4 = lean_ctor_get(x_1, 4);
+lean_dec(x_4);
+lean_ctor_set(x_1, 4, x_2);
+return x_1;
+}
+else
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; 
+x_5 = lean_ctor_get(x_1, 0);
+x_6 = lean_ctor_get(x_1, 1);
+x_7 = lean_ctor_get(x_1, 2);
+x_8 = lean_ctor_get(x_1, 3);
+x_9 = lean_ctor_get_uint8(x_1, sizeof(void*)*5);
+lean_inc(x_8);
+lean_inc(x_7);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_dec(x_1);
+x_10 = lean_alloc_ctor(1, 5, 1);
+lean_ctor_set(x_10, 0, x_5);
+lean_ctor_set(x_10, 1, x_6);
+lean_ctor_set(x_10, 2, x_7);
+lean_ctor_set(x_10, 3, x_8);
+lean_ctor_set(x_10, 4, x_2);
+lean_ctor_set_uint8(x_10, sizeof(void*)*5, x_9);
+return x_10;
+}
+}
+}
+}
 lean_object* l_Lean_LocalDecl_updateUserName(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -862,7 +982,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_1 = l_Lean_LocalDecl_value___closed__1;
-x_2 = lean_unsigned_to_nat(72u);
+x_2 = lean_unsigned_to_nat(80u);
 x_3 = lean_unsigned_to_nat(34u);
 x_4 = l_Lean_LocalDecl_updateBinderInfo___closed__1;
 x_5 = l___private_Init_Util_1__mkPanicMessage(x_1, x_2, x_3, x_4);
@@ -1924,7 +2044,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_1 = l_Lean_LocalDecl_value___closed__1;
-x_2 = lean_unsigned_to_nat(134u);
+x_2 = lean_unsigned_to_nat(142u);
 x_3 = lean_unsigned_to_nat(12u);
 x_4 = l_Lean_LocalContext_get_x21___closed__1;
 x_5 = l___private_Init_Util_1__mkPanicMessage(x_1, x_2, x_3, x_4);
@@ -3858,6 +3978,105 @@ return x_32;
 }
 }
 }
+lean_object* l_Lean_LocalContext_modifyLocalDecl(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_1, 1);
+lean_inc(x_5);
+lean_inc(x_1);
+x_6 = lean_local_ctx_find(x_1, x_2);
+if (lean_obj_tag(x_6) == 0)
+{
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+return x_1;
+}
+else
+{
+uint8_t x_7; 
+x_7 = !lean_is_exclusive(x_1);
+if (x_7 == 0)
+{
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+x_8 = lean_ctor_get(x_1, 1);
+lean_dec(x_8);
+x_9 = lean_ctor_get(x_1, 0);
+lean_dec(x_9);
+x_10 = !lean_is_exclusive(x_6);
+if (x_10 == 0)
+{
+lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+x_11 = lean_ctor_get(x_6, 0);
+x_12 = lean_apply_1(x_3, x_11);
+x_13 = l_Lean_LocalDecl_fvarId(x_12);
+lean_inc(x_12);
+x_14 = l_Std_PersistentHashMap_insert___at_Lean_LocalContext_mkLocalDecl___spec__1(x_4, x_13, x_12);
+x_15 = l_Lean_LocalDecl_index(x_12);
+lean_ctor_set(x_6, 0, x_12);
+x_16 = l_Std_PersistentArray_set___rarg(x_5, x_15, x_6);
+lean_dec(x_15);
+lean_ctor_set(x_1, 1, x_16);
+lean_ctor_set(x_1, 0, x_14);
+return x_1;
+}
+else
+{
+lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_17 = lean_ctor_get(x_6, 0);
+lean_inc(x_17);
+lean_dec(x_6);
+x_18 = lean_apply_1(x_3, x_17);
+x_19 = l_Lean_LocalDecl_fvarId(x_18);
+lean_inc(x_18);
+x_20 = l_Std_PersistentHashMap_insert___at_Lean_LocalContext_mkLocalDecl___spec__1(x_4, x_19, x_18);
+x_21 = l_Lean_LocalDecl_index(x_18);
+x_22 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_22, 0, x_18);
+x_23 = l_Std_PersistentArray_set___rarg(x_5, x_21, x_22);
+lean_dec(x_21);
+lean_ctor_set(x_1, 1, x_23);
+lean_ctor_set(x_1, 0, x_20);
+return x_1;
+}
+}
+else
+{
+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_dec(x_1);
+x_24 = lean_ctor_get(x_6, 0);
+lean_inc(x_24);
+if (lean_is_exclusive(x_6)) {
+ lean_ctor_release(x_6, 0);
+ x_25 = x_6;
+} else {
+ lean_dec_ref(x_6);
+ x_25 = lean_box(0);
+}
+x_26 = lean_apply_1(x_3, x_24);
+x_27 = l_Lean_LocalDecl_fvarId(x_26);
+lean_inc(x_26);
+x_28 = l_Std_PersistentHashMap_insert___at_Lean_LocalContext_mkLocalDecl___spec__1(x_4, x_27, x_26);
+x_29 = l_Lean_LocalDecl_index(x_26);
+if (lean_is_scalar(x_25)) {
+ x_30 = lean_alloc_ctor(1, 1, 0);
+} else {
+ x_30 = x_25;
+}
+lean_ctor_set(x_30, 0, x_26);
+x_31 = l_Std_PersistentArray_set___rarg(x_5, x_29, x_30);
+lean_dec(x_29);
+x_32 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_32, 0, x_28);
+lean_ctor_set(x_32, 1, x_31);
+return x_32;
+}
+}
+}
+}
 lean_object* l_Lean_LocalContext_updateBinderInfo(lean_object* x_1, lean_object* x_2, uint8_t x_3) {
 _start:
 {
@@ -5866,7 +6085,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_1 = l_Lean_LocalDecl_value___closed__1;
-x_2 = lean_unsigned_to_nat(320u);
+x_2 = lean_unsigned_to_nat(335u);
 x_3 = lean_unsigned_to_nat(12u);
 x_4 = l_Lean_LocalContext_get_x21___closed__1;
 x_5 = l___private_Init_Util_1__mkPanicMessage(x_1, x_2, x_3, x_4);
@@ -5921,7 +6140,6 @@ if (x_1 == 0)
 {
 lean_object* x_21; 
 x_21 = l_Lean_mkForall(x_17, x_19, x_20, x_5);
-lean_dec(x_17);
 x_4 = x_9;
 x_5 = x_21;
 goto _start;
@@ -5930,7 +6148,6 @@ else
 {
 lean_object* x_23; 
 x_23 = l_Lean_mkLambda(x_17, x_19, x_20, x_5);
-lean_dec(x_17);
 x_4 = x_9;
 x_5 = x_23;
 goto _start;
@@ -5968,7 +6185,6 @@ lean_dec(x_26);
 x_33 = lean_expr_abstract_range(x_27, x_9, x_3);
 lean_dec(x_27);
 x_34 = l_Lean_mkLet(x_25, x_32, x_33, x_5, x_28);
-lean_dec(x_25);
 x_4 = x_9;
 x_5 = x_34;
 goto _start;
@@ -6062,7 +6278,6 @@ lean_dec(x_15);
 x_19 = lean_expr_abstract_range(x_17, x_8, x_2);
 lean_dec(x_17);
 x_20 = l_Lean_mkLambda(x_16, x_18, x_19, x_4);
-lean_dec(x_16);
 x_3 = x_8;
 x_4 = x_20;
 goto _start;
@@ -6099,7 +6314,6 @@ lean_dec(x_23);
 x_30 = lean_expr_abstract_range(x_24, x_8, x_2);
 lean_dec(x_24);
 x_31 = l_Lean_mkLet(x_22, x_29, x_30, x_4, x_25);
-lean_dec(x_22);
 x_3 = x_8;
 x_4 = x_31;
 goto _start;
@@ -6189,7 +6403,6 @@ lean_dec(x_15);
 x_19 = lean_expr_abstract_range(x_17, x_8, x_2);
 lean_dec(x_17);
 x_20 = l_Lean_mkForall(x_16, x_18, x_19, x_4);
-lean_dec(x_16);
 x_3 = x_8;
 x_4 = x_20;
 goto _start;
@@ -6226,7 +6439,6 @@ lean_dec(x_23);
 x_30 = lean_expr_abstract_range(x_24, x_8, x_2);
 lean_dec(x_24);
 x_31 = l_Lean_mkLet(x_22, x_29, x_30, x_4, x_25);
-lean_dec(x_22);
 x_3 = x_8;
 x_4 = x_31;
 goto _start;

stage0/stdlib/Lean/Meta.c

@@ -1,6 +1,6 @@
 // Lean compiler output
 // Module: Lean.Meta
-// Imports: Init Lean.Meta.Basic Lean.Meta.LevelDefEq Lean.Meta.WHNF Lean.Meta.InferType Lean.Meta.FunInfo Lean.Meta.ExprDefEq Lean.Meta.DiscrTree Lean.Meta.Reduce Lean.Meta.Instances Lean.Meta.AbstractMVars Lean.Meta.SynthInstance Lean.Meta.AppBuilder Lean.Meta.Tactic Lean.Meta.KAbstract Lean.Meta.RecursorInfo Lean.Meta.GeneralizeTelescope Lean.Meta.Match Lean.Meta.ReduceEval Lean.Meta.Closure
+// Imports: Init Lean.Meta.Basic Lean.Meta.LevelDefEq Lean.Meta.WHNF Lean.Meta.InferType Lean.Meta.FunInfo Lean.Meta.ExprDefEq Lean.Meta.DiscrTree Lean.Meta.Reduce Lean.Meta.Instances Lean.Meta.AbstractMVars Lean.Meta.SynthInstance Lean.Meta.AppBuilder Lean.Meta.Tactic Lean.Meta.KAbstract Lean.Meta.RecursorInfo Lean.Meta.GeneralizeTelescope Lean.Meta.Match Lean.Meta.ReduceEval Lean.Meta.Closure Lean.Meta.AbstractNestedProofs
 #include <lean/lean.h>
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wunused-parameter"
@@ -33,6 +33,7 @@ lean_object* initialize_Lean_Meta_GeneralizeTelescope(lean_object*);
 lean_object* initialize_Lean_Meta_Match(lean_object*);
 lean_object* initialize_Lean_Meta_ReduceEval(lean_object*);
 lean_object* initialize_Lean_Meta_Closure(lean_object*);
+lean_object* initialize_Lean_Meta_AbstractNestedProofs(lean_object*);
 static bool _G_initialized = false;
 lean_object* initialize_Lean_Meta(lean_object* w) {
 lean_object * res;
@@ -98,6 +99,9 @@ lean_dec_ref(res);
 res = initialize_Lean_Meta_Closure(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
+res = initialize_Lean_Meta_AbstractNestedProofs(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));
 }
 #ifdef __cplusplus

stage0/stdlib/Lean/Meta/AppBuilder.c

@@ -3499,7 +3499,6 @@ lean_dec(x_25);
 x_37 = 0;
 lean_inc(x_35);
 x_38 = l_Lean_mkLambda(x_34, x_37, x_35, x_36);
-lean_dec(x_34);
 lean_inc(x_6);
 lean_inc(x_5);
 lean_inc(x_4);

stage0/stdlib/Lean/Meta/Basic.c

@@ -189,6 +189,7 @@ lean_object* l_Lean_Meta_lambdaTelescope(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_20__forallTelescopeReducingImp___spec__44(lean_object*);
 lean_object* l_Lean_Meta_elimMVarDeps(lean_object*);
 lean_object* l_Lean_MetavarContext_setMVarKind(lean_object*, lean_object*, uint8_t);
+lean_object* l_Lean_Meta_dependsOn___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_16__isClassExpensive_x3f___main___spec__30(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_26__withNewFVar___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getTransparency___rarg(lean_object*);
@@ -196,6 +197,7 @@ lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___a
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_20__forallTelescopeReducingImp___spec__5___rarg___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_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_21__forallBoundedTelescopeImp___spec__52___rarg(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*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_forallTelescope(lean_object*);
+lean_object* l_Lean_Meta_dependsOn(lean_object*);
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getConstNoEx_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_21__forallBoundedTelescopeImp___spec__58___rarg(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*, lean_object*, lean_object*, lean_object*);
@@ -299,7 +301,6 @@ lean_object* l_Lean_Meta_mkFreshExprMVarAt___at___private_Lean_Meta_Basic_3__mkF
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_20__forallTelescopeReducingImp___spec__68___rarg___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_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_Lean_MonadError___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_15__forallTelescopeReducingAux___at___private_Lean_Meta_Basic_21__forallBoundedTelescopeImp___spec__1(lean_object*);
-lean_object* l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__3;
 lean_object* l_Lean_Meta_whnf___rarg___closed__1;
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_19__forallTelescopeImp___spec__37(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_20__forallTelescopeReducingImp___spec__49(lean_object*);
@@ -514,7 +515,6 @@ lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___a
 lean_object* l_Lean_Meta_MetaM_run_x27___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getFVarLocalDecl___at___private_Lean_Meta_Basic_11__withNewLocalInstanceImp___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_20__forallTelescopeReducingImp___spec__41(lean_object*);
-lean_object* l_StateRefT_x27_MonadLift(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_20__forallTelescopeReducingImp___spec__59(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_21__forallBoundedTelescopeImp___spec__3___rarg(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___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_21__forallBoundedTelescopeImp___spec__8(lean_object*);
@@ -533,6 +533,7 @@ lean_object* l_Lean_replaceRef(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_assignExprMVar___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_6__liftMkBindingM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkFreshId___rarg(lean_object*, lean_object*);
+extern lean_object* l_Lean_MonadCacheT_MonadLift___closed__1;
 lean_object* l_Lean_Meta_mkLambdaFVars(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_2__mkFreshExprMVarAtCore(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isReadOnlyExprMVar___rarg(lean_object*, lean_object*);
@@ -796,6 +797,7 @@ lean_object* l_Lean_Meta_State_inhabited___closed__1;
 lean_object* l_Lean_LocalDecl_type(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_19__forallTelescopeImp___spec__9___rarg(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___private_Lean_Meta_Basic_30__withNewMCtxDepthImp(lean_object*);
+lean_object* l_Lean_MetavarContext_exprDependsOn(lean_object*, lean_object*, lean_object*);
 lean_object* lean_local_ctx_mk_local_decl(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t);
 lean_object* l___private_Lean_Meta_Basic_3__mkFreshExprMVarCore___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_20__forallTelescopeReducingImp___spec__39___rarg___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_object*, lean_object*, lean_object*, lean_object*);
@@ -1068,6 +1070,7 @@ lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___a
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_21__forallBoundedTelescopeImp___spec__68(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___rarg___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_object*);
 lean_object* l_List_foldl___main___at___private_Lean_Meta_Basic_29__withExistingLocalDeclsImp___spec__1(lean_object*, lean_object*);
+lean_object* l_Lean_Meta_dependsOn___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_setInlineAttribute___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withNewMCtxDepth(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_20__forallTelescopeReducingImp___spec__47(lean_object*);
@@ -1145,6 +1148,7 @@ lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___a
 lean_object* l_Lean_Meta_withAtLeastTransparency___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_16__isClassExpensive_x3f___main___spec__33(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___at___private_Lean_Meta_Basic_20__forallTelescopeReducingImp___spec__76(lean_object*);
+lean_object* l_Lean_Meta_dependsOn___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getLocalInstances___at___private_Lean_Meta_Basic_3__mkFreshExprMVarCore___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getConfig___rarg___closed__1;
 lean_object* l_Lean_Meta_getParamNames(lean_object*);
@@ -12027,29 +12031,18 @@ return x_17;
 lean_object* _init_l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__1() {
 _start:
 {
-lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_StateRefT_x27_MonadLift), 4, 3);
-lean_closure_set(x_1, 0, lean_box(0));
-lean_closure_set(x_1, 1, lean_box(0));
-lean_closure_set(x_1, 2, lean_box(0));
-return x_1;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = l_Lean_Core_Lean_MonadNameGenerator;
+x_2 = l_Lean_MonadCacheT_MonadLift___closed__1;
+x_3 = l_Lean_monadNameGeneratorLift___rarg(x_1, x_2);
+return x_3;
 }
 }
 lean_object* _init_l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Core_Lean_MonadNameGenerator;
-x_2 = l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__1;
-x_3 = l_Lean_monadNameGeneratorLift___rarg(x_1, x_2);
-return x_3;
-}
-}
-lean_object* _init_l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__3() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__2;
+x_1 = l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__1;
 x_2 = l_ReaderT_MonadLift___closed__1;
 x_3 = l_Lean_monadNameGeneratorLift___rarg(x_1, x_2);
 return x_3;
@@ -12117,7 +12110,7 @@ x_30 = lean_expr_instantiate_rev_range(x_15, x_7, x_29, x_6);
 lean_dec(x_29);
 lean_dec(x_15);
 x_31 = l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___rarg___closed__3;
-x_32 = l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__3;
+x_32 = l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__2;
 x_33 = l_Lean_mkFreshId___rarg(x_31, x_32);
 lean_inc(x_12);
 lean_inc(x_11);
@@ -90284,6 +90277,56 @@ x_2 = lean_alloc_closure((void*)(l_Lean_Meta_instantiateForall___rarg), 3, 0);
 return x_2;
 }
 }
+lean_object* l_Lean_Meta_dependsOn___rarg___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_9; uint8_t x_10; lean_object* x_11; lean_object* x_12; 
+x_9 = l_Lean_MetavarContext_exprDependsOn(x_3, x_1, x_2);
+x_10 = lean_unbox(x_9);
+lean_dec(x_9);
+x_11 = lean_box(x_10);
+x_12 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_12, 0, x_11);
+lean_ctor_set(x_12, 1, x_8);
+return x_12;
+}
+}
+lean_object* l_Lean_Meta_dependsOn___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_4 = lean_alloc_closure((void*)(l_Lean_Meta_dependsOn___rarg___lambda__1___boxed), 8, 2);
+lean_closure_set(x_4, 0, x_2);
+lean_closure_set(x_4, 1, x_3);
+x_5 = l_Lean_Meta_Lean_MonadMCtx___closed__4;
+x_6 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lean_Meta_Lean_MonadLCtx___spec__2___rarg), 7, 2);
+lean_closure_set(x_6, 0, x_5);
+lean_closure_set(x_6, 1, x_4);
+x_7 = lean_apply_2(x_1, lean_box(0), x_6);
+return x_7;
+}
+}
+lean_object* l_Lean_Meta_dependsOn(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Meta_dependsOn___rarg), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Meta_dependsOn___rarg___lambda__1___boxed(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_9; 
+x_9 = l_Lean_Meta_dependsOn___rarg___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+return x_9;
+}
+}
 lean_object* initialize_Init(lean_object*);
 lean_object* initialize_Lean_Data_LOption(lean_object*);
 lean_object* initialize_Lean_Environment(lean_object*);
@@ -90554,8 +90597,6 @@ l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___cl
 lean_mark_persistent(l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__1);
 l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__2 = _init_l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__2();
 lean_mark_persistent(l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__2);
-l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__3 = _init_l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__3();
-lean_mark_persistent(l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__3);
 l_Lean_Meta_getParamNamesImp___closed__1 = _init_l_Lean_Meta_getParamNamesImp___closed__1();
 lean_mark_persistent(l_Lean_Meta_getParamNamesImp___closed__1);
 l_Lean_Meta_normalizeLevel___rarg___closed__1 = _init_l_Lean_Meta_normalizeLevel___rarg___closed__1();

stage0/stdlib/Lean/Meta/Closure.c

@@ -9466,7 +9466,6 @@ if (x_1 == 0)
 {
 lean_object* x_16; 
 x_16 = l_Lean_mkForall(x_12, x_14, x_15, x_5);
-lean_dec(x_12);
 x_4 = x_9;
 x_5 = x_16;
 goto _start;
@@ -9475,7 +9474,6 @@ else
 {
 lean_object* x_18; 
 x_18 = l_Lean_mkLambda(x_12, x_14, x_15, x_5);
-lean_dec(x_12);
 x_4 = x_9;
 x_5 = x_18;
 goto _start;
@@ -9513,7 +9511,6 @@ lean_dec(x_21);
 x_28 = lean_expr_abstract_range(x_22, x_9, x_3);
 lean_dec(x_22);
 x_29 = l_Lean_mkLet(x_20, x_27, x_28, x_5, x_23);
-lean_dec(x_20);
 x_4 = x_9;
 x_5 = x_29;
 goto _start;
@@ -9593,7 +9590,6 @@ lean_dec(x_10);
 x_14 = lean_expr_abstract_range(x_12, x_8, x_2);
 lean_dec(x_12);
 x_15 = l_Lean_mkLambda(x_11, x_13, x_14, x_4);
-lean_dec(x_11);
 x_3 = x_8;
 x_4 = x_15;
 goto _start;
@@ -9630,7 +9626,6 @@ lean_dec(x_18);
 x_25 = lean_expr_abstract_range(x_19, x_8, x_2);
 lean_dec(x_19);
 x_26 = l_Lean_mkLet(x_17, x_24, x_25, x_4, x_20);
-lean_dec(x_17);
 x_3 = x_8;
 x_4 = x_26;
 goto _start;
@@ -9706,7 +9701,6 @@ lean_dec(x_10);
 x_14 = lean_expr_abstract_range(x_12, x_8, x_2);
 lean_dec(x_12);
 x_15 = l_Lean_mkForall(x_11, x_13, x_14, x_4);
-lean_dec(x_11);
 x_3 = x_8;
 x_4 = x_15;
 goto _start;
@@ -9743,7 +9737,6 @@ lean_dec(x_18);
 x_25 = lean_expr_abstract_range(x_19, x_8, x_2);
 lean_dec(x_19);
 x_26 = l_Lean_mkLet(x_17, x_24, x_25, x_4, x_20);
-lean_dec(x_17);
 x_3 = x_8;
 x_4 = x_26;
 goto _start;

stage0/stdlib/Lean/Meta/ExprDefEq.c

@@ -145,7 +145,6 @@ lean_object* l_Lean_Meta_commitWhen___at___private_Lean_Meta_ExprDefEq_15__proce
 lean_object* l___private_Lean_Meta_ExprDefEq_7__isDefEqBinding(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_ExprDefEq_23__isDefEqLeft___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_ExprDefEq_42__isDefEqQuick___main___lambda__1___closed__5;
-extern lean_object* l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__1;
 lean_object* l_Lean_Meta_CheckAssignment_throwOutOfScopeFVar(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Expr_updateLambdaE_x21___closed__1;
 lean_object* l_Lean_Meta_commitWhenSome_x3f___at_Lean_Meta_isExprDefEqAuxImpl___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -200,6 +199,7 @@ lean_object* l_Lean_Meta_CheckAssignment_assignToConstFun___lambda__1(lean_objec
 uint8_t l_Lean_Expr_hasExprMVar(lean_object*);
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_ExprDefEq_42__isDefEqQuick___main___lambda__2(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_MonadCacheT_MonadLift___closed__1;
 extern lean_object* l_Array_iterateMAux___main___at_Lean_ppGoal___spec__6___closed__4;
 lean_object* l___private_Lean_Meta_Basic_2__mkFreshExprMVarAtCore(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_ExprDefEq_31__unfoldDefEq___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1083,7 +1083,6 @@ lean_inc(x_20);
 x_21 = lean_ctor_get_uint64(x_17, sizeof(void*)*3);
 lean_dec(x_17);
 x_22 = l_Lean_Meta_commitWhen___at___private_Lean_Meta_ExprDefEq_1__isDefEqEta___spec__1(x_1, x_2, x_19, x_20, x_21, x_3, x_4, x_5, x_6, x_18);
-lean_dec(x_19);
 return x_22;
 }
 else
@@ -1206,7 +1205,6 @@ uint64_t x_11; lean_object* x_12;
 x_11 = lean_unbox_uint64(x_5);
 lean_dec(x_5);
 x_12 = l_Lean_Meta_commitWhenSome_x3f___at___private_Lean_Meta_ExprDefEq_1__isDefEqEta___spec__2(x_1, x_2, x_3, x_4, x_11, x_6, x_7, x_8, x_9, x_10);
-lean_dec(x_3);
 return x_12;
 }
 }
@@ -1217,7 +1215,6 @@ uint64_t x_11; lean_object* x_12;
 x_11 = lean_unbox_uint64(x_5);
 lean_dec(x_5);
 x_12 = l_Lean_Meta_commitWhen___at___private_Lean_Meta_ExprDefEq_1__isDefEqEta___spec__1(x_1, x_2, x_3, x_4, x_11, x_6, x_7, x_8, x_9, x_10);
-lean_dec(x_3);
 return x_12;
 }
 }
@@ -8771,7 +8768,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Core_Lean_MonadTrace;
-x_2 = l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__1;
+x_2 = l_Lean_MonadCacheT_MonadLift___closed__1;
 x_3 = l_Lean_monadTraceTrans___rarg(x_1, x_2);
 return x_3;
 }
@@ -8791,7 +8788,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Meta_CheckAssignment_checkFVar___closed__4;
-x_2 = l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__1;
+x_2 = l_Lean_MonadCacheT_MonadLift___closed__1;
 x_3 = l_Lean_monadTraceTrans___rarg(x_1, x_2);
 return x_3;
 }
@@ -8811,7 +8808,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Meta_Lean_AddMessageDataContext;
-x_2 = l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__1;
+x_2 = l_Lean_MonadCacheT_MonadLift___closed__1;
 x_3 = lean_alloc_closure((void*)(l_Lean_addMessageDataContextTrans___rarg), 3, 2);
 lean_closure_set(x_3, 0, x_1);
 lean_closure_set(x_3, 1, x_2);

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

@@ -95,7 +95,6 @@ lean_object* l_Lean_Meta_assignExprMVar___at___private_Lean_Meta_InferType_4__ge
 lean_object* l_Lean_Meta_intro1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_caseValueAux___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_toList___rarg(lean_object*);
-lean_object* l_Lean_Meta_caseValueAux___lambda__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* l_Lean_Meta_caseValueAux___lambda__5___closed__7;
 lean_object* l___private_Lean_Util_Trace_4__addNode___at_Lean_Meta_check___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Util_Trace_3__checkTraceOptionM___at_Lean_Meta_check___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1274,6 +1273,7 @@ x_23 = l_Lean_mkApp(x_22, x_20);
 x_24 = 0;
 lean_inc(x_16);
 lean_inc(x_20);
+lean_inc(x_4);
 x_25 = l_Lean_mkForall(x_4, x_24, x_20, x_16);
 x_26 = l_Lean_mkForall(x_4, x_24, x_23, x_16);
 lean_inc(x_7);
@@ -1693,6 +1693,7 @@ 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_123 = !lean_is_exclusive(x_19);
 if (x_123 == 0)
@@ -1723,6 +1724,7 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
@@ -1755,6 +1757,7 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
@@ -1787,7 +1790,7 @@ lean_inc(x_1);
 x_11 = lean_alloc_closure((void*)(l_Lean_Meta_getMVarTag___boxed), 6, 1);
 lean_closure_set(x_11, 0, x_1);
 lean_inc(x_1);
-x_12 = lean_alloc_closure((void*)(l_Lean_Meta_caseValueAux___lambda__5___boxed), 11, 5);
+x_12 = lean_alloc_closure((void*)(l_Lean_Meta_caseValueAux___lambda__5), 11, 5);
 lean_closure_set(x_12, 0, x_1);
 lean_closure_set(x_12, 1, x_2);
 lean_closure_set(x_12, 2, x_3);
@@ -1841,15 +1844,6 @@ lean_dec(x_1);
 return x_10;
 }
 }
-lean_object* l_Lean_Meta_caseValueAux___lambda__5___boxed(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, lean_object* x_11) {
-_start:
-{
-lean_object* x_12; 
-x_12 = l_Lean_Meta_caseValueAux___lambda__5(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11);
-lean_dec(x_4);
-return x_12;
-}
-}
 lean_object* _init_l_Lean_Meta_caseValue___closed__1() {
 _start:
 {

stage0/stdlib/Lean/Meta/RecursorInfo.c

@@ -19,6 +19,7 @@ lean_object* l_Lean_Meta_recursorAttribute;
 lean_object* l_Nat_foldMAux___main___at___private_Lean_Meta_RecursorInfo_6__getParamsPos___spec__2___closed__1;
 lean_object* l___private_Lean_Meta_RecursorInfo_2__getMajorPosIfAuxRecursor_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_brecOnSuffix___closed__1;
+lean_object* l_Lean_Meta_binductionOnSuffix;
 lean_object* lean_array_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getConstInfoRec___at___private_Lean_Meta_RecursorInfo_2__getMajorPosIfAuxRecursor_x3f___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Option_HasRepr___rarg___closed__2;
@@ -176,6 +177,7 @@ lean_object* l_List_toStringAux___main___at_Lean_Meta_RecursorInfo_HasToString__
 extern lean_object* l_Std_PersistentArray_Stats_toString___closed__4;
 lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___spec__3___closed__3;
 uint8_t l_Array_anyRangeMAux___main___at_Lean_Meta_mkRecursorAttr___spec__7(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_mkBInductionOnFor(lean_object*);
 lean_object* l_Nat_repr(lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_12__mkRecursorInfoAux___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_LocalDecl_binderInfo(lean_object*);
@@ -325,6 +327,7 @@ lean_object* l_List_toArrayAux___main___rarg(lean_object*, lean_object*);
 extern lean_object* l_Nat_Inhabited;
 extern lean_object* l_System_FilePath_dirName___closed__1;
 lean_object* l___private_Lean_Meta_RecursorInfo_6__getParamsPos(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Meta_binductionOnSuffix___closed__1;
 lean_object* l___private_Lean_Meta_RecursorInfo_2__getMajorPosIfAuxRecursor_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_toStringAux___main___at_Lean_Meta_RecursorInfo_HasToString___spec__2___closed__1;
@@ -404,6 +407,22 @@ x_1 = l_Lean_Meta_brecOnSuffix___closed__1;
 return x_1;
 }
 }
+lean_object* _init_l_Lean_Meta_binductionOnSuffix___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("binductionOn");
+return x_1;
+}
+}
+lean_object* _init_l_Lean_Meta_binductionOnSuffix() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Meta_binductionOnSuffix___closed__1;
+return x_1;
+}
+}
 lean_object* l_Lean_Meta_mkCasesOnFor(lean_object* x_1) {
 _start:
 {
@@ -431,6 +450,15 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
+lean_object* l_Lean_Meta_mkBInductionOnFor(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; lean_object* x_3; 
+x_2 = l_Lean_Meta_binductionOnSuffix;
+x_3 = lean_name_mk_string(x_1, x_2);
+return x_3;
+}
+}
 lean_object* _init_l_Lean_Meta_RecursorUnivLevelPos_hasToString___closed__1() {
 _start:
 {
@@ -11374,6 +11402,10 @@ l_Lean_Meta_brecOnSuffix___closed__1 = _init_l_Lean_Meta_brecOnSuffix___closed__
 lean_mark_persistent(l_Lean_Meta_brecOnSuffix___closed__1);
 l_Lean_Meta_brecOnSuffix = _init_l_Lean_Meta_brecOnSuffix();
 lean_mark_persistent(l_Lean_Meta_brecOnSuffix);
+l_Lean_Meta_binductionOnSuffix___closed__1 = _init_l_Lean_Meta_binductionOnSuffix___closed__1();
+lean_mark_persistent(l_Lean_Meta_binductionOnSuffix___closed__1);
+l_Lean_Meta_binductionOnSuffix = _init_l_Lean_Meta_binductionOnSuffix();
+lean_mark_persistent(l_Lean_Meta_binductionOnSuffix);
 l_Lean_Meta_RecursorUnivLevelPos_hasToString___closed__1 = _init_l_Lean_Meta_RecursorUnivLevelPos_hasToString___closed__1();
 lean_mark_persistent(l_Lean_Meta_RecursorUnivLevelPos_hasToString___closed__1);
 l_List_toStringAux___main___at_Lean_Meta_RecursorInfo_HasToString___spec__2___closed__1 = _init_l_List_toStringAux___main___at_Lean_Meta_RecursorInfo_HasToString___spec__2___closed__1();

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

@@ -115,6 +115,7 @@ lean_dec(x_12);
 lean_dec(x_6);
 lean_dec(x_4);
 lean_dec(x_3);
+lean_dec(x_2);
 lean_dec(x_1);
 x_30 = !lean_is_exclusive(x_14);
 if (x_30 == 0)
@@ -142,6 +143,7 @@ uint8_t x_34;
 lean_dec(x_6);
 lean_dec(x_4);
 lean_dec(x_3);
+lean_dec(x_2);
 lean_dec(x_1);
 x_34 = !lean_is_exclusive(x_11);
 if (x_34 == 0)
@@ -213,7 +215,6 @@ lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_5);
-lean_dec(x_2);
 return x_11;
 }
 }
@@ -285,6 +286,7 @@ lean_dec(x_12);
 lean_dec(x_6);
 lean_dec(x_4);
 lean_dec(x_3);
+lean_dec(x_2);
 lean_dec(x_1);
 x_29 = !lean_is_exclusive(x_14);
 if (x_29 == 0)
@@ -312,6 +314,7 @@ uint8_t x_33;
 lean_dec(x_6);
 lean_dec(x_4);
 lean_dec(x_3);
+lean_dec(x_2);
 lean_dec(x_1);
 x_33 = !lean_is_exclusive(x_11);
 if (x_33 == 0)
@@ -383,7 +386,6 @@ lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_5);
-lean_dec(x_2);
 return x_11;
 }
 }
@@ -539,6 +541,8 @@ lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
@@ -570,6 +574,8 @@ lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
@@ -600,6 +606,8 @@ lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
@@ -653,8 +661,6 @@ _start:
 lean_object* x_12; 
 x_12 = l_Lean_Meta_assertExt___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11);
 lean_dec(x_6);
-lean_dec(x_5);
-lean_dec(x_4);
 return x_12;
 }
 }

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

@@ -227,6 +227,7 @@ if (x_62 == 0)
 lean_object* x_63; lean_object* x_64; lean_object* x_65; uint8_t x_66; 
 lean_dec(x_22);
 lean_dec(x_12);
+lean_dec(x_3);
 lean_dec(x_2);
 x_63 = l_Lean_Meta_generalize___lambda__1___closed__6;
 x_64 = lean_box(0);
@@ -415,6 +416,7 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_4);
+lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
 x_57 = !lean_is_exclusive(x_25);
@@ -447,6 +449,7 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_4);
+lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
 x_70 = !lean_is_exclusive(x_21);
@@ -478,6 +481,7 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_4);
+lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
 x_74 = !lean_is_exclusive(x_14);
@@ -508,6 +512,7 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_4);
+lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
 x_78 = !lean_is_exclusive(x_11);
@@ -586,7 +591,6 @@ _start:
 lean_object* x_11; 
 x_11 = l_Lean_Meta_generalize___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10);
 lean_dec(x_5);
-lean_dec(x_3);
 return x_11;
 }
 }

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

@@ -33,7 +33,6 @@ lean_object* l_Lean_Meta_introNCore___at_Lean_Meta_introN___spec__1___boxed(lean
 extern lean_object* l_Lean_Name_inhabited;
 lean_object* l_Lean_Meta_whnf___rarg(lean_object*, lean_object*);
 extern lean_object* l_Id_monad;
-extern lean_object* l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__3;
 lean_object* l_Lean_Meta_introNCore___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_checkNotAssigned___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
@@ -89,6 +88,7 @@ lean_object* l_Lean_Meta_introNCore___at_Lean_Meta_introN___spec__1(uint8_t, lea
 lean_object* l_Lean_Meta_assignExprMVar___at___private_Lean_Meta_InferType_4__getLevelImp___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_intro1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_introNCoreAux___main___rarg(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_object*);
+extern lean_object* l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__2;
 lean_object* l_Lean_Meta_mkFreshExprSyntheticOpaqueMVar(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkAuxName(uint8_t, lean_object*, lean_object*, lean_object*);
@@ -334,7 +334,7 @@ lean_dec(x_44);
 lean_dec(x_41);
 x_46 = l_Lean_Expr_headBeta(x_45);
 x_47 = l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___rarg___closed__3;
-x_48 = l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__3;
+x_48 = l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__2;
 x_49 = l_Lean_mkFreshId___rarg(x_47, x_48);
 lean_inc(x_12);
 lean_inc(x_11);
@@ -427,7 +427,7 @@ x_72 = lean_expr_instantiate_rev_range(x_67, x_6, x_69, x_5);
 lean_dec(x_69);
 lean_dec(x_67);
 x_73 = l___private_Lean_Meta_Basic_12__withNewLocalInstancesImp___main___rarg___closed__3;
-x_74 = l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__3;
+x_74 = l___private_Lean_Meta_Basic_14__forallTelescopeReducingAuxAux___main___rarg___closed__2;
 x_75 = l_Lean_mkFreshId___rarg(x_73, x_74);
 lean_inc(x_12);
 lean_inc(x_11);

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

@@ -1059,7 +1059,6 @@ block_41:
 uint8_t x_16; lean_object* x_17; lean_object* x_18; 
 x_16 = (uint8_t)((x_14 << 24) >> 61);
 x_17 = l_Lean_mkForall(x_11, x_16, x_3, x_13);
-lean_dec(x_11);
 lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);
@@ -1291,7 +1290,6 @@ block_97:
 uint8_t x_73; lean_object* x_74; lean_object* x_75; 
 x_73 = 0;
 x_74 = l_Lean_mkLet(x_68, x_3, x_70, x_71, x_73);
-lean_dec(x_68);
 lean_inc(x_9);
 lean_inc(x_8);
 lean_inc(x_7);

stage0/stdlib/Lean/MetavarContext.c

@@ -34531,7 +34531,6 @@ lean_dec(x_21);
 x_24 = lean_expr_abstract_range(x_22, x_12, x_3);
 lean_dec(x_22);
 x_25 = l_Lean_mkForall(x_16, x_18, x_24, x_6);
-lean_dec(x_16);
 x_5 = x_12;
 x_6 = x_25;
 x_8 = x_23;
@@ -34604,6 +34603,7 @@ lean_dec(x_42);
 x_45 = lean_expr_abstract_range(x_43, x_12, x_3);
 lean_dec(x_43);
 lean_inc(x_40);
+lean_inc(x_31);
 x_46 = l_Lean_mkLet(x_31, x_40, x_45, x_6, x_34);
 x_47 = lean_box(x_4);
 if (lean_obj_tag(x_47) == 2)
@@ -34613,7 +34613,6 @@ x_48 = lean_expr_lift_loose_bvars(x_46, x_9, x_11);
 lean_dec(x_46);
 x_49 = 0;
 x_50 = l_Lean_mkForall(x_31, x_49, x_40, x_48);
-lean_dec(x_31);
 x_5 = x_12;
 x_6 = x_50;
 x_8 = x_44;
@@ -40364,7 +40363,6 @@ if (x_4 == 0)
 {
 lean_object* x_23; lean_object* x_24; lean_object* x_25; 
 x_23 = l_Lean_mkForall(x_15, x_17, x_22, x_10);
-lean_dec(x_15);
 x_24 = lean_unsigned_to_nat(1u);
 x_25 = lean_nat_add(x_11, x_24);
 lean_dec(x_11);
@@ -40377,7 +40375,6 @@ else
 {
 lean_object* x_26; lean_object* x_27; lean_object* x_28; 
 x_26 = l_Lean_mkLambda(x_15, x_17, x_22, x_10);
-lean_dec(x_15);
 x_27 = lean_unsigned_to_nat(1u);
 x_28 = lean_nat_add(x_11, x_27);
 lean_dec(x_11);
@@ -40402,7 +40399,6 @@ if (x_4 == 0)
 {
 lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
 x_32 = l_Lean_mkForall(x_15, x_17, x_31, x_10);
-lean_dec(x_15);
 x_33 = lean_unsigned_to_nat(1u);
 x_34 = lean_nat_add(x_11, x_33);
 lean_dec(x_11);
@@ -40417,7 +40413,6 @@ else
 {
 lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
 x_36 = l_Lean_mkLambda(x_15, x_17, x_31, x_10);
-lean_dec(x_15);
 x_37 = lean_unsigned_to_nat(1u);
 x_38 = lean_nat_add(x_11, x_37);
 lean_dec(x_11);
@@ -40505,7 +40500,6 @@ if (x_4 == 0)
 {
 lean_object* x_57; lean_object* x_58; lean_object* x_59; 
 x_57 = l_Lean_mkForall(x_44, x_46, x_56, x_10);
-lean_dec(x_44);
 x_58 = lean_unsigned_to_nat(1u);
 x_59 = lean_nat_add(x_11, x_58);
 lean_dec(x_11);
@@ -40518,7 +40512,6 @@ else
 {
 lean_object* x_60; lean_object* x_61; lean_object* x_62; 
 x_60 = l_Lean_mkLambda(x_44, x_46, x_56, x_10);
-lean_dec(x_44);
 x_61 = lean_unsigned_to_nat(1u);
 x_62 = lean_nat_add(x_11, x_61);
 lean_dec(x_11);
@@ -40543,7 +40536,6 @@ if (x_4 == 0)
 {
 lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; 
 x_66 = l_Lean_mkForall(x_44, x_46, x_65, x_10);
-lean_dec(x_44);
 x_67 = lean_unsigned_to_nat(1u);
 x_68 = lean_nat_add(x_11, x_67);
 lean_dec(x_11);
@@ -40558,7 +40550,6 @@ else
 {
 lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
 x_70 = l_Lean_mkLambda(x_44, x_46, x_65, x_10);
-lean_dec(x_44);
 x_71 = lean_unsigned_to_nat(1u);
 x_72 = lean_nat_add(x_11, x_71);
 lean_dec(x_11);
@@ -40659,7 +40650,6 @@ x_94 = lean_expr_abstract_range(x_93, x_5, x_1);
 lean_dec(x_1);
 lean_dec(x_93);
 x_95 = l_Lean_mkLet(x_78, x_90, x_94, x_10, x_81);
-lean_dec(x_78);
 x_96 = lean_unsigned_to_nat(1u);
 x_97 = lean_nat_add(x_11, x_96);
 lean_dec(x_11);
@@ -40680,7 +40670,6 @@ x_100 = lean_expr_abstract_range(x_98, x_5, x_1);
 lean_dec(x_1);
 lean_dec(x_98);
 x_101 = l_Lean_mkLet(x_78, x_90, x_100, x_10, x_81);
-lean_dec(x_78);
 x_102 = lean_unsigned_to_nat(1u);
 x_103 = lean_nat_add(x_11, x_102);
 lean_dec(x_11);
@@ -40800,7 +40789,6 @@ if (x_4 == 0)
 {
 lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; 
 x_127 = l_Lean_mkForall(x_118, x_120, x_126, x_113);
-lean_dec(x_118);
 x_128 = lean_unsigned_to_nat(1u);
 x_129 = lean_nat_add(x_114, x_128);
 lean_dec(x_114);
@@ -40820,7 +40808,6 @@ else
 {
 lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; 
 x_132 = l_Lean_mkLambda(x_118, x_120, x_126, x_113);
-lean_dec(x_118);
 x_133 = lean_unsigned_to_nat(1u);
 x_134 = lean_nat_add(x_114, x_133);
 lean_dec(x_114);
@@ -40922,7 +40909,6 @@ if (x_4 == 0)
 {
 lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; 
 x_156 = l_Lean_mkForall(x_141, x_143, x_155, x_113);
-lean_dec(x_141);
 x_157 = lean_unsigned_to_nat(1u);
 x_158 = lean_nat_add(x_114, x_157);
 lean_dec(x_114);
@@ -40942,7 +40928,6 @@ else
 {
 lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; 
 x_161 = l_Lean_mkLambda(x_141, x_143, x_155, x_113);
-lean_dec(x_141);
 x_162 = lean_unsigned_to_nat(1u);
 x_163 = lean_nat_add(x_114, x_162);
 lean_dec(x_114);
@@ -41057,7 +41042,6 @@ x_188 = lean_expr_abstract_range(x_185, x_5, x_1);
 lean_dec(x_1);
 lean_dec(x_185);
 x_189 = l_Lean_mkLet(x_170, x_183, x_188, x_113, x_173);
-lean_dec(x_170);
 x_190 = lean_unsigned_to_nat(1u);
 x_191 = lean_nat_add(x_114, x_190);
 lean_dec(x_114);

stage0/stdlib/Lean/MonadEnv.c

@@ -14,8 +14,10 @@
 extern "C" {
 #endif
 lean_object* l_Lean_getConstInfo___rarg___lambda__1___closed__4;
+lean_object* l_Lean_hasConst___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_addDecl___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_setEnv___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_hasConst(lean_object*);
 lean_object* l_Lean_getConstInfoInduct___rarg___lambda__1___closed__2;
 lean_object* l_Lean_getConstInfo___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_compileDecl___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -26,11 +28,14 @@ lean_object* l_Lean_matchConstRec___rarg(lean_object*, lean_object*, lean_object
 lean_object* l_Lean_compileDecl(lean_object*);
 lean_object* l_Lean_matchConst___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getConstInfoRec___rarg___lambda__1___closed__3;
+lean_object* l_Lean_hasConst___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_matchConstInduct___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_matchConstRec___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_compileDecl___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_setEnv(lean_object*);
+lean_object* l_Lean_hasConst___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_addAndCompile___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_Lean_getConstInfo___rarg___lambda__1___closed__3;
 lean_object* l_Lean_getConstInfoCtor___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_matchConstStruct___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -42,6 +47,8 @@ lean_object* l_Lean_getConstInfoCtor___rarg___lambda__1___closed__3;
 lean_object* l_Lean_addAndCompile___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getConstInfoInduct(lean_object*);
 lean_object* l_Lean_getConstInfo___rarg___lambda__1___closed__5;
+lean_object* l_Lean_Name_appendIndexAfter(lean_object*, lean_object*);
+lean_object* l___private_Lean_MonadEnv_1__mkAuxNameAux___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_addDecl___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_compileDecl___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Char_HasRepr___closed__1;
@@ -50,13 +57,17 @@ lean_object* l_Lean_getConstInfoInduct___rarg___lambda__1(lean_object*, lean_obj
 lean_object* l_Lean_matchConstCtor___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_matchConstStruct___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_matchConst(lean_object*);
+uint8_t l_Lean_Environment_contains(lean_object*, lean_object*);
 lean_object* l_Lean_matchConstInduct(lean_object*);
 lean_object* l_Lean_getConstInfo(lean_object*);
 lean_object* l_Lean_addDecl(lean_object*);
 lean_object* l_Lean_getConstInfoCtor___rarg___lambda__1___closed__1;
 lean_object* l_fix1___rarg___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_getConstInfo___rarg___lambda__1___closed__1;
+lean_object* l_Lean_mkAuxName(lean_object*);
 lean_object* l_Lean_addDecl___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_mkAuxName___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_mkAuxName___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_matchConstRec(lean_object*);
 lean_object* l_Lean_getConstInfo___rarg___lambda__1___closed__2;
 lean_object* l_Lean_throwKernelException___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -65,6 +76,7 @@ lean_object* l_Lean_throwError___rarg(lean_object*, lean_object*, lean_object*,
 lean_object* l_Lean_getConstInfoCtor___rarg___lambda__1___closed__2;
 lean_object* l_Lean_matchConstInduct___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_compileDecl___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_MonadEnv_1__mkAuxNameAux(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getConstInfoRec___rarg___lambda__1___closed__1;
 lean_object* l_Lean_matchConstStruct(lean_object*);
 lean_object* l_Lean_getConstInfoRec___rarg___lambda__1___closed__2;
@@ -440,6 +452,131 @@ x_2 = lean_alloc_closure((void*)(l_Lean_matchConstRec___rarg), 6, 0);
 return x_2;
 }
 }
+lean_object* l_Lean_hasConst___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; 
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+lean_dec(x_1);
+x_5 = lean_ctor_get(x_4, 1);
+lean_inc(x_5);
+lean_dec(x_4);
+x_6 = l_Lean_Environment_contains(x_3, x_2);
+x_7 = lean_box(x_6);
+x_8 = lean_apply_2(x_5, lean_box(0), x_7);
+return x_8;
+}
+}
+lean_object* l_Lean_hasConst___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_4 = lean_ctor_get(x_2, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_alloc_closure((void*)(l_Lean_hasConst___rarg___lambda__1___boxed), 3, 2);
+lean_closure_set(x_6, 0, x_2);
+lean_closure_set(x_6, 1, x_3);
+x_7 = lean_apply_4(x_4, lean_box(0), lean_box(0), x_5, x_6);
+return x_7;
+}
+}
+lean_object* l_Lean_hasConst(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_hasConst___rarg), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_hasConst___rarg___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Lean_hasConst___rarg___lambda__1(x_1, x_2, x_3);
+lean_dec(x_2);
+return x_4;
+}
+}
+lean_object* l___private_Lean_MonadEnv_1__mkAuxNameAux___main(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; uint8_t x_5; 
+lean_inc(x_3);
+lean_inc(x_2);
+x_4 = l_Lean_Name_appendIndexAfter(x_2, x_3);
+lean_inc(x_1);
+x_5 = l_Lean_Environment_contains(x_1, x_4);
+if (x_5 == 0)
+{
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_4;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_4);
+x_6 = lean_unsigned_to_nat(1u);
+x_7 = lean_nat_add(x_3, x_6);
+lean_dec(x_3);
+x_3 = x_7;
+goto _start;
+}
+}
+}
+lean_object* l___private_Lean_MonadEnv_1__mkAuxNameAux(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l___private_Lean_MonadEnv_1__mkAuxNameAux___main(x_1, x_2, x_3);
+return x_4;
+}
+}
+lean_object* l_Lean_mkAuxName___rarg___lambda__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; lean_object* x_8; 
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_ctor_get(x_5, 1);
+lean_inc(x_6);
+lean_dec(x_5);
+x_7 = l___private_Lean_MonadEnv_1__mkAuxNameAux___main(x_4, x_2, x_3);
+x_8 = lean_apply_2(x_6, lean_box(0), x_7);
+return x_8;
+}
+}
+lean_object* l_Lean_mkAuxName___rarg(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; lean_object* x_8; 
+x_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_alloc_closure((void*)(l_Lean_mkAuxName___rarg___lambda__1), 4, 3);
+lean_closure_set(x_7, 0, x_2);
+lean_closure_set(x_7, 1, x_3);
+lean_closure_set(x_7, 2, x_4);
+x_8 = lean_apply_4(x_5, lean_box(0), lean_box(0), x_6, x_7);
+return x_8;
+}
+}
+lean_object* l_Lean_mkAuxName(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_mkAuxName___rarg), 4, 0);
+return x_2;
+}
+}
 lean_object* _init_l_Lean_getConstInfo___rarg___lambda__1___closed__1() {
 _start:
 {

stage0/stdlib/Lean/Util.c

@@ -1,6 +1,6 @@
 // Lean compiler output
 // Module: Lean.Util
-// Imports: Init Lean.Util.CollectFVars Lean.Util.CollectLevelParams Lean.Util.CollectMVars Lean.Util.FindMVar Lean.Util.MonadCache Lean.Util.PPExt Lean.Util.PPGoal Lean.Util.Path Lean.Util.Profile Lean.Util.RecDepth Lean.Util.Sorry Lean.Util.Trace Lean.Util.FindExpr Lean.Util.ReplaceExpr Lean.Util.ReplaceLevel Lean.Util.FoldConsts Lean.Util.Constructions Lean.Util.SCC
+// Imports: Init Lean.Util.CollectFVars Lean.Util.CollectLevelParams Lean.Util.CollectMVars Lean.Util.FindMVar Lean.Util.MonadCache Lean.Util.PPExt Lean.Util.PPGoal Lean.Util.Path Lean.Util.Profile Lean.Util.RecDepth Lean.Util.Sorry Lean.Util.Trace Lean.Util.FindExpr Lean.Util.ReplaceExpr Lean.Util.ForEachExpr Lean.Util.ReplaceLevel Lean.Util.FoldConsts Lean.Util.Constructions Lean.Util.SCC
 #include <lean/lean.h>
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wunused-parameter"
@@ -28,6 +28,7 @@ lean_object* initialize_Lean_Util_Sorry(lean_object*);
 lean_object* initialize_Lean_Util_Trace(lean_object*);
 lean_object* initialize_Lean_Util_FindExpr(lean_object*);
 lean_object* initialize_Lean_Util_ReplaceExpr(lean_object*);
+lean_object* initialize_Lean_Util_ForEachExpr(lean_object*);
 lean_object* initialize_Lean_Util_ReplaceLevel(lean_object*);
 lean_object* initialize_Lean_Util_FoldConsts(lean_object*);
 lean_object* initialize_Lean_Util_Constructions(lean_object*);
@@ -82,6 +83,9 @@ lean_dec_ref(res);
 res = initialize_Lean_Util_ReplaceExpr(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
+res = initialize_Lean_Util_ForEachExpr(lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
 res = initialize_Lean_Util_ReplaceLevel(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);

stage0/stdlib/Lean/Util/MonadCache.c

@@ -13,63 +13,101 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+lean_object* l_Lean_MonadCacheT_Lean_MonadHashMapCacheAdapter___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_run___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_checkCache___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_fromState___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_ReaderT_finally___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_getCache(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_fromState(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_Lean_MonadHashMapCacheAdapter___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_readerLift___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_run(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Std_HashMap_inhabited___closed__1;
 lean_object* l_Lean_WithHashMapCache_modifyCache(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_MonadControl___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_Lean_MonadHashMapCacheAdapter(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_getCache___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_ReaderT_Monad___rarg(lean_object*);
+lean_object* l_ST_Prim_mkRef___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_MonadIO___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_readerLift___rarg(lean_object*);
+lean_object* l_Lean_MonadCacheT_MonadExceptOf___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_checkCache(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_ExceptT_lift___rarg___closed__1;
 lean_object* l_Lean_readerLift___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_getCacheE(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_Monad___rarg(lean_object*);
 lean_object* l_Lean_readerLift___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_Monad___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_getCache___rarg(lean_object*);
 lean_object* l_Lean_MonadHashMapCacheAdapter_Lean_MonadCache(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MonadHashMapCacheAdapter_cache___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_modifyCache___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_modifyThe___rarg___lambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_readerLift___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_MonadLift___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_find_x3f___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MonadHashMapCacheAdapter_findCached_x3f(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_checkCache___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_toEState(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_StateRefT_x27_MonadLift(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_getCacheE___rarg(lean_object*);
+lean_object* l_Lean_MonadCacheT_MonadLift___closed__1;
 lean_object* l_Lean_WithHashMapCache_estateAdapter___rarg___closed__1;
 lean_object* l_Lean_checkCache___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_MonadExceptOf(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_run___rarg___closed__1;
 lean_object* l_Lean_WithHashMapCache_stateAdapter___rarg___closed__1;
+lean_object* l_Lean_MonadCacheT_Lean_MonadHashMapCacheAdapter___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_exceptLift(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_stateAdapter(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_stateAdapter___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_modifyCacheE___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_fromState___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_Monad(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_toState(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_fromEState(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_MonadIO(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_toEState___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_modifyCache___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_StateRefT_x27_run_x27___rarg___lambda__1(lean_object*, lean_object*);
+lean_object* l_StateRefT_x27_MonadIO___rarg(lean_object*);
 lean_object* l_Lean_MonadHashMapCacheAdapter_findCached_x3f___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_estateAdapter___rarg(lean_object*, lean_object*);
+extern lean_object* l_ReaderT_monadControl___closed__2;
 lean_object* l_Lean_readerLift(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_modifyCacheE___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_getCacheE___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_StateRefT_x27_run___rarg___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MonadHashMapCacheAdapter_findCached_x3f___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_fromEState___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_exceptLift___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MonadHashMapCacheAdapter_cache___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_StateRefT_x27_get___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_MonadHashMapCacheAdapter_findCached_x3f___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_Lean_MonadHashMapCacheAdapter___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_toEState___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_toState___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_MonadControl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MonadHashMapCacheAdapter_cache(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_toState___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_ST_Prim_Ref_modifyGetUnsafe___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_StateRefT_x27_MonadExceptOf___rarg(lean_object*);
 lean_object* l_Lean_MonadHashMapCacheAdapter_Lean_MonadCache___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_MonadExceptOf___rarg(lean_object*);
+lean_object* l_Lean_MonadCacheT_MonadIO___rarg(lean_object*);
+lean_object* l_Lean_MonadCacheT_MonadLift(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_modifyCacheE(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_MonadFinally___rarg(lean_object*, lean_object*);
 lean_object* l_ReaderT_Monad___rarg___lambda__4___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_insert___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_estateAdapter(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_MonadFinally(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_exceptLift___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_WithHashMapCache_fromEState___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_run___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MonadCacheT_MonadFinally___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_exceptLift___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_checkCache___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
@@ -399,6 +437,286 @@ x_4 = lean_alloc_closure((void*)(l_Lean_MonadHashMapCacheAdapter_Lean_MonadCache
 return x_4;
 }
 }
+lean_object* l_Lean_MonadCacheT_Lean_MonadHashMapCacheAdapter___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_4 = lean_alloc_closure((void*)(l_modifyThe___rarg___lambda__1), 2, 1);
+lean_closure_set(x_4, 0, x_2);
+x_5 = lean_alloc_closure((void*)(l_ST_Prim_Ref_modifyGetUnsafe___rarg___boxed), 3, 2);
+lean_closure_set(x_5, 0, x_3);
+lean_closure_set(x_5, 1, x_4);
+x_6 = lean_apply_2(x_1, lean_box(0), x_5);
+return x_6;
+}
+}
+lean_object* l_Lean_MonadCacheT_Lean_MonadHashMapCacheAdapter___rarg(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; 
+lean_inc(x_3);
+x_5 = lean_alloc_closure((void*)(l_StateRefT_x27_get___rarg), 2, 1);
+lean_closure_set(x_5, 0, x_3);
+x_6 = lean_alloc_closure((void*)(l_Lean_MonadCacheT_Lean_MonadHashMapCacheAdapter___rarg___lambda__1), 3, 1);
+lean_closure_set(x_6, 0, x_3);
+x_7 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_7, 0, x_5);
+lean_ctor_set(x_7, 1, x_6);
+return x_7;
+}
+}
+lean_object* l_Lean_MonadCacheT_Lean_MonadHashMapCacheAdapter(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; 
+x_6 = lean_alloc_closure((void*)(l_Lean_MonadCacheT_Lean_MonadHashMapCacheAdapter___rarg___boxed), 4, 0);
+return x_6;
+}
+}
+lean_object* l_Lean_MonadCacheT_Lean_MonadHashMapCacheAdapter___rarg___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_MonadCacheT_Lean_MonadHashMapCacheAdapter___rarg(x_1, x_2, x_3, x_4);
+lean_dec(x_4);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_5;
+}
+}
+lean_object* l_Lean_MonadCacheT_Lean_MonadHashMapCacheAdapter___boxed(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; 
+x_6 = l_Lean_MonadCacheT_Lean_MonadHashMapCacheAdapter(x_1, x_2, x_3, x_4, x_5);
+lean_dec(x_5);
+return x_6;
+}
+}
+lean_object* _init_l_Lean_MonadCacheT_run___rarg___closed__1() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Std_HashMap_inhabited___closed__1;
+x_2 = lean_alloc_closure((void*)(l_ST_Prim_mkRef___boxed), 4, 3);
+lean_closure_set(x_2, 0, lean_box(0));
+lean_closure_set(x_2, 1, lean_box(0));
+lean_closure_set(x_2, 2, x_1);
+return x_2;
+}
+}
+lean_object* l_Lean_MonadCacheT_run___rarg(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; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_5 = lean_ctor_get(x_2, 1);
+lean_inc(x_5);
+x_6 = l_Lean_MonadCacheT_run___rarg___closed__1;
+lean_inc(x_1);
+x_7 = lean_apply_2(x_1, lean_box(0), x_6);
+lean_inc(x_5);
+lean_inc(x_2);
+x_8 = lean_alloc_closure((void*)(l_StateRefT_x27_run___rarg___lambda__3), 5, 4);
+lean_closure_set(x_8, 0, x_4);
+lean_closure_set(x_8, 1, x_1);
+lean_closure_set(x_8, 2, x_2);
+lean_closure_set(x_8, 3, x_5);
+lean_inc(x_5);
+x_9 = lean_apply_4(x_5, lean_box(0), lean_box(0), x_7, x_8);
+x_10 = lean_alloc_closure((void*)(l_StateRefT_x27_run_x27___rarg___lambda__1), 2, 1);
+lean_closure_set(x_10, 0, x_2);
+x_11 = lean_apply_4(x_5, lean_box(0), lean_box(0), x_9, x_10);
+return x_11;
+}
+}
+lean_object* l_Lean_MonadCacheT_run(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) {
+_start:
+{
+lean_object* x_8; 
+x_8 = lean_alloc_closure((void*)(l_Lean_MonadCacheT_run___rarg), 4, 0);
+return x_8;
+}
+}
+lean_object* l_Lean_MonadCacheT_run___boxed(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) {
+_start:
+{
+lean_object* x_8; 
+x_8 = l_Lean_MonadCacheT_run(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+return x_8;
+}
+}
+lean_object* l_Lean_MonadCacheT_Monad___rarg(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_ReaderT_Monad___rarg(x_1);
+return x_2;
+}
+}
+lean_object* l_Lean_MonadCacheT_Monad(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_9; 
+x_9 = lean_alloc_closure((void*)(l_Lean_MonadCacheT_Monad___rarg), 1, 0);
+return x_9;
+}
+}
+lean_object* l_Lean_MonadCacheT_Monad___boxed(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_9; 
+x_9 = l_Lean_MonadCacheT_Monad(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+return x_9;
+}
+}
+lean_object* _init_l_Lean_MonadCacheT_MonadLift___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_StateRefT_x27_MonadLift), 4, 3);
+lean_closure_set(x_1, 0, lean_box(0));
+lean_closure_set(x_1, 1, lean_box(0));
+lean_closure_set(x_1, 2, lean_box(0));
+return x_1;
+}
+}
+lean_object* l_Lean_MonadCacheT_MonadLift(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) {
+_start:
+{
+lean_object* x_10; 
+x_10 = l_Lean_MonadCacheT_MonadLift___closed__1;
+return x_10;
+}
+}
+lean_object* l_Lean_MonadCacheT_MonadLift___boxed(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) {
+_start:
+{
+lean_object* x_10; 
+x_10 = l_Lean_MonadCacheT_MonadLift(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9);
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+return x_10;
+}
+}
+lean_object* l_Lean_MonadCacheT_MonadIO___rarg(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_StateRefT_x27_MonadIO___rarg(x_1);
+return x_2;
+}
+}
+lean_object* l_Lean_MonadCacheT_MonadIO(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) {
+_start:
+{
+lean_object* x_10; 
+x_10 = lean_alloc_closure((void*)(l_Lean_MonadCacheT_MonadIO___rarg), 1, 0);
+return x_10;
+}
+}
+lean_object* l_Lean_MonadCacheT_MonadIO___boxed(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) {
+_start:
+{
+lean_object* x_10; 
+x_10 = l_Lean_MonadCacheT_MonadIO(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9);
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+return x_10;
+}
+}
+lean_object* l_Lean_MonadCacheT_MonadExceptOf___rarg(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_StateRefT_x27_MonadExceptOf___rarg(x_1);
+return x_2;
+}
+}
+lean_object* l_Lean_MonadCacheT_MonadExceptOf(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_11; 
+x_11 = lean_alloc_closure((void*)(l_Lean_MonadCacheT_MonadExceptOf___rarg), 1, 0);
+return x_11;
+}
+}
+lean_object* l_Lean_MonadCacheT_MonadExceptOf___boxed(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_11; 
+x_11 = l_Lean_MonadCacheT_MonadExceptOf(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10);
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+return x_11;
+}
+}
+lean_object* l_Lean_MonadCacheT_MonadControl(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) {
+_start:
+{
+lean_object* x_10; 
+x_10 = l_ReaderT_monadControl___closed__2;
+return x_10;
+}
+}
+lean_object* l_Lean_MonadCacheT_MonadControl___boxed(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) {
+_start:
+{
+lean_object* x_10; 
+x_10 = l_Lean_MonadCacheT_MonadControl(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9);
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+return x_10;
+}
+}
+lean_object* l_Lean_MonadCacheT_MonadFinally___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_ReaderT_finally___rarg___boxed), 7, 2);
+lean_closure_set(x_3, 0, x_2);
+lean_closure_set(x_3, 1, x_1);
+return x_3;
+}
+}
+lean_object* l_Lean_MonadCacheT_MonadFinally(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_9; 
+x_9 = lean_alloc_closure((void*)(l_Lean_MonadCacheT_MonadFinally___rarg), 2, 0);
+return x_9;
+}
+}
+lean_object* l_Lean_MonadCacheT_MonadFinally___boxed(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_9; 
+x_9 = l_Lean_MonadCacheT_MonadFinally(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+return x_9;
+}
+}
 lean_object* l_Lean_WithHashMapCache_getCache___rarg(lean_object* x_1) {
 _start:
 {
@@ -1025,6 +1343,10 @@ lean_dec_ref(res);
 res = initialize_Std_Data_HashMap(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
+l_Lean_MonadCacheT_run___rarg___closed__1 = _init_l_Lean_MonadCacheT_run___rarg___closed__1();
+lean_mark_persistent(l_Lean_MonadCacheT_run___rarg___closed__1);
+l_Lean_MonadCacheT_MonadLift___closed__1 = _init_l_Lean_MonadCacheT_MonadLift___closed__1();
+lean_mark_persistent(l_Lean_MonadCacheT_MonadLift___closed__1);
 l_Lean_WithHashMapCache_stateAdapter___rarg___closed__1 = _init_l_Lean_WithHashMapCache_stateAdapter___rarg___closed__1();
 lean_mark_persistent(l_Lean_WithHashMapCache_stateAdapter___rarg___closed__1);
 l_Lean_WithHashMapCache_estateAdapter___rarg___closed__1 = _init_l_Lean_WithHashMapCache_estateAdapter___rarg___closed__1();