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