ghc/compiler/typecheck/TcSplice.lhs

   1 2%
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section[TcSplice]{Template Haskell splices}
   5
   6 \begin{code}
   7 module TcSplice( tcSpliceExpr, tcSpliceDecls, tcBracket ) where
   8
   9 #include "HsVersions.h"
  10
  11 import HscMain          ( compileExpr )
  12 import TcRnDriver       ( importSupportingDecls, tcTopSrcDecls )
  13         -- These imports are the reason that TcSplice
  14         -- is very high up the module hierarchy
  15
  16 import qualified Language.Haskell.THSyntax as Meta
  17
  18 import HscTypes         ( HscEnv(..), GhciMode(..), PersistentCompilerState(..), unQualInScope )
  19 import HsSyn            ( HsBracket(..) )
  20 import Convert          ( convertToHsExpr, convertToHsDecls )
  21 import RnExpr           ( rnExpr )
  22 import RdrHsSyn         ( RdrNameHsExpr, RdrNameHsDecl )
  23 import RnHsSyn          ( RenamedHsExpr )
  24 import TcExpr           ( tcMonoExpr )
  25 import TcHsSyn          ( TcExpr, TypecheckedHsExpr, mkHsLet, zonkTopExpr )
  26 import TcSimplify       ( tcSimplifyTop )
  27 import TcType           ( TcType, openTypeKind, mkAppTy )
  28 import TcEnv            ( spliceOK, tcMetaTy )
  29 import TcRnTypes        ( TopEnv(..) )
  30 import TcMType          ( newTyVarTy, zapToType )
  31 import Name             ( Name )
  32 import TcRnMonad
  33
  34 import TysWiredIn       ( mkListTy )
  35 import DsMeta           ( exprTyConName, declTyConName, decTyConName, qTyConName )
  36 import ErrUtils (Message)
  37 import Outputable
  38 import GHC.Base         ( unsafeCoerce# )       -- Should have a better home in the module hierarchy
  39 import Monad (liftM)
  40 \end{code}
  41
  42
  43 %************************************************************************
  44 %*                                                                      *
  45 \subsection{Main interface + stubs for the non-GHCI case
  46 %*                                                                      *
  47 %************************************************************************
  48
  49 \begin{code}
  50 tcSpliceDecls :: RenamedHsExpr -> TcM [RdrNameHsDecl]
  51
  52 tcSpliceExpr :: Name
  53              -> RenamedHsExpr
  54              -> TcType
  55              -> TcM TcExpr
  56
  57 #ifndef GHCI
  58 tcSpliceExpr n e ty = pprPanic "Cant do tcSpliceExpr without GHCi" (ppr e)
  59 tcSpliceDecls e     = pprPanic "Cant do tcSpliceDecls without GHCi" (ppr e)
  60 #else
  61 \end{code}
  62
  63 %************************************************************************
  64 %*                                                                      *
  65 \subsection{Splicing an expression}
  66 %*                                                                      *
  67 %************************************************************************
  68
  69 \begin{code}
  70 tcBracket :: HsBracket Name -> TcM TcType
  71 tcBracket (ExpBr expr)
  72   = newTyVarTy openTypeKind             `thenM` \ any_ty ->
  73     tcMonoExpr expr any_ty              `thenM_`
  74     tcMetaTy exprTyConName
  75         -- Result type is Expr (= Q Exp)
  76
  77 tcBracket (DecBr decls)
  78   = tcTopSrcDecls decls                 `thenM_`
  79     tcMetaTy decTyConName               `thenM` \ decl_ty ->
  80     tcMetaTy qTyConName                 `thenM` \ q_ty ->
  81     returnM (mkAppTy q_ty (mkListTy decl_ty))
  82         -- Result type is Q [Dec]
  83 \end{code}
  84
  85
  86 %************************************************************************
  87 %*                                                                      *
  88 \subsection{Splicing an expression}
  89 %*                                                                      *
  90 %************************************************************************
  91
  92 \begin{code}
  93 tcSpliceExpr name expr res_ty
  94   = getStage            `thenM` \ level ->
  95     case spliceOK level of {
  96         Nothing         -> failWithTc (illegalSplice level) ;
  97         Just next_level ->
  98
  99     case level of {
 100         Comp                   -> tcTopSplice expr res_ty ;
 101         Brack _ ps_var lie_var ->
 102
 103         -- A splice inside brackets
 104         -- NB: ignore res_ty, apart from zapping it to a mono-type
 105         -- e.g.   [| reverse $(h 4) |]
 106         -- Here (h 4) :: Q Exp
 107         -- but $(h 4) :: forall a.a     i.e. anything!
 108
 109     zapToType res_ty                            `thenM_`
 110     tcMetaTy exprTyConName                      `thenM` \ meta_exp_ty ->
 111     setStage (Splice next_level) (
 112         setLIEVar lie_var          $
 113         tcMonoExpr expr meta_exp_ty
 114     )                                           `thenM` \ expr' ->
 115
 116         -- Write the pending splice into the bucket
 117     readMutVar ps_var                           `thenM` \ ps ->
 118     writeMutVar ps_var ((name,expr') : ps)      `thenM_`
 119
 120     returnM (panic "tcSpliceExpr")      -- The returned expression is ignored
 121     }}
 122
 123 -- tcTopSplice used to have this:
 124 -- Note that we do not decrement the level (to -1) before
 125 -- typechecking the expression.  For example:
 126 --      f x = $( ...$(g 3) ... )
 127 -- The recursive call to tcMonoExpr will simply expand the
 128 -- inner escape before dealing with the outer one
 129
 130 tcTopSplice expr res_ty
 131   = tcMetaTy exprTyConName              `thenM` \ meta_exp_ty ->
 132     setStage topSpliceStage (
 133         getLIE (tcMonoExpr expr meta_exp_ty)
 134     )                                   `thenM` \ (expr', lie) ->
 135
 136         -- Solve the constraints
 137     tcSimplifyTop lie                   `thenM` \ const_binds ->
 138     let
 139         q_expr = mkHsLet const_binds expr'
 140     in
 141     zonkTopExpr q_expr                  `thenM` \ zonked_q_expr ->
 142
 143         -- Run the expression
 144     traceTc (text "About to run" <+> ppr zonked_q_expr)         `thenM_`
 145     runMetaE zonked_q_expr              `thenM` \ simple_expr ->
 146
 147     let
 148         -- simple_expr :: Meta.Exp
 149
 150         expr2 :: RdrNameHsExpr
 151         expr2 = convertToHsExpr simple_expr
 152     in
 153     traceTc (text "Got result" <+> ppr expr2)   `thenM_`
 154
 155     showSplice "expression"
 156                zonked_q_expr (ppr expr2)        `thenM_`
 157     initRn SourceMode (rnExpr expr2)            `thenM` \ (exp3, fvs) ->
 158     importSupportingDecls fvs                   `thenM` \ env ->
 159
 160     setGblEnv env (tcMonoExpr exp3 res_ty)
 161 \end{code}
 162
 163
 164 %************************************************************************
 165 %*                                                                      *
 166 \subsection{Splicing an expression}
 167 %*                                                                      *
 168 %************************************************************************
 169
 170 \begin{code}
 171 -- Always at top level
 172 tcSpliceDecls expr
 173   = tcMetaTy decTyConName               `thenM` \ meta_dec_ty ->
 174     tcMetaTy qTyConName                 `thenM` \ meta_q_ty ->
 175     setStage topSpliceStage (
 176         getLIE (tcMonoExpr expr (mkAppTy meta_q_ty (mkListTy meta_dec_ty)))
 177     )                                   `thenM` \ (expr', lie) ->
 178         -- Solve the constraints
 179     tcSimplifyTop lie                   `thenM` \ const_binds ->
 180     let
 181         q_expr = mkHsLet const_binds expr'
 182     in
 183     zonkTopExpr q_expr                  `thenM` \ zonked_q_expr ->
 184
 185         -- Run the expression
 186     traceTc (text "About to run" <+> ppr zonked_q_expr)         `thenM_`
 187     runMetaD zonked_q_expr              `thenM` \ simple_expr ->
 188     -- simple_expr :: [Meta.Dec]
 189     -- decls :: [RdrNameHsDecl]
 190     handleErrors (convertToHsDecls simple_expr) `thenM` \ decls ->
 191     traceTc (text "Got result" <+> vcat (map ppr decls))        `thenM_`
 192     showSplice "declarations"
 193                zonked_q_expr (vcat (map ppr decls))             `thenM_`
 194     returnM decls
 195
 196   where handleErrors :: [Either a Message] -> TcM [a]
 197         handleErrors [] = return []
 198         handleErrors (Left x:xs) = liftM (x:) (handleErrors xs)
 199         handleErrors (Right m:xs) = do addErrTc m
 200                                        handleErrors xs
 201 \end{code}
 202
 203
 204 %************************************************************************
 205 %*                                                                      *
 206 \subsection{Running an expression}
 207 %*                                                                      *
 208 %************************************************************************
 209
 210 \begin{code}
 211 runMetaE :: TypecheckedHsExpr   -- Of type (Q Exp)
 212          -> TcM Meta.Exp        -- Of type Exp
 213 runMetaE e = runMeta e
 214
 215 runMetaD :: TypecheckedHsExpr   -- Of type Q [Dec]
 216          -> TcM [Meta.Dec]      -- Of type [Dec]
 217 runMetaD e = runMeta e
 218
 219 tcRunQ :: Meta.Q a -> TcM a
 220 tcRunQ thing = ioToTcRn (Meta.runQ thing)
 221
 222 runMeta :: TypecheckedHsExpr    -- Of type X
 223         -> TcM t                -- Of type t
 224 runMeta expr
 225   = getTopEnv           `thenM` \ top_env ->
 226     getGblEnv           `thenM` \ tcg_env ->
 227     getEps              `thenM` \ eps ->
 228     getNameCache        `thenM` \ name_cache ->
 229     getModule           `thenM` \ this_mod ->
 230     let
 231         ghci_mode = top_mode top_env
 232
 233         hsc_env = HscEnv { hsc_mode = ghci_mode, hsc_HPT = top_hpt top_env,
 234                            hsc_dflags = top_dflags top_env }
 235
 236         pcs = PCS { pcs_nc = name_cache, pcs_EPS = eps }
 237
 238         type_env = tcg_type_env tcg_env
 239         rdr_env  = tcg_rdr_env tcg_env
 240     in
 241     ioToTcRn (HscMain.compileExpr
 242                 hsc_env pcs this_mod
 243                 rdr_env type_env expr)  `thenM` \ hval ->
 244
 245     tryM (tcRunQ (unsafeCoerce# hval))  `thenM` \ either_tval ->
 246
 247     case either_tval of
 248           Left exn -> failWithTc (vcat [text "Exception when running compile-time code:",
 249                                         nest 4 (vcat [text "Code:" <+> ppr expr,
 250                                                       text ("Exn: " ++ show exn)])])
 251           Right v  -> returnM v
 252 \end{code}
 253
 254
 255
 256 -----------------------------------
 257         Random comments
 258
 259
 260       module Foo where
 261         import Lib( g :: Int -> M Exp )
 262         h x = not x
 263         f x y = [| \z -> (x, $(g y), z, map, h) |]
 264
 265         h p = $( (\q r -> if q then [| \s -> (p,r,s) |]
 266                                else ... ) True 3)   )
 267
 268 ==> core
 269
 270         f :: Liftable a => a -> Int -> M Exp
 271         f = /\a -> \d::Liftable a ->
 272             \ x y -> genSym "z"         `bindM` \ z::String ->
 273                      g y                `bindM` \ vv::Exp ->
 274                      Lam z (Tup [lift d x, v, Var z,
 275                                  Glob "Prelude" "map",
 276                                  Glob "Foo" "h"])
 277
 278
 279         h :: Tree Int -> M Exp
 280         h = \p -> \s' -> (p,3,s')
 281
 282
 283                 Bound   Used
 284
 285         map:    C0      C1      (top-level/imp)
 286         x:      C0      C1      (lam/case)
 287         y:      C0      C0
 288         z:      C1      C1
 289
 290         p:      C0      S1
 291         r:      S0      S1
 292         q:      S0      S0
 293         s:      S1      S1
 294
 295 -------
 296
 297         f x y = lam "z" (tup [lift x, g y, var "z",
 298                               [| map |], [| h |] ])
 299 ==> core
 300
 301         f = \x y -> lam "z" (tup [lift d x, g y, var "z",
 302                                   return (Glob "Prelude" "map"),
 303                                   return (Glob "Foo" "h")])
 304
 305
 306
 307
 308
 309
 310
 311         h :: M Exp -> M Exp
 312         h v = [| \x -> map $v x |]
 313
 314         g :: Tree Int -> M Exp
 315         g x = $(h [| x |])
 316 ==>
 317         g x = \x' -> map x x'
 318
 319 *** Simon claims x does not have to be liftable! **
 320
 321 Level 0 compile time
 322 Level 1 run time
 323 Level 2 code returned by run time (generation time)
 324
 325 Non-top-level variables
 326         x occurs at level 1
 327           inside brackets
 328             bound at level 0    --> x
 329             bound at level 1    --> var "x"
 330
 331           not inside brackets   --> x
 332
 333         x at level 2
 334           inside brackets
 335             bound at level 0    --> x
 336             bound at level 1    --> var "x"
 337
 338         f x = x
 339
 340 Two successive brackets aren't allowed
 341
 342
 343 %************************************************************************
 344 %*                                                                      *
 345 \subsection{Errors and contexts}
 346 %*                                                                      *
 347 %************************************************************************
 348
 349 \begin{code}
 350 showSplice :: String -> TypecheckedHsExpr -> SDoc -> TcM ()
 351 showSplice what before after
 352   = getSrcLocM          `thenM` \ loc ->
 353     traceSplice (vcat [ppr loc <> colon <+> text "Splicing" <+> text what,
 354                        nest 2 (sep [nest 2 (ppr before),
 355                                     text "======>",
 356                                     nest 2 after])])
 357
 358 illegalSplice level
 359   = ptext SLIT("Illegal splice at level") <+> ppr level
 360
 361 #endif  /* GHCI */
 362 \end{code}