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