| ThNoUserInline

   | ThExoticFormOfType !(HsType GhcRn)

   | ThAmbiguousRecordSelectors !(HsExpr GhcRn)

   | ThCostCentres !(HsExpr GhcRn)

   | ThExpressionForm !(HsExpr GhcRn)

   | ThExoticStatement [Stmt GhcRn (LHsExpr GhcRn)]

   | ThExoticPattern !(Pat GhcRn)

   | ThUnsupportedTyLit !(HsLit GhcRn)

   | ThNegativeOverloadedPatterns !(Pat GhcRn)

   | ThHaddockDocumentation

   | ThWarningAndDeprecationPragmas [LIdP GhcRn]

 --              Expressions

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

 repLEs es = repListM expTyConName repLE es

 -- FIXME: some of these panics should be converted into proper error messages

 --        unless we can make sure that constructs, which are plainly not

 --        supported in TH already lead to error messages at an earlier stage

 repLE (L loc e) = mapReaderT (putSrcSpanDs (locA loc)) (repE e)

 repE :: forall p. (IsPass p) => HsExpr (GhcPass p) -> MetaM (Core (M TH.Exp))

 repE (ExplicitList _ es) = do { xs <- repLEs es; repListExp xs }

 repE (ExplicitTuple _ es boxity) =

       tupArgToCoreExp a

         | (Present _ e) <- a = do { e' <- repLE e

                                   ; coreJustM expTyConName e' }

     HsForAllVis   _ tvs -> mk_forall forallVisEName tvs

     HsForAllInvis _ tvs -> mk_forall forallEName    tvs

   where

     mk_forall forall_name tvs =

       addHsTyVarBinds FreshNamesOnly tvs $ \bndrs -> do

         body' <- repLE body

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

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

 repFunArrMult (HsModifiedFunArr _ mods arr) = case (arr, mods) of

   (HsStandardArr _, []) -> repConName unrestrictedFunTyConName

   (HsStandardArr _, [L _ (HsModifier _ m)]) -> do

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

 -- Building representations of auxiliary structures like Match, Clause, Stmt,

 repMatchTup (L _ (Match { m_pats = L _ [p]

                         , m_grhss = GRHSs _ guards wheres })) =

   do { ss1 <- mkGenSyms (collectPatBinders CollNoDictBinders p)

      ; wrapGenSyms (ss1++ss2) match }}}

 repMatchTup _ = panic "repMatchTup: case alt with more than one arg or with invisible pattern"

 repClauseTup (L _ (Match { m_pats = L _ ps

                          , m_grhss = GRHSs _ guards  wheres })) =

   do { ss1 <- mkGenSyms (collectPatsBinders CollNoDictBinders ps)

      ; clause <- repClause ps1 gs ds

      ; wrapGenSyms (ss1++ss2) clause }}}

 repGuards (L _ (GRHS _ [] e) :| [])

   = do {a <- repLE e; repNormal a }

 repGuards other

        ; gd <- repGuarded (nonEmptyCoreList' ys)

        ; wrapGenSyms (concat xs) gd }

          -> MetaM ([GenSymBind], (Core (M (TH.Guard, TH.Exp))))

 repLGRHS (L _ (GRHS _ [L _ (BodyStmt _ e1 _ _)] e2))

   = do { guarded <- repLNormalGE e1 e2

        ; guarded <- repPatGE (nonEmptyCoreList ss') rhs'

        ; return (gs, guarded) }

 repFields (HsRecFields { rec_flds = flds })

   = repListM fieldExpTyConName rep_fld flds

   where

             -> MetaM (Core (M TH.FieldExp))

     rep_fld (L _ fld) = do { fn <- lookupOcc (hsRecFieldSel fld)

                            ; e  <- repLE (hfbRHS fld)

                            ; repFieldExp fn e }

 repUpdFields = repListM fieldExpTyConName rep_fld

   where

     rep_fld (L l fld) =

       let (FieldOcc _ (L _ sel_name)) = unLoc (hfbLHS fld)

       -- If we have an unbountName in the sel_name, that means we failed to

 -- The helper function repSts computes the translation of each sub expression

 -- and a bunch of prefix bindings denoting the dynamic renaming.

 repLSts stmts = repSts (map unLoc stmts)

 repSts (BindStmt _ p e : ss) =

    do { e2 <- repLE e

       ; ss1 <- mkGenSyms (collectPatBinders CollNoDictBinders p)

       ; (ss2, zs) <- addBinds ss1 (repSts ss)

       ; return (ss1++ss2, z : zs) }

    where

                     -> MetaM ([GenSymBind], Core [(M TH.Stmt)])

      rep_stmt_block (ParStmtBlock _ stmts _ _) =

        do { (ss1, zs) <- repSts (map unLoc stmts)

 --                      Bindings

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

 repBinds (EmptyLocalBinds _)

   = do  { core_list <- coreListM decTyConName []

         ; return ([], core_list) }

                                 (de_loc (sort_by_loc prs))

         ; return (ss, core_list) }

 rep_implicit_param_bind (L loc (IPBind _ (L _ n) (L _ rhs)))

  = do { name <- rep_implicit_param_name n

       ; rhs' <- repE rhs

 rep_implicit_param_name :: HsIPName -> MetaM (Core String)

 rep_implicit_param_name (HsIPName name) = coreStringLit name

 -- Assumes: all the binders of the binding are already in the meta-env

 rep_val_binds (XValBindsLR (HsVBG binds sigs))

  = do { core1 <- rep_binds (concatMap snd binds)

 rep_val_binds (ValBinds _ _ _)

  = panic "rep_val_binds: ValBinds"

 rep_binds = mapM rep_bind

 -- Assumes: all the binders of the binding are already in the meta-env

 -- Note GHC treats declarations of a variable (not a pattern)

        ; patSynD'' <- wrapGenArgSyms args ss patSynD'

        ; return (locA loc, patSynD'') }

   where

     -- for Record Pattern Synonyms we want to conflate the selector

     -- and the pattern-only names in order to provide a nicer TH

     -- API. Whereas inside GHC, record pattern synonym selectors and

       = [ (pat, id) | (sel, id) <- genSyms, (sel', pat) <- selsPats

                     , sel == sel' ]

                    -> [GenSymBind] -> Core (M TH.Dec) -> MetaM (Core (M TH.Dec))

     wrapGenArgSyms (RecCon _) _  dec = return dec

     wrapGenArgSyms _          ss dec = wrapGenSyms ss dec

                     -> MetaM (Core (M TH.PatSynArgs))

 repRecordPatSynArgs (MkC sels) = rep2 recordPatSynName [sels]

 repPatSynDir Unidirectional        = rep2 unidirPatSynName []

 repPatSynDir ImplicitBidirectional = rep2 implBidirPatSynName []

 repPatSynDir (ExplicitBidirectional (MG { mg_alts = (L _ clauses) }))

 -- variable should already appear in the environment.

 -- Process a list of patterns

 repLPs ps = repListM patTyConName repLP ps

 repLPs1 ps = repNonEmptyM patTyConName repLP ps

 repLP :: forall p. IsPass p => LPat (GhcPass p) -> MetaM (Core (M TH.Pat))