8d74c8eecd1debeb2c6c40d88927a25968d04ae3
[ghc.git] / compiler / rename / RnBinds.lhs
1 %
2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
3 %
4 \section[RnBinds]{Renaming and dependency analysis of bindings}
5
6 This module does renaming and dependency analysis on value bindings in
7 the abstract syntax.  It does {\em not} do cycle-checks on class or
8 type-synonym declarations; those cannot be done at this stage because
9 they may be affected by renaming (which isn't fully worked out yet).
10
11 \begin{code}
12 {-# LANGUAGE CPP #-}
13
14 module RnBinds (
15    -- Renaming top-level bindings
16    rnTopBindsLHS, rnTopBindsRHS, rnValBindsRHS,
17
18    -- Renaming local bindings
19    rnLocalBindsAndThen, rnLocalValBindsLHS, rnLocalValBindsRHS,
20
21    -- Other bindings
22    rnMethodBinds, renameSigs, mkSigTvFn,
23    rnMatchGroup, rnGRHSs, rnGRHS,
24    makeMiniFixityEnv, MiniFixityEnv,
25    HsSigCtxt(..)
26    ) where
27
28 import {-# SOURCE #-} RnExpr( rnLExpr, rnStmts )
29
30 import HsSyn
31 import TcRnMonad
32 import TcEvidence     ( emptyTcEvBinds )
33 import RnTypes
34 import RnPat
35 import RnNames
36 import RnEnv
37 import DynFlags
38 import Module
39 import Name
40 import NameEnv
41 import NameSet
42 import RdrName          ( RdrName, rdrNameOcc )
43 import SrcLoc
44 import ListSetOps       ( findDupsEq )
45 import BasicTypes       ( RecFlag(..) )
46 import Digraph          ( SCC(..) )
47 import Bag
48 import Outputable
49 import FastString
50 import Data.List        ( partition, sort )
51 import Maybes           ( orElse )
52 import Control.Monad
53 #if __GLASGOW_HASKELL__ < 709
54 import Data.Traversable ( traverse )
55 #endif
56 \end{code}
57
58 -- ToDo: Put the annotations into the monad, so that they arrive in the proper
59 -- place and can be used when complaining.
60
61 The code tree received by the function @rnBinds@ contains definitions
62 in where-clauses which are all apparently mutually recursive, but which may
63 not really depend upon each other. For example, in the top level program
64 \begin{verbatim}
65 f x = y where a = x
66               y = x
67 \end{verbatim}
68 the definitions of @a@ and @y@ do not depend on each other at all.
69 Unfortunately, the typechecker cannot always check such definitions.
70 \footnote{Mycroft, A. 1984. Polymorphic type schemes and recursive
71 definitions. In Proceedings of the International Symposium on Programming,
72 Toulouse, pp. 217-39. LNCS 167. Springer Verlag.}
73 However, the typechecker usually can check definitions in which only the
74 strongly connected components have been collected into recursive bindings.
75 This is precisely what the function @rnBinds@ does.
76
77 ToDo: deal with case where a single monobinds binds the same variable
78 twice.
79
80 The vertag tag is a unique @Int@; the tags only need to be unique
81 within one @MonoBinds@, so that unique-Int plumbing is done explicitly
82 (heavy monad machinery not needed).
83
84
85 %************************************************************************
86 %*                                                                      *
87 %* naming conventions                                                   *
88 %*                                                                      *
89 %************************************************************************
90
91 \subsection[name-conventions]{Name conventions}
92
93 The basic algorithm involves walking over the tree and returning a tuple
94 containing the new tree plus its free variables. Some functions, such
95 as those walking polymorphic bindings (HsBinds) and qualifier lists in
96 list comprehensions (@Quals@), return the variables bound in local
97 environments. These are then used to calculate the free variables of the
98 expression evaluated in these environments.
99
100 Conventions for variable names are as follows:
101 \begin{itemize}
102 \item
103 new code is given a prime to distinguish it from the old.
104
105 \item
106 a set of variables defined in @Exp@ is written @dvExp@
107
108 \item
109 a set of variables free in @Exp@ is written @fvExp@
110 \end{itemize}
111
112 %************************************************************************
113 %*                                                                      *
114 %* analysing polymorphic bindings (HsBindGroup, HsBind)
115 %*                                                                      *
116 %************************************************************************
117
118 \subsubsection[dep-HsBinds]{Polymorphic bindings}
119
120 Non-recursive expressions are reconstructed without any changes at top
121 level, although their component expressions may have to be altered.
122 However, non-recursive expressions are currently not expected as
123 \Haskell{} programs, and this code should not be executed.
124
125 Monomorphic bindings contain information that is returned in a tuple
126 (a @FlatMonoBinds@) containing:
127
128 \begin{enumerate}
129 \item
130 a unique @Int@ that serves as the ``vertex tag'' for this binding.
131
132 \item
133 the name of a function or the names in a pattern. These are a set
134 referred to as @dvLhs@, the defined variables of the left hand side.
135
136 \item
137 the free variables of the body. These are referred to as @fvBody@.
138
139 \item
140 the definition's actual code. This is referred to as just @code@.
141 \end{enumerate}
142
143 The function @nonRecDvFv@ returns two sets of variables. The first is
144 the set of variables defined in the set of monomorphic bindings, while the
145 second is the set of free variables in those bindings.
146
147 The set of variables defined in a non-recursive binding is just the
148 union of all of them, as @union@ removes duplicates. However, the
149 free variables in each successive set of cumulative bindings is the
150 union of those in the previous set plus those of the newest binding after
151 the defined variables of the previous set have been removed.
152
153 @rnMethodBinds@ deals only with the declarations in class and
154 instance declarations.  It expects only to see @FunMonoBind@s, and
155 it expects the global environment to contain bindings for the binders
156 (which are all class operations).
157
158 %************************************************************************
159 %*                                                                      *
160 \subsubsection{ Top-level bindings}
161 %*                                                                      *
162 %************************************************************************
163
164 \begin{code}
165 -- for top-level bindings, we need to make top-level names,
166 -- so we have a different entry point than for local bindings
167 rnTopBindsLHS :: MiniFixityEnv
168               -> HsValBinds RdrName
169               -> RnM (HsValBindsLR Name RdrName)
170 rnTopBindsLHS fix_env binds
171   = rnValBindsLHS (topRecNameMaker fix_env) binds
172
173 rnTopBindsRHS :: NameSet -> HsValBindsLR Name RdrName
174               -> RnM (HsValBinds Name, DefUses)
175 rnTopBindsRHS bound_names binds
176   = do { is_boot <- tcIsHsBootOrSig
177        ; if is_boot
178          then rnTopBindsBoot binds
179          else rnValBindsRHS (TopSigCtxt bound_names False) binds }
180
181 rnTopBindsBoot :: HsValBindsLR Name RdrName -> RnM (HsValBinds Name, DefUses)
182 -- A hs-boot file has no bindings.
183 -- Return a single HsBindGroup with empty binds and renamed signatures
184 rnTopBindsBoot (ValBindsIn mbinds sigs)
185   = do  { checkErr (isEmptyLHsBinds mbinds) (bindsInHsBootFile mbinds)
186         ; (sigs', fvs) <- renameSigs HsBootCtxt sigs
187         ; return (ValBindsOut [] sigs', usesOnly fvs) }
188 rnTopBindsBoot b = pprPanic "rnTopBindsBoot" (ppr b)
189 \end{code}
190
191
192 %*********************************************************
193 %*                                                      *
194                 HsLocalBinds
195 %*                                                      *
196 %*********************************************************
197
198 \begin{code}
199 rnLocalBindsAndThen :: HsLocalBinds RdrName
200                     -> (HsLocalBinds Name -> RnM (result, FreeVars))
201                     -> RnM (result, FreeVars)
202 -- This version (a) assumes that the binding vars are *not* already in scope
203 --               (b) removes the binders from the free vars of the thing inside
204 -- The parser doesn't produce ThenBinds
205 rnLocalBindsAndThen EmptyLocalBinds thing_inside
206   = thing_inside EmptyLocalBinds
207
208 rnLocalBindsAndThen (HsValBinds val_binds) thing_inside
209   = rnLocalValBindsAndThen val_binds $ \ val_binds' ->
210       thing_inside (HsValBinds val_binds')
211
212 rnLocalBindsAndThen (HsIPBinds binds) thing_inside = do
213     (binds',fv_binds) <- rnIPBinds binds
214     (thing, fvs_thing) <- thing_inside (HsIPBinds binds')
215     return (thing, fvs_thing `plusFV` fv_binds)
216
217 rnIPBinds :: HsIPBinds RdrName -> RnM (HsIPBinds Name, FreeVars)
218 rnIPBinds (IPBinds ip_binds _no_dict_binds) = do
219     (ip_binds', fvs_s) <- mapAndUnzipM (wrapLocFstM rnIPBind) ip_binds
220     return (IPBinds ip_binds' emptyTcEvBinds, plusFVs fvs_s)
221
222 rnIPBind :: IPBind RdrName -> RnM (IPBind Name, FreeVars)
223 rnIPBind (IPBind ~(Left n) expr) = do
224     (expr',fvExpr) <- rnLExpr expr
225     return (IPBind (Left n) expr', fvExpr)
226 \end{code}
227
228
229 %************************************************************************
230 %*                                                                      *
231                 ValBinds
232 %*                                                                      *
233 %************************************************************************
234
235 \begin{code}
236 -- Renaming local binding groups
237 -- Does duplicate/shadow check
238 rnLocalValBindsLHS :: MiniFixityEnv
239                    -> HsValBinds RdrName
240                    -> RnM ([Name], HsValBindsLR Name RdrName)
241 rnLocalValBindsLHS fix_env binds
242   = do { binds' <- rnValBindsLHS (localRecNameMaker fix_env) binds
243
244          -- Check for duplicates and shadowing
245          -- Must do this *after* renaming the patterns
246          -- See Note [Collect binders only after renaming] in HsUtils
247
248          -- We need to check for dups here because we
249          -- don't don't bind all of the variables from the ValBinds at once
250          -- with bindLocatedLocals any more.
251          --
252          -- Note that we don't want to do this at the top level, since
253          -- sorting out duplicates and shadowing there happens elsewhere.
254          -- The behavior is even different. For example,
255          --   import A(f)
256          --   f = ...
257          -- should not produce a shadowing warning (but it will produce
258          -- an ambiguity warning if you use f), but
259          --   import A(f)
260          --   g = let f = ... in f
261          -- should.
262        ; let bound_names = collectHsValBinders binds'
263        ; envs <- getRdrEnvs
264        ; checkDupAndShadowedNames envs bound_names
265
266        ; return (bound_names, binds') }
267
268 -- renames the left-hand sides
269 -- generic version used both at the top level and for local binds
270 -- does some error checking, but not what gets done elsewhere at the top level
271 rnValBindsLHS :: NameMaker
272               -> HsValBinds RdrName
273               -> RnM (HsValBindsLR Name RdrName)
274 rnValBindsLHS topP (ValBindsIn mbinds sigs)
275   = do { mbinds' <- mapBagM (wrapLocM (rnBindLHS topP doc)) mbinds
276        ; return $ ValBindsIn mbinds' sigs }
277   where
278     bndrs = collectHsBindsBinders mbinds
279     doc   = text "In the binding group for:" <+> pprWithCommas ppr bndrs
280
281 rnValBindsLHS _ b = pprPanic "rnValBindsLHSFromDoc" (ppr b)
282
283 -- General version used both from the top-level and for local things
284 -- Assumes the LHS vars are in scope
285 --
286 -- Does not bind the local fixity declarations
287 rnValBindsRHS :: HsSigCtxt
288               -> HsValBindsLR Name RdrName
289               -> RnM (HsValBinds Name, DefUses)
290
291 rnValBindsRHS ctxt (ValBindsIn mbinds sigs)
292   = do { (sigs', sig_fvs) <- renameSigs ctxt sigs
293        ; binds_w_dus <- mapBagM (rnLBind (mkSigTvFn sigs')) mbinds
294        ; case depAnalBinds binds_w_dus of
295            (anal_binds, anal_dus) -> return (valbind', valbind'_dus)
296               where
297                 valbind' = ValBindsOut anal_binds sigs'
298                 valbind'_dus = anal_dus `plusDU` usesOnly sig_fvs
299                                -- Put the sig uses *after* the bindings
300                                -- so that the binders are removed from
301                                -- the uses in the sigs
302        }
303
304 rnValBindsRHS _ b = pprPanic "rnValBindsRHS" (ppr b)
305
306 -- Wrapper for local binds
307 --
308 -- The *client* of this function is responsible for checking for unused binders;
309 -- it doesn't (and can't: we don't have the thing inside the binds) happen here
310 --
311 -- The client is also responsible for bringing the fixities into scope
312 rnLocalValBindsRHS :: NameSet  -- names bound by the LHSes
313                    -> HsValBindsLR Name RdrName
314                    -> RnM (HsValBinds Name, DefUses)
315 rnLocalValBindsRHS bound_names binds
316   = rnValBindsRHS (LocalBindCtxt bound_names) binds
317
318 -- for local binds
319 -- wrapper that does both the left- and right-hand sides
320 --
321 -- here there are no local fixity decls passed in;
322 -- the local fixity decls come from the ValBinds sigs
323 rnLocalValBindsAndThen :: HsValBinds RdrName
324                        -> (HsValBinds Name -> RnM (result, FreeVars))
325                        -> RnM (result, FreeVars)
326 rnLocalValBindsAndThen binds@(ValBindsIn _ sigs) thing_inside
327  = do   {     -- (A) Create the local fixity environment
328           new_fixities <- makeMiniFixityEnv [L loc sig
329                                                   | L loc (FixSig sig) <- sigs]
330
331               -- (B) Rename the LHSes
332         ; (bound_names, new_lhs) <- rnLocalValBindsLHS new_fixities binds
333
334               --     ...and bring them (and their fixities) into scope
335         ; bindLocalNamesFV bound_names              $
336           addLocalFixities new_fixities bound_names $ do
337
338         {      -- (C) Do the RHS and thing inside
339           (binds', dus) <- rnLocalValBindsRHS (mkNameSet bound_names) new_lhs
340         ; (result, result_fvs) <- thing_inside binds'
341
342                 -- Report unused bindings based on the (accurate)
343                 -- findUses.  E.g.
344                 --      let x = x in 3
345                 -- should report 'x' unused
346         ; let real_uses = findUses dus result_fvs
347               -- Insert fake uses for variables introduced implicitly by
348               -- wildcards (#4404)
349               implicit_uses = hsValBindsImplicits binds'
350         ; warnUnusedLocalBinds bound_names
351                                       (real_uses `unionNameSet` implicit_uses)
352
353         ; let
354             -- The variables "used" in the val binds are:
355             --   (1) the uses of the binds (allUses)
356             --   (2) the FVs of the thing-inside
357             all_uses = allUses dus `plusFV` result_fvs
358                 -- Note [Unused binding hack]
359                 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~
360                 -- Note that *in contrast* to the above reporting of
361                 -- unused bindings, (1) above uses duUses to return *all*
362                 -- the uses, even if the binding is unused.  Otherwise consider:
363                 --      x = 3
364                 --      y = let p = x in 'x'    -- NB: p not used
365                 -- If we don't "see" the dependency of 'y' on 'x', we may put the
366                 -- bindings in the wrong order, and the type checker will complain
367                 -- that x isn't in scope
368                 --
369                 -- But note that this means we won't report 'x' as unused,
370                 -- whereas we would if we had { x = 3; p = x; y = 'x' }
371
372         ; return (result, all_uses) }}
373                 -- The bound names are pruned out of all_uses
374                 -- by the bindLocalNamesFV call above
375
376 rnLocalValBindsAndThen bs _ = pprPanic "rnLocalValBindsAndThen" (ppr bs)
377
378
379 -- Process the fixity declarations, making a FastString -> (Located Fixity) map
380 -- (We keep the location around for reporting duplicate fixity declarations.)
381 --
382 -- Checks for duplicates, but not that only locally defined things are fixed.
383 -- Note: for local fixity declarations, duplicates would also be checked in
384 --       check_sigs below.  But we also use this function at the top level.
385
386 makeMiniFixityEnv :: [LFixitySig RdrName] -> RnM MiniFixityEnv
387
388 makeMiniFixityEnv decls = foldlM add_one_sig emptyFsEnv decls
389  where
390    add_one_sig env (L loc (FixitySig names fixity)) =
391      foldlM add_one env [ (loc,name_loc,name,fixity)
392                         | L name_loc name <- names ]
393
394    add_one env (loc, name_loc, name,fixity) = do
395      { -- this fixity decl is a duplicate iff
396        -- the ReaderName's OccName's FastString is already in the env
397        -- (we only need to check the local fix_env because
398        --  definitions of non-local will be caught elsewhere)
399        let { fs = occNameFS (rdrNameOcc name)
400            ; fix_item = L loc fixity };
401
402        case lookupFsEnv env fs of
403          Nothing -> return $ extendFsEnv env fs fix_item
404          Just (L loc' _) -> do
405            { setSrcSpan loc $
406              addErrAt name_loc (dupFixityDecl loc' name)
407            ; return env}
408      }
409
410 dupFixityDecl :: SrcSpan -> RdrName -> SDoc
411 dupFixityDecl loc rdr_name
412   = vcat [ptext (sLit "Multiple fixity declarations for") <+> quotes (ppr rdr_name),
413           ptext (sLit "also at ") <+> ppr loc]
414
415 ---------------------
416
417 -- renaming a single bind
418
419 rnBindLHS :: NameMaker
420           -> SDoc
421           -> HsBind RdrName
422           -- returns the renamed left-hand side,
423           -- and the FreeVars *of the LHS*
424           -- (i.e., any free variables of the pattern)
425           -> RnM (HsBindLR Name RdrName)
426
427 rnBindLHS name_maker _ bind@(PatBind { pat_lhs = pat })
428   = do
429       -- we don't actually use the FV processing of rnPatsAndThen here
430       (pat',pat'_fvs) <- rnBindPat name_maker pat
431       return (bind { pat_lhs = pat', bind_fvs = pat'_fvs })
432                 -- We temporarily store the pat's FVs in bind_fvs;
433                 -- gets updated to the FVs of the whole bind
434                 -- when doing the RHS below
435
436 rnBindLHS name_maker _ bind@(FunBind { fun_id = name@(L nameLoc _) })
437   = do { newname <- applyNameMaker name_maker name
438        ; return (bind { fun_id = L nameLoc newname
439                       , bind_fvs = placeHolderNamesTc }) }
440
441 rnBindLHS name_maker _ (PatSynBind psb@PSB{ psb_id = rdrname@(L nameLoc _) })
442   = do { unless (isTopRecNameMaker name_maker) $
443            addErr localPatternSynonymErr
444        ; addLocM checkConName rdrname
445        ; name <- applyNameMaker name_maker rdrname
446        ; return (PatSynBind psb{ psb_id = L nameLoc name }) }
447   where
448     localPatternSynonymErr :: SDoc
449     localPatternSynonymErr
450       = hang (ptext (sLit "Illegal pattern synonym declaration"))
451            2 (ptext (sLit "Pattern synonym declarations are only valid in the top-level scope"))
452
453 rnBindLHS _ _ b = pprPanic "rnBindHS" (ppr b)
454
455 rnLBind :: (Name -> [Name])             -- Signature tyvar function
456         -> LHsBindLR Name RdrName
457         -> RnM (LHsBind Name, [Name], Uses)
458 rnLBind sig_fn (L loc bind)
459   = setSrcSpan loc $
460     do { (bind', bndrs, dus) <- rnBind sig_fn bind
461        ; return (L loc bind', bndrs, dus) }
462
463 -- assumes the left-hands-side vars are in scope
464 rnBind :: (Name -> [Name])              -- Signature tyvar function
465        -> HsBindLR Name RdrName
466        -> RnM (HsBind Name, [Name], Uses)
467 rnBind _ bind@(PatBind { pat_lhs = pat
468                        , pat_rhs = grhss
469                                    -- pat fvs were stored in bind_fvs
470                                    -- after processing the LHS
471                        , bind_fvs = pat_fvs })
472   = do  { mod <- getModule
473         ; (grhss', rhs_fvs) <- rnGRHSs PatBindRhs rnLExpr grhss
474
475                 -- No scoped type variables for pattern bindings
476         ; let all_fvs = pat_fvs `plusFV` rhs_fvs
477               fvs'    = filterNameSet (nameIsLocalOrFrom mod) all_fvs
478                 -- Keep locally-defined Names
479                 -- As well as dependency analysis, we need these for the
480                 -- MonoLocalBinds test in TcBinds.decideGeneralisationPlan
481               bndrs = collectPatBinders pat
482               bind' = bind { pat_rhs  = grhss',
483                              pat_rhs_ty = placeHolderType, bind_fvs = fvs' }
484               is_wild_pat = case pat of
485                               L _ (WildPat {})                 -> True
486                               L _ (BangPat (L _ (WildPat {}))) -> True -- #9127
487                               _                                -> False
488
489         -- Warn if the pattern binds no variables, except for the
490         -- entirely-explicit idiom    _ = rhs
491         -- which (a) is not that different from  _v = rhs
492         --       (b) is sometimes used to give a type sig for,
493         --           or an occurrence of, a variable on the RHS
494         ; whenWOptM Opt_WarnUnusedBinds $
495           when (null bndrs && not is_wild_pat) $
496           addWarn $ unusedPatBindWarn bind'
497
498         ; fvs' `seq` -- See Note [Free-variable space leak]
499           return (bind', bndrs, all_fvs) }
500
501 rnBind sig_fn bind@(FunBind { fun_id = name
502                             , fun_infix = is_infix
503                             , fun_matches = matches })
504        -- invariant: no free vars here when it's a FunBind
505   = do  { let plain_name = unLoc name
506
507         ; (matches', rhs_fvs) <- bindSigTyVarsFV (sig_fn plain_name) $
508                                 -- bindSigTyVars tests for Opt_ScopedTyVars
509                                  rnMatchGroup (FunRhs plain_name is_infix)
510                                               rnLExpr matches
511         ; when is_infix $ checkPrecMatch plain_name matches'
512
513         ; mod <- getModule
514         ; let fvs' = filterNameSet (nameIsLocalOrFrom mod) rhs_fvs
515                 -- Keep locally-defined Names
516                 -- As well as dependency analysis, we need these for the
517                 -- MonoLocalBinds test in TcBinds.decideGeneralisationPlan
518
519         ; fvs' `seq` -- See Note [Free-variable space leak]
520           return (bind { fun_matches = matches'
521                        , bind_fvs   = fvs' },
522                   [plain_name], rhs_fvs)
523       }
524
525 rnBind sig_fn (PatSynBind bind)
526   = do  { (bind', name, fvs) <- rnPatSynBind sig_fn bind
527         ; return (PatSynBind bind', name, fvs) }
528
529 rnBind _ b = pprPanic "rnBind" (ppr b)
530
531 {-
532 Note [Free-variable space leak]
533 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
534 We have
535     fvs' = trim fvs
536 and we seq fvs' before turning it as part of a record.
537
538 The reason is that trim is sometimes something like
539     \xs -> intersectNameSet (mkNameSet bound_names) xs
540 and we don't want to retain the list bound_names. This showed up in
541 trac ticket #1136.
542 -}
543
544 rnPatSynBind :: (Name -> [Name])                -- Signature tyvar function
545              -> PatSynBind Name RdrName
546              -> RnM (PatSynBind Name Name, [Name], Uses)
547 rnPatSynBind _sig_fn bind@(PSB { psb_id = L _ name
548                                , psb_args = details
549                                , psb_def = pat
550                                , psb_dir = dir })
551        -- invariant: no free vars here when it's a FunBind
552   = do  { pattern_synonym_ok <- xoptM Opt_PatternSynonyms
553         ; unless pattern_synonym_ok (addErr patternSynonymErr)
554
555         ; ((pat', details'), fvs1) <- rnPat PatSyn pat $ \pat' -> do
556          -- We check the 'RdrName's instead of the 'Name's
557          -- so that the binding locations are reported
558          -- from the left-hand side
559         { (details', fvs) <- case details of
560                PrefixPatSyn vars ->
561                    do { checkDupRdrNames vars
562                       ; names <- mapM lookupVar vars
563                       ; return (PrefixPatSyn names, mkFVs (map unLoc names)) }
564                InfixPatSyn var1 var2 ->
565                    do { checkDupRdrNames [var1, var2]
566                       ; name1 <- lookupVar var1
567                       ; name2 <- lookupVar var2
568                       -- ; checkPrecMatch -- TODO
569                       ; return (InfixPatSyn name1 name2, mkFVs (map unLoc [name1, name2])) }
570         ; return ((pat', details'), fvs) }
571         ; (dir', fvs2) <- case dir of
572             Unidirectional -> return (Unidirectional, emptyFVs)
573             ImplicitBidirectional -> return (ImplicitBidirectional, emptyFVs)
574             ExplicitBidirectional mg ->
575                 do { (mg', fvs) <- rnMatchGroup PatSyn rnLExpr mg
576                    ; return (ExplicitBidirectional mg', fvs) }
577
578         ; mod <- getModule
579         ; let fvs = fvs1 `plusFV` fvs2
580               fvs' = filterNameSet (nameIsLocalOrFrom mod) fvs
581                 -- Keep locally-defined Names
582                 -- As well as dependency analysis, we need these for the
583                 -- MonoLocalBinds test in TcBinds.decideGeneralisationPlan
584
585         ; let bind' = bind{ psb_args = details'
586                           , psb_def = pat'
587                           , psb_dir = dir'
588                           , psb_fvs = fvs' }
589
590         ; fvs' `seq` -- See Note [Free-variable space leak]
591           return (bind', [name], fvs1)
592           -- See Note [Pattern synonym wrappers don't yield dependencies]
593       }
594   where
595     lookupVar = wrapLocM lookupOccRn
596
597     patternSynonymErr :: SDoc
598     patternSynonymErr
599       = hang (ptext (sLit "Illegal pattern synonym declaration"))
600            2 (ptext (sLit "Use -XPatternSynonyms to enable this extension"))
601
602 {-
603 Note [Pattern synonym wrappers don't yield dependencies]
604 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
605 When renaming a pattern synonym that has an explicit wrapper,
606 references in the wrapper definition should not be used when
607 calculating dependencies. For example, consider the following pattern
608 synonym definition:
609
610 pattern P x <- C1 x where
611   P x = f (C1 x)
612
613 f (P x) = C2 x
614
615 In this case, 'P' needs to be typechecked in two passes:
616
617 1. Typecheck the pattern definition of 'P', which fully determines the
618 type of 'P'. This step doesn't require knowing anything about 'f',
619 since the wrapper definition is not looked at.
620
621 2. Typecheck the wrapper definition, which needs the typechecked
622 definition of 'f' to be in scope.
623
624 This behaviour is implemented in 'tcValBinds', but it crucially
625 depends on 'P' not being put in a recursive group with 'f' (which
626 would make it look like a recursive pattern synonym a la 'pattern P =
627 P' which is unsound and rejected).
628
629 -}
630
631 ---------------------
632 depAnalBinds :: Bag (LHsBind Name, [Name], Uses)
633              -> ([(RecFlag, LHsBinds Name)], DefUses)
634 -- Dependency analysis; this is important so that
635 -- unused-binding reporting is accurate
636 depAnalBinds binds_w_dus
637   = (map get_binds sccs, map get_du sccs)
638   where
639     sccs = depAnal (\(_, defs, _) -> defs)
640                    (\(_, _, uses) -> nameSetElems uses)
641                    (bagToList binds_w_dus)
642
643     get_binds (AcyclicSCC (bind, _, _)) = (NonRecursive, unitBag bind)
644     get_binds (CyclicSCC  binds_w_dus)  = (Recursive, listToBag [b | (b,_,_) <- binds_w_dus])
645
646     get_du (AcyclicSCC (_, bndrs, uses)) = (Just (mkNameSet bndrs), uses)
647     get_du (CyclicSCC  binds_w_dus)      = (Just defs, uses)
648         where
649           defs = mkNameSet [b | (_,bs,_) <- binds_w_dus, b <- bs]
650           uses = unionNameSets [u | (_,_,u) <- binds_w_dus]
651
652 ---------------------
653 -- Bind the top-level forall'd type variables in the sigs.
654 -- E.g  f :: a -> a
655 --      f = rhs
656 --      The 'a' scopes over the rhs
657 --
658 -- NB: there'll usually be just one (for a function binding)
659 --     but if there are many, one may shadow the rest; too bad!
660 --      e.g  x :: [a] -> [a]
661 --           y :: [(a,a)] -> a
662 --           (x,y) = e
663 --      In e, 'a' will be in scope, and it'll be the one from 'y'!
664
665 mkSigTvFn :: [LSig Name] -> (Name -> [Name])
666 -- Return a lookup function that maps an Id Name to the names
667 -- of the type variables that should scope over its body..
668 mkSigTvFn sigs
669   = \n -> lookupNameEnv env n `orElse` []
670   where
671     env :: NameEnv [Name]
672     env = mkNameEnv [ (name, hsLKiTyVarNames ltvs)  -- Kind variables and type variables
673                     | L _ (TypeSig names
674                                    (L _ (HsForAllTy Explicit ltvs _ _))) <- sigs
675                     , (L _ name) <- names]
676         -- Note the pattern-match on "Explicit"; we only bind
677         -- type variables from signatures with an explicit top-level for-all
678 \end{code}
679
680
681 @rnMethodBinds@ is used for the method bindings of a class and an instance
682 declaration.   Like @rnBinds@ but without dependency analysis.
683
684 NOTA BENE: we record each {\em binder} of a method-bind group as a free variable.
685 That's crucial when dealing with an instance decl:
686 \begin{verbatim}
687         instance Foo (T a) where
688            op x = ...
689 \end{verbatim}
690 This might be the {\em sole} occurrence of @op@ for an imported class @Foo@,
691 and unless @op@ occurs we won't treat the type signature of @op@ in the class
692 decl for @Foo@ as a source of instance-decl gates.  But we should!  Indeed,
693 in many ways the @op@ in an instance decl is just like an occurrence, not
694 a binder.
695
696 \begin{code}
697 rnMethodBinds :: Name                   -- Class name
698               -> (Name -> [Name])       -- Signature tyvar function
699               -> LHsBinds RdrName
700               -> RnM (LHsBinds Name, FreeVars)
701
702 rnMethodBinds cls sig_fn binds
703   = do { checkDupRdrNames meth_names
704              -- Check that the same method is not given twice in the
705              -- same instance decl      instance C T where
706              --                       f x = ...
707              --                       g y = ...
708              --                       f x = ...
709              -- We must use checkDupRdrNames because the Name of the
710              -- method is the Name of the class selector, whose SrcSpan
711              -- points to the class declaration; and we use rnMethodBinds
712              -- for instance decls too
713
714        ; foldlM do_one (emptyBag, emptyFVs) (bagToList binds) }
715   where
716     meth_names  = collectMethodBinders binds
717     do_one (binds,fvs) bind
718        = do { (bind', fvs_bind) <- rnMethodBind cls sig_fn bind
719             ; return (binds `unionBags` bind', fvs_bind `plusFV` fvs) }
720
721 rnMethodBind :: Name
722               -> (Name -> [Name])
723               -> LHsBindLR RdrName RdrName
724               -> RnM (Bag (LHsBindLR Name Name), FreeVars)
725 rnMethodBind cls sig_fn
726              (L loc bind@(FunBind { fun_id = name, fun_infix = is_infix
727                                   , fun_matches = MG { mg_alts = matches
728                                                      , mg_origin = origin } }))
729   = setSrcSpan loc $ do
730     sel_name <- wrapLocM (lookupInstDeclBndr cls (ptext (sLit "method"))) name
731     let plain_name = unLoc sel_name
732         -- We use the selector name as the binder
733
734     (new_matches, fvs) <- bindSigTyVarsFV (sig_fn plain_name) $
735                           mapFvRn (rnMatch (FunRhs plain_name is_infix) rnLExpr)
736                                            matches
737     let new_group = mkMatchGroupName origin new_matches
738
739     when is_infix $ checkPrecMatch plain_name new_group
740     return (unitBag (L loc (bind { fun_id      = sel_name
741                                  , fun_matches = new_group
742                                  , bind_fvs    = fvs })),
743              fvs `addOneFV` plain_name)
744         -- The 'fvs' field isn't used for method binds
745
746 -- Can't handle method pattern-bindings which bind multiple methods.
747 rnMethodBind _ _ (L loc bind@(PatBind {})) = do
748     addErrAt loc (methodBindErr bind)
749     return (emptyBag, emptyFVs)
750
751 -- Associated pattern synonyms are not implemented yet
752 rnMethodBind _ _ (L loc bind@(PatSynBind {})) = do
753     addErrAt loc $ methodPatSynErr bind
754     return (emptyBag, emptyFVs)
755
756 rnMethodBind _ _ b = pprPanic "rnMethodBind" (ppr b)
757 \end{code}
758
759
760
761 %************************************************************************
762 %*                                                                      *
763 \subsubsection[dep-Sigs]{Signatures (and user-pragmas for values)}
764 %*                                                                      *
765 %************************************************************************
766
767 @renameSigs@ checks for:
768 \begin{enumerate}
769 \item more than one sig for one thing;
770 \item signatures given for things not bound here;
771 \end{enumerate}
772 %
773 At the moment we don't gather free-var info from the types in
774 signatures.  We'd only need this if we wanted to report unused tyvars.
775
776 \begin{code}
777 renameSigs :: HsSigCtxt
778            -> [LSig RdrName]
779            -> RnM ([LSig Name], FreeVars)
780 -- Renames the signatures and performs error checks
781 renameSigs ctxt sigs
782   = do  { mapM_ dupSigDeclErr (findDupSigs sigs)
783
784         ; checkDupMinimalSigs sigs
785
786         ; (sigs', sig_fvs) <- mapFvRn (wrapLocFstM (renameSig ctxt)) sigs
787
788         ; let (good_sigs, bad_sigs) = partition (okHsSig ctxt) sigs'
789         ; mapM_ misplacedSigErr bad_sigs                 -- Misplaced
790
791         ; return (good_sigs, sig_fvs) }
792
793 ----------------------
794 -- We use lookupSigOccRn in the signatures, which is a little bit unsatisfactory
795 -- because this won't work for:
796 --      instance Foo T where
797 --        {-# INLINE op #-}
798 --        Baz.op = ...
799 -- We'll just rename the INLINE prag to refer to whatever other 'op'
800 -- is in scope.  (I'm assuming that Baz.op isn't in scope unqualified.)
801 -- Doesn't seem worth much trouble to sort this.
802
803 renameSig :: HsSigCtxt -> Sig RdrName -> RnM (Sig Name, FreeVars)
804 -- FixitySig is renamed elsewhere.
805 renameSig _ (IdSig x)
806   = return (IdSig x, emptyFVs)    -- Actually this never occurs
807
808 renameSig ctxt sig@(TypeSig vs ty)
809   = do  { new_vs <- mapM (lookupSigOccRn ctxt sig) vs
810         ; (new_ty, fvs) <- rnHsSigType (ppr_sig_bndrs vs) ty
811         ; return (TypeSig new_vs new_ty, fvs) }
812
813 renameSig ctxt sig@(GenericSig vs ty)
814   = do  { defaultSigs_on <- xoptM Opt_DefaultSignatures
815         ; unless defaultSigs_on (addErr (defaultSigErr sig))
816         ; new_v <- mapM (lookupSigOccRn ctxt sig) vs
817         ; (new_ty, fvs) <- rnHsSigType (ppr_sig_bndrs vs) ty
818         ; return (GenericSig new_v new_ty, fvs) }
819
820 renameSig _ (SpecInstSig ty)
821   = do  { (new_ty, fvs) <- rnLHsType SpecInstSigCtx ty
822         ; return (SpecInstSig new_ty,fvs) }
823
824 -- {-# SPECIALISE #-} pragmas can refer to imported Ids
825 -- so, in the top-level case (when mb_names is Nothing)
826 -- we use lookupOccRn.  If there's both an imported and a local 'f'
827 -- then the SPECIALISE pragma is ambiguous, unlike all other signatures
828 renameSig ctxt sig@(SpecSig v tys inl)
829   = do  { new_v <- case ctxt of
830                      TopSigCtxt {} -> lookupLocatedOccRn v
831                      _             -> lookupSigOccRn ctxt sig v
832         -- ; (new_ty, fvs) <- rnHsSigType (quotes (ppr v)) ty
833         ; (new_ty, fvs) <- foldM do_one ([],emptyFVs) tys
834         ; return (SpecSig new_v new_ty inl, fvs) }
835   where
836     do_one (tys,fvs) ty
837       = do { (new_ty, fvs_ty) <- rnHsSigType (quotes (ppr v)) ty
838            ; return ( new_ty:tys, fvs_ty `plusFV` fvs) }
839
840 renameSig ctxt sig@(InlineSig v s)
841   = do  { new_v <- lookupSigOccRn ctxt sig v
842         ; return (InlineSig new_v s, emptyFVs) }
843
844 renameSig ctxt sig@(FixSig (FixitySig vs f))
845   = do  { new_vs <- mapM (lookupSigOccRn ctxt sig) vs
846         ; return (FixSig (FixitySig new_vs f), emptyFVs) }
847
848 renameSig ctxt sig@(MinimalSig bf)
849   = do new_bf <- traverse (lookupSigOccRn ctxt sig) bf
850        return (MinimalSig new_bf, emptyFVs)
851
852 renameSig ctxt sig@(PatSynSig v (flag, qtvs) prov req ty)
853   = do  { v' <- lookupSigOccRn ctxt sig v
854         ; let doc = TypeSigCtx $ quotes (ppr v)
855         ; loc <- getSrcSpanM
856
857         ; let (tv_kvs, mentioned) = extractHsTysRdrTyVars (ty:unLoc prov ++ unLoc req)
858         ; tv_bndrs <- case flag of
859             Implicit ->
860                 return $ mkHsQTvs . userHsTyVarBndrs loc $ mentioned
861             Explicit ->
862                 do { let heading = ptext (sLit "In the pattern synonym type signature")
863                                    <+> quotes (ppr sig)
864                    ; warnUnusedForAlls (heading $$ docOfHsDocContext doc) qtvs mentioned
865                    ; return qtvs }
866             Qualified -> panic "renameSig: Qualified"
867
868         ; bindHsTyVars doc Nothing tv_kvs tv_bndrs $ \ tyvars -> do
869         { (prov', fvs1) <- rnContext doc prov
870         ; (req', fvs2) <- rnContext doc req
871         ; (ty', fvs3) <- rnLHsType doc ty
872
873         ; let fvs = plusFVs [fvs1, fvs2, fvs3]
874         ; return (PatSynSig v' (flag, tyvars) prov' req' ty', fvs) }}
875
876 ppr_sig_bndrs :: [Located RdrName] -> SDoc
877 ppr_sig_bndrs bs = quotes (pprWithCommas ppr bs)
878
879 okHsSig :: HsSigCtxt -> LSig a -> Bool
880 okHsSig ctxt (L _ sig)
881   = case (sig, ctxt) of
882      (GenericSig {}, ClsDeclCtxt {}) -> True
883      (GenericSig {}, _)              -> False
884
885      (TypeSig {}, _)              -> True
886
887      (PatSynSig {}, TopSigCtxt{}) -> True
888      (PatSynSig {}, _)            -> False
889
890      (FixSig {}, InstDeclCtxt {}) -> False
891      (FixSig {}, _)               -> True
892
893      (IdSig {}, TopSigCtxt {})   -> True
894      (IdSig {}, InstDeclCtxt {}) -> True
895      (IdSig {}, _)               -> False
896
897      (InlineSig {}, HsBootCtxt) -> False
898      (InlineSig {}, _)          -> True
899
900      (SpecSig {}, TopSigCtxt {})    -> True
901      (SpecSig {}, LocalBindCtxt {}) -> True
902      (SpecSig {}, InstDeclCtxt {})  -> True
903      (SpecSig {}, _)                -> False
904
905      (SpecInstSig {}, InstDeclCtxt {}) -> True
906      (SpecInstSig {}, _)               -> False
907
908      (MinimalSig {}, ClsDeclCtxt {}) -> True
909      (MinimalSig {}, _)              -> False
910
911 -------------------
912 findDupSigs :: [LSig RdrName] -> [[(Located RdrName, Sig RdrName)]]
913 -- Check for duplicates on RdrName version,
914 -- because renamed version has unboundName for
915 -- not-in-scope binders, which gives bogus dup-sig errors
916 -- NB: in a class decl, a 'generic' sig is not considered
917 --     equal to an ordinary sig, so we allow, say
918 --           class C a where
919 --             op :: a -> a
920 --             default op :: Eq a => a -> a
921 findDupSigs sigs
922   = findDupsEq matching_sig (concatMap (expand_sig . unLoc) sigs)
923   where
924     expand_sig sig@(FixSig (FixitySig ns _)) = zip ns (repeat sig)
925     expand_sig sig@(InlineSig n _)          = [(n,sig)]
926     expand_sig sig@(TypeSig  ns _)   = [(n,sig) | n <- ns]
927     expand_sig sig@(GenericSig ns _) = [(n,sig) | n <- ns]
928     expand_sig _ = []
929
930     matching_sig (L _ n1,sig1) (L _ n2,sig2) = n1 == n2 && mtch sig1 sig2
931     mtch (FixSig {})     (FixSig {})     = True
932     mtch (InlineSig {})  (InlineSig {})  = True
933     mtch (TypeSig {})    (TypeSig {})    = True
934     mtch (GenericSig {}) (GenericSig {}) = True
935     mtch _ _ = False
936
937 -- Warn about multiple MINIMAL signatures
938 checkDupMinimalSigs :: [LSig RdrName] -> RnM ()
939 checkDupMinimalSigs sigs
940   = case filter isMinimalLSig sigs of
941       minSigs@(_:_:_) -> dupMinimalSigErr minSigs
942       _ -> return ()
943 \end{code}
944
945
946 %************************************************************************
947 %*                                                                      *
948 \subsection{Match}
949 %*                                                                      *
950 %************************************************************************
951
952 \begin{code}
953 rnMatchGroup :: Outputable (body RdrName) => HsMatchContext Name
954              -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))
955              -> MatchGroup RdrName (Located (body RdrName))
956              -> RnM (MatchGroup Name (Located (body Name)), FreeVars)
957 rnMatchGroup ctxt rnBody (MG { mg_alts = ms, mg_origin = origin })
958   = do { empty_case_ok <- xoptM Opt_EmptyCase
959        ; when (null ms && not empty_case_ok) (addErr (emptyCaseErr ctxt))
960        ; (new_ms, ms_fvs) <- mapFvRn (rnMatch ctxt rnBody) ms
961        ; return (mkMatchGroupName origin new_ms, ms_fvs) }
962
963 rnMatch :: Outputable (body RdrName) => HsMatchContext Name
964         -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))
965         -> LMatch RdrName (Located (body RdrName))
966         -> RnM (LMatch Name (Located (body Name)), FreeVars)
967 rnMatch ctxt rnBody = wrapLocFstM (rnMatch' ctxt rnBody)
968
969 rnMatch' :: Outputable (body RdrName) => HsMatchContext Name
970          -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))
971          -> Match RdrName (Located (body RdrName))
972          -> RnM (Match Name (Located (body Name)), FreeVars)
973 rnMatch' ctxt rnBody match@(Match pats maybe_rhs_sig grhss)
974   = do  {       -- Result type signatures are no longer supported
975           case maybe_rhs_sig of
976                 Nothing -> return ()
977                 Just (L loc ty) -> addErrAt loc (resSigErr ctxt match ty)
978
979                -- Now the main event
980                -- note that there are no local ficity decls for matches
981         ; rnPats ctxt pats      $ \ pats' -> do
982         { (grhss', grhss_fvs) <- rnGRHSs ctxt rnBody grhss
983
984         ; return (Match pats' Nothing grhss', grhss_fvs) }}
985
986 emptyCaseErr :: HsMatchContext Name -> SDoc
987 emptyCaseErr ctxt = hang (ptext (sLit "Empty list of alternatives in") <+> pp_ctxt)
988                        2 (ptext (sLit "Use EmptyCase to allow this"))
989   where
990     pp_ctxt = case ctxt of
991                 CaseAlt    -> ptext (sLit "case expression")
992                 LambdaExpr -> ptext (sLit "\\case expression")
993                 _ -> ptext (sLit "(unexpected)") <+> pprMatchContextNoun ctxt
994
995
996 resSigErr :: Outputable body
997           => HsMatchContext Name -> Match RdrName body -> HsType RdrName -> SDoc
998 resSigErr ctxt match ty
999    = vcat [ ptext (sLit "Illegal result type signature") <+> quotes (ppr ty)
1000           , nest 2 $ ptext (sLit
1001                  "Result signatures are no longer supported in pattern matches")
1002           , pprMatchInCtxt ctxt match ]
1003 \end{code}
1004
1005
1006 %************************************************************************
1007 %*                                                                      *
1008 \subsubsection{Guarded right-hand sides (GRHSs)}
1009 %*                                                                      *
1010 %************************************************************************
1011
1012 \begin{code}
1013 rnGRHSs :: HsMatchContext Name
1014         -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))
1015         -> GRHSs RdrName (Located (body RdrName))
1016         -> RnM (GRHSs Name (Located (body Name)), FreeVars)
1017 rnGRHSs ctxt rnBody (GRHSs grhss binds)
1018   = rnLocalBindsAndThen binds   $ \ binds' -> do
1019     (grhss', fvGRHSs) <- mapFvRn (rnGRHS ctxt rnBody) grhss
1020     return (GRHSs grhss' binds', fvGRHSs)
1021
1022 rnGRHS :: HsMatchContext Name
1023        -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))
1024        -> LGRHS RdrName (Located (body RdrName))
1025        -> RnM (LGRHS Name (Located (body Name)), FreeVars)
1026 rnGRHS ctxt rnBody = wrapLocFstM (rnGRHS' ctxt rnBody)
1027
1028 rnGRHS' :: HsMatchContext Name
1029         -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))
1030         -> GRHS RdrName (Located (body RdrName))
1031         -> RnM (GRHS Name (Located (body Name)), FreeVars)
1032 rnGRHS' ctxt rnBody (GRHS guards rhs)
1033   = do  { pattern_guards_allowed <- xoptM Opt_PatternGuards
1034         ; ((guards', rhs'), fvs) <- rnStmts (PatGuard ctxt) rnLExpr guards $ \ _ ->
1035                                     rnBody rhs
1036
1037         ; unless (pattern_guards_allowed || is_standard_guard guards')
1038                  (addWarn (nonStdGuardErr guards'))
1039
1040         ; return (GRHS guards' rhs', fvs) }
1041   where
1042         -- Standard Haskell 1.4 guards are just a single boolean
1043         -- expression, rather than a list of qualifiers as in the
1044         -- Glasgow extension
1045     is_standard_guard []                       = True
1046     is_standard_guard [L _ (BodyStmt _ _ _ _)] = True
1047     is_standard_guard _                        = False
1048 \end{code}
1049
1050 %************************************************************************
1051 %*                                                                      *
1052 \subsection{Error messages}
1053 %*                                                                      *
1054 %************************************************************************
1055
1056 \begin{code}
1057 dupSigDeclErr :: [(Located RdrName, Sig RdrName)] -> RnM ()
1058 dupSigDeclErr pairs@((L loc name, sig) : _)
1059   = addErrAt loc $
1060     vcat [ ptext (sLit "Duplicate") <+> what_it_is
1061            <> ptext (sLit "s for") <+> quotes (ppr name)
1062          , ptext (sLit "at") <+> vcat (map ppr $ sort $ map (getLoc . fst) pairs) ]
1063   where
1064     what_it_is = hsSigDoc sig
1065
1066 dupSigDeclErr [] = panic "dupSigDeclErr"
1067
1068 misplacedSigErr :: LSig Name -> RnM ()
1069 misplacedSigErr (L loc sig)
1070   = addErrAt loc $
1071     sep [ptext (sLit "Misplaced") <+> hsSigDoc sig <> colon, ppr sig]
1072
1073 defaultSigErr :: Sig RdrName -> SDoc
1074 defaultSigErr sig = vcat [ hang (ptext (sLit "Unexpected default signature:"))
1075                               2 (ppr sig)
1076                          , ptext (sLit "Use DefaultSignatures to enable default signatures") ]
1077
1078 methodBindErr :: HsBindLR RdrName RdrName -> SDoc
1079 methodBindErr mbind
1080  =  hang (ptext (sLit "Pattern bindings (except simple variables) not allowed in instance declarations"))
1081        2 (ppr mbind)
1082
1083 methodPatSynErr :: HsBindLR RdrName RdrName -> SDoc
1084 methodPatSynErr mbind
1085  =  hang (ptext (sLit "Pattern synonyms not allowed in class/instance declarations"))
1086        2 (ppr mbind)
1087
1088 bindsInHsBootFile :: LHsBindsLR Name RdrName -> SDoc
1089 bindsInHsBootFile mbinds
1090   = hang (ptext (sLit "Bindings in hs-boot files are not allowed"))
1091        2 (ppr mbinds)
1092
1093 nonStdGuardErr :: Outputable body => [LStmtLR Name Name body] -> SDoc
1094 nonStdGuardErr guards
1095   = hang (ptext (sLit "accepting non-standard pattern guards (use PatternGuards to suppress this message)"))
1096        4 (interpp'SP guards)
1097
1098 unusedPatBindWarn :: HsBind Name -> SDoc
1099 unusedPatBindWarn bind
1100   = hang (ptext (sLit "This pattern-binding binds no variables:"))
1101        2 (ppr bind)
1102
1103 dupMinimalSigErr :: [LSig RdrName] -> RnM ()
1104 dupMinimalSigErr sigs@(L loc _ : _)
1105   = addErrAt loc $
1106     vcat [ ptext (sLit "Multiple minimal complete definitions")
1107          , ptext (sLit "at") <+> vcat (map ppr $ sort $ map getLoc sigs)
1108          , ptext (sLit "Combine alternative minimal complete definitions with `|'") ]
1109 dupMinimalSigErr [] = panic "dupMinimalSigErr"
1110 \end{code}