chore: update stage0

stage0/src/Init/Core.lean

@@ -1009,16 +1009,17 @@ instance [DecidableEq α] [DecidableEq β] : DecidableEq (α × β) :=
 instance [BEq α] [BEq β] : BEq (α × β) where
   beq := fun (a₁, b₁) (a₂, b₂) => a₁ == a₂ && b₁ == b₂
 
-instance [LT α] [LT β] : LT (α × β) where
-  lt s t := s.1 < t.1 ∨ (s.1 = t.1 ∧ s.2 < t.2)
+/-- Lexicographical order for products -/
+def Prod.lexLt [LT α] [LT β] (s : α × β) (t : α × β) : Prop :=
+  s.1 < t.1 ∨ (s.1 = t.1 ∧ s.2 < t.2)
 
-instance prodHasDecidableLt
+instance Prod.lexLtDec
     [LT α] [LT β] [DecidableEq α] [DecidableEq β]
     [(a b : α) → Decidable (a < b)] [(a b : β) → Decidable (a < b)]
-    : (s t : α × β) → Decidable (s < t) :=
+    : (s t : α × β) → Decidable (Prod.lexLt s t) :=
   fun _ _ => inferInstanceAs (Decidable (_ ∨ _))
 
-theorem Prod.lt_def [LT α] [LT β] (s t : α × β) : (s < t) = (s.1 < t.1 ∨ (s.1 = t.1 ∧ s.2 < t.2)) :=
+theorem Prod.lexLt_def [LT α] [LT β] (s t : α × β) : (Prod.lexLt s t) = (s.1 < t.1 ∨ (s.1 = t.1 ∧ s.2 < t.2)) :=
   rfl
 
 theorem Prod.ext (p : α × β) : (p.1, p.2) = p := by

stage0/src/Init/NotationExtra.lean

@@ -210,6 +210,70 @@ syntax (name := calcTactic) "calc" ppLine withPosition(calcStep) ppLine withPosi
   | `($_ $array $index) => `($array[$index]?)
   | _ => throw ()
 
+@[appUnexpander Name.mkStr1] def unexpandMkStr1 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a:str) => return mkNode `Lean.Parser.Term.quotedName #[Syntax.mkNameLit s!"`{a.getString}"]
+  | _  => throw ()
+
+@[appUnexpander Name.mkStr2] def unexpandMkStr2 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a1:str $a2:str) => return mkNode `Lean.Parser.Term.quotedName #[Syntax.mkNameLit s!"`{a1.getString}.{a2.getString}"]
+  | _  => throw ()
+
+@[appUnexpander Name.mkStr3] def unexpandMkStr3 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a1:str $a2:str $a3:str) => return mkNode `Lean.Parser.Term.quotedName #[Syntax.mkNameLit s!"`{a1.getString}.{a2.getString}.{a3.getString}"]
+  | _  => throw ()
+
+@[appUnexpander Name.mkStr4] def unexpandMkStr4 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a1:str $a2:str $a3:str $a4:str) => return mkNode `Lean.Parser.Term.quotedName #[Syntax.mkNameLit s!"`{a1.getString}.{a2.getString}.{a3.getString}.{a4.getString}"]
+  | _  => throw ()
+
+@[appUnexpander Name.mkStr5] def unexpandMkStr5 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a1:str $a2:str $a3:str $a4:str $a5:str) => return mkNode `Lean.Parser.Term.quotedName #[Syntax.mkNameLit s!"`{a1.getString}.{a2.getString}.{a3.getString}.{a4.getString}.{a5.getString}"]
+  | _  => throw ()
+
+@[appUnexpander Name.mkStr6] def unexpandMkStr6 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a1:str $a2:str $a3:str $a4:str $a5:str $a6:str) => return mkNode `Lean.Parser.Term.quotedName #[Syntax.mkNameLit s!"`{a1.getString}.{a2.getString}.{a3.getString}.{a4.getString}.{a5.getString}.{a6.getString}"]
+  | _  => throw ()
+
+@[appUnexpander Name.mkStr7] def unexpandMkStr7 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a1:str $a2:str $a3:str $a4:str $a5:str $a6:str $a7:str) => return mkNode `Lean.Parser.Term.quotedName #[Syntax.mkNameLit s!"`{a1.getString}.{a2.getString}.{a3.getString}.{a4.getString}.{a5.getString}.{a6.getString}.{a7.getString}"]
+  | _  => throw ()
+
+@[appUnexpander Name.mkStr8] def unexpandMkStr8 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a1:str $a2:str $a3:str $a4:str $a5:str $a6:str $a7:str $a8:str) => return mkNode `Lean.Parser.Term.quotedName #[Syntax.mkNameLit s!"`{a1.getString}.{a2.getString}.{a3.getString}.{a4.getString}.{a5.getString}.{a6.getString}.{a7.getString}.{a8.getString}"]
+  | _  => throw ()
+
+@[appUnexpander Array.mkArray1] def unexpandMkArray1 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a1) => `(#[$a1])
+  | _ => throw ()
+
+@[appUnexpander Array.mkArray2] def unexpandMkArray2 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a1 $a2) => `(#[$a1, $a2])
+  | _ => throw ()
+
+@[appUnexpander Array.mkArray3] def unexpandMkArray3 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a1 $a2 $a3) => `(#[$a1, $a2, $a3])
+  | _ => throw ()
+
+@[appUnexpander Array.mkArray4] def unexpandMkArray4 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a1 $a2 $a3 $a4) => `(#[$a1, $a2, $a3, $a4])
+  | _ => throw ()
+
+@[appUnexpander Array.mkArray5] def unexpandMkArray5 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a1 $a2 $a3 $a4 $a5) => `(#[$a1, $a2, $a3, $a4, $a5])
+  | _ => throw ()
+
+@[appUnexpander Array.mkArray6] def unexpandMkArray6 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a1 $a2 $a3 $a4 $a5 $a6) => `(#[$a1, $a2, $a3, $a4, $a5, $a6])
+  | _ => throw ()
+
+@[appUnexpander Array.mkArray7] def unexpandMkArray7 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a1 $a2 $a3 $a4 $a5 $a6 $a7) => `(#[$a1, $a2, $a3, $a4, $a5, $a6, $a7])
+  | _ => throw ()
+
+@[appUnexpander Array.mkArray8] def unexpandMkArray8 : Lean.PrettyPrinter.Unexpander
+  | `($(_) $a1 $a2 $a3 $a4 $a5 $a6 $a7 $a8) => `(#[$a1, $a2, $a3, $a4, $a5, $a6, $a7, $a8])
+  | _ => throw ()
+
 /--
 Apply function extensionality and introduce new hypotheses.
 The tactic `funext` will keep applying new the `funext` lemma until the goal target is not reducible to

stage0/src/Lean/Compiler/LCNF.lean

@@ -34,4 +34,5 @@ import Lean.Compiler.LCNF.ToLCNF
 import Lean.Compiler.LCNF.Types
 import Lean.Compiler.LCNF.Util
 import Lean.Compiler.LCNF.ConfigOptions
-import Lean.Compiler.LCNF.ForEachExpr
+import Lean.Compiler.LCNF.ForEachExpr
+import Lean.Compiler.LCNF.MonoTypes

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

@@ -147,6 +147,10 @@ def AltCore.getCode : Alt → Code
   | .default k => k
   | .alt _ _ k => k
 
+def AltCore.getParams : Alt → Array Param
+  | .default _ => #[]
+  | .alt _ ps _ => ps
+
 def AltCore.forCodeM [Monad m] (alt : Alt) (f : Code → m Unit) : m Unit := do
   match alt with
   | .default k => f k

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

@@ -71,6 +71,18 @@ instance [MonadCodeBind m] : MonadCodeBind (ReaderT ρ m) where
 instance [STWorld ω m] [MonadCodeBind m] : MonadCodeBind (StateRefT' ω σ m) where
   codeBind c f sref := c.bind fun fvarId => f fvarId sref
 
+/--
+Ensure resulting code has type `◾`.
+-/
+def Code.ensureAnyType (c : Code) : CompilerM Code := do
+  if (← c.inferType).isErased then
+    return c
+  else
+    c.bind fun fvarId => do
+      let cast ← mkLcCast (.fvar fvarId) erasedExpr
+      let decl ← LCNF.mkAuxLetDecl cast
+      return .let decl (.return decl.fvarId)
+
 /--
 Create new parameters for the given arrow type.
 Example: if `type` is `Nat → Bool → Int`, the result is

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

@@ -36,7 +36,7 @@ def checkAppArgs (f : Expr) (args : Array Expr) : CheckM Unit := do
   let mut j := 0
   for i in [:args.size] do
     let arg := args[i]!
-    if fType.isAnyType then
+    if fType.isErased then
       return ()
     fType := fType.headBeta
     let (d, b) ←
@@ -47,7 +47,7 @@ def checkAppArgs (f : Expr) (args : Array Expr) : CheckM Unit := do
         match fType with
         | .forallE _ d b _ => j := i; pure (d, b)
         | _ =>
-          if fType.isAnyType then return ()
+          if fType.isErased then return ()
           throwError "function expected at{indentExpr (mkAppN f args)}\narrow type expected{indentExpr fType}"
     let argType ← inferType arg
     let expectedType := d.instantiateRevRange j i args
@@ -147,7 +147,7 @@ partial def checkCases (c : Cases) : CheckM Expr := do
   let mut hasDefault := false
   checkFVar c.discr
   let discrType ← LCNF.getType c.discr
-  unless discrType.isAnyType do
+  unless discrType.isErased do
     let .const declName _ := discrType.headBeta.getAppFn | throwError "unexpected LCNF discriminant type {discrType}"
     unless c.typeName == declName do
       throwError "invalid LCNF `{c.typeName}.casesOn`, discriminant has type{indentExpr discrType}"

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

@@ -250,110 +250,6 @@ def mkFreshBinderName (binderName := `_x): CompilerM Name := do
   modify fun s => { s with nextIdx := s.nextIdx + 1 }
   return declName
 
-private def refreshBinderName (binderName : Name) : CompilerM Name := do
-  match binderName with
-  | .num p _ =>
-    let r := .num p (← get).nextIdx
-    modify fun s => { s with nextIdx := s.nextIdx + 1 }
-    return r
-  | _ => return binderName
-
-namespace Internalize
-
-abbrev InternalizeM := StateRefT FVarSubst CompilerM
-
-/-
-TODO: during internalization we must convert eliminate data that became computationally irrelevant.
-See note on "erasure confusion" for examples on how this can happen.
--/
-
-/--
-The `InternalizeM` monad is a translator. It "translates" the free variables
-in the input expressions and `Code`, into new fresh free variables in the
-local context.
--/
-instance : MonadFVarSubst InternalizeM true where
-  getSubst := get
-
-instance : MonadFVarSubstState InternalizeM where
-  modifySubst := modify
-
-private def mkNewFVarId (fvarId : FVarId) : InternalizeM FVarId := do
-  let fvarId' ← Lean.mkFreshFVarId
-  addFVarSubst fvarId fvarId'
-  return fvarId'
-
-def internalizeParam (p : Param) : InternalizeM Param := do
-  let binderName ← refreshBinderName p.binderName
-  let type ← normExpr p.type
-  let fvarId ← mkNewFVarId p.fvarId
-  let p := { p with binderName, fvarId, type }
-  modifyLCtx fun lctx => lctx.addParam p
-  return p
-
-def internalizeLetDecl (decl : LetDecl) : InternalizeM LetDecl := do
-  let binderName ← refreshBinderName decl.binderName
-  let type ← normExpr decl.type
-  let value ← normExpr decl.value
-  let fvarId ← mkNewFVarId decl.fvarId
-  let decl := { decl with binderName, fvarId, type, value }
-  modifyLCtx fun lctx => lctx.addLetDecl decl
-  return decl
-
-mutual
-
-partial def internalizeFunDecl (decl : FunDecl) : InternalizeM FunDecl := do
-  let type ← normExpr decl.type
-  let binderName ← refreshBinderName decl.binderName
-  let params ← decl.params.mapM internalizeParam
-  let value ← internalizeCode decl.value
-  let fvarId ← mkNewFVarId decl.fvarId
-  let decl := { decl with binderName, fvarId, params, type, value }
-  modifyLCtx fun lctx => lctx.addFunDecl decl
-  return decl
-
-partial def internalizeCode (code : Code) : InternalizeM Code := do
-  match code with
-  | .let decl k => return .let (← internalizeLetDecl decl) (← internalizeCode k)
-  | .fun decl k => return .fun (← internalizeFunDecl decl) (← internalizeCode k)
-  | .jp decl k => return .jp (← internalizeFunDecl decl) (← internalizeCode k)
-  | .return fvarId => return .return (← normFVar fvarId)
-  | .jmp fvarId args => return .jmp (← normFVar fvarId) (← args.mapM normExpr)
-  | .unreach type => return .unreach (← normExpr type)
-  | .cases c =>
-    let resultType ← normExpr c.resultType
-    let discr ← normFVar c.discr
-    let alts ← c.alts.mapM fun
-      | .alt ctorName params k => return .alt ctorName (← params.mapM internalizeParam) (← internalizeCode k)
-      | .default k => return .default (← internalizeCode k)
-    return .cases { c with discr, alts, resultType }
-
-end
-
-partial def internalizeCodeDecl (decl : CodeDecl) : InternalizeM CodeDecl := do
-  match decl with
-  | .let decl => return .let (← internalizeLetDecl decl)
-  | .fun decl => return .fun (← internalizeFunDecl decl)
-  | .jp decl => return .jp (← internalizeFunDecl decl)
-
-end Internalize
-
-/--
-Refresh free variables ids in `code`, and store their declarations in the local context.
--/
-partial def Code.internalize (code : Code) (s : FVarSubst := {}) : CompilerM Code :=
-  Internalize.internalizeCode code |>.run' s
-
-open Internalize in
-def Decl.internalize (decl : Decl) (s : FVarSubst := {}): CompilerM Decl :=
-  go decl |>.run' s
-where
-  go (decl : Decl) : InternalizeM Decl := do
-    let type ← normExpr decl.type
-    let params ← decl.params.mapM internalizeParam
-    let value ← internalizeCode decl.value
-    return { decl with type, params, value }
-
 /-!
 Helper functions for creating LCNF local declarations.
 -/
