Speed up valid hole-fits by adding early abort and checks.

By adding an early abort flag in `TcSEnv`, we can fail fast in the presence of
insoluble constraints. This helps us avoid a lot of work in valid hole-fits, and
we geta massive speed-up by avoiding a lot of useless work solving constraints that
never come into play.

Additionally, we add a simple check for degenerate hole types, such as
when the type of the hole is an immutable type variable (as is the case
when the hole is completely unconstrained). Then the only valid fits are
the locals, so we can ignore the global candidates.

This fixes #16875

7 files changed, 781 insertions, 0 deletions

diff --git a/testsuite/tests/typecheck/should_compile/T16875.hs b/testsuite/tests/typecheck/should_compile/T16875.hs
new file mode 100644
index 0000000000..0ba3c17d5b
--- /dev/null
+++ b/testsuite/tests/typecheck/should_compile/T16875.hs
@@ -0,0 +1,13 @@
+module T16875 where
+
+import Control.Applicative
+import Control.Monad
+import Data.Kind
+import Data.List
+import Data.Maybe
+import Data.String
+import GHC.Exts
+import GHC.Types
+
+a = _
+
diff --git a/testsuite/tests/typecheck/should_compile/T16875.stderr b/testsuite/tests/typecheck/should_compile/T16875.stderr
new file mode 100644
index 0000000000..af6954792e
--- /dev/null
+++ b/testsuite/tests/typecheck/should_compile/T16875.stderr
@@ -0,0 +1,12 @@
+
+T16875.hs:12:5: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: p
+      Where: ‘p’ is a rigid type variable bound by
+               the inferred type of a :: p
+               at T16875.hs:12:1-5
+    • In an equation for ‘a’: a = _
+    • Relevant bindings include a :: p (bound at T16875.hs:12:1)
+      Valid hole fits include
+        a :: forall {p}. p
+          with a
+          (defined at T16875.hs:12:1)
diff --git a/testsuite/tests/typecheck/should_compile/all.T b/testsuite/tests/typecheck/should_compile/all.T
index f3be68a470..ca903c6295 100644
--- a/testsuite/tests/typecheck/should_compile/all.T
+++ b/testsuite/tests/typecheck/should_compile/all.T
@@ -397,6 +397,12 @@ test('abstract_refinement_hole_fits', normal, compile, ['-fdefer-type-errors -fn
 test('free_monad_hole_fits', normal, compile, ['-fdefer-type-errors -fno-max-valid-hole-fits -fno-max-refinement-hole-fits -frefinement-level-hole-fits=2 -funclutter-valid-hole-fits'])
 test('constraint_hole_fits', normal, compile, ['-fdefer-type-errors -fno-max-valid-hole-fits -fno-max-refinement-hole-fits -frefinement-level-hole-fits=2 -funclutter-valid-hole-fits'])
 test('type_in_type_hole_fits', normal, compile, ['-fdefer-type-errors -fno-max-valid-hole-fits'])
+test('hard_hole_fits', # Testing multiple hole-fits with lots in scope for #16875
+     compile_timeout_multiplier(0.010), # 1 is 300s, 0.010 is 3s. Without  hole-fits it takes 1s
+     compile, ['-fdefer-type-errors -fno-max-valid-hole-fits -package ghc'])
+test('T16875',  # Testing one hole-fit with a lot in scope for #16875
+     compile_timeout_multiplier(0.0015), #0.45s
+     compile, ['-fdefer-type-errors -fno-max-valid-hole-fits -package ghc'])
 test('T15370', normal, compile, ['-fdefer-type-errors -fno-max-valid-hole-fits -funclutter-valid-hole-fits'])
 test('T7408', normal, compile, [''])
 test('UnboxStrictPrimitiveFields', normal, compile, [''])
diff --git a/testsuite/tests/typecheck/should_compile/hard_hole_fits.hs b/testsuite/tests/typecheck/should_compile/hard_hole_fits.hs
new file mode 100644
index 0000000000..e523c4eabe
--- /dev/null
+++ b/testsuite/tests/typecheck/should_compile/hard_hole_fits.hs
@@ -0,0 +1,48 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE RecordWildCards #-}
+
+-- typechecking goes really fast if you uncomment this line
+
+-- {-# OPTIONS_GHC -fmax-valid-hole-fits=0 #-}
+
+module SlowTypecheck where
+
+import Language.Haskell.Syntax.Expr
+import GHC (GhcPs)
+
+testMe :: HsExpr GhcPs -> Int
+testMe (HsVar a b) = _
+testMe (HsUnboundVar xuv uv) = _
+testMe (HsOverLabel xol m_ip) = _
+testMe (HsIPVar xv hin) = _
+testMe (HsOverLit xole hol) = _
+testMe (HsLit xle hl) = _
+testMe (HsLam xl mg) = _
+testMe (HsLamCase xlc mg) = _
+testMe (HsApp xa gl gl') = _
+testMe (HsAppType xate gl hwcb) = _
+testMe (OpApp xoa gl gl' gl2) = _
+testMe (NegApp xna gl se) = _
+testMe (HsPar xp gl ab ac) = _
+testMe (SectionL xsl gl gl') = _
+testMe (SectionR xsr gl gl') = _
+testMe (ExplicitTuple xet gls box) = _
+testMe (ExplicitSum xes n i gl) = _
+testMe (HsCase xc gl mg) = _
+testMe (HsIf xi m_se gl gl' ) = _
+testMe (HsMultiIf xmi gls) = _
+testMe (HsLet xl gl gl') = _
+testMe (HsDo xd hsc gl) = _
+testMe (ExplicitList xel m_se) = _
+testMe (RecordCon xrc gl hrf) = _
+testMe (RecordUpd xru gl gls) = _
+testMe (ExprWithTySig xewts gl hwcb) = _
+testMe (ArithSeq xas m_se asi) = _
+testMe (HsBracket xb hb) = _
+testMe (HsRnBracketOut xrbo hb prss) = _
+testMe (HsTcBracketOut xtbo hb ptss as) = _
+testMe (HsSpliceE xse hs) = _
+testMe (HsProc xp pat gl) = _
+testMe (HsStatic xs gl) = _
+testMe (XExpr xe) = _
+
diff --git a/testsuite/tests/typecheck/should_compile/hard_hole_fits.stderr b/testsuite/tests/typecheck/should_compile/hard_hole_fits.stderr
new file mode 100644
index 0000000000..b30f55179b
--- /dev/null
+++ b/testsuite/tests/typecheck/should_compile/hard_hole_fits.stderr
@@ -0,0 +1,674 @@
+
+hard_hole_fits.hs:14:22: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsVar a b) = _
+    • Relevant bindings include
+        b :: Language.Haskell.Syntax.Extension.LIdP GhcPs
+          (bound at hard_hole_fits.hs:14:17)
+        a :: Language.Haskell.Syntax.Extension.XVar GhcPs
+          (bound at hard_hole_fits.hs:14:15)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:15:32: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsUnboundVar xuv uv) = _
+    • Relevant bindings include
+        uv :: GHC.Types.Name.Occurrence.OccName
+          (bound at hard_hole_fits.hs:15:26)
+        xuv :: Language.Haskell.Syntax.Extension.XUnboundVar GhcPs
+          (bound at hard_hole_fits.hs:15:22)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:16:33: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsOverLabel xol m_ip) = _
+    • Relevant bindings include
+        m_ip :: GHC.Data.FastString.FastString
+          (bound at hard_hole_fits.hs:16:25)
+        xol :: Language.Haskell.Syntax.Extension.XOverLabel GhcPs
+          (bound at hard_hole_fits.hs:16:21)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:17:27: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsIPVar xv hin) = _
+    • Relevant bindings include
+        hin :: Language.Haskell.Syntax.Type.HsIPName
+          (bound at hard_hole_fits.hs:17:20)
+        xv :: Language.Haskell.Syntax.Extension.XIPVar GhcPs
+          (bound at hard_hole_fits.hs:17:17)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:18:31: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsOverLit xole hol) = _
+    • Relevant bindings include
+        hol :: Language.Haskell.Syntax.Lit.HsOverLit GhcPs
+          (bound at hard_hole_fits.hs:18:24)
+        xole :: Language.Haskell.Syntax.Extension.XOverLitE GhcPs
+          (bound at hard_hole_fits.hs:18:19)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:19:25: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsLit xle hl) = _
+    • Relevant bindings include
+        hl :: Language.Haskell.Syntax.Lit.HsLit GhcPs
+          (bound at hard_hole_fits.hs:19:19)
+        xle :: Language.Haskell.Syntax.Extension.XLitE GhcPs
+          (bound at hard_hole_fits.hs:19:15)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:20:24: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsLam xl mg) = _
+    • Relevant bindings include
+        mg :: MatchGroup GhcPs (LHsExpr GhcPs)
+          (bound at hard_hole_fits.hs:20:18)
+        xl :: Language.Haskell.Syntax.Extension.XLam GhcPs
+          (bound at hard_hole_fits.hs:20:15)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:21:29: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsLamCase xlc mg) = _
+    • Relevant bindings include
+        mg :: MatchGroup GhcPs (LHsExpr GhcPs)
+          (bound at hard_hole_fits.hs:21:23)
+        xlc :: Language.Haskell.Syntax.Extension.XLamCase GhcPs
+          (bound at hard_hole_fits.hs:21:19)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:22:28: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsApp xa gl gl') = _
+    • Relevant bindings include
+        gl' :: LHsExpr GhcPs (bound at hard_hole_fits.hs:22:21)
+        gl :: LHsExpr GhcPs (bound at hard_hole_fits.hs:22:18)
+        xa :: Language.Haskell.Syntax.Extension.XApp GhcPs
+          (bound at hard_hole_fits.hs:22:15)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:23:35: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsAppType xate gl hwcb) = _
+    • Relevant bindings include
+        hwcb :: Language.Haskell.Syntax.Type.LHsWcType
+                  (Language.Haskell.Syntax.Extension.NoGhcTc GhcPs)
+          (bound at hard_hole_fits.hs:23:27)
+        gl :: LHsExpr GhcPs (bound at hard_hole_fits.hs:23:24)
+        xate :: Language.Haskell.Syntax.Extension.XAppTypeE GhcPs
+          (bound at hard_hole_fits.hs:23:19)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:24:33: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (OpApp xoa gl gl' gl2) = _
+    • Relevant bindings include
+        gl2 :: LHsExpr GhcPs (bound at hard_hole_fits.hs:24:26)
+        gl' :: LHsExpr GhcPs (bound at hard_hole_fits.hs:24:22)
+        gl :: LHsExpr GhcPs (bound at hard_hole_fits.hs:24:19)
+        xoa :: Language.Haskell.Syntax.Extension.XOpApp GhcPs
+          (bound at hard_hole_fits.hs:24:15)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:25:29: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (NegApp xna gl se) = _
+    • Relevant bindings include
+        se :: SyntaxExpr GhcPs (bound at hard_hole_fits.hs:25:23)
+        gl :: LHsExpr GhcPs (bound at hard_hole_fits.hs:25:20)
+        xna :: Language.Haskell.Syntax.Extension.XNegApp GhcPs
+          (bound at hard_hole_fits.hs:25:16)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:26:30: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsPar xp gl ab ac) = _
+    • Relevant bindings include
+        ac :: Language.Haskell.Syntax.Extension.LHsToken ")" GhcPs
+          (bound at hard_hole_fits.hs:26:24)
+        ab :: LHsExpr GhcPs (bound at hard_hole_fits.hs:26:21)
+        gl :: Language.Haskell.Syntax.Extension.LHsToken "(" GhcPs
+          (bound at hard_hole_fits.hs:26:18)
+        xp :: Language.Haskell.Syntax.Extension.XPar GhcPs
+          (bound at hard_hole_fits.hs:26:15)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:27:32: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (SectionL xsl gl gl') = _
+    • Relevant bindings include
+        gl' :: LHsExpr GhcPs (bound at hard_hole_fits.hs:27:25)
+        gl :: LHsExpr GhcPs (bound at hard_hole_fits.hs:27:22)
+        xsl :: Language.Haskell.Syntax.Extension.XSectionL GhcPs
+          (bound at hard_hole_fits.hs:27:18)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:28:32: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (SectionR xsr gl gl') = _
+    • Relevant bindings include
+        gl' :: LHsExpr GhcPs (bound at hard_hole_fits.hs:28:25)
+        gl :: LHsExpr GhcPs (bound at hard_hole_fits.hs:28:22)
+        xsr :: Language.Haskell.Syntax.Extension.XSectionR GhcPs
+          (bound at hard_hole_fits.hs:28:18)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:29:38: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’:
+          testMe (ExplicitTuple xet gls box) = _
+    • Relevant bindings include
+        box :: GHC.Types.Basic.Boxity (bound at hard_hole_fits.hs:29:31)
+        gls :: [HsTupArg GhcPs] (bound at hard_hole_fits.hs:29:27)
+        xet :: Language.Haskell.Syntax.Extension.XExplicitTuple GhcPs
+          (bound at hard_hole_fits.hs:29:23)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:30:35: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (ExplicitSum xes n i gl) = _
+    • Relevant bindings include
+        gl :: LHsExpr GhcPs (bound at hard_hole_fits.hs:30:29)
+        i :: GHC.Types.Basic.Arity (bound at hard_hole_fits.hs:30:27)
+        n :: GHC.Types.Basic.ConTag (bound at hard_hole_fits.hs:30:25)
+        xes :: Language.Haskell.Syntax.Extension.XExplicitSum GhcPs
+          (bound at hard_hole_fits.hs:30:21)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        n :: GHC.Types.Basic.ConTag (bound at hard_hole_fits.hs:30:25)
+        i :: GHC.Types.Basic.Arity (bound at hard_hole_fits.hs:30:27)
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:31:28: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsCase xc gl mg) = _
+    • Relevant bindings include
+        mg :: MatchGroup GhcPs (LHsExpr GhcPs)
+          (bound at hard_hole_fits.hs:31:22)
+        gl :: LHsExpr GhcPs (bound at hard_hole_fits.hs:31:19)
+        xc :: Language.Haskell.Syntax.Extension.XCase GhcPs
+          (bound at hard_hole_fits.hs:31:16)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:32:33: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsIf xi m_se gl gl') = _
+    • Relevant bindings include
+        gl' :: LHsExpr GhcPs (bound at hard_hole_fits.hs:32:25)
+        gl :: LHsExpr GhcPs (bound at hard_hole_fits.hs:32:22)
+        m_se :: LHsExpr GhcPs (bound at hard_hole_fits.hs:32:17)
+        xi :: Language.Haskell.Syntax.Extension.XIf GhcPs
+          (bound at hard_hole_fits.hs:32:14)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:33:30: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsMultiIf xmi gls) = _
+    • Relevant bindings include
+        gls :: [LGRHS GhcPs (LHsExpr GhcPs)]
+          (bound at hard_hole_fits.hs:33:23)
+        xmi :: Language.Haskell.Syntax.Extension.XMultiIf GhcPs
+          (bound at hard_hole_fits.hs:33:19)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:34:28: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsLet xl gl gl') = _
+    • Relevant bindings include
+        gl' :: LHsExpr GhcPs (bound at hard_hole_fits.hs:34:21)
+        gl :: Language.Haskell.Syntax.Binds.HsLocalBinds GhcPs
+          (bound at hard_hole_fits.hs:34:18)
+        xl :: Language.Haskell.Syntax.Extension.XLet GhcPs
+          (bound at hard_hole_fits.hs:34:15)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:35:27: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsDo xd hsc gl) = _
+    • Relevant bindings include
+        gl :: Language.Haskell.Syntax.Extension.XRec
+                GhcPs [ExprLStmt GhcPs]
+          (bound at hard_hole_fits.hs:35:21)
+        hsc :: HsDoFlavour (bound at hard_hole_fits.hs:35:17)
+        xd :: Language.Haskell.Syntax.Extension.XDo GhcPs
+          (bound at hard_hole_fits.hs:35:14)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:36:34: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (ExplicitList xel m_se) = _
+    • Relevant bindings include
+        m_se :: [LHsExpr GhcPs] (bound at hard_hole_fits.hs:36:26)
+        xel :: Language.Haskell.Syntax.Extension.XExplicitList GhcPs
+          (bound at hard_hole_fits.hs:36:22)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:37:33: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (RecordCon xrc gl hrf) = _
+    • Relevant bindings include
+        hrf :: HsRecordBinds GhcPs (bound at hard_hole_fits.hs:37:26)
+        gl :: Language.Haskell.Syntax.Extension.XRec
+                GhcPs (Language.Haskell.Syntax.Pat.ConLikeP GhcPs)
+          (bound at hard_hole_fits.hs:37:23)
+        xrc :: Language.Haskell.Syntax.Extension.XRecordCon GhcPs
+          (bound at hard_hole_fits.hs:37:19)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:38:33: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (RecordUpd xru gl gls) = _
+    • Relevant bindings include
+        gls :: Either
+                 [Language.Haskell.Syntax.Pat.LHsRecUpdField GhcPs]
+                 [LHsRecUpdProj GhcPs]
+          (bound at hard_hole_fits.hs:38:26)
+        gl :: LHsExpr GhcPs (bound at hard_hole_fits.hs:38:23)
+        xru :: Language.Haskell.Syntax.Extension.XRecordUpd GhcPs
+          (bound at hard_hole_fits.hs:38:19)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:39:40: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’:
+          testMe (ExprWithTySig xewts gl hwcb) = _
+    • Relevant bindings include
+        hwcb :: Language.Haskell.Syntax.Type.LHsSigWcType
+                  (Language.Haskell.Syntax.Extension.NoGhcTc GhcPs)
+          (bound at hard_hole_fits.hs:39:32)
+        gl :: LHsExpr GhcPs (bound at hard_hole_fits.hs:39:29)
+        xewts :: Language.Haskell.Syntax.Extension.XExprWithTySig GhcPs
+          (bound at hard_hole_fits.hs:39:23)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:40:34: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (ArithSeq xas m_se asi) = _
+    • Relevant bindings include
+        asi :: ArithSeqInfo GhcPs (bound at hard_hole_fits.hs:40:27)
+        m_se :: Maybe (SyntaxExpr GhcPs) (bound at hard_hole_fits.hs:40:22)
+        xas :: Language.Haskell.Syntax.Extension.XArithSeq GhcPs
+          (bound at hard_hole_fits.hs:40:18)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:41:28: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsBracket xb hb) = _
+    • Relevant bindings include
+        hb :: HsBracket GhcPs (bound at hard_hole_fits.hs:41:22)
+        xb :: Language.Haskell.Syntax.Extension.XBracket GhcPs
+          (bound at hard_hole_fits.hs:41:19)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:42:40: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’:
+          testMe (HsRnBracketOut xrbo hb prss) = _
+    • Relevant bindings include
+        prss :: [PendingRnSplice' GhcPs] (bound at hard_hole_fits.hs:42:32)
+        hb :: HsBracket (HsBracketRn GhcPs)
+          (bound at hard_hole_fits.hs:42:29)
+        xrbo :: Language.Haskell.Syntax.Extension.XRnBracketOut GhcPs
+          (bound at hard_hole_fits.hs:42:24)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:43:43: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’:
+          testMe (HsTcBracketOut xtbo hb ptss as) = _
+    • Relevant bindings include
+        as :: [PendingTcSplice' GhcPs] (bound at hard_hole_fits.hs:43:37)
+        ptss :: HsBracket (HsBracketRn GhcPs)
+          (bound at hard_hole_fits.hs:43:32)
+        hb :: Maybe GHC.Tc.Types.Evidence.QuoteWrapper
+          (bound at hard_hole_fits.hs:43:29)
+        xtbo :: Language.Haskell.Syntax.Extension.XTcBracketOut GhcPs
+          (bound at hard_hole_fits.hs:43:24)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:44:29: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsSpliceE xse hs) = _
+    • Relevant bindings include
+        hs :: HsSplice GhcPs (bound at hard_hole_fits.hs:44:23)
+        xse :: Language.Haskell.Syntax.Extension.XSpliceE GhcPs
+          (bound at hard_hole_fits.hs:44:19)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:45:29: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsProc xp pat gl) = _
+    • Relevant bindings include
+        gl :: LHsCmdTop GhcPs (bound at hard_hole_fits.hs:45:23)
+        pat :: Language.Haskell.Syntax.Pat.LPat GhcPs
+          (bound at hard_hole_fits.hs:45:19)
+        xp :: Language.Haskell.Syntax.Extension.XProc GhcPs
+          (bound at hard_hole_fits.hs:45:16)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:46:27: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (HsStatic xs gl) = _
+    • Relevant bindings include
+        gl :: LHsExpr GhcPs (bound at hard_hole_fits.hs:46:21)
+        xs :: Language.Haskell.Syntax.Extension.XStatic GhcPs
+          (bound at hard_hole_fits.hs:46:18)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+
+hard_hole_fits.hs:47:1: warning: [-Woverlapping-patterns (in -Wdefault)]
+    Pattern match is redundant
+    In an equation for ‘testMe’: testMe (XExpr xe) = ...
+
+hard_hole_fits.hs:47:21: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: Int
+    • In an equation for ‘testMe’: testMe (XExpr xe) = _
+    • Relevant bindings include
+        xe :: Language.Haskell.Syntax.Extension.XXExpr GhcPs
+          (bound at hard_hole_fits.hs:47:15)
+        testMe :: HsExpr GhcPs -> Int (bound at hard_hole_fits.hs:14:1)
+      Valid hole fits include
+        maxBound :: forall a. Bounded a => a
+          with maxBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
+        minBound :: forall a. Bounded a => a
+          with minBound @Int
+          (imported from ‘Prelude’ at hard_hole_fits.hs:8:8-20
+           (and originally defined in ‘GHC.Enum’))
diff --git a/testsuite/tests/typecheck/should_compile/refinement_hole_fits.hs b/testsuite/tests/typecheck/should_compile/refinement_hole_fits.hs
index 345a6c8f8e..20fac107d7 100644
--- a/testsuite/tests/typecheck/should_compile/refinement_hole_fits.hs
+++ b/testsuite/tests/typecheck/should_compile/refinement_hole_fits.hs
@@ -5,3 +5,6 @@ f = _
 
 g :: [Integer] -> Integer
 g = _ 0
