2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[RnSource]{Main pass of renamer}
8 rnSrcDecls, addTcgDUs, rnTyClDecls, findSplice
11 #include "HsVersions.h"
13 import {-# SOURCE #-} RnExpr( rnLExpr )
15 import {-# SOURCE #-} TcSplice ( runQuasiQuoteDecl )
19 import RdrName ( RdrName, isRdrDataCon, elemLocalRdrEnv, rdrNameOcc )
20 import RdrHsSyn ( extractGenericPatTyVars, extractHsRhoRdrTyVars )
22 import RnTypes ( rnLHsType, rnLHsTypes, rnHsSigType, rnHsTypeFVs, rnContext, rnConDeclFields )
23 import RnBinds ( rnTopBindsLHS, rnTopBindsRHS, rnMethodBinds, renameSigs, mkSigTvFn,
25 import RnEnv ( lookupLocalDataTcNames, lookupLocatedOccRn,
26 lookupTopBndrRn, lookupLocatedTopBndrRn,
27 lookupOccRn, newLocalBndrsRn, bindLocalNamesFV,
28 bindLocatedLocalsFV, bindPatSigTyVarsFV,
29 bindTyVarsRn, bindTyVarsFV, extendTyVarEnvFVRn,
30 bindLocalNames, checkDupRdrNames, mapFvRn
32 import RnNames ( getLocalNonValBinders, extendGlobalRdrEnvRn )
33 import HscTypes ( GenAvailInfo(..), availsToNameSet )
34 import RnHsDoc ( rnHsDoc, rnMbLHsDoc )
37 import ForeignCall ( CCallTarget(..) )
39 import HscTypes ( Warnings(..), plusWarns )
40 import Class ( FunDep )
41 import Name ( Name, nameOccName )
47 import Util ( filterOut )
49 import DynFlags ( DynFlag(..), DynFlags, thisPackage )
50 import HscTypes ( HscEnv, hsc_dflags )
51 import BasicTypes ( Boxity(..) )
52 import ListSetOps ( findDupsEq )
61 thenM :: Monad a => a b -> (b -> a c) -> a c
64 thenM_ :: Monad a => a b -> a c -> a c
68 @rnSourceDecl@ `renames' declarations.
69 It simultaneously performs dependency analysis and precedence parsing.
70 It also does the following error checks:
73 Checks that tyvars are used properly. This includes checking
74 for undefined tyvars, and tyvars in contexts that are ambiguous.
75 (Some of this checking has now been moved to module @TcMonoType@,
76 since we don't have functional dependency information at this point.)
78 Checks that all variable occurences are defined.
80 Checks the @(..)@ etc constraints in the export list.
85 -- Brings the binders of the group into scope in the appropriate places;
86 -- does NOT assume that anything is in scope already
87 rnSrcDecls :: HsGroup RdrName -> RnM (TcGblEnv, HsGroup Name)
88 -- Rename a HsGroup; used for normal source files *and* hs-boot files
89 rnSrcDecls group@(HsGroup {hs_valds = val_decls,
90 hs_tyclds = tycl_decls,
91 hs_instds = inst_decls,
92 hs_derivds = deriv_decls,
94 hs_warnds = warn_decls,
96 hs_fords = foreign_decls,
97 hs_defds = default_decls,
98 hs_ruleds = rule_decls,
101 -- (A) Process the fixity declarations, creating a mapping from
102 -- FastStrings to FixItems.
103 -- Also checks for duplcates.
104 local_fix_env <- makeMiniFixityEnv fix_decls;
106 -- (B) Bring top level binders (and their fixities) into scope,
107 -- *except* for the value bindings, which get brought in below.
108 -- However *do* include class ops, data constructors
109 -- And for hs-boot files *do* include the value signatures
110 tc_avails <- getLocalNonValBinders group ;
111 tc_envs <- extendGlobalRdrEnvRn tc_avails local_fix_env ;
112 setEnvs tc_envs $ do {
114 failIfErrsM ; -- No point in continuing if (say) we have duplicate declarations
116 -- (C) Extract the mapping from data constructors to field names and
117 -- extend the record field env.
118 -- This depends on the data constructors and field names being in
119 -- scope from (B) above
120 inNewEnv (extendRecordFieldEnv tycl_decls inst_decls) $ \ _ -> do {
122 -- (D) Rename the left-hand sides of the value bindings.
123 -- This depends on everything from (B) being in scope,
124 -- and on (C) for resolving record wild cards.
125 -- It uses the fixity env from (A) to bind fixities for view patterns.
126 new_lhs <- rnTopBindsLHS local_fix_env val_decls ;
127 -- bind the LHSes (and their fixities) in the global rdr environment
128 let { val_binders = collectHsValBinders new_lhs ;
129 val_bndr_set = mkNameSet val_binders ;
130 all_bndr_set = val_bndr_set `unionNameSets` availsToNameSet tc_avails ;
131 val_avails = map Avail val_binders
133 (tcg_env, tcl_env) <- extendGlobalRdrEnvRn val_avails local_fix_env ;
134 setEnvs (tcg_env, tcl_env) $ do {
136 -- Now everything is in scope, as the remaining renaming assumes.
138 -- (E) Rename type and class decls
139 -- (note that value LHSes need to be in scope for default methods)
141 -- You might think that we could build proper def/use information
142 -- for type and class declarations, but they can be involved
143 -- in mutual recursion across modules, and we only do the SCC
144 -- analysis for them in the type checker.
145 -- So we content ourselves with gathering uses only; that
146 -- means we'll only report a declaration as unused if it isn't
147 -- mentioned at all. Ah well.
148 traceRn (text "Start rnTyClDecls") ;
149 (rn_tycl_decls, src_fvs1) <- rnList rnTyClDecl tycl_decls ;
151 -- (F) Rename Value declarations right-hand sides
152 traceRn (text "Start rnmono") ;
153 (rn_val_decls, bind_dus) <- rnTopBindsRHS val_bndr_set new_lhs ;
154 traceRn (text "finish rnmono" <+> ppr rn_val_decls) ;
156 -- (G) Rename Fixity and deprecations
158 -- Rename fixity declarations and error if we try to
159 -- fix something from another module (duplicates were checked in (A))
160 rn_fix_decls <- rnSrcFixityDecls all_bndr_set fix_decls ;
162 -- Rename deprec decls;
163 -- check for duplicates and ensure that deprecated things are defined locally
164 -- at the moment, we don't keep these around past renaming
165 rn_warns <- rnSrcWarnDecls all_bndr_set warn_decls ;
167 -- (H) Rename Everything else
169 (rn_inst_decls, src_fvs2) <- rnList rnSrcInstDecl inst_decls ;
170 (rn_rule_decls, src_fvs3) <- setOptM Opt_ScopedTypeVariables $
171 rnList rnHsRuleDecl rule_decls ;
172 -- Inside RULES, scoped type variables are on
173 (rn_foreign_decls, src_fvs4) <- rnList rnHsForeignDecl foreign_decls ;
174 (rn_ann_decls, src_fvs5) <- rnList rnAnnDecl ann_decls ;
175 (rn_default_decls, src_fvs6) <- rnList rnDefaultDecl default_decls ;
176 (rn_deriv_decls, src_fvs7) <- rnList rnSrcDerivDecl deriv_decls ;
177 -- Haddock docs; no free vars
178 rn_docs <- mapM (wrapLocM rnDocDecl) docs ;
180 -- (I) Compute the results and return
181 let {rn_group = HsGroup { hs_valds = rn_val_decls,
182 hs_tyclds = rn_tycl_decls,
183 hs_instds = rn_inst_decls,
184 hs_derivds = rn_deriv_decls,
185 hs_fixds = rn_fix_decls,
186 hs_warnds = [], -- warns are returned in the tcg_env
187 -- (see below) not in the HsGroup
188 hs_fords = rn_foreign_decls,
189 hs_annds = rn_ann_decls,
190 hs_defds = rn_default_decls,
191 hs_ruleds = rn_rule_decls,
192 hs_docs = rn_docs } ;
194 other_fvs = plusFVs [src_fvs1, src_fvs2, src_fvs3, src_fvs4,
195 src_fvs5, src_fvs6, src_fvs7] ;
196 src_dus = bind_dus `plusDU` usesOnly other_fvs;
197 -- Note: src_dus will contain *uses* for locally-defined types
198 -- and classes, but no *defs* for them. (Because rnTyClDecl
199 -- returns only the uses.) This is a little
200 -- surprising but it doesn't actually matter at all.
202 final_tcg_env = let tcg_env' = (tcg_env `addTcgDUs` src_dus)
203 in -- we return the deprecs in the env, not in the HsGroup above
204 tcg_env' { tcg_warns = tcg_warns tcg_env' `plusWarns` rn_warns };
207 traceRn (text "finish rnSrc" <+> ppr rn_group) ;
208 traceRn (text "finish Dus" <+> ppr src_dus ) ;
209 return (final_tcg_env , rn_group)
212 -- some utils because we do this a bunch above
213 -- compute and install the new env
214 inNewEnv :: TcM TcGblEnv -> (TcGblEnv -> TcM a) -> TcM a
215 inNewEnv env cont = do e <- env
218 rnTyClDecls :: [LTyClDecl RdrName] -> RnM [LTyClDecl Name]
219 -- Used for external core
220 rnTyClDecls tycl_decls = do (decls', _fvs) <- rnList rnTyClDecl tycl_decls
223 addTcgDUs :: TcGblEnv -> DefUses -> TcGblEnv
224 -- This function could be defined lower down in the module hierarchy,
225 -- but there doesn't seem anywhere very logical to put it.
226 addTcgDUs tcg_env dus = tcg_env { tcg_dus = tcg_dus tcg_env `plusDU` dus }
228 rnList :: (a -> RnM (b, FreeVars)) -> [Located a] -> RnM ([Located b], FreeVars)
229 rnList f xs = mapFvRn (wrapLocFstM f) xs
233 %*********************************************************
237 %*********************************************************
240 rnDocDecl :: DocDecl -> RnM DocDecl
241 rnDocDecl (DocCommentNext doc) = do
242 rn_doc <- rnHsDoc doc
243 return (DocCommentNext rn_doc)
244 rnDocDecl (DocCommentPrev doc) = do
245 rn_doc <- rnHsDoc doc
246 return (DocCommentPrev rn_doc)
247 rnDocDecl (DocCommentNamed str doc) = do
248 rn_doc <- rnHsDoc doc
249 return (DocCommentNamed str rn_doc)
250 rnDocDecl (DocGroup lev doc) = do
251 rn_doc <- rnHsDoc doc
252 return (DocGroup lev rn_doc)
256 %*********************************************************
258 Source-code fixity declarations
260 %*********************************************************
263 rnSrcFixityDecls :: NameSet -> [LFixitySig RdrName] -> RnM [LFixitySig Name]
264 -- Rename the fixity decls, so we can put
265 -- the renamed decls in the renamed syntax tree
266 -- Errors if the thing being fixed is not defined locally.
268 -- The returned FixitySigs are not actually used for anything,
269 -- except perhaps the GHCi API
270 rnSrcFixityDecls bound_names fix_decls
271 = do fix_decls <- mapM rn_decl fix_decls
272 return (concat fix_decls)
274 rn_decl :: LFixitySig RdrName -> RnM [LFixitySig Name]
275 -- GHC extension: look up both the tycon and data con
276 -- for con-like things; hence returning a list
277 -- If neither are in scope, report an error; otherwise
278 -- return a fixity sig for each (slightly odd)
279 rn_decl (L loc (FixitySig (L name_loc rdr_name) fixity))
280 = setSrcSpan name_loc $
281 -- this lookup will fail if the definition isn't local
282 do names <- lookupLocalDataTcNames bound_names what rdr_name
283 return [ L loc (FixitySig (L name_loc name) fixity)
285 what = ptext (sLit "fixity signature")
289 %*********************************************************
291 Source-code deprecations declarations
293 %*********************************************************
295 Check that the deprecated names are defined, are defined locally, and
296 that there are no duplicate deprecations.
298 It's only imported deprecations, dealt with in RnIfaces, that we
299 gather them together.
302 -- checks that the deprecations are defined locally, and that there are no duplicates
303 rnSrcWarnDecls :: NameSet -> [LWarnDecl RdrName] -> RnM Warnings
304 rnSrcWarnDecls _bound_names []
307 rnSrcWarnDecls bound_names decls
308 = do { -- check for duplicates
309 ; mapM_ (\ (L loc rdr:lrdr':_) -> addErrAt loc (dupWarnDecl lrdr' rdr))
311 ; pairs_s <- mapM (addLocM rn_deprec) decls
312 ; return (WarnSome ((concat pairs_s))) }
314 rn_deprec (Warning rdr_name txt)
315 -- ensures that the names are defined locally
316 = lookupLocalDataTcNames bound_names what rdr_name `thenM` \ names ->
317 return [(nameOccName name, txt) | name <- names]
319 what = ptext (sLit "deprecation")
321 -- look for duplicates among the OccNames;
322 -- we check that the names are defined above
323 -- invt: the lists returned by findDupsEq always have at least two elements
324 warn_rdr_dups = findDupsEq (\ x -> \ y -> rdrNameOcc (unLoc x) == rdrNameOcc (unLoc y))
325 (map (\ (L loc (Warning rdr_name _)) -> L loc rdr_name) decls)
327 dupWarnDecl :: Located RdrName -> RdrName -> SDoc
328 -- Located RdrName -> DeprecDecl RdrName -> SDoc
329 dupWarnDecl (L loc _) rdr_name
330 = vcat [ptext (sLit "Multiple warning declarations for") <+> quotes (ppr rdr_name),
331 ptext (sLit "also at ") <+> ppr loc]
335 %*********************************************************
337 \subsection{Annotation declarations}
339 %*********************************************************
342 rnAnnDecl :: AnnDecl RdrName -> RnM (AnnDecl Name, FreeVars)
343 rnAnnDecl (HsAnnotation provenance expr) = do
344 (provenance', provenance_fvs) <- rnAnnProvenance provenance
345 (expr', expr_fvs) <- rnLExpr expr
346 return (HsAnnotation provenance' expr', provenance_fvs `plusFV` expr_fvs)
348 rnAnnProvenance :: AnnProvenance RdrName -> RnM (AnnProvenance Name, FreeVars)
349 rnAnnProvenance provenance = do
350 provenance' <- modifyAnnProvenanceNameM lookupTopBndrRn provenance
351 return (provenance', maybe emptyFVs unitFV (annProvenanceName_maybe provenance'))
354 %*********************************************************
356 \subsection{Default declarations}
358 %*********************************************************
361 rnDefaultDecl :: DefaultDecl RdrName -> RnM (DefaultDecl Name, FreeVars)
362 rnDefaultDecl (DefaultDecl tys)
363 = mapFvRn (rnHsTypeFVs doc_str) tys `thenM` \ (tys', fvs) ->
364 return (DefaultDecl tys', fvs)
366 doc_str = text "In a `default' declaration"
369 %*********************************************************
371 \subsection{Foreign declarations}
373 %*********************************************************
376 rnHsForeignDecl :: ForeignDecl RdrName -> RnM (ForeignDecl Name, FreeVars)
377 rnHsForeignDecl (ForeignImport name ty spec)
378 = getTopEnv `thenM` \ (topEnv :: HscEnv) ->
379 lookupLocatedTopBndrRn name `thenM` \ name' ->
380 rnHsTypeFVs (fo_decl_msg name) ty `thenM` \ (ty', fvs) ->
382 -- Mark any PackageTarget style imports as coming from the current package
383 let packageId = thisPackage $ hsc_dflags topEnv
384 spec' = patchForeignImport packageId spec
386 in return (ForeignImport name' ty' spec', fvs)
388 rnHsForeignDecl (ForeignExport name ty spec)
389 = lookupLocatedOccRn name `thenM` \ name' ->
390 rnHsTypeFVs (fo_decl_msg name) ty `thenM` \ (ty', fvs) ->
391 return (ForeignExport name' ty' spec, fvs `addOneFV` unLoc name')
392 -- NB: a foreign export is an *occurrence site* for name, so
393 -- we add it to the free-variable list. It might, for example,
394 -- be imported from another module
396 fo_decl_msg :: Located RdrName -> SDoc
397 fo_decl_msg name = ptext (sLit "In the foreign declaration for") <+> ppr name
400 -- | For Windows DLLs we need to know what packages imported symbols are from
401 -- to generate correct calls. Imported symbols are tagged with the current
402 -- package, so if they get inlined across a package boundry we'll still
403 -- know where they're from.
405 patchForeignImport :: PackageId -> ForeignImport -> ForeignImport
406 patchForeignImport packageId (CImport cconv safety fs spec)
407 = CImport cconv safety fs (patchCImportSpec packageId spec)
409 patchCImportSpec :: PackageId -> CImportSpec -> CImportSpec
410 patchCImportSpec packageId spec
412 CFunction callTarget -> CFunction $ patchCCallTarget packageId callTarget
415 patchCCallTarget :: PackageId -> CCallTarget -> CCallTarget
416 patchCCallTarget packageId callTarget
418 StaticTarget label Nothing
419 -> StaticTarget label (Just packageId)
427 %*********************************************************
429 \subsection{Instance declarations}
431 %*********************************************************
434 rnSrcInstDecl :: InstDecl RdrName -> RnM (InstDecl Name, FreeVars)
435 rnSrcInstDecl (InstDecl inst_ty mbinds uprags ats)
436 -- Used for both source and interface file decls
437 = rnHsSigType (text "an instance decl") inst_ty `thenM` \ inst_ty' ->
439 -- Rename the bindings
440 -- The typechecker (not the renamer) checks that all
441 -- the bindings are for the right class
443 meth_names = collectMethodBinders mbinds
444 (inst_tyvars, _, cls,_) = splitHsInstDeclTy (unLoc inst_ty')
446 checkDupRdrNames meth_names `thenM_`
447 -- Check that the same method is not given twice in the
448 -- same instance decl instance C T where
452 -- We must use checkDupRdrNames because the Name of the
453 -- method is the Name of the class selector, whose SrcSpan
454 -- points to the class declaration
456 extendTyVarEnvForMethodBinds inst_tyvars (
457 -- (Slightly strangely) the forall-d tyvars scope over
458 -- the method bindings too
459 rnMethodBinds cls (\_ -> []) -- No scoped tyvars
461 ) `thenM` \ (mbinds', meth_fvs) ->
462 -- Rename the associated types
463 -- The typechecker (not the renamer) checks that all
464 -- the declarations are for the right class
466 at_names = map (head . tyClDeclNames . unLoc) ats
468 checkDupRdrNames at_names `thenM_`
469 -- See notes with checkDupRdrNames for methods, above
471 rnATInsts ats `thenM` \ (ats', at_fvs) ->
473 -- Rename the prags and signatures.
474 -- Note that the type variables are not in scope here,
475 -- so that instance Eq a => Eq (T a) where
476 -- {-# SPECIALISE instance Eq a => Eq (T [a]) #-}
479 -- But the (unqualified) method names are in scope
481 binders = collectHsBindsBinders mbinds'
482 bndr_set = mkNameSet binders
484 bindLocalNames binders
485 (renameSigs (Just bndr_set) okInstDclSig uprags) `thenM` \ uprags' ->
487 return (InstDecl inst_ty' mbinds' uprags' ats',
488 meth_fvs `plusFV` at_fvs
489 `plusFV` hsSigsFVs uprags'
490 `plusFV` extractHsTyNames inst_ty')
491 -- We return the renamed associated data type declarations so
492 -- that they can be entered into the list of type declarations
493 -- for the binding group, but we also keep a copy in the instance.
494 -- The latter is needed for well-formedness checks in the type
495 -- checker (eg, to ensure that all ATs of the instance actually
496 -- receive a declaration).
497 -- NB: Even the copies in the instance declaration carry copies of
498 -- the instance context after renaming. This is a bit
499 -- strange, but should not matter (and it would be more work
500 -- to remove the context).
503 Renaming of the associated types in instances.
506 rnATInsts :: [LTyClDecl RdrName] -> RnM ([LTyClDecl Name], FreeVars)
507 rnATInsts atDecls = rnList rnATInst atDecls
509 rnATInst tydecl@TyData {} = rnTyClDecl tydecl
510 rnATInst tydecl@TySynonym {} = rnTyClDecl tydecl
512 pprPanic "RnSource.rnATInsts: invalid AT instance"
513 (ppr (tcdName tydecl))
516 For the method bindings in class and instance decls, we extend the
517 type variable environment iff -fglasgow-exts
520 extendTyVarEnvForMethodBinds :: [LHsTyVarBndr Name]
521 -> RnM (Bag (LHsBind Name), FreeVars)
522 -> RnM (Bag (LHsBind Name), FreeVars)
523 extendTyVarEnvForMethodBinds tyvars thing_inside
524 = do { scoped_tvs <- doptM Opt_ScopedTypeVariables
526 extendTyVarEnvFVRn (map hsLTyVarName tyvars) thing_inside
531 %*********************************************************
533 \subsection{Stand-alone deriving declarations}
535 %*********************************************************
538 rnSrcDerivDecl :: DerivDecl RdrName -> RnM (DerivDecl Name, FreeVars)
539 rnSrcDerivDecl (DerivDecl ty)
540 = do { standalone_deriv_ok <- doptM Opt_StandaloneDeriving
541 ; unless standalone_deriv_ok (addErr standaloneDerivErr)
542 ; ty' <- rnLHsType (text "a deriving decl") ty
543 ; let fvs = extractHsTyNames ty'
544 ; return (DerivDecl ty', fvs) }
546 standaloneDerivErr :: SDoc
548 = hang (ptext (sLit "Illegal standalone deriving declaration"))
549 2 (ptext (sLit "Use -XStandaloneDeriving to enable this extension"))
552 %*********************************************************
556 %*********************************************************
559 rnHsRuleDecl :: RuleDecl RdrName -> RnM (RuleDecl Name, FreeVars)
560 rnHsRuleDecl (HsRule rule_name act vars lhs _fv_lhs rhs _fv_rhs)
561 = bindPatSigTyVarsFV (collectRuleBndrSigTys vars) $
562 bindLocatedLocalsFV (map get_var vars) $ \ ids ->
563 do { (vars', fv_vars) <- mapFvRn rn_var (vars `zip` ids)
564 -- NB: The binders in a rule are always Ids
565 -- We don't (yet) support type variables
567 ; (lhs', fv_lhs') <- rnLExpr lhs
568 ; (rhs', fv_rhs') <- rnLExpr rhs
570 ; checkValidRule rule_name ids lhs' fv_lhs'
572 ; return (HsRule rule_name act vars' lhs' fv_lhs' rhs' fv_rhs',
573 fv_vars `plusFV` fv_lhs' `plusFV` fv_rhs') }
575 doc = text "In the transformation rule" <+> ftext rule_name
577 get_var (RuleBndr v) = v
578 get_var (RuleBndrSig v _) = v
580 rn_var (RuleBndr (L loc _), id)
581 = return (RuleBndr (L loc id), emptyFVs)
582 rn_var (RuleBndrSig (L loc _) t, id)
583 = rnHsTypeFVs doc t `thenM` \ (t', fvs) ->
584 return (RuleBndrSig (L loc id) t', fvs)
586 badRuleVar :: FastString -> Name -> SDoc
588 = sep [ptext (sLit "Rule") <+> doubleQuotes (ftext name) <> colon,
589 ptext (sLit "Forall'd variable") <+> quotes (ppr var) <+>
590 ptext (sLit "does not appear on left hand side")]
593 Note [Rule LHS validity checking]
594 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
595 Check the shape of a transformation rule LHS. Currently we only allow
596 LHSs of the form @(f e1 .. en)@, where @f@ is not one of the
597 @forall@'d variables.
599 We used restrict the form of the 'ei' to prevent you writing rules
600 with LHSs with a complicated desugaring (and hence unlikely to match);
601 (e.g. a case expression is not allowed: too elaborate.)
603 But there are legitimate non-trivial args ei, like sections and
604 lambdas. So it seems simmpler not to check at all, and that is why
605 check_e is commented out.
608 checkValidRule :: FastString -> [Name] -> LHsExpr Name -> NameSet -> RnM ()
609 checkValidRule rule_name ids lhs' fv_lhs'
610 = do { -- Check for the form of the LHS
611 case (validRuleLhs ids lhs') of
613 Just bad -> failWithTc (badRuleLhsErr rule_name lhs' bad)
615 -- Check that LHS vars are all bound
616 ; let bad_vars = [var | var <- ids, not (var `elemNameSet` fv_lhs')]
617 ; mapM_ (addErr . badRuleVar rule_name) bad_vars }
619 validRuleLhs :: [Name] -> LHsExpr Name -> Maybe (HsExpr Name)
621 -- Just e => Not ok, and e is the offending expression
622 validRuleLhs foralls lhs
625 checkl (L _ e) = check e
627 check (OpApp e1 op _ e2) = checkl op `mplus` checkl_e e1 `mplus` checkl_e e2
628 check (HsApp e1 e2) = checkl e1 `mplus` checkl_e e2
629 check (HsVar v) | v `notElem` foralls = Nothing
630 check other = Just other -- Failure
633 checkl_e (L _ _e) = Nothing -- Was (check_e e); see Note [Rule LHS validity checking]
635 {- Commented out; see Note [Rule LHS validity checking] above
636 check_e (HsVar v) = Nothing
637 check_e (HsPar e) = checkl_e e
638 check_e (HsLit e) = Nothing
639 check_e (HsOverLit e) = Nothing
641 check_e (OpApp e1 op _ e2) = checkl_e e1 `mplus` checkl_e op `mplus` checkl_e e2
642 check_e (HsApp e1 e2) = checkl_e e1 `mplus` checkl_e e2
643 check_e (NegApp e _) = checkl_e e
644 check_e (ExplicitList _ es) = checkl_es es
645 check_e other = Just other -- Fails
647 checkl_es es = foldr (mplus . checkl_e) Nothing es
650 badRuleLhsErr :: FastString -> LHsExpr Name -> HsExpr Name -> SDoc
651 badRuleLhsErr name lhs bad_e
652 = sep [ptext (sLit "Rule") <+> ftext name <> colon,
653 nest 4 (vcat [ptext (sLit "Illegal expression:") <+> ppr bad_e,
654 ptext (sLit "in left-hand side:") <+> ppr lhs])]
656 ptext (sLit "LHS must be of form (f e1 .. en) where f is not forall'd")
660 %*********************************************************
662 \subsection{Type, class and iface sig declarations}
664 %*********************************************************
666 @rnTyDecl@ uses the `global name function' to create a new type
667 declaration in which local names have been replaced by their original
668 names, reporting any unknown names.
670 Renaming type variables is a pain. Because they now contain uniques,
671 it is necessary to pass in an association list which maps a parsed
672 tyvar to its @Name@ representation.
673 In some cases (type signatures of values),
674 it is even necessary to go over the type first
675 in order to get the set of tyvars used by it, make an assoc list,
676 and then go over it again to rename the tyvars!
677 However, we can also do some scoping checks at the same time.
680 rnTyClDecl :: TyClDecl RdrName -> RnM (TyClDecl Name, FreeVars)
681 rnTyClDecl (ForeignType {tcdLName = name, tcdExtName = ext_name})
682 = lookupLocatedTopBndrRn name `thenM` \ name' ->
683 return (ForeignType {tcdLName = name', tcdExtName = ext_name},
686 -- all flavours of type family declarations ("type family", "newtype fanily",
687 -- and "data family")
688 rnTyClDecl tydecl@TyFamily {} = rnFamily tydecl bindTyVarsFV
690 -- "data", "newtype", "data instance, and "newtype instance" declarations
691 rnTyClDecl tydecl@TyData {tcdND = new_or_data, tcdCtxt = context,
692 tcdLName = tycon, tcdTyVars = tyvars,
693 tcdTyPats = typats, tcdCons = condecls,
694 tcdKindSig = sig, tcdDerivs = derivs}
695 = do { tycon' <- if isFamInstDecl tydecl
696 then lookupLocatedOccRn tycon -- may be imported family
697 else lookupLocatedTopBndrRn tycon
698 ; checkTc (h98_style || null (unLoc context))
699 (badGadtStupidTheta tycon)
700 ; ((tyvars', context', typats', derivs'), stuff_fvs)
701 <- bindTyVarsFV tyvars $ \ tyvars' -> do
702 -- Checks for distinct tyvars
703 { context' <- rnContext data_doc context
704 ; (typats', fvs1) <- rnTyPats data_doc tycon' typats
705 ; (derivs', fvs2) <- rn_derivs derivs
706 ; let fvs = fvs1 `plusFV` fvs2 `plusFV`
707 extractHsCtxtTyNames context'
708 ; return ((tyvars', context', typats', derivs'), fvs) }
710 -- For the constructor declarations, bring into scope the tyvars
711 -- bound by the header, but *only* in the H98 case
712 -- Reason: for GADTs, the type variables in the declaration
713 -- do not scope over the constructor signatures
714 -- data T a where { T1 :: forall b. b-> b }
715 ; let tc_tvs_in_scope | h98_style = hsLTyVarNames tyvars'
717 ; (condecls', con_fvs) <- bindLocalNamesFV tc_tvs_in_scope $
719 -- No need to check for duplicate constructor decls
720 -- since that is done by RnNames.extendGlobalRdrEnvRn
722 ; return (TyData {tcdND = new_or_data, tcdCtxt = context',
723 tcdLName = tycon', tcdTyVars = tyvars',
724 tcdTyPats = typats', tcdKindSig = sig,
725 tcdCons = condecls', tcdDerivs = derivs'},
726 con_fvs `plusFV` stuff_fvs)
729 h98_style = case condecls of -- Note [Stupid theta]
730 L _ (ConDecl { con_res = ResTyGADT {} }) : _ -> False
733 data_doc = text "In the data type declaration for" <+> quotes (ppr tycon)
735 rn_derivs Nothing = return (Nothing, emptyFVs)
736 rn_derivs (Just ds) = rnLHsTypes data_doc ds `thenM` \ ds' ->
737 return (Just ds', extractHsTyNames_s ds')
739 -- "type" and "type instance" declarations
740 rnTyClDecl tydecl@(TySynonym {tcdLName = name, tcdTyVars = tyvars,
741 tcdTyPats = typats, tcdSynRhs = ty})
742 = bindTyVarsFV tyvars $ \ tyvars' -> do
743 { -- Checks for distinct tyvars
744 name' <- if isFamInstDecl tydecl
745 then lookupLocatedOccRn name -- may be imported family
746 else lookupLocatedTopBndrRn name
747 ; (typats',fvs1) <- rnTyPats syn_doc name' typats
748 ; (ty', fvs2) <- rnHsTypeFVs syn_doc ty
749 ; return (TySynonym { tcdLName = name', tcdTyVars = tyvars'
750 , tcdTyPats = typats', tcdSynRhs = ty'},
751 fvs1 `plusFV` fvs2) }
753 syn_doc = text "In the declaration for type synonym" <+> quotes (ppr name)
755 rnTyClDecl (ClassDecl {tcdCtxt = context, tcdLName = cname,
756 tcdTyVars = tyvars, tcdFDs = fds, tcdSigs = sigs,
757 tcdMeths = mbinds, tcdATs = ats, tcdDocs = docs})
758 = do { cname' <- lookupLocatedTopBndrRn cname
760 -- Tyvars scope over superclass context and method signatures
761 ; ((tyvars', context', fds', ats', sigs'), stuff_fvs)
762 <- bindTyVarsFV tyvars $ \ tyvars' -> do
763 -- Checks for distinct tyvars
764 { context' <- rnContext cls_doc context
765 ; fds' <- rnFds cls_doc fds
766 ; (ats', at_fvs) <- rnATs ats
767 ; sigs' <- renameSigs Nothing okClsDclSig sigs
768 ; let fvs = at_fvs `plusFV`
769 extractHsCtxtTyNames context' `plusFV`
771 -- The fundeps have no free variables
772 ; return ((tyvars', context', fds', ats', sigs'), fvs) }
774 -- No need to check for duplicate associated type decls
775 -- since that is done by RnNames.extendGlobalRdrEnvRn
777 -- Check the signatures
778 -- First process the class op sigs (op_sigs), then the fixity sigs (non_op_sigs).
779 ; let sig_rdr_names_w_locs = [op | L _ (TypeSig op _) <- sigs]
780 ; checkDupRdrNames sig_rdr_names_w_locs
781 -- Typechecker is responsible for checking that we only
782 -- give default-method bindings for things in this class.
783 -- The renamer *could* check this for class decls, but can't
784 -- for instance decls.
786 -- The newLocals call is tiresome: given a generic class decl
789 -- op {| x+y |} (Inl a) = ...
790 -- op {| x+y |} (Inr b) = ...
791 -- op {| a*b |} (a*b) = ...
792 -- we want to name both "x" tyvars with the same unique, so that they are
793 -- easy to group together in the typechecker.
794 ; (mbinds', meth_fvs)
795 <- extendTyVarEnvForMethodBinds tyvars' $ do
796 { name_env <- getLocalRdrEnv
797 ; let gen_rdr_tyvars_w_locs = [ tv | tv <- extractGenericPatTyVars mbinds,
798 not (unLoc tv `elemLocalRdrEnv` name_env) ]
799 -- No need to check for duplicate method signatures
800 -- since that is done by RnNames.extendGlobalRdrEnvRn
801 -- and the methods are already in scope
802 ; gen_tyvars <- newLocalBndrsRn gen_rdr_tyvars_w_locs
803 ; rnMethodBinds (unLoc cname') (mkSigTvFn sigs') gen_tyvars mbinds }
806 ; docs' <- mapM (wrapLocM rnDocDecl) docs
808 ; return (ClassDecl { tcdCtxt = context', tcdLName = cname',
809 tcdTyVars = tyvars', tcdFDs = fds', tcdSigs = sigs',
810 tcdMeths = mbinds', tcdATs = ats', tcdDocs = docs'},
811 meth_fvs `plusFV` stuff_fvs) }
813 cls_doc = text "In the declaration for class" <+> ppr cname
815 badGadtStupidTheta :: Located RdrName -> SDoc
817 = vcat [ptext (sLit "No context is allowed on a GADT-style data declaration"),
818 ptext (sLit "(You can put a context on each contructor, though.)")]
823 Trac #3850 complains about a regression wrt 6.10 for
825 There is no reason not to allow the stupid theta if there are no data
826 constructors. It's still stupid, but does no harm, and I don't want
827 to cause programs to break unnecessarily (notably HList). So if there
828 are no data constructors we allow h98_style = True
831 %*********************************************************
833 \subsection{Support code for type/data declarations}
835 %*********************************************************
838 rnTyPats :: SDoc -> Located Name -> Maybe [LHsType RdrName] -> RnM (Maybe [LHsType Name], FreeVars)
839 -- Although, we are processing type patterns here, all type variables will
840 -- already be in scope (they are the same as in the 'tcdTyVars' field of the
841 -- type declaration to which these patterns belong)
843 = return (Nothing, emptyFVs)
844 rnTyPats doc tc (Just typats)
845 = do { typats' <- rnLHsTypes doc typats
846 ; let fvs = addOneFV (extractHsTyNames_s typats') (unLoc tc)
847 -- type instance => use, hence addOneFV
848 ; return (Just typats', fvs) }
850 rnConDecls :: [LConDecl RdrName] -> RnM ([LConDecl Name], FreeVars)
852 = do { condecls' <- mapM (wrapLocM rnConDecl) condecls
853 ; return (condecls', plusFVs (map conDeclFVs condecls')) }
855 rnConDecl :: ConDecl RdrName -> RnM (ConDecl Name)
856 rnConDecl decl@(ConDecl { con_name = name, con_qvars = tvs
857 , con_cxt = cxt, con_details = details
858 , con_res = res_ty, con_doc = mb_doc
859 , con_old_rec = old_rec, con_explicit = expl })
860 = do { addLocM checkConName name
861 ; when old_rec (addWarn (deprecRecSyntax decl))
862 ; new_name <- lookupLocatedTopBndrRn name
864 -- For H98 syntax, the tvs are the existential ones
865 -- For GADT syntax, the tvs are all the quantified tyvars
866 -- Hence the 'filter' in the ResTyH98 case only
867 ; rdr_env <- getLocalRdrEnv
868 ; let in_scope = (`elemLocalRdrEnv` rdr_env) . unLoc
869 arg_tys = hsConDeclArgTys details
870 implicit_tvs = case res_ty of
871 ResTyH98 -> filterOut in_scope (get_rdr_tvs arg_tys)
872 ResTyGADT ty -> get_rdr_tvs (ty : arg_tys)
873 new_tvs = case expl of
875 Implicit -> userHsTyVarBndrs implicit_tvs
877 ; mb_doc' <- rnMbLHsDoc mb_doc
879 ; bindTyVarsRn new_tvs $ \new_tyvars -> do
880 { new_context <- rnContext doc cxt
881 ; new_details <- rnConDeclDetails doc details
882 ; (new_details', new_res_ty) <- rnConResult doc new_details res_ty
883 ; return (decl { con_name = new_name, con_qvars = new_tyvars, con_cxt = new_context
884 , con_details = new_details', con_res = new_res_ty, con_doc = mb_doc' }) }}
886 doc = text "In the definition of data constructor" <+> quotes (ppr name)
887 get_rdr_tvs tys = extractHsRhoRdrTyVars cxt (noLoc (HsTupleTy Boxed tys))
890 -> HsConDetails (LHsType Name) [ConDeclField Name]
892 -> RnM (HsConDetails (LHsType Name) [ConDeclField Name],
894 rnConResult _ details ResTyH98 = return (details, ResTyH98)
895 rnConResult doc details (ResTyGADT ty)
896 = do { ty' <- rnLHsType doc ty
897 ; let (arg_tys, res_ty) = splitHsFunType ty'
898 -- We can finally split it up,
899 -- now the renamer has dealt with fixities
900 -- See Note [Sorting out the result type] in RdrHsSyn
902 details' = case details of
904 PrefixCon {} -> PrefixCon arg_tys
905 InfixCon {} -> pprPanic "rnConResult" (ppr ty)
906 -- See Note [Sorting out the result type] in RdrHsSyn
908 ; when (not (null arg_tys) && case details of { RecCon {} -> True; _ -> False })
909 (addErr (badRecResTy doc))
910 ; return (details', ResTyGADT res_ty) }
912 rnConDeclDetails :: SDoc
913 -> HsConDetails (LHsType RdrName) [ConDeclField RdrName]
914 -> RnM (HsConDetails (LHsType Name) [ConDeclField Name])
915 rnConDeclDetails doc (PrefixCon tys)
916 = mapM (rnLHsType doc) tys `thenM` \ new_tys ->
917 return (PrefixCon new_tys)
919 rnConDeclDetails doc (InfixCon ty1 ty2)
920 = rnLHsType doc ty1 `thenM` \ new_ty1 ->
921 rnLHsType doc ty2 `thenM` \ new_ty2 ->
922 return (InfixCon new_ty1 new_ty2)
924 rnConDeclDetails doc (RecCon fields)
925 = do { new_fields <- rnConDeclFields doc fields
926 -- No need to check for duplicate fields
927 -- since that is done by RnNames.extendGlobalRdrEnvRn
928 ; return (RecCon new_fields) }
930 -- Rename family declarations
932 -- * This function is parametrised by the routine handling the index
933 -- variables. On the toplevel, these are defining occurences, whereas they
934 -- are usage occurences for associated types.
936 rnFamily :: TyClDecl RdrName
937 -> ([LHsTyVarBndr RdrName] ->
938 ([LHsTyVarBndr Name] -> RnM (TyClDecl Name, FreeVars)) ->
939 RnM (TyClDecl Name, FreeVars))
940 -> RnM (TyClDecl Name, FreeVars)
942 rnFamily (tydecl@TyFamily {tcdFlavour = flavour,
943 tcdLName = tycon, tcdTyVars = tyvars})
945 do { bindIdxVars tyvars $ \tyvars' -> do {
946 ; tycon' <- lookupLocatedTopBndrRn tycon
947 ; return (TyFamily {tcdFlavour = flavour, tcdLName = tycon',
948 tcdTyVars = tyvars', tcdKind = tcdKind tydecl},
951 rnFamily d _ = pprPanic "rnFamily" (ppr d)
953 -- Rename associated type declarations (in classes)
955 -- * This can be family declarations and (default) type instances
957 rnATs :: [LTyClDecl RdrName] -> RnM ([LTyClDecl Name], FreeVars)
958 rnATs ats = mapFvRn (wrapLocFstM rn_at) ats
960 rn_at (tydecl@TyFamily {}) = rnFamily tydecl lookupIdxVars
961 rn_at (tydecl@TySynonym {}) =
963 unless (isNothing (tcdTyPats tydecl)) $ addErr noPatterns
965 rn_at _ = panic "RnSource.rnATs: invalid TyClDecl"
967 lookupIdxVars tyvars cont =
968 do { checkForDups tyvars
969 ; tyvars' <- mapM lookupIdxVar tyvars
972 -- Type index variables must be class parameters, which are the only
973 -- type variables in scope at this point.
974 lookupIdxVar (L l tyvar) =
976 name' <- lookupOccRn (hsTyVarName tyvar)
977 return $ L l (replaceTyVarName tyvar name')
979 -- Type variable may only occur once.
981 checkForDups [] = return ()
982 checkForDups (L loc tv:ltvs) =
983 do { setSrcSpan loc $
984 when (hsTyVarName tv `ltvElem` ltvs) $
985 addErr (repeatedTyVar tv)
989 _ `ltvElem` [] = False
990 rdrName `ltvElem` (L _ tv:ltvs)
991 | rdrName == hsTyVarName tv = True
992 | otherwise = rdrName `ltvElem` ltvs
994 deprecRecSyntax :: ConDecl RdrName -> SDoc
996 = vcat [ ptext (sLit "Declaration of") <+> quotes (ppr (con_name decl))
997 <+> ptext (sLit "uses deprecated syntax")
998 , ptext (sLit "Instead, use the form")
999 , nest 2 (ppr decl) ] -- Pretty printer uses new form
1001 badRecResTy :: SDoc -> SDoc
1002 badRecResTy doc = ptext (sLit "Malformed constructor signature") $$ doc
1005 noPatterns = text "Default definition for an associated synonym cannot have"
1006 <+> text "type pattern"
1008 repeatedTyVar :: HsTyVarBndr RdrName -> SDoc
1009 repeatedTyVar tv = ptext (sLit "Illegal repeated type variable") <+>
1012 -- This data decl will parse OK
1014 -- treating "a" as the constructor.
1015 -- It is really hard to make the parser spot this malformation.
1016 -- So the renamer has to check that the constructor is legal
1018 -- We can get an operator as the constructor, even in the prefix form:
1019 -- data T = :% Int Int
1020 -- from interface files, which always print in prefix form
1022 checkConName :: RdrName -> TcRn ()
1023 checkConName name = checkErr (isRdrDataCon name) (badDataCon name)
1025 badDataCon :: RdrName -> SDoc
1027 = hsep [ptext (sLit "Illegal data constructor name"), quotes (ppr name)]
1031 %*********************************************************
1033 \subsection{Support code for type/data declarations}
1035 %*********************************************************
1037 Get the mapping from constructors to fields for this module.
1038 It's convenient to do this after the data type decls have been renamed
1040 extendRecordFieldEnv :: [LTyClDecl RdrName] -> [LInstDecl RdrName] -> TcM TcGblEnv
1041 extendRecordFieldEnv tycl_decls inst_decls
1042 = do { tcg_env <- getGblEnv
1043 ; field_env' <- foldrM get_con (tcg_field_env tcg_env) all_data_cons
1044 ; return (tcg_env { tcg_field_env = field_env' }) }
1046 -- we want to lookup:
1047 -- (a) a datatype constructor
1048 -- (b) a record field
1049 -- knowing that they're from this module.
1050 -- lookupLocatedTopBndrRn does this, because it does a lookupGreLocalRn,
1051 -- which keeps only the local ones.
1052 lookup x = do { x' <- lookupLocatedTopBndrRn x
1053 ; return $ unLoc x'}
1055 all_data_cons :: [ConDecl RdrName]
1056 all_data_cons = [con | L _ (TyData { tcdCons = cons }) <- all_tycl_decls
1058 all_tycl_decls = at_tycl_decls ++ tycl_decls
1059 at_tycl_decls = [at | L _ (InstDecl _ _ _ ats) <- inst_decls, at <- ats]
1060 -- Do not forget associated types!
1062 get_con (ConDecl { con_name = con, con_details = RecCon flds })
1063 (RecFields env fld_set)
1064 = do { con' <- lookup con
1065 ; flds' <- mapM lookup (map cd_fld_name flds)
1066 ; let env' = extendNameEnv env con' flds'
1067 fld_set' = addListToNameSet fld_set flds'
1068 ; return $ (RecFields env' fld_set') }
1069 get_con _ env = return env
1072 %*********************************************************
1074 \subsection{Support code to rename types}
1076 %*********************************************************
1079 rnFds :: SDoc -> [Located (FunDep RdrName)] -> RnM [Located (FunDep Name)]
1082 = mapM (wrapLocM rn_fds) fds
1085 = rnHsTyVars doc tys1 `thenM` \ tys1' ->
1086 rnHsTyVars doc tys2 `thenM` \ tys2' ->
1087 return (tys1', tys2')
1089 rnHsTyVars :: SDoc -> [RdrName] -> RnM [Name]
1090 rnHsTyVars doc tvs = mapM (rnHsTyVar doc) tvs
1092 rnHsTyVar :: SDoc -> RdrName -> RnM Name
1093 rnHsTyVar _doc tyvar = lookupOccRn tyvar
1097 %*********************************************************
1101 %*********************************************************
1103 This code marches down the declarations, looking for the first
1104 Template Haskell splice. As it does so it
1105 a) groups the declarations into a HsGroup
1106 b) runs any top-level quasi-quotes
1109 findSplice :: [LHsDecl RdrName] -> RnM (HsGroup RdrName, Maybe (SpliceDecl RdrName, [LHsDecl RdrName]))
1110 findSplice ds = addl emptyRdrGroup ds
1112 addl :: HsGroup RdrName -> [LHsDecl RdrName]
1113 -> RnM (HsGroup RdrName, Maybe (SpliceDecl RdrName, [LHsDecl RdrName]))
1114 -- This stuff reverses the declarations (again) but it doesn't matter
1115 addl gp [] = return (gp, Nothing)
1116 addl gp (L l d : ds) = add gp l d ds
1119 add :: HsGroup RdrName -> SrcSpan -> HsDecl RdrName -> [LHsDecl RdrName]
1120 -> RnM (HsGroup RdrName, Maybe (SpliceDecl RdrName, [LHsDecl RdrName]))
1122 add gp _ (SpliceD e) ds = return (gp, Just (e, ds))
1125 add _ _ (QuasiQuoteD qq) _
1126 = pprPanic "Can't do QuasiQuote declarations without GHCi" (ppr qq)
1128 add gp _ (QuasiQuoteD qq) ds -- Expand quasiquotes
1129 = do { ds' <- runQuasiQuoteDecl qq
1130 ; addl gp (ds' ++ ds) }
1133 -- Class declarations: pull out the fixity signatures to the top
1134 add gp@(HsGroup {hs_tyclds = ts, hs_fixds = fs}) l (TyClD d) ds
1136 = let fsigs = [ L l f | L l (FixSig f) <- tcdSigs d ] in
1137 addl (gp { hs_tyclds = L l d : ts, hs_fixds = fsigs ++ fs}) ds
1139 = addl (gp { hs_tyclds = L l d : ts }) ds
1141 -- Signatures: fixity sigs go a different place than all others
1142 add gp@(HsGroup {hs_fixds = ts}) l (SigD (FixSig f)) ds
1143 = addl (gp {hs_fixds = L l f : ts}) ds
1144 add gp@(HsGroup {hs_valds = ts}) l (SigD d) ds
1145 = addl (gp {hs_valds = add_sig (L l d) ts}) ds
1147 -- Value declarations: use add_bind
1148 add gp@(HsGroup {hs_valds = ts}) l (ValD d) ds
1149 = addl (gp { hs_valds = add_bind (L l d) ts }) ds
1151 -- The rest are routine
1152 add gp@(HsGroup {hs_instds = ts}) l (InstD d) ds
1153 = addl (gp { hs_instds = L l d : ts }) ds
1154 add gp@(HsGroup {hs_derivds = ts}) l (DerivD d) ds
1155 = addl (gp { hs_derivds = L l d : ts }) ds
1156 add gp@(HsGroup {hs_defds = ts}) l (DefD d) ds
1157 = addl (gp { hs_defds = L l d : ts }) ds
1158 add gp@(HsGroup {hs_fords = ts}) l (ForD d) ds
1159 = addl (gp { hs_fords = L l d : ts }) ds
1160 add gp@(HsGroup {hs_warnds = ts}) l (WarningD d) ds
1161 = addl (gp { hs_warnds = L l d : ts }) ds
1162 add gp@(HsGroup {hs_annds = ts}) l (AnnD d) ds
1163 = addl (gp { hs_annds = L l d : ts }) ds
1164 add gp@(HsGroup {hs_ruleds = ts}) l (RuleD d) ds
1165 = addl (gp { hs_ruleds = L l d : ts }) ds
1166 add gp l (DocD d) ds
1167 = addl (gp { hs_docs = (L l d) : (hs_docs gp) }) ds
1169 add_bind :: LHsBind a -> HsValBinds a -> HsValBinds a
1170 add_bind b (ValBindsIn bs sigs) = ValBindsIn (bs `snocBag` b) sigs
1171 add_bind _ (ValBindsOut {}) = panic "RdrHsSyn:add_bind"
1173 add_sig :: LSig a -> HsValBinds a -> HsValBinds a
1174 add_sig s (ValBindsIn bs sigs) = ValBindsIn bs (s:sigs)
1175 add_sig _ (ValBindsOut {}) = panic "RdrHsSyn:add_sig"