HscTypes.lhs 81.1 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, mkPrintUnqualified, extendInteractiveContext,
mnislaih's avatar
mnislaih committed
58
        substInteractiveContext,
59

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

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

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

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

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

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

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

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

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

#include "HsVersions.h"

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

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

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

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

170

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

177 178 179 180 181 182

\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.
183 184 185 186 187 188
data Session = Session !(IORef HscEnv) !(IORef WarningMessages)

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

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

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 298
-- | 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
299 300 301 302 303 304 305 306 307 308
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

309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
-- | 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
327 328 329
  gblock (Ghc m)   = Ghc $ \s -> gblock (m s)
  gunblock (Ghc m) = Ghc $ \s -> gunblock (m s)

330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
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
345

346 347 348 349 350 351 352 353 354 355 356 357 358
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
359 360
  gblock (GhcT m) = GhcT $ \s -> gblock (m s)
  gunblock (GhcT m) = GhcT $ \s -> gunblock (m s)
361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392

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
393
    Nothing -> liftIO $ throwIO (mkSrcErr errs)
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
    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
423

424 425 426
-- > Dual to 'reflectGhc'.  See its documentation.
reifyGhc :: (Session -> IO a) -> Ghc a
reifyGhc act = Ghc $ act
427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444

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)
445 446
\end{code}

