e33ed15808829b0944fcadb755d683727ddd9ae9
[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 {-# LANGUAGE CPP #-}
8
9 module RnEnv (
10         newTopSrcBinder,
11         lookupLocatedTopBndrRn, lookupTopBndrRn,
12         lookupLocatedOccRn, lookupOccRn, lookupOccRn_maybe,
13         lookupLocalOccRn_maybe,
14         lookupLocalOccThLvl_maybe,
15         lookupTypeOccRn, lookupKindOccRn,
16         lookupGlobalOccRn, lookupGlobalOccRn_maybe,
17         reportUnboundName,
18
19         HsSigCtxt(..), lookupLocalTcNames, lookupSigOccRn,
20
21         lookupFixityRn, lookupTyFixityRn,
22         lookupInstDeclBndr, lookupSubBndrOcc, lookupFamInstName,
23         greRdrName,
24         lookupSubBndrGREs, lookupConstructorFields,
25         lookupSyntaxName, lookupSyntaxNames, lookupIfThenElse,
26         lookupGreRn, lookupGreRn_maybe,
27         lookupGreLocalRn_maybe, 
28         getLookupOccRn, addUsedRdrNames,
29
30         newLocalBndrRn, newLocalBndrsRn,
31         bindLocalNames, bindLocalNamesFV,
32         MiniFixityEnv, 
33         addLocalFixities,
34         bindLocatedLocalsFV, bindLocatedLocalsRn,
35         extendTyVarEnvFVRn,
36
37         checkDupRdrNames, checkShadowedRdrNames,
38         checkDupNames, checkDupAndShadowedNames, checkTupSize,
39         addFvRn, mapFvRn, mapMaybeFvRn, mapFvRnCPS,
40         warnUnusedMatches,
41         warnUnusedTopBinds, warnUnusedLocalBinds,
42         dataTcOccs, kindSigErr, perhapsForallMsg,
43         HsDocContext(..), docOfHsDocContext
44     ) where
45
46 #include "HsVersions.h"
47
48 import LoadIface        ( loadInterfaceForName, loadSrcInterface_maybe )
49 import IfaceEnv
50 import HsSyn
51 import RdrName
52 import HscTypes
53 import TcEnv            ( tcLookupDataCon, tcLookupField, isBrackStage )
54 import TcRnMonad
55 import Id               ( isRecordSelector )
56 import Name
57 import NameSet
58 import NameEnv
59 import Avail
60 import Module
61 import ConLike
62 import DataCon          ( dataConFieldLabels, dataConTyCon )
63 import TyCon            ( isTupleTyCon, tyConArity )
64 import PrelNames        ( mkUnboundName, isUnboundName, rOOT_MAIN, forall_tv_RDR )
65 import ErrUtils         ( MsgDoc )
66 import BasicTypes       ( Fixity(..), FixityDirection(..), minPrecedence, defaultFixity )
67 import SrcLoc
68 import Outputable
69 import Util
70 import Maybes
71 import BasicTypes       ( TopLevelFlag(..) )
72 import ListSetOps       ( removeDups )
73 import DynFlags
74 import FastString
75 import Control.Monad
76 import Data.List
77 import qualified Data.Set as Set
78 import Constants        ( mAX_TUPLE_SIZE )
79 \end{code}
80
81 %*********************************************************
82 %*                                                      *
83                 Source-code binders
84 %*                                                      *
85 %*********************************************************
86
87 Note [Signature lazy interface loading]
88 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
89
90 GHC's lazy interface loading can be a bit confusing, so this Note is an
91 empirical description of what happens in one interesting case. When
92 compiling a signature module against an its implementation, we do NOT
93 load interface files associated with its names until after the type
94 checking phase.  For example:
95
96     module ASig where
97         data T
98         f :: T -> T
99
100 Suppose we compile this with -sig-of "A is ASig":
101
102     module B where
103         data T = T
104         f T = T
105
106     module A(module B) where
107         import B
108
109 During type checking, we'll load A.hi because we need to know what the
110 RdrEnv for the module is, but we DO NOT load the interface for B.hi!
111 It's wholly unnecessary: our local definition 'data T' in ASig is all
112 the information we need to finish type checking.  This is contrast to
113 type checking of ordinary Haskell files, in which we would not have the
114 local definition "data T" and would need to consult B.hi immediately.
115 (Also, this situation never occurs for hs-boot files, since you're not
116 allowed to reexport from another module.)
117
118 After type checking, we then check that the types we provided are
119 consistent with the backing implementation (in checkHiBootOrHsigIface).
120 At this point, B.hi is loaded, because we need something to compare
121 against.
122
123 I discovered this behavior when trying to figure out why type class
124 instances for Data.Map weren't in the EPS when I was type checking a
125 test very much like ASig (sigof02dm): the associated interface hadn't
126 been loaded yet!  (The larger issue is a moot point, since an instance
127 declared in a signature can never be a duplicate.)
128
129 This behavior might change in the future.  Consider this
130 alternate module B:
131
132     module B where
133         {-# DEPRECATED T, f "Don't use" #-}
134         data T = T
135         f T = T
136
137 One might conceivably want to report deprecation warnings when compiling
138 ASig with -sig-of B, in which case we need to look at B.hi to find the
139 deprecation warnings during renaming.  At the moment, you don't get any
140 warning until you use the identifier further downstream.  This would
141 require adjusting addUsedRdrName so that during signature compilation,
142 we do not report deprecation warnings for LocalDef.  See also
143 Note [Handling of deprecations]
144
145 \begin{code}
146 newTopSrcBinder :: Located RdrName -> RnM Name
147 newTopSrcBinder (L loc rdr_name)
148   | Just name <- isExact_maybe rdr_name
149   =     -- This is here to catch
150         --   (a) Exact-name binders created by Template Haskell
151         --   (b) The PrelBase defn of (say) [] and similar, for which
152         --       the parser reads the special syntax and returns an Exact RdrName
153         -- We are at a binding site for the name, so check first that it
154         -- the current module is the correct one; otherwise GHC can get
155         -- very confused indeed. This test rejects code like
156         --      data T = (,) Int Int
157         -- unless we are in GHC.Tup
158     if isExternalName name then
159       do { this_mod <- getModule
160          ; unless (this_mod == nameModule name)
161                   (addErrAt loc (badOrigBinding rdr_name))
162          ; return name }
163     else   -- See Note [Binders in Template Haskell] in Convert.hs
164       do { let occ = nameOccName name
165          ; occ `seq` return ()  -- c.f. seq in newGlobalBinder
166          ; this_mod <- getModule
167          ; updNameCache $ \ ns ->
168            let name' = mkExternalName (nameUnique name) this_mod occ loc
169                ns'   = ns { nsNames = extendNameCache (nsNames ns) this_mod occ name' }
170            in (ns', name') }
171
172   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
173   = do  { this_mod <- getModule
174         ; unless (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
175                  (addErrAt loc (badOrigBinding rdr_name))
176         -- When reading External Core we get Orig names as binders,
177         -- but they should agree with the module gotten from the monad
178         --
179         -- We can get built-in syntax showing up here too, sadly.  If you type
180         --      data T = (,,,)
181         -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon
182         -- uses setRdrNameSpace to make it into a data constructors.  At that point
183         -- the nice Exact name for the TyCon gets swizzled to an Orig name.
184         -- Hence the badOrigBinding error message.
185         --
186         -- Except for the ":Main.main = ..." definition inserted into
187         -- the Main module; ugh!
188
189         -- Because of this latter case, we call newGlobalBinder with a module from
190         -- the RdrName, not from the environment.  In principle, it'd be fine to
191         -- have an arbitrary mixture of external core definitions in a single module,
192         -- (apart from module-initialisation issues, perhaps).
193         ; newGlobalBinder rdr_mod rdr_occ loc }
194
195   | otherwise
196   = do  { unless (not (isQual rdr_name))
197                  (addErrAt loc (badQualBndrErr rdr_name))
198                 -- Binders should not be qualified; if they are, and with a different
199                 -- module name, we we get a confusing "M.T is not in scope" error later
200
201         ; stage <- getStage
202         ; env <- getGblEnv
203         ; if isBrackStage stage then
204                 -- We are inside a TH bracket, so make an *Internal* name
205                 -- See Note [Top-level Names in Template Haskell decl quotes] in RnNames
206              do { uniq <- newUnique
207                 ; return (mkInternalName uniq (rdrNameOcc rdr_name) loc) }
208           else case tcg_impl_rdr_env env of
209             Just gr ->
210                 -- We're compiling --sig-of, so resolve with respect to this
211                 -- module.
212                 -- See Note [Signature parameters in TcGblEnv and DynFlags]
213              do { case lookupGlobalRdrEnv gr (rdrNameOcc rdr_name) of
214                     -- Be sure to override the loc so that we get accurate
215                     -- information later
216                     [GRE{ gre_name = n }] -> do
217                       -- NB: Just adding this line will not work:
218                       --    addUsedRdrName True gre rdr_name
219                       -- see Note [Signature lazy interface loading] for
220                       -- more details.
221                       return (setNameLoc n loc)
222                     _ -> do
223                       { -- NB: cannot use reportUnboundName rdr_name
224                         -- because it looks up in the wrong RdrEnv
225                         -- ToDo: more helpful error messages
226                       ; addErr (unknownNameErr (pprNonVarNameSpace
227                             (occNameSpace (rdrNameOcc rdr_name))) rdr_name)
228                       ; return (mkUnboundName rdr_name)
229                       }
230                 }
231             Nothing ->
232                 -- Normal case
233              do { this_mod <- getModule
234                 ; newGlobalBinder this_mod (rdrNameOcc rdr_name) loc } }
235 \end{code}
236
237 %*********************************************************
238 %*                                                      *
239         Source code occurrences
240 %*                                                      *
241 %*********************************************************
242
243 Looking up a name in the RnEnv.
244
245 Note [Type and class operator definitions]
246 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
247 We want to reject all of these unless we have -XTypeOperators (Trac #3265)
248    data a :*: b  = ...
249    class a :*: b where ...
250    data (:*:) a b  = ....
251    class (:*:) a b where ...
252 The latter two mean that we are not just looking for a
253 *syntactically-infix* declaration, but one that uses an operator
254 OccName.  We use OccName.isSymOcc to detect that case, which isn't
255 terribly efficient, but there seems to be no better way.
256
257 \begin{code}
258 lookupTopBndrRn :: RdrName -> RnM Name
259 lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n
260                        case nopt of
261                          Just n' -> return n'
262                          Nothing -> do traceRn $ text "lookupTopBndrRn"
263                                        unboundName WL_LocalTop n
264
265 lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
266 lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn
267
268 lookupTopBndrRn_maybe :: RdrName -> RnM (Maybe Name)
269 -- Look up a top-level source-code binder.   We may be looking up an unqualified 'f',
270 -- and there may be several imported 'f's too, which must not confuse us.
271 -- For example, this is OK:
272 --      import Foo( f )
273 --      infix 9 f       -- The 'f' here does not need to be qualified
274 --      f x = x         -- Nor here, of course
275 -- So we have to filter out the non-local ones.
276 --
277 -- A separate function (importsFromLocalDecls) reports duplicate top level
278 -- decls, so here it's safe just to choose an arbitrary one.
279 --
280 -- There should never be a qualified name in a binding position in Haskell,
281 -- but there can be if we have read in an external-Core file.
282 -- The Haskell parser checks for the illegal qualified name in Haskell
283 -- source files, so we don't need to do so here.
284
285 lookupTopBndrRn_maybe rdr_name
286   | Just name <- isExact_maybe rdr_name
287   = do { name' <- lookupExactOcc name; return (Just name') }
288
289   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
290         -- This deals with the case of derived bindings, where
291         -- we don't bother to call newTopSrcBinder first
292         -- We assume there is no "parent" name
293   = do  { loc <- getSrcSpanM
294         ; n <- newGlobalBinder rdr_mod rdr_occ loc
295         ; return (Just n)}
296
297   | otherwise
298   = do  {  -- Check for operators in type or class declarations
299            -- See Note [Type and class operator definitions]
300           let occ = rdrNameOcc rdr_name
301         ; when (isTcOcc occ && isSymOcc occ)
302                (do { op_ok <- xoptM Opt_TypeOperators
303                    ; unless op_ok (addErr (opDeclErr rdr_name)) })
304
305         ; mb_gre <- lookupGreLocalRn_maybe rdr_name
306         ; case mb_gre of
307                 Nothing  -> return Nothing
308                 Just gre -> return (Just $ gre_name gre) }
309
310
311 -----------------------------------------------
312 lookupExactOcc :: Name -> RnM Name
313 -- See Note [Looking up Exact RdrNames]
314 lookupExactOcc name
315   | Just thing <- wiredInNameTyThing_maybe name
316   , Just tycon <- case thing of
317                     ATyCon tc                 -> Just tc
318                     AConLike (RealDataCon dc) -> Just (dataConTyCon dc)
319                     _                         -> Nothing
320   , isTupleTyCon tycon
321   = do { checkTupSize (tyConArity tycon)
322        ; return name }
323
324   | isExternalName name
325   = return name
326
327   | otherwise
328   = do { env <- getGlobalRdrEnv
329        ; let -- See Note [Splicing Exact names]
330              main_occ =  nameOccName name
331              demoted_occs = case demoteOccName main_occ of
332                               Just occ -> [occ]
333                               Nothing  -> []
334              gres = [ gre | occ <- main_occ : demoted_occs
335                           , gre <- lookupGlobalRdrEnv env occ
336                           , gre_name gre == name ]
337        ; case gres of
338            []    -> -- See Note [Splicing Exact names]
339                     do { lcl_env <- getLocalRdrEnv
340                        ; unless (name `inLocalRdrEnvScope` lcl_env) $
341 #ifdef GHCI
342                          do { th_topnames_var <- fmap tcg_th_topnames getGblEnv
343                             ; th_topnames <- readTcRef th_topnames_var
344                             ; unless (name `elemNameSet` th_topnames)
345                                      (addErr exact_nm_err)
346                             }
347 #else /* !GHCI */
348                          addErr exact_nm_err
349 #endif /* !GHCI */
350                        ; return name
351                        }
352
353            [gre]   -> return (gre_name gre)
354            (gre:_) -> do {addErr dup_nm_err
355                          ; return (gre_name gre)
356                          }
357            -- We can get more than one GRE here, if there are multiple 
358            -- bindings for the same name. Sometimes they are caught later
359            -- by findLocalDupsRdrEnv, like in this example (Trac #8932):
360            --    $( [d| foo :: a->a; foo x = x |])
361            --    foo = True
362            -- But when the names are totally identical, we panic (Trac #7241):
363            --    $(newName "Foo" >>= \o -> return [DataD [] o [] [RecC o []] [''Show]])
364            -- So, let's emit an error here, even if it will lead to duplication in some cases.
365        }
366
367   where
368     exact_nm_err = hang (ptext (sLit "The exact Name") <+> quotes (ppr name) <+> ptext (sLit "is not in scope"))
369                       2 (vcat [ ptext (sLit "Probable cause: you used a unique Template Haskell name (NameU), ")
370                               , ptext (sLit "perhaps via newName, but did not bind it")
371                               , ptext (sLit "If that's it, then -ddump-splices might be useful") ])
372     dup_nm_err   = hang (ptext (sLit "Duplicate exact Name") <+> quotes (ppr $ nameOccName name))
373                       2 (vcat [ ptext (sLit "Probable cause: you used a unique Template Haskell name (NameU), ")
374                               , ptext (sLit "perhaps via newName, but bound it multiple times")
375                               , ptext (sLit "If that's it, then -ddump-splices might be useful") ])
376
377 -----------------------------------------------
378 lookupInstDeclBndr :: Name -> SDoc -> RdrName -> RnM Name
379 -- This is called on the method name on the left-hand side of an
380 -- instance declaration binding. eg.  instance Functor T where
381 --                                       fmap = ...
382 --                                       ^^^^ called on this
383 -- Regardless of how many unqualified fmaps are in scope, we want
384 -- the one that comes from the Functor class.
385 --
386 -- Furthermore, note that we take no account of whether the
387 -- name is only in scope qualified.  I.e. even if method op is
388 -- in scope as M.op, we still allow plain 'op' on the LHS of
389 -- an instance decl
390 --
391 -- The "what" parameter says "method" or "associated type",
392 -- depending on what we are looking up
393 lookupInstDeclBndr cls what rdr
394   = do { when (isQual rdr)
395               (addErr (badQualBndrErr rdr))
396                 -- In an instance decl you aren't allowed
397                 -- to use a qualified name for the method
398                 -- (Although it'd make perfect sense.)
399        ; lookupSubBndrOcc False -- False => we don't give deprecated
400                                 -- warnings when a deprecated class
401                                 -- method is defined. We only warn
402                                 -- when it's used
403                           (ParentIs cls) doc rdr }
404   where
405     doc = what <+> ptext (sLit "of class") <+> quotes (ppr cls)
406
407
408 -----------------------------------------------
409 lookupFamInstName :: Maybe Name -> Located RdrName -> RnM (Located Name)
410 -- Used for TyData and TySynonym family instances only,
411 -- See Note [Family instance binders]
412 lookupFamInstName (Just cls) tc_rdr  -- Associated type; c.f RnBinds.rnMethodBind
413   = wrapLocM (lookupInstDeclBndr cls (ptext (sLit "associated type"))) tc_rdr
414 lookupFamInstName Nothing tc_rdr     -- Family instance; tc_rdr is an *occurrence*
415   = lookupLocatedOccRn tc_rdr
416
417 -----------------------------------------------
418 lookupConstructorFields :: Name -> RnM [Name]
419 -- Look up the fields of a given constructor
420 --   *  For constructors from this module, use the record field env,
421 --      which is itself gathered from the (as yet un-typechecked)
422 --      data type decls
423 --
424 --    * For constructors from imported modules, use the *type* environment
425 --      since imported modles are already compiled, the info is conveniently
426 --      right there
427
428 lookupConstructorFields con_name
429   = do  { this_mod <- getModule
430         ; if nameIsLocalOrFrom this_mod con_name then
431           do { RecFields field_env _ <- getRecFieldEnv
432              ; return (lookupNameEnv field_env con_name `orElse` []) }
433           else
434           do { con <- tcLookupDataCon con_name
435              ; return (dataConFieldLabels con) } }
436
437 -----------------------------------------------
438 -- Used for record construction and pattern matching
439 -- When the -XDisambiguateRecordFields flag is on, take account of the
440 -- constructor name to disambiguate which field to use; it's just the
441 -- same as for instance decls
442 --
443 -- NB: Consider this:
444 --      module Foo where { data R = R { fld :: Int } }
445 --      module Odd where { import Foo; fld x = x { fld = 3 } }
446 -- Arguably this should work, because the reference to 'fld' is
447 -- unambiguous because there is only one field id 'fld' in scope.
448 -- But currently it's rejected.
449
450 lookupSubBndrOcc :: Bool
451                  -> Parent  -- NoParent   => just look it up as usual
452                             -- ParentIs p => use p to disambiguate
453                  -> SDoc -> RdrName
454                  -> RnM Name
455 lookupSubBndrOcc warnIfDeprec parent doc rdr_name
456   | Just n <- isExact_maybe rdr_name   -- This happens in derived code
457   = lookupExactOcc n
458
459   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
460   = lookupOrig rdr_mod rdr_occ
461
462   | otherwise   -- Find all the things the rdr-name maps to
463   = do  {       -- and pick the one with the right parent namep
464           env <- getGlobalRdrEnv
465         ; case lookupSubBndrGREs env parent rdr_name of
466                 -- NB: lookupGlobalRdrEnv, not lookupGRE_RdrName!
467                 --     The latter does pickGREs, but we want to allow 'x'
468                 --     even if only 'M.x' is in scope
469             [gre] -> do { addUsedRdrName warnIfDeprec gre (used_rdr_name gre)
470                           -- Add a usage; this is an *occurrence* site
471                         ; return (gre_name gre) }
472             []    -> do { addErr (unknownSubordinateErr doc rdr_name)
473                         ; return (mkUnboundName rdr_name) }
474             gres  -> do { addNameClashErrRn rdr_name gres
475                         ; return (gre_name (head gres)) } }
476   where
477     -- Note [Usage for sub-bndrs]
478     used_rdr_name gre
479       | isQual rdr_name = rdr_name
480       | otherwise       = greRdrName gre
481
482 greRdrName :: GlobalRdrElt -> RdrName
483 greRdrName gre
484   = case gre_prov gre of
485       LocalDef    -> unqual_rdr
486       Imported is -> used_rdr_name_from_is is
487
488   where
489     occ = nameOccName (gre_name gre)
490     unqual_rdr = mkRdrUnqual occ
491
492     used_rdr_name_from_is imp_specs     -- rdr_name is unqualified
493       | not (all (is_qual . is_decl) imp_specs)
494       = unqual_rdr  -- An unqualified import is available
495       | otherwise
496       =             -- Only qualified imports available, so make up
497                     -- a suitable qualifed name from the first imp_spec
498         ASSERT( not (null imp_specs) )
499         mkRdrQual (is_as (is_decl (head imp_specs))) occ
500
501 lookupSubBndrGREs :: GlobalRdrEnv -> Parent -> RdrName -> [GlobalRdrElt]
502 -- If Parent = NoParent, just do a normal lookup
503 -- If Parent = Parent p then find all GREs that
504 --   (a) have parent p
505 --   (b) for Unqual, are in scope qualified or unqualified
506 --       for Qual, are in scope with that qualification
507 lookupSubBndrGREs env parent rdr_name
508   = case parent of
509       NoParent   -> pickGREs rdr_name gres
510       ParentIs p
511         | isUnqual rdr_name -> filter (parent_is p) gres
512         | otherwise         -> filter (parent_is p) (pickGREs rdr_name gres)
513
514   where
515     gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)
516
517     parent_is p (GRE { gre_par = ParentIs p' }) = p == p'
518     parent_is _ _                               = False
519 \end{code}
520
521 Note [Family instance binders]
522 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
523 Consider
524   data family F a
525   data instance F T = X1 | X2
526
527 The 'data instance' decl has an *occurrence* of F (and T), and *binds*
528 X1 and X2.  (This is unlike a normal data type declaration which would
529 bind F too.)  So we want an AvailTC F [X1,X2].
530
531 Now consider a similar pair:
532   class C a where
533     data G a
534   instance C S where
535     data G S = Y1 | Y2
536
537 The 'data G S' *binds* Y1 and Y2, and has an *occurrence* of G.
538
539 But there is a small complication: in an instance decl, we don't use
540 qualified names on the LHS; instead we use the class to disambiguate.
541 Thus:
542   module M where
543     import Blib( G )
544     class C a where
545       data G a
546     instance C S where
547       data G S = Y1 | Y2
548 Even though there are two G's in scope (M.G and Blib.G), the occurrence
549 of 'G' in the 'instance C S' decl is unambiguous, because C has only
550 one associated type called G. This is exactly what happens for methods,
551 and it is only consistent to do the same thing for types. That's the
552 role of the function lookupTcdName; the (Maybe Name) give the class of
553 the encloseing instance decl, if any.
554
555 Note [Looking up Exact RdrNames]
556 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
557 Exact RdrNames are generated by Template Haskell.  See Note [Binders
558 in Template Haskell] in Convert.
559
560 For data types and classes have Exact system Names in the binding
561 positions for constructors, TyCons etc.  For example
562     [d| data T = MkT Int |]
563 when we splice in and Convert to HsSyn RdrName, we'll get
564     data (Exact (system Name "T")) = (Exact (system Name "MkT")) ...
565 These System names are generated by Convert.thRdrName
566
567 But, constructors and the like need External Names, not System Names!
568 So we do the following
569
570  * In RnEnv.newGlobalBinder we spot Exact RdrNames that wrap a
571    non-External Name, and make an External name for it. This is
572    the name that goes in the GlobalRdrEnv
573
574  * When looking up an occurrence of an Exact name, done in
575    RnEnv.lookupExactOcc, we find the Name with the right unique in the
576    GlobalRdrEnv, and use the one from the envt -- it will be an
577    External Name in the case of the data type/constructor above.
578
579  * Exact names are also use for purely local binders generated
580    by TH, such as    \x_33. x_33
581    Both binder and occurrence are Exact RdrNames.  The occurrence
582    gets looked up in the LocalRdrEnv by RnEnv.lookupOccRn, and
583    misses, because lookupLocalRdrEnv always returns Nothing for
584    an Exact Name.  Now we fall through to lookupExactOcc, which
585    will find the Name is not in the GlobalRdrEnv, so we just use
586    the Exact supplied Name.
587
588 Note [Splicing Exact names]
589 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
590 Consider the splice $(do { x <- newName "x"; return (VarE x) })
591 This will generate a (HsExpr RdrName) term that mentions the
592 Exact RdrName "x_56" (or whatever), but does not bind it.  So
593 when looking such Exact names we want to check that it's in scope,
594 otherwise the type checker will get confused.  To do this we need to
595 keep track of all the Names in scope, and the LocalRdrEnv does just that;
596 we consult it with RdrName.inLocalRdrEnvScope.
597
598 There is another wrinkle.  With TH and -XDataKinds, consider
599    $( [d| data Nat = Zero
600           data T = MkT (Proxy 'Zero)  |] )
601 After splicing, but before renaming we get this:
602    data Nat_77{tc} = Zero_78{d}
603    data T_79{tc} = MkT_80{d} (Proxy 'Zero_78{tc})  |] )
604 The occurrence of 'Zero in the data type for T has the right unique,
605 but it has a TcClsName name-space in its OccName.  (This is set by
606 the ctxt_ns argument of Convert.thRdrName.)  When we check that is
607 in scope in the GlobalRdrEnv, we need to look up the DataName namespace
608 too.  (An alternative would be to make the GlobalRdrEnv also have
609 a Name -> GRE mapping.)
610
611 Note [Usage for sub-bndrs]
612 ~~~~~~~~~~~~~~~~~~~~~~~~~~
613 If you have this
614    import qualified M( C( f ) )
615    instance M.C T where
616      f x = x
617 then is the qualified import M.f used?  Obviously yes.
618 But the RdrName used in the instance decl is unqualified.  In effect,
619 we fill in the qualification by looking for f's whose class is M.C
620 But when adding to the UsedRdrNames we must make that qualification
621 explicit (saying "used  M.f"), otherwise we get "Redundant import of M.f".
622
623 So we make up a suitable (fake) RdrName.  But be careful
624    import qualifed M
625    import M( C(f) )
626    instance C T where
627      f x = x
628 Here we want to record a use of 'f', not of 'M.f', otherwise
629 we'll miss the fact that the qualified import is redundant.
630
631 --------------------------------------------------
632 --              Occurrences
633 --------------------------------------------------
634
635 \begin{code}
636 getLookupOccRn :: RnM (Name -> Maybe Name)
637 getLookupOccRn
638   = do local_env <- getLocalRdrEnv
639        return (lookupLocalRdrOcc local_env . nameOccName)
640
641 lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
642 lookupLocatedOccRn = wrapLocM lookupOccRn
643
644 lookupLocalOccRn_maybe :: RdrName -> RnM (Maybe Name)
645 -- Just look in the local environment
646 lookupLocalOccRn_maybe rdr_name
647   = do { local_env <- getLocalRdrEnv
648        ; return (lookupLocalRdrEnv local_env rdr_name) }
649
650 lookupLocalOccThLvl_maybe :: Name -> RnM (Maybe (TopLevelFlag, ThLevel))
651 -- Just look in the local environment
652 lookupLocalOccThLvl_maybe name
653   = do { lcl_env <- getLclEnv
654        ; return (lookupNameEnv (tcl_th_bndrs lcl_env) name) }
655
656 -- lookupOccRn looks up an occurrence of a RdrName
657 lookupOccRn :: RdrName -> RnM Name
658 lookupOccRn rdr_name
659   = do { mb_name <- lookupOccRn_maybe rdr_name
660        ; case mb_name of
661            Just name -> return name
662            Nothing   -> reportUnboundName rdr_name }
663
664 lookupKindOccRn :: RdrName -> RnM Name
665 -- Looking up a name occurring in a kind
666 lookupKindOccRn rdr_name
667   = do { mb_name <- lookupOccRn_maybe rdr_name
668        ; case mb_name of
669            Just name -> return name
670            Nothing   -> reportUnboundName rdr_name  }
671
672 -- lookupPromotedOccRn looks up an optionally promoted RdrName.
673 lookupTypeOccRn :: RdrName -> RnM Name
674 -- see Note [Demotion]
675 lookupTypeOccRn rdr_name
676   = do { mb_name <- lookupOccRn_maybe rdr_name
677        ; case mb_name of {
678              Just name -> return name ;
679              Nothing   -> lookup_demoted rdr_name } }
680
681 lookup_demoted :: RdrName -> RnM Name
682 lookup_demoted rdr_name
683   | Just demoted_rdr <- demoteRdrName rdr_name
684     -- Maybe it's the name of a *data* constructor
685   = do { data_kinds <- xoptM Opt_DataKinds
686        ; mb_demoted_name <- lookupOccRn_maybe demoted_rdr
687        ; case mb_demoted_name of
688            Nothing -> reportUnboundName rdr_name
689            Just demoted_name
690              | data_kinds -> return demoted_name
691              | otherwise  -> unboundNameX WL_Any rdr_name suggest_dk }
692
693   | otherwise
694   = reportUnboundName rdr_name
695
696   where
697     suggest_dk = ptext (sLit "A data constructor of that name is in scope; did you mean DataKinds?")
698 \end{code}
699
700 Note [Demotion]
701 ~~~~~~~~~~~~~~~
702 When the user writes:
703   data Nat = Zero | Succ Nat
704   foo :: f Zero -> Int
705
706 'Zero' in the type signature of 'foo' is parsed as:
707   HsTyVar ("Zero", TcClsName)
708
709 When the renamer hits this occurrence of 'Zero' it's going to realise
710 that it's not in scope. But because it is renaming a type, it knows
711 that 'Zero' might be a promoted data constructor, so it will demote
712 its namespace to DataName and do a second lookup.
713
714 The final result (after the renamer) will be:
715   HsTyVar ("Zero", DataName)
716
717 \begin{code}
718 --              Use this version to get tracing
719 --
720 -- lookupOccRn_maybe, lookupOccRn_maybe' :: RdrName -> RnM (Maybe Name)
721 -- lookupOccRn_maybe rdr_name
722 --  = do { mb_res <- lookupOccRn_maybe' rdr_name
723 --       ; gbl_rdr_env   <- getGlobalRdrEnv
724 --       ; local_rdr_env <- getLocalRdrEnv
725 --       ; traceRn $ text "lookupOccRn_maybe" <+>
726 --           vcat [ ppr rdr_name <+> ppr (getUnique (rdrNameOcc rdr_name))
727 --                , ppr mb_res
728 --                , text "Lcl env" <+> ppr local_rdr_env
729 --                , text "Gbl env" <+> ppr [ (getUnique (nameOccName (gre_name (head gres'))),gres') | gres <- occEnvElts gbl_rdr_env
730 --                                         , let gres' = filter isLocalGRE gres, not (null gres') ] ]
731 --       ; return mb_res }
732
733 lookupOccRn_maybe :: RdrName -> RnM (Maybe Name)
734 -- lookupOccRn looks up an occurrence of a RdrName
735 lookupOccRn_maybe rdr_name
736   = do { local_env <- getLocalRdrEnv
737        ; case lookupLocalRdrEnv local_env rdr_name of {
738           Just name -> return (Just name) ;
739           Nothing   -> do
740        { mb_name <- lookupGlobalOccRn_maybe rdr_name
741        ; case mb_name of {
742                 Just name  -> return (Just name) ;
743                 Nothing -> do
744        { dflags  <- getDynFlags
745        ; is_ghci <- getIsGHCi   -- This test is not expensive,
746                                 -- and only happens for failed lookups
747        ; lookupQualifiedNameGHCi dflags is_ghci rdr_name } } } } }
748
749 lookupGlobalOccRn :: RdrName -> RnM Name
750 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
751 -- environment.  Adds an error message if the RdrName is not in scope.
752 lookupGlobalOccRn rdr_name
753   = do { mb_name <- lookupGlobalOccRn_maybe rdr_name
754        ; case mb_name of
755            Just n  -> return n
756            Nothing -> do { traceRn (text "lookupGlobalOccRn" <+> ppr rdr_name)
757                          ; unboundName WL_Global rdr_name } }
758
759 lookupGlobalOccRn_maybe :: RdrName -> RnM (Maybe Name)
760 -- No filter function; does not report an error on failure
761
762 lookupGlobalOccRn_maybe rdr_name
763   | Just n <- isExact_maybe rdr_name   -- This happens in derived code
764   = do { n' <- lookupExactOcc n; return (Just n') }
765
766   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
767   = do { n <- lookupOrig rdr_mod rdr_occ
768        ; return (Just n) }
769
770   | otherwise
771   = do  { mb_gre <- lookupGreRn_maybe rdr_name
772         ; case mb_gre of
773                 Nothing  -> return Nothing
774                 Just gre -> return (Just (gre_name gre)) }
775
776
777 --------------------------------------------------
778 --      Lookup in the Global RdrEnv of the module
779 --------------------------------------------------
780
781 lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
782 -- Just look up the RdrName in the GlobalRdrEnv
783 lookupGreRn_maybe rdr_name
784   = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
785
786 lookupGreRn :: RdrName -> RnM GlobalRdrElt
787 -- If not found, add error message, and return a fake GRE
788 lookupGreRn rdr_name
789   = do  { mb_gre <- lookupGreRn_maybe rdr_name
790         ; case mb_gre of {
791             Just gre -> return gre ;
792             Nothing  -> do
793         { traceRn (text "lookupGreRn" <+> ppr rdr_name)
794         ; name <- unboundName WL_Global rdr_name
795         ; return (GRE { gre_name = name, gre_par = NoParent,
796                         gre_prov = LocalDef }) }}}
797
798 lookupGreLocalRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
799 -- Similar, but restricted to locally-defined things
800 lookupGreLocalRn_maybe rdr_name
801   = lookupGreRn_help rdr_name lookup_fn
802   where
803     lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)
804
805 lookupGreRn_help :: RdrName                     -- Only used in error message
806                  -> (GlobalRdrEnv -> [GlobalRdrElt])    -- Lookup function
807                  -> RnM (Maybe GlobalRdrElt)
808 -- Checks for exactly one match; reports deprecations
809 -- Returns Nothing, without error, if too few
810 lookupGreRn_help rdr_name lookup
811   = do  { env <- getGlobalRdrEnv
812         ; case lookup env of
813             []    -> return Nothing
814             [gre] -> do { addUsedRdrName True gre rdr_name
815                         ; return (Just gre) }
816             gres  -> do { addNameClashErrRn rdr_name gres
817                         ; return (Just (head gres)) } }
818 \end{code}
819
820 %*********************************************************
821 %*                                                      *
822                 Deprecations
823 %*                                                      *
824 %*********************************************************
825
826 Note [Handling of deprecations]
827 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
828 * We report deprecations at each *occurrence* of the deprecated thing
829   (see Trac #5867)
830
831 * We do not report deprectations for locally-definded names. For a
832   start, we may be exporting a deprecated thing. Also we may use a
833   deprecated thing in the defn of another deprecated things.  We may
834   even use a deprecated thing in the defn of a non-deprecated thing,
835   when changing a module's interface.
836
837 * addUsedRdrNames: we do not report deprecations for sub-binders:
838      - the ".." completion for records
839      - the ".." in an export item 'T(..)'
840      - the things exported by a module export 'module M'
841
842 \begin{code}
843 addUsedRdrName :: Bool -> GlobalRdrElt -> RdrName -> RnM ()
844 -- Record usage of imported RdrNames
845 addUsedRdrName warnIfDeprec gre rdr
846   | isLocalGRE gre = return ()  -- No call to warnIfDeprecated
847                                 -- See Note [Handling of deprecations]
848   | otherwise      = do { env <- getGblEnv
849                         ; when warnIfDeprec $ warnIfDeprecated gre
850                         ; updMutVar (tcg_used_rdrnames env)
851                                     (\s -> Set.insert rdr s) }
852
853 addUsedRdrNames :: [RdrName] -> RnM ()
854 -- Record used sub-binders
855 -- We don't check for imported-ness here, because it's inconvenient
856 -- and not stritly necessary.
857 -- NB: no call to warnIfDeprecated; see Note [Handling of deprecations]
858 addUsedRdrNames rdrs
859   = do { env <- getGblEnv
860        ; updMutVar (tcg_used_rdrnames env)
861                    (\s -> foldr Set.insert s rdrs) }
862
863 warnIfDeprecated :: GlobalRdrElt -> RnM ()
864 warnIfDeprecated gre@(GRE { gre_name = name, gre_prov = Imported (imp_spec : _) })
865   = do { dflags <- getDynFlags
866        ; when (wopt Opt_WarnWarningsDeprecations dflags) $
867          do { iface <- loadInterfaceForName doc name
868             ; case lookupImpDeprec iface gre of
869                 Just txt -> addWarn (mk_msg txt)
870                 Nothing  -> return () } }
871   where
872     mk_msg txt = sep [ sep [ ptext (sLit "In the use of")
873                              <+> pprNonVarNameSpace (occNameSpace (nameOccName name))
874                              <+> quotes (ppr name)
875                            , parens imp_msg <> colon ]
876                      , ppr txt ]
877
878     name_mod = ASSERT2( isExternalName name, ppr name ) nameModule name
879     imp_mod  = importSpecModule imp_spec
880     imp_msg  = ptext (sLit "imported from") <+> ppr imp_mod <> extra
881     extra | imp_mod == moduleName name_mod = Outputable.empty
882           | otherwise = ptext (sLit ", but defined in") <+> ppr name_mod
883
884     doc = ptext (sLit "The name") <+> quotes (ppr name) <+> ptext (sLit "is mentioned explicitly")
885
886 warnIfDeprecated _ = return ()   -- No deprecations for things defined locally
887
888 lookupImpDeprec :: ModIface -> GlobalRdrElt -> Maybe WarningTxt
889 lookupImpDeprec iface gre
890   = mi_warn_fn iface (gre_name gre) `mplus`  -- Bleat if the thing,
891     case gre_par gre of                      -- or its parent, is warn'd
892        ParentIs p -> mi_warn_fn iface p
893        NoParent   -> Nothing
894 \end{code}
895
896 Note [Used names with interface not loaded]
897 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
898 It's (just) possible to find a used
899 Name whose interface hasn't been loaded:
900
901 a) It might be a WiredInName; in that case we may not load
902    its interface (although we could).
903
904 b) It might be GHC.Real.fromRational, or GHC.Num.fromInteger
905    These are seen as "used" by the renamer (if -XRebindableSyntax)
906    is on), but the typechecker may discard their uses
907    if in fact the in-scope fromRational is GHC.Read.fromRational,
908    (see tcPat.tcOverloadedLit), and the typechecker sees that the type
909    is fixed, say, to GHC.Base.Float (see Inst.lookupSimpleInst).
910    In that obscure case it won't force the interface in.
911
912 In both cases we simply don't permit deprecations;
913 this is, after all, wired-in stuff.
914
915
916 %*********************************************************
917 %*                                                      *
918                 GHCi support
919 %*                                                      *
920 %*********************************************************
921
922 A qualified name on the command line can refer to any module at
923 all: we try to load the interface if we don't already have it, just
924 as if there was an "import qualified M" declaration for every
925 module.
926
927 If we fail we just return Nothing, rather than bleating
928 about "attempting to use module ā€˜Dā€™ (./D.hs) which is not loaded"
929 which is what loadSrcInterface does.
930
931 Note [Safe Haskell and GHCi]
932 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
933 We DONT do this Safe Haskell as we need to check imports. We can
934 and should instead check the qualified import but at the moment
935 this requires some refactoring so leave as a TODO
936
937 \begin{code}
938 lookupQualifiedNameGHCi :: DynFlags -> Bool -> RdrName -> RnM (Maybe Name)
939 lookupQualifiedNameGHCi dflags is_ghci rdr_name
940   | Just (mod,occ) <- isQual_maybe rdr_name
941   , is_ghci
942   , gopt Opt_ImplicitImportQualified dflags   -- Enables this GHCi behaviour
943   , not (safeDirectImpsReq dflags)            -- See Note [Safe Haskell and GHCi]
944   = -- We want to behave as we would for a source file import here,
945     -- and respect hiddenness of modules/packages, hence loadSrcInterface.
946     do { res <- loadSrcInterface_maybe doc mod False Nothing
947        ; case res of
948            Succeeded iface
949              | (n:ns) <- [ name
950                          | avail <- mi_exports iface
951                          , name  <- availNames avail
952                          , nameOccName name == occ ]
953              -> ASSERT(null ns) return (Just n)
954
955            _ -> -- Either we couldn't load the interface, or
956                 -- we could but we didn't find the name in it
957                 do { traceRn (text "lookupQualifiedNameGHCi" <+> ppr rdr_name)
958                    ; return Nothing } }
959
960   | otherwise
961   = return Nothing
962   where
963     doc = ptext (sLit "Need to find") <+> ppr rdr_name
964 \end{code}
965
966 Note [Looking up signature names]
967 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
968 lookupSigOccRn is used for type signatures and pragmas
969 Is this valid?
970   module A
971         import M( f )
972         f :: Int -> Int
973         f x = x
974 It's clear that the 'f' in the signature must refer to A.f
975 The Haskell98 report does not stipulate this, but it will!
976 So we must treat the 'f' in the signature in the same way
977 as the binding occurrence of 'f', using lookupBndrRn
978
979 However, consider this case:
980         import M( f )
981         f :: Int -> Int
982         g x = x
983 We don't want to say 'f' is out of scope; instead, we want to
984 return the imported 'f', so that later on the reanamer will
985 correctly report "misplaced type sig".
986
987 Note [Signatures for top level things]
988 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
989 data HsSigCtxt = ... | TopSigCtxt NameSet Bool | ....
990
991 * The NameSet says what is bound in this group of bindings.
992   We can't use isLocalGRE from the GlobalRdrEnv, because of this:
993        f x = x
994        $( ...some TH splice... )
995        f :: Int -> Int
996   When we encounter the signature for 'f', the binding for 'f'
997   will be in the GlobalRdrEnv, and will be a LocalDef. Yet the
998   signature is mis-placed
999
1000 * The Bool says whether the signature is ok for a class method
1001   or record selector.  Consider
1002       infix 3 `f`          -- Yes, ok
1003       f :: C a => a -> a   -- No, not ok
1004       class C a where
1005         f :: a -> a
1006
1007 \begin{code}
1008 data HsSigCtxt
1009   = TopSigCtxt NameSet Bool  -- At top level, binding these names
1010                              -- See Note [Signatures for top level things]
1011                              -- Bool <=> ok to give sig for
1012                              --          class method or record selctor
1013   | LocalBindCtxt NameSet    -- In a local binding, binding these names
1014   | ClsDeclCtxt   Name       -- Class decl for this class
1015   | InstDeclCtxt  Name       -- Intsance decl for this class
1016   | HsBootCtxt               -- Top level of a hs-boot file
1017
1018 lookupSigOccRn :: HsSigCtxt
1019                -> Sig RdrName
1020                -> Located RdrName -> RnM (Located Name)
1021 lookupSigOccRn ctxt sig
1022   = wrapLocM $ \ rdr_name ->
1023     do { mb_name <- lookupBindGroupOcc ctxt (hsSigDoc sig) rdr_name
1024        ; case mb_name of
1025            Left err   -> do { addErr err; return (mkUnboundName rdr_name) }
1026            Right name -> return name }
1027
1028 lookupBindGroupOcc :: HsSigCtxt
1029                    -> SDoc
1030                    -> RdrName -> RnM (Either MsgDoc Name)
1031 -- Looks up the RdrName, expecting it to resolve to one of the
1032 -- bound names passed in.  If not, return an appropriate error message
1033 --
1034 -- See Note [Looking up signature names]
1035 lookupBindGroupOcc ctxt what rdr_name
1036   | Just n <- isExact_maybe rdr_name
1037   = do { n' <- lookupExactOcc n
1038        ; return (Right n') }  -- Maybe we should check the side conditions
1039                               -- but it's a pain, and Exact things only show
1040                               -- up when you know what you are doing
1041
1042   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
1043   = do { n' <- lookupOrig rdr_mod rdr_occ
1044        ; return (Right n') }
1045
1046   | otherwise
1047   = case ctxt of
1048       HsBootCtxt            -> lookup_top (const True)       True
1049       TopSigCtxt ns meth_ok -> lookup_top (`elemNameSet` ns) meth_ok
1050       LocalBindCtxt ns      -> lookup_group ns
1051       ClsDeclCtxt  cls      -> lookup_cls_op cls
1052       InstDeclCtxt cls      -> lookup_cls_op cls
1053   where
1054     lookup_cls_op cls
1055       = do { env <- getGlobalRdrEnv
1056            ; let gres = lookupSubBndrGREs env (ParentIs cls) rdr_name
1057            ; case gres of
1058                []      -> return (Left (unknownSubordinateErr doc rdr_name))
1059                (gre:_) -> return (Right (gre_name gre)) }
1060                         -- If there is more than one local GRE for the
1061                         -- same OccName 'f', that will be reported separately
1062                         -- as a duplicate top-level binding for 'f'
1063       where
1064         doc = ptext (sLit "method of class") <+> quotes (ppr cls)
1065
1066     lookup_top keep_me meth_ok
1067       = do { env <- getGlobalRdrEnv
1068            ; let all_gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)
1069            ; case filter (keep_me . gre_name) all_gres of
1070                [] | null all_gres -> bale_out_with Outputable.empty
1071                   | otherwise -> bale_out_with local_msg
1072                (gre:_)
1073                   | ParentIs {} <- gre_par gre
1074                   , not meth_ok
1075                   -> bale_out_with sub_msg
1076                   | otherwise
1077                   -> return (Right (gre_name gre)) }
1078
1079     lookup_group bound_names  -- Look in the local envt (not top level)
1080       = do { local_env <- getLocalRdrEnv
1081            ; case lookupLocalRdrEnv local_env rdr_name of
1082                Just n
1083                  | n `elemNameSet` bound_names -> return (Right n)
1084                  | otherwise                   -> bale_out_with local_msg
1085                Nothing                         -> bale_out_with Outputable.empty }
1086
1087     bale_out_with msg
1088         = return (Left (sep [ ptext (sLit "The") <+> what
1089                                 <+> ptext (sLit "for") <+> quotes (ppr rdr_name)
1090                            , nest 2 $ ptext (sLit "lacks an accompanying binding")]
1091                        $$ nest 2 msg))
1092
1093     local_msg = parens $ ptext (sLit "The")  <+> what <+> ptext (sLit "must be given where")
1094                            <+> quotes (ppr rdr_name) <+> ptext (sLit "is declared")
1095
1096     sub_msg = parens $ ptext (sLit "You cannot give a") <+> what
1097                        <+> ptext (sLit "for a record selector or class method")
1098
1099
1100 ---------------
1101 lookupLocalTcNames :: HsSigCtxt -> SDoc -> RdrName -> RnM [Name]
1102 -- GHC extension: look up both the tycon and data con or variable.
1103 -- Used for top-level fixity signatures and deprecations.
1104 -- Complain if neither is in scope.
1105 -- See Note [Fixity signature lookup]
1106 lookupLocalTcNames ctxt what rdr_name
1107   = do { mb_gres <- mapM lookup (dataTcOccs rdr_name)
1108        ; let (errs, names) = splitEithers mb_gres
1109        ; when (null names) $ addErr (head errs) -- Bleat about one only
1110        ; return names }
1111   where
1112     lookup = lookupBindGroupOcc ctxt what
1113
1114 dataTcOccs :: RdrName -> [RdrName]
1115 -- Return both the given name and the same name promoted to the TcClsName
1116 -- namespace.  This is useful when we aren't sure which we are looking at.
1117 dataTcOccs rdr_name
1118   | Just n <- isExact_maybe rdr_name
1119   , not (isBuiltInSyntax n)   -- See Note [dataTcOccs and Exact Names]
1120   = [rdr_name]
1121   | isDataOcc occ || isVarOcc occ
1122   = [rdr_name, rdr_name_tc]
1123   | otherwise
1124   = [rdr_name]
1125   where
1126     occ = rdrNameOcc rdr_name
1127     rdr_name_tc = setRdrNameSpace rdr_name tcName
1128 \end{code}
1129
1130 Note [dataTcOccs and Exact Names]
1131 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1132 Exact RdrNames can occur in code generated by Template Haskell, and generally
1133 those references are, well, exact, so it's wrong to return the TyClsName too.
1134 But there is an awkward exception for built-in syntax. Example in GHCi
1135    :info []
1136 This parses as the Exact RdrName for nilDataCon, but we also want
1137 the list type constructor.
1138
1139 Note that setRdrNameSpace on an Exact name requires the Name to be External,
1140 which it always is for built in syntax.
1141
1142 %*********************************************************
1143 %*                                                      *
1144                 Fixities
1145 %*                                                      *
1146 %*********************************************************
1147
1148 Note [Fixity signature lookup]
1149 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1150 A fixity declaration like
1151
1152     infixr 2 ?
1153
1154 can refer to a value-level operator, e.g.:
1155
1156     (?) :: String -> String -> String
1157
1158 or a type-level operator, like:
1159
1160     data (?) a b = A a | B b
1161
1162 so we extend the lookup of the reader name '?' to the TcClsName namespace, as
1163 well as the original namespace.
1164
1165 The extended lookup is also used in other places, like resolution of
1166 deprecation declarations, and lookup of names in GHCi.
1167
1168 \begin{code}
1169 --------------------------------
1170 type MiniFixityEnv = FastStringEnv (Located Fixity)
1171         -- Mini fixity env for the names we're about
1172         -- to bind, in a single binding group
1173         --
1174         -- It is keyed by the *FastString*, not the *OccName*, because
1175         -- the single fixity decl       infix 3 T
1176         -- affects both the data constructor T and the type constrctor T
1177         --
1178         -- We keep the location so that if we find
1179         -- a duplicate, we can report it sensibly
1180
1181 --------------------------------
1182 -- Used for nested fixity decls to bind names along with their fixities.
1183 -- the fixities are given as a UFM from an OccName's FastString to a fixity decl
1184
1185 addLocalFixities :: MiniFixityEnv -> [Name] -> RnM a -> RnM a
1186 addLocalFixities mini_fix_env names thing_inside
1187   = extendFixityEnv (mapMaybe find_fixity names) thing_inside
1188   where
1189     find_fixity name
1190       = case lookupFsEnv mini_fix_env (occNameFS occ) of
1191           Just (L _ fix) -> Just (name, FixItem occ fix)
1192           Nothing        -> Nothing
1193       where
1194         occ = nameOccName name
1195 \end{code}
1196
1197 --------------------------------
1198 lookupFixity is a bit strange.
1199
1200 * Nested local fixity decls are put in the local fixity env, which we
1201   find with getFixtyEnv
1202
1203 * Imported fixities are found in the HIT or PIT
1204
1205 * Top-level fixity decls in this module may be for Names that are
1206     either  Global         (constructors, class operations)
1207     or      Local/Exported (everything else)
1208   (See notes with RnNames.getLocalDeclBinders for why we have this split.)
1209   We put them all in the local fixity environment
1210
1211 \begin{code}
1212 lookupFixityRn :: Name -> RnM Fixity
1213 lookupFixityRn name
1214   | isUnboundName name
1215   = return (Fixity minPrecedence InfixL) 
1216     -- Minimise errors from ubound names; eg
1217     --    a>0 `foo` b>0
1218     -- where 'foo' is not in scope, should not give an error (Trac #7937)
1219
1220   | otherwise
1221   = do { local_fix_env <- getFixityEnv
1222        ; case lookupNameEnv local_fix_env name of {
1223            Just (FixItem _ fix) -> return fix ;
1224            Nothing ->
1225
1226     do { this_mod <- getModule
1227        ; if nameIsLocalOrFrom this_mod name || isInteractiveModule (nameModule name)
1228                -- Interactive modules are all in the fixity env,
1229                -- and don't have entries in the HPT
1230          then return defaultFixity
1231          else lookup_imported } } }
1232   where
1233     lookup_imported
1234       -- For imported names, we have to get their fixities by doing a
1235       -- loadInterfaceForName, and consulting the Ifaces that comes back
1236       -- from that, because the interface file for the Name might not
1237       -- have been loaded yet.  Why not?  Suppose you import module A,
1238       -- which exports a function 'f', thus;
1239       --        module CurrentModule where
1240       --          import A( f )
1241       --        module A( f ) where
1242       --          import B( f )
1243       -- Then B isn't loaded right away (after all, it's possible that
1244       -- nothing from B will be used).  When we come across a use of
1245       -- 'f', we need to know its fixity, and it's then, and only
1246       -- then, that we load B.hi.  That is what's happening here.
1247       --
1248       -- loadInterfaceForName will find B.hi even if B is a hidden module,
1249       -- and that's what we want.
1250       = do { iface <- loadInterfaceForName doc name
1251            ; traceRn (text "lookupFixityRn: looking up name in iface cache and found:" <+>
1252                       vcat [ppr name, ppr $ mi_fix_fn iface (nameOccName name)])
1253            ; return (mi_fix_fn iface (nameOccName name)) }
1254
1255     doc = ptext (sLit "Checking fixity for") <+> ppr name
1256
1257 ---------------
1258 lookupTyFixityRn :: Located Name -> RnM Fixity
1259 lookupTyFixityRn (L _ n) = lookupFixityRn n
1260
1261 \end{code}
1262
1263 %************************************************************************
1264 %*                                                                      *
1265                         Rebindable names
1266         Dealing with rebindable syntax is driven by the
1267         Opt_RebindableSyntax dynamic flag.
1268
1269         In "deriving" code we don't want to use rebindable syntax
1270         so we switch off the flag locally
1271
1272 %*                                                                      *
1273 %************************************************************************
1274
1275 Haskell 98 says that when you say "3" you get the "fromInteger" from the
1276 Standard Prelude, regardless of what is in scope.   However, to experiment
1277 with having a language that is less coupled to the standard prelude, we're
1278 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
1279 happens to be in scope.  Then you can
1280         import Prelude ()
1281         import MyPrelude as Prelude
1282 to get the desired effect.
1283
1284 At the moment this just happens for
1285   * fromInteger, fromRational on literals (in expressions and patterns)
1286   * negate (in expressions)
1287   * minus  (arising from n+k patterns)
1288   * "do" notation
1289
1290 We store the relevant Name in the HsSyn tree, in
1291   * HsIntegral/HsFractional/HsIsString
1292   * NegApp
1293   * NPlusKPat
1294   * HsDo
1295 respectively.  Initially, we just store the "standard" name (PrelNames.fromIntegralName,
1296 fromRationalName etc), but the renamer changes this to the appropriate user
1297 name if Opt_NoImplicitPrelude is on.  That is what lookupSyntaxName does.
1298
1299 We treat the orignal (standard) names as free-vars too, because the type checker
1300 checks the type of the user thing against the type of the standard thing.
1301
1302 \begin{code}
1303 lookupIfThenElse :: RnM (Maybe (SyntaxExpr Name), FreeVars)
1304 -- Different to lookupSyntaxName because in the non-rebindable
1305 -- case we desugar directly rather than calling an existing function
1306 -- Hence the (Maybe (SyntaxExpr Name)) return type
1307 lookupIfThenElse
1308   = do { rebind <- xoptM Opt_RebindableSyntax
1309        ; if not rebind
1310          then return (Nothing, emptyFVs)
1311          else do { ite <- lookupOccRn (mkVarUnqual (fsLit "ifThenElse"))
1312                  ; return (Just (HsVar ite), unitFV ite) } }
1313
1314 lookupSyntaxName :: Name                                -- The standard name
1315                  -> RnM (SyntaxExpr Name, FreeVars)     -- Possibly a non-standard name
1316 lookupSyntaxName std_name
1317   = do { rebindable_on <- xoptM Opt_RebindableSyntax
1318        ; if not rebindable_on then 
1319            return (HsVar std_name, emptyFVs)
1320          else
1321             -- Get the similarly named thing from the local environment
1322            do { usr_name <- lookupOccRn (mkRdrUnqual (nameOccName std_name))
1323               ; return (HsVar usr_name, unitFV usr_name) } }
1324
1325 lookupSyntaxNames :: [Name]                          -- Standard names
1326                   -> RnM ([HsExpr Name], FreeVars)   -- See comments with HsExpr.ReboundNames
1327 lookupSyntaxNames std_names
1328   = do { rebindable_on <- xoptM Opt_RebindableSyntax
1329        ; if not rebindable_on then 
1330              return (map HsVar std_names, emptyFVs)
1331         else
1332           do { usr_names <- mapM (lookupOccRn . mkRdrUnqual . nameOccName) std_names
1333              ; return (map HsVar usr_names, mkFVs usr_names) } }
1334 \end{code}
1335
1336
1337 %*********************************************************
1338 %*                                                      *
1339 \subsection{Binding}
1340 %*                                                      *
1341 %*********************************************************
1342
1343 \begin{code}
1344 newLocalBndrRn :: Located RdrName -> RnM Name
1345 -- Used for non-top-level binders.  These should
1346 -- never be qualified.
1347 newLocalBndrRn (L loc rdr_name)
1348   | Just name <- isExact_maybe rdr_name
1349   = return name -- This happens in code generated by Template Haskell
1350                 -- See Note [Binders in Template Haskell] in Convert.lhs
1351   | otherwise
1352   = do { unless (isUnqual rdr_name)
1353                 (addErrAt loc (badQualBndrErr rdr_name))
1354        ; uniq <- newUnique
1355        ; return (mkInternalName uniq (rdrNameOcc rdr_name) loc) }
1356
1357 newLocalBndrsRn :: [Located RdrName] -> RnM [Name]
1358 newLocalBndrsRn = mapM newLocalBndrRn
1359
1360 ---------------------
1361 bindLocatedLocalsRn :: [Located RdrName]
1362                     -> ([Name] -> RnM a)
1363                     -> RnM a
1364 bindLocatedLocalsRn rdr_names_w_loc enclosed_scope
1365   = do { checkDupRdrNames rdr_names_w_loc
1366        ; checkShadowedRdrNames rdr_names_w_loc
1367
1368         -- Make fresh Names and extend the environment
1369        ; names <- newLocalBndrsRn rdr_names_w_loc
1370        ; bindLocalNames names (enclosed_scope names) }
1371
1372 bindLocalNames :: [Name] -> RnM a -> RnM a
1373 bindLocalNames names enclosed_scope
1374   = do { lcl_env <- getLclEnv
1375        ; let th_level  = thLevel (tcl_th_ctxt lcl_env)
1376              th_bndrs' = extendNameEnvList (tcl_th_bndrs lcl_env)
1377                            [ (n, (NotTopLevel, th_level)) | n <- names ]
1378              rdr_env'  = extendLocalRdrEnvList (tcl_rdr lcl_env) names
1379        ; setLclEnv (lcl_env { tcl_th_bndrs = th_bndrs'
1380                             , tcl_rdr      = rdr_env' })
1381                     enclosed_scope }
1382
1383 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
1384 bindLocalNamesFV names enclosed_scope
1385   = do  { (result, fvs) <- bindLocalNames names enclosed_scope
1386         ; return (result, delFVs names fvs) }
1387
1388
1389 -------------------------------------
1390         -- binLocalsFVRn is the same as bindLocalsRn
1391         -- except that it deals with free vars
1392 bindLocatedLocalsFV :: [Located RdrName]
1393                     -> ([Name] -> RnM (a,FreeVars)) -> RnM (a, FreeVars)
1394 bindLocatedLocalsFV rdr_names enclosed_scope
1395   = bindLocatedLocalsRn rdr_names       $ \ names ->
1396     do (thing, fvs) <- enclosed_scope names
1397        return (thing, delFVs names fvs)
1398
1399 -------------------------------------
1400
1401 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
1402         -- This function is used only in rnSourceDecl on InstDecl
1403 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
1404
1405 -------------------------------------
1406 checkDupRdrNames :: [Located RdrName] -> RnM ()
1407 -- Check for duplicated names in a binding group
1408 checkDupRdrNames rdr_names_w_loc
1409   = mapM_ (dupNamesErr getLoc) dups
1410   where
1411     (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
1412
1413 checkDupNames :: [Name] -> RnM ()
1414 -- Check for duplicated names in a binding group
1415 checkDupNames names = check_dup_names (filterOut isSystemName names)
1416                 -- See Note [Binders in Template Haskell] in Convert
1417
1418 check_dup_names :: [Name] -> RnM ()
1419 check_dup_names names
1420   = mapM_ (dupNamesErr nameSrcSpan) dups
1421   where
1422     (_, dups) = removeDups (\n1 n2 -> nameOccName n1 `compare` nameOccName n2) names
1423
1424 ---------------------
1425 checkShadowedRdrNames :: [Located RdrName] -> RnM ()
1426 checkShadowedRdrNames loc_rdr_names
1427   = do { envs <- getRdrEnvs
1428        ; checkShadowedOccs envs get_loc_occ filtered_rdrs }
1429   where
1430     filtered_rdrs = filterOut (isExact . unLoc) loc_rdr_names
1431                 -- See Note [Binders in Template Haskell] in Convert
1432     get_loc_occ (L loc rdr) = (loc,rdrNameOcc rdr)
1433
1434 checkDupAndShadowedNames :: (GlobalRdrEnv, LocalRdrEnv) -> [Name] -> RnM ()
1435 checkDupAndShadowedNames envs names
1436   = do { check_dup_names filtered_names
1437        ; checkShadowedOccs envs get_loc_occ filtered_names }
1438   where
1439     filtered_names = filterOut isSystemName names
1440                 -- See Note [Binders in Template Haskell] in Convert
1441     get_loc_occ name = (nameSrcSpan name, nameOccName name)
1442
1443 -------------------------------------
1444 checkShadowedOccs :: (GlobalRdrEnv, LocalRdrEnv)
1445                   -> (a -> (SrcSpan, OccName))
1446                   -> [a] -> RnM ()
1447 checkShadowedOccs (global_env,local_env) get_loc_occ ns
1448   = whenWOptM Opt_WarnNameShadowing $
1449     do  { traceRn (text "shadow" <+> ppr (map get_loc_occ ns))
1450         ; mapM_ check_shadow ns }
1451   where
1452     check_shadow n
1453         | startsWithUnderscore occ = return ()  -- Do not report shadowing for "_x"
1454                                                 -- See Trac #3262
1455         | Just n <- mb_local = complain [ptext (sLit "bound at") <+> ppr (nameSrcLoc n)]
1456         | otherwise = do { gres' <- filterM is_shadowed_gre gres
1457                          ; complain (map pprNameProvenance gres') }
1458         where
1459           (loc,occ) = get_loc_occ n
1460           mb_local  = lookupLocalRdrOcc local_env occ
1461           gres      = lookupGRE_RdrName (mkRdrUnqual occ) global_env
1462                 -- Make an Unqualified RdrName and look that up, so that
1463                 -- we don't find any GREs that are in scope qualified-only
1464
1465           complain []      = return ()
1466           complain pp_locs = addWarnAt loc (shadowedNameWarn occ pp_locs)
1467
1468     is_shadowed_gre :: GlobalRdrElt -> RnM Bool
1469         -- Returns False for record selectors that are shadowed, when
1470         -- punning or wild-cards are on (cf Trac #2723)
1471     is_shadowed_gre gre@(GRE { gre_par = ParentIs _ })
1472         = do { dflags <- getDynFlags
1473              ; if (xopt Opt_RecordPuns dflags || xopt Opt_RecordWildCards dflags)
1474                then do { is_fld <- is_rec_fld gre; return (not is_fld) }
1475                else return True }
1476     is_shadowed_gre _other = return True
1477
1478     is_rec_fld gre      -- Return True for record selector ids
1479         | isLocalGRE gre = do { RecFields _ fld_set <- getRecFieldEnv
1480                               ; return (gre_name gre `elemNameSet` fld_set) }
1481         | otherwise      = do { sel_id <- tcLookupField (gre_name gre)
1482                               ; return (isRecordSelector sel_id) }
1483 \end{code}
1484
1485
1486 %************************************************************************
1487 %*                                                                      *
1488                What to do when a lookup fails
1489 %*                                                                      *
1490 %************************************************************************
1491
1492 \begin{code}
1493 data WhereLooking = WL_Any        -- Any binding
1494                   | WL_Global     -- Any top-level binding (local or imported)
1495                   | WL_LocalTop   -- Any top-level binding in this module
1496
1497 reportUnboundName :: RdrName -> RnM Name
1498 reportUnboundName rdr = unboundName WL_Any rdr
1499
1500 unboundName :: WhereLooking -> RdrName -> RnM Name
1501 unboundName wl rdr = unboundNameX wl rdr Outputable.empty
1502
1503 unboundNameX :: WhereLooking -> RdrName -> SDoc -> RnM Name
1504 unboundNameX where_look rdr_name extra
1505   = do  { show_helpful_errors <- goptM Opt_HelpfulErrors
1506         ; let what = pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))
1507               err = unknownNameErr what rdr_name $$ extra
1508         ; if not show_helpful_errors
1509           then addErr err
1510           else do { suggestions <- unknownNameSuggestErr where_look rdr_name
1511                   ; addErr (err $$ suggestions) }
1512         ; return (mkUnboundName rdr_name) }
1513
1514 unknownNameErr :: SDoc -> RdrName -> SDoc
1515 unknownNameErr what rdr_name
1516   = vcat [ hang (ptext (sLit "Not in scope:"))
1517               2 (what <+> quotes (ppr rdr_name))
1518          , extra ]
1519   where
1520     extra | rdr_name == forall_tv_RDR = perhapsForallMsg
1521           | otherwise                 = Outputable.empty
1522
1523 type HowInScope = Either SrcSpan ImpDeclSpec
1524      -- Left loc    =>  locally bound at loc
1525      -- Right ispec =>  imported as specified by ispec
1526
1527 unknownNameSuggestErr :: WhereLooking -> RdrName -> RnM SDoc
1528 unknownNameSuggestErr where_look tried_rdr_name
1529   = do { local_env <- getLocalRdrEnv
1530        ; global_env <- getGlobalRdrEnv
1531        ; dflags <- getDynFlags
1532
1533        ; let all_possibilities :: [(String, (RdrName, HowInScope))]
1534              all_possibilities
1535                 =  [ (showPpr dflags r, (r, Left loc))
1536                    | (r,loc) <- local_possibilities local_env ]
1537                 ++ [ (showPpr dflags r, rp) | (r, rp) <- global_possibilities global_env ]
1538
1539              suggest = fuzzyLookup (showPpr dflags tried_rdr_name) all_possibilities
1540              perhaps = ptext (sLit "Perhaps you meant")
1541              extra_err = case suggest of
1542                            []  -> Outputable.empty
1543                            [p] -> perhaps <+> pp_item p
1544                            ps  -> sep [ perhaps <+> ptext (sLit "one of these:")
1545                                       , nest 2 (pprWithCommas pp_item ps) ]
1546        ; return extra_err }
1547   where
1548     pp_item :: (RdrName, HowInScope) -> SDoc
1549     pp_item (rdr, Left loc) = pp_ns rdr <+> quotes (ppr rdr) <+> loc' -- Locally defined
1550         where loc' = case loc of
1551                      UnhelpfulSpan l -> parens (ppr l)
1552                      RealSrcSpan l -> parens (ptext (sLit "line") <+> int (srcSpanStartLine l))
1553     pp_item (rdr, Right is) = pp_ns rdr <+> quotes (ppr rdr) <+>   -- Imported
1554                               parens (ptext (sLit "imported from") <+> ppr (is_mod is))
1555
1556     pp_ns :: RdrName -> SDoc
1557     pp_ns rdr | ns /= tried_ns = pprNameSpace ns
1558               | otherwise      = Outputable.empty
1559       where ns = rdrNameSpace rdr
1560
1561     tried_occ     = rdrNameOcc tried_rdr_name
1562     tried_is_sym  = isSymOcc tried_occ
1563     tried_ns      = occNameSpace tried_occ
1564     tried_is_qual = isQual tried_rdr_name
1565
1566     correct_name_space occ =  nameSpacesRelated (occNameSpace occ) tried_ns
1567                            && isSymOcc occ == tried_is_sym
1568         -- Treat operator and non-operators as non-matching
1569         -- This heuristic avoids things like
1570         --      Not in scope 'f'; perhaps you meant '+' (from Prelude)
1571
1572     local_ok = case where_look of { WL_Any -> True; _ -> False }
1573     local_possibilities :: LocalRdrEnv -> [(RdrName, SrcSpan)]
1574     local_possibilities env
1575       | tried_is_qual = []
1576       | not local_ok  = []
1577       | otherwise     = [ (mkRdrUnqual occ, nameSrcSpan name)
1578                         | name <- localRdrEnvElts env
1579                         , let occ = nameOccName name
1580                         , correct_name_space occ]
1581
1582     gre_ok :: GlobalRdrElt -> Bool
1583     gre_ok = case where_look of
1584                    WL_LocalTop -> isLocalGRE
1585                    _           -> \_ -> True
1586
1587     global_possibilities :: GlobalRdrEnv -> [(RdrName, (RdrName, HowInScope))]
1588     global_possibilities global_env
1589       | tried_is_qual = [ (rdr_qual, (rdr_qual, how))
1590                         | gre <- globalRdrEnvElts global_env
1591                         , gre_ok gre
1592                         , let name = gre_name gre
1593                               occ  = nameOccName name
1594                         , correct_name_space occ
1595                         , (mod, how) <- quals_in_scope name (gre_prov gre)
1596                         , let rdr_qual = mkRdrQual mod occ ]
1597
1598       | otherwise = [ (rdr_unqual, pair)
1599                     | gre <- globalRdrEnvElts global_env
1600                     , gre_ok gre
1601                     , let name = gre_name gre
1602                           prov = gre_prov gre
1603                           occ  = nameOccName name
1604                           rdr_unqual = mkRdrUnqual occ
1605                     , correct_name_space occ
1606                     , pair <- case (unquals_in_scope name prov, quals_only occ prov) of
1607                                 (how:_, _)    -> [ (rdr_unqual, how) ]
1608                                 ([],    pr:_) -> [ pr ]  -- See Note [Only-quals]
1609                                 ([],    [])   -> [] ]
1610
1611               -- Note [Only-quals]
1612               -- The second alternative returns those names with the same
1613               -- OccName as the one we tried, but live in *qualified* imports
1614               -- e.g. if you have:
1615               --
1616               -- > import qualified Data.Map as Map
1617               -- > foo :: Map
1618               --
1619               -- then we suggest @Map.Map@.
1620
1621     --------------------
1622     unquals_in_scope :: Name -> Provenance -> [HowInScope]
1623     unquals_in_scope n LocalDef      = [ Left (nameSrcSpan n) ]
1624     unquals_in_scope _ (Imported is) = [ Right ispec
1625                                        | i <- is, let ispec = is_decl i
1626                                        , not (is_qual ispec) ]
1627
1628     --------------------
1629     quals_in_scope :: Name -> Provenance -> [(ModuleName, HowInScope)]
1630     -- Ones for which the qualified version is in scope
1631     quals_in_scope n LocalDef      = case nameModule_maybe n of
1632                                        Nothing -> []
1633                                        Just m  -> [(moduleName m, Left (nameSrcSpan n))]
1634     quals_in_scope _ (Imported is) = [ (is_as ispec, Right ispec)
1635                                      | i <- is, let ispec = is_decl i ]
1636
1637     --------------------
1638     quals_only :: OccName -> Provenance -> [(RdrName, HowInScope)]
1639     -- Ones for which *only* the qualified version is in scope
1640     quals_only _   LocalDef      = []
1641     quals_only occ (Imported is) = [ (mkRdrQual (is_as ispec) occ, Right ispec)
1642                                    | i <- is, let ispec = is_decl i, is_qual ispec ]
1643 \end{code}
1644
1645 %************************************************************************
1646 %*                                                                      *
1647 \subsection{Free variable manipulation}
1648 %*                                                                      *
1649 %************************************************************************
1650
1651 \begin{code}
1652 -- A useful utility
1653 addFvRn :: FreeVars -> RnM (thing, FreeVars) -> RnM (thing, FreeVars)
1654 addFvRn fvs1 thing_inside = do { (res, fvs2) <- thing_inside
1655                                ; return (res, fvs1 `plusFV` fvs2) }
1656
1657 mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
1658 mapFvRn f xs = do stuff <- mapM f xs
1659                   case unzip stuff of
1660                       (ys, fvs_s) -> return (ys, plusFVs fvs_s)
1661
1662 mapMaybeFvRn :: (a -> RnM (b, FreeVars)) -> Maybe a -> RnM (Maybe b, FreeVars)
1663 mapMaybeFvRn _ Nothing = return (Nothing, emptyFVs)
1664 mapMaybeFvRn f (Just x) = do { (y, fvs) <- f x; return (Just y, fvs) }
1665
1666 -- because some of the rename functions are CPSed:
1667 -- maps the function across the list from left to right;
1668 -- collects all the free vars into one set
1669 mapFvRnCPS :: (a  -> (b   -> RnM c) -> RnM c)
1670            -> [a] -> ([b] -> RnM c) -> RnM c
1671
1672 mapFvRnCPS _ []     cont = cont []
1673 mapFvRnCPS f (x:xs) cont = f x             $ \ x' ->
1674                            mapFvRnCPS f xs $ \ xs' ->
1675                            cont (x':xs')
1676 \end{code}
1677
1678
1679 %************************************************************************
1680 %*                                                                      *
1681 \subsection{Envt utility functions}
1682 %*                                                                      *
1683 %************************************************************************
1684
1685 \begin{code}
1686 warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
1687 warnUnusedTopBinds gres
1688     = whenWOptM Opt_WarnUnusedBinds
1689     $ do env <- getGblEnv
1690          let isBoot = tcg_src env == HsBootFile
1691          let noParent gre = case gre_par gre of
1692                             NoParent -> True
1693                             ParentIs _ -> False
1694              -- Don't warn about unused bindings with parents in
1695              -- .hs-boot files, as you are sometimes required to give
1696              -- unused bindings (trac #3449).
1697              -- HOWEVER, in a signature file, you are never obligated to put a
1698              -- definition in the main text.  Thus, if you define something
1699              -- and forget to export it, we really DO want to warn.
1700              gres' = if isBoot then filter noParent gres
1701                                else                 gres
1702          warnUnusedGREs gres'
1703
1704 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> FreeVars -> RnM ()
1705 warnUnusedLocalBinds = check_unused Opt_WarnUnusedBinds
1706 warnUnusedMatches    = check_unused Opt_WarnUnusedMatches
1707
1708 check_unused :: WarningFlag -> [Name] -> FreeVars -> RnM ()
1709 check_unused flag bound_names used_names
1710  = whenWOptM flag (warnUnusedLocals (filterOut (`elemNameSet` used_names) bound_names))
1711
1712 -------------------------
1713 --      Helpers
1714 warnUnusedGREs :: [GlobalRdrElt] -> RnM ()
1715 warnUnusedGREs gres
1716  = warnUnusedBinds [(n,p) | GRE {gre_name = n, gre_prov = p} <- gres]
1717
1718 warnUnusedLocals :: [Name] -> RnM ()
1719 warnUnusedLocals names
1720  = warnUnusedBinds [(n,LocalDef) | n<-names]
1721
1722 warnUnusedBinds :: [(Name,Provenance)] -> RnM ()
1723 warnUnusedBinds names  = mapM_ warnUnusedName (filter reportable names)
1724  where reportable (name,_)
1725         | isWiredInName name = False    -- Don't report unused wired-in names
1726                                         -- Otherwise we get a zillion warnings
1727                                         -- from Data.Tuple
1728         | otherwise = not (startsWithUnderscore (nameOccName name))
1729
1730 -------------------------
1731
1732 warnUnusedName :: (Name, Provenance) -> RnM ()
1733 warnUnusedName (name, LocalDef)
1734   = addUnusedWarning name (nameSrcSpan name)
1735                      (ptext (sLit "Defined but not used"))
1736
1737 warnUnusedName (name, Imported is)
1738   = mapM_ warn is
1739   where
1740     warn spec = addUnusedWarning name span msg
1741         where
1742            span = importSpecLoc spec
1743            pp_mod = quotes (ppr (importSpecModule spec))
1744            msg = ptext (sLit "Imported from") <+> pp_mod <+> ptext (sLit "but not used")
1745
1746 addUnusedWarning :: Name -> SrcSpan -> SDoc -> RnM ()
1747 addUnusedWarning name span msg
1748   = addWarnAt span $
1749     sep [msg <> colon,
1750          nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
1751                         <+> quotes (ppr name)]
1752 \end{code}
1753
1754 \begin{code}
1755 addNameClashErrRn :: RdrName -> [GlobalRdrElt] -> RnM ()
1756 addNameClashErrRn rdr_name gres
1757   | all isLocalGRE gres  -- If there are two or more *local* defns, we'll have reported
1758   = return ()            -- that already, and we don't want an error cascade
1759   | otherwise
1760   = addErr (vcat [ptext (sLit "Ambiguous occurrence") <+> quotes (ppr rdr_name),
1761                   ptext (sLit "It could refer to") <+> vcat (msg1 : msgs)])
1762   where
1763     (np1:nps) = gres
1764     msg1 = ptext  (sLit "either") <+> mk_ref np1
1765     msgs = [ptext (sLit "    or") <+> mk_ref np | np <- nps]
1766     mk_ref gre = sep [quotes (ppr (gre_name gre)) <> comma, pprNameProvenance gre]
1767
1768 shadowedNameWarn :: OccName -> [SDoc] -> SDoc
1769 shadowedNameWarn occ shadowed_locs
1770   = sep [ptext (sLit "This binding for") <+> quotes (ppr occ)
1771             <+> ptext (sLit "shadows the existing binding") <> plural shadowed_locs,
1772          nest 2 (vcat shadowed_locs)]
1773
1774 perhapsForallMsg :: SDoc
1775 perhapsForallMsg
1776   = vcat [ ptext (sLit "Perhaps you intended to use ExplicitForAll or similar flag")
1777          , ptext (sLit "to enable explicit-forall syntax: forall <tvs>. <type>")]
1778
1779 unknownSubordinateErr :: SDoc -> RdrName -> SDoc
1780 unknownSubordinateErr doc op    -- Doc is "method of class" or
1781                                 -- "field of constructor"
1782   = quotes (ppr op) <+> ptext (sLit "is not a (visible)") <+> doc
1783
1784 badOrigBinding :: RdrName -> SDoc
1785 badOrigBinding name
1786   = ptext (sLit "Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
1787         -- The rdrNameOcc is because we don't want to print Prelude.(,)
1788
1789 dupNamesErr :: Outputable n => (n -> SrcSpan) -> [n] -> RnM ()
1790 dupNamesErr get_loc names
1791   = addErrAt big_loc $
1792     vcat [ptext (sLit "Conflicting definitions for") <+> quotes (ppr (head names)),
1793           locations]
1794   where
1795     locs      = map get_loc names
1796     big_loc   = foldr1 combineSrcSpans locs
1797     locations = ptext (sLit "Bound at:") <+> vcat (map ppr (sort locs))
1798
1799 kindSigErr :: Outputable a => a -> SDoc
1800 kindSigErr thing
1801   = hang (ptext (sLit "Illegal kind signature for") <+> quotes (ppr thing))
1802        2 (ptext (sLit "Perhaps you intended to use KindSignatures"))
1803
1804 badQualBndrErr :: RdrName -> SDoc
1805 badQualBndrErr rdr_name
1806   = ptext (sLit "Qualified name in binding position:") <+> ppr rdr_name
1807
1808 opDeclErr :: RdrName -> SDoc
1809 opDeclErr n
1810   = hang (ptext (sLit "Illegal declaration of a type or class operator") <+> quotes (ppr n))
1811        2 (ptext (sLit "Use TypeOperators to declare operators in type and declarations"))
1812
1813 checkTupSize :: Int -> RnM ()
1814 checkTupSize tup_size
1815   | tup_size <= mAX_TUPLE_SIZE
1816   = return ()
1817   | otherwise
1818   = addErr (sep [ptext (sLit "A") <+> int tup_size <> ptext (sLit "-tuple is too large for GHC"),
1819                  nest 2 (parens (ptext (sLit "max size is") <+> int mAX_TUPLE_SIZE)),
1820                  nest 2 (ptext (sLit "Workaround: use nested tuples or define a data type"))])
1821 \end{code}
1822
1823
1824 %************************************************************************
1825 %*                                                                      *
1826 \subsection{Contexts for renaming errors}
1827 %*                                                                      *
1828 %************************************************************************
1829
1830 \begin{code}
1831
1832 data HsDocContext
1833   = TypeSigCtx SDoc
1834   | PatCtx
1835   | SpecInstSigCtx
1836   | DefaultDeclCtx
1837   | ForeignDeclCtx (Located RdrName)
1838   | DerivDeclCtx
1839   | RuleCtx FastString
1840   | TyDataCtx (Located RdrName)
1841   | TySynCtx (Located RdrName)
1842   | TyFamilyCtx (Located RdrName)
1843   | ConDeclCtx (Located RdrName)
1844   | ClassDeclCtx (Located RdrName)
1845   | ExprWithTySigCtx
1846   | TypBrCtx
1847   | HsTypeCtx
1848   | GHCiCtx
1849   | SpliceTypeCtx (LHsType RdrName)
1850   | ClassInstanceCtx
1851   | VectDeclCtx (Located RdrName)
1852   | GenericCtx SDoc   -- Maybe we want to use this more!
1853
1854 docOfHsDocContext :: HsDocContext -> SDoc
1855 docOfHsDocContext (GenericCtx doc) = doc
1856 docOfHsDocContext (TypeSigCtx doc) = text "In the type signature for" <+> doc
1857 docOfHsDocContext PatCtx = text "In a pattern type-signature"
1858 docOfHsDocContext SpecInstSigCtx = text "In a SPECIALISE instance pragma"
1859 docOfHsDocContext DefaultDeclCtx = text "In a `default' declaration"
1860 docOfHsDocContext (ForeignDeclCtx name) = ptext (sLit "In the foreign declaration for") <+> ppr name
1861 docOfHsDocContext DerivDeclCtx = text "In a deriving declaration"
1862 docOfHsDocContext (RuleCtx name) = text "In the transformation rule" <+> ftext name
1863 docOfHsDocContext (TyDataCtx tycon) = text "In the data type declaration for" <+> quotes (ppr tycon)
1864 docOfHsDocContext (TySynCtx name) = text "In the declaration for type synonym" <+> quotes (ppr name)
1865 docOfHsDocContext (TyFamilyCtx name) = text "In the declaration for type family" <+> quotes (ppr name)
1866 docOfHsDocContext (ConDeclCtx name) = text "In the definition of data constructor" <+> quotes (ppr name)
1867 docOfHsDocContext (ClassDeclCtx name) = text "In the declaration for class"     <+> ppr name
1868 docOfHsDocContext ExprWithTySigCtx = text "In an expression type signature"
1869 docOfHsDocContext TypBrCtx = ptext (sLit "In a Template-Haskell quoted type")
1870 docOfHsDocContext HsTypeCtx = text "In a type argument"
1871 docOfHsDocContext GHCiCtx = ptext (sLit "In GHCi input")
1872 docOfHsDocContext (SpliceTypeCtx hs_ty) = ptext (sLit "In the spliced type") <+> ppr hs_ty
1873 docOfHsDocContext ClassInstanceCtx = ptext (sLit "TcSplice.reifyInstances")
1874 docOfHsDocContext (VectDeclCtx tycon) = ptext (sLit "In the VECTORISE pragma for type constructor") <+> quotes (ppr tycon)
1875 \end{code}