Implement Partial Type Signatures
[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     extractScopedTyVars :: LHsType Name -> [Name]
672     extractScopedTyVars (L _ (HsForAllTy Explicit _ ltvs _ _)) = hsLKiTyVarNames ltvs
673     extractScopedTyVars _ = []
674
675     env :: NameEnv [Name]
676     env = mkNameEnv [ (name, nwcs ++ extractScopedTyVars ty)  -- Kind variables and type variables
677                     | L _ (TypeSig names ty nwcs) <- sigs
678                     , L _ name <- names]
679         -- Note the pattern-match on "Explicit"; we only bind
680         -- type variables from signatures with an explicit top-level for-all
681 \end{code}
682
683
684 @rnMethodBinds@ is used for the method bindings of a class and an instance
685 declaration.   Like @rnBinds@ but without dependency analysis.
686
687 NOTA BENE: we record each {\em binder} of a method-bind group as a free variable.
688 That's crucial when dealing with an instance decl:
689 \begin{verbatim}
690         instance Foo (T a) where
691            op x = ...
692 \end{verbatim}
693 This might be the {\em sole} occurrence of @op@ for an imported class @Foo@,
694 and unless @op@ occurs we won't treat the type signature of @op@ in the class
695 decl for @Foo@ as a source of instance-decl gates.  But we should!  Indeed,
696 in many ways the @op@ in an instance decl is just like an occurrence, not
697 a binder.
698
699 \begin{code}
700 rnMethodBinds :: Name                   -- Class name
701               -> (Name -> [Name])       -- Signature tyvar function
702               -> LHsBinds RdrName
703               -> RnM (LHsBinds Name, FreeVars)
704
705 rnMethodBinds cls sig_fn binds
706   = do { checkDupRdrNames meth_names
707              -- Check that the same method is not given twice in the
708              -- same instance decl      instance C T where
709              --                       f x = ...
710              --                       g y = ...
711              --                       f x = ...
712              -- We must use checkDupRdrNames because the Name of the
713              -- method is the Name of the class selector, whose SrcSpan
714              -- points to the class declaration; and we use rnMethodBinds
715              -- for instance decls too
716
717        ; foldlM do_one (emptyBag, emptyFVs) (bagToList binds) }
718   where
719     meth_names  = collectMethodBinders binds
720     do_one (binds,fvs) bind
721        = do { (bind', fvs_bind) <- rnMethodBind cls sig_fn bind
722             ; return (binds `unionBags` bind', fvs_bind `plusFV` fvs) }
723
724 rnMethodBind :: Name
725               -> (Name -> [Name])
726               -> LHsBindLR RdrName RdrName
727               -> RnM (Bag (LHsBindLR Name Name), FreeVars)
728 rnMethodBind cls sig_fn
729              (L loc bind@(FunBind { fun_id = name, fun_infix = is_infix
730                                   , fun_matches = MG { mg_alts = matches
731                                                      , mg_origin = origin } }))
732   = setSrcSpan loc $ do
733     sel_name <- wrapLocM (lookupInstDeclBndr cls (ptext (sLit "method"))) name
734     let plain_name = unLoc sel_name
735         -- We use the selector name as the binder
736
737     (new_matches, fvs) <- bindSigTyVarsFV (sig_fn plain_name) $
738                           mapFvRn (rnMatch (FunRhs plain_name is_infix) rnLExpr)
739                                            matches
740     let new_group = mkMatchGroupName origin new_matches
741
742     when is_infix $ checkPrecMatch plain_name new_group
743     return (unitBag (L loc (bind { fun_id      = sel_name
744                                  , fun_matches = new_group
745                                  , bind_fvs    = fvs })),
746              fvs `addOneFV` plain_name)
747         -- The 'fvs' field isn't used for method binds
748
749 -- Can't handle method pattern-bindings which bind multiple methods.
750 rnMethodBind _ _ (L loc bind@(PatBind {})) = do
751     addErrAt loc (methodBindErr bind)
752     return (emptyBag, emptyFVs)
753
754 -- Associated pattern synonyms are not implemented yet
755 rnMethodBind _ _ (L loc bind@(PatSynBind {})) = do
756     addErrAt loc $ methodPatSynErr bind
757     return (emptyBag, emptyFVs)
758
759 rnMethodBind _ _ b = pprPanic "rnMethodBind" (ppr b)
760 \end{code}
761
762
763
764 %************************************************************************
765 %*                                                                      *
766 \subsubsection[dep-Sigs]{Signatures (and user-pragmas for values)}
767 %*                                                                      *
768 %************************************************************************
769
770 @renameSigs@ checks for:
771 \begin{enumerate}
772 \item more than one sig for one thing;
773 \item signatures given for things not bound here;
774 \end{enumerate}
775 %
776 At the moment we don't gather free-var info from the types in
777 signatures.  We'd only need this if we wanted to report unused tyvars.
778
779 \begin{code}
780 renameSigs :: HsSigCtxt
781            -> [LSig RdrName]
782            -> RnM ([LSig Name], FreeVars)
783 -- Renames the signatures and performs error checks
784 renameSigs ctxt sigs
785   = do  { mapM_ dupSigDeclErr (findDupSigs sigs)
786
787         ; checkDupMinimalSigs sigs
788
789         ; (sigs', sig_fvs) <- mapFvRn (wrapLocFstM (renameSig ctxt)) sigs
790
791         ; let (good_sigs, bad_sigs) = partition (okHsSig ctxt) sigs'
792         ; mapM_ misplacedSigErr bad_sigs                 -- Misplaced
793
794         ; return (good_sigs, sig_fvs) }
795
796 ----------------------
797 -- We use lookupSigOccRn in the signatures, which is a little bit unsatisfactory
798 -- because this won't work for:
799 --      instance Foo T where
800 --        {-# INLINE op #-}
801 --        Baz.op = ...
802 -- We'll just rename the INLINE prag to refer to whatever other 'op'
803 -- is in scope.  (I'm assuming that Baz.op isn't in scope unqualified.)
804 -- Doesn't seem worth much trouble to sort this.
805
806 renameSig :: HsSigCtxt -> Sig RdrName -> RnM (Sig Name, FreeVars)
807 -- FixitySig is renamed elsewhere.
808 renameSig _ (IdSig x)
809   = return (IdSig x, emptyFVs)    -- Actually this never occurs
810
811 renameSig ctxt sig@(TypeSig vs ty _)
812   = do  { new_vs <- mapM (lookupSigOccRn ctxt sig) vs
813         -- (named and anonymous) wildcards are bound here.
814         ; (wcs, ty') <- extractWildcards ty
815         ; bindLocatedLocalsFV wcs $ \wcs_new -> do {
816           (new_ty, fvs) <- rnHsSigType (ppr_sig_bndrs vs) ty'
817         ; return (TypeSig new_vs new_ty wcs_new, fvs) } }
818
819 renameSig ctxt sig@(GenericSig vs ty)
820   = do  { defaultSigs_on <- xoptM Opt_DefaultSignatures
821         ; unless defaultSigs_on (addErr (defaultSigErr sig))
822         ; new_v <- mapM (lookupSigOccRn ctxt sig) vs
823         ; (new_ty, fvs) <- rnHsSigType (ppr_sig_bndrs vs) ty
824         ; return (GenericSig new_v new_ty, fvs) }
825
826 renameSig _ (SpecInstSig ty)
827   = do  { (new_ty, fvs) <- rnLHsType SpecInstSigCtx ty
828         ; return (SpecInstSig new_ty,fvs) }
829
830 -- {-# SPECIALISE #-} pragmas can refer to imported Ids
831 -- so, in the top-level case (when mb_names is Nothing)
832 -- we use lookupOccRn.  If there's both an imported and a local 'f'
833 -- then the SPECIALISE pragma is ambiguous, unlike all other signatures
834 renameSig ctxt sig@(SpecSig v tys inl)
835   = do  { new_v <- case ctxt of
836                      TopSigCtxt {} -> lookupLocatedOccRn v
837                      _             -> lookupSigOccRn ctxt sig v
838         -- ; (new_ty, fvs) <- rnHsSigType (quotes (ppr v)) ty
839         ; (new_ty, fvs) <- foldM do_one ([],emptyFVs) tys
840         ; return (SpecSig new_v new_ty inl, fvs) }
841   where
842     do_one (tys,fvs) ty
843       = do { (new_ty, fvs_ty) <- rnHsSigType (quotes (ppr v)) ty
844            ; return ( new_ty:tys, fvs_ty `plusFV` fvs) }
845
846 renameSig ctxt sig@(InlineSig v s)
847   = do  { new_v <- lookupSigOccRn ctxt sig v
848         ; return (InlineSig new_v s, emptyFVs) }
849
850 renameSig ctxt sig@(FixSig (FixitySig vs f))
851   = do  { new_vs <- mapM (lookupSigOccRn ctxt sig) vs
852         ; return (FixSig (FixitySig new_vs f), emptyFVs) }
853
854 renameSig ctxt sig@(MinimalSig bf)
855   = do new_bf <- traverse (lookupSigOccRn ctxt sig) bf
856        return (MinimalSig new_bf, emptyFVs)
857
858 renameSig ctxt sig@(PatSynSig v (flag, qtvs) prov req ty)
859   = do  { v' <- lookupSigOccRn ctxt sig v
860         ; let doc = TypeSigCtx $ quotes (ppr v)
861         ; loc <- getSrcSpanM
862
863         ; let (tv_kvs, mentioned) = extractHsTysRdrTyVars (ty:unLoc prov ++ unLoc req)
864         ; tv_bndrs <- case flag of
865             Implicit ->
866                 return $ mkHsQTvs . userHsTyVarBndrs loc $ mentioned
867             Explicit ->
868                 do { let heading = ptext (sLit "In the pattern synonym type signature")
869                                    <+> quotes (ppr sig)
870                    ; warnUnusedForAlls (heading $$ docOfHsDocContext doc) qtvs mentioned
871                    ; return qtvs }
872             Qualified -> panic "renameSig: Qualified"
873
874         ; bindHsTyVars doc Nothing tv_kvs tv_bndrs $ \ tyvars -> do
875         { (prov', fvs1) <- rnContext doc prov
876         ; (req', fvs2) <- rnContext doc req
877         ; (ty', fvs3) <- rnLHsType doc ty
878
879         ; let fvs = plusFVs [fvs1, fvs2, fvs3]
880         ; return (PatSynSig v' (flag, tyvars) prov' req' ty', fvs) }}
881
882 ppr_sig_bndrs :: [Located RdrName] -> SDoc
883 ppr_sig_bndrs bs = quotes (pprWithCommas ppr bs)
884
885 okHsSig :: HsSigCtxt -> LSig a -> Bool
886 okHsSig ctxt (L _ sig)
887   = case (sig, ctxt) of
888      (GenericSig {}, ClsDeclCtxt {}) -> True
889      (GenericSig {}, _)              -> False
890
891      (TypeSig {}, _)              -> True
892
893      (PatSynSig {}, TopSigCtxt{}) -> True
894      (PatSynSig {}, _)            -> False
895
896      (FixSig {}, InstDeclCtxt {}) -> False
897      (FixSig {}, _)               -> True
898
899      (IdSig {}, TopSigCtxt {})   -> True
900      (IdSig {}, InstDeclCtxt {}) -> True
901      (IdSig {}, _)               -> False
902
903      (InlineSig {}, HsBootCtxt) -> False
904      (InlineSig {}, _)          -> True
905
906      (SpecSig {}, TopSigCtxt {})    -> True
907      (SpecSig {}, LocalBindCtxt {}) -> True
908      (SpecSig {}, InstDeclCtxt {})  -> True
909      (SpecSig {}, _)                -> False
910
911      (SpecInstSig {}, InstDeclCtxt {}) -> True
912      (SpecInstSig {}, _)               -> False
913
914      (MinimalSig {}, ClsDeclCtxt {}) -> True
915      (MinimalSig {}, _)              -> False
916
917 -------------------
918 findDupSigs :: [LSig RdrName] -> [[(Located RdrName, Sig RdrName)]]
919 -- Check for duplicates on RdrName version,
920 -- because renamed version has unboundName for
921 -- not-in-scope binders, which gives bogus dup-sig errors
922 -- NB: in a class decl, a 'generic' sig is not considered
923 --     equal to an ordinary sig, so we allow, say
924 --           class C a where
925 --             op :: a -> a
926 --             default op :: Eq a => a -> a
927 findDupSigs sigs
928   = findDupsEq matching_sig (concatMap (expand_sig . unLoc) sigs)
929   where
930     expand_sig sig@(FixSig (FixitySig ns _)) = zip ns (repeat sig)
931     expand_sig sig@(InlineSig n _)          = [(n,sig)]
932     expand_sig sig@(TypeSig ns _ _)         = [(n,sig) | n <- ns]
933     expand_sig sig@(GenericSig ns _)        = [(n,sig) | n <- ns]
934     expand_sig _ = []
935
936     matching_sig (L _ n1,sig1) (L _ n2,sig2) = n1 == n2 && mtch sig1 sig2
937     mtch (FixSig {})     (FixSig {})     = True
938     mtch (InlineSig {})  (InlineSig {})  = True
939     mtch (TypeSig {})    (TypeSig {})    = True
940     mtch (GenericSig {}) (GenericSig {}) = True
941     mtch _ _ = False
942
943 -- Warn about multiple MINIMAL signatures
944 checkDupMinimalSigs :: [LSig RdrName] -> RnM ()
945 checkDupMinimalSigs sigs
946   = case filter isMinimalLSig sigs of
947       minSigs@(_:_:_) -> dupMinimalSigErr minSigs
948       _ -> return ()
949 \end{code}
950
951
952 %************************************************************************
953 %*                                                                      *
954 \subsection{Match}
955 %*                                                                      *
956 %************************************************************************
957
958 \begin{code}
959 rnMatchGroup :: Outputable (body RdrName) => HsMatchContext Name
960              -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))
961              -> MatchGroup RdrName (Located (body RdrName))
962              -> RnM (MatchGroup Name (Located (body Name)), FreeVars)
963 rnMatchGroup ctxt rnBody (MG { mg_alts = ms, mg_origin = origin })
964   = do { empty_case_ok <- xoptM Opt_EmptyCase
965        ; when (null ms && not empty_case_ok) (addErr (emptyCaseErr ctxt))
966        ; (new_ms, ms_fvs) <- mapFvRn (rnMatch ctxt rnBody) ms
967        ; return (mkMatchGroupName origin new_ms, ms_fvs) }
968
969 rnMatch :: Outputable (body RdrName) => HsMatchContext Name
970         -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))
971         -> LMatch RdrName (Located (body RdrName))
972         -> RnM (LMatch Name (Located (body Name)), FreeVars)
973 rnMatch ctxt rnBody = wrapLocFstM (rnMatch' ctxt rnBody)
974
975 rnMatch' :: Outputable (body RdrName) => HsMatchContext Name
976          -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))
977          -> Match RdrName (Located (body RdrName))
978          -> RnM (Match Name (Located (body Name)), FreeVars)
979 rnMatch' ctxt rnBody match@(Match pats maybe_rhs_sig grhss)
980   = do  {       -- Result type signatures are no longer supported
981           case maybe_rhs_sig of
982                 Nothing -> return ()
983                 Just (L loc ty) -> addErrAt loc (resSigErr ctxt match ty)
984
985                -- Now the main event
986                -- note that there are no local ficity decls for matches
987         ; rnPats ctxt pats      $ \ pats' -> do
988         { (grhss', grhss_fvs) <- rnGRHSs ctxt rnBody grhss
989
990         ; return (Match pats' Nothing grhss', grhss_fvs) }}
991
992 emptyCaseErr :: HsMatchContext Name -> SDoc
993 emptyCaseErr ctxt = hang (ptext (sLit "Empty list of alternatives in") <+> pp_ctxt)
994                        2 (ptext (sLit "Use EmptyCase to allow this"))
995   where
996     pp_ctxt = case ctxt of
997                 CaseAlt    -> ptext (sLit "case expression")
998                 LambdaExpr -> ptext (sLit "\\case expression")
999                 _ -> ptext (sLit "(unexpected)") <+> pprMatchContextNoun ctxt
1000
1001
1002 resSigErr :: Outputable body
1003           => HsMatchContext Name -> Match RdrName body -> HsType RdrName -> SDoc
1004 resSigErr ctxt match ty
1005    = vcat [ ptext (sLit "Illegal result type signature") <+> quotes (ppr ty)
1006           , nest 2 $ ptext (sLit
1007                  "Result signatures are no longer supported in pattern matches")
1008           , pprMatchInCtxt ctxt match ]
1009 \end{code}
1010
1011
1012 %************************************************************************
1013 %*                                                                      *
1014 \subsubsection{Guarded right-hand sides (GRHSs)}
1015 %*                                                                      *
1016 %************************************************************************
1017
1018 \begin{code}
1019 rnGRHSs :: HsMatchContext Name
1020         -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))
1021         -> GRHSs RdrName (Located (body RdrName))
1022         -> RnM (GRHSs Name (Located (body Name)), FreeVars)
1023 rnGRHSs ctxt rnBody (GRHSs grhss binds)
1024   = rnLocalBindsAndThen binds   $ \ binds' -> do
1025     (grhss', fvGRHSs) <- mapFvRn (rnGRHS ctxt rnBody) grhss
1026     return (GRHSs grhss' binds', fvGRHSs)
1027
1028 rnGRHS :: HsMatchContext Name
1029        -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))
1030        -> LGRHS RdrName (Located (body RdrName))
1031        -> RnM (LGRHS Name (Located (body Name)), FreeVars)
1032 rnGRHS ctxt rnBody = wrapLocFstM (rnGRHS' ctxt rnBody)
1033
1034 rnGRHS' :: HsMatchContext Name
1035         -> (Located (body RdrName) -> RnM (Located (body Name), FreeVars))
1036         -> GRHS RdrName (Located (body RdrName))
1037         -> RnM (GRHS Name (Located (body Name)), FreeVars)
1038 rnGRHS' ctxt rnBody (GRHS guards rhs)
1039   = do  { pattern_guards_allowed <- xoptM Opt_PatternGuards
1040         ; ((guards', rhs'), fvs) <- rnStmts (PatGuard ctxt) rnLExpr guards $ \ _ ->
1041                                     rnBody rhs
1042
1043         ; unless (pattern_guards_allowed || is_standard_guard guards')
1044                  (addWarn (nonStdGuardErr guards'))
1045
1046         ; return (GRHS guards' rhs', fvs) }
1047   where
1048         -- Standard Haskell 1.4 guards are just a single boolean
1049         -- expression, rather than a list of qualifiers as in the
1050         -- Glasgow extension
1051     is_standard_guard []                       = True
1052     is_standard_guard [L _ (BodyStmt _ _ _ _)] = True
1053     is_standard_guard _                        = False
1054 \end{code}
1055
1056 %************************************************************************
1057 %*                                                                      *
1058 \subsection{Error messages}
1059 %*                                                                      *
1060 %************************************************************************
1061
1062 \begin{code}
1063 dupSigDeclErr :: [(Located RdrName, Sig RdrName)] -> RnM ()
1064 dupSigDeclErr pairs@((L loc name, sig) : _)
1065   = addErrAt loc $
1066     vcat [ ptext (sLit "Duplicate") <+> what_it_is
1067            <> ptext (sLit "s for") <+> quotes (ppr name)
1068          , ptext (sLit "at") <+> vcat (map ppr $ sort $ map (getLoc . fst) pairs) ]
1069   where
1070     what_it_is = hsSigDoc sig
1071
1072 dupSigDeclErr [] = panic "dupSigDeclErr"
1073
1074 misplacedSigErr :: LSig Name -> RnM ()
1075 misplacedSigErr (L loc sig)
1076   = addErrAt loc $
1077     sep [ptext (sLit "Misplaced") <+> hsSigDoc sig <> colon, ppr sig]
1078
1079 defaultSigErr :: Sig RdrName -> SDoc
1080 defaultSigErr sig = vcat [ hang (ptext (sLit "Unexpected default signature:"))
1081                               2 (ppr sig)
1082                          , ptext (sLit "Use DefaultSignatures to enable default signatures") ]
1083
1084 methodBindErr :: HsBindLR RdrName RdrName -> SDoc
1085 methodBindErr mbind
1086  =  hang (ptext (sLit "Pattern bindings (except simple variables) not allowed in instance declarations"))
1087        2 (ppr mbind)
1088
1089 methodPatSynErr :: HsBindLR RdrName RdrName -> SDoc
1090 methodPatSynErr mbind
1091  =  hang (ptext (sLit "Pattern synonyms not allowed in class/instance declarations"))
1092        2 (ppr mbind)
1093
1094 bindsInHsBootFile :: LHsBindsLR Name RdrName -> SDoc
1095 bindsInHsBootFile mbinds
1096   = hang (ptext (sLit "Bindings in hs-boot files are not allowed"))
1097        2 (ppr mbinds)
1098
1099 nonStdGuardErr :: Outputable body => [LStmtLR Name Name body] -> SDoc
1100 nonStdGuardErr guards
1101   = hang (ptext (sLit "accepting non-standard pattern guards (use PatternGuards to suppress this message)"))
1102        4 (interpp'SP guards)
1103
1104 unusedPatBindWarn :: HsBind Name -> SDoc
1105 unusedPatBindWarn bind
1106   = hang (ptext (sLit "This pattern-binding binds no variables:"))
1107        2 (ppr bind)
1108
1109 dupMinimalSigErr :: [LSig RdrName] -> RnM ()
1110 dupMinimalSigErr sigs@(L loc _ : _)
1111   = addErrAt loc $
1112     vcat [ ptext (sLit "Multiple minimal complete definitions")
1113          , ptext (sLit "at") <+> vcat (map ppr $ sort $ map getLoc sigs)
1114          , ptext (sLit "Combine alternative minimal complete definitions with `|'") ]
1115 dupMinimalSigErr [] = panic "dupMinimalSigErr"
1116 \end{code}