Module reexports, fixing #8407.
[ghc.git] / compiler / main / Finder.lhs
index d8a6271..37395ce 100644 (file)
@@ -4,6 +4,8 @@
 \section[Finder]{Module Finder}
 
 \begin{code}
+{-# LANGUAGE CPP #-}
+
 module Finder (
     flushFinderCaches,
     FindResult(..),
@@ -37,21 +39,21 @@ import PrelNames        ( gHC_PRIM )
 import DynFlags
 import Outputable
 import UniqFM
-import Maybes          ( expectJust )
+import Maybes           ( expectJust )
 import Exception        ( evaluate )
 
 import Distribution.Text
-import Distribution.Package hiding (PackageId)
-import Data.IORef      ( IORef, writeIORef, readIORef, atomicModifyIORef )
+import Distribution.Package
+import Data.IORef       ( IORef, writeIORef, readIORef, atomicModifyIORef )
 import System.Directory
 import System.FilePath
 import Control.Monad
-import System.Time     ( ClockTime )
 import Data.List        ( partition )
+import Data.Time
 
 
-type FileExt = String  -- Filename extension
-type BaseName = String -- Basename of file
+type FileExt = String   -- Filename extension
+type BaseName = String  -- Basename of file
 
 -- -----------------------------------------------------------------------------
 -- The Finder
@@ -74,17 +76,17 @@ flushFinderCaches hsc_env = do
   writeIORef fc_ref emptyUFM
   flushModLocationCache this_pkg mlc_ref
  where
-       this_pkg = thisPackage (hsc_dflags hsc_env)
-       fc_ref = hsc_FC hsc_env
-       mlc_ref = hsc_MLC hsc_env
+        this_pkg = thisPackage (hsc_dflags hsc_env)
+        fc_ref = hsc_FC hsc_env
+        mlc_ref = hsc_MLC hsc_env
 
-flushModLocationCache :: PackageId -> IORef ModLocationCache -> IO ()
+flushModLocationCache :: PackageKey -> IORef ModLocationCache -> IO ()
 flushModLocationCache this_pkg ref = do
   atomicModifyIORef ref $ \fm -> (filterModuleEnv is_ext fm, ())
   _ <- evaluate =<< readIORef ref
   return ()
-  where is_ext mod _ | modulePackageId mod /= this_pkg = True
-                    | otherwise = False
+  where is_ext mod _ | modulePackageKey mod /= this_pkg = True
+                     | otherwise = False
 
 addToFinderCache :: IORef FinderCache -> ModuleName -> FindResult -> IO ()
 addToFinderCache ref key val =
@@ -103,7 +105,7 @@ removeFromModLocationCache ref key =
   atomicModifyIORef ref $ \c -> (delModuleEnv c key, ())
 
 lookupFinderCache :: IORef FinderCache -> ModuleName -> IO (Maybe FindResult)
-lookupFinderCache ref key = do 
+lookupFinderCache ref key = do
    c <- readIORef ref
    return $! lookupUFM c key
 
@@ -125,30 +127,30 @@ lookupModLocationCache ref key = do
 findImportedModule :: HscEnv -> ModuleName -> Maybe FastString -> IO FindResult
 findImportedModule hsc_env mod_name mb_pkg =
   case mb_pkg of
-       Nothing                        -> unqual_import
-       Just pkg | pkg == fsLit "this" -> home_import -- "this" is special
-                | otherwise           -> pkg_import
+        Nothing                        -> unqual_import
+        Just pkg | pkg == fsLit "this" -> home_import -- "this" is special
+                 | otherwise           -> pkg_import
   where
     home_import   = findHomeModule hsc_env mod_name
 
     pkg_import    = findExposedPackageModule hsc_env mod_name mb_pkg
 
-    unqual_import = home_import 
-                        `orIfNotFound`
-                     findExposedPackageModule hsc_env mod_name Nothing
+    unqual_import = home_import
+                    `orIfNotFound`
+                    findExposedPackageModule hsc_env mod_name Nothing
 
 -- | Locate a specific 'Module'.  The purpose of this function is to
 -- create a 'ModLocation' for a given 'Module', that is to find out
 -- where the files associated with this module live.  It is used when
--- reading the interface for a module mentioned by another interface, 
+-- reading the interface for a module mentioned by another interface,
 -- for example (a "system import").
 
 findExactModule :: HscEnv -> Module -> IO FindResult
 findExactModule hsc_env mod =
-   let dflags = hsc_dflags hsc_env in
-   if modulePackageId mod == thisPackage dflags
-       then findHomeModule hsc_env (moduleName mod)
-       else findPackageModule hsc_env mod
+    let dflags = hsc_dflags hsc_env
+    in if modulePackageKey mod == thisPackage dflags
+       then findHomeModule hsc_env (moduleName mod)
+       else findPackageModule hsc_env mod
 
 -- -----------------------------------------------------------------------------
 -- Helpers
@@ -175,15 +177,15 @@ orIfNotFound this or_this = do
 homeSearchCache :: HscEnv -> ModuleName -> IO FindResult -> IO FindResult
 homeSearchCache hsc_env mod_name do_this = do
   m <- lookupFinderCache (hsc_FC hsc_env) mod_name
-  case m of 
+  case m of
     Just result -> return result
     Nothing     -> do
-       result <- do_this
-       addToFinderCache (hsc_FC hsc_env) mod_name result
-       case result of
-          Found loc mod -> addToModLocationCache (hsc_MLC hsc_env) mod loc
-          _other        -> return ()
-       return result
+        result <- do_this
+        addToFinderCache (hsc_FC hsc_env) mod_name result
+        case result of
+           Found loc mod -> addToModLocationCache (hsc_MLC hsc_env) mod loc
+           _other        -> return ()
+        return result
 
 findExposedPackageModule :: HscEnv -> ModuleName -> Maybe FastString
                          -> IO FindResult
@@ -191,32 +193,39 @@ findExposedPackageModule hsc_env mod_name mb_pkg
         -- not found in any package:
   = case lookupModuleWithSuggestions (hsc_dflags hsc_env) mod_name of
        Left suggest -> return (NotFound { fr_paths = [], fr_pkg = Nothing
-                                        , fr_pkgs_hidden = [], fr_mods_hidden = []
+                                        , fr_pkgs_hidden = []
+                                        , fr_mods_hidden = []
                                         , fr_suggestions = suggest })
-       Right found
-         | null found_exposed   -- Found, but with no exposed copies
+       Right found'
+         | null found_visible   -- Found, but with no exposed copies
           -> return (NotFound { fr_paths = [], fr_pkg = Nothing
-                              , fr_pkgs_hidden = pkg_hiddens, fr_mods_hidden = mod_hiddens
+                              , fr_pkgs_hidden = pkg_hiddens
+                              , fr_mods_hidden = mod_hiddens
                               , fr_suggestions = [] })
 
-         | [(pkg_conf,_)] <- found_exposed     -- Found uniquely
+         | [ModConf mod_name' pkg_conf _ _] <- found_visible -- Found uniquely
          -> let pkgid = packageConfigId pkg_conf in
-            findPackageModule_ hsc_env (mkModule pkgid mod_name) pkg_conf
+            findPackageModule_ hsc_env (mkModule pkgid mod_name') pkg_conf
 
          | otherwise           -- Found in more than one place
-         -> return (FoundMultiple (map (packageConfigId.fst) found_exposed))
+         -> return (FoundMultiple (map (packageConfigId.modConfPkg)
+                                       found_visible))
          where
+           found = eltsUFM found'
            for_this_pkg  = case mb_pkg of
                              Nothing -> found
-                             Just p  -> filter ((`matches` p) . fst) found
-           found_exposed = filter is_exposed for_this_pkg
-           is_exposed (pkg_conf,exposed_mod) = exposed pkg_conf && exposed_mod
+                             Just p  -> filter ((`matches` p).modConfPkg) found
+           found_visible = filter modConfVisible for_this_pkg
 
+           -- NB: _vis is guaranteed to be False; a non-exposed module
+           -- can never be visible.
            mod_hiddens = [ packageConfigId pkg_conf
-                         | (pkg_conf,False) <- found ]
+                         | ModConf _ pkg_conf False _vis <- found ]
 
+           -- NB: We /re-report/ non-exposed modules of hidden packages.
            pkg_hiddens = [ packageConfigId pkg_conf
-                         | (pkg_conf,_) <- found, not (exposed pkg_conf) ]
+                         | ModConf _ pkg_conf _ False <- found
+                         , not (exposed pkg_conf) ]
 
            pkg_conf  `matches` pkg
               = case packageName pkg_conf of
@@ -229,10 +238,10 @@ modLocationCache hsc_env mod do_this = do
      Just loc -> return (Found loc mod)
      Nothing  -> do
         result <- do_this
-       case result of
-           Found loc mod -> addToModLocationCache (hsc_MLC hsc_env) mod loc
-           _other -> return ()
-       return result
+        case result of
+            Found loc mod -> addToModLocationCache (hsc_MLC hsc_env) mod loc
+            _other -> return ()
+        return result
   where
     mlc = hsc_MLC hsc_env
 
@@ -250,7 +259,7 @@ uncacheModule hsc_env mod = do
   removeFromModLocationCache (hsc_MLC hsc_env) (mkModule this_pkg mod)
 
 -- -----------------------------------------------------------------------------
---     The internal workers
+--      The internal workers
 
 -- | Search for a module in the home package only.
 findHomeModule :: HscEnv -> ModuleName -> IO FindResult
@@ -262,60 +271,58 @@ findHomeModule hsc_env mod_name =
      hisuf = hiSuf dflags
      mod = mkModule (thisPackage dflags) mod_name
 
-     source_exts = 
+     source_exts =
       [ ("hs",   mkHomeModLocationSearched dflags mod_name "hs")
       , ("lhs",  mkHomeModLocationSearched dflags mod_name "lhs")
       ]
-     
-     hi_exts = [ (hisuf,               mkHiOnlyModLocation dflags hisuf)
-              , (addBootSuffix hisuf,  mkHiOnlyModLocation dflags hisuf)
-              ]
-     
-       -- In compilation manager modes, we look for source files in the home
-       -- package because we can compile these automatically.  In one-shot
-       -- compilation mode we look for .hi and .hi-boot files only.
+
+     hi_exts = [ (hisuf,                mkHiOnlyModLocation dflags hisuf)
+               , (addBootSuffix hisuf,  mkHiOnlyModLocation dflags hisuf)
+               ]
+
+        -- In compilation manager modes, we look for source files in the home
+        -- package because we can compile these automatically.  In one-shot
+        -- compilation mode we look for .hi and .hi-boot files only.
      exts | isOneShot (ghcMode dflags) = hi_exts
-          | otherwise                 = source_exts
+          | otherwise                  = source_exts
    in
 
   -- special case for GHC.Prim; we won't find it in the filesystem.
   -- This is important only when compiling the base package (where GHC.Prim
   -- is a home module).
-  if mod == gHC_PRIM 
+  if mod == gHC_PRIM
         then return (Found (error "GHC.Prim ModLocation") mod)
-        else 
-
-   searchPathExts home_path mod exts
+        else searchPathExts home_path mod exts
 
 
 -- | Search for a module in external packages only.
 findPackageModule :: HscEnv -> Module -> IO FindResult
 findPackageModule hsc_env mod = do
   let
-       dflags = hsc_dflags hsc_env
-       pkg_id = modulePackageId mod
-       pkg_map = pkgIdMap (pkgState dflags)
+        dflags = hsc_dflags hsc_env
+        pkg_id = modulePackageKey mod
+        pkg_map = pkgIdMap (pkgState dflags)
   --
   case lookupPackage pkg_map pkg_id of
      Nothing -> return (NoPackage pkg_id)
      Just pkg_conf -> findPackageModule_ hsc_env mod pkg_conf
-      
+
 findPackageModule_ :: HscEnv -> Module -> PackageConfig -> IO FindResult
-findPackageModule_ hsc_env mod pkg_conf = 
+findPackageModule_ hsc_env mod pkg_conf =
   modLocationCache hsc_env mod $
 
   -- special case for GHC.Prim; we won't find it in the filesystem.
-  if mod == gHC_PRIM 
+  if mod == gHC_PRIM
         then return (Found (error "GHC.Prim ModLocation") mod)
-        else 
+        else
 
   let
      dflags = hsc_dflags hsc_env
      tag = buildTag dflags
 
-          -- hi-suffix for packages depends on the build tag.
+           -- hi-suffix for packages depends on the build tag.
      package_hisuf | null tag  = "hi"
-                  | otherwise = tag ++ "_hi"
+                   | otherwise = tag ++ "_hi"
 
      mk_hi_loc = mkHiOnlyModLocation dflags package_hisuf
 
@@ -337,52 +344,52 @@ findPackageModule_ hsc_env mod pkg_conf =
 -- General path searching
 
 searchPathExts
-  :: [FilePath]                -- paths to search
-  -> Module            -- module name
+  :: [FilePath]         -- paths to search
+  -> Module             -- module name
   -> [ (
-       FileExt,                                -- suffix
-       FilePath -> BaseName -> IO ModLocation  -- action
+        FileExt,                                -- suffix
+        FilePath -> BaseName -> IO ModLocation  -- action
        )
-     ] 
+     ]
   -> IO FindResult
 
-searchPathExts paths mod exts 
+searchPathExts paths mod exts
    = do result <- search to_search
 {-
-       hPutStrLn stderr (showSDoc $
-               vcat [text "Search" <+> ppr mod <+> sep (map (text. fst) exts)
-                   , nest 2 (vcat (map text paths))
-                   , case result of
-                       Succeeded (loc, p) -> text "Found" <+> ppr loc
-                       Failed fs          -> text "not found"])
--}     
-       return result
+        hPutStrLn stderr (showSDoc $
+                vcat [text "Search" <+> ppr mod <+> sep (map (text. fst) exts)
+                    , nest 2 (vcat (map text paths))
+                    , case result of
+                        Succeeded (loc, p) -> text "Found" <+> ppr loc
+                        Failed fs          -> text "not found"])
+-}
+        return result
 
   where
     basename = moduleNameSlashes (moduleName mod)
 
     to_search :: [(FilePath, IO ModLocation)]
     to_search = [ (file, fn path basename)
-               | path <- paths, 
-                 (ext,fn) <- exts,
-                 let base | path == "." = basename
-                          | otherwise   = path </> basename
-                     file = base <.> ext
-               ]
+                | path <- paths,
+                  (ext,fn) <- exts,
+                  let base | path == "." = basename
+                           | otherwise   = path </> basename
+                      file = base <.> ext
+                ]
 
     search [] = return (NotFound { fr_paths = map fst to_search
-                                 , fr_pkg   = Just (modulePackageId mod)
+                                 , fr_pkg   = Just (modulePackageKey mod)
                                  , fr_mods_hidden = [], fr_pkgs_hidden = []
                                  , fr_suggestions = [] })
 
     search ((file, mk_result) : rest) = do
       b <- doesFileExist file
