cvObtainTerm, -- :: HscEnv -> Bool -> Maybe Type -> HValue -> IO Term
- AddressEnv(..),
- DataConEnv,
- extendAddressEnvList,
- elemAddressEnv,
- delFromAddressEnv,
- emptyAddressEnv,
- lookupAddressEnv,
-
- ClosureType(..),
- getClosureData,
- Closure ( tipe, infoTable, ptrs, nonPtrs ),
- getClosureType,
- isConstr,
- isIndirection,
- getInfoTablePtr,
-
- Term(..),
- printTerm,
- customPrintTerm,
- customPrintTermBase,
+ Term(..),
+ pprTerm,
+ cPprTerm,
+ cPprTermBase,
termType,
foldTerm,
TermFold(..),
isFullyEvaluated,
isPointed,
isFullyEvaluatedTerm,
+ mapTermType,
+ termTyVars,
-- unsafeDeepSeq,
+ cvReconstructType
) where
#include "HsVersions.h"
import DataCon
import Type
-import TcRnMonad ( TcM, initTcPrintErrors, ioToTcRn, recoverM, writeMutVar )
+import TcRnMonad ( TcM, initTcPrintErrors, ioToTcRn, recoverM
+ , writeMutVar )
import TcType
import TcMType
import TcUnify
import Name
import VarEnv
import OccName
+import Util
import VarSet
-import Unique
import {-#SOURCE#-} TcRnDriver ( tcRnRecoverDataCon )
import TysPrim
import PrelNames
import TysWiredIn
-import Constants ( wORD_SIZE )
+import Constants
import Outputable
import Maybes
import Panic
import GHC.Arr ( Array(..) )
import GHC.Ptr ( Ptr(..), castPtr )
-import GHC.Exts
-import GHC.Int ( Int32(..), Int64(..) )
-import GHC.Word ( Word32(..), Word64(..) )
+import GHC.Exts
import Control.Monad
import Data.Maybe
import Data.Array.Base
-import Data.List ( partition )
-import Foreign.Storable
+import Data.List ( partition, nub )
+import Foreign
+import System.IO.Unsafe
---------------------------------------------
-- * A representation of semi evaluated Terms
> (('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
- , dc :: DataCon
+ , dc :: DataCon -- The heap datacon. If ty is a newtype,
+ -- this is NOT the newtype datacon
, val :: HValue
, subTerms :: [Term] }
| Prim { ty :: Type
- , value :: String }
+ , value :: [Word] }
| Suspension { ctype :: ClosureType
, mb_ty :: Maybe Type
termType t@(Suspension {}) = mb_ty t
termType t = Just$ ty t
+isFullyEvaluatedTerm :: Term -> Bool
+isFullyEvaluatedTerm Term {subTerms=tt} = all isFullyEvaluatedTerm tt
+isFullyEvaluatedTerm Suspension {} = False
+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
deriving (Show, Eq)
data Closure = Closure { tipe :: ClosureType
+ , infoPtr :: Ptr ()
, infoTable :: StgInfoTable
, ptrs :: Array Int HValue
- -- What would be the type here? HValue is ok? Should I build a Ptr?
- , nonPtrs :: ByteArray#
+ , nonPtrs :: [Word]
}
instance Outputable ClosureType where
ppr = text . show
-getInfoTablePtr :: a -> Ptr StgInfoTable
-getInfoTablePtr x =
- case infoPtr# x of
- itbl_ptr -> castPtr ( Ptr itbl_ptr )
-
-getClosureType :: a -> IO ClosureType
-getClosureType = liftM (readCType . BCI.tipe ) . peek . getInfoTablePtr
-
#include "../includes/ClosureTypes.h"
aP_CODE = AP
#undef PAP
getClosureData :: a -> IO Closure
-getClosureData a = do
- itbl <- peek (getInfoTablePtr a)
- let tipe = readCType (BCI.tipe itbl)
- case closurePayload# a of
- (# ptrs, nptrs #) ->
- let elems = BCI.ptrs itbl
+getClosureData a =
+ case unpackClosure# a of
+ (# iptr, ptrs, nptrs #) -> do
+ itbl <- peek (Ptr iptr)
+ let tipe = readCType (BCI.tipe itbl)
+ elems = BCI.ptrs itbl
ptrsList = Array 0 (fromIntegral$ elems) ptrs
- in ptrsList `seq` return (Closure tipe itbl ptrsList nptrs)
+ nptrs_data = [W# (indexWordArray# nptrs i)
+ | I# i <- [0.. fromIntegral (BCI.nptrs itbl)] ]
+ ptrsList `seq`
+ return (Closure tipe (Ptr iptr) itbl ptrsList nptrs_data)
readCType :: Integral a => a -> ClosureType
readCType i
| 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
unsafeDeepSeq :: a -> b -> b
unsafeDeepSeq = unsafeDeepSeq1 2
where unsafeDeepSeq1 0 a b = seq a $! b
- unsafeDeepSeq1 i a b -- 1st case avoids infinite loops for non reducible thunks
+ unsafeDeepSeq1 i a b -- 1st case avoids infinite loops for non reducible thunks
| not (isConstr tipe) = seq a $! unsafeDeepSeq1 (i-1) a b
-- | unsafePerformIO (isFullyEvaluated a) = b
| otherwise = case unsafePerformIO (getClosureData a) of
where tipe = unsafePerformIO (getClosureType a)
-}
isPointed :: Type -> Bool
-isPointed t | Just (t, _) <- splitTyConApp_maybe t = not$ isUnliftedTypeKind (tyConKind t)
+isPointed t | Just (t, _) <- splitTyConApp_maybe t
+ = not$ isUnliftedTypeKind (tyConKind t)
isPointed _ = True
-#define MKDECODER(offset,cons,builder) (offset, show$ cons (builder addr 0#))
-
-extractUnboxed :: [Type] -> ByteArray# -> [String]
-extractUnboxed tt ba = helper tt (byteArrayContents# ba)
- where helper :: [Type] -> Addr# -> [String]
- helper (t:tt) addr
- | Just ( tycon,_) <- splitTyConApp_maybe t
- = let (offset, txt) = decode tycon addr
- (I# word_offset) = offset*wORD_SIZE
- in txt : helper tt (plusAddr# addr word_offset)
- | otherwise
- = -- ["extractUnboxed.helper: Urk. I got a " ++ showSDoc (ppr t)]
- panic$ "extractUnboxed.helper: Urk. I got a " ++ showSDoc (ppr t)
- helper [] addr = []
- decode :: TyCon -> Addr# -> (Int, String)
- decode t addr
- | t == charPrimTyCon = MKDECODER(1,C#,indexCharOffAddr#)
- | t == intPrimTyCon = MKDECODER(1,I#,indexIntOffAddr#)
- | t == wordPrimTyCon = MKDECODER(1,W#,indexWordOffAddr#)
- | t == floatPrimTyCon = MKDECODER(1,F#,indexFloatOffAddr#)
- | t == doublePrimTyCon = MKDECODER(2,D#,indexDoubleOffAddr#)
- | t == int32PrimTyCon = MKDECODER(1,I32#,indexInt32OffAddr#)
- | t == word32PrimTyCon = MKDECODER(1,W32#,indexWord32OffAddr#)
- | t == int64PrimTyCon = MKDECODER(2,I64#,indexInt64OffAddr#)
- | t == word64PrimTyCon = MKDECODER(2,W64#,indexWord64OffAddr#)
- | t == addrPrimTyCon = MKDECODER(1,I#,(\x off-> addr2Int# (indexAddrOffAddr# x off))) --OPT Improve the presentation of addresses
- | t == stablePtrPrimTyCon = (1, "<stablePtr>")
- | t == stableNamePrimTyCon = (1, "<stableName>")
- | t == statePrimTyCon = (1, "<statethread>")
- | t == realWorldTyCon = (1, "<realworld>")
- | t == threadIdPrimTyCon = (1, "<ThreadId>")
- | t == weakPrimTyCon = (1, "<Weak>")
- | t == arrayPrimTyCon = (1,"<array>")
- | t == byteArrayPrimTyCon = (1,"<bytearray>")
- | t == mutableArrayPrimTyCon = (1, "<mutableArray>")
- | t == mutableByteArrayPrimTyCon = (1, "<mutableByteArray>")
- | t == mutVarPrimTyCon= (1, "<mutVar>")
- | t == mVarPrimTyCon = (1, "<mVar>")
- | t == tVarPrimTyCon = (1, "<tVar>")
- | otherwise = (1, showSDoc (char '<' <> ppr t <> char '>'))
- -- We cannot know the right offset in the otherwise case, so 1 is just a wild dangerous guess!
- -- TODO: Improve the offset handling in decode (make it machine dependant)
+extractUnboxed :: [Type] -> Closure -> [[Word]]
+extractUnboxed tt clos = go tt (nonPtrs clos)
+ where sizeofType t
+ | Just (tycon,_) <- splitTyConApp_maybe t
+ = ASSERT (isPrimTyCon tycon) sizeofTyCon tycon
+ | otherwise = pprPanic "Expected a TcTyCon" (ppr t)
+ go [] _ = []
+ go (t:tt) xx
+ | (x, rest) <- splitAt (sizeofType t `div` wORD_SIZE) xx
+ = x : go tt rest
+
+sizeofTyCon = sizeofPrimRep . tyConPrimRep
-----------------------------------
--- Boilerplate Fold code for Term
+-- * Traversals for Terms
-----------------------------------
data TermFold a = TermFold { fTerm :: Type -> DataCon -> HValue -> [a] -> a
- , fPrim :: Type -> String -> a
- , fSuspension :: ClosureType -> Maybe Type -> HValue -> Maybe Name -> a
+ , fPrim :: Type -> [Word] -> a
+ , fSuspension :: ClosureType -> Maybe Type -> HValue
+ -> Maybe Name -> a
}
foldTerm :: TermFold a -> Term -> 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,cons_prec ::Int
app_prec = 10
+cons_prec = 5 -- TODO Extract this info from GHC itself
-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} =
- parens$ ppr n <> text "::" <> ppr ty
-
-printTerm1 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)
--}
- | null tt = ppr dc
- | otherwise = parensCond (p > app_prec)
- (ppr dc <+> sep (map (printTerm1 (app_prec+1)) tt))
-
- where fixity = undefined
+pprTerm y p t | Just doc <- pprTermM y p t = doc
-printTerm1 _ t = printTerm t
-
-customPrintTerm :: Monad m => ((Int->Term->m SDoc)->[Term->m (Maybe SDoc)]) -> Term -> m SDoc
-customPrintTerm custom = let
--- go :: Monad m => Int -> Term -> m SDoc
+pprTermM :: Monad m => (Int -> Term -> m SDoc) -> Int -> Term -> m SDoc
+pprTermM y p t@Term{dc=dc, subTerms=tt, ty=ty}
+{- | dataConIsInfix dc, (t1:t2:tt') <- tt --TODO fixity
+ = parens (pprTerm1 True t1 <+> ppr dc <+> pprTerm1 True ppr t2)
+ <+> hsep (map (pprTerm1 True) tt)
+-}
+ | null tt = return$ ppr dc
+ | Just (tc,_) <- splitNewTyConApp_maybe ty
+ , isNewTyCon tc
+ , Just new_dc <- maybeTyConSingleCon tc = do
+ real_value <- y 10 t{ty=repType ty}
+ return$ cparen (p >= app_prec) (ppr new_dc <+> real_value)
+ | otherwise = do
+ tt_docs <- mapM (y app_prec) tt
+ return$ cparen (p >= app_prec) (ppr dc <+> sep tt_docs)
+
+pprTermM y _ t = pprTermM1 y t
+
+pprTermM1 _ Prim{value=words, ty=ty} = return$ text$ repPrim (tyConAppTyCon ty)
+ words
+pprTermM1 y t@Term{} = panic "pprTermM1 - unreachable"
+pprTermM1 _ Suspension{bound_to=Nothing} = return$ char '_'
+pprTermM1 _ Suspension{mb_ty=Just ty, bound_to=Just n}
+ | Just _ <- splitFunTy_maybe ty = return$ ptext SLIT("<function>")
+ | otherwise = return$ parens$ ppr n <> text "::" <> ppr ty
+
+-- Takes a list of custom printers with a explicit recursion knot and a term,
+-- and returns the output of the first succesful printer, or the default printer
+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
- mb_customDocs <- sequence$ sequence (custom go) t -- Inner sequence is List monad
- case msum mb_customDocs of -- msum is in Maybe monad
- Just doc -> return$ parensCond (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
- in go 0
- where fixity = undefined
-
-customPrintTermBase :: Monad m => (Int->Term-> m SDoc)->[Term->m (Maybe SDoc)]
-customPrintTermBase showP =
+ let default_ prec t = Just `liftM` pprTermM go prec t
+ mb_customDocs = [pp prec t | pp <- custom go ++ [default_]]
+ Just doc <- firstJustM mb_customDocs
+ return$ cparen (prec>app_prec+1) doc
+ go _ t = pprTermM1 go t
+ firstJustM (mb:mbs) = mb >>= maybe (firstJustM mbs) (return . Just)
+ firstJustM [] = return Nothing
+
+-- Default set of custom printers. Note that the recursion knot is explicit
+cPprTermBase :: Monad m => (Int->Term-> m SDoc)->[Int->Term->m (Maybe SDoc)]
+cPprTermBase y =
[
- test isTupleDC (liftM (parens . cat . 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 isTupleTy (\_ -> liftM (parens . hcat . punctuate comma)
+ . mapM (y (-1)) . subTerms)
+ , ifTerm (\t -> isTyCon listTyCon t && subTerms t `lengthIs` 2)
+ (\ p Term{subTerms=[h,t]} -> doList p h t)
+ , ifTerm (isTyCon intTyCon) (coerceShow$ \(a::Int)->a)
+ , ifTerm (isTyCon charTyCon) (coerceShow$ \(a::Char)->a)
+-- , ifTerm (isTyCon wordTyCon) (coerceShow$ \(a::Word)->a)
+ , ifTerm (isTyCon floatTyCon) (coerceShow$ \(a::Float)->a)
+ , ifTerm (isTyCon doubleTyCon) (coerceShow$ \(a::Double)->a)
+ , ifTerm isIntegerTy (coerceShow$ \(a::Integer)->a)
]
- where test pred f t = if pred t then liftM Just (f 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 Term{val=val} = return . text . show . f . unsafeCoerce# $ val
+ where ifTerm pred f p t@Term{} | pred t = liftM Just (f p t)
+ | otherwise = return Nothing
+ isIntegerTy Term{ty=ty} | Just (tc,_) <- splitTyConApp_maybe ty
+ = tyConName tc == integerTyConName
+ isTupleTy Term{ty=ty} | Just (tc,_) <- splitTyConApp_maybe ty
+ = tc `elem` (fst.unzip.elems) boxedTupleArr
+ isTyCon a_tc Term{ty=ty} | Just (tc,_) <- splitTyConApp_maybe ty
+ = a_tc == tc
+ 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 (cat (punctuate comma init ++ [last]))
+ isConsLast = termType(last elems) /= termType h
+ print_elems <- mapM (y cons_prec) elems
+ return$ if isConsLast
+ then cparen (p >= cons_prec) . hsep . punctuate (space<>colon)
+ $ print_elems
+ else brackets (hcat$ punctuate comma print_elems)
where Just a /= Just b = not (a `coreEqType` b)
_ /= _ = True
getListTerms t@Suspension{} = [t]
getListTerms t = pprPanic "getListTerms" (ppr t)
-isFullyEvaluatedTerm :: Term -> Bool
-isFullyEvaluatedTerm Term {subTerms=tt} = all isFullyEvaluatedTerm tt
-isFullyEvaluatedTerm Suspension {} = False
-isFullyEvaluatedTerm Prim {} = True
+repPrim :: TyCon -> [Word] -> String
+repPrim t = rep where
+ rep x
+ | t == charPrimTyCon = show (build x :: Char)
+ | t == intPrimTyCon = show (build x :: Int)
+ | t == wordPrimTyCon = show (build x :: Word)
+ | t == floatPrimTyCon = show (build x :: Float)
+ | t == doublePrimTyCon = show (build x :: Double)
+ | t == int32PrimTyCon = show (build x :: Int32)
+ | t == word32PrimTyCon = show (build x :: Word32)
+ | t == int64PrimTyCon = show (build x :: Int64)
+ | t == word64PrimTyCon = show (build x :: Word64)
+ | t == addrPrimTyCon = show (nullPtr `plusPtr` build x)
+ | t == stablePtrPrimTyCon = "<stablePtr>"
+ | t == stableNamePrimTyCon = "<stableName>"
+ | t == statePrimTyCon = "<statethread>"
+ | t == realWorldTyCon = "<realworld>"
+ | t == threadIdPrimTyCon = "<ThreadId>"
+ | t == weakPrimTyCon = "<Weak>"
+ | t == arrayPrimTyCon = "<array>"
+ | t == byteArrayPrimTyCon = "<bytearray>"
+ | t == mutableArrayPrimTyCon = "<mutableArray>"
+ | t == mutableByteArrayPrimTyCon = "<mutableByteArray>"
+ | t == mutVarPrimTyCon= "<mutVar>"
+ | t == mVarPrimTyCon = "<mVar>"
+ | t == tVarPrimTyCon = "<tVar>"
+ | otherwise = showSDoc (char '<' <> ppr t <> char '>')
+ where build ww = unsafePerformIO $ withArray ww (peek . castPtr)
+-- This ^^^ relies on the representation of Haskell heap values being
+-- the same as in a C array.
-----------------------------------
-- Type Reconstruction
-----------------------------------
+{-
+Type Reconstruction is type inference done on heap closures.
+The algorithm walks the heap generating a set of equations, which
+are solved with syntactic unification.
+A type reconstruction equation looks like:
+
+ <datacon reptype> = <actual heap contents>
+
+The full equation set is generated by traversing all the subterms, starting
+from a given term.
+
+The only difficult part is that newtypes are only found in the lhs of equations.
+Right hand sides are missing them. We can either (a) drop them from the lhs, or
+(b) reconstruct them in the rhs when possible.
+
+The function congruenceNewtypes takes a shot at (b)
+-}
-- The Type Reconstruction monad
type TR a = TcM a
-runTR :: HscEnv -> TR Term -> IO Term
+runTR :: HscEnv -> TR a -> IO a
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
+ Just x -> return x
trIO :: IO a -> TR a
trIO = liftTcM . ioToTcRn
-addConstraint :: TcType -> TcType -> TR ()
-addConstraint t1 t2 = congruenceNewtypes t1 t2 >> unifyType t1 t2
-
--- A parallel fold over a Type value, replacing
--- in the right side reptypes for newtypes as found in the lhs
--- Sadly it doesn't cover all the possibilities. It does not always manage
--- to recover the highest level type. See test print016 for an example
-congruenceNewtypes :: TcType -> TcType -> TcM TcType
-congruenceNewtypes lhs rhs
--- | pprTrace "Congruence" (ppr lhs $$ ppr rhs) False = undefined
- -- We have a tctyvar at the other side
- | Just tv <- getTyVar_maybe rhs
--- , trace "congruence, entering tyvar" True
- = recoverM (return rhs) $ do
- Indirect ty_v <- readMetaTyVar tv
- newtyped_tytv <- congruenceNewtypes lhs ty_v
- writeMutVar (metaTvRef tv) (Indirect newtyped_tytv)
- return newtyped_tytv
--- We have a function type: go on inductively
- | Just (r1,r2) <- splitFunTy_maybe rhs
- , Just (l1,l2) <- splitFunTy_maybe lhs
- = liftM2 mkFunTy ( congruenceNewtypes l1 r1)
- (congruenceNewtypes l2 r2)
--- There is a newtype at the top level tycon and we can manage it
- | Just (tycon, args) <- splitNewTyConApp_maybe lhs
- , isNewTyCon tycon
- , (tvs, realtipe) <- newTyConRep tycon
- = case tcUnifyTys (const BindMe) [realtipe] [rhs] of
- Just subst ->
- let tvs' = substTys subst (map mkTyVarTy tvs) in
- liftM (mkTyConApp tycon) (zipWithM congruenceNewtypes args tvs')
- otherwise -> panic "congruenceNewtypes: Can't unify a newtype"
-
--- We have a TyconApp: go on inductively
- | Just (tycon, args) <- splitNewTyConApp_maybe lhs
- , Just (tycon_v, args_v) <- splitNewTyConApp_maybe rhs
- = liftM (mkTyConApp tycon_v) (zipWithM congruenceNewtypes args args_v)
-
- | otherwise = return rhs
-
+liftTcM = id
newVar :: Kind -> TR TcTyVar
newVar = liftTcM . newFlexiTyVar
-liftTcM = id
+-- | 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))
+
+-- Adds a constraint of the form t1 == t2
+-- t1 is expected to come from walking the heap
+-- t2 is expected to come from a datacon signature
+-- Before unification, congruenceNewtypes needs to
+-- do its magic.
+addConstraint :: TcType -> TcType -> TR ()
+addConstraint t1 t2 = congruenceNewtypes t1 t2 >>= uncurry unifyType
+
-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
+-- Type & Term reconstruction
cvObtainTerm :: HscEnv -> Bool -> Maybe Type -> HValue -> IO Term
-cvObtainTerm hsc_env force mb_ty a =
- -- Obtain the term and tidy the type before returning it
- cvObtainTerm1 hsc_env force mb_ty a >>= return . tidyTypes
- 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
- | Nothing <- mb_ty = runTR hsc_env . go argTypeKind $ hval
- | Just ty <- mb_ty = runTR hsc_env $ do
- term <- go argTypeKind hval
- ty' <- instScheme ty
- addConstraint ty' (fromMaybe (error "by definition")
- (termType term))
- return term
+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 k a = do
- ctype <- trIO$ getClosureType a
- case ctype of
+ 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 k a
+-- NB. this won't attempt to force a BLACKHOLE. Even with :force, we never
+-- force blackholes, because it would almost certainly result in deadlock,
+-- and showing the '_' is more useful.
+ t | isThunk t && force -> seq a $ go tv ty a
-- We always follow indirections
- _ | isIndirection ctype
- -> do
- clos <- trIO$ getClosureData a
--- dflags <- getSessionDynFlags session
--- debugTraceMsg dflags 2 (text "Following an indirection")
- go k $! (ptrs clos ! 0)
+ Indirection _ -> go tv ty $! (ptrs clos ! 0)
-- The interesting case
Constr -> do
- m_dc <- trIO$ tcRnRecoverDataCon hsc_env a
+ m_dc <- trIO$ tcRnRecoverDataCon hsc_env (infoPtr clos)
case m_dc of
Nothing -> panic "Can't find the DataCon for a term"
Just dc -> do
- clos <- trIO$ getClosureData a
- let extra_args = length(dataConRepArgTys dc) - length(dataConOrigArgTys dc)
- subTtypes = drop extra_args (dataConRepArgTys dc)
+ let extra_args = length(dataConRepArgTys dc) -
+ length(dataConOrigArgTys dc)
+ subTtypes = matchSubTypes dc ty
(subTtypesP, subTtypesNP) = partition isPointed subTtypes
-
- subTermsP <- mapM (\i->extractSubterm i (ptrs clos)
- (subTtypesP!!(i-extra_args)))
- [extra_args..extra_args + length subTtypesP - 1]
- let unboxeds = extractUnboxed subTtypesNP (nonPtrs clos)
+ 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
+ (signatureType,_) <- instScheme(dataConRepType dc)
+ addConstraint myType signatureType
+ 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 clos
subTermsNP = map (uncurry Prim) (zip subTtypesNP unboxeds)
- subTerms = reOrderTerms subTermsP subTermsNP subTtypes
- resType <- liftM mkTyVarTy (newVar k)
- baseType <- instScheme (dataConRepType dc)
- let myType = mkFunTys (map (fromMaybe undefined . termType)
- subTerms)
- resType
- addConstraint baseType myType
- return (Term resType dc a subTerms)
+ 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
- x <- liftM mkTyVarTy (newVar k)
- return (Suspension ctype (Just x) a Nothing)
+ 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#) ptrs ty = case ptrs of
- (Array _ _ ptrs#) -> case indexArray# ptrs# i# of
- (# e #) -> go (typeKind ty) e
+ matchSubTypes dc ty
+ | Just (_,ty_args) <- splitTyConApp_maybe (repType ty)
+ , isVanillaDataCon dc --TODO non-vanilla case
+ = dataConInstArgTys dc ty_args
+-- assumes that newtypes are looked ^^^ through
+ | 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
+
+
+
+-- Fast, breadth-first Type reconstruction
+
+cvReconstructType :: HscEnv -> Bool -> Maybe Type -> HValue -> IO Type
+cvReconstructType hsc_env force mb_ty hval = runTR hsc_env $ do
+ tv <- liftM mkTyVarTy (newVar argTypeKind)
+ case mb_ty of
+ Nothing -> do search (isMonomorphic `fmap` zonkTcType tv)
+ (uncurry go)
+ [(tv, hval)]
+ zonkTcType tv -- TODO untested!
+ Just ty | isMonomorphic ty -> return ty
+ Just ty -> do
+ (ty',rev_subst) <- instScheme (sigmaType ty)
+ addConstraint tv ty'
+ search (isMonomorphic `fmap` zonkTcType tv)
+ (uncurry go)
+ [(tv, hval)]
+ substTy rev_subst `fmap` zonkTcType tv
+ where
+-- search :: m Bool -> ([a] -> [a] -> [a]) -> [a] -> m ()
+ search stop expand [] = return ()
+ search stop expand (x:xx) = do new <- expand x
+ unlessM stop $ search stop expand (xx ++ new)
+
+ -- returns unification tasks,since we are going to want a breadth-first search
+ go :: Type -> HValue -> TR [(Type, HValue)]
+ go tv a = do
+ clos <- trIO $ getClosureData a
+ case tipe clos of
+ Indirection _ -> go tv $! (ptrs clos ! 0)
+ Constr -> do
+ m_dc <- trIO$ tcRnRecoverDataCon hsc_env (infoPtr clos)
+ case m_dc of
+ Nothing -> panic "Can't find the DataCon for a term"
+ Just dc -> do
+ let extra_args = length(dataConRepArgTys dc) -
+ length(dataConOrigArgTys dc)
+ subTtypes <- mapMif (not . isMonomorphic)
+ (\t -> mkTyVarTy `fmap` newVar (typeKind t))
+ (dataConRepArgTys dc)
+ -- It is vital for newtype reconstruction that the unification step
+ -- is done right here, _before_ the subterms are RTTI reconstructed
+ let myType = mkFunTys subTtypes tv
+ (signatureType,_) <- instScheme(dataConRepType dc)
+ addConstraint myType signatureType
+ return $ map (\(I# i#,t) -> case ptrs clos of
+ (Array _ _ ptrs#) -> case indexArray# ptrs# i# of
+ (# e #) -> (t,e))
+ (drop extra_args $ zip [0..] subTtypes)
+ otherwise -> return []
+
+
+-- Dealing with newtypes
+{-
+ A parallel fold over two Type values,
+ compensating for missing newtypes on both sides.
+ This is necessary because newtypes are not present
+ in runtime, but since sometimes there is evidence
+ available we do our best to reconstruct them.
+ Evidence can come from DataCon signatures or
+ from compile-time type inference.
+ I am using the words congruence and rewriting
+ because what we are doing here is an approximation
+ of unification modulo a set of equations, which would
+ come from newtype definitions. These should be the
+ equality coercions seen in System Fc. Rewriting
+ is performed, taking those equations as rules,
+ before launching unification.
+
+ It doesn't make sense to rewrite everywhere,
+ or we would end up with all newtypes. So we rewrite
+ only in presence of evidence.
+ The lhs comes from the heap structure of ptrs,nptrs.
+ The rhs comes from a DataCon type signature.
+ Rewriting in the rhs is restricted to the result type.
+
+ Note that it is very tricky to make this 'rewriting'
+ work with the unification implemented by TcM, where
+ substitutions are 'inlined'. The order in which
+ constraints are unified is vital for this (or I am
+ using TcM wrongly).
+-}
+congruenceNewtypes :: TcType -> TcType -> TcM (TcType,TcType)
+congruenceNewtypes lhs rhs
+ -- TyVar lhs inductive case
+ | Just tv <- getTyVar_maybe lhs
+ = recoverM (return (lhs,rhs)) $ do
+ Indirect ty_v <- readMetaTyVar tv
+ (lhs1, rhs1) <- congruenceNewtypes ty_v rhs
+ return (lhs, rhs1)
+-- FunTy inductive case
+ | Just (l1,l2) <- splitFunTy_maybe lhs
+ , Just (r1,r2) <- splitFunTy_maybe rhs
+ = do (l2',r2') <- congruenceNewtypes l2 r2
+ (l1',r1') <- congruenceNewtypes l1 r1
+ return (mkFunTy l1' l2', mkFunTy r1' r2')
+-- TyconApp Inductive case; this is the interesting bit.
+ | Just (tycon_l, args_l) <- splitNewTyConApp_maybe lhs
+ , Just (tycon_r, args_r) <- splitNewTyConApp_maybe rhs
+ , tycon_l /= tycon_r
+ = return (lhs, upgrade tycon_l rhs)
+
+ | otherwise = return (lhs,rhs)
+
+ where upgrade :: TyCon -> Type -> Type
+ upgrade new_tycon ty
+ | not (isNewTyCon new_tycon) = ty
+ | ty' <- mkTyConApp new_tycon (map mkTyVarTy $ tyConTyVars new_tycon)
+ , Just subst <- tcUnifyTys (const BindMe) [ty] [repType ty']
+ = substTy subst ty'
+ -- assumes that reptype doesn't touch tyconApp args ^^^
+
+
+--------------------------------------------------------------------------------
+
+isMonomorphic ty | (tvs, ty') <- splitForAllTys ty
+ = null tvs && (isEmptyVarSet . tyVarsOfType) ty'
+
+mapMif :: Monad m => (a -> Bool) -> (a -> m a) -> [a] -> m [a]
+mapMif pred f xx = sequence $ mapMif_ pred f xx
+mapMif_ pred f [] = []
+mapMif_ pred f (x:xx) = (if pred x then f x else return x) : mapMif_ pred f xx
+
+unlessM condM acc = condM >>= \c -> unless c acc
+
+-- Strict application of f at index i
+appArr f (Array _ _ ptrs#) (I# i#) = case indexArray# ptrs# i# of
+ (# e #) -> f e
zonkTerm :: Term -> TcM Term
zonkTerm = foldTerm idTermFoldM {
,fSuspension = \ct ty v b -> fmapMMaybe zonkTcType ty >>= \ty ->
return (Suspension ct ty v b)}
-{-
-Example of Type Reconstruction
---------------------------------
-Suppose we have an existential type such as
-
-data Opaque = forall a. Opaque a
-
-And we have a term built as:
-
-t = Opaque (map Just [[1,1],[2,2]])
-
-The type of t as far as the typechecker goes is t :: Opaque
-If we seq the head of t, we obtain:
-
-t - O (_1::a)
-
-seq _1 ()
-
-t - O ( (_3::b) : (_4::[b]) )
-
-seq _3 ()
-
-t - O ( (Just (_5::c)) : (_4::[b]) )
-
-At this point, we know that b = (Maybe c)
-
-seq _5 ()
-
-t - O ( (Just ((_6::d) : (_7::[d]) )) : (_4::[b]) )
-
-At this point, we know that c = [d]
-
-seq _6 ()
-
-t - O ( (Just (1 : (_7::[d]) )) : (_4::[b]) )
-
-At this point, we know that d = Integer
-
-The fully reconstructed expressions, with propagation, would be:
-
-t - O ( (Just (_5::c)) : (_4::[Maybe c]) )
-t - O ( (Just ((_6::d) : (_7::[d]) )) : (_4::[Maybe [d]]) )
-t - O ( (Just (1 : (_7::[Integer]) )) : (_4::[Maybe [Integer]]) )
-
-
-For reference, the type of the thing inside the opaque is
-map Just [[1,1],[2,2]] :: [Maybe [Integer]]
-
-NOTE: (Num t) contexts have been manually replaced by Integer for clarity
--}
-
---------------------------------------------------------------------
--- The DataConEnv is used to store the addresses of datacons loaded
--- via the dynamic linker
---------------------------------------------------------------------
-
-type DataConEnv = AddressEnv StgInfoTable
-
--- Note that this AddressEnv and DataConEnv I wrote trying to follow
--- conventions in ghc, but probably they make not much sense.
-
-newtype AddressEnv a = AE {aenv:: FiniteMap (Ptr a) Name}
- deriving (Outputable)
-
-emptyAddressEnv = AE emptyFM
-
-extendAddressEnvList :: AddressEnv a -> [(Ptr a, Name)] -> AddressEnv a
-elemAddressEnv :: Ptr a -> AddressEnv a -> Bool
-delFromAddressEnv :: AddressEnv a -> Ptr a -> AddressEnv a
-nullAddressEnv :: AddressEnv a -> Bool
-lookupAddressEnv :: AddressEnv a -> Ptr a -> Maybe Name
-extendAddressEnvList (AE env) = AE . addListToFM env
-elemAddressEnv ptr (AE env) = ptr `elemFM` env
-delFromAddressEnv (AE env) = AE . delFromFM env
-nullAddressEnv = isEmptyFM . aenv
-lookupAddressEnv (AE env) = lookupFM env
+-- Is this defined elsewhere?
+-- Generalize the type: find all free tyvars and wrap in the appropiate ForAll.
+sigmaType ty = mkForAllTys (varSetElems$ tyVarsOfType (dropForAlls ty)) ty
-instance Outputable (Ptr a) where
- ppr = text . show