447
\begin{code}
448 449 450 451 452 453 454 455 456 457 458 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
-- | 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
484 485
  hsc_env' <- getSession
  setSession (hsc_env' { hsc_callbacks = cb0 })
486 487 488 489 490 491
  return r

\end{code}

\begin{code}
-- | Hscenv is like 'Session', except that some of the fields are immutable.
492 493 494 495 496 497 498 499 500
-- 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.
501
data HscEnv 
502 503
  = HscEnv { 
	hsc_dflags :: DynFlags,
504
		-- ^ The dynamic flag settings
505

506 507 508
        hsc_callbacks :: GhcApiCallbacks,
                -- ^ Callbacks for the GHC API.

509
	hsc_targets :: [Target],
510
		-- ^ The targets (or roots) of the current session
511

512
	hsc_mod_graph :: ModuleGraph,
513
		-- ^ The module graph of the current session
514 515

	hsc_IC :: InteractiveContext,
516
		-- ^ The context for evaluating interactive statements
517 518

	hsc_HPT    :: HomePackageTable,
519 520
		-- ^ The home package table describes already-compiled
		-- home-package modules, /excluding/ the module we 
521 522 523
		-- are compiling right now.
		-- (In one-shot mode the current module is the only
		--  home-package module, so hsc_HPT is empty.  All other
524
		--  modules count as \"external-package\" modules.
525
		--  However, even in GHCi mode, hi-boot interfaces are
526
		--  demand-loaded into the external-package table.)
527
		--
528
		-- 'hsc_HPT' is not mutable because we only demand-load 
529
		-- external packages; the home package is eagerly 
530
		-- loaded, module by module, by the compilation manager.
531
		--	
532
		-- The HPT may contain modules compiled earlier by @--make@
533
		-- but not actually below the current module in the dependency
534 535 536
		-- graph.

		-- (This changes a previous invariant: changed Jan 05.)
537
	
538
	hsc_EPS	:: {-# UNPACK #-} !(IORef ExternalPackageState),
539 540 541 542
	        -- ^ Information about the currently loaded external packages.
	        -- This is mutable because packages will be demand-loaded during
	        -- a compilation run as required.
	
543
	hsc_NC	:: {-# UNPACK #-} !(IORef NameCache),
544 545
		-- ^ As with 'hsc_EPS', this is side-effected by compiling to
		-- reflect sucking in interface files.  They cache the state of
546 547
		-- external interface files, in effect.

Simon Marlow's avatar
Simon Marlow committed
548
	hsc_FC   :: {-# UNPACK #-} !(IORef FinderCache),
549
	        -- ^ The cached result of performing finding in the file system
Simon Marlow's avatar
Simon Marlow committed
550
	hsc_MLC  :: {-# UNPACK #-} !(IORef ModLocationCache),
551 552
		-- ^ 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
553

dias@eecs.harvard.edu's avatar
dias@eecs.harvard.edu committed
554
        hsc_OptFuel :: OptFuelState,
555
                -- ^ Settings to control the use of \"optimization fuel\":
dias@eecs.harvard.edu's avatar
dias@eecs.harvard.edu committed
556 557 558
                -- by limiting the number of transformations,
                -- we can use binary search to help find compiler bugs.

559
        hsc_type_env_var :: Maybe (Module, IORef TypeEnv),
560 561 562
                -- ^ Used for one-shot compilation only, to initialise
                -- the 'IfGblEnv'. See 'TcRnTypes.tcg_type_env_var' for 
                -- 'TcRunTypes.TcGblEnv'
563

564
        hsc_global_rdr_env :: GlobalRdrEnv,
565 566 567 568 569
                -- ^ 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!
        
570
        hsc_global_type_env :: TypeEnv
571 572 573
                -- ^ Typing information about all those things in global scope.
                -- Not necessarily just the things directly imported by the module 
                -- being compiled!
574
 }
575 576 577

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

579 580 581 582 583 584
-- | 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
585
data Target = Target
586 587 588 589 590
      { targetId           :: TargetId  -- ^ module or filename
      , targetAllowObjCode :: Bool      -- ^ object code allowed?
      , targetContents     :: Maybe (StringBuffer,ClockTime)
                                        -- ^ in-memory text buffer?
      }
591 592

data TargetId
Simon Marlow's avatar
Simon Marlow committed
593
  = TargetModule ModuleName
594 595 596 597 598 599
	-- ^ 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.
600
  deriving Eq
601 602

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

Ian Lynagh's avatar
Ian Lynagh committed
606 607 608
instance Outputable Target where
    ppr = pprTarget

Simon Marlow's avatar
Simon Marlow committed
609
pprTargetId :: TargetId -> SDoc
610
pprTargetId (TargetModule m) = ppr m
611
pprTargetId (TargetFile f _) = text f
612

Ian Lynagh's avatar
Ian Lynagh committed
613 614 615
instance Outputable TargetId where
    ppr = pprTargetId

616
-- | Helps us find information about modules in the home package
Simon Marlow's avatar
Simon Marlow committed
617
type HomePackageTable  = ModuleNameEnv HomeModInfo
618
	-- Domain = modules in the home package that have been fully compiled
Simon Marlow's avatar
Simon Marlow committed
619
	-- "home" package name cached here for convenience
620 621

-- | Helps us find information about modules in the imported packages
622 623
type PackageIfaceTable = ModuleEnv ModIface
	-- Domain = modules in the imported packages
624

Simon Marlow's avatar
Simon Marlow committed
625
emptyHomePackageTable :: HomePackageTable
Simon Marlow's avatar
Simon Marlow committed
626
emptyHomePackageTable  = emptyUFM
Simon Marlow's avatar
Simon Marlow committed
627 628

emptyPackageIfaceTable :: PackageIfaceTable
629 630
emptyPackageIfaceTable = emptyModuleEnv

631
-- | Information about modules in the package being compiled
632
data HomeModInfo 
633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657
  = 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).
    }
658

659 660
-- | Find the 'ModIface' for a 'Module', searching in both the loaded home
-- and external package module information
Simon Marlow's avatar
Simon Marlow committed
661 662 663 664 665 666 667
lookupIfaceByModule
	:: DynFlags
	-> HomePackageTable
	-> PackageIfaceTable
	-> Module
	-> Maybe ModIface
lookupIfaceByModule dflags hpt pit mod
668 669 670 671 672
  | 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)) 
673
    `mplus` lookupModuleEnv pit mod
674 675 676 677 678 679 680

  | 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.
681
-- We could eliminate (b) if we wanted, by making GHC.Prim belong to a package
682
-- of its own, but it doesn't seem worth the bother.
683
\end{code}
684

685 686

\begin{code}
687
hptInstances :: HscEnv -> (ModuleName -> Bool) -> ([Instance], [FamInst])
688
-- ^ Find all the instance declarations (of classes and families) that are in
689
-- modules imported by this one, directly or indirectly, and are in the Home
690
-- Package Table.  This ensures that we don't see instances from modules @--make@
691
-- compiled before this one, but which are not below this one.
692
hptInstances hsc_env want_this_module
693 694 695 696 697 698 699 700 701 702 703 704
  = 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)
705

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

710 711 712 713 714 715

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

