Module reexports, fixing #8407.
[ghc.git] / compiler / main / Finder.lhs
index ac0eff8..37395ce 100644 (file)
@@ -4,6 +4,8 @@
 \section[Finder]{Module Finder}
 
 \begin{code}
+{-# LANGUAGE CPP #-}
+
 module Finder (
     flushFinderCaches,
     FindResult(..),
@@ -26,30 +28,32 @@ module Finder (
 
   ) where
 
+#include "HsVersions.h"
+
 import Module
 import HscTypes
 import Packages
 import FastString
 import Util
 import PrelNames        ( gHC_PRIM )
-import DynFlags                ( DynFlags(..), isOneShot, GhcMode(..) )
+import DynFlags
 import Outputable
-import FiniteMap
-import LazyUniqFM
-import Maybes          ( expectJust )
+import UniqFM
+import Maybes           ( expectJust )
+import Exception        ( evaluate )
 
-import Distribution.Package hiding (PackageId)
-import Data.IORef      ( IORef, writeIORef, readIORef, modifyIORef )
-import Data.List
+import Distribution.Text
+import Distribution.Package
+import Data.IORef       ( IORef, writeIORef, readIORef, atomicModifyIORef )
 import System.Directory
 import System.FilePath
-import System.IO
 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
@@ -68,35 +72,40 @@ type BaseName = String      -- Basename of file
 -- assumed to not move around during a session.
 flushFinderCaches :: HscEnv -> IO ()
 flushFinderCaches hsc_env = do
+  -- Ideally the update to both caches be a single atomic operation.
   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
-  fm <- readIORef ref
-  writeIORef ref $! filterFM is_ext fm
+  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 = modifyIORef ref $ \c -> addToUFM c key val
+addToFinderCache ref key val =
+  atomicModifyIORef ref $ \c -> (addToUFM c key val, ())
 
 addToModLocationCache :: IORef ModLocationCache -> Module -> ModLocation -> IO ()
-addToModLocationCache  ref key val = modifyIORef ref $ \c -> addToFM c key val
+addToModLocationCache ref key val =
+  atomicModifyIORef ref $ \c -> (extendModuleEnv c key val, ())
 
 removeFromFinderCache :: IORef FinderCache -> ModuleName -> IO ()
-removeFromFinderCache      ref key = modifyIORef ref $ \c -> delFromUFM c key
+removeFromFinderCache ref key =
+  atomicModifyIORef ref $ \c -> (delFromUFM c key, ())
 
 removeFromModLocationCache :: IORef ModLocationCache -> Module -> IO ()
-removeFromModLocationCache ref key = modifyIORef ref $ \c -> delFromFM c key
+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
 
@@ -104,7 +113,7 @@ lookupModLocationCache :: IORef ModLocationCache -> Module
                        -> IO (Maybe ModLocation)
 lookupModLocationCache ref key = do
    c <- readIORef ref
-   return $! lookupFM c key
+   return $! lookupModuleEnv c key
 
 -- -----------------------------------------------------------------------------
 -- The two external entry points
@@ -118,97 +127,109 @@ 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
 
 orIfNotFound :: IO FindResult -> IO FindResult -> IO FindResult
-this `orIfNotFound` or_this = do
+orIfNotFound this or_this = do
   res <- this
   case res of
-    NotFound places1 _mb_pkg1 mod_hiddens1 pkg_hiddens1 -> do
-       res2 <- or_this
-       case res2 of
-          NotFound places2 mb_pkg2 mod_hiddens2 pkg_hiddens2 -> 
-              return (NotFound (places1 ++ places2)
-                               mb_pkg2 -- snd arg is the package search
-                               (mod_hiddens1 ++ mod_hiddens2)
-                               (pkg_hiddens1 ++ pkg_hiddens2))
-          _other -> return res2
+    NotFound { fr_paths = paths1, fr_mods_hidden = mh1
+             , fr_pkgs_hidden = ph1, fr_suggestions = s1 }
+     -> do res2 <- or_this
+           case res2 of
+             NotFound { fr_paths = paths2, fr_pkg = mb_pkg2, fr_mods_hidden = mh2
+                      , fr_pkgs_hidden = ph2, fr_suggestions = s2 }
+              -> return (NotFound { fr_paths = paths1 ++ paths2
+                                  , fr_pkg = mb_pkg2 -- snd arg is the package search
+                                  , fr_mods_hidden = mh1 ++ mh2
+                                  , fr_pkgs_hidden = ph1 ++ ph2
+                                  , fr_suggestions = s1  ++ s2 })
+             _other -> return res2
     _other -> return res
 
 
 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
 findExposedPackageModule hsc_env mod_name mb_pkg
         -- not found in any package:
-  | null found_exposed = return (NotFound [] Nothing mod_hiddens pkg_hiddens)
-        -- found in just one exposed package:
-  | [(pkg_conf, _)] <- found_exposed
-        = let pkgid = mkPackageId (package pkg_conf) in      
-          findPackageModule_ hsc_env (mkModule pkgid mod_name) pkg_conf
-  | otherwise
-        = return (FoundMultiple (map (mkPackageId.package.fst) found_exposed))
-  where
-       dflags = hsc_dflags hsc_env
-        found = lookupModuleInAllPackages dflags mod_name
-
-        for_this_pkg = filter ((`matches` mb_pkg) . fst) found
-
-        found_exposed = [ (pkg_conf,exposed_mod) 
-                        | x@(pkg_conf,exposed_mod) <- for_this_pkg,
-                          is_exposed x ]
-
-        is_exposed (pkg_conf,exposed_mod) = exposed pkg_conf && exposed_mod
-
-        mod_hiddens = [ mkPackageId (package pkg_conf)
-                      | (pkg_conf,False) <- found ]
-
-        pkg_hiddens = [ mkPackageId (package pkg_conf)
-                      | (pkg_conf,_) <- found, not (exposed pkg_conf) ]
-
-        _pkg_conf `matches` Nothing  = True
-        pkg_conf  `matches` Just pkg =
-           case packageName pkg_conf of 
-              PackageName n -> pkg == mkFastString n
-
+  = 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_suggestions = suggest })
+       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_suggestions = [] })
+
+         | [ModConf mod_name' pkg_conf _ _] <- found_visible -- Found uniquely
+         -> let pkgid = packageConfigId pkg_conf in
+            findPackageModule_ hsc_env (mkModule pkgid mod_name') pkg_conf
+
+         | otherwise           -- Found in more than one place
+         -> 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).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
+                         | ModConf _ pkg_conf False _vis <- found ]
+
+           -- NB: We /re-report/ non-exposed modules of hidden packages.
+           pkg_hiddens = [ packageConfigId pkg_conf
+                         | ModConf _ pkg_conf _ False <- found
+                         , not (exposed pkg_conf) ]
+
+           pkg_conf  `matches` pkg
+              = case packageName pkg_conf of
+                  PackageName n -> pkg == mkFastString n
 
 modLocationCache :: HscEnv -> Module -> IO FindResult -> IO FindResult
 modLocationCache hsc_env mod do_this = do