-      if b 
-       then do { loc <- mk_result; return (Found loc mod) }
-       else search rest
+      if b
+        then do { loc <- mk_result; return (Found loc mod) }
+        else search rest
 
 mkHomeModLocationSearched :: DynFlags -> ModuleName -> FileExt
-                         -> FilePath -> BaseName -> IO ModLocation
+                          -> FilePath -> BaseName -> IO ModLocation
 mkHomeModLocationSearched dflags mod suff path basename = do
    mkHomeModLocation2 dflags mod (path </> basename) suff
 
@@ -417,7 +424,7 @@ mkHomeModLocationSearched dflags mod suff path basename = do
 --      (b) and (c): The filename of the source file, minus its extension
 --
 -- ext
---     The filename extension of the source file (usually "hs" or "lhs").
+--      The filename extension of the source file (usually "hs" or "lhs").
 
 mkHomeModLocation :: DynFlags -> ModuleName -> FilePath -> IO ModLocation
 mkHomeModLocation dflags mod src_filename = do
@@ -425,67 +432,65 @@ mkHomeModLocation dflags mod src_filename = do
    mkHomeModLocation2 dflags mod basename extension
 
 mkHomeModLocation2 :: DynFlags
-                  -> ModuleName
-                  -> FilePath  -- Of source module, without suffix
-                  -> String    -- Suffix
-                  -> IO ModLocation
+                   -> ModuleName
+                   -> FilePath  -- Of source module, without suffix
+                   -> String    -- Suffix
+                   -> IO ModLocation
 mkHomeModLocation2 dflags mod src_basename ext = do
    let mod_basename = moduleNameSlashes mod
 
