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