{-# LANGUAGE TypeFamilies #-}

{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}

module GHC.Rename.Splice (
        rnTopSpliceDecls,
        rnSpliceType, rnSpliceExpr, rnSplicePat, rnSpliceDecl,
        rnTypedBracket, rnUntypedBracket,
        checkThLocalName
        , traceSplice, SpliceInfo(..)
  ) where

import GHC.Prelude

import GHC.Types.Name
import GHC.Types.Name.Set
import GHC.Hs
import GHC.Types.Name.Reader
import GHC.Tc.Errors.Types
import GHC.Tc.Utils.Monad
import GHC.Driver.Env.Types

import GHC.Rename.Env
import GHC.Rename.Utils   ( newLocalBndrRn )
import GHC.Rename.Unbound ( isUnboundName )
import GHC.Rename.Module  ( rnSrcDecls, findSplice )
import GHC.Rename.Pat     ( rnPat )
import GHC.Types.Error
import GHC.Types.Basic    ( TopLevelFlag, isTopLevel )
import GHC.Types.SourceText ( SourceText(..) )
import GHC.Utils.Outputable
import GHC.Unit.Module
import GHC.Types.SrcLoc
import GHC.Rename.HsType ( rnLHsType )

import Control.Monad    ( unless, when )

import {-# SOURCE #-} GHC.Rename.Expr ( rnLExpr )

import GHC.Tc.Utils.Env     ( checkWellStaged, tcMetaTy )

import GHC.Driver.Session
import GHC.Data.FastString
import GHC.Utils.Logger
import GHC.Utils.Panic
import GHC.Driver.Hooks
import GHC.Builtin.Names.TH ( decsQTyConName, expQTyConName, liftName
                            , patQTyConName, quoteDecName, quoteExpName
                            , quotePatName, quoteTypeName, typeQTyConName)

import {-# SOURCE #-} GHC.Tc.Gen.Expr   ( tcCheckPolyExpr )
import {-# SOURCE #-} GHC.Tc.Gen.Splice
    ( runMetaD
    , runMetaE
    , runMetaP
    , runMetaT
    , tcTopSpliceExpr
    )

import GHC.Tc.Utils.Zonk

import GHCi.RemoteTypes ( ForeignRef )
import qualified Language.Haskell.TH as TH (Q)

import qualified GHC.LanguageExtensions as LangExt

{-
************************************************************************
*                                                                      *
        Template Haskell brackets
*                                                                      *
************************************************************************
-}

-- Check that -XTemplateHaskellQuotes is enabled and available
checkForTemplateHaskellQuotes :: HsExpr GhcPs ->  RnM ()
checkForTemplateHaskellQuotes :: HsExpr GhcPs -> RnM ()
checkForTemplateHaskellQuotes HsExpr GhcPs
e =
    do { Bool
thQuotesEnabled <- Extension -> TcRnIf TcGblEnv TcLclEnv Bool
forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.TemplateHaskellQuotes
       ; Bool -> RnM () -> RnM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
thQuotesEnabled (RnM () -> RnM ()) -> RnM () -> RnM ()
forall a b. (a -> b) -> a -> b
$
           TcRnMessage -> RnM ()
forall a. TcRnMessage -> TcRn a
failWith ( DiagnosticMessage -> TcRnMessage
forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
-> DiagnosticMessage -> TcRnMessage
forall a b. (a -> b) -> a -> b
$ [GhcHint] -> SDoc -> DiagnosticMessage
mkPlainError [GhcHint]
noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
forall a b. (a -> b) -> a -> b
$ [SDoc] -> SDoc
vcat
                      [ String -> SDoc
text String
"Syntax error on" SDoc -> SDoc -> SDoc
<+> HsExpr GhcPs -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsExpr GhcPs
e
                      , String -> SDoc
text (String
"Perhaps you intended to use TemplateHaskell"
                              String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" or TemplateHaskellQuotes") ] )
       }

rnTypedBracket :: HsExpr GhcPs -> LHsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnTypedBracket :: HsExpr GhcPs -> LHsExpr GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnTypedBracket HsExpr GhcPs
e LHsExpr GhcPs
br_body
  = SDoc
-> RnM (HsExpr GhcRn, FreeVars) -> RnM (HsExpr GhcRn, FreeVars)
forall a. SDoc -> TcM a -> TcM a
addErrCtxt (LHsExpr GhcPs -> SDoc
typedQuotationCtxtDoc LHsExpr GhcPs
br_body) (RnM (HsExpr GhcRn, FreeVars) -> RnM (HsExpr GhcRn, FreeVars))
-> RnM (HsExpr GhcRn, FreeVars) -> RnM (HsExpr GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$
    do { HsExpr GhcPs -> RnM ()
checkForTemplateHaskellQuotes HsExpr GhcPs
e

         -- Check for nested brackets
       ; ThStage
cur_stage <- TcM ThStage
getStage
       ; case ThStage
cur_stage of
           { Splice SpliceType
Typed   -> () -> RnM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
           ; Splice SpliceType
Untyped -> TcRnMessage -> RnM ()
forall a. TcRnMessage -> TcRn a
failWithTc TcRnMessage
illegalTypedBracket
           ; RunSplice TcRef [ForeignRef (Q ())]
_    ->
               -- See Note [RunSplice ThLevel] in GHC.Tc.Types.
               String -> SDoc -> RnM ()
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"rnTypedBracket: Renaming typed bracket when running a splice"
                        (HsExpr GhcPs -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsExpr GhcPs
e)
           ; ThStage
Comp           -> () -> RnM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
           ; Brack {}       -> TcRnMessage -> RnM ()
forall a. TcRnMessage -> TcRn a
failWithTc TcRnMessage
illegalBracket
           }

         -- Brackets are desugared to code that mentions the TH package
       ; RnM ()
recordThUse

       ; String -> SDoc -> RnM ()
traceRn String
"Renaming typed TH bracket" SDoc
empty
       ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
body', FreeVars
fvs_e) <- ThStage
-> TcM (GenLocated SrcSpanAnnA (HsExpr GhcRn), FreeVars)
-> TcM (GenLocated SrcSpanAnnA (HsExpr GhcRn), FreeVars)
forall a. ThStage -> TcM a -> TcM a
setStage (ThStage -> PendingStuff -> ThStage
Brack ThStage
cur_stage PendingStuff
RnPendingTyped) (TcM (GenLocated SrcSpanAnnA (HsExpr GhcRn), FreeVars)
 -> TcM (GenLocated SrcSpanAnnA (HsExpr GhcRn), FreeVars))
-> TcM (GenLocated SrcSpanAnnA (HsExpr GhcRn), FreeVars)
-> TcM (GenLocated SrcSpanAnnA (HsExpr GhcRn), FreeVars)
forall a b. (a -> b) -> a -> b
$ LHsExpr GhcPs -> RnM (LHsExpr GhcRn, FreeVars)
rnLExpr LHsExpr GhcPs
br_body

       ; (HsExpr GhcRn, FreeVars) -> RnM (HsExpr GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XTypedBracket GhcRn -> LHsExpr GhcRn -> HsExpr GhcRn
forall p. XTypedBracket p -> LHsExpr p -> HsExpr p
HsTypedBracket NoExtField
XTypedBracket GhcRn
noExtField LHsExpr GhcRn
GenLocated SrcSpanAnnA (HsExpr GhcRn)
body', FreeVars
fvs_e)

       }

rnUntypedBracket :: HsExpr GhcPs -> HsQuote GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnUntypedBracket :: HsExpr GhcPs -> HsQuote GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnUntypedBracket HsExpr GhcPs
e HsQuote GhcPs
br_body
  = SDoc
-> RnM (HsExpr GhcRn, FreeVars) -> RnM (HsExpr GhcRn, FreeVars)
forall a. SDoc -> TcM a -> TcM a
addErrCtxt (HsQuote GhcPs -> SDoc
untypedQuotationCtxtDoc HsQuote GhcPs
br_body) (RnM (HsExpr GhcRn, FreeVars) -> RnM (HsExpr GhcRn, FreeVars))
-> RnM (HsExpr GhcRn, FreeVars) -> RnM (HsExpr GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$
    do { HsExpr GhcPs -> RnM ()
checkForTemplateHaskellQuotes HsExpr GhcPs
e

         -- Check for nested brackets
       ; ThStage
cur_stage <- TcM ThStage
getStage
       ; case ThStage
cur_stage of
           { Splice SpliceType
Typed   -> TcRnMessage -> RnM ()
forall a. TcRnMessage -> TcRn a
failWithTc TcRnMessage
illegalUntypedBracket
           ; Splice SpliceType
Untyped -> () -> RnM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
           ; RunSplice TcRef [ForeignRef (Q ())]
_    ->
               -- See Note [RunSplice ThLevel] in GHC.Tc.Types.
               String -> SDoc -> RnM ()
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"rnUntypedBracket: Renaming untyped bracket when running a splice"
                        (HsExpr GhcPs -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsExpr GhcPs
e)
           ; ThStage
Comp           -> () -> RnM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
           ; Brack {}       -> TcRnMessage -> RnM ()
forall a. TcRnMessage -> TcRn a
failWithTc TcRnMessage
illegalBracket
           }

         -- Brackets are desugared to code that mentions the TH package
       ; RnM ()
recordThUse

       ; String -> SDoc -> RnM ()
traceRn String
"Renaming untyped TH bracket" SDoc
empty
       ; IORef [PendingRnSplice]
ps_var <- [PendingRnSplice]
-> IOEnv (Env TcGblEnv TcLclEnv) (IORef [PendingRnSplice])
forall a env. a -> IOEnv env (IORef a)
newMutVar []
       ; (HsQuote GhcRn
body', FreeVars
fvs_e) <-
         -- See Note [Rebindable syntax and Template Haskell]
         Extension
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
forall gbl lcl a. Extension -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
unsetXOptM Extension
LangExt.RebindableSyntax (TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
 -> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars))
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$
         ThStage
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
forall a. ThStage -> TcM a -> TcM a
setStage (ThStage -> PendingStuff -> ThStage
Brack ThStage
cur_stage (IORef [PendingRnSplice] -> PendingStuff
RnPendingUntyped IORef [PendingRnSplice]
ps_var)) (TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
 -> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars))
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$
                  ThStage
-> HsQuote GhcPs
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
rn_utbracket ThStage
cur_stage HsQuote GhcPs
br_body
       ; [PendingRnSplice]
pendings <- IORef [PendingRnSplice]
-> IOEnv (Env TcGblEnv TcLclEnv) [PendingRnSplice]
forall a env. IORef a -> IOEnv env a
readMutVar IORef [PendingRnSplice]
ps_var
       ; (HsExpr GhcRn, FreeVars) -> RnM (HsExpr GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XUntypedBracket GhcRn -> HsQuote GhcRn -> HsExpr GhcRn
forall p. XUntypedBracket p -> HsQuote p -> HsExpr p
HsUntypedBracket [PendingRnSplice]
XUntypedBracket GhcRn
pendings HsQuote GhcRn
body', FreeVars
fvs_e)

       }

rn_utbracket :: ThStage -> HsQuote GhcPs -> RnM (HsQuote GhcRn, FreeVars)
rn_utbracket :: ThStage
-> HsQuote GhcPs
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
rn_utbracket ThStage
outer_stage br :: HsQuote GhcPs
br@(VarBr XVarBr GhcPs
x Bool
flg LIdP GhcPs
rdr_name)
  = do { Name
name <- RdrName -> RnM Name
lookupOccRn (GenLocated SrcSpanAnnN RdrName -> RdrName
forall l e. GenLocated l e -> e
unLoc LIdP GhcPs
GenLocated SrcSpanAnnN RdrName
rdr_name)
       ; Bool -> Name -> RnM ()
check_namespace Bool
flg Name
name
       ; Module
this_mod <- IOEnv (Env TcGblEnv TcLclEnv) Module
forall (m :: * -> *). HasModule m => m Module
getModule

       ; Bool -> RnM () -> RnM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
flg Bool -> Bool -> Bool
&& Module -> Name -> Bool
nameIsLocalOrFrom Module
this_mod Name
name) (RnM () -> RnM ()) -> RnM () -> RnM ()
forall a b. (a -> b) -> a -> b
$
             -- Type variables can be quoted in TH. See #5721.
                 do { Maybe (TopLevelFlag, ThLevel)
mb_bind_lvl <- Name -> RnM (Maybe (TopLevelFlag, ThLevel))
lookupLocalOccThLvl_maybe Name
name
                    ; case Maybe (TopLevelFlag, ThLevel)
mb_bind_lvl of
                        { Maybe (TopLevelFlag, ThLevel)
Nothing -> () -> RnM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()      -- Can happen for data constructors,
                                                    -- but nothing needs to be done for them

                        ; Just (TopLevelFlag
top_lvl, ThLevel
bind_lvl)  -- See Note [Quoting names]
                             | TopLevelFlag -> Bool
isTopLevel TopLevelFlag
top_lvl
                             -> Bool -> RnM () -> RnM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Name -> Bool
isExternalName Name
name) (Name -> RnM ()
keepAlive Name
name)
                             | Bool
otherwise
                             -> do { String -> SDoc -> RnM ()
traceRn String
"rn_utbracket VarBr"
                                      (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name SDoc -> SDoc -> SDoc
<+> ThLevel -> SDoc
forall a. Outputable a => a -> SDoc
ppr ThLevel
bind_lvl
                                                SDoc -> SDoc -> SDoc
<+> ThStage -> SDoc
forall a. Outputable a => a -> SDoc
ppr ThStage
outer_stage)
                                   ; Bool -> TcRnMessage -> RnM ()
checkTc (ThStage -> ThLevel
thLevel ThStage
outer_stage ThLevel -> ThLevel -> ThLevel
forall a. Num a => a -> a -> a
+ ThLevel
1 ThLevel -> ThLevel -> Bool
forall a. Eq a => a -> a -> Bool
== ThLevel
bind_lvl)
                                             (HsQuote GhcPs -> TcRnMessage
quotedNameStageErr HsQuote GhcPs
br) }
                        }
                    }
       ; (HsQuote GhcRn, FreeVars)
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XVarBr GhcRn -> Bool -> LIdP GhcRn -> HsQuote GhcRn
forall p. XVarBr p -> Bool -> LIdP p -> HsQuote p
VarBr XVarBr GhcRn
XVarBr GhcPs
x Bool
flg (Name -> LocatedAn NameAnn Name
forall a an. a -> LocatedAn an a
noLocA Name
name), Name -> FreeVars
unitFV Name
name) }