-   obj_fn  <- mkObjPath  dflags src_basename mod_basename
-   hi_fn   <- mkHiPath   dflags src_basename mod_basename
+       obj_fn = mkObjPath  dflags src_basename mod_basename
+       hi_fn  = mkHiPath   dflags src_basename mod_basename
 
    return (ModLocation{ ml_hs_file   = Just (src_basename <.> ext),
-                       ml_hi_file   = hi_fn,
-                       ml_obj_file  = obj_fn })
+                        ml_hi_file   = hi_fn,
+                        ml_obj_file  = obj_fn })
 
 mkHiOnlyModLocation :: DynFlags -> Suffix -> FilePath -> String
-                   -> IO ModLocation
+                    -> IO ModLocation
 mkHiOnlyModLocation dflags hisuf path basename
  = do let full_basename = path </> basename
-      obj_fn  <- mkObjPath  dflags full_basename basename
+          obj_fn = mkObjPath  dflags full_basename basename
       return ModLocation{    ml_hs_file   = Nothing,
-                            ml_hi_file   = full_basename <.> hisuf,
-                               -- Remove the .hi-boot suffix from
-                               -- hi_file, if it had one.  We always
-                               -- want the name of the real .hi file
-                               -- in the ml_hi_file field.
-                            ml_obj_file  = obj_fn
+                             ml_hi_file   = full_basename <.> hisuf,
+                                -- Remove the .hi-boot suffix from
+                                -- hi_file, if it had one.  We always
+                                -- want the name of the real .hi file
+                                -- in the ml_hi_file field.
+                             ml_obj_file  = obj_fn
                   }
 
 -- | Constructs the filename of a .o file for a given source file.
 -- Does /not/ check whether the .o file exists
 mkObjPath
   :: DynFlags
