hscMain, newHscEnv, hscCmmFile,
hscBufferCheck, hscFileCheck,
#ifdef GHCI
- , hscStmt, hscTcExpr, hscKcType
- , hscGetInfo, GetInfoResult
- , compileExpr
+ hscStmt, hscTcExpr, hscKcType,
+ hscGetInfo, GetInfoResult,
+ compileExpr,
#endif
) where
import SrcLoc ( SrcLoc, noSrcLoc )
#endif
+import Module ( emptyModuleEnv )
import RdrName ( RdrName )
import HsSyn ( HsModule )
import SrcLoc ( Located(..) )
= do { eps_var <- newIORef initExternalPackageState
; us <- mkSplitUniqSupply 'r'
; nc_var <- newIORef (initNameCache us knownKeyNames)
+ ; fc_var <- newIORef emptyModuleEnv
; return (HscEnv { hsc_dflags = dflags,
+ hsc_targets = [],
+ hsc_mod_graph = [],
+ hsc_IC = emptyInteractiveContext,
hsc_HPT = emptyHomePackageTable,
hsc_EPS = eps_var,
- hsc_NC = nc_var } ) }
+ hsc_NC = nc_var,
+ hsc_FC = fc_var } ) }
knownKeyNames :: [Name] -- Put here to avoid loops involving DsMeta,
source_unchanged have_object maybe_old_iface
= do {
(recomp_reqd, maybe_checked_iface) <-
- _scc_ "checkOldIface"
+ {-# SCC "checkOldIface" #-}
checkOldIface hsc_env mod_summary
source_unchanged maybe_old_iface;
= do { compilationProgressMsg (hsc_dflags hsc_env) $
("Skipping " ++ showModMsg have_object mod_summary)
- ; new_details <- _scc_ "tcRnIface"
+ ; new_details <- {-# SCC "tcRnIface" #-}
typecheckIface hsc_env old_iface ;
; dumpIfaceStats hsc_env
-------------------
-- RENAME and TYPECHECK
-------------------
- ; (tc_msgs, maybe_tc_result) <- _scc_ "TypeCheck"
+ ; (tc_msgs, maybe_tc_result) <- {-# SCC "TypeCheck" #-}
tcRnExtCore hsc_env rdr_module
; msg_act tc_msgs
; case maybe_tc_result of
-- RENAME and TYPECHECK
-------------------
(tc_msgs, maybe_tc_result)
- <- _scc_ "Typecheck-Rename"
+ <- {-# SCC "Typecheck-Rename" #-}
tcRnModule hsc_env (ms_hsc_src mod_summary) rdr_module
; msg_act tc_msgs
-------------------
-- DESUGAR
-------------------
- ; (warns, maybe_ds_result) <- _scc_ "DeSugar"
+ ; (warns, maybe_ds_result) <- {-# SCC "DeSugar" #-}
deSugar hsc_env tc_result
; msg_act (warns, emptyBag)
; case maybe_ds_result of
hscBootBackEnd hsc_env mod_summary maybe_checked_iface Nothing
= return HscFail
hscBootBackEnd hsc_env mod_summary maybe_checked_iface (Just ds_result)
- = do { final_iface <- _scc_ "MkFinalIface"
+ = do { final_iface <- {-# SCC "MkFinalIface" #-}
mkIface hsc_env (ms_location mod_summary)
maybe_checked_iface ds_result
-------------------
-- FLATTENING
-------------------
- ; flat_result <- _scc_ "Flattening"
+ ; flat_result <- {-# SCC "Flattening" #-}
flatten hsc_env ds_result
-------------------
-- SIMPLIFY
-------------------
- ; simpl_result <- _scc_ "Core2Core"
+ ; simpl_result <- {-# SCC "Core2Core" #-}
core2core hsc_env flat_result
-------------------
-- TIDY
-------------------
- ; tidy_result <- _scc_ "CoreTidy"
+ ; tidy_result <- {-# SCC "CoreTidy" #-}
tidyCorePgm hsc_env simpl_result
-- Emit external core
-- This has to happen *after* code gen so that the back-end
-- info has been set. Not yet clear if it matters waiting
-- until after code output
- ; new_iface <- _scc_ "MkFinalIface"
+ ; new_iface <- {-# SCC "MkFinalIface" #-}
mkIface hsc_env (ms_location mod_summary)
maybe_checked_iface tidy_result
hscBufferTypecheck hsc_env rdr_module msg_act
hscBufferTypecheck hsc_env rdr_module msg_act = do
- (tc_msgs, maybe_tc_result) <- _scc_ "Typecheck-Rename"
+ (tc_msgs, maybe_tc_result) <- {-# SCC "Typecheck-Rename" #-}
tcRnModule hsc_env HsSrcFile rdr_module
msg_act tc_msgs
case maybe_tc_result of
-------------------
-- PREPARE FOR CODE GENERATION
-- Do saturation and convert to A-normal form
- prepd_binds <- _scc_ "CorePrep"
+ prepd_binds <- {-# SCC "CorePrep" #-}
corePrepPgm dflags core_binds type_env;
case hscTarget dflags of
other ->
do
----------------- Convert to STG ------------------
- (stg_binds, cost_centre_info) <- _scc_ "CoreToStg"
+ (stg_binds, cost_centre_info) <- {-# SCC "CoreToStg" #-}
myCoreToStg dflags this_mod prepd_binds
------------------ Code generation ------------------
- abstractC <- _scc_ "CodeGen"
+ abstractC <- {-# SCC "CodeGen" #-}
codeGen dflags this_mod type_env foreign_stubs
dir_imps cost_centre_info stg_binds
myParseModule dflags src_filename maybe_src_buf
- = do -------------------------- Parser ----------------
- showPass dflags "Parser"
- _scc_ "Parser" do
+ = -------------------------- Parser ----------------
+ showPass dflags "Parser" >>
+ {-# SCC "Parser" #-} do
-- sometimes we already have the buffer in memory, perhaps
-- because we needed to parse the imports out of it, or get the
myCoreToStg dflags this_mod prepd_binds
= do
- stg_binds <- _scc_ "Core2Stg"
+ stg_binds <- {-# SCC "Core2Stg" #-}
coreToStg dflags prepd_binds
- (stg_binds2, cost_centre_info) <- _scc_ "Core2Stg"
+ (stg_binds2, cost_centre_info) <- {-# SCC "Core2Stg" #-}
stg2stg dflags this_mod stg_binds
return (stg_binds2, cost_centre_info)
#ifdef GHCI
hscStmt -- Compile a stmt all the way to an HValue, but don't run it
:: HscEnv
- -> InteractiveContext -- Context for compiling
-> String -- The statement
- -> IO (Maybe (InteractiveContext, [Name], HValue))
+ -> IO (Maybe (HscEnv, [Name], HValue))
-hscStmt hsc_env icontext stmt
+hscStmt hsc_env stmt
= do { maybe_stmt <- hscParseStmt (hsc_dflags hsc_env) stmt
; case maybe_stmt of {
Nothing -> return Nothing ; -- Parse error
Just (Just parsed_stmt) -> do { -- The real stuff
-- Rename and typecheck it
- maybe_tc_result
- <- tcRnStmt hsc_env icontext parsed_stmt
+ let icontext = hsc_IC hsc_env
+ ; maybe_tc_result <- tcRnStmt hsc_env icontext parsed_stmt
; case maybe_tc_result of {
Nothing -> return Nothing ;
(ic_type_env new_ic)
tc_expr
- ; return (Just (new_ic, bound_names, hval))
+ ; return (Just (hsc_env{ hsc_IC=new_ic }, bound_names, hval))
}}}}}
hscTcExpr -- Typecheck an expression (but don't run it)
:: HscEnv
- -> InteractiveContext -- Context for compiling
-> String -- The expression
-> IO (Maybe Type)
-hscTcExpr hsc_env icontext expr
+hscTcExpr hsc_env expr
= do { maybe_stmt <- hscParseStmt (hsc_dflags hsc_env) expr
+ ; let icontext = hsc_IC hsc_env
; case maybe_stmt of {
Nothing -> return Nothing ; -- Parse error
Just (Just (L _ (ExprStmt expr _)))
hscKcType -- Find the kind of a type
:: HscEnv
- -> InteractiveContext -- Context for compiling
-> String -- The type
-> IO (Maybe Kind)
-hscKcType hsc_env icontext str
+hscKcType hsc_env str
= do { maybe_type <- hscParseType (hsc_dflags hsc_env) str
+ ; let icontext = hsc_IC hsc_env
; case maybe_type of {
Just ty -> tcRnType hsc_env icontext ty ;
Just other -> do { errorMsg ("not an type: `" ++ str ++ "'") ;
-- Nothing => Parse error (message already printed)
-- Just x => success
hscParseThing parser dflags str
- = do showPass dflags "Parser"
- _scc_ "Parser" do
+ = showPass dflags "Parser" >>
+ {-# SCC "Parser" #-} do
buf <- stringToStringBuffer str
#ifdef GHCI
hscGetInfo -- like hscStmt, but deals with a single identifier
:: HscEnv
- -> InteractiveContext -- Context for compiling
-> String -- The identifier
-> IO [GetInfoResult]
-hscGetInfo hsc_env ic str
+hscGetInfo hsc_env str
= do maybe_rdr_name <- hscParseIdentifier (hsc_dflags hsc_env) str
case maybe_rdr_name of {
Nothing -> return [];
Just (L _ rdr_name) -> do
- maybe_tc_result <- tcRnGetInfo hsc_env ic rdr_name
+ maybe_tc_result <- tcRnGetInfo hsc_env (hsc_IC hsc_env) rdr_name
case maybe_tc_result of
Nothing -> return []