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