%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
\section[RnNames]{Extracting imported and top-level names in scope}
\begin{code}
-#include "HsVersions.h"
-
module RnNames (
- getGlobalNames,
- GlobalNameInfo(..)
+ getGlobalNames
) where
-import PreludeGlaST ( returnPrimIO, thenPrimIO, MutableVar(..) )
-
-import Ubiq
+#include "HsVersions.h"
-import HsSyn
-import RdrHsSyn
-import RnHsSyn
+import CmdLineOpts ( DynFlag(..) )
-import ParseIface ( ParsedIface )
-import RnMonad
-import RnIfaces ( IfaceCache(..), cachedIface )
-import RnUtils ( RnEnv(..), emptyRnEnv, extendGlobalRnEnv, qualNameErr, dupNamesErr )
-
-import Bag ( emptyBag, unitBag, unionBags, unionManyBags, mapBag, listToBag, bagToList )
-import ErrUtils ( Error(..), Warning(..), addShortErrLocLine )
-import FiniteMap ( fmToList )
-import Name ( RdrName(..), Name, isQual, mkTopLevName,
- mkImportedName, nameExportFlag,
- getLocalName, getSrcLoc, pprNonOp
+import HsSyn ( HsModule(..), HsDecl(..), IE(..), ieName, ImportDecl(..),
+ ForeignDecl(..), ForKind(..), isDynamicExtName,
+ collectTopBinders
+ )
+import RdrHsSyn ( RdrNameIE, RdrNameImportDecl,
+ RdrNameHsModule, RdrNameHsDecl
)
-import PrelInfo ( BuiltinNames(..), BuiltinKeys(..) )
-import PrelMods ( fromPrelude )
-import Pretty
-import SrcLoc ( SrcLoc )
-import UniqSupply ( splitUniqSupply )
-import Util ( equivClasses, panic )
+import RnIfaces ( getInterfaceExports, recordLocalSlurps )
+import RnHiFiles ( getTyClDeclBinders )
+import RnEnv
+import RnMonad
+
+import FiniteMap
+import PrelNames ( pRELUDE_Name, mAIN_Name, main_RDR )
+import UniqFM ( lookupUFM )
+import Bag ( bagToList )
+import Module ( ModuleName, moduleName, WhereFrom(..) )
+import NameSet
+import Name ( Name, nameSrcLoc,
+ setLocalNameSort, nameOccName, nameEnvElts )
+import HscTypes ( Provenance(..), ImportReason(..), GlobalRdrEnv,
+ GenAvailInfo(..), AvailInfo, Avails, AvailEnv )
+import RdrName ( RdrName, rdrNameOcc, setRdrNameOcc, mkRdrQual, mkRdrUnqual )
+import OccName ( setOccNameSpace, dataName )
+import NameSet ( elemNameSet, emptyNameSet )
+import Outputable
+import Maybes ( maybeToBool, catMaybes, mapMaybe )
+import UniqFM ( emptyUFM, listToUFM )
+import ListSetOps ( removeDups )
+import Util ( sortLt )
+import List ( partition )
\end{code}
-\begin{code}
-type GlobalNameInfo = (BuiltinNames,
- BuiltinKeys,
- Name -> ExportFlag,
- Name -> [RdrName])
-
-type RnM_Info s r = RnMonad GlobalNameInfo s r
-
-getGlobalNames ::
- IfaceCache
- -> GlobalNameInfo
- -> UniqSupply
- -> RdrNameHsModule
- -> PrimIO (RnEnv,
- [Module], -- directly imported modules
- Bag (Module,(RnName,ExportFlag)), -- unqualified imports from module
- Bag RenamedFixityDecl, -- imported fixity decls
- Bag Error,
- Bag Warning)
-
-getGlobalNames iface_var info us
- (HsModule mod _ _ imports _ ty_decls _ cls_decls _ _ _ binds _ _)
- = case initRn True mod emptyRnEnv us1
- (setExtraRn info $
- getSourceNames ty_decls cls_decls binds)
- of { ((src_vals, src_tcs), src_errs, src_warns) ->
-
- getImportedNames iface_var info us2 imports `thenPrimIO`
- \ (imp_vals, imp_tcs, imp_mods, unqual_imps, imp_fixes, imp_errs, imp_warns) ->
- let
- unqual_vals = mapBag (\rn -> (Unqual (getLocalName rn), rn)) src_vals
- unqual_tcs = mapBag (\rn -> (Unqual (getLocalName rn), rn)) src_tcs
+%************************************************************************
+%* *
+\subsection{Get global names}
+%* *
+%************************************************************************
+
+\begin{code}
+getGlobalNames :: Module -> RdrNameHsModule
+ -> RnMG (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
+
+getGlobalNames this_mod (HsModule _ _ exports imports decls _ mod_loc)
+ = -- These two fix-loops are to get the right
+ -- provenance information into a Name
+ fixRn ( \ ~(rec_gbl_env, _, rec_export_avails, _) ->
+
+ 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
+ -- 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) ->
+
+ -- 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
+ 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) ->
+
+ -- COMBINE RESULTS
+ -- We put the local env second, so that a local provenance
+ -- "wins", even if a module imports itself.
+ let
+ gbl_env :: GlobalRdrEnv
+ imp_gbl_env = foldr plusGlobalRdrEnv emptyRdrEnv (imp_gbl_envs2 ++ imp_gbl_envs1)
+ gbl_env = imp_gbl_env `plusGlobalRdrEnv` local_gbl_env
+
+ all_avails :: ExportAvails
+ all_avails = foldr plusExportAvails local_mod_avails (imp_avails_s2 ++ imp_avails_s1)
+
+ (_, global_avail_env) = all_avails
+ in
+
+ -- PROCESS EXPORT LIST (but not if we've had errors already)
+ checkErrsRn `thenRn` \ no_errs_so_far ->
+ (if no_errs_so_far then
+ exportsFromAvail this_mod_name exports all_avails gbl_env
+ else
+ returnRn []
+ ) `thenRn` \ export_avails ->
+
+ -- ALL DONE
+ returnRn (gbl_env, local_gbl_env, export_avails, global_avail_env)
+ )
+ where
+ 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.
+ 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
+ -> RdrNameImportDecl
+ -> RnMG (GlobalRdrEnv,
+ ExportAvails)
- all_vals = bagToList (unqual_vals `unionBags` imp_vals)
- all_tcs = bagToList (unqual_tcs `unionBags` imp_tcs)
+importsFromImportDecl is_unqual (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) ->
- (all_env, dups) = extendGlobalRnEnv emptyRnEnv all_vals all_tcs
+ if null avails_by_module then
+ -- If there's an error in getInterfaceExports, (e.g. interface
+ -- file not found) we get lots of spurious errors from 'filterImports'
+ returnRn (emptyRdrEnv, mkEmptyExportAvails imp_mod_name)
+ else
- dup_errs = map dup_err (equivClasses cmp_rdr (bagToList dups))
- cmp_rdr (rdr1,_,_) (rdr2,_,_) = cmp rdr1 rdr2
- dup_err ((rdr,rn,rn'):rest) = globalDupNamesErr rdr (rn:rn': [rn|(_,_,rn)<-rest])
+ let
+ avails :: Avails
+ avails = concat (map snd avails_by_module)
+ in
+ filterImports imp_mod_name import_spec avails `thenRn` \ (filtered_avails, hides, explicits) ->
- all_errs = src_errs `unionBags` imp_errs `unionBags` listToBag dup_errs
- all_warns = src_warns `unionBags` imp_warns
+ let
+ mk_provenance name = NonLocalDef (UserImport imp_mod iloc (name `elemNameSet` explicits))
+ (is_unqual name)
in
- returnPrimIO (all_env, bagToList imp_mods, unqual_imps, imp_fixes, all_errs, all_warns)
- }
- where
- (us1, us2) = splitUniqSupply us
+
+ qualifyImports imp_mod_name
+ (not qual_only) -- Maybe want unqualified names
+ as_mod hides
+ mk_provenance
+ filtered_avails
\end{code}
-*********************************************************
-* *
-\subsection{Top-level source names}
-* *
-*********************************************************
\begin{code}
-getSourceNames ::
- [RdrNameTyDecl]
- -> [RdrNameClassDecl]
- -> RdrNameHsBinds
- -> RnM_Info s (Bag RnName, -- values
- Bag RnName) -- tycons/classes
-
-getSourceNames ty_decls cls_decls binds
- = mapAndUnzipRn getTyDeclNames ty_decls `thenRn` \ (tycon_s, constrs_s) ->
- mapAndUnzipRn getClassNames cls_decls `thenRn` \ (cls_s, cls_ops_s) ->
- getTopBindsNames binds `thenRn` \ bind_names ->
- returnRn (unionManyBags constrs_s `unionBags`
- unionManyBags cls_ops_s `unionBags` bind_names,
- listToBag tycon_s `unionBags` listToBag cls_s)
-
-
-getTyDeclNames :: RdrNameTyDecl
- -> RnM_Info s (RnName, Bag RnName) -- tycon and constrs
-
-getTyDeclNames (TyData _ tycon _ condecls _ _ src_loc)
- = newGlobalName src_loc Nothing tycon `thenRn` \ tycon_name ->
- mapRn (getConDeclName (Just (nameExportFlag tycon_name)))
- condecls `thenRn` \ con_names ->
- returnRn (RnData tycon_name con_names,
- listToBag (map (\ n -> RnConstr n tycon_name) con_names))
-
-getTyDeclNames (TyNew _ tycon _ condecls _ _ src_loc)
- = newGlobalName src_loc Nothing tycon `thenRn` \ tycon_name ->
- mapRn (getConDeclName (Just (nameExportFlag tycon_name)))
- condecls `thenRn` \ con_names ->
- returnRn (RnData tycon_name con_names,
- listToBag (map (\ n -> RnConstr n tycon_name) con_names))
-
-getTyDeclNames (TySynonym tycon _ _ src_loc)
- = newGlobalName src_loc Nothing tycon `thenRn` \ tycon_name ->
- returnRn (RnSyn tycon_name, emptyBag)
-
-getConDeclName exp (ConDecl con _ src_loc)
- = newGlobalName src_loc exp con
-getConDeclName exp (ConOpDecl _ op _ src_loc)
- = newGlobalName src_loc exp op
-getConDeclName exp (NewConDecl con _ src_loc)
- = newGlobalName src_loc exp con
-getConDeclName exp (RecConDecl con fields src_loc)
- = panic "getConDeclName:RecConDecl"
- newGlobalName src_loc exp con
-
-
-getClassNames :: RdrNameClassDecl
- -> RnM_Info s (RnName, Bag RnName) -- class and class ops
-
-getClassNames (ClassDecl _ cname _ sigs _ _ src_loc)
- = newGlobalName src_loc Nothing cname `thenRn` \ class_name ->
- getClassOpNames (Just (nameExportFlag class_name))
- sigs `thenRn` \ op_names ->
- returnRn (RnClass class_name op_names,
- listToBag (map (\ n -> RnClassOp n class_name) op_names))
-
-getClassOpNames exp []
+importsFromLocalDecls this_mod rec_exp_fn decls
+ = mapRn (getLocalDeclBinders this_mod rec_exp_fn) decls `thenRn` \ avails_s ->
+
+ let
+ avails = concat avails_s
+
+ all_names :: [Name] -- All the defns; no dups eliminated
+ all_names = [name | avail <- avails, name <- availNames avail]
+
+ dups :: [[Name]]
+ (_, dups) = removeDups compare all_names
+ in
+ -- Check for duplicate definitions
+ mapRn_ (addErrRn . dupDeclErr) dups `thenRn_`
+
+ -- Record that locally-defined things are available
+ recordLocalSlurps avails `thenRn_`
+
+ -- Build the environment
+ qualifyImports (moduleName this_mod)
+ True -- Want unqualified names
+ Nothing -- no 'as M'
+ [] -- Hide nothing
+ (\n -> LocalDef) -- Provenance is local
+ avails
+
+---------------------------
+getLocalDeclBinders :: Module
+ -> (Name -> Bool) -- Whether exported
+ -> RdrNameHsDecl -> RnMG Avails
+getLocalDeclBinders mod rec_exp_fn (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 mod rec_exp_fn (ValD binds)
+ = mapRn (newLocalBinder mod rec_exp_fn)
+ (bagToList (collectTopBinders binds))
+
+getLocalDeclBinders mod rec_exp_fn (ForD (ForeignDecl nm kind _ ext_nm _ loc))
+ | binds_haskell_name kind
+ = newLocalBinder mod rec_exp_fn (nm, loc) `thenRn` \ avail ->
+ returnRn [avail]
+
+ | otherwise -- a foreign export
= returnRn []
-getClassOpNames exp (ClassOpSig op _ _ src_loc : sigs)
- = newGlobalName src_loc exp op `thenRn` \ op_name ->
- getClassOpNames exp sigs `thenRn` \ op_names ->
- returnRn (op_name : op_names)
-getClassOpNames exp (_ : sigs)
- = getClassOpNames exp sigs
+ where
+ binds_haskell_name (FoImport _) = True
+ binds_haskell_name FoLabel = True
+ binds_haskell_name FoExport = isDynamicExtName ext_nm
+
+getLocalDeclBinders mod rec_exp_fn (FixD _) = returnRn []
+getLocalDeclBinders mod rec_exp_fn (DeprecD _) = returnRn []
+getLocalDeclBinders mod rec_exp_fn (DefD _) = returnRn []
+getLocalDeclBinders mod rec_exp_fn (InstD _) = returnRn []
+getLocalDeclBinders mod rec_exp_fn (RuleD _) = returnRn []
+
+---------------------------
+newLocalBinder mod rec_exp_fn (rdr_name, loc)
+ = -- Generate a local name, and with a suitable export indicator
+ newTopBinder mod rdr_name loc `thenRn` \ name ->
+ returnRn (Avail (setLocalNameSort name (rec_exp_fn name)))
\end{code}
-*********************************************************
-* *
-\subsection{Bindings}
-* *
-*********************************************************
+
+%************************************************************************
+%* *
+\subsection{Filtering imports}
+%* *
+%************************************************************************
+
+@filterImports@ takes the @ExportEnv@ telling what the imported module makes
+available, and filters it through the import spec (if any).
\begin{code}
-getTopBindsNames :: RdrNameHsBinds
- -> RnM_Info s (Bag RnName)
-
-getTopBindsNames binds = doBinds binds
-
-doBinds EmptyBinds = returnRn emptyBag
-doBinds (SingleBind bind) = doBind bind
-doBinds (BindWith bind sigs) = doBind bind
-doBinds (ThenBinds binds1 binds2)
- = andRn unionBags (doBinds binds1) (doBinds binds2)
-
-doBind EmptyBind = returnRn emptyBag
-doBind (NonRecBind mbind) = doMBinds mbind
-doBind (RecBind mbind) = doMBinds mbind
-
-doMBinds EmptyMonoBinds = returnRn emptyBag
-doMBinds (PatMonoBind pat grhss_and_binds locn) = doPat locn pat
-doMBinds (FunMonoBind p_name _ _ locn) = doName locn p_name
-doMBinds (AndMonoBinds mbinds1 mbinds2)
- = andRn unionBags (doMBinds mbinds1) (doMBinds mbinds2)
-
-doPats locn pats
- = mapRn (doPat locn) pats `thenRn` \ pats_s ->
- returnRn (unionManyBags pats_s)
-
-doPat locn WildPatIn = returnRn emptyBag
-doPat locn (LitPatIn _) = returnRn emptyBag
-doPat locn (LazyPatIn pat) = doPat locn pat
-doPat locn (VarPatIn var) = doName locn var
-doPat locn (NegPatIn pat) = doPat locn pat
-doPat locn (ParPatIn pat) = doPat locn pat
-doPat locn (ListPatIn pats) = doPats locn pats
-doPat locn (TuplePatIn pats) = doPats locn pats
-doPat locn (ConPatIn name pats) = doPats locn pats
-doPat locn (ConOpPatIn p1 op p2)
- = andRn unionBags (doPat locn p1) (doPat locn p2)
-doPat locn (AsPatIn as_name pat)
- = andRn unionBags (doName locn as_name) (doPat locn pat)
-doPat locn (RecPatIn name fields)
- = mapRn (doField locn) fields `thenRn` \ fields_s ->
- returnRn (unionManyBags fields_s)
-
-doField locn (_, pat, _) = doPat locn pat
-
-doName locn rdr
- = newGlobalName locn Nothing rdr `thenRn` \ name ->
- returnRn (unitBag (RnName name))
+filterImports :: ModuleName -- The module being imported
+ -> Maybe (Bool, [RdrNameIE]) -- Import spec; True => hiding
+ -> [AvailInfo] -- What's available
+ -> RnMG ([AvailInfo], -- What's actually imported
+ [AvailInfo], -- What's to be hidden
+ -- (the unqualified version, that is)
+ -- (We need to return both the above sets, because
+ -- the qualified version is never hidden; so we can't
+ -- implement hiding by reducing what's imported.)
+ NameSet) -- What was imported explicitly
+
+ -- Complains if import spec mentions things that the module doesn't export
+ -- Warns/informs if import spec contains duplicates.
+filterImports mod Nothing imports
+ = returnRn (imports, [], emptyNameSet)
+
+filterImports mod (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
+ explicits = foldl addListToNameSet emptyNameSet explicits_s
+ in
+ if want_hiding
+ then
+ -- All imported; item_avails to be hidden
+ returnRn (total_avails, item_avails, emptyNameSet)
+ else
+ -- Just item_avails imported; nothing to be hidden
+ returnRn (item_avails, [], explicits)
+ where
+ import_fm :: FiniteMap OccName AvailInfo
+ import_fm = listToFM [ (nameOccName name, avail)
+ | avail <- total_avails,
+ name <- availNames avail]
+ -- Even though availNames returns data constructors too,
+ -- 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_`
+ returnRn []
+
+ get_item item@(IEModuleContents _) = bale_out item
+
+ get_item item@(IEThingAll _)
+ = case check_item item of
+ Nothing -> bale_out item
+ Just avail@(AvailTC _ [n]) -> -- This occurs when you import T(..), but
+ -- only export T abstractly. The single [n]
+ -- in the AvailTC is the type or class itself
+ addWarnRn (dodgyImportWarn mod item) `thenRn_`
+ returnRn [(avail, [availName avail])]
+ Just avail -> returnRn [(avail, [availName avail])]
+
+ get_item item@(IEThingAbs n)
+ | want_hiding -- hiding( C )
+ -- Here the 'C' can be a data constructor *or* a type/class
+ = case catMaybes [check_item item, check_item (IEThingAbs data_n)] of
+ [] -> bale_out item
+ avails -> returnRn [(a, []) | a <- avails]
+ -- The 'explicits' list is irrelevant when hiding
+ where
+ data_n = setRdrNameOcc n (setOccNameSpace (rdrNameOcc n) dataName)
+
+ get_item item
+ = case check_item item of
+ Nothing -> bale_out item
+ Just avail -> returnRn [(avail, availNames avail)]
+
+ check_item item
+ | not (maybeToBool maybe_in_import_avails) ||
+ not (maybeToBool maybe_filtered_avail)
+ = Nothing
+
+ | otherwise
+ = Just filtered_avail
+
+ where
+ wanted_occ = rdrNameOcc (ieName item)
+ maybe_in_import_avails = lookupFM import_fm wanted_occ
+
+ Just avail = maybe_in_import_avails
+ maybe_filtered_avail = filterAvail item avail
+ Just filtered_avail = maybe_filtered_avail
\end{code}
-*********************************************************
-* *
-\subsection{Creating a new global name}
-* *
-*********************************************************
+
+
+%************************************************************************
+%* *
+\subsection{Qualifiying imports}
+%* *
+%************************************************************************
+
+@qualifyImports@ takes the @ExportEnv@ after filtering through the import spec
+of an import decl, and deals with producing an @RnEnv@ with the
+right qualified names. It also turns the @Names@ in the @ExportEnv@ into
+fully fledged @Names@.
\begin{code}
-newGlobalName :: SrcLoc -> Maybe ExportFlag
- -> RdrName -> RnM_Info s Name
-
-newGlobalName locn maybe_exp rdr
- = getExtraRn `thenRn` \ (_,_,exp_fn,occ_fn) ->
- getModuleRn `thenRn` \ mod ->
- getSourceRn `thenRn` \ source ->
- rnGetUnique `thenRn` \ u ->
+qualifyImports :: ModuleName -- Imported module
+ -> Bool -- True <=> want unqualified import
+ -> Maybe ModuleName -- Optional "as M" part
+ -> [AvailInfo] -- What's to be hidden
+ -> (Name -> Provenance)
+ -> Avails -- Whats imported and how
+ -> RnMG (GlobalRdrEnv, ExportAvails)
+
+qualifyImports this_mod unqual_imp as_mod hides mk_provenance avails
+ =
+ -- Make the name environment. We're talking about a
+ -- single module here, so there must be no name clashes.
+ -- In practice there only ever will be if it's the module
+ -- being compiled.
let
- src_unqual = getLocalName rdr
+ -- Add the things that are available
+ name_env1 = foldl add_avail emptyRdrEnv avails
- src_orig = if fromPrelude mod
- then (Unqual src_unqual)
- else (Qual mod src_unqual)
+ -- Delete things that are hidden
+ name_env2 = foldl del_avail name_env1 hides
- exp = case maybe_exp of
- Just exp -> exp
- Nothing -> exp_fn n
-
- n = if source then
- mkTopLevName u src_orig locn exp (occ_fn n)
- else
- mkImportedName u rdr locn exp (occ_fn n)
+ -- Create the export-availability info
+ export_avails = mkExportAvails qual_mod unqual_imp name_env2 avails
in
- addErrIfRn (source && isQual rdr)
- (qualNameErr "name in definition" (rdr, locn)) `thenRn_`
- returnRn n
+ returnRn (name_env2, export_avails)
+
+ where
+ qual_mod = case as_mod of
+ Nothing -> this_mod
+ Just another_name -> another_name
+
+ add_avail :: GlobalRdrEnv -> AvailInfo -> GlobalRdrEnv
+ add_avail env avail = foldl add_name env (availNames avail)
+
+ add_name env name
+ | unqual_imp = env2
+ | otherwise = env1
+ where
+ env1 = addOneToGlobalRdrEnv env (mkRdrQual qual_mod occ) (name,prov)
+ env2 = addOneToGlobalRdrEnv env1 (mkRdrUnqual occ) (name,prov)
+ occ = nameOccName name
+ prov = mk_provenance name
+
+ del_avail env avail = foldl delOneFromGlobalRdrEnv env rdr_names
+ where
+ rdr_names = map (mkRdrUnqual . nameOccName) (availNames avail)
+
+
+mkEmptyExportAvails :: ModuleName -> ExportAvails
+mkEmptyExportAvails mod_name = (unitFM mod_name [], emptyUFM)
+
+mkExportAvails :: ModuleName -> Bool -> GlobalRdrEnv -> [AvailInfo] -> ExportAvails
+mkExportAvails mod_name unqual_imp name_env avails
+ = (mod_avail_env, entity_avail_env)
+ where
+ mod_avail_env = unitFM mod_name unqual_avails
+
+ -- unqual_avails is the Avails that are visible in *unqualfied* form
+ -- (1.4 Report, Section 5.1.1)
+ -- For example, in
+ -- import T hiding( f )
+ -- we delete f from avails
+
+ unqual_avails | not unqual_imp = [] -- Short cut when no unqualified imports
+ | otherwise = mapMaybe prune avails
+
+ prune (Avail n) | unqual_in_scope n = Just (Avail n)
+ prune (Avail n) | otherwise = Nothing
+ prune (AvailTC n ns) | null uqs = Nothing
+ | otherwise = Just (AvailTC n uqs)
+ where
+ uqs = filter unqual_in_scope ns
+
+ unqual_in_scope n = unQualInScope name_env n
+
+ entity_avail_env = listToUFM [ (name,avail) | avail <- avails,
+ name <- availNames avail]
+
+plusExportAvails :: ExportAvails -> ExportAvails -> ExportAvails
+plusExportAvails (m1, e1) (m2, e2)
+ = (plusFM_C (++) m1 m2, plusAvailEnv e1 e2)
+ -- ToDo: wasteful: we do this once for each constructor!
\end{code}
-*********************************************************
-* *
-\subsection{Imported names}
-* *
-*********************************************************
+
+%************************************************************************
+%* *
+\subsection{Export list processing}
+%* *
+%************************************************************************
+
+Processing the export list.
+
+You might think that we should record things that appear in the export list
+as ``occurrences'' (using @addOccurrenceName@), but you'd be wrong.
+We do check (here) that they are in scope,
+but there is no need to slurp in their actual declaration
+(which is what @addOccurrenceName@ forces).
+
+Indeed, doing so would big trouble when
+compiling @PrelBase@, because it re-exports @GHC@, which includes @takeMVar#@,
+whose type includes @ConcBase.StateAndSynchVar#@, and so on...
\begin{code}
-getImportedNames ::
- IfaceCache
- -> GlobalNameInfo -- builtin and knot name info
- -> UniqSupply
- -> [RdrNameImportDecl] -- import declarations
- -> PrimIO (Bag (RdrName,RnName), -- imported values in scope
- Bag (RdrName,RnName), -- imported tycons/classes in scope
- Bag Module, -- directly imported modules
- Bag (Module,(RnName,ExportFlag)), -- unqualified imports from module
- Bag RenamedFixityDecl, -- fixity info for imported names
- Bag Error,
- Bag Warning)
-
-getImportedNames iface_var info us imports
- = returnPrimIO (builtin_vals, builtin_tcs, emptyBag, emptyBag, emptyBag, emptyBag, emptyBag)
+type ExportAccum -- The type of the accumulating parameter of
+ -- the main worker function in exportsFromAvail
+ = ([ModuleName], -- 'module M's seen so far
+ ExportOccMap, -- Tracks exported occurrence names
+ AvailEnv) -- The accumulated exported stuff, kept in an env
+ -- so we can common-up related AvailInfos
+
+type ExportOccMap = FiniteMap OccName (Name, RdrNameIE)
+ -- Tracks what a particular exported OccName
+ -- in an export list refers to, and which item
+ -- it came from. It's illegal to export two distinct things
+ -- that have the same occurrence name
+
+
+exportsFromAvail :: ModuleName
+ -> Maybe [RdrNameIE] -- Export spec
+ -> ExportAvails
+ -> GlobalRdrEnv
+ -> RnMG Avails
+ -- Complains if two distinct exports have same OccName
+ -- Warns about identical exports.
+ -- Complains about exports items not in scope
+exportsFromAvail this_mod Nothing export_avails global_name_env
+ = exportsFromAvail this_mod true_exports export_avails global_name_env
where
- -- For now jsut add the builtin names ...
- (b_names,_,_,_) = info
- builtin_vals = listToBag [(Unqual s, rn) | (s,rn) <- fmToList b_names, not (isRnTyCon rn)]
- builtin_tcs = listToBag [(Unqual s, rn) | (s,rn) <- fmToList b_names, isRnTyCon rn]
+ true_exports = Just $ if this_mod == mAIN_Name
+ then [IEVar main_RDR]
+ -- export Main.main *only* unless otherwise specified,
+ else [IEModuleContents this_mod]
+ -- but for all other modules export everything.
+
+exportsFromAvail this_mod (Just export_items)
+ (mod_avail_env, entity_avail_env)
+ global_name_env
+ = doptRn Opt_WarnDuplicateExports `thenRn` \ warn_dup_exports ->
+ foldlRn (exports_from_item warn_dup_exports)
+ ([], emptyFM, emptyAvailEnv) export_items
+ `thenRn` \ (_, _, export_avail_map) ->
+ let
+ export_avails :: [AvailInfo]
+ export_avails = nameEnvElts export_avail_map
+ in
+ returnRn export_avails
+
+ where
+ exports_from_item :: Bool -> ExportAccum -> RdrNameIE -> RnMG ExportAccum
+
+ exports_from_item warn_dups acc@(mods, occs, avails) ie@(IEModuleContents mod)
+ | mod `elem` mods -- Duplicate export of M
+ = warnCheckRn warn_dups (dupModuleExport mod) `thenRn_`
+ returnRn acc
+
+ | otherwise
+ = case lookupFM mod_avail_env mod of
+ Nothing -> failWithRn acc (modExportErr mod)
+ Just mod_avails -> foldlRn (check_occs ie) occs mod_avails
+ `thenRn` \ occs' ->
+ let
+ avails' = foldl addAvail avails mod_avails
+ in
+ 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))
+
+ | not (null dup_names)
+ = addNameClashErrRn rdr_name ((name,prov):dup_names) `thenRn_`
+ 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)
+
+ | otherwise -- 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
+
+check_occs :: RdrNameIE -> ExportOccMap -> AvailInfo -> RnMG ExportOccMap
+check_occs ie occs avail
+ = doptRn Opt_WarnDuplicateExports `thenRn` \ warn_dup_exports ->
+ foldlRn (check warn_dup_exports) occs (availNames avail)
+ where
+ check warn_dup occs name
+ = case lookupFM occs name_occ of
+ Nothing -> returnRn (addToFM occs name_occ (name, ie))
+ Just (name', ie')
+ | name == name' -> -- Duplicate export
+ warnCheckRn warn_dup
+ (dupExportWarn name_occ ie ie')
+ `thenRn_` returnRn occs
+
+ | otherwise -> -- Same occ name but different names: an error
+ 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}
+%************************************************************************
+%* *
+\subsection{Errors}
+%* *
+%************************************************************************
\begin{code}
-globalDupNamesErr rdr rns sty
- = ppHang (ppBesides [pprNonOp sty rdr, ppStr " multiply defined:"])
- 4 (ppAboves (map pp_def rns))
+badImportItemErr mod ie
+ = sep [ptext SLIT("Module"), quotes (ppr mod),
+ ptext SLIT("does not export"), quotes (ppr ie)]
+
+dodgyImportWarn mod item = dodgyMsg (ptext SLIT("import")) item
+dodgyExportWarn item = dodgyMsg (ptext SLIT("export")) item
+
+dodgyMsg kind item@(IEThingAll tc)
+ = sep [ ptext SLIT("The") <+> kind <+> ptext SLIT("item") <+> quotes (ppr item),
+ ptext SLIT("suggests that") <+> quotes (ppr tc) <+> ptext SLIT("has constructor or class methods"),
+ ptext SLIT("but it has none; it is a type synonym or abstract type or class") ]
+
+modExportErr mod
+ = hsep [ ptext SLIT("Unknown module in export list: module"), quotes (ppr mod)]
+
+exportItemErr export_item
+ = sep [ ptext SLIT("The export item") <+> quotes (ppr export_item),
+ ptext SLIT("attempts to export constructors or class methods that are not visible here") ]
+
+exportClashErr occ_name ie1 ie2
+ = hsep [ptext SLIT("The export items"), quotes (ppr ie1)
+ ,ptext SLIT("and"), quotes (ppr ie2)
+ ,ptext SLIT("create conflicting exports for"), quotes (ppr occ_name)]
+
+dupDeclErr (n:ns)
+ = vcat [ptext SLIT("Multiple declarations of") <+> quotes (ppr n),
+ nest 4 (vcat (map ppr sorted_locs))]
where
- pp_def rn = addShortErrLocLine (getSrcLoc rn) (\ sty -> ppr sty rn) sty
-
- -- ToDo: print import src locs for imported names
+ sorted_locs = sortLt occ'ed_before (map nameSrcLoc (n:ns))
+ occ'ed_before a b = LT == compare a b
+
+dupExportWarn occ_name ie1 ie2
+ = hsep [quotes (ppr occ_name),
+ ptext SLIT("is exported by"), quotes (ppr ie1),
+ ptext SLIT("and"), quotes (ppr ie2)]
+
+dupModuleExport mod
+ = hsep [ptext SLIT("Duplicate"),
+ quotes (ptext SLIT("Module") <+> ppr mod),
+ ptext SLIT("in export list")]
\end{code}