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