716 717 718 719 720
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)
721
-- C.f Inst.hptInstances
722 723
hptSomeThingsBelowUs extract include_hi_boot hsc_env deps
 | isOneShot (ghcMode (hsc_dflags hsc_env)) = []
724 725 726 727
  | otherwise
  = let 
	hpt = hsc_HPT hsc_env
    in
728
    [ thing
729
    |	-- Find each non-hi-boot module below me
730 731
      (mod, is_boot_mod) <- deps
    , include_hi_boot || not is_boot_mod
732

733
	-- unsavoury: when compiling the base package with --make, we
734
	-- sometimes try to look up RULES etc for GHC.Prim.  GHC.Prim won't
735 736 737
	-- 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
738
    , mod /= moduleName gHC_PRIM
739

740
	-- Look it up in the HPT
741 742 743
    , let things = case lookupUFM hpt mod of
		    Just info -> extract info
		    Nothing -> pprTrace "WARNING in hptSomeThingsBelowUs" msg [] 
Ian Lynagh's avatar
Ian Lynagh committed
744 745
	  msg = vcat [ptext (sLit "missing module") <+> ppr mod,
		      ptext (sLit "Probable cause: out-of-date interface files")]
746
			-- This really shouldn't happen, but see Trac #962
747 748

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

752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775
%************************************************************************
%*									*
\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 }
776 777
\end{code}

Simon Marlow's avatar
Simon Marlow committed
778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
%************************************************************************
%*									*
\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
798
	-- ^ The module was found
Simon Marlow's avatar
Simon Marlow committed
799
  | NoPackage PackageId
800
	-- ^ The requested package was not found
Simon Marlow's avatar
Simon Marlow committed
801
  | FoundMultiple [PackageId]
802
	-- ^ _Error_: both in multiple packages
Simon Marlow's avatar
Simon Marlow committed
803
  | PackageHidden PackageId
804
	-- ^ For an explicit source import, the package containing the module is
Simon Marlow's avatar
Simon Marlow committed
805 806
	-- not exposed.
  | ModuleHidden  PackageId
807
	-- ^ For an explicit source import, the package containing the module is
Simon Marlow's avatar
Simon Marlow committed
808
	-- exposed, but the module itself is hidden.
809
  | NotFound [FilePath] (Maybe PackageId)
810
	-- ^ The module was not found, the specified places were searched
Simon Marlow's avatar
Simon Marlow committed
811
  | NotFoundInPackage PackageId
812
	-- ^ The module was not found in this package
Simon Marlow's avatar
Simon Marlow committed
813 814 815 816 817 818

-- | 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}
819

820 821
%************************************************************************
%*									*
822
\subsection{Symbol tables and Module details}
823 824 825 826
%*									*
%************************************************************************