-  -> FilePath          -- the filename of the source file, minus the extension
-  -> String            -- the module name with dots replaced by slashes
-  -> IO FilePath
-mkObjPath dflags basename mod_basename
-  = do  let
-               odir = objectDir dflags
-               osuf = objectSuf dflags
-       
-               obj_basename | Just dir <- odir = dir </> mod_basename
-                            | otherwise        = basename
-
-        return (obj_basename <.> osuf)
+  -> FilePath           -- the filename of the source file, minus the extension
+  -> String             -- the module name with dots replaced by slashes
+  -> FilePath
+mkObjPath dflags basename mod_basename = obj_basename <.> osuf
+  where
+                odir = objectDir dflags
+                osuf = objectSuf dflags
+
+                obj_basename | Just dir <- odir = dir </> mod_basename
+                             | otherwise        = basename
+
 
 -- | Constructs the filename of a .hi file for a given source file.
 -- Does /not/ check whether the .hi file exists
 mkHiPath
   :: DynFlags
-  -> FilePath          -- the filename of the source file, minus the extension
-  -> String            -- the module name with dots replaced by slashes
-  -> IO FilePath
-mkHiPath dflags basename mod_basename
-  = do  let
-               hidir = hiDir dflags
-               hisuf = hiSuf dflags
+  -> FilePath           -- the filename of the source file, minus the extension
+  -> String             -- the module name with dots replaced by slashes
+  -> FilePath
+mkHiPath dflags basename mod_basename = hi_basename <.> hisuf
+ where
+                hidir = hiDir dflags
+                hisuf = hiSuf dflags
 
