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