import {-# SOURCE #-} Match ( matchSimply )
import HsSyn
-import TcHsSyn ( TypecheckedPat )
-import DsHsSyn ( outPatType, collectTypedPatBinders )
+import TcHsSyn ( TypecheckedPat, outPatType, collectTypedPatBinders )
import CoreSyn
import DsMonad
import CoreUtils ( exprType, mkIfThenElse )
import PrelInfo ( iRREFUT_PAT_ERROR_ID )
+import MkId ( rebuildConArgs )
import Id ( idType, Id, mkWildId )
import Literal ( Literal(..), inIntRange, tARGET_MAX_INT )
-import TyCon ( isNewTyCon, tyConDataCons )
-import DataCon ( DataCon, StrictnessMark, maybeMarkedUnboxed,
- dataConStrictMarks, dataConId, splitProductType_maybe
- )
-import Type ( mkFunTy, isUnLiftedType, splitAlgTyConApp,
- Type
- )
+import TyCon ( isNewTyCon, tyConDataCons, isRecursiveTyCon )
+import DataCon ( DataCon, dataConStrictMarks, dataConId )
+import Type ( mkFunTy, isUnLiftedType, Type )
+import TcType ( tcTyConAppTyCon, isIntTy, isFloatTy, isDoubleTy )
import TysPrim ( intPrimTy, charPrimTy, floatPrimTy, doublePrimTy )
import TysWiredIn ( nilDataCon, consDataCon,
tupleCon,
- stringTy,
unitDataConId, unitTy,
charTy, charDataCon,
- intTy, intDataCon, smallIntegerDataCon,
- floatTy, floatDataCon,
- doubleTy, doubleDataCon,
+ intDataCon, smallIntegerDataCon,
+ floatDataCon,
+ doubleDataCon,
stringTy
)
import BasicTypes ( Boxity(..) )
plusIntegerName, timesIntegerName )
import Outputable
import UnicodeUtil ( stringToUtf8 )
+import Util ( isSingleton )
\end{code}
mk_char_lit c = ConPat charDataCon charTy [] [] [LitPat (HsCharPrim c) charPrimTy]
tidyNPat lit lit_ty default_pat
- | lit_ty == intTy = ConPat intDataCon lit_ty [] [] [LitPat (mk_int lit) intPrimTy]
- | lit_ty == floatTy = ConPat floatDataCon lit_ty [] [] [LitPat (mk_float lit) floatPrimTy]
- | lit_ty == doubleTy = ConPat doubleDataCon lit_ty [] [] [LitPat (mk_double lit) doublePrimTy]
+ | isIntTy lit_ty = ConPat intDataCon lit_ty [] [] [LitPat (mk_int lit) intPrimTy]
+ | isFloatTy lit_ty = ConPat floatDataCon lit_ty [] [] [LitPat (mk_float lit) floatPrimTy]
+ | isDoubleTy lit_ty = ConPat doubleDataCon lit_ty [] [] [LitPat (mk_double lit) doublePrimTy]
| otherwise = default_pat
where
where
mk_case fail
= mapDs (mk_alt fail) match_alts `thenDs` \ alts ->
- returnDs (Case (Var var) var (alts ++ [(DEFAULT, [], fail)]))
+ returnDs (Case (Var var) var ((DEFAULT, [], fail) : alts))
mk_alt fail (lit, MatchResult _ body_fn) = body_fn fail `thenDs` \ body ->
returnDs (LitAlt lit, [], body)
mkCoAlgCaseMatchResult var match_alts
| isNewTyCon tycon -- Newtype case; use a let
- = ASSERT( newtype_sanity )
- mkCoLetsMatchResult [coercion_bind] match_result
+ = ASSERT( null (tail match_alts) && null (tail arg_ids) )
+ mkCoLetsMatchResult [NonRec arg_id newtype_rhs] match_result
| otherwise -- Datatype case; use a case
= MatchResult fail_flag mk_case
where
-- Common stuff
scrut_ty = idType var
- (tycon, _, _) = splitAlgTyConApp scrut_ty
+ tycon = tcTyConAppTyCon scrut_ty -- Newtypes must be opaque here
-- Stuff for newtype
(_, arg_ids, match_result) = head match_alts
- arg_id = head arg_ids
- coercion_bind = NonRec arg_id (Note (Coerce (idType arg_id)
- scrut_ty)
- (Var var))
- newtype_sanity = null (tail match_alts) && null (tail arg_ids)
+ arg_id = head arg_ids
+ newtype_rhs | isRecursiveTyCon tycon -- Recursive case; need a case
+ = Note (Coerce (idType arg_id) scrut_ty) (Var var)
+ | otherwise -- Normal case (newtype is transparent)
+ = Var var
+
-- Stuff for data types
data_cons = tyConDataCons tycon
wild_var = mkWildId (idType var)
mk_case fail = mapDs (mk_alt fail) match_alts `thenDs` \ alts ->
- returnDs (Case (Var var) wild_var (alts ++ mk_default fail))
+ returnDs (Case (Var var) wild_var (mk_default fail ++ alts))
mk_alt fail (con, args, MatchResult _ body_fn)
- = body_fn fail `thenDs` \ body ->
- rebuildConArgs con args (dataConStrictMarks con) body
- `thenDs` \ (body', real_args) ->
- returnDs (DataAlt con, real_args, body')
+ = body_fn fail `thenDs` \ body ->
+ getUniquesDs `thenDs` \ us ->
+ let
+ (binds, real_args) = rebuildConArgs args (dataConStrictMarks con) us
+ in
+ returnDs (DataAlt con, real_args, mkDsLets binds body)
mk_default fail | exhaustive_case = []
| otherwise = [(DEFAULT, [], fail)]
= mkUniqSet data_cons `minusUniqSet` mkUniqSet [ con | (con, _, _) <- match_alts]
exhaustive_case = isEmptyUniqSet un_mentioned_constructors
\end{code}
-%
-For each constructor we match on, we might need to re-pack some
-of the strict fields if they are unpacked in the constructor.
-%
-\begin{code}
-rebuildConArgs
- :: DataCon -- the con we're matching on
- -> [Id] -- the source-level args
- -> [StrictnessMark] -- the strictness annotations (per-arg)
- -> CoreExpr -- the body
- -> DsM (CoreExpr, [Id])
-
-rebuildConArgs con [] stricts body = returnDs (body, [])
-rebuildConArgs con (arg:args) stricts body | isTyVar arg
- = rebuildConArgs con args stricts body `thenDs` \ (body', args') ->
- returnDs (body',arg:args')
-rebuildConArgs con (arg:args) (str:stricts) body
- = rebuildConArgs con args stricts body `thenDs` \ (body', real_args) ->
- case maybeMarkedUnboxed str of
- Just (pack_con1, _) ->
- case splitProductType_maybe (idType arg) of
- Just (_, tycon_args, pack_con, con_arg_tys) ->
- ASSERT( pack_con == pack_con1 )
- newSysLocalsDs con_arg_tys `thenDs` \ unpacked_args ->
- returnDs (
- mkDsLet (NonRec arg (mkConApp pack_con
- (map Type tycon_args ++
- map Var unpacked_args))) body',
- unpacked_args ++ real_args
- )
-
- _ -> returnDs (body', arg:real_args)
-\end{code}
+
%************************************************************************
%* *
= returnDs [(v, val_expr)]
mkSelectorBinds pat val_expr
- | length binders == 1 || is_simple_pat pat
+ | isSingleton binders || is_simple_pat pat
= newSysLocalDs (exprType val_expr) `thenDs` \ val_var ->
-- For the error message we don't use mkErrorAppDs to avoid
| otherwise
- = mkErrorAppDs iRREFUT_PAT_ERROR_ID tuple_ty (showSDoc (ppr pat))
- `thenDs` \ error_expr ->
- matchSimply val_expr LetMatch pat local_tuple error_expr
- `thenDs` \ tuple_expr ->
- newSysLocalDs tuple_ty
- `thenDs` \ tuple_var ->
+ = mkErrorAppDs iRREFUT_PAT_ERROR_ID
+ tuple_ty (showSDoc (ppr pat)) `thenDs` \ error_expr ->
+ matchSimply val_expr PatBindRhs pat local_tuple error_expr `thenDs` \ tuple_expr ->
+ newSysLocalDs tuple_ty `thenDs` \ tuple_var ->
let
- mk_tup_bind binder =
- (binder, mkTupleSelector binders binder tuple_var (Var tuple_var))
+ mk_tup_bind binder
+ = (binder, mkTupleSelector binders binder tuple_var (Var tuple_var))
in
returnDs ( (tuple_var, tuple_expr) : map mk_tup_bind binders )
where
-- (mk_bind sv bv) generates
-- bv = case sv of { pat -> bv; other -> error-msg }
-- Remember, pat binds bv
- = matchSimply (Var scrut_var) LetMatch pat
+ = matchSimply (Var scrut_var) PatBindRhs pat
(Var bndr_var) error_expr `thenDs` \ rhs_expr ->
returnDs (bndr_var, rhs_expr)
where
\end{code}
-
projects / ghc-hetmet.git / blobdiff