-               hi_basename | Just dir <- hidir = dir </> mod_basename
-                           | otherwise         = basename
+                hi_basename | Just dir <- hidir = dir </> mod_basename
+                            | otherwise         = basename
 
-        return (hi_basename <.> hisuf)
 
 
 -- -----------------------------------------------------------------------------
@@ -498,14 +503,14 @@ mkStubPaths
   :: DynFlags
   -> ModuleName
   -> ModLocation
-  -> (FilePath,FilePath,FilePath)
+  -> FilePath
 
 mkStubPaths dflags mod location
   = let
         stubdir = stubDir dflags
 
         mod_basename = moduleNameSlashes mod
-        src_basename = dropExtension $ expectJust "mkStubPaths" 
+        src_basename = dropExtension $ expectJust "mkStubPaths"
                                                   (ml_hs_file location)
 
         stub_basename0
@@ -513,37 +518,27 @@ mkStubPaths dflags mod location
             | otherwise           = src_basename
 
         stub_basename = stub_basename0 ++ "_stub"
-
-        obj  = ml_obj_file location
-        osuf = objectSuf dflags
-        stub_obj_base = dropTail (length osuf + 1) obj ++ "_stub"
-                        -- NB. not takeFileName, see #3093
      in
-        (stub_basename <.> "c",
-         stub_basename <.> "h",
-         stub_obj_base <.> objectSuf dflags)
+        stub_basename <.> "h"
 
 -- -----------------------------------------------------------------------------
