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