Make Applicative a superclass of Monad
[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 \begin{code}
88 newTopSrcBinder :: Located RdrName -> RnM Name
89 newTopSrcBinder (L loc rdr_name)
90   | Just name <- isExact_maybe rdr_name
91   =     -- This is here to catch
92         --   (a) Exact-name binders created by Template Haskell
93         --   (b) The PrelBase defn of (say) [] and similar, for which
94         --       the parser reads the special syntax and returns an Exact RdrName
95         -- We are at a binding site for the name, so check first that it
96         -- the current module is the correct one; otherwise GHC can get
97         -- very confused indeed. This test rejects code like
98         --      data T = (,) Int Int
99         -- unless we are in GHC.Tup
100     if isExternalName name then
101       do { this_mod <- getModule
102          ; unless (this_mod == nameModule name)
103                   (addErrAt loc (badOrigBinding rdr_name))
104          ; return name }
105     else   -- See Note [Binders in Template Haskell] in Convert.hs
106       do { let occ = nameOccName name
107          ; occ `seq` return ()  -- c.f. seq in newGlobalBinder
108          ; this_mod <- getModule
109          ; updNameCache $ \ ns ->
110            let name' = mkExternalName (nameUnique name) this_mod occ loc
111                ns'   = ns { nsNames = extendNameCache (nsNames ns) this_mod occ name' }
112            in (ns', name') }
113
114   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
115   = do  { this_mod <- getModule
116         ; unless (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
117                  (addErrAt loc (badOrigBinding rdr_name))
118         -- When reading External Core we get Orig names as binders,
119         -- but they should agree with the module gotten from the monad
120         --
121         -- We can get built-in syntax showing up here too, sadly.  If you type
122         --      data T = (,,,)
123         -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon
124         -- uses setRdrNameSpace to make it into a data constructors.  At that point
125         -- the nice Exact name for the TyCon gets swizzled to an Orig name.
126         -- Hence the badOrigBinding error message.
127         --
128         -- Except for the ":Main.main = ..." definition inserted into
129         -- the Main module; ugh!
130
131         -- Because of this latter case, we call newGlobalBinder with a module from
132         -- the RdrName, not from the environment.  In principle, it'd be fine to
133         -- have an arbitrary mixture of external core definitions in a single module,
134         -- (apart from module-initialisation issues, perhaps).
135         ; newGlobalBinder rdr_mod rdr_occ loc }
136
137   | otherwise
138   = do  { unless (not (isQual rdr_name))
139                  (addErrAt loc (badQualBndrErr rdr_name))
140                 -- Binders should not be qualified; if they are, and with a different
141                 -- module name, we we get a confusing "M.T is not in scope" error later
142
143         ; stage <- getStage
144         ; if isBrackStage stage then
145                 -- We are inside a TH bracket, so make an *Internal* name
146                 -- See Note [Top-level Names in Template Haskell decl quotes] in RnNames
147              do { uniq <- newUnique
148                 ; return (mkInternalName uniq (rdrNameOcc rdr_name) loc) }
149           else
150                 -- Normal case
151              do { this_mod <- getModule
152                 ; newGlobalBinder this_mod (rdrNameOcc rdr_name) loc } }
153 \end{code}
154
155 %*********************************************************
156 %*                                                      *
157         Source code occurrences
158 %*                                                      *
159 %*********************************************************
160
161 Looking up a name in the RnEnv.
162
163 Note [Type and class operator definitions]
164 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
165 We want to reject all of these unless we have -XTypeOperators (Trac #3265)
166    data a :*: b  = ...
167    class a :*: b where ...
168    data (:*:) a b  = ....
169    class (:*:) a b where ...
170 The latter two mean that we are not just looking for a
171 *syntactically-infix* declaration, but one that uses an operator
172 OccName.  We use OccName.isSymOcc to detect that case, which isn't
173 terribly efficient, but there seems to be no better way.
174
175 \begin{code}
176 lookupTopBndrRn :: RdrName -> RnM Name
177 lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n
178                        case nopt of
179                          Just n' -> return n'
180                          Nothing -> do traceRn $ text "lookupTopBndrRn"
181                                        unboundName WL_LocalTop n
182
183 lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
184 lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn
185
186 lookupTopBndrRn_maybe :: RdrName -> RnM (Maybe Name)
187 -- Look up a top-level source-code binder.   We may be looking up an unqualified 'f',
188 -- and there may be several imported 'f's too, which must not confuse us.
189 -- For example, this is OK:
190 --      import Foo( f )
191 --      infix 9 f       -- The 'f' here does not need to be qualified
192 --      f x = x         -- Nor here, of course
193 -- So we have to filter out the non-local ones.
194 --
195 -- A separate function (importsFromLocalDecls) reports duplicate top level
196 -- decls, so here it's safe just to choose an arbitrary one.
197 --
198 -- There should never be a qualified name in a binding position in Haskell,
199 -- but there can be if we have read in an external-Core file.
200 -- The Haskell parser checks for the illegal qualified name in Haskell
201 -- source files, so we don't need to do so here.
202
203 lookupTopBndrRn_maybe rdr_name
204   | Just name <- isExact_maybe rdr_name
205   = do { name' <- lookupExactOcc name; return (Just name') }
206
207   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
208         -- This deals with the case of derived bindings, where
209         -- we don't bother to call newTopSrcBinder first
210         -- We assume there is no "parent" name
211   = do  { loc <- getSrcSpanM
212         ; n <- newGlobalBinder rdr_mod rdr_occ loc
213         ; return (Just n)}
214
215   | otherwise
216   = do  {  -- Check for operators in type or class declarations
217            -- See Note [Type and class operator definitions]
218           let occ = rdrNameOcc rdr_name
219         ; when (isTcOcc occ && isSymOcc occ)
220                (do { op_ok <- xoptM Opt_TypeOperators
221                    ; unless op_ok (addErr (opDeclErr rdr_name)) })
222
223         ; mb_gre <- lookupGreLocalRn_maybe rdr_name
224         ; case mb_gre of
225                 Nothing  -> return Nothing
226                 Just gre -> return (Just $ gre_name gre) }
227
228
229 -----------------------------------------------
230 lookupExactOcc :: Name -> RnM Name
231 -- See Note [Looking up Exact RdrNames]
232 lookupExactOcc name
233   | Just thing <- wiredInNameTyThing_maybe name
234   , Just tycon <- case thing of
235                     ATyCon tc                 -> Just tc
236                     AConLike (RealDataCon dc) -> Just (dataConTyCon dc)
237                     _                         -> Nothing
238   , isTupleTyCon tycon
239   = do { checkTupSize (tyConArity tycon)
240        ; return name }
241
242   | isExternalName name
243   = return name
244
245   | otherwise
246   = do { env <- getGlobalRdrEnv
247        ; let -- See Note [Splicing Exact names]
248              main_occ =  nameOccName name
249              demoted_occs = case demoteOccName main_occ of
250                               Just occ -> [occ]
251                               Nothing  -> []
252              gres = [ gre | occ <- main_occ : demoted_occs
253                           , gre <- lookupGlobalRdrEnv env occ
254                           , gre_name gre == name ]
255        ; case gres of
256            []    -> -- See Note [Splicing Exact names]
257                     do { lcl_env <- getLocalRdrEnv
258                        ; unless (name `inLocalRdrEnvScope` lcl_env) $
259 #ifdef GHCI
260                          do { th_topnames_var <- fmap tcg_th_topnames getGblEnv
261                             ; th_topnames <- readTcRef th_topnames_var
262                             ; unless (name `elemNameSet` th_topnames)
263                                      (addErr exact_nm_err)
264                             }
265 #else /* !GHCI */
266                          addErr exact_nm_err
267 #endif /* !GHCI */
268                        ; return name
269                        }
270
271            [gre]   -> return (gre_name gre)
272            (gre:_) -> do {addErr dup_nm_err
273                          ; return (gre_name gre)
274                          }
275            -- We can get more than one GRE here, if there are multiple 
276            -- bindings for the same name. Sometimes they are caught later
277            -- by findLocalDupsRdrEnv, like in this example (Trac #8932):
278            --    $( [d| foo :: a->a; foo x = x |])
279            --    foo = True
280            -- But when the names are totally identical, we panic (Trac #7241):
281            --    $(newName "Foo" >>= \o -> return [DataD [] o [] [RecC o []] [''Show]])
282            -- So, let's emit an error here, even if it will lead to duplication in some cases.
283        }
284
285   where
286     exact_nm_err = hang (ptext (sLit "The exact Name") <+> quotes (ppr name) <+> ptext (sLit "is not in scope"))
287                       2 (vcat [ ptext (sLit "Probable cause: you used a unique Template Haskell name (NameU), ")
288                               , ptext (sLit "perhaps via newName, but did not bind it")
289                               , ptext (sLit "If that's it, then -ddump-splices might be useful") ])
290     dup_nm_err   = hang (ptext (sLit "Duplicate exact Name") <+> quotes (ppr $ nameOccName name))
291                       2 (vcat [ ptext (sLit "Probable cause: you used a unique Template Haskell name (NameU), ")
292                               , ptext (sLit "perhaps via newName, but bound it multiple times")
293                               , ptext (sLit "If that's it, then -ddump-splices might be useful") ])
294
295 -----------------------------------------------
296 lookupInstDeclBndr :: Name -> SDoc -> RdrName -> RnM Name
297 -- This is called on the method name on the left-hand side of an
298 -- instance declaration binding. eg.  instance Functor T where
299 --                                       fmap = ...
300 --                                       ^^^^ called on this
301 -- Regardless of how many unqualified fmaps are in scope, we want
302 -- the one that comes from the Functor class.
303 --
304 -- Furthermore, note that we take no account of whether the
305 -- name is only in scope qualified.  I.e. even if method op is
306 -- in scope as M.op, we still allow plain 'op' on the LHS of
307 -- an instance decl
308 --
309 -- The "what" parameter says "method" or "associated type",
310 -- depending on what we are looking up
311 lookupInstDeclBndr cls what rdr
312   = do { when (isQual rdr)
313               (addErr (badQualBndrErr rdr))
314                 -- In an instance decl you aren't allowed
315                 -- to use a qualified name for the method
316                 -- (Although it'd make perfect sense.)
317        ; lookupSubBndrOcc False -- False => we don't give deprecated
318                                 -- warnings when a deprecated class
319                                 -- method is defined. We only warn
320                                 -- when it's used
321                           (ParentIs cls) doc rdr }
322   where
323     doc = what <+> ptext (sLit "of class") <+> quotes (ppr cls)
324
325
326 -----------------------------------------------
327 lookupFamInstName :: Maybe Name -> Located RdrName -> RnM (Located Name)
328 -- Used for TyData and TySynonym family instances only,
329 -- See Note [Family instance binders]
330 lookupFamInstName (Just cls) tc_rdr  -- Associated type; c.f RnBinds.rnMethodBind
331   = wrapLocM (lookupInstDeclBndr cls (ptext (sLit "associated type"))) tc_rdr
332 lookupFamInstName Nothing tc_rdr     -- Family instance; tc_rdr is an *occurrence*
333   = lookupLocatedOccRn tc_rdr
334
335 -----------------------------------------------
336 lookupConstructorFields :: Name -> RnM [Name]
337 -- Look up the fields of a given constructor
338 --   *  For constructors from this module, use the record field env,
339 --      which is itself gathered from the (as yet un-typechecked)
340 --      data type decls
341 --
342 --    * For constructors from imported modules, use the *type* environment
343 --      since imported modles are already compiled, the info is conveniently
344 --      right there
345
346 lookupConstructorFields con_name
347   = do  { this_mod <- getModule
348         ; if nameIsLocalOrFrom this_mod con_name then
349           do { RecFields field_env _ <- getRecFieldEnv
350              ; return (lookupNameEnv field_env con_name `orElse` []) }
351           else
352           do { con <- tcLookupDataCon con_name
353              ; return (dataConFieldLabels con) } }
354
355 -----------------------------------------------
356 -- Used for record construction and pattern matching
357 -- When the -XDisambiguateRecordFields flag is on, take account of the
358 -- constructor name to disambiguate which field to use; it's just the
359 -- same as for instance decls
360 --
361 -- NB: Consider this:
362 --      module Foo where { data R = R { fld :: Int } }
363 --      module Odd where { import Foo; fld x = x { fld = 3 } }
364 -- Arguably this should work, because the reference to 'fld' is
365 -- unambiguous because there is only one field id 'fld' in scope.
366 -- But currently it's rejected.
367
368 lookupSubBndrOcc :: Bool
369                  -> Parent  -- NoParent   => just look it up as usual
370                             -- ParentIs p => use p to disambiguate
371                  -> SDoc -> RdrName
372                  -> RnM Name
373 lookupSubBndrOcc warnIfDeprec parent doc rdr_name
374   | Just n <- isExact_maybe rdr_name   -- This happens in derived code
375   = lookupExactOcc n
376
377   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
378   = lookupOrig rdr_mod rdr_occ
379
380   | otherwise   -- Find all the things the rdr-name maps to
381   = do  {       -- and pick the one with the right parent namep
382           env <- getGlobalRdrEnv
383         ; case lookupSubBndrGREs env parent rdr_name of
384                 -- NB: lookupGlobalRdrEnv, not lookupGRE_RdrName!
385                 --     The latter does pickGREs, but we want to allow 'x'
386                 --     even if only 'M.x' is in scope
387             [gre] -> do { addUsedRdrName warnIfDeprec gre (used_rdr_name gre)
388                           -- Add a usage; this is an *occurrence* site
389                         ; return (gre_name gre) }
390             []    -> do { addErr (unknownSubordinateErr doc rdr_name)
391                         ; return (mkUnboundName rdr_name) }
392             gres  -> do { addNameClashErrRn rdr_name gres
393                         ; return (gre_name (head gres)) } }
394   where
395     -- Note [Usage for sub-bndrs]
396     used_rdr_name gre
397       | isQual rdr_name = rdr_name
398       | otherwise       = greRdrName gre
399
400 greRdrName :: GlobalRdrElt -> RdrName
401 greRdrName gre
402   = case gre_prov gre of
403       LocalDef    -> unqual_rdr
404       Imported is -> used_rdr_name_from_is is
405
406   where
407     occ = nameOccName (gre_name gre)
408     unqual_rdr = mkRdrUnqual occ
409
410     used_rdr_name_from_is imp_specs     -- rdr_name is unqualified
411       | not (all (is_qual . is_decl) imp_specs)
412       = unqual_rdr  -- An unqualified import is available
413       | otherwise
414       =             -- Only qualified imports available, so make up
415                     -- a suitable qualifed name from the first imp_spec
416         ASSERT( not (null imp_specs) )
417         mkRdrQual (is_as (is_decl (head imp_specs))) occ
418
419 lookupSubBndrGREs :: GlobalRdrEnv -> Parent -> RdrName -> [GlobalRdrElt]
420 -- If Parent = NoParent, just do a normal lookup
421 -- If Parent = Parent p then find all GREs that
422 --   (a) have parent p
423 --   (b) for Unqual, are in scope qualified or unqualified
424 --       for Qual, are in scope with that qualification
425 lookupSubBndrGREs env parent rdr_name
426   = case parent of
427       NoParent   -> pickGREs rdr_name gres
428       ParentIs p
429         | isUnqual rdr_name -> filter (parent_is p) gres
430         | otherwise         -> filter (parent_is p) (pickGREs rdr_name gres)
431
432   where
433     gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)
434
435     parent_is p (GRE { gre_par = ParentIs p' }) = p == p'
436     parent_is _ _                               = False
437 \end{code}
438
439 Note [Family instance binders]
440 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
441 Consider
442   data family F a
443   data instance F T = X1 | X2
444
445 The 'data instance' decl has an *occurrence* of F (and T), and *binds*
446 X1 and X2.  (This is unlike a normal data type declaration which would
447 bind F too.)  So we want an AvailTC F [X1,X2].
448
449 Now consider a similar pair:
450   class C a where
451     data G a
452   instance C S where
453     data G S = Y1 | Y2
454
455 The 'data G S' *binds* Y1 and Y2, and has an *occurrence* of G.
456
457 But there is a small complication: in an instance decl, we don't use
458 qualified names on the LHS; instead we use the class to disambiguate.
459 Thus:
460   module M where
461     import Blib( G )
462     class C a where
463       data G a
464     instance C S where
465       data G S = Y1 | Y2
466 Even though there are two G's in scope (M.G and Blib.G), the occurrence
467 of 'G' in the 'instance C S' decl is unambiguous, because C has only
468 one associated type called G. This is exactly what happens for methods,
469 and it is only consistent to do the same thing for types. That's the
470 role of the function lookupTcdName; the (Maybe Name) give the class of
471 the encloseing instance decl, if any.
472
473 Note [Looking up Exact RdrNames]
474 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
475 Exact RdrNames are generated by Template Haskell.  See Note [Binders
476 in Template Haskell] in Convert.
477
478 For data types and classes have Exact system Names in the binding
479 positions for constructors, TyCons etc.  For example
480     [d| data T = MkT Int |]
481 when we splice in and Convert to HsSyn RdrName, we'll get
482     data (Exact (system Name "T")) = (Exact (system Name "MkT")) ...
483 These System names are generated by Convert.thRdrName
484
485 But, constructors and the like need External Names, not System Names!
486 So we do the following
487
488  * In RnEnv.newGlobalBinder we spot Exact RdrNames that wrap a
489    non-External Name, and make an External name for it. This is
490    the name that goes in the GlobalRdrEnv
491
492  * When looking up an occurrence of an Exact name, done in
493    RnEnv.lookupExactOcc, we find the Name with the right unique in the
494    GlobalRdrEnv, and use the one from the envt -- it will be an
495    External Name in the case of the data type/constructor above.
496
497  * Exact names are also use for purely local binders generated
498    by TH, such as    \x_33. x_33
499    Both binder and occurrence are Exact RdrNames.  The occurrence
500    gets looked up in the LocalRdrEnv by RnEnv.lookupOccRn, and
501    misses, because lookupLocalRdrEnv always returns Nothing for
502    an Exact Name.  Now we fall through to lookupExactOcc, which
503    will find the Name is not in the GlobalRdrEnv, so we just use
504    the Exact supplied Name.
505
506 Note [Splicing Exact names]
507 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
508 Consider the splice $(do { x <- newName "x"; return (VarE x) })
509 This will generate a (HsExpr RdrName) term that mentions the
510 Exact RdrName "x_56" (or whatever), but does not bind it.  So
511 when looking such Exact names we want to check that it's in scope,
512 otherwise the type checker will get confused.  To do this we need to
513 keep track of all the Names in scope, and the LocalRdrEnv does just that;
514 we consult it with RdrName.inLocalRdrEnvScope.
515
516 There is another wrinkle.  With TH and -XDataKinds, consider
517    $( [d| data Nat = Zero
518           data T = MkT (Proxy 'Zero)  |] )
519 After splicing, but before renaming we get this:
520    data Nat_77{tc} = Zero_78{d}
521    data T_79{tc} = MkT_80{d} (Proxy 'Zero_78{tc})  |] )
522 THe occurrence of 'Zero in the data type for T has the right unique,
523 but it has a TcClsName name-space in its OccName.  (This is set by
524 the ctxt_ns argument of Convert.thRdrName.)  When we check that is
525 in scope in the GlobalRdrEnv, we need to look up the DataName namespace
526 too.  (An alternative would be to make the GlobalRdrEnv also have
527 a Name -> GRE mapping.)
528
529 Note [Usage for sub-bndrs]
530 ~~~~~~~~~~~~~~~~~~~~~~~~~~
531 If you have this
532    import qualified M( C( f ) )
533    instance M.C T where
534      f x = x
535 then is the qualified import M.f used?  Obviously yes.
536 But the RdrName used in the instance decl is unqualified.  In effect,
537 we fill in the qualification by looking for f's whose class is M.C
538 But when adding to the UsedRdrNames we must make that qualification
539 explicit (saying "used  M.f"), otherwise we get "Redundant import of M.f".
540
541 So we make up a suitable (fake) RdrName.  But be careful
542    import qualifed M
543    import M( C(f) )
544    instance C T where
545      f x = x
546 Here we want to record a use of 'f', not of 'M.f', otherwise
547 we'll miss the fact that the qualified import is redundant.
548
549 --------------------------------------------------
550 --              Occurrences
551 --------------------------------------------------
552
553 \begin{code}
554 getLookupOccRn :: RnM (Name -> Maybe Name)
555 getLookupOccRn
556   = do local_env <- getLocalRdrEnv
557        return (lookupLocalRdrOcc local_env . nameOccName)
558
559 lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
560 lookupLocatedOccRn = wrapLocM lookupOccRn
561
562 lookupLocalOccRn_maybe :: RdrName -> RnM (Maybe Name)
563 -- Just look in the local environment
564 lookupLocalOccRn_maybe rdr_name
565   = do { local_env <- getLocalRdrEnv
566        ; return (lookupLocalRdrEnv local_env rdr_name) }
567
568 lookupLocalOccThLvl_maybe :: Name -> RnM (Maybe (TopLevelFlag, ThLevel))
569 -- Just look in the local environment
570 lookupLocalOccThLvl_maybe name
571   = do { lcl_env <- getLclEnv
572        ; return (lookupNameEnv (tcl_th_bndrs lcl_env) name) }
573
574 -- lookupOccRn looks up an occurrence of a RdrName
575 lookupOccRn :: RdrName -> RnM Name
576 lookupOccRn rdr_name
577   = do { mb_name <- lookupOccRn_maybe rdr_name
578        ; case mb_name of
579            Just name -> return name
580            Nothing   -> reportUnboundName rdr_name }
581
582 lookupKindOccRn :: RdrName -> RnM Name
583 -- Looking up a name occurring in a kind
584 lookupKindOccRn rdr_name
585   = do { mb_name <- lookupOccRn_maybe rdr_name
586        ; case mb_name of
587            Just name -> return name
588            Nothing   -> reportUnboundName rdr_name  }
589
590 -- lookupPromotedOccRn looks up an optionally promoted RdrName.
591 lookupTypeOccRn :: RdrName -> RnM Name
592 -- see Note [Demotion]
593 lookupTypeOccRn rdr_name
594   = do { mb_name <- lookupOccRn_maybe rdr_name
595        ; case mb_name of {
596              Just name -> return name ;
597              Nothing   -> lookup_demoted rdr_name } }
598
599 lookup_demoted :: RdrName -> RnM Name
600 lookup_demoted rdr_name
601   | Just demoted_rdr <- demoteRdrName rdr_name
602     -- Maybe it's the name of a *data* constructor
603   = do { data_kinds <- xoptM Opt_DataKinds
604        ; mb_demoted_name <- lookupOccRn_maybe demoted_rdr
605        ; case mb_demoted_name of
606            Nothing -> reportUnboundName rdr_name
607            Just demoted_name
608              | data_kinds -> return demoted_name
609              | otherwise  -> unboundNameX WL_Any rdr_name suggest_dk }
610
611   | otherwise
612   = reportUnboundName rdr_name
613
614   where
615     suggest_dk = ptext (sLit "A data constructor of that name is in scope; did you mean DataKinds?")
616 \end{code}
617
618 Note [Demotion]
619 ~~~~~~~~~~~~~~~
620 When the user writes:
621   data Nat = Zero | Succ Nat
622   foo :: f Zero -> Int
623
624 'Zero' in the type signature of 'foo' is parsed as:
625   HsTyVar ("Zero", TcClsName)
626
627 When the renamer hits this occurrence of 'Zero' it's going to realise
628 that it's not in scope. But because it is renaming a type, it knows
629 that 'Zero' might be a promoted data constructor, so it will demote
630 its namespace to DataName and do a second lookup.
631
632 The final result (after the renamer) will be:
633   HsTyVar ("Zero", DataName)
634
635 \begin{code}
636 --              Use this version to get tracing
637 --
638 -- lookupOccRn_maybe, lookupOccRn_maybe' :: RdrName -> RnM (Maybe Name)
639 -- lookupOccRn_maybe rdr_name
640 --  = do { mb_res <- lookupOccRn_maybe' rdr_name
641 --       ; gbl_rdr_env   <- getGlobalRdrEnv
642 --       ; local_rdr_env <- getLocalRdrEnv
643 --       ; traceRn $ text "lookupOccRn_maybe" <+>
644 --           vcat [ ppr rdr_name <+> ppr (getUnique (rdrNameOcc rdr_name))
645 --                , ppr mb_res
646 --                , text "Lcl env" <+> ppr local_rdr_env
647 --                , text "Gbl env" <+> ppr [ (getUnique (nameOccName (gre_name (head gres'))),gres') | gres <- occEnvElts gbl_rdr_env
648 --                                         , let gres' = filter isLocalGRE gres, not (null gres') ] ]
649 --       ; return mb_res }
650
651 lookupOccRn_maybe :: RdrName -> RnM (Maybe Name)
652 -- lookupOccRn looks up an occurrence of a RdrName
653 lookupOccRn_maybe rdr_name
654   = do { local_env <- getLocalRdrEnv
655        ; case lookupLocalRdrEnv local_env rdr_name of {
656           Just name -> return (Just name) ;
657           Nothing   -> do
658        { mb_name <- lookupGlobalOccRn_maybe rdr_name
659        ; case mb_name of {
660                 Just name  -> return (Just name) ;
661                 Nothing -> do
662        { dflags  <- getDynFlags
663        ; is_ghci <- getIsGHCi   -- This test is not expensive,
664                                 -- and only happens for failed lookups
665        ; lookupQualifiedNameGHCi dflags is_ghci rdr_name } } } } }
666
667 lookupGlobalOccRn :: RdrName -> RnM Name
668 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
669 -- environment.  Adds an error message if the RdrName is not in scope.
670 lookupGlobalOccRn rdr_name
671   = do { mb_name <- lookupGlobalOccRn_maybe rdr_name
672        ; case mb_name of
673            Just n  -> return n
674            Nothing -> do { traceRn (text "lookupGlobalOccRn" <+> ppr rdr_name)
675                          ; unboundName WL_Global rdr_name } }
676
677 lookupGlobalOccRn_maybe :: RdrName -> RnM (Maybe Name)
678 -- No filter function; does not report an error on failure
679
680 lookupGlobalOccRn_maybe rdr_name
681   | Just n <- isExact_maybe rdr_name   -- This happens in derived code
682   = do { n' <- lookupExactOcc n; return (Just n') }
683
684   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
685   = do { n <- lookupOrig rdr_mod rdr_occ
686        ; return (Just n) }
687
688   | otherwise
689   = do  { mb_gre <- lookupGreRn_maybe rdr_name
690         ; case mb_gre of
691                 Nothing  -> return Nothing
692                 Just gre -> return (Just (gre_name gre)) }
693
694
695 --------------------------------------------------
696 --      Lookup in the Global RdrEnv of the module
697 --------------------------------------------------
698
699 lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
700 -- Just look up the RdrName in the GlobalRdrEnv
701 lookupGreRn_maybe rdr_name
702   = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
703
704 lookupGreRn :: RdrName -> RnM GlobalRdrElt
705 -- If not found, add error message, and return a fake GRE
706 lookupGreRn rdr_name
707   = do  { mb_gre <- lookupGreRn_maybe rdr_name
708         ; case mb_gre of {
709             Just gre -> return gre ;
710             Nothing  -> do
711         { traceRn (text "lookupGreRn" <+> ppr rdr_name)
712         ; name <- unboundName WL_Global rdr_name
713         ; return (GRE { gre_name = name, gre_par = NoParent,
714                         gre_prov = LocalDef }) }}}
715
716 lookupGreLocalRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
717 -- Similar, but restricted to locally-defined things
718 lookupGreLocalRn_maybe rdr_name
719   = lookupGreRn_help rdr_name lookup_fn
720   where
721     lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)
722
723 lookupGreRn_help :: RdrName                     -- Only used in error message
724                  -> (GlobalRdrEnv -> [GlobalRdrElt])    -- Lookup function
725                  -> RnM (Maybe GlobalRdrElt)
726 -- Checks for exactly one match; reports deprecations
727 -- Returns Nothing, without error, if too few
728 lookupGreRn_help rdr_name lookup
729   = do  { env <- getGlobalRdrEnv
730         ; case lookup env of
731             []    -> return Nothing
732             [gre] -> do { addUsedRdrName True gre rdr_name
733                         ; return (Just gre) }
734             gres  -> do { addNameClashErrRn rdr_name gres
735                         ; return (Just (head gres)) } }
736 \end{code}
737
738 %*********************************************************
739 %*                                                      *
740                 Deprecations
741 %*                                                      *
742 %*********************************************************
743
744 Note [Handling of deprecations]
745 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
746 * We report deprecations at each *occurrence* of the deprecated thing
747   (see Trac #5867)
748
749 * We do not report deprectations for locally-definded names. For a
750   start, we may be exporting a deprecated thing. Also we may use a
751   deprecated thing in the defn of another deprecated things.  We may
752   even use a deprecated thing in the defn of a non-deprecated thing,
753   when changing a module's interface.
754
755 * addUsedRdrNames: we do not report deprecations for sub-binders:
756      - the ".." completion for records
757      - the ".." in an export item 'T(..)'
758      - the things exported by a module export 'module M'
759
760 \begin{code}
761 addUsedRdrName :: Bool -> GlobalRdrElt -> RdrName -> RnM ()
762 -- Record usage of imported RdrNames
763 addUsedRdrName warnIfDeprec gre rdr
764   | isLocalGRE gre = return ()  -- No call to warnIfDeprecated
765                                 -- See Note [Handling of deprecations]
766   | otherwise      = do { env <- getGblEnv
767                         ; when warnIfDeprec $ warnIfDeprecated gre
768                         ; updMutVar (tcg_used_rdrnames env)
769                                     (\s -> Set.insert rdr s) }
770
771 addUsedRdrNames :: [RdrName] -> RnM ()
772 -- Record used sub-binders
773 -- We don't check for imported-ness here, because it's inconvenient
774 -- and not stritly necessary.
775 -- NB: no call to warnIfDeprecated; see Note [Handling of deprecations]
776 addUsedRdrNames rdrs
777   = do { env <- getGblEnv
778        ; updMutVar (tcg_used_rdrnames env)
779                    (\s -> foldr Set.insert s rdrs) }
780
781 warnIfDeprecated :: GlobalRdrElt -> RnM ()
782 warnIfDeprecated gre@(GRE { gre_name = name, gre_prov = Imported (imp_spec : _) })
783   = do { dflags <- getDynFlags
784        ; when (wopt Opt_WarnWarningsDeprecations dflags) $
785          do { iface <- loadInterfaceForName doc name
786             ; case lookupImpDeprec iface gre of
787                 Just txt -> addWarn (mk_msg txt)
788                 Nothing  -> return () } }
789   where
790     mk_msg txt = sep [ sep [ ptext (sLit "In the use of")
791                              <+> pprNonVarNameSpace (occNameSpace (nameOccName name))
792                              <+> quotes (ppr name)
793                            , parens imp_msg <> colon ]
794                      , ppr txt ]
795
796     name_mod = ASSERT2( isExternalName name, ppr name ) nameModule name
797     imp_mod  = importSpecModule imp_spec
798     imp_msg  = ptext (sLit "imported from") <+> ppr imp_mod <> extra
799     extra | imp_mod == moduleName name_mod = Outputable.empty
800           | otherwise = ptext (sLit ", but defined in") <+> ppr name_mod
801
802     doc = ptext (sLit "The name") <+> quotes (ppr name) <+> ptext (sLit "is mentioned explicitly")
803
804 warnIfDeprecated _ = return ()   -- No deprecations for things defined locally
805
806 lookupImpDeprec :: ModIface -> GlobalRdrElt -> Maybe WarningTxt
807 lookupImpDeprec iface gre
808   = mi_warn_fn iface (gre_name gre) `mplus`  -- Bleat if the thing,
809     case gre_par gre of                      -- or its parent, is warn'd
810        ParentIs p -> mi_warn_fn iface p
811        NoParent   -> Nothing
812 \end{code}
813
814 Note [Used names with interface not loaded]
815 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
816 It's (just) possible to find a used
817 Name whose interface hasn't been loaded:
818
819 a) It might be a WiredInName; in that case we may not load
820    its interface (although we could).
821
822 b) It might be GHC.Real.fromRational, or GHC.Num.fromInteger
823    These are seen as "used" by the renamer (if -XRebindableSyntax)
824    is on), but the typechecker may discard their uses
825    if in fact the in-scope fromRational is GHC.Read.fromRational,
826    (see tcPat.tcOverloadedLit), and the typechecker sees that the type
827    is fixed, say, to GHC.Base.Float (see Inst.lookupSimpleInst).
828    In that obscure case it won't force the interface in.
829
830 In both cases we simply don't permit deprecations;
831 this is, after all, wired-in stuff.
832
833
834 %*********************************************************
835 %*                                                      *
836                 GHCi support
837 %*                                                      *
838 %*********************************************************
839
840 A qualified name on the command line can refer to any module at
841 all: we try to load the interface if we don't already have it, just
842 as if there was an "import qualified M" declaration for every
843 module.
844
845 If we fail we just return Nothing, rather than bleating
846 about "attempting to use module ā€˜Dā€™ (./D.hs) which is not loaded"
847 which is what loadSrcInterface does.
848
849 Note [Safe Haskell and GHCi]
850 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
851 We DONT do this Safe Haskell as we need to check imports. We can
852 and should instead check the qualified import but at the moment
853 this requires some refactoring so leave as a TODO
854
855 \begin{code}
856 lookupQualifiedNameGHCi :: DynFlags -> Bool -> RdrName -> RnM (Maybe Name)
857 lookupQualifiedNameGHCi dflags is_ghci rdr_name
858   | Just (mod,occ) <- isQual_maybe rdr_name
859   , is_ghci
860   , gopt Opt_ImplicitImportQualified dflags   -- Enables this GHCi behaviour
861   , not (safeDirectImpsReq dflags)            -- See Note [Safe Haskell and GHCi]
862   = -- We want to behave as we would for a source file import here,
863     -- and respect hiddenness of modules/packages, hence loadSrcInterface.
864     do { res <- loadSrcInterface_maybe doc mod False Nothing
865        ; case res of
866            Succeeded iface
867              | (n:ns) <- [ name
868                          | avail <- mi_exports iface
869                          , name  <- availNames avail
870                          , nameOccName name == occ ]
871              -> ASSERT(null ns) return (Just n)
872
873            _ -> -- Either we couldn't load the interface, or
874                 -- we could but we didn't find the name in it
875                 do { traceRn (text "lookupQualifiedNameGHCi" <+> ppr rdr_name)
876                    ; return Nothing } }
877
878   | otherwise
879   = return Nothing
880   where
881     doc = ptext (sLit "Need to find") <+> ppr rdr_name
882 \end{code}
883
884 Note [Looking up signature names]
885 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
886 lookupSigOccRn is used for type signatures and pragmas
887 Is this valid?
888   module A
889         import M( f )
890         f :: Int -> Int
891         f x = x
892 It's clear that the 'f' in the signature must refer to A.f
893 The Haskell98 report does not stipulate this, but it will!
894 So we must treat the 'f' in the signature in the same way
895 as the binding occurrence of 'f', using lookupBndrRn
896
897 However, consider this case:
898         import M( f )
899         f :: Int -> Int
900         g x = x
901 We don't want to say 'f' is out of scope; instead, we want to
902 return the imported 'f', so that later on the reanamer will
903 correctly report "misplaced type sig".
904
905 Note [Signatures for top level things]
906 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
907 data HsSigCtxt = ... | TopSigCtxt NameSet Bool | ....
908
909 * The NameSet says what is bound in this group of bindings.
910   We can't use isLocalGRE from the GlobalRdrEnv, because of this:
911        f x = x
912        $( ...some TH splice... )
913        f :: Int -> Int
914   When we encounter the signature for 'f', the binding for 'f'
915   will be in the GlobalRdrEnv, and will be a LocalDef. Yet the
916   signature is mis-placed
917
918 * The Bool says whether the signature is ok for a class method
919   or record selector.  Consider
920       infix 3 `f`          -- Yes, ok
921       f :: C a => a -> a   -- No, not ok
922       class C a where
923         f :: a -> a
924
925 \begin{code}
926 data HsSigCtxt
927   = TopSigCtxt NameSet Bool  -- At top level, binding these names
928                              -- See Note [Signatures for top level things]
929                              -- Bool <=> ok to give sig for
930                              --          class method or record selctor
931   | LocalBindCtxt NameSet    -- In a local binding, binding these names
932   | ClsDeclCtxt   Name       -- Class decl for this class
933   | InstDeclCtxt  Name       -- Intsance decl for this class
934   | HsBootCtxt               -- Top level of a hs-boot file
935
936 lookupSigOccRn :: HsSigCtxt
937                -> Sig RdrName
938                -> Located RdrName -> RnM (Located Name)
939 lookupSigOccRn ctxt sig
940   = wrapLocM $ \ rdr_name ->
941     do { mb_name <- lookupBindGroupOcc ctxt (hsSigDoc sig) rdr_name
942        ; case mb_name of
943            Left err   -> do { addErr err; return (mkUnboundName rdr_name) }
944            Right name -> return name }
945
946 lookupBindGroupOcc :: HsSigCtxt
947                    -> SDoc
948                    -> RdrName -> RnM (Either MsgDoc Name)
949 -- Looks up the RdrName, expecting it to resolve to one of the
950 -- bound names passed in.  If not, return an appropriate error message
951 --
952 -- See Note [Looking up signature names]
953 lookupBindGroupOcc ctxt what rdr_name
954   | Just n <- isExact_maybe rdr_name
955   = do { n' <- lookupExactOcc n
956        ; return (Right n') }  -- Maybe we should check the side conditions
957                               -- but it's a pain, and Exact things only show
958                               -- up when you know what you are doing
959
960   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
961   = do { n' <- lookupOrig rdr_mod rdr_occ
962        ; return (Right n') }
963
964   | otherwise
965   = case ctxt of
966       HsBootCtxt            -> lookup_top (const True)       True
967       TopSigCtxt ns meth_ok -> lookup_top (`elemNameSet` ns) meth_ok
968       LocalBindCtxt ns      -> lookup_group ns
969       ClsDeclCtxt  cls      -> lookup_cls_op cls
970       InstDeclCtxt cls      -> lookup_cls_op cls
971   where
972     lookup_cls_op cls
973       = do { env <- getGlobalRdrEnv
974            ; let gres = lookupSubBndrGREs env (ParentIs cls) rdr_name
975            ; case gres of
976                []      -> return (Left (unknownSubordinateErr doc rdr_name))
977                (gre:_) -> return (Right (gre_name gre)) }
978                         -- If there is more than one local GRE for the
979                         -- same OccName 'f', that will be reported separately
980                         -- as a duplicate top-level binding for 'f'
981       where
982         doc = ptext (sLit "method of class") <+> quotes (ppr cls)
983
984     lookup_top keep_me meth_ok
985       = do { env <- getGlobalRdrEnv
986            ; let all_gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)
987            ; case filter (keep_me . gre_name) all_gres of
988                [] | null all_gres -> bale_out_with Outputable.empty
989                   | otherwise -> bale_out_with local_msg
990                (gre:_)
991                   | ParentIs {} <- gre_par gre
992                   , not meth_ok
993                   -> bale_out_with sub_msg
994                   | otherwise
995                   -> return (Right (gre_name gre)) }
996
997     lookup_group bound_names  -- Look in the local envt (not top level)
998       = do { local_env <- getLocalRdrEnv
999            ; case lookupLocalRdrEnv local_env rdr_name of
1000                Just n
1001                  | n `elemNameSet` bound_names -> return (Right n)
1002                  | otherwise                   -> bale_out_with local_msg
1003                Nothing                         -> bale_out_with Outputable.empty }
1004
1005     bale_out_with msg
1006         = return (Left (sep [ ptext (sLit "The") <+> what
1007                                 <+> ptext (sLit "for") <+> quotes (ppr rdr_name)
1008                            , nest 2 $ ptext (sLit "lacks an accompanying binding")]
1009                        $$ nest 2 msg))
1010
1011     local_msg = parens $ ptext (sLit "The")  <+> what <+> ptext (sLit "must be given where")
1012                            <+> quotes (ppr rdr_name) <+> ptext (sLit "is declared")
1013
1014     sub_msg = parens $ ptext (sLit "You cannot give a") <+> what
1015                        <+> ptext (sLit "for a record selector or class method")
1016
1017
1018 ---------------
1019 lookupLocalTcNames :: HsSigCtxt -> SDoc -> RdrName -> RnM [Name]
1020 -- GHC extension: look up both the tycon and data con or variable.
1021 -- Used for top-level fixity signatures and deprecations.
1022 -- Complain if neither is in scope.
1023 -- See Note [Fixity signature lookup]
1024 lookupLocalTcNames ctxt what rdr_name
1025   = do { mb_gres <- mapM lookup (dataTcOccs rdr_name)
1026        ; let (errs, names) = splitEithers mb_gres
1027        ; when (null names) $ addErr (head errs) -- Bleat about one only
1028        ; return names }
1029   where
1030     lookup = lookupBindGroupOcc ctxt what
1031
1032 dataTcOccs :: RdrName -> [RdrName]
1033 -- Return both the given name and the same name promoted to the TcClsName
1034 -- namespace.  This is useful when we aren't sure which we are looking at.
1035 dataTcOccs rdr_name
1036   | Just n <- isExact_maybe rdr_name
1037   , not (isBuiltInSyntax n)   -- See Note [dataTcOccs and Exact Names]
1038   = [rdr_name]
1039   | isDataOcc occ || isVarOcc occ
1040   = [rdr_name, rdr_name_tc]
1041   | otherwise
1042   = [rdr_name]
1043   where
1044     occ = rdrNameOcc rdr_name
1045     rdr_name_tc = setRdrNameSpace rdr_name tcName
1046 \end{code}
1047
1048 Note [dataTcOccs and Exact Names]
1049 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1050 Exact RdrNames can occur in code generated by Template Haskell, and generally
1051 those references are, well, exact, so it's wrong to return the TyClsName too.
1052 But there is an awkward exception for built-in syntax. Example in GHCi
1053    :info []
1054 This parses as the Exact RdrName for nilDataCon, but we also want
1055 the list type constructor.
1056
1057 Note that setRdrNameSpace on an Exact name requires the Name to be External,
1058 which it always is for built in syntax.
1059
1060 %*********************************************************
1061 %*                                                      *
1062                 Fixities
1063 %*                                                      *
1064 %*********************************************************
1065
1066 Note [Fixity signature lookup]
1067 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1068 A fixity declaration like
1069
1070     infixr 2 ?
1071
1072 can refer to a value-level operator, e.g.:
1073
1074     (?) :: String -> String -> String
1075
1076 or a type-level operator, like:
1077
1078     data (?) a b = A a | B b
1079
1080 so we extend the lookup of the reader name '?' to the TcClsName namespace, as
1081 well as the original namespace.
1082
1083 The extended lookup is also used in other places, like resolution of
1084 deprecation declarations, and lookup of names in GHCi.
1085
1086 \begin{code}
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 (mapMaybe 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 Outputable.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                 = Outputable.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                            []  -> Outputable.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) = pp_ns rdr <+> 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) = pp_ns rdr <+> quotes (ppr rdr) <+>   -- Imported
1472                               parens (ptext (sLit "imported from") <+> ppr (is_mod is))
1473
1474     pp_ns :: RdrName -> SDoc
1475     pp_ns rdr | ns /= tried_ns = pprNameSpace ns
1476               | otherwise      = Outputable.empty
1477       where ns = rdrNameSpace rdr
1478
1479     tried_occ     = rdrNameOcc tried_rdr_name
1480     tried_is_sym  = isSymOcc tried_occ
1481     tried_ns      = occNameSpace tried_occ
1482     tried_is_qual = isQual tried_rdr_name
1483
1484     correct_name_space occ =  nameSpacesRelated (occNameSpace occ) tried_ns
1485                            && isSymOcc occ == tried_is_sym
1486         -- Treat operator and non-operators as non-matching
1487         -- This heuristic avoids things like
1488         --      Not in scope 'f'; perhaps you meant '+' (from Prelude)
1489
1490     local_ok = case where_look of { WL_Any -> True; _ -> False }
1491     local_possibilities :: LocalRdrEnv -> [(RdrName, SrcSpan)]
1492     local_possibilities env
1493       | tried_is_qual = []
1494       | not local_ok  = []
1495       | otherwise     = [ (mkRdrUnqual occ, nameSrcSpan name)
1496                         | name <- localRdrEnvElts env
1497                         , let occ = nameOccName name
1498                         , correct_name_space occ]
1499
1500     gre_ok :: GlobalRdrElt -> Bool
1501     gre_ok = case where_look of
1502                    WL_LocalTop -> isLocalGRE
1503                    _           -> \_ -> True
1504
1505     global_possibilities :: GlobalRdrEnv -> [(RdrName, (RdrName, HowInScope))]
1506     global_possibilities global_env
1507       | tried_is_qual = [ (rdr_qual, (rdr_qual, how))
1508                         | gre <- globalRdrEnvElts global_env
1509                         , gre_ok gre
1510                         , let name = gre_name gre
1511                               occ  = nameOccName name
1512                         , correct_name_space occ
1513                         , (mod, how) <- quals_in_scope name (gre_prov gre)
1514                         , let rdr_qual = mkRdrQual mod occ ]
1515
1516       | otherwise = [ (rdr_unqual, pair)
1517                     | gre <- globalRdrEnvElts global_env
1518                     , gre_ok gre
1519                     , let name = gre_name gre
1520                           prov = gre_prov gre
1521                           occ  = nameOccName name
1522                           rdr_unqual = mkRdrUnqual occ
1523                     , correct_name_space occ
1524                     , pair <- case (unquals_in_scope name prov, quals_only occ prov) of
1525                                 (how:_, _)    -> [ (rdr_unqual, how) ]
1526                                 ([],    pr:_) -> [ pr ]  -- See Note [Only-quals]
1527                                 ([],    [])   -> [] ]
1528
1529               -- Note [Only-quals]
1530               -- The second alternative returns those names with the same
1531               -- OccName as the one we tried, but live in *qualified* imports
1532               -- e.g. if you have:
1533               --
1534               -- > import qualified Data.Map as Map
1535               -- > foo :: Map
1536               --
1537               -- then we suggest @Map.Map@.
1538
1539     --------------------
1540     unquals_in_scope :: Name -> Provenance -> [HowInScope]
1541     unquals_in_scope n LocalDef      = [ Left (nameSrcSpan n) ]
1542     unquals_in_scope _ (Imported is) = [ Right ispec
1543                                        | i <- is, let ispec = is_decl i
1544                                        , not (is_qual ispec) ]
1545
1546     --------------------
1547     quals_in_scope :: Name -> Provenance -> [(ModuleName, HowInScope)]
1548     -- Ones for which the qualified version is in scope
1549     quals_in_scope n LocalDef      = case nameModule_maybe n of
1550                                        Nothing -> []
1551                                        Just m  -> [(moduleName m, Left (nameSrcSpan n))]
1552     quals_in_scope _ (Imported is) = [ (is_as ispec, Right ispec)
1553                                      | i <- is, let ispec = is_decl i ]
1554
1555     --------------------
1556     quals_only :: OccName -> Provenance -> [(RdrName, HowInScope)]
1557     -- Ones for which *only* the qualified version is in scope
1558     quals_only _   LocalDef      = []
1559     quals_only occ (Imported is) = [ (mkRdrQual (is_as ispec) occ, Right ispec)
1560                                    | i <- is, let ispec = is_decl i, is_qual ispec ]
1561 \end{code}
1562
1563 %************************************************************************
1564 %*                                                                      *
1565 \subsection{Free variable manipulation}
1566 %*                                                                      *
1567 %************************************************************************
1568
1569 \begin{code}
1570 -- A useful utility
1571 addFvRn :: FreeVars -> RnM (thing, FreeVars) -> RnM (thing, FreeVars)
1572 addFvRn fvs1 thing_inside = do { (res, fvs2) <- thing_inside
1573                                ; return (res, fvs1 `plusFV` fvs2) }
1574
1575 mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
1576 mapFvRn f xs = do stuff <- mapM f xs
1577                   case unzip stuff of
1578                       (ys, fvs_s) -> return (ys, plusFVs fvs_s)
1579
1580 mapMaybeFvRn :: (a -> RnM (b, FreeVars)) -> Maybe a -> RnM (Maybe b, FreeVars)
1581 mapMaybeFvRn _ Nothing = return (Nothing, emptyFVs)
1582 mapMaybeFvRn f (Just x) = do { (y, fvs) <- f x; return (Just y, fvs) }
1583
1584 -- because some of the rename functions are CPSed:
1585 -- maps the function across the list from left to right;
1586 -- collects all the free vars into one set
1587 mapFvRnCPS :: (a  -> (b   -> RnM c) -> RnM c)
1588            -> [a] -> ([b] -> RnM c) -> RnM c
1589
1590 mapFvRnCPS _ []     cont = cont []
1591 mapFvRnCPS f (x:xs) cont = f x             $ \ x' ->
1592                            mapFvRnCPS f xs $ \ xs' ->
1593                            cont (x':xs')
1594 \end{code}
1595
1596
1597 %************************************************************************
1598 %*                                                                      *
1599 \subsection{Envt utility functions}
1600 %*                                                                      *
1601 %************************************************************************
1602
1603 \begin{code}
1604 warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
1605 warnUnusedTopBinds gres
1606     = whenWOptM Opt_WarnUnusedBinds
1607     $ do isBoot <- tcIsHsBoot
1608          let noParent gre = case gre_par gre of
1609                             NoParent -> True
1610                             ParentIs _ -> False
1611              -- Don't warn about unused bindings with parents in
1612              -- .hs-boot files, as you are sometimes required to give
1613              -- unused bindings (trac #3449).
1614              gres' = if isBoot then filter noParent gres
1615                                else                 gres
1616          warnUnusedGREs gres'
1617
1618 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> FreeVars -> RnM ()
1619 warnUnusedLocalBinds = check_unused Opt_WarnUnusedBinds
1620 warnUnusedMatches    = check_unused Opt_WarnUnusedMatches
1621
1622 check_unused :: WarningFlag -> [Name] -> FreeVars -> RnM ()
1623 check_unused flag bound_names used_names
1624  = whenWOptM flag (warnUnusedLocals (filterOut (`elemNameSet` used_names) bound_names))
1625
1626 -------------------------
1627 --      Helpers
1628 warnUnusedGREs :: [GlobalRdrElt] -> RnM ()
1629 warnUnusedGREs gres
1630  = warnUnusedBinds [(n,p) | GRE {gre_name = n, gre_prov = p} <- gres]
1631
1632 warnUnusedLocals :: [Name] -> RnM ()
1633 warnUnusedLocals names
1634  = warnUnusedBinds [(n,LocalDef) | n<-names]
1635
1636 warnUnusedBinds :: [(Name,Provenance)] -> RnM ()
1637 warnUnusedBinds names  = mapM_ warnUnusedName (filter reportable names)
1638  where reportable (name,_)
1639         | isWiredInName name = False    -- Don't report unused wired-in names
1640                                         -- Otherwise we get a zillion warnings
1641                                         -- from Data.Tuple
1642         | otherwise = not (startsWithUnderscore (nameOccName name))
1643
1644 -------------------------
1645
1646 warnUnusedName :: (Name, Provenance) -> RnM ()
1647 warnUnusedName (name, LocalDef)
1648   = addUnusedWarning name (nameSrcSpan name)
1649                      (ptext (sLit "Defined but not used"))
1650
1651 warnUnusedName (name, Imported is)
1652   = mapM_ warn is
1653   where
1654     warn spec = addUnusedWarning name span msg
1655         where
1656            span = importSpecLoc spec
1657            pp_mod = quotes (ppr (importSpecModule spec))
1658            msg = ptext (sLit "Imported from") <+> pp_mod <+> ptext (sLit "but not used")
1659
1660 addUnusedWarning :: Name -> SrcSpan -> SDoc -> RnM ()
1661 addUnusedWarning name span msg
1662   = addWarnAt span $
1663     sep [msg <> colon,
1664          nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
1665                         <+> quotes (ppr name)]
1666 \end{code}
1667
1668 \begin{code}
1669 addNameClashErrRn :: RdrName -> [GlobalRdrElt] -> RnM ()
1670 addNameClashErrRn rdr_name gres
1671   | all isLocalGRE gres  -- If there are two or more *local* defns, we'll have reported
1672   = return ()            -- that already, and we don't want an error cascade
1673   | otherwise
1674   = addErr (vcat [ptext (sLit "Ambiguous occurrence") <+> quotes (ppr rdr_name),
1675                   ptext (sLit "It could refer to") <+> vcat (msg1 : msgs)])
1676   where
1677     (np1:nps) = gres
1678     msg1 = ptext  (sLit "either") <+> mk_ref np1
1679     msgs = [ptext (sLit "    or") <+> mk_ref np | np <- nps]
1680     mk_ref gre = sep [quotes (ppr (gre_name gre)) <> comma, pprNameProvenance gre]
1681
1682 shadowedNameWarn :: OccName -> [SDoc] -> SDoc
1683 shadowedNameWarn occ shadowed_locs
1684   = sep [ptext (sLit "This binding for") <+> quotes (ppr occ)
1685             <+> ptext (sLit "shadows the existing binding") <> plural shadowed_locs,
1686          nest 2 (vcat shadowed_locs)]
1687
1688 perhapsForallMsg :: SDoc
1689 perhapsForallMsg
1690   = vcat [ ptext (sLit "Perhaps you intended to use ExplicitForAll or similar flag")
1691          , ptext (sLit "to enable explicit-forall syntax: forall <tvs>. <type>")]
1692
1693 unknownSubordinateErr :: SDoc -> RdrName -> SDoc
1694 unknownSubordinateErr doc op    -- Doc is "method of class" or
1695                                 -- "field of constructor"
1696   = quotes (ppr op) <+> ptext (sLit "is not a (visible)") <+> doc
1697
1698 badOrigBinding :: RdrName -> SDoc
1699 badOrigBinding name
1700   = ptext (sLit "Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
1701         -- The rdrNameOcc is because we don't want to print Prelude.(,)
1702
1703 dupNamesErr :: Outputable n => (n -> SrcSpan) -> [n] -> RnM ()
1704 dupNamesErr get_loc names
1705   = addErrAt big_loc $
1706     vcat [ptext (sLit "Conflicting definitions for") <+> quotes (ppr (head names)),
1707           locations]
1708   where
1709     locs      = map get_loc names
1710     big_loc   = foldr1 combineSrcSpans locs
1711     locations = ptext (sLit "Bound at:") <+> vcat (map ppr (sort locs))
1712
1713 kindSigErr :: Outputable a => a -> SDoc
1714 kindSigErr thing
1715   = hang (ptext (sLit "Illegal kind signature for") <+> quotes (ppr thing))
1716        2 (ptext (sLit "Perhaps you intended to use KindSignatures"))
1717
1718 badQualBndrErr :: RdrName -> SDoc
1719 badQualBndrErr rdr_name
1720   = ptext (sLit "Qualified name in binding position:") <+> ppr rdr_name
1721
1722 opDeclErr :: RdrName -> SDoc
1723 opDeclErr n
1724   = hang (ptext (sLit "Illegal declaration of a type or class operator") <+> quotes (ppr n))
1725        2 (ptext (sLit "Use TypeOperators to declare operators in type and declarations"))
1726
1727 checkTupSize :: Int -> RnM ()
1728 checkTupSize tup_size
1729   | tup_size <= mAX_TUPLE_SIZE
1730   = return ()
1731   | otherwise
1732   = addErr (sep [ptext (sLit "A") <+> int tup_size <> ptext (sLit "-tuple is too large for GHC"),
1733                  nest 2 (parens (ptext (sLit "max size is") <+> int mAX_TUPLE_SIZE)),
1734                  nest 2 (ptext (sLit "Workaround: use nested tuples or define a data type"))])
1735 \end{code}
1736
1737
1738 %************************************************************************
1739 %*                                                                      *
1740 \subsection{Contexts for renaming errors}
1741 %*                                                                      *
1742 %************************************************************************
1743
1744 \begin{code}
1745
1746 data HsDocContext
1747   = TypeSigCtx SDoc
1748   | PatCtx
1749   | SpecInstSigCtx
1750   | DefaultDeclCtx
1751   | ForeignDeclCtx (Located RdrName)
1752   | DerivDeclCtx
1753   | RuleCtx FastString
1754   | TyDataCtx (Located RdrName)
1755   | TySynCtx (Located RdrName)
1756   | TyFamilyCtx (Located RdrName)
1757   | ConDeclCtx (Located RdrName)
1758   | ClassDeclCtx (Located RdrName)
1759   | ExprWithTySigCtx
1760   | TypBrCtx
1761   | HsTypeCtx
1762   | GHCiCtx
1763   | SpliceTypeCtx (LHsType RdrName)
1764   | ClassInstanceCtx
1765   | VectDeclCtx (Located RdrName)
1766   | GenericCtx SDoc   -- Maybe we want to use this more!
1767
1768 docOfHsDocContext :: HsDocContext -> SDoc
1769 docOfHsDocContext (GenericCtx doc) = doc
1770 docOfHsDocContext (TypeSigCtx doc) = text "In the type signature for" <+> doc
1771 docOfHsDocContext PatCtx = text "In a pattern type-signature"
1772 docOfHsDocContext SpecInstSigCtx = text "In a SPECIALISE instance pragma"
1773 docOfHsDocContext DefaultDeclCtx = text "In a `default' declaration"
1774 docOfHsDocContext (ForeignDeclCtx name) = ptext (sLit "In the foreign declaration for") <+> ppr name
1775 docOfHsDocContext DerivDeclCtx = text "In a deriving declaration"
1776 docOfHsDocContext (RuleCtx name) = text "In the transformation rule" <+> ftext name
1777 docOfHsDocContext (TyDataCtx tycon) = text "In the data type declaration for" <+> quotes (ppr tycon)
1778 docOfHsDocContext (TySynCtx name) = text "In the declaration for type synonym" <+> quotes (ppr name)
1779 docOfHsDocContext (TyFamilyCtx name) = text "In the declaration for type family" <+> quotes (ppr name)
1780 docOfHsDocContext (ConDeclCtx name) = text "In the definition of data constructor" <+> quotes (ppr name)
1781 docOfHsDocContext (ClassDeclCtx name) = text "In the declaration for class"     <+> ppr name
1782 docOfHsDocContext ExprWithTySigCtx = text "In an expression type signature"
1783 docOfHsDocContext TypBrCtx = ptext (sLit "In a Template-Haskell quoted type")
1784 docOfHsDocContext HsTypeCtx = text "In a type argument"
1785 docOfHsDocContext GHCiCtx = ptext (sLit "In GHCi input")
1786 docOfHsDocContext (SpliceTypeCtx hs_ty) = ptext (sLit "In the spliced type") <+> ppr hs_ty
1787 docOfHsDocContext ClassInstanceCtx = ptext (sLit "TcSplice.reifyInstances")
1788 docOfHsDocContext (VectDeclCtx tycon) = ptext (sLit "In the VECTORISE pragma for type constructor") <+> quotes (ppr tycon)
1789 \end{code}