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