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