ghc/compiler/typecheck/TcSplice.lhs

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