+
+j :: a -> a
+j a = _
diff --git a/testsuite/tests/typecheck/should_compile/refinement_hole_fits.stderr b/testsuite/tests/typecheck/should_compile/refinement_hole_fits.stderr
index 5941b587bf..80249908b8 100644
--- a/testsuite/tests/typecheck/should_compile/refinement_hole_fits.stderr
+++ b/testsuite/tests/typecheck/should_compile/refinement_hole_fits.stderr
@@ -85,6 +85,10 @@ refinement_hole_fits.hs:4:5: warning: [-Wtyped-holes (in -Wdefault)]
           with ($!) @GHC.Types.LiftedRep @[Integer] @Integer
           (imported from ‘Prelude’ at refinement_hole_fits.hs:1:8-30
            (and originally defined in ‘GHC.Base’))
+        j (_ :: [Integer] -> Integer)
+          where j :: forall a. a -> a
+          with j @([Integer] -> Integer)
+          (bound at refinement_hole_fits.hs:10:1)
         id (_ :: [Integer] -> Integer)
           where id :: forall a. a -> a
           with id @([Integer] -> Integer)
@@ -180,6 +184,10 @@ refinement_hole_fits.hs:7:5: warning: [-Wtyped-holes (in -Wdefault)]
           with ($!) @GHC.Types.LiftedRep @Integer @([Integer] -> Integer)
           (imported from ‘Prelude’ at refinement_hole_fits.hs:1:8-30
            (and originally defined in ‘GHC.Base’))
