Improve semantics of wild-card expansion (fixes #5334)
[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  [ (mod,occ) | 
513            (mod,avails) <- mi_exports iface,
514            avail        <- avails,
515            name         <- availNames avail,
516            name == occ ] of
517       ((mod,occ):ns) -> ASSERT (null ns) 
518                         lookupOrig mod occ
519       _ -> unboundName WL_Any rdr_name
520
521   | otherwise
522   = pprPanic "RnEnv.lookupQualifiedName" (ppr rdr_name)
523   where
524     doc = ptext (sLit "Need to find") <+> ppr rdr_name
525 \end{code}
526
527 Note [Looking up signature names]
528 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
529 lookupSigOccRn is used for type signatures and pragmas
530 Is this valid?
531   module A
532         import M( f )
533         f :: Int -> Int
534         f x = x
535 It's clear that the 'f' in the signature must refer to A.f
536 The Haskell98 report does not stipulate this, but it will!
537 So we must treat the 'f' in the signature in the same way
538 as the binding occurrence of 'f', using lookupBndrRn
539
540 However, consider this case:
541         import M( f )
542         f :: Int -> Int
543         g x = x
544 We don't want to say 'f' is out of scope; instead, we want to
545 return the imported 'f', so that later on the reanamer will
546 correctly report "misplaced type sig".
547
548 \begin{code}
549 lookupSigOccRn :: Maybe NameSet    -- Just ns => these are the binders
550                                    --            in the same group
551                                    -- Nothing => signatures without 
552                                    --            binders are expected
553                                    --            (a) top-level (SPECIALISE prags)
554                                    --            (b) class decls
555                                    --            (c) hs-boot files
556                -> Sig RdrName
557                -> Located RdrName -> RnM (Located Name)
558 lookupSigOccRn mb_bound_names sig
559   = wrapLocM $ \ rdr_name -> 
560     do { mb_name <- lookupBindGroupOcc mb_bound_names (hsSigDoc sig) rdr_name
561        ; case mb_name of
562            Left err   -> do { addErr err; return (mkUnboundName rdr_name) }
563            Right name -> return name }
564
565 lookupBindGroupOcc :: Maybe NameSet  -- See notes on the (Maybe NameSet)
566                    -> SDoc           --  in lookupSigOccRn
567                    -> RdrName -> RnM (Either Message Name)
568 -- Looks up the RdrName, expecting it to resolve to one of the 
569 -- bound names passed in.  If not, return an appropriate error message
570 --
571 -- See Note [Looking up signature names]
572 lookupBindGroupOcc mb_bound_names what rdr_name
573   = do  { local_env <- getLocalRdrEnv
574         ; case lookupLocalRdrEnv local_env rdr_name of {
575             Just n  -> check_local_name n;
576             Nothing -> do       -- Not defined in a nested scope
577
578         { env <- getGlobalRdrEnv 
579         ; let gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)
580         ; case (filter isLocalGRE gres) of
581             (gre:_) -> check_local_name (gre_name gre)
582                         -- If there is more than one local GRE for the 
583                         -- same OccName 'f', that will be reported separately
584                         -- as a duplicate top-level binding for 'f'
585             [] | null gres -> bale_out_with empty
586                | otherwise -> bale_out_with import_msg
587         }}}
588     where
589       check_local_name name     -- The name is in scope, and not imported
590           = case mb_bound_names of
591                   Just bound_names | not (name `elemNameSet` bound_names)
592                                    -> bale_out_with local_msg
593                   _other -> return (Right name)
594
595       bale_out_with msg 
596         = return (Left (sep [ ptext (sLit "The") <+> what
597                                 <+> ptext (sLit "for") <+> quotes (ppr rdr_name)
598                            , nest 2 $ ptext (sLit "lacks an accompanying binding")]
599                        $$ nest 2 msg))
600
601       local_msg = parens $ ptext (sLit "The")  <+> what <+> ptext (sLit "must be given where")
602                            <+> quotes (ppr rdr_name) <+> ptext (sLit "is declared")
603
604       import_msg = parens $ ptext (sLit "You cannot give a") <+> what
605                           <+> ptext (sLit "for an imported value")
606
607 ---------------
608 lookupLocalDataTcNames :: NameSet -> SDoc -> RdrName -> RnM [Name]
609 -- GHC extension: look up both the tycon and data con 
610 -- for con-like things
611 -- Complain if neither is in scope
612 lookupLocalDataTcNames bound_names what rdr_name
613   | Just n <- isExact_maybe rdr_name    
614         -- Special case for (:), which doesn't get into the GlobalRdrEnv
615   = return [n]  -- For this we don't need to try the tycon too
616   | otherwise
617   = do  { mb_gres <- mapM (lookupBindGroupOcc (Just bound_names) what)
618                           (dataTcOccs rdr_name)
619         ; let (errs, names) = splitEithers mb_gres
620         ; when (null names) (addErr (head errs))        -- Bleat about one only
621         ; return names }
622
623 dataTcOccs :: RdrName -> [RdrName]
624 -- If the input is a data constructor, return both it and a type
625 -- constructor.  This is useful when we aren't sure which we are
626 -- looking at.
627 dataTcOccs rdr_name
628   | Just n <- isExact_maybe rdr_name            -- Ghastly special case
629   , n `hasKey` consDataConKey = [rdr_name]      -- see note below
630   | isDataOcc occ             = [rdr_name, rdr_name_tc]
631   | otherwise                 = [rdr_name]
632   where    
633     occ         = rdrNameOcc rdr_name
634     rdr_name_tc = setRdrNameSpace rdr_name tcName
635
636 -- If the user typed "[]" or "(,,)", we'll generate an Exact RdrName,
637 -- and setRdrNameSpace generates an Orig, which is fine
638 -- But it's not fine for (:), because there *is* no corresponding type
639 -- constructor.  If we generate an Orig tycon for GHC.Base.(:), it'll
640 -- appear to be in scope (because Orig's simply allocate a new name-cache
641 -- entry) and then we get an error when we use dataTcOccs in 
642 -- TcRnDriver.tcRnGetInfo.  Large sigh.
643 \end{code}
644
645
646 %*********************************************************
647 %*                                                      *
648                 Fixities
649 %*                                                      *
650 %*********************************************************
651
652 \begin{code}
653 --------------------------------
654 type FastStringEnv a = UniqFM a         -- Keyed by FastString
655
656
657 emptyFsEnv  :: FastStringEnv a
658 lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a
659 extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a
660
661 emptyFsEnv  = emptyUFM
662 lookupFsEnv = lookupUFM
663 extendFsEnv = addToUFM
664
665 --------------------------------
666 type MiniFixityEnv = FastStringEnv (Located Fixity)
667         -- Mini fixity env for the names we're about 
668         -- to bind, in a single binding group
669         --
670         -- It is keyed by the *FastString*, not the *OccName*, because
671         -- the single fixity decl       infix 3 T
672         -- affects both the data constructor T and the type constrctor T
673         --
674         -- We keep the location so that if we find
675         -- a duplicate, we can report it sensibly
676
677 --------------------------------
678 -- Used for nested fixity decls to bind names along with their fixities.
679 -- the fixities are given as a UFM from an OccName's FastString to a fixity decl
680
681 addLocalFixities :: MiniFixityEnv -> [Name] -> RnM a -> RnM a
682 addLocalFixities mini_fix_env names thing_inside
683   = extendFixityEnv (mapCatMaybes find_fixity names) thing_inside
684   where
685     find_fixity name 
686       = case lookupFsEnv mini_fix_env (occNameFS occ) of
687           Just (L _ fix) -> Just (name, FixItem occ fix)
688           Nothing        -> Nothing
689       where
690         occ = nameOccName name
691 \end{code}
692
693 --------------------------------
694 lookupFixity is a bit strange.  
695
696 * Nested local fixity decls are put in the local fixity env, which we
697   find with getFixtyEnv
698
699 * Imported fixities are found in the HIT or PIT
700
701 * Top-level fixity decls in this module may be for Names that are
702     either  Global         (constructors, class operations)
703     or      Local/Exported (everything else)
704   (See notes with RnNames.getLocalDeclBinders for why we have this split.)
705   We put them all in the local fixity environment
706
707 \begin{code}
708 lookupFixityRn :: Name -> RnM Fixity
709 lookupFixityRn name
710   = getModule                           `thenM` \ this_mod -> 
711     if nameIsLocalOrFrom this_mod name
712     then do     -- It's defined in this module
713       local_fix_env <- getFixityEnv             
714       traceRn (text "lookupFixityRn: looking up name in local environment:" <+> 
715                vcat [ppr name, ppr local_fix_env])
716       return $ lookupFixity local_fix_env name
717     else        -- It's imported
718       -- For imported names, we have to get their fixities by doing a
719       -- loadInterfaceForName, and consulting the Ifaces that comes back
720       -- from that, because the interface file for the Name might not
721       -- have been loaded yet.  Why not?  Suppose you import module A,
722       -- which exports a function 'f', thus;
723       --        module CurrentModule where
724       --          import A( f )
725       --        module A( f ) where
726       --          import B( f )
727       -- Then B isn't loaded right away (after all, it's possible that
728       -- nothing from B will be used).  When we come across a use of
729       -- 'f', we need to know its fixity, and it's then, and only
730       -- then, that we load B.hi.  That is what's happening here.
731       --
732       -- loadInterfaceForName will find B.hi even if B is a hidden module,
733       -- and that's what we want.
734         loadInterfaceForName doc name   `thenM` \ iface -> do {
735           traceRn (text "lookupFixityRn: looking up name in iface cache and found:" <+> 
736                    vcat [ppr name, ppr $ mi_fix_fn iface (nameOccName name)]);
737            return (mi_fix_fn iface (nameOccName name))
738                                                            }
739   where
740     doc = ptext (sLit "Checking fixity for") <+> ppr name
741
742 ---------------
743 lookupTyFixityRn :: Located Name -> RnM Fixity
744 lookupTyFixityRn (L _ n) = lookupFixityRn n
745
746 \end{code}
747
748 %************************************************************************
749 %*                                                                      *
750                         Rebindable names
751         Dealing with rebindable syntax is driven by the 
752         Opt_RebindableSyntax dynamic flag.
753
754         In "deriving" code we don't want to use rebindable syntax
755         so we switch off the flag locally
756
757 %*                                                                      *
758 %************************************************************************
759
760 Haskell 98 says that when you say "3" you get the "fromInteger" from the
761 Standard Prelude, regardless of what is in scope.   However, to experiment
762 with having a language that is less coupled to the standard prelude, we're
763 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
764 happens to be in scope.  Then you can
765         import Prelude ()
766         import MyPrelude as Prelude
767 to get the desired effect.
768
769 At the moment this just happens for
770   * fromInteger, fromRational on literals (in expressions and patterns)
771   * negate (in expressions)
772   * minus  (arising from n+k patterns)
773   * "do" notation
774
775 We store the relevant Name in the HsSyn tree, in 
776   * HsIntegral/HsFractional/HsIsString
777   * NegApp
778   * NPlusKPat
779   * HsDo
780 respectively.  Initially, we just store the "standard" name (PrelNames.fromIntegralName,
781 fromRationalName etc), but the renamer changes this to the appropriate user
782 name if Opt_NoImplicitPrelude is on.  That is what lookupSyntaxName does.
783
784 We treat the orignal (standard) names as free-vars too, because the type checker
785 checks the type of the user thing against the type of the standard thing.
786
787 \begin{code}
788 lookupIfThenElse :: RnM (Maybe (SyntaxExpr Name), FreeVars)
789 -- Different to lookupSyntaxName because in the non-rebindable
790 -- case we desugar directly rather than calling an existing function
791 -- Hence the (Maybe (SyntaxExpr Name)) return type
792 lookupIfThenElse 
793   = do { rebind <- xoptM Opt_RebindableSyntax
794        ; if not rebind 
795          then return (Nothing, emptyFVs)
796          else do { ite <- lookupOccRn (mkVarUnqual (fsLit "ifThenElse"))
797                  ; return (Just (HsVar ite), unitFV ite) } }
798
799 lookupSyntaxName :: Name                                -- The standard name
800                  -> RnM (SyntaxExpr Name, FreeVars)     -- Possibly a non-standard name
801 lookupSyntaxName std_name
802   = xoptM Opt_RebindableSyntax          `thenM` \ rebindable_on -> 
803     if not rebindable_on then normal_case 
804     else
805         -- Get the similarly named thing from the local environment
806     lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenM` \ usr_name ->
807     return (HsVar usr_name, unitFV usr_name)
808   where
809     normal_case = return (HsVar std_name, emptyFVs)
810
811 lookupSyntaxTable :: [Name]                             -- Standard names
812                   -> RnM (SyntaxTable Name, FreeVars)   -- See comments with HsExpr.ReboundNames
813 lookupSyntaxTable std_names
814   = xoptM Opt_RebindableSyntax          `thenM` \ rebindable_on -> 
815     if not rebindable_on then normal_case 
816     else
817         -- Get the similarly named thing from the local environment
818     mapM (lookupOccRn . mkRdrUnqual . nameOccName) std_names    `thenM` \ usr_names ->
819
820     return (std_names `zip` map HsVar usr_names, mkFVs usr_names)
821   where
822     normal_case = return (std_names `zip` map HsVar std_names, emptyFVs)
823 \end{code}
824
825
826 %*********************************************************
827 %*                                                      *
828 \subsection{Binding}
829 %*                                                      *
830 %*********************************************************
831
832 \begin{code}
833 newLocalBndrRn :: Located RdrName -> RnM Name
834 -- Used for non-top-level binders.  These should
835 -- never be qualified.
836 newLocalBndrRn (L loc rdr_name)
837   | Just name <- isExact_maybe rdr_name 
838   = return name -- This happens in code generated by Template Haskell
839                 -- although I'm not sure why. Perhpas it's the call
840                 -- in RnPat.newName LetMk?
841   | otherwise
842   = do { unless (isUnqual rdr_name)
843                 (addErrAt loc (badQualBndrErr rdr_name))
844        ; uniq <- newUnique
845        ; return (mkInternalName uniq (rdrNameOcc rdr_name) loc) }
846
847 newLocalBndrsRn :: [Located RdrName] -> RnM [Name]
848 newLocalBndrsRn = mapM newLocalBndrRn
849
850 ---------------------
851 bindLocatedLocalsRn :: [Located RdrName]
852                     -> ([Name] -> RnM a)
853                     -> RnM a
854 bindLocatedLocalsRn rdr_names_w_loc enclosed_scope
855   = do { checkDupAndShadowedRdrNames rdr_names_w_loc
856
857         -- Make fresh Names and extend the environment
858        ; names <- newLocalBndrsRn rdr_names_w_loc
859        ; bindLocalNames names (enclosed_scope names) }
860
861 bindLocalNames :: [Name] -> RnM a -> RnM a
862 bindLocalNames names enclosed_scope
863   = do { name_env <- getLocalRdrEnv
864        ; setLocalRdrEnv (extendLocalRdrEnvList name_env names)
865                         enclosed_scope }
866
867 bindLocalName :: Name -> RnM a -> RnM a
868 bindLocalName name enclosed_scope
869   = do { name_env <- getLocalRdrEnv
870        ; setLocalRdrEnv (extendLocalRdrEnv name_env name)
871                         enclosed_scope }
872
873 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
874 bindLocalNamesFV names enclosed_scope
875   = do  { (result, fvs) <- bindLocalNames names enclosed_scope
876         ; return (result, delFVs names fvs) }
877
878
879 -------------------------------------
880         -- binLocalsFVRn is the same as bindLocalsRn
881         -- except that it deals with free vars
882 bindLocatedLocalsFV :: [Located RdrName] 
883                     -> ([Name] -> RnM (a,FreeVars)) -> RnM (a, FreeVars)
884 bindLocatedLocalsFV rdr_names enclosed_scope
885   = bindLocatedLocalsRn rdr_names       $ \ names ->
886     enclosed_scope names                `thenM` \ (thing, fvs) ->
887     return (thing, delFVs names fvs)
888
889 -------------------------------------
890 bindTyVarsFV ::  [LHsTyVarBndr RdrName]
891               -> ([LHsTyVarBndr Name] -> RnM (a, FreeVars))
892               -> RnM (a, FreeVars)
893 bindTyVarsFV tyvars thing_inside
894   = bindTyVarsRn tyvars $ \ tyvars' ->
895     do { (res, fvs) <- thing_inside tyvars'
896        ; return (res, delFVs (map hsLTyVarName tyvars') fvs) }
897
898 bindTyVarsRn ::  [LHsTyVarBndr RdrName]
899               -> ([LHsTyVarBndr Name] -> RnM a)
900               -> RnM a
901 -- Haskell-98 binding of type variables; e.g. within a data type decl
902 bindTyVarsRn tyvar_names enclosed_scope
903   = bindLocatedLocalsRn located_tyvars  $ \ names ->
904     do { kind_sigs_ok <- xoptM Opt_KindSignatures
905        ; unless (null kinded_tyvars || kind_sigs_ok) 
906                 (mapM_ (addErr . kindSigErr) kinded_tyvars)
907        ; enclosed_scope (zipWith replace tyvar_names names) }
908   where 
909     replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
910     located_tyvars = hsLTyVarLocNames tyvar_names
911     kinded_tyvars  = [n | L _ (KindedTyVar n _) <- tyvar_names]
912
913 bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
914   -- Find the type variables in the pattern type 
915   -- signatures that must be brought into scope
916 bindPatSigTyVars tys thing_inside
917   = do  { scoped_tyvars <- xoptM Opt_ScopedTypeVariables
918         ; if not scoped_tyvars then 
919                 thing_inside []
920           else 
921     do  { name_env <- getLocalRdrEnv
922         ; let locd_tvs  = [ tv | ty <- tys
923                                , tv <- extractHsTyRdrTyVars ty
924                                , not (unLoc tv `elemLocalRdrEnv` name_env) ]
925               nubbed_tvs = nubBy eqLocated locd_tvs
926                 -- The 'nub' is important.  For example:
927                 --      f (x :: t) (y :: t) = ....
928                 -- We don't want to complain about binding t twice!
929
930         ; bindLocatedLocalsRn nubbed_tvs thing_inside }}
931
932 bindPatSigTyVarsFV :: [LHsType RdrName]
933                    -> RnM (a, FreeVars)
934                    -> RnM (a, FreeVars)
935 bindPatSigTyVarsFV tys thing_inside
936   = bindPatSigTyVars tys        $ \ tvs ->
937     thing_inside                `thenM` \ (result,fvs) ->
938     return (result, fvs `delListFromNameSet` tvs)
939
940 bindSigTyVarsFV :: [Name]
941                 -> RnM (a, FreeVars)
942                 -> RnM (a, FreeVars)
943 bindSigTyVarsFV tvs thing_inside
944   = do  { scoped_tyvars <- xoptM Opt_ScopedTypeVariables
945         ; if not scoped_tyvars then 
946                 thing_inside 
947           else
948                 bindLocalNamesFV tvs thing_inside }
949
950 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
951         -- This function is used only in rnSourceDecl on InstDecl
952 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
953
954 -------------------------------------
955 checkDupRdrNames :: [Located RdrName] -> RnM ()
956 -- Check for duplicated names in a binding group
957 checkDupRdrNames rdr_names_w_loc
958   = mapM_ (dupNamesErr getLoc) dups
959   where
960     (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
961
962 checkDupNames :: [Name] -> RnM ()
963 -- Check for duplicated names in a binding group
964 checkDupNames names
965   = mapM_ (dupNamesErr nameSrcSpan) dups
966   where
967     (_, dups) = removeDups (\n1 n2 -> nameOccName n1 `compare` nameOccName n2) $
968                 filterOut isSystemName names
969                 -- See Note [Binders in Template Haskell] in Convert
970
971 ---------------------
972 checkDupAndShadowedRdrNames :: [Located RdrName] -> RnM ()
973 checkDupAndShadowedRdrNames loc_rdr_names
974   = do  { checkDupRdrNames loc_rdr_names
975         ; envs <- getRdrEnvs
976         ; checkShadowedOccs envs loc_occs }
977   where
978     loc_occs = [(loc,rdrNameOcc rdr) | L loc rdr <- loc_rdr_names]
979
980 checkDupAndShadowedNames :: (GlobalRdrEnv, LocalRdrEnv) -> [Name] -> RnM ()
981 checkDupAndShadowedNames envs names
982   = do { checkDupNames names
983        ; checkShadowedOccs envs loc_occs }
984   where
985     loc_occs = [(nameSrcSpan name, nameOccName name) | name <- names]
986
987 -------------------------------------
988 checkShadowedOccs :: (GlobalRdrEnv, LocalRdrEnv) -> [(SrcSpan,OccName)] -> RnM ()
989 checkShadowedOccs (global_env,local_env) loc_occs
990   = ifWOptM Opt_WarnNameShadowing $ 
991     do  { traceRn (text "shadow" <+> ppr loc_occs)
992         ; mapM_ check_shadow loc_occs }
993   where
994     check_shadow (loc, occ)
995         | startsWithUnderscore occ = return ()  -- Do not report shadowing for "_x"
996                                                 -- See Trac #3262
997         | Just n <- mb_local = complain [ptext (sLit "bound at") <+> ppr (nameSrcLoc n)]
998         | otherwise = do { gres' <- filterM is_shadowed_gre gres
999                          ; complain (map pprNameProvenance gres') }
1000         where
1001           complain []      = return ()
1002           complain pp_locs = addWarnAt loc (shadowedNameWarn occ pp_locs)
1003           mb_local = lookupLocalRdrOcc local_env occ
1004           gres     = lookupGRE_RdrName (mkRdrUnqual occ) global_env
1005                 -- Make an Unqualified RdrName and look that up, so that
1006                 -- we don't find any GREs that are in scope qualified-only
1007
1008     is_shadowed_gre :: GlobalRdrElt -> RnM Bool 
1009         -- Returns False for record selectors that are shadowed, when
1010         -- punning or wild-cards are on (cf Trac #2723)
1011     is_shadowed_gre gre@(GRE { gre_par = ParentIs _ })
1012         = do { dflags <- getDOpts
1013              ; if (xopt Opt_RecordPuns dflags || xopt Opt_RecordWildCards dflags) 
1014                then do { is_fld <- is_rec_fld gre; return (not is_fld) }
1015                else return True }
1016     is_shadowed_gre _other = return True
1017
1018     is_rec_fld gre      -- Return True for record selector ids
1019         | isLocalGRE gre = do { RecFields _ fld_set <- getRecFieldEnv
1020                               ; return (gre_name gre `elemNameSet` fld_set) }
1021         | otherwise      = do { sel_id <- tcLookupField (gre_name gre)
1022                               ; return (isRecordSelector sel_id) }
1023 \end{code}
1024
1025
1026 %************************************************************************
1027 %*                                                                      *
1028                What to do when a lookup fails
1029 %*                                                                      *
1030 %************************************************************************
1031
1032 \begin{code}
1033 data WhereLooking = WL_Any        -- Any binding
1034                   | WL_Global     -- Any top-level binding (local or imported)
1035                   | WL_LocalTop   -- Any top-level binding in this module
1036
1037 unboundName :: WhereLooking -> RdrName -> RnM Name
1038 unboundName where_look rdr_name
1039   = do  { show_helpful_errors <- doptM Opt_HelpfulErrors
1040         ; let err = unknownNameErr rdr_name
1041         ; if not show_helpful_errors
1042           then addErr err
1043           else do { extra_err <- unknownNameSuggestErr where_look rdr_name
1044                   ; addErr (err $$ extra_err) }
1045
1046         ; env <- getGlobalRdrEnv;
1047         ; traceRn (vcat [unknownNameErr rdr_name, 
1048                          ptext (sLit "Global envt is:"),
1049                          nest 3 (pprGlobalRdrEnv env)])
1050
1051         ; return (mkUnboundName rdr_name) }
1052
1053 unknownNameErr :: RdrName -> SDoc
1054 unknownNameErr rdr_name
1055   = vcat [ hang (ptext (sLit "Not in scope:")) 
1056               2 (pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))
1057                           <+> quotes (ppr rdr_name))
1058          , extra ]
1059   where
1060     extra | rdr_name == forall_tv_RDR = perhapsForallMsg
1061           | otherwise                 = empty
1062
1063 type HowInScope = Either SrcSpan ImpDeclSpec
1064      -- Left loc    =>  locally bound at loc
1065      -- Right ispec =>  imported as specified by ispec
1066
1067 unknownNameSuggestErr :: WhereLooking -> RdrName -> RnM SDoc
1068 unknownNameSuggestErr where_look tried_rdr_name
1069   = do { local_env <- getLocalRdrEnv
1070        ; global_env <- getGlobalRdrEnv
1071
1072        ; let all_possibilities :: [(String, (RdrName, HowInScope))]
1073              all_possibilities
1074                 =  [ (showSDoc (ppr r), (r, Left loc))
1075                    | (r,loc) <- local_possibilities local_env ]
1076                 ++ [ (showSDoc (ppr r), rp) | (r,rp) <- global_possibilities global_env ]
1077
1078              suggest = fuzzyLookup (showSDoc (ppr tried_rdr_name)) all_possibilities
1079              perhaps = ptext (sLit "Perhaps you meant")
1080              extra_err = case suggest of
1081                            []  -> empty
1082                            [p] -> perhaps <+> pp_item p
1083                            ps  -> sep [ perhaps <+> ptext (sLit "one of these:")
1084                                       , nest 2 (pprWithCommas pp_item ps) ]
1085        ; return extra_err }
1086   where
1087     pp_item :: (RdrName, HowInScope) -> SDoc
1088     pp_item (rdr, Left loc) = quotes (ppr rdr) <+>   -- Locally defined
1089                               parens (ptext (sLit "line") <+> int (srcSpanStartLine loc'))
1090         where loc' = case loc of
1091                      UnhelpfulSpan _ ->
1092                          panic "unknownNameSuggestErr UnhelpfulSpan"
1093                      RealSrcSpan l -> l
1094     pp_item (rdr, Right is) = quotes (ppr rdr) <+>   -- Imported
1095                               parens (ptext (sLit "imported from") <+> ppr (is_mod is))
1096
1097     tried_occ     = rdrNameOcc tried_rdr_name
1098     tried_is_sym  = isSymOcc tried_occ
1099     tried_ns      = occNameSpace tried_occ
1100     tried_is_qual = isQual tried_rdr_name
1101
1102     correct_name_space occ =  occNameSpace occ == tried_ns
1103                            && isSymOcc occ == tried_is_sym
1104         -- Treat operator and non-operators as non-matching
1105         -- This heuristic avoids things like
1106         --      Not in scope 'f'; perhaps you meant '+' (from Prelude)
1107
1108     local_ok = case where_look of { WL_Any -> True; _ -> False }
1109     local_possibilities :: LocalRdrEnv -> [(RdrName, SrcSpan)]
1110     local_possibilities env
1111       | tried_is_qual = []
1112       | not local_ok  = []
1113       | otherwise     = [ (mkRdrUnqual occ, nameSrcSpan name)
1114                         | name <- occEnvElts env
1115                         , let occ = nameOccName name
1116                         , correct_name_space occ]
1117
1118     gre_ok :: GlobalRdrElt -> Bool
1119     gre_ok = case where_look of
1120                    WL_LocalTop -> isLocalGRE
1121                    _           -> \_ -> True
1122
1123     global_possibilities :: GlobalRdrEnv -> [(RdrName, (RdrName, HowInScope))]
1124     global_possibilities global_env
1125       | tried_is_qual = [ (rdr_qual, (rdr_qual, how))
1126                         | gre <- globalRdrEnvElts global_env
1127                         , gre_ok gre
1128                         , let name = gre_name gre
1129                               occ  = nameOccName name
1130                         , correct_name_space occ
1131                         , (mod, how) <- quals_in_scope name (gre_prov gre)
1132                         , let rdr_qual = mkRdrQual mod occ ]
1133
1134       | otherwise = [ (rdr_unqual, pair)
1135                     | gre <- globalRdrEnvElts global_env
1136                     , gre_ok gre
1137                     , let name = gre_name gre
1138                           prov = gre_prov gre
1139                           occ  = nameOccName name
1140                           rdr_unqual = mkRdrUnqual occ
1141                     , correct_name_space occ
1142                     , pair <- case (unquals_in_scope name prov, quals_only occ prov) of
1143                                 (how:_, _)    -> [ (rdr_unqual, how) ]
1144                                 ([],    pr:_) -> [ pr ]  -- See Note [Only-quals]
1145                                 ([],    [])   -> [] ]
1146
1147               -- Note [Only-quals]
1148               -- The second alternative returns those names with the same
1149               -- OccName as the one we tried, but live in *qualified* imports
1150               -- e.g. if you have:
1151               --
1152               -- > import qualified Data.Map as Map
1153               -- > foo :: Map
1154               --
1155               -- then we suggest @Map.Map@.
1156
1157     --------------------
1158     unquals_in_scope :: Name -> Provenance -> [HowInScope]
1159     unquals_in_scope n LocalDef      = [ Left (nameSrcSpan n) ]
1160     unquals_in_scope _ (Imported is) = [ Right ispec
1161                                        | i <- is, let ispec = is_decl i
1162                                        , not (is_qual ispec) ]
1163
1164     --------------------
1165     quals_in_scope :: Name -> Provenance -> [(ModuleName, HowInScope)]
1166     -- Ones for which the qualified version is in scope
1167     quals_in_scope n LocalDef      = case nameModule_maybe n of
1168                                        Nothing -> []
1169                                        Just m  -> [(moduleName m, Left (nameSrcSpan n))]
1170     quals_in_scope _ (Imported is) = [ (is_as ispec, Right ispec)
1171                                      | i <- is, let ispec = is_decl i ]
1172
1173     --------------------
1174     quals_only :: OccName -> Provenance -> [(RdrName, HowInScope)]
1175     -- Ones for which *only* the qualified version is in scope
1176     quals_only _   LocalDef      = []
1177     quals_only occ (Imported is) = [ (mkRdrQual (is_as ispec) occ, Right ispec)
1178                                    | i <- is, let ispec = is_decl i, is_qual ispec ]
1179 \end{code}
1180
1181 %************************************************************************
1182 %*                                                                      *
1183 \subsection{Free variable manipulation}
1184 %*                                                                      *
1185 %************************************************************************
1186
1187 \begin{code}
1188 -- A useful utility
1189 addFvRn :: FreeVars -> RnM (thing, FreeVars) -> RnM (thing, FreeVars)
1190 addFvRn fvs1 thing_inside = do { (res, fvs2) <- thing_inside
1191                                ; return (res, fvs1 `plusFV` fvs2) }
1192
1193 mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
1194 mapFvRn f xs = do stuff <- mapM f xs
1195                   case unzip stuff of
1196                       (ys, fvs_s) -> return (ys, plusFVs fvs_s)
1197
1198 mapMaybeFvRn :: (a -> RnM (b, FreeVars)) -> Maybe a -> RnM (Maybe b, FreeVars)
1199 mapMaybeFvRn _ Nothing = return (Nothing, emptyFVs)
1200 mapMaybeFvRn f (Just x) = do { (y, fvs) <- f x; return (Just y, fvs) }
1201
1202 -- because some of the rename functions are CPSed:
1203 -- maps the function across the list from left to right; 
1204 -- collects all the free vars into one set
1205 mapFvRnCPS :: (a  -> (b   -> RnM c) -> RnM c) 
1206            -> [a] -> ([b] -> RnM c) -> RnM c
1207
1208 mapFvRnCPS _ []     cont = cont []
1209 mapFvRnCPS f (x:xs) cont = f x             $ \ x' -> 
1210                            mapFvRnCPS f xs $ \ xs' ->
1211                            cont (x':xs')
1212 \end{code}
1213
1214
1215 %************************************************************************
1216 %*                                                                      *
1217 \subsection{Envt utility functions}
1218 %*                                                                      *
1219 %************************************************************************
1220
1221 \begin{code}
1222 warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
1223 warnUnusedTopBinds gres
1224     = ifWOptM Opt_WarnUnusedBinds
1225     $ do isBoot <- tcIsHsBoot
1226          let noParent gre = case gre_par gre of
1227                             NoParent -> True
1228                             ParentIs _ -> False
1229              -- Don't warn about unused bindings with parents in
1230              -- .hs-boot files, as you are sometimes required to give
1231              -- unused bindings (trac #3449).
1232              gres' = if isBoot then filter noParent gres
1233                                else                 gres
1234          warnUnusedGREs gres'
1235
1236 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> FreeVars -> RnM ()
1237 warnUnusedLocalBinds = check_unused Opt_WarnUnusedBinds
1238 warnUnusedMatches    = check_unused Opt_WarnUnusedMatches
1239
1240 check_unused :: WarningFlag -> [Name] -> FreeVars -> RnM ()
1241 check_unused flag bound_names used_names
1242  = ifWOptM flag (warnUnusedLocals (filterOut (`elemNameSet` used_names) bound_names))
1243
1244 -------------------------
1245 --      Helpers
1246 warnUnusedGREs :: [GlobalRdrElt] -> RnM ()
1247 warnUnusedGREs gres 
1248  = warnUnusedBinds [(n,p) | GRE {gre_name = n, gre_prov = p} <- gres]
1249
1250 warnUnusedLocals :: [Name] -> RnM ()
1251 warnUnusedLocals names
1252  = warnUnusedBinds [(n,LocalDef) | n<-names]
1253
1254 warnUnusedBinds :: [(Name,Provenance)] -> RnM ()
1255 warnUnusedBinds names  = mapM_ warnUnusedName (filter reportable names)
1256  where reportable (name,_) 
1257         | isWiredInName name = False    -- Don't report unused wired-in names
1258                                         -- Otherwise we get a zillion warnings
1259                                         -- from Data.Tuple
1260         | otherwise = not (startsWithUnderscore (nameOccName name))
1261
1262 -------------------------
1263
1264 warnUnusedName :: (Name, Provenance) -> RnM ()
1265 warnUnusedName (name, LocalDef)
1266   = addUnusedWarning name (nameSrcSpan name)
1267                      (ptext (sLit "Defined but not used"))
1268
1269 warnUnusedName (name, Imported is)
1270   = mapM_ warn is
1271   where
1272     warn spec = addUnusedWarning name span msg
1273         where
1274            span = importSpecLoc spec
1275            pp_mod = quotes (ppr (importSpecModule spec))
1276            msg = ptext (sLit "Imported from") <+> pp_mod <+> ptext (sLit "but not used")
1277
1278 addUnusedWarning :: Name -> SrcSpan -> SDoc -> RnM ()
1279 addUnusedWarning name span msg
1280   = addWarnAt span $
1281     sep [msg <> colon, 
1282          nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
1283                         <+> quotes (ppr name)]
1284 \end{code}
1285
1286 \begin{code}
1287 addNameClashErrRn :: RdrName -> [GlobalRdrElt] -> RnM ()
1288 addNameClashErrRn rdr_name names
1289   = addErr (vcat [ptext (sLit "Ambiguous occurrence") <+> quotes (ppr rdr_name),
1290                   ptext (sLit "It could refer to") <+> vcat (msg1 : msgs)])
1291   where
1292     (np1:nps) = names
1293     msg1 = ptext  (sLit "either") <+> mk_ref np1
1294     msgs = [ptext (sLit "    or") <+> mk_ref np | np <- nps]
1295     mk_ref gre = sep [quotes (ppr (gre_name gre)) <> comma, pprNameProvenance gre]
1296
1297 shadowedNameWarn :: OccName -> [SDoc] -> SDoc
1298 shadowedNameWarn occ shadowed_locs
1299   = sep [ptext (sLit "This binding for") <+> quotes (ppr occ)
1300             <+> ptext (sLit "shadows the existing binding") <> plural shadowed_locs,
1301          nest 2 (vcat shadowed_locs)]
1302
1303 perhapsForallMsg :: SDoc
1304 perhapsForallMsg 
1305   = vcat [ ptext (sLit "Perhaps you intended to use -XExplicitForAll or similar flag")
1306          , ptext (sLit "to enable explicit-forall syntax: forall <tvs>. <type>")]
1307
1308 unknownSubordinateErr :: SDoc -> RdrName -> SDoc
1309 unknownSubordinateErr doc op    -- Doc is "method of class" or 
1310                                 -- "field of constructor"
1311   = quotes (ppr op) <+> ptext (sLit "is not a (visible)") <+> doc
1312
1313 badOrigBinding :: RdrName -> SDoc
1314 badOrigBinding name
1315   = ptext (sLit "Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
1316         -- The rdrNameOcc is because we don't want to print Prelude.(,)
1317
1318 dupNamesErr :: Outputable n => (n -> SrcSpan) -> [n] -> RnM ()
1319 dupNamesErr get_loc names
1320   = addErrAt big_loc $
1321     vcat [ptext (sLit "Conflicting definitions for") <+> quotes (ppr (head names)),
1322           locations]
1323   where
1324     locs      = map get_loc names
1325     big_loc   = foldr1 combineSrcSpans locs
1326     locations = ptext (sLit "Bound at:") <+> vcat (map ppr (sortLe (<=) locs))
1327
1328 kindSigErr :: Outputable a => a -> SDoc
1329 kindSigErr thing
1330   = hang (ptext (sLit "Illegal kind signature for") <+> quotes (ppr thing))
1331        2 (ptext (sLit "Perhaps you intended to use -XKindSignatures"))
1332
1333
1334 badQualBndrErr :: RdrName -> SDoc
1335 badQualBndrErr rdr_name
1336   = ptext (sLit "Qualified name in binding position:") <+> ppr rdr_name
1337
1338 opDeclErr :: RdrName -> SDoc
1339 opDeclErr n 
1340   = hang (ptext (sLit "Illegal declaration of a type or class operator") <+> quotes (ppr n))
1341        2 (ptext (sLit "Use -XTypeOperators to declare operators in type and declarations"))
1342 \end{code}