rn_utbracket ThStage
_ (ExpBr XExpBr GhcPs
x LHsExpr GhcPs
e) = do { (GenLocated SrcSpanAnnA (HsExpr GhcRn)
e', FreeVars
fvs) <- LHsExpr GhcPs -> RnM (LHsExpr GhcRn, FreeVars)
rnLExpr LHsExpr GhcPs
e
                                ; (HsQuote GhcRn, FreeVars)
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XExpBr GhcRn -> LHsExpr GhcRn -> HsQuote GhcRn
forall p. XExpBr p -> LHsExpr p -> HsQuote p
ExpBr XExpBr GhcRn
XExpBr GhcPs
x LHsExpr GhcRn
GenLocated SrcSpanAnnA (HsExpr GhcRn)
e', FreeVars
fvs) }

rn_utbracket ThStage
_ (PatBr XPatBr GhcPs
x LPat GhcPs
p)
  = HsMatchContext GhcRn
-> LPat GhcPs
-> (LPat GhcRn
    -> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars))
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
forall a.
HsMatchContext GhcRn
-> LPat GhcPs
-> (LPat GhcRn -> RnM (a, FreeVars))
-> RnM (a, FreeVars)
rnPat HsMatchContext GhcRn
forall p. HsMatchContext p
ThPatQuote LPat GhcPs
p ((LPat GhcRn -> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars))
 -> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars))
-> (LPat GhcRn
    -> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars))
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$ \ LPat GhcRn
p' -> (HsQuote GhcRn, FreeVars)
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XPatBr GhcRn -> LPat GhcRn -> HsQuote GhcRn
forall p. XPatBr p -> LPat p -> HsQuote p
PatBr XPatBr GhcRn
XPatBr GhcPs
x LPat GhcRn
p', FreeVars
emptyFVs)

rn_utbracket ThStage
_ (TypBr XTypBr GhcPs
x LHsType GhcPs
t) = do { (GenLocated SrcSpanAnnA (HsType GhcRn)
t', FreeVars
fvs) <- HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars)
rnLHsType HsDocContext
TypBrCtx LHsType GhcPs
t
                                ; (HsQuote GhcRn, FreeVars)
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XTypBr GhcRn -> LHsType GhcRn -> HsQuote GhcRn
forall p. XTypBr p -> LHsType p -> HsQuote p
TypBr XTypBr GhcRn
XTypBr GhcPs
x LHsType GhcRn
GenLocated SrcSpanAnnA (HsType GhcRn)
t', FreeVars
fvs) }

rn_utbracket ThStage
_ (DecBrL XDecBrL GhcPs
x [LHsDecl GhcPs]
decls)
  = do { HsGroup GhcPs
group <- [LHsDecl GhcPs] -> RnM (HsGroup GhcPs)
groupDecls [LHsDecl GhcPs]
decls
       ; TcGblEnv
gbl_env  <- TcRnIf TcGblEnv TcLclEnv TcGblEnv
forall gbl lcl. TcRnIf gbl lcl gbl
getGblEnv
       ; let new_gbl_env :: TcGblEnv
new_gbl_env = TcGblEnv
gbl_env { tcg_dus :: DefUses
tcg_dus = DefUses
emptyDUs }
                          -- The emptyDUs is so that we just collect uses for this
                          -- group alone in the call to rnSrcDecls below
       ; (TcGblEnv
tcg_env, HsGroup GhcRn
group') <- TcGblEnv
-> TcRnIf TcGblEnv TcLclEnv (TcGblEnv, HsGroup GhcRn)
-> TcRnIf TcGblEnv TcLclEnv (TcGblEnv, HsGroup GhcRn)
forall gbl' lcl a gbl.
gbl' -> TcRnIf gbl' lcl a -> TcRnIf gbl lcl a
setGblEnv TcGblEnv
new_gbl_env (TcRnIf TcGblEnv TcLclEnv (TcGblEnv, HsGroup GhcRn)
 -> TcRnIf TcGblEnv TcLclEnv (TcGblEnv, HsGroup GhcRn))
-> TcRnIf TcGblEnv TcLclEnv (TcGblEnv, HsGroup GhcRn)
-> TcRnIf TcGblEnv TcLclEnv (TcGblEnv, HsGroup GhcRn)
forall a b. (a -> b) -> a -> b
$
                              HsGroup GhcPs -> TcRnIf TcGblEnv TcLclEnv (TcGblEnv, HsGroup GhcRn)
rnSrcDecls HsGroup GhcPs
group

              -- Discard the tcg_env; it contains only extra info about fixity
        ; String -> SDoc -> RnM ()
traceRn String
"rn_utbracket dec" (DefUses -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TcGblEnv -> DefUses
tcg_dus TcGblEnv
tcg_env) SDoc -> SDoc -> SDoc
$$
                   FreeVars -> SDoc
forall a. Outputable a => a -> SDoc
ppr (DefUses -> FreeVars
duUses (TcGblEnv -> DefUses
tcg_dus TcGblEnv
tcg_env)))
        ; (HsQuote GhcRn, FreeVars)
-> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XDecBrG GhcRn -> HsGroup GhcRn -> HsQuote GhcRn
forall p. XDecBrG p -> HsGroup p -> HsQuote p
DecBrG XDecBrL GhcPs
XDecBrG GhcRn
x HsGroup GhcRn
group', DefUses -> FreeVars
duUses (TcGblEnv -> DefUses
tcg_dus TcGblEnv
tcg_env)) }
  where
    groupDecls :: [LHsDecl GhcPs] -> RnM (HsGroup GhcPs)
    groupDecls :: [LHsDecl GhcPs] -> RnM (HsGroup GhcPs)
groupDecls [LHsDecl GhcPs]
decls
      = do { (HsGroup GhcPs
group, Maybe (SpliceDecl GhcPs, [GenLocated SrcSpanAnnA (HsDecl GhcPs)])
mb_splice) <- [LHsDecl GhcPs]
-> RnM (HsGroup GhcPs, Maybe (SpliceDecl GhcPs, [LHsDecl GhcPs]))
findSplice [LHsDecl GhcPs]
decls
           ; case Maybe (SpliceDecl GhcPs, [GenLocated SrcSpanAnnA (HsDecl GhcPs)])
mb_splice of
           { Maybe (SpliceDecl GhcPs, [GenLocated SrcSpanAnnA (HsDecl GhcPs)])
Nothing -> HsGroup GhcPs -> RnM (HsGroup GhcPs)
forall (m :: * -> *) a. Monad m => a -> m a
return HsGroup GhcPs
group
           ; Just (SpliceDecl GhcPs
splice, [GenLocated SrcSpanAnnA (HsDecl GhcPs)]
rest) ->
               do { HsGroup GhcPs
group' <- [LHsDecl GhcPs] -> RnM (HsGroup GhcPs)
groupDecls [LHsDecl GhcPs]
[GenLocated SrcSpanAnnA (HsDecl GhcPs)]
rest
                  ; let group'' :: HsGroup GhcPs
group'' = HsGroup GhcPs -> HsGroup GhcPs -> HsGroup GhcPs
forall (p :: Pass).
HsGroup (GhcPass p) -> HsGroup (GhcPass p) -> HsGroup (GhcPass p)
appendGroups HsGroup GhcPs
group HsGroup GhcPs
group'
                  ; HsGroup GhcPs -> RnM (HsGroup GhcPs)
forall (m :: * -> *) a. Monad m => a -> m a
return HsGroup GhcPs
group'' { hs_splcds :: [LSpliceDecl GhcPs]
hs_splcds = SpliceDecl GhcPs -> LocatedAn AnnListItem (SpliceDecl GhcPs)
forall a an. a -> LocatedAn an a
noLocA SpliceDecl GhcPs
splice LocatedAn AnnListItem (SpliceDecl GhcPs)
-> [LocatedAn AnnListItem (SpliceDecl GhcPs)]
-> [LocatedAn AnnListItem (SpliceDecl GhcPs)]
forall a. a -> [a] -> [a]
: HsGroup GhcPs -> [LSpliceDecl GhcPs]
forall p. HsGroup p -> [LSpliceDecl p]
hs_splcds HsGroup GhcPs
group' }
                  }
           }}

rn_utbracket ThStage
_ (DecBrG {}) = String -> TcRnIf TcGblEnv TcLclEnv (HsQuote GhcRn, FreeVars)
forall a. String -> a
panic String
"rn_ut_bracket: unexpected DecBrG"


-- | Ensure that we are not using a term-level name in a type-level namespace
-- or vice-versa. Throws a 'TcRnIncorrectNameSpace' error if there is a problem.
check_namespace :: Bool -> Name -> RnM ()
check_namespace :: Bool -> Name -> RnM ()
check_namespace Bool
is_single_tick Name
nm
  = Bool -> RnM () -> RnM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (NameSpace -> Bool
isValNameSpace NameSpace
ns Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
is_single_tick) (RnM () -> RnM ()) -> RnM () -> RnM ()
forall a b. (a -> b) -> a -> b
$
      TcRnMessage -> RnM ()
forall a. TcRnMessage -> TcRn a
failWithTc (TcRnMessage -> RnM ()) -> TcRnMessage -> RnM ()
forall a b. (a -> b) -> a -> b
$ (Name -> Bool -> TcRnMessage
TcRnIncorrectNameSpace Name
nm Bool
True)
  where
    ns :: NameSpace
ns = Name -> NameSpace
nameNameSpace Name
nm

typedQuotationCtxtDoc :: LHsExpr GhcPs -> SDoc
typedQuotationCtxtDoc :: LHsExpr GhcPs -> SDoc
typedQuotationCtxtDoc LHsExpr GhcPs
br_body
  = SDoc -> ThLevel -> SDoc -> SDoc
hang (String -> SDoc
text String
"In the Template Haskell typed quotation")
         ThLevel
2 (SDoc -> SDoc
thTyBrackets (SDoc -> SDoc)
-> (GenLocated SrcSpanAnnA (HsExpr GhcPs) -> SDoc)
-> GenLocated SrcSpanAnnA (HsExpr GhcPs)
-> SDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenLocated SrcSpanAnnA (HsExpr GhcPs) -> SDoc
forall a. Outputable a => a -> SDoc
ppr (GenLocated SrcSpanAnnA (HsExpr GhcPs) -> SDoc)
-> GenLocated SrcSpanAnnA (HsExpr GhcPs) -> SDoc
forall a b. (a -> b) -> a -> b
$ LHsExpr GhcPs
GenLocated SrcSpanAnnA (HsExpr GhcPs)
br_body)

untypedQuotationCtxtDoc :: HsQuote GhcPs -> SDoc
untypedQuotationCtxtDoc :: HsQuote GhcPs -> SDoc
untypedQuotationCtxtDoc HsQuote GhcPs
br_body
  = SDoc -> ThLevel -> SDoc -> SDoc
hang (String -> SDoc
text String
"In the Template Haskell quotation")
         ThLevel
2 (HsQuote GhcPs -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsQuote GhcPs
br_body)

illegalBracket :: TcRnMessage
illegalBracket :: TcRnMessage
illegalBracket = DiagnosticMessage -> TcRnMessage
forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
-> DiagnosticMessage -> TcRnMessage
forall a b. (a -> b) -> a -> b
$ [GhcHint] -> SDoc -> DiagnosticMessage
mkPlainError [GhcHint]
noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
forall a b. (a -> b) -> a -> b
$
    String -> SDoc
text String
"Template Haskell brackets cannot be nested" SDoc -> SDoc -> SDoc
<+>
    String -> SDoc
text String
"(without intervening splices)"

illegalTypedBracket :: TcRnMessage
illegalTypedBracket :: TcRnMessage
illegalTypedBracket = DiagnosticMessage -> TcRnMessage
forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
-> DiagnosticMessage -> TcRnMessage
forall a b. (a -> b) -> a -> b
$ [GhcHint] -> SDoc -> DiagnosticMessage
mkPlainError [GhcHint]
noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
forall a b. (a -> b) -> a -> b
$
    String -> SDoc
text String
"Typed brackets may only appear in typed splices."

illegalUntypedBracket :: TcRnMessage
illegalUntypedBracket :: TcRnMessage
illegalUntypedBracket = DiagnosticMessage -> TcRnMessage
forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
-> DiagnosticMessage -> TcRnMessage
forall a b. (a -> b) -> a -> b
$ [GhcHint] -> SDoc -> DiagnosticMessage
mkPlainError [GhcHint]
noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
forall a b. (a -> b) -> a -> b
$
    String -> SDoc
text String
"Untyped brackets may only appear in untyped splices."

quotedNameStageErr :: HsQuote GhcPs -> TcRnMessage
quotedNameStageErr :: HsQuote GhcPs -> TcRnMessage
quotedNameStageErr HsQuote GhcPs
br
  = DiagnosticMessage -> TcRnMessage
forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
-> DiagnosticMessage -> TcRnMessage
forall a b. (a -> b) -> a -> b
$ [GhcHint] -> SDoc -> DiagnosticMessage
mkPlainError [GhcHint]
noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
forall a b. (a -> b) -> a -> b
$
    [SDoc] -> SDoc
sep [ String -> SDoc
text String
"Stage error: the non-top-level quoted name" SDoc -> SDoc -> SDoc
<+> HsQuote GhcPs -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsQuote GhcPs
br
        , String -> SDoc
text String
"must be used at the same stage at which it is bound" ]


{-
*********************************************************
*                                                      *
                Splices
*                                                      *
*********************************************************

Note [Free variables of typed splices]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider renaming this:
        f = ...
        h = ...$(thing "f")...

where the splice is a *typed* splice.  The splice can expand into
literally anything, so when we do dependency analysis we must assume
that it might mention 'f'.  So we simply treat all locally-defined
names as mentioned by any splice.  This is terribly brutal, but I
don't see what else to do.  For example, it'll mean that every
locally-defined thing will appear to be used, so no unused-binding
warnings.  But if we miss the dependency, then we might typecheck 'h'
before 'f', and that will crash the type checker because 'f' isn't in
scope.

Currently, I'm not treating a splice as also mentioning every import,
which is a bit inconsistent -- but there are a lot of them.  We might
thereby get some bogus unused-import warnings, but we won't crash the
type checker.  Not very satisfactory really.

Note [Renamer errors]
~~~~~~~~~~~~~~~~~~~~~
It's important to wrap renamer calls in checkNoErrs, because the
renamer does not fail for out of scope variables etc. Instead it
returns a bogus term/type, so that it can report more than one error.
We don't want the type checker to see these bogus unbound variables.
-}

rnSpliceGen :: (HsSplice GhcRn -> RnM (a, FreeVars))
                                            -- Outside brackets, run splice
            -> (HsSplice GhcRn -> (PendingRnSplice, a))
                                            -- Inside brackets, make it pending
            -> HsSplice GhcPs
            -> RnM (a, FreeVars)
rnSpliceGen :: (HsSplice GhcRn -> RnM (a, FreeVars))
-> (HsSplice GhcRn -> (PendingRnSplice, a))
-> HsSplice GhcPs
-> RnM (a, FreeVars)
rnSpliceGen HsSplice GhcRn -> RnM (a, FreeVars)
run_splice HsSplice GhcRn -> (PendingRnSplice, a)
pend_splice HsSplice GhcPs
splice
  = SDoc -> RnM (a, FreeVars) -> RnM (a, FreeVars)
forall a. SDoc -> TcM a -> TcM a
addErrCtxt (HsSplice GhcPs -> SDoc
spliceCtxt HsSplice GhcPs
splice) (RnM (a, FreeVars) -> RnM (a, FreeVars))
-> RnM (a, FreeVars) -> RnM (a, FreeVars)
forall a b. (a -> b) -> a -> b
$ do
    { ThStage
stage <- TcM ThStage
getStage
    ; case ThStage
stage of
        Brack ThStage
pop_stage PendingStuff
RnPendingTyped
          -> do { Bool -> TcRnMessage -> RnM ()
checkTc Bool
is_typed_splice TcRnMessage
illegalUntypedSplice
                ; (HsSplice GhcRn
splice', FreeVars
fvs) <- ThStage
-> TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars)
forall a. ThStage -> TcM a -> TcM a
setStage ThStage
pop_stage (TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars))
-> TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$
                                    HsSplice GhcPs -> TcM (HsSplice GhcRn, FreeVars)
rnSplice HsSplice GhcPs
splice
                ; let (PendingRnSplice
_pending_splice, a
result) = HsSplice GhcRn -> (PendingRnSplice, a)
pend_splice HsSplice GhcRn
splice'
                ; (a, FreeVars) -> RnM (a, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
result, FreeVars
fvs) }

        Brack ThStage