@@ -217,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
 
@@ -238,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
@@ -250,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
 
@@ -325,49 +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
-               ]
-
-    search [] = return (NotFound (map fst to_search) (Just (modulePackageId mod))
-                        [] [])
+                | 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 (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
 
@@ -402,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
@@ -410,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)
 
 
 -- -----------------------------------------------------------------------------
@@ -483,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
@@ -498,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
@@ -546,34 +556,39 @@ 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
-  = hang (ptext cannot_find <+> quotes (ppr mod_name) <> colon)
-       2 more_info
+  = ptext cannot_find <+> quotes (ppr mod_name)
+    $$ more_info
   where
+    pkg_map :: PackageConfigMap
+    pkg_map = pkgIdMap (pkgState dflags)
+
     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
 
-           NotFound files mb_pkg mod_hiddens pkg_hiddens
-               | Just pkg <- mb_pkg, pkg /= thisPackage dflags
-               -> not_found_in_package pkg files
+                | not (null suggest)
+                -> pp_suggestions suggest $$ tried_these files
 
                 | null files && null mod_hiddens && null pkg_hiddens
-               -> ptext (sLit "it is not a module in the current program, or in any known package.")
+                -> ptext (sLit "It is not a module in the current program, or in any known package.")
 
-               | otherwise
-               -> vcat (map pkg_hidden pkg_hiddens) $$
-                   vcat (map mod_hidden mod_hiddens) $$ 
+                | otherwise
+                -> vcat (map pkg_hidden pkg_hiddens) $$
+                   vcat (map mod_hidden mod_hiddens) $$
                    tried_these files
 
-           NotFoundInPackage pkg
-               -> ptext (sLit "it is not in package") <+> quotes (ppr pkg)
-
-           _ -> panic "cantFindErr"
+            _ -> panic "cantFindErr"
 
     build_tag = buildTag dflags
 
@@ -596,13 +611,42 @@ 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)
-        
+               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)
+        ptext (sLit "It is a member of the hidden package") <+> quotes (ppr pkg)
+        <> dot $$ cabal_pkg_hidden_hint pkg
+    cabal_pkg_hidden_hint pkg
+     | gopt Opt_BuildingCabalPackage dflags
+        = case simpleParse (packageKeyString pkg) of
+          Just pid ->
+              ptext (sLit "Perhaps you need to add") <+>
+              quotes (text (display (pkgName pid))) <+>
+              ptext (sLit "to the build-depends in your .cabal file.")
+          Nothing -> empty
+     | otherwise = empty
 
     mod_hidden pkg =
         ptext (sLit "it is a hidden module in the package") <+> quotes (ppr pkg)
+
+    pp_suggestions :: [Module] -> SDoc
+    pp_suggestions sugs
+      | null sugs = empty
+      | otherwise = hang (ptext (sLit "Perhaps you meant"))
+                       2 (vcat [ vcat (map pp_exp exposed_sugs)
+                               , vcat (map pp_hid hidden_sugs) ])
+      where
+        (exposed_sugs, hidden_sugs) = partition from_exposed_pkg sugs
+
+    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 (modulePackageKey mod))
+    pp_hid mod = ppr (moduleName mod)
+                 <+> parens (ptext (sLit "needs flag -package") <+> ppr (modulePackageKey mod))
 \end{code}