\section[TcModule]{Typechecking a whole module}
\begin{code}
+{-# OPTIONS -w #-}
+-- The above warning supression flag is a temporary kludge.
+-- While working on this module you are encouraged to remove it and fix
+-- any warnings in the module. See
+-- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
+-- for details
+
module TcRnDriver (
#ifdef GHCI
tcRnStmt, tcRnExpr, tcRnType,
tcRnLookupName,
tcRnGetInfo,
getModuleExports,
- tcRnRecoverDataCon,
#endif
tcRnModule,
tcTopSrcDecls,
import IdInfo
import {- Kind parts of -} Type
import BasicTypes
+import Foreign.Ptr( Ptr )
#endif
import FastString
import Control.Monad ( unless )
import Data.Maybe ( isJust )
-import Foreign.Ptr ( Ptr )
\end{code}
\begin{code}
tcRnImports :: HscEnv -> Module -> [LImportDecl RdrName] -> TcM TcGblEnv
tcRnImports hsc_env this_mod import_decls
- = do { (rn_imports, rdr_env, imports) <- rnImports import_decls ;
+ = do { (rn_imports, rdr_env, imports,hpc_info) <- rnImports import_decls ;
; let { dep_mods :: ModuleNameEnv (ModuleName, IsBootInterface)
; dep_mods = imp_dep_mods imports
; want_instances :: ModuleName -> Bool
; want_instances mod = mod `elemUFM` dep_mods
&& mod /= moduleName this_mod
- ; home_insts = hptInstances hsc_env want_instances
+ ; (home_insts, home_fam_insts) = hptInstances hsc_env
+ want_instances
} ;
-- Record boot-file info in the EPS, so that it's
-- Update the gbl env
; updGblEnv ( \ gbl ->
- gbl { tcg_rdr_env = plusOccEnv (tcg_rdr_env gbl) rdr_env,
- tcg_imports = tcg_imports gbl `plusImportAvails` imports,
- tcg_rn_imports = fmap (const rn_imports) (tcg_rn_imports gbl),
- tcg_inst_env = extendInstEnvList (tcg_inst_env gbl) home_insts
- }) $ do {
+ gbl {
+ tcg_rdr_env = plusOccEnv (tcg_rdr_env gbl) rdr_env,
+ tcg_imports = tcg_imports gbl `plusImportAvails` imports,
+ tcg_rn_imports = fmap (const rn_imports) (tcg_rn_imports gbl),
+ tcg_inst_env = extendInstEnvList (tcg_inst_env gbl) home_insts,
+ tcg_fam_inst_env = extendFamInstEnvList (tcg_fam_inst_env gbl)
+ home_fam_insts,
+ tcg_hpc = hpc_info
+ }) $ do {
; traceRn (text "rn1" <+> ppr (imp_dep_mods imports))
-- Fail if there are any errors so far
-- Check type-familily consistency
; traceRn (text "rn1: checking family instance consistency")
- ; let { dir_imp_mods = map (\ (mod, _, _) -> mod)
+ ; let { dir_imp_mods = map (\ (mod, _) -> mod)
. moduleEnvElts
. imp_mods
$ imports }
mg_types = final_type_env,
mg_insts = tcg_insts tcg_env,
mg_fam_insts = tcg_fam_insts tcg_env,
+ mg_inst_env = tcg_inst_env tcg_env,
mg_fam_inst_env = tcg_fam_inst_env tcg_env,
mg_rules = [],
mg_binds = core_binds,
mg_fix_env = emptyFixityEnv,
mg_deprecs = NoDeprecs,
mg_foreign = NoStubs,
- mg_hpc_info = noHpcInfo,
+ mg_hpc_info = emptyHpcInfo False,
mg_modBreaks = emptyModBreaks,
mg_vect_info = noVectInfo
} } ;
(tc_val_binds, tcl_env) <- tcTopBinds val_binds ;
setLclTypeEnv tcl_env $ do {
- -- Now GHC-generated derived bindings and generics
- -- Do not generate warnings from compiler-generated code
- (tc_deriv_binds, tcl_env) <- discardWarnings $ setOptM Opt_GlasgowExts $
- tcTopBinds deriv_binds ;
+ -- Now GHC-generated derived bindings and generics.
+ -- Do not generate warnings from compiler-generated code.
+ (tc_deriv_binds, tcl_env) <- discardWarnings $
+ tcTopBinds deriv_binds ;
-- Second pass over class and instance declarations,
traceTc (text "Tc6") ;
checkMain
= do { tcg_env <- getGblEnv ;
dflags <- getDOpts ;
- let { main_mod = mainModIs dflags ;
- main_fn = case mainFunIs dflags of {
- Just fn -> mkRdrUnqual (mkVarOccFS (mkFastString fn)) ;
- Nothing -> main_RDR_Unqual } } ;
-
- check_main dflags tcg_env main_mod main_fn
+ check_main dflags tcg_env
}
-
-check_main dflags tcg_env main_mod main_fn
+check_main dflags tcg_env
| mod /= main_mod
= traceTc (text "checkMain not" <+> ppr main_mod <+> ppr mod) >>
return tcg_env
| otherwise
- = addErrCtxt mainCtxt $
- do { mb_main <- lookupSrcOcc_maybe main_fn
+ = do { mb_main <- lookupSrcOcc_maybe main_fn
-- Check that 'main' is in scope
-- It might be imported from another module!
; case mb_main of {
; complain_no_main
; return tcg_env } ;
Just main_name -> do
+
{ traceTc (text "checkMain found" <+> ppr main_mod <+> ppr main_fn)
; let { rhs = nlHsApp (nlHsVar runMainIOName) (nlHsVar main_name) }
-- :Main.main :: IO () = runMainIO main
- ; (main_expr, ty) <- setSrcSpan (srcLocSpan (getSrcLoc main_name)) $
+ ; (main_expr, ty) <- addErrCtxt mainCtxt $
+ setSrcSpan (srcLocSpan (getSrcLoc main_name)) $
tcInferRho rhs
-- See Note [Root-main Id]
; let { root_main_name = mkExternalName rootMainKey rOOT_MAIN
(mkVarOccFS FSLIT("main"))
- (getSrcLoc main_name)
+ (getSrcSpan main_name)
; root_main_id = Id.mkExportedLocalId root_main_name ty
; main_bind = noLoc (VarBind root_main_id main_expr) }
})
}}}
where
- mod = tcg_mod tcg_env
-
+ mod = tcg_mod tcg_env
+ main_mod = mainModIs dflags
+ main_is_flag = mainFunIs dflags
+
+ main_fn = case main_is_flag of
+ Just fn -> mkRdrUnqual (mkVarOccFS (mkFastString fn))
+ Nothing -> main_RDR_Unqual
+
complain_no_main | ghcLink dflags == LinkInMemory = return ()
| otherwise = failWithTc noMainMsg
-- In interactive mode, don't worry about the absence of 'main'
-- In other modes, fail altogether, so that we don't go on
-- and complain a second time when processing the export list.
- mainCtxt = ptext SLIT("When checking the type of the main function") <+> quotes (ppr main_fn)
- noMainMsg = ptext SLIT("The main function") <+> quotes (ppr main_fn)
+ mainCtxt = ptext SLIT("When checking the type of the") <+> pp_main_fn
+ noMainMsg = ptext SLIT("The") <+> pp_main_fn
<+> ptext SLIT("is not defined in module") <+> quotes (ppr main_mod)
+ pp_main_fn | isJust main_is_flag = ptext SLIT("main function") <+> quotes (ppr main_fn)
+ | otherwise = ptext SLIT("function") <+> quotes (ppr main_fn)
\end{code}
Note [Root-main Id]
-- Initialise the tcg_inst_env with instances
-- from all home modules. This mimics the more selective
-- call to hptInstances in tcRnModule
- dfuns = hptInstances hsc_env (\mod -> True)
+ dfuns = fst (hptInstances hsc_env (\mod -> True))
in
updGblEnv (\env -> env {
tcg_rdr_env = ic_rn_gbl_env icxt,
tcg_inst_env = extendInstEnvList (tcg_inst_env env) dfuns }) $
- tcExtendIdEnv (ic_tmp_ids icxt) $
- -- tcExtendIdEnv does lots:
+ tcExtendGhciEnv (ic_tmp_ids icxt) $
+ -- tcExtendGhciEnv does lots:
-- - it extends the local type env (tcl_env) with the given Ids,
-- - it extends the local rdr env (tcl_rdr) with the Names from
-- the given Ids
(([rn_stmt], _), fvs) <- rnStmts DoExpr [rdr_stmt] (return ((), emptyFVs)) ;
traceRn (text "tcRnStmt" <+> vcat [ppr rdr_stmt, ppr rn_stmt, ppr fvs]) ;
failIfErrsM ;
+ rnDump (ppr rn_stmt) ;
-- The real work is done here
(bound_ids, tc_expr) <- mkPlan rn_stmt ;
} ;
-- OK, we're ready to typecheck the stmts
- traceTc (text "tcs 2") ;
+ traceTc (text "TcRnDriver.tcGhciStmts: tc stmts") ;
((tc_stmts, ids), lie) <- getLIE $ tc_io_stmts stmts $ \ _ ->
mappM tcLookupId names ;
-- Look up the names right in the middle,
-- where they will all be in scope
-- Simplify the context
+ traceTc (text "TcRnDriver.tcGhciStmts: simplify ctxt") ;
const_binds <- checkNoErrs (tcSimplifyInteractive lie) ;
-- checkNoErrs ensures that the plan fails if context redn fails
+ traceTc (text "TcRnDriver.tcGhciStmts: done") ;
return (ids, mkHsDictLet const_binds $
noLoc (HsDo DoExpr tc_stmts (mk_return ids) io_ret_ty))
}
return good_names
}
-tcRnRecoverDataCon :: HscEnv -> Ptr () -> IO (Maybe DataCon)
-tcRnRecoverDataCon hsc_env ptr
- = initTcPrintErrors hsc_env iNTERACTIVE $
- setInteractiveContext hsc_env (hsc_IC hsc_env) $ do
- name <- dataConInfoPtrToName ptr
- tcLookupDataCon name
-
tcRnLookupName :: HscEnv -> Name -> IO (Maybe TyThing)
tcRnLookupName hsc_env name
= initTcPrintErrors hsc_env iNTERACTIVE $
-- in the home package all relevant modules are loaded.)
loadUnqualIfaces ictxt
- thing <- tcRnLookupName' name
+ thing <- tcRnLookupName' name
fixity <- lookupFixityRn name
- ispecs <- lookupInsts (icPrintUnqual ictxt) thing
+ ispecs <- lookupInsts thing
return (thing, fixity, ispecs)
-lookupInsts :: PrintUnqualified -> TyThing -> TcM [Instance]
--- Filter the instances by the ones whose tycons (or clases resp)
--- are in scope unqualified. Otherwise we list a whole lot too many!
-lookupInsts print_unqual (AClass cls)
+lookupInsts :: TyThing -> TcM [Instance]
+lookupInsts (AClass cls)
= do { inst_envs <- tcGetInstEnvs
- ; return [ ispec
- | ispec <- classInstances inst_envs cls
- , plausibleDFun print_unqual (instanceDFunId ispec) ] }
+ ; return (classInstances inst_envs cls) }
-lookupInsts print_unqual (ATyCon tc)
+lookupInsts (ATyCon tc)
= do { eps <- getEps -- Load all instances for all classes that are
-- in the type environment (which are all the ones
-- we've seen in any interface file so far)
; return [ ispec
| ispec <- instEnvElts home_ie ++ instEnvElts pkg_ie
, let dfun = instanceDFunId ispec
- , relevant dfun
- , plausibleDFun print_unqual dfun ] }
+ , relevant dfun ] }
where
relevant df = tc_name `elemNameSet` tyClsNamesOfDFunHead (idType df)
tc_name = tyConName tc
-lookupInsts print_unqual other = return []
-
-plausibleDFun print_unqual dfun -- Dfun involving only names that print unqualified
- = all ok (nameSetToList (tyClsNamesOfType (idType dfun)))
- where
- ok name | isBuiltInSyntax name = True
- | isExternalName name =
- isNothing $ fst print_unqual (nameModule name)
- (nameOccName name)
- | otherwise = True
+lookupInsts other = return []
loadUnqualIfaces :: InteractiveContext -> TcM ()
-- Load the home module for everything that is in scope unqualified
projects / ghc-hetmet.git / blobdiff