data SrcCodeOrigin

   = OrigExpr (HsExpr GhcRn)                -- ^ The source, user written, expression

   | OrigStmt (ExprLStmt GhcRn) HsDoFlavour -- ^ which kind of do-block did this statement come from

 data XXExprGhcRn

                     }

   | PopErrCtxt                                     -- A hint for typechecker to pop

     go do_ql pos (arg : args) =

       do { arg' <- tcValArg do_ql pos' fun arg

          ; args' <- go do_ql pos' args

       where

     -- increment position if the argument is user written type or value argument

         pos' | EValArg{} <- arg

              = pos + 1

              | EValArgQL{} <- arg

              = pos + 1

 tcValArg :: QLFlag -> Int -> HsExpr GhcRn -> HsExprArg 'TcpInst    -- Actual argument

   -- qlMonoHsWrapper: see Note [Monomorphise instantiation variables]

 tcValArg _     _ _ (EWrap ew)          = return (EWrap ew)

                             , ea_arg    = larg@(L arg_loc arg)

                             , ea_arg_ty = sc_arg_ty })

   = addArgCtxt pos fun larg $

                  tcPolyExpr arg (mkCheckExpType exp_arg_ty)

        ; traceTc "tcValArg" $ vcat [ ppr arg'

                                    , text "}" ]

                          , ea_arg = L arg_loc arg'

                          , ea_arg_ty = noExtField }) }

   = addArgCtxt pos fun larg $

     do { -- Expose QL results to tcSkolemise, as in EValArg case

          Scaled mult exp_arg_ty <- liftZonkM $ zonkScaledTcType sc_arg_ty

        ; traceTc "tcEValArgQL }" $

            vcat [ text "app_res_rho:" <+> ppr app_res_rho ]

                          , ea_arg    = L arg_loc (mkHsWrap wrap arg')

                          , ea_arg_ty = noExtField }) }

       = go1 pos (EPrag sp prag : acc) fun_ty args

     -- Rule ITYARG from Fig 4 of the QL paper

                              : rest_args )

       = do { (ty_arg, inst_ty) <- tcVTA fun_conc_tvs fun_ty hs_ty

            ; go pos (arg' : acc) inst_ty rest_args }

     -- Rule IVAR from Fig 4 of the QL paper:

     -- Rule IARG from Fig 4 of the QL paper:

     go1 pos acc fun_ty

       = do { let herald = mk_herald tc_fun (unLoc arg)

            ; (wrap, arg_ty, res_ty) <-

                 -- NB: matchActualFunTy does the rep-poly check.

 -- There are 2 cases:

 -- 1. In the normal case, we add an informative context

 --          "In the third argument of f, namely blah"

 --          "In the expression: arg"

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

 --  See Note [Expanding HsDo with XXExprGhcRn] in GHC.Tc.Gen.Do

 addArgCtxt arg_no fun (L arg_loc arg) thing_inside

 skipQuickLook :: SrcSpan -> LHsExpr GhcRn -> Scaled TcRhoType

               -> TcM (HsExprArg 'TcpInst)

 skipQuickLook ctxt larg arg_ty

                     , ea_arg    = larg

                     , ea_arg_ty = arg_ty })

        ; traceTc "quickLookArg done }" (ppr rn_fun)

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

 *                                                                      *

 expand_do_stmts _ [] = pprPanic "expand_do_stmts: impossible happened. Empty stmts" empty

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

 -- last statement of a list comprehension, needs to explicitly return it

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

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

    -- = return $ L sloc (mkExpandedStmt stmt flav (HsPar noExtField body))

    = return body

    --

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

    --               return e  ~~> return e

 {- Note [Expanding HsDo with XXExprGhcRn]

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

 This is very similar to:

   1. Expansions done in `GHC.Rename.Expr.rnHsIf` for expanding `HsIf`; and

   2. `desugarRecordUpd` in `GHC.Tc.Gen.Expr.tcExpr` for expanding `RecordUpd`

   DO【 _ 】 maps a sequence of do statements and recursively converts them into expressions

           (2) DO【 p <- e; ss 】 = if p is irrefutable

                                    then ‹ExpansionStmt (p <- e)›

                                    else ‹ExpansionStmt (p <- e)›

           (3) DO【 let x = e; ss 】

                                  = ‹ExpansionStmt (let x = e)› (let x = e in (‹PopErrCtxt›DO【 ss 】))

                    {g2} (>>) ({l2} g p)

                              ({l3} return p))

 The 3 non-obvious points to consider are:

       ‹ExpandedThingRn do { e1; e2; e3 }›                        -- Original Do Expression

                                                                  -- Expanded Do Expression

           (‹ExpandedThingRn e1›                                  -- Original Statement

   * Whenever the typechecker steps through an `ExpandedThingRn`,

     we push the original statement in the error context, set the error location to the

     as precise as possible, and not just blame the complete `do`-block.

     Thus, when we typecheck the application `(>>) e1`, we push the "In the stmt of do block e1" with

     the source location of `e1` in the error context stack as we walk inside an `ExpandedThingRn`.

   * After the expanded expression of a `do`-statement is typechecked

     and before moving to the next statement of the `do`-block, we need to first pop the top

        res_ty

   = assert (notNull rbnds) $

     do  { -- Expand the record update. See Note [Record Updates].

             <- expandRecordUpd record_expr possible_parents rbnds res_ty

           setInGeneratedCode (OrigExpr expr) $

           do { -- Typecheck the expanded expression.

                expr' <- tcExpr ds_expr (Check ds_res_ty)

          tcExpr e res_ty

 tcXExpr (ExpandedThingRn o e) res_ty

 -- For record selection, same as HsVar case

 tcXExpr xe res_ty = tcApp (XExpr xe) res_ty

        -- STEP 2 (b): expand to HsCase, as per note [Record Updates]

        ; let ds_expr :: HsExpr GhcRn

              case_expr :: HsExpr GhcRn

              case_expr = HsCase RecUpd record_expr

              upd_ids_lhs = [ (NonRecursive, [genSimpleFunBind (idName id) [] rhs])

                            | (_, (id, rhs)) <- upd_ids ]

              mk_idSig :: (Name, (Id, LHsExpr GhcRn)) -> LSig GhcRn

                -- We let-bind variables using 'IdSig' in order to accept

                -- record updates involving higher-rank types.

                -- See Wrinkle [Using IdSig] in Note [Record Updates].

         ; traceTc "expandRecordUpd" $

             vcat [ text "relevant_con:" <+> ppr relevant_con

   innermost un-expanded head as the "error head".

 * A list of HsExprArg, the arguments

 -}

 data TcPass = TcpRn     -- Arguments decomposed

 data HsExprArg (p :: TcPass) where -- See Note [HsExprArg]

   -- Data constructor EValArg represents a value argument

              , ea_arg_ty :: !(XEVAType p)

              , ea_arg    :: LHsExpr (GhcPass (XPass p)) }

           -> HsExprArg p

   -- Data constructor EValArgQL represents an argument that has been

   -- partly-type-checked by Quick Look; see Note [EValArgQL]

                , eaql_arg_ty  :: Scaled TcSigmaType  -- Argument type expected by function

                , eaql_larg    :: LHsExpr GhcRn       -- Original application, for

                                                      -- location and error msgs

                , eaql_res_rho :: TcRhoType }           -- Result type of the application

             -> HsExprArg 'TcpInst  -- Only exists in TcpInst phase

               , ea_hs_ty  :: LHsWcType GhcRn  -- The type arg

               , ea_ty_arg :: !(XETAType p) }  -- Kind-checked type arg

            -> HsExprArg p

   XPass 'TcpTc   = 'Typechecked

 mkEValArg :: SrcSpan -> LHsExpr GhcRn -> HsExprArg 'TcpRn

                            , ea_arg_ty = noExtField }

 mkETypeArg :: SrcSpan -> LHsWcType GhcRn -> HsExprArg 'TcpRn

            , ea_hs_ty = hs_ty

            , ea_ty_arg = noExtField }

 rebuildHsApps (fun, _) [] = fun

 rebuildHsApps (fun, sloc) (arg : args)

   = case arg of

         -> rebuildHsApps (HsApp noExtField lfun arg, sloc') args

         -> rebuildHsApps (HsAppType ty lfun hs_ty, sloc') args

       EPrag sloc' p

         -> rebuildHsApps (HsPragE noExtField p lfun, sloc') args

   ppr (EPrag _ p)                     = text "EPrag" <+> ppr p

   ppr (ETypeArg { ea_hs_ty = hs_ty }) = char '@' <> ppr hs_ty

   ppr (EWrap wrap)                    = ppr wrap

     = text "EValArg" <> braces (ppr sloc) <+> ppr arg

   ppr (EValArgQL { eaql_tc_fun = fun, eaql_args = args, eaql_res_rho = ty})

     = hang (text "EValArgQL" <+> ppr fun)

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

     }

 data ErrCtxtStack

 isGeneratedCodeCtxt :: ErrCtxtStack -> Bool

 isGeneratedCodeCtxt UserCodeCtxt{} = False

 isGeneratedCodeCtxt _ = True

 get_src_code_origin :: ErrCtxtStack -> Maybe SrcCodeOrigin

 get_src_code_origin (UserCodeCtxt{}) = Nothing

 get_src_code_origin es = Just $ src_code_origin es

 modify_err_ctxt_stack :: ([ErrCtxt] -> [ErrCtxt]) -> ErrCtxtStack -> ErrCtxtStack

 modify_err_ctxt_stack f (UserCodeCtxt e) =  UserCodeCtxt (f e)

 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

 setLclEnvErrCtxt ctxt = modifyLclCtxt (\env -> env { tcl_ctxt = modify_err_ctxt_stack (\ _ -> ctxt) (tcl_ctxt env) })

 setLclEnvSrcCodeOrigin o = modifyLclCtxt (setLclCtxtSrcCodeOrigin o)

 setLclCtxtSrcCodeOrigin :: SrcCodeOrigin -> TcLclCtxt -> TcLclCtxt

 lclCtxtInGeneratedCode :: TcLclCtxt -> Bool

 lclCtxtInGeneratedCode = isGeneratedCodeCtxt . tcl_ctxt

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

 -- See Note [Error contexts in generated code]

 setSrcSpan (RealSrcSpan loc _) thing_inside

               thing_inside

 setSrcSpan (UnhelpfulSpan _) thing_inside

 -- | Mark the inner computation as being done inside generated code.

 --

 -- See Note [Error contexts in generated code]

 setInGeneratedCode :: SrcCodeOrigin -> TcRn a -> TcRn a

 setInGeneratedCode sco thing_inside =

   updLclCtxt (setLclCtxtSrcCodeOrigin sco) thing_inside

 Note [Error contexts in generated code]

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

 -}

 getErrCtxt :: TcM [ErrCtxt]