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

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

   | OrigPat  (Pat GhcRn)                   -- ^ Used for failable patterns that trigger MonadFail constraints

 data XXExprGhcRn

   = ExpandedThingRn { xrn_orig     :: SrcCodeOrigin   -- The original source thing to be used for error messages

                     , xrn_expanded :: HsExpr GhcRn    -- The compiler generated, expanded thing

                     }

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

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

                            -- Note [Record selectors in the AST]

 -- | Build an expression using the extension constructor `XExpr`,

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

 --   expanded expressions.

 mkExpandedStmt oStmt flav eExpr = XExpr (ExpandedThingRn { xrn_orig = OrigStmt oStmt flav

                                                          , xrn_expanded = eExpr })

 data XXExprGhcTc

   = WrapExpr        -- Type and evidence application and abstractions

       HsWrapper (HsExpr GhcTc)

         OrigExpr x    -> ppr_builder "<OrigExpr>:" x

         OrigStmt x _  -> ppr_builder "<OrigStmt>:" x

         OrigPat  x    -> ppr_builder "<OrigPat>:" x

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

 instance Outputable XXExprGhcRn where

   ppr (ExpandedThingRn o e) = ifPprDebug (braces $ vcat [ppr o, text ";;" , ppr e]) (ppr o)

   ppr (HsRecSelRn f)        = pprPrefixOcc f

 instance Outputable XXExprGhcTc where

 ppr_infix_expr_rn :: XXExprGhcRn -> Maybe SDoc

 ppr_infix_expr_rn (ExpandedThingRn thing _) = ppr_infix_hs_expansion thing

 ppr_infix_expr_rn (HsRecSelRn f)            = Just (pprInfixOcc f)

 ppr_infix_expr_tc :: XXExprGhcTc -> Maybe SDoc

     go_x_rn :: XXExprGhcRn -> Bool

     go_x_rn (ExpandedThingRn thing _ )   = hsExpandedNeedsParens thing

     go_x_rn (HsRecSelRn{})               = False

     hsExpandedNeedsParens :: SrcCodeOrigin -> Bool

     go_x_rn :: XXExprGhcRn -> Bool

     go_x_rn (ExpandedThingRn thing _)   = isAtomicExpandedThingRn thing

     go_x_rn (HsRecSelRn{})              = True

     isAtomicExpandedThingRn :: SrcCodeOrigin -> Bool

          else repE e }

   | otherwise

   = notHandled (ThExpressionForm e)

 repE (XExpr (HsRecSelRn (FieldOcc _ (L _ x)))) = repE (mkHsVar (noLocA x))

 repE e@(HsPragE _ (HsPragSCC {}) _) = notHandled (ThCostCentres e)

 repE e@(HsTypedBracket{})   = notHandled (ThExpressionForm e)

         DeprecationWarnings(..), warnIfDeprecated,

         checkUnusedRecordWildcard,

         badQualBndrErr, typeAppErr, badFieldConErr,

         genLHsApp, genAppType,

         genLHsLit, genHsIntegralLit, genHsTyLit, genSimpleConPat,

         genVarPat, genWildPat,

 -- See Note [Rebindable syntax and XXExprGhcRn]

 wrapGenSpan x = L (noAnnSrcSpan generatedSrcSpan) x

 -- | Make a 'SyntaxExpr' from a 'Name' (the "rn" is because this is used in the

 -- renamer).

 mkRnSyntaxExpr :: Name -> SyntaxExprRn

 import GHC.Rename.Unbound

 import GHC.Tc.Types

 import GHC.Tc.Utils.Monad

 import GHC.Tc.Errors.Types

         in different_names && same_occ_names

       | otherwise = False

 {- Note [Report candidate instances]

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

 If we have an unsolved (Num Int), where `Int` is not the Prelude Int,

 pprErrCtxtMsg :: ErrCtxtMsg -> SDoc

 pprErrCtxtMsg = \case

   ExprCtxt expr

     -> hang (text "In the expression:")

        2 (ppr (stripParensHsExpr expr))

   ThetaCtxt ctxt theta ->

 import GHC.Tc.Utils.Concrete  ( unifyConcrete, idConcreteTvs )

 import GHC.Tc.Utils.TcMType

 import GHC.Tc.Types.Evidence

 import GHC.Tc.Types.Origin

 import GHC.Tc.Utils.TcType as TcType

 import GHC.Tc.Utils.Concrete( hasFixedRuntimeRep_syntactic )

 -- CAUTION: Any changes to tcApp should be reflected here

 -- cf. T19167. the head is an expanded expression applied to a type

 -- TODO: Use runInfer for tcExprSigma?

 tcExprSigma :: Bool -> HsExpr GhcRn -> TcM (HsExpr GhcTc, TcSigmaType)

 tcExprSigma inst rn_expr

   = do { (fun@(rn_fun,fun_ctxt), rn_args) <- splitHsApps rn_expr

        ; code_orig <- getSrcCodeOrigin

        ; let fun_orig = srcCodeOriginCtOrigin rn_expr code_orig

        ; (inst_args, app_res_sigma) <- tcInstFun do_ql inst fun_orig (tc_fun, rn_fun, fun_ctxt) fun_sigma rn_args

        ; let tc_expr = rebuildHsApps (tc_fun, fun_ctxt) tc_args

        ; return (tc_expr, app_res_sigma) }

 -- See Note [tcApp: typechecking applications]

 tcApp rn_expr exp_res_ty

   = do { -- Step 1: Split the application chain

        ; traceTc "tcApp {" $

                 , text "rn_fun:" <+> ppr rn_fun

                 , text "rn_args:" <+> ppr rn_args ]

        -- Step 2: Infer the type of `fun`, the head of the application

        ; (tc_fun, fun_sigma) <- tcInferAppHead fun

              -- inst_final: top-instantiate the result type of the application,

              -- EXCEPT if we are trying to infer a sigma-type

              inst_final = case exp_res_ty of

               , text "fun_origin" <+> ppr fun_orig

               , text "do_ql:" <+> ppr do_ql]

        ; (inst_args, app_res_rho)

          -- See (TCAPP1) and (TCAPP2) in

          -- Note [tcApp: typechecking applications]

                                                    app_res_rho exp_res_ty

                          -- Step 4.2: typecheck the  arguments

                          -- Step 4.3: wrap up

                        ; finishApp tc_head tc_args app_res_rho res_wrap }

                          -- Step 5.2: typecheck the arguments, and monomorphise

                          --           any un-unified instantiation variables

                          -- Step 5.3: zonk to expose the polymorphism hidden under

                          --           QuickLook instantiation variables in `app_res_rho`

                        ; app_res_rho <- liftZonkM $ zonkTcType app_res_rho

         thing_inside

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

 -- Importantly, tcValArgs works left-to-right, so that by the time we

 -- encounter an argument, we have monomorphised all the instantiation

 -- variables that its type contains.  All that is left to do is an ordinary

 -- zonkTcType.  See Note [Monomorphise instantiation variables].

   where

     go _ _ [] = return []

     go do_ql pos (arg : args) =

          ; args' <- go do_ql pos' args

          ; return (arg' : args') }

       where

              = pos

          -> TcM (HsExprArg 'TcpTc)          -- Resulting argument

 tcValArg _     _ _ (EPrag l p)         = return (EPrag l (tcExprPrag p))

 tcValArg _     _ _ (ETypeArg l hty ty) = return (ETypeArg l hty ty)

   -- 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 })

     do { -- Crucial step: expose QL results before checking exp_arg_ty

          -- So far as the paper is concerned, this step applies

          -- the poly-substitution Theta, learned by QL, so that we

               DoQL -> liftZonkM $ zonkScaledTcType sc_arg_ty

               NoQL -> return sc_arg_ty

        ; traceTc "tcValArg {" $

               , text "sigma_type" <+> ppr (mkCheckExpType exp_arg_ty)

               , text "arg:" <+> ppr larg

               ]

                  tcPolyExpr arg (mkCheckExpType exp_arg_ty)

        ; traceTc "tcValArg" $ vcat [ ppr arg'

                                    , text "}" ]

                          , ea_arg = L arg_loc arg'

                          , ea_arg_ty = noExtField }) }

                         eaql_wanted   = wanted

                       , eaql_arg_ty   = sc_arg_ty

                       , eaql_larg     = larg@(L arg_loc rn_expr)

                       , eaql_tc_fun   = tc_head

                       , eaql_args     = inst_args

                       , eaql_encl     = arg_influences_enclosing_call

                       , eaql_res_rho  = app_res_rho })

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

          Scaled mult exp_arg_ty <- liftZonkM $ zonkScaledTcType sc_arg_ty

                                        , text "args:" <+> ppr inst_args

                                        , text "mult:" <+> ppr mult

                                        , text "fun" <+> ppr fun

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

        ; ds_flag <- getDeepSubsumptionFlag

                   ; unless arg_influences_enclosing_call $  -- Don't repeat

                     qlUnify app_res_rho exp_arg_rho         -- the qlUnify

                   ; app_res_rho <- liftZonkM $ zonkTcType app_res_rho

                   ; res_wrap <- checkResultTy rn_expr tc_head inst_args

                                               app_res_rho (mkCheckExpType exp_arg_rho)

        ; traceTc "tcEValArgQL }" $

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

                          , ea_arg    = L arg_loc (mkHsWrap wrap arg')

                          , ea_arg_ty = noExtField }) }

                     -- Generally speaking we pass in True; in Fig 5 of the paper

                     --    |-inst returns a rho-type

           -> CtOrigin

           -> TcSigmaType -> [HsExprArg 'TcpRn]

           -> TcM ( [HsExprArg 'TcpInst]

                  , TcSigmaType )   -- Does not instantiate trailing invisible foralls

 -- This crucial function implements the |-inst judgement in Fig 4, plus the

 -- modification in Fig 5, of the QL paper:

 -- "A quick look at impredicativity" (ICFP'20).

   = do { traceTc "tcInstFun" (vcat [ text "origin" <+> ppr fun_orig

                                    , text "tc_fun" <+> ppr tc_fun

                                    , text "fun_sigma" <+> ppr fun_sigma

                                    , text "args:" <+> ppr rn_args

                                    , text "do_ql" <+> ppr do_ql

        ; setQLInstLevel do_ql $  -- See (TCAPP1) and (TCAPP2) in

                                  -- Note [tcApp: typechecking applications]

                  go 1 [] fun_sigma rn_args }

       = do { (_inst_tvs, wrap, fun_rho) <-

                 -- addHeadCtxt: important for the class constraints

                 -- that may be emitted from instantiating fun_sigma

                 instantiateSigma fun_orig fun_conc_tvs tvs theta body2

                   -- See Note [Representation-polymorphism checking built-ins]

                   -- in GHC.Tc.Utils.Concrete.

                   (Just $ HsExprTcThing tc_fun)

                   (n_val_args, fun_sigma) fun_ty

            ; let acc' = arg' : addArgWrap wrap acc

            ; go (pos+1) acc' res_ty rest_args }

     _           -> False

 looks_like_type_arg _ = False

            -> TcM a -> TcM a

 -- There are 2 cases:

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

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

   = do { in_generated_code <- inGeneratedCode

        ; traceTc "addArgCtxt" (vcat [ text "generated:" <+> ppr in_generated_code

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

 *                                                                      *

 -}

              -> LHsExpr GhcRn          -- ^ Argument

              -> Scaled TcSigmaTypeFRR  -- ^ Type expected by the function

              -> TcM (HsExprArg 'TcpInst)

 -- See Note [Quick Look at value arguments]

   = do { is_rho <- tcIsDeepRho (scaledThing orig_arg_ty)

        ; traceTc "qla" (ppr orig_arg_ty $$ ppr is_rho)

        ; if not is_rho

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

               -> TcM (HsExprArg 'TcpInst)

                     , ea_arg    = larg

                     , ea_arg_ty = arg_ty })

   | Just {} <- tcSplitAppTy_maybe ty        = True

   | otherwise                               = False

               -> Scaled TcRhoType  -- Deeply skolemised

               -> TcM (HsExprArg 'TcpInst)

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

                            -- generated by calls in arg

        -- Step 1: get the type of the head of the argument

        ; (fun_ue, mb_fun_ty) <- tcCollectingUsage $ tcInferAppHead_maybe rn_fun

               , text "args:" <+> ppr rn_args ]

        ; case mb_fun_ty of {

            Just (tc_fun, fun_sigma) ->

        -- step 2: use |-inst to instantiate the head applied to the arguments

        ; do_ql <- wantQuickLook rn_fun

        ; ((inst_args, app_res_rho), wanted)

              <- captureConstraints $

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

                 -- not equality constraints.  See (QLA6) in Note [Quick Look at

                 -- value arguments]

        ; traceTc "quickLookArg done }" (ppr rn_fun)

                            , eaql_arg_ty   = sc_arg_ty

                            , eaql_larg     = larg

                            , eaql_tc_fun   = tc_head

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

 --       let x = e ; stmts ~~> let x = e in stmts'

   do expand_stmts_expr <- expand_do_stmts doFlavour lstmts

      return $ L loc (mkExpandedStmt stmt doFlavour expansion)

 expand_do_stmts doFlavour (stmt@(L loc (BindStmt xbsrn pat e)): lstmts)

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

 --       pat <- e ; stmts   ~~> (>>=) e f

   = do expand_stmts_expr <- expand_do_stmts doFlavour lstmts

        let expansion = genHsExpApps bind_op  -- (>>=)

                        , failable_expr ]

        return $ L loc (mkExpandedStmt stmt doFlavour expansion)

   | otherwise

   = pprPanic "expand_do_stmts: The impossible happened, missing bind operator from renamer" (text "stmt" <+> ppr  stmt)

 -- See Note [BodyStmt] in Language.Haskell.Syntax.Expr

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

 --              stmts ~~> stmts'

 --      e ; stmts ~~> (>>) e stmts'

   do expand_stmts_expr <- expand_do_stmts doFlavour lstmts

      let expansion = genHsExpApps then_op  -- (>>)

      return $ L loc (mkExpandedStmt stmt doFlavour expansion)

 expand_do_stmts doFlavour

 -}

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

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

 tcPolyLExpr (L loc expr) res_ty

   = setSrcSpanA loc  $  -- Set location /first/; see GHC.Tc.Utils.Monad

     do { expr' <- tcPolyExpr expr res_ty

        ; return (L loc expr') }

 tcInferExpr, tcInferExprNC :: InferInstFlag -> LHsExpr GhcRn -> TcM (LHsExpr GhcTc, TcType)

 tcInferExpr iif (L loc expr)

   = setSrcSpanA loc  $  -- Set location /first/; see GHC.Tc.Utils.Monad

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

        ; return (L loc expr', rho) }

 tcMonoLExpr (L loc expr) res_ty

   = setSrcSpanA loc   $  -- Set location /first/; see GHC.Tc.Utils.Monad

     do  { expr' <- tcExpr expr res_ty

         ; return (L loc expr') }

        res_ty

   = assert (notNull rbnds) $

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

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

 -- Here we get rid of it and add the finalizers to the global environment.

 -- See Note [Delaying modFinalizers in untyped splices] in GHC.Rename.Splice.

 tcExpr (HsTypedSplice ext splice)   res_ty = tcTypedSplice ext splice res_ty

 tcExpr e@(HsUntypedBracket ps body) res_ty = tcUntypedBracket e body ps res_ty

 tcExpr (HsUntypedSplice splice _)   res_ty

 -}

 tcXExpr :: XXExprGhcRn -> ExpRhoType -> TcM (HsExpr GhcTc)

 tcXExpr (ExpandedThingRn o e) res_ty

 -- For record selection, same as HsVar case

 tcXExpr xe res_ty = tcApp (XExpr xe) res_ty

              ds_expr = HsLet noExtField let_binds (wrapGenSpan case_expr)

              case_expr :: HsExpr GhcRn

                        $ mkMatchGroup (Generated OtherExpansion DoPmc) (wrapGenSpan matches)

              matches :: [LMatch GhcRn (LHsExpr GhcRn)]

              matches = map make_pat (NE.toList relevant_cons)

        , nonBidirectionalErr

        , pprArgInst

 import {-# SOURCE #-} GHC.Tc.Gen.Expr( tcExpr, tcCheckPolyExprNC, tcPolyLExprSig )

 import {-# SOURCE #-} GHC.Tc.Gen.Splice( getUntypedSpliceBody )

 import GHC.Tc.Utils.Env

 import GHC.Tc.Utils.TcMType

 import GHC.Tc.Types.Origin

 import GHC.Tc.Types.Constraint( WantedConstraints )

 import GHC.Tc.Utils.TcType as TcType

 import GHC.Tc.Types.Evidence

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

                                                      -- location and error msgs

                , eaql_rn_fun  :: HsExpr GhcRn  -- Head of the argument if it is an application