%
% (c) The University of Glasgow, 2000-2006
%
\section[Finder]{Module Finder}
\begin{code}
module Finder (
flushFinderCaches,
FindResult(..),
findImportedModule,
findExactModule,
findHomeModule,
findExposedPackageModule,
mkHomeModLocation,
mkHomeModLocation2,
mkHiOnlyModLocation,
addHomeModuleToFinder,
uncacheModule,
mkStubPaths,
findObjectLinkableMaybe,
findObjectLinkable,
cannotFindModule,
cannotFindInterface,
) where
import Module
import HscTypes
import Packages
import FastString
import Util
import PrelNames ( gHC_PRIM )
import DynFlags
import Outputable
import UniqFM
import Maybes ( expectJust )
import Exception ( evaluate )
import Distribution.Text
import Distribution.Package hiding (PackageId)
import Data.IORef ( IORef, writeIORef, readIORef, atomicModifyIORef )
import System.Directory
import System.FilePath
import Control.Monad
import System.Time ( ClockTime )
type FileExt = String
type BaseName = String
flushFinderCaches :: HscEnv -> IO ()
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
flushModLocationCache :: PackageId -> 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
addToFinderCache :: IORef FinderCache -> ModuleName -> FindResult -> IO ()
addToFinderCache ref key val =
atomicModifyIORef ref $ \c -> (addToUFM c key val, ())
addToModLocationCache :: IORef ModLocationCache -> Module -> ModLocation -> IO ()
addToModLocationCache ref key val =
atomicModifyIORef ref $ \c -> (extendModuleEnv c key val, ())
removeFromFinderCache :: IORef FinderCache -> ModuleName -> IO ()
removeFromFinderCache ref key =
atomicModifyIORef ref $ \c -> (delFromUFM c key, ())
removeFromModLocationCache :: IORef ModLocationCache -> Module -> IO ()
removeFromModLocationCache ref key =
atomicModifyIORef ref $ \c -> (delModuleEnv c key, ())
lookupFinderCache :: IORef FinderCache -> ModuleName -> IO (Maybe FindResult)
lookupFinderCache ref key = do
c <- readIORef ref
return $! lookupUFM c key
lookupModLocationCache :: IORef ModLocationCache -> Module
-> IO (Maybe ModLocation)
lookupModLocationCache ref key = do
c <- readIORef ref
return $! lookupModuleEnv c key
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
| 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
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
orIfNotFound :: IO FindResult -> IO FindResult -> IO FindResult
this `orIfNotFound` 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
(mod_hiddens1 ++ mod_hiddens2)
(pkg_hiddens1 ++ pkg_hiddens2))
_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
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
findExposedPackageModule :: HscEnv -> ModuleName -> Maybe FastString
-> IO FindResult
findExposedPackageModule hsc_env mod_name mb_pkg
| null found_exposed = return (NotFound [] Nothing mod_hiddens pkg_hiddens)
| [(pkg_conf, _)] <- found_exposed
= let pkgid = packageConfigId pkg_conf in
findPackageModule_ hsc_env (mkModule pkgid mod_name) pkg_conf
| otherwise
= return (FoundMultiple (map (packageConfigId.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 = [ packageConfigId pkg_conf
| (pkg_conf,False) <- found ]
pkg_hiddens = [ packageConfigId 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
modLocationCache :: HscEnv -> Module -> IO FindResult -> IO FindResult
modLocationCache hsc_env mod do_this = do
mb_loc <- lookupModLocationCache mlc mod
case mb_loc of
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
where
mlc = hsc_MLC hsc_env
addHomeModuleToFinder :: HscEnv -> ModuleName -> ModLocation -> IO Module
addHomeModuleToFinder hsc_env mod_name loc = do
let mod = mkModule (thisPackage (hsc_dflags hsc_env)) mod_name
addToFinderCache (hsc_FC hsc_env) mod_name (Found loc mod)
addToModLocationCache (hsc_MLC hsc_env) mod loc
return mod
uncacheModule :: HscEnv -> ModuleName -> IO ()
uncacheModule hsc_env mod = do
let this_pkg = thisPackage (hsc_dflags hsc_env)
removeFromFinderCache (hsc_FC hsc_env) mod
removeFromModLocationCache (hsc_MLC hsc_env) (mkModule this_pkg mod)
findHomeModule :: HscEnv -> ModuleName -> IO FindResult
findHomeModule hsc_env mod_name =
homeSearchCache hsc_env mod_name $
let
dflags = hsc_dflags hsc_env
home_path = importPaths dflags
hisuf = hiSuf dflags
mod = mkModule (thisPackage dflags) mod_name
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)
]
exts | isOneShot (ghcMode dflags) = hi_exts
| otherwise = source_exts
in
if mod == gHC_PRIM
then return (Found (error "GHC.Prim ModLocation") mod)
else
searchPathExts home_path mod exts
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)
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 =
modLocationCache hsc_env mod $
if mod == gHC_PRIM
then return (Found (error "GHC.Prim ModLocation") mod)
else
let
dflags = hsc_dflags hsc_env
tag = buildTag dflags
package_hisuf | null tag = "hi"
| otherwise = tag ++ "_hi"
mk_hi_loc = mkHiOnlyModLocation dflags package_hisuf
import_dirs = importDirs pkg_conf
in
case import_dirs of
[one] | MkDepend <- ghcMode dflags -> do
let basename = moduleNameSlashes (moduleName mod)
loc <- mk_hi_loc one basename
return (Found loc mod)
_otherwise ->
searchPathExts import_dirs mod [(package_hisuf, mk_hi_loc)]
searchPathExts
:: [FilePath]
-> Module
-> [ (
FileExt,
FilePath -> BaseName -> IO ModLocation
)
]
-> IO FindResult
searchPathExts paths mod exts
= do result <- search to_search
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))
[] [])
search ((file, mk_result) : rest) = do
b <- doesFileExist file
if b
then do { loc <- mk_result; return (Found loc mod) }
else search rest
mkHomeModLocationSearched :: DynFlags -> ModuleName -> FileExt
-> FilePath -> BaseName -> IO ModLocation
mkHomeModLocationSearched dflags mod suff path basename = do
mkHomeModLocation2 dflags mod (path </> basename) suff
mkHomeModLocation :: DynFlags -> ModuleName -> FilePath -> IO ModLocation
mkHomeModLocation dflags mod src_filename = do
let (basename,extension) = splitExtension src_filename
mkHomeModLocation2 dflags mod basename extension
mkHomeModLocation2 :: DynFlags
-> ModuleName
-> FilePath
-> String
-> 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
return (ModLocation{ ml_hs_file = Just (src_basename <.> ext),
ml_hi_file = hi_fn,
ml_obj_file = obj_fn })
mkHiOnlyModLocation :: DynFlags -> Suffix -> FilePath -> String
-> IO ModLocation
mkHiOnlyModLocation dflags hisuf path basename
= do let full_basename = path </> basename
obj_fn <- mkObjPath dflags full_basename basename
return ModLocation{ ml_hs_file = Nothing,
ml_hi_file = full_basename <.> hisuf,
ml_obj_file = obj_fn
}
mkObjPath
:: DynFlags
-> FilePath
-> String
-> 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)
mkHiPath
:: DynFlags
-> FilePath
-> String
-> IO FilePath
mkHiPath dflags basename mod_basename
= do let
hidir = hiDir dflags
hisuf = hiSuf dflags
hi_basename | Just dir <- hidir = dir </> mod_basename
| otherwise = basename
return (hi_basename <.> hisuf)
mkStubPaths
:: DynFlags
-> ModuleName
-> ModLocation
-> (FilePath,FilePath,FilePath)
mkStubPaths dflags mod location
= let
stubdir = stubDir dflags
mod_basename = moduleNameSlashes mod
src_basename = dropExtension $ expectJust "mkStubPaths"
(ml_hs_file location)
stub_basename0
| Just dir <- stubdir = dir </> mod_basename
| 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"
in
(stub_basename <.> "c",
stub_basename <.> "h",
stub_obj_base <.> objectSuf dflags)
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)
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])
cannotFindModule :: DynFlags -> ModuleName -> FindResult -> SDoc
cannotFindModule = cantFindErr (sLit "Could not find module")
(sLit "Ambiguous module name")
cannotFindInterface :: DynFlags -> ModuleName -> FindResult -> SDoc
cannotFindInterface = cantFindErr (sLit "Failed to load interface for")
(sLit "Ambiguous interface for")
cantFindErr :: LitString -> LitString -> DynFlags -> ModuleName -> FindResult
-> SDoc
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)]
)
cantFindErr cannot_find _ dflags mod_name find_result
= hang (ptext cannot_find <+> quotes (ppr mod_name) <> colon)
2 more_info
where
more_info
= case find_result of
NoPackage pkg
-> ptext (sLit "no package matching") <+> quotes (ppr pkg) <+>
ptext (sLit "was found")
NotFound files mb_pkg mod_hiddens pkg_hiddens
| Just pkg <- mb_pkg, pkg /= thisPackage dflags
-> not_found_in_package pkg 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.")
| 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"
build_tag = buildTag dflags
not_found_in_package pkg files
| build_tag /= ""
= let
build = if build_tag == "p" then "profiling"
else "\"" ++ build_tag ++ "\""
in
ptext (sLit "Perhaps you haven't installed the ") <> text build <>
ptext (sLit " libraries for package ") <> quotes (ppr pkg) <> char '?' $$
tried_these files
| otherwise
= ptext (sLit "There are files missing in the ") <> quotes (ppr pkg) <>
ptext (sLit " package,") $$
ptext (sLit "try running 'ghc-pkg check'.") $$
tried_these files
tried_these files
| null files = empty
| verbosity dflags < 3 =
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
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)
\end{code}