--- findLinkable isn't related to the other stuff in here, 
+-- findLinkable isn't related to the other stuff in here,
 -- but there's no other obvious place for it
 
 findObjectLinkableMaybe :: Module -> ModLocation -> IO (Maybe Linkable)
 findObjectLinkableMaybe mod locn
    = do let obj_fn = ml_obj_file locn
-       maybe_obj_time <- modificationTimeIfExists obj_fn
-       case maybe_obj_time of
-         Nothing -> return Nothing
-         Just obj_time -> liftM Just (findObjectLinkable mod obj_fn obj_time)
+        maybe_obj_time <- modificationTimeIfExists obj_fn
+        case maybe_obj_time of
+          Nothing -> return Nothing
+          Just obj_time -> liftM Just (findObjectLinkable mod obj_fn obj_time)
 
 -- Make an object linkable when we know the object file exists, and we know
 -- its modification time.
-findObjectLinkable :: Module -> FilePath -> ClockTime -> IO Linkable
-findObjectLinkable mod obj_fn obj_time = do
-  let stub_fn = (dropExtension obj_fn ++ "_stub") <.> "o"
-  stub_exist <- doesFileExist stub_fn
-  if stub_exist
-       then return (LM obj_time mod [DotO obj_fn, DotO stub_fn])
-       else return (LM obj_time mod [DotO obj_fn])
+findObjectLinkable :: Module -> FilePath -> UTCTime -> IO Linkable
+findObjectLinkable mod obj_fn obj_time = return (LM obj_time mod [DotO obj_fn])
+  -- We used to look for _stub.o files here, but that was a bug (#706)
+  -- Now GHC merges the stub.o into the main .o (#3687)
 
 -- -----------------------------------------------------------------------------
 -- Error messages
@@ -561,7 +556,7 @@ cantFindErr :: LitString -> LitString -> DynFlags -> ModuleName -> FindResult
 cantFindErr _ multiple_found _ mod_name (FoundMultiple pkgs)
   = hang (ptext multiple_found <+> quotes (ppr mod_name) <> colon) 2 (
        sep [ptext (sLit "it was found in multiple packages:"),
-               hsep (map (text.packageIdString) pkgs)]
+                hsep (map (text.packageKeyString) pkgs)]
     )
 cantFindErr cannot_find _ dflags mod_name find_result
   = ptext cannot_find <+> quotes (ppr mod_name)
@@ -572,15 +567,15 @@ cantFindErr cannot_find _ dflags mod_name find_result
 
     more_info
       = case find_result of
-           NoPackage pkg
-               -> ptext (sLit "no package matching") <+> quotes (ppr pkg) <+>
-                  ptext (sLit "was found")
+            NoPackage pkg
+                -> ptext (sLit "no package matching") <+> quotes (ppr pkg) <+>
+                   ptext (sLit "was found")
 
             NotFound { fr_paths = files, fr_pkg = mb_pkg
                      , fr_mods_hidden = mod_hiddens, fr_pkgs_hidden = pkg_hiddens
                      , fr_suggestions = suggest }
-               | Just pkg <- mb_pkg, pkg /= thisPackage dflags
-               -> not_found_in_package pkg files
+                | Just pkg <- mb_pkg, pkg /= thisPackage dflags
+                -> not_found_in_package pkg files
 
                 | not (null suggest)
                 -> pp_suggestions suggest $$ tried_these files
@@ -588,8 +583,8 @@ cantFindErr cannot_find _ dflags mod_name find_result
                 | null files && null mod_hiddens && null pkg_hiddens
                 -> ptext (sLit "It is not a module in the current program, or in any known package.")
 
-               | otherwise
-               -> vcat (map pkg_hidden pkg_hiddens) $$
+                | otherwise
+                -> vcat (map pkg_hidden pkg_hiddens) $$
                    vcat (map mod_hidden mod_hiddens) $$
                    tried_these files
 
@@ -616,16 +611,16 @@ cantFindErr cannot_find _ dflags mod_name find_result
     tried_these files
         | null files = empty
         | verbosity dflags < 3 =
-             ptext (sLit "Use -v to see a list of the files searched for.")
+              ptext (sLit "Use -v to see a list of the files searched for.")
         | otherwise =
                hang (ptext (sLit "Locations searched:")) 2 $ vcat (map text files)
-        
+
     pkg_hidden pkg =
         ptext (sLit "It is a member of the hidden package") <+> quotes (ppr pkg)
         <> dot $$ cabal_pkg_hidden_hint pkg
     cabal_pkg_hidden_hint pkg
-     | dopt Opt_BuildingCabalPackage dflags
-        = case simpleParse (packageIdString pkg) of
+     | gopt Opt_BuildingCabalPackage dflags
+        = case simpleParse (packageKeyString pkg) of
           Just pid ->
               ptext (sLit "Perhaps you need to add") <+>
               quotes (text (display (pkgName pid))) <+>
@@ -645,13 +640,13 @@ cantFindErr cannot_find _ dflags mod_name find_result
       where
         (exposed_sugs, hidden_sugs) = partition from_exposed_pkg sugs
 
-    from_exposed_pkg m = case lookupPackage pkg_map (modulePackageId m) of
+    from_exposed_pkg m = case lookupPackage pkg_map (modulePackageKey m) of
                             Just pkg_config -> exposed pkg_config
                             Nothing         -> WARN( True, ppr m ) -- Should not happen
                                                False
 
     pp_exp mod = ppr (moduleName mod)
-                 <+> parens (ptext (sLit "from") <+> ppr (modulePackageId mod))
+                 <+> parens (ptext (sLit "from") <+> ppr (modulePackageKey mod))
     pp_hid mod = ppr (moduleName mod)
-                 <+> parens (ptext (sLit "needs flag -package") <+> ppr (modulePackageId mod))
+                 <+> parens (ptext (sLit "needs flag -package") <+> ppr (modulePackageKey mod))
 \end{code}