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