Implememt -fdefer-type-errors (Trac #5624)
[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, lookupSubBndrOcc, 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         ( MsgDoc )
67 import SrcLoc
68 import Outputable
69 import Util
70 import Maybes
71 import ListSetOps       ( removeDups )
72 import DynFlags
73 import FastString
74 import Control.Monad
75 import 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        ; lookupSubBndrOcc (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 lookupSubBndrOcc :: Parent  -- NoParent   => just look it up as usual
308                             -- ParentIs p => use p to disambiguate
309                  -> SDoc -> RdrName 
310                  -> RnM Name
311 lookupSubBndrOcc 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                           -- Add a usage; this is an *occurrence* site
327                         ; return (gre_name gre) }
328             []    -> do { addErr (unknownSubordinateErr doc rdr_name)
329                         ; return (mkUnboundName rdr_name) }
330             gres  -> do { addNameClashErrRn rdr_name gres
331                         ; return (gre_name (head gres)) } }
332   where
333     -- Note [Usage for sub-bndrs]
334     used_rdr_name gre
335       | isQual rdr_name = rdr_name
336       | otherwise       = greRdrName gre
337
338 greRdrName :: GlobalRdrElt -> RdrName
339 greRdrName gre
340   = case gre_prov gre of
341       LocalDef    -> unqual_rdr
342       Imported is -> used_rdr_name_from_is is
343
344   where 
345     occ = nameOccName (gre_name gre)
346     unqual_rdr = mkRdrUnqual occ
347
348     used_rdr_name_from_is imp_specs     -- rdr_name is unqualified
349       | not (all (is_qual . is_decl) imp_specs) 
350       = unqual_rdr  -- An unqualified import is available
351       | otherwise
352       =             -- Only qualified imports available, so make up 
353                     -- a suitable qualifed name from the first imp_spec
354         ASSERT( not (null imp_specs) )
355         mkRdrQual (is_as (is_decl (head imp_specs))) occ
356
357 lookupSubBndrGREs :: GlobalRdrEnv -> Parent -> RdrName -> [GlobalRdrElt]
358 -- If Parent = NoParent, just do a normal lookup
359 -- If Parent = Parent p then find all GREs that
360 --   (a) have parent p
361 --   (b) for Unqual, are in scope qualified or unqualified
362 --       for Qual, are in scope with that qualification
363 lookupSubBndrGREs env parent rdr_name
364   = case parent of
365       NoParent   -> pickGREs rdr_name gres
366       ParentIs p 
367         | isUnqual rdr_name -> filter (parent_is p) gres
368         | otherwise         -> filter (parent_is p) (pickGREs rdr_name gres)
369
370   where
371     gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)
372
373     parent_is p (GRE { gre_par = ParentIs p' }) = p == p'
374     parent_is _ _                               = False
375 \end{code}
376
377 Note [Looking up Exact RdrNames]
378 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
379 Exact RdrNames are generated by Template Haskell.  See Note [Binders
380 in Template Haskell] in Convert.
381
382 For data types and classes have Exact system Names in the binding
383 positions for constructors, TyCons etc.  For example
384     [d| data T = MkT Int |]
385 when we splice in and Convert to HsSyn RdrName, we'll get
386     data (Exact (system Name "T")) = (Exact (system Name "MkT")) ...
387
388 But, constructors and the like need External Names, not System Names!
389 So we do the following
390
391  * In RnEnv.newGlobalBinder we spot Exact RdrNames that wrap a
392    non-External Name, and make an External name for it. This is
393    the name that goes in the GlobalRdrEnv
394
395  * When looking up an occurrence of an Exact name, done in
396    RnEnv.lookupExactOcc, we find the Name with the right unique in the
397    GlobalRdrEnv, and use the on from the envt -- it will be an
398    External Name in the case of the data type/constructor above.
399
400  * Exact names are also use for purely local binders generated
401    by TH, such as    \x_33. x_33
402    Both binder and occurrence are Exact RdrNames.  The occurrence
403    gets looked up in the LocalRdrEnv by RnEnv.lookupOccRn, and 
404    misses, because lookupLocalRdrEnv always returns Nothing for
405    an Exact Name.  Now we fall through to lookupExactOcc, which
406    will find the Name is not in the GlobalRdrEnv, so we just use
407    the Exact supplied Name.
408
409
410 Note [Usage for sub-bndrs]
411 ~~~~~~~~~~~~~~~~~~~~~~~~~~
412 If you have this
413    import qualified M( C( f ) ) 
414    instance M.C T where
415      f x = x
416 then is the qualified import M.f used?  Obviously yes.
417 But the RdrName used in the instance decl is unqualified.  In effect,
418 we fill in the qualification by looking for f's whose class is M.C
419 But when adding to the UsedRdrNames we must make that qualification
420 explicit (saying "used  M.f"), otherwise we get "Redundant import of M.f".
421
422 So we make up a suitable (fake) RdrName.  But be careful
423    import qualifed M
424    import M( C(f) )
425    instance C T where
426      f x = x
427 Here we want to record a use of 'f', not of 'M.f', otherwise
428 we'll miss the fact that the qualified import is redundant.
429
430 --------------------------------------------------
431 --              Occurrences
432 --------------------------------------------------
433
434 \begin{code}
435 getLookupOccRn :: RnM (Name -> Maybe Name)
436 getLookupOccRn
437   = getLocalRdrEnv                      `thenM` \ local_env ->
438     return (lookupLocalRdrOcc local_env . nameOccName)
439
440 lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
441 lookupLocatedOccRn = wrapLocM lookupOccRn
442
443 lookupLocalOccRn_maybe :: RdrName -> RnM (Maybe Name)
444 -- Just look in the local environment
445 lookupLocalOccRn_maybe rdr_name 
446   = do { local_env <- getLocalRdrEnv
447        ; return (lookupLocalRdrEnv local_env rdr_name) }
448
449 -- lookupOccRn looks up an occurrence of a RdrName
450 lookupOccRn :: RdrName -> RnM Name
451 lookupOccRn rdr_name = do
452   opt_name <- lookupOccRn_maybe rdr_name
453   maybe (unboundName WL_Any rdr_name) return opt_name
454
455 -- lookupPromotedOccRn looks up an optionally promoted RdrName.
456 lookupPromotedOccRn :: RdrName -> RnM Name
457 -- see Note [Demotion] 
458 lookupPromotedOccRn rdr_name 
459   = do { mb_name <- lookupOccRn_maybe rdr_name 
460        ; case mb_name of {
461              Just name -> return name ;
462              Nothing   -> 
463
464     do { -- Maybe it's the name of a *data* constructor
465          poly_kinds <- xoptM Opt_PolyKinds
466        ; mb_demoted_name <- case demoteRdrName rdr_name of
467                               Just demoted_rdr -> lookupOccRn_maybe demoted_rdr
468                               Nothing          -> return Nothing
469        ; case mb_demoted_name of
470            Nothing -> unboundName WL_Any rdr_name
471            Just demoted_name 
472              | poly_kinds -> return demoted_name
473              | otherwise  -> unboundNameX WL_Any rdr_name suggest_pk }}}
474   where 
475     suggest_pk = ptext (sLit "A data constructor of that name is in scope; did you mean -XPolyKinds?")
476 \end{code}
477
478 Note [Demotion]
479 ~~~~~~~~~~~~~~~
480 When the user writes:
481   data Nat = Zero | Succ Nat
482   foo :: f Zero -> Int
483
484 'Zero' in the type signature of 'foo' is parsed as:
485   HsTyVar ("Zero", TcClsName)
486
487 When the renamer hits this occurence of 'Zero' it's going to realise
488 that it's not in scope. But because it is renaming a type, it knows
489 that 'Zero' might be a promoted data constructor, so it will demote
490 its namespace to DataName and do a second lookup.
491
492 The final result (after the renamer) will be:
493   HsTyVar ("Zero", DataName)
494
495 \begin{code}
496 -- lookupOccRn looks up an occurrence of a RdrName
497 lookupOccRn_maybe :: RdrName -> RnM (Maybe Name)
498 lookupOccRn_maybe rdr_name
499   = do { local_env <- getLocalRdrEnv
500        ; case lookupLocalRdrEnv local_env rdr_name of {
501           Just name -> return (Just name) ;
502           Nothing   -> do
503        { mb_name <- lookupGlobalOccRn_maybe rdr_name
504        ; case mb_name of {
505                 Just name  -> return (Just name) ;
506                 Nothing -> do
507        { -- We allow qualified names on the command line to refer to
508          --  *any* name exported by any module in scope, just as if there
509          -- was an "import qualified M" declaration for every module.
510          allow_qual <- doptM Opt_ImplicitImportQualified
511        ; is_ghci <- getIsGHCi
512                -- This test is not expensive,
513                -- and only happens for failed lookups
514        ; if isQual rdr_name && allow_qual && is_ghci
515          then lookupQualifiedName rdr_name
516          else do { traceRn (text "lookupOccRn" <+> ppr rdr_name)
517                  ; return Nothing } } } } } }
518
519
520 lookupGlobalOccRn :: RdrName -> RnM Name
521 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global 
522 -- environment.  Adds an error message if the RdrName is not in scope.
523 lookupGlobalOccRn rdr_name
524   = do { mb_name <- lookupGlobalOccRn_maybe rdr_name
525        ; case mb_name of
526            Just n  -> return n
527            Nothing -> do { traceRn (text "lookupGlobalOccRn" <+> ppr rdr_name)
528                          ; unboundName WL_Global rdr_name } }
529
530 lookupGlobalOccRn_maybe :: RdrName -> RnM (Maybe Name)
531 -- No filter function; does not report an error on failure
532
533 lookupGlobalOccRn_maybe rdr_name
534   | Just n <- isExact_maybe rdr_name   -- This happens in derived code
535   = do { n' <- lookupExactOcc n; return (Just n') }
536
537   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
538   = do { n <- lookupOrig rdr_mod rdr_occ
539        ; return (Just n) }
540
541   | otherwise
542   = do  { mb_gre <- lookupGreRn_maybe rdr_name
543         ; case mb_gre of
544                 Nothing  -> return Nothing
545                 Just gre -> return (Just (gre_name gre)) }
546
547
548 --------------------------------------------------
549 --      Lookup in the Global RdrEnv of the module
550 --------------------------------------------------
551
552 lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
553 -- Just look up the RdrName in the GlobalRdrEnv
554 lookupGreRn_maybe rdr_name 
555   = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
556
557 lookupGreRn :: RdrName -> RnM GlobalRdrElt
558 -- If not found, add error message, and return a fake GRE
559 lookupGreRn rdr_name 
560   = do  { mb_gre <- lookupGreRn_maybe rdr_name
561         ; case mb_gre of {
562             Just gre -> return gre ;
563             Nothing  -> do
564         { traceRn (text "lookupGreRn" <+> ppr rdr_name)
565         ; name <- unboundName WL_Global rdr_name
566         ; return (GRE { gre_name = name, gre_par = NoParent,
567                         gre_prov = LocalDef }) }}}
568
569 lookupGreLocalRn :: RdrName -> RnM (Maybe GlobalRdrElt)
570 -- Similar, but restricted to locally-defined things
571 lookupGreLocalRn rdr_name 
572   = lookupGreRn_help rdr_name lookup_fn
573   where
574     lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)
575
576 lookupGreRn_help :: RdrName                     -- Only used in error message
577                  -> (GlobalRdrEnv -> [GlobalRdrElt])    -- Lookup function
578                  -> RnM (Maybe GlobalRdrElt)
579 -- Checks for exactly one match; reports deprecations
580 -- Returns Nothing, without error, if too few
581 lookupGreRn_help rdr_name lookup 
582   = do  { env <- getGlobalRdrEnv
583         ; case lookup env of
584             []    -> return Nothing
585             [gre] -> do { addUsedRdrName gre rdr_name
586                         ; return (Just gre) }
587             gres  -> do { addNameClashErrRn rdr_name gres
588                         ; return (Just (head gres)) } }
589
590 addUsedRdrName :: GlobalRdrElt -> RdrName -> RnM ()
591 -- Record usage of imported RdrNames
592 addUsedRdrName gre rdr
593   | isLocalGRE gre = return ()
594   | otherwise      = do { env <- getGblEnv
595                         ; updMutVar (tcg_used_rdrnames env)
596                                     (\s -> Set.insert rdr s) }
597
598 addUsedRdrNames :: [RdrName] -> RnM ()
599 -- Record used sub-binders
600 -- We don't check for imported-ness here, because it's inconvenient
601 -- and not stritly necessary.
602 addUsedRdrNames rdrs
603   = do { env <- getGblEnv
604        ; updMutVar (tcg_used_rdrnames env)
605                    (\s -> foldr Set.insert s rdrs) }
606
607 ------------------------------
608 --      GHCi support
609 ------------------------------
610
611 -- A qualified name on the command line can refer to any module at all: we
612 -- try to load the interface if we don't already have it.
613 lookupQualifiedName :: RdrName -> RnM (Maybe Name)
614 lookupQualifiedName rdr_name
615   | Just (mod,occ) <- isQual_maybe rdr_name
616    -- Note: we want to behave as we would for a source file import here,
617    -- and respect hiddenness of modules/packages, hence loadSrcInterface.
618    = loadSrcInterface doc mod False Nothing     `thenM` \ iface ->
619
620    case  [ name
621          | avail <- mi_exports iface,
622            name  <- availNames avail,
623            nameOccName name == occ ] of
624       (n:ns) -> ASSERT (null ns) return (Just n)
625       _ -> do { traceRn (text "lookupQualified" <+> ppr rdr_name)
626               ; return Nothing }
627
628   | otherwise
629   = pprPanic "RnEnv.lookupQualifiedName" (ppr rdr_name)
630   where
631     doc = ptext (sLit "Need to find") <+> ppr rdr_name
632 \end{code}
633
634 Note [Looking up signature names]
635 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
636 lookupSigOccRn is used for type signatures and pragmas
637 Is this valid?
638   module A
639         import M( f )
640         f :: Int -> Int
641         f x = x
642 It's clear that the 'f' in the signature must refer to A.f
643 The Haskell98 report does not stipulate this, but it will!
644 So we must treat the 'f' in the signature in the same way
645 as the binding occurrence of 'f', using lookupBndrRn
646
647 However, consider this case:
648         import M( f )
649         f :: Int -> Int
650         g x = x
651 We don't want to say 'f' is out of scope; instead, we want to
652 return the imported 'f', so that later on the reanamer will
653 correctly report "misplaced type sig".
654
655 \begin{code}
656 data HsSigCtxt 
657   = HsBootCtxt               -- Top level of a hs-boot file
658   | TopSigCtxt               -- At top level
659   | LocalBindCtxt NameSet    -- In a local binding, binding these names
660   | ClsDeclCtxt   Name       -- Class decl for this class
661   | InstDeclCtxt  Name       -- Intsance decl for this class
662
663 lookupSigOccRn :: HsSigCtxt
664                -> Sig RdrName
665                -> Located RdrName -> RnM (Located Name)
666 lookupSigOccRn ctxt sig
667   = wrapLocM $ \ rdr_name -> 
668     do { mb_name <- lookupBindGroupOcc ctxt (hsSigDoc sig) rdr_name
669        ; case mb_name of
670            Left err   -> do { addErr err; return (mkUnboundName rdr_name) }
671            Right name -> return name }
672
673 lookupBindGroupOcc :: HsSigCtxt
674                    -> SDoc     
675                    -> RdrName -> RnM (Either MsgDoc Name)
676 -- Looks up the RdrName, expecting it to resolve to one of the 
677 -- bound names passed in.  If not, return an appropriate error message
678 --
679 -- See Note [Looking up signature names]
680 lookupBindGroupOcc ctxt what rdr_name
681   | Just n <- isExact_maybe rdr_name
682   = do { n' <- lookupExactOcc n
683        ; return (Right n') }  -- Maybe we should check the side conditions
684                               -- but it's a pain, and Exact things only show
685                               -- up when you know what you are doing
686
687   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
688   = do { n' <- lookupOrig rdr_mod rdr_occ
689        ; return (Right n') }
690
691   | otherwise
692   = case ctxt of 
693       HsBootCtxt       -> lookup_top                
694       TopSigCtxt       -> lookup_top
695       LocalBindCtxt ns -> lookup_group ns
696       ClsDeclCtxt  cls -> lookup_cls_op cls
697       InstDeclCtxt cls -> lookup_cls_op cls
698   where
699     lookup_cls_op cls
700       = do { env <- getGlobalRdrEnv 
701            ; let gres = lookupSubBndrGREs env (ParentIs cls) rdr_name
702            ; case gres of
703                []      -> return (Left (unknownSubordinateErr doc rdr_name))
704                (gre:_) -> return (Right (gre_name gre)) }
705                         -- If there is more than one local GRE for the 
706                         -- same OccName 'f', that will be reported separately
707                         -- as a duplicate top-level binding for 'f'
708       where
709         doc = ptext (sLit "method of class") <+> quotes (ppr cls)
710
711     lookup_top
712       = do { env <- getGlobalRdrEnv 
713            ; let gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)
714            ; case filter isLocalGRE gres of
715                [] | null gres -> bale_out_with empty
716                   | otherwise -> bale_out_with (bad_msg (ptext (sLit "an imported value")))
717                (gre:_) 
718                   | ParentIs {} <- gre_par gre
719                   -> bale_out_with (bad_msg (ptext (sLit "a record selector or class method")))
720                   | otherwise
721                   -> return (Right (gre_name gre)) }
722
723     lookup_group bound_names
724       = do { mb_name <- lookupOccRn_maybe rdr_name
725            ; case mb_name of
726                Just n  
727                  | n `elemNameSet` bound_names -> return (Right n)
728                  | otherwise                   -> bale_out_with local_msg
729                Nothing                         -> bale_out_with empty }
730
731     bale_out_with msg 
732         = return (Left (sep [ ptext (sLit "The") <+> what
733                                 <+> ptext (sLit "for") <+> quotes (ppr rdr_name)
734                            , nest 2 $ ptext (sLit "lacks an accompanying binding")]
735                        $$ nest 2 msg))
736
737     local_msg = parens $ ptext (sLit "The")  <+> what <+> ptext (sLit "must be given where")
738                            <+> quotes (ppr rdr_name) <+> ptext (sLit "is declared")
739
740     bad_msg thing = parens $ ptext (sLit "You cannot give a") <+> what
741                           <+> ptext (sLit "for") <+> thing
742
743
744 ---------------
745 lookupLocalDataTcNames :: NameSet -> SDoc -> RdrName -> RnM [Name]
746 -- GHC extension: look up both the tycon and data con 
747 -- for con-like things.  Used for top-level fixity signatures
748 -- Complain if neither is in scope
749 lookupLocalDataTcNames bndr_set what rdr_name
750   | Just n <- isExact_maybe rdr_name    
751         -- Special case for (:), which doesn't get into the GlobalRdrEnv
752   = do { n' <- lookupExactOcc n; return [n'] }  -- For this we don't need to try the tycon too
753   | otherwise
754   = do  { mb_gres <- mapM (lookupBindGroupOcc (LocalBindCtxt bndr_set) what)
755                           (dataTcOccs rdr_name)
756         ; let (errs, names) = splitEithers mb_gres
757         ; when (null names) (addErr (head errs))        -- Bleat about one only
758         ; return names }
759
760 dataTcOccs :: RdrName -> [RdrName]
761 -- If the input is a data constructor, return both it and a type
762 -- constructor.  This is useful when we aren't sure which we are
763 -- looking at.
764 dataTcOccs rdr_name
765   | isDataOcc occ             = [rdr_name, rdr_name_tc]
766   | otherwise                 = [rdr_name]
767   where    
768     occ         = rdrNameOcc rdr_name
769     rdr_name_tc = setRdrNameSpace rdr_name tcName
770 \end{code}
771
772
773 %*********************************************************
774 %*                                                      *
775                 Fixities
776 %*                                                      *
777 %*********************************************************
778
779 \begin{code}
780 --------------------------------
781 type FastStringEnv a = UniqFM a         -- Keyed by FastString
782
783
784 emptyFsEnv  :: FastStringEnv a
785 lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a
786 extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a
787
788 emptyFsEnv  = emptyUFM
789 lookupFsEnv = lookupUFM
790 extendFsEnv = addToUFM
791
792 --------------------------------
793 type MiniFixityEnv = FastStringEnv (Located Fixity)
794         -- Mini fixity env for the names we're about 
795         -- to bind, in a single binding group
796         --
797         -- It is keyed by the *FastString*, not the *OccName*, because
798         -- the single fixity decl       infix 3 T
799         -- affects both the data constructor T and the type constrctor T
800         --
801         -- We keep the location so that if we find
802         -- a duplicate, we can report it sensibly
803
804 --------------------------------
805 -- Used for nested fixity decls to bind names along with their fixities.
806 -- the fixities are given as a UFM from an OccName's FastString to a fixity decl
807
808 addLocalFixities :: MiniFixityEnv -> [Name] -> RnM a -> RnM a
809 addLocalFixities mini_fix_env names thing_inside
810   = extendFixityEnv (mapCatMaybes find_fixity names) thing_inside
811   where
812     find_fixity name 
813       = case lookupFsEnv mini_fix_env (occNameFS occ) of
814           Just (L _ fix) -> Just (name, FixItem occ fix)
815           Nothing        -> Nothing
816       where
817         occ = nameOccName name
818 \end{code}
819
820 --------------------------------
821 lookupFixity is a bit strange.  
822
823 * Nested local fixity decls are put in the local fixity env, which we
824   find with getFixtyEnv
825
826 * Imported fixities are found in the HIT or PIT
827
828 * Top-level fixity decls in this module may be for Names that are
829     either  Global         (constructors, class operations)
830     or      Local/Exported (everything else)
831   (See notes with RnNames.getLocalDeclBinders for why we have this split.)
832   We put them all in the local fixity environment
833
834 \begin{code}
835 lookupFixityRn :: Name -> RnM Fixity
836 lookupFixityRn name
837   = getModule                           `thenM` \ this_mod -> 
838     if nameIsLocalOrFrom this_mod name
839     then do     -- It's defined in this module
840       local_fix_env <- getFixityEnv             
841       traceRn (text "lookupFixityRn: looking up name in local environment:" <+> 
842                vcat [ppr name, ppr local_fix_env])
843       return $ lookupFixity local_fix_env name
844     else        -- It's imported
845       -- For imported names, we have to get their fixities by doing a
846       -- loadInterfaceForName, and consulting the Ifaces that comes back
847       -- from that, because the interface file for the Name might not
848       -- have been loaded yet.  Why not?  Suppose you import module A,
849       -- which exports a function 'f', thus;
850       --        module CurrentModule where
851       --          import A( f )
852       --        module A( f ) where
853       --          import B( f )
854       -- Then B isn't loaded right away (after all, it's possible that
855       -- nothing from B will be used).  When we come across a use of
856       -- 'f', we need to know its fixity, and it's then, and only
857       -- then, that we load B.hi.  That is what's happening here.
858       --
859       -- loadInterfaceForName will find B.hi even if B is a hidden module,
860       -- and that's what we want.
861         loadInterfaceForName doc name   `thenM` \ iface -> do {
862           traceRn (text "lookupFixityRn: looking up name in iface cache and found:" <+> 
863                    vcat [ppr name, ppr $ mi_fix_fn iface (nameOccName name)]);
864            return (mi_fix_fn iface (nameOccName name))
865                                                            }
866   where
867     doc = ptext (sLit "Checking fixity for") <+> ppr name
868
869 ---------------
870 lookupTyFixityRn :: Located Name -> RnM Fixity
871 lookupTyFixityRn (L _ n) = lookupFixityRn n
872
873 \end{code}
874
875 %************************************************************************
876 %*                                                                      *
877                         Rebindable names
878         Dealing with rebindable syntax is driven by the 
879         Opt_RebindableSyntax dynamic flag.
880
881         In "deriving" code we don't want to use rebindable syntax
882         so we switch off the flag locally
883
884 %*                                                                      *
885 %************************************************************************
886
887 Haskell 98 says that when you say "3" you get the "fromInteger" from the
888 Standard Prelude, regardless of what is in scope.   However, to experiment
889 with having a language that is less coupled to the standard prelude, we're
890 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
891 happens to be in scope.  Then you can
892         import Prelude ()
893         import MyPrelude as Prelude
894 to get the desired effect.
895
896 At the moment this just happens for
897   * fromInteger, fromRational on literals (in expressions and patterns)
898   * negate (in expressions)
899   * minus  (arising from n+k patterns)
900   * "do" notation
901
902 We store the relevant Name in the HsSyn tree, in 
903   * HsIntegral/HsFractional/HsIsString
904   * NegApp
905   * NPlusKPat
906   * HsDo
907 respectively.  Initially, we just store the "standard" name (PrelNames.fromIntegralName,
908 fromRationalName etc), but the renamer changes this to the appropriate user
909 name if Opt_NoImplicitPrelude is on.  That is what lookupSyntaxName does.
910
911 We treat the orignal (standard) names as free-vars too, because the type checker
912 checks the type of the user thing against the type of the standard thing.
913
914 \begin{code}
915 lookupIfThenElse :: RnM (Maybe (SyntaxExpr Name), FreeVars)
916 -- Different to lookupSyntaxName because in the non-rebindable
917 -- case we desugar directly rather than calling an existing function
918 -- Hence the (Maybe (SyntaxExpr Name)) return type
919 lookupIfThenElse 
920   = do { rebind <- xoptM Opt_RebindableSyntax
921        ; if not rebind 
922          then return (Nothing, emptyFVs)
923          else do { ite <- lookupOccRn (mkVarUnqual (fsLit "ifThenElse"))
924                  ; return (Just (HsVar ite), unitFV ite) } }
925
926 lookupSyntaxName :: Name                                -- The standard name
927                  -> RnM (SyntaxExpr Name, FreeVars)     -- Possibly a non-standard name
928 lookupSyntaxName std_name
929   = xoptM Opt_RebindableSyntax          `thenM` \ rebindable_on -> 
930     if not rebindable_on then normal_case 
931     else
932         -- Get the similarly named thing from the local environment
933     lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenM` \ usr_name ->
934     return (HsVar usr_name, unitFV usr_name)
935   where
936     normal_case = return (HsVar std_name, emptyFVs)
937
938 lookupSyntaxTable :: [Name]                             -- Standard names
939                   -> RnM (SyntaxTable Name, FreeVars)   -- See comments with HsExpr.ReboundNames
940 lookupSyntaxTable std_names
941   = xoptM Opt_RebindableSyntax          `thenM` \ rebindable_on -> 
942     if not rebindable_on then normal_case 
943     else
944         -- Get the similarly named thing from the local environment
945     mapM (lookupOccRn . mkRdrUnqual . nameOccName) std_names    `thenM` \ usr_names ->
946
947     return (std_names `zip` map HsVar usr_names, mkFVs usr_names)
948   where
949     normal_case = return (std_names `zip` map HsVar std_names, emptyFVs)
950 \end{code}
951
952
953 %*********************************************************
954 %*                                                      *
955 \subsection{Binding}
956 %*                                                      *
957 %*********************************************************
958
959 \begin{code}
960 newLocalBndrRn :: Located RdrName -> RnM Name
961 -- Used for non-top-level binders.  These should
962 -- never be qualified.
963 newLocalBndrRn (L loc rdr_name)
964   | Just name <- isExact_maybe rdr_name 
965   = return name -- This happens in code generated by Template Haskell
966                 -- See Note [Binders in Template Haskell] in Convert.lhs
967   | otherwise
968   = do { unless (isUnqual rdr_name)
969                 (addErrAt loc (badQualBndrErr rdr_name))
970        ; uniq <- newUnique
971        ; return (mkInternalName uniq (rdrNameOcc rdr_name) loc) }
972
973 newLocalBndrsRn :: [Located RdrName] -> RnM [Name]
974 newLocalBndrsRn = mapM newLocalBndrRn
975
976 ---------------------
977 bindLocatedLocalsRn :: [Located RdrName]
978                     -> ([Name] -> RnM a)
979                     -> RnM a
980 bindLocatedLocalsRn rdr_names_w_loc enclosed_scope
981   = do { checkDupAndShadowedRdrNames rdr_names_w_loc
982
983         -- Make fresh Names and extend the environment
984        ; names <- newLocalBndrsRn rdr_names_w_loc
985        ; bindLocalNames names (enclosed_scope names) }
986
987 bindLocalNames :: [Name] -> RnM a -> RnM a
988 bindLocalNames names enclosed_scope
989   = do { name_env <- getLocalRdrEnv
990        ; setLocalRdrEnv (extendLocalRdrEnvList name_env names)
991                         enclosed_scope }
992
993 bindLocalName :: Name -> RnM a -> RnM a
994 bindLocalName name enclosed_scope
995   = do { name_env <- getLocalRdrEnv
996        ; setLocalRdrEnv (extendLocalRdrEnv name_env name)
997                         enclosed_scope }
998
999 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
1000 bindLocalNamesFV names enclosed_scope
1001   = do  { (result, fvs) <- bindLocalNames names enclosed_scope
1002         ; return (result, delFVs names fvs) }
1003
1004
1005 -------------------------------------
1006         -- binLocalsFVRn is the same as bindLocalsRn
1007         -- except that it deals with free vars
1008 bindLocatedLocalsFV :: [Located RdrName] 
1009                     -> ([Name] -> RnM (a,FreeVars)) -> RnM (a, FreeVars)
1010 bindLocatedLocalsFV rdr_names enclosed_scope
1011   = bindLocatedLocalsRn rdr_names       $ \ names ->
1012     enclosed_scope names                `thenM` \ (thing, fvs) ->
1013     return (thing, delFVs names fvs)
1014
1015 -------------------------------------
1016 bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
1017   -- Find the type variables in the pattern type 
1018   -- signatures that must be brought into scope
1019 bindPatSigTyVars tys thing_inside
1020   = do  { scoped_tyvars <- xoptM Opt_ScopedTypeVariables
1021         ; if not scoped_tyvars then 
1022                 thing_inside []
1023           else 
1024     do  { name_env <- getLocalRdrEnv
1025         ; let locd_tvs  = [ tv | ty <- tys
1026                                , tv <- extractHsTyRdrTyVars ty
1027                                , not (unLoc tv `elemLocalRdrEnv` name_env) ]
1028               nubbed_tvs = nubBy eqLocated locd_tvs
1029                 -- The 'nub' is important.  For example:
1030                 --      f (x :: t) (y :: t) = ....
1031                 -- We don't want to complain about binding t twice!
1032
1033         ; bindLocatedLocalsRn nubbed_tvs thing_inside }}
1034
1035 bindPatSigTyVarsFV :: [LHsType RdrName]
1036                    -> RnM (a, FreeVars)
1037                    -> RnM (a, FreeVars)
1038 bindPatSigTyVarsFV tys thing_inside
1039   = bindPatSigTyVars tys        $ \ tvs ->
1040     thing_inside                `thenM` \ (result,fvs) ->
1041     return (result, fvs `delListFromNameSet` tvs)
1042
1043 bindSigTyVarsFV :: [Name]
1044                 -> RnM (a, FreeVars)
1045                 -> RnM (a, FreeVars)
1046 bindSigTyVarsFV tvs thing_inside
1047   = do  { scoped_tyvars <- xoptM Opt_ScopedTypeVariables
1048         ; if not scoped_tyvars then 
1049                 thing_inside 
1050           else
1051                 bindLocalNamesFV tvs thing_inside }
1052
1053 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
1054         -- This function is used only in rnSourceDecl on InstDecl
1055 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
1056
1057 -------------------------------------
1058 checkDupRdrNames :: [Located RdrName] -> RnM ()
1059 -- Check for duplicated names in a binding group
1060 checkDupRdrNames rdr_names_w_loc
1061   = mapM_ (dupNamesErr getLoc) dups
1062   where
1063     (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
1064
1065 checkDupNames :: [Name] -> RnM ()
1066 -- Check for duplicated names in a binding group
1067 checkDupNames names
1068   = mapM_ (dupNamesErr nameSrcSpan) dups
1069   where
1070     (_, dups) = removeDups (\n1 n2 -> nameOccName n1 `compare` nameOccName n2) $
1071                 filterOut isSystemName names
1072                 -- See Note [Binders in Template Haskell] in Convert
1073
1074 ---------------------
1075 checkDupAndShadowedRdrNames :: [Located RdrName] -> RnM ()
1076 checkDupAndShadowedRdrNames loc_rdr_names
1077   = do  { checkDupRdrNames loc_rdr_names
1078         ; envs <- getRdrEnvs
1079         ; checkShadowedOccs envs loc_occs }
1080   where
1081     loc_occs = [(loc,rdrNameOcc rdr) | L loc rdr <- loc_rdr_names]
1082
1083 checkDupAndShadowedNames :: (GlobalRdrEnv, LocalRdrEnv) -> [Name] -> RnM ()
1084 checkDupAndShadowedNames envs names
1085   = do { checkDupNames names
1086        ; checkShadowedOccs envs loc_occs }
1087   where
1088     loc_occs = [(nameSrcSpan name, nameOccName name) | name <- names]
1089
1090 -------------------------------------
1091 checkShadowedOccs :: (GlobalRdrEnv, LocalRdrEnv) -> [(SrcSpan,OccName)] -> RnM ()
1092 checkShadowedOccs (global_env,local_env) loc_occs
1093   = ifWOptM Opt_WarnNameShadowing $ 
1094     do  { traceRn (text "shadow" <+> ppr loc_occs)
1095         ; mapM_ check_shadow loc_occs }
1096   where
1097     check_shadow (loc, occ)
1098         | startsWithUnderscore occ = return ()  -- Do not report shadowing for "_x"
1099                                                 -- See Trac #3262
1100         | Just n <- mb_local = complain [ptext (sLit "bound at") <+> ppr (nameSrcLoc n)]
1101         | otherwise = do { gres' <- filterM is_shadowed_gre gres
1102                          ; complain (map pprNameProvenance gres') }
1103         where
1104           complain []      = return ()
1105           complain pp_locs = addWarnAt loc (shadowedNameWarn occ pp_locs)
1106           mb_local = lookupLocalRdrOcc local_env occ
1107           gres     = lookupGRE_RdrName (mkRdrUnqual occ) global_env
1108                 -- Make an Unqualified RdrName and look that up, so that
1109                 -- we don't find any GREs that are in scope qualified-only
1110
1111     is_shadowed_gre :: GlobalRdrElt -> RnM Bool 
1112         -- Returns False for record selectors that are shadowed, when
1113         -- punning or wild-cards are on (cf Trac #2723)
1114     is_shadowed_gre gre@(GRE { gre_par = ParentIs _ })
1115         = do { dflags <- getDOpts
1116              ; if (xopt Opt_RecordPuns dflags || xopt Opt_RecordWildCards dflags) 
1117                then do { is_fld <- is_rec_fld gre; return (not is_fld) }
1118                else return True }
1119     is_shadowed_gre _other = return True
1120
1121     is_rec_fld gre      -- Return True for record selector ids
1122         | isLocalGRE gre = do { RecFields _ fld_set <- getRecFieldEnv
1123                               ; return (gre_name gre `elemNameSet` fld_set) }
1124         | otherwise      = do { sel_id <- tcLookupField (gre_name gre)
1125                               ; return (isRecordSelector sel_id) }
1126 \end{code}
1127
1128
1129 %************************************************************************
1130 %*                                                                      *
1131                What to do when a lookup fails
1132 %*                                                                      *
1133 %************************************************************************
1134
1135 \begin{code}
1136 data WhereLooking = WL_Any        -- Any binding
1137                   | WL_Global     -- Any top-level binding (local or imported)
1138                   | WL_LocalTop   -- Any top-level binding in this module
1139
1140 unboundName :: WhereLooking -> RdrName -> RnM Name
1141 unboundName wl rdr = unboundNameX wl rdr empty
1142
1143 unboundNameX :: WhereLooking -> RdrName -> SDoc -> RnM Name
1144 unboundNameX where_look rdr_name extra
1145   = do  { show_helpful_errors <- doptM Opt_HelpfulErrors
1146         ; let err = unknownNameErr rdr_name $$ extra
1147         ; if not show_helpful_errors
1148           then addErr err
1149           else do { suggestions <- unknownNameSuggestErr where_look rdr_name
1150                   ; addErr (err $$ suggestions) }
1151
1152         ; env <- getGlobalRdrEnv;
1153         ; traceRn (vcat [unknownNameErr rdr_name, 
1154                          ptext (sLit "Global envt is:"),
1155                          nest 3 (pprGlobalRdrEnv env)])
1156
1157         ; return (mkUnboundName rdr_name) }
1158
1159 unknownNameErr :: RdrName -> SDoc
1160 unknownNameErr rdr_name
1161   = vcat [ hang (ptext (sLit "Not in scope:")) 
1162               2 (pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))
1163                           <+> quotes (ppr rdr_name))
1164          , extra ]
1165   where
1166     extra | rdr_name == forall_tv_RDR = perhapsForallMsg
1167           | otherwise                 = empty
1168
1169 type HowInScope = Either SrcSpan ImpDeclSpec
1170      -- Left loc    =>  locally bound at loc
1171      -- Right ispec =>  imported as specified by ispec
1172
1173 unknownNameSuggestErr :: WhereLooking -> RdrName -> RnM SDoc
1174 unknownNameSuggestErr where_look tried_rdr_name
1175   = do { local_env <- getLocalRdrEnv
1176        ; global_env <- getGlobalRdrEnv
1177
1178        ; let all_possibilities :: [(String, (RdrName, HowInScope))]
1179              all_possibilities
1180                 =  [ (showSDoc (ppr r), (r, Left loc))
1181                    | (r,loc) <- local_possibilities local_env ]
1182                 ++ [ (showSDoc (ppr r), rp) | (r,rp) <- global_possibilities global_env ]
1183
1184              suggest = fuzzyLookup (showSDoc (ppr tried_rdr_name)) all_possibilities
1185              perhaps = ptext (sLit "Perhaps you meant")
1186              extra_err = case suggest of
1187                            []  -> empty
1188                            [p] -> perhaps <+> pp_item p
1189                            ps  -> sep [ perhaps <+> ptext (sLit "one of these:")
1190                                       , nest 2 (pprWithCommas pp_item ps) ]
1191        ; return extra_err }
1192   where
1193     pp_item :: (RdrName, HowInScope) -> SDoc
1194     pp_item (rdr, Left loc) = quotes (ppr rdr) <+> loc' -- Locally defined
1195         where loc' = case loc of
1196                      UnhelpfulSpan l -> parens (ppr l)
1197                      RealSrcSpan l -> parens (ptext (sLit "line") <+> int (srcSpanStartLine l))
1198     pp_item (rdr, Right is) = quotes (ppr rdr) <+>   -- Imported
1199                               parens (ptext (sLit "imported from") <+> ppr (is_mod is))
1200
1201     tried_occ     = rdrNameOcc tried_rdr_name
1202     tried_is_sym  = isSymOcc tried_occ
1203     tried_ns      = occNameSpace tried_occ
1204     tried_is_qual = isQual tried_rdr_name
1205
1206     correct_name_space occ =  occNameSpace occ == tried_ns
1207                            && isSymOcc occ == tried_is_sym
1208         -- Treat operator and non-operators as non-matching
1209         -- This heuristic avoids things like
1210         --      Not in scope 'f'; perhaps you meant '+' (from Prelude)
1211
1212     local_ok = case where_look of { WL_Any -> True; _ -> False }
1213     local_possibilities :: LocalRdrEnv -> [(RdrName, SrcSpan)]
1214     local_possibilities env
1215       | tried_is_qual = []
1216       | not local_ok  = []
1217       | otherwise     = [ (mkRdrUnqual occ, nameSrcSpan name)
1218                         | name <- occEnvElts env
1219                         , let occ = nameOccName name
1220                         , correct_name_space occ]
1221
1222     gre_ok :: GlobalRdrElt -> Bool
1223     gre_ok = case where_look of
1224                    WL_LocalTop -> isLocalGRE
1225                    _           -> \_ -> True
1226
1227     global_possibilities :: GlobalRdrEnv -> [(RdrName, (RdrName, HowInScope))]
1228     global_possibilities global_env
1229       | tried_is_qual = [ (rdr_qual, (rdr_qual, how))
1230                         | gre <- globalRdrEnvElts global_env
1231                         , gre_ok gre
1232                         , let name = gre_name gre
1233                               occ  = nameOccName name
1234                         , correct_name_space occ
1235                         , (mod, how) <- quals_in_scope name (gre_prov gre)
1236                         , let rdr_qual = mkRdrQual mod occ ]
1237
1238       | otherwise = [ (rdr_unqual, pair)
1239                     | gre <- globalRdrEnvElts global_env
1240                     , gre_ok gre
1241                     , let name = gre_name gre
1242                           prov = gre_prov gre
1243                           occ  = nameOccName name
1244                           rdr_unqual = mkRdrUnqual occ
1245                     , correct_name_space occ
1246                     , pair <- case (unquals_in_scope name prov, quals_only occ prov) of
1247                                 (how:_, _)    -> [ (rdr_unqual, how) ]
1248                                 ([],    pr:_) -> [ pr ]  -- See Note [Only-quals]
1249                                 ([],    [])   -> [] ]
1250
1251               -- Note [Only-quals]
1252               -- The second alternative returns those names with the same
1253               -- OccName as the one we tried, but live in *qualified* imports
1254               -- e.g. if you have:
1255               --
1256               -- > import qualified Data.Map as Map
1257               -- > foo :: Map
1258               --
1259               -- then we suggest @Map.Map@.
1260
1261     --------------------
1262     unquals_in_scope :: Name -> Provenance -> [HowInScope]
1263     unquals_in_scope n LocalDef      = [ Left (nameSrcSpan n) ]
1264     unquals_in_scope _ (Imported is) = [ Right ispec
1265                                        | i <- is, let ispec = is_decl i
1266                                        , not (is_qual ispec) ]
1267
1268     --------------------
1269     quals_in_scope :: Name -> Provenance -> [(ModuleName, HowInScope)]
1270     -- Ones for which the qualified version is in scope
1271     quals_in_scope n LocalDef      = case nameModule_maybe n of
1272                                        Nothing -> []
1273                                        Just m  -> [(moduleName m, Left (nameSrcSpan n))]
1274     quals_in_scope _ (Imported is) = [ (is_as ispec, Right ispec)
1275                                      | i <- is, let ispec = is_decl i ]
1276
1277     --------------------
1278     quals_only :: OccName -> Provenance -> [(RdrName, HowInScope)]
1279     -- Ones for which *only* the qualified version is in scope
1280     quals_only _   LocalDef      = []
1281     quals_only occ (Imported is) = [ (mkRdrQual (is_as ispec) occ, Right ispec)
1282                                    | i <- is, let ispec = is_decl i, is_qual ispec ]
1283 \end{code}
1284
1285 %************************************************************************
1286 %*                                                                      *
1287 \subsection{Free variable manipulation}
1288 %*                                                                      *
1289 %************************************************************************
1290
1291 \begin{code}
1292 -- A useful utility
1293 addFvRn :: FreeVars -> RnM (thing, FreeVars) -> RnM (thing, FreeVars)
1294 addFvRn fvs1 thing_inside = do { (res, fvs2) <- thing_inside
1295                                ; return (res, fvs1 `plusFV` fvs2) }
1296
1297 mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
1298 mapFvRn f xs = do stuff <- mapM f xs
1299                   case unzip stuff of
1300                       (ys, fvs_s) -> return (ys, plusFVs fvs_s)
1301
1302 mapMaybeFvRn :: (a -> RnM (b, FreeVars)) -> Maybe a -> RnM (Maybe b, FreeVars)
1303 mapMaybeFvRn _ Nothing = return (Nothing, emptyFVs)
1304 mapMaybeFvRn f (Just x) = do { (y, fvs) <- f x; return (Just y, fvs) }
1305
1306 -- because some of the rename functions are CPSed:
1307 -- maps the function across the list from left to right; 
1308 -- collects all the free vars into one set
1309 mapFvRnCPS :: (a  -> (b   -> RnM c) -> RnM c) 
1310            -> [a] -> ([b] -> RnM c) -> RnM c
1311
1312 mapFvRnCPS _ []     cont = cont []
1313 mapFvRnCPS f (x:xs) cont = f x             $ \ x' -> 
1314                            mapFvRnCPS f xs $ \ xs' ->
1315                            cont (x':xs')
1316 \end{code}
1317
1318
1319 %************************************************************************
1320 %*                                                                      *
1321 \subsection{Envt utility functions}
1322 %*                                                                      *
1323 %************************************************************************
1324
1325 \begin{code}
1326 warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
1327 warnUnusedTopBinds gres
1328     = ifWOptM Opt_WarnUnusedBinds
1329     $ do isBoot <- tcIsHsBoot
1330          let noParent gre = case gre_par gre of
1331                             NoParent -> True
1332                             ParentIs _ -> False
1333              -- Don't warn about unused bindings with parents in
1334              -- .hs-boot files, as you are sometimes required to give
1335              -- unused bindings (trac #3449).
1336              gres' = if isBoot then filter noParent gres
1337                                else                 gres
1338          warnUnusedGREs gres'
1339
1340 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> FreeVars -> RnM ()
1341 warnUnusedLocalBinds = check_unused Opt_WarnUnusedBinds
1342 warnUnusedMatches    = check_unused Opt_WarnUnusedMatches
1343
1344 check_unused :: WarningFlag -> [Name] -> FreeVars -> RnM ()
1345 check_unused flag bound_names used_names
1346  = ifWOptM flag (warnUnusedLocals (filterOut (`elemNameSet` used_names) bound_names))
1347
1348 -------------------------
1349 --      Helpers
1350 warnUnusedGREs :: [GlobalRdrElt] -> RnM ()
1351 warnUnusedGREs gres 
1352  = warnUnusedBinds [(n,p) | GRE {gre_name = n, gre_prov = p} <- gres]
1353
1354 warnUnusedLocals :: [Name] -> RnM ()
1355 warnUnusedLocals names
1356  = warnUnusedBinds [(n,LocalDef) | n<-names]
1357
1358 warnUnusedBinds :: [(Name,Provenance)] -> RnM ()
1359 warnUnusedBinds names  = mapM_ warnUnusedName (filter reportable names)
1360  where reportable (name,_) 
1361         | isWiredInName name = False    -- Don't report unused wired-in names
1362                                         -- Otherwise we get a zillion warnings
1363                                         -- from Data.Tuple
1364         | otherwise = not (startsWithUnderscore (nameOccName name))
1365
1366 -------------------------
1367
1368 warnUnusedName :: (Name, Provenance) -> RnM ()
1369 warnUnusedName (name, LocalDef)
1370   = addUnusedWarning name (nameSrcSpan name)
1371                      (ptext (sLit "Defined but not used"))
1372
1373 warnUnusedName (name, Imported is)
1374   = mapM_ warn is
1375   where
1376     warn spec = addUnusedWarning name span msg
1377         where
1378            span = importSpecLoc spec
1379            pp_mod = quotes (ppr (importSpecModule spec))
1380            msg = ptext (sLit "Imported from") <+> pp_mod <+> ptext (sLit "but not used")
1381
1382 addUnusedWarning :: Name -> SrcSpan -> SDoc -> RnM ()
1383 addUnusedWarning name span msg
1384   = addWarnAt span $
1385     sep [msg <> colon, 
1386          nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
1387                         <+> quotes (ppr name)]
1388 \end{code}
1389
1390 \begin{code}
1391 addNameClashErrRn :: RdrName -> [GlobalRdrElt] -> RnM ()
1392 addNameClashErrRn rdr_name names
1393   = addErr (vcat [ptext (sLit "Ambiguous occurrence") <+> quotes (ppr rdr_name),
1394                   ptext (sLit "It could refer to") <+> vcat (msg1 : msgs)])
1395   where
1396     (np1:nps) = names
1397     msg1 = ptext  (sLit "either") <+> mk_ref np1
1398     msgs = [ptext (sLit "    or") <+> mk_ref np | np <- nps]
1399     mk_ref gre = sep [quotes (ppr (gre_name gre)) <> comma, pprNameProvenance gre]
1400
1401 shadowedNameWarn :: OccName -> [SDoc] -> SDoc
1402 shadowedNameWarn occ shadowed_locs
1403   = sep [ptext (sLit "This binding for") <+> quotes (ppr occ)
1404             <+> ptext (sLit "shadows the existing binding") <> plural shadowed_locs,
1405          nest 2 (vcat shadowed_locs)]
1406
1407 perhapsForallMsg :: SDoc
1408 perhapsForallMsg 
1409   = vcat [ ptext (sLit "Perhaps you intended to use -XExplicitForAll or similar flag")
1410          , ptext (sLit "to enable explicit-forall syntax: forall <tvs>. <type>")]
1411
1412 unknownSubordinateErr :: SDoc -> RdrName -> SDoc
1413 unknownSubordinateErr doc op    -- Doc is "method of class" or 
1414                                 -- "field of constructor"
1415   = quotes (ppr op) <+> ptext (sLit "is not a (visible)") <+> doc
1416
1417 badOrigBinding :: RdrName -> SDoc
1418 badOrigBinding name
1419   = ptext (sLit "Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
1420         -- The rdrNameOcc is because we don't want to print Prelude.(,)
1421
1422 dupNamesErr :: Outputable n => (n -> SrcSpan) -> [n] -> RnM ()
1423 dupNamesErr get_loc names
1424   = addErrAt big_loc $
1425     vcat [ptext (sLit "Conflicting definitions for") <+> quotes (ppr (head names)),
1426           locations]
1427   where
1428     locs      = map get_loc names
1429     big_loc   = foldr1 combineSrcSpans locs
1430     locations = ptext (sLit "Bound at:") <+> vcat (map ppr (sortLe (<=) locs))
1431
1432 kindSigErr :: Outputable a => a -> SDoc
1433 kindSigErr thing
1434   = hang (ptext (sLit "Illegal kind signature for") <+> quotes (ppr thing))
1435        2 (ptext (sLit "Perhaps you intended to use -XKindSignatures"))
1436
1437 polyKindsErr :: Outputable a => a -> SDoc
1438 polyKindsErr thing
1439   = hang (ptext (sLit "Illegal kind:") <+> quotes (ppr thing))
1440        2 (ptext (sLit "Perhaps you intended to use -XPolyKinds"))
1441
1442
1443 badQualBndrErr :: RdrName -> SDoc
1444 badQualBndrErr rdr_name
1445   = ptext (sLit "Qualified name in binding position:") <+> ppr rdr_name
1446
1447 opDeclErr :: RdrName -> SDoc
1448 opDeclErr n 
1449   = hang (ptext (sLit "Illegal declaration of a type or class operator") <+> quotes (ppr n))
1450        2 (ptext (sLit "Use -XTypeOperators to declare operators in type and declarations"))
1451 \end{code}
1452
1453
1454 %************************************************************************
1455 %*                                                                      *
1456 \subsection{Contexts for renaming errors}
1457 %*                                                                      *
1458 %************************************************************************
1459
1460 \begin{code}
1461
1462 data HsDocContext
1463   = TypeSigCtx SDoc
1464   | PatCtx
1465   | SpecInstSigCtx
1466   | DefaultDeclCtx
1467   | ForeignDeclCtx (Located RdrName)
1468   | DerivDeclCtx
1469   | RuleCtx FastString
1470   | TyDataCtx (Located RdrName)
1471   | TySynCtx (Located RdrName)
1472   | TyFamilyCtx (Located RdrName)
1473   | ConDeclCtx (Located RdrName)
1474   | ClassDeclCtx (Located RdrName)
1475   | ExprWithTySigCtx
1476   | TypBrCtx
1477   | HsTypeCtx
1478   | GHCiCtx
1479   | SpliceTypeCtx (LHsType RdrName)
1480   | ClassInstanceCtx
1481   | VectDeclCtx (Located RdrName)
1482
1483 docOfHsDocContext :: HsDocContext -> SDoc
1484 docOfHsDocContext (TypeSigCtx doc) = text "In the type signature for" <+> doc
1485 docOfHsDocContext PatCtx = text "In a pattern type-signature"
1486 docOfHsDocContext SpecInstSigCtx = text "In a SPECIALISE instance pragma"
1487 docOfHsDocContext DefaultDeclCtx = text "In a `default' declaration"
1488 docOfHsDocContext (ForeignDeclCtx name) = ptext (sLit "In the foreign declaration for") <+> ppr name
1489 docOfHsDocContext DerivDeclCtx = text "In a deriving declaration"
1490 docOfHsDocContext (RuleCtx name) = text "In the transformation rule" <+> ftext name
1491 docOfHsDocContext (TyDataCtx tycon) = text "In the data type declaration for" <+> quotes (ppr tycon)
1492 docOfHsDocContext (TySynCtx name) = text "In the declaration for type synonym" <+> quotes (ppr name)
1493 docOfHsDocContext (TyFamilyCtx name) = text "In the declaration for type family" <+> quotes (ppr name)
1494 docOfHsDocContext (ConDeclCtx name) = text "In the definition of data constructor" <+> quotes (ppr name)
1495 docOfHsDocContext (ClassDeclCtx name) = text "In the declaration for class"     <+> ppr name
1496 docOfHsDocContext ExprWithTySigCtx = text "In an expression type signature"
1497 docOfHsDocContext TypBrCtx = ptext (sLit "In a Template-Haskell quoted type")
1498 docOfHsDocContext HsTypeCtx = text "In a type argument"
1499 docOfHsDocContext GHCiCtx = ptext (sLit "In GHCi input")
1500 docOfHsDocContext (SpliceTypeCtx hs_ty) = ptext (sLit "In the spliced type") <+> ppr hs_ty
1501 docOfHsDocContext ClassInstanceCtx = ptext (sLit "TcSplice.reifyInstances")
1502 docOfHsDocContext (VectDeclCtx tycon) = ptext (sLit "In the VECTORISE pragma for type constructor") <+> quotes (ppr tycon)
1503
1504 \end{code}