\begin{code}
827 828 829 830 831 832 833 834 835
-- | 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'.
836 837
data ModIface 
   = ModIface {
838 839 840
        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
841

842 843 844
        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?
845

846
	mi_deps	    :: Dependencies,
847 848 849
	        -- ^ The dependencies of the module, consulted for directly
	        -- imported modules only
	
850 851
		-- This is consulted for directly-imported modules,
		-- but not for anything else (hence lazy)
852 853
        mi_usages   :: [Usage],
                -- ^ Usages; kept sorted so that it's easy to decide
854
		-- whether to write a new iface file (changing usages
855
		-- doesn't affect the hash of this module)
856
        
857
		-- NOT STRICT!  we read this field lazily from the interface file
858
		-- It is *only* consulted by the recompilation checker
859

860 861 862
		-- Exports
		-- Kept sorted by (mod,occ), to make version comparisons easier
        mi_exports  :: ![IfaceExport],
863 864 865 866
                -- ^ 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
867

868
        mi_fixities :: [(OccName,Fixity)],
869 870
                -- ^ Fixities
        
871
		-- NOT STRICT!  we read this field lazily from the interface file
872

Ian Lynagh's avatar
Ian Lynagh committed
873
	mi_warns  :: Warnings,
874 875
		-- ^ Warnings
		
876
		-- NOT STRICT!  we read this field lazily from the interface file
877

878 879 880 881 882
	mi_anns  :: [IfaceAnnotation],
	        -- ^ Annotations
	
		-- NOT STRICT!  we read this field lazily from the interface file

883
		-- Type, class and variable declarations
884
		-- The hash of an Id changes if its fixity or deprecations change
885 886
		--	(as well as its type of course)
		-- Ditto data constructors, class operations, except that 
887
		-- the hash of the parent class/tycon changes
888
	mi_decls :: [(Fingerprint,IfaceDecl)],	-- ^ Sorted type, variable, class etc. declarations
889

890
        mi_globals  :: !(Maybe GlobalRdrEnv),
891 892
		-- ^ Binds all the things defined at the top level in
		-- the /original source/ code for this module. which
893 894 895 896 897 898 899
		-- 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
900
		-- from source then this field contains @Nothing@).
901 902
		--
		-- Strictly speaking this field should live in the
903
		-- 'HomeModInfo', but that leads to more plumbing.
904

905
		-- Instance declarations and rules
906 907 908 909 910
	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
911
					-- combined
912

913
        mi_vect_info :: !IfaceVectInfo, -- ^ Vectorisation information
914

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

930 931 932
-- | 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'.
933 934
data ModDetails
   = ModDetails {
935 936
	-- The next two fields are created by the typechecker
	md_exports   :: [AvailInfo],
937 938
        md_types     :: !TypeEnv,       -- ^ Local type environment for this particular module
        md_insts     :: ![Instance],    -- ^ 'DFunId's for the instances in this module
939
        md_fam_insts :: ![FamInst],
940
        md_rules     :: ![CoreRule],    -- ^ Domain may include 'Id's from other modules
941 942
        md_anns      :: ![Annotation],  -- ^ Annotations present in this module: currently 
                                        -- they only annotate things also declared in this module
943
        md_vect_info :: !VectInfo       -- ^ Module vectorisation information
944
     }
945

Simon Marlow's avatar
Simon Marlow committed
946
emptyModDetails :: ModDetails
947
emptyModDetails = ModDetails { md_types = emptyTypeEnv,
948
			       md_exports = [],
949 950
			       md_insts     = [],
			       md_rules     = [],
mnislaih's avatar
mnislaih committed
951
			       md_fam_insts = [],
952
                               md_anns      = [],
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
953 954
                               md_vect_info = noVectInfo
                             } 
955

956
-- | Records the modules directly imported by a module for extracting e.g. usage information
957
type ImportedMods = ModuleEnv [(ModuleName, Bool, SrcSpan)]
958 959
-- 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
960

961 962 963 964
-- | 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.
965 966
data ModGuts
  = ModGuts {
967 968 969 970 971 972 973 974
        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')
975

976
        mg_rdr_env   :: !GlobalRdrEnv,	 -- ^ Top-level lexical environment
977

978
	-- These fields all describe the things **declared in this module**
979 980 981 982 983 984 985 986 987 988 989 990
	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 
                                         -- rules declared in this module. After the core
                                         -- pipeline starts, it is changed to contain all
                                         -- known rules for those things imported
	mg_binds     :: ![CoreBind],	 -- ^ Bindings for this module
	mg_foreign   :: !ForeignStubs,   -- ^ Foreign exports declared in this module
	mg_warns     :: !Warnings,	 -- ^ Warnings declared in the module
991
	mg_anns      :: [Annotation],    -- ^ Annotations declared in this module
992 993 994
	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
995 996 997 998 999 1000

	-- 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
1001
	mg_inst_env     :: InstEnv,
1002 1003
        -- ^ Class instance environment from /home-package/ modules (including
	-- this one); c.f. 'tcg_inst_env'
Thomas Schilling's avatar
Thomas Schilling committed
1004 1005
	mg_fam_inst_env :: FamInstEnv
        -- ^ Type-family instance enviroment for /home-package/ modules
1006
	-- (including this one); c.f. 'tcg_fam_inst_env'
1007 1008
    }

1009 1010 1011 1012 1013 1014 1015 1016
-- 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.
1017 1018
data CoreModule
  = CoreModule {
1019
      -- | Module name
1020
      cm_module   :: !Module,
1021
      -- | Type environment for types declared in this module
1022
      cm_types    :: !TypeEnv,
1023
      -- | Declarations
1024
      cm_binds    :: [CoreBind],
1025
      -- | Imports
1026
      cm_imports  :: ![Module]
1027 1028 1029 1030 1031 1032
    }

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)

1033
-- The ModGuts takes on several slightly different forms:
1034
--
1035 1036 1037 1038