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