51b540cc80d713f45a87202a844ade621dc06880
[ghc.git] / compiler / iface / LoadIface.lhs
1 %
2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
3 %
4 \section{Dealing with interface files}
5
6 \begin{code}
7 module LoadIface (
8         loadInterface, loadInterfaceForName, loadWiredInHomeIface, 
9         loadSrcInterface, loadSysInterface, loadOrphanModules, 
10         findAndReadIface, readIface,    -- Used when reading the module's old interface
11         loadDecls, ifaceStats, discardDeclPrags,
12         initExternalPackageState
13    ) where
14
15 #include "HsVersions.h"
16
17 import {-# SOURCE #-}   TcIface( tcIfaceDecl, tcIfaceRule, tcIfaceInst )
18
19 import DynFlags         ( DynFlags(..), DynFlag( Opt_IgnoreInterfacePragmas ) )
20 import IfaceSyn         ( IfaceDecl(..), IfaceConDecl(..), IfaceClassOp(..),
21                           IfaceConDecls(..), IfaceIdInfo(..) )
22 import IfaceEnv         ( newGlobalBinder )
23 import HscTypes         ( ModIface(..), TyThing, emptyModIface, EpsStats(..),
24                           addEpsInStats, ExternalPackageState(..),
25                           PackageTypeEnv, emptyTypeEnv,  HscEnv(..),
26                           lookupIfaceByModule, emptyPackageIfaceTable,
27                           IsBootInterface, mkIfaceFixCache, 
28                           implicitTyThings 
29                          )
30
31 import BasicTypes       ( Version, Fixity(..), FixityDirection(..),
32                           isMarkedStrict )
33 import TcRnMonad
34
35 import PrelNames        ( gHC_PRIM )
36 import PrelInfo         ( ghcPrimExports )
37 import PrelRules        ( builtinRules )
38 import Rules            ( extendRuleBaseList, mkRuleBase )
39 import InstEnv          ( emptyInstEnv, extendInstEnvList )
40 import Name             ( Name {-instance NamedThing-}, getOccName,
41                           nameModule, nameIsLocalOrFrom, isWiredInName )
42 import NameEnv
43 import MkId             ( seqId )
44 import Module
45 import OccName          ( OccName, mkOccEnv, lookupOccEnv, mkClassTyConOcc, mkClassDataConOcc,
46                           mkSuperDictSelOcc, mkDataConWrapperOcc, mkDataConWorkerOcc )
47 import SrcLoc           ( importedSrcLoc )
48 import Maybes           ( MaybeErr(..) )
49 import ErrUtils         ( Message )
50 import Finder           ( findImportedModule, findExactModule,  
51                           FindResult(..), cantFindError )
52 import UniqFM
53 import Outputable
54 import BinIface         ( readBinIface )
55 import Panic            ( ghcError, tryMost, showException, GhcException(..) )
56 import List             ( nub )
57 \end{code}
58
59
60 %************************************************************************
61 %*                                                                      *
62         loadSrcInterface, loadOrphanModules, loadHomeInterface
63
64                 These three are called from TcM-land    
65 %*                                                                      *
66 %************************************************************************
67
68 \begin{code}
69 -- | Load the interface corresponding to an @import@ directive in 
70 -- source code.  On a failure, fail in the monad with an error message.
71 loadSrcInterface :: SDoc -> ModuleName -> IsBootInterface -> RnM ModIface
72 loadSrcInterface doc mod want_boot  = do        
73   -- We must first find which Module this import refers to.  This involves
74   -- calling the Finder, which as a side effect will search the filesystem
75   -- and create a ModLocation.  If successful, loadIface will read the
76   -- interface; it will call the Finder again, but the ModLocation will be
77   -- cached from the first search.
78   hsc_env <- getTopEnv
79   res <- ioToIOEnv $ findImportedModule hsc_env mod Nothing
80   case res of
81     Found _ mod -> do
82       mb_iface <- initIfaceTcRn $ loadInterface doc mod (ImportByUser want_boot)
83       case mb_iface of
84         Failed err      -> failWithTc (elaborate err)
85         Succeeded iface -> return iface
86     err ->
87         let dflags = hsc_dflags hsc_env in
88         failWithTc (elaborate (cantFindError dflags mod err))
89   where
90     elaborate err = hang (ptext SLIT("Failed to load interface for") <+> 
91                           quotes (ppr mod) <> colon) 4 err
92
93 -- | Load interfaces for a collection of orphan modules.
94 loadOrphanModules :: [Module] -> TcM ()
95 loadOrphanModules mods
96   | null mods = returnM ()
97   | otherwise = initIfaceTcRn $
98                 do { traceIf (text "Loading orphan modules:" <+> 
99                                  fsep (map ppr mods))
100                    ; mappM_ load mods
101                    ; returnM () }
102   where
103     load mod   = loadSysInterface (mk_doc mod) mod
104     mk_doc mod = ppr mod <+> ptext SLIT("is a orphan-instance module")
105
106 -- | Loads the interface for a given Name.
107 loadInterfaceForName :: SDoc -> Name -> TcRn ModIface
108 loadInterfaceForName doc name
109   = do  { 
110 #ifdef DEBUG
111                 -- Should not be called with a name from the module being compiled
112           this_mod <- getModule
113         ; ASSERT2( not (nameIsLocalOrFrom this_mod name), ppr name <+> parens doc )
114 #endif
115           initIfaceTcRn $ loadSysInterface doc (nameModule name)
116     }
117
118 -- | An 'IfM' function to load the home interface for a wired-in thing,
119 -- so that we're sure that we see its instance declarations and rules
120 loadWiredInHomeIface :: Name -> IfM lcl ()
121 loadWiredInHomeIface name
122   = ASSERT( isWiredInName name )
123     do loadSysInterface doc (nameModule name); return ()
124   where
125     doc = ptext SLIT("Need home interface for wired-in thing") <+> ppr name
126
127 -- | A wrapper for 'loadInterface' that throws an exception if it fails
128 loadSysInterface :: SDoc -> Module -> IfM lcl ModIface
129 loadSysInterface doc mod_name
130   = do  { mb_iface <- loadInterface doc mod_name ImportBySystem
131         ; case mb_iface of 
132             Failed err      -> ghcError (ProgramError (showSDoc err))
133             Succeeded iface -> return iface }
134 \end{code}
135
136
137 %*********************************************************
138 %*                                                      *
139                 loadInterface
140
141         The main function to load an interface
142         for an imported module, and put it in
143         the External Package State
144 %*                                                      *
145 %*********************************************************
146
147 \begin{code}
148 loadInterface :: SDoc -> Module -> WhereFrom
149               -> IfM lcl (MaybeErr Message ModIface)
150
151 -- If it can't find a suitable interface file, we
152 --      a) modify the PackageIfaceTable to have an empty entry
153 --              (to avoid repeated complaints)
154 --      b) return (Left message)
155 --
156 -- It's not necessarily an error for there not to be an interface
157 -- file -- perhaps the module has changed, and that interface 
158 -- is no longer used
159
160 loadInterface doc_str mod from
161   = do  {       -- Read the state
162           (eps,hpt) <- getEpsAndHpt
163
164         ; traceIf (text "Considering whether to load" <+> ppr mod <+> ppr from)
165
166                 -- Check whether we have the interface already
167         ; dflags <- getDOpts
168         ; case lookupIfaceByModule dflags hpt (eps_PIT eps) mod of {
169             Just iface 
170                 -> returnM (Succeeded iface) ;  -- Already loaded
171                         -- The (src_imp == mi_boot iface) test checks that the already-loaded
172                         -- interface isn't a boot iface.  This can conceivably happen,
173                         -- if an earlier import had a before we got to real imports.   I think.
174             other -> do
175
176         { let { hi_boot_file = case from of
177                                 ImportByUser usr_boot -> usr_boot
178                                 ImportBySystem        -> sys_boot
179
180               ; mb_dep   = lookupUFM (eps_is_boot eps) (moduleName mod)
181               ; sys_boot = case mb_dep of
182                                 Just (_, is_boot) -> is_boot
183                                 Nothing           -> False
184                         -- The boot-ness of the requested interface, 
185               }         -- based on the dependencies in directly-imported modules
186
187         -- READ THE MODULE IN
188         ; read_result <- findAndReadIface doc_str mod hi_boot_file
189         ; dflags <- getDOpts
190         ; case read_result of {
191             Failed err -> do
192                 { let fake_iface = emptyModIface mod
193
194                 ; updateEps_ $ \eps ->
195                         eps { eps_PIT = extendModuleEnv (eps_PIT eps) (mi_module fake_iface) fake_iface }
196                         -- Not found, so add an empty iface to 
197                         -- the EPS map so that we don't look again
198                                 
199                 ; returnM (Failed err) } ;
200
201         -- Found and parsed!
202             Succeeded (iface, file_path)                        -- Sanity check:
203                 | ImportBySystem <- from,       --   system-importing...
204                   modulePackageId (mi_module iface) == thisPackage dflags,
205                                                 --   a home-package module...
206                   Nothing <- mb_dep             --   that we know nothing about
207                 -> returnM (Failed (badDepMsg mod))
208
209                 | otherwise ->
210
211         let 
212             loc_doc = text file_path
213         in 
214         initIfaceLcl mod loc_doc $ do
215
216         --      Load the new ModIface into the External Package State
217         -- Even home-package interfaces loaded by loadInterface 
218         --      (which only happens in OneShot mode; in Batch/Interactive 
219         --      mode, home-package modules are loaded one by one into the HPT)
220         -- are put in the EPS.
221         --
222         -- The main thing is to add the ModIface to the PIT, but
223         -- we also take the
224         --      IfaceDecls, IfaceInst, IfaceRules
225         -- out of the ModIface and put them into the big EPS pools
226
227         -- NB: *first* we do loadDecl, so that the provenance of all the locally-defined
228         ---    names is done correctly (notably, whether this is an .hi file or .hi-boot file).
229         --     If we do loadExport first the wrong info gets into the cache (unless we
230         --      explicitly tag each export which seems a bit of a bore)
231
232         ; ignore_prags <- doptM Opt_IgnoreInterfacePragmas
233         ; new_eps_decls <- loadDecls ignore_prags (mi_decls iface)
234         ; new_eps_insts <- mapM tcIfaceInst (mi_insts iface)
235         ; new_eps_rules <- if ignore_prags 
236                            then return []
237                            else mapM tcIfaceRule (mi_rules iface)
238
239         ; let { final_iface = iface {   mi_decls = panic "No mi_decls in PIT",
240                                         mi_insts = panic "No mi_insts in PIT",
241                                         mi_rules = panic "No mi_rules in PIT" } }
242
243         ; updateEps_  $ \ eps -> 
244             eps { eps_PIT       = extendModuleEnv (eps_PIT eps) mod final_iface,
245                   eps_PTE       = addDeclsToPTE   (eps_PTE eps) new_eps_decls,
246                   eps_rule_base = extendRuleBaseList (eps_rule_base eps) new_eps_rules,
247                   eps_inst_env  = extendInstEnvList  (eps_inst_env eps)  new_eps_insts,
248                   eps_stats     = addEpsInStats (eps_stats eps) (length new_eps_decls)
249                                                 (length new_eps_insts) (length new_eps_rules) }
250
251         ; return (Succeeded final_iface)
252     }}}}
253
254 badDepMsg mod 
255   = hang (ptext SLIT("Interface file inconsistency:"))
256        2 (sep [ptext SLIT("home-package module") <+> quotes (ppr mod) <+> ptext SLIT("is mentioned,"), 
257                ptext SLIT("but does not appear in the dependencies of the interface")])
258
259 -----------------------------------------------------
260 --      Loading type/class/value decls
261 -- We pass the full Module name here, replete with
262 -- its package info, so that we can build a Name for
263 -- each binder with the right package info in it
264 -- All subsequent lookups, including crucially lookups during typechecking
265 -- the declaration itself, will find the fully-glorious Name
266 -----------------------------------------------------
267
268 addDeclsToPTE :: PackageTypeEnv -> [(Name,TyThing)] -> PackageTypeEnv
269 addDeclsToPTE pte things = extendNameEnvList pte things
270
271 loadDecls :: Bool
272           -> [(Version, IfaceDecl)]
273           -> IfL [(Name,TyThing)]
274 loadDecls ignore_prags ver_decls
275    = do { mod <- getIfModule
276         ; thingss <- mapM (loadDecl ignore_prags mod) ver_decls
277         ; return (concat thingss)
278         }
279
280 loadDecl :: Bool                        -- Don't load pragmas into the decl pool
281          -> Module
282           -> (Version, IfaceDecl)
283           -> IfL [(Name,TyThing)]       -- The list can be poked eagerly, but the
284                                         -- TyThings are forkM'd thunks
285 loadDecl ignore_prags mod (_version, decl)
286   = do  {       -- Populate the name cache with final versions of all 
287                 -- the names associated with the decl
288           main_name      <- mk_new_bndr mod Nothing (ifName decl)
289         ; implicit_names <- mapM (mk_new_bndr mod (Just main_name)) (ifaceDeclSubBndrs decl)
290
291         -- Typecheck the thing, lazily
292         -- NB. firstly, the laziness is there in case we never need the
293         -- declaration (in one-shot mode), and secondly it is there so that 
294         -- we don't look up the occurrence of a name before calling mk_new_bndr
295         -- on the binder.  This is important because we must get the right name
296         -- which includes its nameParent.
297         ; thing <- forkM doc (bumpDeclStats main_name >> tcIfaceDecl stripped_decl)
298         ; let mini_env = mkOccEnv [(getOccName t, t) | t <- implicitTyThings thing]
299               lookup n = case lookupOccEnv mini_env (getOccName n) of
300                            Just thing -> thing
301                            Nothing    -> pprPanic "loadDecl" (ppr main_name <+> ppr n)
302
303         ; returnM ((main_name, thing) : [(n, lookup n) | n <- implicit_names]) }
304                 -- We build a list from the *known* names, with (lookup n) thunks
305                 -- as the TyThings.  That way we can extend the PTE without poking the
306                 -- thunks
307   where
308     stripped_decl | ignore_prags = discardDeclPrags decl
309                   | otherwise    = decl
310
311         -- mk_new_bndr allocates in the name cache the final canonical
312         -- name for the thing, with the correct 
313         --      * parent
314         --      * location
315         -- imported name, to fix the module correctly in the cache
316     mk_new_bndr mod mb_parent occ 
317         = newGlobalBinder mod occ mb_parent 
318                           (importedSrcLoc (showSDoc (ppr (moduleName mod))))
319                         -- ToDo: qualify with the package name if necessary
320
321     doc = ptext SLIT("Declaration for") <+> ppr (ifName decl)
322
323 discardDeclPrags :: IfaceDecl -> IfaceDecl
324 discardDeclPrags decl@(IfaceId {ifIdInfo = HasInfo _}) = decl { ifIdInfo = NoInfo }
325 discardDeclPrags decl                                  = decl
326
327 bumpDeclStats :: Name -> IfL ()         -- Record that one more declaration has actually been used
328 bumpDeclStats name
329   = do  { traceIf (text "Loading decl for" <+> ppr name)
330         ; updateEps_ (\eps -> let stats = eps_stats eps
331                               in eps { eps_stats = stats { n_decls_out = n_decls_out stats + 1 } })
332         }
333
334 -----------------
335 ifaceDeclSubBndrs :: IfaceDecl -> [OccName]
336 --  *Excludes* the 'main' name, but *includes* the implicitly-bound names
337 -- Deeply revolting, because it has to predict what gets bound,
338 -- especially the question of whether there's a wrapper for a datacon
339
340 ifaceDeclSubBndrs (IfaceClass {ifCtxt = sc_ctxt, ifName = cls_occ, ifSigs = sigs })
341   = [tc_occ, dc_occ, dcww_occ] ++
342     [op | IfaceClassOp op _ _ <- sigs] ++
343     [mkSuperDictSelOcc n cls_occ | n <- [1..n_ctxt]] 
344   where
345     n_ctxt = length sc_ctxt
346     n_sigs = length sigs
347     tc_occ  = mkClassTyConOcc cls_occ
348     dc_occ  = mkClassDataConOcc cls_occ 
349     dcww_occ | is_newtype = mkDataConWrapperOcc dc_occ  -- Newtypes have wrapper but no worker
350              | otherwise  = mkDataConWorkerOcc dc_occ   -- Otherwise worker but no wrapper
351     is_newtype = n_sigs + n_ctxt == 1                   -- Sigh 
352
353 ifaceDeclSubBndrs (IfaceData {ifCons = IfAbstractTyCon}) 
354   = []
355 -- Newtype
356 ifaceDeclSubBndrs (IfaceData {ifCons = IfNewTyCon (IfVanillaCon { ifConOcc = con_occ, 
357                                                                   ifConFields = fields})}) 
358   = fields ++ [con_occ, mkDataConWrapperOcc con_occ]    
359         -- Wrapper, no worker; see MkId.mkDataConIds
360
361 ifaceDeclSubBndrs (IfaceData {ifCons = IfDataTyCon cons})
362   = nub (concatMap fld_occs cons)       -- Eliminate duplicate fields
363     ++ concatMap dc_occs cons
364   where
365     fld_occs (IfVanillaCon { ifConFields = fields }) = fields
366     fld_occs (IfGadtCon {})                          = []
367     dc_occs con_decl
368         | has_wrapper = [con_occ, work_occ, wrap_occ]
369         | otherwise   = [con_occ, work_occ]
370         where
371           con_occ = ifConOcc con_decl
372           strs    = ifConStricts con_decl
373           wrap_occ = mkDataConWrapperOcc con_occ
374           work_occ = mkDataConWorkerOcc con_occ
375           has_wrapper = any isMarkedStrict strs -- See MkId.mkDataConIds (sigh)
376                 -- ToDo: may miss strictness in existential dicts
377
378 ifaceDeclSubBndrs _other                      = []
379
380 \end{code}
381
382
383 %*********************************************************
384 %*                                                      *
385 \subsection{Reading an interface file}
386 %*                                                      *
387 %*********************************************************
388
389 \begin{code}
390 findAndReadIface :: SDoc -> Module
391                  -> IsBootInterface     -- True  <=> Look for a .hi-boot file
392                                         -- False <=> Look for .hi file
393                  -> TcRnIf gbl lcl (MaybeErr Message (ModIface, FilePath))
394         -- Nothing <=> file not found, or unreadable, or illegible
395         -- Just x  <=> successfully found and parsed 
396
397         -- It *doesn't* add an error to the monad, because 
398         -- sometimes it's ok to fail... see notes with loadInterface
399
400 findAndReadIface doc_str mod hi_boot_file
401   = do  { traceIf (sep [hsep [ptext SLIT("Reading"), 
402                               if hi_boot_file 
403                                 then ptext SLIT("[boot]") 
404                                 else empty,
405                               ptext SLIT("interface for"), 
406                               ppr mod <> semi],
407                         nest 4 (ptext SLIT("reason:") <+> doc_str)])
408
409         -- Check for GHC.Prim, and return its static interface
410         ; dflags <- getDOpts
411         ; if mod == gHC_PRIM
412           then returnM (Succeeded (ghcPrimIface, 
413                                    "<built in interface for GHC.Prim>"))
414           else do
415
416         -- Look for the file
417         ; hsc_env <- getTopEnv
418         ; mb_found <- ioToIOEnv (findHiFile hsc_env mod hi_boot_file)
419         ; case mb_found of {
420               Failed err -> do
421                 { traceIf (ptext SLIT("...not found"))
422                 ; dflags <- getDOpts
423                 ; returnM (Failed (cantFindError dflags (moduleName mod) err)) } ;
424
425               Succeeded file_path -> do 
426
427         -- Found file, so read it
428         { traceIf (ptext SLIT("readIFace") <+> text file_path)
429         ; read_result <- readIface mod file_path hi_boot_file
430         ; case read_result of
431             Failed err -> returnM (Failed (badIfaceFile file_path err))
432             Succeeded iface 
433                 | mi_module iface /= mod ->
434                   return (Failed (wrongIfaceModErr iface mod file_path))
435                 | otherwise ->
436                   returnM (Succeeded (iface, file_path))
437                         -- Don't forget to fill in the package name...
438         }}}
439
440 findHiFile :: HscEnv -> Module -> IsBootInterface
441            -> IO (MaybeErr FindResult FilePath)
442 findHiFile hsc_env mod hi_boot_file
443   = do
444       maybe_found <- findExactModule hsc_env mod
445       case maybe_found of
446         Found loc mod -> return (Succeeded path)
447                 where
448                    path = addBootSuffix_maybe hi_boot_file (ml_hi_file loc)
449         err -> return (Failed err)
450 \end{code}
451
452 @readIface@ tries just the one file.
453
454 \begin{code}
455 readIface :: Module -> FilePath -> IsBootInterface 
456           -> TcRnIf gbl lcl (MaybeErr Message ModIface)
457         -- Failed err    <=> file not found, or unreadable, or illegible
458         -- Succeeded iface <=> successfully found and parsed 
459
460 readIface wanted_mod file_path is_hi_boot_file
461   = do  { dflags <- getDOpts
462         ; ioToIOEnv $ do
463         { res <- tryMost (readBinIface file_path)
464         ; case res of
465             Right iface 
466                 | wanted_mod == actual_mod -> return (Succeeded iface)
467                 | otherwise                -> return (Failed err)
468                 where
469                   actual_mod = mi_module iface
470                   err = hiModuleNameMismatchWarn wanted_mod actual_mod
471
472             Left exn    -> return (Failed (text (showException exn)))
473     }}
474 \end{code}
475
476
477 %*********************************************************
478 %*                                                       *
479         Wired-in interface for GHC.Prim
480 %*                                                       *
481 %*********************************************************
482
483 \begin{code}
484 initExternalPackageState :: ExternalPackageState
485 initExternalPackageState
486   = EPS { 
487       eps_is_boot    = emptyUFM,
488       eps_PIT        = emptyPackageIfaceTable,
489       eps_PTE        = emptyTypeEnv,
490       eps_inst_env   = emptyInstEnv,
491       eps_rule_base  = mkRuleBase builtinRules,
492         -- Initialise the EPS rule pool with the built-in rules
493       eps_stats = EpsStats { n_ifaces_in = 0, n_decls_in = 0, n_decls_out = 0
494                            , n_insts_in = 0, n_insts_out = 0
495                            , n_rules_in = length builtinRules, n_rules_out = 0 }
496     }
497 \end{code}
498
499
500 %*********************************************************
501 %*                                                       *
502         Wired-in interface for GHC.Prim
503 %*                                                       *
504 %*********************************************************
505
506 \begin{code}
507 ghcPrimIface :: ModIface
508 ghcPrimIface
509   = (emptyModIface gHC_PRIM) {
510         mi_exports  = [(gHC_PRIM, ghcPrimExports)],
511         mi_decls    = [],
512         mi_fixities = fixities,
513         mi_fix_fn  = mkIfaceFixCache fixities
514     }           
515   where
516     fixities = [(getOccName seqId, Fixity 0 InfixR)]
517                         -- seq is infixr 0
518 \end{code}
519
520 %*********************************************************
521 %*                                                      *
522 \subsection{Statistics}
523 %*                                                      *
524 %*********************************************************
525
526 \begin{code}
527 ifaceStats :: ExternalPackageState -> SDoc
528 ifaceStats eps 
529   = hcat [text "Renamer stats: ", msg]
530   where
531     stats = eps_stats eps
532     msg = vcat 
533         [int (n_ifaces_in stats) <+> text "interfaces read",
534          hsep [ int (n_decls_out stats), text "type/class/variable imported, out of", 
535                 int (n_decls_in stats), text "read"],
536          hsep [ int (n_insts_out stats), text "instance decls imported, out of",  
537                 int (n_insts_in stats), text "read"],
538          hsep [ int (n_rules_out stats), text "rule decls imported, out of",  
539                 int (n_rules_in stats), text "read"]
540         ]
541 \end{code}    
542
543
544 %*********************************************************
545 %*                                                       *
546 \subsection{Errors}
547 %*                                                       *
548 %*********************************************************
549
550 \begin{code}
551 badIfaceFile file err
552   = vcat [ptext SLIT("Bad interface file:") <+> text file, 
553           nest 4 err]
554
555 hiModuleNameMismatchWarn :: Module -> Module -> Message
556 hiModuleNameMismatchWarn requested_mod read_mod = 
557   withPprStyle defaultUserStyle $
558     -- we want the Modules below to be qualified with package names,
559     -- so reset the PrintUnqualified setting.
560     hsep [ ptext SLIT("Something is amiss; requested module ")
561          , ppr requested_mod
562          , ptext SLIT("differs from name found in the interface file")
563          , ppr read_mod
564          ]
565
566 wrongIfaceModErr iface mod_name file_path 
567   = sep [ptext SLIT("Interface file") <+> iface_file,
568          ptext SLIT("contains module") <+> quotes (ppr (mi_module iface)) <> comma,
569          ptext SLIT("but we were expecting module") <+> quotes (ppr mod_name),
570          sep [ptext SLIT("Probable cause: the source code which generated"),
571              nest 2 iface_file,
572              ptext SLIT("has an incompatible module name")
573             ]
574         ]
575   where iface_file = doubleQuotes (text file_path)
576 \end{code}