HscTypes.lhs 81.6 KB
Newer Older
1 2
%
% (c) The University of Glasgow, 2006
3 4 5 6
%
\section[HscTypes]{Types for the per-module compiler}

\begin{code}
7
-- | Types for the per-module compiler
8
module HscTypes ( 
9 10 11 12 13 14 15
        -- * 'Ghc' monad stuff
        Ghc(..), GhcT(..), liftGhcT,
        GhcMonad(..), WarnLogMonad(..),
        liftIO,
        ioMsgMaybe, ioMsg,
        logWarnings, clearWarnings, hasWarnings,
        SourceError, GhcApiError, mkSrcErr, srcErrorMessages, mkApiErr,
16
        throwOneError, handleSourceError,
17
        reflectGhc, reifyGhc,
18
        handleFlagWarnings,
19

20
	-- * Sessions and compilation state
Thomas Schilling's avatar
Thomas Schilling committed
21
	Session(..), withSession, modifySession, withTempSession,
22
        HscEnv(..), hscEPS,
Simon Marlow's avatar
Simon Marlow committed
23
	FinderCache, FindResult(..), ModLocationCache,
24 25
	Target(..), TargetId(..), pprTarget, pprTargetId,
	ModuleGraph, emptyMG,
26 27
        -- ** Callbacks
        GhcApiCallbacks(..), withLocalCallbacks,
28

29
        -- * Information about modules
30
	ModDetails(..),	emptyModDetails,
31
	ModGuts(..), CoreModule(..), CgGuts(..), ForeignStubs(..),
Simon Marlow's avatar
Simon Marlow committed
32
        ImportedMods,
33

34
	ModSummary(..), ms_mod_name, showModMsg, isBootSummary,
35
	msHsFilePath, msHiFilePath, msObjFilePath,
36

37
        -- * Information about the module being compiled
38 39
	HscSource(..), isHsBoot, hscSourceString,	-- Re-exported from DriverPhases
	
40
	-- * State relating to modules in this package
41
	HomePackageTable, HomeModInfo(..), emptyHomePackageTable,
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
42
	hptInstances, hptRules, hptVectInfo,
43 44
	
	-- * State relating to known packages
45
	ExternalPackageState(..), EpsStats(..), addEpsInStats,
46
	PackageTypeEnv, PackageIfaceTable, emptyPackageIfaceTable,
Simon Marlow's avatar
Simon Marlow committed
47
	lookupIfaceByModule, emptyModIface,
48 49
	
	PackageInstEnv, PackageRuleBase,
50

51 52 53 54

        -- * Annotations
        prepareAnnotations,

55
        -- * Interactive context
56
	InteractiveContext(..), emptyInteractiveContext, 
57
	icPrintUnqual, extendInteractiveContext,
mnislaih's avatar
mnislaih committed
58
        substInteractiveContext,
59
        mkPrintUnqualified, pprModulePrefix,
60

61
	-- * Interfaces
Ian Lynagh's avatar
Ian Lynagh committed
62 63
	ModIface(..), mkIfaceWarnCache, mkIfaceHashCache, mkIfaceFixCache,
	emptyIfaceWarnCache,
64

65
        -- * Fixity
66
	FixityEnv, FixItem(..), lookupFixity, emptyFixityEnv,
67

68 69 70
        -- * TyThings and type environments
	TyThing(..),
	tyThingClass, tyThingTyCon, tyThingDataCon, tyThingId,
71
	implicitTyThings, isImplicitTyThing,
72 73
	
	TypeEnv, lookupType, lookupTypeHscEnv, mkTypeEnv, emptyTypeEnv,
74
	extendTypeEnv, extendTypeEnvList, extendTypeEnvWithIds, lookupTypeEnv,
75
	typeEnvElts, typeEnvClasses, typeEnvTyCons, typeEnvIds,
76
	typeEnvDataCons,
77

78 79 80 81
        -- * MonadThings
        MonadThings(..),

        -- * Information on imports and exports
82
	WhetherHasOrphans, IsBootInterface, Usage(..), 
83
	Dependencies(..), noDependencies,
84
	NameCache(..), OrigNameCache, OrigIParamCache,
85
	Avails, availsToNameSet, availsToNameEnv, availName, availNames,
86
	GenAvailInfo(..), AvailInfo, RdrAvailInfo, 
87
	IfaceExport,
88

89
	-- * Warnings
Ian Lynagh's avatar
Ian Lynagh committed
90
	Warnings(..), WarningTxt(..), plusWarns,
91

92
	-- * Linker stuff
93 94
	Linkable(..), isObjectLinkable,
	Unlinked(..), CompiledByteCode,
andy@galois.com's avatar
andy@galois.com committed
95
	isObject, nameOfObject, isInterpretable, byteCodeOfObject,
96 97
        
        -- * Program coverage
98
        HpcInfo(..), emptyHpcInfo, isHpcUsed, AnyHpcUsage,
99

100
        -- * Breakpoints
101 102
        ModBreaks (..), BreakIndex, emptyModBreaks,

103
        -- * Vectorisation information
104 105
        VectInfo(..), IfaceVectInfo(..), noVectInfo, plusVectInfo, 
        noIfaceVectInfo
106
    ) where
107 108 109

#include "HsVersions.h"

