-> HsDoFlavour          -- ^ source statements do flavour

   -> HsExpr GhcRn         -- ^ expanded expression

   -> HsExpr GhcRn         -- ^ suitably wrapped 'XXExprGhcRn'

                                                          , xrn_expanded = eExpr })

 data XXExprGhcTc

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

 deriving instance Data a => Data (WithUserRdr a)

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

 deriving instance Data XXPatGhcTc

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

 import GHC.Types.CostCentre.State

 import GHC.Types.Tickish

 import GHC.Types.ProfAuto

 import Control.Monad

 import Data.List (isSuffixOf, intersperse)

   d <- getDensity

   case d of

     TickForBreakPoints | isGoodBreakExpr e0 -> tick_it

                        -> dont_tick_it

                        | otherwise -> tick_it

     TickCallSites      | isCallSite e0      -> tick_it

 -- General heuristic: expressions which are calls (do not denote

 -- values) are good break points.

 isGoodBreakExpr :: HsExpr GhcTc -> Bool

 isGoodBreakExpr e = isCallSite e

 isCallSite :: HsExpr GhcTc -> Bool

                     ListComp -> Just $ BinBox QualBinBox

                     _        -> Nothing

 addTickHsExpanded o e = liftM (XExpr . ExpandedThingTc o) $ case o of

   -- We always want statements to get a tick, so we can step over each one.

   -- To avoid duplicates we blacklist SrcSpans we already inserted here.

   _                    -> skip

   where

     skip = addTickHsExpr e

 import GHC.Core.InstEnv

 import GHC.Core.Predicate         ( isEvId )

 import GHC.Tc.Types

 import GHC.Tc.Types.Evidence

 import GHC.Types.Var              ( Id, Var, EvId, varName, varType, varUnique )

 import GHC.Types.Var.Env

         ExprWithTySig _ e _ -> computeLType e

         HsPragE _ _ e -> computeLType e

         XExpr (ExpandedThingTc thing e)

           -> Just (hsExprType e)

           | otherwise -> computeType e

         XExpr (HsTick _ e) -> computeLType e

 import Language.Haskell.Syntax.Basic (FieldLabelString(..))

 import Language.Haskell.Syntax (HsExpr (RecordUpd, HsGetField, HsProjection))

 import Control.Monad      ( when, foldM, forM_ )

 import Data.Bifunctor     ( bimap )

 import GHC.CoreToIface

 import GHC.Driver.Flags

 import GHC.Hs hiding (HoleError)

 import GHC.Hs.Decls.Overlap

 import GHC.Tc.Errors.Types.PromotionErr (pprTermLevelUseCtxt)

 import GHC.Tc.Errors.Hole.FitTypes

 import GHC.Tc.Types.BasicTypes

 import GHC.Iface.Errors.Ppr

 import GHC.Iface.Syntax

 import GHC.Unit.Module

 import GHC.Data.Bag

     -> hang (text "In a stmt of" <+> pprAStmtContext ctxt <> colon)

        2 (ppr_stmt stmt)

   DerivInstCtxt pred ->

     text "When deriving the instance for" <+> parens (ppr pred)

   StandaloneDerivCtxt ty ->

  where

     addNthFunArgErrCtxt :: HsExpr GhcRn -> HsExpr GhcRn -> Int -> TcM a -> TcM a

     addNthFunArgErrCtxt app_head arg arg_no thing_inside

           thing_inside

       | otherwise

       = addErrCtxt (FunAppCtxt (FunAppCtxtExpr app_head arg) arg_no) $

 import GHC.Types.Id

 import GHC.Types.Var as Var

 import GHC.Types.Var.Set

 import GHC.Types.Name

 import GHC.Types.Name.Set

 import GHC.Types.Name.Env

                                           , text "insoluble" <+> ppr insoluble ])

        ; unless insoluble $

          do { checkEscapingKind inferred_poly_ty

                  -- See Note [Inferred type with escaping kind]

             ; checkValidType (InfSigCtxt poly_name) inferred_poly_ty }

 chooseInferredQuantifiers _ _ _ _ (Just sig)

   = pprPanic "chooseInferredQuantifiers" (ppr sig)

 -- | Warn the user about polymorphic local binders that lack type signatures.

 localSigWarn :: Id -> Maybe TcIdSigInst -> TcM ()

 localSigWarn id mb_sig

 function may be exported.  And it's easier to grok "MonoLocalBinds" as

 applying to, well, local bindings.

 -}

 import GHC.Tc.Utils.Monad

 import GHC.Tc.Utils.TcMType

 import GHC.Hs

 import GHC.Utils.Outputable

           fail_op_expr :: DynFlags -> LPat GhcRn -> HsExpr GhcRn -> LHsExpr GhcRn

           fail_op_expr dflags pat@(L pat_lspan _) fail_op

           mk_fail_msg_expr :: DynFlags -> LPat GhcRn -> LHsExpr GhcRn

           mk_fail_msg_expr dflags pat

 -}

                                    { xrn_orig = StmtErrCtxtPat (HsDoStmt flav) stmt pat

 addFunResCtxt fun args fun_res_ty env_ty thing_inside

   = do { env_tv  <- newFlexiTyVarTy liftedTypeKind

        ; dumping <- doptM Opt_D_dump_tc_trace

       -- NB: use a landmark error context, so that an empty context

       -- doesn't suppress some more useful context

   where

       = do { mb_env_ty <- readExpType_maybe env_ty

                      -- by the time the message is rendered, the ExpType

                      -- will be filled in (except if we're debugging)

            ; env'     <- case mb_env_ty of

                            Nothing     -> do { massert dumping; return env_tv }

            ; let -- See Note [Splitting nested sigma types in mismatched

                  --           function types]

                  (_, _, env_tau) = tcSplitNestedSigmaTys env'

                      -- env_ty is an ExpRhoTy, but with simple subsumption it

                      -- is not deeply skolemised, so still use tcSplitNestedSigmaTys

 funsSigCtxt (L _ name1 : _) = FunSigCtxt name1 NoRRC

 funsSigCtxt []              = panic "funSigCtxt"

 addSigCtxt ctxt hs_ty thing_inside

   = setSrcSpan l $

     addErrCtxt (UserSigCtxt ctxt hs_ty) $

   | otherwise

   = do  { (stmt', (stmts', thing)) <-

                 setSrcSpanA loc                             $

                 stmt_chk ctxt stmt res_ty                   $ \ res_ty' ->

                 popErrCtxt                                  $

                 tcStmtsAndThen ctxt stmt_chk stmts res_ty'  $

 import GHC.Tc.Utils.Concrete ( hasFixedRuntimeRep_syntactic )

 import GHC.Tc.Utils.Env

 import GHC.Tc.Utils.TcMType

 import GHC.Core.TyCo.Ppr ( pprTyVars )

 import GHC.Tc.Utils.TcType

 import GHC.Tc.Utils.Unify

         ; case NE.nonEmpty sig_tvs of

             Nothing -> do {

                 -- Just do the subsumption check and return

                           tcSubTypePat PatSigOrigin PatSigCtxt res_ty sig_ty

                 ; return (sig_ty, [], sig_wcs, wrap)

                 }

                 (addErr (TcRnCannotBindScopedTyVarInPatSig sig_tvs_ne))

               -- Now do a subsumption check of the pattern signature against res_ty

                       tcSubTypePat PatSigOrigin PatSigCtxt res_ty sig_ty

               -- Phew!

               return (sig_ty, sig_tvs, sig_wcs, wrap)

        }

   where

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

 *                                                                      *

                                 -- The instance-sig is the focus here; the class-meth-sig

                                 -- is fixed (#18036)

                    ; let orig = InstanceSigOrigin sel_name sig_ty local_meth_ty

                                 tcSubTypeSigma orig ctxt sig_ty local_meth_ty

                    ; return (sig_ty, hs_wrap) }

     poly_meth_ty  = mkSpecSigmaTy tyvars theta local_meth_ty

     theta         = map idType dfun_ev_vars

 {- Note [Instance method signatures]

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

   -- | Warning emitted when inferring use of visible dependent quantification.

   | VDQWarningCtxt !TcTyCon

   | StmtErrCtxtPat !HsStmtContextRn !(ExprLStmt GhcRn) (Pat GhcRn)

   -- | In an rebindable syntax expression.

 import GHC.Prelude

 import GHC.Tc.Utils.TcType ( TcLevel )

 import GHC.Tc.Errors.Types ( TcRnMessage )

 type ErrCtxtStack = [ErrCtxt]

 -- | Get the original source code

                    -- we are in generated code, due to the expansion of the original syntax origSrcCode

 get_src_code_origin _ = Nothing

                    -- we are in user code, so blame the expression in hand

 addLclEnvErrCtxt :: ErrCtxt -> TcLclEnv -> TcLclEnv

 addLclEnvErrCtxt ec = setLclEnvSrcCodeOrigin ec

 getLclEnvSrcCodeOrigin = get_src_code_origin . tcl_err_ctxt . tcl_lcl_ctxt

 setLclEnvSrcCodeOrigin :: ErrCtxt -> TcLclEnv -> TcLclEnv

 -- See Note [ErrCtxtStack Manipulation]

 setLclCtxtSrcCodeOrigin :: ErrCtxt -> TcLclCtxt -> TcLclCtxt

 setLclCtxtSrcCodeOrigin ec lclCtxt

   = lclCtxt { tcl_err_ctxt =  ec : ecs }

   = lclCtxt { tcl_err_ctxt =  ec : ecs }

   | otherwise

   = lclCtxt { tcl_err_ctxt = ec : tcl_err_ctxt lclCtxt }

 lclCtxtInGeneratedCode :: TcLclCtxt -> Bool

 lclCtxtInGeneratedCode lclCtxt

   = True

   | otherwise

   = False

 import GHC.Prelude

 import GHC.Tc.Utils.TcType

 import GHC.Hs

 exprCtOrigin (XExpr (ExpandedThingRn o _)) = ExpansionOrigin o

 exprCtOrigin (XExpr (HsRecSelRn f))  = OccurrenceOfRecSel $ L (getLoc $ foLabel f) (foExt f)

 srcCodeOriginCtOrigin e Nothing = exprCtOrigin e

 srcCodeOriginCtOrigin _ (Just o) = ExpansionOrigin o

       what = case o of

         StmtErrCtxt{} ->

           text "a do statement"

           text "a do statement" $$

              text "with the failable pattern" <+> quotes (ppr p)

         ExprCtxt (HsGetField _ _ (L _ f)) ->

         ExprCtxt (HsProjection _ p) -> text "the record selector" <+>

              quotes (ppr ((FieldLabelStrings $ fmap noLocA p)))

         ExprCtxt e -> text "the expression" <+> (ppr e)

 pprCtOrigin (GivenSCOrigin sk d blk)

   = vcat [ ctoHerald <+> pprSkolInfo sk

 ppr_br (ExpansionOrigin (ExprCtxt e)) = text "an expression" <+> ppr e

 ppr_br (ExpansionOrigin (StmtErrCtxt{})) = text "a do statement"

 ppr_br (ExpansionOrigin (StmtErrCtxtPat{})) = text "a do statement"

 ppr_br (ExpectedTySyntax o _) = ppr_br o

 ppr_br (ExpectedFunTySyntaxOp{}) = text "a rebindable syntax operator"

 ppr_br (ExpectedFunTyViewPat{}) = text "a view pattern"

 import GHC.Tc.Utils.TcMType

 import GHC.Tc.Utils.TcType

 import GHC.Tc.Errors.Types

 import GHC.Rename.Utils( mkRnSyntaxExpr )

         -- case of locally-polymorphic methods.

     span <- getSrcSpanM

         -- Check that the user-supplied thing has the

         -- same type as the standard one.

      hasFixedRuntimeRepRes std_nm user_nm_expr sigma1

      return (std_nm, unLoc expr)

 {-

 ************************************************************************

 *                                                                      *

 setSrcSpan _ thing_inside

   = thing_inside

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

 setSrcSpanA l = setSrcSpan (locA l)

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

 addErrCtxt :: ErrCtxtMsg -> TcM a -> TcM a

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

 -- See Note [ErrCtxtStack Manipulation]

 addExpansionErrCtxt :: ErrCtxtMsg -> TcM a -> TcM a

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

 -- | Add a message to the error context. This message may do tidying.

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

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

 addErrCtxtM ctxt = pushCtxt (MkErrCtxt VanillaUserSrcCode ctxt)

 -- See Note [ErrCtxtStack Manipulation]

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

 addExpansionErrCtxtM ctxt = pushCtxt (MkErrCtxt ExpansionCodeCtxt ctxt)

 -- reported.

 addLandmarkErrCtxt :: ErrCtxtMsg -> TcM a -> TcM a

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

 -- | Variant of 'addLandmarkErrCtxt' that allows for monadic operations

 -- and tidying.

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

 addLandmarkErrCtxtM ctxt = pushCtxt (MkErrCtxt LandmarkUserSrcCode ctxt)

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

    go _ _ _   [] = return []

    go dbg n env (MkErrCtxt LandmarkUserSrcCode ctxt : ctxts)

    go dbg n env (MkErrCtxt _ ctxt : ctxts)

      | n < mAX_CONTEXTS -- Too verbose || dbg

      | otherwise

      = go dbg n env ctxts -- need to compute this for zonking

            ; return (co, arg_ty, res_ty) }

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

     mk_ctxt _res_ty = mkFunTysMsg herald err_info

 {- Note [matchActualFunTy error handling]

 mkFunTysMsg :: CtOrigin

             -> (VisArity, TcType)

 -- See Note [Reporting application arity errors]

              n_fun_args = count isVisiblePiTyBinder pi_ty_bndrs

 {- Note [Reporting application arity errors]

  , isRhoExpTy ty_expected   -- TypeEqOrigin stuff (added by the _NC functions)

  = thing_inside             -- gives enough context by itself

  | otherwise

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

 tc_sub_type :: (TcType -> TcType -> TcM TcCoercionN)  -- How to unify

 checkValidTheta :: UserTypeCtxt -> ThetaType -> TcM ()

 -- Assumes argument is fully zonked

 checkValidTheta ctxt theta

     do { env <- liftZonkM $ tcInitOpenTidyEnv (tyCoVarsOfTypesList theta)

        ; expand <- initialExpandMode

        ; check_valid_theta env ctxt expand theta }

   generalized actually.

 -}

 tyConArityErr :: TyCon -> [TcType] -> TcRnMessage

 -- For type-constructor arity errors, be careful to report

 -- the number of /visible/ arguments required and supplied,

 data ModuleSuggestion

 data ModuleOrigin

 data UnusableUnit

 import GHC.Prelude

 import GHC.Driver.Flags

 import GHC.Types.SrcLoc

 import qualified GHC.Utils.Ppr as Pretty