compiler/iface/LoadIface.lhs

   1 %
   2 % (c) The University of Glasgow 2006
   3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   4 %
   5
   6 Loading interface files
   7
   8 \begin{code}
   9 module LoadIface (
  10         loadInterface, loadInterfaceForName, loadWiredInHomeIface,
  11         loadSrcInterface, loadSysInterface, loadOrphanModules,
  12         findAndReadIface, readIface,    -- Used when reading the module's old interface
  13         loadDecls,      -- Should move to TcIface and be renamed
  14         initExternalPackageState,
  15
  16         ifaceStats, pprModIface, showIface
  17    ) where
  18
  19 #include "HsVersions.h"
  20
  21 import {-# SOURCE #-}   TcIface( tcIfaceDecl, tcIfaceRules, tcIfaceInst,
  22                                  tcIfaceFamInst )
  23
  24 import DynFlags
  25 import IfaceSyn
  26 import IfaceEnv
  27 import HscTypes
  28
  29 import BasicTypes hiding (SuccessFlag(..))
  30 import TcRnMonad
  31 import Type
  32
  33 import PrelNames
  34 import PrelInfo
  35 import PrelRules
  36 import Rules
  37 import InstEnv
  38 import FamInstEnv
  39 import Name
  40 import NameEnv
  41 import MkId
  42 import Module
  43 import OccName
  44 import SrcLoc
  45 import Maybes
  46 import ErrUtils
  47 import Finder
  48 import UniqFM
  49 import StaticFlags
  50 import Outputable
  51 import BinIface
  52 import Panic
  53
  54 import Control.Monad (when)
  55 import Data.List
  56 import Data.Maybe
  57 import Data.IORef
  58 \end{code}
  59
  60
  61 %************************************************************************
  62 %*                                                                      *
  63         loadSrcInterface, loadOrphanModules, loadHomeInterface
  64
  65                 These three are called from TcM-land
  66 %*                                                                      *
  67 %************************************************************************
  68
  69 \begin{code}
  70 -- | Load the interface corresponding to an @import@ directive in
  71 -- source code.  On a failure, fail in the monad with an error message.
  72 loadSrcInterface :: SDoc -> ModuleName -> IsBootInterface -> RnM ModIface
  73 loadSrcInterface doc mod want_boot  = do
  74   -- We must first find which Module this import refers to.  This involves
  75   -- calling the Finder, which as a side effect will search the filesystem
  76   -- and create a ModLocation.  If successful, loadIface will read the
  77   -- interface; it will call the Finder again, but the ModLocation will be
  78   -- cached from the first search.
  79   hsc_env <- getTopEnv
  80   res <- ioToIOEnv $ findImportedModule hsc_env mod Nothing
  81   case res of
  82     Found _ mod -> do
  83       mb_iface <- initIfaceTcRn $ loadInterface doc mod (ImportByUser want_boot)
  84       case mb_iface of
  85         Failed err      -> failWithTc err
  86         Succeeded iface -> return iface
  87     err ->
  88         let dflags = hsc_dflags hsc_env in
  89         failWithTc (cannotFindInterface dflags mod err)
  90
  91 -- | Load interfaces for a collection of orphan modules.
  92 loadOrphanModules :: [Module]         -- the modules
  93                   -> Bool             -- these are family instance-modules
  94                   -> TcM ()
  95 loadOrphanModules mods isFamInstMod
  96   | null mods = returnM ()
  97   | otherwise = initIfaceTcRn $
  98                 do { traceIf (text "Loading orphan modules:" <+>
  99                                  fsep (map ppr mods))
 100                    ; mappM_ load mods
 101                    ; returnM () }
 102   where
 103     load mod   = loadSysInterface (mk_doc mod) mod
 104     mk_doc mod
 105       | isFamInstMod = ppr mod <+> ptext SLIT("is a family-instance module")
 106       | otherwise    = ppr mod <+> ptext SLIT("is a orphan-instance module")
 107
 108 -- | Loads the interface for a given Name.
 109 loadInterfaceForName :: SDoc -> Name -> TcRn ModIface
 110 loadInterfaceForName doc name
 111   = do  {
 112 #ifdef DEBUG
 113                 -- Should not be called with a name from the module being compiled
 114           this_mod <- getModule
 115         ; ASSERT2( not (nameIsLocalOrFrom this_mod name), ppr name <+> parens doc )
 116 #endif
 117           initIfaceTcRn $ loadSysInterface doc (nameModule name)
 118     }
 119
 120 -- | An 'IfM' function to load the home interface for a wired-in thing,
 121 -- so that we're sure that we see its instance declarations and rules
 122 loadWiredInHomeIface :: Name -> IfM lcl ()
 123 loadWiredInHomeIface name
 124   = ASSERT( isWiredInName name )
 125     do loadSysInterface doc (nameModule name); return ()
 126   where
 127     doc = ptext SLIT("Need home interface for wired-in thing") <+> ppr name
 128
 129 -- | A wrapper for 'loadInterface' that throws an exception if it fails
 130 loadSysInterface :: SDoc -> Module -> IfM lcl ModIface
 131 loadSysInterface doc mod_name
 132   = do  { mb_iface <- loadInterface doc mod_name ImportBySystem
 133         ; case mb_iface of
 134             Failed err      -> ghcError (ProgramError (showSDoc err))
 135             Succeeded iface -> return iface }
 136 \end{code}
 137
 138
 139 %*********************************************************
 140 %*                                                      *
 141                 loadInterface
 142
 143         The main function to load an interface
 144         for an imported module, and put it in
 145         the External Package State
 146 %*                                                      *
 147 %*********************************************************
 148
 149 \begin{code}
 150 loadInterface :: SDoc -> Module -> WhereFrom
 151               -> IfM lcl (MaybeErr Message ModIface)
 152
 153 -- loadInterface looks in both the HPT and PIT for the required interface
 154 -- If not found, it loads it, and puts it in the PIT (always).
 155
 156 -- If it can't find a suitable interface file, we
 157 --      a) modify the PackageIfaceTable to have an empty entry
 158 --              (to avoid repeated complaints)
 159 --      b) return (Left message)
 160 --
 161 -- It's not necessarily an error for there not to be an interface
 162 -- file -- perhaps the module has changed, and that interface
 163 -- is no longer used
 164
 165 loadInterface doc_str mod from
 166   = do  {       -- Read the state
 167           (eps,hpt) <- getEpsAndHpt
 168
 169         ; traceIf (text "Considering whether to load" <+> ppr mod <+> ppr from)
 170
 171                 -- Check whether we have the interface already
 172         ; dflags <- getDOpts
 173         ; case lookupIfaceByModule dflags hpt (eps_PIT eps) mod of {
 174             Just iface
 175                 -> returnM (Succeeded iface) ;  -- Already loaded
 176                         -- The (src_imp == mi_boot iface) test checks that the already-loaded
 177                         -- interface isn't a boot iface.  This can conceivably happen,
 178                         -- if an earlier import had a before we got to real imports.   I think.
 179             other -> do {
 180
 181           let { hi_boot_file = case from of
 182                                 ImportByUser usr_boot -> usr_boot
 183                                 ImportBySystem        -> sys_boot
 184
 185               ; mb_dep   = lookupUFM (eps_is_boot eps) (moduleName mod)
 186               ; sys_boot = case mb_dep of
 187                                 Just (_, is_boot) -> is_boot
 188                                 Nothing           -> False
 189                         -- The boot-ness of the requested interface,
 190               }         -- based on the dependencies in directly-imported modules
 191
 192         -- READ THE MODULE IN
 193         ; read_result <- findAndReadIface doc_str mod hi_boot_file
 194         ; case read_result of {
 195             Failed err -> do
 196                 { let fake_iface = emptyModIface mod
 197
 198                 ; updateEps_ $ \eps ->
 199                         eps { eps_PIT = extendModuleEnv (eps_PIT eps) (mi_module fake_iface) fake_iface }
 200                         -- Not found, so add an empty iface to
 201                         -- the EPS map so that we don't look again
 202
 203                 ; returnM (Failed err) } ;
 204
 205         -- Found and parsed!
 206             Succeeded (iface, file_path)        -- Sanity check:
 207                 | ImportBySystem <- from,       --   system-importing...
 208                   modulePackageId (mi_module iface) == thisPackage dflags,
 209                                                 --   a home-package module...
 210                   Nothing <- mb_dep             --   that we know nothing about
 211                 -> returnM (Failed (badDepMsg mod))
 212
 213                 | otherwise ->
 214
 215         let
 216             loc_doc = text file_path
 217         in
 218         initIfaceLcl mod loc_doc $ do
 219
 220         --      Load the new ModIface into the External Package State
 221         -- Even home-package interfaces loaded by loadInterface
 222         --      (which only happens in OneShot mode; in Batch/Interactive
 223         --      mode, home-package modules are loaded one by one into the HPT)
 224         -- are put in the EPS.
 225         --
 226         -- The main thing is to add the ModIface to the PIT, but
 227         -- we also take the
 228         --      IfaceDecls, IfaceInst, IfaceRules
 229         -- out of the ModIface and put them into the big EPS pools
 230
 231         -- NB: *first* we do loadDecl, so that the provenance of all the locally-defined
 232         ---    names is done correctly (notably, whether this is an .hi file or .hi-boot file).
 233         --     If we do loadExport first the wrong info gets into the cache (unless we
 234         --      explicitly tag each export which seems a bit of a bore)
 235
 236         ; ignore_prags      <- doptM Opt_IgnoreInterfacePragmas
 237         ; new_eps_decls     <- loadDecls ignore_prags (mi_decls iface)
 238         ; new_eps_insts     <- mapM tcIfaceInst (mi_insts iface)
 239         ; new_eps_fam_insts <- mapM tcIfaceFamInst (mi_fam_insts iface)
 240         ; new_eps_rules     <- tcIfaceRules ignore_prags (mi_rules iface)
 241
 242         ; let { final_iface = iface {
 243                                 mi_decls     = panic "No mi_decls in PIT",
 244                                 mi_insts     = panic "No mi_insts in PIT",
 245                                 mi_fam_insts = panic "No mi_fam_insts in PIT",
 246                                 mi_rules     = panic "No mi_rules in PIT"
 247                               } }
 248
 249         ; updateEps_  $ \ eps ->
 250             eps {
 251               eps_PIT          = extendModuleEnv (eps_PIT eps) mod final_iface,
 252               eps_PTE          = addDeclsToPTE   (eps_PTE eps) new_eps_decls,
 253               eps_rule_base    = extendRuleBaseList (eps_rule_base eps)
 254                                                     new_eps_rules,
 255               eps_inst_env     = extendInstEnvList (eps_inst_env eps)
 256                                                    new_eps_insts,
 257               eps_fam_inst_env = extendFamInstEnvList (eps_fam_inst_env eps)
 258                                                       new_eps_fam_insts,
 259               eps_mod_fam_inst_env
 260                                = let
 261                                    fam_inst_env =
 262                                      extendFamInstEnvList emptyFamInstEnv
 263                                                           new_eps_fam_insts
 264                                  in
 265                                  extendModuleEnv (eps_mod_fam_inst_env eps)
 266                                                  mod
 267                                                  fam_inst_env,
 268               eps_stats        = addEpsInStats (eps_stats eps)
 269                                                (length new_eps_decls)
 270               (length new_eps_insts) (length new_eps_rules) }
 271
 272         ; return (Succeeded final_iface)
 273     }}}}
 274
 275 badDepMsg mod
 276   = hang (ptext SLIT("Interface file inconsistency:"))
 277        2 (sep [ptext SLIT("home-package module") <+> quotes (ppr mod) <+> ptext SLIT("is mentioned is needed,"),
 278                ptext SLIT("but is not among the dependencies of interfaces directly imported by the module being compiled")])
 279
 280 -----------------------------------------------------
 281 --      Loading type/class/value decls
 282 -- We pass the full Module name here, replete with
 283 -- its package info, so that we can build a Name for
 284 -- each binder with the right package info in it
 285 -- All subsequent lookups, including crucially lookups during typechecking
 286 -- the declaration itself, will find the fully-glorious Name
 287 --
 288 -- We handle ATs specially.  They are not main declarations, but also not
 289 -- implict things (in particular, adding them to `implicitTyThings' would mess
 290 -- things up in the renaming/type checking of source programs).
 291 -----------------------------------------------------
 292
 293 addDeclsToPTE :: PackageTypeEnv -> [(Name,TyThing)] -> PackageTypeEnv
 294 addDeclsToPTE pte things = extendNameEnvList pte things
 295
 296 loadDecls :: Bool
 297           -> [(Version, IfaceDecl)]
 298           -> IfL [(Name,TyThing)]
 299 loadDecls ignore_prags ver_decls
 300    = do { mod <- getIfModule
 301         ; thingss <- mapM (loadDecl ignore_prags mod) ver_decls
 302         ; return (concat thingss)
 303         }
 304
 305 loadDecl :: Bool                    -- Don't load pragmas into the decl pool
 306          -> Module
 307           -> (Version, IfaceDecl)
 308           -> IfL [(Name,TyThing)]   -- The list can be poked eagerly, but the
 309                                     -- TyThings are forkM'd thunks
 310 loadDecl ignore_prags mod (_version, decl)
 311   = do  {       -- Populate the name cache with final versions of all
 312                 -- the names associated with the decl
 313           main_name      <- mk_new_bndr mod (ifName decl)
 314 --        ; traceIf (text "Loading decl for " <> ppr main_name)
 315         ; implicit_names <- mapM (mk_new_bndr mod) (ifaceDeclSubBndrs decl)
 316
 317         -- Typecheck the thing, lazily
 318         -- NB. Firstly, the laziness is there in case we never need the
 319         -- declaration (in one-shot mode), and secondly it is there so that
 320         -- we don't look up the occurrence of a name before calling mk_new_bndr
 321         -- on the binder.  This is important because we must get the right name
 322         -- which includes its nameParent.
 323
 324         ; thing <- forkM doc $ do { bumpDeclStats main_name
 325                                   ; tcIfaceDecl ignore_prags decl }
 326
 327         -- Populate the type environment with the implicitTyThings too.
 328         --
 329         -- Note [Tricky iface loop]
 330         -- ~~~~~~~~~~~~~~~~~~~~~~~~
 331         -- The delicate point here is that 'mini-env' should be
 332         -- buildable from 'thing' without demanding any of the things 'forkM'd
 333         -- by tcIfaceDecl.  For example
 334         --      class C a where { data T a; op :: T a -> Int }
 335         -- We return the bindings
 336         --      [("C", <cls>), ("T", lookup env "T"), ("op", lookup env "op")]
 337         -- The call (lookup env "T") must return the tycon T without first demanding
 338         -- op; because getting the latter will look up T, hence loop.
 339         --
 340         -- Of course, there is no reason in principle why (lookup env "T") should demand
 341         -- anything do to with op, but take care:
 342         --      (a) implicitTyThings, and
 343         --      (b) getOccName of all the things returned by implicitThings,
 344         -- must not depend on any of the nested type-checks
 345         --
 346         -- All a bit too finely-balanced for my liking.
 347
 348         ; let mini_env = mkOccEnv [(getOccName t, t) | t <- implicitTyThings thing]
 349               lookup n = case lookupOccEnv mini_env (getOccName n) of
 350                            Just thing -> thing
 351                            Nothing    ->
 352                              pprPanic "loadDecl" (ppr main_name <+> ppr n $$ ppr (decl))
 353
 354         ; returnM $ (main_name, thing) :  [(n, lookup n) | n <- implicit_names]
 355         }
 356                 -- We build a list from the *known* names, with (lookup n) thunks
 357                 -- as the TyThings.  That way we can extend the PTE without poking the
 358                 -- thunks
 359   where
 360         -- mk_new_bndr allocates in the name cache the final canonical
 361         -- name for the thing, with the correct
 362         --      * parent
 363         --      * location
 364         -- imported name, to fix the module correctly in the cache
 365     mk_new_bndr mod occ
 366         = newGlobalBinder mod occ
 367                           (importedSrcLoc (showSDoc (ppr (moduleName mod))))
 368                         -- ToDo: qualify with the package name if necessary
 369
 370     doc = ptext SLIT("Declaration for") <+> ppr (ifName decl)
 371
 372 bumpDeclStats :: Name -> IfL ()         -- Record that one more declaration has actually been used
 373 bumpDeclStats name
 374   = do  { traceIf (text "Loading decl for" <+> ppr name)
 375         ; updateEps_ (\eps -> let stats = eps_stats eps
 376                               in eps { eps_stats = stats { n_decls_out = n_decls_out stats + 1 } })
 377         }
 378 \end{code}
 379
 380
 381 %*********************************************************
 382 %*                                                      *
 383 \subsection{Reading an interface file}
 384 %*                                                      *
 385 %*********************************************************
 386
 387 \begin{code}
 388 findAndReadIface :: SDoc -> Module
 389                  -> IsBootInterface     -- True  <=> Look for a .hi-boot file
 390                                         -- False <=> Look for .hi file
 391                  -> TcRnIf gbl lcl (MaybeErr Message (ModIface, FilePath))
 392         -- Nothing <=> file not found, or unreadable, or illegible
 393         -- Just x  <=> successfully found and parsed
 394
 395         -- It *doesn't* add an error to the monad, because
 396         -- sometimes it's ok to fail... see notes with loadInterface
 397
 398 findAndReadIface doc_str mod hi_boot_file
 399   = do  { traceIf (sep [hsep [ptext SLIT("Reading"),
 400                               if hi_boot_file
 401                                 then ptext SLIT("[boot]")
 402                                 else empty,
 403                               ptext SLIT("interface for"),
 404                               ppr mod <> semi],
 405                         nest 4 (ptext SLIT("reason:") <+> doc_str)])
 406
 407         -- Check for GHC.Prim, and return its static interface
 408         ; dflags <- getDOpts
 409         ; if mod == gHC_PRIM
 410           then returnM (Succeeded (ghcPrimIface,
 411                                    "<built in interface for GHC.Prim>"))
 412           else do
 413
 414         -- Look for the file
 415         ; hsc_env <- getTopEnv
 416         ; mb_found <- ioToIOEnv (findExactModule hsc_env mod)
 417         ; case mb_found of {
 418
 419               err | notFound err -> do
 420                 { traceIf (ptext SLIT("...not found"))
 421                 ; dflags <- getDOpts
 422                 ; returnM (Failed (cannotFindInterface dflags
 423                                         (moduleName mod) err)) } ;
 424               Found loc mod -> do
 425
 426         -- Found file, so read it
 427         { let { file_path = addBootSuffix_maybe hi_boot_file (ml_hi_file loc) }
 428
 429         ; if thisPackage dflags == modulePackageId mod
 430                 && not (isOneShot (ghcMode dflags))
 431             then returnM (Failed (homeModError mod loc))
 432             else do {
 433
 434         ; traceIf (ptext SLIT("readIFace") <+> text file_path)
 435         ; read_result <- readIface mod file_path hi_boot_file
 436         ; case read_result of
 437             Failed err -> returnM (Failed (badIfaceFile file_path err))
 438             Succeeded iface
 439                 | mi_module iface /= mod ->
 440                   return (Failed (wrongIfaceModErr iface mod file_path))
 441                 | otherwise ->
 442                   returnM (Succeeded (iface, file_path))
 443                         -- Don't forget to fill in the package name...
 444         }}}}
 445
 446 notFound (Found _ _) = False
 447 notFound _ = True
 448 \end{code}
 449
 450 @readIface@ tries just the one file.
 451
 452 \begin{code}
 453 readIface :: Module -> FilePath -> IsBootInterface
 454           -> TcRnIf gbl lcl (MaybeErr Message ModIface)
 455         -- Failed err    <=> file not found, or unreadable, or illegible
 456         -- Succeeded iface <=> successfully found and parsed
 457
 458 readIface wanted_mod file_path is_hi_boot_file
 459   = do  { dflags <- getDOpts
 460         ; res <- tryMostM $ readBinIface file_path
 461         ; case res of
 462             Right iface
 463                 | wanted_mod == actual_mod -> return (Succeeded iface)
 464                 | otherwise                -> return (Failed err)
 465                 where
 466                   actual_mod = mi_module iface
 467                   err = hiModuleNameMismatchWarn wanted_mod actual_mod
 468
 469             Left exn    -> return (Failed (text (showException exn)))
 470     }
 471 \end{code}
 472
 473
 474 %*********************************************************
 475 %*                                                       *
 476         Wired-in interface for GHC.Prim
 477 %*                                                       *
 478 %*********************************************************
 479
 480 \begin{code}
 481 initExternalPackageState :: ExternalPackageState
 482 initExternalPackageState
 483   = EPS {
 484       eps_is_boot      = emptyUFM,
 485       eps_PIT          = emptyPackageIfaceTable,
 486       eps_PTE          = emptyTypeEnv,
 487       eps_inst_env     = emptyInstEnv,
 488       eps_fam_inst_env = emptyFamInstEnv,
 489       eps_rule_base    = mkRuleBase builtinRules,
 490         -- Initialise the EPS rule pool with the built-in rules
 491       eps_mod_fam_inst_env
 492                        = emptyModuleEnv,
 493       eps_stats = EpsStats { n_ifaces_in = 0, n_decls_in = 0, n_decls_out = 0
 494                            , n_insts_in = 0, n_insts_out = 0
 495                            , n_rules_in = length builtinRules, n_rules_out = 0 }
 496     }
 497 \end{code}
 498
 499
 500 %*********************************************************
 501 %*                                                       *
 502         Wired-in interface for GHC.Prim
 503 %*                                                       *
 504 %*********************************************************
 505
 506 \begin{code}
 507 ghcPrimIface :: ModIface
 508 ghcPrimIface
 509   = (emptyModIface gHC_PRIM) {
 510         mi_exports  = [(gHC_PRIM, ghcPrimExports)],
 511         mi_decls    = [],
 512         mi_fixities = fixities,
 513         mi_fix_fn  = mkIfaceFixCache fixities
 514     }
 515   where
 516     fixities = [(getOccName seqId, Fixity 0 InfixR)]
 517                         -- seq is infixr 0
 518 \end{code}
 519
 520 %*********************************************************
 521 %*                                                      *
 522 \subsection{Statistics}
 523 %*                                                      *
 524 %*********************************************************
 525
 526 \begin{code}
 527 ifaceStats :: ExternalPackageState -> SDoc
 528 ifaceStats eps
 529   = hcat [text "Renamer stats: ", msg]
 530   where
 531     stats = eps_stats eps
 532     msg = vcat
 533         [int (n_ifaces_in stats) <+> text "interfaces read",
 534          hsep [ int (n_decls_out stats), text "type/class/variable imported, out of",
 535                 int (n_decls_in stats), text "read"],
 536          hsep [ int (n_insts_out stats), text "instance decls imported, out of",
 537                 int (n_insts_in stats), text "read"],
 538          hsep [ int (n_rules_out stats), text "rule decls imported, out of",
 539                 int (n_rules_in stats), text "read"]
 540         ]
 541 \end{code}
 542
 543
 544 %************************************************************************
 545 %*                                                                      *
 546                 Printing interfaces
 547 %*                                                                      *
 548 %************************************************************************
 549
 550 \begin{code}
 551 -- | Read binary interface, and print it out
 552 showIface :: HscEnv -> FilePath -> IO ()
 553 showIface hsc_env filename = do
 554    -- skip the version check; we don't want to worry about profiled vs.
 555    -- non-profiled interfaces, for example.
 556    writeIORef v_IgnoreHiWay True
 557    iface <- initTcRnIf 's' hsc_env () () $ readBinIface  filename
 558    printDump (pprModIface iface)
 559 \end{code}
 560
 561 \begin{code}
 562 pprModIface :: ModIface -> SDoc
 563 -- Show a ModIface
 564 pprModIface iface
 565  = vcat [ ptext SLIT("interface")
 566                 <+> ppr (mi_module iface) <+> pp_boot
 567                 <+> ppr (mi_mod_vers iface) <+> pp_sub_vers
 568                 <+> (if mi_orphan iface then ptext SLIT("[orphan module]") else empty)
 569                 <+> (if mi_finsts iface then ptext SLIT("[family instance module]") else empty)
 570                 <+> integer opt_HiVersion
 571                 <+> ptext SLIT("where")
 572         , vcat (map pprExport (mi_exports iface))
 573         , pprDeps (mi_deps iface)
 574         , vcat (map pprUsage (mi_usages iface))
 575         , pprFixities (mi_fixities iface)
 576         , vcat (map pprIfaceDecl (mi_decls iface))
 577         , vcat (map ppr (mi_insts iface))
 578         , vcat (map ppr (mi_fam_insts iface))
 579         , vcat (map ppr (mi_rules iface))
 580         , pprDeprecs (mi_deprecs iface)
 581         ]
 582   where
 583     pp_boot | mi_boot iface = ptext SLIT("[boot]")
 584             | otherwise     = empty
 585
 586     exp_vers  = mi_exp_vers iface
 587     rule_vers = mi_rule_vers iface
 588
 589     pp_sub_vers | exp_vers == initialVersion && rule_vers == initialVersion = empty
 590                 | otherwise = brackets (ppr exp_vers <+> ppr rule_vers)
 591 \end{code}
 592
 593 When printing export lists, we print like this:
 594         Avail   f               f
 595         AvailTC C [C, x, y]     C(x,y)
 596         AvailTC C [x, y]        C!(x,y)         -- Exporting x, y but not C
 597
 598 \begin{code}
 599 pprExport :: IfaceExport -> SDoc
 600 pprExport (mod, items)
 601  = hsep [ ptext SLIT("export"), ppr mod, hsep (map pp_avail items) ]
 602   where
 603     pp_avail :: GenAvailInfo OccName -> SDoc
 604     pp_avail (Avail occ)    = ppr occ
 605     pp_avail (AvailTC _ []) = empty
 606     pp_avail (AvailTC n (n':ns))
 607         | n==n'     = ppr n <> pp_export ns
 608         | otherwise = ppr n <> char '|' <> pp_export (n':ns)
 609
 610     pp_export []    = empty
 611     pp_export names = braces (hsep (map ppr names))
 612
 613 pprUsage :: Usage -> SDoc
 614 pprUsage usage
 615   = hsep [ptext SLIT("import"), ppr (usg_name usage),
 616           int (usg_mod usage),
 617           pp_export_version (usg_exports usage),
 618           int (usg_rules usage),
 619           pp_versions (usg_entities usage) ]
 620   where
 621     pp_versions nvs = hsep [ ppr n <+> int v | (n,v) <- nvs ]
 622     pp_export_version Nothing  = empty
 623     pp_export_version (Just v) = int v
 624
 625 pprDeps :: Dependencies -> SDoc
 626 pprDeps (Deps { dep_mods = mods, dep_pkgs = pkgs, dep_orphs = orphs,
 627                 dep_finsts = finsts })
 628   = vcat [ptext SLIT("module dependencies:") <+> fsep (map ppr_mod mods),
 629           ptext SLIT("package dependencies:") <+> fsep (map ppr pkgs),
 630           ptext SLIT("orphans:") <+> fsep (map ppr orphs),
 631           ptext SLIT("family instance modules:") <+> fsep (map ppr finsts)
 632         ]
 633   where
 634     ppr_mod (mod_name, boot) = ppr mod_name <+> ppr_boot boot
 635     ppr_boot True  = text "[boot]"
 636     ppr_boot False = empty
 637
 638 pprIfaceDecl :: (Version, IfaceDecl) -> SDoc
 639 pprIfaceDecl (ver, decl)
 640   = ppr_vers ver <+> ppr decl
 641   where
 642         -- Print the version for the decl
 643     ppr_vers v | v == initialVersion = empty
 644                | otherwise           = int v
 645
 646 pprFixities :: [(OccName, Fixity)] -> SDoc
 647 pprFixities []    = empty
 648 pprFixities fixes = ptext SLIT("fixities") <+> pprWithCommas pprFix fixes
 649                   where
 650                     pprFix (occ,fix) = ppr fix <+> ppr occ
 651
 652 pprDeprecs NoDeprecs        = empty
 653 pprDeprecs (DeprecAll txt)  = ptext SLIT("Deprecate all") <+> doubleQuotes (ftext txt)
 654 pprDeprecs (DeprecSome prs) = ptext SLIT("Deprecate") <+> vcat (map pprDeprec prs)
 655                             where
 656                               pprDeprec (name, txt) = ppr name <+> doubleQuotes (ftext txt)
 657 \end{code}
 658
 659
 660 %*********************************************************
 661 %*                                                       *
 662 \subsection{Errors}
 663 %*                                                       *
 664 %*********************************************************
 665
 666 \begin{code}
 667 badIfaceFile file err
 668   = vcat [ptext SLIT("Bad interface file:") <+> text file,
 669           nest 4 err]
 670
 671 hiModuleNameMismatchWarn :: Module -> Module -> Message
 672 hiModuleNameMismatchWarn requested_mod read_mod =
 673   withPprStyle defaultUserStyle $
 674     -- we want the Modules below to be qualified with package names,
 675     -- so reset the PrintUnqualified setting.
 676     hsep [ ptext SLIT("Something is amiss; requested module ")
 677          , ppr requested_mod
 678          , ptext SLIT("differs from name found in the interface file")
 679          , ppr read_mod
 680          ]
 681
 682 wrongIfaceModErr iface mod_name file_path
 683   = sep [ptext SLIT("Interface file") <+> iface_file,
 684          ptext SLIT("contains module") <+> quotes (ppr (mi_module iface)) <> comma,
 685          ptext SLIT("but we were expecting module") <+> quotes (ppr mod_name),
 686          sep [ptext SLIT("Probable cause: the source code which generated"),
 687              nest 2 iface_file,
 688              ptext SLIT("has an incompatible module name")
 689             ]
 690         ]
 691   where iface_file = doubleQuotes (text file_path)
 692
 693 homeModError mod location
 694   = ptext SLIT("attempting to use module ") <> quotes (ppr mod)
 695     <> (case ml_hs_file location of
 696            Just file -> space <> parens (text file)
 697            Nothing   -> empty)
 698     <+> ptext SLIT("which is not loaded")
 699 \end{code}
 700