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