import Linker
import RtClosureInspect
-import PrelNames
import HscTypes
import IdInfo
--import Id
+import Name
import Var hiding ( varName )
import VarSet
import VarEnv
import Name
-import NameEnv
-import RdrName
import UniqSupply
import Type
-import TyCon
+import TcType
import TcGadt
import GHC
import GhciMonad
-
+import InteractiveEval
import Outputable
import Pretty ( Mode(..), showDocWith )
import FastString
import GHC.Exts
#include "HsVersions.h"
-
-------------------------------------
-- | The :print & friends commands
-------------------------------------
-pprintClosureCommand :: Bool -> Bool -> String -> GHCi ()
-pprintClosureCommand bindThings force str = do
- cms <- getSession
+pprintClosureCommand :: Session -> Bool -> Bool -> String -> IO ()
+pprintClosureCommand session bindThings force str = do
tythings <- (catMaybes . concat) `liftM`
- mapM (\w -> io(GHC.parseName cms w >>=
- mapM (GHC.lookupName cms)))
+ mapM (\w -> GHC.parseName session w >>=
+ mapM (GHC.lookupName session))
(words str)
- substs <- catMaybes `liftM` mapM (io . go cms)
+ substs <- catMaybes `liftM` mapM (go session)
[id | AnId id <- tythings]
- mapM (io . applySubstToEnv cms) substs
- return ()
+ modifySession session $ \hsc_env ->
+ hsc_env{hsc_IC = foldr (flip substInteractiveContext)
+ (hsc_IC hsc_env)
+ (map skolemiseSubst substs)}
where
- -- Do the obtainTerm--bindSuspensions-refineIdType dance
- -- Warning! This function got a good deal of side-effects
+ -- Do the obtainTerm--bindSuspensions-computeSubstitution dance
go :: Session -> Id -> IO (Maybe TvSubst)
- go cms id = do
- mb_term <- obtainTerm cms force id
- maybe (return Nothing) `flip` mb_term $ \term -> do
- term' <- if not bindThings then return term
+ go cms id = do
+ term_ <- withSession cms $ \hsc_env -> obtainTerm hsc_env force id
+ term <- tidyTermTyVars cms term_
+ term' <- if not bindThings then return term
else bindSuspensions cms term
- showterm <- printTerm cms term'
- unqual <- GHC.getPrintUnqual cms
+ showterm <- printTerm cms term'
+ unqual <- GHC.getPrintUnqual cms
let showSDocForUserOneLine unqual doc =
showDocWith LeftMode (doc (mkErrStyle unqual))
- (putStrLn . showSDocForUserOneLine unqual) (ppr id <+> char '=' <+> showterm)
+ (putStrLn . showSDocForUserOneLine unqual)
+ (ppr id <+> char '=' <+> showterm)
-- Before leaving, we compare the type obtained to see if it's more specific
-- Then, we extract a substitution,
-- mapping the old tyvars to the reconstructed types.
let Just reconstructed_type = termType term
- mb_subst = tcUnifyTys (const BindMe) [idType id] [reconstructed_type]
- ASSERT (isJust mb_subst) return mb_subst
+ mb_subst = computeRTTIsubst (idType id) (reconstructed_type)
- applySubstToEnv :: Session -> TvSubst -> IO ()
- applySubstToEnv cms subst | isEmptyTvSubst subst = return ()
- applySubstToEnv cms@(Session ref) subst = do
- hsc_env <- readIORef ref
- inScope <- GHC.getBindings cms
- let ictxt = hsc_IC hsc_env
- type_env = ic_type_env ictxt
- ids = typeEnvIds type_env
- ids' = map (\id -> setIdType id (substTy subst (idType id))) ids
- type_env'= extendTypeEnvWithIds type_env ids'
- ictxt' = ictxt { ic_type_env = type_env' }
- writeIORef ref (hsc_env {hsc_IC = ictxt'})
+ ASSERT2 (isJust mb_subst, ppr reconstructed_type $$ (ppr$ idType id))
+ return mb_subst
+
+ tidyTermTyVars :: Session -> Term -> IO Term
+ tidyTermTyVars (Session ref) t = do
+ hsc_env <- readIORef ref
+ let env_tvs = ic_tyvars (hsc_IC hsc_env)
+ my_tvs = termTyVars t
+ tvs = env_tvs `minusVarSet` my_tvs
+ tyvarOccName = nameOccName . tyVarName
+ tidyEnv = (initTidyOccEnv (map tyvarOccName (varSetElems tvs))
+ , env_tvs `intersectVarSet` my_tvs)
+ return$ mapTermType (snd . tidyOpenType tidyEnv) t
-- | Give names, and bind in the interactive environment, to all the suspensions
-- included (inductively) in a term
hsc_env <- readIORef ref
inScope <- GHC.getBindings cms
let ictxt = hsc_IC hsc_env
- rn_env = ic_rn_local_env ictxt
- type_env = ic_type_env ictxt
prefix = "_t"
alreadyUsedNames = map (occNameString . nameOccName . getName) inScope
availNames = map ((prefix++) . show) [1..] \\ alreadyUsedNames
availNames_var <- newIORef availNames
(t', stuff) <- foldTerm (nameSuspensionsAndGetInfos availNames_var) t
let (names, tys, hvals) = unzip3 stuff
+ let tys' = map (fst.skolemiseTy) tys
let ids = [ mkGlobalId VanillaGlobal name ty vanillaIdInfo
- | (name,ty) <- zip names tys]
- new_type_env = extendTypeEnvWithIds type_env ids
- new_rn_env = extendLocalRdrEnv rn_env names
- new_ic = ictxt { ic_rn_local_env = new_rn_env,
- ic_type_env = new_type_env }
+ | (name,ty) <- zip names tys']
+ new_tyvars = tyVarsOfTypes tys'
+ new_ic = extendInteractiveContext ictxt ids new_tyvars
extendLinkEnv (zip names hvals)
writeIORef ref (hsc_env {hsc_IC = new_ic })
return t'
- where
+ where
-- Processing suspensions. Give names and recopilate info
- nameSuspensionsAndGetInfos :: IORef [String] -> TermFold (IO (Term, [(Name,Type,HValue)]))
+ nameSuspensionsAndGetInfos :: IORef [String] ->
+ TermFold (IO (Term, [(Name,Type,HValue)]))
nameSuspensionsAndGetInfos freeNames = TermFold
{
fSuspension = doSuspension freeNames
GHC.setSessionDynFlags cms dflags{log_action=noop_log}
mb_txt <- withExtendedLinkEnv [(bname, val)]
(GHC.compileExpr cms expr)
- let myprec = 9 -- TODO Infix constructors
+ let myprec = 10 -- application precedence. TODO Infix constructors
case mb_txt of
- Just txt -> return . Just . text . unsafeCoerce#
- $ txt
- Nothing -> return Nothing
+ Just txt_ | txt <- unsafeCoerce# txt_, not (null txt)
+ -> return $ Just$ cparen (prec >= myprec &&
+ needsParens txt)
+ (text txt)
+ _ -> return Nothing
`finally` do
writeIORef ref hsc_env
GHC.setSessionDynFlags cms dflags
-
+ needsParens ('"':txt) = False -- some simple heuristics to see whether parens
+ -- are redundant in an arbitrary Show output
+ needsParens ('(':txt) = False
+ needsParens txt = ' ' `elem` txt
+
+
bindToFreshName hsc_env ty userName = do
name <- newGrimName cms userName
let ictxt = hsc_IC hsc_env
- rn_env = ic_rn_local_env ictxt
- type_env = ic_type_env ictxt
- id = mkGlobalId VanillaGlobal name ty vanillaIdInfo
- new_type_env = extendTypeEnv type_env (AnId id)
- new_rn_env = extendLocalRdrEnv rn_env [name]
- new_ic = ictxt { ic_rn_local_env = new_rn_env,
- ic_type_env = new_type_env }
+ tmp_ids = ic_tmp_ids ictxt
+ id = mkGlobalId VanillaGlobal name (sigmaType ty) vanillaIdInfo
+ new_ic = ictxt { ic_tmp_ids = id : tmp_ids }
return (hsc_env {hsc_IC = new_ic }, name)
-- Create new uniques and give them sequentially numbered names
us <- mkSplitUniqSupply 'b'
let unique = uniqFromSupply us
occname = mkOccName varName userName
- name = mkInternalName unique occname noSrcLoc
+ name = mkInternalName unique occname noSrcSpan
return name
projects / ghc-hetmet.git / blobdiff