HscResult(..),
hscMain, newHscEnv, hscCmmFile,
hscFileCheck,
+ hscParseIdentifier,
#ifdef GHCI
hscStmt, hscTcExpr, hscKcType,
- hscGetInfo, GetInfoResult,
compileExpr,
#endif
) where
#include "HsVersions.h"
#ifdef GHCI
-import HsSyn ( Stmt(..), LStmt, LHsExpr, LHsType )
-import IfaceSyn ( IfaceDecl, IfaceInst )
+import HsSyn ( Stmt(..), LHsExpr, LStmt, LHsType )
import Module ( Module )
import CodeOutput ( outputForeignStubs )
import ByteCodeGen ( byteCodeGen, coreExprToBCOs )
import Linker ( HValue, linkExpr )
-import TidyPgm ( tidyCoreExpr )
+import CoreTidy ( tidyExpr )
import CorePrep ( corePrepExpr )
import Flattening ( flattenExpr )
-import TcRnDriver ( tcRnStmt, tcRnExpr, tcRnGetInfo, GetInfoResult, tcRnType )
-import RdrName ( rdrNameOcc )
-import OccName ( occNameUserString )
+import TcRnDriver ( tcRnStmt, tcRnExpr, tcRnType )
import Type ( Type )
import PrelNames ( iNTERACTIVE )
-import StringBuffer ( stringToStringBuffer )
import Kind ( Kind )
import CoreLint ( lintUnfolding )
import DsMeta ( templateHaskellNames )
-import BasicTypes ( Fixity )
-import SrcLoc ( SrcLoc, noSrcLoc )
+import SrcLoc ( noSrcLoc )
+import VarEnv ( emptyTidyEnv )
#endif
import Var ( Id )
-import Module ( emptyModuleEnv )
-import RdrName ( RdrName )
-import HsSyn ( HsModule, LHsBinds )
+import Module ( emptyModuleEnv, ModLocation(..) )
+import RdrName ( GlobalRdrEnv, RdrName )
+import HsSyn ( HsModule, LHsBinds, HsGroup )
import SrcLoc ( Located(..) )
-import StringBuffer ( hGetStringBuffer )
+import StringBuffer ( hGetStringBuffer, stringToStringBuffer )
import Parser
import Lexer ( P(..), ParseResult(..), mkPState )
import SrcLoc ( mkSrcLoc )
import TcRnDriver ( tcRnModule, tcRnExtCore )
-import TcRnTypes ( TcGblEnv(..) )
import TcIface ( typecheckIface )
+import TcRnMonad ( initIfaceCheck, TcGblEnv(..) )
import IfaceEnv ( initNameCache )
import LoadIface ( ifaceStats, initExternalPackageState )
import PrelInfo ( wiredInThings, basicKnownKeyNames )
-import RdrName ( GlobalRdrEnv )
-import MkIface ( checkOldIface, mkIface )
+import MkIface ( checkOldIface, mkIface, writeIfaceFile )
import Desugar
import Flattening ( flatten )
import SimplCore
-import TidyPgm ( tidyCorePgm )
+import TidyPgm ( tidyProgram, mkBootModDetails )
import CorePrep ( corePrepPgm )
import CoreToStg ( coreToStg )
+import TyCon ( isDataTyCon )
+import Packages ( mkHomeModules )
import Name ( Name, NamedThing(..) )
import SimplStg ( stg2stg )
import CodeGen ( codeGen )
import CodeOutput ( codeOutput )
import DynFlags
-import DriverPhases ( HscSource(..) )
import ErrUtils
import UniqSupply ( mkSplitUniqSupply )
import ParserCoreUtils
import FastString
import Maybes ( expectJust )
-import StringBuffer ( StringBuffer )
-import Bag ( unitBag, emptyBag )
-
+import Bag ( unitBag )
import Monad ( when )
import Maybe ( isJust )
import IO
= HscFail
-- In IDE mode: we just do the static/dynamic checks
- | HscChecked (Located (HsModule RdrName)) (Maybe (LHsBinds Id, GlobalRdrEnv))
+ | HscChecked
+ (Located (HsModule RdrName)) -- parsed
+ (Maybe (HsGroup Name)) -- renamed
+ (Maybe (LHsBinds Id, GlobalRdrEnv, ModDetails)) -- typechecked
-- Concluded that it wasn't necessary
| HscNoRecomp ModDetails -- new details (HomeSymbolTable additions)
hscMain
:: HscEnv
- -> MessageAction -- What to do with errors/warnings
-> ModSummary
-> Bool -- True <=> source unchanged
-> Bool -- True <=> have an object file (for msgs only)
-> Maybe ModIface -- Old interface, if available
+ -> Maybe (Int, Int) -- Just (i,n) <=> module i of n (for msgs)
-> IO HscResult
-hscMain hsc_env msg_act mod_summary
+hscMain hsc_env mod_summary
source_unchanged have_object maybe_old_iface
+ mb_mod_index
= do {
(recomp_reqd, maybe_checked_iface) <-
{-# SCC "checkOldIface" #-}
what_next | recomp_reqd || no_old_iface = hscRecomp
| otherwise = hscNoRecomp
- ; what_next hsc_env msg_act mod_summary have_object
+ ; what_next hsc_env mod_summary have_object
maybe_checked_iface
+ mb_mod_index
}
------------------------------
--- hscNoRecomp definitely expects to have the old interface available
-hscNoRecomp hsc_env msg_act mod_summary
+hscNoRecomp hsc_env mod_summary
have_object (Just old_iface)
+ mb_mod_index
| isOneShot (ghcMode (hsc_dflags hsc_env))
= do {
compilationProgressMsg (hsc_dflags hsc_env) $
}
| otherwise
= do { compilationProgressMsg (hsc_dflags hsc_env) $
- ("Skipping " ++ showModMsg have_object mod_summary)
+ (showModuleIndex mb_mod_index ++
+ "Skipping " ++ showModMsg have_object mod_summary)
; new_details <- {-# SCC "tcRnIface" #-}
- typecheckIface hsc_env old_iface ;
+ initIfaceCheck hsc_env $
+ typecheckIface old_iface ;
; dumpIfaceStats hsc_env
; return (HscNoRecomp new_details old_iface)
}
+hscNoRecomp hsc_env mod_summary
+ have_object Nothing
+ mb_mod_index
+ = panic "hscNoRecomp" -- hscNoRecomp definitely expects to
+ -- have the old interface available
+
------------------------------
-hscRecomp hsc_env msg_act mod_summary
- have_object maybe_checked_iface
+hscRecomp hsc_env mod_summary
+ have_object maybe_old_iface
+ mb_mod_index
= case ms_hsc_src mod_summary of
- HsSrcFile -> do
- front_res <- hscFileFrontEnd hsc_env msg_act mod_summary
- hscBackEnd hsc_env mod_summary maybe_checked_iface front_res
+ HsSrcFile -> do
+ front_res <- hscFileFrontEnd hsc_env mod_summary mb_mod_index
+ case ghcMode (hsc_dflags hsc_env) of
+ JustTypecheck -> hscBootBackEnd hsc_env mod_summary maybe_old_iface front_res
+ _ -> hscBackEnd hsc_env mod_summary maybe_old_iface front_res
HsBootFile -> do
- front_res <- hscFileFrontEnd hsc_env msg_act mod_summary
- hscBootBackEnd hsc_env mod_summary maybe_checked_iface front_res
+ front_res <- hscFileFrontEnd hsc_env mod_summary mb_mod_index
+ hscBootBackEnd hsc_env mod_summary maybe_old_iface front_res
ExtCoreFile -> do
- front_res <- hscCoreFrontEnd hsc_env msg_act mod_summary
- hscBackEnd hsc_env mod_summary maybe_checked_iface front_res
+ front_res <- hscCoreFrontEnd hsc_env mod_summary
+ hscBackEnd hsc_env mod_summary maybe_old_iface front_res
-hscCoreFrontEnd hsc_env msg_act mod_summary = do {
+hscCoreFrontEnd hsc_env mod_summary = do {
-------------------
-- PARSE
-------------------
; inp <- readFile (expectJust "hscCoreFrontEnd" (ms_hspp_file mod_summary))
; case parseCore inp 1 of
- FailP s -> putMsg s{-ToDo: wrong-} >> return Nothing
+ FailP s -> errorMsg (hsc_dflags hsc_env) (text s{-ToDo: wrong-}) >> return Nothing
OkP rdr_module -> do {
-------------------
-------------------
; (tc_msgs, maybe_tc_result) <- {-# SCC "TypeCheck" #-}
tcRnExtCore hsc_env rdr_module
- ; msg_act tc_msgs
+ ; printErrorsAndWarnings (hsc_dflags hsc_env) tc_msgs
; case maybe_tc_result of
Nothing -> return Nothing
Just mod_guts -> return (Just mod_guts) -- No desugaring to do!
}}
-hscFileFrontEnd hsc_env msg_act mod_summary = do {
+hscFileFrontEnd hsc_env mod_summary mb_mod_index = do {
-------------------
-- DISPLAY PROGRESS MESSAGE
-------------------
- let one_shot = isOneShot (ghcMode (hsc_dflags hsc_env))
- ; let dflags = hsc_dflags hsc_env
- ; let toInterp = hscTarget dflags == HscInterpreted
+ ; let dflags = hsc_dflags hsc_env
+ one_shot = isOneShot (ghcMode dflags)
+ toInterp = hscTarget dflags == HscInterpreted
; when (not one_shot) $
compilationProgressMsg dflags $
- ("Compiling " ++ showModMsg (not toInterp) mod_summary)
+ (showModuleIndex mb_mod_index ++
+ "Compiling " ++ showModMsg (not toInterp) mod_summary)
-------------------
-- PARSE
; let hspp_file = expectJust "hscFileFrontEnd" (ms_hspp_file mod_summary)
hspp_buf = ms_hspp_buf mod_summary
- ; maybe_parsed <- myParseModule (hsc_dflags hsc_env) hspp_file hspp_buf
+ ; maybe_parsed <- myParseModule dflags hspp_file hspp_buf
; case maybe_parsed of {
- Left err -> do { msg_act (unitBag err, emptyBag)
+ Left err -> do { printBagOfErrors dflags (unitBag err)
; return Nothing } ;
Right rdr_module -> do {
-------------------
(tc_msgs, maybe_tc_result)
<- {-# SCC "Typecheck-Rename" #-}
- tcRnModule hsc_env (ms_hsc_src mod_summary) rdr_module
+ tcRnModule hsc_env (ms_hsc_src mod_summary) False rdr_module
- ; msg_act tc_msgs
+ ; printErrorsAndWarnings dflags tc_msgs
; case maybe_tc_result of {
Nothing -> return Nothing ;
Just tc_result -> do {
-------------------
; (warns, maybe_ds_result) <- {-# SCC "DeSugar" #-}
deSugar hsc_env tc_result
- ; msg_act (warns, emptyBag)
- ; case maybe_ds_result of
- Nothing -> return Nothing
- Just ds_result -> return (Just ds_result)
+ ; printBagOfWarnings dflags warns
+ ; return maybe_ds_result
}}}}}
------------------------------
-hscFileCheck :: HscEnv -> MessageAction -> ModSummary -> IO HscResult
-hscFileCheck hsc_env msg_act mod_summary = do {
+hscFileCheck :: HscEnv -> ModSummary -> IO HscResult
+hscFileCheck hsc_env mod_summary = do {
-------------------
-- PARSE
-------------------
- ; let hspp_file = expectJust "hscFileFrontEnd" (ms_hspp_file mod_summary)
+ ; let dflags = hsc_dflags hsc_env
+ hspp_file = expectJust "hscFileFrontEnd" (ms_hspp_file mod_summary)
hspp_buf = ms_hspp_buf mod_summary
- ; maybe_parsed <- myParseModule (hsc_dflags hsc_env) hspp_file hspp_buf
+ ; maybe_parsed <- myParseModule dflags hspp_file hspp_buf
; case maybe_parsed of {
- Left err -> do { msg_act (unitBag err, emptyBag)
+ Left err -> do { printBagOfErrors dflags (unitBag err)
; return HscFail } ;
Right rdr_module -> do {
-------------------
(tc_msgs, maybe_tc_result)
<- _scc_ "Typecheck-Rename"
- tcRnModule hsc_env (ms_hsc_src mod_summary) rdr_module
+ tcRnModule hsc_env (ms_hsc_src mod_summary)
+ True{-save renamed syntax-}
+ rdr_module
- ; msg_act tc_msgs
+ ; printErrorsAndWarnings dflags tc_msgs
; case maybe_tc_result of {
- Nothing -> return (HscChecked rdr_module Nothing);
- Just tc_result -> return (HscChecked rdr_module
- (Just (tcg_binds tc_result,
- tcg_rdr_env tc_result)))
- }}}}
+ Nothing -> return (HscChecked rdr_module Nothing Nothing);
+ Just tc_result -> do
+ let md = ModDetails {
+ md_types = tcg_type_env tc_result,
+ md_exports = tcg_exports tc_result,
+ md_insts = tcg_insts tc_result,
+ md_rules = [panic "no rules"] }
+ -- Rules are CoreRules, not the
+ -- RuleDecls we get out of the typechecker
+ return (HscChecked rdr_module
+ (tcg_rn_decls tc_result)
+ (Just (tcg_binds tc_result,
+ tcg_rdr_env tc_result,
+ md)))
+ }}}}
------------------------------
hscBootBackEnd :: HscEnv -> ModSummary -> Maybe ModIface -> Maybe ModGuts -> IO HscResult
-- For hs-boot files, there's no code generation to do
-hscBootBackEnd hsc_env mod_summary maybe_checked_iface Nothing
+hscBootBackEnd hsc_env mod_summary maybe_old_iface Nothing
= return HscFail
-hscBootBackEnd hsc_env mod_summary maybe_checked_iface (Just ds_result)
- = do { final_iface <- {-# SCC "MkFinalIface" #-}
- mkIface hsc_env (ms_location mod_summary)
- maybe_checked_iface ds_result
-
- ; let { final_details = ModDetails { md_types = mg_types ds_result,
- md_insts = mg_insts ds_result,
- md_rules = mg_rules ds_result } }
+hscBootBackEnd hsc_env mod_summary maybe_old_iface (Just ds_result)
+ = do { details <- mkBootModDetails hsc_env ds_result
+
+ ; (new_iface, no_change)
+ <- {-# SCC "MkFinalIface" #-}
+ mkIface hsc_env maybe_old_iface ds_result details
+
+ ; writeIfaceFile hsc_env (ms_location mod_summary) new_iface no_change
+
-- And the answer is ...
; dumpIfaceStats hsc_env
- ; return (HscRecomp final_details
- final_iface
+ ; return (HscRecomp details new_iface
False False Nothing)
}
------------------------------
hscBackEnd :: HscEnv -> ModSummary -> Maybe ModIface -> Maybe ModGuts -> IO HscResult
-hscBackEnd hsc_env mod_summary maybe_checked_iface Nothing
+hscBackEnd hsc_env mod_summary maybe_old_iface Nothing
= return HscFail
-hscBackEnd hsc_env mod_summary maybe_checked_iface (Just ds_result)
+hscBackEnd hsc_env mod_summary maybe_old_iface (Just ds_result)
= do { -- OMITTED:
-- ; seqList imported_modules (return ())
-------------------
-- TIDY
-------------------
- ; tidy_result <- {-# SCC "CoreTidy" #-}
- tidyCorePgm hsc_env simpl_result
-
- -- Emit external core
- ; emitExternalCore dflags tidy_result
+ ; (cg_guts, details) <- {-# SCC "CoreTidy" #-}
+ tidyProgram hsc_env simpl_result
-- Alive at this point:
-- tidy_result, pcs_final
-- 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" #-}
- mkIface hsc_env (ms_location mod_summary)
- maybe_checked_iface tidy_result
+ ; (new_iface, no_change)
+ <- {-# SCC "MkFinalIface" #-}
+ mkIface hsc_env maybe_old_iface simpl_result details
+
+ ; writeIfaceFile hsc_env (ms_location mod_summary) new_iface no_change
-- Space leak reduction: throw away the new interface if
-- we're in one-shot mode; we won't be needing it any
-- more.
- ; final_iface <-
- if one_shot then return (error "no final iface")
+ ; final_iface <- if one_shot then return (error "no final iface")
else return new_iface
-- Build the final ModDetails (except in one-shot mode, where
-- we won't need this information after compilation).
- ; final_details <-
- if one_shot then return (error "no final details")
- else return $! ModDetails {
- md_types = mg_types tidy_result,
- md_insts = mg_insts tidy_result,
- md_rules = mg_rules tidy_result }
+ ; final_details <- if one_shot then return (error "no final details")
+ else return $! details
+
+ -- Emit external core
+ ; emitExternalCore dflags cg_guts
-------------------
-- CONVERT TO STG and COMPLETE CODE GENERATION
; (stub_h_exists, stub_c_exists, maybe_bcos)
- <- hscCodeGen dflags tidy_result
+ <- hscCodeGen dflags (ms_location mod_summary) cg_guts
-- And the answer is ...
; dumpIfaceStats hsc_env
-hscCodeGen dflags
- ModGuts{ -- This is the last use of the ModGuts in a compilation.
+hscCodeGen dflags location
+ CgGuts{ -- This is the last use of the ModGuts in a compilation.
-- From now on, we just use the bits we need.
- mg_module = this_mod,
- mg_binds = core_binds,
- mg_types = type_env,
- mg_dir_imps = dir_imps,
- mg_foreign = foreign_stubs,
- mg_deps = dependencies } = do {
+ cg_module = this_mod,
+ cg_binds = core_binds,
+ cg_tycons = tycons,
+ cg_dir_imps = dir_imps,
+ cg_foreign = foreign_stubs,
+ cg_home_mods = home_mods,
+ cg_dep_pkgs = dependencies } = do {
+
+ let { data_tycons = filter isDataTyCon tycons } ;
+ -- cg_tycons includes newtypes, for the benefit of External Core,
+ -- but we don't generate any code for newtypes
-------------------
-- PREPARE FOR CODE GENERATION
-- Do saturation and convert to A-normal form
prepd_binds <- {-# SCC "CorePrep" #-}
- corePrepPgm dflags core_binds type_env;
+ corePrepPgm dflags core_binds data_tycons ;
case hscTarget dflags of
HscNothing -> return (False, False, Nothing)
HscInterpreted ->
#ifdef GHCI
do ----------------- Generate byte code ------------------
- comp_bc <- byteCodeGen dflags prepd_binds type_env
+ comp_bc <- byteCodeGen dflags prepd_binds data_tycons
------------------ Create f-x-dynamic C-side stuff ---
(istub_h_exists, istub_c_exists)
- <- outputForeignStubs dflags foreign_stubs
+ <- outputForeignStubs dflags this_mod location foreign_stubs
return ( istub_h_exists, istub_c_exists, Just comp_bc )
#else
do
----------------- Convert to STG ------------------
(stg_binds, cost_centre_info) <- {-# SCC "CoreToStg" #-}
- myCoreToStg dflags this_mod prepd_binds
+ myCoreToStg dflags home_mods this_mod prepd_binds
------------------ Code generation ------------------
abstractC <- {-# SCC "CodeGen" #-}
- codeGen dflags this_mod type_env foreign_stubs
- dir_imps cost_centre_info stg_binds
+ codeGen dflags home_mods this_mod data_tycons
+ foreign_stubs dir_imps cost_centre_info
+ stg_binds
------------------ Code output -----------------------
(stub_h_exists, stub_c_exists)
- <- codeOutput dflags this_mod foreign_stubs
+ <- codeOutput dflags this_mod location foreign_stubs
dependencies abstractC
return (stub_h_exists, stub_c_exists, Nothing)
hscCmmFile :: DynFlags -> FilePath -> IO Bool
hscCmmFile dflags filename = do
- maybe_cmm <- parseCmmFile dflags filename
+ maybe_cmm <- parseCmmFile dflags (mkHomeModules []) filename
case maybe_cmm of
Nothing -> return False
Just cmm -> do
- codeOutput dflags no_mod NoStubs noDependencies [cmm]
+ codeOutput dflags no_mod no_loc NoStubs [] [cmm]
return True
where
no_mod = panic "hscCmmFile: no_mod"
+ no_loc = ModLocation{ ml_hs_file = Just filename,
+ ml_hi_file = panic "hscCmmFile: no hi file",
+ ml_obj_file = panic "hscCmmFile: no obj file" }
myParseModule dflags src_filename maybe_src_buf
}}
-myCoreToStg dflags this_mod prepd_binds
+myCoreToStg dflags home_mods this_mod prepd_binds
= do
stg_binds <- {-# SCC "Core2Stg" #-}
- coreToStg dflags prepd_binds
+ coreToStg home_mods prepd_binds
- (stg_binds2, cost_centre_info) <- {-# SCC "Core2Stg" #-}
- stg2stg dflags this_mod stg_binds
+ (stg_binds2, cost_centre_info) <- {-# SCC "Stg2Stg" #-}
+ stg2stg dflags home_mods this_mod stg_binds
return (stg_binds2, cost_centre_info)
\end{code}
; let icontext = hsc_IC hsc_env
; case maybe_stmt of {
Nothing -> return Nothing ; -- Parse error
- Just (Just (L _ (ExprStmt expr _)))
+ Just (Just (L _ (ExprStmt expr _ _)))
-> tcRnExpr hsc_env icontext expr ;
- Just other -> do { errorMsg ("not an expression: `" ++ expr ++ "'") ;
+ Just other -> do { errorMsg (hsc_dflags hsc_env) (text "not an expression:" <+> quotes (text expr)) ;
return Nothing } ;
} }
; 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 ++ "'") ;
+ Just other -> do { errorMsg (hsc_dflags hsc_env) (text "not an type:" <+> quotes (text str)) ;
return Nothing } ;
Nothing -> return Nothing } }
+#endif
\end{code}
\begin{code}
+#ifdef GHCI
hscParseStmt :: DynFlags -> String -> IO (Maybe (Maybe (LStmt RdrName)))
hscParseStmt = hscParseThing parseStmt
hscParseType :: DynFlags -> String -> IO (Maybe (LHsType RdrName))
hscParseType = hscParseThing parseType
+#endif
hscParseIdentifier :: DynFlags -> String -> IO (Maybe (Located RdrName))
hscParseIdentifier = hscParseThing parseIdentifier
dumpIfSet_dyn dflags Opt_D_dump_parsed "Parser" (ppr thing);
return (Just thing)
}}
-#endif
-\end{code}
-
-%************************************************************************
-%* *
-\subsection{Getting information about an identifer}
-%* *
-%************************************************************************
-
-\begin{code}
-#ifdef GHCI
-hscGetInfo -- like hscStmt, but deals with a single identifier
- :: HscEnv
- -> String -- The identifier
- -> IO [GetInfoResult]
-
-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 (hsc_IC hsc_env) rdr_name
-
- case maybe_tc_result of
- Nothing -> return []
- Just things -> return things
- }
-#endif
\end{code}
%************************************************************************
; simpl_expr <- simplifyExpr dflags flat_expr
-- Tidy it (temporary, until coreSat does cloning)
- ; tidy_expr <- tidyCoreExpr simpl_expr
+ ; let tidy_expr = tidyExpr emptyTidyEnv simpl_expr
-- Prepare for codegen
; prepd_expr <- corePrepExpr dflags tidy_expr
dump_rn_stats = dopt Opt_D_dump_rn_stats dflags
dump_if_trace = dopt Opt_D_dump_if_trace dflags
\end{code}
+
+%************************************************************************
+%* *
+ Progress Messages: Module i of n
+%* *
+%************************************************************************
+
+\begin{code}
+showModuleIndex Nothing = ""
+showModuleIndex (Just (i,n)) = "[" ++ padded ++ " of " ++ n_str ++ "] "
+ where
+ n_str = show n
+ i_str = show i
+ padded = replicate (length n_str - length i_str) ' ' ++ i_str
+\end{code}
+
projects / ghc-hetmet.git / blobdiff