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