2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[RnNames]{Extracting imported and top-level names in scope}
8 rnImports, getLocalNonValBinders,
9 rnExports, extendGlobalRdrEnvRn,
11 reportUnusedNames, finishWarnings,
14 #include "HsVersions.h"
18 import TcEnv ( isBrackStage )
20 import RnHsDoc ( rnHsDoc )
21 import IfaceEnv ( ifaceExportNames )
22 import LoadIface ( loadSrcInterface, loadSysInterface )
23 import TcRnMonad hiding (LIE)
25 import HeaderInfo ( mkPrelImports )
41 import Data.List ( partition, (\\), delete )
42 import qualified Data.Set as Set
49 %************************************************************************
53 %************************************************************************
56 rnImports :: [LImportDecl RdrName]
57 -> RnM ([LImportDecl Name], GlobalRdrEnv, ImportAvails,AnyHpcUsage)
60 -- PROCESS IMPORT DECLS
61 -- Do the non {- SOURCE -} ones first, so that we get a helpful
62 -- warning for {- SOURCE -} ones that are unnecessary
63 = do this_mod <- getModule
64 implicit_prelude <- doptM Opt_ImplicitPrelude
65 let prel_imports = mkPrelImports (moduleName this_mod) implicit_prelude imports
66 (source, ordinary) = partition is_source_import imports
67 is_source_import (L _ (ImportDecl _ _ is_boot _ _ _)) = is_boot
69 ifOptM Opt_WarnImplicitPrelude (
70 when (notNull prel_imports) $ addWarn (implicitPreludeWarn)
73 stuff1 <- mapM (rnImportDecl this_mod True) prel_imports
74 stuff2 <- mapM (rnImportDecl this_mod False) ordinary
75 stuff3 <- mapM (rnImportDecl this_mod False) source
76 let (decls, rdr_env, imp_avails, hpc_usage) = combine (stuff1 ++ stuff2 ++ stuff3)
77 return (decls, rdr_env, imp_avails, hpc_usage)
80 combine :: [(LImportDecl Name, GlobalRdrEnv, ImportAvails,AnyHpcUsage)]
81 -> ([LImportDecl Name], GlobalRdrEnv, ImportAvails,AnyHpcUsage)
82 combine = foldr plus ([], emptyGlobalRdrEnv, emptyImportAvails,False)
83 where plus (decl, gbl_env1, imp_avails1,hpc_usage1)
84 (decls, gbl_env2, imp_avails2,hpc_usage2)
86 gbl_env1 `plusGlobalRdrEnv` gbl_env2,
87 imp_avails1 `plusImportAvails` imp_avails2,
88 hpc_usage1 || hpc_usage2)
90 rnImportDecl :: Module -> Bool
91 -> LImportDecl RdrName
92 -> RnM (LImportDecl Name, GlobalRdrEnv, ImportAvails,AnyHpcUsage)
94 rnImportDecl this_mod implicit_prelude (L loc (ImportDecl loc_imp_mod_name mb_pkg want_boot
95 qual_only as_mod imp_details))
98 when (isJust mb_pkg) $ do
99 pkg_imports <- doptM Opt_PackageImports
100 when (not pkg_imports) $ addErr packageImportErr
102 -- If there's an error in loadInterface, (e.g. interface
103 -- file not found) we get lots of spurious errors from 'filterImports'
105 imp_mod_name = unLoc loc_imp_mod_name
106 doc = ppr imp_mod_name <+> ptext (sLit "is directly imported")
110 Nothing -> unless implicit_prelude $
111 ifOptM Opt_WarnMissingImportList (addWarn (missingImportListWarn imp_mod_name))
113 iface <- loadSrcInterface doc imp_mod_name want_boot mb_pkg
115 -- Compiler sanity check: if the import didn't say
116 -- {-# SOURCE #-} we should not get a hi-boot file
117 WARN( not want_boot && mi_boot iface, ppr imp_mod_name ) (do
119 -- Issue a user warning for a redundant {- SOURCE -} import
120 -- NB that we arrange to read all the ordinary imports before
121 -- any of the {- SOURCE -} imports.
123 -- in --make and GHCi, the compilation manager checks for this,
124 -- and indeed we shouldn't do it here because the existence of
125 -- the non-boot module depends on the compilation order, which
126 -- is not deterministic. The hs-boot test can show this up.
128 warnIf (want_boot && not (mi_boot iface) && isOneShot (ghcMode dflags))
129 (warnRedundantSourceImport imp_mod_name)
132 imp_mod = mi_module iface
133 warns = mi_warns iface
134 orph_iface = mi_orphan iface
135 has_finsts = mi_finsts iface
138 filtered_exports = filter not_this_mod (mi_exports iface)
139 not_this_mod (mod,_) = mod /= this_mod
140 -- If the module exports anything defined in this module, just
141 -- ignore it. Reason: otherwise it looks as if there are two
142 -- local definition sites for the thing, and an error gets
143 -- reported. Easiest thing is just to filter them out up
144 -- front. This situation only arises if a module imports
145 -- itself, or another module that imported it. (Necessarily,
146 -- this invoves a loop.)
148 -- Tiresome consequence: if you say
153 -- module B( AType ) where
154 -- import {-# SOURCE #-} A( AType )
156 -- then you'll get a 'B does not export AType' message. Oh well.
158 qual_mod_name = case as_mod of
159 Nothing -> imp_mod_name
160 Just another_name -> another_name
161 imp_spec = ImpDeclSpec { is_mod = imp_mod_name, is_qual = qual_only,
162 is_dloc = loc, is_as = qual_mod_name }
165 -- Get the total exports from this module
166 total_avails <- ifaceExportNames filtered_exports
168 -- filter the imports according to the import declaration
169 (new_imp_details, gbl_env) <-
170 filterImports iface imp_spec imp_details total_avails
175 -- Compute new transitive dependencies
177 orphans | orph_iface = ASSERT( not (imp_mod `elem` dep_orphs deps) )
178 imp_mod : dep_orphs deps
179 | otherwise = dep_orphs deps
181 finsts | has_finsts = ASSERT( not (imp_mod `elem` dep_finsts deps) )
182 imp_mod : dep_finsts deps
183 | otherwise = dep_finsts deps
185 pkg = modulePackageId (mi_module iface)
187 (dependent_mods, dependent_pkgs)
188 | pkg == thisPackage dflags =
189 -- Imported module is from the home package
190 -- Take its dependent modules and add imp_mod itself
191 -- Take its dependent packages unchanged
193 -- NB: (dep_mods deps) might include a hi-boot file
194 -- for the module being compiled, CM. Do *not* filter
195 -- this out (as we used to), because when we've
196 -- finished dealing with the direct imports we want to
197 -- know if any of them depended on CM.hi-boot, in
198 -- which case we should do the hi-boot consistency
199 -- check. See LoadIface.loadHiBootInterface
200 ((imp_mod_name, want_boot) : dep_mods deps, dep_pkgs deps)
203 -- Imported module is from another package
204 -- Dump the dependent modules
205 -- Add the package imp_mod comes from to the dependent packages
206 ASSERT2( not (pkg `elem` dep_pkgs deps), ppr pkg <+> ppr (dep_pkgs deps) )
207 ([], pkg : dep_pkgs deps)
209 -- True <=> import M ()
210 import_all = case imp_details of
211 Just (is_hiding, ls) -> not is_hiding && null ls
214 imports = ImportAvails {
215 imp_mods = unitModuleEnv imp_mod [(qual_mod_name, import_all, loc)],
218 imp_dep_mods = mkModDeps dependent_mods,
219 imp_dep_pkgs = dependent_pkgs
222 -- Complain if we import a deprecated module
223 ifOptM Opt_WarnWarningsDeprecations (
225 WarnAll txt -> addWarn (moduleWarn imp_mod_name txt)
229 let new_imp_decl = L loc (ImportDecl loc_imp_mod_name mb_pkg want_boot
230 qual_only as_mod new_imp_details)
232 return (new_imp_decl, gbl_env, imports, mi_hpc iface)
235 warnRedundantSourceImport :: ModuleName -> SDoc
236 warnRedundantSourceImport mod_name
237 = ptext (sLit "Unnecessary {-# SOURCE #-} in the import of module")
238 <+> quotes (ppr mod_name)
242 %************************************************************************
244 importsFromLocalDecls
246 %************************************************************************
248 From the top-level declarations of this module produce
249 * the lexical environment
251 created by its bindings.
253 Note [Top-level Names in Template Haskell decl quotes]
254 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
255 Consider a Template Haskell declaration quotation like this:
258 When renaming the declarations inside [d| ...|], we treat the
259 top level binders specially in two ways
261 1. We give them an Internal name, not (as usual) an External one.
262 Otherwise the NameCache gets confused by a second allocation of
263 M.f. (We used to invent a fake module ThFake to avoid this, but
264 that had other problems, notably in getting the correct answer for
265 nameIsLocalOrFrom in lookupFixity. So we now leave tcg_module
268 2. We make them *shadow* the outer bindings. If we don't do that,
269 we'll get a complaint when extending the GlobalRdrEnv, saying that
270 there are two bindings for 'f'.
272 This shadowing applies even if the binding for 'f' is in a
273 where-clause, and hence is in the *local* RdrEnv not the *global*
276 We find out whether we are inside a [d| ... |] by testing the TH
277 stage. This is a slight hack, because the stage field was really meant for
278 the type checker, and here we are not interested in the fields of Brack,
279 hence the error thunks in thRnBrack.
282 extendGlobalRdrEnvRn :: [AvailInfo]
284 -> RnM (TcGblEnv, TcLclEnv)
285 -- Updates both the GlobalRdrEnv and the FixityEnv
286 -- We return a new TcLclEnv only becuase we might have to
287 -- delete some bindings from it;
288 -- see Note [Top-level Names in Template Haskell decl quotes]
290 extendGlobalRdrEnvRn avails new_fixities
291 = do { (gbl_env, lcl_env) <- getEnvs
293 ; let rdr_env = tcg_rdr_env gbl_env
294 fix_env = tcg_fix_env gbl_env
296 -- Delete new_occs from global and local envs
297 -- If we are in a TemplateHaskell decl bracket,
298 -- we are going to shadow them
299 -- See Note [Top-level Names in Template Haskell decl quotes]
300 shadowP = isBrackStage stage
301 new_occs = map (nameOccName . gre_name) gres
302 rdr_env1 = hideSomeUnquals rdr_env new_occs
303 lcl_env1 = lcl_env { tcl_rdr = delListFromOccEnv (tcl_rdr lcl_env) new_occs }
304 (rdr_env2, lcl_env2) | shadowP = (rdr_env1, lcl_env1)
305 | otherwise = (rdr_env, lcl_env)
307 rdr_env3 = foldl extendGlobalRdrEnv rdr_env2 gres
308 fix_env' = foldl extend_fix_env fix_env gres
309 (rdr_env', dups) = findLocalDupsRdrEnv rdr_env3 new_occs
311 gbl_env' = gbl_env { tcg_rdr_env = rdr_env', tcg_fix_env = fix_env' }
313 ; mapM_ addDupDeclErr dups
315 ; traceRn (text "extendGlobalRdrEnvRn" <+> (ppr new_fixities $$ ppr fix_env $$ ppr fix_env'))
316 ; return (gbl_env', lcl_env2) }
318 gres = gresFromAvails LocalDef avails
320 -- If there is a fixity decl for the gre, add it to the fixity env
321 extend_fix_env fix_env gre
322 | Just (L _ fi) <- lookupFsEnv new_fixities (occNameFS occ)
323 = extendNameEnv fix_env name (FixItem occ fi)
328 occ = nameOccName name
331 @getLocalDeclBinders@ returns the names for an @HsDecl@. It's
332 used for source code.
334 *** See "THE NAMING STORY" in HsDecls ****
336 Instances of type families
337 ~~~~~~~~~~~~~~~~~~~~~~~~~~
338 Family instances contain data constructors that we need to collect and we also
339 need to descend into the type instances of associated families in class
340 instances. The type constructor of a family instance is a usage occurence.
341 Hence, we don't return it as a subname in 'AvailInfo'; otherwise, we would get
342 a duplicate declaration error.
344 Note [Looking up family names in family instances]
345 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
350 type instance M.T Int = Bool
352 We might think that we can simply use 'lookupOccRn' when processing the type
353 instance to look up 'M.T'. Alas, we can't! The type family declaration is in
354 the *same* HsGroup as the type instance declaration. Hence, as we are
355 currently collecting the binders declared in that HsGroup, these binders will
356 not have been added to the global environment yet.
358 In the case of type classes, this problem does not arise, as a class instance
359 does not define any binders of it's own. So, we simply don't attempt to look
360 up the class names of class instances in 'get_local_binders' below.
362 If we don't look up class instances, can't we get away without looking up type
363 instances, too? No, we can't. Data type instances define data constructors
366 (1) collect those in 'get_local_binders' and
367 (2) we need to get their parent name in 'get_local_binders', too, to
368 produce an appropriate 'AvailTC'.
370 This parent name is exactly the family name of the type instance that is so
371 difficult to look up.
373 We solve this problem as follows:
375 (a) We process all type declarations other than type instances first.
376 (b) Then, we compute a 'GlobalRdrEnv' from the result of the first step.
377 (c) Finally, we process all type instances (both those on the toplevel and
378 those nested in class instances) and check for the family names in the
379 'GlobalRdrEnv' produced in the previous step before using 'lookupOccRn'.
382 getLocalNonValBinders :: HsGroup RdrName -> RnM [AvailInfo]
383 -- Get all the top-level binders bound the group *except*
384 -- for value bindings, which are treated separately
385 -- Specificaly we return AvailInfo for
390 -- (in hs-boot files) value signatures
392 getLocalNonValBinders group
393 = do { gbl_env <- getGblEnv
394 ; get_local_binders gbl_env group }
396 get_local_binders :: TcGblEnv -> HsGroup RdrName -> RnM [GenAvailInfo Name]
397 get_local_binders gbl_env (HsGroup {hs_valds = ValBindsIn _ val_sigs,
398 hs_tyclds = tycl_decls,
399 hs_instds = inst_decls,
400 hs_fords = foreign_decls })
401 = do { -- separate out the family instance declarations
402 let (tyinst_decls1, tycl_decls_noinsts)
403 = partition (isFamInstDecl . unLoc) tycl_decls
404 tyinst_decls = tyinst_decls1 ++ instDeclATs inst_decls
406 -- process all type/class decls except family instances
407 ; tc_names <- mapM new_tc tycl_decls_noinsts
409 -- create a temporary rdr env of the type binders
410 ; let tc_gres = gresFromAvails LocalDef tc_names
411 tc_name_env = foldl extendGlobalRdrEnv emptyGlobalRdrEnv tc_gres
413 -- process all family instances
414 ; ti_names <- mapM (new_ti tc_name_env) tyinst_decls
416 -- finish off with value binder in case of a hs-boot file
417 ; val_names <- mapM new_simple val_bndrs
418 ; return (val_names ++ tc_names ++ ti_names) }
420 is_hs_boot = isHsBoot (tcg_src gbl_env) ;
422 for_hs_bndrs :: [Located RdrName]
423 for_hs_bndrs = [nm | L _ (ForeignImport nm _ _) <- foreign_decls]
425 -- In a hs-boot file, the value binders come from the
426 -- *signatures*, and there should be no foreign binders
427 val_bndrs :: [Located RdrName]
428 val_bndrs | is_hs_boot = [nm | L _ (TypeSig nm _) <- val_sigs]
429 | otherwise = for_hs_bndrs
431 new_simple :: Located RdrName -> RnM (GenAvailInfo Name)
432 new_simple rdr_name = do
433 nm <- newTopSrcBinder rdr_name
436 new_tc tc_decl -- NOT for type/data instances
437 = do { main_name <- newTopSrcBinder main_rdr
438 ; sub_names <- mapM newTopSrcBinder sub_rdrs
439 ; return (AvailTC main_name (main_name : sub_names)) }
441 (main_rdr : sub_rdrs) = hsTyClDeclBinders tc_decl
443 new_ti tc_name_env ti_decl -- ONLY for type/data instances
444 = do { main_name <- lookupFamInstDeclBndr tc_name_env main_rdr
445 ; sub_names <- mapM newTopSrcBinder sub_rdrs
446 ; return (AvailTC main_name sub_names) }
447 -- main_name is not bound here!
449 (main_rdr : sub_rdrs) = hsTyClDeclBinders ti_decl
451 get_local_binders _ g = pprPanic "get_local_binders" (ppr g)
455 %************************************************************************
457 \subsection{Filtering imports}
459 %************************************************************************
461 @filterImports@ takes the @ExportEnv@ telling what the imported module makes
462 available, and filters it through the import spec (if any).
465 filterImports :: ModIface
466 -> ImpDeclSpec -- The span for the entire import decl
467 -> Maybe (Bool, [LIE RdrName]) -- Import spec; True => hiding
468 -> [AvailInfo] -- What's available
469 -> RnM (Maybe (Bool, [LIE Name]), -- Import spec w/ Names
470 GlobalRdrEnv) -- Same again, but in GRE form
471 filterImports _ decl_spec Nothing all_avails
472 = return (Nothing, mkGlobalRdrEnv (gresFromAvails prov all_avails))
474 prov = Imported [ImpSpec { is_decl = decl_spec, is_item = ImpAll }]
477 filterImports iface decl_spec (Just (want_hiding, import_items)) all_avails
478 = do -- check for errors, convert RdrNames to Names
479 opt_typeFamilies <- doptM Opt_TypeFamilies
480 items1 <- mapM (lookup_lie opt_typeFamilies) import_items
482 let items2 :: [(LIE Name, AvailInfo)]
483 items2 = concat items1
484 -- NB the AvailInfo may have duplicates, and several items
485 -- for the same parent; e.g N(x) and N(y)
487 names = availsToNameSet (map snd items2)
488 keep n = not (n `elemNameSet` names)
489 pruned_avails = filterAvails keep all_avails
490 hiding_prov = Imported [ImpSpec { is_decl = decl_spec, is_item = ImpAll }]
492 gres | want_hiding = gresFromAvails hiding_prov pruned_avails
493 | otherwise = concatMap (gresFromIE decl_spec) items2
495 return (Just (want_hiding, map fst items2), mkGlobalRdrEnv gres)
497 -- This environment is how we map names mentioned in the import
498 -- list to the actual Name they correspond to, and the name family
499 -- that the Name belongs to (the AvailInfo). The situation is
500 -- complicated by associated families, which introduce a three-level
501 -- hierachy, where class = grand parent, assoc family = parent, and
502 -- data constructors = children. The occ_env entries for associated
503 -- families needs to capture all this information; hence, we have the
504 -- third component of the environment that gives the class name (=
505 -- grand parent) in case of associated families.
507 -- This env will have entries for data constructors too,
508 -- they won't make any difference because naked entities like T
509 -- in an import list map to TcOccs, not VarOccs.
510 occ_env :: OccEnv (Name, -- the name
511 AvailInfo, -- the export item providing the name
512 Maybe Name) -- the parent of associated types
513 occ_env = mkOccEnv_C combine [ (nameOccName n, (n, a, Nothing))
514 | a <- all_avails, n <- availNames a]
516 -- we know that (1) there are at most entries for one name, (2) their
517 -- first component is identical, (3) they are for tys/cls, and (4) one
518 -- entry has the name in its parent position (the other doesn't)
519 combine (name, AvailTC p1 subs1, Nothing)
520 (_ , AvailTC p2 subs2, Nothing)
522 (parent, subs) = if p1 == name then (p2, subs1) else (p1, subs2)
524 (name, AvailTC name subs, Just parent)
525 combine x y = pprPanic "filterImports/combine" (ppr x $$ ppr y)
527 lookup_lie :: Bool -> LIE RdrName -> TcRn [(LIE Name, AvailInfo)]
528 lookup_lie opt_typeFamilies (L loc ieRdr)
530 stuff <- setSrcSpan loc $
531 case lookup_ie opt_typeFamilies ieRdr of
532 Failed err -> addErr err >> return []
533 Succeeded a -> return a
534 checkDodgyImport stuff
535 return [ (L loc ie, avail) | (ie,avail) <- stuff ]
537 -- Warn when importing T(..) if T was exported abstractly
538 checkDodgyImport stuff
539 | IEThingAll n <- ieRdr, (_, AvailTC _ [_]):_ <- stuff
540 = ifOptM Opt_WarnDodgyImports (addWarn (dodgyImportWarn n))
541 -- NB. use the RdrName for reporting the warning
545 -- For each import item, we convert its RdrNames to Names,
546 -- and at the same time construct an AvailInfo corresponding
547 -- to what is actually imported by this item.
548 -- Returns Nothing on error.
549 -- We return a list here, because in the case of an import
550 -- item like C, if we are hiding, then C refers to *both* a
551 -- type/class and a data constructor. Moreover, when we import
552 -- data constructors of an associated family, we need separate
553 -- AvailInfos for the data constructors and the family (as they have
554 -- different parents). See the discussion at occ_env.
555 lookup_ie :: Bool -> IE RdrName -> MaybeErr Message [(IE Name,AvailInfo)]
556 lookup_ie opt_typeFamilies ie
557 = let bad_ie = Failed (badImportItemErr iface decl_spec ie)
560 | isQual rdr = Failed (qualImportItemErr rdr)
561 | Just nm <- lookupOccEnv occ_env (rdrNameOcc rdr) = return nm
566 (name, avail, _) <- lookup_name n
567 return [(IEVar name, trimAvail avail name)]
570 (name, avail@(AvailTC name2 subs), mb_parent) <- lookup_name tc
572 -- non-associated ty/cls
573 Nothing -> return [(IEThingAll name, avail)]
575 Just parent -> return [(IEThingAll name,
576 AvailTC name2 (subs \\ [name])),
577 (IEThingAll name, AvailTC parent [name])]
580 | want_hiding -- hiding ( C )
581 -- Here the 'C' can be a data constructor
582 -- *or* a type/class, or even both
583 -> let tc_name = lookup_name tc
584 dc_name = lookup_name (setRdrNameSpace tc srcDataName)
586 case catMaybeErr [ tc_name, dc_name ] of
588 names -> return [mkIEThingAbs name | name <- names]
590 -> do nameAvail <- lookup_name tc
591 return [mkIEThingAbs nameAvail]
593 IEThingWith tc ns -> do
594 (name, AvailTC _ subnames, mb_parent) <- lookup_name tc
596 env = mkOccEnv [(nameOccName s, s) | s <- subnames]
597 mb_children = map (lookupOccEnv env . rdrNameOcc) ns
598 children <- if any isNothing mb_children
600 else return (catMaybes mb_children)
601 -- check for proper import of type families
602 when (not opt_typeFamilies && any isTyConName children) $
603 Failed (typeItemErr (head . filter isTyConName $ children)
604 (text "in import list"))
606 -- non-associated ty/cls
607 Nothing -> return [(IEThingWith name children,
608 AvailTC name (name:children))]
610 Just parent -> return [(IEThingWith name children,
611 AvailTC name children),
612 (IEThingWith name children,
613 AvailTC parent [name])]
615 _other -> Failed illegalImportItemErr
616 -- could be IEModuleContents, IEGroup, IEDoc, IEDocNamed
620 mkIEThingAbs (n, av, Nothing ) = (IEThingAbs n, trimAvail av n)
621 mkIEThingAbs (n, _, Just parent) = (IEThingAbs n, AvailTC parent [n])
624 catMaybeErr :: [MaybeErr err a] -> [a]
625 catMaybeErr ms = [ a | Succeeded a <- ms ]
628 %************************************************************************
632 %************************************************************************
635 -- | make a 'GlobalRdrEnv' where all the elements point to the same
636 -- import declaration (useful for "hiding" imports, or imports with
638 gresFromAvails :: Provenance -> [AvailInfo] -> [GlobalRdrElt]
639 gresFromAvails prov avails
640 = concatMap (gresFromAvail (const prov)) avails
642 gresFromAvail :: (Name -> Provenance) -> AvailInfo -> [GlobalRdrElt]
643 gresFromAvail prov_fn avail
644 = [ GRE {gre_name = n,
645 gre_par = availParent n avail,
646 gre_prov = prov_fn n}
647 | n <- availNames avail ]
649 greAvail :: GlobalRdrElt -> AvailInfo
650 greAvail gre = mkUnitAvail (gre_name gre) (gre_par gre)
652 mkUnitAvail :: Name -> Parent -> AvailInfo
653 mkUnitAvail me (ParentIs p) = AvailTC p [me]
654 mkUnitAvail me NoParent | isTyConName me = AvailTC me [me]
655 | otherwise = Avail me
657 plusAvail :: GenAvailInfo Name -> GenAvailInfo Name -> GenAvailInfo Name
658 plusAvail (Avail n1) (Avail _) = Avail n1
659 plusAvail (AvailTC _ ns1) (AvailTC n2 ns2) = AvailTC n2 (ns1 `unionLists` ns2)
660 plusAvail a1 a2 = pprPanic "RnEnv.plusAvail" (hsep [ppr a1,ppr a2])
662 availParent :: Name -> AvailInfo -> Parent
663 availParent _ (Avail _) = NoParent
664 availParent n (AvailTC m _) | n == m = NoParent
665 | otherwise = ParentIs m
667 trimAvail :: AvailInfo -> Name -> AvailInfo
668 trimAvail (Avail n) _ = Avail n
669 trimAvail (AvailTC n ns) m = ASSERT( m `elem` ns) AvailTC n [m]
671 -- | filters 'AvailInfo's by the given predicate
672 filterAvails :: (Name -> Bool) -> [AvailInfo] -> [AvailInfo]
673 filterAvails keep avails = foldr (filterAvail keep) [] avails
675 -- | filters an 'AvailInfo' by the given predicate
676 filterAvail :: (Name -> Bool) -> AvailInfo -> [AvailInfo] -> [AvailInfo]
677 filterAvail keep ie rest =
679 Avail n | keep n -> ie : rest
682 let left = filter keep ns in
683 if null left then rest else AvailTC tc left : rest
685 -- | Given an import\/export spec, construct the appropriate 'GlobalRdrElt's.
686 gresFromIE :: ImpDeclSpec -> (LIE Name, AvailInfo) -> [GlobalRdrElt]
687 gresFromIE decl_spec (L loc ie, avail)
688 = gresFromAvail prov_fn avail
690 is_explicit = case ie of
691 IEThingAll name -> \n -> n == name
693 prov_fn name = Imported [imp_spec]
695 imp_spec = ImpSpec { is_decl = decl_spec, is_item = item_spec }
696 item_spec = ImpSome { is_explicit = is_explicit name, is_iloc = loc }
698 mkChildEnv :: [GlobalRdrElt] -> NameEnv [Name]
699 mkChildEnv gres = foldr add emptyNameEnv gres
701 add (GRE { gre_name = n, gre_par = ParentIs p }) env = extendNameEnv_Acc (:) singleton env p n
704 findChildren :: NameEnv [Name] -> Name -> [Name]
705 findChildren env n = lookupNameEnv env n `orElse` []
708 ---------------------------------------
711 All this AvailEnv stuff is hardly used; only in a very small
712 part of RnNames. Todo: remove?
713 ---------------------------------------
716 type AvailEnv = NameEnv AvailInfo -- Maps a Name to the AvailInfo that contains it
718 emptyAvailEnv :: AvailEnv
719 emptyAvailEnv = emptyNameEnv
722 unitAvailEnv :: AvailInfo -> AvailEnv
723 unitAvailEnv a = unitNameEnv (availName a) a
725 plusAvailEnv :: AvailEnv -> AvailEnv -> AvailEnv
726 plusAvailEnv = plusNameEnv_C plusAvail
728 availEnvElts :: AvailEnv -> [AvailInfo]
729 availEnvElts = nameEnvElts
732 addAvail :: AvailEnv -> AvailInfo -> AvailEnv
733 addAvail avails avail = extendNameEnv_C plusAvail avails (availName avail) avail
735 mkAvailEnv :: [AvailInfo] -> AvailEnv
736 -- 'avails' may have several items with the same availName
737 -- E.g import Ix( Ix(..), index )
738 -- will give Ix(Ix,index,range) and Ix(index)
739 -- We want to combine these; addAvail does that
740 mkAvailEnv avails = foldl addAvail emptyAvailEnv avails
742 -- After combining the avails, we need to ensure that the parent name is the
743 -- first entry in the list of subnames, if it is included at all. (Subsequent
744 -- functions rely on that.)
745 normaliseAvail :: AvailInfo -> AvailInfo
746 normaliseAvail avail@(Avail _) = avail
747 normaliseAvail (AvailTC name subs) = AvailTC name subs'
749 subs' = if name `elem` subs then name : (delete name subs) else subs
751 -- | combines 'AvailInfo's from the same family
752 nubAvails :: [AvailInfo] -> [AvailInfo]
753 nubAvails avails = map normaliseAvail . nameEnvElts . mkAvailEnv $ avails
757 %************************************************************************
759 \subsection{Export list processing}
761 %************************************************************************
763 Processing the export list.
765 You might think that we should record things that appear in the export
766 list as ``occurrences'' (using @addOccurrenceName@), but you'd be
767 wrong. We do check (here) that they are in scope, but there is no
768 need to slurp in their actual declaration (which is what
769 @addOccurrenceName@ forces).
771 Indeed, doing so would big trouble when compiling @PrelBase@, because
772 it re-exports @GHC@, which includes @takeMVar#@, whose type includes
773 @ConcBase.StateAndSynchVar#@, and so on...
776 type ExportAccum -- The type of the accumulating parameter of
777 -- the main worker function in rnExports
778 = ([LIE Name], -- Export items with Names
779 ExportOccMap, -- Tracks exported occurrence names
780 [AvailInfo]) -- The accumulated exported stuff
783 emptyExportAccum :: ExportAccum
784 emptyExportAccum = ([], emptyOccEnv, [])
786 type ExportOccMap = OccEnv (Name, IE RdrName)
787 -- Tracks what a particular exported OccName
788 -- in an export list refers to, and which item
789 -- it came from. It's illegal to export two distinct things
790 -- that have the same occurrence name
792 rnExports :: Bool -- False => no 'module M(..) where' header at all
793 -> Maybe [LIE RdrName] -- Nothing => no explicit export list
797 -- Complains if two distinct exports have same OccName
798 -- Warns about identical exports.
799 -- Complains about exports items not in scope
801 rnExports explicit_mod exports
802 tcg_env@(TcGblEnv { tcg_mod = this_mod,
803 tcg_rdr_env = rdr_env,
804 tcg_imports = imports })
806 -- If the module header is omitted altogether, then behave
807 -- as if the user had written "module Main(main) where..."
808 -- EXCEPT in interactive mode, when we behave as if he had
809 -- written "module Main where ..."
810 -- Reason: don't want to complain about 'main' not in scope
811 -- in interactive mode
814 | explicit_mod = exports
815 | ghcLink dflags == LinkInMemory = Nothing
816 | otherwise = Just ([noLoc (IEVar main_RDR_Unqual)])
817 -- ToDo: the 'noLoc' here is unhelpful if 'main'
818 -- turns out to be out of scope
820 ; (rn_exports, avails) <- exports_from_avail real_exports rdr_env imports this_mod
821 ; let final_avails = nubAvails avails -- Combine families
823 ; return (tcg_env { tcg_exports = final_avails,
824 tcg_rn_exports = case tcg_rn_exports tcg_env of
826 Just _ -> rn_exports,
827 tcg_dus = tcg_dus tcg_env `plusDU`
828 usesOnly (availsToNameSet final_avails) }) }
830 exports_from_avail :: Maybe [LIE RdrName]
831 -- Nothing => no explicit export list
835 -> RnM (Maybe [LIE Name], [AvailInfo])
837 exports_from_avail Nothing rdr_env _imports _this_mod
838 = -- The same as (module M) where M is the current module name,
839 -- so that's how we handle it.
841 avails = [ greAvail gre | gre <- globalRdrEnvElts rdr_env,
844 return (Nothing, avails)
846 exports_from_avail (Just rdr_items) rdr_env imports this_mod
847 = do (ie_names, _, exports) <- foldlM do_litem emptyExportAccum rdr_items
849 return (Just ie_names, exports)
851 do_litem :: ExportAccum -> LIE RdrName -> RnM ExportAccum
852 do_litem acc lie = setSrcSpan (getLoc lie) (exports_from_item acc lie)
854 kids_env :: NameEnv [Name] -- Maps a parent to its in-scope children
855 kids_env = mkChildEnv (globalRdrEnvElts rdr_env)
857 imported_modules = [ qual_name
858 | xs <- moduleEnvElts $ imp_mods imports,
859 (qual_name, _, _) <- xs ]
861 exports_from_item :: ExportAccum -> LIE RdrName -> RnM ExportAccum
862 exports_from_item acc@(ie_names, occs, exports)
863 (L loc ie@(IEModuleContents mod))
864 | let earlier_mods = [ mod | (L _ (IEModuleContents mod)) <- ie_names ]
865 , mod `elem` earlier_mods -- Duplicate export of M
866 = do { warn_dup_exports <- doptM Opt_WarnDuplicateExports ;
867 warnIf warn_dup_exports (dupModuleExport mod) ;
871 = do { implicit_prelude <- doptM Opt_ImplicitPrelude
872 ; warnDodgyExports <- doptM Opt_WarnDodgyExports
873 ; let { exportValid = (mod `elem` imported_modules)
874 || (moduleName this_mod == mod)
875 ; gres = filter (isModuleExported implicit_prelude mod)
876 (globalRdrEnvElts rdr_env)
877 ; names = map gre_name gres
880 ; checkErr exportValid (moduleNotImported mod)
881 ; warnIf (warnDodgyExports && exportValid && null gres) (nullModuleExport mod)
883 ; addUsedRdrNames (concat [ [mkRdrQual mod occ, mkRdrUnqual occ]
884 | occ <- map nameOccName names ])
885 -- The qualified and unqualified version of all of
886 -- these names are, in effect, used by this export
888 ; occs' <- check_occs ie occs names
889 -- This check_occs not only finds conflicts
890 -- between this item and others, but also
891 -- internally within this item. That is, if
892 -- 'M.x' is in scope in several ways, we'll have
893 -- several members of mod_avails with the same
895 ; return (L loc (IEModuleContents mod) : ie_names,
896 occs', map greAvail gres ++ exports) }
898 exports_from_item acc@(lie_names, occs, exports) (L loc ie)
900 = do new_ie <- lookup_doc_ie ie
901 return (L loc new_ie : lie_names, occs, exports)
904 = do (new_ie, avail) <- lookup_ie ie
905 if isUnboundName (ieName new_ie)
906 then return acc -- Avoid error cascade
909 occs' <- check_occs ie occs (availNames avail)
911 return (L loc new_ie : lie_names, occs', avail : exports)
914 lookup_ie :: IE RdrName -> RnM (IE Name, AvailInfo)
915 lookup_ie (IEVar rdr)
916 = do gre <- lookupGreRn rdr
917 return (IEVar (gre_name gre), greAvail gre)
919 lookup_ie (IEThingAbs rdr)
920 = do gre <- lookupGreRn rdr
921 let name = gre_name gre
923 NoParent -> return (IEThingAbs name,
925 ParentIs p -> return (IEThingAbs name,
928 lookup_ie ie@(IEThingAll rdr)
929 = do name <- lookupGlobalOccRn rdr
930 let kids = findChildren kids_env name
931 mkKidRdrName = case isQual_maybe rdr of
932 Nothing -> mkRdrUnqual
933 Just (modName, _) -> mkRdrQual modName
934 addUsedRdrNames $ map (mkKidRdrName . nameOccName) kids
935 warnDodgyExports <- doptM Opt_WarnDodgyExports
938 then when warnDodgyExports $ addWarn (dodgyExportWarn name)
939 else -- This occurs when you export T(..), but
940 -- only import T abstractly, or T is a synonym.
941 addErr (exportItemErr ie)
943 return (IEThingAll name, AvailTC name (name:kids))
945 lookup_ie ie@(IEThingWith rdr sub_rdrs)
946 = do name <- lookupGlobalOccRn rdr
947 if isUnboundName name
948 then return (IEThingWith name [], AvailTC name [name])
950 let env = mkOccEnv [ (nameOccName s, s)
951 | s <- findChildren kids_env name ]
952 mb_names = map (lookupOccEnv env . rdrNameOcc) sub_rdrs
953 if any isNothing mb_names
954 then do addErr (exportItemErr ie)
955 return (IEThingWith name [], AvailTC name [name])
956 else do let names = catMaybes mb_names
957 optTyFam <- doptM Opt_TypeFamilies
958 when (not optTyFam && any isTyConName names) $
959 addErr (typeItemErr ( head
962 (text "in export list"))
963 return (IEThingWith name names, AvailTC name (name:names))
965 lookup_ie _ = panic "lookup_ie" -- Other cases covered earlier
968 lookup_doc_ie :: IE RdrName -> RnM (IE Name)
969 lookup_doc_ie (IEGroup lev doc) = do rn_doc <- rnHsDoc doc
970 return (IEGroup lev rn_doc)
971 lookup_doc_ie (IEDoc doc) = do rn_doc <- rnHsDoc doc
972 return (IEDoc rn_doc)
973 lookup_doc_ie (IEDocNamed str) = return (IEDocNamed str)
974 lookup_doc_ie _ = panic "lookup_doc_ie" -- Other cases covered earlier
977 isDoc :: IE RdrName -> Bool
978 isDoc (IEDoc _) = True
979 isDoc (IEDocNamed _) = True
980 isDoc (IEGroup _ _) = True
983 -------------------------------
984 isModuleExported :: Bool -> ModuleName -> GlobalRdrElt -> Bool
985 -- True if the thing is in scope *both* unqualified, *and* with qualifier M
986 isModuleExported implicit_prelude mod (GRE { gre_name = name, gre_prov = prov })
987 | implicit_prelude && isBuiltInSyntax name = False
988 -- Optimisation: filter out names for built-in syntax
989 -- They just clutter up the environment (esp tuples), and the parser
990 -- will generate Exact RdrNames for them, so the cluttered
991 -- envt is no use. To avoid doing this filter all the time,
992 -- we use -XNoImplicitPrelude as a clue that the filter is
993 -- worth while. Really, it's only useful for GHC.Base and GHC.Tuple.
995 -- It's worth doing because it makes the environment smaller for
996 -- every module that imports the Prelude
999 LocalDef | Just name_mod <- nameModule_maybe name
1000 -> moduleName name_mod == mod
1001 | otherwise -> False
1002 Imported is -> any unQualSpecOK is && any (qualSpecOK mod) is
1004 -------------------------------
1005 check_occs :: IE RdrName -> ExportOccMap -> [Name] -> RnM ExportOccMap
1006 check_occs ie occs names
1007 = foldlM check occs names
1010 = case lookupOccEnv occs name_occ of
1011 Nothing -> return (extendOccEnv occs name_occ (name, ie))
1014 | name == name' -- Duplicate export
1015 -> do { warn_dup_exports <- doptM Opt_WarnDuplicateExports ;
1016 warnIf warn_dup_exports (dupExportWarn name_occ ie ie') ;
1019 | otherwise -- Same occ name but different names: an error
1020 -> do { global_env <- getGlobalRdrEnv ;
1021 addErr (exportClashErr global_env name' name ie' ie) ;
1024 name_occ = nameOccName name
1027 %*********************************************************
1031 %*********************************************************
1034 finishWarnings :: DynFlags -> Maybe WarningTxt
1035 -> TcGblEnv -> RnM TcGblEnv
1036 -- (a) Report usage of imports that are deprecated or have other warnings
1037 -- (b) If the whole module is warned about or deprecated, update tcg_warns
1038 -- All this happens only once per module
1039 finishWarnings dflags mod_warn tcg_env
1040 = do { (eps,hpt) <- getEpsAndHpt
1041 ; ifOptM Opt_WarnWarningsDeprecations $
1042 mapM_ (check hpt (eps_PIT eps)) all_gres
1043 -- By this time, typechecking is complete,
1044 -- so the PIT is fully populated
1046 -- Deal with a module deprecation; it overrides all existing warns
1047 ; let new_warns = case mod_warn of
1048 Just txt -> WarnAll txt
1049 Nothing -> tcg_warns tcg_env
1050 ; return (tcg_env { tcg_warns = new_warns }) }
1052 used_names = allUses (tcg_dus tcg_env)
1053 -- Report on all deprecated uses; hence allUses
1054 all_gres = globalRdrEnvElts (tcg_rdr_env tcg_env)
1056 check hpt pit gre@(GRE {gre_name = name, gre_prov = Imported (imp_spec:_)})
1057 | name `elemNameSet` used_names
1058 , Just deprec_txt <- lookupImpDeprec dflags hpt pit gre
1059 = addWarnAt (importSpecLoc imp_spec)
1060 (sep [ptext (sLit "In the use of") <+>
1061 pprNonVarNameSpace (occNameSpace (nameOccName name)) <+>
1063 (parens imp_msg) <> colon,
1066 name_mod = ASSERT2( isExternalName name, ppr name ) nameModule name
1067 imp_mod = importSpecModule imp_spec
1068 imp_msg = ptext (sLit "imported from") <+> ppr imp_mod <> extra
1069 extra | imp_mod == moduleName name_mod = empty
1070 | otherwise = ptext (sLit ", but defined in") <+> ppr name_mod
1072 check _ _ _ = return () -- Local, or not used, or not deprectated
1073 -- The Imported pattern-match: don't deprecate locally defined names
1074 -- For a start, we may be exporting a deprecated thing
1075 -- Also we may use a deprecated thing in the defn of another
1076 -- deprecated things. We may even use a deprecated thing in
1077 -- the defn of a non-deprecated thing, when changing a module's
1080 lookupImpDeprec :: DynFlags -> HomePackageTable -> PackageIfaceTable
1081 -> GlobalRdrElt -> Maybe WarningTxt
1082 -- The name is definitely imported, so look in HPT, PIT
1083 lookupImpDeprec dflags hpt pit gre
1084 = case lookupIfaceByModule dflags hpt pit mod of
1085 Just iface -> mi_warn_fn iface name `mplus` -- Bleat if the thing, *or
1087 ParentIs p -> mi_warn_fn iface p -- its parent*, is warn'd
1090 Nothing -> Nothing -- See Note [Used names with interface not loaded]
1093 mod = ASSERT2( isExternalName name, ppr name ) nameModule name
1096 Note [Used names with interface not loaded]
1097 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1098 By now all the interfaces should have been loaded,
1099 because reportDeprecations happens after typechecking.
1100 However, it's still (just) possible to to find a used
1101 Name whose interface hasn't been loaded:
1103 a) It might be a WiredInName; in that case we may not load
1104 its interface (although we could).
1106 b) It might be GHC.Real.fromRational, or GHC.Num.fromInteger
1107 These are seen as "used" by the renamer (if -XNoImplicitPrelude)
1108 is on), but the typechecker may discard their uses
1109 if in fact the in-scope fromRational is GHC.Read.fromRational,
1110 (see tcPat.tcOverloadedLit), and the typechecker sees that the type
1111 is fixed, say, to GHC.Base.Float (see Inst.lookupSimpleInst).
1112 In that obscure case it won't force the interface in.
1114 In both cases we simply don't permit deprecations;
1115 this is, after all, wired-in stuff.
1118 %*********************************************************
1122 %*********************************************************
1125 reportUnusedNames :: Maybe [LIE RdrName] -- Export list
1126 -> TcGblEnv -> RnM ()
1127 reportUnusedNames _export_decls gbl_env
1128 = do { traceRn ((text "RUN") <+> (ppr (tcg_dus gbl_env)))
1129 ; warnUnusedImportDecls gbl_env
1130 ; warnUnusedTopBinds unused_locals }
1132 used_names :: NameSet
1133 used_names = findUses (tcg_dus gbl_env) emptyNameSet
1134 -- NB: currently, if f x = g, we only treat 'g' as used if 'f' is used
1137 -- Collect the defined names from the in-scope environment
1138 defined_names :: [GlobalRdrElt]
1139 defined_names = globalRdrEnvElts (tcg_rdr_env gbl_env)
1141 -- Note that defined_and_used, defined_but_not_used
1142 -- are both [GRE]; that's why we need defined_and_used
1143 -- rather than just used_names
1144 _defined_and_used, defined_but_not_used :: [GlobalRdrElt]
1145 (_defined_and_used, defined_but_not_used)
1146 = partition (gre_is_used used_names) defined_names
1148 kids_env = mkChildEnv defined_names
1149 -- This is done in mkExports too; duplicated work
1151 gre_is_used :: NameSet -> GlobalRdrElt -> Bool
1152 gre_is_used used_names (GRE {gre_name = name})
1153 = name `elemNameSet` used_names
1154 || any (`elemNameSet` used_names) (findChildren kids_env name)
1155 -- A use of C implies a use of T,
1156 -- if C was brought into scope by T(..) or T(C)
1158 -- Filter out the ones that are
1159 -- (a) defined in this module, and
1160 -- (b) not defined by a 'deriving' clause
1161 -- The latter have an Internal Name, so we can filter them out easily
1162 unused_locals :: [GlobalRdrElt]
1163 unused_locals = filter is_unused_local defined_but_not_used
1164 is_unused_local :: GlobalRdrElt -> Bool
1165 is_unused_local gre = isLocalGRE gre && isExternalName (gre_name gre)
1168 %*********************************************************
1172 %*********************************************************
1174 This code finds which import declarations are unused. The
1175 specification and implementation notes are here:
1176 http://hackage.haskell.org/trac/ghc/wiki/Commentary/Compiler/UnusedImports
1179 type ImportDeclUsage
1180 = ( LImportDecl Name -- The import declaration
1181 , [AvailInfo] -- What *is* used (normalised)
1182 , [Name] ) -- What is imported but *not* used
1186 warnUnusedImportDecls :: TcGblEnv -> RnM ()
1187 warnUnusedImportDecls gbl_env
1188 = do { uses <- readMutVar (tcg_used_rdrnames gbl_env)
1189 ; let imports = filter explicit_import (tcg_rn_imports gbl_env)
1190 rdr_env = tcg_rdr_env gbl_env
1192 ; let usage :: [ImportDeclUsage]
1193 usage = findImportUsage imports rdr_env (Set.elems uses)
1195 ; ifOptM Opt_WarnUnusedImports $
1196 mapM_ warnUnusedImport usage
1198 ; ifOptM Opt_D_dump_minimal_imports $
1199 printMinimalImports usage }
1201 explicit_import (L loc _) = isGoodSrcSpan loc
1202 -- Filter out the implicit Prelude import
1203 -- which we do not want to bleat about
1207 findImportUsage :: [LImportDecl Name]
1210 -> [ImportDeclUsage]
1212 type ImportMap = FiniteMap SrcLoc [AvailInfo]
1213 -- The intermediate data struture records, for each import
1214 -- declaration, what stuff brought into scope by that
1215 -- declaration is actually used in the module.
1217 -- The SrcLoc is the location of the start
1218 -- of a particular 'import' declaration
1220 -- The AvailInfos are the things imported from that decl
1221 -- (just a list, not normalised)
1223 findImportUsage imports rdr_env rdrs
1224 = map unused_decl imports
1226 import_usage :: ImportMap
1227 import_usage = foldr add_rdr emptyFM rdrs
1229 unused_decl decl@(L loc (ImportDecl { ideclHiding = imps }))
1230 = (decl, nubAvails used_avails, unused_imps)
1232 used_avails = lookupFM import_usage (srcSpanStart loc) `orElse` []
1233 used_names = availsToNameSet used_avails
1235 unused_imps = case imps of
1236 Just (False, imp_ies) -> nameSetToList unused_imps
1238 imp_names = mkNameSet (concatMap (ieNames . unLoc) imp_ies)
1239 unused_imps = imp_names `minusNameSet` used_names
1241 _other -> [] -- No explicit import list => no unused-name list
1243 add_rdr :: RdrName -> ImportMap -> ImportMap
1245 = case lookupGRE_RdrName rdr rdr_env of
1246 [gre] | Imported imps <- gre_prov gre
1247 -> add_imp gre (bestImport imps) iu
1250 add_imp :: GlobalRdrElt -> ImportSpec -> ImportMap -> ImportMap
1251 add_imp gre (ImpSpec { is_decl = imp_decl_spec }) iu
1252 = addToFM_C add iu decl_loc [avail]
1254 add avails _ = avail : avails
1255 decl_loc = srcSpanStart (is_dloc imp_decl_spec)
1257 avail = case gre_par gre of
1258 ParentIs p -> AvailTC p [p,name]
1259 NoParent | isTyConName name -> AvailTC name [name]
1260 | otherwise -> Avail name
1261 -- If you use (+) from Num, then for this purpose we want
1262 -- to say that Num is used as well. That is why in the
1263 -- ParentIs case we have [p,name] in the ParentIs case
1265 bestImport :: [ImportSpec] -> ImportSpec
1267 = case partition isImpAll iss of
1268 ([], imp_somes) -> textuallyFirst imp_somes
1269 (imp_alls, _) -> textuallyFirst imp_alls
1271 textuallyFirst :: [ImportSpec] -> ImportSpec
1272 textuallyFirst iss = case sortWith (is_dloc . is_decl) iss of
1273 [] -> pprPanic "textuallyFirst" (ppr iss)
1276 isImpAll :: ImportSpec -> Bool
1277 isImpAll (ImpSpec { is_item = ImpAll }) = True
1278 isImpAll _other = False
1282 warnUnusedImport :: ImportDeclUsage -> RnM ()
1283 warnUnusedImport (L loc decl, used, unused)
1284 | Just (False,[]) <- ideclHiding decl
1285 = return () -- Do not warn for 'import M()'
1286 | null used = addWarnAt loc msg1 -- Nothing used; drop entire decl
1287 | null unused = return () -- Everything imported is used; nop
1288 | otherwise = addWarnAt loc msg2 -- Some imports are unused
1290 msg1 = vcat [pp_herald <+> quotes pp_mod <+> pp_not_used,
1291 nest 2 (ptext (sLit "except perhaps to import instances from")
1293 ptext (sLit "To import instances alone, use:")
1294 <+> ptext (sLit "import") <+> pp_mod <> parens empty ]
1295 msg2 = sep [pp_herald <+> quotes (pprWithCommas ppr unused),
1296 text "from module" <+> quotes pp_mod <+> pp_not_used]
1297 pp_herald = text "The import of"
1298 pp_mod = ppr (unLoc (ideclName decl))
1299 pp_not_used = text "is redundant"
1302 To print the minimal imports we walk over the user-supplied import
1303 decls, and simply trim their import lists. NB that
1305 * We do *not* change the 'qualified' or 'as' parts!
1307 * We do not disard a decl altogether; we might need instances
1308 from it. Instead we just trim to an empty import list
1311 printMinimalImports :: [ImportDeclUsage] -> RnM ()
1312 printMinimalImports imports_w_usage
1313 = do { imports' <- mapM mk_minimal imports_w_usage
1314 ; this_mod <- getModule
1316 do { h <- openFile (mkFilename this_mod) WriteMode
1317 ; printForUser h neverQualify (vcat (map ppr imports')) }
1318 -- The neverQualify is important. We are printing Names
1319 -- but they are in the context of an 'import' decl, and
1320 -- we never qualify things inside there
1321 -- E.g. import Blag( f, b )
1322 -- not import Blag( Blag.f, Blag.g )!
1325 mkFilename this_mod = moduleNameString (moduleName this_mod) ++ ".imports"
1327 mk_minimal (L l decl, used, unused)
1329 , Just (False, _) <- ideclHiding decl
1332 = do { ies <- initIfaceTcRn $ mapM to_ie used
1333 ; return (L l (decl { ideclHiding = Just (False, map (L l) ies) })) }
1335 to_ie :: AvailInfo -> IfG (IE Name)
1336 -- The main trick here is that if we're importing all the constructors
1337 -- we want to say "T(..)", but if we're importing only a subset we want
1338 -- to say "T(A,B,C)". So we have to find out what the module exports.
1339 to_ie (Avail n) = return (IEVar n)
1340 to_ie (AvailTC n [m]) = ASSERT( n==m )
1341 return (IEThingAbs n)
1342 to_ie (AvailTC n ns) = do
1343 iface <- loadSysInterface doc n_mod
1344 case [xs | (m,as) <- mi_exports iface,
1347 x == nameOccName n] of
1348 [xs] | all_used xs -> return (IEThingAll n)
1349 | otherwise -> return (IEThingWith n (filter (/= n) ns))
1350 other -> pprTrace "to_ie" (ppr n <+> ppr n_mod <+> ppr other) $
1353 all_used avail_occs = all (`elem` map nameOccName ns) avail_occs
1354 doc = text "Compute minimal imports from" <+> ppr n
1355 n_mod = ASSERT( isExternalName n ) nameModule n
1358 %************************************************************************
1362 %************************************************************************
1365 qualImportItemErr :: RdrName -> SDoc
1366 qualImportItemErr rdr
1367 = hang (ptext (sLit "Illegal qualified name in import item:"))
1370 badImportItemErr :: ModIface -> ImpDeclSpec -> IE RdrName -> SDoc
1371 badImportItemErr iface decl_spec ie
1372 = sep [ptext (sLit "Module"), quotes (ppr (is_mod decl_spec)), source_import,
1373 ptext (sLit "does not export"), quotes (ppr ie)]
1375 source_import | mi_boot iface = ptext (sLit "(hi-boot interface)")
1378 illegalImportItemErr :: SDoc
1379 illegalImportItemErr = ptext (sLit "Illegal import item")
1381 dodgyImportWarn :: RdrName -> SDoc
1382 dodgyImportWarn item = dodgyMsg (ptext (sLit "import")) item
1383 dodgyExportWarn :: Name -> SDoc
1384 dodgyExportWarn item = dodgyMsg (ptext (sLit "export")) item
1386 dodgyMsg :: OutputableBndr n => SDoc -> n -> SDoc
1388 = sep [ ptext (sLit "The") <+> kind <+> ptext (sLit "item") <+> quotes (ppr (IEThingAll tc))
1389 <+> ptext (sLit "suggests that"),
1390 quotes (ppr tc) <+> ptext (sLit "has (in-scope) constructors or class methods,"),
1391 ptext (sLit "but it has none") ]
1393 exportItemErr :: IE RdrName -> SDoc
1394 exportItemErr export_item
1395 = sep [ ptext (sLit "The export item") <+> quotes (ppr export_item),
1396 ptext (sLit "attempts to export constructors or class methods that are not visible here") ]
1398 typeItemErr :: Name -> SDoc -> SDoc
1399 typeItemErr name wherestr
1400 = sep [ ptext (sLit "Using 'type' tag on") <+> quotes (ppr name) <+> wherestr,
1401 ptext (sLit "Use -XTypeFamilies to enable this extension") ]
1403 exportClashErr :: GlobalRdrEnv -> Name -> Name -> IE RdrName -> IE RdrName
1405 exportClashErr global_env name1 name2 ie1 ie2
1406 = vcat [ ptext (sLit "Conflicting exports for") <+> quotes (ppr occ) <> colon
1407 , ppr_export ie1' name1'
1408 , ppr_export ie2' name2' ]
1410 occ = nameOccName name1
1411 ppr_export ie name = nest 2 (quotes (ppr ie) <+> ptext (sLit "exports") <+>
1412 quotes (ppr name) <+> pprNameProvenance (get_gre name))
1414 -- get_gre finds a GRE for the Name, so that we can show its provenance
1416 = case lookupGRE_Name global_env name of
1418 [] -> pprPanic "exportClashErr" (ppr name)
1419 get_loc name = nameSrcLoc $ gre_name $ get_gre name
1420 (name1', ie1', name2', ie2') = if get_loc name1 < get_loc name2
1421 then (name1, ie1, name2, ie2)
1422 else (name2, ie2, name1, ie1)
1424 addDupDeclErr :: [Name] -> TcRn ()
1426 = panic "addDupDeclErr: empty list"
1427 addDupDeclErr names@(name : _)
1428 = addErrAt (getSrcSpan (last sorted_names)) $
1429 -- Report the error at the later location
1430 vcat [ptext (sLit "Multiple declarations of") <+> quotes (ppr name),
1431 ptext (sLit "Declared at:") <+> vcat (map (ppr . nameSrcLoc) sorted_names)]
1433 sorted_names = sortWith nameSrcLoc names
1435 dupExportWarn :: OccName -> IE RdrName -> IE RdrName -> SDoc
1436 dupExportWarn occ_name ie1 ie2
1437 = hsep [quotes (ppr occ_name),
1438 ptext (sLit "is exported by"), quotes (ppr ie1),
1439 ptext (sLit "and"), quotes (ppr ie2)]
1441 dupModuleExport :: ModuleName -> SDoc
1443 = hsep [ptext (sLit "Duplicate"),
1444 quotes (ptext (sLit "Module") <+> ppr mod),
1445 ptext (sLit "in export list")]
1447 moduleNotImported :: ModuleName -> SDoc
1448 moduleNotImported mod
1449 = ptext (sLit "The export item `module") <+> ppr mod <>
1450 ptext (sLit "' is not imported")
1452 nullModuleExport :: ModuleName -> SDoc
1453 nullModuleExport mod
1454 = ptext (sLit "The export item `module") <+> ppr mod <> ptext (sLit "' exports nothing")
1456 missingImportListWarn :: ModuleName -> SDoc
1457 missingImportListWarn mod
1458 = ptext (sLit "The module") <+> quotes (ppr mod) <+> ptext (sLit "is missing an import list")
1460 moduleWarn :: ModuleName -> WarningTxt -> SDoc
1461 moduleWarn mod (WarningTxt txt)
1462 = sep [ ptext (sLit "Module") <+> quotes (ppr mod) <> ptext (sLit ":"),
1463 nest 2 (vcat (map ppr txt)) ]
1464 moduleWarn mod (DeprecatedTxt txt)
1465 = sep [ ptext (sLit "Module") <+> quotes (ppr mod)
1466 <+> ptext (sLit "is deprecated:"),
1467 nest 2 (vcat (map ppr txt)) ]
1469 implicitPreludeWarn :: SDoc
1471 = ptext (sLit "Module `Prelude' implicitly imported")
1473 packageImportErr :: SDoc
1475 = ptext (sLit "Package-qualified imports are not enabled; use -XPackageImports")