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