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