)
import TysWiredIn ( charTy, mkListTy )
import PrelRules ( primOpRules )
-import Type ( TyThing(..), mkForAllTy, tyVarsOfTypes, newTyConInstRhs, coreEqType,
- PredType(..),
- mkTopTvSubst, substTyVar )
+import Type ( TyThing(..), mkForAllTy, tyVarsOfTypes,
+ newTyConInstRhs, mkTopTvSubst, substTyVar )
import TcGadt ( gadtRefine, refineType, emptyRefinement )
import HsBinds ( ExprCoFn(..), isIdCoercion )
-import Coercion ( mkSymCoercion, mkUnsafeCoercion,
- splitNewTypeRepCo_maybe, isEqPred )
+import Coercion ( mkSymCoercion, mkUnsafeCoercion, isEqPred )
import TcType ( Type, ThetaType, mkDictTy, mkPredTys, mkPredTy,
- mkTyConApp, mkTyVarTys, mkClassPred,
- mkFunTys, mkFunTy, mkSigmaTy, tcSplitSigmaTy,
+ mkTyConApp, mkTyVarTys, mkClassPred, isPredTy,
+ mkFunTys, mkFunTy, mkSigmaTy, tcSplitSigmaTy, tcEqType,
isUnLiftedType, mkForAllTys, mkTyVarTy, tyVarsOfType,
tcSplitFunTys, tcSplitForAllTys, dataConsStupidTheta
)
import Literal ( nullAddrLit, mkStringLit )
import TyCon ( TyCon, isNewTyCon, tyConDataCons, FieldLabel,
tyConStupidTheta, isProductTyCon, isDataTyCon, isRecursiveTyCon,
- newTyConCo, tyConArity )
+ newTyConCo )
import Class ( Class, classTyCon, classSelIds )
-import Var ( Id, TyVar, Var, setIdType, mkCoVar, mkWildCoVar )
+import Var ( Id, TyVar, Var, setIdType )
import VarSet ( isEmptyVarSet, subVarSet, varSetElems )
-import Name ( mkFCallName, mkWiredInName, Name, BuiltInSyntax(..),
- mkSysTvName )
+import Name ( mkFCallName, mkWiredInName, Name, BuiltInSyntax(..))
import OccName ( mkOccNameFS, varName )
import PrimOp ( PrimOp, primOpSig, primOpOcc, primOpTag )
import ForeignCall ( ForeignCall )
import DataCon ( DataCon, DataConIds(..), dataConTyCon, dataConUnivTyVars,
dataConFieldLabels, dataConRepArity, dataConResTys,
dataConRepArgTys, dataConRepType, dataConFullSig,
- dataConSig, dataConStrictMarks, dataConExStricts,
+ dataConStrictMarks, dataConExStricts,
splitProductType, isVanillaDataCon, dataConFieldType,
- dataConInstOrigArgTys, deepSplitProductType
+ deepSplitProductType
)
import Id ( idType, mkGlobalId, mkVanillaGlobal, mkSysLocal,
mkTemplateLocals, mkTemplateLocalsNum, mkExportedLocalId,
- mkTemplateLocal, idName, mkWildId
+ mkTemplateLocal, idName
)
import IdInfo ( IdInfo, noCafIdInfo, setUnfoldingInfo,
setArityInfo, setSpecInfo, setCafInfo,
(zip (dict_args ++ id_args) all_strict_marks)
i3 []
- con_app i rep_ids = Var wrk_id `mkTyApps` result_ty_args
+ con_app _ rep_ids = Var wrk_id `mkTyApps` result_ty_args
`mkVarApps` ex_tvs
`mkTyApps` map snd eq_spec
`mkVarApps` reverse rep_ids
Case (Var arg) arg result_ty [(DEFAULT,[], body i (arg:rep_args))]
MarkedUnboxed
- -> unboxProduct i (Var arg) (idType arg) the_body result_ty
+ -> unboxProduct i (Var arg) (idType arg) the_body
where
the_body i con_args = body i (reverse con_args ++ rep_args)
-- foo = /\a. \t:T. case t of { MkT f -> f a }
mk_alt data_con
- = -- In the non-vanilla case, the pattern must bind type variables and
- -- the context stuff; hence the arg_prefix binding below
- mkReboxingAlt uniqs' data_con (arg_prefix ++ arg_ids) rhs
+ = ASSERT2( res_ty `tcEqType` field_ty, ppr data_con $$ ppr res_ty $$ ppr field_ty )
+ mkReboxingAlt rebox_uniqs data_con (ex_tvs ++ co_tvs ++ arg_vs) rhs
where
- (arg_prefix, arg_ids)
- = (ex_tvs ++ co_tvs ++ dict_vs, field_vs)
-
-- get pattern binders with types appropriately instantiated
- (ex_tvs, co_tvs, arg_vs) = dataConOrigInstPat uniqs data_con res_tys
- n_vars = (length ex_tvs + length co_tvs + length arg_vs)
- -- separate dicts vars and field vars so we can associate field lbls
- (dict_vs, field_vs) = splitAt (length dc_theta) arg_vs
-
- (_, pre_dc_theta, dc_arg_tys) = dataConSig data_con
- dc_theta = filter (not . isEqPred) pre_dc_theta
-
- arg_base' = arg_base + length dc_theta
+ arg_uniqs = map mkBuiltinUnique [arg_base..]
+ (ex_tvs, co_tvs, arg_vs) = dataConOrigInstPat arg_uniqs data_con res_tys
- unpack_base = arg_base' + length dc_arg_tys
+ rebox_base = arg_base + length ex_tvs + length co_tvs + length arg_vs
+ rebox_uniqs = map mkBuiltinUnique [rebox_base..]
- uniq_list = map mkBuiltinUnique [unpack_base..]
+ -- data T :: *->* where T1 { fld :: Maybe b } -> T [b]
+ -- Hence T1 :: forall a b. (a=[b]) => b -> T a
+ -- fld :: forall b. T [b] -> Maybe b
+ -- fld = /\b.\(t:T[b]). case t of
+ -- T1 b' (c : [b]=[b']) (x:Maybe b')
+ -- -> x `cast` Maybe (sym (right c))
Succeeded refinement = gadtRefine emptyRefinement ex_tvs co_tvs
- (co_fn, _) = refineType refinement (idType the_arg_id)
-
- rhs = perform_co co_fn (Var the_arg_id)
-
- perform_co (ExprCoFn co) expr = Cast expr co
- perform_co id_co expr = ASSERT(isIdCoercion id_co) expr
+ (co_fn, res_ty) = refineType refinement (idType the_arg_id)
+ -- Generate the refinement for b'=b,
+ -- and apply to (Maybe b'), to get (Maybe b)
- -- split the uniq_list into two
- uniqs = uniq_list
- uniqs' = drop n_vars uniqs
+ rhs = case co_fn of
+ ExprCoFn co -> Cast (Var the_arg_id) co
+ id_co -> ASSERT(isIdCoercion id_co) Var the_arg_id
- the_arg_id = assoc "mkRecordSelId:mk_alt" (field_lbls `zip` arg_ids) field_label
+ field_vs = filter (not . isPredTy . idType) arg_vs
+ the_arg_id = assoc "mkRecordSelId:mk_alt" (field_lbls `zip` field_vs) field_label
field_lbls = dataConFieldLabels data_con
- error_expr = mkRuntimeErrorApp rEC_SEL_ERROR_ID field_tau full_msg
+ error_expr = mkRuntimeErrorApp rEC_SEL_ERROR_ID field_ty full_msg
full_msg = showSDoc (sep [text "No match in record selector", ppr sel_id])
-- unbox a product type...
-- PairInt a b -> body [a,b]
--
-- The Ints passed around are just for creating fresh locals
-unboxProduct :: Int -> CoreExpr -> Type -> (Int -> [Id] -> CoreExpr) -> Type -> CoreExpr
-unboxProduct i arg arg_ty body res_ty
+unboxProduct :: Int -> CoreExpr -> Type -> (Int -> [Id] -> CoreExpr) -> CoreExpr
+unboxProduct i arg arg_ty body
= result
where
- result = mkUnpackCase the_id arg arg_ty con_args boxing_con rhs
- (tycon, tycon_args, boxing_con, tys) = deepSplitProductType "unboxProduct" arg_ty
+ result = mkUnpackCase the_id arg con_args boxing_con rhs
+ (_tycon, _tycon_args, boxing_con, tys) = deepSplitProductType "unboxProduct" arg_ty
([the_id], i') = mkLocals i [arg_ty]
(con_args, i'') = mkLocals i' tys
rhs = body i'' con_args
-mkUnpackCase :: Id -> CoreExpr -> Type -> [Id] -> DataCon -> CoreExpr -> CoreExpr
+mkUnpackCase :: Id -> CoreExpr -> [Id] -> DataCon -> CoreExpr -> CoreExpr
-- (mkUnpackCase x e args Con body)
-- returns
-- case (e `cast` ...) of bndr { Con args -> body }
--
-- the type of the bndr passed in is irrelevent
-mkUnpackCase bndr arg arg_ty unpk_args boxing_con body
+mkUnpackCase bndr arg unpk_args boxing_con body
= Case cast_arg (setIdType bndr bndr_ty) (exprType body) [(DataAlt boxing_con, unpk_args, body)]
where
(cast_arg, bndr_ty) = go (idType bndr) arg
go ty arg
- | res@(tycon, tycon_args, _, _) <- splitProductType "mkUnpackCase" ty
+ | (tycon, tycon_args, _, _) <- splitProductType "mkUnpackCase" ty
, isNewTyCon tycon && not (isRecursiveTyCon tycon)
= go (newTyConInstRhs tycon tycon_args)
(unwrapNewTypeBody tycon tycon_args arg)
[Id]) -- Ids being boxed into product
reboxProduct us ty
= let
- (tycon, tycon_args, pack_con, con_arg_tys) = deepSplitProductType "reboxProduct" ty
+ (_tycon, _tycon_args, _pack_con, con_arg_tys) = deepSplitProductType "reboxProduct" ty
us' = dropList con_arg_tys us
mkProductBox arg_ids ty
= result_expr
where
- (tycon, tycon_args, pack_con, con_arg_tys) = splitProductType "mkProductBox" ty
+ (tycon, tycon_args, pack_con, _con_arg_tys) = splitProductType "mkProductBox" ty
result_expr
| isNewTyCon tycon && not (isRecursiveTyCon tycon)
where
stricts = dataConExStricts con ++ dataConStrictMarks con
- go [] stricts us = ([], [])
+ go [] _stricts _us = ([], [])
-- Type variable case
go (arg:args) stricts us