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