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