import HscTypes
import ListSetOps
import Outputable
-import Breakpoints
#ifdef GHCI
import Linker
import IdInfo
import {- Kind parts of -} Type
import BasicTypes
+import Foreign.Ptr( Ptr )
#endif
import FastString
import Bag
import Control.Monad ( unless )
+import Data.Maybe ( isJust )
+
\end{code}
; 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
+ }) $ do {
; traceRn (text "rn1" <+> ppr (imp_dep_mods imports))
-- Fail if there are any errors so far
mg_deprecs = NoDeprecs,
mg_foreign = NoStubs,
mg_hpc_info = noHpcInfo,
- mg_dbg_sites = noDbgSites
+ mg_modBreaks = emptyModBreaks,
+ mg_vect_info = noVectInfo
} } ;
tcCoreDump mod_guts ;
-- We also typecheck any extra binds that came out
-- of the "deriving" process (deriv_binds)
traceTc (text "Tc5") ;
- (tc_val_binds, tcl_env) <- tcTopBinds (val_binds `plusHsValBinds` deriv_binds) ;
+ (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 ;
+
-- Second pass over class and instance declarations,
traceTc (text "Tc6") ;
- (inst_binds, tcl_env) <- tcInstDecls2 tycl_decls inst_infos ;
+ (inst_binds, tcl_env) <- setLclTypeEnv tcl_env $ tcInstDecls2 tycl_decls inst_infos ;
showLIE (text "after instDecls2") ;
-- Foreign exports
traceTc (text "Tc7a") ;
tcg_env <- getGblEnv ;
let { all_binds = tc_val_binds `unionBags`
+ tc_deriv_binds `unionBags`
inst_binds `unionBags`
foe_binds ;
-- 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) }
-- 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_type_env = ic_type_env icxt,
tcg_inst_env = extendInstEnvList (tcg_inst_env env) dfuns }) $
- updLclEnv (\env -> env { tcl_rdr = ic_rn_local_env icxt }) $
- do { traceTc (text "setIC" <+> ppr (ic_type_env icxt))
+ tcExtendIdEnv (ic_tmp_ids icxt) $
+ -- tcExtendIdEnv 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
+ -- - it adds the free tyvars of the Ids to the tcl_tyvars
+ -- set.
+ --
+ -- later ids in ic_tmp_ids must shadow earlier ones with the same
+ -- OccName, and tcExtendIdEnv implements this behaviour.
+
+ do { traceTc (text "setIC" <+> ppr (ic_tmp_ids icxt))
; thing_inside }
\end{code}
tcRnStmt :: HscEnv
-> InteractiveContext
-> LStmt RdrName
- -> IO (Maybe (InteractiveContext, [Name], LHsExpr Id))
- -- The returned [Name] is the same as the input except for
- -- ExprStmt, in which case the returned [Name] is [itName]
+ -> IO (Maybe ([Id], LHsExpr Id))
+ -- The returned [Id] is the list of new Ids bound by
+ -- this statement. It can be used to extend the
+ -- InteractiveContext via extendInteractiveContext.
--
-- The returned TypecheckedHsExpr is of type IO [ () ],
-- a list of the bound values, coerced to ().
-- up to have tidy types
global_ids = map globaliseAndTidy zonked_ids ;
- -- Update the interactive context
- rn_env = ic_rn_local_env ictxt ;
- type_env = ic_type_env ictxt ;
-
- bound_names = map idName global_ids ;
- new_rn_env = extendLocalRdrEnv rn_env bound_names ;
-
{- ---------------------------------------------
At one stage I removed any shadowed bindings from the type_env;
they are inaccessible but might, I suppose, cause a space leak if we leave them there.
Hence this code is commented out
- shadowed = [ n | name <- bound_names,
- let rdr_name = mkRdrUnqual (nameOccName name),
- Just n <- [lookupLocalRdrEnv rn_env rdr_name] ] ;
- filtered_type_env = delListFromNameEnv type_env shadowed ;
-------------------------------------------------- -}
-
- new_type_env = extendTypeEnvWithIds type_env global_ids ;
- new_ic = ictxt { ic_rn_local_env = new_rn_env,
- ic_type_env = new_type_env }
} ;
dumpOptTcRn Opt_D_dump_tc
(vcat [text "Bound Ids" <+> pprWithCommas ppr global_ids,
text "Typechecked expr" <+> ppr zonked_expr]) ;
- returnM (new_ic, bound_names, zonked_expr)
+ returnM (global_ids, zonked_expr)
}
where
bad_unboxed id = addErr (sep [ptext SLIT("GHCi can't bind a variable of unlifted type:"),
return good_names
}
-tcRnRecoverDataCon :: HscEnv -> a -> IO (Maybe DataCon)
-tcRnRecoverDataCon hsc_env a
+tcRnRecoverDataCon :: HscEnv -> Ptr () -> IO (Maybe DataCon)
+tcRnRecoverDataCon hsc_env ptr
= initTcPrintErrors hsc_env iNTERACTIVE $
- setInteractiveContext hsc_env (hsc_IC hsc_env) $
- do name <- recoverDataCon a
+ 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 $
setInteractiveContext hsc_env (hsc_IC hsc_env) $
- tcLookupGlobal name
+ tcRnLookupName' name
+
+-- To look up a name we have to look in the local environment (tcl_lcl)
+-- as well as the global environment, which is what tcLookup does.
+-- But we also want a TyThing, so we have to convert:
+tcRnLookupName' :: Name -> TcRn TyThing
+tcRnLookupName' name = do
+ tcthing <- tcLookup name
+ case tcthing of
+ AGlobal thing -> return thing
+ ATcId{tct_id=id} -> return (AnId id)
+ _ -> panic "tcRnLookupName'"
tcRnGetInfo :: HscEnv
-> Name
-- in the home package all relevant modules are loaded.)
loadUnqualIfaces ictxt
- thing <- tcLookupGlobal name
+ thing <- tcRnLookupName' name
fixity <- lookupFixityRn name
ispecs <- lookupInsts (icPrintUnqual ictxt) thing
return (thing, fixity, ispecs)