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