-- | Wrap a located expression with a `PopErrCtxt`

 genPopErrCtxtExpr :: LHsExpr GhcRn -> LHsExpr GhcRn

 mkExpandedPatRn :: Pat GhcRn -> HsExpr GhcRn -> HsExpr GhcRn

 mkExpandedPatRn pat e = XExpr (ExpandedThingRn (OrigPat pat) e)

    --    f x = _

    -- when we don't want to say "In the expression: _",

    -- because it is mentioned in the error message itself

       _ -> addErrCtxt (ExprCtxt e) thing_inside -- no op in generated code

 {-# LANGUAGE UndecidableInstances #-}

 module GHC.Tc.Types.ErrCtxt

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

   , TyConInstFlavour(..)

   )

 import GHC.Types.Basic       ( TyConFlavour )

 import GHC.Types.Name        ( Name )

 import GHC.Types.Var         ( Id, TyCoVar )

 import GHC.Types.Var.Env     ( TidyEnv )

 -- | Additional context to include in an error message, e.g.

 -- "In the type signature ...", "In the ambiguity check for ...", etc.

         -- Monadic so that we have a chance

         -- to deal with bound type variables just before error

         -- message construction

         -- Bool:  True <=> this is a landmark context; do not

         --                 discard it when trimming for display

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

 -- Error message contexts

   | MergeSignaturesCtxt !UnitState !ModuleName ![InstantiatedModule]

   -- | While checking that a module implements a Backpack signature.

   | CheckImplementsCtxt !UnitState !Module !InstantiatedModule

   , addLclEnvErrCtxt

   , ArrowCtxt(..)

   , ThBindEnv

   , TcTypeEnv

 -- See Note [Error Context Stack]

 -- | Are we in a generated context?

 isGeneratedCodeCtxt :: ErrCtxtStack -> Bool

 -- | Get the original source code

 get_src_code_origin :: ErrCtxtStack -> Maybe SrcCodeOrigin

                    -- we are in generated code, so extract the original expression

 data TcLclCtxt

   = TcLclCtxt {

         tcl_loc        :: RealSrcSpan,     -- Source span

         tcl_tclvl      :: TcLevel,

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

                                            -- and for tidying type

 getLclEnvLoc = tcl_loc . tcl_lcl_ctxt

 getLclEnvErrCtxt :: TcLclEnv -> [ErrCtxt]

 setLclEnvErrCtxt :: [ErrCtxt] -> TcLclEnv -> TcLclEnv

 addLclEnvErrCtxt :: ErrCtxt -> TcLclEnv -> TcLclEnv

 getLclEnvSrcCodeOrigin :: TcLclEnv -> Maybe SrcCodeOrigin

 setLclEnvSrcCodeOrigin :: SrcCodeOrigin -> TcLclEnv -> TcLclEnv

 setLclEnvSrcCodeOrigin o = modifyLclCtxt (setLclCtxtSrcCodeOrigin o)

 setLclCtxtSrcCodeOrigin :: SrcCodeOrigin -> TcLclCtxt -> TcLclCtxt

 lclCtxtInGeneratedCode :: TcLclCtxt -> Bool

 lclEnvInGeneratedCode :: TcLclEnv -> Bool

 lclEnvInGeneratedCode = lclCtxtInGeneratedCode . tcl_lcl_ctxt

 import GHC.Tc.Types.Constraint

 import GHC.Tc.Types.CtLoc

 import GHC.Tc.Types.Evidence

 import GHC.Tc.Types.LclEnv

 import GHC.Tc.Types.Origin

 import GHC.Tc.Types.TcRef

                 tcl_lcl_ctxt   = TcLclCtxt {

                 tcl_loc        = loc,

                 -- tcl_loc should be over-ridden very soon!

                 tcl_rdr        = emptyLocalRdrEnv,

                 tcl_th_ctxt    = topLevel,

                 tcl_th_bndrs   = emptyNameEnv,

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

 -- See Note [Error contexts in generated code]

 setSrcSpan (RealSrcSpan loc _) thing_inside

 setSrcSpan (UnhelpfulSpan _) thing_inside

   = thing_inside

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

 addErrCtxtM :: (TidyEnv -> ZonkM (TidyEnv, ErrCtxtMsg)) -> TcM a -> TcM a

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

 -- | Add a fixed landmark message to the error context. A landmark

 -- message is always sure to be reported, even if there is a lot of

 -- and tidying.

 addLandmarkErrCtxtM :: (TidyEnv -> ZonkM (TidyEnv, ErrCtxtMsg)) -> TcM a -> TcM a

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

 -- | NB. no op in generated code

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

 updCtxt :: ErrCtxt -> TcLclEnv -> TcLclEnv

 -- Do not update the context if we are in generated code

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

 popErrCtxt :: TcM a -> TcM a

 popErrCtxt thing_inside = updLclEnv (\env -> setLclEnvErrCtxt (pop $ getLclEnvErrCtxt env) env) $

  where

    go :: Bool -> Int -> TidyEnv -> [ErrCtxt] -> TcM [ErrCtxtMsg]

    go _ _ _   [] = return []

      | is_landmark || n < mAX_CONTEXTS -- Too verbose || dbg

      = do { (env', msg) <- liftZonkM $ ctxt env

           ; let n' = if is_landmark then n else n+1

           ; return (msg : rest) }

      | otherwise

      = go dbg n env ctxts

 mAX_CONTEXTS :: Int     -- No more than this number of non-landmark contexts