2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[RnNames]{Extracting imported and top-level names in scope}
8 getGlobalNames, exportsFromAvail
11 #include "HsVersions.h"
13 import CmdLineOpts ( DynFlag(..) )
15 import HsSyn ( HsModule(..), HsDecl(..), IE(..), ieName, ImportDecl(..),
16 ForeignDecl(..), ForKind(..), isDynamicExtName,
19 import RdrHsSyn ( RdrNameIE, RdrNameImportDecl,
20 RdrNameHsModule, RdrNameHsDecl
22 import RnIfaces ( recordLocalSlurps )
23 import RnHiFiles ( getTyClDeclBinders, loadInterface )
28 import PrelNames ( pRELUDE_Name, mAIN_Name, main_RDR_Unqual, isUnboundName )
29 import UniqFM ( lookupUFM )
30 import Bag ( bagToList )
31 import Module ( ModuleName, moduleName, WhereFrom(..) )
33 import Name ( Name, nameSrcLoc, nameOccName, nameEnvElts )
34 import HscTypes ( Provenance(..), ImportReason(..), GlobalRdrEnv,
35 GenAvailInfo(..), AvailInfo, Avails, AvailEnv,
36 Deprecations(..), ModIface(..)
38 import RdrName ( RdrName, rdrNameOcc, setRdrNameOcc )
39 import OccName ( setOccNameSpace, dataName )
40 import NameSet ( elemNameSet, emptyNameSet )
42 import Maybes ( maybeToBool, catMaybes, mapMaybe )
43 import UniqFM ( emptyUFM, listToUFM )
44 import ListSetOps ( removeDups )
45 import Util ( sortLt )
46 import List ( partition )
51 %************************************************************************
53 \subsection{Get global names}
55 %************************************************************************
58 getGlobalNames :: Module -> RdrNameHsModule
59 -> RnMG (GlobalRdrEnv, -- Maps all in-scope things
60 GlobalRdrEnv, -- Maps just *local* things
61 ExportAvails) -- The exported stuff
63 getGlobalNames this_mod (HsModule _ _ _ imports decls _ mod_loc)
64 = -- PROCESS LOCAL DECLS
65 -- Do these *first* so that the correct provenance gets
66 -- into the global name cache.
67 importsFromLocalDecls this_mod decls `thenRn` \ (local_gbl_env, local_mod_avails) ->
69 -- PROCESS IMPORT DECLS
70 -- Do the non {- SOURCE -} ones first, so that we get a helpful
71 -- warning for {- SOURCE -} ones that are unnecessary
72 doptRn Opt_NoImplicitPrelude `thenRn` \ opt_no_prelude ->
74 all_imports = mk_prel_imports opt_no_prelude ++ imports
75 (source, ordinary) = partition is_source_import all_imports
76 is_source_import (ImportDecl _ ImportByUserSource _ _ _ _) = True
77 is_source_import other = False
79 get_imports = importsFromImportDecl this_mod_name
81 mapAndUnzipRn get_imports ordinary `thenRn` \ (imp_gbl_envs1, imp_avails_s1) ->
82 mapAndUnzipRn get_imports source `thenRn` \ (imp_gbl_envs2, imp_avails_s2) ->
85 -- We put the local env second, so that a local provenance
86 -- "wins", even if a module imports itself.
88 gbl_env :: GlobalRdrEnv
89 imp_gbl_env = foldr plusGlobalRdrEnv emptyRdrEnv (imp_gbl_envs2 ++ imp_gbl_envs1)
90 gbl_env = imp_gbl_env `plusGlobalRdrEnv` local_gbl_env
92 all_avails :: ExportAvails
93 all_avails = foldr plusExportAvails local_mod_avails (imp_avails_s2 ++ imp_avails_s1)
97 returnRn (gbl_env, local_gbl_env, all_avails)
99 this_mod_name = moduleName this_mod
101 -- NB: opt_NoImplicitPrelude is slightly different to import Prelude ();
102 -- because the former doesn't even look at Prelude.hi for instance declarations,
103 -- whereas the latter does.
104 mk_prel_imports no_prelude
105 | this_mod_name == pRELUDE_Name ||
106 explicit_prelude_import ||
110 | otherwise = [ImportDecl pRELUDE_Name
112 False {- Not qualified -}
113 Nothing {- No "as" -}
114 Nothing {- No import list -}
117 explicit_prelude_import
118 = not (null [ () | (ImportDecl mod _ _ _ _ _) <- imports, mod == pRELUDE_Name ])
122 importsFromImportDecl :: ModuleName
124 -> RnMG (GlobalRdrEnv,
127 importsFromImportDecl this_mod_name (ImportDecl imp_mod_name from qual_only as_mod import_spec iloc)
128 = pushSrcLocRn iloc $
130 loadInterface (ppr imp_mod_name <+> ptext SLIT("is directly imported"))
131 imp_mod_name from `thenRn` \ iface ->
133 imp_mod = mi_module iface
134 avails_by_module = mi_exports iface
135 deprecs = mi_deprecs iface
138 avails = [ avail | (mod_name, avails) <- avails_by_module,
139 mod_name /= this_mod_name,
141 -- If the module exports anything defined in this module, just ignore it.
142 -- Reason: otherwise it looks as if there are two local definition sites
143 -- for the thing, and an error gets reported. Easiest thing is just to
144 -- filter them out up front. This situation only arises if a module
145 -- imports 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.
159 if null avails_by_module then
160 -- If there's an error in loadInterface, (e.g. interface
161 -- file not found) we get lots of spurious errors from 'filterImports'
162 returnRn (emptyRdrEnv, mkEmptyExportAvails imp_mod_name)
165 -- Complain if we import a deprecated module
167 DeprecAll txt -> addWarnRn (moduleDeprec imp_mod_name txt)
171 -- Filter the imports according to the import list
172 filterImports imp_mod_name from import_spec avails `thenRn` \ (filtered_avails, hides, explicits) ->
175 unqual_imp = not qual_only -- Maybe want unqualified names
176 qual_mod = case as_mod of
177 Nothing -> imp_mod_name
178 Just another_name -> another_name
180 mk_prov name = NonLocalDef (UserImport imp_mod iloc (name `elemNameSet` explicits))
181 gbl_env = mkGlobalRdrEnv qual_mod unqual_imp True hides mk_prov filtered_avails deprecs
182 exports = mkExportAvails qual_mod unqual_imp gbl_env filtered_avails
184 returnRn (gbl_env, exports)
189 importsFromLocalDecls this_mod decls
190 = mapRn (getLocalDeclBinders this_mod) decls `thenRn` \ avails_s ->
191 -- The avails that are returned don't include the "system" names
193 avails = concat avails_s
195 all_names :: [Name] -- All the defns; no dups eliminated
196 all_names = [name | avail <- avails, name <- availNames avail]
199 (_, dups) = removeDups compare all_names
201 -- Check for duplicate definitions
202 mapRn_ (addErrRn . dupDeclErr) dups `thenRn_`
205 -- Record that locally-defined things are available
206 recordLocalSlurps (availsToNameSet avails) `thenRn_`
208 mod_name = moduleName this_mod
209 unqual_imp = True -- Want unqualified names
210 mk_prov n = LocalDef -- Provenance is local
211 hides = [] -- Hide nothing
213 gbl_env = mkGlobalRdrEnv mod_name unqual_imp True hides mk_prov avails NoDeprecs
214 -- NoDeprecs: don't complain about locally defined names
215 -- For a start, we may be exporting a deprecated thing
216 -- Also we may use a deprecated thing in the defn of another
217 -- deprecated things. We may even use a deprecated thing in
218 -- the defn of a non-deprecated thing, when changing a module's
221 exports = mkExportAvails mod_name unqual_imp gbl_env avails
223 returnRn (gbl_env, exports)
225 ---------------------------
226 getLocalDeclBinders :: Module -> RdrNameHsDecl -> RnMG [AvailInfo]
227 getLocalDeclBinders mod (TyClD tycl_decl)
228 = -- For type and class decls, we generate Global names, with
229 -- no export indicator. They need to be global because they get
230 -- permanently bound into the TyCons and Classes. They don't need
231 -- an export indicator because they are all implicitly exported.
232 getTyClDeclBinders mod tycl_decl `thenRn` \ (avail, sys_names) ->
234 -- Record that the system names are available
235 recordLocalSlurps (mkNameSet sys_names) `thenRn_`
238 getLocalDeclBinders mod (ValD binds)
239 = mapRn new (bagToList (collectTopBinders binds)) `thenRn` \ avails ->
242 new (rdr_name, loc) = newTopBinder mod rdr_name loc `thenRn` \ name ->
243 returnRn (Avail name)
245 getLocalDeclBinders mod (ForD (ForeignDecl nm kind _ ext_nm _ loc))
246 | binds_haskell_name kind
247 = newTopBinder mod nm loc `thenRn` \ name ->
248 returnRn [Avail name]
250 | otherwise -- a foreign export
253 binds_haskell_name (FoImport _) = True
254 binds_haskell_name FoLabel = True
255 binds_haskell_name FoExport = isDynamicExtName ext_nm
257 getLocalDeclBinders mod (FixD _) = returnRn []
258 getLocalDeclBinders mod (DeprecD _) = returnRn []
259 getLocalDeclBinders mod (DefD _) = returnRn []
260 getLocalDeclBinders mod (InstD _) = returnRn []
261 getLocalDeclBinders mod (RuleD _) = returnRn []
265 %************************************************************************
267 \subsection{Filtering imports}
269 %************************************************************************
271 @filterImports@ takes the @ExportEnv@ telling what the imported module makes
272 available, and filters it through the import spec (if any).
275 filterImports :: ModuleName -- The module being imported
276 -> WhereFrom -- Tells whether it's a {-# SOURCE #-} import
277 -> Maybe (Bool, [RdrNameIE]) -- Import spec; True => hiding
278 -> [AvailInfo] -- What's available
279 -> RnMG ([AvailInfo], -- What's actually imported
280 [AvailInfo], -- What's to be hidden
281 -- (the unqualified version, that is)
282 -- (We need to return both the above sets, because
283 -- the qualified version is never hidden; so we can't
284 -- implement hiding by reducing what's imported.)
285 NameSet) -- What was imported explicitly
287 -- Complains if import spec mentions things that the module doesn't export
288 -- Warns/informs if import spec contains duplicates.
289 filterImports mod from Nothing imports
290 = returnRn (imports, [], emptyNameSet)
292 filterImports mod from (Just (want_hiding, import_items)) total_avails
293 = flatMapRn get_item import_items `thenRn` \ avails_w_explicits ->
295 (item_avails, explicits_s) = unzip avails_w_explicits
296 explicits = foldl addListToNameSet emptyNameSet explicits_s
300 -- All imported; item_avails to be hidden
301 returnRn (total_avails, item_avails, emptyNameSet)
303 -- Just item_avails imported; nothing to be hidden
304 returnRn (item_avails, [], explicits)
306 import_fm :: FiniteMap OccName AvailInfo
307 import_fm = listToFM [ (nameOccName name, avail)
308 | avail <- total_avails,
309 name <- availNames avail]
310 -- Even though availNames returns data constructors too,
311 -- they won't make any difference because naked entities like T
312 -- in an import list map to TcOccs, not VarOccs.
314 bale_out item = addErrRn (badImportItemErr mod from item) `thenRn_`
317 get_item item@(IEModuleContents _) = bale_out item
319 get_item item@(IEThingAll _)
320 = case check_item item of
321 Nothing -> bale_out item
322 Just avail@(AvailTC _ [n]) -> -- This occurs when you import T(..), but
323 -- only export T abstractly. The single [n]
324 -- in the AvailTC is the type or class itself
325 addWarnRn (dodgyImportWarn mod item) `thenRn_`
326 returnRn [(avail, [availName avail])]
327 Just avail -> returnRn [(avail, [availName avail])]
329 get_item item@(IEThingAbs n)
330 | want_hiding -- hiding( C )
331 -- Here the 'C' can be a data constructor *or* a type/class
332 = case catMaybes [check_item item, check_item (IEThingAbs data_n)] of
334 avails -> returnRn [(a, []) | a <- avails]
335 -- The 'explicits' list is irrelevant when hiding
337 data_n = setRdrNameOcc n (setOccNameSpace (rdrNameOcc n) dataName)
340 = case check_item item of
341 Nothing -> bale_out item
342 Just avail -> returnRn [(avail, availNames avail)]
345 | not (maybeToBool maybe_in_import_avails) ||
346 not (maybeToBool maybe_filtered_avail)
350 = Just filtered_avail
353 wanted_occ = rdrNameOcc (ieName item)
354 maybe_in_import_avails = lookupFM import_fm wanted_occ
356 Just avail = maybe_in_import_avails
357 maybe_filtered_avail = filterAvail item avail
358 Just filtered_avail = maybe_filtered_avail
363 %************************************************************************
365 \subsection{Qualifiying imports}
367 %************************************************************************
370 mkEmptyExportAvails :: ModuleName -> ExportAvails
371 mkEmptyExportAvails mod_name = (unitFM mod_name [], emptyUFM)
373 mkExportAvails :: ModuleName -> Bool -> GlobalRdrEnv -> [AvailInfo] -> ExportAvails
374 mkExportAvails mod_name unqual_imp gbl_env avails
375 = (mod_avail_env, entity_avail_env)
377 mod_avail_env = unitFM mod_name unqual_avails
379 -- unqual_avails is the Avails that are visible in *unqualfied* form
380 -- (1.4 Report, Section 5.1.1)
382 -- import T hiding( f )
383 -- we delete f from avails
385 unqual_avails | not unqual_imp = [] -- Short cut when no unqualified imports
386 | otherwise = mapMaybe prune avails
388 prune (Avail n) | unqual_in_scope n = Just (Avail n)
389 prune (Avail n) | otherwise = Nothing
390 prune (AvailTC n ns) | null uqs = Nothing
391 | otherwise = Just (AvailTC n uqs)
393 uqs = filter unqual_in_scope ns
395 unqual_in_scope n = unQualInScope gbl_env n
397 entity_avail_env = listToUFM [ (name,avail) | avail <- avails,
398 name <- availNames avail]
400 plusExportAvails :: ExportAvails -> ExportAvails -> ExportAvails
401 plusExportAvails (m1, e1) (m2, e2)
402 = (plusFM_C (++) m1 m2, plusAvailEnv e1 e2)
403 -- ToDo: wasteful: we do this once for each constructor!
407 %************************************************************************
409 \subsection{Export list processing}
411 %************************************************************************
413 Processing the export list.
415 You might think that we should record things that appear in the export list
416 as ``occurrences'' (using @addOccurrenceName@), but you'd be wrong.
417 We do check (here) that they are in scope,
418 but there is no need to slurp in their actual declaration
419 (which is what @addOccurrenceName@ forces).
421 Indeed, doing so would big trouble when
422 compiling @PrelBase@, because it re-exports @GHC@, which includes @takeMVar#@,
423 whose type includes @ConcBase.StateAndSynchVar#@, and so on...
426 type ExportAccum -- The type of the accumulating parameter of
427 -- the main worker function in exportsFromAvail
428 = ([ModuleName], -- 'module M's seen so far
429 ExportOccMap, -- Tracks exported occurrence names
430 AvailEnv) -- The accumulated exported stuff, kept in an env
431 -- so we can common-up related AvailInfos
433 type ExportOccMap = FiniteMap OccName (Name, RdrNameIE)
434 -- Tracks what a particular exported OccName
435 -- in an export list refers to, and which item
436 -- it came from. It's illegal to export two distinct things
437 -- that have the same occurrence name
440 exportsFromAvail :: ModuleName
441 -> Maybe [RdrNameIE] -- Export spec
445 -- Complains if two distinct exports have same OccName
446 -- Warns about identical exports.
447 -- Complains about exports items not in scope
448 exportsFromAvail this_mod Nothing export_avails global_name_env
449 = exportsFromAvail this_mod true_exports export_avails global_name_env
451 true_exports = Just $ if this_mod == mAIN_Name
452 then [IEVar main_RDR_Unqual]
453 -- export Main.main *only* unless otherwise specified,
454 else [IEModuleContents this_mod]
455 -- but for all other modules export everything.
457 exportsFromAvail this_mod (Just export_items)
458 (mod_avail_env, entity_avail_env)
460 = doptRn Opt_WarnDuplicateExports `thenRn` \ warn_dup_exports ->
461 foldlRn (exports_from_item warn_dup_exports)
462 ([], emptyFM, emptyAvailEnv) export_items
463 `thenRn` \ (_, _, export_avail_map) ->
465 export_avails :: [AvailInfo]
466 export_avails = nameEnvElts export_avail_map
468 returnRn export_avails
471 exports_from_item :: Bool -> ExportAccum -> RdrNameIE -> RnMG ExportAccum
473 exports_from_item warn_dups acc@(mods, occs, avails) ie@(IEModuleContents mod)
474 | mod `elem` mods -- Duplicate export of M
475 = warnCheckRn warn_dups (dupModuleExport mod) `thenRn_`
479 = case lookupFM mod_avail_env mod of
480 Nothing -> failWithRn acc (modExportErr mod)
481 Just mod_avails -> foldlRn (check_occs ie) occs mod_avails
484 avails' = foldl addAvail avails mod_avails
486 returnRn (mod:mods, occs', avails')
488 exports_from_item warn_dups acc@(mods, occs, avails) ie
489 = lookupSrcName global_name_env (ieName ie) `thenRn` \ name ->
491 -- See what's available in the current environment
492 case lookupUFM entity_avail_env name of {
493 Nothing -> -- Presumably this happens because lookupSrcName didn't find
494 -- the name and returned an unboundName, which won't be in
495 -- the entity_avail_env, of course
496 WARN( not (isUnboundName name), ppr name )
501 -- Filter out the bits we want
502 case filterAvail ie avail of {
503 Nothing -> -- Not enough availability
504 failWithRn acc (exportItemErr ie) ;
508 -- Phew! It's OK! Now to check the occurrence stuff!
509 warnCheckRn (ok_item ie avail) (dodgyExportWarn ie) `thenRn_`
510 check_occs ie occs export_avail `thenRn` \ occs' ->
511 returnRn (mods, occs', addAvail avails export_avail)
516 ok_item (IEThingAll _) (AvailTC _ [n]) = False
517 -- This occurs when you import T(..), but
518 -- only export T abstractly. The single [n]
519 -- in the AvailTC is the type or class itself
522 check_occs :: RdrNameIE -> ExportOccMap -> AvailInfo -> RnMG ExportOccMap
523 check_occs ie occs avail
524 = doptRn Opt_WarnDuplicateExports `thenRn` \ warn_dup_exports ->
525 foldlRn (check warn_dup_exports) occs (availNames avail)
527 check warn_dup occs name
528 = case lookupFM occs name_occ of
529 Nothing -> returnRn (addToFM occs name_occ (name, ie))
531 | name == name' -> -- Duplicate export
533 (dupExportWarn name_occ ie ie')
534 `thenRn_` returnRn occs
536 | otherwise -> -- Same occ name but different names: an error
537 failWithRn occs (exportClashErr name_occ ie ie')
539 name_occ = nameOccName name
542 %************************************************************************
546 %************************************************************************
549 badImportItemErr mod from ie
550 = sep [ptext SLIT("Module"), quotes (ppr mod), source_import,
551 ptext SLIT("does not export"), quotes (ppr ie)]
553 source_import = case from of
554 ImportByUserSource -> ptext SLIT("(hi-boot interface)")
557 dodgyImportWarn mod item = dodgyMsg (ptext SLIT("import")) item
558 dodgyExportWarn item = dodgyMsg (ptext SLIT("export")) item
560 dodgyMsg kind item@(IEThingAll tc)
561 = sep [ ptext SLIT("The") <+> kind <+> ptext SLIT("item") <+> quotes (ppr item),
562 ptext SLIT("suggests that") <+> quotes (ppr tc) <+> ptext SLIT("has constructor or class methods"),
563 ptext SLIT("but it has none; it is a type synonym or abstract type or class") ]
566 = hsep [ ptext SLIT("Unknown module in export list: module"), quotes (ppr mod)]
568 exportItemErr export_item
569 = sep [ ptext SLIT("The export item") <+> quotes (ppr export_item),
570 ptext SLIT("attempts to export constructors or class methods that are not visible here") ]
572 exportClashErr occ_name ie1 ie2
573 = hsep [ptext SLIT("The export items"), quotes (ppr ie1)
574 ,ptext SLIT("and"), quotes (ppr ie2)
575 ,ptext SLIT("create conflicting exports for"), quotes (ppr occ_name)]
578 = vcat [ptext SLIT("Multiple declarations of") <+> quotes (ppr n),
579 nest 4 (vcat (map ppr sorted_locs))]
581 sorted_locs = sortLt occ'ed_before (map nameSrcLoc (n:ns))
582 occ'ed_before a b = LT == compare a b
584 dupExportWarn occ_name ie1 ie2
585 = hsep [quotes (ppr occ_name),
586 ptext SLIT("is exported by"), quotes (ppr ie1),
587 ptext SLIT("and"), quotes (ppr ie2)]
590 = hsep [ptext SLIT("Duplicate"),
591 quotes (ptext SLIT("Module") <+> ppr mod),
592 ptext SLIT("in export list")]
595 = sep [ ptext SLIT("Module") <+> quotes (ppr mod) <+> ptext SLIT("is deprecated:"),