cvObtainTerm, -- :: HscEnv -> Bool -> Maybe Type -> HValue -> IO Term
- ClosureType(..),
- getClosureData, -- :: a -> IO Closure
- Closure ( tipe, infoPtr, ptrs, nonPtrs ),
- isConstr, -- :: ClosureType -> Bool
- isIndirection, -- :: ClosureType -> Bool
-
- Term(..),
- printTerm,
- customPrintTerm,
- customPrintTermBase,
+ Term(..),
+ pprTerm,
+ cPprTerm,
+ cPprTermBase,
termType,
foldTerm,
TermFold(..),
isFullyEvaluated,
isPointed,
isFullyEvaluatedTerm,
+ mapTermType,
+ termTyVars
-- unsafeDeepSeq,
) where
import Control.Monad
import Data.Maybe
import Data.Array.Base
-import Data.List ( partition )
+import Data.List ( partition, nub )
import Foreign.Storable
import IO
> (('a',_,_),_,('b',_,_)) =
Term ((Char,b,c),d,(Char,e,f)) (,,) (('a',_,_),_,('b',_,_))
- [ Term (Char, b, c) (,,) ('a',_,_) [Term Char C# "a", Thunk, Thunk]
- , Thunk
- , Term (Char, e, f) (,,) ('b',_,_) [Term Char C# "b", Thunk, Thunk]]
+ [ Term (Char, b, c) (,,) ('a',_,_) [Term Char C# "a", Suspension, Suspension]
+ , Suspension
+ , Term (Char, e, f) (,,) ('b',_,_) [Term Char C# "b", Suspension, Suspension]]
-}
data Term = Term { ty :: Type
isFullyEvaluatedTerm Prim {} = True
instance Outputable (Term) where
- ppr = head . customPrintTerm customPrintTermBase
+ ppr = head . cPprTerm cPprTermBase
-------------------------------------------------------------------------
-- Runtime Closure Datatype and functions for retrieving closure related stuff
, infoPtr :: Ptr ()
, infoTable :: StgInfoTable
, ptrs :: Array Int HValue
- -- What would be the type here? HValue is ok? Should I build a Ptr?
, nonPtrs :: ByteArray#
}
| i == BLACKHOLE = Blackhole
| i >= IND && i <= IND_STATIC = Indirection (fromIntegral i)
| fromIntegral i == aP_CODE = AP
+ | i == AP_STACK = AP
| fromIntegral i == pAP_CODE = PAP
| otherwise = Other (fromIntegral i)
--isIndirection ThunkSelector = True
isIndirection _ = False
+isThunk (Thunk _) = True
+isThunk ThunkSelector = True
+isThunk AP = True
+isThunk _ = False
+
isFullyEvaluated :: a -> IO Bool
isFullyEvaluated a = do
closure <- getClosureData a
fSuspension = (((return.).).). Suspension
}
+mapTermType f = foldTerm idTermFold {
+ fTerm = \ty dc hval tt -> Term (f ty) dc hval tt,
+ fSuspension = \ct mb_ty hval n ->
+ Suspension ct (fmap f mb_ty) hval n }
+
+termTyVars = foldTerm TermFold {
+ fTerm = \ty _ _ tt ->
+ tyVarsOfType ty `plusVarEnv` concatVarEnv tt,
+ fSuspension = \_ mb_ty _ _ ->
+ maybe emptyVarEnv tyVarsOfType mb_ty,
+ fPrim = \ _ _ -> emptyVarEnv }
+ where concatVarEnv = foldr plusVarEnv emptyVarEnv
----------------------------------
-- Pretty printing of terms
----------------------------------
-parensCond True = parens
-parensCond False = id
app_prec::Int
app_prec = 10
-printTerm :: Term -> SDoc
-printTerm Prim{value=value} = text value
-printTerm t@Term{} = printTerm1 0 t
-printTerm Suspension{bound_to=Nothing} = char '_' -- <> ppr ct <> char '_'
-printTerm Suspension{mb_ty=Just ty, bound_to=Just n}
- | Just _ <- splitFunTy_maybe ty = text "<function>"
- | otherwise = parens$ ppr n <> text "::" <> ppr ty
-
-printTerm1 p Term{dc=dc, subTerms=tt}
+pprTerm :: Int -> Term -> SDoc
+pprTerm p Term{dc=dc, subTerms=tt}
{- | dataConIsInfix dc, (t1:t2:tt') <- tt
- = parens (printTerm1 True t1 <+> ppr dc <+> printTerm1 True ppr t2)
- <+> hsep (map (printTerm1 True) tt)
+ = parens (pprTerm1 True t1 <+> ppr dc <+> pprTerm1 True ppr t2)
+ <+> hsep (map (pprTerm1 True) tt)
-}
| null tt = ppr dc
- | otherwise = parensCond (p > app_prec)
- (ppr dc <+> sep (map (printTerm1 (app_prec+1)) tt))
+ | otherwise = cparen (p >= app_prec)
+ (ppr dc <+> sep (map (pprTerm app_prec) tt))
where fixity = undefined
-printTerm1 _ t = printTerm t
+pprTerm _ t = pprTerm1 t
+
+pprTerm1 Prim{value=value} = text value
+pprTerm1 t@Term{} = pprTerm 0 t
+pprTerm1 Suspension{bound_to=Nothing} = char '_' -- <> ppr ct <> char '_'
+pprTerm1 Suspension{mb_ty=Just ty, bound_to=Just n}
+ | Just _ <- splitFunTy_maybe ty = ptext SLIT("<function>")
+ | otherwise = parens$ ppr n <> text "::" <> ppr ty
+
-customPrintTerm :: forall m. Monad m => ((Int->Term->m SDoc)->[Term->m (Maybe SDoc)]) -> Term -> m SDoc
-customPrintTerm custom = go 0 where
--- go :: Monad m => Int -> Term -> m SDoc
+cPprTerm :: forall m. Monad m => ((Int->Term->m SDoc)->[Int->Term->m (Maybe SDoc)]) -> Term -> m SDoc
+cPprTerm custom = go 0 where
go prec t@Term{subTerms=tt, dc=dc} = do
- let mb_customDocs = map ($t) (custom go) :: [m (Maybe SDoc)]
+ let mb_customDocs = map (($t) . ($prec)) (custom go) :: [m (Maybe SDoc)]
first_success <- firstJustM mb_customDocs
case first_success of
- Just doc -> return$ parensCond (prec>app_prec+1) doc
+ Just doc -> return$ cparen (prec>app_prec+1) doc
-- | dataConIsInfix dc, (t1:t2:tt') <- tt =
Nothing -> do pprSubterms <- mapM (go (app_prec+1)) tt
- return$ parensCond (prec>app_prec+1)
- (ppr dc <+> sep pprSubterms)
- go _ t = return$ printTerm t
+ return$ cparen (prec >= app_prec)
+ (ppr dc <+> sep pprSubterms)
+ go _ t = return$ pprTerm1 t
firstJustM (mb:mbs) = mb >>= maybe (firstJustM mbs) (return . Just)
firstJustM [] = return Nothing
-customPrintTermBase :: Monad m => (Int->Term-> m SDoc)->[Term->m (Maybe SDoc)]
-customPrintTermBase showP =
+cPprTermBase :: Monad m => (Int->Term-> m SDoc)->[Int->Term->m (Maybe SDoc)]
+cPprTermBase pprP =
[
- test isTupleDC (liftM (parens . hcat . punctuate comma) . mapM (showP 0) . subTerms)
- , test (isDC consDataCon) (\Term{subTerms=[h,t]} -> doList h t)
- , test (isDC intDataCon) (coerceShow$ \(a::Int)->a)
- , test (isDC charDataCon) (coerceShow$ \(a::Char)->a)
--- , test (isDC wordDataCon) (coerceShow$ \(a::Word)->a)
- , test (isDC floatDataCon) (coerceShow$ \(a::Float)->a)
- , test (isDC doubleDataCon) (coerceShow$ \(a::Double)->a)
- , test isIntegerDC (coerceShow$ \(a::Integer)->a)
+ ifTerm isTupleDC (\_ -> liftM (parens . hcat . punctuate comma)
+ . mapM (pprP (-1)) . subTerms)
+ , ifTerm (isDC consDataCon) (\ p Term{subTerms=[h,t]} -> doList p h t)
+ , ifTerm (isDC intDataCon) (coerceShow$ \(a::Int)->a)
+ , ifTerm (isDC charDataCon) (coerceShow$ \(a::Char)->a)
+-- , ifTerm (isDC wordDataCon) (coerceShow$ \(a::Word)->a)
+ , ifTerm (isDC floatDataCon) (coerceShow$ \(a::Float)->a)
+ , ifTerm (isDC doubleDataCon) (coerceShow$ \(a::Double)->a)
+ , ifTerm isIntegerDC (coerceShow$ \(a::Integer)->a)
]
- where test pred f t = if pred t then liftM Just (f t) else return Nothing
+ where ifTerm pred f p t = if pred t then liftM Just (f p t) else return Nothing
isIntegerDC Term{dc=dc} =
dataConName dc `elem` [ smallIntegerDataConName
, largeIntegerDataConName]
- isTupleDC Term{dc=dc} = dc `elem` snd (unzip (elems boxedTupleArr))
- isDC a_dc Term{dc=dc} = a_dc == dc
- coerceShow f = return . text . show . f . unsafeCoerce# . val
+ isTupleDC Term{dc=dc} = dc `elem` snd (unzip (elems boxedTupleArr))
+ isDC a_dc Term{dc=dc} = a_dc == dc
+ coerceShow f _ = return . text . show . f . unsafeCoerce# . val
--TODO pprinting of list terms is not lazy
- doList h t = do
+ doList p h t = do
let elems = h : getListTerms t
- isConsLast = isSuspension (last elems) &&
- (mb_ty$ last elems) /= (termType h)
- init <- mapM (showP 0) (init elems)
- last0 <- showP 0 (last elems)
- let last = case length elems of
- 1 -> last0
- _ | isConsLast -> text " | " <> last0
- _ -> comma <> last0
- return$ brackets (hcat (punctuate comma init ++ [last]))
+ isConsLast = termType(last elems) /= termType h
+ print_elems <- mapM (pprP 5) elems
+ return$ if isConsLast
+ then cparen (p >= 5) . hsep . punctuate (space<>colon)
+ $ print_elems
+ else brackets (hcat$ punctuate comma print_elems)
where Just a /= Just b = not (a `coreEqType` b)
_ /= _ = True
runTR :: HscEnv -> TR Term -> IO Term
runTR hsc_env c = do
- mb_term <- initTcPrintErrors hsc_env iNTERACTIVE (c >>= zonkTerm)
+ mb_term <- initTcPrintErrors hsc_env iNTERACTIVE c
case mb_term of
Nothing -> panic "Can't unify"
Just term -> return term
liftTcM = id
-instScheme :: Type -> TR TcType
-instScheme ty = liftTcM$ liftM trd (tcInstType (liftM fst3 . tcInstTyVars) ty)
- where fst3 (x,y,z) = x
- trd (x,y,z) = z
+-- | Returns the instantiated type scheme ty', and the substitution sigma
+-- such that sigma(ty') = ty
+instScheme :: Type -> TR (TcType, TvSubst)
+instScheme ty | (tvs, rho) <- tcSplitForAllTys ty = liftTcM$ do
+ (tvs',theta,ty') <- tcInstType (mapM tcInstTyVar) ty
+ return (ty', zipTopTvSubst tvs' (mkTyVarTys tvs))
cvObtainTerm :: HscEnv -> Bool -> Maybe Type -> HValue -> IO Term
-cvObtainTerm hsc_env force mb_ty a = do
- -- Obtain the term and tidy the type before returning it
- term <- cvObtainTerm1 hsc_env force mb_ty a
- return $ tidyTypes term
- where
- tidyTypes = foldTerm idTermFold {
- fTerm = \ty dc hval tt -> Term (tidy ty) dc hval tt,
- fSuspension = \ct mb_ty hval n ->
- Suspension ct (fmap tidy mb_ty) hval n
- }
- tidy ty = tidyType (emptyTidyOccEnv, tidyVarEnv ty) ty
- tidyVarEnv ty =
-
- mkVarEnv$ [ (v, setTyVarName v (tyVarName tv))
- | (tv,v) <- zip alphaTyVars vars]
- where vars = varSetElems$ tyVarsOfType ty
-
-cvObtainTerm1 :: HscEnv -> Bool -> Maybe Type -> HValue -> IO Term
-cvObtainTerm1 hsc_env force mb_ty hval = runTR hsc_env $ do
- tv <- liftM mkTyVarTy (newVar argTypeKind)
- when (isJust mb_ty) $
- instScheme (sigmaType$ fromJust mb_ty) >>= addConstraint tv
- go tv hval
+cvObtainTerm hsc_env force mb_ty hval = runTR hsc_env $ do
+ tv <- liftM mkTyVarTy (newVar argTypeKind)
+ case mb_ty of
+ Nothing -> go tv tv hval >>= zonkTerm
+ Just ty | isMonomorphic ty -> go ty ty hval >>= zonkTerm
+ Just ty -> do
+ (ty',rev_subst) <- instScheme (sigmaType ty)
+ addConstraint tv ty'
+ term <- go tv tv hval >>= zonkTerm
+ --restore original Tyvars
+ return$ mapTermType (substTy rev_subst) term
where
- go tv a = do
+ go tv ty a = do
+ let monomorphic = not(isTyVarTy tv) -- This is a convention. The ancestor tests for
+ -- monomorphism and passes a type instead of a tv
clos <- trIO $ getClosureData a
case tipe clos of
-- Thunks we may want to force
- Thunk _ | force -> seq a $ go tv a
+ t | isThunk t && force -> seq a $ go tv ty a
-- We always follow indirections
- Indirection _ -> go tv $! (ptrs clos ! 0)
+ Indirection _ -> go tv ty $! (ptrs clos ! 0)
-- The interesting case
Constr -> do
m_dc <- trIO$ tcRnRecoverDataCon hsc_env (infoPtr clos)
Nothing -> panic "Can't find the DataCon for a term"
Just dc -> do
let extra_args = length(dataConRepArgTys dc) - length(dataConOrigArgTys dc)
- subTtypes = drop extra_args (dataConRepArgTys dc)
+ subTtypes = matchSubTypes dc ty
(subTtypesP, subTtypesNP) = partition isPointed subTtypes
- n_subtermsP= length subTtypesP
- subTermTvs <- mapM (liftM mkTyVarTy . newVar ) (map typeKind subTtypesP)
- baseType <- instScheme (dataConRepType dc)
- let myType = mkFunTys (reOrderTerms subTermTvs subTtypesNP subTtypes) tv
- addConstraint myType baseType
- subTermsP <- sequence [ extractSubterm i tv (ptrs clos)
- | (i,tv) <- zip [extra_args..extra_args + n_subtermsP - 1]
- subTermTvs ]
+ subTermTvs <- sequence
+ [ if isMonomorphic t then return t else (mkTyVarTy `fmap` newVar k)
+ | (t,k) <- zip subTtypesP (map typeKind subTtypesP)]
+ -- It is vital for newtype reconstruction that the unification step is done
+ -- right here, _before_ the subterms are RTTI reconstructed.
+ when (not monomorphic) $ do
+ let myType = mkFunTys (reOrderTerms subTermTvs subTtypesNP subTtypes) tv
+ instScheme(dataConRepType dc) >>= addConstraint myType . fst
+ subTermsP <- sequence $ drop extra_args -- all extra arguments are pointed
+ [ appArr (go tv t) (ptrs clos) i
+ | (i,tv,t) <- zip3 [0..] subTermTvs subTtypesP]
let unboxeds = extractUnboxed subTtypesNP (nonPtrs clos)
subTermsNP = map (uncurry Prim) (zip subTtypesNP unboxeds)
- subTerms = reOrderTerms subTermsP subTermsNP subTtypes
+ subTerms = reOrderTerms subTermsP subTermsNP (drop extra_args subTtypes)
return (Term tv dc a subTerms)
-- The otherwise case: can be a Thunk,AP,PAP,etc.
- otherwise -> do
+ otherwise ->
return (Suspension (tipe clos) (Just tv) a Nothing)
-- Access the array of pointers and recurse down. Needs to be done with
-- care of no introducing a thunk! or go will fail to do its job
- extractSubterm (I# i#) tv ptrs = case ptrs of
+ appArr f arr (I# i#) = case arr of
(Array _ _ ptrs#) -> case indexArray# ptrs# i# of
- (# e #) -> go tv e
+ (# e #) -> f e
+
+ matchSubTypes dc ty
+ | Just (_,ty_args) <- splitTyConApp_maybe (repType ty)
+ , null (dataConExTyVars dc) --TODO Handle the case of extra existential tyvars
+ = dataConInstArgTys dc ty_args
+
+ | otherwise = dataConRepArgTys dc
-- This is used to put together pointed and nonpointed subterms in the
-- correct order.
reOrderTerms _ _ [] = []
reOrderTerms pointed unpointed (ty:tys)
- | isPointed ty = head pointed : reOrderTerms (tail pointed) unpointed tys
- | otherwise = head unpointed : reOrderTerms pointed (tail unpointed) tys
+ | isPointed ty = ASSERT2(not(null pointed)
+ , ptext SLIT("reOrderTerms") $$ (ppr pointed $$ ppr unpointed))
+ head pointed : reOrderTerms (tail pointed) unpointed tys
+ | otherwise = ASSERT2(not(null unpointed)
+ , ptext SLIT("reOrderTerms") $$ (ppr pointed $$ ppr unpointed))
+ head unpointed : reOrderTerms pointed (tail unpointed) tys
+
+isMonomorphic ty | isForAllTy ty = False
+isMonomorphic ty = (isEmptyVarSet . tyVarsOfType) ty
zonkTerm :: Term -> TcM Term
zonkTerm = foldTerm idTermFoldM {