@@ -472,15 +368,6 @@ def mkFreshJpName : CompilerM Name := do
 def mkAuxParam (type : Expr) (borrow := false) : CompilerM Param := do
   mkParam (← mkFreshBinderName `_y) type borrow
 
-/--
-Create a fresh local context and internalize the given decls.
--/
-def cleanup (decl : Array Decl) : CompilerM (Array Decl) := do
-  modify fun _ => {}
-  decl.mapM fun decl => do
-    modify fun s => { s with nextIdx := 1 }
-    decl.internalize
-
 def getConfig : CompilerM ConfigOptions :=
   return (← read).config
 

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

@@ -31,6 +31,14 @@ private partial def depOn (c : Code) : M Bool :=
 abbrev LetDecl.dependsOn (decl : LetDecl) (s : FVarIdSet) :  Bool :=
   decl.depOn s
 
+abbrev FunDecl.dependsOn (decl : FunDecl) (s : FVarIdSet) :  Bool :=
+  exprDepOn decl.type s || depOn decl.value s
+
+def CodeDecl.dependsOn (decl : CodeDecl) (s : FVarIdSet) : Bool :=
+  match decl with
+  | .let decl => decl.dependsOn s
+  | .jp decl | .fun decl => decl.dependsOn s
+
 /--
 Return `true` is `c` depends on a free variable in `s`.
 -/

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

@@ -6,6 +6,7 @@ Authors: Leonardo de Moura
 import Lean.Compiler.LCNF.CompilerM
 import Lean.Compiler.LCNF.Types
 import Lean.Compiler.LCNF.PhaseExt
+import Lean.Compiler.LCNF.OtherDecl
 
 namespace Lean.Compiler.LCNF
 /-! # Type inference for LCNF -/
@@ -91,17 +92,13 @@ def mkForallParams (params : Array Param) (type : Expr) : InferTypeM Expr :=
     k (.fvar fvarId)
 
 def inferConstType (declName : Name) (us : List Level) : CompilerM Expr := do
-  if declName == ``lcAny || declName == ``lcErased then
-    return anyTypeExpr
+  if declName == ``lcErased then
+    return erasedExpr
   else if let some decl ← getDecl? declName then
     return decl.instantiateTypeLevelParams us
   else
-    /-
-    We need this case for declarations that do not have code associated with them.
-    Example: constructors.
-    TODO: phase support.
-    -/
-    instantiateLCNFTypeLevelParams declName us
+    /- Declaration does not have code associated with it: constructor, inductive type, foreign function -/
+    getOtherDeclType declName us
 
 mutual
 
@@ -132,7 +129,7 @@ mutual
         match fType with
         | .forallE _ _ b _ => j := i; fType := b
         | _ =>
-          if fType.isAnyType then return anyTypeExpr
+          if fType.isErased then return erasedExpr
           throwError "function expected{indentExpr (mkAppN f args[:i])} : {fType}\nfunction type{indentExpr (← inferType f)}"
     return fType.instantiateRevRange j args.size args |>.headBeta
 
@@ -143,9 +140,9 @@ mutual
     let failed {α} : Unit → InferTypeM α := fun _ =>
       throwError "invalid projection{indentExpr (mkProj structName idx s)}"
     let structType := (← inferType s).headBeta
-    if structType.isAnyType then
+    if structType.isErased then
       /- TODO: after we erase universe variables, we can just extract a better type using just `structName` and `idx`. -/
-      return anyTypeExpr
+      return erasedExpr
     else
       matchConstStruct structType.getAppFn failed fun structVal structLvls ctorVal =>
         let n := structVal.numParams
@@ -159,23 +156,23 @@ mutual
             | .forallE _ _ body _ =>
               if body.hasLooseBVars then
                 -- This can happen when one of the fields is a type or type former.
-                ctorType := body.instantiate1 anyTypeExpr
+                ctorType := body.instantiate1 erasedExpr
               else
                 ctorType := body
             | _ =>
-              if ctorType.isAnyType then return anyTypeExpr
+              if ctorType.isErased then return erasedExpr
               failed ()
           match ctorType with
           | .forallE _ d _ _ => return d
           | _ =>
-            if ctorType.isAnyType then return anyTypeExpr
+            if ctorType.isErased then return erasedExpr
             failed ()
 
   partial def getLevel? (type : Expr) : InferTypeM (Option Level) := do
     match (← inferType type) with
     | .sort u => return some u
     | e =>
-      if e.isAnyType then
+      if e.isErased then
         return none
       else
         throwError "type expected{indentExpr type}"
@@ -190,11 +187,11 @@ mutual
           go b (fvars.push fvar)
       | _ =>
         let e := e.instantiateRev fvars
-        let some u ← getLevel? e | return anyTypeExpr
+        let some u ← getLevel? e | return erasedExpr
         let mut u := u
         for x in fvars.reverse do
           let xType ← inferType x
-          let some v ← getLevel? xType | return anyTypeExpr
+          let some v ← getLevel? xType | return erasedExpr
           u := mkLevelIMax' v u
         return .sort u.normalize
 
@@ -220,7 +217,7 @@ def inferType (e : Expr) : CompilerM Expr :=
 def getLevel (type : Expr) : CompilerM Level := do
   match (← inferType type) with
   | .sort u => return u
-  | e => if e.isAnyType then return levelOne else throwError "type expected{indentExpr type}"
+  | e => if e.isErased then return levelOne else throwError "type expected{indentExpr type}"
 
 /-- Create `lcCast expectedType e : expectedType` -/
 def mkLcCast (e : Expr) (expectedType : Expr) : CompilerM Expr := do
@@ -315,9 +312,7 @@ Remark: if the result is `true`, then `a` and `b` are indeed compatible.
 If it is `false`, we must use the full-check.
 -/
 partial def compatibleTypesQuick (a b : Expr) : Bool :=
-  if a.isAnyType || b.isAnyType then
-    true
-  else if a.isErased || b.isErased then
+  if a.isErased || b.isErased then
     true
   else
     let a' := a.headBeta
@@ -343,9 +338,7 @@ partial def compatibleTypesQuick (a b : Expr) : Bool :=
 Complete check for `compatibleTypes`. It eta-expands type formers. See comment at `compatibleTypes`.
 -/
 partial def InferType.compatibleTypesFull (a b : Expr) : InferTypeM Bool := do
-  if a.isAnyType || b.isAnyType then
-    return true
-  else if a.isErased || b.isErased then
+  if a.isErased || b.isErased then
     return true
   else
     let a' := a.headBeta

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

@@ -0,0 +1,172 @@
+/-
+Copyright (c) 2022 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Compiler.LCNF.Types
+import Lean.Compiler.LCNF.Bind
+import Lean.Compiler.LCNF.CompilerM
+
+namespace Lean.Compiler.LCNF
+
+private def refreshBinderName (binderName : Name) : CompilerM Name := do
+  match binderName with
+  | .num p _ =>
+    let r := .num p (← get).nextIdx
+    modify fun s => { s with nextIdx := s.nextIdx + 1 }
+    return r
+  | _ => return binderName
+
+namespace Internalize
+
+abbrev InternalizeM := StateRefT FVarSubst CompilerM
+
+/--
+The `InternalizeM` monad is a translator. It "translates" the free variables
+in the input expressions and `Code`, into new fresh free variables in the
+local context.
+-/
+instance : MonadFVarSubst InternalizeM true where
+  getSubst := get
+
+instance : MonadFVarSubstState InternalizeM where
+  modifySubst := modify
+
+private def mkNewFVarId (fvarId : FVarId) : InternalizeM FVarId := do
+  let fvarId' ← Lean.mkFreshFVarId
+  addFVarSubst fvarId fvarId'
+  return fvarId'
+
+def internalizeParam (p : Param) : InternalizeM Param := do
+  let binderName ← refreshBinderName p.binderName
+  let type ← normExpr p.type
+  let fvarId ← mkNewFVarId p.fvarId
+  let p := { p with binderName, fvarId, type }
+  modifyLCtx fun lctx => lctx.addParam p
+  return p
+
+def internalizeLetDecl (decl : LetDecl) : InternalizeM LetDecl := do
+  let binderName ← refreshBinderName decl.binderName
+  let type ← normExpr decl.type
+  let value ← normExpr decl.value
+  let fvarId ← mkNewFVarId decl.fvarId
+  let decl := { decl with binderName, fvarId, type, value }
+  modifyLCtx fun lctx => lctx.addLetDecl decl
+  return decl
+
+mutual
+
+partial def internalizeFunDecl (decl : FunDecl) : InternalizeM FunDecl := do
+  let type ← normExpr decl.type
+  let binderName ← refreshBinderName decl.binderName
+  let params ← decl.params.mapM internalizeParam
+  let value ← internalizeCode decl.value
+  let fvarId ← mkNewFVarId decl.fvarId
+  let decl := { decl with binderName, fvarId, params, type, value }
+  modifyLCtx fun lctx => lctx.addFunDecl decl
+  return decl
+
+partial def internalizeCode (code : Code) : InternalizeM Code := do
+  match code with
+  | .let decl k => return .let (← internalizeLetDecl decl) (← internalizeCode k)
+  | .fun decl k => return .fun (← internalizeFunDecl decl) (← internalizeCode k)
+  | .jp decl k => return .jp (← internalizeFunDecl decl) (← internalizeCode k)
+  | .return fvarId => return .return (← normFVar fvarId)
+  | .jmp fvarId args => return .jmp (← normFVar fvarId) (← args.mapM normExpr)
+  | .unreach type => return .unreach (← normExpr type)
+  | .cases c =>
+    let resultType ← normExpr c.resultType
+    let ensureAny := resultType != c.resultType && resultType.isErased
+    /-
+    Note:
+    If the new result type for the cases is `◾`, we must add a cast to `◾` (aka the any type)
+    to every alternative if their resulting type is not `◾`. This is similar to what we do at `ToLCNF.visitCases`.
+    Here is an example to illustrate this issue.
+    Suppose we have
+    ```
+    inductive Id {A : Type u} : A → A → Type u
+      | refl {a : A} : Id a a
+    def transport {A : Type u} (B : A → Type v) {a b : A} (p : Id a b) : B a → B b :=
+    ```
+    Its LCNF type is
+    ```
+    {A : Type u} (B : A → Type v) {a b : A} (p : Id ◾ ◾) (a.1 : B ◾) : B ◾
+    ```
+    and base phase code is
+    ```
+    cases p : B ◾
+    | Id.refl =>
+      a.1
+    ```
+    Now suppose we define
+    ```
+    def transportconst {A B : Type u} : A = B → A → B :=
+      transport id
+    ```
+    By setting `B` as `id`, and then inlining `transport, we would have the following code for `transportconst` is
+    ```
+    cases p : ◾
+    | Id.refl =>
+      a.1
+    ```
+    Which can be checked by `Check.lean` because it assumes `◾` is compatible with anything and `a.1 : A`.
+    However, if inline `transportconst`, we can hit type error since the continuation for transportconst is
+    expecting a `B` instead of an `A`. We avoid this problem by adding a cast to `◾`. See `ToLCNF.visitCases` for
+    another place where we use this approach.
+    Thus, the resulting code for `transportconst` is
+    ```
+    def MWE.transportconst (A : Type u) (B : Type u) (p : Id A B) (a.1 : A) :=
+      cases p
+      | Id.refl =>
+        let _x.2 := @lcCast A ◾ a.1
+        _x.2
+    ```
+    -/
+    let internalizeAltCode (k : Code) : InternalizeM Code := do
+      let k ← internalizeCode k
+      if ensureAny then
+        k.ensureAnyType
+      else
+        return k
+    let discr ← normFVar c.discr
+    let alts ← c.alts.mapM fun
+      | .alt ctorName params k => return .alt ctorName (← params.mapM internalizeParam) (← internalizeAltCode k)
+      | .default k => return .default (← internalizeAltCode k)
+    return .cases { c with discr, alts, resultType }
+
+end
+
+partial def internalizeCodeDecl (decl : CodeDecl) : InternalizeM CodeDecl := do
+  match decl with
+  | .let decl => return .let (← internalizeLetDecl decl)
+  | .fun decl => return .fun (← internalizeFunDecl decl)
+  | .jp decl => return .jp (← internalizeFunDecl decl)
+
+end Internalize
+
+/--
+Refresh free variables ids in `code`, and store their declarations in the local context.
+-/
+partial def Code.internalize (code : Code) (s : FVarSubst := {}) : CompilerM Code :=
+  Internalize.internalizeCode code |>.run' s
+
+open Internalize in
+def Decl.internalize (decl : Decl) (s : FVarSubst := {}): CompilerM Decl :=
+  go decl |>.run' s
+where
+  go (decl : Decl) : InternalizeM Decl := do
+    let type ← normExpr decl.type
+    let params ← decl.params.mapM internalizeParam
+    let value ← internalizeCode decl.value
+    return { decl with type, params, value }
+
+/--
+Create a fresh local context and internalize the given decls.
+-/
+def cleanup (decl : Array Decl) : CompilerM (Array Decl) := do
+  modify fun _ => {}
+  decl.mapM fun decl => do
+    modify fun s => { s with nextIdx := 1 }
+    decl.internalize
+
+end Lean.Compiler.LCNF

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

@@ -5,11 +5,94 @@ Authors: Henrik Böving
 -/
 import Lean.Compiler.LCNF.CompilerM
 import Lean.Compiler.LCNF.PassManager
+import Lean.Compiler.LCNF.PullFunDecls
 
 namespace Lean.Compiler.LCNF
 
+-- TODO: These can be used in a much more general context
+partial def mapFVarM [Monad m] (f : FVarId → m FVarId) (e : Expr) : m Expr := do
+  match e with
+  | .proj typ idx struct => return .proj typ idx (←mapFVarM f struct)
+  | .app fn arg => return .app (←mapFVarM f fn) (←mapFVarM f arg)
+  | .fvar fvarId => return .fvar (←f fvarId)
+  | .lam arg ty body bi =>
+    return .lam arg (←mapFVarM f ty) (←mapFVarM f body) bi
+  | .forallE arg ty body bi =>
+    return .forallE arg (←mapFVarM f ty) (←mapFVarM f body) bi
+  | .letE var ty value body nonDep  =>
+    return .letE var (←mapFVarM f ty) (←mapFVarM f value) (←mapFVarM f body) nonDep
+  | .bvar .. | .sort .. => return e
+  | .mdata .. | .const .. | .lit .. => return e
+  | .mvar .. => unreachable!
+
+partial def forFVarM [Monad m] (f : FVarId → m Unit) (e : Expr) : m Unit := do
+  match e with
+  | .proj _ _ struct => forFVarM f struct
+  | .app fn arg =>
+    forFVarM f fn
+    forFVarM f arg
+  | .fvar fvarId => f fvarId
+  | .lam _ ty body .. =>
+    forFVarM f ty
+    forFVarM f body
+  | .forallE _ ty body .. =>
+    forFVarM f ty
+    forFVarM f body
+  | .letE _ ty value body ..  =>
+    forFVarM f ty
+    forFVarM f value
+    forFVarM f body
+  | .bvar .. | .sort .. => return
+  | .mdata .. | .const .. | .lit .. => return
+  | .mvar .. => unreachable!
+
+/--
+A general abstraction for the idea of a scope in the compiler.
+-/
+abbrev ScopeM := StateRefT FVarIdSet CompilerM
+
+namespace ScopeM
+
+def getScope : ScopeM FVarIdSet := get
+def setScope (newScope : FVarIdSet) : ScopeM Unit := set newScope
+def clearScope : ScopeM Unit := setScope {}
+
+/--
+Execute `x` but recover the previous scope after doing so.
+-/
+def withBackTrackingScope [MonadLiftT ScopeM m] [Monad m] [MonadFinally m] (x : m α) : m α := do
+  let scope ← getScope
+  try x finally setScope scope
+
+/--
+Clear the current scope for the monadic action `x`, afterwards continuing
+with the old one.
+-/
+def withNewScope [MonadLiftT ScopeM m] [Monad m] [MonadFinally m] (x : m α) : m α := do
+  withBackTrackingScope do
+    clearScope
+    x
+
+/--
+Check whether `fvarId` is in the current scope, that is, was declared within
+the current `fun` declaration that is being processed.
+-/
+def isInScope (fvarId : FVarId) : ScopeM Bool := do
+  let scope ← getScope
+  return scope.contains fvarId
+
+/--
+Add a new `FVarId` to the current scope.
+-/
+def addToScope (fvarId : FVarId) : ScopeM Unit :=
+  modify fun scope => scope.insert fvarId
+
+end ScopeM
+
 namespace JoinPointFinder
 
+open ScopeM
+
 /--
 Info about a join point candidate (a `fun` declaration) during the find phase.
 -/
@@ -41,7 +124,7 @@ structure FindState where
 
 abbrev ReplaceCtx := HashMap FVarId Name
 
-abbrev FindM := ReaderT (Option FVarId) StateRefT FindState CompilerM
+abbrev FindM := ReaderT (Option FVarId) StateRefT FindState ScopeM
 abbrev ReplaceM := ReaderT ReplaceCtx CompilerM
 
 /--
@@ -69,17 +152,7 @@ private def modifyCandidates (f : HashMap FVarId CandidateInfo → HashMap FVarI
 Remove all join point candidates contained in `e`.
 -/
 private partial def removeCandidatesContainedIn (e : Expr) : FindM Unit := do
-  match e with
-  | .proj _ _ struct => removeCandidatesContainedIn struct
-  | .app fn arg =>
-    removeCandidatesContainedIn fn
-    removeCandidatesContainedIn arg
-  | .fvar fvarId => eraseCandidate fvarId
-  -- These cannot occur in (computationally relevant) LCNF
-  | .bvar .. | .lam .. | .sort .. | .forallE .. | .letE .. => return
-  -- These we just don't care about
-  | .mdata .. | .const .. | .lit .. => return
-  | .mvar .. => unreachable!
+  forFVarM eraseCandidate e
 
 /--
 Add a new join point candidate to the state.
@@ -97,29 +170,6 @@ private def addDependency (src : FVarId) (target : FVarId) : FindM Unit := do
   else
     eraseCandidate src
 
-/--
-Clear the current scope for the monadic action `x`, afterwards continuing
-with the old one.
--/
-private def withNewScope (x : FindM α) : FindM α := do
-  let scope := (← get).scope
-  modify fun s => { s with scope := {} }
-  try x finally modify fun s => { s with scope }
-
-/--
-Check whether `fvarId` is in the current scope, that is, was declared within
-the current `fun` declaration that is being processed.
--/
-private def isInScope (fvarId : FVarId) : FindM Bool := do
-  let scope := (← get).scope
-  return scope.contains fvarId
-
-/--
-Add a new `FVarId` to the current scope.
--/
-private def addToScope (fvarId : FVarId) : FindM Unit :=
-  modify fun state => { state with scope := state.scope.insert fvarId }
-
 /--
 Find all `fun` declarations that qualify as a join point, that is:
 - are always fully applied
@@ -153,7 +203,7 @@ this. This is because otherwise the calls to `myjp` in `f` and `g` would
 produce out of scope join point jumps.
 -/
 partial def find (decl : Decl) : CompilerM FindState := do
-  let (_, candidates) ← go decl.value |>.run none |>.run {}
+  let (_, candidates) ← go decl.value |>.run none |>.run {} |>.run' {}
   return candidates
 where
   go : Code → FindM Unit
@@ -236,6 +286,235 @@ where
 
 end JoinPointFinder
 
+namespace JoinPointContextExtender
+
+open ScopeM
+
+/--
+The context managed by `ExtendM`.
+-/
+structure ExtendContext where
+  /--
+  The `FVarId` of the current join point if we are currently inside one.
+  -/
+  currentJp? : Option FVarId := none
+  /--
+  The list of valid candidates for extending the context. This will be
+  all `let` and `fun` declarations as well as all `jp` parameters up
+  until the last `fun` declaration in the tree.
+  -/
+  candidates : FVarIdSet := {}
+
+/--
+The state managed by `ExtendM`.
+-/
+structure ExtendState where
+  /--
+  A map from join point `FVarId`s to a respective map from free variables
+  to `Param`s. The free variables in this map are the once that the context
+  of said join point will be extended by by passing in the respective parameter.
+  -/
+  fvarMap : HashMap FVarId (HashMap FVarId Param) := {}
+
+/--
+The monad for the `extendJoinPointContext` pass.
+-/
+abbrev ExtendM := ReaderT ExtendContext StateRefT ExtendState ScopeM
+
+/--
+Replace a free variable if necessary, that is:
+- It is in the list of candidates
+- We are currently within a join point (if we are within a function there
+  cannot be a need to replace them since we dont extend their context)
+- Said join point actually has a replacement parameter registered.
+otherwise just return `fvar`.
+-/
+def replaceFVar (fvar : FVarId) : ExtendM FVarId := do
+  if (←read).candidates.contains fvar then
+    if let some currentJp := (←read).currentJp? then
+      if let some replacement := (←get).fvarMap.find! currentJp |>.find? fvar then
+        return replacement.fvarId
+  return fvar
+
+/--
+Add a new candidate to the current scope + to the list of candidates
+if we are currently within a join point. Then execute `x`.
+-/
+def withNewCandidate (fvar : FVarId) (x : ExtendM α) : ExtendM α := do
+  addToScope fvar
+  if (←read).currentJp?.isSome then
+    withReader (fun ctx => { ctx with candidates := ctx.candidates.insert fvar }) do
+      x
+  else
+    x
+
+/--
+Same as `withNewCandidate` but with multiple `FVarId`s.
+-/
+def withNewCandidates (fvars : Array FVarId) (x : ExtendM α) : ExtendM α := do
+  if (←read).currentJp?.isSome then
+    let candidates := (←read).candidates
+    let folder := (fun acc val => do addToScope val; return acc.insert val)
+    let newCandidates ← fvars.foldlM (init := candidates) folder
+    withReader (fun ctx => { ctx with candidates := newCandidates }) do
+      x
+  else
+    x
+
+/--
+Extend the context of the current join point (if we are within one)
+by `fvar` if necessary.
+This is necessary if:
+- `fvar` is not in scope (that is, was declared outside of the current jp)
+- we have not already extended the context by `fvar`
+- the list of candidates contains `fvar`. This is because if we have something
+  like:
+  ```
+  let x := ..
+  fun f a =>
+    jp j b =>
+      let y := x
+      y
+  ```
+  There is no point in extending the context of `j` by `x` because we
+  cannot lift a join point outside of a local function declaration.
+-/
+def extendByIfNecessary (fvar : FVarId) : ExtendM Unit := do
+  if let some currentJp := (←read).currentJp? then
+    let mut translator := (←get).fvarMap.find! currentJp
+    let candidates := (←read).candidates
+    if !(←isInScope fvar) && !translator.contains fvar && candidates.contains fvar then
+      let typ ← getType fvar
+      let newParam ← mkAuxParam typ
+      translator := translator.insert fvar newParam
+      modify fun s => { s with fvarMap := s.fvarMap.insert currentJp translator }
+
+/--
+Merge the extended context of two join points if necessary. That is
+if we have a structure such as:
+```
+jp j.1 ... =>
+  jp j.2 .. =>
+    ...
+  ...
+```
+And we are just done visiting `j.2` we want to extend the context of
+`j.1` by all free variables that the context of `j.2` was extended by
+as well because we need to drag these variables through at the call sites
+of `j.2` in `j.1`.
+-/
+def mergeJpContextIfNecessary (jp : FVarId) : ExtendM Unit := do
+  if (←read).currentJp?.isSome then
+    let additionalArgs := (←get).fvarMap.find! jp |>.toArray
+    for (fvar, _) in additionalArgs do
+      extendByIfNecessary fvar
+
+/--
+We call this whenever we enter a new local function. It clears both the
+current join point and the list of candidates since we cant lift join
+points outside of functions as explained in `mergeJpContextIfNecessary`.
+-/
+def withNewFunScope (decl : FunDecl) (x : ExtendM α): ExtendM α := do
+  withReader (fun ctx => { ctx with currentJp? := none, candidates := {} }) do
+    withNewScope do
+      x
+
+/--
+We call this whenever we enter a new join point. It will set the current
+join point and extend the list of candidates by all of the parameters of
+the join point. This is so in the case of nested join points that refer
+to parameters of the current one we extend the context of the nested
+join points by said parameters.
+-/
+def withNewJpScope (decl : FunDecl) (x : ExtendM α): ExtendM α := do
+  withReader (fun ctx => { ctx with currentJp? := some decl.fvarId }) do
+    modify fun s => { s with fvarMap := s.fvarMap.insert decl.fvarId {} }
+    withNewScope do
+      withNewCandidates (decl.params.map (·.fvarId)) do
+        x
+
+/--
+We call this whenever we visit a new arm of a cases statement.
+It will back up the current scope (since we are doing a case split
+and want to continue with other arms afterwards) and add all of the
+parameters of the match arm to the list of candidates.
+-/
+def withNewAltScope (alt : Alt) (x : ExtendM α) : ExtendM α := do
+  withBackTrackingScope do
+    withNewCandidates (alt.getParams.map (·.fvarId)) do
+      x
+
+/--
+Use all of the above functions to find free variables declared outside
+of join points that said join points can be reasonaly extended by. Reasonable
+meaning that in case the current join point is nested within a function
+declaration we will not extend it by free variables declared before the
+function declaration because we cannot lift join points outside of function
+declarations.
+
+All of this is done to eliminate dependencies of join points onto their
+position within the code so we can pull them out as far as possible, hopefully
+enabling new inlining possibilities in the next simplifier run.
+-/
+partial def extend (decl : Decl) : CompilerM Decl := do
+  let newValue ← go decl.value |>.run {} |>.run' {} |>.run' {}
+  let decl := { decl with value := newValue }
+  decl.pullFunDecls
+where
+  goExpr (e : Expr) : ExtendM Expr :=
+    let visitor := fun fvar => do
+      extendByIfNecessary fvar
+      replaceFVar fvar
+    mapFVarM visitor e
+  go (code : Code) : ExtendM Code := do
+    match code with
+    | .let decl k =>
+      let decl ← decl.updateValue (←goExpr decl.value)
+      withNewCandidate decl.fvarId do
+        return Code.updateLet! code decl (←go k)
+    | .jp decl k =>
+      let decl ← withNewJpScope decl do
+        let value ← go decl.value
+        let additionalParams := (←get).fvarMap.find! decl.fvarId |>.toArray |>.map Prod.snd
+        let newType := additionalParams.foldr (init := decl.type) (fun val acc => .forallE val.binderName val.type acc .default)
+        decl.update newType (additionalParams ++ decl.params) value
+      mergeJpContextIfNecessary decl.fvarId
+      withNewCandidate decl.fvarId do
+        return Code.updateFun! code decl (←go k)
+    | .fun decl k =>
+      let decl ← withNewFunScope decl do
+        decl.updateValue (←go decl.value)
+      withNewCandidate decl.fvarId do
+        return Code.updateFun! code decl (←go k)
+    | .cases cs =>
+      extendByIfNecessary cs.discr
+      let discr ← replaceFVar cs.discr
+      let visitor := fun alt => do
+        withNewAltScope alt do
+          alt.mapCodeM go
+      let alts ← cs.alts.mapM visitor
+      return Code.updateCases! code cs.resultType discr alts
+    | .jmp fn args =>
+      let mut newArgs ← args.mapM goExpr
+      let additionalArgs := (←get).fvarMap.find! fn |>.toArray |>.map Prod.fst
+      if let some currentJp := (←read).currentJp? then
+        let translator := (←get).fvarMap.find! currentJp
+        let f := fun arg =>
+          if let some translated := translator.find? arg then
+            .fvar translated.fvarId
+          else
+            .fvar arg
+        newArgs := (additionalArgs.map f) ++ newArgs
+      else
+        newArgs := (additionalArgs.map .fvar) ++ newArgs
+      return Code.updateJmp! code fn newArgs
+    | .return var =>
+      extendByIfNecessary var
+      return Code.updateReturn! code (←replaceFVar var)
+    | .unreach .. => return code
+
+end JoinPointContextExtender
+
 /--
 Find all `fun` declarations in `decl` that qualify as join points then replace
 their definitions and call sites with `jp`/`jmp`.
@@ -251,4 +530,13 @@ def findJoinPoints : Pass :=
 builtin_initialize
   registerTraceClass `Compiler.findJoinPoints (inherited := true)
 
+def Decl.extendJoinPointContext (decl : Decl) : CompilerM Decl := do
+  JoinPointContextExtender.extend decl
+
+def extendJoinPointContext : Pass :=
+  .mkPerDeclaration `extendJoinPointContext Decl.extendJoinPointContext .base
+
+builtin_initialize
+  registerTraceClass `Compiler.extendJoinPointContext (inherited := true)
+
 end Lean.Compiler.LCNF

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

@@ -50,7 +50,7 @@ def checkpoint (stepName : Name) (decls : Array Decl) : CompilerM Unit := do
     withOptions (fun opts => opts.setBool `pp.motives.pi false) do
       let clsName := `Compiler ++ stepName
       if (← Lean.isTracingEnabledFor clsName) then
-        Lean.addTrace clsName m!"size: {decl.size}\n{← ppDecl decl}"
+        Lean.addTrace clsName m!"size: {decl.size}\n{← ppDecl' decl}"
       if compiler.check.get (← getOptions) then
         decl.check
   if compiler.check.get (← getOptions) then
@@ -91,8 +91,9 @@ def showDecl (phase : Phase) (declName : Name) : CoreM Format := do
   ppDecl' decl
 
 @[export lean_lcnf_compile_decls]
-def main (declNames : List Name) : CoreM Unit :=
-  CompilerM.run <| discard <| PassManager.run declNames.toArray
+def main (declNames : List Name) : CoreM Unit := do
+  profileitM Exception "compilation new" (← getOptions) do
+    CompilerM.run <| discard <| PassManager.run declNames.toArray
 
 builtin_initialize
   registerTraceClass `Compiler.init (inherited := true)

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

@@ -0,0 +1,49 @@
+/-
+Copyright (c) 2022 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Compiler.LCNF.InferType
+
+namespace Lean.Compiler.LCNF
+
+/--
+Convert a LCNF type from the base phase to the mono phase.
+
+LCNF types in the mono phase do not have dependencies,
+and universe levels have been erased.
+
+The type contains only `→` and constants.
+-/
+partial def toMonoType (type : Expr) : CompilerM Expr := do
+  let type := type.headBeta
+  if type.isErased then
+    return erasedExpr
+  else if type.isErased then
+    return erasedExpr
+  else if isTypeFormerType type then
+    return erasedExpr
+  else match type with
+    | .const ..        => visitApp type #[]
+    | .app ..          => type.withApp visitApp
+    | .forallE _ d b _ => mkArrow (← toMonoType d) (← toMonoType (b.instantiate1 erasedExpr))
+    | _                => return erasedExpr
+where
+  visitApp (f : Expr) (args : Array Expr) : CompilerM Expr := do
+    match f with
+    | .const declName _ =>
+      let mut result := mkConst declName
+      for arg in args do
+        let arg := arg.headBeta
+        if arg.isErased then
+          result := mkApp result arg
+        else
+          let argType := (← inferType arg).headBeta
+          if argType.isErased || argType matches .sort _ then
+            result := mkApp result (← toMonoType arg)
+          else
+            result := mkApp result erasedExpr
+      return result
+    | _ => return erasedExpr
+
+end Lean.Compiler.LCNF

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

@@ -0,0 +1,44 @@
+/-
+Copyright (c) 2022 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Compiler.LCNF.CompilerM
+import Lean.Compiler.LCNF.Types
+
+namespace Lean.Compiler.LCNF
+
+/--
+State for the environment extension used to save the type of declarations
+that do not have code associated with them.
+Example: constructors, inductive types, foreign functions.
+-/
+structure OtherTypeExtState where
+  /-- The LCNF type for the `base` phase. -/
+  base : PHashMap Name Expr := {}
+  /-- The LCNF type for the `mono` phase. -/
+  mono : PHashMap Name Expr := {}
+  deriving Inhabited
+
+builtin_initialize otherTypeExt : EnvExtension OtherTypeExtState ←
+  registerEnvExtension (pure {})
+
+def getOtherDeclBaseType (declName : Name) (us : List Level) : CoreM Expr := do
+  let info ← getConstInfo declName
+  let type ← match otherTypeExt.getState (← getEnv) |>.base.find? declName with
+    | some type => pure type
+    | none =>
+      let type ← Meta.MetaM.run' <| toLCNFType info.type
+      modifyEnv fun env => otherTypeExt.modifyState env fun s => { s with base := s.base.insert declName type }
+      pure type
+  return type.instantiateLevelParams info.levelParams us
+
+/--
+Return the LCNF type for constructors, inductive types, and foreign functions.
+-/
+def getOtherDeclType (declName : Name) (us : List Level := []) : CompilerM Expr := do
+  match (← getPhase) with
+  | .base => getOtherDeclBaseType declName us
+  | _ => unreachable! -- TODO
+
+end Lean.Compiler.LCNF

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

@@ -24,6 +24,17 @@ def init : Pass where
     return decls
   phase := .base
 
+def normalizeFVarIds (decl : Decl) : CoreM Decl := do
+  let ngenSaved ← getNGen
+  setNGen {}
+  try
+    CompilerM.run <| decl.internalize
+  finally
+    setNGen ngenSaved
+
+def saveBase : Pass :=
+  .mkPerDeclaration `saveBase (fun decl => do (← normalizeFVarIds decl).saveBase; return decl) .base
+
 def builtinPassManager : PassManager := {
   passes := #[
     init,
@@ -33,6 +44,7 @@ def builtinPassManager : PassManager := {
     findJoinPoints,
     pullFunDecls,
     reduceJpArity,
+    -- extendJoinPointContext,
     simp { etaPoly := true, inlinePartial := true, implementedBy := true } (occurrence := 1),
     specialize,
     simp (occurrence := 2),

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

@@ -54,17 +54,6 @@ def getDeclAt? (declName : Name) (phase : Phase) : CoreM (Option Decl) :=
 def getDecl? (declName : Name) : CompilerM (Option Decl) := do
   getDeclAt? declName (← getPhase)
 
-def normalizeFVarIds (decl : Decl) : CoreM Decl := do
-  let ngenSaved ← getNGen
-  setNGen {}
-  try
-    CompilerM.run <| decl.internalize
-  finally
-    setNGen ngenSaved
-
-def saveBase : Pass :=
-  .mkPerDeclaration `saveBase (fun decl => do (← normalizeFVarIds decl).saveBase; return decl) .base
-
 def forEachDecl (f : Decl → CoreM Unit) : CoreM Unit := do
   let env ← getEnv
   for modIdx in [:env.allImportedModuleNames.size] do

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

@@ -5,6 +5,7 @@ Authors: Leonardo de Moura
 -/
 import Lean.PrettyPrinter
 import Lean.Compiler.LCNF.CompilerM
+import Lean.Compiler.LCNF.Internalize
 
 namespace Lean.Compiler.LCNF
 

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

@@ -50,7 +50,7 @@ partial def Decl.simp (decl : Decl) (config : Config) : CompilerM Decl := do
   go decl config
 where
   go (decl : Decl) (config : Config) : CompilerM Decl := do
-    if let some decl ← decl.simp? |>.run { config, declName := decl.name } |>.run' {} then
+    if let some decl ← decl.simp? |>.run { config, declName := decl.name } |>.run' {} |>.run {} then
       -- TODO: bound number of steps?
       go decl config
     else

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

@@ -0,0 +1,76 @@
+/-
+Copyright (c) 2022 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+import Lean.Compiler.LCNF.CompilerM
+import Lean.Compiler.LCNF.Types
+import Lean.Compiler.LCNF.InferType
+import Lean.Compiler.LCNF.Simp.Basic
+
+namespace Lean.Compiler.LCNF
+namespace Simp
+
+structure DiscrM.Context where
+  /--
+  A mapping from discriminant to constructor application it is equal to in the current context.
+  -/
+  discrCtorMap : FVarIdMap Expr := {}
+  /--
+  A mapping from constructor application to discriminant it is equal to in the current context.
+  -/
+  ctorDiscrMap : PersistentExprMap FVarId := {}
+
+/--
+Helper monad for tracking mappings from discriminant to constructor applications and back.
+The combinator `withDiscrCtor` should be used when visiting `cases` alternatives.
+-/
+abbrev DiscrM := ReaderT DiscrM.Context CompilerM
+
+/--
+This method uses `findExpr`, and if the result is a free variable, checks whether it is in the map `discrCtorMap`.
+We use this method when simplifying projections and cases-constructor.
+-/
+def findCtor (e : Expr) : DiscrM Expr := do
+  let e ← findExpr e
+  let .fvar fvarId := e | return e
+  let some ctor := (← read).discrCtorMap.find? fvarId | return e
+  return ctor
+
+/--
+If `type` is an inductive datatype, return its universe levels and parameters.
+-/
+def getIndInfo? (type : Expr) : CoreM (Option (List Level × Array Expr)) := do
+  let type := type.headBeta
+  let .const declName us := type.getAppFn | return none
+  let .inductInfo info ← getConstInfo declName | return none
+  unless type.getAppNumArgs >= info.numParams do return none
+  return some (us, type.getAppArgs[:info.numParams])
+
+/--
+Execute `x` with the information that `discr = ctorName ctorFields`.
+We use this information to simplify nested cases on the same discriminant.
+-/
+def withDiscrCtorImp (discr : FVarId) (ctorName : Name) (ctorFields : Array Param) (x : DiscrM α) : DiscrM α := do
+  let ctorInfo ← getConstInfoCtor ctorName
+  let fieldArgs := ctorFields.map (.fvar ·.fvarId)
+  if let some (us, params) ← getIndInfo? (← getType discr) then
+    let ctor := mkAppN (mkAppN (mkConst ctorName us) params) fieldArgs
+    withReader (fun ctx => { ctx with discrCtorMap := ctx.discrCtorMap.insert discr ctor, ctorDiscrMap := ctx.ctorDiscrMap.insert ctor discr }) do
+      x
+  else
+    -- For the discrCtor map, the constructor parameters are irrelevant for optimizations that use this information
+    let ctor := mkAppN (mkAppN (mkConst ctorName) (mkArray ctorInfo.numParams erasedExpr)) fieldArgs
+    withReader (fun ctx => { ctx with discrCtorMap := ctx.discrCtorMap.insert discr ctor }) do
+     x
+
+@[inline, inheritDoc withDiscrCtorImp] def withDiscrCtor [MonadFunctorT DiscrM m] (discr : FVarId) (ctorName : Name) (ctorFields : Array Param) : m α → m α :=
+  monadMap (m := DiscrM) <| withDiscrCtorImp discr ctorName ctorFields
+
+def simpCtorDiscrCore? (e : Expr) : DiscrM (Option Expr) := do
+  let some discr := (← read).ctorDiscrMap.find? e | return none
+  unless (← compatibleTypes (← getType discr) (← inferType e)) do return none
+  return some <| .fvar discr
+
+end Simp
+end Lean.Compiler.LCNF

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

@@ -5,13 +5,15 @@ Authors: Leonardo de Moura
 -/
 import Lean.Compiler.LCNF.DependsOn
 import Lean.Compiler.LCNF.InferType
+import Lean.Compiler.LCNF.Internalize
 import Lean.Compiler.LCNF.Simp.Basic
+import Lean.Compiler.LCNF.Simp.DiscrM
 
 namespace Lean.Compiler.LCNF
 namespace Simp
 
 /--
-Given the function declaration `decl`, return `true` if it is of the form
+Given the function declaration `decl`, return `some idx` if it is of the form
 ```
 f y :=
   ... /- This part is not bigger than smallThreshold. -/
@@ -19,55 +21,71 @@ f y :=
   | ... => ...
   ...
 ```
+`idx` is the index of the parameter used in the `cases` statement.
 -/
-def isJpCases (decl : FunDecl) : CompilerM Bool := do
-  if decl.params.size != 1 then
-    return false
+def isJpCases? (decl : FunDecl) : CompilerM (Option Nat) := do
+  if decl.params.size == 0 then
+    return none
   else
-    let param := decl.params[0]!
     let small := (← getConfig).smallThreshold
-    let rec go (code : Code) (prefixSize : Nat) : Bool :=
-      prefixSize <= small &&
+    let rec go (code : Code) (prefixSize : Nat) : Option Nat :=
+      if prefixSize > small then none else
       match code with
       | .let _ k => go k (prefixSize + 1) /- TODO: we should have uniform heuristics for estimating the size. -/
-      | .cases c => c.discr == param.fvarId
-      | _ => false
+      | .cases c => decl.params.findIdx? fun param => c.discr == param.fvarId
+      | _ => none
     return go decl.value 0
 
-abbrev JpCasesInfo := FVarIdMap NameSet
+/--
+Information for join points that satisfy `isJpCases?`
+-/
+structure JpCasesInfo where
+  /-- Parameter index returned by `isJpCases?`. This parameter is the one the join point is performing the case-split. -/
+  paramIdx  : Nat
+  /--
+  Set of constructor names s.t. `ctorName` is in the set if there is a jump to the join point where the parameter
+  `paramIdx` is a constructor application.
+  -/
+  ctorNames : NameSet := {}
+  deriving Inhabited
+
+abbrev JpCasesInfoMap := FVarIdMap JpCasesInfo
 
 /-- Return `true` if the collected information suggests opportunities for the `JpCases` optimization. -/
-def JpCasesInfo.isCandidate (info : JpCasesInfo) : Bool :=
-  info.any fun _ s => !s.isEmpty
+def JpCasesInfoMap.isCandidate (info : JpCasesInfoMap) : Bool :=
+  info.any fun _ s => !s.ctorNames.isEmpty
 
 /--
-Return a map containing entries `jpFVarId ↦ ctorNames` where `jpFVarId` is the id of join point
+Return a map containing entries `jpFVarId ↦ { paramIdx, ctorNames }` where `jpFVarId` is the id of join point
 in code that satisfies `isJpCases`, and `ctorNames` is a set of constructor names such that
-there is a jump `.jmp jpFVarId #[x]` in `code` and `x` is a constructor application.
+there is a jump `.jmp jpFVarId #[..., x, ...]` in `code` and `x` is a constructor application.
+`paramIdx` is the index of the parameter
 -/
-partial def collectJpCasesInfo (code : Code) : CompilerM JpCasesInfo := do
-  let (_, s) ← go code |>.run {}
+partial def collectJpCasesInfo (code : Code) : CompilerM JpCasesInfoMap := do
+  let (_, s) ← go code |>.run {} |>.run {}
   return s
 where
-  go (code : Code) : StateRefT JpCasesInfo CompilerM Unit := do
+  go (code : Code) : StateRefT JpCasesInfoMap DiscrM Unit := do
     match code with
     | .let _ k => go k
     | .fun decl k => go decl.value; go k
     | .jp decl k =>
-      if (← isJpCases decl) then
-        modify fun s => s.insert decl.fvarId {}
+      if let some paramIdx ← isJpCases? decl then
+        modify fun s => s.insert decl.fvarId { paramIdx }
       go decl.value; go k
-    | .cases c => c.alts.forM fun alt => go alt.getCode
+    | .cases c => c.alts.forM fun alt =>
+      match alt with
+      | .default k => go k
+      | .alt ctorName ps k => withDiscrCtor c.discr ctorName ps <| go k
     | .return .. | .unreach .. => return ()
     | .jmp fvarId args =>
-      if args.size == 1 then
-      if let some ctorNames := (← get).find? fvarId then
-        let arg ← findExpr args[0]!
+      if let some info := (← get).find? fvarId then
+        let arg ← findCtor args[info.paramIdx]!
         let some (cval, _) := arg.constructorApp? (← getEnv) | return ()
-        modify fun s => s.insert fvarId <| ctorNames.insert cval.name
+        modify fun map => map.insert fvarId <| { info with ctorNames := info.ctorNames.insert cval.name }
 
 /--
-Extract the let-declarations and `cases` for a join point body that satisfies `isJpCases`.
+Extract the let-declarations and `cases` for a join point body that satisfies `isJpCases?`.
 -/
 private def extractJpCases (code : Code) : Array CodeDecl × Cases :=
   go code #[]
@@ -86,21 +104,49 @@ structure JpCasesAlt where
 abbrev Ctor2JpCasesAlt := FVarIdMap (NameMap JpCasesAlt)
 
 open Internalize in
-private def mkJpAlt (decls : Array CodeDecl) (discr : Param) (fields : Array Param) (k : Code) (default : Bool) : CompilerM JpCasesAlt := do
+/--
+Construct an auxiliary join point for a particular alternative in a join-point that satifies `isJpCases?`.
+- `decls` is the prefix (before the `cases`). See `isJpCases?`.
+- `params` are the parameters of the main join point that satisfies `isJpCases?`.
+- `targetParamIdx` is the index of the parameter that we are expanding to `fields`
+- `fields` are the fields/parameter of the alternative.
+- `k` is the body of the alternative.
+- `default` is true if it is a default alternative.
+-/
+private def mkJpAlt (decls : Array CodeDecl) (params : Array Param) (targetParamIdx : Nat) (fields : Array Param) (k : Code) (default : Bool) : CompilerM JpCasesAlt := do
   go |>.run' {}
 where
   go : InternalizeM JpCasesAlt := do
-    let s : FVarIdSet := {}
     let mut paramsNew := #[]
-    let dependsOnDiscr := k.dependsOn (s.insert discr.fvarId)
-    if dependsOnDiscr then
-      paramsNew := paramsNew.push (← internalizeParam discr)
-    paramsNew := paramsNew ++ (← fields.mapM internalizeParam)
+    let singleton : FVarIdSet := ({} : FVarIdSet).insert params[targetParamIdx]!.fvarId
+    let dependsOnDiscr := k.dependsOn singleton || decls.any (·.dependsOn singleton)
+    for i in [:params.size] do
+      let param := params[i]!
+      if targetParamIdx == i then
+        if dependsOnDiscr then
+          paramsNew := paramsNew.push (← internalizeParam param)
+        paramsNew := paramsNew ++ (← fields.mapM internalizeParam)
+      else
+        paramsNew := paramsNew.push (← internalizeParam param)
     let decls ← decls.mapM internalizeCodeDecl
     let k ← internalizeCode k
     let value := LCNF.attachCodeDecls decls k
     return { decl := (← mkAuxJpDecl paramsNew value), default, dependsOnDiscr }
 
+/-- Create the arguments for a jump to an auxiliary join point created using `mkJpAlt`. -/
+private def mkJmpNewArgs (args : Array Expr) (targetParamIdx : Nat) (fields : Array Expr) (dependsOnTarget : Bool) : Array Expr :=
+  if dependsOnTarget then
+    args[:targetParamIdx+1] ++ fields ++ args[targetParamIdx+1:]
+  else
+    args[:targetParamIdx] ++ fields ++ args[targetParamIdx+1:]
+
+/--
+Create the arguments for a jump to an auxiliary join point created using `mkJpAlt`.
+This function is used to create jumps from the join point satisfying `isJpCases?` to the new auxiliary join points created using `mkJpAlt`.
+-/
+private def mkJmpArgsAtJp (params : Array Param) (targetParamIdx : Nat) (fields : Array Param) (dependsOnTarget : Bool) : Array Expr := Id.run do
+  mkJmpNewArgs (params.map (mkFVar ·.fvarId)) targetParamIdx (fields.map (mkFVar ·.fvarId)) dependsOnTarget
+
 /--
 Try to optimize `jpCases` join points.
 We say a join point is a `jpCases` when it satifies the predicate `isJpCases`.
@@ -146,16 +192,16 @@ Note that if all jumps to the join point are with constructors,
 then the join point is eliminated as dead code.
 -/
 partial def simpJpCases? (code : Code) : CompilerM (Option Code) := do
-  let info ← collectJpCasesInfo code
-  unless info.isCandidate do return none
+  let map ← collectJpCasesInfo code
+  unless map.isCandidate do return none
   traceM `Compiler.simp.jpCases do
     let mut msg : MessageData := "candidates"
-    for (fvarId, ctorName) in info.toList do
-      msg := msg ++ indentD m!"{mkFVar fvarId} ↦ {ctorName.toList}"
+    for (fvarId, info) in map.toList do
+      msg := msg ++ indentD m!"{mkFVar fvarId} ↦ {info.ctorNames.toList}"
     return msg
-  visit code info |>.run' {}
+  visit code map |>.run' {} |>.run {}
 where
-  visit (code : Code) : ReaderT JpCasesInfo (StateRefT Ctor2JpCasesAlt CompilerM) Code := do
+  visit (code : Code) : ReaderT JpCasesInfoMap (StateRefT Ctor2JpCasesAlt DiscrM) Code := do
     match code with
     | .let decl k =>
       return code.updateLet! decl (← visit k)
@@ -171,18 +217,22 @@ where
         let decl ← decl.updateValue value
         return code.updateFun! decl (← visit k)
     | .cases c =>
-      let alts ← c.alts.mapMonoM fun alt => return alt.updateCode (← visit alt.getCode)
+      let alts ← c.alts.mapMonoM fun alt =>
+        match alt with
+        | .alt ctorName ps k =>
+          withDiscrCtor c.discr ctorName ps do
+            return alt.updateCode (← visit k)
+        | .default k => return alt.updateCode (← visit k)
       return code.updateAlts! alts
     | .return _ | .unreach _ => return code
     | .jmp fvarId args =>
       let some code ← visitJmp? fvarId args | return code
       return code
 
-  visitJp? (decl : FunDecl) (k : Code) : ReaderT JpCasesInfo (StateRefT Ctor2JpCasesAlt CompilerM) (Option Code) := do
-    let some s := (← read).find? decl.fvarId | return none
-    if s.isEmpty then return none
-    -- This join point satisfies `isJp` and there jumps with constructors in `s` to it.
-    let p := decl.params[0]!
+  visitJp? (decl : FunDecl) (k : Code) : ReaderT JpCasesInfoMap (StateRefT Ctor2JpCasesAlt DiscrM) (Option Code) := do
+    let some info := (← read).find? decl.fvarId | return none
+    if info.ctorNames.isEmpty then return none
+    -- This join point satisfies `isJpCases?` and there are jumps with constructors in `info` to it.
     let (decls, cases) := extractJpCases decl.value
     let mut jpAltMap := {}
     let mut jpAltDecls := #[]
@@ -192,26 +242,24 @@ where
       | .default k =>
         let k ← visit k
         let explicitCtorNames := cases.getCtorNames
-        if s.any fun ctorNameInJump => !explicitCtorNames.contains ctorNameInJump then
-          let jpAlt ← mkJpAlt decls p #[] k (default := true)
+        if info.ctorNames.any fun ctorNameInJump => !explicitCtorNames.contains ctorNameInJump then
+          let jpAlt ← mkJpAlt decls decl.params info.paramIdx #[] k (default := true)
           jpAltDecls := jpAltDecls.push (.jp jpAlt.decl)
           eraseCode k
-          for ctorNameInJmp in s do
+          for ctorNameInJmp in info.ctorNames do
             unless explicitCtorNames.contains ctorNameInJmp do
               jpAltMap := jpAltMap.insert ctorNameInJmp jpAlt
-          let args := if jpAlt.dependsOnDiscr then #[.fvar p.fvarId] else #[]
+          let args := mkJmpArgsAtJp decl.params info.paramIdx #[] jpAlt.dependsOnDiscr
           altsNew := altsNew.push (alt.updateCode (.jmp jpAlt.decl.fvarId args))
         else
           altsNew := altsNew.push (alt.updateCode k)
       | .alt ctorName fields k =>
-        let k ← visit k
-        if s.contains ctorName then
-          let jpAlt ← mkJpAlt decls p fields k (default := false)
+        let k ← withDiscrCtor cases.discr ctorName fields <| visit k
+        if info.ctorNames.contains ctorName then
+          let jpAlt ← mkJpAlt decls decl.params info.paramIdx fields k (default := false)
           jpAltDecls := jpAltDecls.push (.jp jpAlt.decl)
           jpAltMap := jpAltMap.insert ctorName jpAlt
-          let mut args := fields.map (mkFVar ·.fvarId)
-          if jpAlt.dependsOnDiscr then
-            args := #[mkFVar p.fvarId] ++ args
+          let args := mkJmpArgsAtJp decl.params info.paramIdx fields jpAlt.dependsOnDiscr
           eraseCode k
           altsNew := altsNew.push (alt.updateCode (.jmp jpAlt.decl.fvarId args))
         else
@@ -222,23 +270,18 @@ where
     let code := .jp decl (← visit k)
     return LCNF.attachCodeDecls jpAltDecls code
 
-  visitJmp? (fvarId : FVarId) (args : Array Expr) : ReaderT JpCasesInfo (StateRefT Ctor2JpCasesAlt CompilerM) (Option Code) := do
+  visitJmp? (fvarId : FVarId) (args : Array Expr) : ReaderT JpCasesInfoMap (StateRefT Ctor2JpCasesAlt DiscrM) (Option Code) := do
     let some ctorJpAltMap := (← get).find? fvarId | return none
-    assert! args.size == 1
-    let arg ← findExpr args[0]!
+    let some info := (← read).find? fvarId | return none
+    let arg ← findCtor args[info.paramIdx]!
     let some (ctorVal, ctorArgs) := arg.constructorApp? (← getEnv) (useRaw := true) | return none
     let some jpAlt := ctorJpAltMap.find? ctorVal.name | return none
-    if jpAlt.default then
-      if jpAlt.dependsOnDiscr then
-        return some <| .jmp jpAlt.decl.fvarId args
-      else
-        return some <| .jmp jpAlt.decl.fvarId #[]
-    else
-      let fields := ctorArgs[ctorVal.numParams:]
-      -- Recall that if `arg` is a `Nat` literal, then `ctorArgs` is a literal too.
-      -- We use a for-loop because we may have other special cases in the future.
-      let mut auxDecls := #[]
-      let mut fieldsNew := #[]
+    let fields := ctorArgs[ctorVal.numParams:]
+    -- Recall that if `arg` is a `Nat` literal, then `ctorArgs` is a literal too.
+    -- We use a for-loop because we may have other special cases in the future.
+    let mut auxDecls := #[]
+    let mut fieldsNew := #[]
+    unless jpAlt.default do
       for field in fields do
         if field.isFVar then
           fieldsNew := fieldsNew.push field
@@ -246,11 +289,8 @@ where
           let letDecl ← mkAuxLetDecl field
           auxDecls := auxDecls.push (CodeDecl.let letDecl)
           fieldsNew := fieldsNew.push (.fvar letDecl.fvarId)
-      let code ← if jpAlt.dependsOnDiscr then
-        pure <| .jmp jpAlt.decl.fvarId (args ++ fieldsNew)
-      else
-        pure <| .jmp jpAlt.decl.fvarId fieldsNew
-      return some <| LCNF.attachCodeDecls auxDecls code
+    let argsNew := mkJmpNewArgs args info.paramIdx fieldsNew jpAlt.dependsOnDiscr
+    return some <| LCNF.attachCodeDecls auxDecls (.jmp jpAlt.decl.fvarId argsNew)
 
 end Simp
 

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

@@ -9,7 +9,9 @@ import Lean.Compiler.LCNF.ElimDead
 import Lean.Compiler.LCNF.AlphaEqv
 import Lean.Compiler.LCNF.PrettyPrinter
 import Lean.Compiler.LCNF.Bind
+import Lean.Compiler.LCNF.Internalize
 import Lean.Compiler.LCNF.Simp.JpCases
+import Lean.Compiler.LCNF.Simp.DiscrM
 import Lean.Compiler.LCNF.Simp.FunDeclInfo
 import Lean.Compiler.LCNF.Simp.Config
 
@@ -25,14 +27,6 @@ structure Context where
   declName : Name
   config : Config := {}
   /--
-  A mapping from discriminant to constructor application it is equal to in the current context.
-  -/
-  discrCtorMap : FVarIdMap Expr := {}
-  /--
-  A mapping from constructor application to discriminant it is equal to in the current context.
-  -/
-  ctorDiscrMap : PersistentExprMap FVarId := {}
-  /--
   Stack of global declarations being recursively inlined.
   -/
   inlineStack : List Name := []
@@ -79,7 +73,7 @@ structure State where
   -/
   inlineLocal : Nat := 0
 
-abbrev SimpM := ReaderT Context $ StateRefT State CompilerM
+abbrev SimpM := ReaderT Context $ StateRefT State DiscrM
 
 instance : MonadFVarSubst SimpM false where
   getSubst := return (← get).subst
@@ -87,47 +81,6 @@ instance : MonadFVarSubst SimpM false where
 instance : MonadFVarSubstState SimpM where
   modifySubst f := modify fun s => { s with subst := f s.subst }
 
-/--
-Use `findExpr`, and if the result is a free variable, check whether it is in the map `discrCtorMap`.
-We use this method when simplifying projections and cases-constructor.
--/
-def findCtor (e : Expr) : SimpM Expr := do
-  let e ← findExpr e
-  let .fvar fvarId := e | return e
-  let some ctor := (← read).discrCtorMap.find? fvarId | return e
-  return ctor
-
-/--
-If `type` is an inductive datatype, return its universe levels and parameters.
--/
-def getIndInfo? (type : Expr) : CoreM (Option (List Level × Array Expr)) := do
-  let type := type.headBeta
-  let .const declName us := type.getAppFn | return none
-  let .inductInfo info ← getConstInfo declName | return none
-  unless type.getAppNumArgs >= info.numParams do return none
-  return some (us, type.getAppArgs[:info.numParams])
-
-/--
-Execute `x` with the information that `discr = ctorName ctorFields`.
-We use this information to simplify nested cases on the same discriminant.
-
-Remark: we do not perform the reverse direction at this phase.
-That is, we do not replace occurrences of `ctorName ctorFields` with `discr`.
-We wait more type information to be erased.
--/
-def withDiscrCtor (discr : FVarId) (ctorName : Name) (ctorFields : Array Param) (x : SimpM α) : SimpM α := do
-  let ctorInfo ← getConstInfoCtor ctorName
-  let fieldArgs := ctorFields.map (.fvar ·.fvarId)
-  if let some (us, params) ← getIndInfo? (← getType discr) then
-    let ctor := mkAppN (mkAppN (mkConst ctorName us) params) fieldArgs
-    withReader (fun ctx => { ctx with discrCtorMap := ctx.discrCtorMap.insert discr ctor, ctorDiscrMap := ctx.ctorDiscrMap.insert ctor discr }) do
-      x
-  else
-    -- For the discrCtor map, the constructor parameters are irrelevant for optimizations that use this information
-    let ctor := mkAppN (mkAppN (mkConst ctorName) (mkArray ctorInfo.numParams erasedExpr)) fieldArgs
-    withReader (fun ctx => { ctx with discrCtorMap := ctx.discrCtorMap.insert discr ctor }) do
-     x
-
 /-- Set the `simplified` flag to `true`. -/
 def markSimplified : SimpM Unit :=
   modify fun s => { s with simplified := true }
@@ -253,13 +206,13 @@ def betaReduce (params : Array Param) (code : Code) (args : Array Expr) (mustInl
   let mut castDecls := #[]
   for param in params, arg in args do
     /-
-    If `param` hast type `⊤` but `arg` does not, we must insert a cast.
+    If `param` hast type `◾` but `arg` does not, we must insert a cast.
     Otherwise, the resulting code may be type incorrect.
     For example, the following code is type correct before inlining `f`
-    because `x : ⊤`.
+    because `x : ◾`.
     ```
     def foo (g : A → A) (a : B) :=
-      fun f (x : ⊤) :=
+      fun f (x : ◾) :=
         let _x.1 := g x
         ...
       let _x.2 := f a
@@ -267,8 +220,8 @@ def betaReduce (params : Array Param) (code : Code) (args : Array Expr) (mustInl
     ```
     We must introduce a cast around `a` to make sure the resulting expression is type correct.
     -/
-    if param.type.isAnyType && !(← inferType arg).isAnyType then
-      let castArg ← mkLcCast arg anyTypeExpr
+    if param.type.isErased && !(← inferType arg).isErased then
+      let castArg ← mkLcCast arg erasedExpr
       let castDecl ← mkAuxLetDecl castArg
       castDecls := castDecls.push (CodeDecl.let castDecl)
       subst := subst.insert param.fvarId (.fvar castDecl.fvarId)

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

@@ -36,9 +36,8 @@ def simpAppApp? (e : Expr) : OptionT SimpM Expr := do
   return mkAppN f e.getAppArgs
 
 def simpCtorDiscr? (e : Expr) : OptionT SimpM Expr := do
-  let some discr := (← read).ctorDiscrMap.find? e | failure
-  guard <| (← compatibleTypes (← getType discr) (← inferType e))
-  return .fvar discr
+  let some v ← simpCtorDiscrCore? e | failure
+  return v
 
 def applyImplementedBy? (e : Expr) : OptionT SimpM Expr := do
   guard <| (← read).config.implementedBy

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

@@ -198,9 +198,11 @@ structure State where
   /-- LCNF sequence, we chain it to create a LCNF `Code` object. -/
   seq : Array Element := #[]
   /--
-  Fields that are type formers must be replaced with `lcAny`
+  Fields that are type formers must be replaced with `◾`
   in the resulting code. Otherwise, we have data occurring in
   types.
+  When converting a `casesOn` into LCNF, we add constructor fields
+  that are types and type formers into this set. See `visitCases`.
   -/
   toAny : FVarIdSet := {}
 
@@ -278,14 +280,14 @@ def withNewScope (x : M α) : M α := do
     set saved
 
 /-
-Replace free variables in `type'` that occur in `toAny` into `lcAny`.
+Replace free variables in `type'` that occur in `toAny` into `◾`.
 Recall that we populate `toAny` with the free variable ids of fields that
 are type formers. This can happen when we have a field whose type is, for example, `Type u`.
 -/
 def applyToAny (type : Expr) : M Expr := do
   let toAny := (← get).toAny
   return type.replace fun
-    | .fvar fvarId => if toAny.contains fvarId then some anyTypeExpr else none
+    | .fvar fvarId => if toAny.contains fvarId then some erasedExpr else none
     | _ => none
 
 def toLCNFType (type : Expr) : M Expr := do
@@ -410,7 +412,7 @@ where
       | .forallE ..  => unreachable!
       | .mvar ..     => throwError "unexpected occurrence of metavariable in code generator{indentExpr e}"
       | .bvar ..     => unreachable!
-      | .fvar fvarId => if (← get).toAny.contains fvarId then pure anyTypeExpr else pure e
+      | .fvar fvarId => if (← get).toAny.contains fvarId then pure erasedExpr else pure e
       | _            => pure e
     modify fun s => { s with cache := s.cache.insert e r }
     return r
@@ -529,19 +531,37 @@ where
         let typeName := casesInfo.declName.getPrefix
         let discr ← visitAppArg args[casesInfo.discrPos]!
         let .inductInfo indVal ← getConstInfo typeName | unreachable!
-        for i in casesInfo.altsRange, numParams in casesInfo.altNumParams, ctorName in indVal.ctors do
-          let (altType, alt) ← visitAlt ctorName numParams args[i]!
-          unless (← compatibleTypes altType resultType) do
-            resultType := anyTypeExpr
-          alts := alts.push alt
-        let cases : Cases := { typeName, discr := discr.fvarId!, resultType, alts }
-        let auxDecl ← mkAuxParam resultType
-        pushElement (.cases auxDecl cases)
-        let result := .fvar auxDecl.fvarId
-        if args.size == casesInfo.arity then
-          return result
+        if !discr.isFVar then
+          /-
+          This can happen for inductive predicates that can eliminate into type (e.g., `And`, `Iff`).
+          TODO: add support for them. Right now, we have hard-coded support for the ones defined at `Init`.
+          -/
+          throwError "unsupported `{casesInfo.declName}` application during code generation"
         else
-          mkOverApplication result args casesInfo.arity
+          for i in casesInfo.altsRange, numParams in casesInfo.altNumParams, ctorName in indVal.ctors do
+            let (altType, alt) ← visitAlt ctorName numParams args[i]!
+            unless (← compatibleTypes altType resultType) do
+              resultType := erasedExpr
+            alts := alts.push alt
+          if resultType.isErased || resultType.isErased then
+            /-
+            If the result type for a `cases` is `◾`, we put a cast to `◾` (aka the any type)
+            at every alternative that does not have `◾` type.
+            The cast is useful to ensure the result is type correct when reducing `cases` in the simplifier
+            or applying `bind`. For example, suppose we are using `Code.bind` to connect a `cases` with type `◾`
+            to a continuation that expects type `B`, and one of the alternatives has type `A`. The operation makes
+            sense, but we need a cast since we are connecting a value of type `A` to a continuation that expects `B`.
+            -/
+            alts ← alts.mapM fun alt =>
+              return alt.updateCode (← alt.getCode.ensureAnyType)
+          let cases : Cases := { typeName, discr := discr.fvarId!, resultType, alts }
+          let auxDecl ← mkAuxParam resultType
+          pushElement (.cases auxDecl cases)
+          let result := .fvar auxDecl.fvarId
+          if args.size == casesInfo.arity then
+            return result
+          else
+            mkOverApplication result args casesInfo.arity
 
   visitCtor (arity : Nat) (e : Expr) : M Expr :=
     etaIfUnderApplied e arity do
@@ -583,13 +603,13 @@ where
       let type ← toLCNFType (← liftMetaM do Meta.inferType e)
       mkUnreachable type
 
-  visitAndRec (e : Expr) : M Expr :=
+  visitAndIffRecCore (e : Expr) (minorPos : Nat) : M Expr :=
     let arity := 5
     etaIfUnderApplied e arity do
       let args := e.getAppArgs
       let ha := mkLcProof args[0]! -- We should not use `lcErased` here since we use it to create a pre-LCNF Expr.
       let hb := mkLcProof args[1]!
-      let minor := if e.isAppOf ``And.rec then args[3]! else args[4]!
+      let minor := args[minorPos]!
       let minor := minor.beta #[ha, hb]
       visit (mkAppN minor args[arity:])
 
@@ -650,8 +670,10 @@ where
         visitCtor 3 e
       else if declName == ``Eq.casesOn || declName == ``Eq.rec || declName == ``Eq.ndrec then
         visitEqRec e
-      else if declName == ``And.rec || declName == ``And.casesOn then
-        visitAndRec e
+      else if declName == ``And.rec || declName == ``Iff.rec then
+        visitAndIffRecCore e (minorPos := 3)
+      else if declName == ``And.casesOn || declName == ``Iff.casesOn then
+        visitAndIffRecCore e (minorPos := 4)
       else if declName == ``False.rec || declName == ``Empty.rec || declName == ``False.casesOn || declName == ``Empty.casesOn then
         visitFalseRec e
       else if let some casesInfo ← getCasesInfo? declName then

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

@@ -8,23 +8,10 @@ import Lean.Meta.InferType
 namespace Lean.Compiler
 
 scoped notation:max "◾" => lcErased
-scoped notation:max "⊤" => lcAny
 
 namespace LCNF
 
-structure LCNFTypeExtState where
-  types : PHashMap Name Expr := {}
-  instLevelType : Core.InstantiateLevelCache := {}
-  deriving Inhabited
-
-builtin_initialize lcnfTypeExt : EnvExtension LCNFTypeExtState ←
-  registerEnvExtension (pure {})
-
 def erasedExpr := mkConst ``lcErased
-def anyTypeExpr := mkConst  ``lcAny
-
-def _root_.Lean.Expr.isAnyType (e : Expr) :=
-  e.isAppOf ``lcAny
 
 def _root_.Lean.Expr.isErased (e : Expr) :=
   e.isAppOf ``lcErased
@@ -92,10 +79,11 @@ Thus, in the first code generator pass, we convert types into a `LCNFType` (Lean
 The method `toLCNFType` produces a type with the following properties:
 
 - All constants occurring in the result type are inductive datatypes.
-- The arguments of type formers are type formers, `◾`, or `⊤`. We use `◾` to denote erased information,
-  and `⊤` the any type.
-- All type definitions are expanded. If reduction gets stuck, it is replaced with `⊤`.
+- The arguments of type formers are type formers, or `◾`. We use `◾` to denote erased information.
+- All type definitions are expanded. If reduction gets stuck, it is replaced with `◾`.
 
+Remark: you can view `◾` occurring in a type position as the "any type".
+Remark: in our runtime, `◾` is represented as `box(0)`.
 
 The goal is to preserve as much information as possible and avoid the problems described above.
 Then, we don't have `let x := v; ...` in LCNF code when `x` is a type former.
@@ -110,22 +98,14 @@ the result produced by each code generator step.
 
 Below, we provide some example programs and their erased variants:
 -- 1. Source type: `f: (n: Nat) -> (tupleN Nat n)`.
-      LCNF type: `f: Nat -> Any`.
-      We convert the return type `(tupleN Nat n) to `Any`, since we cannot reduce
+      LCNF type: `f: Nat -> ◾`.
+      We convert the return type `(tupleN Nat n) to `◾`, since we cannot reduce
       `(tupleN Nat n)` to a term of the form `(InductiveTy ...)`.
 
 -- 2. Source type: `f: (n: Nat) (fin: Fin n) -> (tupleN Nat fin)`.
-      LCNF type: `f: Nat -> Fin Erased -> Any`.
+      LCNF type: `f: Nat -> Fin ◾ -> ◾`.
       Since `(Fin n)` has dependency on `n`, we erase the `n` to get the
-      type `(Fin Erased)`. See that Erased only
-      occurs at argument position to a type constructor.
-
-- NOTE: we cannot have separate notions of ErasedProof
-        (which occurs at the value level for erased proofs) and ErasedData
-        (which occurs at the type level for erased dependencies)
-        because of universe polymorphism. Thus, we have a single notion of
-        Erased which unifies the two concepts.
-
+      type `(Fin ◾)`.
 -/
 
 open Meta in
@@ -143,14 +123,14 @@ partial def toLCNFType (type : Expr) : MetaM Expr := do
     withLocalDecl n bi d fun x => do
       let d ← toLCNFType d
       let b ← toLCNFType (b.instantiate1 x)
-      if b.isAnyType || b.isErased then
+      if b.isErased then
         return b
       else
         return Expr.lam n d (b.abstract #[x]) bi
   | .forallE .. => visitForall type #[]
   | .app ..  => type.withApp visitApp
   | .fvar .. => visitApp type #[]
-  | _        => return anyTypeExpr
+  | _        => return erasedExpr
 where
   whnfEta (type : Expr) : MetaM Expr := do
     let type ← whnf type
@@ -174,10 +154,10 @@ where
   visitApp (f : Expr) (args : Array Expr) := do
     let fNew ← match f with
       | .const declName us =>
-        let .inductInfo _ ← getConstInfo declName | return anyTypeExpr
+        let .inductInfo _ ← getConstInfo declName | return erasedExpr
         pure <| .const declName us
       | .fvar .. => pure f
-      | _ => return anyTypeExpr
+      | _ => return erasedExpr
     let mut result := fNew
     for arg in args do
       if (← isProp arg) then
@@ -190,52 +170,16 @@ where
         result := mkApp result erasedExpr
     return result
 
-/--
-Save the LCNF type for the given declaration.
--/
-def saveLCNFType (declName : Name) (type : Expr) : CoreM Unit := do
-  modifyEnv fun env =>
-    lcnfTypeExt.modifyState env fun s => { s with types := s.types.insert declName type }
-
-/--
-Return the LCNF type for the given declaration.
--/
-def getDeclLCNFType (declName : Name) : CoreM Expr := do
-  match lcnfTypeExt.getState (← getEnv) |>.types.find? declName with
-  | some type => return type
-  | none =>
-    let info ← getConstInfo declName
-    let type ← Meta.MetaM.run' <| toLCNFType info.type
-    saveLCNFType declName type
-    return type
-
-/--
-Instantiate the LCNF type for the given declaration with the given universe levels.
--/
-def instantiateLCNFTypeLevelParams (declName : Name) (us : List Level) : CoreM Expr := do
-  if us.isEmpty then
-    getDeclLCNFType declName
-  else
-    if let some (us', r) := lcnfTypeExt.getState (← getEnv) |>.instLevelType.find? declName then
-      if us == us' then
-        return r
-    let type ← getDeclLCNFType declName
-    let info ← getConstInfo declName
-    let r := type.instantiateLevelParams info.levelParams us
-    modifyEnv fun env => lcnfTypeExt.modifyState env fun s => { s with instLevelType := s.instLevelType.insert declName (us, r) }
-    return r
-
 mutual
 
 partial def joinTypes (a b : Expr) : Expr :=
-  joinTypes? a b |>.getD anyTypeExpr
+  joinTypes? a b |>.getD erasedExpr
 
 partial def joinTypes? (a b : Expr) : Option Expr := do
-  if a.isAnyType then return a
-  else if b.isAnyType then return b
-  else if a == b then return a
-  else if a.isErased || b.isErased then
+  if a.isErased || b.isErased then
     return erasedExpr -- See comment at `compatibleTypes`.
+  else if a == b then
+    return a
   else
     let a' := a.headBeta
     let b' := b.headBeta
@@ -248,16 +192,16 @@ partial def joinTypes? (a b : Expr) : Option Expr := do
       | .app f a, .app g b =>
         (do return .app (← joinTypes? f g) (← joinTypes? a b))
          <|>
-        return anyTypeExpr
+        return erasedExpr
       | .forallE n d₁ b₁ _, .forallE _ d₂ b₂ _ =>
         (do return .forallE n (← joinTypes? d₁ d₂) (joinTypes b₁ b₂) .default)
         <|>
-        return anyTypeExpr
+        return erasedExpr
       | .lam n d₁ b₁ _, .lam _ d₂ b₂ _ =>
         (do return .lam n (← joinTypes? d₁ d₂) (joinTypes b₁ b₂) .default)
         <|>
-        return anyTypeExpr
-      | _, _ => return anyTypeExpr
+        return erasedExpr
+      | _, _ => return erasedExpr
 
 end
 
@@ -286,14 +230,14 @@ partial def isPredicateType (type : Expr) : Bool :=
 /--
 Return `true` if `type` is a LCNF type former type or it is an "any" type.
 This function is similar to `isTypeFormerType`, but more liberal.
-For example, `isTypeFormerType` returns false for `lcAny` and `Nat → lcAny`, but
+For example, `isTypeFormerType` returns false for `◾` and `Nat → ◾`, but
 this function returns true.
 -/
 partial def maybeTypeFormerType (type : Expr) : Bool :=
   match type.headBeta with
   | .sort .. => true
   | .forallE _ _ b _ => maybeTypeFormerType b
-  | _ => type.isAnyType
+  | _ => type.isErased
 
 /--
 `isClass? type` return `some ClsName` if the LCNF `type` is an instance of the class `ClsName`.

stage0/src/Lean/Data/Name.lean

@@ -31,13 +31,13 @@ def updatePrefix : Name → Name → Name
   | str _ s,   newP => Name.mkStr newP s
   | num _ s,   newP => Name.mkNum newP s
 
-def components' : Name → List Name
+def componentsRev : Name → List Name
   | anonymous => []
-  | str n s   => Name.mkStr anonymous s :: components' n
-  | num n v   => Name.mkNum anonymous v :: components' n
+  | str n s   => Name.mkStr anonymous s :: componentsRev n
+  | num n v   => Name.mkNum anonymous v :: componentsRev n
 
 def components (n : Name) : List Name :=
-  n.components'.reverse
+  n.componentsRev.reverse
 
 def eqStr : Name → String → Bool
   | str anonymous s, s' => s == s'

stage0/src/Lean/Data/Position.lean

@@ -15,7 +15,7 @@ structure Position where
 
 namespace Position
 protected def lt : Position → Position → Bool
-  | ⟨l₁, c₁⟩, ⟨l₂, c₂⟩ => (l₁, c₁) < (l₂, c₂)
+  | ⟨l₁, c₁⟩, ⟨l₂, c₂⟩ => Prod.lexLt (l₁, c₁) (l₂, c₂)
 
 instance : ToFormat Position :=
   ⟨fun ⟨l, c⟩ => "⟨" ++ format l ++ ", " ++ format c ++ "⟩"⟩

stage0/src/Lean/Data/RBMap.lean

@@ -123,36 +123,30 @@ def setBlack : RBNode α β → RBNode α β
 
 end Insert
 
--- Okasaki's full `balance`
-def balance₃ (a : RBNode α β) (k : α) (v : β k) (d : RBNode α β) : RBNode α β :=
-  match a with
-  | node red (node red a kx vx b) ky vy c
-  | node red a kx vx (node red b ky vy c) => node red (node black a kx vx b) ky vy (node black c k v d)
-  | a => match d with
-    | node red b ky vy (node red c kz vz d)
-    | node red (node red b ky vy c) kz vz d => node red (node black a k v b) ky vy (node black c kz vz d)
-    | _                                     => node black a k v d
-
 def setRed : RBNode α β → RBNode α β
   | node _ a k v b => node red a k v b
   | e              => e
 
 def balLeft : RBNode α β → (k : α) → β k → RBNode α β → RBNode α β
   | node red a kx vx b,   k, v, r                    => node red (node black a kx vx b) k v r
-  | l, k, v, node black a ky vy b                    => balance₃ l k v (node red a ky vy b)
-  | l, k, v, node red (node black a ky vy b) kz vz c => node red (node black l k v a) ky vy (balance₃ b kz vz (setRed c))
+  | l, k, v, node black a ky vy b                    => balance2 l k v (node red a ky vy b)
+  | l, k, v, node red (node black a ky vy b) kz vz c => node red (node black l k v a) ky vy (balance2 b kz vz (setRed c))
   | l, k, v, r                                       => node red l k v r -- unreachable
 
 def balRight (l : RBNode α β) (k : α) (v : β k) (r : RBNode α β) : RBNode α β :=
   match r with
   | (node red b ky vy c) => node red l k v (node black b ky vy c)
   | _ => match l with
-    | node black a kx vx b                    => balance₃ (node red a kx vx b) k v r
-    | node red a kx vx (node black b ky vy c) => node red (balance₃ (setRed a) kx vx b) ky vy (node black c k v r)
+    | node black a kx vx b                    => balance1 (node red a kx vx b) k v r
+    | node red a kx vx (node black b ky vy c) => node red (balance1 (setRed a) kx vx b) ky vy (node black c k v r)
     | _                                       => node red l k v r -- unreachable
 
--- TODO: use wellfounded recursion
-partial def appendTrees :  RBNode α β → RBNode α β → RBNode α β
+/-- The number of nodes in the tree. -/
+@[local simp] def size : RBNode α β → Nat
+  | leaf => 0
+  | node _ x _ _ y => x.size + y.size + 1
+
+def appendTrees :  RBNode α β → RBNode α β → RBNode α β
   | leaf, x => x
   | x, leaf => x
   | node red a kx vx b,   node red c ky vy d   =>
@@ -165,6 +159,7 @@ partial def appendTrees :  RBNode α β → RBNode α β → RBNode α β
      | bc                   => balLeft a kx vx (node black bc ky vy d)
    | a, node red b kx vx c   => node red (appendTrees a b) kx vx c
    | node red a kx vx b,   c => node red a kx vx (appendTrees b c)
+termination_by _ x y => x.size + y.size
 
 section Erase
 

stage0/src/Lean/Elab/Deriving/Repr.lean

@@ -32,7 +32,7 @@ def mkBodyForStruct (header : Header) (indVal : InductiveVal) : TermElabM Term :
       let fieldName := fieldNames[i]!
       let fieldNameLit := Syntax.mkStrLit (toString fieldName)
       let x := xs[numParams + i]!
-      if i > numParams then
+      if i != 0 then
         fields ← `($fields ++ "," ++ Format.line)
       if (← isType x <||> isProof x) then
         fields ← `($fields ++ $fieldNameLit ++ " := " ++ "_")

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

@@ -35,17 +35,17 @@ private def getFixedPrefix (declName : Name) (xs : Array Expr) (value : Expr) :
            We disable to proof irrelevance to be able to use structural recursion on inductive predicates.
            For example, consider the example
            ```
-          inductive PList (α : Type) : Prop
-          | nil
-          | cons : α → PList α → PList α
+           inductive PList (α : Type) : Prop
+           | nil
+           | cons : α → PList α → PList α
 
-          infixr:67 " ::: " => PList.cons
+           infixr:67 " ::: " => PList.cons
 
-          set_option trace.Elab.definition.structural true in
-          def pmap {α β} (f : α → β) : PList α → PList β
-          | PList.nil => PList.nil
-          | a:::as => f a ::: pmap f as
-          ```
+           set_option trace.Elab.definition.structural true in
+           def pmap {α β} (f : α → β) : PList α → PList β
+             | PList.nil => PList.nil
+             | a:::as => f a ::: pmap f as
+           ```
           The "Fixed" prefix would be 4 since all elements of type `PList α` are definitionally equal.
         -/
         if !(← withoutProofIrrelevance <| withReducible <| isDefEq arg x) then

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

@@ -90,6 +90,7 @@ def wfRecursion (preDefs : Array PreDefinition) (wf? : Option TerminationWF) (de
     let unaryPreDefs ← packDomain fixedPrefixSize preDefsDIte
     return (← packMutual fixedPrefixSize preDefs unaryPreDefs, fixedPrefixSize)
   let preDefNonRec ← forallBoundedTelescope unaryPreDef.type fixedPrefixSize fun prefixArgs type => do
+    let type ← whnfForall type
     let packedArgType := type.bindingDomain!
     elabWFRel preDefs unaryPreDef.declName fixedPrefixSize packedArgType wf? fun wfRel => do
       trace[Elab.definition.wf] "wfRel: {wfRel}"

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

@@ -67,6 +67,19 @@ def filterOldMVars (mvarIds : Array MVarId) (mvarCounterSaved : Nat) : MetaM (Ar
     return r
   | _ => throwUnsupportedSyntax
 
+def sortMVarIdArrayByIndex [MonadMCtx m] [Monad m] (mvarIds : Array MVarId) : m (Array MVarId) := do
+  let mctx ← getMCtx
+  return mvarIds.qsort fun mvarId₁ mvarId₂ =>
+    let decl₁ := mctx.getDecl mvarId₁
+    let decl₂ := mctx.getDecl mvarId₂
+    if decl₁.index != decl₂.index then
+      decl₁.index < decl₂.index
+    else
+      Name.quickLt mvarId₁.name mvarId₂.name
+
+def sortMVarIdsByIndex [MonadMCtx m] [Monad m] (mvarIds : List MVarId) : m (List MVarId) :=
+  return (← sortMVarIdArrayByIndex mvarIds.toArray).toList
+
 /--
   Execute `k`, and collect new "holes" in the resulting expression.
 -/
@@ -84,6 +97,13 @@ def withCollectingNewGoalsFrom (k : TacticM Expr) (tagSuffix : Name) (allowNatur
     let naturalMVarIds ← filterOldMVars naturalMVarIds mvarCounterSaved
     logUnassignedAndAbort naturalMVarIds
     pure syntheticMVarIds.toList
+  /-
+  We sort the new metavariable ids by index to ensure the new goals are ordered using the order the metavariables have been created.
+  See issue #1682.
+  Potential problem: if elaboration of subterms is delayed the order the new metavariables are created may not match the order they
+  appear in the `.lean` file. We should tell users to prefer tagged goals.
+  -/
+  let newMVarIds ← sortMVarIdsByIndex newMVarIds
   tagUntaggedGoals (← getMainTag) tagSuffix newMVarIds
   return (val, newMVarIds)
 

stage0/src/Lean/ResolveName.lean

@@ -321,7 +321,7 @@ def unresolveNameGlobal [Monad m] [MonadResolveName m] [MonadEnv m] (n₀ : Name
   return n₀ -- if can't resolve, return the original
 where
   unresolveNameCore (n : Name) : m (Option Name) := do
-    let mut revComponents := n.components'
+    let mut revComponents := n.componentsRev
     let mut candidate := Name.anonymous
     for _ in [:revComponents.length] do
       match revComponents with

stage0/src/Lean/Server/FileWorker/RequestHandling.lean

@@ -264,6 +264,31 @@ partial def handleDocumentHighlight (p : DocumentHighlightParams)
         return #[hi]
       return #[]
 
+structure NamespaceEntry where
+  /-- The list of the name components introduced by this namespace command,
+  in reverse order so that `end` will peel them off from the front. -/
+  name : List Name
+  stx : Syntax
+  selection : Syntax
+  prevSiblings : Array DocumentSymbol
+
+def NamespaceEntry.finish (text : FileMap) (syms : Array DocumentSymbol) (endStx : Option Syntax) :
+    NamespaceEntry → Array DocumentSymbol
+  | { name, stx, selection, prevSiblings, .. } =>
+    -- we can assume that commands always have at least one position (see `parseCommand`)
+    let range := match endStx with
+      | some endStx => (mkNullNode #[stx, endStx]).getRange?.get!
+      | none        =>  { stx.getRange?.get! with stop := text.source.endPos }
+    let name := name.foldr (fun x y => y ++ x) Name.anonymous
+    prevSiblings.push <| DocumentSymbol.mk {
+      -- anonymous sections are represented by `«»` name components
+      name := if name == `«» then "<section>" else name.toString
+      kind := .namespace
+      range := range.toLspRange text
+      selectionRange := selection.getRange?.getD range |>.toLspRange text
+      children? := syms
+    }
+
 open Parser.Command in
 partial def handleDocumentSymbol (_ : DocumentSymbolParams)
     : RequestM (RequestTask DocumentSymbolResult) := do
@@ -272,20 +297,38 @@ partial def handleDocumentSymbol (_ : DocumentSymbolParams)
   let t := doc.cmdSnaps.waitAll
   mapTask t fun (snaps, _) => do
     let mut stxs := snaps.map (·.stx)
-    let (syms, _) := toDocumentSymbols doc.meta.text stxs
-    return { syms := syms.toArray }
+    return { syms := toDocumentSymbols doc.meta.text stxs #[] [] }
 where
-  toDocumentSymbols (text : FileMap) (stxs : List Syntax) : List DocumentSymbol × List Syntax :=
+  toDocumentSymbols (text : FileMap) (stxs : List Syntax)
+      (syms : Array DocumentSymbol) (stack : List NamespaceEntry) :
+      Array DocumentSymbol :=
     match stxs with
-    | [] => ([], [])
+    | [] => stack.foldl (fun syms entry => entry.finish text syms none) syms
     | stx::stxs => match stx with
-      | `(namespace $id)  => sectionLikeToDocumentSymbols text stx stxs (id.getId.toString) SymbolKind.namespace id
-      | `(section $(id)?) => sectionLikeToDocumentSymbols text stx stxs ((·.getId.toString) <$> id |>.getD "<section>") SymbolKind.namespace (id.map (·.raw) |>.getD stx)
-      | `(end $(_id)?) => ([], stx::stxs)
+      | `(namespace $id)  =>
+        let entry := { name := id.getId.componentsRev, stx, selection := id, prevSiblings := syms }
+        toDocumentSymbols text stxs #[] (entry :: stack)
+      | `(section $(id)?) =>
+        let name := id.map (·.getId.componentsRev) |>.getD [`«»]
+        let entry := { name, stx, selection := id.map (·.raw) |>.getD stx, prevSiblings := syms }
+        toDocumentSymbols text stxs #[] (entry :: stack)
+      | `(end $(id)?) =>
+        let rec popStack n syms
+          | [] => toDocumentSymbols text stxs syms []
+          | entry :: stack =>
+            if entry.name.length == n then
+              let syms := entry.finish text syms stx
+              toDocumentSymbols text stxs syms stack
+            else if entry.name.length > n then
+              let syms := { entry with name := entry.name.take n, prevSiblings := #[] }.finish text syms stx
+              toDocumentSymbols text stxs syms ({ entry with name := entry.name.drop n } :: stack)
+            else
+              let syms := entry.finish text syms stx
+              popStack (n - entry.name.length) syms stack
+        popStack (id.map (·.getId.getNumParts) |>.getD 1) syms stack
       | _ => Id.run do
-        let (syms, stxs') := toDocumentSymbols text stxs
         unless stx.isOfKind ``Lean.Parser.Command.declaration do
-          return (syms, stxs')
+          return toDocumentSymbols text stxs syms stack
         if let some stxRange := stx.getRange? then
           let (name, selection) := match stx with
             | `($_:declModifiers $_:attrKind instance $[$np:namedPrio]? $[$id$[.{$ls,*}]?]? $sig:declSig $_) =>
@@ -297,30 +340,14 @@ where
                 let stx10 : Syntax := (stx.getArg 1).getArg 0 -- TODO: stx[1][0] times out
                 (stx10.isIdOrAtom?.getD "<unknown>", stx10)
           if let some selRange := selection.getRange? then
-            return (DocumentSymbol.mk {
+            let sym := DocumentSymbol.mk {
               name := name
               kind := SymbolKind.method
               range := stxRange.toLspRange text
               selectionRange := selRange.toLspRange text
-              } :: syms, stxs')
-        return (syms, stxs')
-
-  sectionLikeToDocumentSymbols (text : FileMap) (stx : Syntax) (stxs : List Syntax) (name : String) (kind : SymbolKind) (selection : Syntax) : List DocumentSymbol × List Syntax :=
-    let (syms, stxs') := toDocumentSymbols text stxs
-    -- discard `end`
-    let (syms', stxs'') := toDocumentSymbols text (stxs'.drop 1)
-    let endStx := match stxs' with
-      | endStx::_ => endStx
-      | []        => (stx::stxs').getLast!
-    -- we can assume that commands always have at least one position (see `parseCommand`)
-    let range := (mkNullNode #[stx, endStx]).getRange?.get!.toLspRange text
-    (DocumentSymbol.mk {
-      name
-      kind
-      range
-      selectionRange := selection.getRange? |>.map (·.toLspRange text) |>.getD range
-      children? := syms.toArray
-    } :: syms', stxs'')
+            }
+            return toDocumentSymbols text stxs (syms.push sym) stack
+        toDocumentSymbols text stxs syms stack
 
 def noHighlightKinds : Array SyntaxNodeKind := #[
   -- usually have special highlighting by the client
@@ -440,16 +467,31 @@ partial def handleFoldingRange (_ : FoldingRangeParams)
     isImport stx := stx.isOfKind ``Lean.Parser.Module.header || stx.isOfKind ``Lean.Parser.Command.open
 
     addRanges (text : FileMap) sections
-    | [] => return
+    | [] => do
+      if let (_, start)::rest := sections then
+        addRange text FoldingRangeKind.region start text.source.endPos
+        addRanges text rest []
     | stx::stxs => match stx with
-      | `(namespace $_id)  => addRanges text (stx.getPos?::sections) stxs
-      | `(section $(_id)?) => addRanges text (stx.getPos?::sections) stxs
-      | `(end $(_id)?) => do
-        if let start::rest := sections then
-          addRange text FoldingRangeKind.region start stx.getTailPos?
-          addRanges text rest stxs
-        else
-          addRanges text sections stxs
+      | `(namespace $id)  =>
+        addRanges text ((id.getId.getNumParts, stx.getPos?)::sections) stxs
+      | `(section $(id)?) =>
+        addRanges text ((id.map (·.getId.getNumParts) |>.getD 1, stx.getPos?)::sections) stxs
+      | `(end $(id)?) => do
+        let rec popRanges n sections := do
+          if let (size, start)::rest := sections then
+            if size == n then
+              addRange text FoldingRangeKind.region start stx.getTailPos?
+              addRanges text rest stxs
+            else if size > n then
+              -- we don't add a range here because vscode doesn't like
+              -- multiple folding regions with the same start line
+              addRanges text ((size - n, start)::rest) stxs
+            else
+              addRange text FoldingRangeKind.region start stx.getTailPos?
+              popRanges (n - size) rest
+          else
+            addRanges text sections stxs
+        popRanges (id.map (·.getId.getNumParts) |>.getD 1) sections
       | `(mutual $body* end) => do
         addRangeFromSyntax text FoldingRangeKind.region stx
         addRanges text [] body.raw.toList

stage0/stdlib/Init/Core.c

@@ -28,7 +28,6 @@ LEAN_EXPORT lean_object* l_instInhabitedMProd___rarg(lean_object*, lean_object*)
 LEAN_EXPORT uint8_t l_instDecidableEqProp___rarg(uint8_t);
 LEAN_EXPORT uint8_t l_Lean_reduceBool(uint8_t);
 LEAN_EXPORT lean_object* l_inline(lean_object*);
-LEAN_EXPORT lean_object* l_instLTProd___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 lean_object* l_Lean_Name_str___override(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Quotient_lift_u2082___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -46,6 +45,7 @@ static lean_object* l___aux__Init__Core______macroRules__term___u2295____1___clo
 static lean_object* l___aux__Init__Core______macroRules__term___u2248____1___closed__1;
 LEAN_EXPORT lean_object* l_Quotient_recOn___rarg(lean_object*, lean_object*, lean_object*);
 static lean_object* l_term___x21_x3d_____closed__6;
+LEAN_EXPORT lean_object* l_Prod_lexLtDec___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___aux__Init__Core______unexpand__Sum__1(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_bne___rarg___boxed(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Quotient_lift___boxed(lean_object*, lean_object*, lean_object*);
@@ -97,7 +97,6 @@ LEAN_EXPORT lean_object* l_noConfusionEnum___rarg(lean_object*, lean_object*, le
 LEAN_EXPORT uint8_t l_instDecidableEqPUnit(lean_object*, lean_object*);
 static lean_object* l___aux__Init__Core______macroRules__term___u2295____1___closed__6;
 static lean_object* l_term___x21_x3d_____closed__3;
-LEAN_EXPORT lean_object* l_prodHasDecidableLt___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___aux__Init__Core______unexpand__HasEquiv__Equiv__1___boxed(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_instDecidableIteProp___rarg___boxed(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_decidable__of__decidable__of__eq(lean_object*, lean_object*);
@@ -189,6 +188,7 @@ LEAN_EXPORT lean_object* l_term___u2260__;
 LEAN_EXPORT lean_object* l_Quotient_hrecOn___boxed(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Quotient_rec(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_instInhabitedPProd___rarg(lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Prod_lexLtDec(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___aux__Init__Core______macroRules__term___x3c_x2d_x3e____1___closed__2;
 static lean_object* l___aux__Init__Core______macroRules__term_x7b_x7d__1___closed__3;
 LEAN_EXPORT lean_object* l___aux__Init__Core______unexpand__bne__1(lean_object*, lean_object*, lean_object*);
@@ -207,6 +207,7 @@ static lean_object* l_term___u2295_x27_____closed__3;
 LEAN_EXPORT lean_object* l_Eq_mpr___rarg(lean_object*);
 static lean_object* l_term___x3c_x2d_x3e_____closed__4;
 static lean_object* l___aux__Init__Core______macroRules__term___u2260____1___closed__2;
+LEAN_EXPORT lean_object* l_Prod_lexLtDec___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_term_u2205___closed__1;
 static lean_object* l___aux__Init__Core______macroRules__term___u2248____1___closed__5;
 LEAN_EXPORT lean_object* l_instDecidableEqProd___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -215,7 +216,6 @@ static lean_object* l_term___u2260_____closed__6;
 static lean_object* l_term___u2248_____closed__5;
 static lean_object* l___aux__Init__Core______macroRules__term___u2260____1___closed__4;
 lean_object* lean_mk_thunk(lean_object*);
-LEAN_EXPORT lean_object* l_instLTProd(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_term___x3c_x2d_x3e_____closed__7;
 LEAN_EXPORT lean_object* l_Task_Priority_default;
 static lean_object* l_noConfusionEnum___rarg___closed__1;
@@ -242,6 +242,7 @@ static lean_object* l_term___x3c_x2d_x3e_____closed__3;
 LEAN_EXPORT lean_object* l_instDecidableIteProp(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Eq_mp(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT uint8_t l_decidable__of__decidable__of__eq___rarg(uint8_t, lean_object*);
+LEAN_EXPORT lean_object* l_Prod_lexLtDec___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_term___u2295_____closed__6;
 LEAN_EXPORT lean_object* l_toBoolUsing(lean_object*);
 LEAN_EXPORT lean_object* l___aux__Init__Core______unexpand__HasEquiv__Equiv__1(lean_object*, lean_object*, lean_object*);
@@ -255,7 +256,6 @@ static lean_object* l___aux__Init__Core______macroRules__term___u2248____1___clo
 LEAN_EXPORT uint8_t l_instDecidableFalse;
 lean_object* l_Array_mkArray1___rarg(lean_object*);
 static lean_object* l_term___x3c_x2d_x3e_____closed__2;
-LEAN_EXPORT lean_object* l_prodHasDecidableLt___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Quotient_mk___rarg(lean_object*);
 LEAN_EXPORT lean_object* l_Prod_map___rarg(lean_object*, lean_object*, lean_object*);
 static lean_object* l___aux__Init__Core______macroRules__term_x7b_x7d__1___closed__2;
@@ -296,7 +296,6 @@ static lean_object* l_term___x3c_x2d_x3e_____closed__8;
 static lean_object* l___aux__Init__Core______macroRules__term___u2260____1___closed__5;
 static lean_object* l___aux__Init__Core______macroRules__term___x3c_x2d_x3e____1___closed__5;
 static lean_object* l___aux__Init__Core______macroRules__term___u2248____1___closed__2;
-LEAN_EXPORT lean_object* l_prodHasDecidableLt___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Quot_rec(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Task_Priority_max;
 static lean_object* l___aux__Init__Core______macroRules__term___x3c_x2d_x3e____1___closed__14;
@@ -323,7 +322,6 @@ static lean_object* l___aux__Init__Core______macroRules__term_x7b_x7d__1___close
 static lean_object* l_term___u2248_____closed__6;
 LEAN_EXPORT lean_object* l_Decidable_byCases___rarg(uint8_t, lean_object*, lean_object*);
 static lean_object* l_term_u2205___closed__4;
-LEAN_EXPORT lean_object* l_prodHasDecidableLt(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Subtype_instInhabitedSubtype___rarg(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_flip(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*);
@@ -5804,25 +5802,7 @@ x_3 = lean_alloc_closure((void*)(l_instBEqProd___rarg), 4, 0);
 return x_3;
 }
 }
-LEAN_EXPORT lean_object* l_instLTProd(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = lean_box(0);
-return x_5;
-}
-}
-LEAN_EXPORT lean_object* l_instLTProd___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_instLTProd(x_1, x_2, x_3, x_4);
-lean_dec(x_4);
-lean_dec(x_3);
-return x_5;
-}
-}
-LEAN_EXPORT lean_object* l_prodHasDecidableLt___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_EXPORT lean_object* l_Prod_lexLtDec___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) {
 _start:
 {
 lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; 
@@ -5879,28 +5859,28 @@ return x_19;
 }
 }
 }
-LEAN_EXPORT lean_object* l_prodHasDecidableLt(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+LEAN_EXPORT lean_object* l_Prod_lexLtDec(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = lean_alloc_closure((void*)(l_prodHasDecidableLt___rarg___boxed), 6, 0);
+x_5 = lean_alloc_closure((void*)(l_Prod_lexLtDec___rarg___boxed), 6, 0);
 return x_5;
 }
 }
-LEAN_EXPORT lean_object* l_prodHasDecidableLt___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_EXPORT lean_object* l_Prod_lexLtDec___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) {
 _start:
 {
 lean_object* x_7; 
-x_7 = l_prodHasDecidableLt___rarg(x_1, x_2, x_3, x_4, x_5, x_6);
+x_7 = l_Prod_lexLtDec___rarg(x_1, x_2, x_3, x_4, x_5, x_6);
 lean_dec(x_2);
 return x_7;
 }
 }
-LEAN_EXPORT lean_object* l_prodHasDecidableLt___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+LEAN_EXPORT lean_object* l_Prod_lexLtDec___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_prodHasDecidableLt(x_1, x_2, x_3, x_4);
+x_5 = l_Prod_lexLtDec(x_1, x_2, x_3, x_4);
 lean_dec(x_4);
 lean_dec(x_3);
 return x_5;

stage0/stdlib/Lean/Compiler/LCNF.c

@@ -1,6 +1,6 @@
 // Lean compiler output
 // Module: Lean.Compiler.LCNF
-// Imports: Init Lean.Compiler.LCNF.AlphaEqv Lean.Compiler.LCNF.Basic Lean.Compiler.LCNF.Bind Lean.Compiler.LCNF.Check Lean.Compiler.LCNF.CompilerM Lean.Compiler.LCNF.CSE Lean.Compiler.LCNF.DependsOn Lean.Compiler.LCNF.ElimDead Lean.Compiler.LCNF.FixedArgs Lean.Compiler.LCNF.InferType Lean.Compiler.LCNF.JoinPoints Lean.Compiler.LCNF.LCtx Lean.Compiler.LCNF.Level Lean.Compiler.LCNF.Main Lean.Compiler.LCNF.Passes Lean.Compiler.LCNF.PassManager Lean.Compiler.LCNF.PhaseExt Lean.Compiler.LCNF.PrettyPrinter Lean.Compiler.LCNF.PullFunDecls Lean.Compiler.LCNF.PullLetDecls Lean.Compiler.LCNF.ReduceJpArity Lean.Compiler.LCNF.Simp Lean.Compiler.LCNF.Specialize Lean.Compiler.LCNF.SpecInfo Lean.Compiler.LCNF.Testing Lean.Compiler.LCNF.ToDecl Lean.Compiler.LCNF.ToExpr Lean.Compiler.LCNF.ToLCNF Lean.Compiler.LCNF.Types Lean.Compiler.LCNF.Util Lean.Compiler.LCNF.ConfigOptions Lean.Compiler.LCNF.ForEachExpr
+// Imports: Init Lean.Compiler.LCNF.AlphaEqv Lean.Compiler.LCNF.Basic Lean.Compiler.LCNF.Bind Lean.Compiler.LCNF.Check Lean.Compiler.LCNF.CompilerM Lean.Compiler.LCNF.CSE Lean.Compiler.LCNF.DependsOn Lean.Compiler.LCNF.ElimDead Lean.Compiler.LCNF.FixedArgs Lean.Compiler.LCNF.InferType Lean.Compiler.LCNF.JoinPoints Lean.Compiler.LCNF.LCtx Lean.Compiler.LCNF.Level Lean.Compiler.LCNF.Main Lean.Compiler.LCNF.Passes Lean.Compiler.LCNF.PassManager Lean.Compiler.LCNF.PhaseExt Lean.Compiler.LCNF.PrettyPrinter Lean.Compiler.LCNF.PullFunDecls Lean.Compiler.LCNF.PullLetDecls Lean.Compiler.LCNF.ReduceJpArity Lean.Compiler.LCNF.Simp Lean.Compiler.LCNF.Specialize Lean.Compiler.LCNF.SpecInfo Lean.Compiler.LCNF.Testing Lean.Compiler.LCNF.ToDecl Lean.Compiler.LCNF.ToExpr Lean.Compiler.LCNF.ToLCNF Lean.Compiler.LCNF.Types Lean.Compiler.LCNF.Util Lean.Compiler.LCNF.ConfigOptions Lean.Compiler.LCNF.ForEachExpr Lean.Compiler.LCNF.MonoTypes
 #include <lean/lean.h>
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wunused-parameter"
@@ -46,6 +46,7 @@ lean_object* initialize_Lean_Compiler_LCNF_Types(uint8_t builtin, lean_object*);
 lean_object* initialize_Lean_Compiler_LCNF_Util(uint8_t builtin, lean_object*);
 lean_object* initialize_Lean_Compiler_LCNF_ConfigOptions(uint8_t builtin, lean_object*);
 lean_object* initialize_Lean_Compiler_LCNF_ForEachExpr(uint8_t builtin, lean_object*);
+lean_object* initialize_Lean_Compiler_LCNF_MonoTypes(uint8_t builtin, lean_object*);
 static bool _G_initialized = false;
 LEAN_EXPORT lean_object* initialize_Lean_Compiler_LCNF(uint8_t builtin, lean_object* w) {
 lean_object * res;
@@ -150,6 +151,9 @@ lean_dec_ref(res);
 res = initialize_Lean_Compiler_LCNF_ForEachExpr(builtin, lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
+res = initialize_Lean_Compiler_LCNF_MonoTypes(builtin, 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/Compiler/LCNF/Basic.c

@@ -22,11 +22,11 @@ size_t lean_usize_add(size_t, size_t);
 static lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_collectExpr___closed__1;
 static lean_object* l_Lean_Compiler_LCNF_instInhabitedParam___closed__2;
 LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateReturnImp(lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_List_beq___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646____spec__1___boxed(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_Code_forM_go___spec__1___rarg___lambda__1(size_t, lean_object*, lean_object*, lean_object*, size_t, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_attachCodeDecls_go___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_attachCodeDecls_go___closed__1;
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_AltCore_getParams(lean_object*);
 LEAN_EXPORT lean_object* l_Array_isEqvAux___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_eqAlt___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateContImp___closed__1;
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_Code_size_go___spec__1(lean_object*, size_t, size_t, lean_object*);
@@ -67,7 +67,7 @@ lean_object* lean_array_get_size(lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_Code_collectUsed___spec__1(lean_object*, size_t, size_t, lean_object*);
 LEAN_EXPORT uint8_t l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqLetDecl____x40_Lean_Compiler_LCNF_Basic___hyg_282_(lean_object*, lean_object*);
 static lean_object* l_panic___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_collectExpr___spec__3___closed__1;
-LEAN_EXPORT uint8_t l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646_(lean_object*, lean_object*);
+LEAN_EXPORT uint8_t l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694_(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Code_size(lean_object*);
 LEAN_EXPORT uint8_t l_Array_isEqvAux___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_eqAlt___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Decl_instantiateValueLevelParams(lean_object*, lean_object*);
@@ -92,6 +92,7 @@ LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_instInhabitedAltCore(lean_object*)
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Compiler_LCNF_markRecDecls___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__2;
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_markRecDecls_go___spec__1(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_AltCore_getParams___boxed(lean_object*);
 static lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltsImp___closed__2;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_markRecDecls_visit___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_instBEqFunDecl;
@@ -118,22 +119,21 @@ extern lean_object* l_Lean_instFVarIdSetInhabited;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Decl_getArity(lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_instInhabitedCodeDecl___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_collectUsedAtExpr(lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Array_isEqvAux___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646____spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Decl_instantiateValueLevelParams_instAlt(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_AltCore_forCodeM(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_attachCodeDecls___boxed(lean_object*, lean_object*);
+LEAN_EXPORT uint8_t l_List_beq___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694____spec__1(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_collectParams(lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646____boxed(lean_object*, lean_object*);
 lean_object* l_instInhabitedForAll__1___rarg(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Code_isFun___boxed(lean_object*);
 static lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateJmpImp___closed__2;
+LEAN_EXPORT lean_object* l_Array_isEqvAux___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694____spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_instBEqLetDecl___closed__1;
 static lean_object* l_Lean_Compiler_LCNF_attachCodeDecls_go___closed__3;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_instInhabitedLetDecl;
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_Code_sizeLe_go___spec__1(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_markRecDecls(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Decl_instantiateValueLevelParams_instExpr(lean_object*, lean_object*, lean_object*);
-LEAN_EXPORT uint8_t l_List_beq___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646____spec__1(lean_object*, lean_object*);
 uint8_t l_Lean_Name_quickCmp(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_CasesCore_extractAlt_x21___closed__3;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_FunDeclCore_collectUsed(lean_object*, lean_object*);
@@ -143,6 +143,7 @@ LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at___private_Lean_Compiler_
 LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_eqImp___boxed(lean_object*, lean_object*);
 LEAN_EXPORT uint8_t l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_eqImp(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_FunDeclCore_getArity(lean_object*);
+LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694____boxed(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Decl_instantiateValueLevelParams_instLetDecl___boxed(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_instBEqCode___closed__1;
 static lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateReturnImp___closed__2;
@@ -160,6 +161,7 @@ lean_object* l_Lean_Expr_bvar___override(lean_object*);
 LEAN_EXPORT lean_object* l_Array_anyMUnsafe_any___at_Lean_Compiler_LCNF_markRecDecls_visit___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_instInhabitedDecl___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Decl_instantiateValueLevelParams_instParams___lambda__1(lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT uint8_t l_Array_isEqvAux___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694____spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_RBNode_insert___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_collectExpr___spec__1(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_Code_forM_go___spec__1___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_CasesCore_getCtorNames___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -211,6 +213,7 @@ LEAN_EXPORT uint8_t l_Array_isEqvAux___at___private_Lean_Compiler_LCNF_Basic_0__
 LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltsImp(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Code_size_go(lean_object*, lean_object*);
 static lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateCasesImp___closed__2;
+LEAN_EXPORT lean_object* l_List_beq___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694____spec__1___boxed(lean_object*, lean_object*);
 static lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateUnreachImp___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Decl_instantiateValueLevelParams_instFunDecl(lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateLetImp___closed__2;
@@ -235,7 +238,6 @@ LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Decl_instantiateValueLevelParams_i
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Code_forM(lean_object*);
 LEAN_EXPORT lean_object* l_panic___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_collectExpr___spec__3(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_getAppFn(lean_object*);
-LEAN_EXPORT uint8_t l_Array_isEqvAux___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646____spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateUnreachImp(lean_object*, lean_object*);
 lean_object* l_Array_findIdx_x3f_loop___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_panic___at_Lean_Compiler_LCNF_CasesCore_extractAlt_x21___spec__1(lean_object*);
@@ -1777,6 +1779,33 @@ lean_dec(x_1);
 return x_2;
 }
 }
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_AltCore_getParams(lean_object* x_1) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_2; 
+x_2 = lean_ctor_get(x_1, 1);
+lean_inc(x_2);
+return x_2;
+}
+else
+{
+lean_object* x_3; 
+x_3 = l_Lean_Compiler_LCNF_instInhabitedAltCore___rarg___closed__1;
+return x_3;
+}
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_AltCore_getParams___boxed(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_Lean_Compiler_LCNF_AltCore_getParams(x_1);
+lean_dec(x_1);
+return x_2;
+}
+}
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_AltCore_forCodeM___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -1954,7 +1983,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__1;
 x_2 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__2;
-x_3 = lean_unsigned_to_nat(165u);
+x_3 = lean_unsigned_to_nat(169u);
 x_4 = lean_unsigned_to_nat(9u);
 x_5 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -2085,7 +2114,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__1;
 x_2 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltsImp___closed__1;
-x_3 = lean_unsigned_to_nat(172u);
+x_3 = lean_unsigned_to_nat(176u);
 x_4 = lean_unsigned_to_nat(9u);
 x_5 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -2218,7 +2247,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__1;
 x_2 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateCasesImp___closed__1;
-x_3 = lean_unsigned_to_nat(179u);
+x_3 = lean_unsigned_to_nat(183u);
 x_4 = lean_unsigned_to_nat(9u);
 x_5 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -2489,7 +2518,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__1;
 x_2 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateLetImp___closed__1;
-x_3 = lean_unsigned_to_nat(186u);
+x_3 = lean_unsigned_to_nat(190u);
 x_4 = lean_unsigned_to_nat(9u);
 x_5 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -2602,7 +2631,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__1;
 x_2 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateContImp___closed__1;
-x_3 = lean_unsigned_to_nat(195u);
+x_3 = lean_unsigned_to_nat(199u);
 x_4 = lean_unsigned_to_nat(9u);
 x_5 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -2765,7 +2794,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__1;
 x_2 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateFunImp___closed__1;
-x_3 = lean_unsigned_to_nat(203u);
+x_3 = lean_unsigned_to_nat(207u);
 x_4 = lean_unsigned_to_nat(9u);
 x_5 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -2957,7 +2986,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__1;
 x_2 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateReturnImp___closed__1;
-x_3 = lean_unsigned_to_nat(210u);
+x_3 = lean_unsigned_to_nat(214u);
 x_4 = lean_unsigned_to_nat(9u);
 x_5 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -3026,7 +3055,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__1;
 x_2 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateJmpImp___closed__1;
-x_3 = lean_unsigned_to_nat(217u);
+x_3 = lean_unsigned_to_nat(221u);
 x_4 = lean_unsigned_to_nat(9u);
 x_5 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -3137,7 +3166,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__1;
 x_2 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateUnreachImp___closed__1;
-x_3 = lean_unsigned_to_nat(224u);
+x_3 = lean_unsigned_to_nat(228u);
 x_4 = lean_unsigned_to_nat(9u);
 x_5 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -3591,7 +3620,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__1;
 x_2 = l_Lean_Compiler_LCNF_CasesCore_extractAlt_x21___closed__2;
-x_3 = lean_unsigned_to_nat(274u);
+x_3 = lean_unsigned_to_nat(278u);
 x_4 = lean_unsigned_to_nat(4u);
 x_5 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -4901,7 +4930,7 @@ x_1 = l_Lean_Compiler_LCNF_instInhabitedDecl___closed__1;
 return x_1;
 }
 }
-LEAN_EXPORT uint8_t l_List_beq___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646____spec__1(lean_object* x_1, lean_object* x_2) {
+LEAN_EXPORT uint8_t l_List_beq___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694____spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -4951,7 +4980,7 @@ goto _start;
 }
 }
 }
-LEAN_EXPORT uint8_t l_Array_isEqvAux___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646____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_EXPORT uint8_t l_Array_isEqvAux___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694____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) {
 _start:
 {
 lean_object* x_7; uint8_t x_8; 
@@ -4993,7 +5022,7 @@ goto _start;
 }
 }
 }
-LEAN_EXPORT uint8_t l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646_(lean_object* x_1, lean_object* x_2) {
+LEAN_EXPORT uint8_t l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694_(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; uint8_t x_16; lean_object* x_17; uint8_t x_21; 
@@ -5032,7 +5061,7 @@ return x_22;
 else
 {
 uint8_t x_23; 
-x_23 = l_List_beq___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646____spec__1(x_4, x_11);
+x_23 = l_List_beq___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694____spec__1(x_4, x_11);
 lean_dec(x_4);
 if (x_23 == 0)
 {
@@ -5076,7 +5105,7 @@ else
 {
 lean_object* x_31; uint8_t x_32; 
 x_31 = lean_unsigned_to_nat(0u);
-x_32 = l_Array_isEqvAux___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646____spec__2(x_6, x_13, lean_box(0), x_6, x_13, x_31);
+x_32 = l_Array_isEqvAux___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694____spec__2(x_6, x_13, lean_box(0), x_6, x_13, x_31);
 lean_dec(x_6);
 if (x_32 == 0)
 {
@@ -5160,22 +5189,22 @@ return x_16;
 }
 }
 }
-LEAN_EXPORT lean_object* l_List_beq___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646____spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+LEAN_EXPORT lean_object* l_List_beq___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694____spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; lean_object* x_4; 
-x_3 = l_List_beq___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646____spec__1(x_1, x_2);
+x_3 = l_List_beq___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694____spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 x_4 = lean_box(x_3);
 return x_4;
 }
 }
-LEAN_EXPORT lean_object* l_Array_isEqvAux___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646____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_EXPORT lean_object* l_Array_isEqvAux___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694____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) {
 _start:
 {
 uint8_t x_7; lean_object* x_8; 
-x_7 = l_Array_isEqvAux___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646____spec__2(x_1, x_2, x_3, x_4, x_5, x_6);
+x_7 = l_Array_isEqvAux___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694____spec__2(x_1, x_2, x_3, x_4, x_5, x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_2);
@@ -5184,11 +5213,11 @@ x_8 = lean_box(x_7);
 return x_8;
 }
 }
-LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646____boxed(lean_object* x_1, lean_object* x_2) {
+LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694____boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; lean_object* x_4; 
-x_3 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646_(x_1, x_2);
+x_3 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694_(x_1, x_2);
 lean_dec(x_2);
 x_4 = lean_box(x_3);
 return x_4;
@@ -5198,7 +5227,7 @@ static lean_object* _init_l_Lean_Compiler_LCNF_instBEqDecl___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646____boxed), 2, 0);
+x_1 = lean_alloc_closure((void*)(l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694____boxed), 2, 0);
 return x_1;
 }
 }
@@ -8588,7 +8617,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__1;
 x_2 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_collectExpr___closed__1;
-x_3 = lean_unsigned_to_nat(472u);
+x_3 = lean_unsigned_to_nat(476u);
 x_4 = lean_unsigned_to_nat(24u);
 x_5 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_updateAltImp___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

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

@@ -20,6 +20,7 @@ lean_object* l_Lean_stringToMessageData(lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 lean_object* l_Lean_Name_str___override(lean_object*, lean_object*);
 lean_object* lean_array_uget(lean_object*, size_t);
+lean_object* l_Lean_Compiler_LCNF_mkLcCast(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Compiler_LCNF_CompilerM_codeBind_go___spec__3(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_mkNewParams_go(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_append___rarg(lean_object*, lean_object*);
@@ -28,13 +29,12 @@ LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Compiler_LCNF_CompilerM_cod
 static lean_object* l_Lean_throwError___at_Lean_Compiler_LCNF_CompilerM_codeBind_go___spec__2___closed__4;
 LEAN_EXPORT uint8_t l_Lean_Compiler_LCNF_FunDeclCore_isEtaExpandCandidate(lean_object*);
 lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_etaExpandCore___lambda__1___closed__1;
+uint8_t l_Lean_Expr_isErased(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_instMonadCodeBindStateRefT_x27(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_throwError___at_Lean_Compiler_LCNF_CompilerM_codeBind_go___spec__2___closed__5;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_CompilerM_codeBind_go___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_instMonadCodeBindCompilerM;
-static lean_object* l_Lean_Compiler_LCNF_etaExpandCore___lambda__1___closed__2;
 lean_object* l_Lean_Compiler_LCNF_eraseParam(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_instMonadCodeBindReaderT___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_LCNF_mkCasesResultType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -49,6 +49,8 @@ lean_object* l_Lean_Compiler_LCNF_Code_inferType(lean_object*, lean_object*, lea
 static lean_object* l_Lean_Compiler_LCNF_CompilerM_codeBind_go___closed__4;
 lean_object* l_Lean_mkAppN(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_LCNF_Code_inferParamType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Compiler_LCNF_erasedExpr;
+static lean_object* l_Lean_Compiler_LCNF_Code_ensureAnyType___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_CompilerM_codeBind_go___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_instMonadCodeBindReaderT___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_CompilerM_codeBind(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -63,6 +65,7 @@ uint8_t l_Lean_Name_quickCmp(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_FunDeclCore_etaExpand(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Array_isEmpty___rarg(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_RBNode_findCore___at_Lean_Compiler_LCNF_CompilerM_codeBind_go___spec__1(lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Code_ensureAnyType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_updateFunDeclImp(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_etaExpandCore(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_RBNode_insert___at___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_collectExpr___spec__1(lean_object*, lean_object*, lean_object*);
@@ -77,6 +80,7 @@ uint8_t lean_expr_eqv(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Compiler_LCNF_CompilerM_codeBind_go___spec__3___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_Compiler_LCNF_eraseCode(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_LCNF_LCtx_toLocalContext(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Code_ensureAnyType___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_throwError___at_Lean_Compiler_LCNF_CompilerM_codeBind_go___spec__2___closed__3;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_etaExpandCore_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_expr_instantiate_rev(lean_object*, lean_object*);
@@ -85,6 +89,8 @@ static lean_object* l_Lean_throwError___at_Lean_Compiler_LCNF_CompilerM_codeBind
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_etaExpandCore___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_RBNode_findCore___at_Lean_Compiler_LCNF_CompilerM_codeBind_go___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Array_mapMUnsafe_map___at_Lean_Compiler_LCNF_InferType_mkForallParams___spec__1(size_t, size_t, lean_object*);
+static lean_object* l_Lean_Compiler_LCNF_Code_ensureAnyType___lambda__1___closed__2;
+static lean_object* l_Lean_Compiler_LCNF_Code_ensureAnyType___lambda__1___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_instMonadCodeBindReaderT(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_LCNF_mkAuxParam(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_CompilerM_codeBind_go___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1899,6 +1905,242 @@ lean_dec(x_4);
 return x_5;
 }
 }
+static lean_object* _init_l_Lean_Compiler_LCNF_Code_ensureAnyType___lambda__1___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string_from_bytes("_x", 2);
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_Compiler_LCNF_Code_ensureAnyType___lambda__1___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l_Lean_Compiler_LCNF_Code_ensureAnyType___lambda__1___closed__1;
+x_3 = l_Lean_Name_str___override(x_1, x_2);
+return x_3;
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Code_ensureAnyType___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) {
+_start:
+{
+lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_7 = l_Lean_Expr_fvar___override(x_1);
+x_8 = l_Lean_Compiler_LCNF_erasedExpr;
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+lean_inc(x_2);
+x_9 = l_Lean_Compiler_LCNF_mkLcCast(x_7, x_8, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_9, 1);
+lean_inc(x_11);
+lean_dec(x_9);
+x_12 = l_Lean_Compiler_LCNF_Code_ensureAnyType___lambda__1___closed__2;
+x_13 = l_Lean_Compiler_LCNF_mkAuxLetDecl(x_10, x_12, x_2, x_3, x_4, x_5, x_11);
+if (lean_obj_tag(x_13) == 0)
+{
+uint8_t x_14; 
+x_14 = !lean_is_exclusive(x_13);
+if (x_14 == 0)
+{
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+x_15 = lean_ctor_get(x_13, 0);
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
+x_17 = lean_alloc_ctor(5, 1, 0);
+lean_ctor_set(x_17, 0, x_16);
+x_18 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_18, 0, x_15);
+lean_ctor_set(x_18, 1, x_17);
+lean_ctor_set(x_13, 0, x_18);
+return x_13;
+}
+else
+{
+lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_19 = lean_ctor_get(x_13, 0);
+x_20 = lean_ctor_get(x_13, 1);
+lean_inc(x_20);
+lean_inc(x_19);
+lean_dec(x_13);
+x_21 = lean_ctor_get(x_19, 0);
+lean_inc(x_21);
+x_22 = lean_alloc_ctor(5, 1, 0);
+lean_ctor_set(x_22, 0, x_21);
+x_23 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_23, 0, x_19);
+lean_ctor_set(x_23, 1, x_22);
+x_24 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_24, 0, x_23);
+lean_ctor_set(x_24, 1, x_20);
+return x_24;
+}
+}
+else
+{
+uint8_t x_25; 
+x_25 = !lean_is_exclusive(x_13);
+if (x_25 == 0)
+{
+return x_13;
+}
+else
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+x_26 = lean_ctor_get(x_13, 0);
+x_27 = lean_ctor_get(x_13, 1);
+lean_inc(x_27);
+lean_inc(x_26);
+lean_dec(x_13);
+x_28 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_28, 0, x_26);
+lean_ctor_set(x_28, 1, x_27);
+return x_28;
+}
+}
+}
+else
+{
+uint8_t x_29; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_29 = !lean_is_exclusive(x_9);
+if (x_29 == 0)
+{
+return x_9;
+}
+else
+{
+lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+x_30 = lean_ctor_get(x_9, 0);
+x_31 = lean_ctor_get(x_9, 1);
+lean_inc(x_31);
+lean_inc(x_30);
+lean_dec(x_9);
+x_32 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_32, 0, x_30);
+lean_ctor_set(x_32, 1, x_31);
+return x_32;
+}
+}
+}
+}
+static lean_object* _init_l_Lean_Compiler_LCNF_Code_ensureAnyType___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Compiler_LCNF_Code_ensureAnyType___lambda__1), 6, 0);
+return x_1;
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Code_ensureAnyType(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+lean_object* x_7; 
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+lean_inc(x_2);
+lean_inc(x_1);
+x_7 = l_Lean_Compiler_LCNF_Code_inferType(x_1, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_7) == 0)
+{
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_7);
+if (x_8 == 0)
+{
+lean_object* x_9; lean_object* x_10; uint8_t x_11; 
+x_9 = lean_ctor_get(x_7, 0);
+x_10 = lean_ctor_get(x_7, 1);
+x_11 = l_Lean_Expr_isErased(x_9);
+lean_dec(x_9);
+if (x_11 == 0)
+{
+lean_object* x_12; lean_object* x_13; 
+lean_free_object(x_7);
+x_12 = l_Lean_Compiler_LCNF_Code_ensureAnyType___closed__1;
+x_13 = l_Lean_Compiler_LCNF_CompilerM_codeBind(x_1, x_12, x_2, x_3, x_4, x_5, x_10);
+return x_13;
+}
+else
+{
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_ctor_set(x_7, 0, x_1);
+return x_7;
+}
+}
+else
+{
+lean_object* x_14; lean_object* x_15; uint8_t x_16; 
+x_14 = lean_ctor_get(x_7, 0);
+x_15 = lean_ctor_get(x_7, 1);
+lean_inc(x_15);
+lean_inc(x_14);
+lean_dec(x_7);
+x_16 = l_Lean_Expr_isErased(x_14);
+lean_dec(x_14);
+if (x_16 == 0)
+{
+lean_object* x_17; lean_object* x_18; 
+x_17 = l_Lean_Compiler_LCNF_Code_ensureAnyType___closed__1;
+x_18 = l_Lean_Compiler_LCNF_CompilerM_codeBind(x_1, x_17, x_2, x_3, x_4, x_5, x_15);
+return x_18;
+}
+else
+{
+lean_object* x_19; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_19 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_19, 0, x_1);
+lean_ctor_set(x_19, 1, x_15);
+return x_19;
+}
+}
+}
+else
+{
+uint8_t x_20; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_20 = !lean_is_exclusive(x_7);
+if (x_20 == 0)
+{
+return x_7;
+}
+else
+{
+lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+x_21 = lean_ctor_get(x_7, 0);
+x_22 = lean_ctor_get(x_7, 1);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_dec(x_7);
+x_23 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_23, 0, x_21);
+lean_ctor_set(x_23, 1, x_22);
+return x_23;
+}
+}
+}
+}
 static lean_object* _init_l_Lean_Compiler_LCNF_mkNewParams_go___closed__1() {
 _start:
 {
@@ -2047,31 +2289,13 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Compiler_LCNF_etaExpandCore___lambda__1___closed__1() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string_from_bytes("_x", 2);
-return x_1;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_etaExpandCore___lambda__1___closed__2() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = lean_box(0);
-x_2 = l_Lean_Compiler_LCNF_etaExpandCore___lambda__1___closed__1;
-x_3 = l_Lean_Name_str___override(x_1, x_2);
-return x_3;
-}
-}
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_etaExpandCore___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) {
 _start:
 {
 lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
 x_8 = l_Lean_Expr_fvar___override(x_2);
 x_9 = l_Lean_mkAppN(x_8, x_1);
-x_10 = l_Lean_Compiler_LCNF_etaExpandCore___lambda__1___closed__2;
+x_10 = l_Lean_Compiler_LCNF_Code_ensureAnyType___lambda__1___closed__2;
 x_11 = l_Lean_Compiler_LCNF_mkAuxLetDecl(x_9, x_10, x_3, x_4, x_5, x_6, x_7);
 if (lean_obj_tag(x_11) == 0)
 {
@@ -2646,12 +2870,14 @@ l_Lean_Compiler_LCNF_instMonadCodeBindCompilerM___closed__1 = _init_l_Lean_Compi
 lean_mark_persistent(l_Lean_Compiler_LCNF_instMonadCodeBindCompilerM___closed__1);
 l_Lean_Compiler_LCNF_instMonadCodeBindCompilerM = _init_l_Lean_Compiler_LCNF_instMonadCodeBindCompilerM();
 lean_mark_persistent(l_Lean_Compiler_LCNF_instMonadCodeBindCompilerM);
+l_Lean_Compiler_LCNF_Code_ensureAnyType___lambda__1___closed__1 = _init_l_Lean_Compiler_LCNF_Code_ensureAnyType___lambda__1___closed__1();
+lean_mark_persistent(l_Lean_Compiler_LCNF_Code_ensureAnyType___lambda__1___closed__1);
+l_Lean_Compiler_LCNF_Code_ensureAnyType___lambda__1___closed__2 = _init_l_Lean_Compiler_LCNF_Code_ensureAnyType___lambda__1___closed__2();
+lean_mark_persistent(l_Lean_Compiler_LCNF_Code_ensureAnyType___lambda__1___closed__2);
+l_Lean_Compiler_LCNF_Code_ensureAnyType___closed__1 = _init_l_Lean_Compiler_LCNF_Code_ensureAnyType___closed__1();
+lean_mark_persistent(l_Lean_Compiler_LCNF_Code_ensureAnyType___closed__1);
 l_Lean_Compiler_LCNF_mkNewParams_go___closed__1 = _init_l_Lean_Compiler_LCNF_mkNewParams_go___closed__1();
 lean_mark_persistent(l_Lean_Compiler_LCNF_mkNewParams_go___closed__1);
-l_Lean_Compiler_LCNF_etaExpandCore___lambda__1___closed__1 = _init_l_Lean_Compiler_LCNF_etaExpandCore___lambda__1___closed__1();
-lean_mark_persistent(l_Lean_Compiler_LCNF_etaExpandCore___lambda__1___closed__1);
-l_Lean_Compiler_LCNF_etaExpandCore___lambda__1___closed__2 = _init_l_Lean_Compiler_LCNF_etaExpandCore___lambda__1___closed__2();
-lean_mark_persistent(l_Lean_Compiler_LCNF_etaExpandCore___lambda__1___closed__2);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus

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

@@ -68,8 +68,10 @@ LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_normLetDecl___at_Lean_Compiler_LCN
 lean_object* lean_st_ref_take(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_normParams___at_Lean_Compiler_LCNF_Code_cse_goFunDecl___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_normExpr___at_Lean_Compiler_LCNF_Code_cse_go___spec__6(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_mkHashMap___at_Lean_Compiler_LCNF_CSE_State_subst___default___spec__1(lean_object*);
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_mkHashMap___at_Lean_Compiler_LCNF_CSE_State_subst___default___spec__1___boxed(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_PersistentHashMap_insertAux___at_Lean_Compiler_LCNF_CSE_addEntry___spec__2(lean_object*, size_t, size_t, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_CSE_replaceLet___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_normParams___at_Lean_Compiler_LCNF_Code_cse_goFunDecl___spec__1(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -80,7 +82,6 @@ LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_normParam___at_Lean_Compiler_LCNF_
 uint64_t l_Lean_Expr_hash(lean_object*);
 size_t lean_usize_shift_left(size_t, size_t);
 lean_object* l_Lean_Compiler_LCNF_Pass_mkPerDeclaration(lean_object*, lean_object*, uint8_t, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_CSE_State_subst___default___closed__1;
 static size_t l_Lean_PersistentHashMap_insertAux___at_Lean_Compiler_LCNF_CSE_addEntry___spec__2___closed__2;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Decl_cse(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_PersistentHashMap_findAtAux___at_Lean_Compiler_LCNF_Code_cse_go___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -119,6 +120,7 @@ lean_object* l_Lean_PersistentHashMap_mkEmptyEntries(lean_object*, lean_object*)
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_cse;
 LEAN_EXPORT lean_object* l_Lean_PersistentHashMap_findAux___at_Lean_Compiler_LCNF_Code_cse_go___spec__3(lean_object*, size_t, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_Code_cse___closed__1;
+static lean_object* l_Lean_Compiler_LCNF_Code_cse___closed__2;
 lean_object* l___private_Lean_Compiler_LCNF_CompilerM_0__Lean_Compiler_LCNF_normExprImp_go(lean_object*, uint8_t, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_CSE_State_subst___default;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Code_cse_go___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -171,7 +173,15 @@ x_1 = l_Lean_Compiler_LCNF_CSE_State_map___default___closed__3;
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Compiler_LCNF_CSE_State_subst___default___closed__1() {
+LEAN_EXPORT lean_object* l_Lean_mkHashMap___at_Lean_Compiler_LCNF_CSE_State_subst___default___spec__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = l_Lean_mkHashMapImp___rarg(x_1);
+return x_2;
+}
+}
+static lean_object* _init_l_Lean_Compiler_LCNF_CSE_State_subst___default() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -180,12 +190,13 @@ x_2 = l_Lean_mkHashMapImp___rarg(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_Compiler_LCNF_CSE_State_subst___default() {
+LEAN_EXPORT lean_object* l_Lean_mkHashMap___at_Lean_Compiler_LCNF_CSE_State_subst___default___spec__1___boxed(lean_object* x_1) {
 _start:
 {
-lean_object* x_1; 
-x_1 = l_Lean_Compiler_LCNF_CSE_State_subst___default___closed__1;
-return x_1;
+lean_object* x_2; 
+x_2 = l_Lean_mkHashMap___at_Lean_Compiler_LCNF_CSE_State_subst___default___spec__1(x_1);
+lean_dec(x_1);
+return x_2;
 }
 }
 LEAN_EXPORT lean_object* l_StateRefT_x27_get___at_Lean_Compiler_LCNF_CSE_instMonadFVarSubstMFalse___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) {
@@ -4976,9 +4987,18 @@ return x_10;
 static lean_object* _init_l_Lean_Compiler_LCNF_Code_cse___closed__1() {
 _start:
 {
+lean_object* x_1; lean_object* x_2; 
+x_1 = lean_unsigned_to_nat(0u);
+x_2 = l_Lean_mkHashMapImp___rarg(x_1);
+return x_2;
+}
+}
+static lean_object* _init_l_Lean_Compiler_LCNF_Code_cse___closed__2() {
+_start:
+{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_Compiler_LCNF_CSE_State_map___default___closed__3;
-x_2 = l_Lean_Compiler_LCNF_CSE_State_subst___default___closed__1;
+x_2 = l_Lean_Compiler_LCNF_Code_cse___closed__1;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
@@ -4993,7 +5013,7 @@ x_7 = lean_st_ref_get(x_5, x_6);
 x_8 = lean_ctor_get(x_7, 1);
 lean_inc(x_8);
 lean_dec(x_7);
-x_9 = l_Lean_Compiler_LCNF_Code_cse___closed__1;
+x_9 = l_Lean_Compiler_LCNF_Code_cse___closed__2;
 x_10 = lean_st_mk_ref(x_9, x_8);
 x_11 = lean_ctor_get(x_10, 0);
 lean_inc(x_11);
@@ -5317,8 +5337,6 @@ l_Lean_Compiler_LCNF_CSE_State_map___default___closed__3 = _init_l_Lean_Compiler
 lean_mark_persistent(l_Lean_Compiler_LCNF_CSE_State_map___default___closed__3);
 l_Lean_Compiler_LCNF_CSE_State_map___default = _init_l_Lean_Compiler_LCNF_CSE_State_map___default();
 lean_mark_persistent(l_Lean_Compiler_LCNF_CSE_State_map___default);
-l_Lean_Compiler_LCNF_CSE_State_subst___default___closed__1 = _init_l_Lean_Compiler_LCNF_CSE_State_subst___default___closed__1();
-lean_mark_persistent(l_Lean_Compiler_LCNF_CSE_State_subst___default___closed__1);
 l_Lean_Compiler_LCNF_CSE_State_subst___default = _init_l_Lean_Compiler_LCNF_CSE_State_subst___default();
 lean_mark_persistent(l_Lean_Compiler_LCNF_CSE_State_subst___default);
 l_Lean_Compiler_LCNF_CSE_instMonadFVarSubstMFalse___closed__1 = _init_l_Lean_Compiler_LCNF_CSE_instMonadFVarSubstMFalse___closed__1();
@@ -5337,6 +5355,8 @@ l_Lean_Compiler_LCNF_Code_cse_go___closed__2 = _init_l_Lean_Compiler_LCNF_Code_c
 lean_mark_persistent(l_Lean_Compiler_LCNF_Code_cse_go___closed__2);
 l_Lean_Compiler_LCNF_Code_cse___closed__1 = _init_l_Lean_Compiler_LCNF_Code_cse___closed__1();
 lean_mark_persistent(l_Lean_Compiler_LCNF_Code_cse___closed__1);
+l_Lean_Compiler_LCNF_Code_cse___closed__2 = _init_l_Lean_Compiler_LCNF_Code_cse___closed__2();
+lean_mark_persistent(l_Lean_Compiler_LCNF_Code_cse___closed__2);
 l_Lean_Compiler_LCNF_cse___closed__1 = _init_l_Lean_Compiler_LCNF_cse___closed__1();
 lean_mark_persistent(l_Lean_Compiler_LCNF_cse___closed__1);
 l_Lean_Compiler_LCNF_cse___closed__2 = _init_l_Lean_Compiler_LCNF_cse___closed__2();

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

@@ -44,6 +44,7 @@ LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Check_checkExpr(lean_object*, lean
 LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Compiler_LCNF_Check_checkAppArgs___spec__3___lambda__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*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_LCNF_InferType_compatibleTypes(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_checkDeadLocalDecls___spec__6___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_Expr_isErased(lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_Check_check___closed__2;
 static lean_object* l_Std_Range_forIn_loop___at_Lean_Compiler_LCNF_Check_checkAppArgs___spec__3___lambda__5___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_checkDeadLocalDecls_visitParams___boxed(lean_object*, lean_object*);
@@ -86,7 +87,6 @@ static lean_object* l_Lean_Compiler_LCNF_Check_check___closed__6;
 uint8_t lean_usize_dec_lt(size_t, size_t);
 static lean_object* l_Lean_Compiler_LCNF_Check_checkCases___closed__4;
 lean_object* l_Lean_mkHashSetImp___rarg(lean_object*);
-lean_object* l_Lean_RBNode_findCore___at_Lean_Meta_ToHide_isMarked___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_LCNF_Code_inferType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_levelZero;
 static lean_object* l_Lean_Compiler_LCNF_Check_run___rarg___closed__2;
@@ -182,6 +182,7 @@ lean_object* l___private_Init_Util_0__mkPanicMessageWithDecl(lean_object*, lean_
 uint8_t l_Lean_Expr_isConst(lean_object*);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_Check_checkCases___spec__4___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_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_checkDeadLocalDecls___spec__6(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_RBNode_findCore___at_Lean_Compiler_LCNF_CompilerM_codeBind_go___spec__1(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Check_checkFunDecl___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_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_checkDeadLocalDecls___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_Check_addFVarId___closed__1;
@@ -252,7 +253,6 @@ LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Check_run___rarg(lean_object*, lea
 lean_object* l_Lean_Compiler_LCNF_getType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_mul(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_Check_withParams___spec__1(lean_object*, size_t, size_t, lean_object*);
-uint8_t l_Lean_Expr_isAnyType(lean_object*);
 static lean_object* l_Lean_getConstInfo___at_Lean_Compiler_LCNF_Check_checkCases___spec__1___closed__3;
 static lean_object* l_Lean_Compiler_LCNF_Check_checkLetDecl___closed__3;
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
@@ -543,7 +543,7 @@ _start:
 {
 lean_object* x_10; lean_object* x_11; 
 x_10 = lean_ctor_get(x_2, 1);
-x_11 = l_Lean_RBNode_findCore___at_Lean_Meta_ToHide_isMarked___spec__1(x_10, x_1);
+x_11 = l_Lean_RBNode_findCore___at_Lean_Compiler_LCNF_CompilerM_codeBind_go___spec__1(x_10, x_1);
 if (lean_obj_tag(x_11) == 0)
 {
 lean_object* x_12; 
@@ -1528,7 +1528,7 @@ uint8_t x_29;
 lean_dec(x_4);
 lean_dec(x_2);
 lean_dec(x_1);
-x_29 = l_Lean_Expr_isAnyType(x_24);
+x_29 = l_Lean_Expr_isErased(x_24);
 if (x_29 == 0)
 {
 lean_object* x_30; lean_object* x_31; 
@@ -1645,7 +1645,7 @@ if (lean_is_exclusive(x_23)) {
  x_26 = lean_box(0);
 }
 x_27 = lean_nat_dec_lt(x_6, x_3);
-x_28 = l_Lean_Expr_isAnyType(x_24);
+x_28 = l_Lean_Expr_isErased(x_24);
 if (x_27 == 0)
 {
 lean_object* x_52; lean_object* x_53; 
@@ -2557,7 +2557,7 @@ _start:
 {
 lean_object* x_10; lean_object* x_11; 
 x_10 = lean_ctor_get(x_2, 0);
-x_11 = l_Lean_RBNode_findCore___at_Lean_Meta_ToHide_isMarked___spec__1(x_10, x_1);
+x_11 = l_Lean_RBNode_findCore___at_Lean_Compiler_LCNF_CompilerM_codeBind_go___spec__1(x_10, x_1);
 if (lean_obj_tag(x_11) == 0)
 {
 lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
@@ -7342,7 +7342,7 @@ lean_inc(x_14);
 x_15 = lean_ctor_get(x_13, 1);
 lean_inc(x_15);
 lean_dec(x_13);
-x_16 = l_Lean_Expr_isAnyType(x_14);
+x_16 = l_Lean_Expr_isErased(x_14);
 if (x_16 == 0)
 {
 lean_object* x_17; lean_object* x_18; 

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

@@ -14,6 +14,7 @@
 extern "C" {
 #endif
 size_t lean_usize_add(size_t, size_t);
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_FunDecl_dependsOn___boxed(lean_object*, lean_object*);
 uint8_t lean_usize_dec_eq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* lean_array_get_size(lean_object*);
@@ -21,10 +22,13 @@ LEAN_EXPORT lean_object* l_Array_anyMUnsafe_any___at___private_Lean_Compiler_LCN
 LEAN_EXPORT uint8_t l_Lean_Compiler_LCNF_Code_dependsOn(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_DependsOn_0__Lean_Compiler_LCNF_exprDepOn___boxed(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_DependsOn_0__Lean_Compiler_LCNF_LetDecl_depOn___boxed(lean_object*, lean_object*);
+LEAN_EXPORT uint8_t l_Lean_Compiler_LCNF_CodeDecl_dependsOn(lean_object*, lean_object*);
+LEAN_EXPORT uint8_t l_Lean_Compiler_LCNF_FunDecl_dependsOn(lean_object*, lean_object*);
 LEAN_EXPORT uint8_t l___private_Lean_Compiler_LCNF_DependsOn_0__Lean_Compiler_LCNF_depOn(lean_object*, lean_object*);
 LEAN_EXPORT uint8_t l___private_Lean_Compiler_LCNF_DependsOn_0__Lean_Compiler_LCNF_LetDecl_depOn(lean_object*, lean_object*);
 LEAN_EXPORT uint8_t l___private_Lean_Compiler_LCNF_DependsOn_0__Lean_Compiler_LCNF_exprDepOn(lean_object*, lean_object*);
 uint8_t l_Lean_Name_quickCmp(lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_CodeDecl_dependsOn___boxed(lean_object*, lean_object*);
 size_t lean_usize_of_nat(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Expr_hasAnyFVar_visit___at___private_Lean_Compiler_LCNF_DependsOn_0__Lean_Compiler_LCNF_exprDepOn___spec__1___boxed(lean_object*, lean_object*);
 LEAN_EXPORT uint8_t l___private_Lean_Compiler_LCNF_DependsOn_0__Lean_Compiler_LCNF_fvarDepOn(lean_object*, lean_object*);
@@ -678,6 +682,95 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
+LEAN_EXPORT uint8_t l_Lean_Compiler_LCNF_FunDecl_dependsOn(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; uint8_t x_4; 
+x_3 = lean_ctor_get(x_1, 3);
+lean_inc(x_3);
+x_4 = l_Lean_Expr_hasAnyFVar_visit___at___private_Lean_Compiler_LCNF_DependsOn_0__Lean_Compiler_LCNF_exprDepOn___spec__1(x_2, x_3);
+lean_dec(x_3);
+if (x_4 == 0)
+{
+lean_object* x_5; uint8_t x_6; 
+x_5 = lean_ctor_get(x_1, 4);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = l___private_Lean_Compiler_LCNF_DependsOn_0__Lean_Compiler_LCNF_depOn(x_5, x_2);
+return x_6;
+}
+else
+{
+uint8_t x_7; 
+lean_dec(x_2);
+lean_dec(x_1);
+x_7 = 1;
+return x_7;
+}
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_FunDecl_dependsOn___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = l_Lean_Compiler_LCNF_FunDecl_dependsOn(x_1, x_2);
+x_4 = lean_box(x_3);
+return x_4;
+}
+}
+LEAN_EXPORT uint8_t l_Lean_Compiler_LCNF_CodeDecl_dependsOn(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_3; uint8_t x_4; 
+x_3 = lean_ctor_get(x_1, 0);
+lean_inc(x_3);
+lean_dec(x_1);
+x_4 = l___private_Lean_Compiler_LCNF_DependsOn_0__Lean_Compiler_LCNF_LetDecl_depOn(x_3, x_2);
+lean_dec(x_2);
+lean_dec(x_3);
+return x_4;
+}
+else
+{
+lean_object* x_5; lean_object* x_6; uint8_t x_7; 
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_ctor_get(x_5, 3);
+lean_inc(x_6);
+x_7 = l_Lean_Expr_hasAnyFVar_visit___at___private_Lean_Compiler_LCNF_DependsOn_0__Lean_Compiler_LCNF_exprDepOn___spec__1(x_2, x_6);
+lean_dec(x_6);
+if (x_7 == 0)
+{
+lean_object* x_8; uint8_t x_9; 
+x_8 = lean_ctor_get(x_5, 4);
+lean_inc(x_8);
+lean_dec(x_5);
+x_9 = l___private_Lean_Compiler_LCNF_DependsOn_0__Lean_Compiler_LCNF_depOn(x_8, x_2);
+return x_9;
+}
+else
+{
+uint8_t x_10; 
+lean_dec(x_5);
+lean_dec(x_2);
+x_10 = 1;
+return x_10;
+}
+}
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_CodeDecl_dependsOn___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = l_Lean_Compiler_LCNF_CodeDecl_dependsOn(x_1, x_2);
+x_4 = lean_box(x_3);
+return x_4;
+}
+}
 LEAN_EXPORT uint8_t l_Lean_Compiler_LCNF_Code_dependsOn(lean_object* x_1, lean_object* x_2) {
 _start:
 {

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

@@ -14,7 +14,6 @@
 extern "C" {
 #endif
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__13;
-lean_object* l_Lean_Compiler_LCNF_ppDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__23;
 lean_object* l_Lean_KVMap_setBool(lean_object*, lean_object*, uint8_t);
 size_t lean_usize_add(size_t, size_t);
@@ -33,6 +32,7 @@ uint8_t lean_usize_dec_eq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PassManager_run___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2___closed__6;
+lean_object* l_Lean_Compiler_LCNF_CompilerM_run___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_LCNF_getPassManager___rarg(lean_object*, lean_object*);
 lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_PassManager_run___spec__4___closed__3;
@@ -49,6 +49,7 @@ LEAN_EXPORT lean_object* l_Lean_addTrace___at_Lean_Compiler_LCNF_PassManager_run
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PassManager_run(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_mkStr2(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_profileitM___at_Lean_Compiler_LCNF_main___spec__1___rarg___boxed(lean_object*, lean_object*, 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*);
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__8;
@@ -63,7 +64,6 @@ uint8_t lean_usize_dec_lt(size_t, size_t);
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__19;
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___lambda__2___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__6;
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_PassManager_run___spec__2___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrCore(lean_object*, uint8_t, lean_object*);
 uint8_t l_Lean_Option_get___at_Lean_getSanitizeNames___spec__1(lean_object*, lean_object*);
@@ -81,6 +81,7 @@ lean_object* l_Lean_Name_toString(lean_object*, uint8_t);
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__12;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_PassManager_run___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_LCNF_markRecDecls(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_profileitM___at_Lean_Compiler_LCNF_main___spec__1(lean_object*);
 lean_object* l_Nat_repr(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_mk_ref(lean_object*, lean_object*);
@@ -89,8 +90,8 @@ uint8_t lean_is_matcher(lean_object*, lean_object*);
 extern lean_object* l_Lean_Expr_instHashableExpr;
 uint8_t l_Lean_ConstantInfo_hasValue(lean_object*);
 lean_object* l_Lean_Meta_InfoCacheKey_instHashableInfoCacheKey___boxed(lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__4;
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_PassManager_run___spec__4___closed__4;
+LEAN_EXPORT lean_object* l_Lean_profileitM___at_Lean_Compiler_LCNF_main___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_PassManager_run___spec__4___closed__1;
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_PassManager_run___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Util_0__mkPanicMessageWithDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -101,16 +102,13 @@ lean_object* l_Lean_Compiler_LCNF_ppDecl_x27(lean_object*, lean_object*, lean_ob
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isTypeFormerType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 size_t lean_usize_of_nat(lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__1;
 lean_object* l_Lean_ConstantInfo_type(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_main___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_instBEqProd___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_LCNF_checkDeadLocalDecls(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__3;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___closed__3;
 lean_object* l_Lean_PersistentHashMap_mkEmptyEntriesArray(lean_object*, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__2;
 lean_object* l_Lean_PersistentArray_push___rarg(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_compile___closed__3;
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2___closed__12;
@@ -120,7 +118,6 @@ extern lean_object* l_Lean_Compiler_compiler_check;
 lean_object* l_List_redLength___rarg(lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__16;
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Compiler_LCNF_PassManager_run___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__5;
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Compiler_LCNF_PassManager_run___spec__1(size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 lean_object* l_Lean_Name_append(lean_object*, lean_object*);
@@ -134,21 +131,26 @@ LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___lambda__1___b
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__10;
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2___closed__11;
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__7;
+static lean_object* l_Lean_Compiler_LCNF_main___closed__1;
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_PassManager_run___spec__2___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_compile___closed__2;
-LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339_(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374_(lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__3;
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__15;
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__18;
 lean_object* l_List_toArrayAux___rarg(lean_object*, lean_object*);
+static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__1;
 LEAN_EXPORT lean_object* l_Lean_addTrace___at_Lean_Compiler_LCNF_PassManager_run___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_instHashableProd___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_profileitIOUnsafe___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___closed__4;
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2___closed__3;
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2___closed__4;
 lean_object* l_Lean_Compiler_LCNF_getDeclAt_x3f(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__4;
+static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__2;
 extern lean_object* l_Lean_Expr_instBEqExpr;
 lean_object* l_Lean_Compiler_LCNF_getDeclInfo_x3f(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_PassManager_run___spec__4(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -163,6 +165,7 @@ static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__14;
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2___closed__9;
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2___closed__2;
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_PassManager_run___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__6;
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isProp(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -175,8 +178,10 @@ static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__22;
 static lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2___closed__13;
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_PassManager_run___spec__5(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_LCNF_toDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__5;
 static lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode___closed__6;
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
+static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__3;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_shouldGenerateCode_isCompIrrelevant(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
@@ -1305,10 +1310,8 @@ lean_inc(x_32);
 lean_dec(x_16);
 lean_inc(x_7);
 lean_inc(x_6);
-lean_inc(x_5);
-lean_inc(x_4);
 lean_inc(x_2);
-x_33 = l_Lean_Compiler_LCNF_ppDecl(x_2, x_4, x_5, x_6, x_7, x_32);
+x_33 = l_Lean_Compiler_LCNF_ppDecl_x27(x_2, x_6, x_7, x_32);
 if (lean_obj_tag(x_33) == 0)
 {
 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; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; 
@@ -1540,10 +1543,8 @@ lean_inc(x_95);
 lean_dec(x_81);
 lean_inc(x_7);
 lean_inc(x_80);
-lean_inc(x_5);
-lean_inc(x_4);
 lean_inc(x_2);
-x_96 = l_Lean_Compiler_LCNF_ppDecl(x_2, x_4, x_5, x_80, x_7, x_95);
+x_96 = l_Lean_Compiler_LCNF_ppDecl_x27(x_2, x_80, x_7, x_95);
 if (lean_obj_tag(x_96) == 0)
 {
 lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; 
@@ -3791,6 +3792,23 @@ x_7 = l_Lean_Compiler_LCNF_showDecl(x_6, x_2, x_3, x_4, x_5);
 return x_7;
 }
 }
+LEAN_EXPORT lean_object* l_Lean_profileitM___at_Lean_Compiler_LCNF_main___spec__1___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) {
+_start:
+{
+lean_object* x_7; lean_object* x_8; 
+x_7 = lean_apply_2(x_3, x_4, x_5);
+x_8 = l_Lean_profileitIOUnsafe___rarg(x_1, x_2, x_7, x_6);
+return x_8;
+}
+}
+LEAN_EXPORT lean_object* l_Lean_profileitM___at_Lean_Compiler_LCNF_main___spec__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_profileitM___at_Lean_Compiler_LCNF_main___spec__1___rarg___boxed), 6, 0);
+return x_2;
+}
+}
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_main___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) {
 _start:
 {
@@ -3846,23 +3864,50 @@ return x_17;
 }
 }
 }
+static lean_object* _init_l_Lean_Compiler_LCNF_main___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string_from_bytes("compilation new", 15);
+return x_1;
+}
+}
 LEAN_EXPORT lean_object* lean_lcnf_compile_decls(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; uint8_t x_10; lean_object* x_11; 
-x_5 = l_List_redLength___rarg(x_1);
-x_6 = lean_mk_empty_array_with_capacity(x_5);
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+x_5 = lean_ctor_get(x_2, 2);
+lean_inc(x_5);
+x_6 = l_List_redLength___rarg(x_1);
+x_7 = lean_mk_empty_array_with_capacity(x_6);
+lean_dec(x_6);
+x_8 = l_List_toArrayAux___rarg(x_1, x_7);
+x_9 = lean_alloc_closure((void*)(l_Lean_Compiler_LCNF_main___lambda__1), 6, 1);
+lean_closure_set(x_9, 0, x_8);
+x_10 = l_Lean_Compiler_LCNF_compile___closed__3;
+x_11 = 0;
+x_12 = lean_box(x_11);
+x_13 = lean_alloc_closure((void*)(l_Lean_Compiler_LCNF_CompilerM_run___rarg___boxed), 6, 3);
+lean_closure_set(x_13, 0, x_9);
+lean_closure_set(x_13, 1, x_10);
+lean_closure_set(x_13, 2, x_12);
+x_14 = l_Lean_Compiler_LCNF_main___closed__1;
+x_15 = l_Lean_profileitM___at_Lean_Compiler_LCNF_main___spec__1___rarg(x_14, x_5, x_13, x_2, x_3, x_4);
 lean_dec(x_5);
-x_7 = l_List_toArrayAux___rarg(x_1, x_6);
-x_8 = lean_alloc_closure((void*)(l_Lean_Compiler_LCNF_main___lambda__1), 6, 1);
-lean_closure_set(x_8, 0, x_7);
-x_9 = l_Lean_Compiler_LCNF_compile___closed__3;
-x_10 = 0;
-x_11 = l_Lean_Compiler_LCNF_CompilerM_run___rarg(x_8, x_9, x_10, x_2, x_3, x_4);
-return x_11;
+return x_15;
 }
 }
-static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__1() {
+LEAN_EXPORT lean_object* l_Lean_profileitM___at_Lean_Compiler_LCNF_main___spec__1___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) {
+_start:
+{
+lean_object* x_7; 
+x_7 = l_Lean_profileitM___at_Lean_Compiler_LCNF_main___spec__1___rarg(x_1, x_2, x_3, x_4, x_5, x_6);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_7;
+}
+}
+static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -3870,17 +3915,17 @@ x_1 = lean_mk_string_from_bytes("init", 4);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__2() {
+static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2___closed__1;
-x_2 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__1;
+x_2 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__1;
 x_3 = l_Lean_Name_mkStr2(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__3() {
+static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -3888,17 +3933,17 @@ x_1 = lean_mk_string_from_bytes("test", 4);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__4() {
+static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__4() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2___closed__1;
-x_2 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__3;
+x_2 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__3;
 x_3 = l_Lean_Name_mkStr2(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__5() {
+static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__5() {
 _start:
 {
 lean_object* x_1; 
@@ -3906,21 +3951,21 @@ x_1 = lean_mk_string_from_bytes("jp", 2);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__6() {
+static lean_object* _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__6() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_checkpoint___spec__1___lambda__2___closed__1;
-x_2 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__5;
+x_2 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__5;
 x_3 = l_Lean_Name_mkStr2(x_1, x_2);
 return x_3;
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339_(lean_object* x_1) {
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; uint8_t x_3; lean_object* x_4; 
-x_2 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__2;
+x_2 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__2;
 x_3 = 1;
 x_4 = l_Lean_registerTraceClass(x_2, x_3, x_1);
 if (lean_obj_tag(x_4) == 0)
@@ -3929,7 +3974,7 @@ lean_object* x_5; lean_object* x_6; lean_object* x_7;
 x_5 = lean_ctor_get(x_4, 1);
 lean_inc(x_5);
 lean_dec(x_4);
-x_6 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__4;
+x_6 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__4;
 x_7 = l_Lean_registerTraceClass(x_6, x_3, x_5);
 if (lean_obj_tag(x_7) == 0)
 {
@@ -3945,7 +3990,7 @@ lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14;
 x_11 = lean_ctor_get(x_10, 1);
 lean_inc(x_11);
 lean_dec(x_10);
-x_12 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__6;
+x_12 = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__6;
 x_13 = 0;
 x_14 = l_Lean_registerTraceClass(x_12, x_13, x_11);
 return x_14;
@@ -4173,19 +4218,21 @@ l_Lean_Compiler_LCNF_showDecl___closed__1 = _init_l_Lean_Compiler_LCNF_showDecl_
 lean_mark_persistent(l_Lean_Compiler_LCNF_showDecl___closed__1);
 l_Lean_Compiler_LCNF_showDecl___closed__2 = _init_l_Lean_Compiler_LCNF_showDecl___closed__2();
 lean_mark_persistent(l_Lean_Compiler_LCNF_showDecl___closed__2);
-l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__1 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__1();
-lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__1);
-l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__2 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__2();
-lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__2);
-l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__3 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__3();
-lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__3);
-l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__4 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__4();
-lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__4);
-l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__5 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__5();
-lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__5);
-l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__6 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__6();
-lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339____closed__6);
-res = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1339_(lean_io_mk_world());
+l_Lean_Compiler_LCNF_main___closed__1 = _init_l_Lean_Compiler_LCNF_main___closed__1();
+lean_mark_persistent(l_Lean_Compiler_LCNF_main___closed__1);
+l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__1 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__1();
+lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__1);
+l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__2 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__2();
+lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__2);
+l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__3 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__3();
+lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__3);
+l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__4 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__4();
+lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__4);
+l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__5 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__5();
+lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__5);
+l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__6 = _init_l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__6();
+lean_mark_persistent(l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374____closed__6);
+res = l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_Main___hyg_1374_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));

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

@@ -0,0 +1,682 @@
+// Lean compiler output
+// Module: Lean.Compiler.LCNF.MonoTypes
+// Imports: Init Lean.Compiler.LCNF.InferType
+#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* lean_array_set(lean_object*, lean_object*, lean_object*);
+size_t lean_usize_add(size_t, size_t);
+lean_object* lean_mk_empty_array_with_capacity(lean_object*);
+lean_object* lean_array_uget(lean_object*, size_t);
+uint8_t l_Lean_Expr_isErased(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_toMonoType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* lean_expr_instantiate1(lean_object*, lean_object*);
+lean_object* lean_array_get_size(lean_object*);
+static lean_object* l_Lean_Compiler_LCNF_toMonoType___closed__2;
+uint8_t lean_usize_dec_lt(size_t, size_t);
+extern lean_object* l_Lean_levelZero;
+extern lean_object* l_Lean_Compiler_LCNF_erasedExpr;
+static lean_object* l_Lean_Compiler_LCNF_toMonoType___closed__1;
+lean_object* lean_nat_sub(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_headBeta(lean_object*);
+lean_object* l_Lean_Compiler_LCNF_inferType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_toMonoType_visitApp___spec__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_Expr_0__Lean_Expr_getAppNumArgsAux(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_sort___override(lean_object*);
+lean_object* l_Lean_mkArrow(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+size_t lean_usize_of_nat(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_toMonoType_visitApp___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Expr_const___override(lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_toMonoType_visitApp(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Expr_app___override(lean_object*, lean_object*);
+lean_object* lean_mk_array(lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_toMonoType_visitApp___spec__1(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t l_Lean_Compiler_LCNF_isTypeFormerType(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Expr_withAppAux___at_Lean_Compiler_LCNF_toMonoType___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_toMonoType_visitApp___spec__1(lean_object* x_1, size_t x_2, size_t 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:
+{
+uint8_t x_10; 
+x_10 = lean_usize_dec_lt(x_3, x_2);
+if (x_10 == 0)
+{
+lean_object* x_11; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+x_11 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_11, 0, x_4);
+lean_ctor_set(x_11, 1, x_9);
+return x_11;
+}
+else
+{
+lean_object* x_12; lean_object* x_13; lean_object* x_31; uint8_t x_32; 
+x_12 = lean_array_uget(x_1, x_3);
+x_31 = l_Lean_Expr_headBeta(x_12);
+x_32 = l_Lean_Expr_isErased(x_31);
+if (x_32 == 0)
+{
+lean_object* x_33; 
+lean_inc(x_8);
+lean_inc(x_7);
+lean_inc(x_6);
+lean_inc(x_5);
+lean_inc(x_31);
+x_33 = l_Lean_Compiler_LCNF_inferType(x_31, x_5, x_6, x_7, x_8, x_9);
+if (lean_obj_tag(x_33) == 0)
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_43; lean_object* x_59; uint8_t x_60; 
+x_34 = lean_ctor_get(x_33, 0);
+lean_inc(x_34);
+x_35 = lean_ctor_get(x_33, 1);
+lean_inc(x_35);
+if (lean_is_exclusive(x_33)) {
+ lean_ctor_release(x_33, 0);
+ lean_ctor_release(x_33, 1);
+ x_36 = x_33;
+} else {
+ lean_dec_ref(x_33);
+ x_36 = lean_box(0);
+}
+x_59 = l_Lean_Expr_headBeta(x_34);
+x_60 = l_Lean_Expr_isErased(x_59);
+if (x_60 == 0)
+{
+if (lean_obj_tag(x_59) == 3)
+{
+lean_object* x_61; 
+lean_dec(x_59);
+lean_dec(x_36);
+x_61 = lean_box(0);
+x_43 = x_61;
+goto block_58;
+}
+else
+{
+lean_object* x_62; 
+lean_dec(x_59);
+lean_dec(x_31);
+x_62 = lean_box(0);
+x_37 = x_62;
+goto block_42;
+}
+}
+else
+{
+lean_object* x_63; 
+lean_dec(x_59);
+lean_dec(x_36);
+x_63 = lean_box(0);
+x_43 = x_63;
+goto block_58;
+}
+block_42:
+{
+lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
+lean_dec(x_37);
+x_38 = l_Lean_Compiler_LCNF_erasedExpr;
+x_39 = l_Lean_Expr_app___override(x_4, x_38);
+x_40 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_40, 0, x_39);
+if (lean_is_scalar(x_36)) {
+ x_41 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_41 = x_36;
+}
+lean_ctor_set(x_41, 0, x_40);
+lean_ctor_set(x_41, 1, x_35);
+x_13 = x_41;
+goto block_30;
+}
+block_58:
+{
+lean_object* x_44; 
+lean_dec(x_43);
+lean_inc(x_8);
+lean_inc(x_7);
+lean_inc(x_6);
+lean_inc(x_5);
+x_44 = l_Lean_Compiler_LCNF_toMonoType(x_31, x_5, x_6, x_7, x_8, x_35);
+if (lean_obj_tag(x_44) == 0)
+{
+uint8_t x_45; 
+x_45 = !lean_is_exclusive(x_44);
+if (x_45 == 0)
+{
+lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+x_46 = lean_ctor_get(x_44, 0);
+x_47 = l_Lean_Expr_app___override(x_4, x_46);
+x_48 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_48, 0, x_47);
+lean_ctor_set(x_44, 0, x_48);
+x_13 = x_44;
+goto block_30;
+}
+else
+{
+lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+x_49 = lean_ctor_get(x_44, 0);
+x_50 = lean_ctor_get(x_44, 1);
+lean_inc(x_50);
+lean_inc(x_49);
+lean_dec(x_44);
+x_51 = l_Lean_Expr_app___override(x_4, x_49);
+x_52 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_52, 0, x_51);
+x_53 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_53, 0, x_52);
+lean_ctor_set(x_53, 1, x_50);
+x_13 = x_53;
+goto block_30;
+}
+}
+else
+{
+uint8_t x_54; 
+lean_dec(x_4);
+x_54 = !lean_is_exclusive(x_44);
+if (x_54 == 0)
+{
+x_13 = x_44;
+goto block_30;
+}
+else
+{
+lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+x_55 = lean_ctor_get(x_44, 0);
+x_56 = lean_ctor_get(x_44, 1);
+lean_inc(x_56);
+lean_inc(x_55);
+lean_dec(x_44);
+x_57 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_57, 0, x_55);
+lean_ctor_set(x_57, 1, x_56);
+x_13 = x_57;
+goto block_30;
+}
+}
+}
+}
+else
+{
+uint8_t x_64; 
+lean_dec(x_31);
+lean_dec(x_4);
+x_64 = !lean_is_exclusive(x_33);
+if (x_64 == 0)
+{
+x_13 = x_33;
+goto block_30;
+}
+else
+{
+lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+x_65 = lean_ctor_get(x_33, 0);
+x_66 = lean_ctor_get(x_33, 1);
+lean_inc(x_66);
+lean_inc(x_65);
+lean_dec(x_33);
+x_67 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_67, 0, x_65);
+lean_ctor_set(x_67, 1, x_66);
+x_13 = x_67;
+goto block_30;
+}
+}
+}
+else
+{
+lean_object* x_68; lean_object* x_69; lean_object* x_70; 
+x_68 = l_Lean_Expr_app___override(x_4, x_31);
+x_69 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_69, 0, x_68);
+x_70 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_70, 0, x_69);
+lean_ctor_set(x_70, 1, x_9);
+x_13 = x_70;
+goto block_30;
+}
+block_30:
+{
+if (lean_obj_tag(x_13) == 0)
+{
+lean_object* x_14; 
+x_14 = lean_ctor_get(x_13, 0);
+lean_inc(x_14);
+if (lean_obj_tag(x_14) == 0)
+{
+uint8_t x_15; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+x_15 = !lean_is_exclusive(x_13);
+if (x_15 == 0)
+{
+lean_object* x_16; lean_object* x_17; 
+x_16 = lean_ctor_get(x_13, 0);
+lean_dec(x_16);
+x_17 = lean_ctor_get(x_14, 0);
+lean_inc(x_17);
+lean_dec(x_14);
+lean_ctor_set(x_13, 0, x_17);
+return x_13;
+}
+else
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = lean_ctor_get(x_13, 1);
+lean_inc(x_18);
+lean_dec(x_13);
+x_19 = lean_ctor_get(x_14, 0);
+lean_inc(x_19);
+lean_dec(x_14);
+x_20 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_20, 0, x_19);
+lean_ctor_set(x_20, 1, x_18);
+return x_20;
+}
+}
+else
+{
+lean_object* x_21; lean_object* x_22; size_t x_23; size_t x_24; 
+x_21 = lean_ctor_get(x_13, 1);
+lean_inc(x_21);
+lean_dec(x_13);
+x_22 = lean_ctor_get(x_14, 0);
+lean_inc(x_22);
+lean_dec(x_14);
+x_23 = 1;
+x_24 = lean_usize_add(x_3, x_23);
+x_3 = x_24;
+x_4 = x_22;
+x_9 = x_21;
+goto _start;
+}
+}
+else
+{
+uint8_t x_26; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+x_26 = !lean_is_exclusive(x_13);
+if (x_26 == 0)
+{
+return x_13;
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+x_27 = lean_ctor_get(x_13, 0);
+x_28 = lean_ctor_get(x_13, 1);
+lean_inc(x_28);
+lean_inc(x_27);
+lean_dec(x_13);
+x_29 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_29, 0, x_27);
+lean_ctor_set(x_29, 1, x_28);
+return x_29;
+}
+}
+}
+}
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_toMonoType_visitApp(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:
+{
+if (lean_obj_tag(x_1) == 4)
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; size_t x_12; size_t x_13; lean_object* x_14; 
+x_8 = lean_ctor_get(x_1, 0);
+lean_inc(x_8);
+lean_dec(x_1);
+x_9 = lean_box(0);
+x_10 = l_Lean_Expr_const___override(x_8, x_9);
+x_11 = lean_array_get_size(x_2);
+x_12 = lean_usize_of_nat(x_11);
+lean_dec(x_11);
+x_13 = 0;
+x_14 = l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_toMonoType_visitApp___spec__1(x_2, x_12, x_13, x_10, x_3, x_4, x_5, x_6, x_7);
+if (lean_obj_tag(x_14) == 0)
+{
+uint8_t x_15; 
+x_15 = !lean_is_exclusive(x_14);
+if (x_15 == 0)
+{
+return x_14;
+}
+else
+{
+lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+x_16 = lean_ctor_get(x_14, 0);
+x_17 = lean_ctor_get(x_14, 1);
+lean_inc(x_17);
+lean_inc(x_16);
+lean_dec(x_14);
+x_18 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_18, 0, x_16);
+lean_ctor_set(x_18, 1, x_17);
+return x_18;
+}
+}
+else
+{
+uint8_t x_19; 
+x_19 = !lean_is_exclusive(x_14);
+if (x_19 == 0)
+{
+return x_14;
+}
+else
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_20 = lean_ctor_get(x_14, 0);
+x_21 = lean_ctor_get(x_14, 1);
+lean_inc(x_21);
+lean_inc(x_20);
+lean_dec(x_14);
+x_22 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_21);
+return x_22;
+}
+}
+}
+else
+{
+lean_object* x_23; lean_object* x_24; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+x_23 = l_Lean_Compiler_LCNF_erasedExpr;
+x_24 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_24, 0, x_23);
+lean_ctor_set(x_24, 1, x_7);
+return x_24;
+}
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Expr_withAppAux___at_Lean_Compiler_LCNF_toMonoType___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) {
+_start:
+{
+if (lean_obj_tag(x_1) == 5)
+{
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_array_set(x_2, x_3, x_10);
+x_12 = lean_unsigned_to_nat(1u);
+x_13 = lean_nat_sub(x_3, x_12);
+lean_dec(x_3);
+x_1 = x_9;
+x_2 = x_11;
+x_3 = x_13;
+goto _start;
+}
+else
+{
+lean_object* x_15; 
+lean_dec(x_3);
+x_15 = l_Lean_Compiler_LCNF_toMonoType_visitApp(x_1, x_2, x_4, x_5, x_6, x_7, x_8);
+lean_dec(x_2);
+return x_15;
+}
+}
+}
+static lean_object* _init_l_Lean_Compiler_LCNF_toMonoType___closed__1() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = lean_unsigned_to_nat(0u);
+x_2 = lean_mk_empty_array_with_capacity(x_1);
+return x_2;
+}
+}
+static lean_object* _init_l_Lean_Compiler_LCNF_toMonoType___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_levelZero;
+x_2 = l_Lean_Expr_sort___override(x_1);
+return x_2;
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_toMonoType(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+lean_object* x_7; uint8_t x_8; 
+x_7 = l_Lean_Expr_headBeta(x_1);
+x_8 = l_Lean_Expr_isErased(x_7);
+if (x_8 == 0)
+{
+uint8_t x_9; 
+lean_inc(x_7);
+x_9 = l_Lean_Compiler_LCNF_isTypeFormerType(x_7);
+if (x_9 == 0)
+{
+switch (lean_obj_tag(x_7)) {
+case 4:
+{
+lean_object* x_10; lean_object* x_11; 
+x_10 = l_Lean_Compiler_LCNF_toMonoType___closed__1;
+x_11 = l_Lean_Compiler_LCNF_toMonoType_visitApp(x_7, x_10, x_2, x_3, x_4, x_5, x_6);
+return x_11;
+}
+case 5:
+{
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+x_12 = lean_unsigned_to_nat(0u);
+x_13 = l___private_Lean_Expr_0__Lean_Expr_getAppNumArgsAux(x_7, x_12);
+x_14 = l_Lean_Compiler_LCNF_toMonoType___closed__2;
+lean_inc(x_13);
+x_15 = lean_mk_array(x_13, x_14);
+x_16 = lean_unsigned_to_nat(1u);
+x_17 = lean_nat_sub(x_13, x_16);
+lean_dec(x_13);
+x_18 = l_Lean_Expr_withAppAux___at_Lean_Compiler_LCNF_toMonoType___spec__1(x_7, x_15, x_17, x_2, x_3, x_4, x_5, x_6);
+return x_18;
+}
+case 7:
+{
+lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_19 = lean_ctor_get(x_7, 1);
+lean_inc(x_19);
+x_20 = lean_ctor_get(x_7, 2);
+lean_inc(x_20);
+lean_dec(x_7);
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+lean_inc(x_2);
+x_21 = l_Lean_Compiler_LCNF_toMonoType(x_19, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_21) == 0)
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+x_22 = lean_ctor_get(x_21, 0);
+lean_inc(x_22);
+x_23 = lean_ctor_get(x_21, 1);
+lean_inc(x_23);
+lean_dec(x_21);
+x_24 = l_Lean_Compiler_LCNF_erasedExpr;
+x_25 = lean_expr_instantiate1(x_20, x_24);
+lean_dec(x_20);
+lean_inc(x_5);
+lean_inc(x_4);
+x_26 = l_Lean_Compiler_LCNF_toMonoType(x_25, x_2, x_3, x_4, x_5, x_23);
+if (lean_obj_tag(x_26) == 0)
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+x_27 = lean_ctor_get(x_26, 0);
+lean_inc(x_27);
+x_28 = lean_ctor_get(x_26, 1);
+lean_inc(x_28);
+lean_dec(x_26);
+x_29 = l_Lean_mkArrow(x_22, x_27, x_4, x_5, x_28);
+lean_dec(x_5);
+lean_dec(x_4);
+return x_29;
+}
+else
+{
+uint8_t x_30; 
+lean_dec(x_22);
+lean_dec(x_5);
+lean_dec(x_4);
+x_30 = !lean_is_exclusive(x_26);
+if (x_30 == 0)
+{
+return x_26;
+}
+else
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_31 = lean_ctor_get(x_26, 0);
+x_32 = lean_ctor_get(x_26, 1);
+lean_inc(x_32);
+lean_inc(x_31);
+lean_dec(x_26);
+x_33 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_32);
+return x_33;
+}
+}
+}
+else
+{
+uint8_t x_34; 
+lean_dec(x_20);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_34 = !lean_is_exclusive(x_21);
+if (x_34 == 0)
+{
+return x_21;
+}
+else
+{
+lean_object* x_35; lean_object* x_36; lean_object* x_37; 
+x_35 = lean_ctor_get(x_21, 0);
+x_36 = lean_ctor_get(x_21, 1);
+lean_inc(x_36);
+lean_inc(x_35);
+lean_dec(x_21);
+x_37 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_37, 0, x_35);
+lean_ctor_set(x_37, 1, x_36);
+return x_37;
+}
+}
+}
+default: 
+{
+lean_object* x_38; lean_object* x_39; 
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_38 = l_Lean_Compiler_LCNF_erasedExpr;
+x_39 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_39, 0, x_38);
+lean_ctor_set(x_39, 1, x_6);
+return x_39;
+}
+}
+}
+else
+{
+lean_object* x_40; lean_object* x_41; 
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_40 = l_Lean_Compiler_LCNF_erasedExpr;
+x_41 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_41, 0, x_40);
+lean_ctor_set(x_41, 1, x_6);
+return x_41;
+}
+}
+else
+{
+lean_object* x_42; lean_object* x_43; 
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_42 = l_Lean_Compiler_LCNF_erasedExpr;
+x_43 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_43, 0, x_42);
+lean_ctor_set(x_43, 1, x_6);
+return x_43;
+}
+}
+}
+LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_toMonoType_visitApp___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) {
+_start:
+{
+size_t x_10; size_t x_11; lean_object* x_12; 
+x_10 = lean_unbox_usize(x_2);
+lean_dec(x_2);
+x_11 = lean_unbox_usize(x_3);
+lean_dec(x_3);
+x_12 = l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_toMonoType_visitApp___spec__1(x_1, x_10, x_11, x_4, x_5, x_6, x_7, x_8, x_9);
+lean_dec(x_1);
+return x_12;
+}
+}
+LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_toMonoType_visitApp___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_Compiler_LCNF_toMonoType_visitApp(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
+lean_dec(x_2);
+return x_8;
+}
+}
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_Lean_Compiler_LCNF_InferType(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_Lean_Compiler_LCNF_MonoTypes(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Lean_Compiler_LCNF_InferType(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+l_Lean_Compiler_LCNF_toMonoType___closed__1 = _init_l_Lean_Compiler_LCNF_toMonoType___closed__1();
+lean_mark_persistent(l_Lean_Compiler_LCNF_toMonoType___closed__1);
+l_Lean_Compiler_LCNF_toMonoType___closed__2 = _init_l_Lean_Compiler_LCNF_toMonoType___closed__2();
+lean_mark_persistent(l_Lean_Compiler_LCNF_toMonoType___closed__2);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

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

@@ -26,10 +26,8 @@ uint8_t lean_usize_dec_eq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
 static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____closed__5;
 uint8_t l_Lean_Name_quickLt(lean_object*, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_normalizeFVarIds___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_getBaseDeclCore_x3f(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_getBaseDecl_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_normalizeFVarIds___closed__2;
 LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Compiler_LCNF_forEachDecl___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 size_t lean_usize_sub(size_t, size_t);
 LEAN_EXPORT lean_object* l_Array_qsort_sort___at___private_Lean_Compiler_LCNF_PhaseExt_0__Lean_Compiler_LCNF_sortDecls___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -42,7 +40,6 @@ LEAN_EXPORT lean_object* l_Lean_PersistentHashMap_foldlMAux___at_Lean_Compiler_L
 extern lean_object* l_Lean_instHashableName;
 uint8_t lean_name_eq(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_PersistentHashMap_forM___at_Lean_Compiler_LCNF_forEachDecl___spec__3___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_normalizeFVarIds___closed__4;
 static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____closed__7;
 static lean_object* l_Lean_Compiler_LCNF_forEachModuleDecl___closed__2;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_getDeclAt_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -55,7 +52,6 @@ lean_object* l_Array_qpartition_loop___rarg(lean_object*, lean_object*, lean_obj
 size_t lean_usize_shift_right(size_t, size_t);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_forEachDecl___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static size_t l_Lean_PersistentHashMap_insertAux___at_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____spec__2___closed__1;
-static lean_object* l_Lean_Compiler_LCNF_saveBase___closed__2;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_forEachDecl___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_PersistentHashMap_foldlMAux_traverse___at_Lean_Compiler_LCNF_forEachDecl___spec__7(lean_object*, lean_object*, lean_object*);
 uint8_t lean_usize_dec_lt(size_t, size_t);
@@ -69,12 +65,10 @@ LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_PhaseExt_0__Lean_Compile
 size_t lean_uint64_to_usize(uint64_t);
 static lean_object* l_Lean_Compiler_LCNF_Decl_saveBase___closed__1;
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_forEachDecl___spec__6(lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_normalizeFVarIds___closed__3;
 lean_object* l_Lean_PersistentHashMap_getCollisionNodeSize___rarg(lean_object*);
 uint64_t l_Lean_Name_hash___override(lean_object*);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_forEachModuleDecl___spec__1(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
-lean_object* l_Lean_mkHashMapImp___rarg(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_PersistentHashMap_insert___at_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____spec__1(lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_forEachMainModuleDecl(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -96,7 +90,6 @@ LEAN_EXPORT lean_object* l_Array_qsort_sort___at___private_Lean_Compiler_LCNF_Ph
 static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____closed__4;
 static lean_object* l_Lean_Compiler_LCNF_forEachModuleDecl___closed__4;
 size_t lean_usize_shift_left(size_t, size_t);
-lean_object* l_Lean_Compiler_LCNF_Pass_mkPerDeclaration(lean_object*, lean_object*, uint8_t, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____closed__1;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____lambda__5(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_getDecl_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -107,7 +100,6 @@ LEAN_EXPORT lean_object* l_Lean_PersistentHashMap_foldlMAux___at_Lean_Compiler_L
 size_t lean_usize_mul(size_t, size_t);
 static lean_object* l_Lean_Compiler_LCNF_getBaseDeclCore_x3f___closed__2;
 lean_object* l_Lean_Expr_bvar___override(lean_object*);
-LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_saveBase___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_addDecl___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 size_t lean_usize_of_nat(lean_object*);
 static lean_object* l_Lean_PersistentHashMap_insertAux___at_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____spec__2___closed__3;
@@ -115,7 +107,6 @@ LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_forEachDecl(lean_object*, lean_obj
 lean_object* l_Lean_PersistentEnvExtension_addEntry___rarg(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_getDecl_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 size_t lean_usize_land(size_t, size_t);
-LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_normalizeFVarIds(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PersistentHashMap_mkEmptyEntriesArray(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____closed__2;
@@ -136,17 +127,12 @@ static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseE
 LEAN_EXPORT lean_object* l_Lean_PersistentHashMap_foldlMAux_traverse___at_Lean_Compiler_LCNF_forEachDecl___spec__7___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Environment_addExtraName(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_binSearchAux___at___private_Lean_Compiler_LCNF_PhaseExt_0__Lean_Compiler_LCNF_findAtSorted_x3f___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Compiler_LCNF_CompilerM_run___rarg(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____lambda__3___boxed(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____lambda__4___closed__1;
-static lean_object* l_Lean_Compiler_LCNF_saveBase___closed__1;
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_Environment_getModuleIdxFor_x3f(lean_object*, lean_object*);
 lean_object* l_Lean_PersistentHashMap_mkEmptyEntries(lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_saveBase;
-static lean_object* l_Lean_Compiler_LCNF_saveBase___closed__3;
-LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_saveBase___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Compiler_LCNF_instInhabitedDecl;
 lean_object* l_Lean_Environment_allImportedModuleNames(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_saveBaseDeclCore(lean_object*, lean_object*);
@@ -157,8 +143,6 @@ LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_PhaseExt_0__Lean_Compile
 static lean_object* l_Lean_Compiler_LCNF_forEachModuleDecl___closed__3;
 LEAN_EXPORT lean_object* l_Lean_PersistentHashMap_insertAux___at_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_PersistentHashMap_findAtAux___at_Lean_Compiler_LCNF_getBaseDeclCore_x3f___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_normalizeFVarIds___closed__5;
-static lean_object* l_Lean_Compiler_LCNF_normalizeFVarIds___closed__6;
 static lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____closed__6;
 static lean_object* l___private_Lean_Compiler_LCNF_PhaseExt_0__Lean_Compiler_LCNF_findAtSorted_x3f___closed__3;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_getBaseDecl_x3f(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -167,10 +151,8 @@ lean_object* lean_usize_to_nat(size_t);
 lean_object* l_Lean_Compiler_LCNF_getPhase(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_forEachModuleDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_EStateM_pure___rarg(lean_object*, lean_object*);
-lean_object* l_Lean_Compiler_LCNF_Decl_internalize___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PersistentHashMap_mkCollisionNode___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-static lean_object* l_Lean_Compiler_LCNF_saveBase___closed__4;
 lean_object* l_Lean_PersistentHashMap_instInhabitedPersistentHashMap___rarg(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_initFn____x40_Lean_Compiler_LCNF_PhaseExt___hyg_50____lambda__4(lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
@@ -1842,599 +1824,6 @@ lean_dec(x_2);
 return x_7;
 }
 }
-static lean_object* _init_l_Lean_Compiler_LCNF_normalizeFVarIds___closed__1() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string_from_bytes("_uniq", 5);
-return x_1;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_normalizeFVarIds___closed__2() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = lean_box(0);
-x_2 = l_Lean_Compiler_LCNF_normalizeFVarIds___closed__1;
-x_3 = l_Lean_Name_str___override(x_1, x_2);
-return x_3;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_normalizeFVarIds___closed__3() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Compiler_LCNF_normalizeFVarIds___closed__2;
-x_2 = lean_unsigned_to_nat(1u);
-x_3 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_3, 0, x_1);
-lean_ctor_set(x_3, 1, x_2);
-return x_3;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_normalizeFVarIds___closed__4() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; 
-x_1 = lean_unsigned_to_nat(0u);
-x_2 = l_Lean_mkHashMapImp___rarg(x_1);
-return x_2;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_normalizeFVarIds___closed__5() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Compiler_LCNF_normalizeFVarIds___closed__4;
-x_2 = lean_alloc_ctor(0, 3, 0);
-lean_ctor_set(x_2, 0, x_1);
-lean_ctor_set(x_2, 1, x_1);
-lean_ctor_set(x_2, 2, x_1);
-return x_2;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_normalizeFVarIds___closed__6() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Compiler_LCNF_normalizeFVarIds___closed__5;
-x_2 = lean_unsigned_to_nat(1u);
-x_3 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_3, 0, x_1);
-lean_ctor_set(x_3, 1, x_2);
-return x_3;
-}
-}
-LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_normalizeFVarIds(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; uint8_t x_12; 
-x_5 = lean_st_ref_get(x_3, x_4);
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-x_7 = lean_ctor_get(x_5, 1);
-lean_inc(x_7);
-lean_dec(x_5);
-x_8 = lean_ctor_get(x_6, 2);
-lean_inc(x_8);
-lean_dec(x_6);
-x_9 = lean_st_ref_take(x_3, x_7);
-x_10 = lean_ctor_get(x_9, 0);
-lean_inc(x_10);
-x_11 = lean_ctor_get(x_9, 1);
-lean_inc(x_11);
-lean_dec(x_9);
-x_12 = !lean_is_exclusive(x_10);
-if (x_12 == 0)
-{
-lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; 
-x_13 = lean_ctor_get(x_10, 2);
-lean_dec(x_13);
-x_14 = l_Lean_Compiler_LCNF_normalizeFVarIds___closed__3;
-lean_ctor_set(x_10, 2, x_14);
-x_15 = lean_st_ref_set(x_3, x_10, x_11);
-x_16 = lean_ctor_get(x_15, 1);
-lean_inc(x_16);
-lean_dec(x_15);
-x_17 = l_Lean_Compiler_LCNF_normalizeFVarIds___closed__4;
-x_18 = lean_alloc_closure((void*)(l_Lean_Compiler_LCNF_Decl_internalize___boxed), 7, 2);
-lean_closure_set(x_18, 0, x_1);
-lean_closure_set(x_18, 1, x_17);
-x_19 = l_Lean_Compiler_LCNF_normalizeFVarIds___closed__6;
-x_20 = 0;
-lean_inc(x_3);
-x_21 = l_Lean_Compiler_LCNF_CompilerM_run___rarg(x_18, x_19, x_20, x_2, x_3, x_16);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; 
-x_22 = lean_ctor_get(x_21, 0);
-lean_inc(x_22);
-x_23 = lean_ctor_get(x_21, 1);
-lean_inc(x_23);
-lean_dec(x_21);
-x_24 = lean_st_ref_take(x_3, x_23);
-x_25 = lean_ctor_get(x_24, 0);
-lean_inc(x_25);
-x_26 = lean_ctor_get(x_24, 1);
-lean_inc(x_26);
-lean_dec(x_24);
-x_27 = !lean_is_exclusive(x_25);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; uint8_t x_30; 
-x_28 = lean_ctor_get(x_25, 2);
-lean_dec(x_28);
-lean_ctor_set(x_25, 2, x_8);
-x_29 = lean_st_ref_set(x_3, x_25, x_26);
-lean_dec(x_3);
-x_30 = !lean_is_exclusive(x_29);
-if (x_30 == 0)
-{
-lean_object* x_31; 
-x_31 = lean_ctor_get(x_29, 0);
-lean_dec(x_31);
-lean_ctor_set(x_29, 0, x_22);
-return x_29;
-}
-else
-{
-lean_object* x_32; lean_object* x_33; 
-x_32 = lean_ctor_get(x_29, 1);
-lean_inc(x_32);
-lean_dec(x_29);
-x_33 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_33, 0, x_22);
-lean_ctor_set(x_33, 1, x_32);
-return x_33;
-}
-}
-else
-{
-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; 
-x_34 = lean_ctor_get(x_25, 0);
-x_35 = lean_ctor_get(x_25, 1);
-x_36 = lean_ctor_get(x_25, 3);
-x_37 = lean_ctor_get(x_25, 4);
-x_38 = lean_ctor_get(x_25, 5);
-x_39 = lean_ctor_get(x_25, 6);
-lean_inc(x_39);
-lean_inc(x_38);
-lean_inc(x_37);
-lean_inc(x_36);
-lean_inc(x_35);
-lean_inc(x_34);
-lean_dec(x_25);
-x_40 = lean_alloc_ctor(0, 7, 0);
-lean_ctor_set(x_40, 0, x_34);
-lean_ctor_set(x_40, 1, x_35);
-lean_ctor_set(x_40, 2, x_8);
-lean_ctor_set(x_40, 3, x_36);
-lean_ctor_set(x_40, 4, x_37);
-lean_ctor_set(x_40, 5, x_38);
-lean_ctor_set(x_40, 6, x_39);
-x_41 = lean_st_ref_set(x_3, x_40, x_26);
-lean_dec(x_3);
-x_42 = lean_ctor_get(x_41, 1);
-lean_inc(x_42);
-if (lean_is_exclusive(x_41)) {
- lean_ctor_release(x_41, 0);
- lean_ctor_release(x_41, 1);
- x_43 = x_41;
-} else {
- lean_dec_ref(x_41);
- x_43 = lean_box(0);
-}
-if (lean_is_scalar(x_43)) {
- x_44 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_44 = x_43;
-}
-lean_ctor_set(x_44, 0, x_22);
-lean_ctor_set(x_44, 1, x_42);
-return x_44;
-}
-}
-else
-{
-lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; 
-x_45 = lean_ctor_get(x_21, 0);
-lean_inc(x_45);
-x_46 = lean_ctor_get(x_21, 1);
-lean_inc(x_46);
-lean_dec(x_21);
-x_47 = lean_st_ref_take(x_3, x_46);
-x_48 = lean_ctor_get(x_47, 0);
-lean_inc(x_48);
-x_49 = lean_ctor_get(x_47, 1);
-lean_inc(x_49);
-lean_dec(x_47);
-x_50 = !lean_is_exclusive(x_48);
-if (x_50 == 0)
-{
-lean_object* x_51; lean_object* x_52; uint8_t x_53; 
-x_51 = lean_ctor_get(x_48, 2);
-lean_dec(x_51);
-lean_ctor_set(x_48, 2, x_8);
-x_52 = lean_st_ref_set(x_3, x_48, x_49);
-lean_dec(x_3);
-x_53 = !lean_is_exclusive(x_52);
-if (x_53 == 0)
-{
-lean_object* x_54; 
-x_54 = lean_ctor_get(x_52, 0);
-lean_dec(x_54);
-lean_ctor_set_tag(x_52, 1);
-lean_ctor_set(x_52, 0, x_45);
-return x_52;
-}
-else
-{
-lean_object* x_55; lean_object* x_56; 
-x_55 = lean_ctor_get(x_52, 1);
-lean_inc(x_55);
-lean_dec(x_52);
-x_56 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_56, 0, x_45);
-lean_ctor_set(x_56, 1, x_55);
-return x_56;
-}
-}
-else
-{
-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; lean_object* x_65; lean_object* x_66; lean_object* x_67; 
-x_57 = lean_ctor_get(x_48, 0);
-x_58 = lean_ctor_get(x_48, 1);
-x_59 = lean_ctor_get(x_48, 3);
-x_60 = lean_ctor_get(x_48, 4);
-x_61 = lean_ctor_get(x_48, 5);
-x_62 = lean_ctor_get(x_48, 6);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_inc(x_60);
-lean_inc(x_59);
-lean_inc(x_58);
-lean_inc(x_57);
-lean_dec(x_48);
-x_63 = lean_alloc_ctor(0, 7, 0);
-lean_ctor_set(x_63, 0, x_57);
-lean_ctor_set(x_63, 1, x_58);
-lean_ctor_set(x_63, 2, x_8);
-lean_ctor_set(x_63, 3, x_59);
-lean_ctor_set(x_63, 4, x_60);
-lean_ctor_set(x_63, 5, x_61);
-lean_ctor_set(x_63, 6, x_62);
-x_64 = lean_st_ref_set(x_3, x_63, x_49);
-lean_dec(x_3);
-x_65 = lean_ctor_get(x_64, 1);
-lean_inc(x_65);
-if (lean_is_exclusive(x_64)) {
- lean_ctor_release(x_64, 0);
- lean_ctor_release(x_64, 1);
- x_66 = x_64;
-} else {
- lean_dec_ref(x_64);
- x_66 = lean_box(0);
-}
-if (lean_is_scalar(x_66)) {
- x_67 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_67 = x_66;
- lean_ctor_set_tag(x_67, 1);
-}
-lean_ctor_set(x_67, 0, x_45);
-lean_ctor_set(x_67, 1, x_65);
-return x_67;
-}
-}
-}
-else
-{
-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; lean_object* x_80; uint8_t x_81; lean_object* x_82; 
-x_68 = lean_ctor_get(x_10, 0);
-x_69 = lean_ctor_get(x_10, 1);
-x_70 = lean_ctor_get(x_10, 3);
-x_71 = lean_ctor_get(x_10, 4);
-x_72 = lean_ctor_get(x_10, 5);
-x_73 = lean_ctor_get(x_10, 6);
-lean_inc(x_73);
-lean_inc(x_72);
-lean_inc(x_71);
-lean_inc(x_70);
-lean_inc(x_69);
-lean_inc(x_68);
-lean_dec(x_10);
-x_74 = l_Lean_Compiler_LCNF_normalizeFVarIds___closed__3;
-x_75 = lean_alloc_ctor(0, 7, 0);
-lean_ctor_set(x_75, 0, x_68);
-lean_ctor_set(x_75, 1, x_69);
-lean_ctor_set(x_75, 2, x_74);
-lean_ctor_set(x_75, 3, x_70);
-lean_ctor_set(x_75, 4, x_71);
-lean_ctor_set(x_75, 5, x_72);
-lean_ctor_set(x_75, 6, x_73);
-x_76 = lean_st_ref_set(x_3, x_75, x_11);
-x_77 = lean_ctor_get(x_76, 1);
-lean_inc(x_77);
-lean_dec(x_76);
-x_78 = l_Lean_Compiler_LCNF_normalizeFVarIds___closed__4;
-x_79 = lean_alloc_closure((void*)(l_Lean_Compiler_LCNF_Decl_internalize___boxed), 7, 2);
-lean_closure_set(x_79, 0, x_1);
-lean_closure_set(x_79, 1, x_78);
-x_80 = l_Lean_Compiler_LCNF_normalizeFVarIds___closed__6;
-x_81 = 0;
-lean_inc(x_3);
-x_82 = l_Lean_Compiler_LCNF_CompilerM_run___rarg(x_79, x_80, x_81, x_2, x_3, x_77);
-if (lean_obj_tag(x_82) == 0)
-{
-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; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; 
-x_83 = lean_ctor_get(x_82, 0);
-lean_inc(x_83);
-x_84 = lean_ctor_get(x_82, 1);
-lean_inc(x_84);
-lean_dec(x_82);
-x_85 = lean_st_ref_take(x_3, x_84);
-x_86 = lean_ctor_get(x_85, 0);
-lean_inc(x_86);
-x_87 = lean_ctor_get(x_85, 1);
-lean_inc(x_87);
-lean_dec(x_85);
-x_88 = lean_ctor_get(x_86, 0);
-lean_inc(x_88);
-x_89 = lean_ctor_get(x_86, 1);
-lean_inc(x_89);
-x_90 = lean_ctor_get(x_86, 3);
-lean_inc(x_90);
-x_91 = lean_ctor_get(x_86, 4);
-lean_inc(x_91);
-x_92 = lean_ctor_get(x_86, 5);
-lean_inc(x_92);
-x_93 = lean_ctor_get(x_86, 6);
-lean_inc(x_93);
-if (lean_is_exclusive(x_86)) {
- lean_ctor_release(x_86, 0);
- lean_ctor_release(x_86, 1);
- lean_ctor_release(x_86, 2);
- lean_ctor_release(x_86, 3);
- lean_ctor_release(x_86, 4);
- lean_ctor_release(x_86, 5);
- lean_ctor_release(x_86, 6);
- x_94 = x_86;
-} else {
- lean_dec_ref(x_86);
- x_94 = lean_box(0);
-}
-if (lean_is_scalar(x_94)) {
- x_95 = lean_alloc_ctor(0, 7, 0);
-} else {
- x_95 = x_94;
-}
-lean_ctor_set(x_95, 0, x_88);
-lean_ctor_set(x_95, 1, x_89);
-lean_ctor_set(x_95, 2, x_8);
-lean_ctor_set(x_95, 3, x_90);
-lean_ctor_set(x_95, 4, x_91);
-lean_ctor_set(x_95, 5, x_92);
-lean_ctor_set(x_95, 6, x_93);
-x_96 = lean_st_ref_set(x_3, x_95, x_87);
-lean_dec(x_3);
-x_97 = lean_ctor_get(x_96, 1);
-lean_inc(x_97);
-if (lean_is_exclusive(x_96)) {
- lean_ctor_release(x_96, 0);
- lean_ctor_release(x_96, 1);
- x_98 = x_96;
-} else {
- lean_dec_ref(x_96);
- x_98 = lean_box(0);
-}
-if (lean_is_scalar(x_98)) {
- x_99 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_99 = x_98;
-}
-lean_ctor_set(x_99, 0, x_83);
-lean_ctor_set(x_99, 1, x_97);
-return x_99;
-}
-else
-{
-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; 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; 
-x_100 = lean_ctor_get(x_82, 0);
-lean_inc(x_100);
-x_101 = lean_ctor_get(x_82, 1);
-lean_inc(x_101);
-lean_dec(x_82);
-x_102 = lean_st_ref_take(x_3, x_101);
-x_103 = lean_ctor_get(x_102, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_102, 1);
-lean_inc(x_104);
-lean_dec(x_102);
-x_105 = lean_ctor_get(x_103, 0);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_103, 1);
-lean_inc(x_106);
-x_107 = lean_ctor_get(x_103, 3);
-lean_inc(x_107);
-x_108 = lean_ctor_get(x_103, 4);
-lean_inc(x_108);
-x_109 = lean_ctor_get(x_103, 5);
-lean_inc(x_109);
-x_110 = lean_ctor_get(x_103, 6);
-lean_inc(x_110);
-if (lean_is_exclusive(x_103)) {
- lean_ctor_release(x_103, 0);
- lean_ctor_release(x_103, 1);
- lean_ctor_release(x_103, 2);
- lean_ctor_release(x_103, 3);
- lean_ctor_release(x_103, 4);
- lean_ctor_release(x_103, 5);
- lean_ctor_release(x_103, 6);
- x_111 = x_103;
-} else {
- lean_dec_ref(x_103);
- x_111 = lean_box(0);
-}
-if (lean_is_scalar(x_111)) {
- x_112 = lean_alloc_ctor(0, 7, 0);
-} else {
- x_112 = x_111;
-}
-lean_ctor_set(x_112, 0, x_105);
-lean_ctor_set(x_112, 1, x_106);
-lean_ctor_set(x_112, 2, x_8);
-lean_ctor_set(x_112, 3, x_107);
-lean_ctor_set(x_112, 4, x_108);
-lean_ctor_set(x_112, 5, x_109);
-lean_ctor_set(x_112, 6, x_110);
-x_113 = lean_st_ref_set(x_3, x_112, x_104);
-lean_dec(x_3);
-x_114 = lean_ctor_get(x_113, 1);
-lean_inc(x_114);
-if (lean_is_exclusive(x_113)) {
- lean_ctor_release(x_113, 0);
- lean_ctor_release(x_113, 1);
- x_115 = x_113;
-} else {
- lean_dec_ref(x_113);
- x_115 = lean_box(0);
-}
-if (lean_is_scalar(x_115)) {
- x_116 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_116 = x_115;
- lean_ctor_set_tag(x_116, 1);
-}
-lean_ctor_set(x_116, 0, x_100);
-lean_ctor_set(x_116, 1, x_114);
-return x_116;
-}
-}
-}
-}
-LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_saveBase___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) {
-_start:
-{
-lean_object* x_7; 
-lean_inc(x_5);
-lean_inc(x_4);
-lean_inc(x_1);
-x_7 = l_Lean_Compiler_LCNF_normalizeFVarIds(x_1, x_4, x_5, x_6);
-if (lean_obj_tag(x_7) == 0)
-{
-lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; 
-x_8 = lean_ctor_get(x_7, 0);
-lean_inc(x_8);
-x_9 = lean_ctor_get(x_7, 1);
-lean_inc(x_9);
-lean_dec(x_7);
-x_10 = l_Lean_Compiler_LCNF_Decl_saveBase(x_8, x_4, x_5, x_9);
-lean_dec(x_5);
-lean_dec(x_4);
-x_11 = !lean_is_exclusive(x_10);
-if (x_11 == 0)
-{
-lean_object* x_12; 
-x_12 = lean_ctor_get(x_10, 0);
-lean_dec(x_12);
-lean_ctor_set(x_10, 0, x_1);
-return x_10;
-}
-else
-{
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_10, 1);
-lean_inc(x_13);
-lean_dec(x_10);
-x_14 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_14, 0, x_1);
-lean_ctor_set(x_14, 1, x_13);
-return x_14;
-}
-}
-else
-{
-uint8_t x_15; 
-lean_dec(x_5);
-lean_dec(x_4);
-lean_dec(x_1);
-x_15 = !lean_is_exclusive(x_7);
-if (x_15 == 0)
-{
-return x_7;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_16 = lean_ctor_get(x_7, 0);
-x_17 = lean_ctor_get(x_7, 1);
-lean_inc(x_17);
-lean_inc(x_16);
-lean_dec(x_7);
-x_18 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_18, 0, x_16);
-lean_ctor_set(x_18, 1, x_17);
-return x_18;
-}
-}
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_saveBase___closed__1() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string_from_bytes("saveBase", 8);
-return x_1;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_saveBase___closed__2() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = lean_box(0);
-x_2 = l_Lean_Compiler_LCNF_saveBase___closed__1;
-x_3 = l_Lean_Name_str___override(x_1, x_2);
-return x_3;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_saveBase___closed__3() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_Compiler_LCNF_saveBase___lambda__1___boxed), 6, 0);
-return x_1;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_saveBase___closed__4() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_Compiler_LCNF_saveBase___closed__2;
-x_2 = l_Lean_Compiler_LCNF_saveBase___closed__3;
-x_3 = 0;
-x_4 = lean_unsigned_to_nat(0u);
-x_5 = l_Lean_Compiler_LCNF_Pass_mkPerDeclaration(x_1, x_2, x_3, x_4);
-return x_5;
-}
-}
-static lean_object* _init_l_Lean_Compiler_LCNF_saveBase() {
-_start:
-{
-lean_object* x_1; 
-x_1 = l_Lean_Compiler_LCNF_saveBase___closed__4;
-return x_1;
-}
-}
-LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_saveBase___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) {
-_start:
-{
-lean_object* x_7; 
-x_7 = l_Lean_Compiler_LCNF_saveBase___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6);
-lean_dec(x_3);
-lean_dec(x_2);
-return x_7;
-}
-}
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Compiler_LCNF_forEachDecl___spec__1(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
 _start:
 {
@@ -3375,28 +2764,6 @@ l_Lean_Compiler_LCNF_getBaseDeclCore_x3f___closed__2 = _init_l_Lean_Compiler_LCN
 lean_mark_persistent(l_Lean_Compiler_LCNF_getBaseDeclCore_x3f___closed__2);
 l_Lean_Compiler_LCNF_Decl_saveBase___closed__1 = _init_l_Lean_Compiler_LCNF_Decl_saveBase___closed__1();
 lean_mark_persistent(l_Lean_Compiler_LCNF_Decl_saveBase___closed__1);
-l_Lean_Compiler_LCNF_normalizeFVarIds___closed__1 = _init_l_Lean_Compiler_LCNF_normalizeFVarIds___closed__1();
-lean_mark_persistent(l_Lean_Compiler_LCNF_normalizeFVarIds___closed__1);
-l_Lean_Compiler_LCNF_normalizeFVarIds___closed__2 = _init_l_Lean_Compiler_LCNF_normalizeFVarIds___closed__2();
-lean_mark_persistent(l_Lean_Compiler_LCNF_normalizeFVarIds___closed__2);
-l_Lean_Compiler_LCNF_normalizeFVarIds___closed__3 = _init_l_Lean_Compiler_LCNF_normalizeFVarIds___closed__3();
-lean_mark_persistent(l_Lean_Compiler_LCNF_normalizeFVarIds___closed__3);
-l_Lean_Compiler_LCNF_normalizeFVarIds___closed__4 = _init_l_Lean_Compiler_LCNF_normalizeFVarIds___closed__4();
-lean_mark_persistent(l_Lean_Compiler_LCNF_normalizeFVarIds___closed__4);
-l_Lean_Compiler_LCNF_normalizeFVarIds___closed__5 = _init_l_Lean_Compiler_LCNF_normalizeFVarIds___closed__5();
-lean_mark_persistent(l_Lean_Compiler_LCNF_normalizeFVarIds___closed__5);
-l_Lean_Compiler_LCNF_normalizeFVarIds___closed__6 = _init_l_Lean_Compiler_LCNF_normalizeFVarIds___closed__6();
-lean_mark_persistent(l_Lean_Compiler_LCNF_normalizeFVarIds___closed__6);
-l_Lean_Compiler_LCNF_saveBase___closed__1 = _init_l_Lean_Compiler_LCNF_saveBase___closed__1();
-lean_mark_persistent(l_Lean_Compiler_LCNF_saveBase___closed__1);
-l_Lean_Compiler_LCNF_saveBase___closed__2 = _init_l_Lean_Compiler_LCNF_saveBase___closed__2();
-lean_mark_persistent(l_Lean_Compiler_LCNF_saveBase___closed__2);
-l_Lean_Compiler_LCNF_saveBase___closed__3 = _init_l_Lean_Compiler_LCNF_saveBase___closed__3();
-lean_mark_persistent(l_Lean_Compiler_LCNF_saveBase___closed__3);
-l_Lean_Compiler_LCNF_saveBase___closed__4 = _init_l_Lean_Compiler_LCNF_saveBase___closed__4();
-lean_mark_persistent(l_Lean_Compiler_LCNF_saveBase___closed__4);
-l_Lean_Compiler_LCNF_saveBase = _init_l_Lean_Compiler_LCNF_saveBase();
-lean_mark_persistent(l_Lean_Compiler_LCNF_saveBase);
 l_Lean_Compiler_LCNF_forEachModuleDecl___closed__1 = _init_l_Lean_Compiler_LCNF_forEachModuleDecl___closed__1();
 lean_mark_persistent(l_Lean_Compiler_LCNF_forEachModuleDecl___closed__1);
 l_Lean_Compiler_LCNF_forEachModuleDecl___closed__2 = _init_l_Lean_Compiler_LCNF_forEachModuleDecl___closed__2();

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

@@ -1,6 +1,6 @@
 // Lean compiler output
 // Module: Lean.Compiler.LCNF.PrettyPrinter
-// Imports: Init Lean.PrettyPrinter Lean.Compiler.LCNF.CompilerM
+// Imports: Init Lean.PrettyPrinter Lean.Compiler.LCNF.CompilerM Lean.Compiler.LCNF.Internalize
 #include <lean/lean.h>
 #if defined(__clang__)
 #pragma clang diagnostic ignored "-Wunused-parameter"
@@ -3866,9 +3866,16 @@ return x_2;
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_ppDecl_x27_go(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+lean_object* x_7; lean_object* x_8; 
 x_7 = l_Lean_Compiler_LCNF_ppDecl_x27_go___closed__1;
+lean_inc(x_5);
+lean_inc(x_4);
+lean_inc(x_3);
+lean_inc(x_2);
 x_8 = l_Lean_Compiler_LCNF_Decl_internalize(x_1, x_7, x_2, x_3, x_4, x_5, x_6);
+if (lean_obj_tag(x_8) == 0)
+{
+lean_object* x_9; lean_object* x_10; lean_object* x_11; 
 x_9 = lean_ctor_get(x_8, 0);
 lean_inc(x_9);
 x_10 = lean_ctor_get(x_8, 1);
@@ -3877,6 +3884,33 @@ lean_dec(x_8);
 x_11 = l_Lean_Compiler_LCNF_ppDecl(x_9, x_2, x_3, x_4, x_5, x_10);
 return x_11;
 }
+else
+{
+uint8_t x_12; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_12 = !lean_is_exclusive(x_8);
+if (x_12 == 0)
+{
+return x_8;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+x_13 = lean_ctor_get(x_8, 0);
+x_14 = lean_ctor_get(x_8, 1);
+lean_inc(x_14);
+lean_inc(x_13);
+lean_dec(x_8);
+x_15 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_15, 0, x_13);
+lean_ctor_set(x_15, 1, x_14);
+return x_15;
+}
+}
+}
 }
 static lean_object* _init_l_Lean_Compiler_LCNF_ppDecl_x27___closed__1() {
 _start:
@@ -3986,6 +4020,7 @@ return x_25;
 lean_object* initialize_Init(uint8_t builtin, lean_object*);
 lean_object* initialize_Lean_PrettyPrinter(uint8_t builtin, lean_object*);
 lean_object* initialize_Lean_Compiler_LCNF_CompilerM(uint8_t builtin, lean_object*);
+lean_object* initialize_Lean_Compiler_LCNF_Internalize(uint8_t builtin, lean_object*);
 static bool _G_initialized = false;
 LEAN_EXPORT lean_object* initialize_Lean_Compiler_LCNF_PrettyPrinter(uint8_t builtin, lean_object* w) {
 lean_object * res;
@@ -4000,6 +4035,9 @@ lean_dec_ref(res);
 res = initialize_Lean_Compiler_LCNF_CompilerM(builtin, lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
+res = initialize_Lean_Compiler_LCNF_Internalize(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
 l_Subarray_forInUnsafe_loop___at___private_Lean_Compiler_LCNF_PrettyPrinter_0__Lean_Compiler_LCNF_PP_join___spec__1___rarg___closed__1 = _init_l_Subarray_forInUnsafe_loop___at___private_Lean_Compiler_LCNF_PrettyPrinter_0__Lean_Compiler_LCNF_PP_join___spec__1___rarg___closed__1();
 lean_mark_persistent(l_Subarray_forInUnsafe_loop___at___private_Lean_Compiler_LCNF_PrettyPrinter_0__Lean_Compiler_LCNF_PP_join___spec__1___rarg___closed__1);
 l_Subarray_forInUnsafe_loop___at___private_Lean_Compiler_LCNF_PrettyPrinter_0__Lean_Compiler_LCNF_PP_join___spec__1___rarg___closed__2 = _init_l_Subarray_forInUnsafe_loop___at___private_Lean_Compiler_LCNF_PrettyPrinter_0__Lean_Compiler_LCNF_PP_join___spec__1___rarg___closed__2();

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

@@ -1748,7 +1748,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Compiler_LCNF_PullLetDecls_pullDecls___lambda__1___closed__1;
 x_2 = l_Lean_Compiler_LCNF_PullLetDecls_pullDecls___lambda__1___closed__2;
-x_3 = lean_unsigned_to_nat(203u);
+x_3 = lean_unsigned_to_nat(207u);
 x_4 = lean_unsigned_to_nat(9u);
 x_5 = l_Lean_Compiler_LCNF_PullLetDecls_pullDecls___lambda__1___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
@@ -2468,7 +2468,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_Compiler_LCNF_PullLetDecls_pullDecls___lambda__1___closed__1;
 x_2 = l_Lean_Compiler_LCNF_PullLetDecls_pullDecls___lambda__2___closed__1;
-x_3 = lean_unsigned_to_nat(172u);
+x_3 = lean_unsigned_to_nat(176u);
 x_4 = lean_unsigned_to_nat(9u);
 x_5 = l_Lean_Compiler_LCNF_PullLetDecls_pullDecls___lambda__1___closed__3;
 x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);

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

@@ -58,7 +58,7 @@ lean_object* l_Lean_Name_mkStr2(lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_Code_containsConst_goExpr___closed__2;
-uint8_t l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646_(lean_object*, lean_object*);
+uint8_t l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694_(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Compiler_LCNF_Testing_assertNoFun___spec__3(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Compiler_LCNF_Testing_0__Lean_Compiler_LCNF_Testing_assertAfterTest___elambda__1___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Testing_InOutAssertionM_run___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -76,7 +76,6 @@ LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Testing_assertAfterEachOccurrence(
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Code_containsConst___boxed(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_Testing_assertReducesSize___closed__1;
 static lean_object* l_Lean_throwError___at_Lean_Compiler_LCNF_Testing_assert___spec__1___closed__6;
-lean_object* l_panic___at_Lean_PrettyPrinter_Delaborator_TopDownAnalyze_analyzeAppStagedCore_maybeSetExplicit___spec__4(lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_Testing_assertForEachDeclAfter___closed__1;
 LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Compiler_LCNF_Testing_assert___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Compiler_LCNF_Testing_0__Lean_Compiler_LCNF_Testing_assertAfterTest___elambda__1___closed__2;
@@ -96,6 +95,7 @@ LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Testing_assertAfter(lean_object*,
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Code_containsConst_goExpr(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_Testing_assertNoFun___closed__1;
 static lean_object* l___private_Lean_Compiler_LCNF_Testing_0__Lean_Compiler_LCNF_Testing_assertAfterTest___elambda__1___closed__4;
+lean_object* l_panic___at_Lean_Compiler_LCNF_isErasedCompatible_go___spec__1(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_LCNF_Testing_assertReducesOrPreservesSize(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_LCNF_Testing_assertIsAtFixPoint___closed__1;
 LEAN_EXPORT uint8_t l_Lean_Compiler_LCNF_Code_containsConst(lean_object*, lean_object*);
@@ -282,7 +282,7 @@ case 8:
 {
 lean_object* x_15; lean_object* x_16; 
 x_15 = l_Lean_Compiler_LCNF_Code_containsConst_goExpr___closed__4;
-x_16 = l_panic___at_Lean_PrettyPrinter_Delaborator_TopDownAnalyze_analyzeAppStagedCore_maybeSetExplicit___spec__4(x_15);
+x_16 = l_panic___at_Lean_Compiler_LCNF_isErasedCompatible_go___spec__1(x_15);
 return x_16;
 }
 case 11:
@@ -2822,7 +2822,7 @@ else
 lean_object* x_10; lean_object* x_11; uint8_t x_12; 
 x_10 = lean_array_fget(x_4, x_6);
 x_11 = lean_array_fget(x_5, x_6);
-x_12 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3646_(x_10, x_11);
+x_12 = l___private_Lean_Compiler_LCNF_Basic_0__Lean_Compiler_LCNF_beqDecl____x40_Lean_Compiler_LCNF_Basic___hyg_3694_(x_10, x_11);
 lean_dec(x_11);
 if (x_12 == 0)
 {

stage0/stdlib/Lean/Compiler/Main.c

@@ -17,35 +17,15 @@ lean_object* l_Lean_registerTraceClass(lean_object*, uint8_t, lean_object*);
 lean_object* l_Lean_Name_str___override(lean_object*, lean_object*);
 lean_object* l_Lean_Name_mkStr2(lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Main___hyg_49____closed__4;
-LEAN_EXPORT lean_object* l_Lean_profileitM___at_Lean_Compiler_compile___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Main___hyg_49_(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_compile(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_profileitM___at_Lean_Compiler_LCNF_main___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Main___hyg_49____closed__3;
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Main___hyg_49____closed__1;
 static lean_object* l_Lean_Compiler_compile___closed__1;
 lean_object* l_Lean_Compiler_LCNF_compile(lean_object*, lean_object*, lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Lean_profileitM___at_Lean_Compiler_compile___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_profileitIOUnsafe___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Main___hyg_49____closed__2;
-LEAN_EXPORT lean_object* l_Lean_profileitM___at_Lean_Compiler_compile___spec__1(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Compiler_compile___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
-LEAN_EXPORT lean_object* l_Lean_profileitM___at_Lean_Compiler_compile___spec__1___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) {
-_start:
-{
-lean_object* x_7; lean_object* x_8; 
-x_7 = lean_apply_2(x_3, x_4, x_5);
-x_8 = l_Lean_profileitIOUnsafe___rarg(x_1, x_2, x_7, x_6);
-return x_8;
-}
-}
-LEAN_EXPORT lean_object* l_Lean_profileitM___at_Lean_Compiler_compile___spec__1(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_profileitM___at_Lean_Compiler_compile___spec__1___rarg___boxed), 6, 0);
-return x_2;
-}
-}
 LEAN_EXPORT lean_object* l_Lean_Compiler_compile___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -118,21 +98,11 @@ lean_inc(x_5);
 x_6 = lean_alloc_closure((void*)(l_Lean_Compiler_compile___lambda__1), 4, 1);
 lean_closure_set(x_6, 0, x_1);
 x_7 = l_Lean_Compiler_compile___closed__1;
-x_8 = l_Lean_profileitM___at_Lean_Compiler_compile___spec__1___rarg(x_7, x_5, x_6, x_2, x_3, x_4);
+x_8 = l_Lean_profileitM___at_Lean_Compiler_LCNF_main___spec__1___rarg(x_7, x_5, x_6, x_2, x_3, x_4);
 lean_dec(x_5);
 return x_8;
 }
 }
-LEAN_EXPORT lean_object* l_Lean_profileitM___at_Lean_Compiler_compile___spec__1___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) {
-_start:
-{
-lean_object* x_7; 
-x_7 = l_Lean_profileitM___at_Lean_Compiler_compile___spec__1___rarg(x_1, x_2, x_3, x_4, x_5, x_6);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_7;
-}
-}
 static lean_object* _init_l_Lean_Compiler_initFn____x40_Lean_Compiler_Main___hyg_49____closed__1() {
 _start:
 {

stage0/stdlib/Lean/Data/Name.c

@@ -42,7 +42,6 @@ LEAN_EXPORT uint8_t l_Lean_Name_eqStr(lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Name_instDecidableRelNameLtHasLtQuick___boxed(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_String_toName(lean_object*);
-LEAN_EXPORT lean_object* l_Lean_Name_components_x27(lean_object*);
 lean_object* l_Lean_Name_num___override(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Name_hashEx___boxed(lean_object*);
 LEAN_EXPORT uint64_t lean_name_hash_exported(lean_object*);
@@ -80,6 +79,7 @@ LEAN_EXPORT lean_object* l_Lean_Name_isNum___boxed(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Name_isPrefixOf___boxed(lean_object*, lean_object*);
 static lean_object* l_Lean_Name_getString_x21___closed__4;
 LEAN_EXPORT lean_object* l_panic___at_Lean_Name_getString_x21___spec__1(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Name_componentsRev(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Name_components(lean_object*);
 uint8_t lean_string_dec_lt(lean_object*, lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
@@ -275,7 +275,7 @@ return x_7;
 }
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Name_components_x27(lean_object* x_1) {
+LEAN_EXPORT lean_object* l_Lean_Name_componentsRev(lean_object* x_1) {
 _start:
 {
 switch (lean_obj_tag(x_1)) {
@@ -295,7 +295,7 @@ lean_inc(x_4);
 lean_dec(x_1);
 x_5 = lean_box(0);
 x_6 = l_Lean_Name_str___override(x_5, x_4);
-x_7 = l_Lean_Name_components_x27(x_3);
+x_7 = l_Lean_Name_componentsRev(x_3);
 x_8 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_8, 0, x_6);
 lean_ctor_set(x_8, 1, x_7);
@@ -311,7 +311,7 @@ lean_inc(x_10);
 lean_dec(x_1);
 x_11 = lean_box(0);
 x_12 = l_Lean_Name_num___override(x_11, x_10);
-x_13 = l_Lean_Name_components_x27(x_9);
+x_13 = l_Lean_Name_componentsRev(x_9);
 x_14 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_14, 0, x_12);
 lean_ctor_set(x_14, 1, x_13);
@@ -324,7 +324,7 @@ LEAN_EXPORT lean_object* l_Lean_Name_components(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
-x_2 = l_Lean_Name_components_x27(x_1);
+x_2 = l_Lean_Name_componentsRev(x_1);
 x_3 = l_List_reverse___rarg(x_2);
 return x_3;
 }

stage0/stdlib/Lean/Data/Position.c

@@ -38,7 +38,6 @@ lean_object* lean_string_append(lean_object*, lean_object*);
 static lean_object* l___private_Lean_Data_Position_0__Lean_reprPosition____x40_Lean_Data_Position___hyg_162____closed__18;
 lean_object* l_Lean_Name_mkStr3(lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_Position_instToFormatPosition___closed__2;
-lean_object* l_prodHasDecidableLt___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l___private_Lean_Data_Position_0__Lean_reprPosition____x40_Lean_Data_Position___hyg_162____closed__5;
 static lean_object* l___private_Lean_Data_Position_0__Lean_reprPosition____x40_Lean_Data_Position___hyg_162____closed__2;
 static lean_object* l_Lean_FileMap_toPosition_loop___closed__3;
@@ -84,6 +83,7 @@ LEAN_EXPORT lean_object* l_Lean_FileMap_toPosition_toColumn___boxed(lean_object*
 LEAN_EXPORT uint8_t l_Lean_instDecidableEqPosition(lean_object*, lean_object*);
 static lean_object* l___private_Lean_Data_Position_0__Lean_reprPosition____x40_Lean_Data_Position___hyg_162____closed__7;
 LEAN_EXPORT lean_object* l_Lean_Position_instToStringPosition(lean_object*);
+lean_object* l_Prod_lexLtDec___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_FileMap_toPosition_loop(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_uint32_dec_eq(uint32_t, uint32_t);
 static lean_object* l_Lean_Position_instToExprPosition___lambda__1___closed__5;
@@ -492,7 +492,7 @@ lean_ctor_set(x_8, 0, x_5);
 lean_ctor_set(x_8, 1, x_6);
 x_9 = l_Lean_Position_lt___closed__1;
 x_10 = l_Lean_Position_lt___closed__2;
-x_11 = l_prodHasDecidableLt___rarg(x_9, x_9, x_10, x_10, x_7, x_8);
+x_11 = l_Prod_lexLtDec___rarg(x_9, x_9, x_10, x_10, x_7, x_8);
 return x_11;
 }
 }

stage0/stdlib/Lean/Elab/Deriving/Repr.c

@@ -2196,7 +2196,7 @@ x_27 = lean_nat_add(x_2, x_10);
 x_28 = lean_array_get_size(x_4);
 x_29 = lean_nat_dec_lt(x_27, x_28);
 lean_dec(x_28);
-x_30 = lean_nat_dec_lt(x_2, x_10);
+x_30 = lean_nat_dec_eq(x_10, x_22);
 if (x_26 == 0)
 {
 lean_object* x_106; lean_object* x_107; 
@@ -2241,8 +2241,79 @@ block_101:
 {
 if (x_30 == 0)
 {
-lean_object* x_37; lean_object* x_38; 
-x_37 = lean_box(0);
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 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; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; 
+lean_inc(x_18);
+x_37 = l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Term_exprToSyntax___spec__1___rarg(x_18, x_19, x_20);
+x_38 = lean_ctor_get(x_37, 0);
+lean_inc(x_38);
+x_39 = lean_ctor_get(x_37, 1);
+lean_inc(x_39);
+lean_dec(x_37);
+x_40 = lean_ctor_get(x_18, 10);
+lean_inc(x_40);
+x_41 = lean_st_ref_get(x_19, x_39);
+x_42 = lean_ctor_get(x_41, 0);
+lean_inc(x_42);
+x_43 = lean_ctor_get(x_41, 1);
+lean_inc(x_43);
+lean_dec(x_41);
+x_44 = lean_ctor_get(x_42, 0);
+lean_inc(x_44);
+lean_dec(x_42);
+x_45 = lean_environment_main_module(x_44);
+x_46 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___lambda__1___closed__5;
+lean_inc(x_38);
+x_47 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_47, 0, x_38);
+lean_ctor_set(x_47, 1, x_46);
+x_48 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___closed__1;
+lean_inc(x_38);
+x_49 = lean_alloc_ctor(2, 2, 0);
+lean_ctor_set(x_49, 0, x_38);
+lean_ctor_set(x_49, 1, x_48);
+x_50 = l_Array_mkArray1___rarg(x_49);
+x_51 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___lambda__1___closed__7;
+lean_inc(x_38);
+x_52 = lean_alloc_ctor(1, 3, 0);
+lean_ctor_set(x_52, 0, x_38);
+lean_ctor_set(x_52, 1, x_51);
+lean_ctor_set(x_52, 2, x_50);
+lean_inc(x_47);
+x_53 = l_Array_mkArray3___rarg(x_13, x_47, x_52);
+x_54 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___lambda__1___closed__4;
+lean_inc(x_38);
+x_55 = lean_alloc_ctor(1, 3, 0);
+lean_ctor_set(x_55, 0, x_38);
+lean_ctor_set(x_55, 1, x_54);
+lean_ctor_set(x_55, 2, x_53);
+x_56 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___closed__5;
+x_57 = l_Lean_addMacroScope(x_45, x_56, x_40);
+x_58 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___closed__6;
+lean_inc(x_6);
+x_59 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_59, 0, x_58);
+lean_ctor_set(x_59, 1, x_6);
+x_60 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___closed__7;
+lean_inc(x_7);
+x_61 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_61, 0, x_60);
+lean_ctor_set(x_61, 1, x_7);
+x_62 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_62, 0, x_59);
+lean_ctor_set(x_62, 1, x_61);
+x_63 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___closed__3;
+lean_inc(x_38);
+x_64 = lean_alloc_ctor(3, 4, 0);
+lean_ctor_set(x_64, 0, x_38);
+lean_ctor_set(x_64, 1, x_63);
+lean_ctor_set(x_64, 2, x_57);
+lean_ctor_set(x_64, 3, x_62);
+x_65 = l_Array_mkArray3___rarg(x_55, x_47, x_64);
+x_66 = lean_alloc_ctor(1, 3, 0);
+lean_ctor_set(x_66, 0, x_38);
+lean_ctor_set(x_66, 1, x_54);
+lean_ctor_set(x_66, 2, x_65);
+x_67 = lean_box(0);
 lean_inc(x_19);
 lean_inc(x_18);
 lean_inc(x_17);
@@ -2250,16 +2321,16 @@ lean_inc(x_16);
 lean_inc(x_3);
 lean_inc(x_7);
 lean_inc(x_6);
-x_38 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___lambda__1(x_33, x_35, x_6, x_7, x_31, x_3, x_36, x_13, x_37, x_14, x_15, x_16, x_17, x_18, x_19, x_20);
+x_68 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___lambda__1(x_33, x_35, x_6, x_7, x_31, x_3, x_36, x_66, x_67, x_14, x_15, x_16, x_17, x_18, x_19, x_43);
 lean_dec(x_33);
-if (lean_obj_tag(x_38) == 0)
+if (lean_obj_tag(x_68) == 0)
 {
-lean_object* x_39; 
-x_39 = lean_ctor_get(x_38, 0);
-lean_inc(x_39);
-if (lean_obj_tag(x_39) == 0)
+lean_object* x_69; 
+x_69 = lean_ctor_get(x_68, 0);
+lean_inc(x_69);
+if (lean_obj_tag(x_69) == 0)
 {
-uint8_t x_40; 
+uint8_t x_70; 
 lean_dec(x_25);
 lean_dec(x_19);
 lean_dec(x_18);
@@ -2269,54 +2340,54 @@ lean_dec(x_10);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
-x_40 = !lean_is_exclusive(x_38);
-if (x_40 == 0)
+x_70 = !lean_is_exclusive(x_68);
+if (x_70 == 0)
 {
-lean_object* x_41; lean_object* x_42; 
-x_41 = lean_ctor_get(x_38, 0);
-lean_dec(x_41);
-x_42 = lean_ctor_get(x_39, 0);
-lean_inc(x_42);
-lean_dec(x_39);
-lean_ctor_set(x_38, 0, x_42);
-return x_38;
+lean_object* x_71; lean_object* x_72; 
+x_71 = lean_ctor_get(x_68, 0);
+lean_dec(x_71);
+x_72 = lean_ctor_get(x_69, 0);
+lean_inc(x_72);
+lean_dec(x_69);
+lean_ctor_set(x_68, 0, x_72);
+return x_68;
 }
 else
 {
-lean_object* x_43; lean_object* x_44; lean_object* x_45; 
-x_43 = lean_ctor_get(x_38, 1);
-lean_inc(x_43);
-lean_dec(x_38);
-x_44 = lean_ctor_get(x_39, 0);
-lean_inc(x_44);
-lean_dec(x_39);
-x_45 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_45, 0, x_44);
-lean_ctor_set(x_45, 1, x_43);
-return x_45;
+lean_object* x_73; lean_object* x_74; lean_object* x_75; 
+x_73 = lean_ctor_get(x_68, 1);
+lean_inc(x_73);
+lean_dec(x_68);
+x_74 = lean_ctor_get(x_69, 0);
+lean_inc(x_74);
+lean_dec(x_69);
+x_75 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_75, 0, x_74);
+lean_ctor_set(x_75, 1, x_73);
+return x_75;
 }
 }
 else
 {
-lean_object* x_46; lean_object* x_47; lean_object* x_48; 
-x_46 = lean_ctor_get(x_38, 1);
-lean_inc(x_46);
-lean_dec(x_38);
-x_47 = lean_ctor_get(x_39, 0);
-lean_inc(x_47);
-lean_dec(x_39);
-x_48 = lean_nat_add(x_10, x_12);
+lean_object* x_76; lean_object* x_77; lean_object* x_78; 
+x_76 = lean_ctor_get(x_68, 1);
+lean_inc(x_76);
+lean_dec(x_68);
+x_77 = lean_ctor_get(x_69, 0);
+lean_inc(x_77);
+lean_dec(x_69);
+x_78 = lean_nat_add(x_10, x_12);
 lean_dec(x_10);
 x_9 = x_25;
-x_10 = x_48;
-x_13 = x_47;
-x_20 = x_46;
+x_10 = x_78;
+x_13 = x_77;
+x_20 = x_76;
 goto _start;
 }
 }
 else
 {
-uint8_t x_50; 
+uint8_t x_80; 
 lean_dec(x_25);
 lean_dec(x_19);
 lean_dec(x_18);
@@ -2326,100 +2397,29 @@ lean_dec(x_10);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_3);
-x_50 = !lean_is_exclusive(x_38);
-if (x_50 == 0)
+x_80 = !lean_is_exclusive(x_68);
+if (x_80 == 0)
 {
-return x_38;
+return x_68;
 }
 else
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-x_51 = lean_ctor_get(x_38, 0);
-x_52 = lean_ctor_get(x_38, 1);
-lean_inc(x_52);
-lean_inc(x_51);
-lean_dec(x_38);
-x_53 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_53, 0, x_51);
-lean_ctor_set(x_53, 1, x_52);
-return x_53;
+lean_object* x_81; lean_object* x_82; lean_object* x_83; 
+x_81 = lean_ctor_get(x_68, 0);
+x_82 = lean_ctor_get(x_68, 1);
+lean_inc(x_82);
+lean_inc(x_81);
+lean_dec(x_68);
+x_83 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_83, 0, x_81);
+lean_ctor_set(x_83, 1, x_82);
+return x_83;
 }
 }
 }
 else
 {
-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; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 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_inc(x_18);
-x_54 = l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Term_exprToSyntax___spec__1___rarg(x_18, x_19, x_20);
-x_55 = lean_ctor_get(x_54, 0);
-lean_inc(x_55);
-x_56 = lean_ctor_get(x_54, 1);
-lean_inc(x_56);
-lean_dec(x_54);
-x_57 = lean_ctor_get(x_18, 10);
-lean_inc(x_57);
-x_58 = lean_st_ref_get(x_19, x_56);
-x_59 = lean_ctor_get(x_58, 0);
-lean_inc(x_59);
-x_60 = lean_ctor_get(x_58, 1);
-lean_inc(x_60);
-lean_dec(x_58);
-x_61 = lean_ctor_get(x_59, 0);
-lean_inc(x_61);
-lean_dec(x_59);
-x_62 = lean_environment_main_module(x_61);
-x_63 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___lambda__1___closed__5;
-lean_inc(x_55);
-x_64 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_64, 0, x_55);
-lean_ctor_set(x_64, 1, x_63);
-x_65 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___closed__1;
-lean_inc(x_55);
-x_66 = lean_alloc_ctor(2, 2, 0);
-lean_ctor_set(x_66, 0, x_55);
-lean_ctor_set(x_66, 1, x_65);
-x_67 = l_Array_mkArray1___rarg(x_66);
-x_68 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___lambda__1___closed__7;
-lean_inc(x_55);
-x_69 = lean_alloc_ctor(1, 3, 0);
-lean_ctor_set(x_69, 0, x_55);
-lean_ctor_set(x_69, 1, x_68);
-lean_ctor_set(x_69, 2, x_67);
-lean_inc(x_64);
-x_70 = l_Array_mkArray3___rarg(x_13, x_64, x_69);
-x_71 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___lambda__1___closed__4;
-lean_inc(x_55);
-x_72 = lean_alloc_ctor(1, 3, 0);
-lean_ctor_set(x_72, 0, x_55);
-lean_ctor_set(x_72, 1, x_71);
-lean_ctor_set(x_72, 2, x_70);
-x_73 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___closed__5;
-x_74 = l_Lean_addMacroScope(x_62, x_73, x_57);
-x_75 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___closed__6;
-lean_inc(x_6);
-x_76 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_76, 0, x_75);
-lean_ctor_set(x_76, 1, x_6);
-x_77 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___closed__7;
-lean_inc(x_7);
-x_78 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_78, 0, x_77);
-lean_ctor_set(x_78, 1, x_7);
-x_79 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_79, 0, x_76);
-lean_ctor_set(x_79, 1, x_78);
-x_80 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___closed__3;
-lean_inc(x_55);
-x_81 = lean_alloc_ctor(3, 4, 0);
-lean_ctor_set(x_81, 0, x_55);
-lean_ctor_set(x_81, 1, x_80);
-lean_ctor_set(x_81, 2, x_74);
-lean_ctor_set(x_81, 3, x_79);
-x_82 = l_Array_mkArray3___rarg(x_72, x_64, x_81);
-x_83 = lean_alloc_ctor(1, 3, 0);
-lean_ctor_set(x_83, 0, x_55);
-lean_ctor_set(x_83, 1, x_71);
-lean_ctor_set(x_83, 2, x_82);
+lean_object* x_84; lean_object* x_85; 
 x_84 = lean_box(0);
 lean_inc(x_19);
 lean_inc(x_18);
@@ -2428,7 +2428,7 @@ lean_inc(x_16);
 lean_inc(x_3);
 lean_inc(x_7);
 lean_inc(x_6);
-x_85 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___lambda__1(x_33, x_35, x_6, x_7, x_31, x_3, x_36, x_83, x_84, x_14, x_15, x_16, x_17, x_18, x_19, x_60);
+x_85 = l_Std_Range_forIn_loop___at_Lean_Elab_Deriving_Repr_mkBodyForStruct___spec__3___lambda__1(x_33, x_35, x_6, x_7, x_31, x_3, x_36, x_13, x_84, x_14, x_15, x_16, x_17, x_18, x_19, x_20);
 lean_dec(x_33);
 if (lean_obj_tag(x_85) == 0)
 {

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

@@ -23,6 +23,7 @@ static lean_object* l_Lean_setEnv___at_Lean_Elab_wfRecursion___spec__1___closed_
 lean_object* l_Lean_stringToMessageData(lean_object*);
 lean_object* l_Lean_Elab_addAsAxiom(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
+lean_object* l_Lean_Meta_whnfForall(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_usize_dec_eq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* l_List_mapTRAux___at_Lean_Elab_addAndCompileUnsafe___spec__2(lean_object*, lean_object*);
@@ -35,7 +36,6 @@ static lean_object* l_Std_Range_forIn_loop___at___private_Lean_Elab_PreDefinitio
 static lean_object* l___private_Lean_Elab_PreDefinition_WF_Main_0__Lean_Elab_isOnlyOneUnaryDef___closed__3;
 static lean_object* l_Lean_Elab_wfRecursion___closed__6;
 static lean_object* l_Lean_Expr_withAppAux___at___private_Lean_Elab_PreDefinition_WF_Main_0__Lean_Elab_addNonRecPreDefs_mkSum___spec__1___closed__11;
-LEAN_EXPORT lean_object* l_Lean_Elab_wfRecursion___lambda__3___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_st_ref_get(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_getFixedPrefix___spec__3___lambda__3(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*);
 static lean_object* l___private_Lean_Elab_PreDefinition_WF_Main_0__Lean_Elab_isOnlyOneUnaryDef___closed__1;
@@ -119,7 +119,7 @@ lean_object* lean_st_mk_ref(lean_object*, lean_object*);
 lean_object* l_instMonadControlReaderT___lambda__3___boxed(lean_object*, lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_wfRecursion___lambda__3(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_Lean_Expr_instHashableExpr;
-LEAN_EXPORT lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_PreDefinition_WF_Main___hyg_2374_(lean_object*);
+LEAN_EXPORT lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_PreDefinition_WF_Main___hyg_2389_(lean_object*);
 static lean_object* l_Lean_Expr_withAppAux___at___private_Lean_Elab_PreDefinition_WF_Main_0__Lean_Elab_addNonRecPreDefs_mkSum___spec__1___closed__10;
 lean_object* l_Lean_Expr_sort___override(lean_object*);
 static lean_object* l_Lean_Elab_wfRecursion___closed__5;
@@ -5436,19 +5436,69 @@ return x_30;
 LEAN_EXPORT lean_object* l_Lean_Elab_wfRecursion___lambda__3(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* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15) {
 _start:
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-x_16 = l_Lean_Expr_bindingDomain_x21(x_8);
-x_17 = lean_ctor_get(x_1, 3);
+lean_object* x_16; 
+lean_inc(x_14);
+lean_inc(x_13);
+lean_inc(x_12);
+lean_inc(x_11);
+x_16 = l_Lean_Meta_whnfForall(x_8, x_11, x_12, x_13, x_14, x_15);
+if (lean_obj_tag(x_16) == 0)
+{
+lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_17 = lean_ctor_get(x_16, 0);
 lean_inc(x_17);
-lean_inc(x_17);
-x_18 = lean_alloc_closure((void*)(l_Lean_Elab_wfRecursion___lambda__2), 13, 5);
-lean_closure_set(x_18, 0, x_1);
-lean_closure_set(x_18, 1, x_7);
-lean_closure_set(x_18, 2, x_2);
-lean_closure_set(x_18, 3, x_17);
-lean_closure_set(x_18, 4, x_3);
-x_19 = l_Lean_Elab_WF_elabWFRel___rarg(x_4, x_17, x_5, x_16, x_6, x_18, x_9, x_10, x_11, x_12, x_13, x_14, x_15);
-return x_19;
+x_18 = lean_ctor_get(x_16, 1);
+lean_inc(x_18);
+lean_dec(x_16);
+x_19 = l_Lean_Expr_bindingDomain_x21(x_17);
+lean_dec(x_17);
+x_20 = lean_ctor_get(x_1, 3);
+lean_inc(x_20);
+lean_inc(x_20);
+x_21 = lean_alloc_closure((void*)(l_Lean_Elab_wfRecursion___lambda__2), 13, 5);
+lean_closure_set(x_21, 0, x_1);
+lean_closure_set(x_21, 1, x_7);
+lean_closure_set(x_21, 2, x_2);
+lean_closure_set(x_21, 3, x_20);
+lean_closure_set(x_21, 4, x_3);
+x_22 = l_Lean_Elab_WF_elabWFRel___rarg(x_4, x_20, x_5, x_19, x_6, x_21, x_9, x_10, x_11, x_12, x_13, x_14, x_18);
+return x_22;
+}
+else
+{
+uint8_t x_23; 
+lean_dec(x_14);
+lean_dec(x_13);
+lean_dec(x_12);
+lean_dec(x_11);
+lean_dec(x_10);
+lean_dec(x_9);
+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_23 = !lean_is_exclusive(x_16);
+if (x_23 == 0)
+{
+return x_16;
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+x_24 = lean_ctor_get(x_16, 0);
+x_25 = lean_ctor_get(x_16, 1);
+lean_inc(x_25);
+lean_inc(x_24);
+lean_dec(x_16);
+x_26 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_26, 0, x_24);
+lean_ctor_set(x_26, 1, x_25);
+return x_26;
+}
+}
 }
 }
 LEAN_EXPORT lean_object* l_Lean_Elab_wfRecursion___lambda__4(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) {
@@ -6163,7 +6213,7 @@ lean_ctor_set(x_16, 0, x_14);
 lean_inc(x_14);
 lean_inc(x_1);
 lean_inc(x_15);
-x_17 = lean_alloc_closure((void*)(l_Lean_Elab_wfRecursion___lambda__3___boxed), 15, 6);
+x_17 = lean_alloc_closure((void*)(l_Lean_Elab_wfRecursion___lambda__3), 15, 6);
 lean_closure_set(x_17, 0, x_13);
 lean_closure_set(x_17, 1, x_3);
 lean_closure_set(x_17, 2, x_15);
@@ -6342,15 +6392,6 @@ lean_dec(x_7);
 return x_15;
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Elab_wfRecursion___lambda__3___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* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15) {
-_start:
-{
-lean_object* x_16; 
-x_16 = l_Lean_Elab_wfRecursion___lambda__3(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15);
-lean_dec(x_8);
-return x_16;
-}
-}
 LEAN_EXPORT lean_object* l_Lean_Elab_wfRecursion___lambda__4___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:
 {
@@ -6375,7 +6416,7 @@ lean_dec(x_5);
 return x_15;
 }
 }
-LEAN_EXPORT lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_PreDefinition_WF_Main___hyg_2374_(lean_object* x_1) {
+LEAN_EXPORT lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_PreDefinition_WF_Main___hyg_2389_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; uint8_t x_3; lean_object* x_4; 
@@ -6560,7 +6601,7 @@ l_Lean_Elab_wfRecursion___closed__5 = _init_l_Lean_Elab_wfRecursion___closed__5(
 lean_mark_persistent(l_Lean_Elab_wfRecursion___closed__5);
 l_Lean_Elab_wfRecursion___closed__6 = _init_l_Lean_Elab_wfRecursion___closed__6();
 lean_mark_persistent(l_Lean_Elab_wfRecursion___closed__6);
-res = l_Lean_Elab_initFn____x40_Lean_Elab_PreDefinition_WF_Main___hyg_2374_(lean_io_mk_world());
+res = l_Lean_Elab_initFn____x40_Lean_Elab_PreDefinition_WF_Main___hyg_2389_(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/Tactic/Simp.c

@@ -224,7 +224,6 @@ lean_object* l_Lean_Elab_Tactic_expandOptLocation(lean_object*);
 LEAN_EXPORT lean_object* l___private_Lean_Elab_Tactic_Simp_0__Lean_Elab_Tactic_addSimpTheorem___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Meta_SimpTheorems_isLemma(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Tactic_elabSimpConfigCore___spec__9___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_Name_components_x27(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_Elab_Tactic_dsimpLocation___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*);
 extern lean_object* l_Lean_Meta_simpExtension;
 static lean_object* l_Lean_Elab_Tactic_mkSimpContext___lambda__3___closed__1;
@@ -526,6 +525,7 @@ static lean_object* l_Lean_Elab_Tactic_tacticToDischarge___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Elab_Tactic_instBEqSimpKind;
 static lean_object* l___regBuiltin_Lean_Elab_Tactic_evalDSimp___closed__1;
 LEAN_EXPORT lean_object* l_Lean_Elab_Tactic_mkSimpContext(lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Name_componentsRev(lean_object*);
 static lean_object* l___regBuiltin_Lean_Elab_Tactic_evalSimp_declRange___closed__2;
 static lean_object* l_Lean_Elab_Tactic_SimpKind_noConfusion___rarg___closed__1;
 static lean_object* l_Lean_resolveGlobalConst___at_Lean_Elab_Tactic_elabSimpArgs___spec__5___closed__2;
@@ -11106,7 +11106,7 @@ LEAN_EXPORT lean_object* l_Lean_unresolveNameGlobal_unresolveNameCore___at_Lean_
 _start:
 {
 lean_object* x_8; 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; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_8 = l_Lean_Name_components_x27(x_2);
+x_8 = l_Lean_Name_componentsRev(x_2);
 x_9 = lean_unsigned_to_nat(0u);
 x_10 = l_List_lengthTRAux___rarg(x_8, x_9);
 x_11 = lean_box(0);

stage0/stdlib/Lean/PrettyPrinter/Delaborator/Builtins.c

@@ -406,7 +406,6 @@ static lean_object* l_Lean_PrettyPrinter_Delaborator_delabMData___closed__1;
 static lean_object* l_Lean_PrettyPrinter_Delaborator_delabDoElems___lambda__3___closed__5;
 static lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppImplicit___lambda__2___closed__1;
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingImp___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Name_components_x27(lean_object*);
 static lean_object* l_Lean_PrettyPrinter_Delaborator_delabSort___closed__5;
 static lean_object* l_Lean_PrettyPrinter_Delaborator_delabDo___closed__1;
 static lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppExplicit___lambda__4___closed__9;
@@ -985,6 +984,7 @@ LEAN_EXPORT lean_object* l_ReaderT_bind___at_Lean_PrettyPrinter_Delaborator_dela
 LEAN_EXPORT lean_object* l_Lean_PrettyPrinter_Delaborator_delabProj(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* l_Lean_PrettyPrinter_Delaborator_delabForall___lambda__2___closed__2;
 uint8_t l_Lean_getPPPiBinderTypes(lean_object*);
+lean_object* l_Lean_Name_componentsRev(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_PrettyPrinter_Delaborator_SubExpr_withProj___at_Lean_PrettyPrinter_Delaborator_delabProj___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_bindingBody_x21(lean_object*);
 static lean_object* l_Lean_PrettyPrinter_Delaborator_delabAppExplicit___closed__1;
@@ -3038,7 +3038,7 @@ LEAN_EXPORT lean_object* l_Lean_unresolveNameGlobal_unresolveNameCore___at_Lean_
 _start:
 {
 lean_object* x_10; 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; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-x_10 = l_Lean_Name_components_x27(x_2);
+x_10 = l_Lean_Name_componentsRev(x_2);
 x_11 = lean_unsigned_to_nat(0u);
 x_12 = l_List_lengthTRAux___rarg(x_10, x_11);
 x_13 = lean_box(0);

stage0/stdlib/Lean/ResolveName.c

@@ -123,7 +123,6 @@ static lean_object* l_Std_Range_forIn_loop___at_Lean_unresolveNameGlobal_unresol
 LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lean_initFn____x40_Lean_ResolveName___hyg_68____spec__3(lean_object*, size_t, size_t, lean_object*);
 lean_object* lean_nat_sub(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_mkHashMap___at_Lean_initFn____x40_Lean_ResolveName___hyg_68____spec__1(lean_object*);
-lean_object* l_Lean_Name_components_x27(lean_object*);
 static lean_object* l_Lean_resolveUniqueNamespace___rarg___lambda__1___closed__2;
 LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lean_unresolveNameGlobal___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*);
 LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_unresolveNameGlobal_unresolveNameCore___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -268,6 +267,7 @@ lean_object* lean_usize_to_nat(size_t);
 static lean_object* l_Lean_resolveNamespace___rarg___closed__3;
 LEAN_EXPORT lean_object* l_List_toString___at_Lean_resolveGlobalConstNoOverloadCore___spec__2(lean_object*);
 LEAN_EXPORT lean_object* l_Lean_resolveGlobalConstNoOverload___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Name_componentsRev(lean_object*);
 static size_t l_Lean_PersistentHashMap_findAux___at_Lean_addAliasEntry___spec__3___closed__1;
 LEAN_EXPORT lean_object* l___private_Lean_ResolveName_0__Lean_ResolveName_resolveExact(lean_object*, lean_object*);
 LEAN_EXPORT lean_object* l_Lean_resolveNamespaceCore___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t);
@@ -5567,7 +5567,7 @@ LEAN_EXPORT lean_object* l_Lean_unresolveNameGlobal_unresolveNameCore___rarg(lea
 _start:
 {
 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* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
-x_6 = l_Lean_Name_components_x27(x_5);
+x_6 = l_Lean_Name_componentsRev(x_5);
 x_7 = lean_ctor_get(x_1, 1);
 lean_inc(x_7);
 x_8 = lean_unsigned_to_nat(0u);