remove most warnings
[ghc.git] / compiler / main / Finder.lhs
1 %
2 % (c) The University of Glasgow, 2000-2006
3 %
4 \section[Finder]{Module Finder}
5
6 \begin{code}
7 {-# OPTIONS -w #-}
8 -- The above warning supression flag is a temporary kludge.
9 -- While working on this module you are encouraged to remove it and fix
10 -- any warnings in the module. See
11 --     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
12 -- for details
13
14 module Finder (
15     flushFinderCaches,
16     FindResult(..),
17     findImportedModule,
18     findExactModule,
19     findHomeModule,
20     mkHomeModLocation,
21     mkHomeModLocation2,
22     addHomeModuleToFinder,
23     uncacheModule,
24     mkStubPaths,
25
26     findObjectLinkableMaybe,
27     findObjectLinkable,
28
29     cannotFindModule,
30     cannotFindInterface,
31   ) where
32
33 #include "HsVersions.h"
34
35 import Module
36 import HscTypes
37 import Packages
38 import FastString
39 import Util
40 import PrelNames        ( gHC_PRIM )
41 import DynFlags         ( DynFlags(..), isOneShot, GhcMode(..) )
42 import Outputable
43 import FiniteMap
44 import UniqFM
45 import Maybes           ( expectJust )
46
47 import Data.IORef       ( IORef, writeIORef, readIORef, modifyIORef )
48 import Data.List
49 import System.Directory
50 import System.IO
51 import Control.Monad
52 import System.Time      ( ClockTime )
53
54
55 type FileExt = String   -- Filename extension
56 type BaseName = String  -- Basename of file
57
58 -- -----------------------------------------------------------------------------
59 -- The Finder
60
61 -- The Finder provides a thin filesystem abstraction to the rest of
62 -- the compiler.  For a given module, it can tell you where the
63 -- source, interface, and object files for that module live.
64
65 -- It does *not* know which particular package a module lives in.  Use
66 -- Packages.lookupModuleInAllPackages for that.
67
68 -- -----------------------------------------------------------------------------
69 -- The finder's cache
70
71 -- remove all the home modules from the cache; package modules are
72 -- assumed to not move around during a session.
73 flushFinderCaches :: HscEnv -> IO ()
74 flushFinderCaches hsc_env = do
75   writeIORef fc_ref emptyUFM
76   flushModLocationCache this_pkg mlc_ref
77  where
78         this_pkg = thisPackage (hsc_dflags hsc_env)
79         fc_ref = hsc_FC hsc_env
80         mlc_ref = hsc_MLC hsc_env
81
82 flushModLocationCache :: PackageId -> IORef ModLocationCache -> IO ()
83 flushModLocationCache this_pkg ref = do
84   fm <- readIORef ref
85   writeIORef ref $! filterFM is_ext fm
86   return ()
87   where is_ext mod _ | modulePackageId mod /= this_pkg = True
88                      | otherwise = False
89
90 addToFinderCache :: IORef FinderCache -> ModuleName -> FindResult -> IO ()
91 addToFinderCache       ref key val = modifyIORef ref $ \c -> addToUFM c key val
92
93 addToModLocationCache :: IORef ModLocationCache -> Module -> ModLocation -> IO ()
94 addToModLocationCache  ref key val = modifyIORef ref $ \c -> addToFM c key val
95
96 removeFromFinderCache :: IORef FinderCache -> ModuleName -> IO ()
97 removeFromFinderCache      ref key = modifyIORef ref $ \c -> delFromUFM c key
98
99 removeFromModLocationCache :: IORef ModLocationCache -> Module -> IO ()
100 removeFromModLocationCache ref key = modifyIORef ref $ \c -> delFromFM c key
101
102 lookupFinderCache :: IORef FinderCache -> ModuleName -> IO (Maybe FindResult)
103 lookupFinderCache ref key = do 
104    c <- readIORef ref
105    return $! lookupUFM c key
106
107 lookupModLocationCache :: IORef ModLocationCache -> Module
108                        -> IO (Maybe ModLocation)
109 lookupModLocationCache ref key = do
110    c <- readIORef ref
111    return $! lookupFM c key
112
113 -- -----------------------------------------------------------------------------
114 -- The two external entry points
115
116 -- | Locate a module that was imported by the user.  We have the
117 -- module's name, and possibly a package name.  Without a package
118 -- name, this function will use the search path and the known exposed
119 -- packages to find the module, if a package is specified then only
120 -- that package is searched for the module.
121
122 findImportedModule :: HscEnv -> ModuleName -> Maybe PackageId -> IO FindResult
123 findImportedModule hsc_env mod_name mb_pkgid =
124   case mb_pkgid of
125         Nothing                    -> unqual_import
126         Just pkg | pkg == this_pkg -> home_import
127                  | otherwise       -> pkg_import pkg
128   where
129     dflags = hsc_dflags hsc_env
130     this_pkg = thisPackage dflags
131
132     home_import     = findHomeModule hsc_env mod_name
133
134     pkg_import pkg  = findPackageModule hsc_env (mkModule pkg mod_name)
135                         -- ToDo: this isn't quite right, the module we want
136                         -- might actually be in another package, but re-exposed
137                         -- ToDo: should return NotFoundInPackage if
138                         -- the module isn't exposed by the package.
139
140     unqual_import   = home_import 
141                         `orIfNotFound`
142                       findExposedPackageModule hsc_env mod_name
143
144 -- | Locate a specific 'Module'.  The purpose of this function is to
145 -- create a 'ModLocation' for a given 'Module', that is to find out
146 -- where the files associated with this module live.  It is used when
147 -- reading the interface for a module mentioned by another interface, 
148 -- for example (a "system import").
149
150 findExactModule :: HscEnv -> Module -> IO FindResult
151 findExactModule hsc_env mod =
152    let dflags = hsc_dflags hsc_env in
153    if modulePackageId mod == thisPackage dflags
154         then findHomeModule hsc_env (moduleName mod)
155         else findPackageModule hsc_env mod
156
157 -- -----------------------------------------------------------------------------
158 -- Helpers
159
160 orIfNotFound :: IO FindResult -> IO FindResult -> IO FindResult
161 this `orIfNotFound` or_this = do
162   res <- this
163   case res of
164     NotFound here _ -> do
165         res2 <- or_this
166         case res2 of
167            NotFound or_here pkg -> return (NotFound (here ++ or_here) pkg)
168            _other -> return res2
169     _other -> return res
170
171
172 homeSearchCache :: HscEnv -> ModuleName -> IO FindResult -> IO FindResult
173 homeSearchCache hsc_env mod_name do_this = do
174   m <- lookupFinderCache (hsc_FC hsc_env) mod_name
175   case m of 
176     Just result -> return result
177     Nothing     -> do
178         result <- do_this
179         addToFinderCache (hsc_FC hsc_env) mod_name result
180         case result of
181            Found loc mod -> addToModLocationCache (hsc_MLC hsc_env) mod loc
182            _other        -> return ()
183         return result
184
185 findExposedPackageModule :: HscEnv -> ModuleName -> IO FindResult
186 findExposedPackageModule hsc_env mod_name
187         -- not found in any package:
188   | null found = return (NotFound [] Nothing)
189         -- found in just one exposed package:
190   | [(pkg_conf, _)] <- found_exposed
191         = let pkgid = mkPackageId (package pkg_conf) in      
192           findPackageModule_ hsc_env (mkModule pkgid mod_name) pkg_conf
193         -- not found in any exposed package, report how it was hidden:
194   | null found_exposed, ((pkg_conf, exposed_mod):_) <- found
195         = let pkgid = mkPackageId (package pkg_conf) in
196           if not (exposed_mod)
197                 then return (ModuleHidden pkgid)
198                 else return (PackageHidden pkgid)
199   | otherwise
200         = return (FoundMultiple (map (mkPackageId.package.fst) found_exposed))
201   where
202         dflags = hsc_dflags hsc_env
203         found = lookupModuleInAllPackages dflags mod_name
204         found_exposed = filter is_exposed found
205         is_exposed (pkg_conf,exposed_mod) = exposed pkg_conf && exposed_mod
206
207
208 modLocationCache :: HscEnv -> Module -> IO FindResult -> IO FindResult
209 modLocationCache hsc_env mod do_this = do
210   mb_loc <- lookupModLocationCache mlc mod
211   case mb_loc of
212      Just loc -> return (Found loc mod)
213      Nothing  -> do
214         result <- do_this
215         case result of
216             Found loc mod -> addToModLocationCache (hsc_MLC hsc_env) mod loc
217             _other -> return ()
218         return result
219   where
220     mlc = hsc_MLC hsc_env
221
222 addHomeModuleToFinder :: HscEnv -> ModuleName -> ModLocation -> IO Module
223 addHomeModuleToFinder hsc_env mod_name loc = do
224   let mod = mkModule (thisPackage (hsc_dflags hsc_env)) mod_name
225   addToFinderCache (hsc_FC hsc_env) mod_name (Found loc mod)
226   addToModLocationCache (hsc_MLC hsc_env) mod loc
227   return mod
228
229 uncacheModule :: HscEnv -> ModuleName -> IO ()
230 uncacheModule hsc_env mod = do
231   let this_pkg = thisPackage (hsc_dflags hsc_env)
232   removeFromFinderCache (hsc_FC hsc_env) mod
233   removeFromModLocationCache (hsc_MLC hsc_env) (mkModule this_pkg mod)
234
235 -- -----------------------------------------------------------------------------
236 --      The internal workers
237
238 -- | Search for a module in the home package only.
239 findHomeModule :: HscEnv -> ModuleName -> IO FindResult
240 findHomeModule hsc_env mod_name =
241    homeSearchCache hsc_env mod_name $
242    let 
243      dflags = hsc_dflags hsc_env
244      home_path = importPaths dflags
245      hisuf = hiSuf dflags
246      mod = mkModule (thisPackage dflags) mod_name
247
248      source_exts = 
249       [ ("hs",   mkHomeModLocationSearched dflags mod_name "hs")
250       , ("lhs",  mkHomeModLocationSearched dflags mod_name "lhs")
251       ]
252      
253      hi_exts = [ (hisuf,                mkHiOnlyModLocation dflags hisuf)
254                , (addBootSuffix hisuf,  mkHiOnlyModLocation dflags hisuf)
255                ]
256      
257         -- In compilation manager modes, we look for source files in the home
258         -- package because we can compile these automatically.  In one-shot
259         -- compilation mode we look for .hi and .hi-boot files only.
260      exts | isOneShot (ghcMode dflags) = hi_exts
261           | otherwise                  = source_exts
262    in
263
264   -- special case for GHC.Prim; we won't find it in the filesystem.
265   -- This is important only when compiling the base package (where GHC.Prim
266   -- is a home module).
267   if mod == gHC_PRIM 
268         then return (Found (error "GHC.Prim ModLocation") mod)
269         else 
270
271    searchPathExts home_path mod exts
272
273
274 -- | Search for a module in external packages only.
275 findPackageModule :: HscEnv -> Module -> IO FindResult
276 findPackageModule hsc_env mod = do
277   let
278         dflags = hsc_dflags hsc_env
279         pkg_id = modulePackageId mod
280         pkg_map = pkgIdMap (pkgState dflags)
281   --
282   case lookupPackage pkg_map pkg_id of
283      Nothing -> return (NoPackage pkg_id)
284      Just pkg_conf -> findPackageModule_ hsc_env mod pkg_conf
285       
286 findPackageModule_ :: HscEnv -> Module -> PackageConfig -> IO FindResult
287 findPackageModule_ hsc_env mod pkg_conf = 
288   modLocationCache hsc_env mod $
289
290   -- special case for GHC.Prim; we won't find it in the filesystem.
291   if mod == gHC_PRIM 
292         then return (Found (error "GHC.Prim ModLocation") mod)
293         else 
294
295   let
296      dflags = hsc_dflags hsc_env
297      tag = buildTag dflags
298
299            -- hi-suffix for packages depends on the build tag.
300      package_hisuf | null tag  = "hi"
301                    | otherwise = tag ++ "_hi"
302      hi_exts =
303         [ (package_hisuf, mkHiOnlyModLocation dflags package_hisuf) ]
304
305      source_exts = 
306        [ ("hs",   mkHiOnlyModLocation dflags package_hisuf)
307        , ("lhs",  mkHiOnlyModLocation dflags package_hisuf)
308        ]
309
310      -- mkdependHS needs to look for source files in packages too, so
311      -- that we can make dependencies between package before they have
312      -- been built.
313      exts 
314       | MkDepend <- ghcMode dflags = hi_exts ++ source_exts
315       | otherwise                  = hi_exts
316       -- we never look for a .hi-boot file in an external package;
317       -- .hi-boot files only make sense for the home package.
318   in
319   searchPathExts (importDirs pkg_conf) mod exts
320
321 -- -----------------------------------------------------------------------------
322 -- General path searching
323
324 searchPathExts
325   :: [FilePath]         -- paths to search
326   -> Module             -- module name
327   -> [ (
328         FileExt,                                -- suffix
329         FilePath -> BaseName -> IO ModLocation  -- action
330        )
331      ] 
332   -> IO FindResult
333
334 searchPathExts paths mod exts 
335    = do result <- search to_search
336 {-
337         hPutStrLn stderr (showSDoc $
338                 vcat [text "Search" <+> ppr mod <+> sep (map (text. fst) exts)
339                     , nest 2 (vcat (map text paths))
340                     , case result of
341                         Succeeded (loc, p) -> text "Found" <+> ppr loc
342                         Failed fs          -> text "not found"])
343 -}      
344         return result
345
346   where
347     basename = dots_to_slashes (moduleNameString (moduleName mod))
348
349     to_search :: [(FilePath, IO ModLocation)]
350     to_search = [ (file, fn path basename)
351                 | path <- paths, 
352                   (ext,fn) <- exts,
353                   let base | path == "." = basename
354                            | otherwise   = path `joinFileName` basename
355                       file = base `joinFileExt` ext
356                 ]
357
358     search [] = return (NotFound (map fst to_search) (Just (modulePackageId mod)))
359     search ((file, mk_result) : rest) = do
360       b <- doesFileExist file
361       if b 
362         then do { loc <- mk_result; return (Found loc mod) }
363         else search rest
364
365 mkHomeModLocationSearched :: DynFlags -> ModuleName -> FileExt
366                           -> FilePath -> BaseName -> IO ModLocation
367 mkHomeModLocationSearched dflags mod suff path basename = do
368    mkHomeModLocation2 dflags mod (path `joinFileName` basename) suff
369
370 -- -----------------------------------------------------------------------------
371 -- Constructing a home module location
372
373 -- This is where we construct the ModLocation for a module in the home
374 -- package, for which we have a source file.  It is called from three
375 -- places:
376 --
377 --  (a) Here in the finder, when we are searching for a module to import,
378 --      using the search path (-i option).
379 --
380 --  (b) The compilation manager, when constructing the ModLocation for
381 --      a "root" module (a source file named explicitly on the command line
382 --      or in a :load command in GHCi).
383 --
384 --  (c) The driver in one-shot mode, when we need to construct a
385 --      ModLocation for a source file named on the command-line.
386 --
387 -- Parameters are:
388 --
389 -- mod
390 --      The name of the module
391 --
392 -- path
393 --      (a): The search path component where the source file was found.
394 --      (b) and (c): "."
395 --
396 -- src_basename
397 --      (a): dots_to_slashes (moduleNameUserString mod)
398 --      (b) and (c): The filename of the source file, minus its extension
399 --
400 -- ext
401 --      The filename extension of the source file (usually "hs" or "lhs").
402
403 mkHomeModLocation :: DynFlags -> ModuleName -> FilePath -> IO ModLocation
404 mkHomeModLocation dflags mod src_filename = do
405    let (basename,extension) = splitFilename src_filename
406    mkHomeModLocation2 dflags mod basename extension
407
408 mkHomeModLocation2 :: DynFlags
409                    -> ModuleName
410                    -> FilePath  -- Of source module, without suffix
411                    -> String    -- Suffix
412                    -> IO ModLocation
413 mkHomeModLocation2 dflags mod src_basename ext = do
414    let mod_basename = dots_to_slashes (moduleNameString mod)
415
416    obj_fn  <- mkObjPath  dflags src_basename mod_basename
417    hi_fn   <- mkHiPath   dflags src_basename mod_basename
418
419    return (ModLocation{ ml_hs_file   = Just (src_basename `joinFileExt` ext),
420                         ml_hi_file   = hi_fn,
421                         ml_obj_file  = obj_fn })
422
423 mkHiOnlyModLocation :: DynFlags -> Suffix -> FilePath -> String
424                     -> IO ModLocation
425 mkHiOnlyModLocation dflags hisuf path basename
426  = do let full_basename = path `joinFileName` basename
427       obj_fn  <- mkObjPath  dflags full_basename basename
428       return ModLocation{    ml_hs_file   = Nothing,
429                              ml_hi_file   = full_basename  `joinFileExt` hisuf,
430                                 -- Remove the .hi-boot suffix from
431                                 -- hi_file, if it had one.  We always
432                                 -- want the name of the real .hi file
433                                 -- in the ml_hi_file field.
434                              ml_obj_file  = obj_fn
435                   }
436
437 -- | Constructs the filename of a .o file for a given source file.
438 -- Does /not/ check whether the .o file exists
439 mkObjPath
440   :: DynFlags
441   -> FilePath           -- the filename of the source file, minus the extension
442   -> String             -- the module name with dots replaced by slashes
443   -> IO FilePath
444 mkObjPath dflags basename mod_basename
445   = do  let
446                 odir = objectDir dflags
447                 osuf = objectSuf dflags
448         
449                 obj_basename | Just dir <- odir = dir `joinFileName` mod_basename
450                              | otherwise        = basename
451
452         return (obj_basename `joinFileExt` osuf)
453
454 -- | Constructs the filename of a .hi file for a given source file.
455 -- Does /not/ check whether the .hi file exists
456 mkHiPath
457   :: DynFlags
458   -> FilePath           -- the filename of the source file, minus the extension
459   -> String             -- the module name with dots replaced by slashes
460   -> IO FilePath
461 mkHiPath dflags basename mod_basename
462   = do  let
463                 hidir = hiDir dflags
464                 hisuf = hiSuf dflags
465
466                 hi_basename | Just dir <- hidir = dir `joinFileName` mod_basename
467                             | otherwise         = basename
468
469         return (hi_basename `joinFileExt` hisuf)
470
471
472 -- -----------------------------------------------------------------------------
473 -- Filenames of the stub files
474
475 -- We don't have to store these in ModLocations, because they can be derived
476 -- from other available information, and they're only rarely needed.
477
478 mkStubPaths
479   :: DynFlags
480   -> ModuleName
481   -> ModLocation
482   -> (FilePath,FilePath,FilePath)
483
484 mkStubPaths dflags mod location
485   = let
486                 stubdir = stubDir dflags
487
488                 mod_basename = dots_to_slashes (moduleNameString mod)
489                 src_basename = basenameOf (expectJust "mkStubPaths" 
490                                                 (ml_hs_file location))
491
492                 stub_basename0
493                         | Just dir <- stubdir = dir `joinFileName` mod_basename
494                         | otherwise           = src_basename
495
496                 stub_basename = stub_basename0 ++ "_stub"
497
498                 -- this is the filename we're going to use when
499                 -- #including the stub_h file from the .hc file.
500                 -- Without -stubdir, we just #include the basename
501                 -- (eg. for a module A.B, we #include "B_stub.h"),
502                 -- relying on the fact that we add an implicit -I flag
503                 -- for the directory in which the source file resides
504                 -- (see DriverPipeline.hs).  With -stubdir, we
505                 -- #include "A/B.h", assuming that the user has added
506                 -- -I<dir> along with -stubdir <dir>.
507                 include_basename
508                         | Just _ <- stubdir = mod_basename 
509                         | otherwise         = filenameOf src_basename
510      in
511         (stub_basename `joinFileExt` "c",
512          stub_basename `joinFileExt` "h",
513          (include_basename ++ "_stub") `joinFileExt` "h")
514         -- the _stub.o filename is derived from the ml_obj_file.
515
516 -- -----------------------------------------------------------------------------
517 -- findLinkable isn't related to the other stuff in here, 
518 -- but there's no other obvious place for it
519
520 findObjectLinkableMaybe :: Module -> ModLocation -> IO (Maybe Linkable)
521 findObjectLinkableMaybe mod locn
522    = do let obj_fn = ml_obj_file locn
523         maybe_obj_time <- modificationTimeIfExists obj_fn
524         case maybe_obj_time of
525           Nothing -> return Nothing
526           Just obj_time -> liftM Just (findObjectLinkable mod obj_fn obj_time)
527
528 -- Make an object linkable when we know the object file exists, and we know
529 -- its modification time.
530 findObjectLinkable :: Module -> FilePath -> ClockTime -> IO Linkable
531 findObjectLinkable mod obj_fn obj_time = do
532   let stub_fn = case splitFilename3 obj_fn of
533                         (dir, base, ext) -> dir ++ "/" ++ base ++ "_stub.o"
534   stub_exist <- doesFileExist stub_fn
535   if stub_exist
536         then return (LM obj_time mod [DotO obj_fn, DotO stub_fn])
537         else return (LM obj_time mod [DotO obj_fn])
538
539 -- -----------------------------------------------------------------------------
540 -- Utils
541
542 dots_to_slashes :: String -> String
543 dots_to_slashes = map (\c -> if c == '.' then '/' else c)
544
545 -- -----------------------------------------------------------------------------
546 -- Error messages
547
548 cannotFindModule :: DynFlags -> ModuleName -> FindResult -> SDoc
549 cannotFindModule = cantFindErr SLIT("Could not find module")
550
551 cannotFindInterface  :: DynFlags -> ModuleName -> FindResult -> SDoc
552 cannotFindInterface = cantFindErr SLIT("Failed to load interface for")
553
554 cantFindErr :: LitString -> DynFlags -> ModuleName -> FindResult -> SDoc
555 cantFindErr cannot_find _dflags mod_name (FoundMultiple pkgs)
556   = hang (ptext cannot_find <+> quotes (ppr mod_name) <> colon) 2 (
557        sep [ptext SLIT("it was found in multiple packages:"),
558                 hsep (map (text.packageIdString) pkgs)]
559     )
560 cantFindErr cannot_find dflags mod_name find_result
561   = hang (ptext cannot_find <+> quotes (ppr mod_name) <> colon)
562        2 more_info
563   where
564     more_info
565       = case find_result of
566             PackageHidden pkg 
567                 -> ptext SLIT("it is a member of package") <+> ppr pkg <> comma
568                    <+> ptext SLIT("which is hidden")
569
570             ModuleHidden pkg
571                 -> ptext SLIT("it is hidden") <+> parens (ptext SLIT("in package")
572                    <+> ppr pkg)
573
574             NoPackage pkg
575                 -> ptext SLIT("no package matching") <+> ppr pkg <+>
576                    ptext SLIT("was found")
577
578             NotFound files mb_pkg
579                 | null files
580                 -> ptext SLIT("it is not a module in the current program, or in any known package.")
581                 | Just pkg <- mb_pkg, pkg /= thisPackage dflags, build_tag /= ""
582                 -> let 
583                      build = if build_tag == "p" then "profiling" 
584                                                  else "\"" ++ build_tag ++ "\""
585                    in
586                    ptext SLIT("Perhaps you haven't installed the ") <> text build <>
587                    ptext SLIT(" libraries for package ") <> ppr pkg <> char '?' $$
588                    not_found files
589
590                 | otherwise
591                 -> not_found files
592
593             NotFoundInPackage pkg
594                 -> ptext SLIT("it is not in package") <+> ppr pkg
595
596             _ -> panic "cantFindErr"
597
598     build_tag = buildTag dflags
599
600     not_found files
601         | verbosity dflags < 3
602         = ptext SLIT("Use -v to see a list of the files searched for.")
603         | otherwise 
604         = hang (ptext SLIT("locations searched:")) 2 (vcat (map text files))
605 \end{code}