*                                                                      *

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

 data XXExprGhcRn

   | HsRecSelRn  (FieldOcc GhcRn)   -- ^ Variable pointing to record selector

                            -- See Note [Non-overloaded record field selectors] and

   = WrapExpr        -- Type and evidence application and abstractions

       HsWrapper (HsExpr GhcTc)

   | ConLikeTc

       -- ^ A 'ConLike', either a data constructor or pattern synonym

   GhcRn -> ppr x

   GhcTc -> ppr x

     where

       ppr_builder prefix x = ifPprDebug (braces (text prefix <+> parens x)) x

       pprCtxt :: HsCtxt -> SDoc

       pprCtxt (FunAppCtxt (FunAppCtxtExpr _ e) _) = ppr_builder "<FunAppCtxt>:"  (ppr e)

       pprCtxt _ = ppr_builder "<MiscHsCtxt>:" empty

 instance Outputable XXExprGhcTc where

   ppr (WrapExpr co_fn e)

     = pprHsWrapper co_fn (\_parens -> pprExpr e)

   ppr (ConLikeTc con) = pprPrefixOcc con

    -- Used in error messages generated by

 ppr_infix_expr _ = Nothing

 ppr_infix_expr_rn :: XXExprGhcRn -> Maybe SDoc

 ppr_infix_expr_rn (HsRecSelRn f)            = Just (pprInfixOcc f)

 ppr_infix_expr_tc :: XXExprGhcTc -> Maybe SDoc

 ppr_infix_expr_tc (WrapExpr _ e)    = ppr_infix_expr e

 ppr_infix_expr_tc (ConLikeTc con)            = Just (pprInfixOcc (conLikeName con))

 ppr_infix_expr_tc (HsTick {})                = Nothing

 ppr_infix_expr_tc (HsBinTick {})             = Nothing

     go_x_tc :: XXExprGhcTc -> Bool

     go_x_tc (WrapExpr _ e)                   = hsExprNeedsParens prec e

     go_x_tc (ConLikeTc {})                   = False

     go_x_tc (HsTick _ (L _ e))               = hsExprNeedsParens prec e

     go_x_tc (HsBinTick _ _ (L _ e))          = hsExprNeedsParens prec e

     go_x_tc (HsRecSelTc{})                   = False

     go_x_rn :: XXExprGhcRn -> Bool

     go_x_rn (HsRecSelRn{})               = False

     hsExpandedNeedsParens :: HsCtxt -> Bool

   where

     go_x_tc :: XXExprGhcTc -> Bool

     go_x_tc (WrapExpr _ e)            = isAtomicHsExpr e

     go_x_tc (ConLikeTc {})            = True

     go_x_tc (HsTick {})               = False

     go_x_tc (HsBinTick {})            = False

     go_x_tc (HsRecSelTc{})            = True

     go_x_rn :: XXExprGhcRn -> Bool

     go_x_rn (HsRecSelRn{})              = True

     isAtomicExpandedThingRn :: HsCtxt -> Bool

 deriving instance Data XXExprGhcRn

 deriving instance Data a => Data (WithUserRdr a)

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

 hsExprType (HsForAll x _ _) = dataConCantHappen x

 hsExprType (HsFunArr x _ _ _) = dataConCantHappen x

 hsExprType (XExpr (WrapExpr wrap e)) = hsWrapperType wrap $ hsExprType e

 hsExprType (XExpr (ConLikeTc con)) = conLikeType con

 hsExprType (XExpr (HsTick _ e)) = lhsExprType e

 hsExprType (XExpr (HsBinTick _ _ e)) = lhsExprType e

       WrapExpr {}   -> dsApp e

       ConLikeTc {}  -> dsApp e

       -- Hpc Support

       HsTick tickish e -> do

     -- we have to compare the wrappers

     exp (XExpr (WrapExpr h e)) (XExpr (WrapExpr h' e')) =

       wrap h h' && exp e e'

       = lexp x x'

     exp (HsVar _ i) (HsVar _ i') = i == i'

     exp (HsIPVar _ i) (HsIPVar _ i') =

   arg' <- repLE arg

   res' <- repLE res

   repApps fun [arg', res']

   | ExprCtxt e <- o

   = do { rebindable_on <- lift $ xoptM LangExt.RebindableSyntax

        ; if rebindable_on  -- See Note [Quotation and rebindable syntax]

   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

 isCallSite HsApp{}     = True

 isCallSite HsAppType{} = True

 isCallSite HsCase{}    = True

   = isCallSite (unLoc e)

 -- NB: OpApp, SectionL, SectionR are all expanded out

 addTickHsExpr (XExpr (WrapExpr w e)) =

         liftM (XExpr . WrapExpr w) $

               (addTickHsExpr e)        -- Explicitly no tick on inside

 addTickHsExpr e@(XExpr (ConLikeTc {})) = return e

   -- We used to do a freeVar on a pat-syn builder, but actually

                     ListComp -> Just $ BinBox QualBinBox

                     _        -> Nothing

   -- 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.

   StmtErrCtxt _ (L pos _) -> do_tick_black pos

         RecordCon con_expr _ _ -> computeType con_expr

         ExprWithTySig _ e _ -> computeLType e

         HsPragE _ _ e -> computeLType e

           | ExprCtxt (HsGetField{}) <- thing -- for record-dot-syntax

           -> Just (lhsExprType e)

           | otherwise -> computeLType e

           WrapExpr w a

             -> [ toHie $ L mspan a

                , toHie (L mspan w) ]

             -> [ toHie e ]

           ConLikeTc con

             -> [ toHie $ C Use $ L mspan $ conLikeName con ]

 mkExpandedRn

   :: HsCtxt          -- ^ source, user written do statement/expression

   -> LHsExpr GhcRn           -- ^ expanded typechecked expression

 -- | Build a 'XXExprGhcRn' out of an extension constructor,

 --   and the two components of the expansion: original and

 mkExpandedTc

   :: HsCtxt          -- ^ source, user written do statement/expression

   -> LHsExpr GhcTc           -- ^ expanded typechecked expression

       | otherwise = not_in_scope

       where occ = occName rdr

             not_in_scope = failWith $ TcRnNotInScope NotInScope rdr

       -- Use the original, user-written expression (before expansion).

       -- Example. Say we have   vfun :: forall a -> blah

       --          and the call  vfun (Maybe [1,2,3])

               -> Scaled TcRhoType  -- Deeply skolemised

               -> TcM (HsExprArg 'TcpInst)

 -- quickLookArg1 implements the "QL Argument" judgement in Fig 5 of the paper

   = addArgCtxt pos (fun, fun_lspan) larg $ -- Context needed for constraints

                            -- generated by calls in arg

     do { ((rn_fun_arg, fun_lspan_arg), rn_args) <- splitHsApps arg

              <- captureConstraints $

                 tcInstFun do_ql True ds_flag_arg (arg_orig, rn_fun_arg, fun_lspan_arg) tc_fun_arg_head fun_sigma_arg_head rn_args

                 -- We must capture type-class and equality constraints here, but

                 -- value arguments]

        ; traceTc "quickLookArg 2" $

 --   so that they can be typechecked.

 --   See Note [Expanding HsDo with XXExprGhcRn] below for `HsDo` specific commentary

 --   and Note [Handling overloaded and rebindable constructs] for high level commentary

 -- | The main work horse for expanding do block statements into applications of binds and thens

 --   See Note [Expanding HsDo with XXExprGhcRn]

 To disabmiguate desugaring (`HsExpr GhcTc -> Core.Expr`) we use the phrase expansion

 (`HsExpr GhcRn -> HsExpr GhcRn`)

 See Part 2. of Note [Doing XXExprGhcRn in the Renamer vs Typechecker] in `GHC.Rename.Expr`

 Historical note START

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

                                                                  -- Expanded Do Expression

           (‹ExpandedThingRn e1›                                  -- Original Statement

                       (‹ExpandedThingRn e2›

   * Whenever the typechecker steps through an `ExpandedThingRn`,

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

 mkExpandedPatRn :: LPat GhcRn -> HsExpr GhcRn -> HsExpr GhcRn

 tcExpr e@(HsAppType {})          res_ty = tcApp e res_ty

 tcExpr e@(ExprWithTySig {})      res_ty = tcApp e res_ty

 -- Typecheck an occurrence of an unbound Id

 --

        ; res_ty <- readExpType res_ty

        ; return (HsMultiIf res_ty alts') }

   | DoExpr{} <- do_or_lc

   -- ApplicativeDo are typechecked using tcDoStmts

   = do isApplicativeDo <- xoptM LangExt.ApplicativeDo

          then tcDoStmts do_or_lc stmts res_ty

          -- Expand expression on the fly otherwise

          -- See Note [Typechecking by expansion: overview]

   | MDoExpr{} <- do_or_lc

   | otherwise

   = tcDoStmts do_or_lc stmts res_ty

 tcExpr (HsProc x pat cmd) res_ty

         ; (ds_expr, ds_res_ty, err_msg)

             <- expandRecordUpd record_expr possible_parents rbnds res_ty

           do { -- Typecheck the expanded expression.

                expr' <- tcExpr ds_expr (Check ds_res_ty)

                -- NB: it's important to use ds_res_ty and not res_ty here.

   hence `RealSrcSpan`.

   The `tcl_err_ctxt` is a stack of contexts, each saying something

   The `tcl_in_gen_code` is a boolean that keeps track of whether

   the current expression being typechecked is compiler generated

 -}

    = mkExpandedTc o <$> -- necessary for hpc ticks

          -- Need to call tcExpr and not tcApp

          -- as e can be let statement which tcApp cannot gracefully handle

          tcMonoLExpr e res_ty

 {-

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

 *                                                                      *

     field_strs = conLikeImplBangs con_like

     fl `elemField` flds = any (\ fl' -> flSelector fl == fl') flds

       ExprWithTySig _ e hs_ty     -> Just <$> with_get_ds (tcExprWithSig e hs_ty)

       HsOverLit _ lit             -> Just <$> with_get_ds (tcInferOverLit lit)

       XExpr (HsRecSelRn f)        -> Just <$> with_get_ds (tcInferRecSelId f)

                                               -- We do not want to instantiate the type of the head as there may be

                                               -- visible type applications in the argument.

                                               -- c.f. T19167

 exprCtOrigin (HsProjection _ p)   = RecordFieldProjectionOrigin (FieldLabelStrings $ fmap noLocA p)

 exprCtOrigin (RecordUpd{})        = RecordUpdOrigin

 exprCtOrigin (HsGetField _ _ f)   = GetFieldOrigin (fmap field_label $ dfoLabel (unLoc f))

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

 srcCodeOriginCtOrigin :: HsCtxt -> CtOrigin

 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

                      -- error context. c.f. RecordDotSyntaxFail9

                      -- Add the original HsCtxt if we are typechecking an expanded expression

                        ExprWithTySig _ (L _ e') _

                        _ -> addErrCtxt (ExprCtxt e) thing_inside

               }

     go app_head

      | XExpr (ConLikeTc (RealDataCon {})) <- app_head

      = Deep TopSub

      = go f

      | XExpr (WrapExpr _ f) <- app_head

      = go f

     do new_expr <- zonkExpr expr

        return (XExpr (WrapExpr new_co_fn new_expr))

   = do e' <- zonkLExpr e

 zonkExpr e@(XExpr (ConLikeTc {}))

   = return e