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