fix: First miss-handling of free variables

DocGen4/Process/NameInfo.lean

@@ -15,33 +15,37 @@ def NameInfo.ofTypedName (n : Name) (t : Expr) : MetaM NameInfo := do
   let env ← getEnv
   return { name := n, type := ← prettyPrintTerm t, doc := ← findDocString? env n}
 
-partial def typeToArgsType (e : Expr) : (Array ((Option Name) × Expr × BinderInfo) × Expr) :=
+partial def argTypeTelescope {α : Type} (e : Expr) (k : Array ((Option Name) × Expr × BinderInfo) → Expr → MetaM α) : MetaM α :=
-  let helper := fun name type body data =>
+  go e #[]
+where
+  go (e : Expr) (args : Array ((Option Name) × Expr × BinderInfo)) : MetaM α := do
+    let helper := fun name type body bi =>
       -- Once we hit a name with a macro scope we stop traversing the expression
       -- and print what is left after the : instead. The only exception
       -- to this is instances since these almost never have a name
       -- but should still be printed as arguments instead of after the :.
-    if data.isInstImplicit && name.hasMacroScopes then
+      if bi.isInstImplicit && name.hasMacroScopes then
-      let arg := (none, type, data)
+        let arg := (none, type, bi)
-      let (args, final) := typeToArgsType (Expr.instantiate1 body (mkFVar ⟨name⟩))
+        Meta.withLocalDecl name bi type fun fvar => do
-      (#[arg] ++ args, final)
+          go (Expr.instantiate1 body fvar) (args.push arg)
       else if name.hasMacroScopes then
-      (#[], e)
+        k args e
       else
-      let arg := (some name, type, data)
+        let arg := (some name, type, bi)
-      let (args, final) := typeToArgsType (Expr.instantiate1 body (mkFVar ⟨name⟩))
+        Meta.withLocalDecl name bi type fun fvar => do
-      (#[arg] ++ args, final)
+          go (Expr.instantiate1 body fvar) (args.push arg)
     match e.consumeMData with
     | Expr.forallE name type body binderInfo => helper name type body binderInfo
-  | _ => (#[], e)
+    | _ => k args e
 
 def Info.ofConstantVal (v : ConstantVal) : MetaM Info := do
-  let (args, type) := typeToArgsType v.type
+  argTypeTelescope v.type fun args type => do
     let args ← args.mapM (fun (n, e, b) => do return Arg.mk n (← prettyPrintTerm e) b)
     let nameInfo ← NameInfo.ofTypedName v.name type
     match ← findDeclarationRanges? v.name with
     -- TODO: Maybe selection range is more relevant? Figure this out in the future
-  | some range => return {
+    | some range =>
+      return {
         toNameInfo := nameInfo,
         args,
         declarationRange := range.range,