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