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