pop_stage (RnPendingUntyped IORef [PendingRnSplice]
ps_var)
          -> do { Bool -> TcRnMessage -> RnM ()
checkTc (Bool -> Bool
not Bool
is_typed_splice) TcRnMessage
illegalTypedSplice
                ; (HsSplice GhcRn
splice', FreeVars
fvs) <- ThStage
-> TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars)
forall a. ThStage -> TcM a -> TcM a
setStage ThStage
pop_stage (TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars))
-> TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$
                                    HsSplice GhcPs -> TcM (HsSplice GhcRn, FreeVars)
rnSplice HsSplice GhcPs
splice
                ; let (PendingRnSplice
pending_splice, a
result) = HsSplice GhcRn -> (PendingRnSplice, a)
pend_splice HsSplice GhcRn
splice'
                ; [PendingRnSplice]
ps <- IORef [PendingRnSplice]
-> IOEnv (Env TcGblEnv TcLclEnv) [PendingRnSplice]
forall a env. IORef a -> IOEnv env a
readMutVar IORef [PendingRnSplice]
ps_var
                ; IORef [PendingRnSplice] -> [PendingRnSplice] -> RnM ()
forall a env. IORef a -> a -> IOEnv env ()
writeMutVar IORef [PendingRnSplice]
ps_var (PendingRnSplice
pending_splice PendingRnSplice -> [PendingRnSplice] -> [PendingRnSplice]
forall a. a -> [a] -> [a]
: [PendingRnSplice]
ps)
                ; (a, FreeVars) -> RnM (a, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
result, FreeVars
fvs) }

        ThStage
_ ->  do { HsSplice GhcPs -> RnM ()
checkTopSpliceAllowed HsSplice GhcPs
splice
                 ; (HsSplice GhcRn
splice', FreeVars
fvs1) <- TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars)
forall r. TcM r -> TcM r
checkNoErrs (TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars))
-> TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$
                                         ThStage
-> TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars)
forall a. ThStage -> TcM a -> TcM a
setStage (SpliceType -> ThStage
Splice SpliceType
splice_type) (TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars))
-> TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$
                                         HsSplice GhcPs -> TcM (HsSplice GhcRn, FreeVars)
rnSplice HsSplice GhcPs
splice
                   -- checkNoErrs: don't attempt to run the splice if
                   -- renaming it failed; otherwise we get a cascade of
                   -- errors from e.g. unbound variables
                 ; (a
result, FreeVars
fvs2) <- HsSplice GhcRn -> RnM (a, FreeVars)
run_splice HsSplice GhcRn
splice'
                 ; (a, FreeVars) -> RnM (a, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
result, FreeVars
fvs1 FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
fvs2) } }
   where
     is_typed_splice :: Bool
is_typed_splice = HsSplice GhcPs -> Bool
forall id. HsSplice id -> Bool
isTypedSplice HsSplice GhcPs
splice
     splice_type :: SpliceType
splice_type = if Bool
is_typed_splice
                   then SpliceType
Typed
                   else SpliceType
Untyped


-- Nested splices are fine without TemplateHaskell because they
-- are not executed until the top-level splice is run.
checkTopSpliceAllowed :: HsSplice GhcPs -> RnM ()
checkTopSpliceAllowed :: HsSplice GhcPs -> RnM ()
checkTopSpliceAllowed HsSplice GhcPs
splice = do
  let (String
herald, Extension
ext) = HsSplice GhcPs -> (String, Extension)
spliceExtension HsSplice GhcPs
splice
  Bool
extEnabled <- Extension -> TcRnIf TcGblEnv TcLclEnv Bool
forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
ext
  Bool -> RnM () -> RnM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
extEnabled
    (TcRnMessage -> RnM ()
forall a. TcRnMessage -> TcRn a
failWith (TcRnMessage -> RnM ()) -> TcRnMessage -> RnM ()
forall a b. (a -> b) -> a -> b
$ DiagnosticMessage -> TcRnMessage
forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
-> DiagnosticMessage -> TcRnMessage
forall a b. (a -> b) -> a -> b
$ [GhcHint] -> SDoc -> DiagnosticMessage
mkPlainError [GhcHint]
noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
forall a b. (a -> b) -> a -> b
$
       String -> SDoc
text String
herald SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
"are not permitted without" SDoc -> SDoc -> SDoc
<+> Extension -> SDoc
forall a. Outputable a => a -> SDoc
ppr Extension
ext)
  where
     spliceExtension :: HsSplice GhcPs -> (String, LangExt.Extension)
     spliceExtension :: HsSplice GhcPs -> (String, Extension)
spliceExtension (HsQuasiQuote {}) = (String
"Quasi-quotes", Extension
LangExt.QuasiQuotes)
     spliceExtension (HsTypedSplice {}) = (String
"Top-level splices", Extension
LangExt.TemplateHaskell)
     spliceExtension (HsUntypedSplice {}) = (String
"Top-level splices", Extension
LangExt.TemplateHaskell)
     spliceExtension s :: HsSplice GhcPs
s@(HsSpliced {}) = String -> SDoc -> (String, Extension)
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"spliceExtension" (HsSplice GhcPs -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsSplice GhcPs
s)

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

-- | Returns the result of running a splice and the modFinalizers collected
-- during the execution.
--
-- See Note [Delaying modFinalizers in untyped splices].
runRnSplice :: UntypedSpliceFlavour
            -> (LHsExpr GhcTc -> TcRn res)
            -> (res -> SDoc)    -- How to pretty-print res
                                -- Usually just ppr, but not for [Decl]
            -> HsSplice GhcRn   -- Always untyped
            -> TcRn (res, [ForeignRef (TH.Q ())])
runRnSplice :: UntypedSpliceFlavour
-> (LHsExpr GhcTc -> TcRn res)
-> (res -> SDoc)
-> HsSplice GhcRn
-> TcRn (res, [ForeignRef (Q ())])
runRnSplice UntypedSpliceFlavour
flavour LHsExpr GhcTc -> TcRn res
run_meta res -> SDoc
ppr_res HsSplice GhcRn
splice
  = do { Hooks
hooks <- HscEnv -> Hooks
hsc_hooks (HscEnv -> Hooks)
-> IOEnv (Env TcGblEnv TcLclEnv) HscEnv
-> IOEnv (Env TcGblEnv TcLclEnv) Hooks
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IOEnv (Env TcGblEnv TcLclEnv) HscEnv
forall gbl lcl. TcRnIf gbl lcl HscEnv
getTopEnv
       ; HsSplice GhcRn
splice' <- case Hooks
-> Maybe
     (HsSplice GhcRn -> IOEnv (Env TcGblEnv TcLclEnv) (HsSplice GhcRn))
runRnSpliceHook Hooks
hooks of
            Maybe
  (HsSplice GhcRn -> IOEnv (Env TcGblEnv TcLclEnv) (HsSplice GhcRn))
Nothing -> HsSplice GhcRn -> IOEnv (Env TcGblEnv TcLclEnv) (HsSplice GhcRn)
forall (m :: * -> *) a. Monad m => a -> m a
return HsSplice GhcRn
splice
            Just HsSplice GhcRn -> IOEnv (Env TcGblEnv TcLclEnv) (HsSplice GhcRn)
h  -> HsSplice GhcRn -> IOEnv (Env TcGblEnv TcLclEnv) (HsSplice GhcRn)
h HsSplice GhcRn
splice

       ; let the_expr :: GenLocated SrcSpanAnnA (HsExpr GhcRn)
the_expr = case HsSplice GhcRn
splice' of
                HsUntypedSplice XUntypedSplice GhcRn
_ SpliceDecoration
_ IdP GhcRn
_ LHsExpr GhcRn
e   ->  LHsExpr GhcRn
GenLocated SrcSpanAnnA (HsExpr GhcRn)
e
                HsQuasiQuote XQuasiQuote GhcRn
_ IdP GhcRn
_ IdP GhcRn
q SrcSpan
qs FastString
str -> UntypedSpliceFlavour
-> Name -> SrcSpan -> FastString -> LHsExpr GhcRn
mkQuasiQuoteExpr UntypedSpliceFlavour
flavour IdP GhcRn
Name
q SrcSpan
qs FastString
str
                HsTypedSplice {}          -> String -> SDoc -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"runRnSplice" (HsSplice GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsSplice GhcRn
splice)
                HsSpliced {}              -> String -> SDoc -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"runRnSplice" (HsSplice GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsSplice GhcRn
splice)

             -- Typecheck the expression
       ; Type
meta_exp_ty   <- Name -> TcM Type
tcMetaTy Name
meta_ty_name
       ; GenLocated SrcSpanAnnA (HsExpr GhcTc)
zonked_q_expr <- LHsExpr GhcTc -> TcM (LHsExpr GhcTc)
GenLocated SrcSpanAnnA (HsExpr GhcTc)
-> IOEnv
     (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnA (HsExpr GhcTc))
zonkTopLExpr (GenLocated SrcSpanAnnA (HsExpr GhcTc)
 -> IOEnv
      (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnA (HsExpr GhcTc)))
-> IOEnv
     (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnA (HsExpr GhcTc))
-> IOEnv
     (Env TcGblEnv TcLclEnv) (GenLocated SrcSpanAnnA (HsExpr GhcTc))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
                            SpliceType -> TcM (LHsExpr GhcTc) -> TcM (LHsExpr GhcTc)
tcTopSpliceExpr SpliceType
Untyped
                              (LHsExpr GhcRn -> Type -> TcM (LHsExpr GhcTc)
tcCheckPolyExpr LHsExpr GhcRn
GenLocated SrcSpanAnnA (HsExpr GhcRn)
the_expr Type
meta_exp_ty)

             -- Run the expression
       ; TcRef [ForeignRef (Q ())]
mod_finalizers_ref <- [ForeignRef (Q ())]
-> TcRnIf TcGblEnv TcLclEnv (TcRef [ForeignRef (Q ())])
forall a gbl lcl. a -> TcRnIf gbl lcl (TcRef a)
newTcRef []
       ; res
result <- ThStage -> TcRn res -> TcRn res
forall a. ThStage -> TcM a -> TcM a
setStage (TcRef [ForeignRef (Q ())] -> ThStage
RunSplice TcRef [ForeignRef (Q ())]
mod_finalizers_ref) (TcRn res -> TcRn res) -> TcRn res -> TcRn res
forall a b. (a -> b) -> a -> b
$
                     LHsExpr GhcTc -> TcRn res
run_meta LHsExpr GhcTc
GenLocated SrcSpanAnnA (HsExpr GhcTc)
zonked_q_expr
       ; [ForeignRef (Q ())]
mod_finalizers <- TcRef [ForeignRef (Q ())]
-> TcRnIf TcGblEnv TcLclEnv [ForeignRef (Q ())]
forall a gbl lcl. TcRef a -> TcRnIf gbl lcl a
readTcRef TcRef [ForeignRef (Q ())]
mod_finalizers_ref
       ; SpliceInfo -> RnM ()
traceSplice (SpliceInfo :: String -> Maybe (LHsExpr GhcRn) -> Bool -> SDoc -> SpliceInfo
SpliceInfo { spliceDescription :: String
spliceDescription = String
what
                                 , spliceIsDecl :: Bool
spliceIsDecl      = Bool
is_decl
                                 , spliceSource :: Maybe (LHsExpr GhcRn)
spliceSource      = GenLocated SrcSpanAnnA (HsExpr GhcRn)
-> Maybe (GenLocated SrcSpanAnnA (HsExpr GhcRn))
forall a. a -> Maybe a
Just GenLocated SrcSpanAnnA (HsExpr GhcRn)
the_expr
                                 , spliceGenerated :: SDoc
spliceGenerated   = res -> SDoc
ppr_res res
result })

       ; (res, [ForeignRef (Q ())]) -> TcRn (res, [ForeignRef (Q ())])
forall (m :: * -> *) a. Monad m => a -> m a
return (res
result, [ForeignRef (Q ())]
mod_finalizers) }

  where
    meta_ty_name :: Name
