Commit f3a84161 authored by Simon Peyton Jones's avatar Simon Peyton Jones

More faff to get GHCi's top-level environment right

This fixes #8540 (again), and simplifies matters a bit more. In
particular, I got rid of ic_sys_vars altogether.  Mostly they can just
go in ic_tythings, apart from dfuns, which are readily gettable from
the instances anyway.

See documentation in Note [Initialising the type environment for GHCi]
in TcEnv.
parent a8ac471d
......@@ -17,6 +17,7 @@ import MkIface
import Id
import Name
import Type
import FamInstEnv
import InstEnv
import Class
import Avail
......@@ -28,13 +29,12 @@ import DsExpr
import DsBinds
import DsForeign
import Module
import RdrName
import NameSet
import NameEnv
import FamInstEnv ( FamInstEnv )
import Rules
import BasicTypes ( Activation(.. ) )
import CoreMonad ( endPass, CoreToDo(..) )
import PrelNames ( iNTERACTIVE )
import FastString
import ErrUtils
import Outputable
......@@ -218,29 +218,29 @@ and Rec the rest.
\begin{code}
deSugarExpr :: HscEnv
-> Module -> GlobalRdrEnv -> TypeEnv -> FamInstEnv
-> LHsExpr Id
-> IO (Messages, Maybe CoreExpr)
-- Prints its own errors; returns Nothing if error occurred
deSugarExpr :: HscEnv -> LHsExpr Id -> IO (Messages, Maybe CoreExpr)
deSugarExpr hsc_env tc_expr
= do { let dflags = hsc_dflags hsc_env
icntxt = hsc_IC hsc_env
rdr_env = ic_rn_gbl_env icntxt
type_env = mkTypeEnvWithImplicits (ic_tythings icntxt)
fam_insts = snd (ic_instances icntxt)
fam_inst_env = extendFamInstEnvList emptyFamInstEnv fam_insts
-- This stuff is a half baked version of TcRnDriver.setInteractiveContext
deSugarExpr hsc_env this_mod rdr_env type_env fam_inst_env tc_expr
= do { let dflags = hsc_dflags hsc_env
; showPass dflags "Desugar"
-- Do desugaring
; (msgs, mb_core_expr) <- initDs hsc_env this_mod rdr_env
; (msgs, mb_core_expr) <- initDs hsc_env iNTERACTIVE rdr_env
type_env fam_inst_env $
dsLExpr tc_expr
; case mb_core_expr of {
Nothing -> return (msgs, Nothing) ;
Just expr ->
-- Dump output
do { dumpIfSet_dyn dflags Opt_D_dump_ds "Desugared" (pprCoreExpr expr)
; case mb_core_expr of
Nothing -> return ()
Just expr -> dumpIfSet_dyn dflags Opt_D_dump_ds "Desugared" (pprCoreExpr expr)
; return (msgs, Just expr) } } }
; return (msgs, mb_core_expr) }
\end{code}
%************************************************************************
......
......@@ -286,9 +286,8 @@ hscTcRnGetInfo hsc_env0 name = runInteractiveHsc hsc_env0 $ do
#ifdef GHCI
hscIsGHCiMonad :: HscEnv -> String -> IO Name
hscIsGHCiMonad hsc_env name =
let icntxt = hsc_IC hsc_env
in runHsc hsc_env $ ioMsgMaybe $ isGHCiMonad hsc_env icntxt name
hscIsGHCiMonad hsc_env name
= runHsc hsc_env $ ioMsgMaybe $ isGHCiMonad hsc_env name
hscGetModuleInterface :: HscEnv -> Module -> IO ModIface
hscGetModuleInterface hsc_env0 mod = runInteractiveHsc hsc_env0 $ do
......@@ -1353,25 +1352,18 @@ hscStmtWithLocation hsc_env0 stmt source linenumber =
Nothing -> return Nothing
Just parsed_stmt -> do
let icntxt = hsc_IC hsc_env
rdr_env = ic_rn_gbl_env icntxt
type_env = mkTypeEnvWithImplicits (ic_tythings icntxt)
fam_insts = snd (ic_instances icntxt)
fam_inst_env = extendFamInstEnvList emptyFamInstEnv fam_insts
src_span = srcLocSpan interactiveSrcLoc
-- Rename and typecheck it
-- Here we lift the stmt into the IO monad, see Note
-- [Interactively-bound Ids in GHCi] in TcRnDriver
(ids, tc_expr, fix_env) <- ioMsgMaybe $ tcRnStmt hsc_env icntxt parsed_stmt
(ids, tc_expr, fix_env) <- ioMsgMaybe $ tcRnStmt hsc_env parsed_stmt
-- Desugar it
ds_expr <- ioMsgMaybe $
deSugarExpr hsc_env iNTERACTIVE rdr_env type_env fam_inst_env tc_expr
ds_expr <- ioMsgMaybe $ deSugarExpr hsc_env tc_expr
liftIO (lintInteractiveExpr "desugar expression" hsc_env ds_expr)
handleWarnings
-- Then code-gen, and link it
let src_span = srcLocSpan interactiveSrcLoc
hval <- liftIO $ hscCompileCoreExpr hsc_env src_span ds_expr
let hval_io = unsafeCoerce# hval :: IO [HValue]
......@@ -1396,8 +1388,7 @@ hscDeclsWithLocation hsc_env0 str source linenumber =
hscParseThingWithLocation source linenumber parseModule str
{- Rename and typecheck it -}
let icontext = hsc_IC hsc_env
tc_gblenv <- ioMsgMaybe $ tcRnDeclsi hsc_env icontext decls
tc_gblenv <- ioMsgMaybe $ tcRnDeclsi hsc_env decls
{- Grab the new instances -}
-- We grab the whole environment because of the overlapping that may have
......@@ -1441,26 +1432,22 @@ hscDeclsWithLocation hsc_env0 str source linenumber =
hsc_env <- getHscEnv
liftIO $ linkDecls hsc_env src_span cbc
let tcs = filter (not . isImplicitTyCon) $ (mg_tcs simpl_mg)
let tcs = filterOut isImplicitTyCon (mg_tcs simpl_mg)
ext_vars = filter (isExternalName . idName) $
bindersOfBinds core_binds
ext_ids = [ id | id <- bindersOfBinds core_binds
, isExternalName (idName id)
, not (isDFunId id) ]
-- We only need to keep around the external bindings
-- (as decided by TidyPgm), since those are the only ones
-- that might be referenced elsewhere.
-- The DFunIds are in 'insts' (see Note [ic_tythings] in HscTypes
(sys_vars, user_vars) = partition is_sys_var ext_vars
is_sys_var id = isDFunId id
|| isRecordSelector id
|| isJust (isClassOpId_maybe id)
-- we only need to keep around the external bindings
-- (as decided by TidyPgm), since those are the only ones
-- that might be referenced elsewhere.
tythings = map AnId ext_ids ++ map ATyCon tcs
tythings = map AnId user_vars
++ map ATyCon tcs
let ictxt1 = extendInteractiveContext icontext tythings
ictxt = ictxt1 { ic_sys_vars = sys_vars ++ ic_sys_vars ictxt1,
ic_instances = (insts, finsts),
ic_default = defaults }
let icontext = hsc_IC hsc_env
ictxt1 = extendInteractiveContext icontext tythings
ictxt = ictxt1 { ic_instances = (insts, finsts)
, ic_default = defaults }
return (tythings, ictxt)
......@@ -1484,7 +1471,7 @@ hscTcExpr hsc_env0 expr = runInteractiveHsc hsc_env0 $ do
maybe_stmt <- hscParseStmt expr
case maybe_stmt of
Just (L _ (BodyStmt expr _ _ _)) ->
ioMsgMaybe $ tcRnExpr hsc_env (hsc_IC hsc_env) expr
ioMsgMaybe $ tcRnExpr hsc_env expr
_ ->
throwErrors $ unitBag $ mkPlainErrMsg (hsc_dflags hsc_env) noSrcSpan
(text "not an expression:" <+> quotes (text expr))
......@@ -1499,7 +1486,7 @@ hscKcType
hscKcType hsc_env0 normalise str = runInteractiveHsc hsc_env0 $ do
hsc_env <- getHscEnv
ty <- hscParseType str
ioMsgMaybe $ tcRnType hsc_env (hsc_IC hsc_env) normalise ty
ioMsgMaybe $ tcRnType hsc_env normalise ty
hscParseStmt :: String -> Hsc (Maybe (GhciLStmt RdrName))
hscParseStmt = hscParseThing parseStmt
......
......@@ -1104,17 +1104,12 @@ data InteractiveContext
-- ^ The cached 'GlobalRdrEnv', built by
-- 'InteractiveEval.setContext' and updated regularly
-- It contains everything in scope at the command line,
-- including everything in ic_tythings and ic_sys_vars
-- including everything in ic_tythings
ic_tythings :: [TyThing],
-- ^ TyThings defined by the user, in reverse order of
-- definition. At a breakpoint, this list includes the
-- local variables in scope at that point
ic_sys_vars :: [Id],
-- ^ Variables defined automatically from
-- ic_ty_things (e.g. record field selectors).
-- See Notes [ic_sys_vars]
-- definition (ie most recent at the front)
-- See Note [ic_tythings]
ic_instances :: ([ClsInst], [FamInst]),
-- ^ All instances and family instances created during
......@@ -1144,24 +1139,24 @@ data InteractiveContext
}
{-
Note [ic_sys_vars]
Note [ic_tythings]
~~~~~~~~~~~~~~~~~~
This list constains any Ids that arise from TyCons, Classes or
instances defined interactively, but that are *not* given by
'implicitTyThings'. This includes record selectors, default methods,
and dfuns.
We *could* get rid of this list and generate these Ids from
ic_tythings:
- dfuns come from Instances
- record selectors from TyCons
- default methods from Classes
For record selectors the TyCon gives the Name, but in order to make an
Id we would have to construct the type ourselves. Similarly for
default methods. So for now we collect the Ids after tidying (see
hscDeclsWithLocation) and save them in ic_sys_vars.
The ic_tythings field contains
* The TyThings declared by the user at the command prompt
(eg Ids, TyCons, Classes)
* The user-visible Ids that arise from such things, which
*don't* come from 'implicitTyThings', notably:
- record selectors
- class ops
The implicitTyThings are readily obtained from the TyThings
but record selectors etc are not
It does *not* contain
* DFunIds (they can be gotten from ic_instances)
* CoAxioms (ditto)
See also Note [Interactively-bound Ids in GHCi] in TcRnDriver
-}
-- | Constructs an empty InteractiveContext.
......@@ -1173,7 +1168,6 @@ emptyInteractiveContext dflags
ic_imports = [],
ic_rn_gbl_env = emptyGlobalRdrEnv,
ic_tythings = [],
ic_sys_vars = [],
ic_instances = ([],[]),
ic_fix_env = emptyNameEnv,
-- System.IO.print by default
......
......@@ -84,6 +84,9 @@ import IOEnv hiding ( liftIO, failM, failWithM )
import qualified IOEnv ( liftIO )
import TcEnv ( tcLookupGlobal )
import TcRnMonad ( initTcForLookup )
import InstEnv ( instanceDFunId )
import Type ( tyVarsOfType )
import Id ( idType )
import Var
import VarSet
......@@ -264,12 +267,15 @@ interactiveInScope :: HscEnv -> [Var]
--
-- See Trac #8215 for an example
interactiveInScope hsc_env
= tyvars ++ vars
= varSetElems tyvars ++ ids
where
ictxt = hsc_IC hsc_env
te = mkTypeEnvWithImplicits (ic_tythings ictxt ++ map AnId (ic_sys_vars ictxt))
vars = typeEnvIds te
tyvars = varSetElems $ tyThingsTyVars $ typeEnvElts $ te
-- C.f. TcRnDriver.setInteractiveContext, Desugar.deSugarExpr
ictxt = hsc_IC hsc_env
(cls_insts, _fam_insts) = ic_instances ictxt
te1 = mkTypeEnvWithImplicits (ic_tythings ictxt)
te = extendTypeEnvWithIds te1 (map instanceDFunId cls_insts)
ids = typeEnvIds te
tyvars = foldr (unionVarSet . tyVarsOfType . idType) emptyVarSet ids
-- Why the type variables? How can the top level envt have free tyvars?
-- I think it's because of the GHCi debugger, which can bind variables
-- f :: [t] -> [t]
......
......@@ -25,7 +25,7 @@ module TcEnv(
tcExtendTyVarEnv, tcExtendTyVarEnv2,
tcExtendLetEnv,
tcExtendIdEnv, tcExtendIdEnv1, tcExtendIdEnv2,
tcExtendIdBndrs, tcExtendGlobalTyVars,
tcExtendIdBndrs, tcExtendGhciIdEnv,
tcLookup, tcLookupLocated, tcLookupLocalIds,
tcLookupId, tcLookupTyVar,
......@@ -380,13 +380,66 @@ getScopedTyVarBinds
; return [(name, tv) | ATyVar name tv <- nameEnvElts (tcl_env lcl_env)] }
\end{code}
Note [Initialising the type environment for GHCi]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
tcExtendGhciIdEnv extends the local type environemnt with GHCi
identifiers (from ic_tythings), bound earlier in the interaction.
They may have free type variables (RuntimeUnk things), and if we don't
register these free TyVars as global TyVars then the typechecker will
try to quantify over them and fall over in zonkQuantifiedTyVar.
So we must add any free TyVars to the typechecker's global
TyVar set. That is most conveniently done here, using the local function
tcExtendLocalTypeEnv.
Note especially that
* tcExtendGhciIdEnv extends the local type env, tcl_env
That's important because some are not closed (ie have free tyvars)
and the compiler assumes that the global type env (tcg_type_env) has
no free tyvars. Actually, only ones with Internal names can be non-closed
so we jsut add those
* The tct_closed flag depends on whether the thing has free (RuntimeUnk)
type variables
* It will also does tcExtendGlobalTyVars; this is important
because of those RuntimeUnk variables
* It does not extend the local RdrEnv (tcl_rdr), because the things are
already in the GlobalRdrEnv. Extending the local RdrEnv isn't terrible,
but it means there is an entry for the same Name in both global and local
RdrEnvs, and that lead to duplicate "perhpas you meant..." suggestions
(e.g. T5564).
We don't bother with the tcl_th_bndrs environment either.
* NB: all these TcTyThings will be in the global type envt (tcg_type_env) as
well. We are just shadowing them here to deal with the global tyvar
stuff. That's why we can simply drop the External-Name ones; they
will be found in the global envt
\begin{code}
tcExtendGhciIdEnv :: [TyThing] -> TcM a -> TcM a
-- Used to bind Ids for GHCi identifiers bound earlier in the user interaction
-- See Note [Initialising the type environment for GHCi]
tcExtendGhciIdEnv ids thing_inside
= do { lcl_env <- tcExtendLocalTypeEnv tc_ty_things
; setLclEnv lcl_env thing_inside }
where
tc_ty_things = [ (name, ATcId { tct_id = id
, tct_closed = is_top id })
| AnId id <- ids
, let name = idName id
, isInternalName name ]
is_top id | isEmptyVarSet (tyVarsOfType (idType id)) = TopLevel
| otherwise = NotTopLevel
tcExtendLetEnv :: TopLevelFlag -> TopLevelFlag -> [TcId] -> TcM a -> TcM a
tcExtendLetEnv top_lvl closed ids thing_inside
-- Used for both top-level value bindings and and nested let/where-bindings
tcExtendLetEnv top_lvl closed ids thing_inside
= do { stage <- getStage
; tc_extend_local_env (top_lvl, thLevel stage)
[ (idName id, ATcId { tct_id = id
[ (idName id, ATcId { tct_id = id
, tct_closed = closed })
| id <- ids] $
tcExtendIdBndrs [TcIdBndr id top_lvl | id <- ids] thing_inside }
......@@ -431,50 +484,50 @@ tc_extend_local_env :: (TopLevelFlag, ThLevel) -> [(Name, TcTyThing)] -> TcM a -
tc_extend_local_env thlvl extra_env thing_inside
= do { traceTc "env2" (ppr extra_env)
; env1 <- tcExtendGlobalTyVars (map snd extra_env)
; env1 <- tcExtendLocalTypeEnv extra_env
; let env2 = extend_local_env thlvl extra_env env1
; setLclEnv env2 thing_inside }
extend_local_env :: (TopLevelFlag, ThLevel) -> [(Name, TcTyThing)] -> TcLclEnv -> TcLclEnv
-- Extend the local TcTypeEnv *and* the local LocalRdrEnv simultaneously
-- Reason for extending LocalRdrEnv: after running a TH splice we need
-- to do renaming.
extend_local_env thlvl pairs env@(TcLclEnv { tcl_rdr = rdr_env
, tcl_env = type_env
, tcl_th_bndrs = th_bndrs })
= env { tcl_rdr = extendLocalRdrEnvList rdr_env
[ n | (n, _) <- pairs, isInternalName n ]
-- The LocalRdrEnv contains only non-top-level names
-- (GlobalRdrEnv handles the top level)
, tcl_th_bndrs = extendNameEnvList th_bndrs -- We only track Ids in tcl_th_bndrs
[(n, thlvl) | (n, ATcId {}) <- pairs]
, tcl_env = extendNameEnvList type_env pairs }
tcExtendGlobalTyVars :: [TcTyThing] -> TcM TcLclEnv
tcExtendGlobalTyVars tc_ty_things
where
extend_local_env :: (TopLevelFlag, ThLevel) -> [(Name, TcTyThing)] -> TcLclEnv -> TcLclEnv
-- Extend the local LocalRdrEnv and Template Haskell staging env simultaneously
-- Reason for extending LocalRdrEnv: after running a TH splice we need
-- to do renaming.
extend_local_env thlvl pairs env@(TcLclEnv { tcl_rdr = rdr_env
, tcl_th_bndrs = th_bndrs })
= env { tcl_rdr = extendLocalRdrEnvList rdr_env
[ n | (n, _) <- pairs, isInternalName n ]
-- The LocalRdrEnv contains only non-top-level names
-- (GlobalRdrEnv handles the top level)
, tcl_th_bndrs = extendNameEnvList th_bndrs -- We only track Ids in tcl_th_bndrs
[(n, thlvl) | (n, ATcId {}) <- pairs] }
tcExtendLocalTypeEnv :: [(Name, TcTyThing)] -> TcM TcLclEnv
tcExtendLocalTypeEnv tc_ty_things
| isEmptyVarSet extra_tvs
= getLclEnv
= do { lcl_env@(TcLclEnv { tcl_env = lcl_type_env }) <- getLclEnv
; return (lcl_env { tcl_env = extendNameEnvList lcl_type_env tc_ty_things } ) }
| otherwise
= do { lcl_env <- getLclEnv
= do { lcl_env@(TcLclEnv { tcl_env = lcl_type_env }) <- getLclEnv
; global_tvs <- readMutVar (tcl_tyvars lcl_env)
; new_g_var <- newMutVar (global_tvs `unionVarSet` extra_tvs)
; return (lcl_env { tcl_tyvars = new_g_var }) }
; return (lcl_env { tcl_tyvars = new_g_var
, tcl_env = extendNameEnvList lcl_type_env tc_ty_things } ) }
where
extra_tvs = foldr get_tvs emptyVarSet tc_ty_things
get_tvs (ATcId { tct_id = id, tct_closed = closed }) tvs
get_tvs (_, ATcId { tct_id = id, tct_closed = closed }) tvs
= case closed of
TopLevel -> ASSERT2( isEmptyVarSet (tyVarsOfType (idType id)), ppr id $$ ppr (idType id) )
tvs
NotTopLevel -> tvs `unionVarSet` tyVarsOfType (idType id)
get_tvs (ATyVar _ tv) tvs -- See Note [Global TyVars]
get_tvs (_, ATyVar _ tv) tvs -- See Note [Global TyVars]
= tvs `unionVarSet` tyVarsOfType (tyVarKind tv) `extendVarSet` tv
get_tvs (AThing k) tvs = tvs `unionVarSet` tyVarsOfType k
get_tvs (_, AThing k) tvs = tvs `unionVarSet` tyVarsOfType k
get_tvs (AGlobal {}) tvs = tvs
get_tvs (APromotionErr {}) tvs = tvs
get_tvs (_, AGlobal {}) tvs = tvs
get_tvs (_, APromotionErr {}) tvs = tvs
-- Note [Global TyVars]
-- It's important to add the in-scope tyvars to the global tyvar set
......
......@@ -62,7 +62,6 @@ import CoreSyn
import ErrUtils
import Id
import VarEnv
import VarSet
import Module
import UniqFM
import Name
......@@ -83,9 +82,9 @@ import Annotations
import Data.List ( sortBy )
import Data.IORef ( readIORef )
import Data.Ord
import BasicTypes hiding( SuccessFlag(..) )
#ifdef GHCI
import BasicTypes hiding( SuccessFlag(..) )
import TcType ( isUnitTy, isTauTy )
import TcHsType
import TcMatches
......@@ -1440,22 +1439,32 @@ get two defns for 'main' in the interface file!
%*********************************************************
\begin{code}
setInteractiveContext :: HscEnv -> InteractiveContext -> TcRn a -> TcRn a
setInteractiveContext hsc_env icxt thing_inside
setInteractiveContext :: HscEnv -> TcRn a -> TcRn a
setInteractiveContext hsc_env thing_inside
= let -- Initialise the tcg_inst_env with instances from all home modules.
-- This mimics the more selective call to hptInstances in tcRnImports
icxt = hsc_IC hsc_env
(home_insts, home_fam_insts) = hptInstances hsc_env (\_ -> True)
(ic_insts, ic_finsts) = ic_instances icxt
ty_things = ic_tythings icxt
type_env = mkTypeEnvWithImplicits
(map AnId (ic_sys_vars icxt) ++ ty_things)
type_env1 = mkTypeEnvWithImplicits ty_things
type_env = extendTypeEnvWithIds type_env1 (map instanceDFunId ic_insts)
-- Putting the dfuns in the type_env is just
-- to keep Core Lint happy
con_fields = [ (dataConName c, dataConFieldLabels c)
| ATyCon t <- ty_things
| ATyCon t <- ic_tythings icxt
, c <- tyConDataCons t ]
in
do { gbl_env <- getGblEnv
do { traceTc "setInteractiveContext" $
vcat [ text "ic_tythings:" <+> vcat (map ppr (ic_tythings icxt))
, text "ic_insts:" <+> vcat (map (pprBndr LetBind . instanceDFunId) ic_insts)
, text "ic_rn_gbl_env (LocalDef)" <+>
vcat (map ppr [ local_gres | gres <- occEnvElts (ic_rn_gbl_env icxt)
, let local_gres = filter isLocalGRE gres
, not (null local_gres) ]) ]
; gbl_env <- getGblEnv
; let gbl_env' = gbl_env {
tcg_rdr_env = ic_rn_gbl_env icxt
, tcg_type_env = type_env
......@@ -1470,17 +1479,14 @@ setInteractiveContext hsc_env icxt thing_inside
home_fam_insts
, tcg_field_env = RecFields (mkNameEnv con_fields)
(mkNameSet (concatMap snd con_fields))
-- setting tcg_field_env is necessary
-- setting tcg_field_env is necessary
-- to make RecordWildCards work (test: ghci049)
, tcg_fix_env = ic_fix_env icxt
, tcg_default = ic_default icxt }
; lcl_env' <- tcExtendGlobalTyVars [ ATcId { tct_id = id, tct_closed = NotTopLevel }
| AnId id <- ty_things
, not (isEmptyVarSet (tyVarsOfType (idType id))) ]
-- See Note [Global tyvars]
; setEnvs (gbl_env', lcl_env') thing_inside }
; setGblEnv gbl_env' $
tcExtendGhciIdEnv ty_things $ -- See Note [Initialising the type environment for GHCi]
thing_inside } -- in TcEnv
#ifdef GHCI
-- | The returned [Id] is the list of new Ids bound by this statement. It can
......@@ -1488,11 +1494,11 @@ setInteractiveContext hsc_env icxt thing_inside
--
-- The returned TypecheckedHsExpr is of type IO [ () ], a list of the bound
-- values, coerced to ().
tcRnStmt :: HscEnv -> InteractiveContext -> GhciLStmt RdrName
tcRnStmt :: HscEnv -> GhciLStmt RdrName
-> IO (Messages, Maybe ([Id], LHsExpr Id, FixityEnv))
tcRnStmt hsc_env ictxt rdr_stmt
tcRnStmt hsc_env rdr_stmt
= initTcPrintErrors hsc_env iNTERACTIVE $
setInteractiveContext hsc_env ictxt $ do {
setInteractiveContext hsc_env $ do {
-- The real work is done here
((bound_ids, tc_expr), fix_env) <- tcUserStmt rdr_stmt ;
......@@ -1537,16 +1543,6 @@ tcRnStmt hsc_env ictxt rdr_stmt
nest 2 (ppr id <+> dcolon <+> ppr (idType id))])
\end{code}
Note [Global tyvars]
~~~~~~~~~~~~~~~~~~~~
Ids bound interactively (in ic_tythings) might have some free type
variables (RuntimeUnk things), and if we don't register these free
TyVars as global TyVars then the typechecker will try to quantify over
them and fall over in zonkQuantifiedTyVar.
So we must add any free TyVars to the typechecker's global
TyVar set.
Note [Interactively-bound Ids in GHCi]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The Ids bound by previous Stmts in GHCi are currently
......@@ -1778,10 +1774,10 @@ getGhciStepIO = do
step = noLoc $ ExprWithTySig (nlHsVar ghciStepIoMName) stepTy
return step
isGHCiMonad :: HscEnv -> InteractiveContext -> String -> IO (Messages, Maybe Name)
isGHCiMonad hsc_env ictxt ty
isGHCiMonad :: HscEnv -> String -> IO (Messages, Maybe Name)
isGHCiMonad hsc_env ty
= initTcPrintErrors hsc_env iNTERACTIVE $
setInteractiveContext hsc_env ictxt $ do
setInteractiveContext hsc_env $ do
rdrEnv <- getGlobalRdrEnv
let occIO = lookupOccEnv rdrEnv (mkOccName tcName ty)
case occIO of
......@@ -1802,13 +1798,12 @@ tcRnExpr just finds the type of an expression
\begin{code}
tcRnExpr :: HscEnv
-> InteractiveContext
-> LHsExpr RdrName
-> IO (Messages, Maybe Type)
-- Type checks the expression and returns its most general type
tcRnExpr hsc_env ictxt rdr_expr
tcRnExpr hsc_env rdr_expr
= initTcPrintErrors hsc_env iNTERACTIVE $
setInteractiveContext hsc_env ictxt $ do {
setInteractiveContext hsc_env $ do {
(rn_expr, _fvs) <- rnLExpr rdr_expr ;
failIfErrsM ;
......@@ -1845,13 +1840,12 @@ tcRnType just finds the kind of a type
\begin{code}
tcRnType :: HscEnv
-> InteractiveContext
-> Bool -- Normalise the returned type
-> LHsType RdrName
-> IO (Messages, Maybe (Type, Kind))
tcRnType hsc_env ictxt normalise rdr_type
tcRnType hsc_env normalise rdr_type
= initTcPrintErrors hsc_env iNTERACTIVE $
setInteractiveContext hsc_env ictxt $
setInteractiveContext hsc_env $
setXOptM Opt_PolyKinds $ -- See Note [Kind-generalise in tcRnType]
do { (rn_type, _fvs) <- rnLHsType GHCiCtx rdr_type
; failIfErrsM
......@@ -1891,13 +1885,12 @@ tcRnDeclsi exists to allow class, data, and other declarations in GHCi.
\begin{code}
tcRnDeclsi :: HscEnv
-> InteractiveContext
-> [LHsDecl RdrName]
-> IO (Messages, Maybe TcGblEnv)
tcRnDeclsi hsc_env ictxt local_decls =
tcRnDeclsi hsc_env local_decls =
initTcPrintErrors hsc_env iNTERACTIVE $
setInteractiveContext hsc_env ictxt $ do
setInteractiveContext hsc_env $ do
((tcg_env, tclcl_env), lie) <-
captureConstraints $ tc_rn_src_decls emptyModDetails local_decls
......@@ -1953,7 +1946,7 @@ getModuleInterface hsc_env mod
tcRnLookupRdrName :: HscEnv -> RdrName -> IO (Messages, Maybe [Name])
tcRnLookupRdrName hsc_env rdr_name
= initTcPrintErrors hsc_env iNTERACTIVE $
setInteractiveContext hsc_env (hsc_IC hsc_env) $
setInteractiveContext hsc_env $
lookup_rdr_name rdr_name
lookup_rdr_name :: RdrName -> TcM [Name]
......@@ -1989,7 +1982,7 @@ lookup_rdr_name rdr_name = do
tcRnLookupName :: HscEnv -> Name -> IO (Messages, Maybe TyThing)
tcRnLookupName hsc_env name
= initTcPrintErrors hsc_env iNTERACTIVE $
setInteractiveContext hsc_env (hsc_IC hsc_env) $
setInteractiveContext hsc_env $
tcRnLookupName' name
-- To look up a name we have to look in the local environment (tcl_lcl)
......@@ -2016,15 +2009,14 @@ tcRnGetInfo :: HscEnv
-- *and* as a type or class constructor;
-- hence the call to dataTcOccs, and we return up to two results
tcRnGetInfo hsc_env name
= let ictxt = hsc_IC hsc_env in
initTcPrintErrors hsc_env iNTERACTIVE $
setInteractiveContext hsc_env ictxt $ do
= initTcPrintErrors hsc_env iNTERACTIVE $
setInteractiveContext hsc_env $ do
-- Load the interface for all unqualified types and classes
-- That way we will find all the instance declarations
-- (Packages have not orphan modules, and we assume that
-- in the home package all relevant modules are loaded.)
loadUnqualIfaces hsc_env ictxt
loadUnqualIfaces hsc_env (hsc_IC hsc_env)
thing <- tcRnLookupName' name
fixity <- lookupFixityRn name
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment