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