compiler: add new modules pulling in FunFlags
[ghc.git] / compiler / rename / RnSplice.lhs
1 \begin{code}
2 {-# LANGUAGE CPP #-}
3
4 module RnSplice (
5         rnTopSpliceDecls,
6         rnSpliceType, rnSpliceExpr, rnSplicePat, rnSpliceDecl,
7         rnBracket,
8         checkThLocalName
9   ) where
10
11
12 import Name
13 import NameSet
14 import HsSyn
15 import RdrName
16 import TcRnMonad
17 import Kind
18
19 #ifdef GHCI
20 import Control.Monad    ( unless, when )
21 import DynFlags
22 import DsMeta           ( decsQTyConName, expQTyConName, patQTyConName, typeQTyConName )
23 import LoadIface        ( loadInterfaceForName )
24 import Module
25 import RnEnv
26 import RnPat            ( rnPat )
27 import RnSource         ( rnSrcDecls, findSplice )
28 import RnTypes          ( rnLHsType )
29 import SrcLoc
30 import TcEnv            ( checkWellStaged, tcMetaTy )
31 import Outputable
32 import BasicTypes       ( TopLevelFlag, isTopLevel )
33 import FastString
34 import Hooks
35
36 import {-# SOURCE #-} RnExpr   ( rnLExpr )
37 import {-# SOURCE #-} TcExpr   ( tcMonoExpr )
38 import {-# SOURCE #-} TcSplice ( runMetaD, runMetaE, runMetaP, runMetaT, tcTopSpliceExpr )
39 #endif
40 \end{code}
41
42 \begin{code}
43 #ifndef GHCI
44 rnBracket :: HsExpr RdrName -> HsBracket RdrName -> RnM (HsExpr Name, FreeVars)
45 rnBracket e _ = failTH e "Template Haskell bracket"
46
47 rnTopSpliceDecls :: HsSplice RdrName -> RnM ([LHsDecl RdrName], FreeVars)
48 rnTopSpliceDecls e = failTH e "Template Haskell top splice"
49
50 rnSpliceType :: HsSplice RdrName -> PostTc Name Kind
51              -> RnM (HsType Name, FreeVars)
52 rnSpliceType e _ = failTH e "Template Haskell type splice"
53
54 rnSpliceExpr :: Bool -> HsSplice RdrName -> RnM (HsExpr Name, FreeVars)
55 rnSpliceExpr _ e = failTH e "Template Haskell splice"
56
57 rnSplicePat :: HsSplice RdrName -> RnM (Either (Pat RdrName) (Pat Name), FreeVars)
58 rnSplicePat e = failTH e "Template Haskell pattern splice"
59
60 rnSpliceDecl :: SpliceDecl RdrName -> RnM (SpliceDecl Name, FreeVars)
61 rnSpliceDecl e = failTH e "Template Haskell declaration splice"
62 #else
63 \end{code}
64
65 %*********************************************************
66 %*                                                      *
67                 Splices
68 %*                                                      *
69 %*********************************************************
70
71 Note [Free variables of typed splices]
72 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
73 Consider renaming this:
74         f = ...
75         h = ...$(thing "f")...
76
77 where the splice is a *typed* splice.  The splice can expand into
78 literally anything, so when we do dependency analysis we must assume
79 that it might mention 'f'.  So we simply treat all locally-defined
80 names as mentioned by any splice.  This is terribly brutal, but I
81 don't see what else to do.  For example, it'll mean that every
82 locally-defined thing will appear to be used, so no unused-binding
83 warnings.  But if we miss the dependency, then we might typecheck 'h'
84 before 'f', and that will crash the type checker because 'f' isn't in
85 scope.
86
87 Currently, I'm not treating a splice as also mentioning every import,
88 which is a bit inconsistent -- but there are a lot of them.  We might
89 thereby get some bogus unused-import warnings, but we won't crash the
90 type checker.  Not very satisfactory really.
91
92 Note [Renamer errors]
93 ~~~~~~~~~~~~~~~~~~~~~
94 It's important to wrap renamer calls in checkNoErrs, because the
95 renamer does not fail for out of scope variables etc. Instead it
96 returns a bogus term/type, so that it can report more than one error.
97 We don't want the type checker to see these bogus unbound variables.
98
99 \begin{code}
100 rnSpliceGen :: Bool                                     -- Typed splice?
101             -> (HsSplice Name -> RnM (a, FreeVars))     -- Outside brackets, run splice
102             -> (HsSplice Name -> (PendingRnSplice, a))  -- Inside brackets, make it pending
103             -> HsSplice RdrName
104             -> RnM (a, FreeVars)
105 rnSpliceGen is_typed_splice run_splice pend_splice splice@(HsSplice _ expr)
106   = addErrCtxt (spliceCtxt (HsSpliceE is_typed_splice splice)) $
107     setSrcSpan (getLoc expr) $ do
108     { stage <- getStage
109     ; case stage of
110         Brack pop_stage RnPendingTyped
111           -> do { checkTc is_typed_splice illegalUntypedSplice
112                 ; (splice', fvs) <- setStage pop_stage $
113                                     rnSplice splice
114                 ; let (_pending_splice, result) = pend_splice splice'
115                 ; return (result, fvs) }
116
117         Brack pop_stage (RnPendingUntyped ps_var)
118           -> do { checkTc (not is_typed_splice) illegalTypedSplice
119                 ; (splice', fvs) <- setStage pop_stage $
120                                     rnSplice splice
121                 ; let (pending_splice, result) = pend_splice splice'
122                 ; ps <- readMutVar ps_var
123                 ; writeMutVar ps_var (pending_splice : ps)
124                 ; return (result, fvs) }
125
126         _ ->  do { (splice', fvs1) <- setStage (Splice is_typed_splice) $
127                                       rnSplice splice
128
129                  ; (result, fvs2) <- run_splice splice'
130                  ; return (result, fvs1 `plusFV` fvs2) } }
131
132 ---------------------
133 rnSplice :: HsSplice RdrName -> RnM (HsSplice Name, FreeVars)
134 -- Not exported...used for all
135 rnSplice (HsSplice splice_name expr)
136   = do  { checkTH expr "Template Haskell splice"
137         ; loc  <- getSrcSpanM
138         ; n' <- newLocalBndrRn (L loc splice_name)
139         ; (expr', fvs) <- rnLExpr expr
140         ; return (HsSplice n' expr', fvs) }
141
142 ---------------------
143 rnSpliceExpr :: Bool -> HsSplice RdrName -> RnM (HsExpr Name, FreeVars)
144 rnSpliceExpr is_typed splice
145   = rnSpliceGen is_typed run_expr_splice pend_expr_splice splice
146   where
147     pend_expr_splice :: HsSplice Name -> (PendingRnSplice, HsExpr Name)
148     pend_expr_splice rn_splice@(HsSplice n e)
149         = (PendingRnExpSplice (PendSplice n e), HsSpliceE is_typed rn_splice)
150
151     run_expr_splice :: HsSplice Name -> RnM (HsExpr Name, FreeVars)
152     run_expr_splice rn_splice@(HsSplice _ expr')
153       | is_typed   -- Run it later, in the type checker
154       = do {  -- Ugh!  See Note [Splices] above
155              lcl_rdr <- getLocalRdrEnv
156            ; gbl_rdr <- getGlobalRdrEnv
157            ; let gbl_names = mkNameSet [gre_name gre | gre <- globalRdrEnvElts gbl_rdr
158                                                      , isLocalGRE gre]
159                  lcl_names = mkNameSet (localRdrEnvElts lcl_rdr)
160
161            ; return (HsSpliceE is_typed rn_splice, lcl_names `plusFV` gbl_names) }
162
163       | otherwise  -- Run it here
164       = do { expr <- getHooked runRnSpliceHook return >>= ($ expr')
165
166              -- The splice must have type ExpQ
167            ; meta_exp_ty <- tcMetaTy expQTyConName
168
169              -- Typecheck the expression
170            ; zonked_q_expr <- tcTopSpliceExpr False $
171                               tcMonoExpr expr meta_exp_ty
172
173              -- Run the expression
174            ; expr2 <- runMetaE zonked_q_expr
175            ; showSplice "expression" expr (ppr expr2)
176
177            ; (lexpr3, fvs) <- checkNoErrs $
178                               rnLExpr expr2
179            ; return (unLoc lexpr3, fvs)  }
180
181 ----------------------
182 rnSpliceType :: HsSplice RdrName -> PostTc Name Kind
183              -> RnM (HsType Name, FreeVars)
184 rnSpliceType splice k
185   = rnSpliceGen False run_type_splice pend_type_splice splice
186   where
187     pend_type_splice rn_splice@(HsSplice n e)
188        = (PendingRnTypeSplice (PendSplice n e), HsSpliceTy rn_splice k)
189
190     run_type_splice (HsSplice _ expr')
191        = do { expr <- getHooked runRnSpliceHook return >>= ($ expr')
192
193             ; meta_exp_ty <- tcMetaTy typeQTyConName
194
195               -- Typecheck the expression
196             ; zonked_q_expr <- tcTopSpliceExpr False $
197                                tcMonoExpr expr meta_exp_ty
198
199               -- Run the expression
200             ; hs_ty2 <- runMetaT zonked_q_expr
201             ; showSplice "type" expr (ppr hs_ty2)
202
203             ; (hs_ty3, fvs) <- do { let doc = SpliceTypeCtx hs_ty2
204                                   ; checkNoErrs $ rnLHsType doc hs_ty2
205                                     -- checkNoErrs: see Note [Renamer errors]
206                                   }
207             ; return (unLoc hs_ty3, fvs) }
208
209 \end{code}
210
211 Note [rnSplicePat]
212 ~~~~~~~~~~~~~~~~~~
213 Renaming a pattern splice is a bit tricky, because we need the variables
214 bound in the pattern to be in scope in the RHS of the pattern. This scope
215 management is effectively done by using continuation-passing style in
216 RnPat, through the CpsRn monad. We don't wish to be in that monad here
217 (it would create import cycles and generally conflict with renaming other
218 splices), so we really want to return a (Pat RdrName) -- the result of
219 running the splice -- which can then be further renamed in RnPat, in
220 the CpsRn monad.
221
222 The problem is that if we're renaming a splice within a bracket, we
223 *don't* want to run the splice now. We really do just want to rename
224 it to an HsSplice Name. Of course, then we can't know what variables
225 are bound within the splice, so pattern splices within brackets aren't
226 all that useful.
227
228 In any case, when we're done in rnSplicePat, we'll either have a
229 Pat RdrName (the result of running a top-level splice) or a Pat Name
230 (the renamed nested splice). Thus, the awkward return type of
231 rnSplicePat.
232
233 \begin{code}
234
235 -- | Rename a splice pattern. See Note [rnSplicePat]
236 rnSplicePat :: HsSplice RdrName -> RnM ( Either (Pat RdrName) (Pat Name)
237                                        , FreeVars)
238 rnSplicePat splice
239   = rnSpliceGen False run_pat_splice pend_pat_splice splice
240   where
241     pend_pat_splice rn_splice@(HsSplice n e)
242       = (PendingRnPatSplice (PendSplice n e), Right $ SplicePat rn_splice)
243
244     run_pat_splice (HsSplice _ expr')
245       = do { expr <- getHooked runRnSpliceHook return >>= ($ expr')
246
247            ; meta_exp_ty <- tcMetaTy patQTyConName
248
249              -- Typecheck the expression
250            ; zonked_q_expr <- tcTopSpliceExpr False $
251                               tcMonoExpr expr meta_exp_ty
252
253              -- Run the expression
254            ; pat <- runMetaP zonked_q_expr
255            ; showSplice "pattern" expr (ppr pat)
256
257            ; return (Left $ unLoc pat, emptyFVs) }
258
259 ----------------------
260 rnSpliceDecl :: SpliceDecl RdrName -> RnM (SpliceDecl Name, FreeVars)
261 rnSpliceDecl (SpliceDecl (L loc splice) flg)
262   = rnSpliceGen False run_decl_splice pend_decl_splice splice
263   where
264     pend_decl_splice rn_splice@(HsSplice n e)
265        = (PendingRnDeclSplice (PendSplice n e), SpliceDecl(L loc rn_splice) flg)
266
267     run_decl_splice rn_splice = pprPanic "rnSpliceDecl" (ppr rn_splice)
268 \end{code}
269
270 \begin{code}
271 rnTopSpliceDecls :: HsSplice RdrName -> RnM ([LHsDecl RdrName], FreeVars)
272 -- Declaration splice at the very top level of the module
273 rnTopSpliceDecls (HsSplice _ expr'')
274    = do  { (expr, fvs) <- setStage (Splice False) $
275                            rnLExpr expr''
276
277          ; expr' <- getHooked runRnSpliceHook return >>= ($ expr)
278
279          ; list_q <- tcMetaTy decsQTyConName     -- Q [Dec]
280          ; zonked_q_expr <- tcTopSpliceExpr False (tcMonoExpr expr' list_q)
281
282                 -- Run the expression
283          ; decls <- runMetaD zonked_q_expr
284          ; showSplice "declarations" expr'
285                  (ppr (getLoc expr) $$ (vcat (map ppr decls)))
286
287          ; return (decls,fvs) }
288 \end{code}
289
290 %************************************************************************
291 %*                                                                      *
292         Template Haskell brackets
293 %*                                                                      *
294 %************************************************************************
295
296 \begin{code}
297 rnBracket :: HsExpr RdrName -> HsBracket RdrName -> RnM (HsExpr Name, FreeVars)
298 rnBracket e br_body
299   = addErrCtxt (quotationCtxtDoc br_body) $
300     do { -- Check that Template Haskell is enabled and available
301          thEnabled <- xoptM Opt_TemplateHaskell
302        ; unless thEnabled $
303            failWith ( vcat [ ptext (sLit "Syntax error on") <+> ppr e
304                            , ptext (sLit "Perhaps you intended to use TemplateHaskell") ] )
305        ; checkTH e "Template Haskell bracket"
306
307          -- Check for nested brackets
308        ; cur_stage <- getStage
309        ; case cur_stage of
310            { Splice True  -> checkTc (isTypedBracket br_body) illegalUntypedBracket
311            ; Splice False -> checkTc (not (isTypedBracket br_body)) illegalTypedBracket
312            ; Comp         -> return ()
313            ; Brack {}     -> failWithTc illegalBracket
314            }
315
316          -- Brackets are desugared to code that mentions the TH package
317        ; recordThUse
318
319        ; case isTypedBracket br_body of
320             True  -> do { (body', fvs_e) <- setStage (Brack cur_stage RnPendingTyped) $
321                                             rn_bracket cur_stage br_body
322                         ; return (HsBracket body', fvs_e) }
323
324             False -> do { ps_var <- newMutVar []
325                         ; (body', fvs_e) <- setStage (Brack cur_stage (RnPendingUntyped ps_var)) $
326                                             rn_bracket cur_stage br_body
327                         ; pendings <- readMutVar ps_var
328                         ; return (HsRnBracketOut body' pendings, fvs_e) }
329        }
330
331 rn_bracket :: ThStage -> HsBracket RdrName -> RnM (HsBracket Name, FreeVars)
332 rn_bracket outer_stage br@(VarBr flg rdr_name)
333   = do { name <- lookupOccRn rdr_name
334        ; this_mod <- getModule
335
336        ; case flg of
337            { -- Type variables can be quoted in TH. See #5721.
338              False -> return ()
339            ; True | nameIsLocalOrFrom this_mod name ->
340                  do { mb_bind_lvl <- lookupLocalOccThLvl_maybe name
341                     ; case mb_bind_lvl of
342                         { Nothing -> return ()      -- Can happen for data constructors,
343                                                     -- but nothing needs to be done for them
344
345                         ; Just (top_lvl, bind_lvl)  -- See Note [Quoting names]
346                              | isTopLevel top_lvl
347                              -> when (isExternalName name) (keepAlive name)
348                              | otherwise
349                              -> do { traceRn (text "rn_bracket VarBr" <+> ppr name <+> ppr bind_lvl <+> ppr outer_stage)
350                                    ; checkTc (thLevel outer_stage + 1 == bind_lvl)
351                                              (quotedNameStageErr br) }
352                         }
353                     }
354            ; True | otherwise ->  -- Imported thing
355                  discardResult (loadInterfaceForName msg name)
356                      -- Reason for loadInterface: deprecation checking
357                      -- assumes that the home interface is loaded, and
358                      -- this is the only way that is going to happen
359            }
360        ; return (VarBr flg name, unitFV name) }
361   where
362     msg = ptext (sLit "Need interface for Template Haskell quoted Name")
363
364 rn_bracket _ (ExpBr e) = do { (e', fvs) <- rnLExpr e
365                             ; return (ExpBr e', fvs) }
366
367 rn_bracket _ (PatBr p) = rnPat ThPatQuote p $ \ p' -> return (PatBr p', emptyFVs)
368
369 rn_bracket _ (TypBr t) = do { (t', fvs) <- rnLHsType TypBrCtx t
370                             ; return (TypBr t', fvs) }
371
372 rn_bracket _ (DecBrL decls)
373   = do { group <- groupDecls decls
374        ; gbl_env  <- getGblEnv
375        ; let new_gbl_env = gbl_env { tcg_dus = emptyDUs }
376                           -- The emptyDUs is so that we just collect uses for this
377                           -- group alone in the call to rnSrcDecls below
378        ; (tcg_env, group') <- setGblEnv new_gbl_env $
379                               rnSrcDecls [] group
380    -- The empty list is for extra dependencies coming from .hs-boot files
381    -- See Note [Extra dependencies from .hs-boot files] in RnSource
382
383               -- Discard the tcg_env; it contains only extra info about fixity
384         ; traceRn (text "rn_bracket dec" <+> (ppr (tcg_dus tcg_env) $$
385                    ppr (duUses (tcg_dus tcg_env))))
386         ; return (DecBrG group', duUses (tcg_dus tcg_env)) }
387   where
388     groupDecls :: [LHsDecl RdrName] -> RnM (HsGroup RdrName)
389     groupDecls decls
390       = do { (group, mb_splice) <- findSplice decls
391            ; case mb_splice of
392            { Nothing -> return group
393            ; Just (splice, rest) ->
394                do { group' <- groupDecls rest
395                   ; let group'' = appendGroups group group'
396                   ; return group'' { hs_splcds = noLoc splice : hs_splcds group' }
397                   }
398            }}
399
400 rn_bracket _ (DecBrG _) = panic "rn_bracket: unexpected DecBrG"
401
402 rn_bracket _ (TExpBr e) = do { (e', fvs) <- rnLExpr e
403                              ; return (TExpBr e', fvs) }
404 \end{code}
405
406 \begin{code}
407 spliceCtxt :: HsExpr RdrName -> SDoc
408 spliceCtxt expr= hang (ptext (sLit "In the splice:")) 2 (ppr expr)
409
410 showSplice :: String -> LHsExpr Name -> SDoc -> TcM ()
411 -- Note that 'before' is *renamed* but not *typechecked*
412 -- Reason (a) less typechecking crap
413 --        (b) data constructors after type checking have been
414 --            changed to their *wrappers*, and that makes them
415 --            print always fully qualified
416 showSplice what before after
417   = do { loc <- getSrcSpanM
418        ; traceSplice (vcat [ppr loc <> colon <+> text "Splicing" <+> text what,
419                             nest 2 (sep [nest 2 (ppr before),
420                                          text "======>",
421                                          nest 2 after])]) }
422
423 illegalBracket :: SDoc
424 illegalBracket = ptext (sLit "Template Haskell brackets cannot be nested (without intervening splices)")
425
426 illegalTypedBracket :: SDoc
427 illegalTypedBracket = ptext (sLit "Typed brackets may only appear in typed slices.")
428
429 illegalUntypedBracket :: SDoc
430 illegalUntypedBracket = ptext (sLit "Untyped brackets may only appear in untyped slices.")
431
432 illegalTypedSplice :: SDoc
433 illegalTypedSplice = ptext (sLit "Typed splices may not appear in untyped brackets")
434
435 illegalUntypedSplice :: SDoc
436 illegalUntypedSplice = ptext (sLit "Untyped splices may not appear in typed brackets")
437
438 quotedNameStageErr :: HsBracket RdrName -> SDoc
439 quotedNameStageErr br
440   = sep [ ptext (sLit "Stage error: the non-top-level quoted name") <+> ppr br
441         , ptext (sLit "must be used at the same stage at which is is bound")]
442
443 quotationCtxtDoc :: HsBracket RdrName -> SDoc
444 quotationCtxtDoc br_body
445   = hang (ptext (sLit "In the Template Haskell quotation"))
446          2 (ppr br_body)
447
448 -- spliceResultDoc :: OutputableBndr id => LHsExpr id -> SDoc
449 -- spliceResultDoc expr
450 --  = vcat [ hang (ptext (sLit "In the splice:"))
451 --              2 (char '$' <> pprParendExpr expr)
452 --        , ptext (sLit "To see what the splice expanded to, use -ddump-splices") ]
453 #endif
454 \end{code}
455
456 \begin{code}
457 checkThLocalName :: Name -> RnM ()
458 #ifndef GHCI  /* GHCI and TH is off */
459 --------------------------------------
460 -- Check for cross-stage lifting
461 checkThLocalName _name
462   = return ()
463
464 #else         /* GHCI and TH is on */
465 checkThLocalName name 
466   = do  { traceRn (text "checkThLocalName" <+> ppr name)
467         ; mb_local_use <- getStageAndBindLevel name
468         ; case mb_local_use of {
469              Nothing -> return () ;  -- Not a locally-bound thing
470              Just (top_lvl, bind_lvl, use_stage) ->
471     do  { let use_lvl = thLevel use_stage
472         ; checkWellStaged (quotes (ppr name)) bind_lvl use_lvl
473         ; traceRn (text "checkThLocalName" <+> ppr name <+> ppr bind_lvl <+> ppr use_stage <+> ppr use_lvl)
474         ; when (use_lvl > bind_lvl) $
475           checkCrossStageLifting top_lvl name use_stage } } }
476
477 --------------------------------------
478 checkCrossStageLifting :: TopLevelFlag -> Name -> ThStage -> TcM ()
479 -- We are inside brackets, and (use_lvl > bind_lvl)
480 -- Now we must check whether there's a cross-stage lift to do
481 -- Examples   \x -> [| x |]
482 --            [| map |]
483
484 checkCrossStageLifting top_lvl name (Brack _ (RnPendingUntyped ps_var))
485   | isTopLevel top_lvl
486         -- Top-level identifiers in this module,
487         -- (which have External Names)
488         -- are just like the imported case:
489         -- no need for the 'lifting' treatment
490         -- E.g.  this is fine:
491         --   f x = x
492         --   g y = [| f 3 |]
493   = when (isExternalName name) (keepAlive name)
494     -- See Note [Keeping things alive for Template Haskell]
495
496   | otherwise
497   =     -- Nested identifiers, such as 'x' in
498         -- E.g. \x -> [| h x |]
499         -- We must behave as if the reference to x was
500         --      h $(lift x)
501         -- We use 'x' itself as the splice proxy, used by
502         -- the desugarer to stitch it all back together.
503         -- If 'x' occurs many times we may get many identical
504         -- bindings of the same splice proxy, but that doesn't
505         -- matter, although it's a mite untidy.
506     do  { traceRn (text "checkCrossStageLifting" <+> ppr name)
507         ; -- Update the pending splices
508         ; ps <- readMutVar ps_var
509         ; writeMutVar ps_var (PendingRnCrossStageSplice name : ps) }
510
511 checkCrossStageLifting _ _ _ = return ()
512 #endif /* GHCI */
513 \end{code}
514
515 Note [Keeping things alive for Template Haskell]
516 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
517 Consider
518   f x = x+1
519   g y = [| f 3 |]
520
521 Here 'f' is referred to from inside the bracket, which turns into data
522 and mentions only f's *name*, not 'f' itself. So we need some other
523 way to keep 'f' alive, lest it get dropped as dead code.  That's what
524 keepAlive does. It puts it in the keep-alive set, which subsequently
525 ensures that 'f' stays as a top level binding.
526
527 This must be done by the renamer, not the type checker (as of old),
528 because the type checker doesn't typecheck the body of untyped
529 brackets (Trac #8540).
530
531 A thing can have a bind_lvl of outerLevel, but have an internal name:
532    foo = [d| op = 3
533              bop = op + 1 |]
534 Here the bind_lvl of 'op' is (bogusly) outerLevel, even though it is
535 bound inside a bracket.  That is because we don't even even record
536 binding levels for top-level things; the binding levels are in the
537 LocalRdrEnv.
538
539 So the occurrence of 'op' in the rhs of 'bop' looks a bit like a
540 cross-stage thing, but it isn't really.  And in fact we never need
541 to do anything here for top-level bound things, so all is fine, if
542 a bit hacky.
543
544 For these chaps (which have Internal Names) we don't want to put
545 them in the keep-alive set.
546
547 Note [Quoting names]
548 ~~~~~~~~~~~~~~~~~~~~
549 A quoted name 'n is a bit like a quoted expression [| n |], except that we
550 have no cross-stage lifting (c.f. TcExpr.thBrackId).  So, after incrementing
551 the use-level to account for the brackets, the cases are:
552
553         bind > use                      Error
554         bind = use+1                    OK
555         bind < use
556                 Imported things         OK
557                 Top-level things        OK
558                 Non-top-level           Error
559
560 where 'use' is the binding level of the 'n quote. (So inside the implied
561 bracket the level would be use+1.)
562
563 Examples:
564
565   f 'map        -- OK; also for top-level defns of this module
566
567   \x. f 'x      -- Not ok (bind = 1, use = 1)
568                 -- (whereas \x. f [| x |] might have been ok, by
569                 --                               cross-stage lifting
570
571   \y. [| \x. $(f 'y) |] -- Not ok (bind =1, use = 1)
572
573   [| \x. $(f 'x) |]     -- OK (bind = 2, use = 1)
574