import VarSet ( emptyVarSet )
import VarEnv ( TidyEnv, emptyTidyEnv )
import ErrUtils ( Message, Messages, emptyMessages, errorsFound,
- mkErrMsg, mkWarnMsg, printErrorsAndWarnings )
+ mkErrMsg, mkWarnMsg, printErrorsAndWarnings,
+ mkLocMessage, mkLongErrMsg )
import SrcLoc ( mkGeneralSrcSpan, SrcSpan, Located(..) )
import NameEnv ( emptyNameEnv )
import NameSet ( emptyDUs, emptyNameSet )
initTc :: HscEnv
-> Module
-> TcM r
- -> IO (Maybe r)
+ -> IO (Messages, Maybe r)
-- Nothing => error thrown by the thing inside
-- (error messages should have been printed already)
tvs_var <- newIORef emptyVarSet ;
type_env_var <- newIORef emptyNameEnv ;
dfuns_var <- newIORef emptyNameSet ;
+ th_var <- newIORef False ;
let {
gbl_env = TcGblEnv {
tcg_type_env_var = type_env_var,
tcg_inst_env = mkImpInstEnv hsc_env,
tcg_inst_uses = dfuns_var,
- tcg_exports = [],
+ tcg_th_used = th_var,
+ tcg_exports = emptyNameSet,
tcg_imports = init_imports,
tcg_dus = emptyDUs,
tcg_binds = emptyBag,
Right res -> return (Just res)
Left _ -> return Nothing } ;
- -- Print any error messages
+ -- Collect any error messages
msgs <- readIORef errs_var ;
- printErrorsAndWarnings msgs ;
let { dflags = hsc_dflags hsc_env
; final_res | errorsFound dflags msgs = Nothing
| otherwise = maybe_res } ;
- return final_res
+ return (msgs, final_res)
}
where
init_imports = emptyImportAvails { imp_qual = unitModuleEnv mod emptyAvailEnv }
-- list, and there are no bindings in M, we don't bleat
-- "unknown module M".
+initTcPrintErrors
+ :: HscEnv
+ -> Module
+ -> TcM r
+ -> IO (Maybe r)
+initTcPrintErrors env mod todo = do
+ (msgs, res) <- initTc env mod todo
+ printErrorsAndWarnings msgs
+ return res
+
mkImpInstEnv :: HscEnv -> InstEnv
-- At the moment we (wrongly) build an instance environment from all the
-- home-package modules we have already compiled.
ioToIOEnv (printForUser stderr alwaysQualify doc)
dumpOptTcRn :: DynFlag -> SDoc -> TcRn ()
-dumpOptTcRn flag doc = ifOptM flag (dumpTcRn doc)
+dumpOptTcRn flag doc = ifOptM flag $ do
+ { ctxt <- getErrCtxt
+ ; loc <- getSrcSpanM
+ ; ctxt_msgs <- do_ctxt emptyTidyEnv ctxt
+ ; let real_doc = mkLocMessage loc (vcat (doc : ctxt_to_use ctxt_msgs))
+ ; dumpTcRn real_doc }
dumpTcRn :: SDoc -> TcRn ()
dumpTcRn doc = do { rdr_env <- getGlobalRdrEnv ;
addLocErr (L loc e) fn = addErrAt loc (fn e)
addErrAt :: SrcSpan -> Message -> TcRn ()
-addErrAt loc msg
+addErrAt loc msg = addLongErrAt loc msg empty
+
+addLongErrAt :: SrcSpan -> Message -> Message -> TcRn ()
+addLongErrAt loc msg extra
= do { errs_var <- getErrsVar ;
rdr_env <- getGlobalRdrEnv ;
- let { err = mkErrMsg loc (unQualInScope rdr_env) msg } ;
+ let { err = mkLongErrMsg loc (unQualInScope rdr_env) msg extra } ;
(warns, errs) <- readMutVar errs_var ;
writeMutVar errs_var (warns, errs `snocBag` err) }
\begin{code}
add_err_tcm tidy_env err_msg loc ctxt
= do { ctxt_msgs <- do_ctxt tidy_env ctxt ;
- addErrAt loc (vcat (err_msg : ctxt_to_use ctxt_msgs)) }
+ addLongErrAt loc err_msg (vcat (ctxt_to_use ctxt_msgs)) }
do_ctxt tidy_env []
= return []
%************************************************************************
\begin{code}
+recordThUse :: TcM ()
+recordThUse = do { env <- getGblEnv; writeMutVar (tcg_th_used env) True }
+
getStage :: TcM ThStage
getStage = do { env <- getLclEnv; return (tcl_th_ctxt env) }