ghc/compiler/rename/RnNames.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
   3 %
   4 \section[RnNames]{Extracting imported and top-level names in scope}
   5
   6 \begin{code}
   7 module RnNames (
   8         getGlobalNames
   9     ) where
  10
  11 #include "HsVersions.h"
  12
  13 import CmdLineOpts    ( opt_NoImplicitPrelude, opt_WarnDuplicateExports,
  14                         opt_SourceUnchanged
  15                       )
  16
  17 import HsSyn    ( HsModule(..), ImportDecl(..), HsDecl(..),
  18                   IE(..), ieName,
  19                   FixityDecl(..),
  20                   collectTopBinders
  21                 )
  22 import RdrHsSyn ( RdrNameHsDecl(..), RdrName(..), RdrNameIE(..), RdrNameImportDecl,
  23                   RdrNameHsModule, RdrNameFixityDecl,
  24                   rdrNameOcc, ieOcc
  25                 )
  26 import RnHsSyn  ( RenamedHsModule(..), RenamedFixityDecl(..) )
  27 import RnIfaces ( getInterfaceExports, getDeclBinders, recordSlurp, checkUpToDate )
  28 import BasicTypes ( IfaceFlavour(..) )
  29 import RnEnv
  30 import RnMonad
  31
  32 import FiniteMap
  33 import PrelMods
  34 import UniqFM   ( UniqFM, emptyUFM, addListToUFM_C, lookupUFM )
  35 import Bag      ( Bag, bagToList )
  36 import Maybes   ( maybeToBool, expectJust )
  37 import Name
  38 import Outputable
  39 import Util     ( removeDups )
  40 \end{code}
  41
  42
  43
  44 %************************************************************************
  45 %*                                                                      *
  46 \subsection{Get global names}
  47 %*                                                                      *
  48 %************************************************************************
  49
  50 \begin{code}
  51 getGlobalNames :: RdrNameHsModule
  52                -> RnMG (Maybe (ExportEnv, RnEnv, NameSet, Name -> PrintUnqualified))
  53                         -- The NameSet is the set of names that are
  54                         --      either locally defined,
  55                         --      or explicitly imported
  56                         -- Nothing => no need to recompile
  57
  58 getGlobalNames m@(HsModule this_mod _ exports imports _ _ mod_loc)
  59   = fixRn (\ ~(rec_exp_fn, _) ->
  60
  61         -- PROCESS LOCAL DECLS
  62         -- Do these *first* so that the correct provenance gets
  63         -- into the global name cache.
  64       importsFromLocalDecls rec_exp_fn m        `thenRn` \ (local_rn_env, local_mod_avails, local_avails) ->
  65
  66         -- PROCESS IMPORT DECLS
  67       mapAndUnzip3Rn importsFromImportDecl all_imports
  68                                                 `thenRn` \ (imp_rn_envs, imp_avails_s, explicit_imports_s) ->
  69
  70         -- COMBINE RESULTS
  71         -- We put the local env second, so that a local provenance
  72         -- "wins", even if a module imports itself.
  73       foldlRn plusRnEnv emptyRnEnv imp_rn_envs          `thenRn` \ imp_rn_env ->
  74       plusRnEnv imp_rn_env local_rn_env                 `thenRn` \ rn_env ->
  75
  76         -- TRY FOR EARLY EXIT
  77         -- We can't go for an early exit before this because we have to check
  78         -- for name clashes.  Consider:
  79         --
  80         --      module A where          module B where
  81         --         import B                h = True
  82         --         f = h
  83         --
  84         -- Suppose I've compiled everything up, and then I add a
  85         -- new definition to module B, that defines "f".
  86         --
  87         -- Then I must detect the name clash in A before going for an early
  88         -- exit.  The early-exit code checks what's actually needed from B
  89         -- to compile A, and of course that doesn't include B.f.  That's
  90         -- why we wait till after the plusRnEnv stuff to do the early-exit.
  91       checkEarlyExit this_mod                           `thenRn` \ up_to_date ->
  92       if up_to_date then
  93         returnRn (error "early exit", Nothing)
  94       else
  95
  96
  97         -- PROCESS EXPORT LISTS
  98       let
  99          export_avails :: ExportAvails
 100          export_avails = foldr plusExportAvails local_mod_avails imp_avails_s
 101
 102          explicit_names :: NameSet      -- locally defined or explicitly imported
 103          explicit_names = foldr add_on emptyNameSet (local_avails : explicit_imports_s)
 104          add_on avails names = foldr (unionNameSets . mkNameSet . availNames) names avails
 105       in
 106       exportsFromAvail this_mod exports export_avails rn_env
 107                                                         `thenRn` \ (export_fn, export_env) ->
 108
 109         -- RECORD THAT LOCALLY DEFINED THINGS ARE AVAILABLE
 110       mapRn (recordSlurp Nothing Compulsory) local_avails       `thenRn_`
 111
 112         -- BUILD THE "IMPORT FN".  It just tells whether a name is in
 113         -- scope in an unqualified form.
 114       let
 115           print_unqual = mkImportFn imp_rn_env
 116       in
 117
 118       returnRn (export_fn, Just (export_env, rn_env, explicit_names, print_unqual))
 119     )                                                   `thenRn` \ (_, result) ->
 120     returnRn result
 121   where
 122     junk_exp_fn = error "RnNames:export_fn"
 123
 124     all_imports = prel_imports ++ imports
 125
 126         -- NB: opt_NoImplicitPrelude is slightly different to import Prelude ();
 127         -- because the former doesn't even look at Prelude.hi for instance declarations,
 128         -- whereas the latter does.
 129     prel_imports | this_mod == pRELUDE ||
 130                    explicit_prelude_import ||
 131                    opt_NoImplicitPrelude
 132                  = []
 133
 134                  | otherwise               = [ImportDecl pRELUDE
 135                                                          False          {- Not qualified -}
 136                                                          HiFile         {- Not source imported -}
 137                                                          Nothing        {- No "as" -}
 138                                                          Nothing        {- No import list -}
 139                                                          mod_loc]
 140
 141     explicit_prelude_import
 142       = not (null [ () | (ImportDecl mod qual _ _ _ _) <- imports, mod == pRELUDE ])
 143 \end{code}
 144
 145 \begin{code}
 146 checkEarlyExit mod
 147   = checkErrsRn                         `thenRn` \ no_errs_so_far ->
 148     if not no_errs_so_far then
 149         -- Found errors already, so exit now
 150         returnRn True
 151     else
 152
 153     traceRn (text "Considering whether compilation is required...")     `thenRn_`
 154     if not opt_SourceUnchanged then
 155         -- Source code changed and no errors yet... carry on
 156         traceRn (nest 4 (text "source file changed or recompilation check turned off")) `thenRn_`
 157         returnRn False
 158     else
 159
 160         -- Unchanged source, and no errors yet; see if usage info
 161         -- up to date, and exit if so
 162     checkUpToDate mod                                           `thenRn` \ up_to_date ->
 163     putDocRn (text "Compilation" <+>
 164               text (if up_to_date then "IS NOT" else "IS") <+>
 165               text "required")                                  `thenRn_`
 166     returnRn up_to_date
 167 \end{code}
 168
 169 \begin{code}
 170 importsFromImportDecl :: RdrNameImportDecl
 171                       -> RnMG (RnEnv, ExportAvails, [AvailInfo])
 172
 173 importsFromImportDecl (ImportDecl mod qual_only as_source as_mod import_spec loc)
 174   = pushSrcLocRn loc $
 175     getInterfaceExports mod as_source           `thenRn` \ (avails, fixities) ->
 176     filterImports mod import_spec avails        `thenRn` \ (filtered_avails, hides, explicits) ->
 177     let
 178         how_in_scope = FromImportDecl mod loc
 179     in
 180     qualifyImports mod
 181                    True                 -- Want qualified names
 182                    (not qual_only)      -- Maybe want unqualified names
 183                    as_mod
 184                    hides
 185                    filtered_avails (\n -> how_in_scope)
 186                    [ (occ,(fixity,how_in_scope)) | (occ,fixity) <- fixities ]
 187                                                         `thenRn` \ (rn_env, mod_avails) ->
 188     returnRn (rn_env, mod_avails, explicits)
 189 \end{code}
 190
 191
 192 \begin{code}
 193 importsFromLocalDecls rec_exp_fn (HsModule mod _ _ _ fix_decls decls _)
 194   = foldlRn getLocalDeclBinders [] decls                `thenRn` \ avails ->
 195     mapRn fixityFromFixDecl fix_decls                   `thenRn` \ fixities ->
 196     qualifyImports mod
 197                    False        -- Don't want qualified names
 198                    True         -- Want unqualified names
 199                    Nothing      -- No "as M" part
 200                    []           -- Hide nothing
 201                    avails (\n -> FromLocalDefn (getSrcLoc n))
 202                    fixities
 203                                                         `thenRn` \ (rn_env, mod_avails) ->
 204     returnRn (rn_env, mod_avails, avails)
 205   where
 206     newLocalName rdr_name loc
 207       = newLocallyDefinedGlobalName mod (rdrNameOcc rdr_name) rec_exp_fn loc
 208
 209     getLocalDeclBinders avails (ValD binds)
 210       = mapRn do_one (bagToList (collectTopBinders binds))      `thenRn` \ val_avails ->
 211         returnRn (val_avails ++ avails)
 212
 213     getLocalDeclBinders avails decl
 214       = getDeclBinders newLocalName decl        `thenRn` \ avail ->
 215         case avail of
 216            NotAvailable -> returnRn avails              -- Instance decls and suchlike
 217            other        -> returnRn (avail : avails)
 218
 219     do_one (rdr_name, loc)
 220       = newLocalName rdr_name loc       `thenRn` \ name ->
 221         returnRn (Avail name)
 222 \end{code}
 223
 224 %************************************************************************
 225 %*                                                                      *
 226 \subsection{Filtering imports}
 227 %*                                                                      *
 228 %************************************************************************
 229
 230 @filterImports@ takes the @ExportEnv@ telling what the imported module makes
 231 available, and filters it through the import spec (if any).
 232
 233 \begin{code}
 234 filterImports :: Module
 235               -> Maybe (Bool, [RdrNameIE])              -- Import spec; True => hidin
 236               -> [AvailInfo]                            -- What's available
 237               -> RnMG ([AvailInfo],                     -- What's actually imported
 238                        [AvailInfo],                     -- What's to be hidden (the unqualified version, that is)
 239                        [AvailInfo])                     -- What was imported explicitly
 240
 241         -- Complains if import spec mentions things that the module doesn't export
 242         -- Warns/informs if import spec contains duplicates.
 243 filterImports mod Nothing imports
 244   = returnRn (imports, [], [])
 245
 246 filterImports mod (Just (want_hiding, import_items)) avails
 247   = mapRn check_item import_items               `thenRn` \ item_avails ->
 248     if want_hiding
 249     then
 250         returnRn (avails, item_avails, [])      -- All imported; item_avails to be hidden
 251     else
 252         returnRn (item_avails, [], item_avails) -- Just item_avails imported; nothing to be hidden
 253
 254   where
 255     import_fm :: FiniteMap OccName AvailInfo
 256     import_fm = listToFM [ (nameOccName name, avail)
 257                          | avail <- avails,
 258                            name  <- availEntityNames avail]
 259
 260     check_item item@(IEModuleContents _)
 261       = addErrRn (badImportItemErr mod item)    `thenRn_`
 262         returnRn NotAvailable
 263
 264     check_item item
 265       | not (maybeToBool maybe_in_import_avails) ||
 266         (case filtered_avail of { NotAvailable -> True; other -> False })
 267       = addErrRn (badImportItemErr mod item)    `thenRn_`
 268         returnRn NotAvailable
 269
 270       | otherwise   = returnRn filtered_avail
 271
 272       where
 273         maybe_in_import_avails = lookupFM import_fm (ieOcc item)
 274         Just avail             = maybe_in_import_avails
 275         filtered_avail         = filterAvail item avail
 276 \end{code}
 277
 278
 279
 280 %************************************************************************
 281 %*                                                                      *
 282 \subsection{Qualifiying imports}
 283 %*                                                                      *
 284 %************************************************************************
 285
 286 @qualifyImports@ takes the @ExportEnv@ after filtering through the import spec
 287 of an import decl, and deals with producing an @RnEnv@ with the
 288 right qualified names.  It also turns the @Names@ in the @ExportEnv@ into
 289 fully fledged @Names@.
 290
 291 \begin{code}
 292 qualifyImports :: Module                                -- Imported module
 293                -> Bool                                  -- True <=> want qualified import
 294                -> Bool                                  -- True <=> want unqualified import
 295                -> Maybe Module                          -- Optional "as M" part
 296                -> [AvailInfo]                           -- What's to be hidden
 297                -> Avails -> (Name -> HowInScope)        -- Whats imported and how
 298                -> [(OccName, (Fixity, HowInScope))]     -- Ditto for fixities
 299                -> RnMG (RnEnv, ExportAvails)
 300
 301 qualifyImports this_mod qual_imp unqual_imp as_mod hides
 302                avails name_to_his fixities
 303   =
 304         -- Make the name environment.  Even though we're talking about a
 305         -- single import module there might still be name clashes,
 306         -- because it might be the module being compiled.
 307     foldlRn add_avail emptyGlobalNameEnv avails `thenRn` \ name_env1 ->
 308     let
 309         -- Delete things that are hidden
 310         name_env2 = foldl del_avail name_env1 hides
 311
 312         -- Create the fixity env
 313         fixity_env = foldl (add_fixity name_env2) emptyFixityEnv fixities
 314
 315         -- Create the export-availability info
 316         export_avails = mkExportAvails unqual_imp qual_mod avails
 317     in
 318     returnRn (RnEnv name_env2 fixity_env, export_avails)
 319   where
 320     qual_mod = case as_mod of
 321                   Nothing           -> this_mod
 322                   Just another_name -> another_name
 323
 324     add_avail :: GlobalNameEnv -> AvailInfo -> RnMG GlobalNameEnv
 325     add_avail env avail = foldlRn add_name env (availNames avail)
 326     add_name env name   = add qual_imp   env  (Qual qual_mod occ err_hif) `thenRn` \ env1 ->
 327                           add unqual_imp env1 (Unqual occ)
 328                         where
 329                           add False env rdr_name = returnRn env
 330                           add True  env rdr_name = addOneToGlobalNameEnv env rdr_name (name, name_to_his name)
 331                           occ  = nameOccName name
 332
 333     del_avail env avail = foldl delOneFromGlobalNameEnv env rdr_names
 334                         where
 335                           rdr_names = map (Unqual . nameOccName) (availNames avail)
 336
 337     add_fixity name_env fix_env (occ_name, fixity)
 338         = add qual $ add unqual $ fix_env
 339         where
 340           qual   = Qual qual_mod occ_name err_hif
 341           unqual = Unqual occ_name
 342
 343           add rdr_name fix_env | maybeToBool (lookupFM name_env rdr_name)
 344                                = addOneToFixityEnv fix_env rdr_name fixity
 345                                | otherwise
 346                                = fix_env
 347
 348 err_hif = error "qualifyImports: hif"   -- Not needed in key to mapping
 349 \end{code}
 350
 351 unQualify adds an Unqual binding for every existing Qual binding.
 352
 353 \begin{code}
 354 unQualify :: FiniteMap RdrName elt -> FiniteMap RdrName elt
 355 unQualify fm = addListToFM fm [(Unqual occ, elt) | (Qual _ occ _, elt) <- fmToList fm]
 356 \end{code}
 357
 358 %************************************************************************
 359 %*                                                                      *
 360 \subsection{Local declarations}
 361 %*                                                                      *
 362 %************************************************************************
 363
 364
 365 \begin{code}
 366 fixityFromFixDecl :: RdrNameFixityDecl -> RnMG (OccName, (Fixity, HowInScope))
 367
 368 fixityFromFixDecl (FixityDecl rdr_name fixity loc)
 369   = returnRn (rdrNameOcc rdr_name, (fixity, FromLocalDefn loc))
 370 \end{code}
 371
 372
 373 %************************************************************************
 374 %*                                                                      *
 375 \subsection{Export list processing
 376 %*                                                                      *
 377 %************************************************************************
 378
 379 The @AvailEnv@ type is just used internally in @exportsFromAvail@.
 380 When exporting we need to combine the availabilities for a particular
 381 exported thing, and we also need to check for name clashes -- that
 382 is: two exported things must have different @OccNames@.
 383
 384 \begin{code}
 385 type AvailEnv = FiniteMap OccName (RdrNameIE, AvailInfo, Int{-no. of clashes-})
 386         -- The FM maps each OccName to the RdrNameIE that gave rise to it,
 387         -- for error reporting, as well as to its AvailInfo
 388
 389 emptyAvailEnv = emptyFM
 390
 391 {-
 392  Add new entry to environment. Checks for name clashes, i.e.,
 393  plain duplicates or exported entity pairs that have different OccNames.
 394  (c.f. 5.1.1 of Haskell 1.4 report.)
 395 -}
 396 addAvailEnv :: Bool -> RdrNameIE -> AvailEnv -> AvailInfo -> RnM s d AvailEnv
 397 addAvailEnv warn_dups ie env NotAvailable   = returnRn env
 398 addAvailEnv warn_dups ie env (AvailTC _ []) = returnRn env
 399 addAvailEnv warn_dups ie env avail
 400   | warn_dups = mapMaybeRn (addErrRn  . availClashErr) () conflict `thenRn_`
 401                 returnRn (addToFM_C add_avail env key elt)
 402   | otherwise = returnRn (addToFM_C add_avail env key elt)
 403   where
 404    key  = nameOccName (availName avail)
 405    elt  = (ie,avail,reports_on)
 406
 407    reports_on
 408     | maybeToBool dup = 1
 409     | otherwise       = 0
 410
 411    conflict = conflictFM bad_avail env key elt
 412    dup
 413     | warn_dups = conflictFM dup_avail env key elt
 414     | otherwise = Nothing
 415
 416 addListToAvailEnv :: AvailEnv -> RdrNameIE -> [AvailInfo] -> RnM s d AvailEnv
 417 addListToAvailEnv env ie items = foldlRn (addAvailEnv False ie) env items
 418
 419 bad_avail  (ie1,avail1,r1) (ie2,avail2,r2)
 420    = availName avail1 /= availName avail2  -- Same OccName, different Name
 421 dup_avail  (ie1,avail1,r1) (ie2,avail2,r2)
 422    = availName avail1 == availName avail2 -- Same OccName & avail.
 423
 424 add_avail (ie1,a1,r1) (ie2,a2,r2) = (ie1, a1 `plusAvail` a2, r1 + r2)
 425 \end{code}
 426
 427 Processing the export list.
 428
 429 You might think that we should record things that appear in the export list as
 430 ``occurrences'' (using addOccurrenceName), but you'd be wrong.  We do check (here)
 431 that they are in scope, but there is no need to slurp in their actual declaration
 432 (which is what addOccurrenceName forces).  Indeed, doing so would big trouble when
 433 compiling PrelBase, because it re-exports GHC, which includes takeMVar#, whose type
 434 includes ConcBase.StateAndSynchVar#, and so on...
 435
 436 \begin{code}
 437 exportsFromAvail :: Module
 438                  -> Maybe [RdrNameIE]   -- Export spec
 439                  -> ExportAvails
 440                  -> RnEnv
 441                  -> RnMG (Name -> ExportFlag, ExportEnv)
 442         -- Complains if two distinct exports have same OccName
 443         -- Warns about identical exports.
 444         -- Complains about exports items not in scope
 445 exportsFromAvail this_mod Nothing export_avails rn_env
 446   = exportsFromAvail this_mod (Just [IEModuleContents this_mod]) export_avails rn_env
 447
 448 exportsFromAvail this_mod (Just export_items)
 449                  (mod_avail_env, entity_avail_env)
 450                  (RnEnv global_name_env fixity_env)
 451   = checkForModuleExportDups export_items                 `thenRn` \ export_items' ->
 452     foldlRn exports_from_item emptyAvailEnv export_items' `thenRn` \ export_avail_env ->
 453     let
 454      dup_entries = fmToList (filterFM (\ _ (_,_,clashes) -> clashes > 0) export_avail_env)
 455     in
 456     mapRn (addWarnRn . dupExportWarn) dup_entries         `thenRn_`
 457     let
 458         export_avails   = map (\ (_,a,_) -> a) (eltsFM export_avail_env)
 459         export_fixities = mk_exported_fixities (availsToNameSet export_avails)
 460         export_fn       = mk_export_fn export_avails
 461     in
 462     returnRn (export_fn, ExportEnv export_avails export_fixities)
 463
 464   where
 465     exports_from_item :: AvailEnv -> RdrNameIE -> RnMG AvailEnv
 466     exports_from_item export_avail_env ie@(IEModuleContents mod)
 467         = case lookupFM mod_avail_env mod of
 468                 Nothing     -> failWithRn export_avail_env (modExportErr mod)
 469                 Just avails -> addListToAvailEnv export_avail_env ie avails
 470
 471     exports_from_item export_avail_env ie
 472         | not (maybeToBool maybe_in_scope)
 473         = failWithRn export_avail_env (unknownNameErr (ieName ie))
 474
 475 #ifdef DEBUG
 476         -- I can't see why this should ever happen; if the thing is in scope
 477         -- at all it ought to have some availability
 478         | not (maybeToBool maybe_avail)
 479         = pprTrace "exportsFromAvail: curious Nothing:" (ppr name)
 480           returnRn export_avail_env
 481 #endif
 482
 483         | not enough_avail
 484         = failWithRn export_avail_env (exportItemErr ie export_avail)
 485
 486         | otherwise     -- Phew!  It's OK!
 487         = addAvailEnv opt_WarnDuplicateExports ie export_avail_env export_avail
 488        where
 489           maybe_in_scope  = lookupFM global_name_env (ieName ie)
 490           Just (name,_)   = maybe_in_scope
 491           maybe_avail     = lookupUFM entity_avail_env name
 492           Just avail      = maybe_avail
 493           export_avail    = filterAvail ie avail
 494           enough_avail    = case export_avail of {NotAvailable -> False; other -> True}
 495
 496         -- We export a fixity iff we export a thing with the same (qualified) RdrName
 497     mk_exported_fixities :: NameSet -> [(OccName, Fixity)]
 498     mk_exported_fixities exports
 499         = fmToList (foldr (perhaps_add_fixity exports)
 500                           emptyFM
 501                           (fmToList fixity_env))
 502
 503     perhaps_add_fixity :: NameSet -> (RdrName, (Fixity, HowInScope))
 504                        -> FiniteMap OccName Fixity
 505                        -> FiniteMap OccName Fixity
 506     perhaps_add_fixity exports (rdr_name, (fixity, how_in_scope)) fix_env
 507       =  let
 508             do_nothing = fix_env                -- The default is to pass on the env unchanged
 509          in
 510                 -- Step 1: check whether the rdr_name is in scope; if so find its Name
 511          case lookupFM global_name_env rdr_name of {
 512            Nothing              -> do_nothing;
 513            Just (fixity_name,_) ->
 514
 515                 -- Step 2: check whether the fixity thing is exported
 516          if not (fixity_name `elemNameSet` exports) then
 517                 do_nothing
 518          else
 519
 520                 -- Step 3: check whether we already have a fixity for the
 521                 -- Name's OccName in the fix_env we are building up.  This can easily
 522                 -- happen.  the original fixity_env might contain bindings for
 523                 --      M.a and N.a, if a was imported via M and N.
 524                 -- If this does happen, we expect the fixity to be the same either way.
 525         let
 526             occ_name = rdrNameOcc rdr_name
 527         in
 528         case lookupFM fix_env occ_name of {
 529           Just fixity1 ->       -- Got it already
 530                            ASSERT( fixity == fixity1 )
 531                            do_nothing;
 532           Nothing ->
 533
 534                 -- Step 3: add it to the outgoing fix_env
 535         addToFM fix_env occ_name fixity
 536         }}
 537
 538 {- warn and weed out duplicate module entries from export list. -}
 539 checkForModuleExportDups :: [RdrNameIE] -> RnMG [RdrNameIE]
 540 checkForModuleExportDups ls
 541   | opt_WarnDuplicateExports = check_modules ls
 542   | otherwise                = returnRn ls
 543   where
 544    -- NOTE: reorders the export list by moving all module-contents
 545    -- exports to the end (removing duplicates in the process.)
 546    check_modules ls =
 547      (case dups of
 548         [] -> returnRn ()
 549         ls -> mapRn (\ ds@(IEModuleContents x:_) ->
 550                        addWarnRn (dupModuleExport x (length ds))) ls `thenRn_`
 551               returnRn ()) `thenRn_`
 552      returnRn (ls_no_modules ++ no_module_dups)
 553      where
 554       (ls_no_modules,modules) = foldr split_mods ([],[]) ls
 555
 556       split_mods i@(IEModuleContents _) ~(no_ms,ms) = (no_ms,i:ms)
 557       split_mods i ~(no_ms,ms) = (i:no_ms,ms)
 558
 559       (no_module_dups, dups) = removeDups cmp_mods modules
 560
 561       cmp_mods (IEModuleContents m1) (IEModuleContents m2) = m1 `compare` m2
 562
 563 mk_export_fn :: [AvailInfo] -> (Name -> ExportFlag)
 564 mk_export_fn avails
 565   = \name -> if name `elemNameSet` exported_names
 566              then Exported
 567              else NotExported
 568   where
 569     exported_names :: NameSet
 570     exported_names = availsToNameSet avails
 571 \end{code}
 572
 573 %************************************************************************
 574 %*                                                                      *
 575 \subsection{Errors}
 576 %*                                                                      *
 577 %************************************************************************
 578
 579 \begin{code}
 580 badImportItemErr mod ie
 581   = sep [ptext SLIT("Module"), quotes (pprModule mod),
 582          ptext SLIT("does not export"), quotes (ppr ie)]
 583
 584 modExportErr mod
 585   = hsep [ ptext SLIT("Unknown module in export list: module"), quotes (pprModule mod)]
 586
 587 exportItemErr export_item NotAvailable
 588   = sep [ ptext SLIT("Export item not in scope:"), quotes (ppr export_item)]
 589
 590 exportItemErr export_item avail
 591   = hang (ptext SLIT("Export item not fully in scope:"))
 592            4 (vcat [hsep [ptext SLIT("Wanted:   "), ppr export_item],
 593                     hsep [ptext SLIT("Available:"), ppr (ieOcc export_item), pprAvail avail]])
 594
 595 availClashErr (occ_name, ((ie1,avail1,_), (ie2,avail2,_)))
 596   = hsep [ptext SLIT("The export items"), quotes (ppr ie1), ptext SLIT("and"), quotes (ppr ie2),
 597           ptext SLIT("create conflicting exports for"), quotes (ppr occ_name)]
 598
 599 dupExportWarn (occ_name, (_,_,times))
 600   = hsep [quotes (ppr occ_name),
 601           ptext SLIT("mentioned"), speakNTimes (times+1),
 602           ptext SLIT("in export list")]
 603
 604 dupModuleExport mod times
 605   = hsep [ptext SLIT("Module"), quotes (pprModule mod),
 606           ptext SLIT("mentioned"), speakNTimes times,
 607           ptext SLIT("in export list")]
 608 \end{code}
 609