-- ^ Suggested fixes

               -> TcM (MsgEnvelope TcRnMessage)

 mkErrorReport tcl_env msg mb_ctxt supp hints

        ; unit_state <- hsc_units <$> getTopEnv

        ; hfdc <- getHoleFitDispConfig

        ; let

 pprTypeSyntaxName FunctionArrowSyntax   = "function type arrow (->)"

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

 pprTyConInstFlavour :: TyConInstFlavour -> SDoc

 pprTyConInstFlavour

                                     , ppr arg

                                     , ppr arg_no])

        ; setSrcSpanA arg_loc $

        }

   | otherwise

   = do { traceTc "addArgCtxt" (vcat [text "generated Head"

                                     , ppr app_head_lspan

                                     , ppr arg_loc

                                     , ppr arg])

        }

                            , eaql_res_rho  = app_res_rho }) }}}

           -> HsExpr GhcRn  -- The head of the expression application chain

           -> TcM CtOrigin

 mk_origin fun_lspan rn_fun

   | not (isGeneratedSrcSpan fun_lspan)

   = return $ exprCtOrigin rn_fun

        }

                             -> TcM (LHsExpr GhcTc)

 tcPolyLExpr (L loc expr) res_ty

     do { expr' <- tcPolyExpr expr res_ty

        ; return (L loc expr') }

 tcInferExpr   = tc_infer_expr    IFRR_Any

 tcInferExprNC = tc_infer_expr_NC IFRR_Any

 tc_infer_expr ifrr iif (L loc expr)

     do { (expr', rho) <- runInfer iif ifrr (tcExpr expr)

        ; return (L loc expr', rho) }

     -> TcM (LHsExpr GhcTc)

 tcMonoLExpr (L loc expr) res_ty

 tcMonoLExprNC (L loc expr) res_ty

   = setSrcSpanA loc $

   where `ee` is the expansion of the user written thing `ue`

 * The type checker context has 3 key fields that describe the context:

                , tcl_in_gen_code :: Bool

                , ... }

   Note `tcl_loc` always points to a real place in the source code,

   hence `RealSrcSpan`.

 * Now, when

       tcMonoLExpr :: LHsExpr GhcRn -> ExpRhoType -> TcM (HsExpr GhcTc)

 * The type checker error-stack element `GHC.Tc.Types.ErrCtxt.HsCtxt`

   just stores an error message

   When called on an `XExpr`, `addLExprCtxt`, adds the user written thing

   `ue`, and the error message provided by the caller on the `ErrCtxtStack` See

 with_get_ds mthing =

   do { (expr_tc, sig_ty) <- mthing

      ; ds_flag <- getDeepSubsumptionFlag_DataConHead expr_tc

 so that constraints arising in the thing_inside can be discharged by the

 pattern.

 want the error-context for the pattern to scope over the RHS.

 Hence the getErrCtxt/setErrCtxt stuff in tcMultiple

 -}

         FrontendResult(..),

         -- Renamer types

         ImportAvails(..), emptyImportAvails, plusImportAvails,

         ImportUserSpec(..),

         ImpUserList(..),

 -- when reporting errors, see `setCtLocM`.

 --

 -- See also 'TcLclCtxt'.

                          , ctl_loc :: !RealSrcSpan

                          , ctl_bndrs :: !TcBinderStack

                          , ctl_tclvl :: !TcLevel

 {-# LANGUAGE UndecidableInstances #-}

 module GHC.Tc.Types.ErrCtxt

   , UserSigType(..), FunAppCtxtFunArg(..)

   , TyConInstFlavour(..)

   -- * UserTypeCtxt

   , UserTypeCtxt(..), pprUserTypeCtxt, isSigMaybe

 {- *********************************************************************

 *                                                                      *

           UserTypeCtxt

 *                                                                      *

 ********************************************************************* -}

 {- *********************************************************************

 *                                                                      *

 *                                                                      *

 ********************************************************************* -}

 data UserSigType

   = UserLHsSigType !(LHsSigType GhcRn)

   , setLclEnvTypeEnv

   , modifyLclEnvTcLevel

   , setLclEnvHsCtxt

   , setLclCtxtHsCtxt

   , lclEnvInGeneratedCode

         tcl_errs :: TcRef (Messages TcRnMessage)     -- Place to accumulate diagnostics

     }

 -- | Get the top of the error message stack

 get_err_ctxt_stack_head :: ErrCtxtStack -> HsCtxt

 get_err_ctxt_stack_head (e : _) = e

   = TcLclCtxt {

         tcl_loc         :: RealSrcSpan,     -- Source span

         tcl_in_gen_code :: Bool,            -- Are we type checking a generated expression?

         tcl_tclvl       :: TcLevel,

         tcl_bndrs       :: TcBinderStack,   -- Used for reporting relevant bindings,

                                             -- and for tidying type

 getLclEnvLoc :: TcLclEnv -> RealSrcSpan

 getLclEnvLoc = tcl_loc . tcl_lcl_ctxt

 getLclEnvErrCtxt = tcl_err_ctxt . tcl_lcl_ctxt

 setLclEnvErrCtxt :: ErrCtxtStack -> TcLclEnv -> TcLclEnv

 setLclEnvErrCtxt ctxt = modifyLclCtxt (\env -> env { tcl_err_ctxt = ctxt })

 -- See Note [ErrCtxtStack Manipulation]

 addLclEnvErrCtxt ec = setLclEnvHsCtxt ec

 setLclEnvHsCtxt ec = modifyLclCtxt (setLclCtxtHsCtxt ec)

 -- See Note [ErrCtxtStack Manipulation]

 setLclCtxtHsCtxt ec lclCtxt

   | StmtErrCtxt{} : ecs <- tcl_err_ctxt lclCtxt

   , StmtErrCtxt{} <- ec

   = lclCtxt { tcl_err_ctxt =  ec : ecs }

   addDependentFiles, addDependentDirectories,

   -- * Error management

   getSrcSpanM, getRealSrcSpanM, setSrcSpan, setSrcSpanA, addLocM,

   inGeneratedCode,

   wrapLocM, wrapLocFstM, wrapLocFstMA, wrapLocSndM, wrapLocSndMA, wrapLocM_,

   -- * Context management for the type checker

   getErrCtxt, setErrCtxt, addErrCtxt,

   popErrCtxt, getCtLocM, setCtLocM, mkCtLocEnv,

   -- * Diagnostic message generation (type checker)

   checkTc, checkTcM,

   checkJustTc, checkJustTcM,

   failIfTc, failIfTcM,

   addTcRnDiagnostic, addDetailedDiagnostic,

   mkTcRnMessage, reportDiagnostic, reportDiagnostics,

   warnIf, diagnosticTc, diagnosticTcM,

 setSrcSpan :: SrcSpan -> TcRn a -> TcRn a

 -- See Note [Error contexts in generated code]

 setSrcSpan (RealSrcSpan loc _) thing_inside

   = updLclCtxt (\ctxt -> ctxt {tcl_loc = loc, tcl_in_gen_code = False}) thing_inside

 setSrcSpan (GeneratedSrcSpan{}) thing_inside

 setSrcSpan _ thing_inside

   = thing_inside

 setSrcSpanA :: EpAnn ann -> TcRn a -> TcRn a

 setSrcSpanA l = setSrcSpan (locA l)

 -- work doesn't matter

 addErrAt loc msg = do { ctxt <- getErrCtxt

                       ; tidy_env <- liftZonkM $ tcInitTidyEnv

                       ; let detailed_msg = mkDetailedMessage (ErrInfo err_ctxt Nothing noHints) msg

                       ; add_long_err_at loc detailed_msg }

 Note [Error contexts in generated code]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 This ensures that the error messages do not leak compiler generated expressions which can

 be confusing to the users as they never appear in the original source code

 - See Note [Rebindable syntax and XXExprGhcRn] in `GHC.Hs.Expr` for

 - See Note [Generated code and pattern-match checking] in `GHC.Types.Basic` for the

 -}

 -- See Note [Error contexts in generated code]

 getErrCtxt = do { env <- getLclEnv; return (getLclEnvErrCtxt env) }

 {-# INLINE setErrCtxt #-}   -- Note [Inlining addErrCtxt]

 setErrCtxt ctxt = updLclEnv (setLclEnvErrCtxt ctxt)

 addErrCtxt ctxt = pushCtxt ctxt

 -- See Note [Rebindable syntax and XXExprGhcRn] in GHC.Hs.Expr

 {-# INLINE pushCtxt #-} -- Note [Inlining addErrCtxt]

 pushCtxt ctxt = updLclEnv (addLclEnvErrCtxt ctxt)

 addDiagnosticTcM :: (TidyEnv, TcRnMessage) -> TcM ()

 addDiagnosticTcM (env0, msg)

  = do { ctxt <- getErrCtxt

       ; let detailed_msg = mkDetailedMessage (ErrInfo extra Nothing noHints) msg

       ; add_diagnostic detailed_msg }

   !diag_opts  <- initDiagOpts <$> getDynFlags

   env0 <- liftZonkM tcInitTidyEnv

   ctxt <- getErrCtxt

   reportDiagnostic $

     mkMsgEnvelope diag_opts loc name_ppr_ctx $

       mkMsg err_info

 -}

 add_err_tcm :: TidyEnv -> TcRnMessage -> SrcSpan

             -> TcM ()

 add_err_tcm tidy_env msg loc ctxt

       ; add_long_err_at loc $

           mkDetailedMessage (ErrInfo err_ctxt Nothing noHints) msg }

 --  = do

 --       dbg <- hasPprDebug <$> getDynFlags

 --       if dbg                -- In -dppr-debug style the output

 --          else go dbg 0 env ctxts

  = go False 0 env ctxts -- regular error ctx

  where

    go _ _ _ [] = return []

    go dbg n env (ctxt : ctxts)

      | isHsCtxtLandmark ctxt

          -- snocBag: see Note [Work-list ordering] in GHC.Tc.Solver.Equality

        -- Error trace only

        --     because it is hugely expensive (#5631)

        ; whenDOptM Opt_D_dump_tc_trace $

          do { ctxt     <- getErrCtxt

             ; traceTc "utype_defer" $

                 vcat ( ppr role

                      : debugPprType ty1

 zonkTidyHsCtxt :: TidyEnv -> HsCtxt -> ZonkM (TidyEnv, HsCtxt)

 zonkTidyHsCtxt env e@(ExprCtxt{}) = return (env, e)

 zonkTidyHsCtxt env (ThetaCtxt ctxt theta_ty) = do

   (env', theta_ty') <- zonkTidyTcTypes env theta_ty

   as used in GHC.Tc.Zonk.TcType.

   Crucially, it never errors. It is the monad we use when reporting errors

   of reporting an error!

 I.2. GHC.Tc.Zonk.TcType - zonking types in the typechecker