-- See `checkLastStmt` and `Syntax.Expr.StmtLR.LastStmt`

    | NoSyntaxExprRn <- ret_expr

    -- Last statement is just body if we are not in ListComp context. See Syntax.Expr.LastStmt

    | SyntaxExprRn ret <- ret_expr  -- We have unfortunately lost the location on the return function :(

    --

    --    ------------------------------------------------

    --               return e  ~~> return e

    -- to make T18324 work

 expand_do_stmts doFlavour (stmt@(L loc (LetStmt _ bs)) : lstmts) =

 -- See  Note [Expanding HsDo with XXExprGhcRn] Equation (3) below

 addLExprCtxt :: LHsExpr GhcRn -> TcRn a -> TcRn a

 addLExprCtxt (L lspan e) thing_inside

   | (RealSrcSpan{}) <- locA lspan

   = addExprCtxt e thing_inside

   | otherwise

         (use -fprint-potential-instances to see them all)

     • In the first argument of ‘($)’, namely ‘toList’

       In the first argument of ‘print’, namely ‘(toList $ pure 21)’

 default-fail05.hs:11:19: error: [GHC-39999]

     • Ambiguous type variable ‘t0’ arising from a use of ‘pure’

         (use -fprint-potential-instances to see them all)

     • In the second argument of ‘($)’, namely ‘pure 21’

       In the first argument of ‘print’, namely ‘(toList $ pure 21)’

 default-fail05.hs:12:3: error: [GHC-39999]

       prevents the constraint ‘(Traversable t1)’ from being solved.

       Relevant bindings include

         main :: IO (t1 ()) (bound at default-fail05.hs:10:1)

       The type variable ‘a0’ is ambiguous

     • In the first argument of ‘mapM’, namely ‘g’

       In the expression: mapM g undefined

 T26480b.hs:47:10: error: [GHC-39999]

     • No instance for ‘HasField "xyzzywyzzydyzzd" G H’

       NB: ‘G’ does not have a record field named ‘xyzzywyzzydyzzd’.

     • In the expression: (.xyzzywyzzydyzzd)

       In an equation for ‘test3a’: test3a = (.xyzzywyzzydyzzd)

 T26480b.hs:50:10: error: [GHC-39999]

     • No instance for ‘HasField "xyzzywyzzydyzze" G H’

       NB: ‘G’ does not have a record field named ‘xyzzywyzzydyzze’.

     • In the expression: (.field1.xyzzywyzzydyzze)

       In an equation for ‘test3b’: test3b = (.field1.xyzzywyzzydyzze)

 T26480b.hs:57:12: error: [GHC-39999]

     • No instance for ‘HasField "xyzzywyzzydyzzg" G H’

       NB: ‘G’ does not have a record field named ‘xyzzywyzzydyzzg’.

     • In the expression: d {field1.xyzzywyzzydyzzg = MkH 3}

       In an equation for ‘test4b’:

         KnownNat a0 arising from a use of ‘q’

     • In the first argument of ‘(+)’, namely ‘q’

       In the second argument of ‘($)’, namely ‘q + w’

 test-defaulting-plugin.hs:28:15: warning: [GHC-18042] [-Wtype-defaults (in -Wall)]

     • Defaulting the type variable ‘a0’ to type ‘2’ in the following constraints

           arising from a use of ‘w’ at test-defaulting-plugin.hs:28:15

     • In the second argument of ‘(+)’, namely ‘w’

       In the second argument of ‘($)’, namely ‘q + w’

 test-defaulting-plugin.hs:29:11: warning: [GHC-18042] [-Wtype-defaults (in -Wall)]

     • Defaulting the type variable ‘b0’ to type ‘0’ in the following constraint

 T13393.hs:61:3: error: [GHC-39999]

       prevents the constraint ‘(Traversable t0)’ from being solved.

       Probable fix: use a type annotation to specify what ‘t0’ should be.

       Potentially matching instances:

       In the expression:

       In an equation for ‘encodeLinearToAac’:

 valid_hole_fits.hs:17:17: warning: [GHC-88464] [-Wtyped-holes (in -Wdefault)]

     • Found hole: _ :: Int -> IO Int

     • In the expression: _ x

       In the expression:

         do x <- a 0

            y <- _ x

            return y

     • Relevant bindings include

         x :: Int (bound at valid_hole_fits.hs:16:12)

         c :: Int -> IO Int (bound at valid_hole_fits.hs:16:1)

                   with actual type: Maybe a3

     • In the first argument of ‘f’, namely ‘(Just 1)’

       In the second argument of ‘($)’, namely ‘f (Just 1)’

 T10971d.hs:5:19: error: [GHC-83865]

     • Couldn't match expected type: [b0]

                   with actual type: Maybe a4

     • In the second argument of ‘g’, namely ‘(Just 5)’

       In the second argument of ‘($)’, namely ‘g (+ 1) (Just 5)’

 T10971d.hs:6:23: error: [GHC-83865]

     • Couldn't match expected type: [a2]

     • Couldn't match expected type: IO a0

                   with actual type: Maybe a1 -> Maybe b0

     • Probable cause: ‘f’ is applied to too few arguments

       In the expression:

         do f

            putChar 'a'

         the type signature for:

           test :: forall (m :: * -> *). (C2 m, F2 m ~ Y) => m ()

         at T24064.hs:40:1-32

       In the expression:

         do fun1

            fun2

     • Couldn't match type ‘IO’ with ‘Maybe’

       Expected: Maybe ()

         Actual: IO ()

       In the first argument of ‘fooThen’, namely

         ‘(do bar

              undefined)’

 T6069.hs:13:15: error: [GHC-83865]

     • Couldn't match type: forall s. ST s b0

                      with: ST s0 Int

         Actual: (forall s. ST s b2) -> b2

     • In the second argument of ‘(.)’, namely ‘runST’

       In the expression: print . runST

     • Couldn't match expected type: IO a0

                   with actual type: a1 -> IO ()

     • Probable cause: ‘print’ is applied to too few arguments

       In the expression:

         do print

            print "Hello"

                       m a -> t m a’

         has only one

       In the expression: lift uniform [1, 2, 3]

                      with: (Int, a)

         arising from a functional dependency between:

           constraint ‘MonadWriter (Int, a) (WriterT [(Int, a)] Identity)’

           instance ‘MonadWriter w (WriterT w m)’ at T9612.hs:20:10-59

       In the expression:

         do tell (n, x)

            return (1, y)

       one instance involving out-of-scope types

       (use -fprint-potential-instances to see them all)

     • In the expression: thaw tmp

       In the expression:

         do let sL = [...]

                dim = length sL

                ...

            v <- thaw tmp

            return ()

 tcfail140.hs:15:15: error: [GHC-83865]

     • Couldn't match expected type ‘t -> b’ with actual type ‘Int’

       In the expression: map (3 `f`) xs

       In an equation for ‘bot’: bot xs = map (3 `f`) xs

     • Relevant bindings include

 tcfail168.hs:7:11: error: [GHC-83865]

     • Couldn't match expected type: IO a0

     • Probable cause: ‘putChar’ is applied to too few arguments

       In the expression:

       In an equation for ‘foo’:

 tcfail181.hs:17:9: error: [GHC-39999]

       from the context: Monad m

         bound by the inferred type of

                    wog :: Monad m => p -> Something (m Bool) e

         ...plus six others

         ...plus one instance involving out-of-scope types

         (use -fprint-potential-instances to see them all)

       with type constructor ‘Something’

       and data constructor ‘Something’.

       In the expression: foo {bar = return True}

 CaretDiagnostics1.hs:7:8-15: error: [GHC-83865]

     • Couldn't match expected type ‘IO a0’ with actual type ‘Int’

     • In the second argument of ‘(+)’, namely ‘(3 :: Int)’

         10000000000000000000000000000000000000 + 2 + (3 :: Int)

       In the expression:

         do 10000000000000000000000000000000000000 + 2 + (3 :: Int)