Refactor HsDecls again, to put family instances in InstDecl
[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, lookupTcdName,
11         reportUnusedNames, finishWarnings,
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               lcl_env1 = lcl_env { tcl_rdr = delListFromOccEnv (tcl_rdr lcl_env) new_occs }
410               (rdr_env2, lcl_env2) | shadowP   = (rdr_env_TH,   lcl_env1)
411                                    | isGHCi    = (rdr_env_GHCi, lcl_env1)
412                                    | otherwise = (rdr_env,      lcl_env)
413
414               rdr_env3 = foldl extendGlobalRdrEnv rdr_env2 gres
415               fix_env' = foldl extend_fix_env     fix_env  gres
416               (rdr_env', dups) = findLocalDupsRdrEnv rdr_env3 new_occs
417
418               gbl_env' = gbl_env { tcg_rdr_env = rdr_env', tcg_fix_env = fix_env' }
419
420         ; mapM_ addDupDeclErr dups
421
422         ; traceRn (text "extendGlobalRdrEnvRn" <+> (ppr new_fixities $$ ppr fix_env $$ ppr fix_env'))
423         ; return (gbl_env', lcl_env2) }
424   where
425     gres = gresFromAvails LocalDef avails
426
427     -- If there is a fixity decl for the gre, add it to the fixity env
428     extend_fix_env fix_env gre
429       | Just (L _ fi) <- lookupFsEnv new_fixities (occNameFS occ)
430       = extendNameEnv fix_env name (FixItem occ fi)
431       | otherwise
432       = fix_env
433       where
434         name = gre_name gre
435         occ  = nameOccName name
436
437     qual_gre :: GlobalRdrElt -> GlobalRdrElt
438     -- Transform top-level GREs from the module being compiled
439     -- so that they are out of the way of new definitions in a Template
440     -- Haskell bracket
441     -- See Note [Top-level Names in Template Haskell decl quotes]
442     -- Seems like 5 times as much work as it deserves!
443     --
444     -- For a LocalDef we make a (fake) qualified imported GRE for a
445     -- local GRE so that the original *qualified* name is still in scope
446     -- but the *unqualified* one no longer is.  What a hack!
447
448     qual_gre gre@(GRE { gre_prov = LocalDef, gre_name = name })
449         | isExternalName name = gre { gre_prov = Imported [imp_spec] }
450         | otherwise           = gre
451           -- Do not shadow Internal (ie Template Haskell) Names
452           -- See Note [Top-level Names in Template Haskell decl quotes]
453         where
454           mod = ASSERT2( isExternalName name, ppr name) moduleName (nameModule name)
455           imp_spec = ImpSpec { is_item = ImpAll, is_decl = decl_spec }
456           decl_spec = ImpDeclSpec { is_mod = mod, is_as = mod,
457                                     is_qual = True,  -- Qualified only!
458                                     is_dloc = srcLocSpan (nameSrcLoc name) }
459
460     qual_gre gre@(GRE { gre_prov = Imported specs })
461         = gre { gre_prov = Imported (map qual_spec specs) }
462
463     qual_spec spec@(ImpSpec { is_decl = decl_spec })
464         = spec { is_decl = decl_spec { is_qual = True } }
465 \end{code}
466
467 @getLocalDeclBinders@ returns the names for an @HsDecl@.  It's
468 used for source code.
469
470         *** See "THE NAMING STORY" in HsDecls ****
471
472 \begin{code}
473 getLocalNonValBinders :: MiniFixityEnv -> HsGroup RdrName 
474                       -> RnM ((TcGblEnv, TcLclEnv), NameSet)
475 -- Get all the top-level binders bound the group *except*
476 -- for value bindings, which are treated separately
477 -- Specificaly we return AvailInfo for
478 --      type decls (incl constructors and record selectors)
479 --      class decls (including class ops)
480 --      associated types
481 --      foreign imports
482 --      (in hs-boot files) value signatures
483
484 getLocalNonValBinders fixity_env 
485      (HsGroup { hs_valds  = val_binds,
486                 hs_tyclds = tycl_decls,
487                 hs_instds = inst_decls,
488                 hs_fords  = foreign_decls })
489   = do  { -- Process all type/class decls *except* family instances
490         ; tc_avails <- mapM new_tc (concat tycl_decls)
491         ; envs <- extendGlobalRdrEnvRn tc_avails fixity_env
492         ; setEnvs envs $ do {
493             -- Bring these things into scope first
494             -- See Note [Looking up family names in family instances]
495
496           -- Process all family instances
497           -- to bring new data constructors into scope
498         ; nti_avails <- concatMapM new_assoc inst_decls
499
500           -- Finish off with value binders:
501           --    foreign decls for an ordinary module
502           --    type sigs in case of a hs-boot file only
503         ; is_boot <- tcIsHsBoot 
504         ; let val_bndrs | is_boot   = hs_boot_sig_bndrs
505                         | otherwise = for_hs_bndrs
506         ; val_avails <- mapM new_simple val_bndrs
507
508         ; let avails    = nti_avails ++ val_avails
509               new_bndrs = availsToNameSet avails `unionNameSets` 
510                           availsToNameSet tc_avails
511         ; envs <- extendGlobalRdrEnvRn avails fixity_env 
512         ; return (envs, new_bndrs) } }
513   where
514     for_hs_bndrs :: [Located RdrName]
515     for_hs_bndrs = [nm | L _ (ForeignImport nm _ _ _) <- foreign_decls]
516
517     -- In a hs-boot file, the value binders come from the
518     --  *signatures*, and there should be no foreign binders
519     hs_boot_sig_bndrs = [n | L _ (TypeSig ns _) <- val_sigs, n <- ns]
520     ValBindsIn _ val_sigs = val_binds
521
522     new_simple :: Located RdrName -> RnM AvailInfo
523     new_simple rdr_name = do{ nm <- newTopSrcBinder rdr_name
524                             ; return (Avail nm) }
525
526     new_tc tc_decl              -- NOT for type/data instances
527         = do { let bndrs = hsTyClDeclBinders (unLoc tc_decl)
528              ; names@(main_name : _) <- mapM newTopSrcBinder bndrs
529              ; return (AvailTC main_name names) }
530
531     new_ti :: Maybe Name -> FamInstDecl RdrName -> RnM AvailInfo
532     new_ti mb_cls ti_decl  -- ONLY for type/data instances
533         = ASSERT( isFamInstDecl ti_decl ) 
534           do { main_name <- lookupTcdName mb_cls ti_decl
535              ; sub_names <- mapM newTopSrcBinder (hsTyClDeclBinders ti_decl)
536              ; return (AvailTC (unLoc main_name) sub_names) }
537                         -- main_name is not bound here!
538
539     new_assoc :: LInstDecl RdrName -> RnM [AvailInfo]
540     new_assoc (L _ (FamInstDecl d)) 
541       = do { avail <- new_ti Nothing d
542            ; return [avail] }
543     new_assoc (L _ (ClsInstDecl inst_ty _ _ ats))
544       = do { mb_cls_nm <- get_cls_parent inst_ty 
545            ; mapM (new_ti mb_cls_nm . unLoc) ats }
546       where
547         get_cls_parent inst_ty
548           | Just (_, _, L loc cls_rdr, _) <- splitLHsInstDeclTy_maybe inst_ty
549           = setSrcSpan loc $ do { nm <- lookupGlobalOccRn cls_rdr; return (Just nm) }
550           | otherwise
551           = return Nothing
552
553 lookupTcdName :: Maybe Name -> TyClDecl RdrName -> RnM (Located Name)
554 -- Used for TyData and TySynonym only, 
555 -- both ordinary ones and family instances
556 -- See Note [Family instance binders]
557 lookupTcdName mb_cls tc_decl
558   | not (isFamInstDecl tc_decl)   -- The normal case
559   = ASSERT2( isNothing mb_cls, ppr tc_rdr )     -- Parser prevents this
560     lookupLocatedTopBndrRn tc_rdr
561
562   | Just cls <- mb_cls      -- Associated type; c.f RnBinds.rnMethodBind
563   = wrapLocM (lookupInstDeclBndr cls (ptext (sLit "associated type"))) tc_rdr
564
565   | otherwise               -- Family instance; tc_rdr is an *occurrence*
566   = lookupLocatedOccRn tc_rdr 
567   where
568     tc_rdr = tcdLName tc_decl
569 \end{code}
570
571 Note [Looking up family names in family instances]
572 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
573 Consider
574
575   module M where
576     type family T a :: *
577     type instance M.T Int = Bool
578
579 We might think that we can simply use 'lookupOccRn' when processing the type
580 instance to look up 'M.T'.  Alas, we can't!  The type family declaration is in
581 the *same* HsGroup as the type instance declaration.  Hence, as we are
582 currently collecting the binders declared in that HsGroup, these binders will
583 not have been added to the global environment yet.
584
585 Solution is simple: process the type family declarations first, extend
586 the environment, and then process the type instances.
587
588
589 Note [Family instance binders]
590 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
591 Consider
592   data family F a
593   data instance F T = X1 | X2
594
595 The 'data instance' decl has an *occurrence* of F (and T), and *binds*
596 X1 and X2.  (This is unlike a normal data type declaration which would
597 bind F too.)  So we want an AvailTC F [X1,X2].
598
599 Now consider a similar pair:
600   class C a where
601     data G a
602   instance C S where
603     data G S = Y1 | Y2
604
605 The 'data G S' *binds* Y1 and Y2, and has an *occurrence* of G.
606
607 But there is a small complication: in an instance decl, we don't use
608 qualified names on the LHS; instead we use the class to disambiguate.
609 Thus:
610   module M where
611     import Blib( G )
612     class C a where
613       data G a
614     instance C S where
615       data G S = Y1 | Y2
616 Even though there are two G's in scope (M.G and Blib.G), the occurence
617 of 'G' in the 'instance C S' decl is unambiguous, becuase C has only
618 one associated type called G. This is exactly what happens for methods,
619 and it is only consistent to do the same thing for types. That's the
620 role of the function lookupTcdName; the (Maybe Name) give the class of
621 the encloseing instance decl, if any.
622
623
624 %************************************************************************
625 %*                                                                      *
626 \subsection{Filtering imports}
627 %*                                                                      *
628 %************************************************************************
629
630 @filterImports@ takes the @ExportEnv@ telling what the imported module makes
631 available, and filters it through the import spec (if any).
632
633 \begin{code}
634 filterImports :: ModIface
635               -> ImpDeclSpec                    -- The span for the entire import decl
636               -> Maybe (Bool, [LIE RdrName])    -- Import spec; True => hiding
637               -> RnM (Maybe (Bool, [LIE Name]), -- Import spec w/ Names
638                       [GlobalRdrElt])           -- Same again, but in GRE form
639 filterImports iface decl_spec Nothing
640   = return (Nothing, gresFromAvails prov (mi_exports iface))
641   where
642     prov = Imported [ImpSpec { is_decl = decl_spec, is_item = ImpAll }]
643
644
645 filterImports iface decl_spec (Just (want_hiding, import_items))
646   = do  -- check for errors, convert RdrNames to Names
647         opt_typeFamilies <- xoptM Opt_TypeFamilies
648         items1 <- mapM (lookup_lie opt_typeFamilies) import_items
649
650         let items2 :: [(LIE Name, AvailInfo)]
651             items2 = concat items1
652                 -- NB the AvailInfo may have duplicates, and several items
653                 --    for the same parent; e.g N(x) and N(y)
654
655             names  = availsToNameSet (map snd items2)
656             keep n = not (n `elemNameSet` names)
657             pruned_avails = filterAvails keep all_avails
658             hiding_prov = Imported [ImpSpec { is_decl = decl_spec, is_item = ImpAll }]
659
660             gres | want_hiding = gresFromAvails hiding_prov pruned_avails
661                  | otherwise   = concatMap (gresFromIE decl_spec) items2
662
663         return (Just (want_hiding, map fst items2), gres)
664   where
665     all_avails = mi_exports iface
666
667         -- This environment is how we map names mentioned in the import
668         -- list to the actual Name they correspond to, and the name family
669         -- that the Name belongs to (the AvailInfo).  The situation is
670         -- complicated by associated families, which introduce a three-level
671         -- hierachy, where class = grand parent, assoc family = parent, and
672         -- data constructors = children.  The occ_env entries for associated
673         -- families needs to capture all this information; hence, we have the
674         -- third component of the environment that gives the class name (=
675         -- grand parent) in case of associated families.
676         --
677         -- This env will have entries for data constructors too,
678         -- they won't make any difference because naked entities like T
679         -- in an import list map to TcOccs, not VarOccs.
680     occ_env :: OccEnv (Name,        -- the name
681                        AvailInfo,   -- the export item providing the name
682                        Maybe Name)  -- the parent of associated types
683     occ_env = mkOccEnv_C combine [ (nameOccName n, (n, a, Nothing))
684                                  | a <- all_avails, n <- availNames a]
685       where
686         -- we know that (1) there are at most entries for one name, (2) their
687         -- first component is identical, (3) they are for tys/cls, and (4) one
688         -- entry has the name in its parent position (the other doesn't)
689         combine (name, AvailTC p1 subs1, Nothing)
690                 (_   , AvailTC p2 subs2, Nothing)
691           = let
692               (parent, subs) = if p1 == name then (p2, subs1) else (p1, subs2)
693             in
694             (name, AvailTC name subs, Just parent)
695         combine x y = pprPanic "filterImports/combine" (ppr x $$ ppr y)
696
697     lookup_lie :: Bool -> LIE RdrName -> TcRn [(LIE Name, AvailInfo)]
698     lookup_lie opt_typeFamilies (L loc ieRdr)
699         = do
700              stuff <- setSrcSpan loc $
701                       case lookup_ie opt_typeFamilies ieRdr of
702                             Failed err  -> addErr err >> return []
703                             Succeeded a -> return a
704              checkDodgyImport stuff
705              return [ (L loc ie, avail) | (ie,avail) <- stuff ]
706         where
707             -- Warn when importing T(..) if T was exported abstractly
708             checkDodgyImport stuff
709                 | IEThingAll n <- ieRdr, (_, AvailTC _ [_]):_ <- stuff
710                 = ifWOptM Opt_WarnDodgyImports (addWarn (dodgyImportWarn n))
711                     -- NB. use the RdrName for reporting the warning
712                 | IEThingAll {} <- ieRdr
713                 , not (is_qual decl_spec)
714                 = ifWOptM Opt_WarnMissingImportList $
715                   addWarn (missingImportListItem ieRdr)
716             checkDodgyImport _
717                 = return ()
718
719         -- For each import item, we convert its RdrNames to Names,
720         -- and at the same time construct an AvailInfo corresponding
721         -- to what is actually imported by this item.
722         -- Returns Nothing on error.
723         -- We return a list here, because in the case of an import
724         -- item like C, if we are hiding, then C refers to *both* a
725         -- type/class and a data constructor.  Moreover, when we import
726         -- data constructors of an associated family, we need separate
727         -- AvailInfos for the data constructors and the family (as they have
728         -- different parents).  See the discussion at occ_env.
729     lookup_ie :: Bool -> IE RdrName -> MaybeErr MsgDoc [(IE Name,AvailInfo)]
730     lookup_ie opt_typeFamilies ie
731       = let bad_ie :: MaybeErr MsgDoc a
732             bad_ie = Failed (badImportItemErr iface decl_spec ie all_avails)
733
734             lookup_name rdr
735               | isQual rdr = Failed (qualImportItemErr rdr)
736               | Just nm <- lookupOccEnv occ_env (rdrNameOcc rdr) = return nm
737               | otherwise                                        = bad_ie
738         in
739         case ie of
740          IEVar n -> do
741              (name, avail, _) <- lookup_name n
742              return [(IEVar name, trimAvail avail name)]
743
744          IEThingAll tc -> do
745              (name, avail@(AvailTC name2 subs), mb_parent) <- lookup_name tc
746              case mb_parent of
747                -- non-associated ty/cls
748                Nothing     -> return [(IEThingAll name, avail)]
749                -- associated ty
750                Just parent -> return [(IEThingAll name,
751                                        AvailTC name2 (subs \\ [name])),
752                                       (IEThingAll name, AvailTC parent [name])]
753
754          IEThingAbs tc
755              | want_hiding   -- hiding ( C )
756                         -- Here the 'C' can be a data constructor
757                         --  *or* a type/class, or even both
758              -> let tc_name = lookup_name tc
759                     dc_name = lookup_name (setRdrNameSpace tc srcDataName)
760                 in
761                 case catMaybeErr [ tc_name, dc_name ] of
762                   []    -> bad_ie
763                   names -> return [mkIEThingAbs name | name <- names]
764              | otherwise
765              -> do nameAvail <- lookup_name tc
766                    return [mkIEThingAbs nameAvail]
767
768          IEThingWith tc ns -> do
769             (name, AvailTC _ subnames, mb_parent) <- lookup_name tc
770             let
771               env         = mkOccEnv [(nameOccName s, s) | s <- subnames]
772               mb_children = map (lookupOccEnv env . rdrNameOcc) ns
773             children <- if any isNothing mb_children
774                         then bad_ie
775                         else return (catMaybes mb_children)
776             -- check for proper import of type families
777             when (not opt_typeFamilies && any isTyConName children) $
778               Failed (typeItemErr (head . filter isTyConName $ children)
779                                   (text "in import list"))
780             case mb_parent of
781               -- non-associated ty/cls
782               Nothing     -> return [(IEThingWith name children,
783                                       AvailTC name (name:children))]
784               -- associated ty
785               Just parent -> return [(IEThingWith name children,
786                                       AvailTC name children),
787                                      (IEThingWith name children,
788                                       AvailTC parent [name])]
789
790          _other -> Failed illegalImportItemErr
791          -- could be IEModuleContents, IEGroup, IEDoc, IEDocNamed
792          -- all errors.
793
794       where
795         mkIEThingAbs (n, av, Nothing    ) = (IEThingAbs n, trimAvail av n)
796         mkIEThingAbs (n, _,  Just parent) = (IEThingAbs n, AvailTC parent [n])
797
798
799 catMaybeErr :: [MaybeErr err a] -> [a]
800 catMaybeErr ms =  [ a | Succeeded a <- ms ]
801 \end{code}
802
803 %************************************************************************
804 %*                                                                      *
805 \subsection{Import/Export Utils}
806 %*                                                                      *
807 %************************************************************************
808
809 \begin{code}
810 greExportAvail :: GlobalRdrElt -> AvailInfo
811 greExportAvail gre 
812   = case gre_par gre of
813       ParentIs p                  -> AvailTC p [me]
814       NoParent   | isTyConName me -> AvailTC me [me]
815                  | otherwise      -> Avail   me
816   where
817     me = gre_name gre
818
819 plusAvail :: AvailInfo -> AvailInfo -> AvailInfo
820 plusAvail a1 a2
821   | debugIsOn && availName a1 /= availName a2 
822   = pprPanic "RnEnv.plusAvail names differ" (hsep [ppr a1,ppr a2])
823 plusAvail a1@(Avail {})         (Avail {})      = a1
824 plusAvail (AvailTC _ [])        a2@(AvailTC {}) = a2
825 plusAvail a1@(AvailTC {})       (AvailTC _ [])  = a1
826 plusAvail (AvailTC n1 (s1:ss1)) (AvailTC n2 (s2:ss2))
827   = case (n1==s1, n2==s2) of  -- Maintain invariant the parent is first
828        (True,True)   -> AvailTC n1 (s1 : (ss1 `unionLists` ss2))
829        (True,False)  -> AvailTC n1 (s1 : (ss1 `unionLists` (s2:ss2)))
830        (False,True)  -> AvailTC n1 (s2 : ((s1:ss1) `unionLists` ss2))
831        (False,False) -> AvailTC n1 ((s1:ss1) `unionLists` (s2:ss2))
832 plusAvail a1 a2 = pprPanic "RnEnv.plusAvail" (hsep [ppr a1,ppr a2])
833
834 trimAvail :: AvailInfo -> Name -> AvailInfo
835 trimAvail (Avail n)      _ = Avail n
836 trimAvail (AvailTC n ns) m = ASSERT( m `elem` ns) AvailTC n [m]
837
838 -- | filters 'AvailInfo's by the given predicate
839 filterAvails  :: (Name -> Bool) -> [AvailInfo] -> [AvailInfo]
840 filterAvails keep avails = foldr (filterAvail keep) [] avails
841
842 -- | filters an 'AvailInfo' by the given predicate
843 filterAvail :: (Name -> Bool) -> AvailInfo -> [AvailInfo] -> [AvailInfo]
844 filterAvail keep ie rest =
845   case ie of
846     Avail n | keep n    -> ie : rest
847             | otherwise -> rest
848     AvailTC tc ns ->
849         let left = filter keep ns in
850         if null left then rest else AvailTC tc left : rest
851
852 -- | Given an import\/export spec, construct the appropriate 'GlobalRdrElt's.
853 gresFromIE :: ImpDeclSpec -> (LIE Name, AvailInfo) -> [GlobalRdrElt]
854 gresFromIE decl_spec (L loc ie, avail)
855   = gresFromAvail prov_fn avail
856   where
857     is_explicit = case ie of
858                     IEThingAll name -> \n -> n == name
859                     _               -> \_ -> True
860     prov_fn name = Imported [imp_spec]
861         where
862           imp_spec  = ImpSpec { is_decl = decl_spec, is_item = item_spec }
863           item_spec = ImpSome { is_explicit = is_explicit name, is_iloc = loc }
864
865 mkChildEnv :: [GlobalRdrElt] -> NameEnv [Name]
866 mkChildEnv gres = foldr add emptyNameEnv gres
867     where
868         add (GRE { gre_name = n, gre_par = ParentIs p }) env = extendNameEnv_Acc (:) singleton env p n
869         add _                                            env = env
870
871 findChildren :: NameEnv [Name] -> Name -> [Name]
872 findChildren env n = lookupNameEnv env n `orElse` []
873
874 -- | Combines 'AvailInfo's from the same family
875 -- 'avails' may have several items with the same availName
876 -- E.g  import Ix( Ix(..), index )
877 -- will give Ix(Ix,index,range) and Ix(index)
878 -- We want to combine these; addAvail does that
879 nubAvails :: [AvailInfo] -> [AvailInfo]
880 nubAvails avails = nameEnvElts (foldl add emptyNameEnv avails)
881   where
882     add env avail = extendNameEnv_C plusAvail env (availName avail) avail
883 \end{code}
884
885
886 %************************************************************************
887 %*                                                                      *
888 \subsection{Export list processing}
889 %*                                                                      *
890 %************************************************************************
891
892 Processing the export list.
893
894 You might think that we should record things that appear in the export
895 list as ``occurrences'' (using @addOccurrenceName@), but you'd be
896 wrong.  We do check (here) that they are in scope, but there is no
897 need to slurp in their actual declaration (which is what
898 @addOccurrenceName@ forces).
899
900 Indeed, doing so would big trouble when compiling @PrelBase@, because
901 it re-exports @GHC@, which includes @takeMVar#@, whose type includes
902 @ConcBase.StateAndSynchVar#@, and so on...
903
904 Note [Exports of data families]
905 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
906 Suppose you see (Trac #5306)
907         module M where
908           import X( F )
909           data instance F Int = FInt
910 What does M export?  AvailTC F [FInt] 
911                   or AvailTC F [F,FInt]?
912 The former is strictly right because F isn't defined in this module.
913 But then you can never do an explicit import of M, thus
914     import M( F( FInt ) )
915 becuase F isn't exported by M.  Nor can you import FInt alone from here
916     import M( FInt )
917 because we don't have syntax to support that.  (It looks like an import of 
918 the type FInt.)
919
920 At one point I implemented a compromise:
921   * When constructing exports with no export list, or with module M(
922     module M ), we add the parent to the exports as well.
923   * But not when you see module M( f ), even if f is a 
924     class method with a parent.  
925   * Nor when you see module M( module N ), with N /= M.
926
927 But the compromise seemed too much of a hack, so we backed it out.
928 You just have to use an explicit export list:
929     module M( F(..) ) where ...
930
931 \begin{code}
932 type ExportAccum        -- The type of the accumulating parameter of
933                         -- the main worker function in rnExports
934      = ([LIE Name],             -- Export items with Names
935         ExportOccMap,           -- Tracks exported occurrence names
936         [AvailInfo])            -- The accumulated exported stuff
937                                 --   Not nub'd!
938
939 emptyExportAccum :: ExportAccum
940 emptyExportAccum = ([], emptyOccEnv, [])
941
942 type ExportOccMap = OccEnv (Name, IE RdrName)
943         -- Tracks what a particular exported OccName
944         --   in an export list refers to, and which item
945         --   it came from.  It's illegal to export two distinct things
946         --   that have the same occurrence name
947
948 rnExports :: Bool       -- False => no 'module M(..) where' header at all
949           -> Maybe [LIE RdrName]        -- Nothing => no explicit export list
950           -> TcGblEnv
951           -> RnM TcGblEnv
952
953         -- Complains if two distinct exports have same OccName
954         -- Warns about identical exports.
955         -- Complains about exports items not in scope
956
957 rnExports explicit_mod exports
958           tcg_env@(TcGblEnv { tcg_mod     = this_mod,
959                               tcg_rdr_env = rdr_env,
960                               tcg_imports = imports })
961  = do   {
962         -- If the module header is omitted altogether, then behave
963         -- as if the user had written "module Main(main) where..."
964         -- EXCEPT in interactive mode, when we behave as if he had
965         -- written "module Main where ..."
966         -- Reason: don't want to complain about 'main' not in scope
967         --         in interactive mode
968         ; dflags <- getDynFlags
969         ; let real_exports
970                  | explicit_mod = exports
971                  | ghcLink dflags == LinkInMemory = Nothing
972                  | otherwise = Just ([noLoc (IEVar main_RDR_Unqual)])
973                         -- ToDo: the 'noLoc' here is unhelpful if 'main'
974                         --       turns out to be out of scope
975
976         ; (rn_exports, avails) <- exports_from_avail real_exports rdr_env imports this_mod
977         ; let final_avails = nubAvails avails    -- Combine families
978
979         ; traceRn (vcat [ text "rnExports: RdrEnv:" <+> ppr rdr_env
980                         , text "     Exports:" <+> ppr final_avails] )
981
982         ; return (tcg_env { tcg_exports    = final_avails,
983                             tcg_rn_exports = case tcg_rn_exports tcg_env of
984                                                 Nothing -> Nothing
985                                                 Just _  -> rn_exports,
986                             tcg_dus = tcg_dus tcg_env `plusDU`
987                                       usesOnly (availsToNameSet final_avails) }) }
988
989 exports_from_avail :: Maybe [LIE RdrName]
990                          -- Nothing => no explicit export list
991                    -> GlobalRdrEnv
992                    -> ImportAvails
993                    -> Module
994                    -> RnM (Maybe [LIE Name], [AvailInfo])
995
996 exports_from_avail Nothing rdr_env _imports _this_mod
997  = -- The same as (module M) where M is the current module name,
998    -- so that's how we handle it.
999    let
1000        avails = [ greExportAvail gre 
1001                 | gre <- globalRdrEnvElts rdr_env
1002                 , isLocalGRE gre ]
1003    in
1004    return (Nothing, avails)
1005
1006 exports_from_avail (Just rdr_items) rdr_env imports this_mod
1007   = do (ie_names, _, exports) <- foldlM do_litem emptyExportAccum rdr_items
1008
1009        return (Just ie_names, exports)
1010   where
1011     do_litem :: ExportAccum -> LIE RdrName -> RnM ExportAccum
1012     do_litem acc lie = setSrcSpan (getLoc lie) (exports_from_item acc lie)
1013
1014     kids_env :: NameEnv [Name]  -- Maps a parent to its in-scope children
1015     kids_env = mkChildEnv (globalRdrEnvElts rdr_env)
1016
1017     imported_modules = [ qual_name
1018                        | xs <- moduleEnvElts $ imp_mods imports,
1019                          (qual_name, _, _, _) <- xs ]
1020
1021     exports_from_item :: ExportAccum -> LIE RdrName -> RnM ExportAccum
1022     exports_from_item acc@(ie_names, occs, exports)
1023                       (L loc (IEModuleContents mod))
1024         | let earlier_mods = [ mod | (L _ (IEModuleContents mod)) <- ie_names ]
1025         , mod `elem` earlier_mods    -- Duplicate export of M
1026         = do { warn_dup_exports <- woptM Opt_WarnDuplicateExports ;
1027                warnIf warn_dup_exports (dupModuleExport mod) ;
1028                return acc }
1029
1030         | otherwise
1031         = do { implicit_prelude <- xoptM Opt_ImplicitPrelude
1032              ; warnDodgyExports <- woptM Opt_WarnDodgyExports
1033              ; let { exportValid = (mod `elem` imported_modules)
1034                                 || (moduleName this_mod == mod)
1035                    ; gres = filter (isModuleExported implicit_prelude mod)
1036                                    (globalRdrEnvElts rdr_env)
1037                    ; new_exports = map greExportAvail gres
1038                    ; names       = map gre_name gres }
1039
1040              ; checkErr exportValid (moduleNotImported mod)
1041              ; warnIf (warnDodgyExports && exportValid && null names) 
1042                       (nullModuleExport mod)
1043
1044              ; addUsedRdrNames (concat [ [mkRdrQual mod occ, mkRdrUnqual occ]
1045                                        | occ <- map nameOccName names ])
1046                         -- The qualified and unqualified version of all of
1047                         -- these names are, in effect, used by this export
1048
1049              ; occs' <- check_occs (IEModuleContents mod) occs names
1050                       -- This check_occs not only finds conflicts
1051                       -- between this item and others, but also
1052                       -- internally within this item.  That is, if
1053                       -- 'M.x' is in scope in several ways, we'll have
1054                       -- several members of mod_avails with the same
1055                       -- OccName.
1056              ; traceRn (vcat [ text "export mod" <+> ppr mod
1057                              , ppr new_exports ])
1058              ; return (L loc (IEModuleContents mod) : ie_names,
1059                        occs', new_exports ++ exports) }
1060
1061     exports_from_item acc@(lie_names, occs, exports) (L loc ie)
1062         | isDoc ie
1063         = do new_ie <- lookup_doc_ie ie
1064              return (L loc new_ie : lie_names, occs, exports)
1065
1066         | otherwise
1067         = do (new_ie, avail) <- lookup_ie ie
1068              if isUnboundName (ieName new_ie)
1069                   then return acc    -- Avoid error cascade
1070                   else do
1071
1072              occs' <- check_occs ie occs (availNames avail)
1073
1074              return (L loc new_ie : lie_names, occs', avail : exports)
1075
1076     -------------
1077     lookup_ie :: IE RdrName -> RnM (IE Name, AvailInfo)
1078     lookup_ie (IEVar rdr)
1079         = do gre <- lookupGreRn rdr
1080              return (IEVar (gre_name gre), greExportAvail gre)
1081
1082     lookup_ie (IEThingAbs rdr)
1083         = do gre <- lookupGreRn rdr
1084              let name = gre_name gre
1085              case gre_par gre of
1086                 NoParent   -> return (IEThingAbs name,
1087                                       AvailTC name [name])
1088                 ParentIs p -> return (IEThingAbs name,
1089                                       AvailTC p [name])
1090
1091     lookup_ie ie@(IEThingAll rdr)
1092         = do name <- lookupGlobalOccRn rdr
1093              let kids = findChildren kids_env name
1094                  mkKidRdrName = case isQual_maybe rdr of
1095                                 Nothing -> mkRdrUnqual
1096                                 Just (modName, _) -> mkRdrQual modName
1097              addUsedRdrNames $ map (mkKidRdrName . nameOccName) 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 env = mkOccEnv [ (nameOccName s, s)
1114                                 | s <- findChildren kids_env name ]
1115                  mb_names = map (lookupOccEnv env . rdrNameOcc) sub_rdrs
1116              if any isNothing mb_names
1117                 then do addErr (exportItemErr ie)
1118                         return (IEThingWith name [], AvailTC name [name])
1119                 else do let names = catMaybes mb_names
1120                         optTyFam <- xoptM Opt_TypeFamilies
1121                         when (not optTyFam && any isTyConName names) $
1122                           addErr (typeItemErr ( head
1123                                               . filter isTyConName
1124                                               $ names )
1125                                               (text "in export list"))
1126                         return (IEThingWith name names, AvailTC name (name:names))
1127
1128     lookup_ie _ = panic "lookup_ie"    -- Other cases covered earlier
1129
1130     -------------
1131     lookup_doc_ie :: IE RdrName -> RnM (IE Name)
1132     lookup_doc_ie (IEGroup lev doc) = do rn_doc <- rnHsDoc doc
1133                                          return (IEGroup lev rn_doc)
1134     lookup_doc_ie (IEDoc doc)       = do rn_doc <- rnHsDoc doc
1135                                          return (IEDoc rn_doc)
1136     lookup_doc_ie (IEDocNamed str)  = return (IEDocNamed str)
1137     lookup_doc_ie _ = panic "lookup_doc_ie"    -- Other cases covered earlier
1138
1139
1140 isDoc :: IE RdrName -> Bool
1141 isDoc (IEDoc _)      = True
1142 isDoc (IEDocNamed _) = True
1143 isDoc (IEGroup _ _)  = True
1144 isDoc _ = False
1145
1146 -------------------------------
1147 isModuleExported :: Bool -> ModuleName -> GlobalRdrElt -> Bool
1148 -- True if the thing is in scope *both* unqualified, *and* with qualifier M
1149 isModuleExported implicit_prelude mod (GRE { gre_name = name, gre_prov = prov })
1150   | implicit_prelude && isBuiltInSyntax name = False
1151         -- Optimisation: filter out names for built-in syntax
1152         -- They just clutter up the environment (esp tuples), and the parser
1153         -- will generate Exact RdrNames for them, so the cluttered
1154         -- envt is no use.  To avoid doing this filter all the time,
1155         -- we use -XNoImplicitPrelude as a clue that the filter is
1156         -- worth while.  Really, it's only useful for GHC.Base and GHC.Tuple.
1157         --
1158         -- It's worth doing because it makes the environment smaller for
1159         -- every module that imports the Prelude
1160   | otherwise
1161   = case prov of
1162         LocalDef | Just name_mod <- nameModule_maybe name
1163                  -> moduleName name_mod == mod
1164                  | otherwise -> False
1165         Imported is -> any unQualSpecOK is && any (qualSpecOK mod) is
1166
1167 -------------------------------
1168 check_occs :: IE RdrName -> ExportOccMap -> [Name] -> RnM ExportOccMap
1169 check_occs ie occs names  -- 'names' are the entities specifed by 'ie'
1170   = foldlM check occs names
1171   where
1172     check occs name
1173       = case lookupOccEnv occs name_occ of
1174           Nothing -> return (extendOccEnv occs name_occ (name, ie))
1175
1176           Just (name', ie')
1177             | name == name'   -- Duplicate export
1178             -- But we don't want to warn if the same thing is exported
1179             -- by two different module exports. See ticket #4478.
1180             -> do unless (dupExport_ok name ie ie') $ do
1181                       warn_dup_exports <- woptM Opt_WarnDuplicateExports
1182                       warnIf warn_dup_exports (dupExportWarn name_occ ie ie')
1183                   return occs
1184
1185             | otherwise    -- Same occ name but different names: an error
1186             ->  do { global_env <- getGlobalRdrEnv ;
1187                      addErr (exportClashErr global_env name' name ie' ie) ;
1188                      return occs }
1189       where
1190         name_occ = nameOccName name
1191
1192
1193 dupExport_ok :: Name -> IE RdrName -> IE RdrName -> Bool
1194 -- The Name is exported by both IEs. Is that ok?
1195 -- "No"  iff the name is mentioned explicitly in both IEs
1196 --        or one of the IEs mentions the name *alone*
1197 -- "Yes" otherwise
1198 -- 
1199 -- Examples of "no":  module M( f, f )
1200 --                    module M( fmap, Functor(..) )
1201 --                    module M( module Data.List, head )
1202 --
1203 -- Example of "yes"
1204 --    module M( module A, module B ) where
1205 --        import A( f )
1206 --        import B( f )
1207 --
1208 -- Example of "yes" (Trac #2436)
1209 --    module M( C(..), T(..) ) where
1210 --         class C a where { data T a }
1211 --         instace C Int where { data T Int = TInt }
1212 -- 
1213 -- Example of "yes" (Trac #2436)
1214 --    module Foo ( T ) where
1215 --      data family T a
1216 --    module Bar ( T(..), module Foo ) where
1217 --        import Foo
1218 --        data instance T Int = TInt
1219
1220 dupExport_ok n ie1 ie2 
1221   = not (  single ie1 || single ie2
1222         || (explicit_in ie1 && explicit_in ie2) )
1223   where
1224     explicit_in (IEModuleContents _) = False                -- module M
1225     explicit_in (IEThingAll r) = nameOccName n == rdrNameOcc r  -- T(..)
1226     explicit_in _              = True
1227   
1228     single (IEVar {})      = True
1229     single (IEThingAbs {}) = True
1230     single _               = False
1231 \end{code}
1232
1233 %*********************************************************
1234 %*                                                       *
1235 \subsection{Deprecations}
1236 %*                                                       *
1237 %*********************************************************
1238
1239 \begin{code}
1240 finishWarnings :: DynFlags -> Maybe WarningTxt
1241                -> TcGblEnv -> RnM TcGblEnv
1242 -- (a) Report usage of imports that are deprecated or have other warnings
1243 -- (b) If the whole module is warned about or deprecated, update tcg_warns
1244 --     All this happens only once per module
1245 finishWarnings dflags mod_warn tcg_env
1246   = do  { (eps,hpt) <- getEpsAndHpt
1247         ; ifWOptM Opt_WarnWarningsDeprecations $
1248           mapM_ (check hpt (eps_PIT eps)) all_gres
1249                 -- By this time, typechecking is complete,
1250                 -- so the PIT is fully populated
1251
1252         -- Deal with a module deprecation; it overrides all existing warns
1253         ; let new_warns = case mod_warn of
1254                                 Just txt -> WarnAll txt
1255                                 Nothing  -> tcg_warns tcg_env
1256         ; return (tcg_env { tcg_warns = new_warns }) }
1257   where
1258     used_names = allUses (tcg_dus tcg_env)
1259         -- Report on all deprecated uses; hence allUses
1260     all_gres   = globalRdrEnvElts (tcg_rdr_env tcg_env)
1261
1262     check hpt pit gre@(GRE {gre_name = name, gre_prov = Imported (imp_spec:_)})
1263       | name `elemNameSet` used_names
1264       , Just deprec_txt <- lookupImpDeprec dflags hpt pit gre
1265       = addWarnAt (importSpecLoc imp_spec)
1266                   (sep [ptext (sLit "In the use of") <+>
1267                         pprNonVarNameSpace (occNameSpace (nameOccName name)) <+>
1268                         quotes (ppr name),
1269                       (parens imp_msg) <> colon,
1270                       (ppr deprec_txt) ])
1271         where
1272           name_mod = ASSERT2( isExternalName name, ppr name ) nameModule name
1273           imp_mod  = importSpecModule imp_spec
1274           imp_msg  = ptext (sLit "imported from") <+> ppr imp_mod <> extra
1275           extra | imp_mod == moduleName name_mod = empty
1276                 | otherwise = ptext (sLit ", but defined in") <+> ppr name_mod
1277
1278     check _ _ _ = return ()        -- Local, or not used, or not deprectated
1279             -- The Imported pattern-match: don't deprecate locally defined names
1280             -- For a start, we may be exporting a deprecated thing
1281             -- Also we may use a deprecated thing in the defn of another
1282             -- deprecated things.  We may even use a deprecated thing in
1283             -- the defn of a non-deprecated thing, when changing a module's
1284             -- interface
1285
1286 lookupImpDeprec :: DynFlags -> HomePackageTable -> PackageIfaceTable
1287                 -> GlobalRdrElt -> Maybe WarningTxt
1288 -- The name is definitely imported, so look in HPT, PIT
1289 lookupImpDeprec dflags hpt pit gre
1290   = case lookupIfaceByModule dflags hpt pit mod of
1291         Just iface -> mi_warn_fn iface name `mplus`    -- Bleat if the thing, *or
1292                       case gre_par gre of
1293                         ParentIs p -> mi_warn_fn iface p    -- its parent*, is warn'd
1294                         NoParent   -> Nothing
1295
1296         Nothing -> Nothing    -- See Note [Used names with interface not loaded]
1297   where
1298     name = gre_name gre
1299     mod = ASSERT2( isExternalName name, ppr name ) nameModule name
1300 \end{code}
1301
1302 Note [Used names with interface not loaded]
1303 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1304 By now all the interfaces should have been loaded,
1305 because reportDeprecations happens after typechecking.
1306 However, it's still (just) possible to to find a used
1307 Name whose interface hasn't been loaded:
1308
1309 a) It might be a WiredInName; in that case we may not load
1310    its interface (although we could).
1311
1312 b) It might be GHC.Real.fromRational, or GHC.Num.fromInteger
1313    These are seen as "used" by the renamer (if -XRebindableSyntax)
1314    is on), but the typechecker may discard their uses
1315    if in fact the in-scope fromRational is GHC.Read.fromRational,
1316    (see tcPat.tcOverloadedLit), and the typechecker sees that the type
1317    is fixed, say, to GHC.Base.Float (see Inst.lookupSimpleInst).
1318    In that obscure case it won't force the interface in.
1319
1320 In both cases we simply don't permit deprecations;
1321 this is, after all, wired-in stuff.
1322
1323
1324 %*********************************************************
1325 %*                                                       *
1326 \subsection{Unused names}
1327 %*                                                       *
1328 %*********************************************************
1329
1330 \begin{code}
1331 reportUnusedNames :: Maybe [LIE RdrName]    -- Export list
1332                   -> TcGblEnv -> RnM ()
1333 reportUnusedNames _export_decls gbl_env
1334   = do  { traceRn ((text "RUN") <+> (ppr (tcg_dus gbl_env)))
1335         ; warnUnusedImportDecls gbl_env
1336         ; warnUnusedTopBinds   unused_locals }
1337   where
1338     used_names :: NameSet
1339     used_names = findUses (tcg_dus gbl_env) emptyNameSet
1340     -- NB: currently, if f x = g, we only treat 'g' as used if 'f' is used
1341     -- Hence findUses
1342
1343     -- Collect the defined names from the in-scope environment
1344     defined_names :: [GlobalRdrElt]
1345     defined_names = globalRdrEnvElts (tcg_rdr_env gbl_env)
1346
1347     -- Note that defined_and_used, defined_but_not_used
1348     -- are both [GRE]; that's why we need defined_and_used
1349     -- rather than just used_names
1350     _defined_and_used, defined_but_not_used :: [GlobalRdrElt]
1351     (_defined_and_used, defined_but_not_used)
1352         = partition (gre_is_used used_names) defined_names
1353
1354     kids_env = mkChildEnv defined_names
1355     -- This is done in mkExports too; duplicated work
1356
1357     gre_is_used :: NameSet -> GlobalRdrElt -> Bool
1358     gre_is_used used_names (GRE {gre_name = name})
1359         = name `elemNameSet` used_names
1360           || any (`elemNameSet` used_names) (findChildren kids_env name)
1361                 -- A use of C implies a use of T,
1362                 -- if C was brought into scope by T(..) or T(C)
1363
1364     -- Filter out the ones that are
1365     --  (a) defined in this module, and
1366     --  (b) not defined by a 'deriving' clause
1367     -- The latter have an Internal Name, so we can filter them out easily
1368     unused_locals :: [GlobalRdrElt]
1369     unused_locals = filter is_unused_local defined_but_not_used
1370     is_unused_local :: GlobalRdrElt -> Bool
1371     is_unused_local gre = isLocalGRE gre && isExternalName (gre_name gre)
1372 \end{code}
1373
1374 %*********************************************************
1375 %*                                                       *
1376 \subsection{Unused imports}
1377 %*                                                       *
1378 %*********************************************************
1379
1380 This code finds which import declarations are unused.  The
1381 specification and implementation notes are here:
1382   http://hackage.haskell.org/trac/ghc/wiki/Commentary/Compiler/UnusedImports
1383
1384 \begin{code}
1385 type ImportDeclUsage
1386    = ( LImportDecl Name   -- The import declaration
1387      , [AvailInfo]        -- What *is* used (normalised)
1388      , [Name] )           -- What is imported but *not* used
1389 \end{code}
1390
1391 \begin{code}
1392 warnUnusedImportDecls :: TcGblEnv -> RnM ()
1393 warnUnusedImportDecls gbl_env
1394   = do { uses <- readMutVar (tcg_used_rdrnames gbl_env)
1395        ; let imports = filter explicit_import (tcg_rn_imports gbl_env)
1396              rdr_env = tcg_rdr_env gbl_env
1397
1398        ; let usage :: [ImportDeclUsage]
1399              usage = findImportUsage imports rdr_env (Set.elems uses)
1400
1401        ; traceRn (vcat [ ptext (sLit "Uses:") <+> ppr (Set.elems uses)
1402                        , ptext (sLit "Import usage") <+> ppr usage])
1403        ; ifWOptM Opt_WarnUnusedImports $
1404          mapM_ warnUnusedImport usage
1405
1406        ; ifDOptM Opt_D_dump_minimal_imports $
1407          printMinimalImports usage }
1408   where
1409     explicit_import (L _ decl) = unLoc (ideclName decl) /= pRELUDE_NAME
1410         -- Filter out the implicit Prelude import
1411         -- which we do not want to bleat about
1412         -- This also filters out an *explicit* Prelude import
1413         -- but solving that problem involves more plumbing, and
1414         -- it just doesn't seem worth it
1415 \end{code}
1416
1417 \begin{code}
1418 findImportUsage :: [LImportDecl Name]
1419                 -> GlobalRdrEnv
1420                 -> [RdrName]
1421                 -> [ImportDeclUsage]
1422
1423 type ImportMap = Map SrcLoc [AvailInfo]
1424 -- The intermediate data struture records, for each import
1425 -- declaration, what stuff brought into scope by that
1426 -- declaration is actually used in the module.
1427 --
1428 -- The SrcLoc is the location of the start
1429 -- of a particular 'import' declaration
1430 --
1431 -- The AvailInfos are the things imported from that decl
1432 -- (just a list, not normalised)
1433
1434 findImportUsage imports rdr_env rdrs
1435   = map unused_decl imports
1436   where
1437     import_usage :: ImportMap
1438     import_usage = foldr (addUsedRdrName rdr_env) Map.empty rdrs
1439
1440     unused_decl decl@(L loc (ImportDecl { ideclHiding = imps }))
1441       = (decl, nubAvails used_avails, unused_imps)
1442       where
1443         used_avails = Map.lookup (srcSpanStart loc) import_usage `orElse` []
1444         dont_report_as_unused = foldr add emptyNameSet used_avails
1445         add (Avail n) s = s `addOneToNameSet` n
1446         add (AvailTC n ns) s = s `addListToNameSet` (n:ns)
1447        -- If you use 'signum' from Num, then the user may well have
1448        -- imported Num(signum).  We don't want to complain that
1449        -- Num is not itself mentioned.  Hence adding 'n' as
1450        -- well to the list of of "don't report if unused" names
1451
1452         unused_imps = case imps of
1453                         Just (False, imp_ies) -> nameSetToList unused_imps
1454                           where
1455                             imp_names = mkNameSet (concatMap (ieNames . unLoc) imp_ies)
1456                             unused_imps = imp_names `minusNameSet` dont_report_as_unused
1457
1458                         _other -> []    -- No explicit import list => no unused-name list
1459
1460 addUsedRdrName :: GlobalRdrEnv -> RdrName -> ImportMap -> ImportMap
1461 -- For a used RdrName, find all the import decls that brought
1462 -- it into scope; choose one of them (bestImport), and record
1463 -- the RdrName in that import decl's entry in the ImportMap
1464 addUsedRdrName rdr_env rdr imp_map
1465   | [gre] <- lookupGRE_RdrName rdr rdr_env
1466   , Imported imps <- gre_prov gre
1467   = add_imp gre (bestImport imps) imp_map
1468   | otherwise
1469   = imp_map
1470   where
1471     add_imp :: GlobalRdrElt -> ImportSpec -> ImportMap -> ImportMap
1472     add_imp gre (ImpSpec { is_decl = imp_decl_spec }) imp_map
1473       = Map.insertWith add decl_loc [avail] imp_map
1474       where
1475         add _ avails = avail : avails -- add is really just a specialised (++)
1476         decl_loc = srcSpanStart (is_dloc imp_decl_spec)
1477         name     = gre_name gre
1478         avail    = case gre_par gre of
1479                       ParentIs p                  -> AvailTC p [name]
1480                       NoParent | isTyConName name -> AvailTC name [name]
1481                                | otherwise        -> Avail name
1482
1483     bestImport :: [ImportSpec] -> ImportSpec
1484     bestImport iss
1485       = case partition isImpAll iss of
1486           ([], imp_somes) -> textuallyFirst imp_somes
1487           (imp_alls, _)   -> textuallyFirst imp_alls
1488
1489     textuallyFirst :: [ImportSpec] -> ImportSpec
1490     textuallyFirst iss = case sortWith (is_dloc . is_decl) iss of
1491                            []     -> pprPanic "textuallyFirst" (ppr iss)
1492                            (is:_) -> is
1493
1494     isImpAll :: ImportSpec -> Bool
1495     isImpAll (ImpSpec { is_item = ImpAll }) = True
1496     isImpAll _other                         = False
1497 \end{code}
1498
1499 \begin{code}
1500 warnUnusedImport :: ImportDeclUsage -> RnM ()
1501 warnUnusedImport (L loc decl, used, unused)
1502   | Just (False,[]) <- ideclHiding decl
1503                 = return ()            -- Do not warn for 'import M()'
1504   | null used   = addWarnAt loc msg1   -- Nothing used; drop entire decl
1505   | null unused = return ()            -- Everything imported is used; nop
1506   | otherwise   = addWarnAt loc msg2   -- Some imports are unused
1507   where
1508     msg1 = vcat [pp_herald <+> quotes pp_mod <+> pp_not_used,
1509                  nest 2 (ptext (sLit "except perhaps to import instances from")
1510                                    <+> quotes pp_mod),
1511                  ptext (sLit "To import instances alone, use:")
1512                                    <+> ptext (sLit "import") <+> pp_mod <> parens empty ]
1513     msg2 = sep [pp_herald <+> quotes (pprWithCommas ppr unused),
1514                     text "from module" <+> quotes pp_mod <+> pp_not_used]
1515     pp_herald   = text "The import of"
1516     pp_mod      = ppr (unLoc (ideclName decl))
1517     pp_not_used = text "is redundant"
1518 \end{code}
1519
1520 To print the minimal imports we walk over the user-supplied import
1521 decls, and simply trim their import lists.  NB that
1522
1523   * We do *not* change the 'qualified' or 'as' parts!
1524
1525   * We do not disard a decl altogether; we might need instances
1526     from it.  Instead we just trim to an empty import list
1527
1528 \begin{code}
1529 printMinimalImports :: [ImportDeclUsage] -> RnM ()
1530 printMinimalImports imports_w_usage
1531   = do { imports' <- mapM mk_minimal imports_w_usage
1532        ; this_mod <- getModule
1533        ; liftIO $
1534          do { h <- openFile (mkFilename this_mod) WriteMode
1535             ; printForUser h neverQualify (vcat (map ppr imports')) }
1536               -- The neverQualify is important.  We are printing Names
1537               -- but they are in the context of an 'import' decl, and
1538               -- we never qualify things inside there
1539               -- E.g.   import Blag( f, b )
1540               -- not    import Blag( Blag.f, Blag.g )!
1541        }
1542   where
1543     mkFilename this_mod = moduleNameString (moduleName this_mod) ++ ".imports"
1544
1545     mk_minimal (L l decl, used, unused)
1546       | null unused
1547       , Just (False, _) <- ideclHiding decl
1548       = return (L l decl)
1549       | otherwise
1550       = do { let ImportDecl { ideclName    = L _ mod_name
1551                             , ideclSource  = is_boot
1552                             , ideclPkgQual = mb_pkg } = decl
1553            ; iface <- loadSrcInterface doc mod_name is_boot mb_pkg
1554            ; let lies = map (L l) (concatMap (to_ie iface) used)
1555            ; return (L l (decl { ideclHiding = Just (False, lies) })) }
1556       where
1557         doc = text "Compute minimal imports for" <+> ppr decl
1558
1559     to_ie :: ModIface -> AvailInfo -> [IE Name]
1560     -- The main trick here is that if we're importing all the constructors
1561     -- we want to say "T(..)", but if we're importing only a subset we want
1562     -- to say "T(A,B,C)".  So we have to find out what the module exports.
1563     to_ie _ (Avail n)
1564        = [IEVar n]
1565     to_ie _ (AvailTC n [m])
1566        | n==m = [IEThingAbs n]
1567     to_ie iface (AvailTC n ns)
1568       = case [xs | AvailTC x xs <- mi_exports iface
1569                  , x == n
1570                  , x `elem` xs    -- Note [Partial export]
1571                  ] of
1572            [xs] | all_used xs -> [IEThingAll n]
1573                 | otherwise   -> [IEThingWith n (filter (/= n) ns)]
1574            _other             -> map IEVar ns
1575         where
1576           all_used avail_occs = all (`elem` ns) avail_occs
1577 \end{code}
1578
1579 Note [Partial export]
1580 ~~~~~~~~~~~~~~~~~~~~~
1581 Suppose we have
1582
1583    module A( op ) where
1584      class C a where
1585        op :: a -> a
1586
1587    module B where
1588    import A
1589    f = ..op...
1590
1591 Then the minimal import for module B is
1592    import A( op )
1593 not
1594    import A( C( op ) )
1595 which we would usually generate if C was exported from B.  Hence
1596 the (x `elem` xs) test when deciding what to generate.
1597
1598
1599 %************************************************************************
1600 %*                                                                      *
1601 \subsection{Errors}
1602 %*                                                                      *
1603 %************************************************************************
1604
1605 \begin{code}
1606 qualImportItemErr :: RdrName -> SDoc
1607 qualImportItemErr rdr
1608   = hang (ptext (sLit "Illegal qualified name in import item:"))
1609        2 (ppr rdr)
1610
1611 badImportItemErrStd :: ModIface -> ImpDeclSpec -> IE RdrName -> SDoc
1612 badImportItemErrStd iface decl_spec ie
1613   = sep [ptext (sLit "Module"), quotes (ppr (is_mod decl_spec)), source_import,
1614          ptext (sLit "does not export"), quotes (ppr ie)]
1615   where
1616     source_import | mi_boot iface = ptext (sLit "(hi-boot interface)")
1617                   | otherwise     = empty
1618
1619 badImportItemErrDataCon :: OccName -> ModIface -> ImpDeclSpec -> IE RdrName -> SDoc
1620 badImportItemErrDataCon dataType iface decl_spec ie
1621   = vcat [ ptext (sLit "In module")
1622              <+> quotes (ppr (is_mod decl_spec))
1623              <+> source_import <> colon
1624          , nest 2 $ quotes datacon
1625              <+> ptext (sLit "is a data constructor of")
1626              <+> quotes (ppr dataType)
1627          , ptext (sLit "To import it use")
1628          , nest 2 $ quotes (ptext (sLit "import"))
1629              <+> ppr (is_mod decl_spec)
1630              <> parens_sp (ppr dataType <> parens_sp datacon)
1631          , ptext (sLit "or")
1632          , nest 2 $ quotes (ptext (sLit "import"))
1633              <+> ppr (is_mod decl_spec)
1634              <> parens_sp (ppr dataType <> ptext (sLit "(..)"))
1635          ]
1636   where
1637     datacon_occ = rdrNameOcc $ ieName ie
1638     datacon = parenSymOcc datacon_occ (ppr datacon_occ) 
1639     source_import | mi_boot iface = ptext (sLit "(hi-boot interface)")
1640                   | otherwise     = empty
1641     parens_sp d = parens (space <> d <> space)  -- T( f,g )
1642
1643 badImportItemErr :: ModIface -> ImpDeclSpec -> IE RdrName -> [AvailInfo] -> SDoc
1644 badImportItemErr iface decl_spec ie avails
1645   = case find checkIfDataCon avails of
1646       Just con -> badImportItemErrDataCon (availOccName con) iface decl_spec ie
1647       Nothing  -> badImportItemErrStd iface decl_spec ie
1648   where
1649     checkIfDataCon (AvailTC _ ns) =
1650       case find (\n -> importedFS == nameOccNameFS n) ns of
1651         Just n  -> isDataConName n
1652         Nothing -> False
1653     checkIfDataCon _ = False
1654     availOccName = nameOccName . availName
1655     nameOccNameFS = occNameFS . nameOccName
1656     importedFS = occNameFS . rdrNameOcc $ ieName ie
1657
1658 illegalImportItemErr :: SDoc
1659 illegalImportItemErr = ptext (sLit "Illegal import item")
1660
1661 dodgyImportWarn :: RdrName -> SDoc
1662 dodgyImportWarn item = dodgyMsg (ptext (sLit "import")) item
1663 dodgyExportWarn :: Name -> SDoc
1664 dodgyExportWarn item = dodgyMsg (ptext (sLit "export")) item
1665
1666 dodgyMsg :: OutputableBndr n => SDoc -> n -> SDoc
1667 dodgyMsg kind tc
1668   = sep [ ptext (sLit "The") <+> kind <+> ptext (sLit "item") <+> quotes (ppr (IEThingAll tc))
1669                 <+> ptext (sLit "suggests that"),
1670           quotes (ppr tc) <+> ptext (sLit "has (in-scope) constructors or class methods,"),
1671           ptext (sLit "but it has none") ]
1672
1673 exportItemErr :: IE RdrName -> SDoc
1674 exportItemErr export_item
1675   = sep [ ptext (sLit "The export item") <+> quotes (ppr export_item),
1676           ptext (sLit "attempts to export constructors or class methods that are not visible here") ]
1677
1678 typeItemErr :: Name -> SDoc -> SDoc
1679 typeItemErr name wherestr
1680   = sep [ ptext (sLit "Using 'type' tag on") <+> quotes (ppr name) <+> wherestr,
1681           ptext (sLit "Use -XTypeFamilies to enable this extension") ]
1682
1683 exportClashErr :: GlobalRdrEnv -> Name -> Name -> IE RdrName -> IE RdrName
1684                -> MsgDoc
1685 exportClashErr global_env name1 name2 ie1 ie2
1686   = vcat [ ptext (sLit "Conflicting exports for") <+> quotes (ppr occ) <> colon
1687          , ppr_export ie1' name1'
1688          , ppr_export ie2' name2' ]
1689   where
1690     occ = nameOccName name1
1691     ppr_export ie name = nest 3 (hang (quotes (ppr ie) <+> ptext (sLit "exports") <+>
1692                                        quotes (ppr name))
1693                                     2 (pprNameProvenance (get_gre name)))
1694
1695     -- get_gre finds a GRE for the Name, so that we can show its provenance
1696     get_gre name
1697         = case lookupGRE_Name global_env name of
1698              (gre:_) -> gre
1699              []      -> pprPanic "exportClashErr" (ppr name)
1700     get_loc name = greSrcSpan (get_gre name)
1701     (name1', ie1', name2', ie2') = if get_loc name1 < get_loc name2
1702                                    then (name1, ie1, name2, ie2)
1703                                    else (name2, ie2, name1, ie1)
1704
1705 -- the SrcSpan that pprNameProvenance prints out depends on whether
1706 -- the Name is defined locally or not: for a local definition the
1707 -- definition site is used, otherwise the location of the import
1708 -- declaration.  We want to sort the export locations in
1709 -- exportClashErr by this SrcSpan, we need to extract it:
1710 greSrcSpan :: GlobalRdrElt -> SrcSpan
1711 greSrcSpan gre
1712   | Imported (is:_) <- gre_prov gre = is_dloc (is_decl is)
1713   | otherwise                       = name_span
1714   where
1715     name_span = nameSrcSpan (gre_name gre)
1716
1717 addDupDeclErr :: [Name] -> TcRn ()
1718 addDupDeclErr []
1719   = panic "addDupDeclErr: empty list"
1720 addDupDeclErr names@(name : _)
1721   = addErrAt (getSrcSpan (last sorted_names)) $
1722     -- Report the error at the later location
1723     vcat [ptext (sLit "Multiple declarations of") <+>
1724              quotes (ppr (nameOccName name)),
1725              -- NB. print the OccName, not the Name, because the
1726              -- latter might not be in scope in the RdrEnv and so will
1727              -- be printed qualified.
1728           ptext (sLit "Declared at:") <+>
1729                    vcat (map (ppr . nameSrcLoc) sorted_names)]
1730   where
1731     sorted_names = sortWith nameSrcLoc names
1732
1733 dupExportWarn :: OccName -> IE RdrName -> IE RdrName -> SDoc
1734 dupExportWarn occ_name ie1 ie2
1735   = hsep [quotes (ppr occ_name),
1736           ptext (sLit "is exported by"), quotes (ppr ie1),
1737           ptext (sLit "and"),            quotes (ppr ie2)]
1738
1739 dupModuleExport :: ModuleName -> SDoc
1740 dupModuleExport mod
1741   = hsep [ptext (sLit "Duplicate"),
1742           quotes (ptext (sLit "Module") <+> ppr mod),
1743           ptext (sLit "in export list")]
1744
1745 moduleNotImported :: ModuleName -> SDoc
1746 moduleNotImported mod
1747   = ptext (sLit "The export item `module") <+> ppr mod <>
1748     ptext (sLit "' is not imported")
1749
1750 nullModuleExport :: ModuleName -> SDoc
1751 nullModuleExport mod
1752   = ptext (sLit "The export item `module") <+> ppr mod <> ptext (sLit "' exports nothing")
1753
1754 missingImportListWarn :: ModuleName -> SDoc
1755 missingImportListWarn mod
1756   = ptext (sLit "The module") <+> quotes (ppr mod) <+> ptext (sLit "does not have an explicit import list")
1757
1758 missingImportListItem :: IE RdrName -> SDoc
1759 missingImportListItem ie
1760   = ptext (sLit "The import item") <+> quotes (ppr ie) <+> ptext (sLit "does not have an explicit import list")
1761
1762 moduleWarn :: ModuleName -> WarningTxt -> SDoc
1763 moduleWarn mod (WarningTxt txt)
1764   = sep [ ptext (sLit "Module") <+> quotes (ppr mod) <> ptext (sLit ":"),
1765           nest 2 (vcat (map ppr txt)) ]
1766 moduleWarn mod (DeprecatedTxt txt)
1767   = sep [ ptext (sLit "Module") <+> quotes (ppr mod)
1768                                 <+> ptext (sLit "is deprecated:"),
1769           nest 2 (vcat (map ppr txt)) ]
1770
1771 packageImportErr :: SDoc
1772 packageImportErr
1773   = ptext (sLit "Package-qualified imports are not enabled; use -XPackageImports")
1774 \end{code}