deriving instance Eq (IE GhcTc)

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

 instance Data ErrCtxtMsg where

   gunfold _ _ _ = error "no gunfold for ErrCtxtMsg"

   gfoldl _ _ _ = error "no goldl for ErrCtxtMsg"

 deriving instance Data XXExprGhcRn

 import GHC.Tc.Gen.Head

 import GHC.Tc.Errors.Types

 import GHC.Tc.Utils.Monad

 import GHC.Tc.Utils.Unify

 import GHC.Tc.Utils.Instantiate

 2. Use tcInferAppHead to infer the type of the function,

      as an (uninstantiated) TcSigmaType

    There are special cases for

    Otherwise, delegate back to tcExpr, which

      infers an (instantiated) TcRhoType

   = return $ exprCtOrigin rn_fun_arg

   | otherwise

   = do { code_orig <- getSrcCodeOrigin

        ; return $ srcCodeOriginCtOrigin rn_fun code_orig

        }

           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

 -}

 mkExpandedPatRn flav pat stmt e = XExpr $ ExpandedThingRn

                                    { xrn_orig = StmtErrCtxtPat (HsDoStmt flav) stmt pat

                                    , xrn_expanded = e}

 --   * A bare identifier (just look it up)

 --     This case also covers a record selector HsRecSel

 --   * An expression with a type signature (e :: ty)

 -- See Note [Application chains and heads] in GHC.Tc.Gen.App

 --

 -- Note that [] and (,,) are both HsVar:

                      -> TcM (Maybe (HsExpr GhcTc, DeepSubsumptionFlag, TcSigmaType))

 -- See Note [Application chains and heads] in GHC.Tc.Gen.App

 -- Returns Nothing for a complicated head

 tcInferAppHead_maybe fun = case fun of

       HsVar _ nm                  -> Just <$> with_get_ds (tcInferId nm)

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

 {-# LANGUAGE PatternSynonyms            #-}

 {-

 (c) The University of Glasgow 2006-2012

 (c) The GRASP Project, Glasgow University, 1992-2002

   | DoStmtErrCtxt !HsStmtContextRn !(ExprLStmt GhcRn)

   -- | In patten of the do statement. (c.f. MonadFailErrors)

   -- | In an rebindable syntax expression.

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

 -- See Note [ErrCtxtStack Manipulation]

 setLclCtxtSrcCodeOrigin :: ErrCtxt -> TcLclCtxt -> TcLclCtxt

 setLclCtxtSrcCodeOrigin ec lclCtxt

   = lclCtxt { tcl_err_ctxt =  ec : ecs }

   | otherwise

   = lclCtxt { tcl_err_ctxt = ec : tcl_err_ctxt lclCtxt }

       -- `ty1` to `ty2`.

   | DefaultOrigin       -- Typechecking a default decl

   | DoPatOrigin (LPat GhcRn) -- Arising from a failable pattern in

                              -- a do expression

   | MCompOrigin         -- Arising from a monad comprehension

 exprCtOrigin e@(HsProjection _ _) = ExpansionOrigin (ExprCtxt e)

 exprCtOrigin e@(RecordUpd{})      = ExpansionOrigin (ExprCtxt e)

 exprCtOrigin e@(HsGetField{})     = ExpansionOrigin (ExprCtxt e)

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

 srcCodeOriginCtOrigin :: HsExpr GhcRn -> Maybe ErrCtxtMsg -> CtOrigin

 srcCodeOriginCtOrigin e Nothing = exprCtOrigin e

 -- | Extract a suitable CtOrigin from a MatchGroup

 matchesCtOrigin :: MatchGroup GhcRn (LHsExpr GhcRn) -> CtOrigin

       what = case o of

         StmtErrCtxt{} ->

           text "a do statement"

         StmtErrCtxtPat _ _ p ->

           text "a do statement" $$

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

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

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

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

         _ -> text "shouldn't happen ExpansionOrigin pprCtOrigin"

 pprCtOrigin (GivenSCOrigin sk d blk)

 import GHC.Core ( isOrphan ) -- For the Coercion constructor

 import GHC.Core.Type

 import GHC.Core.TyCo.Ppr ( debugPprType )

 import GHC.Core.Class( Class )

 import GHC.Core.Coercion.Axiom

   = setSrcSpan lspan $ add_expr_ctxt e thing_inside

   | otherwise   -- no op in generated code

   = thing_inside

 getErrCtxt :: TcM [ErrCtxt]