meta_ty_name = case UntypedSpliceFlavour
flavour of
                       UntypedSpliceFlavour
UntypedExpSplice  -> Name
expQTyConName
                       UntypedSpliceFlavour
UntypedPatSplice  -> Name
patQTyConName
                       UntypedSpliceFlavour
UntypedTypeSplice -> Name
typeQTyConName
                       UntypedSpliceFlavour
UntypedDeclSplice -> Name
decsQTyConName
    what :: String
what = case UntypedSpliceFlavour
flavour of
                  UntypedSpliceFlavour
UntypedExpSplice  -> String
"expression"
                  UntypedSpliceFlavour
UntypedPatSplice  -> String
"pattern"
                  UntypedSpliceFlavour
UntypedTypeSplice -> String
"type"
                  UntypedSpliceFlavour
UntypedDeclSplice -> String
"declarations"
    is_decl :: Bool
is_decl = case UntypedSpliceFlavour
flavour of
                 UntypedSpliceFlavour
UntypedDeclSplice -> Bool
True
                 UntypedSpliceFlavour
_                 -> Bool
False

------------------
makePending :: UntypedSpliceFlavour
            -> HsSplice GhcRn
            -> PendingRnSplice
makePending :: UntypedSpliceFlavour -> HsSplice GhcRn -> PendingRnSplice
makePending UntypedSpliceFlavour
flavour (HsUntypedSplice XUntypedSplice GhcRn
_ SpliceDecoration
_ IdP GhcRn
n LHsExpr GhcRn
e)
  = UntypedSpliceFlavour -> Name -> LHsExpr GhcRn -> PendingRnSplice
PendingRnSplice UntypedSpliceFlavour
flavour IdP GhcRn
Name
n LHsExpr GhcRn
e
makePending UntypedSpliceFlavour
flavour (HsQuasiQuote XQuasiQuote GhcRn
_ IdP GhcRn
n IdP GhcRn
quoter SrcSpan
q_span FastString
quote)
  = UntypedSpliceFlavour -> Name -> LHsExpr GhcRn -> PendingRnSplice
PendingRnSplice UntypedSpliceFlavour
flavour IdP GhcRn
Name
n (UntypedSpliceFlavour
-> Name -> SrcSpan -> FastString -> LHsExpr GhcRn
mkQuasiQuoteExpr UntypedSpliceFlavour
flavour IdP GhcRn
Name
quoter SrcSpan
q_span FastString
quote)
makePending UntypedSpliceFlavour
_ splice :: HsSplice GhcRn
splice@(HsTypedSplice {})
  = String -> SDoc -> PendingRnSplice
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"makePending" (HsSplice GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsSplice GhcRn
splice)
makePending UntypedSpliceFlavour
_ splice :: HsSplice GhcRn
splice@(HsSpliced {})
  = String -> SDoc -> PendingRnSplice
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"makePending" (HsSplice GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsSplice GhcRn
splice)

------------------
mkQuasiQuoteExpr :: UntypedSpliceFlavour -> Name -> SrcSpan -> FastString
                 -> LHsExpr GhcRn
-- Return the expression (quoter "...quote...")
-- which is what we must run in a quasi-quote
mkQuasiQuoteExpr :: UntypedSpliceFlavour
-> Name -> SrcSpan -> FastString -> LHsExpr GhcRn
mkQuasiQuoteExpr UntypedSpliceFlavour
flavour Name
quoter SrcSpan
q_span' FastString
quote
  = SrcSpanAnnA
-> HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
q_span (HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn))
-> HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
forall a b. (a -> b) -> a -> b
$ XApp GhcRn -> LHsExpr GhcRn -> LHsExpr GhcRn -> HsExpr GhcRn
forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp XApp GhcRn
EpAnnCO
noComments (SrcSpanAnnA
-> HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
q_span
             (HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn))
-> HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
forall a b. (a -> b) -> a -> b
$ XApp GhcRn -> LHsExpr GhcRn -> LHsExpr GhcRn -> HsExpr GhcRn
forall p. XApp p -> LHsExpr p -> LHsExpr p -> HsExpr p
HsApp XApp GhcRn
EpAnnCO
noComments (SrcSpanAnnA
-> HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
q_span
                    (XVar GhcRn -> LIdP GhcRn -> HsExpr GhcRn
forall p. XVar p -> LIdP p -> HsExpr p
HsVar NoExtField
XVar GhcRn
noExtField (SrcSpanAnnN -> Name -> LocatedAn NameAnn Name
forall l e. l -> e -> GenLocated l e
L (SrcSpanAnnA -> SrcSpanAnnN
forall a. SrcSpanAnn' a -> SrcSpanAnnN
la2na SrcSpanAnnA
q_span) Name
quote_selector)))
                                LHsExpr GhcRn
GenLocated SrcSpanAnnA (HsExpr GhcRn)
quoterExpr)
                    LHsExpr GhcRn
GenLocated SrcSpanAnnA (HsExpr GhcRn)
quoteExpr
  where
    q_span :: SrcSpanAnnA
q_span = SrcSpan -> SrcSpanAnnA
forall ann. SrcSpan -> SrcAnn ann
noAnnSrcSpan SrcSpan
q_span'
    quoterExpr :: GenLocated SrcSpanAnnA (HsExpr GhcRn)
quoterExpr = SrcSpanAnnA
-> HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
q_span (HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn))
-> HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
forall a b. (a -> b) -> a -> b
$! XVar GhcRn -> LIdP GhcRn -> HsExpr GhcRn
forall p. XVar p -> LIdP p -> HsExpr p
HsVar NoExtField
XVar GhcRn
noExtField (LocatedAn NameAnn Name -> HsExpr GhcRn)
-> LocatedAn NameAnn Name -> HsExpr GhcRn
forall a b. (a -> b) -> a -> b
$! (SrcSpanAnnN -> Name -> LocatedAn NameAnn Name
forall l e. l -> e -> GenLocated l e
L (SrcSpanAnnA -> SrcSpanAnnN
forall a. SrcSpanAnn' a -> SrcSpanAnnN
la2na SrcSpanAnnA
q_span) Name
quoter)
    quoteExpr :: GenLocated SrcSpanAnnA (HsExpr GhcRn)
quoteExpr  = SrcSpanAnnA
-> HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
q_span (HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn))
-> HsExpr GhcRn -> GenLocated SrcSpanAnnA (HsExpr GhcRn)
forall a b. (a -> b) -> a -> b
$! XLitE GhcRn -> HsLit GhcRn -> HsExpr GhcRn
forall p. XLitE p -> HsLit p -> HsExpr p
HsLit XLitE GhcRn
EpAnnCO
noComments (HsLit GhcRn -> HsExpr GhcRn) -> HsLit GhcRn -> HsExpr GhcRn
forall a b. (a -> b) -> a -> b
$! XHsString GhcRn -> FastString -> HsLit GhcRn
forall x. XHsString x -> FastString -> HsLit x
HsString XHsString GhcRn
SourceText
NoSourceText FastString
quote
    quote_selector :: Name
quote_selector = case UntypedSpliceFlavour
flavour of
                       UntypedSpliceFlavour
UntypedExpSplice  -> Name
quoteExpName
                       UntypedSpliceFlavour
UntypedPatSplice  -> Name
quotePatName
                       UntypedSpliceFlavour
UntypedTypeSplice -> Name
quoteTypeName
                       UntypedSpliceFlavour
UntypedDeclSplice -> Name
quoteDecName

---------------------
rnSplice :: HsSplice GhcPs -> RnM (HsSplice GhcRn, FreeVars)
-- Not exported...used for all
rnSplice :: HsSplice GhcPs -> TcM (HsSplice GhcRn, FreeVars)
rnSplice (HsTypedSplice XTypedSplice GhcPs
x SpliceDecoration
hasParen IdP GhcPs
splice_name LHsExpr GhcPs
expr)
  = do  { SrcSpan
loc  <- TcRn SrcSpan
getSrcSpanM
        ; Name
n' <- GenLocated SrcSpanAnnN RdrName -> RnM Name
newLocalBndrRn (SrcSpanAnnN -> RdrName -> GenLocated SrcSpanAnnN RdrName
forall l e. l -> e -> GenLocated l e
L (SrcSpan -> SrcSpanAnnN
forall ann. SrcSpan -> SrcAnn ann
noAnnSrcSpan SrcSpan
loc) IdP GhcPs
RdrName
splice_name)
        ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvs) <- LHsExpr GhcPs -> RnM (LHsExpr GhcRn, FreeVars)
rnLExpr LHsExpr GhcPs
expr
        ; (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XTypedSplice GhcRn
-> SpliceDecoration -> IdP GhcRn -> LHsExpr GhcRn -> HsSplice GhcRn
forall id.
XTypedSplice id
-> SpliceDecoration -> IdP id -> LHsExpr id -> HsSplice id
HsTypedSplice XTypedSplice GhcRn
XTypedSplice GhcPs
x SpliceDecoration
hasParen IdP GhcRn
Name
n' LHsExpr GhcRn
GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvs) }

rnSplice (HsUntypedSplice XUntypedSplice GhcPs
x SpliceDecoration
hasParen IdP GhcPs
splice_name LHsExpr GhcPs
expr)
  = do  { SrcSpan
loc  <- TcRn SrcSpan
getSrcSpanM
        ; Name
n' <- GenLocated SrcSpanAnnN RdrName -> RnM Name
newLocalBndrRn (SrcSpanAnnN -> RdrName -> GenLocated SrcSpanAnnN RdrName
forall l e. l -> e -> GenLocated l e
L (SrcSpan -> SrcSpanAnnN
forall ann. SrcSpan -> SrcAnn ann
noAnnSrcSpan SrcSpan
loc) IdP GhcPs
RdrName
splice_name)
        ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvs) <- LHsExpr GhcPs -> RnM (LHsExpr GhcRn, FreeVars)
rnLExpr LHsExpr GhcPs
expr
        ; (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XUntypedSplice GhcRn
-> SpliceDecoration -> IdP GhcRn -> LHsExpr GhcRn -> HsSplice GhcRn
forall id.
XUntypedSplice id
-> SpliceDecoration -> IdP id -> LHsExpr id -> HsSplice id
HsUntypedSplice XUntypedSplice GhcRn
XUntypedSplice GhcPs
x SpliceDecoration
hasParen IdP GhcRn
Name
n' LHsExpr GhcRn
GenLocated SrcSpanAnnA (HsExpr GhcRn)
expr', FreeVars
fvs) }

