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