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