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