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