+        j (_ :: Integer -> [Integer] -> Integer)
+          where j :: forall a. a -> a
+          with j @(Integer -> [Integer] -> Integer)
+          (bound at refinement_hole_fits.hs:10:1)
         id (_ :: Integer -> [Integer] -> Integer)
           where id :: forall a. a -> a
           with id @(Integer -> [Integer] -> Integer)
@@ -206,3 +214,20 @@ refinement_hole_fits.hs:7:5: warning: [-Wtyped-holes (in -Wdefault)]
           with (!!) @(Integer -> [Integer] -> Integer)
           (imported from ‘Prelude’ at refinement_hole_fits.hs:1:8-30
            (and originally defined in ‘GHC.List’))
+
+refinement_hole_fits.hs:10:7: warning: [-Wtyped-holes (in -Wdefault)]
+    • Found hole: _ :: a
+      Where: ‘a’ is a rigid type variable bound by
+               the type signature for:
+                 j :: forall a. a -> a
+               at refinement_hole_fits.hs:9:1-11
+    • In an equation for ‘j’: j a = _
+    • Relevant bindings include
+        a :: a (bound at refinement_hole_fits.hs:10:3)
+        j :: a -> a (bound at refinement_hole_fits.hs:10:1)
+      Valid hole fits include
+        a :: a (bound at refinement_hole_fits.hs:10:3)
+      Valid refinement hole fits include
+        j (_ :: a)
+          where j :: a -> a
+          (bound at refinement_hole_fits.hs:10:1)