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