rnSplice (HsQuasiQuote XQuasiQuote GhcPs
x IdP GhcPs
splice_name IdP GhcPs
quoter SrcSpan
q_loc FastString
quote)
  = do  { SrcSpan
loc  <- TcRn SrcSpan
getSrcSpanM
        ; Name
splice_name' <- GenLocated SrcSpanAnnN RdrName -> RnM Name
newLocalBndrRn (SrcSpanAnnN -> RdrName -> GenLocated SrcSpanAnnN RdrName
forall l e. l -> e -> GenLocated l e
L (SrcSpan -> SrcSpanAnnN
forall ann. SrcSpan -> SrcAnn ann
noAnnSrcSpan SrcSpan
loc) IdP GhcPs
RdrName
splice_name)

          -- Rename the quoter; akin to the HsVar case of rnExpr
        ; Name
quoter' <- RdrName -> RnM Name
lookupOccRn IdP GhcPs
RdrName
quoter
        ; Module
this_mod <- IOEnv (Env TcGblEnv TcLclEnv) Module
forall (m :: * -> *). HasModule m => m Module
getModule
        ; Bool -> RnM () -> RnM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Module -> Name -> Bool
nameIsLocalOrFrom Module
this_mod Name
quoter') (RnM () -> RnM ()) -> RnM () -> RnM ()
forall a b. (a -> b) -> a -> b
$
          Name -> RnM ()
checkThLocalName Name
quoter'

        ; (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XQuasiQuote GhcRn
-> IdP GhcRn
-> IdP GhcRn
-> SrcSpan
-> FastString
-> HsSplice GhcRn
forall id.
XQuasiQuote id
-> IdP id -> IdP id -> SrcSpan -> FastString -> HsSplice id
HsQuasiQuote XQuasiQuote GhcRn
XQuasiQuote GhcPs
x IdP GhcRn
Name
splice_name' IdP GhcRn
Name
quoter' SrcSpan
q_loc FastString
quote
                                                             , Name -> FreeVars
unitFV Name
quoter') }

rnSplice splice :: HsSplice GhcPs
splice@(HsSpliced {}) = String -> SDoc -> TcM (HsSplice GhcRn, FreeVars)
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"rnSplice" (HsSplice GhcPs -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsSplice GhcPs
splice)

---------------------
rnSpliceExpr :: HsSplice GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnSpliceExpr :: HsSplice GhcPs -> RnM (HsExpr GhcRn, FreeVars)
rnSpliceExpr HsSplice GhcPs
splice
  = (HsSplice GhcRn -> RnM (HsExpr GhcRn, FreeVars))
-> (HsSplice GhcRn -> (PendingRnSplice, HsExpr GhcRn))
-> HsSplice GhcPs
-> RnM (HsExpr GhcRn, FreeVars)
forall a.
(HsSplice GhcRn -> RnM (a, FreeVars))
-> (HsSplice GhcRn -> (PendingRnSplice, a))
-> HsSplice GhcPs
-> RnM (a, FreeVars)
rnSpliceGen HsSplice GhcRn -> RnM (HsExpr GhcRn, FreeVars)
run_expr_splice HsSplice GhcRn -> (PendingRnSplice, HsExpr GhcRn)
pend_expr_splice HsSplice GhcPs
splice
  where
    pend_expr_splice :: HsSplice GhcRn -> (PendingRnSplice, HsExpr GhcRn)
    pend_expr_splice :: HsSplice GhcRn -> (PendingRnSplice, HsExpr GhcRn)
pend_expr_splice HsSplice GhcRn
rn_splice
        = (UntypedSpliceFlavour -> HsSplice GhcRn -> PendingRnSplice
makePending UntypedSpliceFlavour
UntypedExpSplice HsSplice GhcRn
rn_splice, XSpliceE GhcRn -> HsSplice GhcRn -> HsExpr GhcRn
forall p. XSpliceE p -> HsSplice p -> HsExpr p
HsSpliceE XSpliceE GhcRn
forall a. EpAnn a
noAnn HsSplice GhcRn
rn_splice)

    run_expr_splice :: HsSplice GhcRn -> RnM (HsExpr GhcRn, FreeVars)
    run_expr_splice :: HsSplice GhcRn -> RnM (HsExpr GhcRn, FreeVars)
run_expr_splice HsSplice GhcRn
rn_splice
      | HsSplice GhcRn -> Bool
forall id. HsSplice id -> Bool
isTypedSplice HsSplice GhcRn
rn_splice   -- Run it later, in the type checker
      = do {  -- Ugh!  See Note [Splices] above
             String -> SDoc -> RnM ()
traceRn String
"rnSpliceExpr: typed expression splice" SDoc
empty
           ; LocalRdrEnv
lcl_rdr <- RnM LocalRdrEnv
getLocalRdrEnv
           ; GlobalRdrEnv
gbl_rdr <- TcRn GlobalRdrEnv
getGlobalRdrEnv
           ; let gbl_names :: FreeVars
gbl_names = [Name] -> FreeVars
mkNameSet [GlobalRdrElt -> Name
greMangledName GlobalRdrElt
gre | GlobalRdrElt
gre <- GlobalRdrEnv -> [GlobalRdrElt]
globalRdrEnvElts GlobalRdrEnv
gbl_rdr
                                                     , GlobalRdrElt -> Bool
isLocalGRE GlobalRdrElt
gre]
                 lcl_names :: FreeVars
lcl_names = [Name] -> FreeVars
mkNameSet (LocalRdrEnv -> [Name]
localRdrEnvElts LocalRdrEnv
lcl_rdr)

           ; (HsExpr GhcRn, FreeVars) -> RnM (HsExpr GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (XSpliceE GhcRn -> HsSplice GhcRn -> HsExpr GhcRn
forall p. XSpliceE p -> HsSplice p -> HsExpr p
HsSpliceE XSpliceE GhcRn
forall a. EpAnn a
noAnn HsSplice GhcRn
rn_splice, FreeVars
lcl_names FreeVars -> FreeVars -> FreeVars
`plusFV` FreeVars
gbl_names) }

      | Bool
otherwise  -- Run it here, see Note [Running splices in the Renamer]
      = do { String -> SDoc -> RnM ()
traceRn String
"rnSpliceExpr: untyped expression splice" SDoc
empty
           ; (GenLocated SrcSpanAnnA (HsExpr GhcPs)
rn_expr, [ForeignRef (Q ())]
mod_finalizers) <-
                UntypedSpliceFlavour
-> (LHsExpr GhcTc -> TcRn (GenLocated SrcSpanAnnA (HsExpr GhcPs)))
-> (GenLocated SrcSpanAnnA (HsExpr GhcPs) -> SDoc)
-> HsSplice GhcRn
-> TcRn
     (GenLocated SrcSpanAnnA (HsExpr GhcPs), [ForeignRef (Q ())])
forall res.
UntypedSpliceFlavour
-> (LHsExpr GhcTc -> TcRn res)
-> (res -> SDoc)
-> HsSplice GhcRn
-> TcRn (res, [ForeignRef (Q ())])
runRnSplice UntypedSpliceFlavour
UntypedExpSplice LHsExpr GhcTc -> TcM (LHsExpr GhcPs)
LHsExpr GhcTc -> TcRn (GenLocated SrcSpanAnnA (HsExpr GhcPs))
runMetaE GenLocated SrcSpanAnnA (HsExpr GhcPs) -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsSplice GhcRn
rn_splice
           ; (GenLocated SrcSpanAnnA (HsExpr GhcRn)
lexpr3, FreeVars
fvs) <- TcM (GenLocated SrcSpanAnnA (HsExpr GhcRn), FreeVars)
-> TcM (GenLocated SrcSpanAnnA (HsExpr GhcRn), FreeVars)
forall r. TcM r -> TcM r
checkNoErrs (LHsExpr GhcPs -> RnM (LHsExpr GhcRn, FreeVars)
rnLExpr LHsExpr GhcPs
GenLocated SrcSpanAnnA (HsExpr GhcPs)
rn_expr)
             -- See Note [Delaying modFinalizers in untyped splices].
           ; let e :: GenLocated SrcSpanAnnA (HsExpr GhcRn)
e =  XSpliceE GhcRn -> HsSplice GhcRn -> HsExpr GhcRn
forall p. XSpliceE p -> HsSplice p -> HsExpr p
HsSpliceE XSpliceE GhcRn
forall a. EpAnn a
noAnn
                    (HsSplice GhcRn -> HsExpr GhcRn)
-> (HsExpr GhcRn -> HsSplice GhcRn) -> HsExpr GhcRn -> HsExpr GhcRn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XSpliced GhcRn
-> ThModFinalizers -> HsSplicedThing GhcRn -> HsSplice GhcRn
forall id.
XSpliced id -> ThModFinalizers -> HsSplicedThing id -> HsSplice id
HsSpliced NoExtField
XSpliced GhcRn
noExtField ([ForeignRef (Q ())] -> ThModFinalizers
ThModFinalizers [ForeignRef (Q ())]
mod_finalizers)
                    (HsSplicedThing GhcRn -> HsSplice GhcRn)
-> (HsExpr GhcRn -> HsSplicedThing GhcRn)
-> HsExpr GhcRn
-> HsSplice GhcRn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HsExpr GhcRn -> HsSplicedThing GhcRn
forall id. HsExpr id -> HsSplicedThing id
HsSplicedExpr
                        (HsExpr GhcRn -> HsExpr GhcRn)
-> GenLocated SrcSpanAnnA (HsExpr GhcRn)
-> GenLocated SrcSpanAnnA (HsExpr GhcRn)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenLocated SrcSpanAnnA (HsExpr GhcRn)
lexpr3
           ; (HsExpr GhcRn, FreeVars) -> RnM (HsExpr GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (LHsExpr GhcRn -> HsExpr GhcRn
forall (id :: Pass). LHsExpr (GhcPass id) -> HsExpr (GhcPass id)
gHsPar LHsExpr GhcRn
GenLocated SrcSpanAnnA (HsExpr GhcRn)
e, FreeVars
fvs)
           }

{- Note [Running splices in the Renamer]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Splices used to be run in the typechecker, which led to (#4364). Since the
renamer must decide which expressions depend on which others, and it cannot
reliably do this for arbitrary splices, we used to conservatively say that
splices depend on all other expressions in scope. Unfortunately, this led to
the problem of cyclic type declarations seen in (#4364). Instead, by
running splices in the renamer, we side-step the problem of determining
dependencies: by the time the dependency analysis happens, any splices have
already been run, and expression dependencies can be determined as usual.

However, see (#9813), for an example where we would like to run splices
*after* performing dependency analysis (that is, after renaming). It would be
desirable to typecheck "non-splicy" expressions (those expressions that do not
contain splices directly or via dependence on an expression that does) before
"splicy" expressions, such that types/expressions within the same declaration
group would be available to `reify` calls, for example consider the following:

> module M where
>   data D = C
>   f = 1
>   g = $(mapM reify ['f, 'D, ''C] ...)

Compilation of this example fails since D/C/f are not in the type environment
and thus cannot be reified as they have not been typechecked by the time the
splice is renamed and thus run.

These requirements are at odds: we do not want to run splices in the renamer as
we wish to first determine dependencies and typecheck certain expressions,
making them available to reify, but cannot accurately determine dependencies
without running splices in the renamer!

Indeed, the conclusion of (#9813) was that it is not worth the complexity
to try and
 a) implement and maintain the code for renaming/typechecking non-splicy
    expressions before splicy expressions,
 b) explain to TH users which expressions are/not available to reify at any
    given point.

-}

{- Note [Rebindable syntax and Template Haskell]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When processing Template Haskell quotes with Rebindable Syntax (RS) enabled,
there are two possibilities: apply the RS rules to the quotes or don't.

One might expect that with {-# LANGUAGE RebindableSyntax #-} at the top of a
module, any 'if' expression would end up being turned into a call to whatever
'ifThenElse' function is in scope, regardless of whether the said if expression
appears in "normal" Haskell code or in a TH quote. This however comes with its
problems. Consider the following code:

  {-# LANGUAGE TemplateHaskell, RebindableSyntax #-}

  module X where

  import Prelude ( Monad(..), Bool(..), print, ($) )
  import Language.Haskell.TH.Syntax

  $( do stuff <- [| if True then 10 else 15 |]
        runIO $ print stuff
        return [] )

If we apply the RS rules, then GHC would complain about not having suitable
fromInteger/ifThenElse functions in scope. But this quote is just a bit of
Haskell syntax that has yet to be used, or, to put it differently, placed
(spliced) in some context where the said functions might be available. More
generally, untyped TH quotes are meant to work with yet-unbound identifiers.
This tends to show that untyped TH and Rebindable Syntax overall don't play
well together. Users still have the option to splice "normal" if expressions
into modules where RS is enabled, to turn them into applications of
an 'ifThenElse' function of their choice.

Typed TH (TTH) quotes, on the other hand, come with different constraints. They
don't quite have this "delayed" nature: we typecheck them while processing
them, and TTH users expect RS to Just Work in their quotes, exactly like it does
outside of the quotes. There, we do not have to accept unbound identifiers and
we can apply the RS rules both in the typechecking and desugaring of the quotes
without triggering surprising/bad behaviour for users. For instance, the
following code is expected to be rejected (because of the lack of suitable
'fromInteger'/'ifThenElse' functions in scope):

  {-# LANGUAGE TemplateHaskell, RebindableSyntax #-}

  module X where

  import Prelude ( Monad(..), Bool(..), print, ($) )
  import Language.Haskell.TH.Syntax

  $$( do stuff <- [|| if True then 10 else 15 ||]
         runIO $ print stuff
         return [] )

The conclusion is that even if RS is enabled for a given module, GHC disables it
when processing untyped TH quotes from that module, to avoid the aforementioned
problems, but keeps it on while processing typed TH quotes.

This note and approach originated in #18102.

-}

{- Note [Delaying modFinalizers in untyped splices]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

When splices run in the renamer, 'reify' does not have access to the local
type environment (#11832, [1]).

For instance, in

> let x = e in $(reify (mkName "x") >>= runIO . print >> [| return () |])

'reify' cannot find @x@, because the local type environment is not yet
populated. To address this, we allow 'reify' execution to be deferred with
'addModFinalizer'.

> let x = e in $(do addModFinalizer (reify (mkName "x") >>= runIO . print)
                    [| return () |]
                )

The finalizer is run with the local type environment when type checking is
complete.

Since the local type environment is not available in the renamer, we annotate
the tree at the splice point [2] with @HsSpliceE (HsSpliced finalizers e)@ where
@e@ is the result of splicing and @finalizers@ are the finalizers that have been
collected during evaluation of the splice [3]. In our example,

> HsLet
>   (x = e)
>   (HsSpliceE $ HsSpliced [reify (mkName "x") >>= runIO . print]
>                          (HsSplicedExpr $ return ())
>   )

When the typechecker finds the annotation, it inserts the finalizers in the
global environment and exposes the current local environment to them [4, 5, 6].

> addModFinalizersWithLclEnv [reify (mkName "x") >>= runIO . print]

References:

[1] https://gitlab.haskell.org/ghc/ghc/wikis/template-haskell/reify
[2] 'rnSpliceExpr'
[3] 'GHC.Tc.Gen.Splice.qAddModFinalizer'
[4] 'GHC.Tc.Gen.Expr.tcExpr' ('HsSpliceE' ('HsSpliced' ...))
[5] 'GHC.Tc.Gen.HsType.tc_hs_type' ('HsSpliceTy' ('HsSpliced' ...))
[6] 'GHC.Tc.Gen.Pat.tc_pat' ('SplicePat' ('HsSpliced' ...))

-}

----------------------
rnSpliceType :: HsSplice GhcPs -> RnM (HsType GhcRn, FreeVars)
rnSpliceType :: HsSplice GhcPs -> RnM (HsType GhcRn, FreeVars)
rnSpliceType HsSplice GhcPs
splice
  = (HsSplice GhcRn -> RnM (HsType GhcRn, FreeVars))
-> (HsSplice GhcRn -> (PendingRnSplice, HsType GhcRn))
-> HsSplice GhcPs
-> RnM (HsType GhcRn, FreeVars)
forall a.
(HsSplice GhcRn -> RnM (a, FreeVars))
-> (HsSplice GhcRn -> (PendingRnSplice, a))
-> HsSplice GhcPs
-> RnM (a, FreeVars)
rnSpliceGen HsSplice GhcRn -> RnM (HsType GhcRn, FreeVars)
run_type_splice HsSplice GhcRn -> (PendingRnSplice, HsType GhcRn)
pend_type_splice HsSplice GhcPs
splice
  where
    pend_type_splice :: HsSplice GhcRn -> (PendingRnSplice, HsType GhcRn)
pend_type_splice HsSplice GhcRn
rn_splice
       = ( UntypedSpliceFlavour -> HsSplice GhcRn -> PendingRnSplice
makePending UntypedSpliceFlavour
UntypedTypeSplice HsSplice GhcRn
rn_splice
         , XSpliceTy GhcRn -> HsSplice GhcRn -> HsType GhcRn
forall pass. XSpliceTy pass -> HsSplice pass -> HsType pass
HsSpliceTy NoExtField
XSpliceTy GhcRn
noExtField HsSplice GhcRn
rn_splice)

    run_type_splice :: HsSplice GhcRn -> RnM (HsType GhcRn, FreeVars)
run_type_splice HsSplice GhcRn
rn_splice
      = do { String -> SDoc -> RnM ()
traceRn String
"rnSpliceType: untyped type splice" SDoc
empty
           ; (GenLocated SrcSpanAnnA (HsType GhcPs)
hs_ty2, [ForeignRef (Q ())]
mod_finalizers) <-
                UntypedSpliceFlavour
-> (LHsExpr GhcTc -> TcRn (GenLocated SrcSpanAnnA (HsType GhcPs)))
-> (GenLocated SrcSpanAnnA (HsType GhcPs) -> SDoc)
-> HsSplice GhcRn
-> TcRn
     (GenLocated SrcSpanAnnA (HsType GhcPs), [ForeignRef (Q ())])
forall res.
UntypedSpliceFlavour
-> (LHsExpr GhcTc -> TcRn res)
-> (res -> SDoc)
-> HsSplice GhcRn
-> TcRn (res, [ForeignRef (Q ())])
runRnSplice UntypedSpliceFlavour
UntypedTypeSplice LHsExpr GhcTc -> TcM (LHsType GhcPs)
LHsExpr GhcTc -> TcRn (GenLocated SrcSpanAnnA (HsType GhcPs))
runMetaT GenLocated SrcSpanAnnA (HsType GhcPs) -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsSplice GhcRn
rn_splice
           ; (GenLocated SrcSpanAnnA (HsType GhcRn)
hs_ty3, FreeVars
fvs) <- do { let doc :: HsDocContext
doc = LHsType GhcPs -> HsDocContext
SpliceTypeCtx LHsType GhcPs
GenLocated SrcSpanAnnA (HsType GhcPs)
hs_ty2
                                 ; IOEnv
  (Env TcGblEnv TcLclEnv)
  (GenLocated SrcSpanAnnA (HsType GhcRn), FreeVars)
-> IOEnv
     (Env TcGblEnv TcLclEnv)
     (GenLocated SrcSpanAnnA (HsType GhcRn), FreeVars)
forall r. TcM r -> TcM r
checkNoErrs (IOEnv
   (Env TcGblEnv TcLclEnv)
   (GenLocated SrcSpanAnnA (HsType GhcRn), FreeVars)
 -> IOEnv
      (Env TcGblEnv TcLclEnv)
      (GenLocated SrcSpanAnnA (HsType GhcRn), FreeVars))
-> IOEnv
     (Env TcGblEnv TcLclEnv)
     (GenLocated SrcSpanAnnA (HsType GhcRn), FreeVars)
-> IOEnv
     (Env TcGblEnv TcLclEnv)
     (GenLocated SrcSpanAnnA (HsType GhcRn), FreeVars)
forall a b. (a -> b) -> a -> b
$ HsDocContext -> LHsType GhcPs -> RnM (LHsType GhcRn, FreeVars)
rnLHsType HsDocContext
doc LHsType GhcPs
GenLocated SrcSpanAnnA (HsType GhcPs)
hs_ty2 }
                                    -- checkNoErrs: see Note [Renamer errors]
             -- See Note [Delaying modFinalizers in untyped splices].
           ; (HsType GhcRn, FreeVars) -> RnM (HsType GhcRn, FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return ( XParTy GhcRn -> LHsType GhcRn -> HsType GhcRn
forall pass. XParTy pass -> LHsType pass -> HsType pass
HsParTy XParTy GhcRn
forall a. EpAnn a
noAnn
                              (LHsType GhcRn -> HsType GhcRn) -> LHsType GhcRn -> HsType GhcRn
forall a b. (a -> b) -> a -> b
$ XSpliceTy GhcRn -> HsSplice GhcRn -> HsType GhcRn
forall pass. XSpliceTy pass -> HsSplice pass -> HsType pass
HsSpliceTy NoExtField
XSpliceTy GhcRn
noExtField
                              (HsSplice GhcRn -> HsType GhcRn)
-> (HsType GhcRn -> HsSplice GhcRn) -> HsType GhcRn -> HsType GhcRn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XSpliced GhcRn
-> ThModFinalizers -> HsSplicedThing GhcRn -> HsSplice GhcRn
forall id.
XSpliced id -> ThModFinalizers -> HsSplicedThing id -> HsSplice id
HsSpliced NoExtField
XSpliced GhcRn
noExtField ([ForeignRef (Q ())] -> ThModFinalizers
ThModFinalizers [ForeignRef (Q ())]
mod_finalizers)
                              (HsSplicedThing GhcRn -> HsSplice GhcRn)
-> (HsType GhcRn -> HsSplicedThing GhcRn)
-> HsType GhcRn
-> HsSplice GhcRn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HsType GhcRn -> HsSplicedThing GhcRn
forall id. HsType id -> HsSplicedThing id
HsSplicedTy (HsType GhcRn -> HsType GhcRn)
-> GenLocated SrcSpanAnnA (HsType GhcRn)
-> GenLocated SrcSpanAnnA (HsType GhcRn)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                              GenLocated SrcSpanAnnA (HsType GhcRn)
hs_ty3
                    , FreeVars
fvs
                    ) }
              -- Wrap the result of the splice in parens so that we don't
              -- lose the outermost location set by runQuasiQuote (#7918)

{- Note [Partial Type Splices]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Partial Type Signatures are partially supported in TH type splices: only
anonymous wild cards are allowed.

  -- ToDo: SLPJ says: I don't understand all this

Normally, named wild cards are collected before renaming a (partial) type
signature. However, TH type splices are run during renaming, i.e. after the
initial traversal, leading to out of scope errors for named wild cards. We
can't just extend the initial traversal to collect the named wild cards in TH
type splices, as we'd need to expand them, which is supposed to happen only
once, during renaming.

Similarly, the extra-constraints wild card is handled right before renaming
too, and is therefore also not supported in a TH type splice. Another reason
to forbid extra-constraints wild cards in TH type splices is that a single
signature can contain many TH type splices, whereas it mustn't contain more
than one extra-constraints wild card. Enforcing would this be hard the way
things are currently organised.

Anonymous wild cards pose no problem, because they start out without names and
are given names during renaming. These names are collected right after
renaming. The names generated for anonymous wild cards in TH type splices will
thus be collected as well.

For more details about renaming wild cards, see GHC.Rename.HsType.rnHsSigWcType

Note that partial type signatures are fully supported in TH declaration
splices, e.g.:

     [d| foo :: _ => _
         foo x y = x == y |]

This is because in this case, the partial type signature can be treated as a
whole signature, instead of as an arbitrary type.

-}


----------------------
-- | Rename a splice pattern. See Note [rnSplicePat]
rnSplicePat :: HsSplice GhcPs -> RnM ( Either (Pat GhcPs) (Pat GhcRn)
                                       , FreeVars)
rnSplicePat :: HsSplice GhcPs -> RnM (Either (Pat GhcPs) (Pat GhcRn), FreeVars)
rnSplicePat HsSplice GhcPs
splice
  = (HsSplice GhcRn -> RnM (Either (Pat GhcPs) (Pat GhcRn), FreeVars))
-> (HsSplice GhcRn
    -> (PendingRnSplice, Either (Pat GhcPs) (Pat GhcRn)))
-> HsSplice GhcPs
-> RnM (Either (Pat GhcPs) (Pat GhcRn), FreeVars)
forall a.
(HsSplice GhcRn -> RnM (a, FreeVars))
-> (HsSplice GhcRn -> (PendingRnSplice, a))
-> HsSplice GhcPs
-> RnM (a, FreeVars)
rnSpliceGen HsSplice GhcRn -> RnM (Either (Pat GhcPs) (Pat GhcRn), FreeVars)
run_pat_splice HsSplice GhcRn -> (PendingRnSplice, Either (Pat GhcPs) (Pat GhcRn))
forall b. HsSplice GhcRn -> (PendingRnSplice, Either b (Pat GhcRn))
pend_pat_splice HsSplice GhcPs
splice
  where
    pend_pat_splice :: HsSplice GhcRn ->
                       (PendingRnSplice, Either b (Pat GhcRn))
    pend_pat_splice :: HsSplice GhcRn -> (PendingRnSplice, Either b (Pat GhcRn))
pend_pat_splice HsSplice GhcRn
rn_splice
      = (UntypedSpliceFlavour -> HsSplice GhcRn -> PendingRnSplice
makePending UntypedSpliceFlavour
UntypedPatSplice HsSplice GhcRn
rn_splice
        , Pat GhcRn -> Either b (Pat GhcRn)
forall a b. b -> Either a b
Right (XSplicePat GhcRn -> HsSplice GhcRn -> Pat GhcRn
forall p. XSplicePat p -> HsSplice p -> Pat p
SplicePat NoExtField
XSplicePat GhcRn
noExtField HsSplice GhcRn
rn_splice))

    run_pat_splice :: HsSplice GhcRn ->
                      RnM (Either (Pat GhcPs) (Pat GhcRn), FreeVars)
    run_pat_splice :: HsSplice GhcRn -> RnM (Either (Pat GhcPs) (Pat GhcRn), FreeVars)
run_pat_splice HsSplice GhcRn
rn_splice
      = do { String -> SDoc -> RnM ()
traceRn String
"rnSplicePat: untyped pattern splice" SDoc
empty
           ; (GenLocated SrcSpanAnnA (Pat GhcPs)
pat, [ForeignRef (Q ())]
mod_finalizers) <-
                UntypedSpliceFlavour
-> (LHsExpr GhcTc -> TcRn (GenLocated SrcSpanAnnA (Pat GhcPs)))
-> (GenLocated SrcSpanAnnA (Pat GhcPs) -> SDoc)
-> HsSplice GhcRn
-> TcRn (GenLocated SrcSpanAnnA (Pat GhcPs), [ForeignRef (Q ())])
forall res.
UntypedSpliceFlavour
-> (LHsExpr GhcTc -> TcRn res)
-> (res -> SDoc)
-> HsSplice GhcRn
-> TcRn (res, [ForeignRef (Q ())])
runRnSplice UntypedSpliceFlavour
UntypedPatSplice LHsExpr GhcTc -> TcM (LPat GhcPs)
LHsExpr GhcTc -> TcRn (GenLocated SrcSpanAnnA (Pat GhcPs))
runMetaP GenLocated SrcSpanAnnA (Pat GhcPs) -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsSplice GhcRn
rn_splice
             -- See Note [Delaying modFinalizers in untyped splices].
           ; let p :: GenLocated SrcSpanAnnA (Pat GhcPs)
p =  XSplicePat GhcPs -> HsSplice GhcPs -> Pat GhcPs
forall p. XSplicePat p -> HsSplice p -> Pat p
SplicePat NoExtField
XSplicePat GhcPs
noExtField
                    (HsSplice GhcPs -> Pat GhcPs)
-> (Pat GhcPs -> HsSplice GhcPs) -> Pat GhcPs -> Pat GhcPs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. XSpliced GhcPs
-> ThModFinalizers -> HsSplicedThing GhcPs -> HsSplice GhcPs
forall id.
XSpliced id -> ThModFinalizers -> HsSplicedThing id -> HsSplice id
HsSpliced NoExtField
XSpliced GhcPs
noExtField ([ForeignRef (Q ())] -> ThModFinalizers
ThModFinalizers [ForeignRef (Q ())]
mod_finalizers)
                    (HsSplicedThing GhcPs -> HsSplice GhcPs)
-> (Pat GhcPs -> HsSplicedThing GhcPs)
-> Pat GhcPs
-> HsSplice GhcPs
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pat GhcPs -> HsSplicedThing GhcPs
forall id. Pat id -> HsSplicedThing id
HsSplicedPat
                        (Pat GhcPs -> Pat GhcPs)
-> GenLocated SrcSpanAnnA (Pat GhcPs)
-> GenLocated SrcSpanAnnA (Pat GhcPs)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> GenLocated SrcSpanAnnA (Pat GhcPs)
pat
           ; (Either (Pat GhcPs) (Pat GhcRn), FreeVars)
-> RnM (Either (Pat GhcPs) (Pat GhcRn), FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return (Pat GhcPs -> Either (Pat GhcPs) (Pat GhcRn)
forall a b. a -> Either a b
Left (Pat GhcPs -> Either (Pat GhcPs) (Pat GhcRn))
-> Pat GhcPs -> Either (Pat GhcPs) (Pat GhcRn)
forall a b. (a -> b) -> a -> b
$ LPat GhcPs -> Pat GhcPs
forall (pass :: Pass). LPat (GhcPass pass) -> Pat (GhcPass pass)
gParPat LPat GhcPs
GenLocated SrcSpanAnnA (Pat GhcPs)
p, FreeVars
emptyFVs) }
              -- Wrap the result of the quasi-quoter in parens so that we don't
              -- lose the outermost location set by runQuasiQuote (#7918)

----------------------
rnSpliceDecl :: SpliceDecl GhcPs -> RnM (SpliceDecl GhcRn, FreeVars)
rnSpliceDecl :: SpliceDecl GhcPs -> RnM (SpliceDecl GhcRn, FreeVars)
rnSpliceDecl (SpliceDecl XSpliceDecl GhcPs
_ (L loc splice) SpliceExplicitFlag
flg)
  = (HsSplice GhcRn -> RnM (SpliceDecl GhcRn, FreeVars))
-> (HsSplice GhcRn -> (PendingRnSplice, SpliceDecl GhcRn))
-> HsSplice GhcPs
-> RnM (SpliceDecl GhcRn, FreeVars)
forall a.
(HsSplice GhcRn -> RnM (a, FreeVars))
-> (HsSplice GhcRn -> (PendingRnSplice, a))
-> HsSplice GhcPs
-> RnM (a, FreeVars)
rnSpliceGen HsSplice GhcRn -> RnM (SpliceDecl GhcRn, FreeVars)
forall a a. Outputable a => a -> a
run_decl_splice HsSplice GhcRn -> (PendingRnSplice, SpliceDecl GhcRn)
pend_decl_splice HsSplice GhcPs
splice
  where
    pend_decl_splice :: HsSplice GhcRn -> (PendingRnSplice, SpliceDecl GhcRn)
pend_decl_splice HsSplice GhcRn
rn_splice
       = ( UntypedSpliceFlavour -> HsSplice GhcRn -> PendingRnSplice
makePending UntypedSpliceFlavour
UntypedDeclSplice HsSplice GhcRn
rn_splice
         , XSpliceDecl GhcRn
-> XRec GhcRn (HsSplice GhcRn)
-> SpliceExplicitFlag
-> SpliceDecl GhcRn
forall p.
XSpliceDecl p
-> XRec p (HsSplice p) -> SpliceExplicitFlag -> SpliceDecl p
SpliceDecl NoExtField
XSpliceDecl GhcRn
noExtField (SrcSpanAnnA
-> HsSplice GhcRn -> GenLocated SrcSpanAnnA (HsSplice GhcRn)
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
loc HsSplice GhcRn
rn_splice) SpliceExplicitFlag
flg)

    run_decl_splice :: a -> a
run_decl_splice a
rn_splice  = String -> SDoc -> a
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"rnSpliceDecl" (a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
rn_splice)

rnTopSpliceDecls :: HsSplice GhcPs -> RnM ([LHsDecl GhcPs], FreeVars)
-- Declaration splice at the very top level of the module
rnTopSpliceDecls :: HsSplice GhcPs -> RnM ([LHsDecl GhcPs], FreeVars)
rnTopSpliceDecls HsSplice GhcPs
splice
   =  do { HsSplice GhcPs -> RnM ()
checkTopSpliceAllowed HsSplice GhcPs
splice
         ; (HsSplice GhcRn
rn_splice, FreeVars
fvs) <- TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars)
forall r. TcM r -> TcM r
checkNoErrs (TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars))
-> TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$
                               ThStage
-> TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars)
forall a. ThStage -> TcM a -> TcM a
setStage (SpliceType -> ThStage
Splice SpliceType
Untyped) (TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars))
-> TcM (HsSplice GhcRn, FreeVars) -> TcM (HsSplice GhcRn, FreeVars)
forall a b. (a -> b) -> a -> b
$
                               HsSplice GhcPs -> TcM (HsSplice GhcRn, FreeVars)
rnSplice HsSplice GhcPs
splice
           -- As always, be sure to checkNoErrs above lest we end up with
           -- holes making it to typechecking, hence #12584.
           --
           -- Note that we cannot call checkNoErrs for the whole duration
           -- of rnTopSpliceDecls. The reason is that checkNoErrs changes
           -- the local environment to temporarily contain a new
           -- reference to store errors, and add_mod_finalizers would
           -- cause this reference to be stored after checkNoErrs finishes.
           -- This is checked by test TH_finalizer.
         ; String -> SDoc -> RnM ()
traceRn String
"rnTopSpliceDecls: untyped declaration splice" SDoc
empty
         ; ([GenLocated SrcSpanAnnA (HsDecl GhcPs)]
decls, [ForeignRef (Q ())]
mod_finalizers) <- TcM ([GenLocated SrcSpanAnnA (HsDecl GhcPs)], [ForeignRef (Q ())])
-> TcM
     ([GenLocated SrcSpanAnnA (HsDecl GhcPs)], [ForeignRef (Q ())])
forall r. TcM r -> TcM r
checkNoErrs (TcM ([GenLocated SrcSpanAnnA (HsDecl GhcPs)], [ForeignRef (Q ())])
 -> TcM
      ([GenLocated SrcSpanAnnA (HsDecl GhcPs)], [ForeignRef (Q ())]))
-> TcM
     ([GenLocated SrcSpanAnnA (HsDecl GhcPs)], [ForeignRef (Q ())])
-> TcM
     ([GenLocated SrcSpanAnnA (HsDecl GhcPs)], [ForeignRef (Q ())])
forall a b. (a -> b) -> a -> b
$
               UntypedSpliceFlavour
-> (LHsExpr GhcTc -> TcRn [GenLocated SrcSpanAnnA (HsDecl GhcPs)])
-> ([GenLocated SrcSpanAnnA (HsDecl GhcPs)] -> SDoc)
-> HsSplice GhcRn
-> TcM
     ([GenLocated SrcSpanAnnA (HsDecl GhcPs)], [ForeignRef (Q ())])
forall res.
UntypedSpliceFlavour
-> (LHsExpr GhcTc -> TcRn res)
-> (res -> SDoc)
-> HsSplice GhcRn
-> TcRn (res, [ForeignRef (Q ())])
runRnSplice UntypedSpliceFlavour
UntypedDeclSplice LHsExpr GhcTc -> TcM [LHsDecl GhcPs]
LHsExpr GhcTc -> TcRn [GenLocated SrcSpanAnnA (HsDecl GhcPs)]
runMetaD [LHsDecl GhcPs] -> SDoc
[GenLocated SrcSpanAnnA (HsDecl GhcPs)] -> SDoc
ppr_decls HsSplice GhcRn
rn_splice
         ; [ForeignRef (Q ())] -> RnM ()
add_mod_finalizers_now [ForeignRef (Q ())]
mod_finalizers
         ; ([GenLocated SrcSpanAnnA (HsDecl GhcPs)], FreeVars)
-> IOEnv
     (Env TcGblEnv TcLclEnv)
     ([GenLocated SrcSpanAnnA (HsDecl GhcPs)], FreeVars)
forall (m :: * -> *) a. Monad m => a -> m a
return ([GenLocated SrcSpanAnnA (HsDecl GhcPs)]
decls,FreeVars
fvs) }
   where
     ppr_decls :: [LHsDecl GhcPs] -> SDoc
     ppr_decls :: [LHsDecl GhcPs] -> SDoc
ppr_decls [LHsDecl GhcPs]
ds = [SDoc] -> SDoc
vcat ((GenLocated SrcSpanAnnA (HsDecl GhcPs) -> SDoc)
-> [GenLocated SrcSpanAnnA (HsDecl GhcPs)] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map GenLocated SrcSpanAnnA (HsDecl GhcPs) -> SDoc
forall a. Outputable a => a -> SDoc
ppr [LHsDecl GhcPs]
[GenLocated SrcSpanAnnA (HsDecl GhcPs)]
ds)

     -- Adds finalizers to the global environment instead of delaying them
     -- to the type checker.
     --
     -- Declaration splices do not have an interesting local environment so
     -- there is no point in delaying them.
     --
     -- See Note [Delaying modFinalizers in untyped splices].
     add_mod_finalizers_now :: [ForeignRef (TH.Q ())] -> TcRn ()
     add_mod_finalizers_now :: [ForeignRef (Q ())] -> RnM ()
add_mod_finalizers_now []             = () -> RnM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     add_mod_finalizers_now [ForeignRef (Q ())]
mod_finalizers = do
       TcRef [(TcLclEnv, ThModFinalizers)]
th_modfinalizers_var <- (TcGblEnv -> TcRef [(TcLclEnv, ThModFinalizers)])
-> TcRnIf TcGblEnv TcLclEnv TcGblEnv
-> IOEnv
     (Env TcGblEnv TcLclEnv) (TcRef [(TcLclEnv, ThModFinalizers)])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TcGblEnv -> TcRef [(TcLclEnv, ThModFinalizers)]
tcg_th_modfinalizers TcRnIf TcGblEnv TcLclEnv TcGblEnv
forall gbl lcl. TcRnIf gbl lcl gbl
getGblEnv
       TcLclEnv
env <- TcRnIf TcGblEnv TcLclEnv TcLclEnv
forall gbl lcl. TcRnIf gbl lcl lcl
getLclEnv
       TcRef [(TcLclEnv, ThModFinalizers)]
-> ([(TcLclEnv, ThModFinalizers)] -> [(TcLclEnv, ThModFinalizers)])
-> RnM ()
forall a gbl lcl. TcRef a -> (a -> a) -> TcRnIf gbl lcl ()
updTcRef TcRef [(TcLclEnv, ThModFinalizers)]
th_modfinalizers_var (([(TcLclEnv, ThModFinalizers)] -> [(TcLclEnv, ThModFinalizers)])
 -> RnM ())
-> ([(TcLclEnv, ThModFinalizers)] -> [(TcLclEnv, ThModFinalizers)])
-> RnM ()
forall a b. (a -> b) -> a -> b
$ \[(TcLclEnv, ThModFinalizers)]
fins ->
         (TcLclEnv
env, [ForeignRef (Q ())] -> ThModFinalizers
ThModFinalizers [ForeignRef (Q ())]
mod_finalizers) (TcLclEnv, ThModFinalizers)
-> [(TcLclEnv, ThModFinalizers)] -> [(TcLclEnv, ThModFinalizers)]
forall a. a -> [a] -> [a]
: [(TcLclEnv, ThModFinalizers)]
fins


{-
Note [rnSplicePat]
~~~~~~~~~~~~~~~~~~
Renaming a pattern splice is a bit tricky, because we need the variables
bound in the pattern to be in scope in the RHS of the pattern. This scope
management is effectively done by using continuation-passing style in
GHC.Rename.Pat, through the CpsRn monad. We don't wish to be in that monad here
(it would create import cycles and generally conflict with renaming other
splices), so we really want to return a (Pat RdrName) -- the result of
running the splice -- which can then be further renamed in GHC.Rename.Pat, in
the CpsRn monad.

The problem is that if we're renaming a splice within a bracket, we
*don't* want to run the splice now. We really do just want to rename
it to an HsSplice Name. Of course, then we can't know what variables
are bound within the splice. So we accept any unbound variables and
rename them again when the bracket is spliced in.  If a variable is brought
into scope by a pattern splice all is fine.  If it is not then an error is
reported.

In any case, when we're done in rnSplicePat, we'll either have a
Pat RdrName (the result of running a top-level splice) or a Pat Name
(the renamed nested splice). Thus, the awkward return type of
rnSplicePat.
-}

spliceCtxt :: HsSplice GhcPs -> SDoc
spliceCtxt :: HsSplice GhcPs -> SDoc
spliceCtxt HsSplice GhcPs
splice
  = SDoc -> ThLevel -> SDoc -> SDoc
hang (String -> SDoc
text String
"In the" SDoc -> SDoc -> SDoc
<+> SDoc
what) ThLevel
2 (HsSplice GhcPs -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsSplice GhcPs
splice)
  where
    what :: SDoc
what = case HsSplice GhcPs
splice of
             HsUntypedSplice {} -> String -> SDoc
text String
"untyped splice:"
             HsTypedSplice   {} -> String -> SDoc
text String
"typed splice:"
             HsQuasiQuote    {} -> String -> SDoc
text String
"quasi-quotation:"
             HsSpliced       {} -> String -> SDoc
text String
"spliced expression:"

-- | The splice data to be logged
data SpliceInfo
  = SpliceInfo
    { SpliceInfo -> String
spliceDescription  :: String
    , SpliceInfo -> Maybe (LHsExpr GhcRn)
spliceSource       :: Maybe (LHsExpr GhcRn) -- Nothing <=> top-level decls
                                                  --        added by addTopDecls
    , SpliceInfo -> Bool
spliceIsDecl       :: Bool    -- True <=> put the generate code in a file
                                    --          when -dth-dec-file is on
    , SpliceInfo -> SDoc
spliceGenerated    :: SDoc
    }
        -- Note that 'spliceSource' is *renamed* but not *typechecked*
        -- Reason (a) less typechecking crap
        --        (b) data constructors after type checking have been
        --            changed to their *wrappers*, and that makes them
        --            print always fully qualified

-- | outputs splice information for 2 flags which have different output formats:
-- `-ddump-splices` and `-dth-dec-file`
traceSplice :: SpliceInfo -> TcM ()
traceSplice :: SpliceInfo -> RnM ()
traceSplice (SpliceInfo { spliceDescription :: SpliceInfo -> String
spliceDescription = String
sd, spliceSource :: SpliceInfo -> Maybe (LHsExpr GhcRn)
spliceSource = Maybe (LHsExpr GhcRn)
mb_src
                        , spliceGenerated :: SpliceInfo -> SDoc
spliceGenerated = SDoc
gen, spliceIsDecl :: SpliceInfo -> Bool
spliceIsDecl = Bool
is_decl })
  = do SrcSpan
loc <- case Maybe (LHsExpr GhcRn)
mb_src of
                 Maybe (LHsExpr GhcRn)
Nothing        -> TcRn SrcSpan
getSrcSpanM
                 Just (L loc _) -> SrcSpan -> TcRn SrcSpan
forall (m :: * -> *) a. Monad m => a -> m a
return (SrcSpanAnnA -> SrcSpan
forall a. SrcSpanAnn' a -> SrcSpan
locA SrcSpanAnnA
loc)
       DumpFlag -> SDoc -> RnM ()
traceOptTcRn DumpFlag
Opt_D_dump_splices (SrcSpan -> SDoc
spliceDebugDoc SrcSpan
loc)

       Bool -> RnM () -> RnM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
is_decl (RnM () -> RnM ()) -> RnM () -> RnM ()
forall a b. (a -> b) -> a -> b
$ do -- Raw material for -dth-dec-file
        Logger
logger <- IOEnv (Env TcGblEnv TcLclEnv) Logger
forall (m :: * -> *). HasLogger m => m Logger
getLogger
        IO () -> RnM ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> RnM ()) -> IO () -> RnM ()
forall a b. (a -> b) -> a -> b
$ Logger -> DumpFlag -> String -> DumpFormat -> SDoc -> IO ()
putDumpFileMaybe Logger
logger DumpFlag
Opt_D_th_dec_file String
"" DumpFormat
FormatHaskell (SrcSpan -> SDoc
spliceCodeDoc SrcSpan
loc)
  where
    -- `-ddump-splices`
    spliceDebugDoc :: SrcSpan -> SDoc
    spliceDebugDoc :: SrcSpan -> SDoc
spliceDebugDoc SrcSpan
loc
      = let code :: [SDoc]
code = case Maybe (LHsExpr GhcRn)
mb_src of
                     Maybe (LHsExpr GhcRn)
Nothing -> [SDoc]
ending
                     Just LHsExpr GhcRn
e  -> ThLevel -> SDoc -> SDoc
nest ThLevel
2 (GenLocated SrcSpanAnnA (HsExpr GhcRn) -> SDoc
forall a. Outputable a => a -> SDoc
ppr (LHsExpr GhcRn -> LHsExpr GhcRn
forall (p :: Pass). LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)
stripParensLHsExpr LHsExpr GhcRn
e)) SDoc -> [SDoc] -> [SDoc]
forall a. a -> [a] -> [a]
: [SDoc]
ending
            ending :: [SDoc]
ending = [ String -> SDoc
text String
"======>", ThLevel -> SDoc -> SDoc
nest ThLevel
2 SDoc
gen ]
        in  SDoc -> ThLevel -> SDoc -> SDoc
hang (SrcSpan -> SDoc
forall a. Outputable a => a -> SDoc
ppr SrcSpan
loc SDoc -> SDoc -> SDoc
<> SDoc
colon SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
"Splicing" SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
sd)
               ThLevel
2 ([SDoc] -> SDoc
sep [SDoc]
code)

    -- `-dth-dec-file`
    spliceCodeDoc :: SrcSpan -> SDoc
    spliceCodeDoc :: SrcSpan -> SDoc
spliceCodeDoc SrcSpan
loc
      = [SDoc] -> SDoc
vcat [ String -> SDoc
text String
"--" SDoc -> SDoc -> SDoc
<+> SrcSpan -> SDoc
forall a. Outputable a => a -> SDoc
ppr SrcSpan
loc SDoc -> SDoc -> SDoc
<> SDoc
colon SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
"Splicing" SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
sd
             , SDoc
gen ]

illegalTypedSplice :: TcRnMessage
illegalTypedSplice :: TcRnMessage
illegalTypedSplice = DiagnosticMessage -> TcRnMessage
forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
-> DiagnosticMessage -> TcRnMessage
forall a b. (a -> b) -> a -> b
$ [GhcHint] -> SDoc -> DiagnosticMessage
mkPlainError [GhcHint]
noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
forall a b. (a -> b) -> a -> b
$
  String -> SDoc
text String
"Typed splices may not appear in untyped brackets"

illegalUntypedSplice :: TcRnMessage
illegalUntypedSplice :: TcRnMessage
illegalUntypedSplice = DiagnosticMessage -> TcRnMessage
forall a. (Diagnostic a, Typeable a) => a -> TcRnMessage
TcRnUnknownMessage (DiagnosticMessage -> TcRnMessage)
-> DiagnosticMessage -> TcRnMessage
forall a b. (a -> b) -> a -> b
$ [GhcHint] -> SDoc -> DiagnosticMessage
mkPlainError [GhcHint]
noHints (SDoc -> DiagnosticMessage) -> SDoc -> DiagnosticMessage
forall a b. (a -> b) -> a -> b
$
  String -> SDoc
text String
"Untyped splices may not appear in typed brackets"

checkThLocalName :: Name -> RnM ()
checkThLocalName :: Name -> RnM ()
checkThLocalName Name
name
  | Name -> Bool
isUnboundName Name
name   -- Do not report two errors for
  = () -> RnM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()            --   $(not_in_scope args)

  | Bool
otherwise
  = do  { String -> SDoc -> RnM ()
traceRn String
"checkThLocalName" (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name)
        ; Maybe (TopLevelFlag, ThLevel, ThStage)
mb_local_use <- Name -> TcRn (Maybe (TopLevelFlag, ThLevel, ThStage))
getStageAndBindLevel Name
name
        ; case Maybe (TopLevelFlag, ThLevel, ThStage)
mb_local_use of {
             Maybe (TopLevelFlag, ThLevel, ThStage)
Nothing -> () -> RnM ()
forall (m :: * -> *) a. Monad m => a -> m a
return () ;  -- Not a locally-bound thing
             Just (TopLevelFlag
top_lvl, ThLevel
bind_lvl, ThStage
use_stage) ->
    do  { let use_lvl :: ThLevel
use_lvl = ThStage -> ThLevel
thLevel ThStage
use_stage
        ; SDoc -> ThLevel -> ThLevel -> RnM ()
checkWellStaged (SDoc -> SDoc
quotes (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name)) ThLevel
bind_lvl ThLevel
use_lvl
        ; String -> SDoc -> RnM ()
traceRn String
"checkThLocalName" (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name SDoc -> SDoc -> SDoc
<+> ThLevel -> SDoc
forall a. Outputable a => a -> SDoc
ppr ThLevel
bind_lvl
                                               SDoc -> SDoc -> SDoc
<+> ThStage -> SDoc
forall a. Outputable a => a -> SDoc
ppr ThStage
use_stage
                                               SDoc -> SDoc -> SDoc
<+> ThLevel -> SDoc
forall a. Outputable a => a -> SDoc
ppr ThLevel
use_lvl)
        ; TopLevelFlag -> ThLevel -> ThStage -> ThLevel -> Name -> RnM ()
checkCrossStageLifting TopLevelFlag
top_lvl ThLevel
bind_lvl ThStage
use_stage ThLevel
use_lvl Name
name } } }

--------------------------------------
checkCrossStageLifting :: TopLevelFlag -> ThLevel -> ThStage -> ThLevel
                       -> Name -> TcM ()
-- We are inside brackets, and (use_lvl > bind_lvl)
-- Now we must check whether there's a cross-stage lift to do
-- Examples   \x -> [| x |]
--            [| map |]
--
-- This code is similar to checkCrossStageLifting in GHC.Tc.Gen.Expr, but
-- this is only run on *untyped* brackets.

checkCrossStageLifting :: TopLevelFlag -> ThLevel -> ThStage -> ThLevel -> Name -> RnM ()
checkCrossStageLifting TopLevelFlag
top_lvl ThLevel
bind_lvl ThStage
use_stage ThLevel
use_lvl Name
name
  | Brack ThStage
_ (RnPendingUntyped IORef [PendingRnSplice]
ps_var) <- ThStage
use_stage   -- Only for untyped brackets
  , ThLevel
use_lvl ThLevel -> ThLevel -> Bool
forall a. Ord a => a -> a -> Bool
> ThLevel
bind_lvl                               -- Cross-stage condition
  = TopLevelFlag -> Name -> IORef [PendingRnSplice] -> RnM ()
check_cross_stage_lifting TopLevelFlag
top_lvl Name
name IORef [PendingRnSplice]
ps_var
  | Bool
otherwise
  = () -> RnM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

check_cross_stage_lifting :: TopLevelFlag -> Name -> TcRef [PendingRnSplice] -> TcM ()
check_cross_stage_lifting :: TopLevelFlag -> Name -> IORef [PendingRnSplice] -> RnM ()
check_cross_stage_lifting TopLevelFlag
top_lvl Name
name IORef [PendingRnSplice]
ps_var
  | TopLevelFlag -> Bool
isTopLevel TopLevelFlag
top_lvl
        -- Top-level identifiers in this module,
        -- (which have External Names)
        -- are just like the imported case:
        -- no need for the 'lifting' treatment
        -- E.g.  this is fine:
        --   f x = x
        --   g y = [| f 3 |]
  = Bool -> RnM () -> RnM ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Name -> Bool
isExternalName Name
name) (Name -> RnM ()
keepAlive Name
name)
    -- See Note [Keeping things alive for Template Haskell]

  | Bool
otherwise
  =     -- Nested identifiers, such as 'x' in
        -- E.g. \x -> [| h x |]
        -- We must behave as if the reference to x was
        --      h $(lift x)
        -- We use 'x' itself as the SplicePointName, used by
        -- the desugarer to stitch it all back together.
        -- If 'x' occurs many times we may get many identical
        -- bindings of the same SplicePointName, but that doesn't
        -- matter, although it's a mite untidy.
    do  { String -> SDoc -> RnM ()
traceRn String
"checkCrossStageLifting" (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name)

          -- Construct the (lift x) expression
        ; let lift_expr :: LHsExpr GhcRn
lift_expr   = LHsExpr GhcRn -> LHsExpr GhcRn -> LHsExpr GhcRn
forall (id :: Pass).
IsPass id =>
LHsExpr (GhcPass id)
-> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)
nlHsApp (IdP GhcRn -> LHsExpr GhcRn
forall (p :: Pass) a.
IsSrcSpanAnn p a =>
IdP (GhcPass p) -> LHsExpr (GhcPass p)
nlHsVar IdP GhcRn
Name
liftName) (IdP GhcRn -> LHsExpr GhcRn
forall (p :: Pass) a.
IsSrcSpanAnn p a =>
IdP (GhcPass p) -> LHsExpr (GhcPass p)
nlHsVar IdP GhcRn
Name
name)
              pend_splice :: PendingRnSplice
pend_splice = UntypedSpliceFlavour -> Name -> LHsExpr GhcRn -> PendingRnSplice
PendingRnSplice UntypedSpliceFlavour
UntypedExpSplice Name
name LHsExpr GhcRn
lift_expr

          -- Warning for implicit lift (#17804)
        ; (ErrInfo -> TcRnMessage) -> RnM ()
addDetailedDiagnostic (Name -> ErrInfo -> TcRnMessage
forall var. Outputable var => var -> ErrInfo -> TcRnMessage
TcRnImplicitLift Name
name)

          -- Update the pending splices
        ; [PendingRnSplice]
ps <- IORef [PendingRnSplice]
-> IOEnv (Env TcGblEnv TcLclEnv) [PendingRnSplice]
forall a env. IORef a -> IOEnv env a
readMutVar IORef [PendingRnSplice]
ps_var
        ; IORef [PendingRnSplice] -> [PendingRnSplice] -> RnM ()
forall a env. IORef a -> a -> IOEnv env ()
writeMutVar IORef [PendingRnSplice]
ps_var (PendingRnSplice
pend_splice PendingRnSplice -> [PendingRnSplice] -> [PendingRnSplice]
forall a. a -> [a] -> [a]
: [PendingRnSplice]
ps) }

{-
Note [Keeping things alive for Template Haskell]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
  f x = x+1
  g y = [| f 3 |]

Here 'f' is referred to from inside the bracket, which turns into data
and mentions only f's *name*, not 'f' itself. So we need some other
way to keep 'f' alive, lest it get dropped as dead code.  That's what
keepAlive does. It puts it in the keep-alive set, which subsequently
ensures that 'f' stays as a top level binding.

This must be done by the renamer, not the type checker (as of old),
because the type checker doesn't typecheck the body of untyped
brackets (#8540).

A thing can have a bind_lvl of outerLevel, but have an internal name:
   foo = [d| op = 3
             bop = op + 1 |]
Here the bind_lvl of 'op' is (bogusly) outerLevel, even though it is
bound inside a bracket.  That is because we don't even record
binding levels for top-level things; the binding levels are in the
LocalRdrEnv.

So the occurrence of 'op' in the rhs of 'bop' looks a bit like a
cross-stage thing, but it isn't really.  And in fact we never need
to do anything here for top-level bound things, so all is fine, if
a bit hacky.

For these chaps (which have Internal Names) we don't want to put
them in the keep-alive set.

Note [Quoting names]
~~~~~~~~~~~~~~~~~~~~
A quoted name 'n is a bit like a quoted expression [| n |], except that we
have no cross-stage lifting (c.f. GHC.Tc.Gen.Expr.thBrackId).  So, after incrementing
the use-level to account for the brackets, the cases are:

        bind > use                      Error
        bind = use+1                    OK
        bind < use
                Imported things         OK
                Top-level things        OK
                Non-top-level           Error

where 'use' is the binding level of the 'n quote. (So inside the implied
bracket the level would be use+1.)

Examples:

  f 'map        -- OK; also for top-level defns of this module

  \x. f 'x      -- Not ok (bind = 1, use = 1)
                -- (whereas \x. f [| x |] might have been ok, by
                --                               cross-stage lifting

  \y. [| \x. $(f 'y) |] -- Not ok (bind =1, use = 1)

  [| \x. $(f 'x) |]     -- OK (bind = 2, use = 1)
-}