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 )
25 import HeaderInfo ( mkPrelImports )
40 import Data.List ( partition, (\\), delete )
41 import qualified Data.Set as Set
45 import qualified Data.Map as Map
50 %************************************************************************
54 %************************************************************************
57 rnImports :: [LImportDecl RdrName]
58 -> RnM ([LImportDecl Name], GlobalRdrEnv, ImportAvails,AnyHpcUsage)
61 -- PROCESS IMPORT DECLS
62 -- Do the non {- SOURCE -} ones first, so that we get a helpful
63 -- warning for {- SOURCE -} ones that are unnecessary
64 = do this_mod <- getModule
65 implicit_prelude <- xoptM Opt_ImplicitPrelude
66 let prel_imports = mkPrelImports (moduleName this_mod) implicit_prelude imports
67 (source, ordinary) = partition is_source_import imports
68 is_source_import (L _ (ImportDecl _ _ is_boot _ _ _)) = is_boot
70 ifDOptM Opt_WarnImplicitPrelude (
71 when (notNull prel_imports) $ addWarn (implicitPreludeWarn)
74 stuff1 <- mapM (rnImportDecl this_mod True) prel_imports
75 stuff2 <- mapM (rnImportDecl this_mod False) ordinary
76 stuff3 <- mapM (rnImportDecl this_mod False) source
77 let (decls, rdr_env, imp_avails, hpc_usage) = combine (stuff1 ++ stuff2 ++ stuff3)
78 return (decls, rdr_env, imp_avails, hpc_usage)
81 combine :: [(LImportDecl Name, GlobalRdrEnv, ImportAvails,AnyHpcUsage)]
82 -> ([LImportDecl Name], GlobalRdrEnv, ImportAvails,AnyHpcUsage)
83 combine = foldr plus ([], emptyGlobalRdrEnv, emptyImportAvails,False)
84 where plus (decl, gbl_env1, imp_avails1,hpc_usage1)
85 (decls, gbl_env2, imp_avails2,hpc_usage2)
87 gbl_env1 `plusGlobalRdrEnv` gbl_env2,
88 imp_avails1 `plusImportAvails` imp_avails2,
89 hpc_usage1 || hpc_usage2)
91 rnImportDecl :: Module -> Bool
92 -> LImportDecl RdrName
93 -> RnM (LImportDecl Name, GlobalRdrEnv, ImportAvails,AnyHpcUsage)
95 rnImportDecl this_mod implicit_prelude
96 (L loc (ImportDecl { ideclName = loc_imp_mod_name, ideclPkgQual = mb_pkg
97 , ideclSource = want_boot, ideclQualified = qual_only
98 , ideclAs = as_mod, ideclHiding = imp_details }))
101 when (isJust mb_pkg) $ do
102 pkg_imports <- xoptM Opt_PackageImports
103 when (not pkg_imports) $ addErr packageImportErr
105 -- If there's an error in loadInterface, (e.g. interface
106 -- file not found) we get lots of spurious errors from 'filterImports'
108 imp_mod_name = unLoc loc_imp_mod_name
109 doc = ppr imp_mod_name <+> ptext (sLit "is directly imported")
111 -- Check for a missing import list
112 -- (Opt_WarnMissingImportList also checks for T(..) items
113 -- but that is done in checkDodgyImport below)
115 Just (False, _) -> return ()
116 _ | implicit_prelude -> return ()
117 | otherwise -> ifDOptM Opt_WarnMissingImportList $
118 addWarn (missingImportListWarn imp_mod_name)
120 iface <- loadSrcInterface doc imp_mod_name want_boot mb_pkg
122 -- Compiler sanity check: if the import didn't say
123 -- {-# SOURCE #-} we should not get a hi-boot file
124 WARN( not want_boot && mi_boot iface, ppr imp_mod_name ) (do
126 -- Issue a user warning for a redundant {- SOURCE -} import
127 -- NB that we arrange to read all the ordinary imports before
128 -- any of the {- SOURCE -} imports.
130 -- in --make and GHCi, the compilation manager checks for this,
131 -- and indeed we shouldn't do it here because the existence of
132 -- the non-boot module depends on the compilation order, which
133 -- is not deterministic. The hs-boot test can show this up.
135 warnIf (want_boot && not (mi_boot iface) && isOneShot (ghcMode dflags))
136 (warnRedundantSourceImport imp_mod_name)
139 imp_mod = mi_module iface
140 warns = mi_warns iface
141 orph_iface = mi_orphan iface
142 has_finsts = mi_finsts iface
145 filtered_exports = filter not_this_mod (mi_exports iface)
146 not_this_mod (mod,_) = mod /= this_mod
147 -- If the module exports anything defined in this module, just
148 -- ignore it. Reason: otherwise it looks as if there are two
149 -- local definition sites for the thing, and an error gets
150 -- reported. Easiest thing is just to filter them out up
151 -- front. This situation only arises if a module imports
152 -- itself, or another module that imported it. (Necessarily,
153 -- this invoves a loop.)
155 -- Tiresome consequence: if you say
160 -- module B( AType ) where
161 -- import {-# SOURCE #-} A( AType )
163 -- then you'll get a 'B does not export AType' message. Oh well.
165 qual_mod_name = case as_mod of
166 Nothing -> imp_mod_name
167 Just another_name -> another_name
168 imp_spec = ImpDeclSpec { is_mod = imp_mod_name, is_qual = qual_only,
169 is_dloc = loc, is_as = qual_mod_name }
172 -- Get the total exports from this module
173 total_avails <- ifaceExportNames filtered_exports
175 -- filter the imports according to the import declaration
176 (new_imp_details, gbl_env) <-
177 filterImports iface imp_spec imp_details total_avails
182 -- Compute new transitive dependencies
184 orphans | orph_iface = ASSERT( not (imp_mod `elem` dep_orphs deps) )
185 imp_mod : dep_orphs deps
186 | otherwise = dep_orphs deps
188 finsts | has_finsts = ASSERT( not (imp_mod `elem` dep_finsts deps) )
189 imp_mod : dep_finsts deps
190 | otherwise = dep_finsts deps
192 pkg = modulePackageId (mi_module iface)
194 (dependent_mods, dependent_pkgs)
195 | pkg == thisPackage dflags =
196 -- Imported module is from the home package
197 -- Take its dependent modules and add imp_mod itself
198 -- Take its dependent packages unchanged
200 -- NB: (dep_mods deps) might include a hi-boot file
201 -- for the module being compiled, CM. Do *not* filter
202 -- this out (as we used to), because when we've
203 -- finished dealing with the direct imports we want to
204 -- know if any of them depended on CM.hi-boot, in
205 -- which case we should do the hi-boot consistency
206 -- check. See LoadIface.loadHiBootInterface
207 ((imp_mod_name, want_boot) : dep_mods deps, dep_pkgs deps)
210 -- Imported module is from another package
211 -- Dump the dependent modules
212 -- Add the package imp_mod comes from to the dependent packages
213 ASSERT2( not (pkg `elem` dep_pkgs deps), ppr pkg <+> ppr (dep_pkgs deps) )
214 ([], pkg : dep_pkgs deps)
216 -- True <=> import M ()
217 import_all = case imp_details of
218 Just (is_hiding, ls) -> not is_hiding && null ls
221 imports = ImportAvails {
222 imp_mods = unitModuleEnv imp_mod [(qual_mod_name, import_all, loc)],
225 imp_dep_mods = mkModDeps dependent_mods,
226 imp_dep_pkgs = dependent_pkgs
229 -- Complain if we import a deprecated module
230 ifDOptM Opt_WarnWarningsDeprecations (
232 WarnAll txt -> addWarn (moduleWarn imp_mod_name txt)
236 let new_imp_decl = L loc (ImportDecl loc_imp_mod_name mb_pkg want_boot
237 qual_only as_mod new_imp_details)
239 return (new_imp_decl, gbl_env, imports, mi_hpc iface)
242 warnRedundantSourceImport :: ModuleName -> SDoc
243 warnRedundantSourceImport mod_name
244 = ptext (sLit "Unnecessary {-# SOURCE #-} in the import of module")
245 <+> quotes (ppr mod_name)
249 %************************************************************************
251 importsFromLocalDecls
253 %************************************************************************
255 From the top-level declarations of this module produce
256 * the lexical environment
258 created by its bindings.
260 Note [Top-level Names in Template Haskell decl quotes]
261 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
262 Consider a Template Haskell declaration quotation like this:
265 When renaming the declarations inside [d| ...|], we treat the
266 top level binders specially in two ways
268 1. We give them an Internal name, not (as usual) an External one.
269 Otherwise the NameCache gets confused by a second allocation of
270 M.f. (We used to invent a fake module ThFake to avoid this, but
271 that had other problems, notably in getting the correct answer for
272 nameIsLocalOrFrom in lookupFixity. So we now leave tcg_module
275 2. We make them *shadow* the outer bindings. If we don't do that,
276 we'll get a complaint when extending the GlobalRdrEnv, saying that
277 there are two bindings for 'f'. There are several tricky points:
279 * This shadowing applies even if the binding for 'f' is in a
280 where-clause, and hence is in the *local* RdrEnv not the *global*
283 * The *qualified* name M.f from the enclosing module must certainly
284 still be available. So we don't nuke it entirely; we just make
285 it seem like qualified import.
287 * We only shadow *External* names (which come from the main module)
288 Do not shadow *Inernal* names because in the bracket
289 [d| class C a where f :: a
291 rnSrcDecls will first call extendGlobalRdrEnvRn with C[f] from the
292 class decl, and *separately* extend the envt with the value binding.
294 3. We find out whether we are inside a [d| ... |] by testing the TH
295 stage. This is a slight hack, because the stage field was really
296 meant for the type checker, and here we are not interested in the
297 fields of Brack, hence the error thunks in thRnBrack.
300 extendGlobalRdrEnvRn :: [AvailInfo]
302 -> RnM (TcGblEnv, TcLclEnv)
303 -- Updates both the GlobalRdrEnv and the FixityEnv
304 -- We return a new TcLclEnv only because we might have to
305 -- delete some bindings from it;
306 -- see Note [Top-level Names in Template Haskell decl quotes]
308 extendGlobalRdrEnvRn avails new_fixities
309 = do { (gbl_env, lcl_env) <- getEnvs
311 ; let rdr_env = tcg_rdr_env gbl_env
312 fix_env = tcg_fix_env gbl_env
314 -- Delete new_occs from global and local envs
315 -- If we are in a TemplateHaskell decl bracket,
316 -- we are going to shadow them
317 -- See Note [Top-level Names in Template Haskell decl quotes]
318 shadowP = isBrackStage stage
319 new_occs = map (nameOccName . gre_name) gres
320 rdr_env1 = transformGREs qual_gre new_occs rdr_env
321 lcl_env1 = lcl_env { tcl_rdr = delListFromOccEnv (tcl_rdr lcl_env) new_occs }
322 (rdr_env2, lcl_env2) | shadowP = (rdr_env1, lcl_env1)
323 | otherwise = (rdr_env, lcl_env)
325 rdr_env3 = foldl extendGlobalRdrEnv rdr_env2 gres
326 fix_env' = foldl extend_fix_env fix_env gres
327 (rdr_env', dups) = findLocalDupsRdrEnv rdr_env3 new_occs
329 gbl_env' = gbl_env { tcg_rdr_env = rdr_env', tcg_fix_env = fix_env' }
331 ; mapM_ addDupDeclErr dups
333 ; traceRn (text "extendGlobalRdrEnvRn" <+> (ppr new_fixities $$ ppr fix_env $$ ppr fix_env'))
334 ; return (gbl_env', lcl_env2) }
336 gres = gresFromAvails LocalDef avails
338 -- If there is a fixity decl for the gre, add it to the fixity env
339 extend_fix_env fix_env gre
340 | Just (L _ fi) <- lookupFsEnv new_fixities (occNameFS occ)
341 = extendNameEnv fix_env name (FixItem occ fi)
346 occ = nameOccName name
348 qual_gre :: GlobalRdrElt -> GlobalRdrElt
349 -- Transform top-level GREs from the module being compiled
350 -- so that they are out of the way of new definitions in a Template
352 -- See Note [Top-level Names in Template Haskell decl quotes]
353 -- Seems like 5 times as much work as it deserves!
355 -- For a LocalDef we make a (fake) qualified imported GRE for a
356 -- local GRE so that the original *qualified* name is still in scope
357 -- but the *unqualified* one no longer is. What a hack!
359 qual_gre gre@(GRE { gre_prov = LocalDef, gre_name = name })
360 | isExternalName name = gre { gre_prov = Imported [imp_spec] }
362 -- Do not shadow Internal (ie Template Haskell) Names
363 -- See Note [Top-level Names in Template Haskell decl quotes]
365 mod = ASSERT2( isExternalName name, ppr name) moduleName (nameModule name)
366 imp_spec = ImpSpec { is_item = ImpAll, is_decl = decl_spec }
367 decl_spec = ImpDeclSpec { is_mod = mod, is_as = mod,
368 is_qual = True, -- Qualified only!
369 is_dloc = srcLocSpan (nameSrcLoc name) }
371 qual_gre gre@(GRE { gre_prov = Imported specs })
372 = gre { gre_prov = Imported (map qual_spec specs) }
374 qual_spec spec@(ImpSpec { is_decl = decl_spec })
375 = spec { is_decl = decl_spec { is_qual = True } }
378 @getLocalDeclBinders@ returns the names for an @HsDecl@. It's
379 used for source code.
381 *** See "THE NAMING STORY" in HsDecls ****
383 Instances of type families
384 ~~~~~~~~~~~~~~~~~~~~~~~~~~
385 Family instances contain data constructors that we need to collect and we also
386 need to descend into the type instances of associated families in class
387 instances. The type constructor of a family instance is a usage occurence.
388 Hence, we don't return it as a subname in 'AvailInfo'; otherwise, we would get
389 a duplicate declaration error.
391 Note [Looking up family names in family instances]
392 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
397 type instance M.T Int = Bool
399 We might think that we can simply use 'lookupOccRn' when processing the type
400 instance to look up 'M.T'. Alas, we can't! The type family declaration is in
401 the *same* HsGroup as the type instance declaration. Hence, as we are
402 currently collecting the binders declared in that HsGroup, these binders will
403 not have been added to the global environment yet.
405 In the case of type classes, this problem does not arise, as a class instance
406 does not define any binders of it's own. So, we simply don't attempt to look
407 up the class names of class instances in 'get_local_binders' below.
409 If we don't look up class instances, can't we get away without looking up type
410 instances, too? No, we can't. Data type instances define data constructors
413 (1) collect those in 'get_local_binders' and
414 (2) we need to get their parent name in 'get_local_binders', too, to
415 produce an appropriate 'AvailTC'.
417 This parent name is exactly the family name of the type instance that is so
418 difficult to look up.
420 We solve this problem as follows:
422 (a) We process all type declarations other than type instances first.
423 (b) Then, we compute a 'GlobalRdrEnv' from the result of the first step.
424 (c) Finally, we process all type instances (both those on the toplevel and
425 those nested in class instances) and check for the family names in the
426 'GlobalRdrEnv' produced in the previous step before using 'lookupOccRn'.
429 getLocalNonValBinders :: HsGroup RdrName -> RnM [AvailInfo]
430 -- Get all the top-level binders bound the group *except*
431 -- for value bindings, which are treated separately
432 -- Specificaly we return AvailInfo for
433 -- type decls (incl constructors and record selectors)
434 -- class decls (including class ops)
437 -- (in hs-boot files) value signatures
439 getLocalNonValBinders group
440 = do { gbl_env <- getGblEnv
441 ; get_local_binders gbl_env group }
443 get_local_binders :: TcGblEnv -> HsGroup RdrName -> RnM [GenAvailInfo Name]
444 get_local_binders gbl_env (HsGroup {hs_valds = ValBindsIn _ val_sigs,
445 hs_tyclds = tycl_decls,
446 hs_instds = inst_decls,
447 hs_fords = foreign_decls })
448 = do { -- separate out the family instance declarations
449 let (tyinst_decls1, tycl_decls_noinsts)
450 = partition (isFamInstDecl . unLoc) tycl_decls
451 tyinst_decls = tyinst_decls1 ++ instDeclATs inst_decls
453 -- process all type/class decls except family instances
454 ; tc_names <- mapM new_tc tycl_decls_noinsts
456 -- create a temporary rdr env of the type binders
457 ; let tc_gres = gresFromAvails LocalDef tc_names
458 tc_name_env = foldl extendGlobalRdrEnv emptyGlobalRdrEnv tc_gres
460 -- process all family instances
461 ; ti_names <- mapM (new_ti tc_name_env) tyinst_decls
463 -- finish off with value binder in case of a hs-boot file
464 ; val_names <- mapM new_simple val_bndrs
465 ; return (val_names ++ tc_names ++ ti_names) }
467 is_hs_boot = isHsBoot (tcg_src gbl_env) ;
469 for_hs_bndrs :: [Located RdrName]
470 for_hs_bndrs = [nm | L _ (ForeignImport nm _ _) <- foreign_decls]
472 -- In a hs-boot file, the value binders come from the
473 -- *signatures*, and there should be no foreign binders
474 val_bndrs :: [Located RdrName]
475 val_bndrs | is_hs_boot = [nm | L _ (TypeSig nm _) <- val_sigs]
476 | otherwise = for_hs_bndrs
478 new_simple :: Located RdrName -> RnM (GenAvailInfo Name)
479 new_simple rdr_name = do
480 nm <- newTopSrcBinder rdr_name
483 new_tc tc_decl -- NOT for type/data instances
484 = do { main_name <- newTopSrcBinder main_rdr
485 ; sub_names <- mapM newTopSrcBinder sub_rdrs
486 ; return (AvailTC main_name (main_name : sub_names)) }
488 (main_rdr : sub_rdrs) = hsTyClDeclBinders tc_decl
490 new_ti tc_name_env ti_decl -- ONLY for type/data instances
491 = do { main_name <- lookupFamInstDeclBndr tc_name_env main_rdr
492 ; sub_names <- mapM newTopSrcBinder sub_rdrs
493 ; return (AvailTC main_name sub_names) }
494 -- main_name is not bound here!
496 (main_rdr : sub_rdrs) = hsTyClDeclBinders ti_decl
498 get_local_binders _ g = pprPanic "get_local_binders" (ppr g)
502 %************************************************************************
504 \subsection{Filtering imports}
506 %************************************************************************
508 @filterImports@ takes the @ExportEnv@ telling what the imported module makes
509 available, and filters it through the import spec (if any).
512 filterImports :: ModIface
513 -> ImpDeclSpec -- The span for the entire import decl
514 -> Maybe (Bool, [LIE RdrName]) -- Import spec; True => hiding
515 -> [AvailInfo] -- What's available
516 -> RnM (Maybe (Bool, [LIE Name]), -- Import spec w/ Names
517 GlobalRdrEnv) -- Same again, but in GRE form
518 filterImports _ decl_spec Nothing all_avails
519 = return (Nothing, mkGlobalRdrEnv (gresFromAvails prov all_avails))
521 prov = Imported [ImpSpec { is_decl = decl_spec, is_item = ImpAll }]
524 filterImports iface decl_spec (Just (want_hiding, import_items)) all_avails
525 = do -- check for errors, convert RdrNames to Names
526 opt_typeFamilies <- xoptM Opt_TypeFamilies
527 items1 <- mapM (lookup_lie opt_typeFamilies) import_items
529 let items2 :: [(LIE Name, AvailInfo)]
530 items2 = concat items1
531 -- NB the AvailInfo may have duplicates, and several items
532 -- for the same parent; e.g N(x) and N(y)
534 names = availsToNameSet (map snd items2)
535 keep n = not (n `elemNameSet` names)
536 pruned_avails = filterAvails keep all_avails
537 hiding_prov = Imported [ImpSpec { is_decl = decl_spec, is_item = ImpAll }]
539 gres | want_hiding = gresFromAvails hiding_prov pruned_avails
540 | otherwise = concatMap (gresFromIE decl_spec) items2
542 return (Just (want_hiding, map fst items2), mkGlobalRdrEnv gres)
544 -- This environment is how we map names mentioned in the import
545 -- list to the actual Name they correspond to, and the name family
546 -- that the Name belongs to (the AvailInfo). The situation is
547 -- complicated by associated families, which introduce a three-level
548 -- hierachy, where class = grand parent, assoc family = parent, and
549 -- data constructors = children. The occ_env entries for associated
550 -- families needs to capture all this information; hence, we have the
551 -- third component of the environment that gives the class name (=
552 -- grand parent) in case of associated families.
554 -- This env will have entries for data constructors too,
555 -- they won't make any difference because naked entities like T
556 -- in an import list map to TcOccs, not VarOccs.
557 occ_env :: OccEnv (Name, -- the name
558 AvailInfo, -- the export item providing the name
559 Maybe Name) -- the parent of associated types
560 occ_env = mkOccEnv_C combine [ (nameOccName n, (n, a, Nothing))
561 | a <- all_avails, n <- availNames a]
563 -- we know that (1) there are at most entries for one name, (2) their
564 -- first component is identical, (3) they are for tys/cls, and (4) one
565 -- entry has the name in its parent position (the other doesn't)
566 combine (name, AvailTC p1 subs1, Nothing)
567 (_ , AvailTC p2 subs2, Nothing)
569 (parent, subs) = if p1 == name then (p2, subs1) else (p1, subs2)
571 (name, AvailTC name subs, Just parent)
572 combine x y = pprPanic "filterImports/combine" (ppr x $$ ppr y)
574 lookup_lie :: Bool -> LIE RdrName -> TcRn [(LIE Name, AvailInfo)]
575 lookup_lie opt_typeFamilies (L loc ieRdr)
577 stuff <- setSrcSpan loc $
578 case lookup_ie opt_typeFamilies ieRdr of
579 Failed err -> addErr err >> return []
580 Succeeded a -> return a
581 checkDodgyImport stuff
582 return [ (L loc ie, avail) | (ie,avail) <- stuff ]
584 -- Warn when importing T(..) if T was exported abstractly
585 checkDodgyImport stuff
586 | IEThingAll n <- ieRdr, (_, AvailTC _ [_]):_ <- stuff
587 = ifDOptM Opt_WarnDodgyImports (addWarn (dodgyImportWarn n))
588 -- NB. use the RdrName for reporting the warning
589 | IEThingAll {} <- ieRdr
590 = ifDOptM Opt_WarnMissingImportList $
591 addWarn (missingImportListItem ieRdr)
595 -- For each import item, we convert its RdrNames to Names,
596 -- and at the same time construct an AvailInfo corresponding
597 -- to what is actually imported by this item.
598 -- Returns Nothing on error.
599 -- We return a list here, because in the case of an import
600 -- item like C, if we are hiding, then C refers to *both* a
601 -- type/class and a data constructor. Moreover, when we import
602 -- data constructors of an associated family, we need separate
603 -- AvailInfos for the data constructors and the family (as they have
604 -- different parents). See the discussion at occ_env.
605 lookup_ie :: Bool -> IE RdrName -> MaybeErr Message [(IE Name,AvailInfo)]
606 lookup_ie opt_typeFamilies ie
607 = let bad_ie :: MaybeErr Message a
608 bad_ie = Failed (badImportItemErr iface decl_spec ie)
611 | isQual rdr = Failed (qualImportItemErr rdr)
612 | Just nm <- lookupOccEnv occ_env (rdrNameOcc rdr) = return nm
617 (name, avail, _) <- lookup_name n
618 return [(IEVar name, trimAvail avail name)]
621 (name, avail@(AvailTC name2 subs), mb_parent) <- lookup_name tc
623 -- non-associated ty/cls
624 Nothing -> return [(IEThingAll name, avail)]
626 Just parent -> return [(IEThingAll name,
627 AvailTC name2 (subs \\ [name])),
628 (IEThingAll name, AvailTC parent [name])]
631 | want_hiding -- hiding ( C )
632 -- Here the 'C' can be a data constructor
633 -- *or* a type/class, or even both
634 -> let tc_name = lookup_name tc
635 dc_name = lookup_name (setRdrNameSpace tc srcDataName)
637 case catMaybeErr [ tc_name, dc_name ] of
639 names -> return [mkIEThingAbs name | name <- names]
641 -> do nameAvail <- lookup_name tc
642 return [mkIEThingAbs nameAvail]
644 IEThingWith tc ns -> do
645 (name, AvailTC _ subnames, mb_parent) <- lookup_name tc
647 env = mkOccEnv [(nameOccName s, s) | s <- subnames]
648 mb_children = map (lookupOccEnv env . rdrNameOcc) ns
649 children <- if any isNothing mb_children
651 else return (catMaybes mb_children)
652 -- check for proper import of type families
653 when (not opt_typeFamilies && any isTyConName children) $
654 Failed (typeItemErr (head . filter isTyConName $ children)
655 (text "in import list"))
657 -- non-associated ty/cls
658 Nothing -> return [(IEThingWith name children,
659 AvailTC name (name:children))]
661 Just parent -> return [(IEThingWith name children,
662 AvailTC name children),
663 (IEThingWith name children,
664 AvailTC parent [name])]
666 _other -> Failed illegalImportItemErr
667 -- could be IEModuleContents, IEGroup, IEDoc, IEDocNamed
671 mkIEThingAbs (n, av, Nothing ) = (IEThingAbs n, trimAvail av n)
672 mkIEThingAbs (n, _, Just parent) = (IEThingAbs n, AvailTC parent [n])
675 catMaybeErr :: [MaybeErr err a] -> [a]
676 catMaybeErr ms = [ a | Succeeded a <- ms ]
679 %************************************************************************
683 %************************************************************************
686 -- | make a 'GlobalRdrEnv' where all the elements point to the same
687 -- import declaration (useful for "hiding" imports, or imports with
689 gresFromAvails :: Provenance -> [AvailInfo] -> [GlobalRdrElt]
690 gresFromAvails prov avails
691 = concatMap (gresFromAvail (const prov)) avails
693 gresFromAvail :: (Name -> Provenance) -> AvailInfo -> [GlobalRdrElt]
694 gresFromAvail prov_fn avail
695 = [ GRE {gre_name = n,
696 gre_par = availParent n avail,
697 gre_prov = prov_fn n}
698 | n <- availNames avail ]
700 greAvail :: GlobalRdrElt -> AvailInfo
701 greAvail gre = mkUnitAvail (gre_name gre) (gre_par gre)
703 mkUnitAvail :: Name -> Parent -> AvailInfo
704 mkUnitAvail me (ParentIs p) = AvailTC p [me]
705 mkUnitAvail me NoParent | isTyConName me = AvailTC me [me]
706 | otherwise = Avail me
708 plusAvail :: GenAvailInfo Name -> GenAvailInfo Name -> GenAvailInfo Name
709 plusAvail (Avail n1) (Avail _) = Avail n1
710 plusAvail (AvailTC _ ns1) (AvailTC n2 ns2) = AvailTC n2 (ns1 `unionLists` ns2)
711 plusAvail a1 a2 = pprPanic "RnEnv.plusAvail" (hsep [ppr a1,ppr a2])
713 availParent :: Name -> AvailInfo -> Parent
714 availParent _ (Avail _) = NoParent
715 availParent n (AvailTC m _) | n == m = NoParent
716 | otherwise = ParentIs m
718 trimAvail :: AvailInfo -> Name -> AvailInfo
719 trimAvail (Avail n) _ = Avail n
720 trimAvail (AvailTC n ns) m = ASSERT( m `elem` ns) AvailTC n [m]
722 -- | filters 'AvailInfo's by the given predicate
723 filterAvails :: (Name -> Bool) -> [AvailInfo] -> [AvailInfo]
724 filterAvails keep avails = foldr (filterAvail keep) [] avails
726 -- | filters an 'AvailInfo' by the given predicate
727 filterAvail :: (Name -> Bool) -> AvailInfo -> [AvailInfo] -> [AvailInfo]
728 filterAvail keep ie rest =
730 Avail n | keep n -> ie : rest
733 let left = filter keep ns in
734 if null left then rest else AvailTC tc left : rest
736 -- | Given an import\/export spec, construct the appropriate 'GlobalRdrElt's.
737 gresFromIE :: ImpDeclSpec -> (LIE Name, AvailInfo) -> [GlobalRdrElt]
738 gresFromIE decl_spec (L loc ie, avail)
739 = gresFromAvail prov_fn avail
741 is_explicit = case ie of
742 IEThingAll name -> \n -> n == name
744 prov_fn name = Imported [imp_spec]
746 imp_spec = ImpSpec { is_decl = decl_spec, is_item = item_spec }
747 item_spec = ImpSome { is_explicit = is_explicit name, is_iloc = loc }
749 mkChildEnv :: [GlobalRdrElt] -> NameEnv [Name]
750 mkChildEnv gres = foldr add emptyNameEnv gres
752 add (GRE { gre_name = n, gre_par = ParentIs p }) env = extendNameEnv_Acc (:) singleton env p n
755 findChildren :: NameEnv [Name] -> Name -> [Name]
756 findChildren env n = lookupNameEnv env n `orElse` []
759 ---------------------------------------
762 All this AvailEnv stuff is hardly used; only in a very small
763 part of RnNames. Todo: remove?
764 ---------------------------------------
767 type AvailEnv = NameEnv AvailInfo -- Maps a Name to the AvailInfo that contains it
769 emptyAvailEnv :: AvailEnv
770 emptyAvailEnv = emptyNameEnv
773 unitAvailEnv :: AvailInfo -> AvailEnv
774 unitAvailEnv a = unitNameEnv (availName a) a
776 plusAvailEnv :: AvailEnv -> AvailEnv -> AvailEnv
777 plusAvailEnv = plusNameEnv_C plusAvail
779 availEnvElts :: AvailEnv -> [AvailInfo]
780 availEnvElts = nameEnvElts
783 addAvail :: AvailEnv -> AvailInfo -> AvailEnv
784 addAvail avails avail = extendNameEnv_C plusAvail avails (availName avail) avail
786 mkAvailEnv :: [AvailInfo] -> AvailEnv
787 -- 'avails' may have several items with the same availName
788 -- E.g import Ix( Ix(..), index )
789 -- will give Ix(Ix,index,range) and Ix(index)
790 -- We want to combine these; addAvail does that
791 mkAvailEnv avails = foldl addAvail emptyAvailEnv avails
793 -- After combining the avails, we need to ensure that the parent name is the
794 -- first entry in the list of subnames, if it is included at all. (Subsequent
795 -- functions rely on that.)
796 normaliseAvail :: AvailInfo -> AvailInfo
797 normaliseAvail avail@(Avail _) = avail
798 normaliseAvail (AvailTC name subs) = AvailTC name subs'
800 subs' = if name `elem` subs then name : (delete name subs) else subs
802 -- | combines 'AvailInfo's from the same family
803 nubAvails :: [AvailInfo] -> [AvailInfo]
804 nubAvails avails = map normaliseAvail . nameEnvElts . mkAvailEnv $ avails
808 %************************************************************************
810 \subsection{Export list processing}
812 %************************************************************************
814 Processing the export list.
816 You might think that we should record things that appear in the export
817 list as ``occurrences'' (using @addOccurrenceName@), but you'd be
818 wrong. We do check (here) that they are in scope, but there is no
819 need to slurp in their actual declaration (which is what
820 @addOccurrenceName@ forces).
822 Indeed, doing so would big trouble when compiling @PrelBase@, because
823 it re-exports @GHC@, which includes @takeMVar#@, whose type includes
824 @ConcBase.StateAndSynchVar#@, and so on...
827 type ExportAccum -- The type of the accumulating parameter of
828 -- the main worker function in rnExports
829 = ([LIE Name], -- Export items with Names
830 ExportOccMap, -- Tracks exported occurrence names
831 [AvailInfo]) -- The accumulated exported stuff
834 emptyExportAccum :: ExportAccum
835 emptyExportAccum = ([], emptyOccEnv, [])
837 type ExportOccMap = OccEnv (Name, IE RdrName)
838 -- Tracks what a particular exported OccName
839 -- in an export list refers to, and which item
840 -- it came from. It's illegal to export two distinct things
841 -- that have the same occurrence name
843 rnExports :: Bool -- False => no 'module M(..) where' header at all
844 -> Maybe [LIE RdrName] -- Nothing => no explicit export list
848 -- Complains if two distinct exports have same OccName
849 -- Warns about identical exports.
850 -- Complains about exports items not in scope
852 rnExports explicit_mod exports
853 tcg_env@(TcGblEnv { tcg_mod = this_mod,
854 tcg_rdr_env = rdr_env,
855 tcg_imports = imports })
857 -- If the module header is omitted altogether, then behave
858 -- as if the user had written "module Main(main) where..."
859 -- EXCEPT in interactive mode, when we behave as if he had
860 -- written "module Main where ..."
861 -- Reason: don't want to complain about 'main' not in scope
862 -- in interactive mode
865 | explicit_mod = exports
866 | ghcLink dflags == LinkInMemory = Nothing
867 | otherwise = Just ([noLoc (IEVar main_RDR_Unqual)])
868 -- ToDo: the 'noLoc' here is unhelpful if 'main'
869 -- turns out to be out of scope
871 ; (rn_exports, avails) <- exports_from_avail real_exports rdr_env imports this_mod
872 ; let final_avails = nubAvails avails -- Combine families
874 ; return (tcg_env { tcg_exports = final_avails,
875 tcg_rn_exports = case tcg_rn_exports tcg_env of
877 Just _ -> rn_exports,
878 tcg_dus = tcg_dus tcg_env `plusDU`
879 usesOnly (availsToNameSet final_avails) }) }
881 exports_from_avail :: Maybe [LIE RdrName]
882 -- Nothing => no explicit export list
886 -> RnM (Maybe [LIE Name], [AvailInfo])
888 exports_from_avail Nothing rdr_env _imports _this_mod
889 = -- The same as (module M) where M is the current module name,
890 -- so that's how we handle it.
892 avails = [ greAvail gre | gre <- globalRdrEnvElts rdr_env,
895 return (Nothing, avails)
897 exports_from_avail (Just rdr_items) rdr_env imports this_mod
898 = do (ie_names, _, exports) <- foldlM do_litem emptyExportAccum rdr_items
900 return (Just ie_names, exports)
902 do_litem :: ExportAccum -> LIE RdrName -> RnM ExportAccum
903 do_litem acc lie = setSrcSpan (getLoc lie) (exports_from_item acc lie)
905 kids_env :: NameEnv [Name] -- Maps a parent to its in-scope children
906 kids_env = mkChildEnv (globalRdrEnvElts rdr_env)
908 imported_modules = [ qual_name
909 | xs <- moduleEnvElts $ imp_mods imports,
910 (qual_name, _, _) <- xs ]
912 exports_from_item :: ExportAccum -> LIE RdrName -> RnM ExportAccum
913 exports_from_item acc@(ie_names, occs, exports)
914 (L loc ie@(IEModuleContents mod))
915 | let earlier_mods = [ mod | (L _ (IEModuleContents mod)) <- ie_names ]
916 , mod `elem` earlier_mods -- Duplicate export of M
917 = do { warn_dup_exports <- doptM Opt_WarnDuplicateExports ;
918 warnIf warn_dup_exports (dupModuleExport mod) ;
922 = do { implicit_prelude <- xoptM Opt_ImplicitPrelude
923 ; warnDodgyExports <- doptM Opt_WarnDodgyExports
924 ; let { exportValid = (mod `elem` imported_modules)
925 || (moduleName this_mod == mod)
926 ; gres = filter (isModuleExported implicit_prelude mod)
927 (globalRdrEnvElts rdr_env)
928 ; names = map gre_name gres
931 ; checkErr exportValid (moduleNotImported mod)
932 ; warnIf (warnDodgyExports && exportValid && null gres) (nullModuleExport mod)
934 ; addUsedRdrNames (concat [ [mkRdrQual mod occ, mkRdrUnqual occ]
935 | occ <- map nameOccName names ])
936 -- The qualified and unqualified version of all of
937 -- these names are, in effect, used by this export
939 ; occs' <- check_occs ie occs names
940 -- This check_occs not only finds conflicts
941 -- between this item and others, but also
942 -- internally within this item. That is, if
943 -- 'M.x' is in scope in several ways, we'll have
944 -- several members of mod_avails with the same
946 ; return (L loc (IEModuleContents mod) : ie_names,
947 occs', map greAvail gres ++ exports) }
949 exports_from_item acc@(lie_names, occs, exports) (L loc ie)
951 = do new_ie <- lookup_doc_ie ie
952 return (L loc new_ie : lie_names, occs, exports)
955 = do (new_ie, avail) <- lookup_ie ie
956 if isUnboundName (ieName new_ie)
957 then return acc -- Avoid error cascade
960 occs' <- check_occs ie occs (availNames avail)
962 return (L loc new_ie : lie_names, occs', avail : exports)
965 lookup_ie :: IE RdrName -> RnM (IE Name, AvailInfo)
966 lookup_ie (IEVar rdr)
967 = do gre <- lookupGreRn rdr
968 return (IEVar (gre_name gre), greAvail gre)
970 lookup_ie (IEThingAbs rdr)
971 = do gre <- lookupGreRn rdr
972 let name = gre_name gre
974 NoParent -> return (IEThingAbs name,
976 ParentIs p -> return (IEThingAbs name,
979 lookup_ie ie@(IEThingAll rdr)
980 = do name <- lookupGlobalOccRn rdr
981 let kids = findChildren kids_env name
982 mkKidRdrName = case isQual_maybe rdr of
983 Nothing -> mkRdrUnqual
984 Just (modName, _) -> mkRdrQual modName
985 addUsedRdrNames $ map (mkKidRdrName . nameOccName) kids
986 warnDodgyExports <- doptM Opt_WarnDodgyExports
989 then when warnDodgyExports $ addWarn (dodgyExportWarn name)
990 else -- This occurs when you export T(..), but
991 -- only import T abstractly, or T is a synonym.
992 addErr (exportItemErr ie)
994 return (IEThingAll name, AvailTC name (name:kids))
996 lookup_ie ie@(IEThingWith rdr sub_rdrs)
997 = do name <- lookupGlobalOccRn rdr
998 if isUnboundName name
999 then return (IEThingWith name [], AvailTC name [name])
1001 let env = mkOccEnv [ (nameOccName s, s)
1002 | s <- findChildren kids_env name ]
1003 mb_names = map (lookupOccEnv env . rdrNameOcc) sub_rdrs
1004 if any isNothing mb_names
1005 then do addErr (exportItemErr ie)
1006 return (IEThingWith name [], AvailTC name [name])
1007 else do let names = catMaybes mb_names
1008 optTyFam <- xoptM Opt_TypeFamilies
1009 when (not optTyFam && any isTyConName names) $
1010 addErr (typeItemErr ( head
1011 . filter isTyConName
1013 (text "in export list"))
1014 return (IEThingWith name names, AvailTC name (name:names))
1016 lookup_ie _ = panic "lookup_ie" -- Other cases covered earlier
1019 lookup_doc_ie :: IE RdrName -> RnM (IE Name)
1020 lookup_doc_ie (IEGroup lev doc) = do rn_doc <- rnHsDoc doc
1021 return (IEGroup lev rn_doc)
1022 lookup_doc_ie (IEDoc doc) = do rn_doc <- rnHsDoc doc
1023 return (IEDoc rn_doc)
1024 lookup_doc_ie (IEDocNamed str) = return (IEDocNamed str)
1025 lookup_doc_ie _ = panic "lookup_doc_ie" -- Other cases covered earlier
1028 isDoc :: IE RdrName -> Bool
1029 isDoc (IEDoc _) = True
1030 isDoc (IEDocNamed _) = True
1031 isDoc (IEGroup _ _) = True
1034 -------------------------------
1035 isModuleExported :: Bool -> ModuleName -> GlobalRdrElt -> Bool
1036 -- True if the thing is in scope *both* unqualified, *and* with qualifier M
1037 isModuleExported implicit_prelude mod (GRE { gre_name = name, gre_prov = prov })
1038 | implicit_prelude && isBuiltInSyntax name = False
1039 -- Optimisation: filter out names for built-in syntax
1040 -- They just clutter up the environment (esp tuples), and the parser
1041 -- will generate Exact RdrNames for them, so the cluttered
1042 -- envt is no use. To avoid doing this filter all the time,
1043 -- we use -XNoImplicitPrelude as a clue that the filter is
1044 -- worth while. Really, it's only useful for GHC.Base and GHC.Tuple.
1046 -- It's worth doing because it makes the environment smaller for
1047 -- every module that imports the Prelude
1050 LocalDef | Just name_mod <- nameModule_maybe name
1051 -> moduleName name_mod == mod
1052 | otherwise -> False
1053 Imported is -> any unQualSpecOK is && any (qualSpecOK mod) is
1055 -------------------------------
1056 check_occs :: IE RdrName -> ExportOccMap -> [Name] -> RnM ExportOccMap
1057 check_occs ie occs names
1058 = foldlM check occs names
1061 = case lookupOccEnv occs name_occ of
1062 Nothing -> return (extendOccEnv occs name_occ (name, ie))
1065 | name == name' -- Duplicate export
1066 -> do { warn_dup_exports <- doptM Opt_WarnDuplicateExports ;
1067 warnIf warn_dup_exports (dupExportWarn name_occ ie ie') ;
1070 | otherwise -- Same occ name but different names: an error
1071 -> do { global_env <- getGlobalRdrEnv ;
1072 addErr (exportClashErr global_env name' name ie' ie) ;
1075 name_occ = nameOccName name
1078 %*********************************************************
1082 %*********************************************************
1085 finishWarnings :: DynFlags -> Maybe WarningTxt
1086 -> TcGblEnv -> RnM TcGblEnv
1087 -- (a) Report usage of imports that are deprecated or have other warnings
1088 -- (b) If the whole module is warned about or deprecated, update tcg_warns
1089 -- All this happens only once per module
1090 finishWarnings dflags mod_warn tcg_env
1091 = do { (eps,hpt) <- getEpsAndHpt
1092 ; ifDOptM Opt_WarnWarningsDeprecations $
1093 mapM_ (check hpt (eps_PIT eps)) all_gres
1094 -- By this time, typechecking is complete,
1095 -- so the PIT is fully populated
1097 -- Deal with a module deprecation; it overrides all existing warns
1098 ; let new_warns = case mod_warn of
1099 Just txt -> WarnAll txt
1100 Nothing -> tcg_warns tcg_env
1101 ; return (tcg_env { tcg_warns = new_warns }) }
1103 used_names = allUses (tcg_dus tcg_env)
1104 -- Report on all deprecated uses; hence allUses
1105 all_gres = globalRdrEnvElts (tcg_rdr_env tcg_env)
1107 check hpt pit gre@(GRE {gre_name = name, gre_prov = Imported (imp_spec:_)})
1108 | name `elemNameSet` used_names
1109 , Just deprec_txt <- lookupImpDeprec dflags hpt pit gre
1110 = addWarnAt (importSpecLoc imp_spec)
1111 (sep [ptext (sLit "In the use of") <+>
1112 pprNonVarNameSpace (occNameSpace (nameOccName name)) <+>
1114 (parens imp_msg) <> colon,
1117 name_mod = ASSERT2( isExternalName name, ppr name ) nameModule name
1118 imp_mod = importSpecModule imp_spec
1119 imp_msg = ptext (sLit "imported from") <+> ppr imp_mod <> extra
1120 extra | imp_mod == moduleName name_mod = empty
1121 | otherwise = ptext (sLit ", but defined in") <+> ppr name_mod
1123 check _ _ _ = return () -- Local, or not used, or not deprectated
1124 -- The Imported pattern-match: don't deprecate locally defined names
1125 -- For a start, we may be exporting a deprecated thing
1126 -- Also we may use a deprecated thing in the defn of another
1127 -- deprecated things. We may even use a deprecated thing in
1128 -- the defn of a non-deprecated thing, when changing a module's
1131 lookupImpDeprec :: DynFlags -> HomePackageTable -> PackageIfaceTable
1132 -> GlobalRdrElt -> Maybe WarningTxt
1133 -- The name is definitely imported, so look in HPT, PIT
1134 lookupImpDeprec dflags hpt pit gre
1135 = case lookupIfaceByModule dflags hpt pit mod of
1136 Just iface -> mi_warn_fn iface name `mplus` -- Bleat if the thing, *or
1138 ParentIs p -> mi_warn_fn iface p -- its parent*, is warn'd
1141 Nothing -> Nothing -- See Note [Used names with interface not loaded]
1144 mod = ASSERT2( isExternalName name, ppr name ) nameModule name
1147 Note [Used names with interface not loaded]
1148 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1149 By now all the interfaces should have been loaded,
1150 because reportDeprecations happens after typechecking.
1151 However, it's still (just) possible to to find a used
1152 Name whose interface hasn't been loaded:
1154 a) It might be a WiredInName; in that case we may not load
1155 its interface (although we could).
1157 b) It might be GHC.Real.fromRational, or GHC.Num.fromInteger
1158 These are seen as "used" by the renamer (if -XRebindableSyntax)
1159 is on), but the typechecker may discard their uses
1160 if in fact the in-scope fromRational is GHC.Read.fromRational,
1161 (see tcPat.tcOverloadedLit), and the typechecker sees that the type
1162 is fixed, say, to GHC.Base.Float (see Inst.lookupSimpleInst).
1163 In that obscure case it won't force the interface in.
1165 In both cases we simply don't permit deprecations;
1166 this is, after all, wired-in stuff.
1169 %*********************************************************
1173 %*********************************************************
1176 reportUnusedNames :: Maybe [LIE RdrName] -- Export list
1177 -> TcGblEnv -> RnM ()
1178 reportUnusedNames _export_decls gbl_env
1179 = do { traceRn ((text "RUN") <+> (ppr (tcg_dus gbl_env)))
1180 ; warnUnusedImportDecls gbl_env
1181 ; warnUnusedTopBinds unused_locals }
1183 used_names :: NameSet
1184 used_names = findUses (tcg_dus gbl_env) emptyNameSet
1185 -- NB: currently, if f x = g, we only treat 'g' as used if 'f' is used
1188 -- Collect the defined names from the in-scope environment
1189 defined_names :: [GlobalRdrElt]
1190 defined_names = globalRdrEnvElts (tcg_rdr_env gbl_env)
1192 -- Note that defined_and_used, defined_but_not_used
1193 -- are both [GRE]; that's why we need defined_and_used
1194 -- rather than just used_names
1195 _defined_and_used, defined_but_not_used :: [GlobalRdrElt]
1196 (_defined_and_used, defined_but_not_used)
1197 = partition (gre_is_used used_names) defined_names
1199 kids_env = mkChildEnv defined_names
1200 -- This is done in mkExports too; duplicated work
1202 gre_is_used :: NameSet -> GlobalRdrElt -> Bool
1203 gre_is_used used_names (GRE {gre_name = name})
1204 = name `elemNameSet` used_names
1205 || any (`elemNameSet` used_names) (findChildren kids_env name)
1206 -- A use of C implies a use of T,
1207 -- if C was brought into scope by T(..) or T(C)
1209 -- Filter out the ones that are
1210 -- (a) defined in this module, and
1211 -- (b) not defined by a 'deriving' clause
1212 -- The latter have an Internal Name, so we can filter them out easily
1213 unused_locals :: [GlobalRdrElt]
1214 unused_locals = filter is_unused_local defined_but_not_used
1215 is_unused_local :: GlobalRdrElt -> Bool
1216 is_unused_local gre = isLocalGRE gre && isExternalName (gre_name gre)
1219 %*********************************************************
1223 %*********************************************************
1225 This code finds which import declarations are unused. The
1226 specification and implementation notes are here:
1227 http://hackage.haskell.org/trac/ghc/wiki/Commentary/Compiler/UnusedImports
1230 type ImportDeclUsage
1231 = ( LImportDecl Name -- The import declaration
1232 , [AvailInfo] -- What *is* used (normalised)
1233 , [Name] ) -- What is imported but *not* used
1237 warnUnusedImportDecls :: TcGblEnv -> RnM ()
1238 warnUnusedImportDecls gbl_env
1239 = do { uses <- readMutVar (tcg_used_rdrnames gbl_env)
1240 ; let imports = filter explicit_import (tcg_rn_imports gbl_env)
1241 rdr_env = tcg_rdr_env gbl_env
1243 ; let usage :: [ImportDeclUsage]
1244 usage = findImportUsage imports rdr_env (Set.elems uses)
1246 ; ifDOptM Opt_WarnUnusedImports $
1247 mapM_ warnUnusedImport usage
1249 ; ifDOptM Opt_D_dump_minimal_imports $
1250 printMinimalImports usage }
1252 explicit_import (L loc _) = isGoodSrcSpan loc
1253 -- Filter out the implicit Prelude import
1254 -- which we do not want to bleat about
1258 findImportUsage :: [LImportDecl Name]
1261 -> [ImportDeclUsage]
1263 type ImportMap = Map SrcLoc [AvailInfo]
1264 -- The intermediate data struture records, for each import
1265 -- declaration, what stuff brought into scope by that
1266 -- declaration is actually used in the module.
1268 -- The SrcLoc is the location of the start
1269 -- of a particular 'import' declaration
1271 -- The AvailInfos are the things imported from that decl
1272 -- (just a list, not normalised)
1274 findImportUsage imports rdr_env rdrs
1275 = map unused_decl imports
1277 import_usage :: ImportMap
1278 import_usage = foldr (addUsedRdrName rdr_env) Map.empty rdrs
1280 unused_decl decl@(L loc (ImportDecl { ideclHiding = imps }))
1281 = (decl, nubAvails used_avails, unused_imps)
1283 used_avails = Map.lookup (srcSpanStart loc) import_usage `orElse` []
1284 dont_report_as_unused = foldr add emptyNameSet used_avails
1285 add (Avail n) s = s `addOneToNameSet` n
1286 add (AvailTC n ns) s = s `addListToNameSet` (n:ns)
1287 -- If you use 'signum' from Num, then the user may well have
1288 -- imported Num(signum). We don't want to complain that
1289 -- Num is not itself mentioned. Hence adding 'n' as
1290 -- well to the list of of "don't report if unused" names
1292 unused_imps = case imps of
1293 Just (False, imp_ies) -> nameSetToList unused_imps
1295 imp_names = mkNameSet (concatMap (ieNames . unLoc) imp_ies)
1296 unused_imps = imp_names `minusNameSet` dont_report_as_unused
1298 _other -> [] -- No explicit import list => no unused-name list
1300 addUsedRdrName :: GlobalRdrEnv -> RdrName -> ImportMap -> ImportMap
1301 -- For a used RdrName, find all the import decls that brought
1302 -- it into scope; choose one of them (bestImport), and record
1303 -- the RdrName in that import decl's entry in the ImportMap
1304 addUsedRdrName rdr_env rdr imp_map
1305 | [gre] <- lookupGRE_RdrName rdr rdr_env
1306 , Imported imps <- gre_prov gre
1307 = add_imp gre (bestImport imps) imp_map
1311 add_imp :: GlobalRdrElt -> ImportSpec -> ImportMap -> ImportMap
1312 add_imp gre (ImpSpec { is_decl = imp_decl_spec }) imp_map
1313 = Map.insertWith add decl_loc [avail] imp_map
1315 add _ avails = avail : avails -- add is really just a specialised (++)
1316 decl_loc = srcSpanStart (is_dloc imp_decl_spec)
1318 avail = case gre_par gre of
1319 ParentIs p -> AvailTC p [name]
1320 NoParent | isTyConName name -> AvailTC name [name]
1321 | otherwise -> Avail name
1323 bestImport :: [ImportSpec] -> ImportSpec
1325 = case partition isImpAll iss of
1326 ([], imp_somes) -> textuallyFirst imp_somes
1327 (imp_alls, _) -> textuallyFirst imp_alls
1329 textuallyFirst :: [ImportSpec] -> ImportSpec
1330 textuallyFirst iss = case sortWith (is_dloc . is_decl) iss of
1331 [] -> pprPanic "textuallyFirst" (ppr iss)
1334 isImpAll :: ImportSpec -> Bool
1335 isImpAll (ImpSpec { is_item = ImpAll }) = True
1336 isImpAll _other = False
1340 warnUnusedImport :: ImportDeclUsage -> RnM ()
1341 warnUnusedImport (L loc decl, used, unused)
1342 | Just (False,[]) <- ideclHiding decl
1343 = return () -- Do not warn for 'import M()'
1344 | null used = addWarnAt loc msg1 -- Nothing used; drop entire decl
1345 | null unused = return () -- Everything imported is used; nop
1346 | otherwise = addWarnAt loc msg2 -- Some imports are unused
1348 msg1 = vcat [pp_herald <+> quotes pp_mod <+> pp_not_used,
1349 nest 2 (ptext (sLit "except perhaps to import instances from")
1351 ptext (sLit "To import instances alone, use:")
1352 <+> ptext (sLit "import") <+> pp_mod <> parens empty ]
1353 msg2 = sep [pp_herald <+> quotes (pprWithCommas ppr unused),
1354 text "from module" <+> quotes pp_mod <+> pp_not_used]
1355 pp_herald = text "The import of"
1356 pp_mod = ppr (unLoc (ideclName decl))
1357 pp_not_used = text "is redundant"
1360 To print the minimal imports we walk over the user-supplied import
1361 decls, and simply trim their import lists. NB that
1363 * We do *not* change the 'qualified' or 'as' parts!
1365 * We do not disard a decl altogether; we might need instances
1366 from it. Instead we just trim to an empty import list
1369 printMinimalImports :: [ImportDeclUsage] -> RnM ()
1370 printMinimalImports imports_w_usage
1371 = do { imports' <- mapM mk_minimal imports_w_usage
1372 ; this_mod <- getModule
1374 do { h <- openFile (mkFilename this_mod) WriteMode
1375 ; printForUser h neverQualify (vcat (map ppr imports')) }
1376 -- The neverQualify is important. We are printing Names
1377 -- but they are in the context of an 'import' decl, and
1378 -- we never qualify things inside there
1379 -- E.g. import Blag( f, b )
1380 -- not import Blag( Blag.f, Blag.g )!
1383 mkFilename this_mod = moduleNameString (moduleName this_mod) ++ ".imports"
1385 mk_minimal (L l decl, used, unused)
1387 , Just (False, _) <- ideclHiding decl
1390 = do { let ImportDecl { ideclName = L _ mod_name
1391 , ideclSource = is_boot
1392 , ideclPkgQual = mb_pkg } = decl
1393 ; iface <- loadSrcInterface doc mod_name is_boot mb_pkg
1394 ; let lies = map (L l) (concatMap (to_ie iface) used)
1395 ; return (L l (decl { ideclHiding = Just (False, lies) })) }
1397 doc = text "Compute minimal imports for" <+> ppr decl
1399 to_ie :: ModIface -> AvailInfo -> [IE Name]
1400 -- The main trick here is that if we're importing all the constructors
1401 -- we want to say "T(..)", but if we're importing only a subset we want
1402 -- to say "T(A,B,C)". So we have to find out what the module exports.
1405 to_ie _ (AvailTC n [m])
1406 | n==m = [IEThingAbs n]
1407 to_ie iface (AvailTC n ns)
1408 = case [xs | (m,as) <- mi_exports iface
1410 , AvailTC x xs <- as
1411 , x == nameOccName n
1412 , x `elem` xs -- Note [Partial export]
1414 [xs] | all_used xs -> [IEThingAll n]
1415 | otherwise -> [IEThingWith n (filter (/= n) ns)]
1416 _other -> (map IEVar ns)
1418 all_used avail_occs = all (`elem` map nameOccName ns) avail_occs
1419 n_mod = ASSERT( isExternalName n ) nameModule n
1422 Note [Partial export]
1423 ~~~~~~~~~~~~~~~~~~~~~
1426 module A( op ) where
1434 Then the minimal import for module B is
1438 which we would usually generate if C was exported from B. Hence
1439 the (x `elem` xs) test when deciding what to generate.
1442 %************************************************************************
1446 %************************************************************************
1449 qualImportItemErr :: RdrName -> SDoc
1450 qualImportItemErr rdr
1451 = hang (ptext (sLit "Illegal qualified name in import item:"))
1454 badImportItemErr :: ModIface -> ImpDeclSpec -> IE RdrName -> SDoc
1455 badImportItemErr iface decl_spec ie
1456 = sep [ptext (sLit "Module"), quotes (ppr (is_mod decl_spec)), source_import,
1457 ptext (sLit "does not export"), quotes (ppr ie)]
1459 source_import | mi_boot iface = ptext (sLit "(hi-boot interface)")
1462 illegalImportItemErr :: SDoc
1463 illegalImportItemErr = ptext (sLit "Illegal import item")
1465 dodgyImportWarn :: RdrName -> SDoc
1466 dodgyImportWarn item = dodgyMsg (ptext (sLit "import")) item
1467 dodgyExportWarn :: Name -> SDoc
1468 dodgyExportWarn item = dodgyMsg (ptext (sLit "export")) item
1470 dodgyMsg :: OutputableBndr n => SDoc -> n -> SDoc
1472 = sep [ ptext (sLit "The") <+> kind <+> ptext (sLit "item") <+> quotes (ppr (IEThingAll tc))
1473 <+> ptext (sLit "suggests that"),
1474 quotes (ppr tc) <+> ptext (sLit "has (in-scope) constructors or class methods,"),
1475 ptext (sLit "but it has none") ]
1477 exportItemErr :: IE RdrName -> SDoc
1478 exportItemErr export_item
1479 = sep [ ptext (sLit "The export item") <+> quotes (ppr export_item),
1480 ptext (sLit "attempts to export constructors or class methods that are not visible here") ]
1482 typeItemErr :: Name -> SDoc -> SDoc
1483 typeItemErr name wherestr
1484 = sep [ ptext (sLit "Using 'type' tag on") <+> quotes (ppr name) <+> wherestr,
1485 ptext (sLit "Use -XTypeFamilies to enable this extension") ]
1487 exportClashErr :: GlobalRdrEnv -> Name -> Name -> IE RdrName -> IE RdrName
1489 exportClashErr global_env name1 name2 ie1 ie2
1490 = vcat [ ptext (sLit "Conflicting exports for") <+> quotes (ppr occ) <> colon
1491 , ppr_export ie1' name1'
1492 , ppr_export ie2' name2' ]
1494 occ = nameOccName name1
1495 ppr_export ie name = nest 2 (quotes (ppr ie) <+> ptext (sLit "exports") <+>
1496 quotes (ppr name) <+> pprNameProvenance (get_gre name))
1498 -- get_gre finds a GRE for the Name, so that we can show its provenance
1500 = case lookupGRE_Name global_env name of
1502 [] -> pprPanic "exportClashErr" (ppr name)
1503 get_loc name = greSrcSpan (get_gre name)
1504 (name1', ie1', name2', ie2') = if get_loc name1 < get_loc name2
1505 then (name1, ie1, name2, ie2)
1506 else (name2, ie2, name1, ie1)
1508 -- the SrcSpan that pprNameProvenance prints out depends on whether
1509 -- the Name is defined locally or not: for a local definition the
1510 -- definition site is used, otherwise the location of the import
1511 -- declaration. We want to sort the export locations in
1512 -- exportClashErr by this SrcSpan, we need to extract it:
1513 greSrcSpan :: GlobalRdrElt -> SrcSpan
1515 | Imported (is:_) <- gre_prov gre = is_dloc (is_decl is)
1516 | otherwise = name_span
1518 name_span = nameSrcSpan (gre_name gre)
1520 addDupDeclErr :: [Name] -> TcRn ()
1522 = panic "addDupDeclErr: empty list"
1523 addDupDeclErr names@(name : _)
1524 = addErrAt (getSrcSpan (last sorted_names)) $
1525 -- Report the error at the later location
1526 vcat [ptext (sLit "Multiple declarations of") <+> quotes (ppr name),
1527 ptext (sLit "Declared at:") <+> vcat (map (ppr . nameSrcLoc) sorted_names)]
1529 sorted_names = sortWith nameSrcLoc names
1531 dupExportWarn :: OccName -> IE RdrName -> IE RdrName -> SDoc
1532 dupExportWarn occ_name ie1 ie2
1533 = hsep [quotes (ppr occ_name),
1534 ptext (sLit "is exported by"), quotes (ppr ie1),
1535 ptext (sLit "and"), quotes (ppr ie2)]
1537 dupModuleExport :: ModuleName -> SDoc
1539 = hsep [ptext (sLit "Duplicate"),
1540 quotes (ptext (sLit "Module") <+> ppr mod),
1541 ptext (sLit "in export list")]
1543 moduleNotImported :: ModuleName -> SDoc
1544 moduleNotImported mod
1545 = ptext (sLit "The export item `module") <+> ppr mod <>
1546 ptext (sLit "' is not imported")
1548 nullModuleExport :: ModuleName -> SDoc
1549 nullModuleExport mod
1550 = ptext (sLit "The export item `module") <+> ppr mod <> ptext (sLit "' exports nothing")
1552 missingImportListWarn :: ModuleName -> SDoc
1553 missingImportListWarn mod
1554 = ptext (sLit "The module") <+> quotes (ppr mod) <+> ptext (sLit "does not have an explicit import list")
1556 missingImportListItem :: IE RdrName -> SDoc
1557 missingImportListItem ie
1558 = ptext (sLit "The import item") <+> quotes (ppr ie) <+> ptext (sLit "does not have an explicit import list")
1560 moduleWarn :: ModuleName -> WarningTxt -> SDoc
1561 moduleWarn mod (WarningTxt txt)
1562 = sep [ ptext (sLit "Module") <+> quotes (ppr mod) <> ptext (sLit ":"),
1563 nest 2 (vcat (map ppr txt)) ]
1564 moduleWarn mod (DeprecatedTxt txt)
1565 = sep [ ptext (sLit "Module") <+> quotes (ppr mod)
1566 <+> ptext (sLit "is deprecated:"),
1567 nest 2 (vcat (map ppr txt)) ]
1569 implicitPreludeWarn :: SDoc
1571 = ptext (sLit "Module `Prelude' implicitly imported")
1573 packageImportErr :: SDoc
1575 = ptext (sLit "Package-qualified imports are not enabled; use -XPackageImports")