Make Applicative a superclass of Monad
[ghc.git] / compiler / rename / RnNames.lhs
1 %
2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
3 %
4 \section[RnNames]{Extracting imported and top-level names in scope}
5
6 \begin{code}
7 {-# LANGUAGE CPP, NondecreasingIndentation #-}
8
9 module RnNames (
10         rnImports, getLocalNonValBinders,
11         rnExports, extendGlobalRdrEnvRn,
12         gresFromAvails,
13         reportUnusedNames,
14         checkConName
15     ) where
16
17 #include "HsVersions.h"
18
19 import DynFlags
20 import HsSyn
21 import TcEnv            ( isBrackStage )
22 import RnEnv
23 import RnHsDoc          ( rnHsDoc )
24 import LoadIface        ( loadSrcInterface )
25 import TcRnMonad
26 import PrelNames
27 import Module
28 import Name
29 import NameEnv
30 import NameSet
31 import Avail
32 import HscTypes
33 import RdrName
34 import Outputable
35 import Maybes
36 import SrcLoc
37 import BasicTypes      ( TopLevelFlag(..) )
38 import ErrUtils
39 import Util
40 import FastString
41 import ListSetOps
42
43 import Control.Monad
44 import Data.Map         ( Map )
45 import qualified Data.Map as Map
46 import Data.List        ( partition, (\\), find )
47 import qualified Data.Set as Set
48 import System.FilePath  ((</>))
49 import System.IO
50 \end{code}
51
52
53 %************************************************************************
54 %*                                                                      *
55 \subsection{rnImports}
56 %*                                                                      *
57 %************************************************************************
58
59 Note [Tracking Trust Transitively]
60 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
61 When we import a package as well as checking that the direct imports are safe
62 according to the rules outlined in the Note [HscMain . Safe Haskell Trust Check]
63 we must also check that these rules hold transitively for all dependent modules
64 and packages. Doing this without caching any trust information would be very
65 slow as we would need to touch all packages and interface files a module depends
66 on. To avoid this we make use of the property that if a modules Safe Haskell
67 mode changes, this triggers a recompilation from that module in the dependcy
68 graph. So we can just worry mostly about direct imports.
69
70 There is one trust property that can change for a package though without
71 recompliation being triggered: package trust. So we must check that all
72 packages a module tranitively depends on to be trusted are still trusted when
73 we are compiling this module (as due to recompilation avoidance some modules
74 below may not be considered trusted any more without recompilation being
75 triggered).
76
77 We handle this by augmenting the existing transitive list of packages a module M
78 depends on with a bool for each package that says if it must be trusted when the
79 module M is being checked for trust. This list of trust required packages for a
80 single import is gathered in the rnImportDecl function and stored in an
81 ImportAvails data structure. The union of these trust required packages for all
82 imports is done by the rnImports function using the combine function which calls
83 the plusImportAvails function that is a union operation for the ImportAvails
84 type. This gives us in an ImportAvails structure all packages required to be
85 trusted for the module we are currently compiling. Checking that these packages
86 are still trusted (and that direct imports are trusted) is done in
87 HscMain.checkSafeImports.
88
89 See the note below, [Trust Own Package] for a corner case in this method and
90 how its handled.
91
92
93 Note [Trust Own Package]
94 ~~~~~~~~~~~~~~~~~~~~~~~~
95 There is a corner case of package trust checking that the usual transitive check
96 doesn't cover. (For how the usual check operates see the Note [Tracking Trust
97 Transitively] below). The case is when you import a -XSafe module M and M
98 imports a -XTrustworthy module N. If N resides in a different package than M,
99 then the usual check works as M will record a package dependency on N's package
100 and mark it as required to be trusted. If N resides in the same package as M
101 though, then importing M should require its own package be trusted due to N
102 (since M is -XSafe so doesn't create this requirement by itself). The usual
103 check fails as a module doesn't record a package dependency of its own package.
104 So instead we now have a bool field in a modules interface file that simply
105 states if the module requires its own package to be trusted. This field avoids
106 us having to load all interface files that the module depends on to see if one
107 is trustworthy.
108
109
110 Note [Trust Transitive Property]
111 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
112 So there is an interesting design question in regards to transitive trust
113 checking. Say I have a module B compiled with -XSafe. B is dependent on a bunch
114 of modules and packages, some packages it requires to be trusted as its using
115 -XTrustworthy modules from them. Now if I have a module A that doesn't use safe
116 haskell at all and simply imports B, should A inherit all the the trust
117 requirements from B? Should A now also require that a package p is trusted since
118 B required it?
119
120 We currently say no but saying yes also makes sense. The difference is, if a
121 module M that doesn't use Safe Haskell imports a module N that does, should all
122 the trusted package requirements be dropped since M didn't declare that it cares
123 about Safe Haskell (so -XSafe is more strongly associated with the module doing
124 the importing) or should it be done still since the author of the module N that
125 uses Safe Haskell said they cared (so -XSafe is more strongly associated with
126 the module that was compiled that used it).
127
128 Going with yes is a simpler semantics we think and harder for the user to stuff
129 up but it does mean that Safe Haskell will affect users who don't care about
130 Safe Haskell as they might grab a package from Cabal which uses safe haskell (say
131 network) and that packages imports -XTrustworthy modules from another package
132 (say bytestring), so requires that package is trusted. The user may now get
133 compilation errors in code that doesn't do anything with Safe Haskell simply
134 because they are using the network package. They will have to call 'ghc-pkg
135 trust network' to get everything working. Due to this invasive nature of going
136 with yes we have gone with no for now.
137
138
139 \begin{code}
140 -- | Process Import Decls
141 -- Do the non SOURCE ones first, so that we get a helpful warning for SOURCE
142 -- ones that are unnecessary
143 rnImports :: [LImportDecl RdrName]
144           -> RnM ([LImportDecl Name], GlobalRdrEnv, ImportAvails, AnyHpcUsage)
145 rnImports imports = do
146     this_mod <- getModule
147     let (source, ordinary) = partition is_source_import imports
148         is_source_import d = ideclSource (unLoc d)
149     stuff1 <- mapAndReportM (rnImportDecl this_mod) ordinary
150     stuff2 <- mapAndReportM (rnImportDecl this_mod) source
151     -- Safe Haskell: See Note [Tracking Trust Transitively]
152     let (decls, rdr_env, imp_avails, hpc_usage) = combine (stuff1 ++ stuff2)
153     return (decls, rdr_env, imp_avails, hpc_usage)
154
155   where
156     combine :: [(LImportDecl Name,  GlobalRdrEnv, ImportAvails, AnyHpcUsage)]
157             -> ([LImportDecl Name], GlobalRdrEnv, ImportAvails, AnyHpcUsage)
158     combine = foldr plus ([], emptyGlobalRdrEnv, emptyImportAvails, False)
159
160     plus (decl,  gbl_env1, imp_avails1,hpc_usage1)
161          (decls, gbl_env2, imp_avails2,hpc_usage2)
162       = ( decl:decls,
163           gbl_env1 `plusGlobalRdrEnv` gbl_env2,
164           imp_avails1 `plusImportAvails` imp_avails2,
165           hpc_usage1 || hpc_usage2 )
166
167 rnImportDecl  :: Module -> LImportDecl RdrName
168               -> RnM (LImportDecl Name, GlobalRdrEnv, ImportAvails, AnyHpcUsage)
169 rnImportDecl this_mod
170              (L loc decl@(ImportDecl { ideclName = loc_imp_mod_name, ideclPkgQual = mb_pkg
171                                      , ideclSource = want_boot, ideclSafe = mod_safe
172                                      , ideclQualified = qual_only, ideclImplicit = implicit
173                                      , ideclAs = as_mod, ideclHiding = imp_details }))
174   = setSrcSpan loc $ do
175
176     when (isJust mb_pkg) $ do
177         pkg_imports <- xoptM Opt_PackageImports
178         when (not pkg_imports) $ addErr packageImportErr
179
180     -- If there's an error in loadInterface, (e.g. interface
181     -- file not found) we get lots of spurious errors from 'filterImports'
182     let imp_mod_name = unLoc loc_imp_mod_name
183         doc = ppr imp_mod_name <+> ptext (sLit "is directly imported")
184
185     -- Check for a missing import list (Opt_WarnMissingImportList also
186     -- checks for T(..) items but that is done in checkDodgyImport below)
187     case imp_details of
188         Just (False, _) -> return () -- Explicit import list
189         _  | implicit   -> return () -- Do not bleat for implicit imports
190            | qual_only  -> return ()
191            | otherwise  -> whenWOptM Opt_WarnMissingImportList $
192                            addWarn (missingImportListWarn imp_mod_name)
193
194     iface <- loadSrcInterface doc imp_mod_name want_boot mb_pkg
195
196     -- Compiler sanity check: if the import didn't say
197     -- {-# SOURCE #-} we should not get a hi-boot file
198     WARN( not want_boot && mi_boot iface, ppr imp_mod_name ) do
199
200     -- Issue a user warning for a redundant {- SOURCE -} import
201     -- NB that we arrange to read all the ordinary imports before
202     -- any of the {- SOURCE -} imports.
203     --
204     -- in --make and GHCi, the compilation manager checks for this,
205     -- and indeed we shouldn't do it here because the existence of
206     -- the non-boot module depends on the compilation order, which
207     -- is not deterministic.  The hs-boot test can show this up.
208     dflags <- getDynFlags
209     warnIf (want_boot && not (mi_boot iface) && isOneShot (ghcMode dflags))
210            (warnRedundantSourceImport imp_mod_name)
211     when (mod_safe && not (safeImportsOn dflags)) $
212         addErrAt loc (ptext (sLit "safe import can't be used as Safe Haskell isn't on!")
213                   $+$ ptext (sLit $ "please enable Safe Haskell through either "
214                                  ++ "Safe, Trustworthy or Unsafe"))
215
216     let imp_mod    = mi_module iface
217         warns      = mi_warns iface
218         orph_iface = mi_orphan iface
219         has_finsts = mi_finsts iface
220         deps       = mi_deps iface
221         trust      = getSafeMode $ mi_trust iface
222         trust_pkg  = mi_trust_pkg iface
223
224         qual_mod_name = as_mod `orElse` imp_mod_name
225         imp_spec  = ImpDeclSpec { is_mod = imp_mod_name, is_qual = qual_only,
226                                   is_dloc = loc, is_as = qual_mod_name }
227
228     -- filter the imports according to the import declaration
229     (new_imp_details, gres) <- filterImports iface imp_spec imp_details
230
231     let gbl_env = mkGlobalRdrEnv (filterOut from_this_mod gres)
232         from_this_mod gre = nameModule (gre_name gre) == this_mod
233         -- If the module exports anything defined in this module, just
234         -- ignore it.  Reason: otherwise it looks as if there are two
235         -- local definition sites for the thing, and an error gets
236         -- reported.  Easiest thing is just to filter them out up
237         -- front. This situation only arises if a module imports
238         -- itself, or another module that imported it.  (Necessarily,
239         -- this invoves a loop.)
240         --
241         -- We do this *after* filterImports, so that if you say
242         --      module A where
243         --         import B( AType )
244         --         type AType = ...
245         --
246         --      module B( AType ) where
247         --         import {-# SOURCE #-} A( AType )
248         --
249         -- then you won't get a 'B does not export AType' message.
250
251
252         -- Compute new transitive dependencies
253
254         orphans | orph_iface = ASSERT( not (imp_mod `elem` dep_orphs deps) )
255                                imp_mod : dep_orphs deps
256                 | otherwise  = dep_orphs deps
257
258         finsts | has_finsts = ASSERT( not (imp_mod `elem` dep_finsts deps) )
259                               imp_mod : dep_finsts deps
260                | otherwise  = dep_finsts deps
261
262         pkg = modulePackageKey (mi_module iface)
263
264         -- Does this import mean we now require our own pkg
265         -- to be trusted? See Note [Trust Own Package]
266         ptrust = trust == Sf_Trustworthy || trust_pkg
267
268         (dependent_mods, dependent_pkgs, pkg_trust_req)
269            | pkg == thisPackage dflags =
270                 -- Imported module is from the home package
271                 -- Take its dependent modules and add imp_mod itself
272                 -- Take its dependent packages unchanged
273                 --
274                 -- NB: (dep_mods deps) might include a hi-boot file
275                 -- for the module being compiled, CM. Do *not* filter
276                 -- this out (as we used to), because when we've
277                 -- finished dealing with the direct imports we want to
278                 -- know if any of them depended on CM.hi-boot, in
279                 -- which case we should do the hi-boot consistency
280                 -- check.  See LoadIface.loadHiBootInterface
281                 ((imp_mod_name, want_boot) : dep_mods deps, dep_pkgs deps, ptrust)
282
283            | otherwise =
284                 -- Imported module is from another package
285                 -- Dump the dependent modules
286                 -- Add the package imp_mod comes from to the dependent packages
287                 ASSERT2( not (pkg `elem` (map fst $ dep_pkgs deps))
288                        , ppr pkg <+> ppr (dep_pkgs deps) )
289                 ([], (pkg, False) : dep_pkgs deps, False)
290
291         -- True <=> import M ()
292         import_all = case imp_details of
293                         Just (is_hiding, ls) -> not is_hiding && null ls
294                         _                    -> False
295
296         -- should the import be safe?
297         mod_safe' = mod_safe
298                     || (not implicit && safeDirectImpsReq dflags)
299                     || (implicit && safeImplicitImpsReq dflags)
300
301         imports   = ImportAvails {
302                         imp_mods       = unitModuleEnv imp_mod
303                                         [(qual_mod_name, import_all, loc, mod_safe')],
304                         imp_orphs      = orphans,
305                         imp_finsts     = finsts,
306                         imp_dep_mods   = mkModDeps dependent_mods,
307                         imp_dep_pkgs   = map fst $ dependent_pkgs,
308                         -- Add in the imported modules trusted package
309                         -- requirements. ONLY do this though if we import the
310                         -- module as a safe import.
311                         -- See Note [Tracking Trust Transitively]
312                         -- and Note [Trust Transitive Property]
313                         imp_trust_pkgs = if mod_safe'
314                                              then map fst $ filter snd dependent_pkgs
315                                              else [],
316                         -- Do we require our own pkg to be trusted?
317                         -- See Note [Trust Own Package]
318                         imp_trust_own_pkg = pkg_trust_req
319                    }
320
321     -- Complain if we import a deprecated module
322     whenWOptM Opt_WarnWarningsDeprecations (
323        case warns of
324           WarnAll txt -> addWarn $ moduleWarn imp_mod_name txt
325           _           -> return ()
326      )
327
328     let new_imp_decl = L loc (decl { ideclSafe = mod_safe'
329                                    , ideclHiding = new_imp_details })
330
331     return (new_imp_decl, gbl_env, imports, mi_hpc iface)
332
333 warnRedundantSourceImport :: ModuleName -> SDoc
334 warnRedundantSourceImport mod_name
335   = ptext (sLit "Unnecessary {-# SOURCE #-} in the import of module")
336           <+> quotes (ppr mod_name)
337 \end{code}
338
339
340 %************************************************************************
341 %*                                                                      *
342 \subsection{importsFromLocalDecls}
343 %*                                                                      *
344 %************************************************************************
345
346 From the top-level declarations of this module produce
347         * the lexical environment
348         * the ImportAvails
349 created by its bindings.
350
351 Note [Top-level Names in Template Haskell decl quotes]
352 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
353 See also: Note [Interactively-bound Ids in GHCi] in HscTypes
354
355 Consider a Template Haskell declaration quotation like this:
356       module M where
357         f x = h [d| f = 3 |]
358 When renaming the declarations inside [d| ...|], we treat the
359 top level binders specially in two ways
360
361 1.  We give them an Internal name, not (as usual) an External one.
362     Otherwise the NameCache gets confused by a second allocation of
363     M.f.  (We used to invent a fake module ThFake to avoid this, but
364     that had other problems, notably in getting the correct answer for
365     nameIsLocalOrFrom in lookupFixity. So we now leave tcg_module
366     unaffected.)
367
368 2.  We make them *shadow* the outer bindings. If we don't do that,
369     we'll get a complaint when extending the GlobalRdrEnv, saying that
370     there are two bindings for 'f'.  There are several tricky points:
371
372     * This shadowing applies even if the binding for 'f' is in a
373       where-clause, and hence is in the *local* RdrEnv not the *global*
374       RdrEnv.
375
376     * The *qualified* name M.f from the enclosing module must certainly
377       still be available.  So we don't nuke it entirely; we just make
378       it seem like qualified import.
379
380     * We only shadow *External* names (which come from the main module)
381       Do not shadow *Inernal* names because in the bracket
382           [d| class C a where f :: a
383               f = 4 |]
384       rnSrcDecls will first call extendGlobalRdrEnvRn with C[f] from the
385       class decl, and *separately* extend the envt with the value binding.
386
387 3. We find out whether we are inside a [d| ... |] by testing the TH
388    stage. This is a slight hack, because the stage field was really
389    meant for the type checker, and here we are not interested in the
390    fields of Brack, hence the error thunks in thRnBrack.
391
392 \begin{code}
393 extendGlobalRdrEnvRn :: [AvailInfo]
394                      -> MiniFixityEnv
395                      -> RnM (TcGblEnv, TcLclEnv)
396 -- Updates both the GlobalRdrEnv and the FixityEnv
397 -- We return a new TcLclEnv only because we might have to
398 -- delete some bindings from it;
399 -- see Note [Top-level Names in Template Haskell decl quotes]
400
401 extendGlobalRdrEnvRn avails new_fixities
402   = do  { (gbl_env, lcl_env) <- getEnvs
403         ; stage <- getStage
404         ; isGHCi <- getIsGHCi
405         ; let rdr_env  = tcg_rdr_env gbl_env
406               fix_env  = tcg_fix_env gbl_env
407               th_bndrs = tcl_th_bndrs lcl_env
408               th_lvl   = thLevel stage
409
410               -- Delete new_occs from global and local envs
411               -- If we are in a TemplateHaskell decl bracket,
412               --    we are going to shadow them
413               -- See Note [Top-level Names in Template Haskell decl quotes]
414               inBracket = isBrackStage stage
415               lcl_env_TH = lcl_env { tcl_rdr = delLocalRdrEnvList (tcl_rdr lcl_env) new_occs }
416
417               lcl_env2 | inBracket = lcl_env_TH
418                        | otherwise = lcl_env
419
420               rdr_env2  = extendGlobalRdrEnv (isGHCi && not inBracket) rdr_env avails
421                  -- Shadowing only applies for GHCi decls outside brackets
422                  -- e.g. (Trac #4127a)
423                  --   ghci> runQ [d| class C a where f :: a
424                  --                  f = True
425                  --                  instance C Int where f = 2 |]
426                  --   We don't want the f=True to shadow the f class-op
427
428               lcl_env3 = lcl_env2 { tcl_th_bndrs = extendNameEnvList th_bndrs
429                                                        [ (n, (TopLevel, th_lvl))
430                                                        | n <- new_names ] }
431               fix_env' = foldl extend_fix_env fix_env new_names
432               dups = findLocalDupsRdrEnv rdr_env2 new_names
433
434               gbl_env' = gbl_env { tcg_rdr_env = rdr_env2, tcg_fix_env = fix_env' }
435
436         ; traceRn (text "extendGlobalRdrEnvRn 1" <+> (ppr avails $$ (ppr dups)))
437         ; mapM_ (addDupDeclErr . map gre_name) dups
438
439         ; traceRn (text "extendGlobalRdrEnvRn 2" <+> (pprGlobalRdrEnv True rdr_env2))
440         ; return (gbl_env', lcl_env3) }
441   where
442     new_names = concatMap availNames avails
443     new_occs  = map nameOccName new_names
444
445     -- If there is a fixity decl for the gre, add it to the fixity env
446     extend_fix_env fix_env name
447       | Just (L _ fi) <- lookupFsEnv new_fixities (occNameFS occ)
448       = extendNameEnv fix_env name (FixItem occ fi)
449       | otherwise
450       = fix_env
451       where
452         occ  = nameOccName name
453 \end{code}
454
455 @getLocalDeclBinders@ returns the names for an @HsDecl@.  It's
456 used for source code.
457
458         *** See "THE NAMING STORY" in HsDecls ****
459
460 \begin{code}
461 getLocalNonValBinders :: MiniFixityEnv -> HsGroup RdrName
462                       -> RnM ((TcGblEnv, TcLclEnv), NameSet)
463 -- Get all the top-level binders bound the group *except*
464 -- for value bindings, which are treated separately
465 -- Specifically we return AvailInfo for
466 --      type decls (incl constructors and record selectors)
467 --      class decls (including class ops)
468 --      associated types
469 --      foreign imports
470 --      (in hs-boot files) value signatures
471
472 getLocalNonValBinders fixity_env
473      (HsGroup { hs_valds  = val_binds,
474                 hs_tyclds = tycl_decls,
475                 hs_instds = inst_decls,
476                 hs_fords  = foreign_decls })
477   = do  { -- Process all type/class decls *except* family instances
478         ; tc_avails <- mapM new_tc (tyClGroupConcat tycl_decls)
479         ; traceRn (text "getLocalNonValBinders 1" <+> ppr tc_avails)
480         ; envs <- extendGlobalRdrEnvRn tc_avails fixity_env
481         ; setEnvs envs $ do {
482             -- Bring these things into scope first
483             -- See Note [Looking up family names in family instances]
484
485           -- Process all family instances
486           -- to bring new data constructors into scope
487         ; nti_avails <- concatMapM new_assoc inst_decls
488
489           -- Finish off with value binders:
490           --    foreign decls for an ordinary module
491           --    type sigs in case of a hs-boot file only
492         ; is_boot <- tcIsHsBoot
493         ; let val_bndrs | is_boot   = hs_boot_sig_bndrs
494                         | otherwise = for_hs_bndrs
495         ; val_avails <- mapM new_simple val_bndrs
496
497         ; let avails    = nti_avails ++ val_avails
498               new_bndrs = availsToNameSet avails `unionNameSets`
499                           availsToNameSet tc_avails
500         ; traceRn (text "getLocalNonValBinders 2" <+> ppr avails)
501         ; envs <- extendGlobalRdrEnvRn avails fixity_env
502         ; return (envs, new_bndrs) } }
503   where
504     for_hs_bndrs :: [Located RdrName]
505     for_hs_bndrs = [ L decl_loc (unLoc nm)
506                    | L decl_loc (ForeignImport nm _ _ _) <- foreign_decls]
507
508     -- In a hs-boot file, the value binders come from the
509     --  *signatures*, and there should be no foreign binders
510     hs_boot_sig_bndrs = [ L decl_loc (unLoc n)
511                         | L decl_loc (TypeSig ns _) <- val_sigs, n <- ns]
512     ValBindsIn _ val_sigs = val_binds
513
514       -- the SrcSpan attached to the input should be the span of the
515       -- declaration, not just the name
516     new_simple :: Located RdrName -> RnM AvailInfo
517     new_simple rdr_name = do{ nm <- newTopSrcBinder rdr_name
518                             ; return (Avail nm) }
519
520     new_tc tc_decl              -- NOT for type/data instances
521         = do { let bndrs = hsLTyClDeclBinders tc_decl
522              ; names@(main_name : _) <- mapM newTopSrcBinder bndrs
523              ; return (AvailTC main_name names) }
524
525     new_assoc :: LInstDecl RdrName -> RnM [AvailInfo]
526     new_assoc (L _ (TyFamInstD {})) = return []
527       -- type instances don't bind new names
528
529     new_assoc (L _ (DataFamInstD { dfid_inst = d }))
530       = do { avail <- new_di Nothing d
531            ; return [avail] }
532     new_assoc (L _ (ClsInstD { cid_inst = ClsInstDecl
533                              { cid_poly_ty = inst_ty
534                              , cid_datafam_insts = adts } }))
535       | Just (_, _, L loc cls_rdr, _) <- splitLHsInstDeclTy_maybe inst_ty
536       = do { cls_nm <- setSrcSpan loc $ lookupGlobalOccRn cls_rdr
537            ; mapM (new_di (Just cls_nm) . unLoc) adts }
538       | otherwise
539       = return []     -- Do not crash on ill-formed instances
540                       -- Eg   instance !Show Int   Trac #3811c
541
542     new_di :: Maybe Name -> DataFamInstDecl RdrName -> RnM AvailInfo
543     new_di mb_cls ti_decl
544         = do { main_name <- lookupFamInstName mb_cls (dfid_tycon ti_decl)
545              ; sub_names <- mapM newTopSrcBinder (hsDataFamInstBinders ti_decl)
546              ; return (AvailTC (unLoc main_name) sub_names) }
547                         -- main_name is not bound here!
548 \end{code}
549
550 Note [Looking up family names in family instances]
551 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
552 Consider
553
554   module M where
555     type family T a :: *
556     type instance M.T Int = Bool
557
558 We might think that we can simply use 'lookupOccRn' when processing the type
559 instance to look up 'M.T'.  Alas, we can't!  The type family declaration is in
560 the *same* HsGroup as the type instance declaration.  Hence, as we are
561 currently collecting the binders declared in that HsGroup, these binders will
562 not have been added to the global environment yet.
563
564 Solution is simple: process the type family declarations first, extend
565 the environment, and then process the type instances.
566
567
568 %************************************************************************
569 %*                                                                      *
570 \subsection{Filtering imports}
571 %*                                                                      *
572 %************************************************************************
573
574 @filterImports@ takes the @ExportEnv@ telling what the imported module makes
575 available, and filters it through the import spec (if any).
576
577 Note [Dealing with imports]
578 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
579 For import M( ies ), we take the mi_exports of M, and make 
580    imp_occ_env :: OccEnv (Name, AvailInfo, Maybe Name) 
581 One entry for each Name that M exports; the AvailInfo describes just
582 that Name.   
583
584 The situation is made more complicated by associated types. E.g.
585    module M where
586      class    C a    where { data T a }
587      instance C Int  where { data T Int = T1 | T2 }
588      instance C Bool where { data T Int = T3 }
589 Then M's export_avails are (recall the AvailTC invariant from Avails.hs)
590   C(C,T), T(T,T1,T2,T3)
591 Notice that T appears *twice*, once as a child and once as a parent.
592 From this we construct the imp_occ_env
593    C  -> (C,  C(C,T),        Nothing
594    T  -> (T,  T(T,T1,T2,T3), Just C)
595    T1 -> (T1, T(T1,T2,T3),   Nothing)   -- similarly T2,T3
596
597 Note that the imp_occ_env will have entries for data constructors too,
598 although we never look up data constructors.
599
600 \begin{code}
601 filterImports :: ModIface
602               -> ImpDeclSpec                    -- The span for the entire import decl
603               -> Maybe (Bool, [LIE RdrName])    -- Import spec; True => hiding
604               -> RnM (Maybe (Bool, [LIE Name]), -- Import spec w/ Names
605                       [GlobalRdrElt])           -- Same again, but in GRE form
606 filterImports iface decl_spec Nothing
607   = return (Nothing, gresFromAvails prov (mi_exports iface))
608   where
609     prov = Imported [ImpSpec { is_decl = decl_spec, is_item = ImpAll }]
610
611
612 filterImports iface decl_spec (Just (want_hiding, import_items))
613   = do  -- check for errors, convert RdrNames to Names
614         items1 <- mapM lookup_lie import_items
615
616         let items2 :: [(LIE Name, AvailInfo)]
617             items2 = concat items1
618                 -- NB the AvailInfo may have duplicates, and several items
619                 --    for the same parent; e.g N(x) and N(y)
620
621             names  = availsToNameSet (map snd items2)
622             keep n = not (n `elemNameSet` names)
623             pruned_avails = filterAvails keep all_avails
624             hiding_prov = Imported [ImpSpec { is_decl = decl_spec, is_item = ImpAll }]
625
626             gres | want_hiding = gresFromAvails hiding_prov pruned_avails
627                  | otherwise   = concatMap (gresFromIE decl_spec) items2
628
629         return (Just (want_hiding, map fst items2), gres)
630   where
631     all_avails = mi_exports iface
632
633         -- See Note [Dealing with imports]
634     imp_occ_env :: OccEnv (Name,        -- the name
635                            AvailInfo,   -- the export item providing the name
636                            Maybe Name)  -- the parent of associated types
637     imp_occ_env = mkOccEnv_C combine [ (nameOccName n, (n, a, Nothing))
638                                      | a <- all_avails, n <- availNames a]
639       where
640         -- See example in Note [Dealing with imports]
641         -- 'combine' is only called for associated types which appear twice
642         -- in the all_avails. In the example, we combine
643         --    T(T,T1,T2,T3) and C(C,T)  to give   (T, T(T,T1,T2,T3), Just C)
644         combine (name1, a1@(AvailTC p1 _), mp1)
645                 (name2, a2@(AvailTC p2 _), mp2)
646           = ASSERT( name1 == name2 && isNothing mp1 && isNothing mp2 )
647             if p1 == name1 then (name1, a1, Just p2)
648                            else (name1, a2, Just p1)
649         combine x y = pprPanic "filterImports/combine" (ppr x $$ ppr y)
650
651     lookup_name :: RdrName -> IELookupM (Name, AvailInfo, Maybe Name)
652     lookup_name rdr | isQual rdr              = failLookupWith (QualImportError rdr)
653                     | Just succ <- mb_success = return succ
654                     | otherwise               = failLookupWith BadImport
655       where
656         mb_success = lookupOccEnv imp_occ_env (rdrNameOcc rdr)
657
658     lookup_lie :: LIE RdrName -> TcRn [(LIE Name, AvailInfo)]
659     lookup_lie (L loc ieRdr)
660         = do (stuff, warns) <- setSrcSpan loc $
661                                liftM (fromMaybe ([],[])) $
662                                run_lookup (lookup_ie ieRdr)
663              mapM_ emit_warning warns
664              return [ (L loc ie, avail) | (ie,avail) <- stuff ]
665         where
666             -- Warn when importing T(..) if T was exported abstractly
667             emit_warning (DodgyImport n) = whenWOptM Opt_WarnDodgyImports $
668               addWarn (dodgyImportWarn n)
669             emit_warning MissingImportList = whenWOptM Opt_WarnMissingImportList $
670               addWarn (missingImportListItem ieRdr)
671             emit_warning BadImportW = whenWOptM Opt_WarnDodgyImports $
672               addWarn (lookup_err_msg BadImport)
673
674             run_lookup :: IELookupM a -> TcRn (Maybe a)
675             run_lookup m = case m of
676               Failed err -> addErr (lookup_err_msg err) >> return Nothing
677               Succeeded a -> return (Just a)
678
679             lookup_err_msg err = case err of
680               BadImport -> badImportItemErr iface decl_spec ieRdr all_avails
681               IllegalImport -> illegalImportItemErr
682               QualImportError rdr -> qualImportItemErr rdr
683
684         -- For each import item, we convert its RdrNames to Names,
685         -- and at the same time construct an AvailInfo corresponding
686         -- to what is actually imported by this item.
687         -- Returns Nothing on error.
688         -- We return a list here, because in the case of an import
689         -- item like C, if we are hiding, then C refers to *both* a
690         -- type/class and a data constructor.  Moreover, when we import
691         -- data constructors of an associated family, we need separate
692         -- AvailInfos for the data constructors and the family (as they have
693         -- different parents).  See Note [Dealing with imports]
694     lookup_ie :: IE RdrName -> IELookupM ([(IE Name, AvailInfo)], [IELookupWarning])
695     lookup_ie ie = handle_bad_import $ do
696       case ie of
697         IEVar n -> do
698             (name, avail, _) <- lookup_name n
699             return ([(IEVar name, trimAvail avail name)], [])
700
701         IEThingAll tc -> do
702             (name, avail@(AvailTC name2 subs), mb_parent) <- lookup_name tc
703             let warns | null (drop 1 subs)      = [DodgyImport tc]
704                       | not (is_qual decl_spec) = [MissingImportList]
705                       | otherwise               = []
706             case mb_parent of
707               -- non-associated ty/cls
708               Nothing     -> return ([(IEThingAll name, avail)], warns)
709               -- associated ty
710               Just parent -> return ([(IEThingAll name,
711                                        AvailTC name2 (subs \\ [name])),
712                                       (IEThingAll name, AvailTC parent [name])],
713                                      warns)
714
715         IEThingAbs tc
716             | want_hiding   -- hiding ( C )
717                        -- Here the 'C' can be a data constructor
718                        --  *or* a type/class, or even both
719             -> let tc_name = lookup_name tc
720                    dc_name = lookup_name (setRdrNameSpace tc srcDataName)
721                in
722                case catIELookupM [ tc_name, dc_name ] of
723                  []    -> failLookupWith BadImport
724                  names -> return ([mkIEThingAbs name | name <- names], [])
725             | otherwise
726             -> do nameAvail <- lookup_name tc
727                   return ([mkIEThingAbs nameAvail], [])
728
729         IEThingWith rdr_tc rdr_ns -> do
730            (name, AvailTC _ ns, mb_parent) <- lookup_name rdr_tc
731
732            -- Look up the children in the sub-names of the parent
733            let subnames = case ns of   -- The tc is first in ns, 
734                             [] -> []   -- if it is there at all
735                                        -- See the AvailTC Invariant in Avail.hs
736                             (n1:ns1) | n1 == name -> ns1
737                                      | otherwise  -> ns
738                mb_children = lookupChildren subnames rdr_ns
739
740            children <- if any isNothing mb_children
741                        then failLookupWith BadImport
742                        else return (catMaybes mb_children)
743
744            case mb_parent of
745              -- non-associated ty/cls
746              Nothing     -> return ([(IEThingWith name children,
747                                       AvailTC name (name:children))],
748                                     [])
749              -- associated ty
750              Just parent -> return ([(IEThingWith name children,
751                                       AvailTC name children),
752                                      (IEThingWith name children,
753                                       AvailTC parent [name])],
754                                     [])
755
756         _other -> failLookupWith IllegalImport
757         -- could be IEModuleContents, IEGroup, IEDoc, IEDocNamed
758         -- all errors.
759
760       where
761         mkIEThingAbs (n, av, Nothing    ) = (IEThingAbs n, trimAvail av n)
762         mkIEThingAbs (n, _,  Just parent) = (IEThingAbs n, AvailTC parent [n])
763
764         handle_bad_import m = catchIELookup m $ \err -> case err of
765           BadImport | want_hiding -> return ([], [BadImportW])
766           _                       -> failLookupWith err
767
768 type IELookupM = MaybeErr IELookupError
769
770 data IELookupWarning
771   = BadImportW
772   | MissingImportList
773   | DodgyImport RdrName
774   -- NB. use the RdrName for reporting a "dodgy" import
775
776 data IELookupError
777   = QualImportError RdrName
778   | BadImport
779   | IllegalImport
780
781 failLookupWith :: IELookupError -> IELookupM a
782 failLookupWith err = Failed err
783
784 catchIELookup :: IELookupM a -> (IELookupError -> IELookupM a) -> IELookupM a
785 catchIELookup m h = case m of
786   Succeeded r -> return r
787   Failed err  -> h err
788
789 catIELookupM :: [IELookupM a] -> [a]
790 catIELookupM ms = [ a | Succeeded a <- ms ]
791 \end{code}
792
793 %************************************************************************
794 %*                                                                      *
795 \subsection{Import/Export Utils}
796 %*                                                                      *
797 %************************************************************************
798
799 \begin{code}
800 greExportAvail :: GlobalRdrElt -> AvailInfo
801 greExportAvail gre
802   = case gre_par gre of
803       ParentIs p                  -> AvailTC p [me]
804       NoParent   | isTyConName me -> AvailTC me [me]
805                  | otherwise      -> Avail   me
806   where
807     me = gre_name gre
808
809 plusAvail :: AvailInfo -> AvailInfo -> AvailInfo
810 plusAvail a1 a2
811   | debugIsOn && availName a1 /= availName a2
812   = pprPanic "RnEnv.plusAvail names differ" (hsep [ppr a1,ppr a2])
813 plusAvail a1@(Avail {})         (Avail {})      = a1
814 plusAvail (AvailTC _ [])        a2@(AvailTC {}) = a2
815 plusAvail a1@(AvailTC {})       (AvailTC _ [])  = a1
816 plusAvail (AvailTC n1 (s1:ss1)) (AvailTC n2 (s2:ss2))
817   = case (n1==s1, n2==s2) of  -- Maintain invariant the parent is first
818        (True,True)   -> AvailTC n1 (s1 : (ss1 `unionLists` ss2))
819        (True,False)  -> AvailTC n1 (s1 : (ss1 `unionLists` (s2:ss2)))
820        (False,True)  -> AvailTC n1 (s2 : ((s1:ss1) `unionLists` ss2))
821        (False,False) -> AvailTC n1 ((s1:ss1) `unionLists` (s2:ss2))
822 plusAvail a1 a2 = pprPanic "RnEnv.plusAvail" (hsep [ppr a1,ppr a2])
823
824 trimAvail :: AvailInfo -> Name -> AvailInfo
825 trimAvail (Avail n)      _ = Avail n
826 trimAvail (AvailTC n ns) m = ASSERT( m `elem` ns) AvailTC n [m]
827
828 -- | filters 'AvailInfo's by the given predicate
829 filterAvails  :: (Name -> Bool) -> [AvailInfo] -> [AvailInfo]
830 filterAvails keep avails = foldr (filterAvail keep) [] avails
831
832 -- | filters an 'AvailInfo' by the given predicate
833 filterAvail :: (Name -> Bool) -> AvailInfo -> [AvailInfo] -> [AvailInfo]
834 filterAvail keep ie rest =
835   case ie of
836     Avail n | keep n    -> ie : rest
837             | otherwise -> rest
838     AvailTC tc ns ->
839         let left = filter keep ns in
840         if null left then rest else AvailTC tc left : rest
841
842 -- | Given an import\/export spec, construct the appropriate 'GlobalRdrElt's.
843 gresFromIE :: ImpDeclSpec -> (LIE Name, AvailInfo) -> [GlobalRdrElt]
844 gresFromIE decl_spec (L loc ie, avail)
845   = gresFromAvail prov_fn avail
846   where
847     is_explicit = case ie of
848                     IEThingAll name -> \n -> n == name
849                     _               -> \_ -> True
850     prov_fn name = Imported [imp_spec]
851         where
852           imp_spec  = ImpSpec { is_decl = decl_spec, is_item = item_spec }
853           item_spec = ImpSome { is_explicit = is_explicit name, is_iloc = loc }
854
855 mkChildEnv :: [GlobalRdrElt] -> NameEnv [Name]
856 mkChildEnv gres = foldr add emptyNameEnv gres
857     where
858         add (GRE { gre_name = n, gre_par = ParentIs p }) env = extendNameEnv_Acc (:) singleton env p n
859         add _                                            env = env
860
861 findChildren :: NameEnv [Name] -> Name -> [Name]
862 findChildren env n = lookupNameEnv env n `orElse` []
863
864 lookupChildren :: [Name] -> [RdrName] -> [Maybe Name]
865 -- (lookupChildren all_kids rdr_items) maps each rdr_item to its
866 -- corresponding Name all_kids, if the former exists
867 -- The matching is done by FastString, not OccName, so that
868 --    Cls( meth, AssocTy )
869 -- will correctly find AssocTy among the all_kids of Cls, even though
870 -- the RdrName for AssocTy may have a (bogus) DataName namespace
871 -- (Really the rdr_items should be FastStrings in the first place.)
872 lookupChildren all_kids rdr_items
873   = map (lookupFsEnv kid_env . occNameFS . rdrNameOcc) rdr_items
874   where
875     kid_env = mkFsEnv [(occNameFS (nameOccName n), n) | n <- all_kids]
876
877 -- | Combines 'AvailInfo's from the same family
878 -- 'avails' may have several items with the same availName
879 -- E.g  import Ix( Ix(..), index )
880 -- will give Ix(Ix,index,range) and Ix(index)
881 -- We want to combine these; addAvail does that
882 nubAvails :: [AvailInfo] -> [AvailInfo]
883 nubAvails avails = nameEnvElts (foldl add emptyNameEnv avails)
884   where
885     add env avail = extendNameEnv_C plusAvail env (availName avail) avail
886 \end{code}
887
888
889 %************************************************************************
890 %*                                                                      *
891 \subsection{Export list processing}
892 %*                                                                      *
893 %************************************************************************
894
895 Processing the export list.
896
897 You might think that we should record things that appear in the export
898 list as ``occurrences'' (using @addOccurrenceName@), but you'd be
899 wrong.  We do check (here) that they are in scope, but there is no
900 need to slurp in their actual declaration (which is what
901 @addOccurrenceName@ forces).
902
903 Indeed, doing so would big trouble when compiling @PrelBase@, because
904 it re-exports @GHC@, which includes @takeMVar#@, whose type includes
905 @ConcBase.StateAndSynchVar#@, and so on...
906
907 Note [Exports of data families]
908 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
909 Suppose you see (Trac #5306)
910         module M where
911           import X( F )
912           data instance F Int = FInt
913 What does M export?  AvailTC F [FInt]
914                   or AvailTC F [F,FInt]?
915 The former is strictly right because F isn't defined in this module.
916 But then you can never do an explicit import of M, thus
917     import M( F( FInt ) )
918 because F isn't exported by M.  Nor can you import FInt alone from here
919     import M( FInt )
920 because we don't have syntax to support that.  (It looks like an import of
921 the type FInt.)
922
923 At one point I implemented a compromise:
924   * When constructing exports with no export list, or with module M(
925     module M ), we add the parent to the exports as well.
926   * But not when you see module M( f ), even if f is a
927     class method with a parent.
928   * Nor when you see module M( module N ), with N /= M.
929
930 But the compromise seemed too much of a hack, so we backed it out.
931 You just have to use an explicit export list:
932     module M( F(..) ) where ...
933
934 \begin{code}
935 type ExportAccum        -- The type of the accumulating parameter of
936                         -- the main worker function in rnExports
937      = ([LIE Name],             -- Export items with Names
938         ExportOccMap,           -- Tracks exported occurrence names
939         [AvailInfo])            -- The accumulated exported stuff
940                                 --   Not nub'd!
941
942 emptyExportAccum :: ExportAccum
943 emptyExportAccum = ([], emptyOccEnv, [])
944
945 type ExportOccMap = OccEnv (Name, IE RdrName)
946         -- Tracks what a particular exported OccName
947         --   in an export list refers to, and which item
948         --   it came from.  It's illegal to export two distinct things
949         --   that have the same occurrence name
950
951 rnExports :: Bool       -- False => no 'module M(..) where' header at all
952           -> Maybe [LIE RdrName]        -- Nothing => no explicit export list
953           -> TcGblEnv
954           -> RnM TcGblEnv
955
956         -- Complains if two distinct exports have same OccName
957         -- Warns about identical exports.
958         -- Complains about exports items not in scope
959
960 rnExports explicit_mod exports
961           tcg_env@(TcGblEnv { tcg_mod     = this_mod,
962                               tcg_rdr_env = rdr_env,
963                               tcg_imports = imports })
964  = unsetWOptM Opt_WarnWarningsDeprecations $
965        -- Do not report deprecations arising from the export
966        -- list, to avoid bleating about re-exporting a deprecated
967        -- thing (especially via 'module Foo' export item)
968    do   {
969         -- If the module header is omitted altogether, then behave
970         -- as if the user had written "module Main(main) where..."
971         -- EXCEPT in interactive mode, when we behave as if he had
972         -- written "module Main where ..."
973         -- Reason: don't want to complain about 'main' not in scope
974         --         in interactive mode
975         ; dflags <- getDynFlags
976         ; let real_exports
977                  | explicit_mod = exports
978                  | ghcLink dflags == LinkInMemory = Nothing
979                  | otherwise = Just [noLoc (IEVar main_RDR_Unqual)]
980                         -- ToDo: the 'noLoc' here is unhelpful if 'main'
981                         --       turns out to be out of scope
982
983         ; (rn_exports, avails) <- exports_from_avail real_exports rdr_env imports this_mod
984         ; let final_avails = nubAvails avails    -- Combine families
985
986         ; traceRn (text "rnExports: Exports:" <+> ppr final_avails)
987
988         ; return (tcg_env { tcg_exports    = final_avails,
989                             tcg_rn_exports = case tcg_rn_exports tcg_env of
990                                                 Nothing -> Nothing
991                                                 Just _  -> rn_exports,
992                             tcg_dus = tcg_dus tcg_env `plusDU`
993                                       usesOnly (availsToNameSet final_avails) }) }
994
995 exports_from_avail :: Maybe [LIE RdrName]
996                          -- Nothing => no explicit export list
997                    -> GlobalRdrEnv
998                    -> ImportAvails
999                    -> Module
1000                    -> RnM (Maybe [LIE Name], [AvailInfo])
1001
1002 exports_from_avail Nothing rdr_env _imports _this_mod
1003  = -- The same as (module M) where M is the current module name,
1004    -- so that's how we handle it.
1005    let
1006        avails = [ greExportAvail gre
1007                 | gre <- globalRdrEnvElts rdr_env
1008                 , isLocalGRE gre ]
1009    in
1010    return (Nothing, avails)
1011
1012 exports_from_avail (Just rdr_items) rdr_env imports this_mod
1013   = do (ie_names, _, exports) <- foldlM do_litem emptyExportAccum rdr_items
1014
1015        return (Just ie_names, exports)
1016   where
1017     do_litem :: ExportAccum -> LIE RdrName -> RnM ExportAccum
1018     do_litem acc lie = setSrcSpan (getLoc lie) (exports_from_item acc lie)
1019
1020     kids_env :: NameEnv [Name]  -- Maps a parent to its in-scope children
1021     kids_env = mkChildEnv (globalRdrEnvElts rdr_env)
1022
1023     imported_modules = [ qual_name
1024                        | xs <- moduleEnvElts $ imp_mods imports,
1025                          (qual_name, _, _, _) <- xs ]
1026
1027     exports_from_item :: ExportAccum -> LIE RdrName -> RnM ExportAccum
1028     exports_from_item acc@(ie_names, occs, exports)
1029                       (L loc (IEModuleContents mod))
1030         | let earlier_mods = [ mod | (L _ (IEModuleContents mod)) <- ie_names ]
1031         , mod `elem` earlier_mods    -- Duplicate export of M
1032         = do { warn_dup_exports <- woptM Opt_WarnDuplicateExports ;
1033                warnIf warn_dup_exports (dupModuleExport mod) ;
1034                return acc }
1035
1036         | otherwise
1037         = do { implicit_prelude <- xoptM Opt_ImplicitPrelude
1038              ; warnDodgyExports <- woptM Opt_WarnDodgyExports
1039              ; let { exportValid = (mod `elem` imported_modules)
1040                                 || (moduleName this_mod == mod)
1041                    ; gres = filter (isModuleExported implicit_prelude mod)
1042                                    (globalRdrEnvElts rdr_env)
1043                    ; new_exports = map greExportAvail gres
1044                    ; names       = map gre_name gres }
1045
1046              ; checkErr exportValid (moduleNotImported mod)
1047              ; warnIf (warnDodgyExports && exportValid && null names)
1048                       (nullModuleExport mod)
1049
1050              ; addUsedRdrNames (concat [ [mkRdrQual mod occ, mkRdrUnqual occ]
1051                                        | occ <- map nameOccName names ])
1052                         -- The qualified and unqualified version of all of
1053                         -- these names are, in effect, used by this export
1054
1055              ; occs' <- check_occs (IEModuleContents mod) occs names
1056                       -- This check_occs not only finds conflicts
1057                       -- between this item and others, but also
1058                       -- internally within this item.  That is, if
1059                       -- 'M.x' is in scope in several ways, we'll have
1060                       -- several members of mod_avails with the same
1061                       -- OccName.
1062              ; traceRn (vcat [ text "export mod" <+> ppr mod
1063                              , ppr new_exports ])
1064              ; return (L loc (IEModuleContents mod) : ie_names,
1065                        occs', new_exports ++ exports) }
1066
1067     exports_from_item acc@(lie_names, occs, exports) (L loc ie)
1068         | isDoc ie
1069         = do new_ie <- lookup_doc_ie ie
1070              return (L loc new_ie : lie_names, occs, exports)
1071
1072         | otherwise
1073         = do (new_ie, avail) <- lookup_ie ie
1074              if isUnboundName (ieName new_ie)
1075                   then return acc    -- Avoid error cascade
1076                   else do
1077
1078              occs' <- check_occs ie occs (availNames avail)
1079
1080              return (L loc new_ie : lie_names, occs', avail : exports)
1081
1082     -------------
1083     lookup_ie :: IE RdrName -> RnM (IE Name, AvailInfo)
1084     lookup_ie (IEVar rdr)
1085         = do gre <- lookupGreRn rdr
1086              return (IEVar (gre_name gre), greExportAvail gre)
1087
1088     lookup_ie (IEThingAbs rdr)
1089         = do gre <- lookupGreRn rdr
1090              let name = gre_name gre
1091                  avail = greExportAvail gre
1092              return (IEThingAbs name, avail)
1093
1094     lookup_ie ie@(IEThingAll rdr)
1095         = do name <- lookupGlobalOccRn rdr
1096              let kids = findChildren kids_env name
1097              addUsedKids rdr kids
1098              warnDodgyExports <- woptM Opt_WarnDodgyExports
1099              when (null kids) $
1100                   if isTyConName name
1101                   then when warnDodgyExports $ addWarn (dodgyExportWarn name)
1102                   else -- This occurs when you export T(..), but
1103                        -- only import T abstractly, or T is a synonym.
1104                        addErr (exportItemErr ie)
1105
1106              return (IEThingAll name, AvailTC name (name:kids))
1107
1108     lookup_ie ie@(IEThingWith rdr sub_rdrs)
1109         = do name <- lookupGlobalOccRn rdr
1110              if isUnboundName name
1111                 then return (IEThingWith name [], AvailTC name [name])
1112                 else do
1113              let mb_names = lookupChildren (findChildren kids_env name) sub_rdrs
1114              if any isNothing mb_names
1115                 then do addErr (exportItemErr ie)
1116                         return (IEThingWith name [], AvailTC name [name])
1117                 else do let names = catMaybes mb_names
1118                         addUsedKids rdr names
1119                         return (IEThingWith name names, AvailTC name (name:names))
1120
1121     lookup_ie _ = panic "lookup_ie"    -- Other cases covered earlier
1122
1123     -------------
1124     lookup_doc_ie :: IE RdrName -> RnM (IE Name)
1125     lookup_doc_ie (IEGroup lev doc) = do rn_doc <- rnHsDoc doc
1126                                          return (IEGroup lev rn_doc)
1127     lookup_doc_ie (IEDoc doc)       = do rn_doc <- rnHsDoc doc
1128                                          return (IEDoc rn_doc)
1129     lookup_doc_ie (IEDocNamed str)  = return (IEDocNamed str)
1130     lookup_doc_ie _ = panic "lookup_doc_ie"    -- Other cases covered earlier
1131
1132     -- In an export item M.T(A,B,C), we want to treat the uses of
1133     -- A,B,C as if they were M.A, M.B, M.C
1134     addUsedKids parent_rdr kid_names
1135        = addUsedRdrNames $ map (mk_kid_rdr . nameOccName) kid_names
1136        where
1137          mk_kid_rdr = case isQual_maybe parent_rdr of
1138                          Nothing           -> mkRdrUnqual
1139                          Just (modName, _) -> mkRdrQual modName
1140
1141 isDoc :: IE RdrName -> Bool
1142 isDoc (IEDoc _)      = True
1143 isDoc (IEDocNamed _) = True
1144 isDoc (IEGroup _ _)  = True
1145 isDoc _ = False
1146
1147 -------------------------------
1148 isModuleExported :: Bool -> ModuleName -> GlobalRdrElt -> Bool
1149 -- True if the thing is in scope *both* unqualified, *and* with qualifier M
1150 isModuleExported implicit_prelude mod (GRE { gre_name = name, gre_prov = prov })
1151   | implicit_prelude && isBuiltInSyntax name = False
1152         -- Optimisation: filter out names for built-in syntax
1153         -- They just clutter up the environment (esp tuples), and the parser
1154         -- will generate Exact RdrNames for them, so the cluttered
1155         -- envt is no use.  To avoid doing this filter all the time,
1156         -- we use -XNoImplicitPrelude as a clue that the filter is
1157         -- worth while.  Really, it's only useful for GHC.Base and GHC.Tuple.
1158         --
1159         -- It's worth doing because it makes the environment smaller for
1160         -- every module that imports the Prelude
1161   | otherwise
1162   = case prov of
1163         LocalDef | Just name_mod <- nameModule_maybe name
1164                  -> moduleName name_mod == mod
1165                  | otherwise -> False
1166         Imported is -> any unQualSpecOK is && any (qualSpecOK mod) is
1167
1168 -------------------------------
1169 check_occs :: IE RdrName -> ExportOccMap -> [Name] -> RnM ExportOccMap
1170 check_occs ie occs names  -- 'names' are the entities specifed by 'ie'
1171   = foldlM check occs names
1172   where
1173     check occs name
1174       = case lookupOccEnv occs name_occ of
1175           Nothing -> return (extendOccEnv occs name_occ (name, ie))
1176
1177           Just (name', ie')
1178             | name == name'   -- Duplicate export
1179             -- But we don't want to warn if the same thing is exported
1180             -- by two different module exports. See ticket #4478.
1181             -> do unless (dupExport_ok name ie ie') $ do
1182                       warn_dup_exports <- woptM Opt_WarnDuplicateExports
1183                       warnIf warn_dup_exports (dupExportWarn name_occ ie ie')
1184                   return occs
1185
1186             | otherwise    -- Same occ name but different names: an error
1187             ->  do { global_env <- getGlobalRdrEnv ;
1188                      addErr (exportClashErr global_env name' name ie' ie) ;
1189                      return occs }
1190       where
1191         name_occ = nameOccName name
1192
1193
1194 dupExport_ok :: Name -> IE RdrName -> IE RdrName -> Bool
1195 -- The Name is exported by both IEs. Is that ok?
1196 -- "No"  iff the name is mentioned explicitly in both IEs
1197 --        or one of the IEs mentions the name *alone*
1198 -- "Yes" otherwise
1199 --
1200 -- Examples of "no":  module M( f, f )
1201 --                    module M( fmap, Functor(..) )
1202 --                    module M( module Data.List, head )
1203 --
1204 -- Example of "yes"
1205 --    module M( module A, module B ) where
1206 --        import A( f )
1207 --        import B( f )
1208 --
1209 -- Example of "yes" (Trac #2436)
1210 --    module M( C(..), T(..) ) where
1211 --         class C a where { data T a }
1212 --         instace C Int where { data T Int = TInt }
1213 --
1214 -- Example of "yes" (Trac #2436)
1215 --    module Foo ( T ) where
1216 --      data family T a
1217 --    module Bar ( T(..), module Foo ) where
1218 --        import Foo
1219 --        data instance T Int = TInt
1220
1221 dupExport_ok n ie1 ie2
1222   = not (  single ie1 || single ie2
1223         || (explicit_in ie1 && explicit_in ie2) )
1224   where
1225     explicit_in (IEModuleContents _) = False                -- module M
1226     explicit_in (IEThingAll r) = nameOccName n == rdrNameOcc r  -- T(..)
1227     explicit_in _              = True
1228
1229     single (IEVar {})      = True
1230     single (IEThingAbs {}) = True
1231     single _               = False
1232 \end{code}
1233
1234
1235 %*********************************************************
1236 %*                                                       *
1237 \subsection{Unused names}
1238 %*                                                       *
1239 %*********************************************************
1240
1241 \begin{code}
1242 reportUnusedNames :: Maybe [LIE RdrName]    -- Export list
1243                   -> TcGblEnv -> RnM ()
1244 reportUnusedNames _export_decls gbl_env
1245   = do  { traceRn ((text "RUN") <+> (ppr (tcg_dus gbl_env)))
1246         ; warnUnusedImportDecls gbl_env
1247         ; warnUnusedTopBinds   unused_locals }
1248   where
1249     used_names :: NameSet
1250     used_names = findUses (tcg_dus gbl_env) emptyNameSet
1251     -- NB: currently, if f x = g, we only treat 'g' as used if 'f' is used
1252     -- Hence findUses
1253
1254     -- Collect the defined names from the in-scope environment
1255     defined_names :: [GlobalRdrElt]
1256     defined_names = globalRdrEnvElts (tcg_rdr_env gbl_env)
1257
1258     -- Note that defined_and_used, defined_but_not_used
1259     -- are both [GRE]; that's why we need defined_and_used
1260     -- rather than just used_names
1261     _defined_and_used, defined_but_not_used :: [GlobalRdrElt]
1262     (_defined_and_used, defined_but_not_used)
1263         = partition (gre_is_used used_names) defined_names
1264
1265     kids_env = mkChildEnv defined_names
1266     -- This is done in mkExports too; duplicated work
1267
1268     gre_is_used :: NameSet -> GlobalRdrElt -> Bool
1269     gre_is_used used_names (GRE {gre_name = name})
1270         = name `elemNameSet` used_names
1271           || any (`elemNameSet` used_names) (findChildren kids_env name)
1272                 -- A use of C implies a use of T,
1273                 -- if C was brought into scope by T(..) or T(C)
1274
1275     -- Filter out the ones that are
1276     --  (a) defined in this module, and
1277     --  (b) not defined by a 'deriving' clause
1278     -- The latter have an Internal Name, so we can filter them out easily
1279     unused_locals :: [GlobalRdrElt]
1280     unused_locals = filter is_unused_local defined_but_not_used
1281     is_unused_local :: GlobalRdrElt -> Bool
1282     is_unused_local gre = isLocalGRE gre && isExternalName (gre_name gre)
1283 \end{code}
1284
1285 %*********************************************************
1286 %*                                                       *
1287 \subsection{Unused imports}
1288 %*                                                       *
1289 %*********************************************************
1290
1291 This code finds which import declarations are unused.  The
1292 specification and implementation notes are here:
1293   http://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/UnusedImports
1294
1295 \begin{code}
1296 type ImportDeclUsage
1297    = ( LImportDecl Name   -- The import declaration
1298      , [AvailInfo]        -- What *is* used (normalised)
1299      , [Name] )           -- What is imported but *not* used
1300 \end{code}
1301
1302 \begin{code}
1303 warnUnusedImportDecls :: TcGblEnv -> RnM ()
1304 warnUnusedImportDecls gbl_env
1305   = do { uses <- readMutVar (tcg_used_rdrnames gbl_env)
1306        ; let user_imports = filterOut (ideclImplicit . unLoc) (tcg_rn_imports gbl_env)
1307                             -- This whole function deals only with *user* imports
1308                             -- both for warning about unnecessary ones, and for
1309                             -- deciding the minimal ones
1310              rdr_env = tcg_rdr_env gbl_env
1311
1312        ; let usage :: [ImportDeclUsage]
1313              usage = findImportUsage user_imports rdr_env (Set.elems uses)
1314
1315        ; traceRn (vcat [ ptext (sLit "Uses:") <+> ppr (Set.elems uses)
1316                        , ptext (sLit "Import usage") <+> ppr usage])
1317        ; whenWOptM Opt_WarnUnusedImports $
1318          mapM_ warnUnusedImport usage
1319
1320        ; whenGOptM Opt_D_dump_minimal_imports $
1321          printMinimalImports usage }
1322 \end{code}
1323
1324
1325 Note [The ImportMap]
1326 ~~~~~~~~~~~~~~~~~~~~
1327 The ImportMap is a short-lived intermediate data struture records, for
1328 each import declaration, what stuff brought into scope by that
1329 declaration is actually used in the module.
1330
1331 The SrcLoc is the location of the END of a particular 'import'
1332 declaration.  Why *END*?  Because we don't want to get confused
1333 by the implicit Prelude import. Consider (Trac #7476) the module
1334     import Foo( foo )
1335     main = print foo
1336 There is an implicit 'import Prelude(print)', and it gets a SrcSpan
1337 of line 1:1 (just the point, not a span). If we use the *START* of
1338 the SrcSpan to identify the import decl, we'll confuse the implicit
1339 import Prelude with the explicit 'import Foo'.  So we use the END.
1340 It's just a cheap hack; we could equally well use the Span too.
1341
1342 The AvailInfos are the things imported from that decl (just a list,
1343 not normalised).
1344
1345 \begin{code}
1346 type ImportMap = Map SrcLoc [AvailInfo]  -- See [The ImportMap]
1347
1348 findImportUsage :: [LImportDecl Name]
1349                 -> GlobalRdrEnv
1350                 -> [RdrName]
1351                 -> [ImportDeclUsage]
1352
1353 findImportUsage imports rdr_env rdrs
1354   = map unused_decl imports
1355   where
1356     import_usage :: ImportMap
1357     import_usage = foldr (extendImportMap rdr_env) Map.empty rdrs
1358
1359     unused_decl decl@(L loc (ImportDecl { ideclHiding = imps }))
1360       = (decl, nubAvails used_avails, nameSetToList unused_imps)
1361       where
1362         used_avails = Map.lookup (srcSpanEnd loc) import_usage `orElse` []
1363                       -- srcSpanEnd: see Note [The ImportMap]
1364         used_names   = availsToNameSet used_avails
1365         used_parents = mkNameSet [n | AvailTC n _ <- used_avails]
1366
1367         unused_imps   -- Not trivial; see eg Trac #7454
1368           = case imps of
1369               Just (False, imp_ies) -> foldr (add_unused . unLoc) emptyNameSet imp_ies
1370               _other -> emptyNameSet -- No explicit import list => no unused-name list
1371
1372         add_unused :: IE Name -> NameSet -> NameSet
1373         add_unused (IEVar n)          acc = add_unused_name n acc
1374         add_unused (IEThingAbs n)     acc = add_unused_name n acc
1375         add_unused (IEThingAll n)     acc = add_unused_all  n acc
1376         add_unused (IEThingWith p ns) acc = add_unused_with p ns acc
1377         add_unused _                  acc = acc
1378
1379         add_unused_name n acc
1380           | n `elemNameSet` used_names = acc
1381           | otherwise                  = acc `addOneToNameSet` n
1382         add_unused_all n acc
1383           | n `elemNameSet` used_names   = acc
1384           | n `elemNameSet` used_parents = acc
1385           | otherwise                    = acc `addOneToNameSet` n
1386         add_unused_with p ns acc
1387           | all (`elemNameSet` acc1) ns = add_unused_name p acc1
1388           | otherwise = acc1
1389           where
1390             acc1 = foldr add_unused_name acc ns
1391        -- If you use 'signum' from Num, then the user may well have
1392        -- imported Num(signum).  We don't want to complain that
1393        -- Num is not itself mentioned.  Hence the two cases in add_unused_with.
1394
1395
1396 extendImportMap :: GlobalRdrEnv -> RdrName -> ImportMap -> ImportMap
1397 -- For a used RdrName, find all the import decls that brought
1398 -- it into scope; choose one of them (bestImport), and record
1399 -- the RdrName in that import decl's entry in the ImportMap
1400 extendImportMap rdr_env rdr imp_map
1401   | [gre] <- lookupGRE_RdrName rdr rdr_env
1402   , Imported imps <- gre_prov gre
1403   = add_imp gre (bestImport imps) imp_map
1404   | otherwise
1405   = imp_map
1406   where
1407     add_imp :: GlobalRdrElt -> ImportSpec -> ImportMap -> ImportMap
1408     add_imp gre (ImpSpec { is_decl = imp_decl_spec }) imp_map
1409       = Map.insertWith add decl_loc [avail] imp_map
1410       where
1411         add _ avails = avail : avails -- add is really just a specialised (++)
1412         decl_loc = srcSpanEnd (is_dloc imp_decl_spec)
1413                    -- For srcSpanEnd see Note [The ImportMap]
1414         avail    = greExportAvail gre
1415
1416     bestImport :: [ImportSpec] -> ImportSpec
1417     bestImport iss
1418       = case partition isImpAll iss of
1419           ([], imp_somes) -> textuallyFirst imp_somes
1420           (imp_alls, _)   -> textuallyFirst imp_alls
1421
1422     textuallyFirst :: [ImportSpec] -> ImportSpec
1423     textuallyFirst iss = case sortWith (is_dloc . is_decl) iss of
1424                            []     -> pprPanic "textuallyFirst" (ppr iss)
1425                            (is:_) -> is
1426
1427     isImpAll :: ImportSpec -> Bool
1428     isImpAll (ImpSpec { is_item = ImpAll }) = True
1429     isImpAll _other                         = False
1430 \end{code}
1431
1432 \begin{code}
1433 warnUnusedImport :: ImportDeclUsage -> RnM ()
1434 warnUnusedImport (L loc decl, used, unused)
1435   | Just (False,[]) <- ideclHiding decl
1436                 = return ()            -- Do not warn for 'import M()'
1437
1438   | Just (True, hides) <- ideclHiding decl
1439   , not (null hides)
1440   , pRELUDE_NAME == unLoc (ideclName decl)
1441                 = return ()            -- Note [Do not warn about Prelude hiding]
1442   | null used   = addWarnAt loc msg1   -- Nothing used; drop entire decl
1443   | null unused = return ()            -- Everything imported is used; nop
1444   | otherwise   = addWarnAt loc msg2   -- Some imports are unused
1445   where
1446     msg1 = vcat [pp_herald <+> quotes pp_mod <+> pp_not_used,
1447                  nest 2 (ptext (sLit "except perhaps to import instances from")
1448                                    <+> quotes pp_mod),
1449                  ptext (sLit "To import instances alone, use:")
1450                                    <+> ptext (sLit "import") <+> pp_mod <> parens Outputable.empty ]
1451     msg2 = sep [pp_herald <+> quotes (pprWithCommas ppr unused),
1452                     text "from module" <+> quotes pp_mod <+> pp_not_used]
1453     pp_herald  = text "The" <+> pp_qual <+> text "import of"
1454     pp_qual
1455       | ideclQualified decl = text "qualified"
1456       | otherwise           = Outputable.empty
1457     pp_mod      = ppr (unLoc (ideclName decl))
1458     pp_not_used = text "is redundant"
1459 \end{code}
1460
1461 Note [Do not warn about Prelude hiding]
1462 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1463 We do not warn about
1464    import Prelude hiding( x, y )
1465 because even if nothing else from Prelude is used, it may be essential to hide
1466 x,y to avoid name-shadowing warnings.  Example (Trac #9061)
1467    import Prelude hiding( log )
1468    f x = log where log = ()
1469
1470
1471
1472 Note [Printing minimal imports]
1473 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1474 To print the minimal imports we walk over the user-supplied import
1475 decls, and simply trim their import lists.  NB that
1476
1477   * We do *not* change the 'qualified' or 'as' parts!
1478
1479   * We do not disard a decl altogether; we might need instances
1480     from it.  Instead we just trim to an empty import list
1481
1482 \begin{code}
1483 printMinimalImports :: [ImportDeclUsage] -> RnM ()
1484 -- See Note [Printing minimal imports]
1485 printMinimalImports imports_w_usage
1486   = do { imports' <- mapM mk_minimal imports_w_usage
1487        ; this_mod <- getModule
1488        ; dflags   <- getDynFlags
1489        ; liftIO $
1490          do { h <- openFile (mkFilename dflags this_mod) WriteMode
1491             ; printForUser dflags h neverQualify (vcat (map ppr imports')) }
1492               -- The neverQualify is important.  We are printing Names
1493               -- but they are in the context of an 'import' decl, and
1494               -- we never qualify things inside there
1495               -- E.g.   import Blag( f, b )
1496               -- not    import Blag( Blag.f, Blag.g )!
1497        }
1498   where
1499     mkFilename dflags this_mod
1500       | Just d <- dumpDir dflags = d </> basefn
1501       | otherwise                = basefn
1502       where
1503         basefn = moduleNameString (moduleName this_mod) ++ ".imports"
1504
1505     mk_minimal (L l decl, used, unused)
1506       | null unused
1507       , Just (False, _) <- ideclHiding decl
1508       = return (L l decl)
1509       | otherwise
1510       = do { let ImportDecl { ideclName    = L _ mod_name
1511                             , ideclSource  = is_boot
1512                             , ideclPkgQual = mb_pkg } = decl
1513            ; iface <- loadSrcInterface doc mod_name is_boot mb_pkg
1514            ; let lies = map (L l) (concatMap (to_ie iface) used)
1515            ; return (L l (decl { ideclHiding = Just (False, lies) })) }
1516       where
1517         doc = text "Compute minimal imports for" <+> ppr decl
1518
1519     to_ie :: ModIface -> AvailInfo -> [IE Name]
1520     -- The main trick here is that if we're importing all the constructors
1521     -- we want to say "T(..)", but if we're importing only a subset we want
1522     -- to say "T(A,B,C)".  So we have to find out what the module exports.
1523     to_ie _ (Avail n)
1524        = [IEVar n]
1525     to_ie _ (AvailTC n [m])
1526        | n==m = [IEThingAbs n]
1527     to_ie iface (AvailTC n ns)
1528       = case [xs | AvailTC x xs <- mi_exports iface
1529                  , x == n
1530                  , x `elem` xs    -- Note [Partial export]
1531                  ] of
1532            [xs] | all_used xs -> [IEThingAll n]
1533                 | otherwise   -> [IEThingWith n (filter (/= n) ns)]
1534            _other             -> map IEVar ns
1535         where
1536           all_used avail_occs = all (`elem` ns) avail_occs
1537 \end{code}
1538
1539 Note [Partial export]
1540 ~~~~~~~~~~~~~~~~~~~~~
1541 Suppose we have
1542
1543    module A( op ) where
1544      class C a where
1545        op :: a -> a
1546
1547    module B where
1548    import A
1549    f = ..op...
1550
1551 Then the minimal import for module B is
1552    import A( op )
1553 not
1554    import A( C( op ) )
1555 which we would usually generate if C was exported from B.  Hence
1556 the (x `elem` xs) test when deciding what to generate.
1557
1558
1559 %************************************************************************
1560 %*                                                                      *
1561 \subsection{Errors}
1562 %*                                                                      *
1563 %************************************************************************
1564
1565 \begin{code}
1566 qualImportItemErr :: RdrName -> SDoc
1567 qualImportItemErr rdr
1568   = hang (ptext (sLit "Illegal qualified name in import item:"))
1569        2 (ppr rdr)
1570
1571 badImportItemErrStd :: ModIface -> ImpDeclSpec -> IE RdrName -> SDoc
1572 badImportItemErrStd iface decl_spec ie
1573   = sep [ptext (sLit "Module"), quotes (ppr (is_mod decl_spec)), source_import,
1574          ptext (sLit "does not export"), quotes (ppr ie)]
1575   where
1576     source_import | mi_boot iface = ptext (sLit "(hi-boot interface)")
1577                   | otherwise     = Outputable.empty
1578
1579 badImportItemErrDataCon :: OccName -> ModIface -> ImpDeclSpec -> IE RdrName -> SDoc
1580 badImportItemErrDataCon dataType iface decl_spec ie
1581   = vcat [ ptext (sLit "In module")
1582              <+> quotes (ppr (is_mod decl_spec))
1583              <+> source_import <> colon
1584          , nest 2 $ quotes datacon
1585              <+> ptext (sLit "is a data constructor of")
1586              <+> quotes (ppr dataType)
1587          , ptext (sLit "To import it use")
1588          , nest 2 $ quotes (ptext (sLit "import"))
1589              <+> ppr (is_mod decl_spec)
1590              <> parens_sp (ppr dataType <> parens_sp datacon)
1591          , ptext (sLit "or")
1592          , nest 2 $ quotes (ptext (sLit "import"))
1593              <+> ppr (is_mod decl_spec)
1594              <> parens_sp (ppr dataType <> ptext (sLit "(..)"))
1595          ]
1596   where
1597     datacon_occ = rdrNameOcc $ ieName ie
1598     datacon = parenSymOcc datacon_occ (ppr datacon_occ)
1599     source_import | mi_boot iface = ptext (sLit "(hi-boot interface)")
1600                   | otherwise     = Outputable.empty
1601     parens_sp d = parens (space <> d <> space)  -- T( f,g )
1602
1603 badImportItemErr :: ModIface -> ImpDeclSpec -> IE RdrName -> [AvailInfo] -> SDoc
1604 badImportItemErr iface decl_spec ie avails
1605   = case find checkIfDataCon avails of
1606       Just con -> badImportItemErrDataCon (availOccName con) iface decl_spec ie
1607       Nothing  -> badImportItemErrStd iface decl_spec ie
1608   where
1609     checkIfDataCon (AvailTC _ ns) =
1610       case find (\n -> importedFS == nameOccNameFS n) ns of
1611         Just n  -> isDataConName n
1612         Nothing -> False
1613     checkIfDataCon _ = False
1614     availOccName = nameOccName . availName
1615     nameOccNameFS = occNameFS . nameOccName
1616     importedFS = occNameFS . rdrNameOcc $ ieName ie
1617
1618 illegalImportItemErr :: SDoc
1619 illegalImportItemErr = ptext (sLit "Illegal import item")
1620
1621 dodgyImportWarn :: RdrName -> SDoc
1622 dodgyImportWarn item = dodgyMsg (ptext (sLit "import")) item
1623 dodgyExportWarn :: Name -> SDoc
1624 dodgyExportWarn item = dodgyMsg (ptext (sLit "export")) item
1625
1626 dodgyMsg :: (OutputableBndr n, HasOccName n) => SDoc -> n -> SDoc
1627 dodgyMsg kind tc
1628   = sep [ ptext (sLit "The") <+> kind <+> ptext (sLit "item") <+> quotes (ppr (IEThingAll tc))
1629                 <+> ptext (sLit "suggests that"),
1630           quotes (ppr tc) <+> ptext (sLit "has (in-scope) constructors or class methods,"),
1631           ptext (sLit "but it has none") ]
1632
1633 exportItemErr :: IE RdrName -> SDoc
1634 exportItemErr export_item
1635   = sep [ ptext (sLit "The export item") <+> quotes (ppr export_item),
1636           ptext (sLit "attempts to export constructors or class methods that are not visible here") ]
1637
1638 exportClashErr :: GlobalRdrEnv -> Name -> Name -> IE RdrName -> IE RdrName
1639                -> MsgDoc
1640 exportClashErr global_env name1 name2 ie1 ie2
1641   = vcat [ ptext (sLit "Conflicting exports for") <+> quotes (ppr occ) <> colon
1642          , ppr_export ie1' name1'
1643          , ppr_export ie2' name2' ]
1644   where
1645     occ = nameOccName name1
1646     ppr_export ie name = nest 3 (hang (quotes (ppr ie) <+> ptext (sLit "exports") <+>
1647                                        quotes (ppr name))
1648                                     2 (pprNameProvenance (get_gre name)))
1649
1650     -- get_gre finds a GRE for the Name, so that we can show its provenance
1651     get_gre name
1652         = case lookupGRE_Name global_env name of
1653              (gre:_) -> gre
1654              []      -> pprPanic "exportClashErr" (ppr name)
1655     get_loc name = greSrcSpan (get_gre name)
1656     (name1', ie1', name2', ie2') = if get_loc name1 < get_loc name2
1657                                    then (name1, ie1, name2, ie2)
1658                                    else (name2, ie2, name1, ie1)
1659
1660 -- the SrcSpan that pprNameProvenance prints out depends on whether
1661 -- the Name is defined locally or not: for a local definition the
1662 -- definition site is used, otherwise the location of the import
1663 -- declaration.  We want to sort the export locations in
1664 -- exportClashErr by this SrcSpan, we need to extract it:
1665 greSrcSpan :: GlobalRdrElt -> SrcSpan
1666 greSrcSpan gre
1667   | Imported (is:_) <- gre_prov gre = is_dloc (is_decl is)
1668   | otherwise                       = name_span
1669   where
1670     name_span = nameSrcSpan (gre_name gre)
1671
1672 addDupDeclErr :: [Name] -> TcRn ()
1673 addDupDeclErr []
1674   = panic "addDupDeclErr: empty list"
1675 addDupDeclErr names@(name : _)
1676   = addErrAt (getSrcSpan (last sorted_names)) $
1677     -- Report the error at the later location
1678     vcat [ptext (sLit "Multiple declarations of") <+>
1679              quotes (ppr (nameOccName name)),
1680              -- NB. print the OccName, not the Name, because the
1681              -- latter might not be in scope in the RdrEnv and so will
1682              -- be printed qualified.
1683           ptext (sLit "Declared at:") <+>
1684                    vcat (map (ppr . nameSrcLoc) sorted_names)]
1685   where
1686     sorted_names = sortWith nameSrcLoc names
1687
1688 dupExportWarn :: OccName -> IE RdrName -> IE RdrName -> SDoc
1689 dupExportWarn occ_name ie1 ie2
1690   = hsep [quotes (ppr occ_name),
1691           ptext (sLit "is exported by"), quotes (ppr ie1),
1692           ptext (sLit "and"),            quotes (ppr ie2)]
1693
1694 dupModuleExport :: ModuleName -> SDoc
1695 dupModuleExport mod
1696   = hsep [ptext (sLit "Duplicate"),
1697           quotes (ptext (sLit "Module") <+> ppr mod),
1698           ptext (sLit "in export list")]
1699
1700 moduleNotImported :: ModuleName -> SDoc
1701 moduleNotImported mod
1702   = ptext (sLit "The export item `module") <+> ppr mod <>
1703     ptext (sLit "' is not imported")
1704
1705 nullModuleExport :: ModuleName -> SDoc
1706 nullModuleExport mod
1707   = ptext (sLit "The export item `module") <+> ppr mod <> ptext (sLit "' exports nothing")
1708
1709 missingImportListWarn :: ModuleName -> SDoc
1710 missingImportListWarn mod
1711   = ptext (sLit "The module") <+> quotes (ppr mod) <+> ptext (sLit "does not have an explicit import list")
1712
1713 missingImportListItem :: IE RdrName -> SDoc
1714 missingImportListItem ie
1715   = ptext (sLit "The import item") <+> quotes (ppr ie) <+> ptext (sLit "does not have an explicit import list")
1716
1717 moduleWarn :: ModuleName -> WarningTxt -> SDoc
1718 moduleWarn mod (WarningTxt txt)
1719   = sep [ ptext (sLit "Module") <+> quotes (ppr mod) <> ptext (sLit ":"),
1720           nest 2 (vcat (map ppr txt)) ]
1721 moduleWarn mod (DeprecatedTxt txt)
1722   = sep [ ptext (sLit "Module") <+> quotes (ppr mod)
1723                                 <+> ptext (sLit "is deprecated:"),
1724           nest 2 (vcat (map ppr txt)) ]
1725
1726 packageImportErr :: SDoc
1727 packageImportErr
1728   = ptext (sLit "Package-qualified imports are not enabled; use PackageImports")
1729
1730 -- This data decl will parse OK
1731 --      data T = a Int
1732 -- treating "a" as the constructor.
1733 -- It is really hard to make the parser spot this malformation.
1734 -- So the renamer has to check that the constructor is legal
1735 --
1736 -- We can get an operator as the constructor, even in the prefix form:
1737 --      data T = :% Int Int
1738 -- from interface files, which always print in prefix form
1739
1740 checkConName :: RdrName -> TcRn ()
1741 checkConName name = checkErr (isRdrDataCon name) (badDataCon name)
1742
1743 badDataCon :: RdrName -> SDoc
1744 badDataCon name
1745    = hsep [ptext (sLit "Illegal data constructor name"), quotes (ppr name)]
1746 \end{code}