110 111
#ifdef GHCI
import ByteCodeAsm	( CompiledByteCode )
112
import {-# SOURCE #-}  InteractiveEval ( Resume )
113 114
#endif

115
import HsSyn
116
import RdrName
117
import Name
118
import NameEnv
119
import NameSet	
120
import Module
121
import InstEnv		( InstEnv, Instance )
122
import FamInstEnv	( FamInstEnv, FamInst )
123
import Rules		( RuleBase )
124
import CoreSyn		( CoreBind )
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
125
import VarEnv
126
import VarSet
127
import Var
128
import Id
mnislaih's avatar
mnislaih committed
129
import Type		
130

131
import Annotations
132
import Class		( Class, classSelIds, classATs, classTyCon )
133
import TyCon
134
import DataCon		( DataCon, dataConImplicitIds, dataConWrapId )
135
import PrelNames	( gHC_PRIM )
136
import Packages hiding ( Version(..) )
137 138
import DynFlags		( DynFlags(..), isOneShot, HscTarget (..), dopt,
                          DynFlag(..) )
139
import DriverPhases	( HscSource(..), isHsBoot, hscSourceString, Phase )
Ian Lynagh's avatar
Ian Lynagh committed
140
import BasicTypes	( IPName, defaultFixity, WarningTxt(..) )
dias@eecs.harvard.edu's avatar
dias@eecs.harvard.edu committed
141
import OptimizationFuel	( OptFuelState )
142
import IfaceSyn
143
import FiniteMap	( FiniteMap )
144
import CoreSyn		( CoreRule )
145
import Maybes		( orElse, expectJust, catMaybes )
146
import Outputable
147
import BreakArray
148
import SrcLoc		( SrcSpan, Located(..) )
149
import UniqFM		( lookupUFM, eltsUFM, emptyUFM )
150
import UniqSupply	( UniqSupply )
151
import FastString
152
import StringBuffer	( StringBuffer )
153
import Fingerprint
154 155 156
import MonadUtils
import Data.Dynamic     ( Typeable )
import qualified Data.Dynamic as Dyn
157 158
import Bag
import ErrUtils
Simon Marlow's avatar
Simon Marlow committed
159

160
import System.FilePath
Simon Marlow's avatar
Simon Marlow committed
161
import System.Time	( ClockTime )
162
import Data.IORef
163
import Data.Array       ( Array, array )
mnislaih's avatar
mnislaih committed
164
import Data.List
165
import Control.Monad    ( mplus, guard, liftM, when )
166
import Exception
167 168
\end{code}

169

170 171
%************************************************************************
%*									*
172
\subsection{Compilation environment}
173 174 175
%*									*
%************************************************************************

176 177 178 179 180 181

\begin{code}
-- | The Session is a handle to the complete state of a compilation
-- session.  A compilation session consists of a set of modules
-- constituting the current program or library, the context for
-- interactive evaluation, and various caches.
182 183 184 185 186 187
data Session = Session !(IORef HscEnv) !(IORef WarningMessages)

mkSrcErr :: ErrorMessages -> SourceError
srcErrorMessages :: SourceError -> ErrorMessages
mkApiErr :: SDoc -> GhcApiError

188 189 190
throwOneError :: MonadIO m => ErrMsg -> m ab
throwOneError err = liftIO $ throwIO $ mkSrcErr $ unitBag err

191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
-- | A source error is an error that is caused by one or more errors in the
-- source code.  A 'SourceError' is thrown by many functions in the
-- compilation pipeline.  Inside GHC these errors are merely printed via
-- 'log_action', but API clients may treat them differently, for example,
-- insert them into a list box.  If you want the default behaviour, use the
-- idiom:
--
-- > handleSourceError printExceptionAndWarnings $ do
-- >   ... api calls that may fail ...
--
-- The 'SourceError's error messages can be accessed via 'srcErrorMessages'.
-- This list may be empty if the compiler failed due to @-Werror@
-- ('Opt_WarnIsError').
--
-- See 'printExceptionAndWarnings' for more information on what to take care
-- of when writing a custom error handler.
data SourceError = SourceError ErrorMessages

instance Show SourceError where
  show (SourceError msgs) = unlines . map show . bagToList $ msgs
    -- ToDo: is there some nicer way to print this?

sourceErrorTc :: Dyn.TyCon
sourceErrorTc = Dyn.mkTyCon "SourceError"
{-# NOINLINE sourceErrorTc #-}
instance Typeable SourceError where
  typeOf _ = Dyn.mkTyConApp sourceErrorTc []

instance Exception SourceError

mkSrcErr = SourceError

-- | Perform the given action and call the exception handler if the action
-- throws a 'SourceError'.  See 'SourceError' for more information.
handleSourceError :: (ExceptionMonad m) =>
                     (SourceError -> m a) -- ^ exception handler
                  -> m a -- ^ action to perform
                  -> m a
handleSourceError handler act =
  gcatch act (\(e :: SourceError) -> handler e)

srcErrorMessages (SourceError msgs) = msgs

-- | XXX: what exactly is an API error?
data GhcApiError = GhcApiError SDoc

instance Show GhcApiError where
  show (GhcApiError msg) = showSDoc msg

ghcApiErrorTc :: Dyn.TyCon
ghcApiErrorTc = Dyn.mkTyCon "GhcApiError"
{-# NOINLINE ghcApiErrorTc #-}
instance Typeable GhcApiError where
  typeOf _ = Dyn.mkTyConApp ghcApiErrorTc []

instance Exception GhcApiError

mkApiErr = GhcApiError

-- | A monad that allows logging of warnings.
class Monad m => WarnLogMonad m where
  setWarnings  :: WarningMessages -> m ()
  getWarnings :: m WarningMessages

logWarnings :: WarnLogMonad m => WarningMessages -> m ()
logWarnings warns = do
    warns0 <- getWarnings
    setWarnings (unionBags warns warns0)

-- | Clear the log of 'Warnings'.
clearWarnings :: WarnLogMonad m => m ()
clearWarnings = setWarnings emptyBag

-- | Returns true if there were any warnings.
hasWarnings :: WarnLogMonad m => m Bool
hasWarnings = getWarnings >>= return . not . isEmptyBag

-- | A monad that has all the features needed by GHC API calls.
--
-- In short, a GHC monad
--
--   - allows embedding of IO actions,
--
--   - can log warnings,
--
--   - allows handling of (extensible) exceptions, and
--
--   - maintains a current session.
--
-- If you do not use 'Ghc' or 'GhcT', make sure to call 'GHC.initGhcMonad'
-- before any call to the GHC API functions can occur.
--
class (Functor m, MonadIO m, WarnLogMonad m, ExceptionMonad m)
    => GhcMonad m where
  getSession :: m HscEnv
  setSession :: HscEnv -> m ()

-- | Call the argument with the current session.
withSession :: GhcMonad m => (HscEnv -> m a) -> m a
withSession f = getSession >>= f

-- | Set the current session to the result of applying the current session to
-- the argument.
modifySession :: GhcMonad m => (HscEnv -> HscEnv) -> m ()
modifySession f = do h <- getSession
                     setSession $! f h

Thomas Schilling's avatar
Thomas Schilling committed
298 299 300 301 302 303 304 305 306 307
withSavedSession :: GhcMonad m => m a -> m a
withSavedSession m = do
  saved_session <- getSession
  m `gfinally` setSession saved_session

-- | Call an action with a temporarily modified Session.
withTempSession :: GhcMonad m => (HscEnv -> HscEnv) -> m a -> m a
withTempSession f m =
  withSavedSession $ modifySession f >> m

308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
-- | A minimal implementation of a 'GhcMonad'.  If you need a custom monad,
-- e.g., to maintain additional state consider wrapping this monad or using
-- 'GhcT'.
newtype Ghc a = Ghc { unGhc :: Session -> IO a }

instance Functor Ghc where
  fmap f m = Ghc $ \s -> f `fmap` unGhc m s

instance Monad Ghc where
  return a = Ghc $ \_ -> return a
  m >>= g  = Ghc $ \s -> do a <- unGhc m s; unGhc (g a) s

instance MonadIO Ghc where
  liftIO ioA = Ghc $ \_ -> ioA

instance ExceptionMonad Ghc where
  gcatch act handle =
      Ghc $ \s -> unGhc act s `gcatch` \e -> unGhc (handle e) s
326 327
  gblock (Ghc m)   = Ghc $ \s -> gblock (m s)
  gunblock (Ghc m) = Ghc $ \s -> gunblock (m s)
328 329 330 331 332 333
  gmask f =
      Ghc $ \s -> gmask $ \io_restore ->
                             let
                                g_restore (Ghc m) = Ghc $ \s -> io_restore (m s)
                             in
                                unGhc (f g_restore) s
334

335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
instance WarnLogMonad Ghc where
  setWarnings warns = Ghc $ \(Session _ wref) -> writeIORef wref warns
  -- | Return 'Warnings' accumulated so far.
  getWarnings       = Ghc $ \(Session _ wref) -> readIORef wref

instance GhcMonad Ghc where
  getSession = Ghc $ \(Session r _) -> readIORef r
  setSession s' = Ghc $ \(Session r _) -> writeIORef r s'

-- | A monad transformer to add GHC specific features to another monad.
--
-- Note that the wrapped monad must support IO and handling of exceptions.
newtype GhcT m a = GhcT { unGhcT :: Session -> m a }
liftGhcT :: Monad m => m a -> GhcT m a
liftGhcT m = GhcT $ \_ -> m
350

351 352 353 354 355 356 357 358 359 360 361 362 363
instance Functor m => Functor (GhcT m) where
  fmap f m = GhcT $ \s -> f `fmap` unGhcT m s

instance Monad m => Monad (GhcT m) where
  return x = GhcT $ \_ -> return x
  m >>= k  = GhcT $ \s -> do a <- unGhcT m s; unGhcT (k a) s

instance MonadIO m => MonadIO (GhcT m) where
  liftIO ioA = GhcT $ \_ -> liftIO ioA

instance ExceptionMonad m => ExceptionMonad (GhcT m) where
  gcatch act handle =
      GhcT $ \s -> unGhcT act s `gcatch` \e -> unGhcT (handle e) s
364 365
  gblock (GhcT m) = GhcT $ \s -> gblock (m s)
  gunblock (GhcT m) = GhcT $ \s -> gunblock (m s)
366 367 368 369 370 371
  gmask f =
      GhcT $ \s -> gmask $ \io_restore ->
                           let
                              g_restore (GhcT m) = GhcT $ \s -> io_restore (m s)
                           in
                              unGhcT (f g_restore) s
372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403

instance MonadIO m => WarnLogMonad (GhcT m) where
  setWarnings warns = GhcT $ \(Session _ wref) -> liftIO $ writeIORef wref warns
  -- | Return 'Warnings' accumulated so far.
  getWarnings       = GhcT $ \(Session _ wref) -> liftIO $ readIORef wref

instance (Functor m, ExceptionMonad m, MonadIO m) => GhcMonad (GhcT m) where
  getSession = GhcT $ \(Session r _) -> liftIO $ readIORef r
  setSession s' = GhcT $ \(Session r _) -> liftIO $ writeIORef r s'

-- | Lift an IO action returning errors messages into a 'GhcMonad'.
--
-- In order to reduce dependencies to other parts of the compiler, functions
-- outside the "main" parts of GHC return warnings and errors as a parameter
-- and signal success via by wrapping the result in a 'Maybe' type.  This
-- function logs the returned warnings and propagates errors as exceptions
-- (of type 'SourceError').
--
-- This function assumes the following invariants:
--
--  1. If the second result indicates success (is of the form 'Just x'),
--     there must be no error messages in the first result.
--
--  2. If there are no error messages, but the second result indicates failure
--     there should be warnings in the first result.  That is, if the action
--     failed, it must have been due to the warnings (i.e., @-Werror@).
ioMsgMaybe :: GhcMonad m =>
              IO (Messages, Maybe a) -> m a
ioMsgMaybe ioA = do
  ((warns,errs), mb_r) <- liftIO ioA
  logWarnings warns
  case mb_r of
404
    Nothing -> liftIO $ throwIO (mkSrcErr errs)
405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
    Just r  -> ASSERT( isEmptyBag errs ) return r

-- | Lift a non-failing IO action into a 'GhcMonad'.
--
-- Like 'ioMsgMaybe', but assumes that the action will never return any error
-- messages.
ioMsg :: GhcMonad m => IO (Messages, a) -> m a
ioMsg ioA = do
    ((warns,errs), r) <- liftIO ioA
    logWarnings warns
    ASSERT( isEmptyBag errs ) return r

-- | Reflect a computation in the 'Ghc' monad into the 'IO' monad.
--
-- You can use this to call functions returning an action in the 'Ghc' monad
-- inside an 'IO' action.  This is needed for some (too restrictive) callback
-- arguments of some library functions:
--
-- > libFunc :: String -> (Int -> IO a) -> IO a
-- > ghcFunc :: Int -> Ghc a
-- >
-- > ghcFuncUsingLibFunc :: String -> Ghc a -> Ghc a
-- > ghcFuncUsingLibFunc str =
-- >   reifyGhc $ \s ->
-- >     libFunc $ \i -> do
-- >       reflectGhc (ghcFunc i) s
--
reflectGhc :: Ghc a -> Session -> IO a
reflectGhc m = unGhc m
434

435 436 437
-- > Dual to 'reflectGhc'.  See its documentation.
reifyGhc :: (Session -> IO a) -> Ghc a
reifyGhc act = Ghc $ act
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455

handleFlagWarnings :: GhcMonad m => DynFlags -> [Located String] -> m ()
handleFlagWarnings dflags warns
 = when (dopt Opt_WarnDeprecatedFlags dflags)
        (handleFlagWarnings' dflags warns)

handleFlagWarnings' :: GhcMonad m => DynFlags -> [Located String] -> m ()
handleFlagWarnings' _ [] = return ()
handleFlagWarnings' dflags warns
 = do -- It would be nicer if warns :: [Located Message], but that has circular
      -- import problems.
      logWarnings $ listToBag (map mkFlagWarning warns)
      when (dopt Opt_WarnIsError dflags) $
        liftIO $ throwIO $ mkSrcErr emptyBag

mkFlagWarning :: Located String -> WarnMsg
mkFlagWarning (L loc warn)
 = mkPlainWarnMsg loc (text warn)
456 457
\end{code}

458
\begin{code}
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494
-- | These functions are called in various places of the GHC API.
--
-- API clients can override any of these callbacks to change GHC's default
-- behaviour.
data GhcApiCallbacks
  = GhcApiCallbacks {

    -- | Called by 'load' after the compilating of each module.
    --
    -- The default implementation simply prints all warnings and errors to
    -- @stderr@.  Don't forget to call 'clearWarnings' when implementing your
    -- own call.
    --
    -- The first argument is the module that was compiled.
    --
    -- The second argument is @Nothing@ if no errors occured, but there may
    -- have been warnings.  If it is @Just err@ at least one error has
    -- occured.  If 'srcErrorMessages' is empty, compilation failed due to
    -- @-Werror@.
    reportModuleCompilationResult :: GhcMonad m =>
                                     ModSummary -> Maybe SourceError
                                  -> m ()
  }

-- | Temporarily modify the callbacks.  After the action is executed all
-- callbacks are reset (not, however, any other modifications to the session
-- state.)
withLocalCallbacks :: GhcMonad m =>
                      (GhcApiCallbacks -> GhcApiCallbacks)
                   -> m a -> m a
withLocalCallbacks f m = do
  hsc_env <- getSession
  let cb0 = hsc_callbacks hsc_env
  let cb' = f cb0
  setSession (hsc_env { hsc_callbacks = cb' `seq` cb' })
  r <- m
495 496
  hsc_env' <- getSession
  setSession (hsc_env' { hsc_callbacks = cb0 })
497 498 499 500 501 502
  return r

\end{code}

\begin{code}
-- | Hscenv is like 'Session', except that some of the fields are immutable.
503 504 505 506 507 508 509 510 511
-- An HscEnv is used to compile a single module from plain Haskell source
-- code (after preprocessing) to either C, assembly or C--.  Things like
-- the module graph don't change during a single compilation.
--
-- Historical note: \"hsc\" used to be the name of the compiler binary,
-- when there was a separate driver and compiler.  To compile a single
-- module, the driver would invoke hsc on the source code... so nowadays
-- we think of hsc as the layer of the compiler that deals with compiling
-- a single module.
512
data HscEnv 
513 514
  = HscEnv { 
	hsc_dflags :: DynFlags,
515
		-- ^ The dynamic flag settings
516

517 518 519
        hsc_callbacks :: GhcApiCallbacks,
                -- ^ Callbacks for the GHC API.

520
	hsc_targets :: [Target],
521
		-- ^ The targets (or roots) of the current session
522

523
	hsc_mod_graph :: ModuleGraph,
524
		-- ^ The module graph of the current session
525 526

	hsc_IC :: InteractiveContext,
527
		-- ^ The context for evaluating interactive statements
528 529

	hsc_HPT    :: HomePackageTable,
530 531
		-- ^ The home package table describes already-compiled
		-- home-package modules, /excluding/ the module we 
532 533 534
		-- are compiling right now.
		-- (In one-shot mode the current module is the only
		--  home-package module, so hsc_HPT is empty.  All other
535
		--  modules count as \"external-package\" modules.
536
		--  However, even in GHCi mode, hi-boot interfaces are
537
		--  demand-loaded into the external-package table.)
538
		--
539
		-- 'hsc_HPT' is not mutable because we only demand-load 
540
		-- external packages; the home package is eagerly 
541
		-- loaded, module by module, by the compilation manager.
542
		--	
543
		-- The HPT may contain modules compiled earlier by @--make@
544
		-- but not actually below the current module in the dependency
545 546 547
		-- graph.

		-- (This changes a previous invariant: changed Jan 05.)
548
	
549
	hsc_EPS	:: {-# UNPACK #-} !(IORef ExternalPackageState),
550 551 552 553
	        -- ^ Information about the currently loaded external packages.
	        -- This is mutable because packages will be demand-loaded during
	        -- a compilation run as required.
	
554
	hsc_NC	:: {-# UNPACK #-} !(IORef NameCache),
555 556
		-- ^ As with 'hsc_EPS', this is side-effected by compiling to
		-- reflect sucking in interface files.  They cache the state of
557 558
		-- external interface files, in effect.

Simon Marlow's avatar
Simon Marlow committed
559
	hsc_FC   :: {-# UNPACK #-} !(IORef FinderCache),
560
	        -- ^ The cached result of performing finding in the file system
Simon Marlow's avatar
Simon Marlow committed
561
	hsc_MLC  :: {-# UNPACK #-} !(IORef ModLocationCache),
562 563
		-- ^ This caches the location of modules, so we don't have to 
		-- search the filesystem multiple times. See also 'hsc_FC'.
Simon Marlow's avatar
Simon Marlow committed
564

dias@eecs.harvard.edu's avatar
dias@eecs.harvard.edu committed
565
        hsc_OptFuel :: OptFuelState,
566
                -- ^ Settings to control the use of \"optimization fuel\":
dias@eecs.harvard.edu's avatar
dias@eecs.harvard.edu committed
567 568 569
                -- by limiting the number of transformations,
                -- we can use binary search to help find compiler bugs.

570
        hsc_type_env_var :: Maybe (Module, IORef TypeEnv),
571 572 573
                -- ^ Used for one-shot compilation only, to initialise
                -- the 'IfGblEnv'. See 'TcRnTypes.tcg_type_env_var' for 
                -- 'TcRunTypes.TcGblEnv'
574

575
        hsc_global_rdr_env :: GlobalRdrEnv,
576 577 578 579 580
                -- ^ A mapping from 'RdrName's that are in global scope during
                -- the compilation of the current file to more detailed
                -- information about those names. Not necessarily just the
                -- names directly imported by the module being compiled!
        
581
        hsc_global_type_env :: TypeEnv
582 583 584
                -- ^ Typing information about all those things in global scope.
                -- Not necessarily just the things directly imported by the module 
                -- being compiled!
585
 }
586 587 588

hscEPS :: HscEnv -> IO ExternalPackageState
hscEPS hsc_env = readIORef (hsc_EPS hsc_env)
589

590 591 592 593 594 595
-- | A compilation target.
--
-- A target may be supplied with the actual text of the
-- module.  If so, use this instead of the file contents (this
-- is for use in an IDE where the file hasn't been saved by
-- the user yet).
Simon Marlow's avatar
Simon Marlow committed
596
data Target = Target
597 598 599 600 601
      { targetId           :: TargetId  -- ^ module or filename
      , targetAllowObjCode :: Bool      -- ^ object code allowed?
      , targetContents     :: Maybe (StringBuffer,ClockTime)
                                        -- ^ in-memory text buffer?
      }
602 603

data TargetId
Simon Marlow's avatar
Simon Marlow committed
604
  = TargetModule ModuleName
605 606 607 608 609 610
	-- ^ A module name: search for the file
  | TargetFile FilePath (Maybe Phase)
	-- ^ A filename: preprocess & parse it to find the module name.
	-- If specified, the Phase indicates how to compile this file
	-- (which phase to start from).  Nothing indicates the starting phase
	-- should be determined from the suffix of the filename.
611
  deriving Eq
612 613

pprTarget :: Target -> SDoc
Simon Marlow's avatar
Simon Marlow committed
614 615
pprTarget (Target id obj _) = 
   (if obj then char '*' else empty) <> pprTargetId id
616

Ian Lynagh's avatar
Ian Lynagh committed
617 618 619
instance Outputable Target where
    ppr = pprTarget

Simon Marlow's avatar
Simon Marlow committed
620
pprTargetId :: TargetId -> SDoc
621
pprTargetId (TargetModule m) = ppr m
622
pprTargetId (TargetFile f _) = text f
623

Ian Lynagh's avatar
Ian Lynagh committed
624 625 626
instance Outputable TargetId where
    ppr = pprTargetId

627
-- | Helps us find information about modules in the home package
Simon Marlow's avatar
Simon Marlow committed
628
type HomePackageTable  = ModuleNameEnv HomeModInfo
629
	-- Domain = modules in the home package that have been fully compiled
Simon Marlow's avatar
Simon Marlow committed
630
	-- "home" package name cached here for convenience
631 632

-- | Helps us find information about modules in the imported packages
633 634
type PackageIfaceTable = ModuleEnv ModIface
	-- Domain = modules in the imported packages
635

Simon Marlow's avatar
Simon Marlow committed
636
emptyHomePackageTable :: HomePackageTable
Simon Marlow's avatar
Simon Marlow committed
637
emptyHomePackageTable  = emptyUFM
Simon Marlow's avatar
Simon Marlow committed
638 639

emptyPackageIfaceTable :: PackageIfaceTable
640 641
emptyPackageIfaceTable = emptyModuleEnv

642
-- | Information about modules in the package being compiled
643
data HomeModInfo 
644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
  = HomeModInfo {
      hm_iface    :: !ModIface,
        -- ^ The basic loaded interface file: every loaded module has one of
        -- these, even if it is imported from another package
      hm_details  :: !ModDetails,
        -- ^ Extra information that has been created from the 'ModIface' for
	-- the module, typically during typechecking
      hm_linkable :: !(Maybe Linkable)
        -- ^ The actual artifact we would like to link to access things in
	-- this module.
	--
	-- 'hm_linkable' might be Nothing:
	--
	--   1. If this is an .hs-boot module
	--
	--   2. Temporarily during compilation if we pruned away
	--      the old linkable because it was out of date.
	--
	-- After a complete compilation ('GHC.load'), all 'hm_linkable' fields
	-- in the 'HomePackageTable' will be @Just@.
	--
	-- When re-linking a module ('HscMain.HscNoRecomp'), we construct the
	-- 'HomeModInfo' by building a new 'ModDetails' from the old
	-- 'ModIface' (only).
    }
669

670 671
-- | Find the 'ModIface' for a 'Module', searching in both the loaded home
-- and external package module information
Simon Marlow's avatar
Simon Marlow committed
672 673 674 675 676 677 678
lookupIfaceByModule
	:: DynFlags
	-> HomePackageTable
	-> PackageIfaceTable
	-> Module
	-> Maybe ModIface
lookupIfaceByModule dflags hpt pit mod
679 680 681 682 683
  | modulePackageId mod == thisPackage dflags
  = 	-- The module comes from the home package, so look first
	-- in the HPT.  If it's not from the home package it's wrong to look
	-- in the HPT, because the HPT is indexed by *ModuleName* not Module
    fmap hm_iface (lookupUFM hpt (moduleName mod)) 
684
    `mplus` lookupModuleEnv pit mod
685 686 687 688 689 690 691

  | otherwise = lookupModuleEnv pit mod		-- Look in PIT only 

-- If the module does come from the home package, why do we look in the PIT as well?
-- (a) In OneShot mode, even home-package modules accumulate in the PIT
-- (b) Even in Batch (--make) mode, there is *one* case where a home-package
--     module is in the PIT, namely GHC.Prim when compiling the base package.
692
-- We could eliminate (b) if we wanted, by making GHC.Prim belong to a package
693
-- of its own, but it doesn't seem worth the bother.
694
\end{code}
695

696 697

\begin{code}
698
hptInstances :: HscEnv -> (ModuleName -> Bool) -> ([Instance], [FamInst])
699
-- ^ Find all the instance declarations (of classes and families) that are in
700
-- modules imported by this one, directly or indirectly, and are in the Home
701
-- Package Table.  This ensures that we don't see instances from modules @--make@
702
-- compiled before this one, but which are not below this one.
703
hptInstances hsc_env want_this_module
704 705 706 707 708 709 710 711 712 713 714 715
  = let (insts, famInsts) = unzip $ flip hptAllThings hsc_env $ \mod_info -> do
                guard (want_this_module (moduleName (mi_module (hm_iface mod_info))))
                let details = hm_details mod_info
                return (md_insts details, md_fam_insts details)
    in (concat insts, concat famInsts)

hptVectInfo :: HscEnv -> VectInfo
-- ^ Get the combined VectInfo of all modules in the home package table.  In
-- contrast to instances and rules, we don't care whether the modules are
-- \"below\" us in the dependency sense.  The VectInfo of those modules not \"below\" 
-- us does not affect the compilation of the current module.
hptVectInfo = concatVectInfo . hptAllThings ((: []) . md_vect_info . hm_details)
716

Simon Marlow's avatar
Simon Marlow committed
717
hptRules :: HscEnv -> [(ModuleName, IsBootInterface)] -> [CoreRule]
718 719 720
-- ^ Get rules from modules \"below\" this one (in the dependency sense)
hptRules = hptSomeThingsBelowUs (md_rules . hm_details) False

721 722 723 724 725 726

hptAnns :: HscEnv -> Maybe [(ModuleName, IsBootInterface)] -> [Annotation]
-- ^ Get annotations from modules \"below\" this one (in the dependency sense)
hptAnns hsc_env (Just deps) = hptSomeThingsBelowUs (md_anns . hm_details) False hsc_env deps
hptAnns hsc_env Nothing = hptAllThings (md_anns . hm_details) hsc_env

727 728 729 730 731
hptAllThings :: (HomeModInfo -> [a]) -> HscEnv -> [a]
hptAllThings extract hsc_env = concatMap extract (eltsUFM (hsc_HPT hsc_env))

hptSomeThingsBelowUs :: (HomeModInfo -> [a]) -> Bool -> HscEnv -> [(ModuleName, IsBootInterface)] -> [a]
-- Get things from modules \"below\" this one (in the dependency sense)
732
-- C.f Inst.hptInstances
733 734
hptSomeThingsBelowUs extract include_hi_boot hsc_env deps
 | isOneShot (ghcMode (hsc_dflags hsc_env)) = []
735 736 737 738
  | otherwise
  = let 
	hpt = hsc_HPT hsc_env
    in
739
    [ thing
740
    |	-- Find each non-hi-boot module below me
741 742
      (mod, is_boot_mod) <- deps
    , include_hi_boot || not is_boot_mod
743

744
	-- unsavoury: when compiling the base package with --make, we
745
	-- sometimes try to look up RULES etc for GHC.Prim.  GHC.Prim won't
746 747 748
	-- be in the HPT, because we never compile it; it's in the EPT
	-- instead.  ToDo: clean up, and remove this slightly bogus
	-- filter:
Simon Marlow's avatar
Simon Marlow committed
749
    , mod /= moduleName gHC_PRIM
750

751
	-- Look it up in the HPT
752 753 754
    , let things = case lookupUFM hpt mod of
		    Just info -> extract info
		    Nothing -> pprTrace "WARNING in hptSomeThingsBelowUs" msg [] 
Ian Lynagh's avatar
Ian Lynagh committed
755 756
	  msg = vcat [ptext (sLit "missing module") <+> ppr mod,
		      ptext (sLit "Probable cause: out-of-date interface files")]
757
			-- This really shouldn't happen, but see Trac #962
758 759

	-- And get its dfuns
760
    , thing <- things ]
761
\end{code}
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
762

763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786
%************************************************************************
%*									*
\subsection{Dealing with Annotations}
%*									*
%************************************************************************

\begin{code}
prepareAnnotations :: HscEnv -> Maybe ModGuts -> IO AnnEnv
-- ^ Deal with gathering annotations in from all possible places 
--   and combining them into a single 'AnnEnv'
prepareAnnotations hsc_env mb_guts
  = do { eps <- hscEPS hsc_env
       ; let -- Extract annotations from the module being compiled if supplied one
            mb_this_module_anns = fmap (mkAnnEnv . mg_anns) mb_guts
        -- Extract dependencies of the module if we are supplied one,
        -- otherwise load annotations from all home package table
        -- entries regardless of dependency ordering.
            home_pkg_anns  = (mkAnnEnv . hptAnns hsc_env) $ fmap (dep_mods . mg_deps) mb_guts
            other_pkg_anns = eps_ann_env eps
            ann_env        = foldl1' plusAnnEnv $ catMaybes [mb_this_module_anns, 
                                                             Just home_pkg_anns, 
                                                             Just other_pkg_anns]

       ; return ann_env }
787 788
\end{code}

Simon Marlow's avatar
Simon Marlow committed
789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
%************************************************************************
%*									*
\subsection{The Finder cache}
%*									*
%************************************************************************

\begin{code}
-- | The 'FinderCache' maps home module names to the result of
-- searching for that module.  It records the results of searching for
-- modules along the search path.  On @:load@, we flush the entire
-- contents of this cache.
--
-- Although the @FinderCache@ range is 'FindResult' for convenience ,
-- in fact it will only ever contain 'Found' or 'NotFound' entries.
--
type FinderCache = ModuleNameEnv FindResult

-- | The result of searching for an imported module.
data FindResult
  = Found ModLocation Module
809
	-- ^ The module was found
Simon Marlow's avatar
Simon Marlow committed
810
  | NoPackage PackageId
811
	-- ^ The requested package was not found
Simon Marlow's avatar
Simon Marlow committed
812
  | FoundMultiple [PackageId]
813
	-- ^ _Error_: both in multiple packages
814 815 816 817 818 819
  | NotFound [FilePath] (Maybe PackageId) [PackageId] [PackageId]
	-- ^ The module was not found, including either
        --    * the specified places were searched
        --    * the package that this module should have been in
        --    * list of packages in which the module was hidden,
        --    * list of hidden packages containing this module
Simon Marlow's avatar
Simon Marlow committed
820
  | NotFoundInPackage PackageId
821
	-- ^ The module was not found in this package
Simon Marlow's avatar
Simon Marlow committed
822 823 824 825 826 827

-- | Cache that remembers where we found a particular module.  Contains both
-- home modules and package modules.  On @:load@, only home modules are
-- purged from this cache.
type ModLocationCache = ModuleEnv ModLocation
\end{code}
828

829 830
%************************************************************************
%*									*
831
\subsection{Symbol tables and Module details}
832 833 834 835
%*									*
%************************************************************************

\begin{code}
836 837 838 839 840 841 842 843 844
-- | A 'ModIface' plus a 'ModDetails' summarises everything we know 
-- about a compiled module.  The 'ModIface' is the stuff *before* linking,
-- and can be written out to an interface file. The 'ModDetails is after 
-- linking and can be completely recovered from just the 'ModIface'.
-- 
-- When we read an interface file, we also construct a 'ModIface' from it,
-- except that we explicitly make the 'mi_decls' and a few other fields empty;
-- as when reading we consolidate the declarations etc. into a number of indexed
-- maps and environments in the 'ExternalPackageState'.
845 846
data ModIface 
   = ModIface {
847 848 849
        mi_module   :: !Module,             -- ^ Name of the module we are for
        mi_iface_hash :: !Fingerprint,      -- ^ Hash of the whole interface
        mi_mod_hash :: !Fingerprint,	    -- ^ Hash of the ABI only
850

851 852 853
        mi_orphan   :: !WhetherHasOrphans,  -- ^ Whether this module has orphans
        mi_finsts   :: !WhetherHasFamInst,  -- ^ Whether this module has family instances
	mi_boot	    :: !IsBootInterface,    -- ^ Read from an hi-boot file?
854

855
	mi_deps	    :: Dependencies,
Simon Marlow's avatar
Simon Marlow committed
856 857 858 859
	        -- ^ The dependencies of the module.  This is
		-- consulted for directly-imported modules, but not
		-- for anything else (hence lazy)

860 861
        mi_usages   :: [Usage],
                -- ^ Usages; kept sorted so that it's easy to decide
862
		-- whether to write a new iface file (changing usages
863
		-- doesn't affect the hash of this module)
864
        
865
		-- NOT STRICT!  we read this field lazily from the interface file
866
		-- It is *only* consulted by the recompilation checker
867

868 869 870
		-- Exports
		-- Kept sorted by (mod,occ), to make version comparisons easier
        mi_exports  :: ![IfaceExport],
871 872 873 874
                -- ^ Records the modules that are the declaration points for things
                -- exported by this module, and the 'OccName's of those things
        
        mi_exp_hash :: !Fingerprint,	-- ^ Hash of export list
875

876
        mi_fixities :: [(OccName,Fixity)],
877 878
                -- ^ Fixities
        
879
		-- NOT STRICT!  we read this field lazily from the interface file
880

Ian Lynagh's avatar
Ian Lynagh committed
881
	mi_warns  :: Warnings,
882 883
		-- ^ Warnings
		
884
		-- NOT STRICT!  we read this field lazily from the interface file
885

886 887 888 889 890
	mi_anns  :: [IfaceAnnotation],
	        -- ^ Annotations
	
		-- NOT STRICT!  we read this field lazily from the interface file

891
		-- Type, class and variable declarations
892
		-- The hash of an Id changes if its fixity or deprecations change
893 894
		--	(as well as its type of course)
		-- Ditto data constructors, class operations, except that 
895
		-- the hash of the parent class/tycon changes
896
	mi_decls :: [(Fingerprint,IfaceDecl)],	-- ^ Sorted type, variable, class etc. declarations
897

898
        mi_globals  :: !(Maybe GlobalRdrEnv),
899 900
		-- ^ Binds all the things defined at the top level in
		-- the /original source/ code for this module. which
901 902 903 904 905 906 907
		-- is NOT the same as mi_exports, nor mi_decls (which
		-- may contains declarations for things not actually
		-- defined by the user).  Used for GHCi and for inspecting
		-- the contents of modules via the GHC API only.
		--
		-- (We need the source file to figure out the
		-- top-level environment, if we didn't compile this module
908
		-- from source then this field contains @Nothing@).
909 910
		--
		-- Strictly speaking this field should live in the
911
		-- 'HomeModInfo', but that leads to more plumbing.
912

913
		-- Instance declarations and rules
914 915 916 917 918
	mi_insts     :: [IfaceInst],			-- ^ Sorted class instance
	mi_fam_insts :: [IfaceFamInst],			-- ^ Sorted family instances
	mi_rules     :: [IfaceRule],			-- ^ Sorted rules
	mi_orphan_hash :: !Fingerprint,	-- ^ Hash for orphan rules and 
					-- class and family instances
919
					-- combined
920

921
        mi_vect_info :: !IfaceVectInfo, -- ^ Vectorisation information
922

923 924 925
		-- Cached environments for easy lookup
		-- These are computed (lazily) from other fields
		-- and are not put into the interface file
926 927
	mi_warn_fn  :: Name -> Maybe WarningTxt,        -- ^ Cached lookup for 'mi_warns'
	mi_fix_fn  :: OccName -> Fixity,	        -- ^ Cached lookup for 'mi_fixities'
928
	mi_hash_fn :: OccName -> Maybe (OccName, Fingerprint),
929 930
                        -- ^ Cached lookup for 'mi_decls'.
			-- The @Nothing@ in 'mi_hash_fn' means that the thing
931
			-- isn't in decls. It's useful to know that when
932
			-- seeing if we are up to date wrt. the old interface.
933
                        -- The 'OccName' is the parent of the name, if it has one.
934
	mi_hpc    :: !AnyHpcUsage
935
	        -- ^ True if this program uses Hpc at any point in the program.
936
     }
937

938 939 940
-- | The 'ModDetails' is essentially a cache for information in the 'ModIface'
-- for home modules only. Information relating to packages will be loaded into
-- global environments in 'ExternalPackageState'.
941 942
data ModDetails
   = ModDetails {
943 944
	-- The next two fields are created by the typechecker
	md_exports   :: [AvailInfo],
945 946
        md_types     :: !TypeEnv,       -- ^ Local type environment for this particular module
        md_insts     :: ![Instance],    -- ^ 'DFunId's for the instances in this module
947
        md_fam_insts :: ![FamInst],
948
        md_rules     :: ![CoreRule],    -- ^ Domain may include 'Id's from other modules
949 950
        md_anns      :: ![Annotation],  -- ^ Annotations present in this module: currently 
                                        -- they only annotate things also declared in this module
951
        md_vect_info :: !VectInfo       -- ^ Module vectorisation information
952
     }
953

Simon Marlow's avatar
Simon Marlow committed
954
emptyModDetails :: ModDetails
955
emptyModDetails = ModDetails { md_types = emptyTypeEnv,
956
			       md_exports = [],
957 958
			       md_insts     = [],
			       md_rules     = [],
mnislaih's avatar
mnislaih committed
959
			       md_fam_insts = [],
960
                               md_anns      = [],
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
961 962
                               md_vect_info = noVectInfo
                             } 
963

964
-- | Records the modules directly imported by a module for extracting e.g. usage information
965
type ImportedMods = ModuleEnv [(ModuleName, Bool, SrcSpan)]
966 967
-- TODO: we are not actually using the codomain of this type at all, so it can be
-- replaced with ModuleEnv ()
Simon Marlow's avatar
Simon Marlow committed
968

969 970 971 972
-- | A ModGuts is carried through the compiler, accumulating stuff as it goes
-- There is only one ModGuts at any time, the one for the module
-- being compiled right now.  Once it is compiled, a 'ModIface' and 
-- 'ModDetails' are extracted and the ModGuts is dicarded.
973 974
data ModGuts
  = ModGuts {
975 976 977 978 979 980 981 982
        mg_module    :: !Module,         -- ^ Module being compiled
	mg_boot      :: IsBootInterface, -- ^ Whether it's an hs-boot module
	mg_exports   :: ![AvailInfo],	 -- ^ What it exports
	mg_deps	     :: !Dependencies,	 -- ^ What it depends on, directly or
	                                 -- otherwise
	mg_dir_imps  :: !ImportedMods,	 -- ^ Directly-imported modules; used to
					 -- generate initialisation code
	mg_used_names:: !NameSet,	 -- ^ What the module needed (used in 'MkIface.mkIface')
983

984
        mg_rdr_env   :: !GlobalRdrEnv,	 -- ^ Top-level lexical environment
985

986
	-- These fields all describe the things **declared in this module**
987 988 989 990 991 992
	mg_fix_env   :: !FixityEnv,	 -- ^ Fixities declared in this module
	                                 -- TODO: I'm unconvinced this is actually used anywhere
	mg_types     :: !TypeEnv,        -- ^ Types declared in this module
	mg_insts     :: ![Instance],	 -- ^ Class instances declared in this module
	mg_fam_insts :: ![FamInst],	 -- ^ Family instances declared in this module
        mg_rules     :: ![CoreRule],	 -- ^ Before the core pipeline starts, contains 
993
		     			 -- See Note [Overall plumbing for rules] in Rules.lhs
994 995 996
	mg_binds     :: ![CoreBind],	 -- ^ Bindings for this module
	mg_foreign   :: !ForeignStubs,   -- ^ Foreign exports declared in this module
	mg_warns     :: !Warnings,	 -- ^ Warnings declared in the module
997
	mg_anns      :: [Annotation],    -- ^ Annotations declared in this module
998 999 1000
	mg_hpc_info  :: !HpcInfo,        -- ^ Coverage tick boxes in the module
        mg_modBreaks :: !ModBreaks,      -- ^ Breakpoints for the module
        mg_vect_info :: !VectInfo,       -- ^ Pool of vectorised declarations in the module
1001 1002 1003 1004 1005 1006

	-- The next two fields are unusual, because they give instance
	-- environments for *all* modules in the home package, including
	-- this module, rather than for *just* this module.  
	-- Reason: when looking up an instance we don't want to have to
	--	  look at each module in the home package in turn
Thomas Schilling's avatar
Thomas Schilling committed
1007
	mg_inst_env     :: InstEnv,
1008 1009
        -- ^ Class instance environment from /home-package/ modules (including
	-- this one); c.f. 'tcg_inst_env'
Thomas Schilling's avatar
Thomas Schilling committed
1010 1011
	mg_fam_inst_env :: FamInstEnv
        -- ^ Type-family instance enviroment for /home-package/ modules
1012
	-- (including this one); c.f. 'tcg_fam_inst_env'
1013 1014
    }

1015 1016 1017 1018 1019 1020 1021 1022
-- The ModGuts takes on several slightly different forms:
--
-- After simplification, the following fields change slightly:
--	mg_rules	Orphan rules only (local ones now attached to binds)
--	mg_binds	With rules attached

-- | A CoreModule consists of just the fields of a 'ModGuts' that are needed for
-- the 'GHC.compileToCoreModule' interface.
1023 1024
data CoreModule
  = CoreModule {
1025
      -- | Module name
1026
      cm_module   :: !Module,
1027
      -- | Type environment for types declared in this module
1028
      cm_types    :: !TypeEnv,
1029
      -- | Declarations
1030
      cm_binds    :: [CoreBind],
1031
      -- | Imports
1032
      cm_imports  :: ![Module]
1033 1034 1035 1036 1037 1038
    }

instance Outputable CoreModule where
   ppr (CoreModule {cm_module = mn, cm_types = te, cm_binds = cb}) =
      text "%module" <+> ppr mn <+> ppr te $$ vcat (map ppr cb)

1039
-- The ModGuts takes on several slightly different forms:
1040
--
1041 1042 1043 1044 1045
-- After simplification, the following fields change slightly:
--	mg_rules	Orphan rules only (local ones now attached to binds)
--	mg_binds	With rules attached


1046 1047 1048 1049 1050
---------------------------------------------------------
-- The Tidy pass forks the information about this module: 
--	* one lot goes to interface file generation (ModIface)
--	  and later compilations (ModDetails)
--	* the other lot goes to code generation (CgGuts)
1051 1052

-- | A restricted form of 'ModGuts' for code generation purposes
1053 1054
data CgGuts 
  = CgGuts {
1055
	cg_module   :: !Module, -- ^ Module being compiled
1056

1057
	cg_tycons   :: [TyCon],
1058
		-- ^ Algebraic data types (including ones that started
1059
		-- life as classes); generate constructors and info
1060
		-- tables. Includes newtypes, just for the benefit of
1061
		-- External Core
1062

1063
	cg_binds    :: [CoreBind],
1064
		-- ^ The tidied main bindings, including
1065 1066 1067 1068
		-- previously-implicit bindings for record and class
		-- selectors, and data construtor wrappers.  But *not*
		-- data constructor workers; reason: we we regard them
		-- as part of the code-gen of tycons
1069

1070
	cg_dir_imps :: ![Module],
1071
		-- ^ Directly-imported modules; used to generate