Remove LazyUniqFM; fixes trac #3880
[ghc.git] / compiler / rename / RnEnv.lhs
1 %
2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-2006
3 %
4 \section[RnEnv]{Environment manipulation for the renamer monad}
5
6 \begin{code}
7 module RnEnv ( 
8         newTopSrcBinder, lookupFamInstDeclBndr,
9         lookupLocatedTopBndrRn, lookupTopBndrRn,
10         lookupLocatedOccRn, lookupOccRn, 
11         lookupLocatedGlobalOccRn, 
12         lookupGlobalOccRn, lookupGlobalOccRn_maybe,
13         lookupLocalDataTcNames, lookupSigOccRn,
14         lookupFixityRn, lookupTyFixityRn, 
15         lookupInstDeclBndr, lookupSubBndr, lookupConstructorFields,
16         lookupSyntaxName, lookupSyntaxTable, 
17         lookupGreRn, lookupGreLocalRn, lookupGreRn_maybe,
18         getLookupOccRn, addUsedRdrNames,
19
20         newLocalBndrRn, newLocalBndrsRn, newIPNameRn,
21         bindLocalName, bindLocalNames, bindLocalNamesFV, 
22         MiniFixityEnv, emptyFsEnv, extendFsEnv, lookupFsEnv,
23         bindLocalNamesFV_WithFixities,
24         bindLocatedLocalsFV, bindLocatedLocalsRn,
25         bindSigTyVarsFV, bindPatSigTyVars, bindPatSigTyVarsFV,
26         bindTyVarsRn, extendTyVarEnvFVRn,
27
28         checkDupRdrNames, checkDupAndShadowedRdrNames,
29         checkDupNames, checkDupAndShadowedNames, 
30         addFvRn, mapFvRn, mapMaybeFvRn, mapFvRnCPS,
31         warnUnusedMatches, warnUnusedModules, warnUnusedImports, 
32         warnUnusedTopBinds, warnUnusedLocalBinds,
33         dataTcOccs, unknownNameErr, kindSigErr, perhapsForallMsg
34     ) where
35
36 #include "HsVersions.h"
37
38 import LoadIface        ( loadInterfaceForName, loadSrcInterface )
39 import IfaceEnv         ( lookupOrig, newGlobalBinder, newIPName )
40 import HsSyn
41 import RdrHsSyn         ( extractHsTyRdrTyVars )
42 import RdrName
43 import HscTypes         ( availNames, ModIface(..), FixItem(..), lookupFixity)
44 import TcEnv            ( tcLookupDataCon, tcLookupField, isBrackStage )
45 import TcRnMonad
46 import Id               ( isRecordSelector )
47 import Name             ( Name, nameIsLocalOrFrom, mkInternalName, isWiredInName,
48                           nameSrcLoc, nameSrcSpan, nameOccName, nameModule, isExternalName )
49 import NameSet
50 import NameEnv
51 import UniqFM
52 import DataCon          ( dataConFieldLabels )
53 import OccName
54 import Module           ( Module, ModuleName )
55 import PrelNames        ( mkUnboundName, rOOT_MAIN, iNTERACTIVE, 
56                           consDataConKey, forall_tv_RDR )
57 import Unique
58 import BasicTypes
59 import ErrUtils         ( Message )
60 import SrcLoc
61 import Outputable
62 import Util
63 import Maybes
64 import ListSetOps       ( removeDups )
65 import DynFlags
66 import FastString
67 import Control.Monad
68 import Data.List
69 import qualified Data.Set as Set
70 \end{code}
71
72 \begin{code}
73 -- XXX
74 thenM :: Monad a => a b -> (b -> a c) -> a c
75 thenM = (>>=)
76 \end{code}
77
78 %*********************************************************
79 %*                                                      *
80                 Source-code binders
81 %*                                                      *
82 %*********************************************************
83
84 \begin{code}
85 newTopSrcBinder :: Module -> Located RdrName -> RnM Name
86 newTopSrcBinder this_mod (L loc rdr_name)
87   | Just name <- isExact_maybe rdr_name
88   =     -- This is here to catch 
89         --   (a) Exact-name binders created by Template Haskell
90         --   (b) The PrelBase defn of (say) [] and similar, for which
91         --       the parser reads the special syntax and returns an Exact RdrName
92         -- We are at a binding site for the name, so check first that it 
93         -- the current module is the correct one; otherwise GHC can get
94         -- very confused indeed. This test rejects code like
95         --      data T = (,) Int Int
96         -- unless we are in GHC.Tup
97     ASSERT2( isExternalName name,  ppr name )
98     do  { unless (this_mod == nameModule name)
99                  (addErrAt loc (badOrigBinding rdr_name))
100         ; return name }
101
102
103   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
104   = do  { unless (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
105                  (addErrAt loc (badOrigBinding rdr_name))
106         -- When reading External Core we get Orig names as binders, 
107         -- but they should agree with the module gotten from the monad
108         --
109         -- We can get built-in syntax showing up here too, sadly.  If you type
110         --      data T = (,,,)
111         -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon 
112         -- uses setRdrNameSpace to make it into a data constructors.  At that point
113         -- the nice Exact name for the TyCon gets swizzled to an Orig name.
114         -- Hence the badOrigBinding error message.
115         --
116         -- Except for the ":Main.main = ..." definition inserted into 
117         -- the Main module; ugh!
118
119         -- Because of this latter case, we call newGlobalBinder with a module from 
120         -- the RdrName, not from the environment.  In principle, it'd be fine to 
121         -- have an arbitrary mixture of external core definitions in a single module,
122         -- (apart from module-initialisation issues, perhaps).
123         ; newGlobalBinder rdr_mod rdr_occ loc }
124                 --TODO, should pass the whole span
125
126   | otherwise
127   = do  { unless (not (isQual rdr_name))
128                  (addErrAt loc (badQualBndrErr rdr_name))
129                 -- Binders should not be qualified; if they are, and with a different
130                 -- module name, we we get a confusing "M.T is not in scope" error later
131
132         ; stage <- getStage
133         ; if isBrackStage stage then
134                 -- We are inside a TH bracket, so make an *Internal* name
135                 -- See Note [Top-level Names in Template Haskell decl quotes] in RnNames
136              do { uniq <- newUnique
137                 ; return (mkInternalName uniq (rdrNameOcc rdr_name) loc) } 
138           else  
139                 -- Normal case
140              newGlobalBinder this_mod (rdrNameOcc rdr_name) loc }
141 \end{code}
142
143 %*********************************************************
144 %*                                                      *
145         Source code occurrences
146 %*                                                      *
147 %*********************************************************
148
149 Looking up a name in the RnEnv.
150
151 Note [Type and class operator definitions]
152 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
153 We want to reject all of these unless we have -XTypeOperators (Trac #3265)
154    data a :*: b  = ...
155    class a :*: b where ...
156    data (:*:) a b  = ....
157    class (:*:) a b where ...
158 The latter two mean that we are not just looking for a
159 *syntactically-infix* declaration, but one that uses an operator
160 OccName.  We use OccName.isSymOcc to detect that case, which isn't
161 terribly efficient, but there seems to be no better way.
162
163 \begin{code}
164 lookupTopBndrRn :: RdrName -> RnM Name
165 lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n
166                        case nopt of 
167                          Just n' -> return n'
168                          Nothing -> do traceRn $ text "lookupTopBndrRn"
169                                        unboundName n
170
171 lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
172 lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn
173
174 lookupTopBndrRn_maybe :: RdrName -> RnM (Maybe Name)
175 -- Look up a top-level source-code binder.   We may be looking up an unqualified 'f',
176 -- and there may be several imported 'f's too, which must not confuse us.
177 -- For example, this is OK:
178 --      import Foo( f )
179 --      infix 9 f       -- The 'f' here does not need to be qualified
180 --      f x = x         -- Nor here, of course
181 -- So we have to filter out the non-local ones.
182 --
183 -- A separate function (importsFromLocalDecls) reports duplicate top level
184 -- decls, so here it's safe just to choose an arbitrary one.
185 --
186 -- There should never be a qualified name in a binding position in Haskell,
187 -- but there can be if we have read in an external-Core file.
188 -- The Haskell parser checks for the illegal qualified name in Haskell 
189 -- source files, so we don't need to do so here.
190
191 lookupTopBndrRn_maybe rdr_name
192   | Just name <- isExact_maybe rdr_name
193   = return (Just name)
194
195   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name    
196         -- This deals with the case of derived bindings, where
197         -- we don't bother to call newTopSrcBinder first
198         -- We assume there is no "parent" name
199   = do  { loc <- getSrcSpanM
200         ; n <- newGlobalBinder rdr_mod rdr_occ loc 
201         ; return (Just n)}
202
203   | otherwise
204   = do  {  -- Check for operators in type or class declarations
205            -- See Note [Type and class operator definitions]
206           let occ = rdrNameOcc rdr_name
207         ; when (isTcOcc occ && isSymOcc occ)
208                (do { op_ok <- doptM Opt_TypeOperators
209                    ; unless op_ok (addErr (opDeclErr rdr_name)) })
210
211         ; mb_gre <- lookupGreLocalRn rdr_name
212         ; case mb_gre of
213                 Nothing  -> return Nothing
214                 Just gre -> return (Just $ gre_name gre) }
215               
216
217 -----------------------------------------------
218 lookupInstDeclBndr :: Name -> RdrName -> RnM Name
219 -- This is called on the method name on the left-hand side of an 
220 -- instance declaration binding. eg.  instance Functor T where
221 --                                       fmap = ...
222 --                                       ^^^^ called on this
223 -- Regardless of how many unqualified fmaps are in scope, we want
224 -- the one that comes from the Functor class.
225 --
226 -- Furthermore, note that we take no account of whether the 
227 -- name is only in scope qualified.  I.e. even if method op is
228 -- in scope as M.op, we still allow plain 'op' on the LHS of
229 -- an instance decl
230 lookupInstDeclBndr cls rdr
231   = do { when (isQual rdr)
232               (addErr (badQualBndrErr rdr)) 
233                 -- In an instance decl you aren't allowed
234                 -- to use a qualified name for the method
235                 -- (Although it'd make perfect sense.)
236        ; lookupSubBndr (ParentIs cls) doc rdr }
237   where
238     doc = ptext (sLit "method of class") <+> quotes (ppr cls)
239
240 -----------------------------------------------
241 lookupConstructorFields :: Name -> RnM [Name]
242 -- Look up the fields of a given constructor
243 --   *  For constructors from this module, use the record field env,
244 --      which is itself gathered from the (as yet un-typechecked)
245 --      data type decls
246 -- 
247 --    * For constructors from imported modules, use the *type* environment
248 --      since imported modles are already compiled, the info is conveniently
249 --      right there
250
251 lookupConstructorFields con_name
252   = do  { this_mod <- getModule
253         ; if nameIsLocalOrFrom this_mod con_name then
254           do { RecFields field_env _ <- getRecFieldEnv
255              ; return (lookupNameEnv field_env con_name `orElse` []) }
256           else 
257           do { con <- tcLookupDataCon con_name
258              ; return (dataConFieldLabels con) } }
259
260 -----------------------------------------------
261 -- Used for record construction and pattern matching
262 -- When the -XDisambiguateRecordFields flag is on, take account of the
263 -- constructor name to disambiguate which field to use; it's just the
264 -- same as for instance decls
265 -- 
266 -- NB: Consider this:
267 --      module Foo where { data R = R { fld :: Int } }
268 --      module Odd where { import Foo; fld x = x { fld = 3 } }
269 -- Arguably this should work, because the reference to 'fld' is
270 -- unambiguous because there is only one field id 'fld' in scope.
271 -- But currently it's rejected.
272
273 lookupSubBndr :: Parent  -- NoParent   => just look it up as usual
274                          -- ParentIs p => use p to disambiguate
275               -> SDoc -> RdrName 
276               -> RnM Name
277 lookupSubBndr parent doc rdr_name
278   | Just n <- isExact_maybe rdr_name   -- This happens in derived code
279   = return n
280
281   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
282   = lookupOrig rdr_mod rdr_occ
283
284   | otherwise   -- Find all the things the rdr-name maps to
285   = do  {       -- and pick the one with the right parent name
286         ; env <- getGlobalRdrEnv
287         ; let gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)
288         ; case pick parent gres  of
289                 -- NB: lookupGlobalRdrEnv, not lookupGRE_RdrName!
290                 --     The latter does pickGREs, but we want to allow 'x'
291                 --     even if only 'M.x' is in scope
292             [gre] -> do { addUsedRdrNames (used_rdr_names gre)
293                         ; return (gre_name gre) }
294             []    -> do { addErr (unknownSubordinateErr doc rdr_name)
295                         ; traceRn (text "RnEnv.lookup_sub_bndr" <+> (ppr rdr_name $$ ppr gres))
296                         ; return (mkUnboundName rdr_name) }
297             gres  -> do { addNameClashErrRn rdr_name gres
298                         ; return (gre_name (head gres)) } }
299   where
300     pick NoParent gres          -- Normal lookup 
301       = pickGREs rdr_name gres
302     pick (ParentIs p) gres      -- Disambiguating lookup
303       | isUnqual rdr_name = filter (right_parent p) gres
304       | otherwise         = filter (right_parent p) (pickGREs rdr_name gres)
305
306     right_parent p (GRE { gre_par = ParentIs p' }) = p==p' 
307     right_parent _ _                               = False
308
309     -- Note [Usage for sub-bndrs]
310     used_rdr_names gre
311       | isQual rdr_name = [rdr_name]
312       | otherwise       = case gre_prov gre of
313                             LocalDef -> [rdr_name]
314                             Imported is -> map mk_qual_rdr is
315     mk_qual_rdr imp_spec = mkRdrQual (is_as (is_decl imp_spec)) rdr_occ
316     rdr_occ = rdrNameOcc rdr_name    
317
318 newIPNameRn :: IPName RdrName -> TcRnIf m n (IPName Name)
319 newIPNameRn ip_rdr = newIPName (mapIPName rdrNameOcc ip_rdr)
320
321 -- If the family is declared locally, it will not yet be in the main
322 -- environment; hence, we pass in an extra one here, which we check first.
323 -- See "Note [Looking up family names in family instances]" in 'RnNames'.
324 --
325 lookupFamInstDeclBndr :: GlobalRdrEnv -> Located RdrName -> RnM Name
326 lookupFamInstDeclBndr tyclGroupEnv (L loc rdr_name)
327   = setSrcSpan loc $
328       case lookupGRE_RdrName rdr_name tyclGroupEnv of
329         (gre:_) -> return $ gre_name gre
330           -- if there is more than one, an error will be raised elsewhere
331         []      -> lookupOccRn rdr_name
332 \end{code}
333
334 Note [Usage for sub-bndrs]
335 ~~~~~~~~~~~~~~~~~~~~~~~~~~
336 If you have this
337    import qualified M( C( f ) ) 
338    intance M.C T where
339      f x = x
340 then is the qualified import M.f used?  Obviously yes.
341 But the RdrName used in the instance decl is unqualified.  In effect,
342 we fill in the qualification by looking for f's whose class is M.C
343 But when adding to the UsedRdrNames we must make that qualification
344 explicit, otherwise we get "Redundant import of M.C".
345
346 --------------------------------------------------
347 --              Occurrences
348 --------------------------------------------------
349
350 \begin{code}
351 getLookupOccRn :: RnM (Name -> Maybe Name)
352 getLookupOccRn
353   = getLocalRdrEnv                      `thenM` \ local_env ->
354     return (lookupLocalRdrOcc local_env . nameOccName)
355
356 lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
357 lookupLocatedOccRn = wrapLocM lookupOccRn
358
359 -- lookupOccRn looks up an occurrence of a RdrName
360 lookupOccRn :: RdrName -> RnM Name
361 lookupOccRn rdr_name
362   = getLocalRdrEnv                      `thenM` \ local_env ->
363     case lookupLocalRdrEnv local_env rdr_name of
364           Just name -> return name
365           Nothing   -> lookupGlobalOccRn rdr_name
366
367 lookupLocatedGlobalOccRn :: Located RdrName -> RnM (Located Name)
368 lookupLocatedGlobalOccRn = wrapLocM lookupGlobalOccRn
369
370 lookupGlobalOccRn :: RdrName -> RnM Name
371 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global 
372 -- environment.  Adds an error message if the RdrName is not in scope.
373 -- Also has a special case for GHCi.
374
375 lookupGlobalOccRn rdr_name
376   = do { -- First look up the name in the normal environment.
377          mb_name <- lookupGlobalOccRn_maybe rdr_name
378        ; case mb_name of {
379                 Just n  -> return n ;
380                 Nothing -> do
381
382        { -- We allow qualified names on the command line to refer to 
383          --  *any* name exported by any module in scope, just as if there
384          -- was an "import qualified M" declaration for every module.
385          allow_qual <- doptM Opt_ImplicitImportQualified
386        ; mod <- getModule
387                -- This test is not expensive,
388                -- and only happens for failed lookups
389        ; if isQual rdr_name && allow_qual && mod == iNTERACTIVE
390          then lookupQualifiedName rdr_name
391          else unboundName rdr_name } } }
392
393 lookupGlobalOccRn_maybe :: RdrName -> RnM (Maybe Name)
394 -- No filter function; does not report an error on failure
395
396 lookupGlobalOccRn_maybe rdr_name
397   | Just n <- isExact_maybe rdr_name   -- This happens in derived code
398   = return (Just n)
399
400   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
401   = do { n <- lookupOrig rdr_mod rdr_occ; return (Just n) }
402
403   | otherwise
404   = do  { mb_gre <- lookupGreRn_maybe rdr_name
405         ; case mb_gre of
406                 Nothing  -> return Nothing
407                 Just gre -> return (Just (gre_name gre)) }
408
409
410 unboundName :: RdrName -> RnM Name
411 unboundName rdr_name 
412   = do  { addErr (unknownNameErr rdr_name)
413         ; env <- getGlobalRdrEnv;
414         ; traceRn (vcat [unknownNameErr rdr_name, 
415                          ptext (sLit "Global envt is:"),
416                          nest 3 (pprGlobalRdrEnv env)])
417         ; return (mkUnboundName rdr_name) }
418
419 --------------------------------------------------
420 --      Lookup in the Global RdrEnv of the module
421 --------------------------------------------------
422
423 lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
424 -- Just look up the RdrName in the GlobalRdrEnv
425 lookupGreRn_maybe rdr_name 
426   = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
427
428 lookupGreRn :: RdrName -> RnM GlobalRdrElt
429 -- If not found, add error message, and return a fake GRE
430 lookupGreRn rdr_name 
431   = do  { mb_gre <- lookupGreRn_maybe rdr_name
432         ; case mb_gre of {
433             Just gre -> return gre ;
434             Nothing  -> do
435         { traceRn $ text "lookupGreRn"
436         ; name <- unboundName rdr_name
437         ; return (GRE { gre_name = name, gre_par = NoParent,
438                         gre_prov = LocalDef }) }}}
439
440 lookupGreLocalRn :: RdrName -> RnM (Maybe GlobalRdrElt)
441 -- Similar, but restricted to locally-defined things
442 lookupGreLocalRn rdr_name 
443   = lookupGreRn_help rdr_name lookup_fn
444   where
445     lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)
446
447 lookupGreRn_help :: RdrName                     -- Only used in error message
448                  -> (GlobalRdrEnv -> [GlobalRdrElt])    -- Lookup function
449                  -> RnM (Maybe GlobalRdrElt)
450 -- Checks for exactly one match; reports deprecations
451 -- Returns Nothing, without error, if too few
452 lookupGreRn_help rdr_name lookup 
453   = do  { env <- getGlobalRdrEnv
454         ; case lookup env of
455             []    -> return Nothing
456             [gre] -> do { addUsedRdrName gre rdr_name
457                         ; return (Just gre) }
458             gres  -> do { addNameClashErrRn rdr_name gres
459                         ; return (Just (head gres)) } }
460
461 addUsedRdrName :: GlobalRdrElt -> RdrName -> RnM ()
462 -- Record usage of imported RdrNames
463 addUsedRdrName gre rdr
464   | isLocalGRE gre = return ()
465   | otherwise      = do { env <- getGblEnv
466                         ; updMutVar (tcg_used_rdrnames env)
467                                     (\s -> Set.insert rdr s) }
468
469 addUsedRdrNames :: [RdrName] -> RnM ()
470 -- Record used sub-binders
471 -- We don't check for imported-ness here, because it's inconvenient
472 -- and not stritly necessary.
473 addUsedRdrNames rdrs
474   = do { env <- getGblEnv
475        ; updMutVar (tcg_used_rdrnames env)
476                    (\s -> foldr Set.insert s rdrs) }
477
478 ------------------------------
479 --      GHCi support
480 ------------------------------
481
482 -- A qualified name on the command line can refer to any module at all: we
483 -- try to load the interface if we don't already have it.
484 lookupQualifiedName :: RdrName -> RnM Name
485 lookupQualifiedName rdr_name
486   | Just (mod,occ) <- isQual_maybe rdr_name
487    -- Note: we want to behave as we would for a source file import here,
488    -- and respect hiddenness of modules/packages, hence loadSrcInterface.
489    = loadSrcInterface doc mod False Nothing     `thenM` \ iface ->
490
491    case  [ (mod,occ) | 
492            (mod,avails) <- mi_exports iface,
493            avail        <- avails,
494            name         <- availNames avail,
495            name == occ ] of
496       ((mod,occ):ns) -> ASSERT (null ns) 
497                         lookupOrig mod occ
498       _ -> unboundName rdr_name
499
500   | otherwise
501   = pprPanic "RnEnv.lookupQualifiedName" (ppr rdr_name)
502   where
503     doc = ptext (sLit "Need to find") <+> ppr rdr_name
504 \end{code}
505
506 lookupSigOccRn is used for type signatures and pragmas
507 Is this valid?
508   module A
509         import M( f )
510         f :: Int -> Int
511         f x = x
512 It's clear that the 'f' in the signature must refer to A.f
513 The Haskell98 report does not stipulate this, but it will!
514 So we must treat the 'f' in the signature in the same way
515 as the binding occurrence of 'f', using lookupBndrRn
516
517 However, consider this case:
518         import M( f )
519         f :: Int -> Int
520         g x = x
521 We don't want to say 'f' is out of scope; instead, we want to
522 return the imported 'f', so that later on the reanamer will
523 correctly report "misplaced type sig".
524
525 \begin{code}
526 lookupSigOccRn :: Maybe NameSet    -- Just ns => source file; these are the binders
527                                    --            in the same group
528                                    -- Nothing => hs-boot file; signatures without 
529                                    --            binders are expected
530                -> Sig RdrName
531                -> Located RdrName -> RnM (Located Name)
532 lookupSigOccRn mb_bound_names sig
533   = wrapLocM $ \ rdr_name -> 
534     do { mb_name <- lookupBindGroupOcc mb_bound_names (hsSigDoc sig) rdr_name
535        ; case mb_name of
536            Left err   -> do { addErr err; return (mkUnboundName rdr_name) }
537            Right name -> return name }
538
539 lookupBindGroupOcc :: Maybe NameSet  -- Just ns => source file; these are the binders
540                                      --                  in the same group
541                                      -- Nothing => hs-boot file; signatures without 
542                                      --                  binders are expected
543                    -> SDoc
544                    -> RdrName -> RnM (Either Message Name)
545 -- Looks up the RdrName, expecting it to resolve to one of the 
546 -- bound names passed in.  If not, return an appropriate error message
547 lookupBindGroupOcc mb_bound_names what rdr_name
548   = do  { local_env <- getLocalRdrEnv
549         ; case lookupLocalRdrEnv local_env rdr_name of 
550             Just n  -> check_local_name n
551             Nothing -> do       -- Not defined in a nested scope
552
553         { env <- getGlobalRdrEnv 
554         ; let gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)
555         ; case (filter isLocalGRE gres) of
556             (gre:_) -> check_local_name (gre_name gre)
557                         -- If there is more than one local GRE for the 
558                         -- same OccName, that will be reported separately
559             [] | null gres -> bale_out_with empty
560                | otherwise -> bale_out_with import_msg
561         }}
562     where
563       check_local_name name     -- The name is in scope, and not imported
564           = case mb_bound_names of
565                   Just bound_names | not (name `elemNameSet` bound_names)
566                                    -> bale_out_with local_msg
567                   _other -> return (Right name)
568
569       bale_out_with msg 
570         = return (Left (sep [ ptext (sLit "The") <+> what
571                                 <+> ptext (sLit "for") <+> quotes (ppr rdr_name)
572                            , nest 2 $ ptext (sLit "lacks an accompanying binding")]
573                        $$ nest 2 msg))
574
575       local_msg = parens $ ptext (sLit "The")  <+> what <+> ptext (sLit "must be given where")
576                            <+> quotes (ppr rdr_name) <+> ptext (sLit "is declared")
577
578       import_msg = parens $ ptext (sLit "You cannot give a") <+> what
579                           <+> ptext (sLit "for an imported value")
580
581 ---------------
582 lookupLocalDataTcNames :: NameSet -> SDoc -> RdrName -> RnM [Name]
583 -- GHC extension: look up both the tycon and data con 
584 -- for con-like things
585 -- Complain if neither is in scope
586 lookupLocalDataTcNames bound_names what rdr_name
587   | Just n <- isExact_maybe rdr_name    
588         -- Special case for (:), which doesn't get into the GlobalRdrEnv
589   = return [n]  -- For this we don't need to try the tycon too
590   | otherwise
591   = do  { mb_gres <- mapM (lookupBindGroupOcc (Just bound_names) what)
592                           (dataTcOccs rdr_name)
593         ; let (errs, names) = splitEithers mb_gres
594         ; when (null names) (addErr (head errs))        -- Bleat about one only
595         ; return names }
596
597 dataTcOccs :: RdrName -> [RdrName]
598 -- If the input is a data constructor, return both it and a type
599 -- constructor.  This is useful when we aren't sure which we are
600 -- looking at.
601 dataTcOccs rdr_name
602   | Just n <- isExact_maybe rdr_name            -- Ghastly special case
603   , n `hasKey` consDataConKey = [rdr_name]      -- see note below
604   | isDataOcc occ             = [rdr_name, rdr_name_tc]
605   | otherwise                 = [rdr_name]
606   where    
607     occ         = rdrNameOcc rdr_name
608     rdr_name_tc = setRdrNameSpace rdr_name tcName
609
610 -- If the user typed "[]" or "(,,)", we'll generate an Exact RdrName,
611 -- and setRdrNameSpace generates an Orig, which is fine
612 -- But it's not fine for (:), because there *is* no corresponding type
613 -- constructor.  If we generate an Orig tycon for GHC.Base.(:), it'll
614 -- appear to be in scope (because Orig's simply allocate a new name-cache
615 -- entry) and then we get an error when we use dataTcOccs in 
616 -- TcRnDriver.tcRnGetInfo.  Large sigh.
617 \end{code}
618
619
620 %*********************************************************
621 %*                                                      *
622                 Fixities
623 %*                                                      *
624 %*********************************************************
625
626 \begin{code}
627 --------------------------------
628 type FastStringEnv a = UniqFM a         -- Keyed by FastString
629
630
631 emptyFsEnv  :: FastStringEnv a
632 lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a
633 extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a
634
635 emptyFsEnv  = emptyUFM
636 lookupFsEnv = lookupUFM
637 extendFsEnv = addToUFM
638
639 --------------------------------
640 type MiniFixityEnv = FastStringEnv (Located Fixity)
641         -- Mini fixity env for the names we're about 
642         -- to bind, in a single binding group
643         --
644         -- It is keyed by the *FastString*, not the *OccName*, because
645         -- the single fixity decl       infix 3 T
646         -- affects both the data constructor T and the type constrctor T
647         --
648         -- We keep the location so that if we find
649         -- a duplicate, we can report it sensibly
650
651 --------------------------------
652 -- Used for nested fixity decls to bind names along with their fixities.
653 -- the fixities are given as a UFM from an OccName's FastString to a fixity decl
654 bindLocalNamesFV_WithFixities :: [Name]
655                               -> MiniFixityEnv
656                               -> RnM (a, FreeVars) -> RnM (a, FreeVars)
657 bindLocalNamesFV_WithFixities names fixities thing_inside
658   = bindLocalNamesFV names $
659     extendFixityEnv boundFixities $ 
660     thing_inside
661   where
662     -- find the names that have fixity decls
663     boundFixities = foldr 
664                         (\ name -> \ acc -> 
665                          -- check whether this name has a fixity decl
666                           case lookupFsEnv fixities (occNameFS (nameOccName name)) of
667                                Just (L _ fix) -> (name, FixItem (nameOccName name) fix) : acc
668                                Nothing -> acc) [] names
669     -- bind the names; extend the fixity env; do the thing inside
670 \end{code}
671
672 --------------------------------
673 lookupFixity is a bit strange.  
674
675 * Nested local fixity decls are put in the local fixity env, which we
676   find with getFixtyEnv
677
678 * Imported fixities are found in the HIT or PIT
679
680 * Top-level fixity decls in this module may be for Names that are
681     either  Global         (constructors, class operations)
682     or      Local/Exported (everything else)
683   (See notes with RnNames.getLocalDeclBinders for why we have this split.)
684   We put them all in the local fixity environment
685
686 \begin{code}
687 lookupFixityRn :: Name -> RnM Fixity
688 lookupFixityRn name
689   = getModule                           `thenM` \ this_mod -> 
690     if nameIsLocalOrFrom this_mod name
691     then do     -- It's defined in this module
692       local_fix_env <- getFixityEnv             
693       traceRn (text "lookupFixityRn: looking up name in local environment:" <+> 
694                vcat [ppr name, ppr local_fix_env])
695       return $ lookupFixity local_fix_env name
696     else        -- It's imported
697       -- For imported names, we have to get their fixities by doing a
698       -- loadInterfaceForName, and consulting the Ifaces that comes back
699       -- from that, because the interface file for the Name might not
700       -- have been loaded yet.  Why not?  Suppose you import module A,
701       -- which exports a function 'f', thus;
702       --        module CurrentModule where
703       --          import A( f )
704       --        module A( f ) where
705       --          import B( f )
706       -- Then B isn't loaded right away (after all, it's possible that
707       -- nothing from B will be used).  When we come across a use of
708       -- 'f', we need to know its fixity, and it's then, and only
709       -- then, that we load B.hi.  That is what's happening here.
710       --
711       -- loadInterfaceForName will find B.hi even if B is a hidden module,
712       -- and that's what we want.
713         loadInterfaceForName doc name   `thenM` \ iface -> do {
714           traceRn (text "lookupFixityRn: looking up name in iface cache and found:" <+> 
715                    vcat [ppr name, ppr $ mi_fix_fn iface (nameOccName name)]);
716            return (mi_fix_fn iface (nameOccName name))
717                                                            }
718   where
719     doc = ptext (sLit "Checking fixity for") <+> ppr name
720
721 ---------------
722 lookupTyFixityRn :: Located Name -> RnM Fixity
723 lookupTyFixityRn (L _ n) = lookupFixityRn n
724
725 \end{code}
726
727 %************************************************************************
728 %*                                                                      *
729                         Rebindable names
730         Dealing with rebindable syntax is driven by the 
731         Opt_NoImplicitPrelude dynamic flag.
732
733         In "deriving" code we don't want to use rebindable syntax
734         so we switch off the flag locally
735
736 %*                                                                      *
737 %************************************************************************
738
739 Haskell 98 says that when you say "3" you get the "fromInteger" from the
740 Standard Prelude, regardless of what is in scope.   However, to experiment
741 with having a language that is less coupled to the standard prelude, we're
742 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
743 happens to be in scope.  Then you can
744         import Prelude ()
745         import MyPrelude as Prelude
746 to get the desired effect.
747
748 At the moment this just happens for
749   * fromInteger, fromRational on literals (in expressions and patterns)
750   * negate (in expressions)
751   * minus  (arising from n+k patterns)
752   * "do" notation
753
754 We store the relevant Name in the HsSyn tree, in 
755   * HsIntegral/HsFractional/HsIsString
756   * NegApp
757   * NPlusKPat
758   * HsDo
759 respectively.  Initially, we just store the "standard" name (PrelNames.fromIntegralName,
760 fromRationalName etc), but the renamer changes this to the appropriate user
761 name if Opt_NoImplicitPrelude is on.  That is what lookupSyntaxName does.
762
763 We treat the orignal (standard) names as free-vars too, because the type checker
764 checks the type of the user thing against the type of the standard thing.
765
766 \begin{code}
767 lookupSyntaxName :: Name                                -- The standard name
768                  -> RnM (SyntaxExpr Name, FreeVars)     -- Possibly a non-standard name
769 lookupSyntaxName std_name
770   = doptM Opt_ImplicitPrelude           `thenM` \ implicit_prelude -> 
771     if implicit_prelude then normal_case
772     else
773         -- Get the similarly named thing from the local environment
774     lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenM` \ usr_name ->
775     return (HsVar usr_name, unitFV usr_name)
776   where
777     normal_case = return (HsVar std_name, emptyFVs)
778
779 lookupSyntaxTable :: [Name]                             -- Standard names
780                   -> RnM (SyntaxTable Name, FreeVars)   -- See comments with HsExpr.ReboundNames
781 lookupSyntaxTable std_names
782   = doptM Opt_ImplicitPrelude           `thenM` \ implicit_prelude -> 
783     if implicit_prelude then normal_case 
784     else
785         -- Get the similarly named thing from the local environment
786     mapM (lookupOccRn . mkRdrUnqual . nameOccName) std_names    `thenM` \ usr_names ->
787
788     return (std_names `zip` map HsVar usr_names, mkFVs usr_names)
789   where
790     normal_case = return (std_names `zip` map HsVar std_names, emptyFVs)
791 \end{code}
792
793
794 %*********************************************************
795 %*                                                      *
796 \subsection{Binding}
797 %*                                                      *
798 %*********************************************************
799
800 \begin{code}
801 newLocalBndrRn :: Located RdrName -> RnM Name
802 -- Used for non-top-level binders.  These should
803 -- never be qualified.
804 newLocalBndrRn (L loc rdr_name)
805   | Just name <- isExact_maybe rdr_name 
806   = return name -- This happens in code generated by Template Haskell
807                 -- although I'm not sure why. Perhpas it's the call
808                 -- in RnPat.newName LetMk?
809   | otherwise
810   = do { unless (isUnqual rdr_name)
811                 (addErrAt loc (badQualBndrErr rdr_name))
812        ; uniq <- newUnique
813        ; return (mkInternalName uniq (rdrNameOcc rdr_name) loc) }
814
815 newLocalBndrsRn :: [Located RdrName] -> RnM [Name]
816 newLocalBndrsRn = mapM newLocalBndrRn
817
818 ---------------------
819 bindLocatedLocalsRn :: [Located RdrName]
820                     -> ([Name] -> RnM a)
821                     -> RnM a
822 bindLocatedLocalsRn rdr_names_w_loc enclosed_scope
823   = do { checkDupAndShadowedRdrNames rdr_names_w_loc
824
825         -- Make fresh Names and extend the environment
826        ; names <- newLocalBndrsRn rdr_names_w_loc
827        ; bindLocalNames names (enclosed_scope names) }
828
829 bindLocalNames :: [Name] -> RnM a -> RnM a
830 bindLocalNames names enclosed_scope
831   = do { name_env <- getLocalRdrEnv
832        ; setLocalRdrEnv (extendLocalRdrEnvList name_env names)
833                         enclosed_scope }
834
835 bindLocalName :: Name -> RnM a -> RnM a
836 bindLocalName name enclosed_scope
837   = do { name_env <- getLocalRdrEnv
838        ; setLocalRdrEnv (extendLocalRdrEnv name_env name)
839                         enclosed_scope }
840
841 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
842 bindLocalNamesFV names enclosed_scope
843   = do  { (result, fvs) <- bindLocalNames names enclosed_scope
844         ; return (result, delListFromNameSet fvs names) }
845
846
847 -------------------------------------
848         -- binLocalsFVRn is the same as bindLocalsRn
849         -- except that it deals with free vars
850 bindLocatedLocalsFV :: [Located RdrName] 
851                     -> ([Name] -> RnM (a,FreeVars)) -> RnM (a, FreeVars)
852 bindLocatedLocalsFV rdr_names enclosed_scope
853   = bindLocatedLocalsRn rdr_names       $ \ names ->
854     enclosed_scope names                `thenM` \ (thing, fvs) ->
855     return (thing, delListFromNameSet fvs names)
856
857 -------------------------------------
858 bindTyVarsRn ::  [LHsTyVarBndr RdrName]
859               -> ([LHsTyVarBndr Name] -> RnM a)
860               -> RnM a
861 -- Haskell-98 binding of type variables; e.g. within a data type decl
862 bindTyVarsRn tyvar_names enclosed_scope
863   = bindLocatedLocalsRn located_tyvars  $ \ names ->
864     do { kind_sigs_ok <- doptM Opt_KindSignatures
865        ; unless (null kinded_tyvars || kind_sigs_ok) 
866                 (mapM_ (addErr . kindSigErr) kinded_tyvars)
867        ; enclosed_scope (zipWith replace tyvar_names names) }
868   where 
869     replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
870     located_tyvars = hsLTyVarLocNames tyvar_names
871     kinded_tyvars  = [n | L _ (KindedTyVar n _) <- tyvar_names]
872
873 bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
874   -- Find the type variables in the pattern type 
875   -- signatures that must be brought into scope
876 bindPatSigTyVars tys thing_inside
877   = do  { scoped_tyvars <- doptM Opt_ScopedTypeVariables
878         ; if not scoped_tyvars then 
879                 thing_inside []
880           else 
881     do  { name_env <- getLocalRdrEnv
882         ; let locd_tvs  = [ tv | ty <- tys
883                                , tv <- extractHsTyRdrTyVars ty
884                                , not (unLoc tv `elemLocalRdrEnv` name_env) ]
885               nubbed_tvs = nubBy eqLocated locd_tvs
886                 -- The 'nub' is important.  For example:
887                 --      f (x :: t) (y :: t) = ....
888                 -- We don't want to complain about binding t twice!
889
890         ; bindLocatedLocalsRn nubbed_tvs thing_inside }}
891
892 bindPatSigTyVarsFV :: [LHsType RdrName]
893                    -> RnM (a, FreeVars)
894                    -> RnM (a, FreeVars)
895 bindPatSigTyVarsFV tys thing_inside
896   = bindPatSigTyVars tys        $ \ tvs ->
897     thing_inside                `thenM` \ (result,fvs) ->
898     return (result, fvs `delListFromNameSet` tvs)
899
900 bindSigTyVarsFV :: [Name]
901                 -> RnM (a, FreeVars)
902                 -> RnM (a, FreeVars)
903 bindSigTyVarsFV tvs thing_inside
904   = do  { scoped_tyvars <- doptM Opt_ScopedTypeVariables
905         ; if not scoped_tyvars then 
906                 thing_inside 
907           else
908                 bindLocalNamesFV tvs thing_inside }
909
910 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
911         -- This function is used only in rnSourceDecl on InstDecl
912 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
913
914 -------------------------------------
915 checkDupRdrNames :: [Located RdrName] -> RnM ()
916 checkDupRdrNames rdr_names_w_loc
917   =     -- Check for duplicated names in a binding group
918     mapM_ (dupNamesErr getLoc) dups
919   where
920     (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
921
922 checkDupNames :: [Name] -> RnM ()
923 checkDupNames names
924   =     -- Check for duplicated names in a binding group
925     mapM_ (dupNamesErr nameSrcSpan) dups
926   where
927     (_, dups) = removeDups (\n1 n2 -> nameOccName n1 `compare` nameOccName n2) names
928
929 ---------------------
930 checkDupAndShadowedRdrNames :: [Located RdrName] -> RnM ()
931 checkDupAndShadowedRdrNames loc_rdr_names
932   = do  { checkDupRdrNames loc_rdr_names
933         ; envs <- getRdrEnvs
934         ; checkShadowedOccs envs loc_occs }
935   where
936     loc_occs = [(loc,rdrNameOcc rdr) | L loc rdr <- loc_rdr_names]
937
938 checkDupAndShadowedNames :: (GlobalRdrEnv, LocalRdrEnv) -> [Name] -> RnM ()
939 checkDupAndShadowedNames envs names
940   = do { checkDupNames names
941        ; checkShadowedOccs envs loc_occs }
942   where
943     loc_occs = [(nameSrcSpan name, nameOccName name) | name <- names]
944
945 -------------------------------------
946 checkShadowedOccs :: (GlobalRdrEnv, LocalRdrEnv) -> [(SrcSpan,OccName)] -> RnM ()
947 checkShadowedOccs (global_env,local_env) loc_occs
948   = ifOptM Opt_WarnNameShadowing $ 
949     do  { traceRn (text "shadow" <+> ppr loc_occs)
950         ; mapM_ check_shadow loc_occs }
951   where
952     check_shadow (loc, occ)
953         | startsWithUnderscore occ = return ()  -- Do not report shadowing for "_x"
954                                                 -- See Trac #3262
955         | Just n <- mb_local = complain [ptext (sLit "bound at") <+> ppr (nameSrcLoc n)]
956         | otherwise = do { gres' <- filterM is_shadowed_gre gres
957                          ; complain (map pprNameProvenance gres') }
958         where
959           complain []      = return ()
960           complain pp_locs = addWarnAt loc (shadowedNameWarn occ pp_locs)
961           mb_local = lookupLocalRdrOcc local_env occ
962           gres     = lookupGRE_RdrName (mkRdrUnqual occ) global_env
963                 -- Make an Unqualified RdrName and look that up, so that
964                 -- we don't find any GREs that are in scope qualified-only
965
966     is_shadowed_gre :: GlobalRdrElt -> RnM Bool 
967         -- Returns False for record selectors that are shadowed, when
968         -- punning or wild-cards are on (cf Trac #2723)
969     is_shadowed_gre gre@(GRE { gre_par = ParentIs _ })
970         = do { dflags <- getDOpts
971              ; if (dopt Opt_RecordPuns dflags || dopt Opt_RecordWildCards dflags) 
972                then do { is_fld <- is_rec_fld gre; return (not is_fld) }
973                else return True }
974     is_shadowed_gre _other = return True
975
976     is_rec_fld gre      -- Return True for record selector ids
977         | isLocalGRE gre = do { RecFields _ fld_set <- getRecFieldEnv
978                               ; return (gre_name gre `elemNameSet` fld_set) }
979         | otherwise      = do { sel_id <- tcLookupField (gre_name gre)
980                               ; return (isRecordSelector sel_id) }
981 \end{code}
982
983
984 %************************************************************************
985 %*                                                                      *
986 \subsection{Free variable manipulation}
987 %*                                                                      *
988 %************************************************************************
989
990 \begin{code}
991 -- A useful utility
992 addFvRn :: FreeVars -> RnM (thing, FreeVars) -> RnM (thing, FreeVars)
993 addFvRn fvs1 thing_inside = do { (res, fvs2) <- thing_inside
994                                ; return (res, fvs1 `plusFV` fvs2) }
995
996 mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
997 mapFvRn f xs = do stuff <- mapM f xs
998                   case unzip stuff of
999                       (ys, fvs_s) -> return (ys, plusFVs fvs_s)
1000
1001 mapMaybeFvRn :: (a -> RnM (b, FreeVars)) -> Maybe a -> RnM (Maybe b, FreeVars)
1002 mapMaybeFvRn _ Nothing = return (Nothing, emptyFVs)
1003 mapMaybeFvRn f (Just x) = do { (y, fvs) <- f x; return (Just y, fvs) }
1004
1005 -- because some of the rename functions are CPSed:
1006 -- maps the function across the list from left to right; 
1007 -- collects all the free vars into one set
1008 mapFvRnCPS :: (a  -> (b   -> RnM c) -> RnM c) 
1009            -> [a] -> ([b] -> RnM c) -> RnM c
1010
1011 mapFvRnCPS _ []     cont = cont []
1012 mapFvRnCPS f (x:xs) cont = f x             $ \ x' -> 
1013                            mapFvRnCPS f xs $ \ xs' ->
1014                            cont (x':xs')
1015 \end{code}
1016
1017
1018 %************************************************************************
1019 %*                                                                      *
1020 \subsection{Envt utility functions}
1021 %*                                                                      *
1022 %************************************************************************
1023
1024 \begin{code}
1025 warnUnusedModules :: [(ModuleName,SrcSpan)] -> RnM ()
1026 warnUnusedModules mods
1027   = ifOptM Opt_WarnUnusedImports (mapM_ bleat mods)
1028   where
1029     bleat (mod,loc) = addWarnAt loc (mk_warn mod)
1030     mk_warn m = vcat [ptext (sLit "Module") <+> quotes (ppr m)
1031                         <+> text "is imported, but nothing from it is used,",
1032                       nest 2 (ptext (sLit "except perhaps instances visible in") 
1033                         <+> quotes (ppr m)),
1034                       ptext (sLit "To suppress this warning, use:") 
1035                         <+> ptext (sLit "import") <+> ppr m <> parens empty ]
1036
1037
1038 warnUnusedImports, warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
1039 warnUnusedImports gres  = ifOptM Opt_WarnUnusedImports (warnUnusedGREs gres)
1040 warnUnusedTopBinds gres = ifOptM Opt_WarnUnusedBinds   (warnUnusedGREs gres)
1041
1042 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> FreeVars -> RnM ()
1043 warnUnusedLocalBinds = check_unused Opt_WarnUnusedBinds
1044 warnUnusedMatches    = check_unused Opt_WarnUnusedMatches
1045
1046 check_unused :: DynFlag -> [Name] -> FreeVars -> RnM ()
1047 check_unused flag bound_names used_names
1048  = ifOptM flag (warnUnusedLocals (filterOut (`elemNameSet` used_names) bound_names))
1049
1050 -------------------------
1051 --      Helpers
1052 warnUnusedGREs :: [GlobalRdrElt] -> RnM ()
1053 warnUnusedGREs gres 
1054  = warnUnusedBinds [(n,p) | GRE {gre_name = n, gre_prov = p} <- gres]
1055
1056 warnUnusedLocals :: [Name] -> RnM ()
1057 warnUnusedLocals names
1058  = warnUnusedBinds [(n,LocalDef) | n<-names]
1059
1060 warnUnusedBinds :: [(Name,Provenance)] -> RnM ()
1061 warnUnusedBinds names  = mapM_ warnUnusedName (filter reportable names)
1062  where reportable (name,_) 
1063         | isWiredInName name = False    -- Don't report unused wired-in names
1064                                         -- Otherwise we get a zillion warnings
1065                                         -- from Data.Tuple
1066         | otherwise = not (startsWithUnderscore (nameOccName name))
1067
1068 -------------------------
1069
1070 warnUnusedName :: (Name, Provenance) -> RnM ()
1071 warnUnusedName (name, LocalDef)
1072   = addUnusedWarning name (nameSrcSpan name)
1073                      (ptext (sLit "Defined but not used"))
1074
1075 warnUnusedName (name, Imported is)
1076   = mapM_ warn is
1077   where
1078     warn spec = addUnusedWarning name span msg
1079         where
1080            span = importSpecLoc spec
1081            pp_mod = quotes (ppr (importSpecModule spec))
1082            msg = ptext (sLit "Imported from") <+> pp_mod <+> ptext (sLit "but not used")
1083
1084 addUnusedWarning :: Name -> SrcSpan -> SDoc -> RnM ()
1085 addUnusedWarning name span msg
1086   = addWarnAt span $
1087     sep [msg <> colon, 
1088          nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
1089                         <+> quotes (ppr name)]
1090 \end{code}
1091
1092 \begin{code}
1093 addNameClashErrRn :: RdrName -> [GlobalRdrElt] -> RnM ()
1094 addNameClashErrRn rdr_name names
1095   = addErr (vcat [ptext (sLit "Ambiguous occurrence") <+> quotes (ppr rdr_name),
1096                   ptext (sLit "It could refer to") <+> vcat (msg1 : msgs)])
1097   where
1098     (np1:nps) = names
1099     msg1 = ptext  (sLit "either") <+> mk_ref np1
1100     msgs = [ptext (sLit "    or") <+> mk_ref np | np <- nps]
1101     mk_ref gre = quotes (ppr (gre_name gre)) <> comma <+> pprNameProvenance gre
1102
1103 shadowedNameWarn :: OccName -> [SDoc] -> SDoc
1104 shadowedNameWarn occ shadowed_locs
1105   = sep [ptext (sLit "This binding for") <+> quotes (ppr occ)
1106             <+> ptext (sLit "shadows the existing binding") <> plural shadowed_locs,
1107          nest 2 (vcat shadowed_locs)]
1108
1109 unknownNameErr :: RdrName -> SDoc
1110 unknownNameErr rdr_name
1111   = vcat [ hang (ptext (sLit "Not in scope:")) 
1112               2 (pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))
1113                           <+> quotes (ppr rdr_name))
1114          , extra ]
1115   where
1116     extra | rdr_name == forall_tv_RDR = perhapsForallMsg
1117           | otherwise                 = empty
1118
1119 perhapsForallMsg :: SDoc
1120 perhapsForallMsg 
1121   = vcat [ ptext (sLit "Perhaps you intended to use -XExplicitForAll or similar flag")
1122          , ptext (sLit "to enable explicit-forall syntax: forall <tvs>. <type>")]
1123
1124 unknownSubordinateErr :: SDoc -> RdrName -> SDoc
1125 unknownSubordinateErr doc op    -- Doc is "method of class" or 
1126                                 -- "field of constructor"
1127   = quotes (ppr op) <+> ptext (sLit "is not a (visible)") <+> doc
1128
1129 badOrigBinding :: RdrName -> SDoc
1130 badOrigBinding name
1131   = ptext (sLit "Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
1132         -- The rdrNameOcc is because we don't want to print Prelude.(,)
1133
1134 dupNamesErr :: Outputable n => (n -> SrcSpan) -> [n] -> RnM ()
1135 dupNamesErr get_loc names
1136   = addErrAt big_loc $
1137     vcat [ptext (sLit "Conflicting definitions for") <+> quotes (ppr (head names)),
1138           locations]
1139   where
1140     locs      = map get_loc names
1141     big_loc   = foldr1 combineSrcSpans locs
1142     locations = ptext (sLit "Bound at:") <+> vcat (map ppr (sortLe (<=) locs))
1143
1144 kindSigErr :: Outputable a => a -> SDoc
1145 kindSigErr thing
1146   = hang (ptext (sLit "Illegal kind signature for") <+> quotes (ppr thing))
1147        2 (ptext (sLit "Perhaps you intended to use -XKindSignatures"))
1148
1149
1150 badQualBndrErr :: RdrName -> SDoc
1151 badQualBndrErr rdr_name
1152   = ptext (sLit "Qualified name in binding position:") <+> ppr rdr_name
1153
1154 opDeclErr :: RdrName -> SDoc
1155 opDeclErr n 
1156   = hang (ptext (sLit "Illegal declaration of a type or class operator") <+> quotes (ppr n))
1157        2 (ptext (sLit "Use -XTypeOperators to declare operators in type and declarations"))
1158 \end{code}