2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[RnSource]{Main pass of renamer}
9 rnHsType, rnLHsType, rnLHsTypes, rnContext,
10 rnHsSigType, rnHsTypeFVs, rnConDeclFields,
12 -- Precence related stuff
13 mkOpAppRn, mkNegAppRn, mkOpFormRn, mkConOpPatRn,
14 checkPrecMatch, checkSectionPrec,
16 -- Splice related stuff
20 import {-# SOURCE #-} RnExpr( rnLExpr )
24 import RdrHsSyn ( extractHsRhoRdrTyVars )
25 import RnHsSyn ( extractHsTyNames )
26 import RnHsDoc ( rnLHsDoc, rnMbLHsDoc )
31 import TypeRep ( funTyConName )
36 import BasicTypes ( compareFixity, funTyFixity, negateFixity,
37 Fixity(..), FixityDirection(..) )
40 import Control.Monad ( unless )
42 #include "HsVersions.h"
45 These type renamers are in a separate module, rather than in (say) RnSource,
46 to break several loop.
48 %*********************************************************
50 \subsection{Renaming types}
52 %*********************************************************
55 rnHsTypeFVs :: SDoc -> LHsType RdrName -> RnM (LHsType Name, FreeVars)
56 rnHsTypeFVs doc_str ty = do
57 ty' <- rnLHsType doc_str ty
58 return (ty', extractHsTyNames ty')
60 rnHsSigType :: SDoc -> LHsType RdrName -> RnM (LHsType Name)
61 -- rnHsSigType is used for source-language type signatures,
62 -- which use *implicit* universal quantification.
63 rnHsSigType doc_str ty
64 = rnLHsType (text "In the type signature for" <+> doc_str) ty
67 rnHsType is here because we call it from loadInstDecl, and I didn't
68 want a gratuitous knot.
71 rnLHsType :: SDoc -> LHsType RdrName -> RnM (LHsType Name)
72 rnLHsType doc = wrapLocM (rnHsType doc)
74 rnHsType :: SDoc -> HsType RdrName -> RnM (HsType Name)
76 rnHsType doc (HsForAllTy Implicit _ ctxt ty) = do
77 -- Implicit quantifiction in source code (no kinds on tyvars)
78 -- Given the signature C => T we universally quantify
79 -- over FV(T) \ {in-scope-tyvars}
80 name_env <- getLocalRdrEnv
82 mentioned = extractHsRhoRdrTyVars ctxt ty
84 -- Don't quantify over type variables that are in scope;
85 -- when GlasgowExts is off, there usually won't be any, except for
87 -- class C a where { op :: a -> a }
88 forall_tyvars = filter (not . (`elemLocalRdrEnv` name_env) . unLoc) mentioned
89 tyvar_bndrs = userHsTyVarBndrs forall_tyvars
91 rnForAll doc Implicit tyvar_bndrs ctxt ty
93 rnHsType doc (HsForAllTy Explicit forall_tyvars ctxt tau) = do
94 -- Explicit quantification.
95 -- Check that the forall'd tyvars are actually
96 -- mentioned in the type, and produce a warning if not
98 mentioned = map unLoc (extractHsRhoRdrTyVars ctxt tau)
99 forall_tyvar_names = hsLTyVarLocNames forall_tyvars
101 -- Explicitly quantified but not mentioned in ctxt or tau
102 warn_guys = filter ((`notElem` mentioned) . unLoc) forall_tyvar_names
104 mapM_ (forAllWarn doc tau) warn_guys
105 rnForAll doc Explicit forall_tyvars ctxt tau
107 rnHsType _ (HsTyVar tyvar) = do
108 tyvar' <- lookupOccRn tyvar
109 return (HsTyVar tyvar')
111 -- If we see (forall a . ty), without foralls on, the forall will give
112 -- a sensible error message, but we don't want to complain about the dot too
113 -- Hence the jiggery pokery with ty1
114 rnHsType doc ty@(HsOpTy ty1 (L loc op) ty2)
116 do { ops_ok <- doptM Opt_TypeOperators
119 else do { addErr (opTyErr op ty)
120 ; return (mkUnboundName op) } -- Avoid double complaint
121 ; let l_op' = L loc op'
122 ; fix <- lookupTyFixityRn l_op'
123 ; ty1' <- rnLHsType doc ty1
124 ; ty2' <- rnLHsType doc ty2
125 ; mkHsOpTyRn (\t1 t2 -> HsOpTy t1 l_op' t2) op' fix ty1' ty2' }
127 rnHsType doc (HsParTy ty) = do
128 ty' <- rnLHsType doc ty
131 rnHsType doc (HsBangTy b ty)
132 = do { ty' <- rnLHsType doc ty
133 ; return (HsBangTy b ty') }
135 rnHsType doc (HsRecTy flds)
136 = do { flds' <- rnConDeclFields doc flds
137 ; return (HsRecTy flds') }
139 rnHsType _ (HsNumTy i)
140 | i == 1 = return (HsNumTy i)
141 | otherwise = addErr err_msg >> return (HsNumTy i)
143 err_msg = ptext (sLit "Only unit numeric type pattern is valid")
146 rnHsType doc (HsFunTy ty1 ty2) = do
147 ty1' <- rnLHsType doc ty1
148 -- Might find a for-all as the arg of a function type
149 ty2' <- rnLHsType doc ty2
150 -- Or as the result. This happens when reading Prelude.hi
151 -- when we find return :: forall m. Monad m -> forall a. a -> m a
153 -- Check for fixity rearrangements
154 mkHsOpTyRn HsFunTy funTyConName funTyFixity ty1' ty2'
156 rnHsType doc (HsListTy ty) = do
157 ty' <- rnLHsType doc ty
158 return (HsListTy ty')
160 rnHsType doc (HsKindSig ty k)
161 = do { kind_sigs_ok <- doptM Opt_KindSignatures
162 ; unless kind_sigs_ok (addErr (kindSigErr ty))
163 ; ty' <- rnLHsType doc ty
164 ; return (HsKindSig ty' k) }
166 rnHsType doc (HsPArrTy ty) = do
167 ty' <- rnLHsType doc ty
168 return (HsPArrTy ty')
170 -- Unboxed tuples are allowed to have poly-typed arguments. These
171 -- sometimes crop up as a result of CPR worker-wrappering dictionaries.
172 rnHsType doc (HsTupleTy tup_con tys) = do
173 tys' <- mapM (rnLHsType doc) tys
174 return (HsTupleTy tup_con tys')
176 rnHsType doc (HsAppTy ty1 ty2) = do
177 ty1' <- rnLHsType doc ty1
178 ty2' <- rnLHsType doc ty2
179 return (HsAppTy ty1' ty2')
181 rnHsType doc (HsPredTy pred) = do
182 pred' <- rnPred doc pred
183 return (HsPredTy pred')
185 rnHsType _ (HsSpliceTy sp)
186 = do { (sp', _fvs) <- rnSplice sp -- ToDo: deal with fvs
187 ; return (HsSpliceTy sp') }
189 rnHsType doc (HsDocTy ty haddock_doc) = do
190 ty' <- rnLHsType doc ty
191 haddock_doc' <- rnLHsDoc haddock_doc
192 return (HsDocTy ty' haddock_doc')
194 rnLHsTypes :: SDoc -> [LHsType RdrName]
195 -> IOEnv (Env TcGblEnv TcLclEnv) [LHsType Name]
196 rnLHsTypes doc tys = mapM (rnLHsType doc) tys
201 rnForAll :: SDoc -> HsExplicitForAll -> [LHsTyVarBndr RdrName]
202 -> LHsContext RdrName -> LHsType RdrName -> RnM (HsType Name)
204 rnForAll doc _ [] (L _ []) (L _ ty) = rnHsType doc ty
205 -- One reason for this case is that a type like Int#
206 -- starts off as (HsForAllTy Nothing [] Int), in case
207 -- there is some quantification. Now that we have quantified
208 -- and discovered there are no type variables, it's nicer to turn
209 -- it into plain Int. If it were Int# instead of Int, we'd actually
210 -- get an error, because the body of a genuine for-all is
213 rnForAll doc exp forall_tyvars ctxt ty
214 = bindTyVarsRn doc forall_tyvars $ \ new_tyvars -> do
215 new_ctxt <- rnContext doc ctxt
216 new_ty <- rnLHsType doc ty
217 return (HsForAllTy exp new_tyvars new_ctxt new_ty)
218 -- Retain the same implicit/explicit flag as before
219 -- so that we can later print it correctly
221 rnConDeclFields :: SDoc -> [ConDeclField RdrName] -> RnM [ConDeclField Name]
222 rnConDeclFields doc fields = mapM (rnField doc) fields
224 rnField :: SDoc -> ConDeclField RdrName -> RnM (ConDeclField Name)
225 rnField doc (ConDeclField name ty haddock_doc)
226 = do { new_name <- lookupLocatedTopBndrRn name
227 ; new_ty <- rnLHsType doc ty
228 ; new_haddock_doc <- rnMbLHsDoc haddock_doc
229 ; return (ConDeclField new_name new_ty new_haddock_doc) }
232 %*********************************************************
234 \subsection{Contexts and predicates}
236 %*********************************************************
239 rnContext :: SDoc -> LHsContext RdrName -> RnM (LHsContext Name)
240 rnContext doc = wrapLocM (rnContext' doc)
242 rnContext' :: SDoc -> HsContext RdrName -> RnM (HsContext Name)
243 rnContext' doc ctxt = mapM (rnLPred doc) ctxt
245 rnLPred :: SDoc -> LHsPred RdrName -> RnM (LHsPred Name)
246 rnLPred doc = wrapLocM (rnPred doc)
248 rnPred :: SDoc -> HsPred RdrName
249 -> IOEnv (Env TcGblEnv TcLclEnv) (HsPred Name)
250 rnPred doc (HsClassP clas tys)
251 = do { clas_name <- lookupOccRn clas
252 ; tys' <- rnLHsTypes doc tys
253 ; return (HsClassP clas_name tys')
255 rnPred doc (HsEqualP ty1 ty2)
256 = do { ty1' <- rnLHsType doc ty1
257 ; ty2' <- rnLHsType doc ty2
258 ; return (HsEqualP ty1' ty2')
260 rnPred doc (HsIParam n ty)
261 = do { name <- newIPNameRn n
262 ; ty' <- rnLHsType doc ty
263 ; return (HsIParam name ty')
268 %************************************************************************
270 Fixities and precedence parsing
272 %************************************************************************
274 @mkOpAppRn@ deals with operator fixities. The argument expressions
275 are assumed to be already correctly arranged. It needs the fixities
276 recorded in the OpApp nodes, because fixity info applies to the things
277 the programmer actually wrote, so you can't find it out from the Name.
279 Furthermore, the second argument is guaranteed not to be another
280 operator application. Why? Because the parser parses all
281 operator appications left-associatively, EXCEPT negation, which
282 we need to handle specially.
283 Infix types are read in a *right-associative* way, so that
288 mkHsOpTyRn rearranges where necessary. The two arguments
289 have already been renamed and rearranged. It's made rather tiresome
290 by the presence of ->, which is a separate syntactic construct.
294 -- Building (ty1 `op1` (ty21 `op2` ty22))
295 mkHsOpTyRn :: (LHsType Name -> LHsType Name -> HsType Name)
296 -> Name -> Fixity -> LHsType Name -> LHsType Name
299 mkHsOpTyRn mk1 pp_op1 fix1 ty1 (L loc2 (HsOpTy ty21 op2 ty22))
300 = do { fix2 <- lookupTyFixityRn op2
301 ; mk_hs_op_ty mk1 pp_op1 fix1 ty1
302 (\t1 t2 -> HsOpTy t1 op2 t2)
303 (unLoc op2) fix2 ty21 ty22 loc2 }
305 mkHsOpTyRn mk1 pp_op1 fix1 ty1 (L loc2 (HsFunTy ty21 ty22))
306 = mk_hs_op_ty mk1 pp_op1 fix1 ty1
307 HsFunTy funTyConName funTyFixity ty21 ty22 loc2
309 mkHsOpTyRn mk1 _ _ ty1 ty2 -- Default case, no rearrangment
310 = return (mk1 ty1 ty2)
313 mk_hs_op_ty :: (LHsType Name -> LHsType Name -> HsType Name)
314 -> Name -> Fixity -> LHsType Name
315 -> (LHsType Name -> LHsType Name -> HsType Name)
316 -> Name -> Fixity -> LHsType Name -> LHsType Name -> SrcSpan
318 mk_hs_op_ty mk1 op1 fix1 ty1
319 mk2 op2 fix2 ty21 ty22 loc2
320 | nofix_error = do { precParseErr (op1,fix1) (op2,fix2)
321 ; return (mk1 ty1 (L loc2 (mk2 ty21 ty22))) }
322 | associate_right = return (mk1 ty1 (L loc2 (mk2 ty21 ty22)))
323 | otherwise = do { -- Rearrange to ((ty1 `op1` ty21) `op2` ty22)
324 new_ty <- mkHsOpTyRn mk1 op1 fix1 ty1 ty21
325 ; return (mk2 (noLoc new_ty) ty22) }
327 (nofix_error, associate_right) = compareFixity fix1 fix2
330 ---------------------------
331 mkOpAppRn :: LHsExpr Name -- Left operand; already rearranged
332 -> LHsExpr Name -> Fixity -- Operator and fixity
333 -> LHsExpr Name -- Right operand (not an OpApp, but might
337 -- (e11 `op1` e12) `op2` e2
338 mkOpAppRn e1@(L _ (OpApp e11 op1 fix1 e12)) op2 fix2 e2
340 = do precParseErr (get_op op1,fix1) (get_op op2,fix2)
341 return (OpApp e1 op2 fix2 e2)
343 | associate_right = do
344 new_e <- mkOpAppRn e12 op2 fix2 e2
345 return (OpApp e11 op1 fix1 (L loc' new_e))
347 loc'= combineLocs e12 e2
348 (nofix_error, associate_right) = compareFixity fix1 fix2
350 ---------------------------
351 -- (- neg_arg) `op` e2
352 mkOpAppRn e1@(L _ (NegApp neg_arg neg_name)) op2 fix2 e2
354 = do precParseErr (negateName,negateFixity) (get_op op2,fix2)
355 return (OpApp e1 op2 fix2 e2)
358 = do new_e <- mkOpAppRn neg_arg op2 fix2 e2
359 return (NegApp (L loc' new_e) neg_name)
361 loc' = combineLocs neg_arg e2
362 (nofix_error, associate_right) = compareFixity negateFixity fix2
364 ---------------------------
366 mkOpAppRn e1 op1 fix1 e2@(L _ (NegApp _ _)) -- NegApp can occur on the right
367 | not associate_right -- We *want* right association
368 = do precParseErr (get_op op1, fix1) (negateName, negateFixity)
369 return (OpApp e1 op1 fix1 e2)
371 (_, associate_right) = compareFixity fix1 negateFixity
373 ---------------------------
375 mkOpAppRn e1 op fix e2 -- Default case, no rearrangment
376 = ASSERT2( right_op_ok fix (unLoc e2),
377 ppr e1 $$ text "---" $$ ppr op $$ text "---" $$ ppr fix $$ text "---" $$ ppr e2
379 return (OpApp e1 op fix e2)
381 ----------------------------
382 get_op :: LHsExpr Name -> Name
383 get_op (L _ (HsVar n)) = n
384 get_op other = pprPanic "get_op" (ppr other)
386 -- Parser left-associates everything, but
387 -- derived instances may have correctly-associated things to
388 -- in the right operarand. So we just check that the right operand is OK
389 right_op_ok :: Fixity -> HsExpr Name -> Bool
390 right_op_ok fix1 (OpApp _ _ fix2 _)
391 = not error_please && associate_right
393 (error_please, associate_right) = compareFixity fix1 fix2
397 -- Parser initially makes negation bind more tightly than any other operator
398 -- And "deriving" code should respect this (use HsPar if not)
399 mkNegAppRn :: LHsExpr id -> SyntaxExpr id -> RnM (HsExpr id)
400 mkNegAppRn neg_arg neg_name
401 = ASSERT( not_op_app (unLoc neg_arg) )
402 return (NegApp neg_arg neg_name)
404 not_op_app :: HsExpr id -> Bool
405 not_op_app (OpApp _ _ _ _) = False
408 ---------------------------
409 mkOpFormRn :: LHsCmdTop Name -- Left operand; already rearranged
410 -> LHsExpr Name -> Fixity -- Operator and fixity
411 -> LHsCmdTop Name -- Right operand (not an infix)
414 -- (e11 `op1` e12) `op2` e2
415 mkOpFormRn a1@(L loc (HsCmdTop (L _ (HsArrForm op1 (Just fix1) [a11,a12])) _ _ _))
418 = do precParseErr (get_op op1,fix1) (get_op op2,fix2)
419 return (HsArrForm op2 (Just fix2) [a1, a2])
422 = do new_c <- mkOpFormRn a12 op2 fix2 a2
423 return (HsArrForm op1 (Just fix1)
424 [a11, L loc (HsCmdTop (L loc new_c) [] placeHolderType [])])
425 -- TODO: locs are wrong
427 (nofix_error, associate_right) = compareFixity fix1 fix2
430 mkOpFormRn arg1 op fix arg2 -- Default case, no rearrangment
431 = return (HsArrForm op (Just fix) [arg1, arg2])
434 --------------------------------------
435 mkConOpPatRn :: Located Name -> Fixity -> LPat Name -> LPat Name
438 mkConOpPatRn op2 fix2 p1@(L loc (ConPatIn op1 (InfixCon p11 p12))) p2
439 = do { fix1 <- lookupFixityRn (unLoc op1)
440 ; let (nofix_error, associate_right) = compareFixity fix1 fix2
442 ; if nofix_error then do
443 { precParseErr (unLoc op1,fix1) (unLoc op2,fix2)
444 ; return (ConPatIn op2 (InfixCon p1 p2)) }
446 else if associate_right then do
447 { new_p <- mkConOpPatRn op2 fix2 p12 p2
448 ; return (ConPatIn op1 (InfixCon p11 (L loc new_p))) } -- XXX loc right?
449 else return (ConPatIn op2 (InfixCon p1 p2)) }
451 mkConOpPatRn op _ p1 p2 -- Default case, no rearrangment
452 = ASSERT( not_op_pat (unLoc p2) )
453 return (ConPatIn op (InfixCon p1 p2))
455 not_op_pat :: Pat Name -> Bool
456 not_op_pat (ConPatIn _ (InfixCon _ _)) = False
459 --------------------------------------
460 checkPrecMatch :: Bool -> Name -> MatchGroup Name -> RnM ()
461 -- True indicates an infix lhs
462 -- See comments with rnExpr (OpApp ...) about "deriving"
464 checkPrecMatch False _ _
466 checkPrecMatch True op (MatchGroup ms _)
469 check (L _ (Match (p1:p2:_) _ _))
470 = do checkPrec op (unLoc p1) False
471 checkPrec op (unLoc p2) True
474 -- This can happen. Consider
477 -- The infix flag comes from the first binding of the group
478 -- but the second eqn has no args (an error, but not discovered
479 -- until the type checker). So we don't want to crash on the
482 checkPrec :: Name -> Pat Name -> Bool -> IOEnv (Env TcGblEnv TcLclEnv) ()
483 checkPrec op (ConPatIn op1 (InfixCon _ _)) right = do
484 op_fix@(Fixity op_prec op_dir) <- lookupFixityRn op
485 op1_fix@(Fixity op1_prec op1_dir) <- lookupFixityRn (unLoc op1)
487 inf_ok = op1_prec > op_prec ||
488 (op1_prec == op_prec &&
489 (op1_dir == InfixR && op_dir == InfixR && right ||
490 op1_dir == InfixL && op_dir == InfixL && not right))
493 info1 = (unLoc op1, op1_fix)
494 (infol, infor) = if right then (info, info1) else (info1, info)
495 unless inf_ok (precParseErr infol infor)
500 -- Check precedence of (arg op) or (op arg) respectively
501 -- If arg is itself an operator application, then either
502 -- (a) its precedence must be higher than that of op
503 -- (b) its precedency & associativity must be the same as that of op
504 checkSectionPrec :: FixityDirection -> HsExpr RdrName
505 -> LHsExpr Name -> LHsExpr Name -> RnM ()
506 checkSectionPrec direction section op arg
508 OpApp _ op fix _ -> go_for_it (get_op op) fix
509 NegApp _ _ -> go_for_it negateName negateFixity
513 go_for_it arg_op arg_fix@(Fixity arg_prec assoc) = do
514 op_fix@(Fixity op_prec _) <- lookupFixityRn op_name
515 unless (op_prec < arg_prec
516 || (op_prec == arg_prec && direction == assoc))
517 (sectionPrecErr (op_name, op_fix)
518 (arg_op, arg_fix) section)
521 Precedence-related error messages
524 precParseErr :: (Name, Fixity) -> (Name, Fixity) -> RnM ()
525 precParseErr op1@(n1,_) op2@(n2,_)
526 | isUnboundName n1 || isUnboundName n2
527 = return () -- Avoid error cascade
529 = addErr $ hang (ptext (sLit "Precedence parsing error"))
530 4 (hsep [ptext (sLit "cannot mix"), ppr_opfix op1, ptext (sLit "and"),
532 ptext (sLit "in the same infix expression")])
534 sectionPrecErr :: (Name, Fixity) -> (Name, Fixity) -> HsExpr RdrName -> RnM ()
535 sectionPrecErr op@(n1,_) arg_op@(n2,_) section
536 | isUnboundName n1 || isUnboundName n2
537 = return () -- Avoid error cascade
539 = addErr $ vcat [ptext (sLit "The operator") <+> ppr_opfix op <+> ptext (sLit "of a section"),
540 nest 4 (sep [ptext (sLit "must have lower precedence than that of the operand,"),
541 nest 2 (ptext (sLit "namely") <+> ppr_opfix arg_op)]),
542 nest 4 (ptext (sLit "in the section:") <+> quotes (ppr section))]
544 ppr_opfix :: (Name, Fixity) -> SDoc
545 ppr_opfix (op, fixity) = pp_op <+> brackets (ppr fixity)
547 pp_op | op == negateName = ptext (sLit "prefix `-'")
548 | otherwise = quotes (ppr op)
551 %*********************************************************
555 %*********************************************************
558 forAllWarn :: SDoc -> LHsType RdrName -> Located RdrName
559 -> TcRnIf TcGblEnv TcLclEnv ()
560 forAllWarn doc ty (L loc tyvar)
561 = ifOptM Opt_WarnUnusedMatches $
562 addWarnAt loc (sep [ptext (sLit "The universally quantified type variable") <+> quotes (ppr tyvar),
563 nest 4 (ptext (sLit "does not appear in the type") <+> quotes (ppr ty))]
567 opTyErr :: RdrName -> HsType RdrName -> SDoc
568 opTyErr op ty@(HsOpTy ty1 _ _)
569 = hang (ptext (sLit "Illegal operator") <+> quotes (ppr op) <+> ptext (sLit "in type") <+> quotes (ppr ty))
572 extra | op == dot_tv_RDR && forall_head ty1
575 = ptext (sLit "Use -XTypeOperators to allow operators in types")
577 forall_head (L _ (HsTyVar tv)) = tv == forall_tv_RDR
578 forall_head (L _ (HsAppTy ty _)) = forall_head ty
579 forall_head _other = False
580 opTyErr _ ty = pprPanic "opTyErr: Not an op" (ppr ty)
583 %*********************************************************
587 %*********************************************************
593 h = ...$(thing "f")...
595 The splice can expand into literally anything, so when we do dependency
596 analysis we must assume that it might mention 'f'. So we simply treat
597 all locally-defined names as mentioned by any splice. This is terribly
598 brutal, but I don't see what else to do. For example, it'll mean
599 that every locally-defined thing will appear to be used, so no unused-binding
600 warnings. But if we miss the dependency, then we might typecheck 'h' before 'f',
601 and that will crash the type checker because 'f' isn't in scope.
603 Currently, I'm not treating a splice as also mentioning every import,
604 which is a bit inconsistent -- but there are a lot of them. We might
605 thereby get some bogus unused-import warnings, but we won't crash the
606 type checker. Not very satisfactory really.
609 rnSplice :: HsSplice RdrName -> RnM (HsSplice Name, FreeVars)
610 rnSplice (HsSplice n expr)
611 = do { checkTH expr "splice"
613 ; n' <- newLocalBndrRn (L loc n)
614 ; (expr', fvs) <- rnLExpr expr
616 -- Ugh! See Note [Splices] above
617 ; lcl_rdr <- getLocalRdrEnv
618 ; gbl_rdr <- getGlobalRdrEnv
619 ; let gbl_names = mkNameSet [gre_name gre | gre <- globalRdrEnvElts gbl_rdr,
621 lcl_names = mkNameSet (occEnvElts lcl_rdr)
623 ; return (HsSplice n' expr', fvs `plusFV` lcl_names `plusFV` gbl_names) }
625 checkTH :: Outputable a => a -> String -> RnM ()
627 checkTH _ _ = return () -- OK
629 checkTH e what -- Raise an error in a stage-1 compiler
630 = addErr (vcat [ptext (sLit "Template Haskell") <+> text what <+>
631 ptext (sLit "illegal in a stage-1 compiler"),