-- others:

 import GHC.Tc.Types.Evidence

 import GHC.Types.Id.Info ( RecSelParent )

 import GHC.Types.Name

 import GHC.Types.Name.Reader

 *                                                                      *

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

 data XXExprGhcRn

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

                     }

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

 --   expanded expressions.

 mkExpandedExpr

   -> HsExpr GhcRn         -- ^ expanded expression

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

                                                     , xrn_expanded = eExpr })

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

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

 --   expanded expression

 mkExpandedStmt

   -> HsExpr GhcRn         -- ^ expanded expression

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

                                                          , xrn_expanded = eExpr })

 data XXExprGhcTc

   | ExpandedThingTc                         -- See Note [Rebindable syntax and XXExprGhcRn]

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

          , xtc_expanded :: HsExpr GhcTc }   -- The expanded typechecked expression

   | ConLikeTc

   :: HsExpr GhcRn           -- ^ source expression

   -> HsExpr GhcTc           -- ^ expanded typechecked expression

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

 mkExpandedTc

   -> HsExpr GhcTc           -- ^ expanded typechecked expression

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

 mkExpandedTc o e = XExpr (ExpandedThingTc o e)

   GhcRn -> ppr x

   GhcTc -> ppr x

 instance Outputable XXExprGhcRn where

   ppr (HsRecSelRn f)        = pprPrefixOcc f

 instance Outputable XXExprGhcTc where

   ppr (WrapExpr co_fn e)

     = pprHsWrapper co_fn (\_parens -> pprExpr e)

   ppr (ExpandedThingTc o e)

             -- e is the expanded expression, we print the original

             -- expression (HsExpr GhcRn), not the

             -- expanded typechecked one (HsExpr GhcTc),

 ppr_infix_expr_tc (HsBinTick {})             = Nothing

 ppr_infix_expr_tc (HsRecSelTc f)            = Just (pprInfixOcc f)

 ppr_infix_hs_expansion _            = Nothing

 pprDebugParendExpr :: (OutputableBndrId p)

     go_x_rn (ExpandedThingRn thing _ )   = hsExpandedNeedsParens thing

     go_x_rn (HsRecSelRn{})               = False

     hsExpandedNeedsParens _            = False

 -- | Parenthesize an expression without token information

     go_x_rn (ExpandedThingRn thing _)   = isAtomicExpandedThingRn thing

     go_x_rn (HsRecSelRn{})              = True

     isAtomicExpandedThingRn _            = False

 isAtomicHsExpr _ = False

   , GRHSs

   , HsUntypedSplice

   , HsTypedSplice

   )

 import GHC.Types.Name   ( Name )

 import Data.Bool  ( Bool )

 import Data.Maybe ( Maybe )

       , utsplice_result            :: thing

       }

   | HsUntypedSpliceNested SplicePointName

 import Language.Haskell.Syntax.Decls.Overlap (OverlapMode(..))

 import Language.Haskell.Syntax.Extension (Anno)

 import Language.Haskell.Syntax.Binds.InlinePragma (ActivationX(..), InlinePragma(..))

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

 -- Data derivations from GHC.Hs-----------------------------------------

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

 deriving instance Data XXExprGhcRn

 deriving instance Data a => Data (WithUserRdr a)

   RecordUpdOrigin {} -> True

   RecordFieldProjectionOrigin {} -> True

   GetFieldOrigin {} -> True

     | HsGetField{} <- e -> True

     | RecordUpd{} <- e -> True

     | HsProjection{} <- e -> True

 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

     mk_herald :: HsExpr GhcTc -> HsExpr GhcRn -> CtOrigin

     mk_herald tc_fun arg

       = case fun_orig of

            _ -> ExpectedFunTyArg (HsExprTcThing tc_fun) arg

 -- Is the argument supposed to instantiate a forall?

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

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

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

     -- GHC.Tc.Gen.App.tcInstFun arranges that the CtOrigin of (r.x) is GetFieldOrigin,

     -- despite the expansion to (getField @"x" r)

     isGetFieldOrigin _                   = False

 lookupHasFieldLabel

 {-# LANGUAGE UndecidableInstances #-}

 module GHC.Tc.Types.ErrCtxt

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

   , TyConInstFlavour(..)

   )

   where

 import GHC.Prelude

 import GHC.Hs.Extension

 import GHC.Parser.Annotation ( LocatedN, SrcSpanAnnA )

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

 import GHC.Types.Basic       ( TyConFlavour )

 import GHC.Types.Name        ( Name )

 import GHC.Types.Var         ( Id, TyCoVar )

 import GHC.Unit.Types ( Module, InstantiatedModule )

 import GHC.Core.TyCon    ( TyCon )

 import GHC.Core.TyCo.Rep ( Type, ThetaType, PredType )

 import GHC.Data.FastString  ( FastString )

 import GHC.Utils.Outputable ( Outputable(..) )

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

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

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

                  -- LandmarkUserSrcCode <=> this is a landmark context; do not

                  --                         discard it when trimming for display

                  -- Monadic so that we have a chance

                  -- to deal with bound type variables just before error

                  -- message construction

 data CodeSrcFlag = VanillaUserSrcCode

                  | LandmarkUserSrcCode

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

 -- Error message contexts

   ppr (UserLHsSigType ty) = ppr ty

   ppr (UserLHsType ty) = ppr ty

 data FunAppCtxtFunArg

   = FunAppCtxtExpr !(HsExpr GhcRn) !(HsExpr GhcRn)

   | FunAppCtxtTy   !(LHsType GhcRn) !(LHsType GhcRn)

   -- or a type signature, or... (see 'Sig').

   | SigCtxt !(Sig GhcRn)

   -- | In a user-written type signature.

   -- | In a record update.

   | RecordUpdCtxt !(NE.NonEmpty ConLike) ![Name] ![TyCoVar]

   -- | In a class method.

   | VDQWarningCtxt !TcTyCon

   -- | In a statement.

   -- | In an rebindable syntax expression.

   | SyntaxNameCtxt !(HsExpr GhcRn) !CtOrigin !TcType !SrcSpan

   | MergeSignaturesCtxt !UnitState !ModuleName ![InstantiatedModule]

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

   | CheckImplementsCtxt !UnitState !Module !InstantiatedModule

 setLclCtxtSrcCodeOrigin :: ErrCtxt -> TcLclCtxt -> TcLclCtxt

 setLclCtxtSrcCodeOrigin ec lclCtxt

   | ecs@(MkErrCtxt (ExpansionCodeCtxt{}) _ : _) <- tcl_err_ctxt lclCtxt

   = lclCtxt { tcl_err_ctxt =  ec : ecs }

   | MkErrCtxt (ExpansionCodeCtxt{}) _ : ecs <- tcl_err_ctxt lclCtxt

   , MkErrCtxt (ExpansionCodeCtxt{}) _ <- ec

   | AmbiguityCheckOrigin UserTypeCtxt

   | ImplicitLiftOrigin HsImplicitLiftSplice

   | ExpectedTySyntax !CtOrigin (HsExpr GhcRn)

 exprCtOrigin (HsForAll {})       = Shouldn'tHappenOrigin "forall telescope"    -- See Note [Types in terms]

 exprCtOrigin (HsQual {})         = Shouldn'tHappenOrigin "constraint context"  -- See Note [Types in terms]

 exprCtOrigin (HsFunArr {})       = Shouldn'tHappenOrigin "function arrow"      -- See Note [Types in terms]

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

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

     where

       what :: SDoc

       what = case o of

           text "a do statement"

           text "a do statement" $$

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

           hsep [text "selecting the field", quotes (ppr f)]

           hsep [text "the overloaded label" , quotes (char '#' <> ppr l)]

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

 pprCtOrigin (GivenSCOrigin sk d blk)

   = vcat [ ctoHerald <+> pprSkolInfo sk

 ppr_br (AmbiguityCheckOrigin {})    = text "a type ambiguity check"

 ppr_br (ImpedanceMatching {})       = text "combining required constraints"

 ppr_br (NonLinearPatternOrigin _ pat) = hsep [text "a non-linear pattern" <+> quotes (ppr pat)]

 ppr_br (ExpectedTySyntax o _) = ppr_br o

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

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

 import GHC.Utils.Misc ( HasDebugCallStack )

 import {-# SOURCE #-} GHC.Core.TyCo.Rep ( Type )

 data SkolemInfoAnon

 data SkolemInfo

 data FixedRuntimeRepContext

    -- because it is mentioned in the error message itself

       ExprWithTySig _ (L _ e') _

    -- There is a special case for expressions with signatures to avoid having too verbose

    -- error context. So here we flip the ErrCtxt state to expanded if the expression is expanded.

    -- c.f. RecordDotSyntaxFail9

    -- Flip error ctxt into expansion mode

       _ -> addErrCtxt (ExprCtxt e) thing_inside

 addErrCtxt msg = addErrCtxtM (\env -> return (env, msg))

 -- See Note [ErrCtxtStack Manipulation]

 {-# 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

 addErrCtxtM ctxt = pushCtxt (MkErrCtxt VanillaUserSrcCode ctxt)

 -- See Note [ErrCtxtStack Manipulation]

 {-# INLINE addExpansionErrCtxtM #-}  -- 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

 import {-# SOURCE #-} GHC.Types.Var ( TcTyVar )

 import {-# SOURCE #-} GHC.Tc.Types.Origin ( FixedRuntimeRepOrigin )

 import GHC.Types.Name.Env ( NameEnv )

 data MetaDetails

 isConcreteTyVar :: TcTyVar -> Bool

 noConcreteTyVars :: ConcreteTyVars

 import GHC.Prelude

 import GHC.Driver.Flags

 import GHC.Types.SrcLoc

 import qualified GHC.Utils.Ppr as Pretty