refactor: optimize critical import path

src/Lean/Elab/Term.lean

@@ -24,55 +24,6 @@ import Lean.Elab.Open
 import Lean.Elab.SetOption
 
 namespace Lean.Elab.Term
-/-
-  Set isDefEq configuration for the elaborator.
-  Note that we enable all approximations but `quasiPatternApprox`
-
-  In Lean3 and Lean 4, we used to use the quasi-pattern approximation during elaboration.
-  The example:
-  ```
-  def ex : StateT δ (StateT σ Id) σ :=
-  monadLift (get : StateT σ Id σ)
-  ```
-  demonstrates why it produces counterintuitive behavior.
-  We have the `Monad-lift` application:
-  ```
-  @monadLift ?m ?n ?c ?α (get : StateT σ id σ) : ?n ?α
-  ```
-  It produces the following unification problem when we process the expected type:
-  ```
-  ?n ?α =?= StateT δ (StateT σ id) σ
-  ==> (approximate using first-order unification)
-  ?n := StateT δ (StateT σ id)
-  ?α := σ
-  ```
-  Then, we need to solve:
-  ```
-  ?m ?α =?= StateT σ id σ
-  ==> instantiate metavars
-  ?m σ =?= StateT σ id σ
-  ==> (approximate since it is a quasi-pattern unification constraint)
-  ?m := fun σ => StateT σ id σ
-  ```
-  Note that the constraint is not a Milner pattern because σ is in
-  the local context of `?m`. We are ignoring the other possible solutions:
-  ```
-  ?m := fun σ' => StateT σ id σ
-  ?m := fun σ' => StateT σ' id σ
-  ?m := fun σ' => StateT σ id σ'
-  ```
-
-  We need the quasi-pattern approximation for elaborating recursor-like expressions (e.g., dependent `match with` expressions).
-
-  If we had use first-order unification, then we would have produced
-  the right answer: `?m := StateT σ id`
-
-  Haskell would work on this example since it always uses
-  first-order unification.
--/
-def setElabConfig (cfg : Meta.Config) : Meta.Config :=
-  { cfg with foApprox := true, ctxApprox := true, constApprox := false, quasiPatternApprox := false }
-
 structure Context where
   fileName        : String
   fileMap         : FileMap

src/Lean/Meta/Basic.lean

@@ -1158,6 +1158,55 @@ def isInductivePredicate (declName : Name) : MetaM Bool := do
       | _ => return false
   | _ => return false
 
+/-
+  Set isDefEq configuration for the elaborator.
+  Note that we enable all approximations but `quasiPatternApprox`
+
+  In Lean3 and Lean 4, we used to use the quasi-pattern approximation during elaboration.
+  The example:
+  ```
+  def ex : StateT δ (StateT σ Id) σ :=
+  monadLift (get : StateT σ Id σ)
+  ```
+  demonstrates why it produces counterintuitive behavior.
+  We have the `Monad-lift` application:
+  ```
+  @monadLift ?m ?n ?c ?α (get : StateT σ id σ) : ?n ?α
+  ```
+  It produces the following unification problem when we process the expected type:
+  ```
+  ?n ?α =?= StateT δ (StateT σ id) σ
+  ==> (approximate using first-order unification)
+  ?n := StateT δ (StateT σ id)
+  ?α := σ
+  ```
+  Then, we need to solve:
+  ```
+  ?m ?α =?= StateT σ id σ
+  ==> instantiate metavars
+  ?m σ =?= StateT σ id σ
+  ==> (approximate since it is a quasi-pattern unification constraint)
+  ?m := fun σ => StateT σ id σ
+  ```
+  Note that the constraint is not a Milner pattern because σ is in
+  the local context of `?m`. We are ignoring the other possible solutions:
+  ```
+  ?m := fun σ' => StateT σ id σ
+  ?m := fun σ' => StateT σ' id σ
+  ?m := fun σ' => StateT σ id σ'
+  ```
+
+  We need the quasi-pattern approximation for elaborating recursor-like expressions (e.g., dependent `match with` expressions).
+
+  If we had use first-order unification, then we would have produced
+  the right answer: `?m := StateT σ id`
+
+  Haskell would work on this example since it always uses
+  first-order unification.
+-/
+def setElabConfig (cfg : Meta.Config) : Meta.Config :=
+  { cfg with foApprox := true, ctxApprox := true, constApprox := false, quasiPatternApprox := false }
+
 end Meta
 
 export Meta (MetaM)

src/Lean/PrettyPrinter/Delaborator/TopDownAnalyze.lean

@@ -3,7 +3,7 @@ Copyright (c) 2021 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Daniel Selsam
 -/
-import Lean.Meta
+import Lean.Meta.SynthInstance
 import Lean.Util.FindMVar
 import Lean.Util.FindLevelMVar
 import Lean.Util.CollectLevelParams
@@ -625,7 +625,7 @@ open TopDownAnalyze SubExpr
 def topDownAnalyze (e : Expr) : MetaM OptionsPerPos := do
   let s₀ ← get
   traceCtx `pp.analyze do
-    withReader (fun ctx => { ctx with config := Lean.Elab.Term.setElabConfig ctx.config }) do
+    withReader (fun ctx => { ctx with config := setElabConfig ctx.config }) do
       let ϕ : AnalyzeM OptionsPerPos := do withNewMCtxDepth analyze; (← get).annotations
       try
         let knowsType := getPPAnalyzeKnowsType (← getOptions)

src/Lean/Widget/InteractiveCode.lean

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 
 Authors: Wojciech Nawrocki
 -/
-import Lean.PrettyPrinter
+import Lean.PrettyPrinter.Delaborator.Basic
 import Lean.Server.Rpc.Basic
 import Lean.Widget.TaggedText
 

src/Lean/Widget/InteractiveDiagnostic.lean

@@ -7,7 +7,6 @@ Authors: Wojciech Nawrocki
 import Lean.Data.Lsp
 import Lean.Message
 import Lean.Elab.InfoTree
-import Lean.PrettyPrinter
 
 import Lean.Server.Utils
 import Lean.Server.Rpc.Basic

tests/lean/run/smartUnfoldingBug.lean

@@ -1,4 +1,4 @@
-import Lean.Meta
+import Lean.Elab
 open Nat
 
 structure ProvedSkip(n m: Nat) where