\begin{code}
module RnNames (
- getGlobalNames
+ getGlobalNames, exportsFromAvail
) where
#include "HsVersions.h"
-import CmdLineOpts ( DynFlag(..), opt_NoImplicitPrelude )
+import CmdLineOpts ( DynFlag(..) )
import HsSyn ( HsModule(..), HsDecl(..), IE(..), ieName, ImportDecl(..),
ForeignDecl(..), ForKind(..), isDynamicExtName,
import RnMonad
import FiniteMap
-import PrelNames ( pRELUDE_Name, mAIN_Name, main_RDR )
+import PrelNames ( pRELUDE_Name, mAIN_Name, main_RDR_Unqual, isUnboundName )
import UniqFM ( lookupUFM )
import Bag ( bagToList )
-import Module ( ModuleName, mkModuleInThisPackage, WhereFrom(..) )
+import Module ( ModuleName, moduleName, WhereFrom(..) )
import NameSet
-import Name ( Name, nameSrcLoc,
- setLocalNameSort, nameOccName, nameEnvElts )
+import Name ( Name, nameSrcLoc, nameOccName, nameEnvElts )
import HscTypes ( Provenance(..), ImportReason(..), GlobalRdrEnv,
GenAvailInfo(..), AvailInfo, Avails, AvailEnv )
-import RdrName ( RdrName, rdrNameOcc, setRdrNameOcc, mkRdrQual, mkRdrUnqual, isUnqual )
+import RdrName ( RdrName, rdrNameOcc, setRdrNameOcc, mkRdrQual, mkRdrUnqual )
import OccName ( setOccNameSpace, dataName )
import NameSet ( elemNameSet, emptyNameSet )
-import SrcLoc ( SrcLoc )
import Outputable
import Maybes ( maybeToBool, catMaybes, mapMaybe )
import UniqFM ( emptyUFM, listToUFM )
%************************************************************************
\begin{code}
-getGlobalNames :: RdrNameHsModule
- -> RnMG (Maybe (GlobalRdrEnv, -- Maps all in-scope things
- GlobalRdrEnv, -- Maps just *local* things
- Avails, -- The exported stuff
- AvailEnv -- Maps a name to its parent AvailInfo
- -- Just for in-scope things only
- ))
- -- Nothing => no need to recompile
-
-getGlobalNames (HsModule this_mod _ exports imports decls _ mod_loc)
- = -- These two fix-loops are to get the right
- -- provenance information into a Name
- fixRn ( \ ~(Just (rec_gbl_env, _, rec_export_avails, _)) ->
+getGlobalNames :: Module -> RdrNameHsModule
+ -> RnMG (GlobalRdrEnv, -- Maps all in-scope things
+ GlobalRdrEnv, -- Maps just *local* things
+ ExportAvails) -- The exported stuff
- let
- rec_unqual_fn :: Name -> Bool -- Is this chap in scope unqualified?
- rec_unqual_fn = unQualInScope rec_gbl_env
-
- rec_exp_fn :: Name -> Bool
- rec_exp_fn = mk_export_fn (availsToNameSet rec_export_avails)
- in
-
- -- PROCESS LOCAL DECLS
+getGlobalNames this_mod (HsModule _ _ _ imports decls _ mod_loc)
+ = -- PROCESS LOCAL DECLS
-- Do these *first* so that the correct provenance gets
-- into the global name cache.
- importsFromLocalDecls this_mod rec_exp_fn decls
- `thenRn` \ (local_gbl_env, local_mod_avails) ->
+ importsFromLocalDecls this_mod decls `thenRn` \ (local_gbl_env, local_mod_avails) ->
-- PROCESS IMPORT DECLS
-- Do the non {- SOURCE -} ones first, so that we get a helpful
-- warning for {- SOURCE -} ones that are unnecessary
+ doptRn Opt_NoImplicitPrelude `thenRn` \ opt_no_prelude ->
let
+ all_imports = mk_prel_imports opt_no_prelude ++ imports
(source, ordinary) = partition is_source_import all_imports
is_source_import (ImportDecl _ ImportByUserSource _ _ _ _) = True
is_source_import other = False
+
+ get_imports = importsFromImportDecl this_mod_name
in
- mapAndUnzipRn (importsFromImportDecl rec_unqual_fn) ordinary
- `thenRn` \ (imp_gbl_envs1, imp_avails_s1) ->
- mapAndUnzipRn (importsFromImportDecl rec_unqual_fn) source
- `thenRn` \ (imp_gbl_envs2, imp_avails_s2) ->
+ mapAndUnzipRn get_imports ordinary `thenRn` \ (imp_gbl_envs1, imp_avails_s1) ->
+ mapAndUnzipRn get_imports source `thenRn` \ (imp_gbl_envs2, imp_avails_s2) ->
-- COMBINE RESULTS
-- We put the local env second, so that a local provenance
all_avails :: ExportAvails
all_avails = foldr plusExportAvails local_mod_avails (imp_avails_s2 ++ imp_avails_s1)
- (_, global_avail_env) = all_avails
in
- -- TRY FOR EARLY EXIT
- -- We can't go for an early exit before this because we have to check
- -- for name clashes. Consider:
- --
- -- module A where module B where
- -- import B h = True
- -- f = h
- --
- -- Suppose I've compiled everything up, and then I add a
- -- new definition to module B, that defines "f".
- --
- -- Then I must detect the name clash in A before going for an early
- -- exit. The early-exit code checks what's actually needed from B
- -- to compile A, and of course that doesn't include B.f. That's
- -- why we wait till after the plusEnv stuff to do the early-exit.
-
- -- Check For early exit
- checkErrsRn `thenRn` \ no_errs_so_far ->
- if not no_errs_so_far then
- -- Found errors already, so exit now
- returnRn Nothing
- else
-
- -- PROCESS EXPORT LISTS
- exportsFromAvail this_mod exports all_avails gbl_env `thenRn` \ export_avails ->
-
-
-- ALL DONE
- returnRn (Just (gbl_env, local_gbl_env, export_avails, global_avail_env))
- )
+ returnRn (gbl_env, local_gbl_env, all_avails)
where
- all_imports = prel_imports ++ imports
+ this_mod_name = moduleName this_mod
-- NB: opt_NoImplicitPrelude is slightly different to import Prelude ();
-- because the former doesn't even look at Prelude.hi for instance declarations,
-- whereas the latter does.
- prel_imports | this_mod == pRELUDE_Name ||
- explicit_prelude_import ||
- opt_NoImplicitPrelude
- = []
-
- | otherwise = [ImportDecl pRELUDE_Name
- ImportByUser
- False {- Not qualified -}
- Nothing {- No "as" -}
- Nothing {- No import list -}
- mod_loc]
+ mk_prel_imports no_prelude
+ | this_mod_name == pRELUDE_Name ||
+ explicit_prelude_import ||
+ no_prelude
+ = []
+
+ | otherwise = [ImportDecl pRELUDE_Name
+ ImportByUser
+ False {- Not qualified -}
+ Nothing {- No "as" -}
+ Nothing {- No import list -}
+ mod_loc]
explicit_prelude_import
= not (null [ () | (ImportDecl mod _ _ _ _ _) <- imports, mod == pRELUDE_Name ])
\end{code}
\begin{code}
-importsFromImportDecl :: (Name -> Bool) -- OK to omit qualifier
+importsFromImportDecl :: ModuleName
-> RdrNameImportDecl
-> RnMG (GlobalRdrEnv,
ExportAvails)
-importsFromImportDecl is_unqual (ImportDecl imp_mod_name from qual_only as_mod import_spec iloc)
+importsFromImportDecl this_mod_name (ImportDecl imp_mod_name from qual_only as_mod import_spec iloc)
= pushSrcLocRn iloc $
getInterfaceExports imp_mod_name from `thenRn` \ (imp_mod, avails_by_module) ->
let
avails :: Avails
- avails = concat (map snd avails_by_module)
+ avails = [ avail | (mod_name, avails) <- avails_by_module,
+ mod_name /= this_mod_name,
+ avail <- avails ]
+ -- If the module exports anything defined in this module, just ignore it.
+ -- Reason: otherwise it looks as if there are two local definition sites
+ -- for the thing, and an error gets reported. Easiest thing is just to
+ -- filter them out up front. This situation only arises if a module
+ -- imports itself, or another module that imported it. (Necessarily,
+ -- this invoves a loop.)
+ --
+ -- Tiresome consequence: if you say
+ -- module A where
+ -- import B( AType )
+ -- type AType = ...
+ --
+ -- module B( AType ) where
+ -- import {-# SOURCE #-} A( AType )
+ --
+ -- then you'll get a 'B does not export AType' message. Oh well.
+
in
- filterImports imp_mod_name import_spec avails `thenRn` \ (filtered_avails, hides, explicits) ->
+ filterImports imp_mod_name from import_spec avails `thenRn` \ (filtered_avails, hides, explicits) ->
let
mk_provenance name = NonLocalDef (UserImport imp_mod iloc (name `elemNameSet` explicits))
- (is_unqual name)
in
qualifyImports imp_mod_name
\begin{code}
-importsFromLocalDecls mod_name rec_exp_fn decls
- = mapRn (getLocalDeclBinders (newLocalName mod rec_exp_fn)) decls `thenRn` \ avails_s ->
+importsFromLocalDecls this_mod decls
+ = mapRn (getLocalDeclBinders this_mod) decls `thenRn` \ avails_s ->
let
avails = concat avails_s
(_, dups) = removeDups compare all_names
in
-- Check for duplicate definitions
- mapRn_ (addErrRn . dupDeclErr) dups `thenRn_`
+ mapRn_ (addErrRn . dupDeclErr) dups `thenRn_`
-- Record that locally-defined things are available
- recordLocalSlurps avails `thenRn_`
+ recordLocalSlurps (availsToNameSet avails) `thenRn_`
-- Build the environment
- qualifyImports mod_name
+ qualifyImports (moduleName this_mod)
True -- Want unqualified names
Nothing -- no 'as M'
[] -- Hide nothing
(\n -> LocalDef) -- Provenance is local
avails
- where
- mod = mkModuleInThisPackage mod_name
---------------------------
-getLocalDeclBinders :: (RdrName -> SrcLoc -> RnMG Name)
+getLocalDeclBinders :: Module
-> RdrNameHsDecl -> RnMG Avails
-getLocalDeclBinders new_name (ValD binds)
- = mapRn do_one (bagToList (collectTopBinders binds))
- where
- do_one (rdr_name, loc) = new_name rdr_name loc `thenRn` \ name ->
- returnRn (Avail name)
-
-getLocalDeclBinders new_name (TyClD tycl_decl)
- = getTyClDeclBinders new_name tycl_decl `thenRn` \ avail ->
+getLocalDeclBinders mod (TyClD tycl_decl)
+ = -- For type and class decls, we generate Global names, with
+ -- no export indicator. They need to be global because they get
+ -- permanently bound into the TyCons and Classes. They don't need
+ -- an export indicator because they are all implicitly exported.
+ getTyClDeclBinders mod tycl_decl `thenRn` \ avail ->
returnRn [avail]
-getLocalDeclBinders new_name (ForD (ForeignDecl nm kind _ ext_nm _ loc))
+getLocalDeclBinders mod (ValD binds)
+ = mapRn new (bagToList (collectTopBinders binds))
+ where
+ new (rdr_name, loc) = newTopBinder mod rdr_name loc `thenRn` \ name ->
+ returnRn (Avail name)
+
+getLocalDeclBinders mod (ForD (ForeignDecl nm kind _ ext_nm _ loc))
| binds_haskell_name kind
- = new_name nm loc `thenRn` \ name ->
+ = newTopBinder mod nm loc `thenRn` \ name ->
returnRn [Avail name]
| otherwise -- a foreign export
- = lookupOrigName nm `thenRn_`
- returnRn []
+ = returnRn []
where
binds_haskell_name (FoImport _) = True
binds_haskell_name FoLabel = True
binds_haskell_name FoExport = isDynamicExtName ext_nm
-getLocalDeclBinders new_name (FixD _) = returnRn []
-getLocalDeclBinders new_name (DeprecD _) = returnRn []
-getLocalDeclBinders new_name (DefD _) = returnRn []
-getLocalDeclBinders new_name (InstD _) = returnRn []
-getLocalDeclBinders new_name (RuleD _) = returnRn []
-
-
----------------------------
-newLocalName mod rec_exp_fn rdr_name loc
- = check_unqual rdr_name loc `thenRn_`
- newTopBinder mod rdr_name loc `thenRn` \ name ->
- returnRn (setLocalNameSort name (rec_exp_fn name))
- where
- -- There should never be a qualified name in a binding position (except in instance decls)
- -- The parser doesn't check this because the same parser parses instance decls
- check_unqual rdr_name loc
- | isUnqual rdr_name = returnRn ()
- | otherwise = qualNameErr (text "the binding for" <+> quotes (ppr rdr_name))
- (rdr_name,loc)
+getLocalDeclBinders mod (FixD _) = returnRn []
+getLocalDeclBinders mod (DeprecD _) = returnRn []
+getLocalDeclBinders mod (DefD _) = returnRn []
+getLocalDeclBinders mod (InstD _) = returnRn []
+getLocalDeclBinders mod (RuleD _) = returnRn []
\end{code}
\begin{code}
filterImports :: ModuleName -- The module being imported
+ -> WhereFrom -- Tells whether it's a {-# SOURCE #-} import
-> Maybe (Bool, [RdrNameIE]) -- Import spec; True => hiding
-> [AvailInfo] -- What's available
-> RnMG ([AvailInfo], -- What's actually imported
-- Complains if import spec mentions things that the module doesn't export
-- Warns/informs if import spec contains duplicates.
-filterImports mod Nothing imports
+filterImports mod from Nothing imports
= returnRn (imports, [], emptyNameSet)
-filterImports mod (Just (want_hiding, import_items)) total_avails
+filterImports mod from (Just (want_hiding, import_items)) total_avails
= flatMapRn get_item import_items `thenRn` \ avails_w_explicits ->
let
(item_avails, explicits_s) = unzip avails_w_explicits
-- they won't make any difference because naked entities like T
-- in an import list map to TcOccs, not VarOccs.
- bale_out item = addErrRn (badImportItemErr mod item) `thenRn_`
+ bale_out item = addErrRn (badImportItemErr mod from item) `thenRn_`
returnRn []
get_item item@(IEModuleContents _) = bale_out item
qualifyImports :: ModuleName -- Imported module
-> Bool -- True <=> want unqualified import
-> Maybe ModuleName -- Optional "as M" part
- -> [AvailInfo] -- What's to be hidden
+ -> [AvailInfo] -- What's to be hidden (but only the unqualified
+ -- version is hidden)
-> (Name -> Provenance)
-> Avails -- Whats imported and how
-> RnMG (GlobalRdrEnv, ExportAvails)
= exportsFromAvail this_mod true_exports export_avails global_name_env
where
true_exports = Just $ if this_mod == mAIN_Name
- then [IEVar main_RDR]
+ then [IEVar main_RDR_Unqual]
-- export Main.main *only* unless otherwise specified,
else [IEModuleContents this_mod]
-- but for all other modules export everything.
returnRn (mod:mods, occs', avails')
exports_from_item warn_dups acc@(mods, occs, avails) ie
- | not (maybeToBool maybe_in_scope)
- = failWithRn acc (unknownNameErr (ieName ie))
+ = lookupSrcName global_name_env (ieName ie) `thenRn` \ name ->
- | not (null dup_names)
- = addNameClashErrRn rdr_name ((name,prov):dup_names) `thenRn_`
- returnRn acc
+ -- See what's available in the current environment
+ case lookupUFM entity_avail_env name of {
+ Nothing -> -- Presumably this happens because lookupSrcName didn't find
+ -- the name and returned an unboundName, which won't be in
+ -- the entity_avail_env, of course
+ WARN( not (isUnboundName name), ppr name )
+ returnRn acc ;
-#ifdef DEBUG
- -- I can't see why this should ever happen; if the thing is in scope
- -- at all it ought to have some availability
- | not (maybeToBool maybe_avail)
- = pprTrace "exportsFromAvail: curious Nothing:" (ppr name)
- returnRn acc
-#endif
-
- | not enough_avail
- = failWithRn acc (exportItemErr ie)
+ Just avail ->
- | otherwise -- Phew! It's OK! Now to check the occurrence stuff!
+ -- Filter out the bits we want
+ case filterAvail ie avail of {
+ Nothing -> -- Not enough availability
+ failWithRn acc (exportItemErr ie) ;
+ Just export_avail ->
- = warnCheckRn (ok_item ie avail) (dodgyExportWarn ie) `thenRn_`
+ -- Phew! It's OK! Now to check the occurrence stuff!
+ warnCheckRn (ok_item ie avail) (dodgyExportWarn ie) `thenRn_`
check_occs ie occs export_avail `thenRn` \ occs' ->
returnRn (mods, occs', addAvail avails export_avail)
+ }}
+
- where
- rdr_name = ieName ie
- maybe_in_scope = lookupFM global_name_env rdr_name
- Just ((name,prov):dup_names) = maybe_in_scope
- maybe_avail = lookupUFM entity_avail_env name
- Just avail = maybe_avail
- maybe_export_avail = filterAvail ie avail
- enough_avail = maybeToBool maybe_export_avail
- Just export_avail = maybe_export_avail
-
- ok_item (IEThingAll _) (AvailTC _ [n]) = False
- -- This occurs when you import T(..), but
- -- only export T abstractly. The single [n]
- -- in the AvailTC is the type or class itself
- ok_item _ _ = True
+
+ok_item (IEThingAll _) (AvailTC _ [n]) = False
+ -- This occurs when you import T(..), but
+ -- only export T abstractly. The single [n]
+ -- in the AvailTC is the type or class itself
+ok_item _ _ = True
check_occs :: RdrNameIE -> ExportOccMap -> AvailInfo -> RnMG ExportOccMap
check_occs ie occs avail
failWithRn occs (exportClashErr name_occ ie ie')
where
name_occ = nameOccName name
-
-mk_export_fn :: NameSet -> (Name -> Bool) -- True => exported
-mk_export_fn exported_names = \name -> name `elemNameSet` exported_names
\end{code}
%************************************************************************
%************************************************************************
\begin{code}
-badImportItemErr mod ie
- = sep [ptext SLIT("Module"), quotes (ppr mod),
+badImportItemErr mod from ie
+ = sep [ptext SLIT("Module"), quotes (ppr mod), source_import,
ptext SLIT("does not export"), quotes (ppr ie)]
+ where
+ source_import = case from of
+ ImportByUserSource -> ptext SLIT("(hi-boot interface)")
+ other -> empty
dodgyImportWarn mod item = dodgyMsg (ptext SLIT("import")) item
dodgyExportWarn item = dodgyMsg (ptext SLIT("export")) item