{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE TypeFamilies #-}
module GHC.HsToCore.Utils (
EquationInfo(..),
firstPat, shiftEqns,
MatchResult (..), CaseAlt(..),
cantFailMatchResult, alwaysFailMatchResult,
extractMatchResult, combineMatchResults,
adjustMatchResultDs,
shareFailureHandler,
dsHandleMonadicFailure,
mkCoLetMatchResult, mkViewMatchResult, mkGuardedMatchResult,
matchCanFail, mkEvalMatchResult,
mkCoPrimCaseMatchResult, mkCoAlgCaseMatchResult, mkCoSynCaseMatchResult,
wrapBind, wrapBinds,
mkErrorAppDs, mkCoreAppDs, mkCoreAppsDs, mkCastDs,
mkFailExpr,
seqVar,
mkLHsPatTup, mkVanillaTuplePat,
mkBigLHsVarTupId, mkBigLHsTupId, mkBigLHsVarPatTupId, mkBigLHsPatTupId,
mkSelectorBinds,
selectSimpleMatchVarL, selectMatchVars, selectMatchVar,
mkOptTickBox, mkBinaryTickBox, decideBangHood,
isTrueLHsExpr
) where
#include "HsVersions.h"
import GHC.Prelude
import {-# SOURCE #-} GHC.HsToCore.Match ( matchSimply )
import {-# SOURCE #-} GHC.HsToCore.Expr ( dsLExpr, dsSyntaxExpr )
import GHC.Hs
import GHC.Tc.Utils.Zonk
import GHC.Tc.Utils.TcType( tcSplitTyConApp )
import GHC.Core
import GHC.HsToCore.Monad
import GHC.Core.Utils
import GHC.Core.Make
import GHC.Types.Id.Make
import GHC.Types.Id
import GHC.Types.Literal
import GHC.Core.TyCon
import GHC.Core.DataCon
import GHC.Core.PatSyn
import GHC.Core.Type
import GHC.Core.Coercion
import GHC.Builtin.Types
import GHC.Types.Basic
import GHC.Core.ConLike
import GHC.Types.Unique.Set
import GHC.Types.Unique.Supply
import GHC.Unit.Module
import GHC.Builtin.Names
import GHC.Types.Name( isInternalName )
import GHC.Utils.Outputable
import GHC.Utils.Panic
import GHC.Types.SrcLoc
import GHC.Types.Tickish
import GHC.Utils.Misc
import GHC.Driver.Session
import GHC.Driver.Ppr
import GHC.Data.FastString
import qualified GHC.LanguageExtensions as LangExt
import GHC.Tc.Types.Evidence
import Control.Monad ( zipWithM )
import Data.List.NonEmpty (NonEmpty(..))
import Data.Maybe (maybeToList)
import qualified Data.List.NonEmpty as NEL
selectSimpleMatchVarL :: Mult -> LPat GhcTc -> DsM Id
selectSimpleMatchVarL :: Mult -> XRec GhcTc (Pat GhcTc) -> DsM Var
selectSimpleMatchVarL Mult
w XRec GhcTc (Pat GhcTc)
pat = Mult -> Pat GhcTc -> DsM Var
selectMatchVar Mult
w (forall l e. GenLocated l e -> e
unLoc XRec GhcTc (Pat GhcTc)
pat)
selectMatchVars :: [(Mult, Pat GhcTc)] -> DsM [Id]
selectMatchVars :: [(Mult, Pat GhcTc)] -> DsM [Var]
selectMatchVars [(Mult, Pat GhcTc)]
ps = forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Mult -> Pat GhcTc -> DsM Var
selectMatchVar) [(Mult, Pat GhcTc)]
ps
selectMatchVar :: Mult -> Pat GhcTc -> DsM Id
selectMatchVar :: Mult -> Pat GhcTc -> DsM Var
selectMatchVar Mult
w (BangPat XBangPat GhcTc
_ XRec GhcTc (Pat GhcTc)
pat) = Mult -> Pat GhcTc -> DsM Var
selectMatchVar Mult
w (forall l e. GenLocated l e -> e
unLoc XRec GhcTc (Pat GhcTc)
pat)
selectMatchVar Mult
w (LazyPat XLazyPat GhcTc
_ XRec GhcTc (Pat GhcTc)
pat) = Mult -> Pat GhcTc -> DsM Var
selectMatchVar Mult
w (forall l e. GenLocated l e -> e
unLoc XRec GhcTc (Pat GhcTc)
pat)
selectMatchVar Mult
w (ParPat XParPat GhcTc
_ XRec GhcTc (Pat GhcTc)
pat) = Mult -> Pat GhcTc -> DsM Var
selectMatchVar Mult
w (forall l e. GenLocated l e -> e
unLoc XRec GhcTc (Pat GhcTc)
pat)
selectMatchVar Mult
_w (VarPat XVarPat GhcTc
_ LIdP GhcTc
var) = forall (m :: * -> *) a. Monad m => a -> m a
return (Var -> Var
localiseId (forall l e. GenLocated l e -> e
unLoc LIdP GhcTc
var))
selectMatchVar Mult
_w (AsPat XAsPat GhcTc
_ LIdP GhcTc
var XRec GhcTc (Pat GhcTc)
_) = ASSERT( isManyDataConTy _w ) (return (unLoc var))
selectMatchVar Mult
w Pat GhcTc
other_pat = Mult -> Mult -> DsM Var
newSysLocalDsNoLP Mult
w (Pat GhcTc -> Mult
hsPatType Pat GhcTc
other_pat)
firstPat :: EquationInfo -> Pat GhcTc
firstPat :: EquationInfo -> Pat GhcTc
firstPat EquationInfo
eqn = ASSERT( notNull (eqn_pats eqn) ) head (eqn_pats eqn)
shiftEqns :: Functor f => f EquationInfo -> f EquationInfo
shiftEqns :: forall (f :: * -> *). Functor f => f EquationInfo -> f EquationInfo
shiftEqns = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a -> b) -> a -> b
$ \EquationInfo
eqn -> EquationInfo
eqn { eqn_pats :: [Pat GhcTc]
eqn_pats = forall a. [a] -> [a]
tail (EquationInfo -> [Pat GhcTc]
eqn_pats EquationInfo
eqn) }
matchCanFail :: MatchResult a -> Bool
matchCanFail :: forall a. MatchResult a -> Bool
matchCanFail (MR_Fallible {}) = Bool
True
matchCanFail (MR_Infallible {}) = Bool
False
alwaysFailMatchResult :: MatchResult CoreExpr
alwaysFailMatchResult :: MatchResult CoreExpr
alwaysFailMatchResult = forall a. (CoreExpr -> DsM a) -> MatchResult a
MR_Fallible forall a b. (a -> b) -> a -> b
$ \CoreExpr
fail -> forall (m :: * -> *) a. Monad m => a -> m a
return CoreExpr
fail
cantFailMatchResult :: CoreExpr -> MatchResult CoreExpr
cantFailMatchResult :: CoreExpr -> MatchResult CoreExpr
cantFailMatchResult CoreExpr
expr = forall a. DsM a -> MatchResult a
MR_Infallible forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return CoreExpr
expr
extractMatchResult :: MatchResult CoreExpr -> CoreExpr -> DsM CoreExpr
MatchResult CoreExpr
match_result CoreExpr
failure_expr =
forall a. CoreExpr -> MatchResult a -> DsM a
runMatchResult
CoreExpr
failure_expr
(MatchResult CoreExpr -> MatchResult CoreExpr
shareFailureHandler MatchResult CoreExpr
match_result)
combineMatchResults :: MatchResult CoreExpr -> MatchResult CoreExpr -> MatchResult CoreExpr
combineMatchResults :: MatchResult CoreExpr
-> MatchResult CoreExpr -> MatchResult CoreExpr
combineMatchResults match_result1 :: MatchResult CoreExpr
match_result1@(MR_Infallible DsM CoreExpr
_) MatchResult CoreExpr
_
= MatchResult CoreExpr
match_result1
combineMatchResults MatchResult CoreExpr
match_result1 MatchResult CoreExpr
match_result2 =
case MatchResult CoreExpr -> MatchResult CoreExpr
shareFailureHandler MatchResult CoreExpr
match_result1 of
MR_Infallible DsM CoreExpr
_ -> MatchResult CoreExpr
match_result1
MR_Fallible CoreExpr -> DsM CoreExpr
body_fn1 -> forall a. (CoreExpr -> DsM a) -> MatchResult a
MR_Fallible forall a b. (a -> b) -> a -> b
$ \CoreExpr
fail_expr ->
CoreExpr -> DsM CoreExpr
body_fn1 forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a. CoreExpr -> MatchResult a -> DsM a
runMatchResult CoreExpr
fail_expr MatchResult CoreExpr
match_result2
adjustMatchResultDs :: (a -> DsM b) -> MatchResult a -> MatchResult b
adjustMatchResultDs :: forall a b. (a -> DsM b) -> MatchResult a -> MatchResult b
adjustMatchResultDs a -> DsM b
encl_fn = \case
MR_Infallible DsM a
body_fn -> forall a. DsM a -> MatchResult a
MR_Infallible forall a b. (a -> b) -> a -> b
$
a -> DsM b
encl_fn forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< DsM a
body_fn
MR_Fallible CoreExpr -> DsM a
body_fn -> forall a. (CoreExpr -> DsM a) -> MatchResult a
MR_Fallible forall a b. (a -> b) -> a -> b
$ \CoreExpr
fail ->
a -> DsM b
encl_fn forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< CoreExpr -> DsM a
body_fn CoreExpr
fail
wrapBinds :: [(Var,Var)] -> CoreExpr -> CoreExpr
wrapBinds :: [(Var, Var)] -> CoreExpr -> CoreExpr
wrapBinds [] CoreExpr
e = CoreExpr
e
wrapBinds ((Var
new,Var
old):[(Var, Var)]
prs) CoreExpr
e = Var -> Var -> CoreExpr -> CoreExpr
wrapBind Var
new Var
old ([(Var, Var)] -> CoreExpr -> CoreExpr
wrapBinds [(Var, Var)]
prs CoreExpr
e)
wrapBind :: Var -> Var -> CoreExpr -> CoreExpr
wrapBind :: Var -> Var -> CoreExpr -> CoreExpr
wrapBind Var
new Var
old CoreExpr
body
| Var
newforall a. Eq a => a -> a -> Bool
==Var
old = CoreExpr
body
| Bool
otherwise = forall b. Bind b -> Expr b -> Expr b
Let (forall b. b -> Expr b -> Bind b
NonRec Var
new (forall b. Var -> Expr b
varToCoreExpr Var
old)) CoreExpr
body
seqVar :: Var -> CoreExpr -> CoreExpr
seqVar :: Var -> CoreExpr -> CoreExpr
seqVar Var
var CoreExpr
body = CoreExpr -> Var -> CoreExpr -> CoreExpr
mkDefaultCase (forall b. Var -> Expr b
Var Var
var) Var
var CoreExpr
body
mkCoLetMatchResult :: CoreBind -> MatchResult CoreExpr -> MatchResult CoreExpr
mkCoLetMatchResult :: CoreBind -> MatchResult CoreExpr -> MatchResult CoreExpr
mkCoLetMatchResult CoreBind
bind = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (CoreBind -> CoreExpr -> CoreExpr
mkCoreLet CoreBind
bind)
mkViewMatchResult :: Id -> CoreExpr -> MatchResult CoreExpr -> MatchResult CoreExpr
mkViewMatchResult :: Var -> CoreExpr -> MatchResult CoreExpr -> MatchResult CoreExpr
mkViewMatchResult Var
var' CoreExpr
viewExpr = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a -> b) -> a -> b
$ CoreBind -> CoreExpr -> CoreExpr
mkCoreLet forall a b. (a -> b) -> a -> b
$ forall b. b -> Expr b -> Bind b
NonRec Var
var' CoreExpr
viewExpr
mkEvalMatchResult :: Id -> Type -> MatchResult CoreExpr -> MatchResult CoreExpr
mkEvalMatchResult :: Var -> Mult -> MatchResult CoreExpr -> MatchResult CoreExpr
mkEvalMatchResult Var
var Mult
ty = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a -> b) -> a -> b
$ \CoreExpr
e ->
forall b. Expr b -> b -> Mult -> [Alt b] -> Expr b
Case (forall b. Var -> Expr b
Var Var
var) Var
var Mult
ty [forall b. AltCon -> [b] -> Expr b -> Alt b
Alt AltCon
DEFAULT [] CoreExpr
e]
mkGuardedMatchResult :: CoreExpr -> MatchResult CoreExpr -> MatchResult CoreExpr
mkGuardedMatchResult :: CoreExpr -> MatchResult CoreExpr -> MatchResult CoreExpr
mkGuardedMatchResult CoreExpr
pred_expr MatchResult CoreExpr
mr = forall a. (CoreExpr -> DsM a) -> MatchResult a
MR_Fallible forall a b. (a -> b) -> a -> b
$ \CoreExpr
fail -> do
CoreExpr
body <- forall a. CoreExpr -> MatchResult a -> DsM a
runMatchResult CoreExpr
fail MatchResult CoreExpr
mr
forall (m :: * -> *) a. Monad m => a -> m a
return (CoreExpr -> CoreExpr -> CoreExpr -> CoreExpr
mkIfThenElse CoreExpr
pred_expr CoreExpr
body CoreExpr
fail)
mkCoPrimCaseMatchResult :: Id
-> Type
-> [(Literal, MatchResult CoreExpr)]
-> MatchResult CoreExpr
mkCoPrimCaseMatchResult :: Var
-> Mult
-> [(Literal, MatchResult CoreExpr)]
-> MatchResult CoreExpr
mkCoPrimCaseMatchResult Var
var Mult
ty [(Literal, MatchResult CoreExpr)]
match_alts
= forall a. (CoreExpr -> DsM a) -> MatchResult a
MR_Fallible CoreExpr -> DsM CoreExpr
mk_case
where
mk_case :: CoreExpr -> DsM CoreExpr
mk_case CoreExpr
fail = do
[Alt Var]
alts <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall {b}.
CoreExpr
-> (Literal, MatchResult (Expr b))
-> IOEnv (Env DsGblEnv DsLclEnv) (Alt b)
mk_alt CoreExpr
fail) [(Literal, MatchResult CoreExpr)]
sorted_alts
forall (m :: * -> *) a. Monad m => a -> m a
return (forall b. Expr b -> b -> Mult -> [Alt b] -> Expr b
Case (forall b. Var -> Expr b
Var Var
var) Var
var Mult
ty (forall b. AltCon -> [b] -> Expr b -> Alt b
Alt AltCon
DEFAULT [] CoreExpr
fail forall a. a -> [a] -> [a]
: [Alt Var]
alts))
sorted_alts :: [(Literal, MatchResult CoreExpr)]
sorted_alts = forall b a. Ord b => (a -> b) -> [a] -> [a]
sortWith forall a b. (a, b) -> a
fst [(Literal, MatchResult CoreExpr)]
match_alts
mk_alt :: CoreExpr
-> (Literal, MatchResult (Expr b))
-> IOEnv (Env DsGblEnv DsLclEnv) (Alt b)
mk_alt CoreExpr
fail (Literal
lit, MatchResult (Expr b)
mr)
= ASSERT( not (litIsLifted lit) )
do Expr b
body <- forall a. CoreExpr -> MatchResult a -> DsM a
runMatchResult CoreExpr
fail MatchResult (Expr b)
mr
forall (m :: * -> *) a. Monad m => a -> m a
return (forall b. AltCon -> [b] -> Expr b -> Alt b
Alt (Literal -> AltCon
LitAlt Literal
lit) [] Expr b
body)
data CaseAlt a = MkCaseAlt{ forall a. CaseAlt a -> a
alt_pat :: a,
forall a. CaseAlt a -> [Var]
alt_bndrs :: [Var],
forall a. CaseAlt a -> HsWrapper
alt_wrapper :: HsWrapper,
forall a. CaseAlt a -> MatchResult CoreExpr
alt_result :: MatchResult CoreExpr }
mkCoAlgCaseMatchResult
:: Id
-> Type
-> NonEmpty (CaseAlt DataCon)
-> MatchResult CoreExpr
mkCoAlgCaseMatchResult :: Var -> Mult -> NonEmpty (CaseAlt DataCon) -> MatchResult CoreExpr
mkCoAlgCaseMatchResult Var
var Mult
ty NonEmpty (CaseAlt DataCon)
match_alts
| Bool
isNewtype
= ASSERT( null match_alts_tail && null (tail arg_ids1) )
CoreBind -> MatchResult CoreExpr -> MatchResult CoreExpr
mkCoLetMatchResult (forall b. b -> Expr b -> Bind b
NonRec Var
arg_id1 CoreExpr
newtype_rhs) MatchResult CoreExpr
match_result1
| Bool
otherwise
= Var -> Mult -> NonEmpty (CaseAlt DataCon) -> MatchResult CoreExpr
mkDataConCase Var
var Mult
ty NonEmpty (CaseAlt DataCon)
match_alts
where
isNewtype :: Bool
isNewtype = TyCon -> Bool
isNewTyCon (DataCon -> TyCon
dataConTyCon (forall a. CaseAlt a -> a
alt_pat CaseAlt DataCon
alt1))
alt1 :: CaseAlt DataCon
alt1@MkCaseAlt{ alt_bndrs :: forall a. CaseAlt a -> [Var]
alt_bndrs = [Var]
arg_ids1, alt_result :: forall a. CaseAlt a -> MatchResult CoreExpr
alt_result = MatchResult CoreExpr
match_result1 } :| [CaseAlt DataCon]
match_alts_tail
= NonEmpty (CaseAlt DataCon)
match_alts
arg_id1 :: Var
arg_id1 = ASSERT( notNull arg_ids1 ) head arg_ids1
var_ty :: Mult
var_ty = Var -> Mult
idType Var
var
(TyCon
tc, [Mult]
ty_args) = Mult -> (TyCon, [Mult])
tcSplitTyConApp Mult
var_ty
newtype_rhs :: CoreExpr
newtype_rhs = TyCon -> [Mult] -> CoreExpr -> CoreExpr
unwrapNewTypeBody TyCon
tc [Mult]
ty_args (forall b. Var -> Expr b
Var Var
var)
mkCoSynCaseMatchResult :: Id -> Type -> CaseAlt PatSyn -> MatchResult CoreExpr
mkCoSynCaseMatchResult :: Var -> Mult -> CaseAlt PatSyn -> MatchResult CoreExpr
mkCoSynCaseMatchResult Var
var Mult
ty CaseAlt PatSyn
alt = forall a. (CoreExpr -> DsM a) -> MatchResult a
MR_Fallible forall a b. (a -> b) -> a -> b
$ Var -> Mult -> CaseAlt PatSyn -> CoreExpr -> DsM CoreExpr
mkPatSynCase Var
var Mult
ty CaseAlt PatSyn
alt
mkPatSynCase :: Id -> Type -> CaseAlt PatSyn -> CoreExpr -> DsM CoreExpr
mkPatSynCase :: Var -> Mult -> CaseAlt PatSyn -> CoreExpr -> DsM CoreExpr
mkPatSynCase Var
var Mult
ty CaseAlt PatSyn
alt CoreExpr
fail = do
Var
matcher_id <- Name -> DsM Var
dsLookupGlobalId Name
matcher_name
CoreExpr
matcher <- LHsExpr GhcTc -> DsM CoreExpr
dsLExpr forall a b. (a -> b) -> a -> b
$ HsWrapper -> LHsExpr GhcTc -> LHsExpr GhcTc
mkLHsWrap HsWrapper
wrapper forall a b. (a -> b) -> a -> b
$
Var -> [Mult] -> LHsExpr GhcTc
nlHsTyApp Var
matcher_id [HasDebugCallStack => Mult -> Mult
getRuntimeRep Mult
ty, Mult
ty]
CoreExpr
cont <- [Var] -> CoreExpr -> CoreExpr
mkCoreLams [Var]
bndrs forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. CoreExpr -> MatchResult a -> DsM a
runMatchResult CoreExpr
fail MatchResult CoreExpr
match_result
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ SDoc -> CoreExpr -> [CoreExpr] -> CoreExpr
mkCoreAppsDs (String -> SDoc
text String
"patsyn" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr Var
var) CoreExpr
matcher [forall b. Var -> Expr b
Var Var
var, CoreExpr -> CoreExpr
ensure_unstrict CoreExpr
cont, forall b. b -> Expr b -> Expr b
Lam Var
voidArgId CoreExpr
fail]
where
MkCaseAlt{ alt_pat :: forall a. CaseAlt a -> a
alt_pat = PatSyn
psyn,
alt_bndrs :: forall a. CaseAlt a -> [Var]
alt_bndrs = [Var]
bndrs,
alt_wrapper :: forall a. CaseAlt a -> HsWrapper
alt_wrapper = HsWrapper
wrapper,
alt_result :: forall a. CaseAlt a -> MatchResult CoreExpr
alt_result = MatchResult CoreExpr
match_result} = CaseAlt PatSyn
alt
(Name
matcher_name, Mult
_, Bool
needs_void_lam) = PatSyn -> (Name, Mult, Bool)
patSynMatcher PatSyn
psyn
ensure_unstrict :: CoreExpr -> CoreExpr
ensure_unstrict CoreExpr
cont | Bool
needs_void_lam = forall b. b -> Expr b -> Expr b
Lam Var
voidArgId CoreExpr
cont
| Bool
otherwise = CoreExpr
cont
mkDataConCase :: Id -> Type -> NonEmpty (CaseAlt DataCon) -> MatchResult CoreExpr
mkDataConCase :: Var -> Mult -> NonEmpty (CaseAlt DataCon) -> MatchResult CoreExpr
mkDataConCase Var
var Mult
ty alts :: NonEmpty (CaseAlt DataCon)
alts@(CaseAlt DataCon
alt1 :| [CaseAlt DataCon]
_)
= forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 Maybe (Alt Var) -> [Alt Var] -> CoreExpr
mk_case MatchResult (Maybe (Alt Var))
mk_default MatchResult [Alt Var]
mk_alts
where
con1 :: DataCon
con1 = forall a. CaseAlt a -> a
alt_pat CaseAlt DataCon
alt1
tycon :: TyCon
tycon = DataCon -> TyCon
dataConTyCon DataCon
con1
data_cons :: [DataCon]
data_cons = TyCon -> [DataCon]
tyConDataCons TyCon
tycon
sorted_alts :: [ CaseAlt DataCon ]
sorted_alts :: [CaseAlt DataCon]
sorted_alts = forall b a. Ord b => (a -> b) -> [a] -> [a]
sortWith (DataCon -> ConTag
dataConTag forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. CaseAlt a -> a
alt_pat) forall a b. (a -> b) -> a -> b
$ forall a. NonEmpty a -> [a]
NEL.toList NonEmpty (CaseAlt DataCon)
alts
var_ty :: Mult
var_ty = Var -> Mult
idType Var
var
(TyCon
_, [Mult]
ty_args) = Mult -> (TyCon, [Mult])
tcSplitTyConApp Mult
var_ty
mk_case :: Maybe CoreAlt -> [CoreAlt] -> CoreExpr
mk_case :: Maybe (Alt Var) -> [Alt Var] -> CoreExpr
mk_case Maybe (Alt Var)
def [Alt Var]
alts = CoreExpr -> Scaled Mult -> Mult -> [Alt Var] -> CoreExpr
mkWildCase (forall b. Var -> Expr b
Var Var
var) (Var -> Scaled Mult
idScaledType Var
var) Mult
ty forall a b. (a -> b) -> a -> b
$
forall a. Maybe a -> [a]
maybeToList Maybe (Alt Var)
def forall a. [a] -> [a] -> [a]
++ [Alt Var]
alts
mk_alts :: MatchResult [CoreAlt]
mk_alts :: MatchResult [Alt Var]
mk_alts = forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse CaseAlt DataCon -> MatchResult (Alt Var)
mk_alt [CaseAlt DataCon]
sorted_alts
mk_alt :: CaseAlt DataCon -> MatchResult CoreAlt
mk_alt :: CaseAlt DataCon -> MatchResult (Alt Var)
mk_alt MkCaseAlt { alt_pat :: forall a. CaseAlt a -> a
alt_pat = DataCon
con
, alt_bndrs :: forall a. CaseAlt a -> [Var]
alt_bndrs = [Var]
args
, alt_result :: forall a. CaseAlt a -> MatchResult CoreExpr
alt_result = MatchResult CoreExpr
match_result } =
forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a b. (a -> DsM b) -> MatchResult a -> MatchResult b
adjustMatchResultDs MatchResult CoreExpr
match_result forall a b. (a -> b) -> a -> b
$ \CoreExpr
body -> do
case DataCon -> Maybe DataConBoxer
dataConBoxer DataCon
con of
Maybe DataConBoxer
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall b. AltCon -> [b] -> Expr b -> Alt b
Alt (DataCon -> AltCon
DataAlt DataCon
con) [Var]
args CoreExpr
body)
Just (DCB [Mult] -> [Var] -> UniqSM ([Var], [CoreBind])
boxer) -> do
UniqSupply
us <- forall gbl lcl. TcRnIf gbl lcl UniqSupply
newUniqueSupply
let ([Var]
rep_ids, [CoreBind]
binds) = forall a. UniqSupply -> UniqSM a -> a
initUs_ UniqSupply
us ([Mult] -> [Var] -> UniqSM ([Var], [CoreBind])
boxer [Mult]
ty_args [Var]
args)
let rep_ids' :: [Var]
rep_ids' = forall a b. (a -> b) -> [a] -> [b]
map (Mult -> Var -> Var
scaleVarBy (Var -> Mult
idMult Var
var)) [Var]
rep_ids
forall (m :: * -> *) a. Monad m => a -> m a
return (forall b. AltCon -> [b] -> Expr b -> Alt b
Alt (DataCon -> AltCon
DataAlt DataCon
con) [Var]
rep_ids' (forall b. [Bind b] -> Expr b -> Expr b
mkLets [CoreBind]
binds CoreExpr
body))
mk_default :: MatchResult (Maybe CoreAlt)
mk_default :: MatchResult (Maybe (Alt Var))
mk_default
| Bool
exhaustive_case = forall a. DsM a -> MatchResult a
MR_Infallible forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
| Bool
otherwise = forall a. (CoreExpr -> DsM a) -> MatchResult a
MR_Fallible forall a b. (a -> b) -> a -> b
$ \CoreExpr
fail -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just (forall b. AltCon -> [b] -> Expr b -> Alt b
Alt AltCon
DEFAULT [] CoreExpr
fail)
mentioned_constructors :: UniqSet DataCon
mentioned_constructors = forall a. Uniquable a => [a] -> UniqSet a
mkUniqSet forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map forall a. CaseAlt a -> a
alt_pat [CaseAlt DataCon]
sorted_alts
un_mentioned_constructors :: UniqSet DataCon
un_mentioned_constructors
= forall a. Uniquable a => [a] -> UniqSet a
mkUniqSet [DataCon]
data_cons forall a. UniqSet a -> UniqSet a -> UniqSet a
`minusUniqSet` UniqSet DataCon
mentioned_constructors
exhaustive_case :: Bool
exhaustive_case = forall a. UniqSet a -> Bool
isEmptyUniqSet UniqSet DataCon
un_mentioned_constructors
mkErrorAppDs :: Id
-> Type
-> SDoc
-> DsM CoreExpr
mkErrorAppDs :: Var -> Mult -> SDoc -> DsM CoreExpr
mkErrorAppDs Var
err_id Mult
ty SDoc
msg = do
SrcSpan
src_loc <- DsM SrcSpan
getSrcSpanDs
DynFlags
dflags <- forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags
let
full_msg :: String
full_msg = DynFlags -> SDoc -> String
showSDoc DynFlags
dflags ([SDoc] -> SDoc
hcat [forall a. Outputable a => a -> SDoc
ppr SrcSpan
src_loc, SDoc
vbar, SDoc
msg])
core_msg :: CoreExpr
core_msg = forall b. Literal -> Expr b
Lit (String -> Literal
mkLitString String
full_msg)
forall (m :: * -> *) a. Monad m => a -> m a
return (forall b. Expr b -> [Expr b] -> Expr b
mkApps (forall b. Var -> Expr b
Var Var
err_id) [forall b. Mult -> Expr b
Type (HasDebugCallStack => Mult -> Mult
getRuntimeRep Mult
ty), forall b. Mult -> Expr b
Type Mult
ty, CoreExpr
core_msg])
mkFailExpr :: HsMatchContext GhcRn -> Type -> DsM CoreExpr
mkFailExpr :: HsMatchContext GhcRn -> Mult -> DsM CoreExpr
mkFailExpr HsMatchContext GhcRn
ctxt Mult
ty
= do CoreExpr
fail_expr <- Var -> Mult -> SDoc -> DsM CoreExpr
mkErrorAppDs Var
pAT_ERROR_ID Mult
unitTy (forall (p :: Pass).
OutputableBndrId p =>
HsMatchContext (GhcPass p) -> SDoc
matchContextErrString HsMatchContext GhcRn
ctxt)
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ CoreExpr -> Scaled Mult -> Mult -> [Alt Var] -> CoreExpr
mkWildCase CoreExpr
fail_expr (forall a. a -> Scaled a
unrestricted Mult
unitTy) Mult
ty []
mkCoreAppDs :: SDoc -> CoreExpr -> CoreExpr -> CoreExpr
mkCoreAppDs :: SDoc -> CoreExpr -> CoreExpr -> CoreExpr
mkCoreAppDs SDoc
_ (Var Var
f `App` Type Mult
_r `App` Type Mult
ty1 `App` Type Mult
ty2 `App` CoreExpr
arg1) CoreExpr
arg2
| Var
f forall a. Uniquable a => a -> Unique -> Bool
`hasKey` Unique
seqIdKey
= forall b. Expr b -> b -> Mult -> [Alt b] -> Expr b
Case CoreExpr
arg1 Var
case_bndr Mult
ty2 [forall b. AltCon -> [b] -> Expr b -> Alt b
Alt AltCon
DEFAULT [] CoreExpr
arg2]
where
case_bndr :: Var
case_bndr = case CoreExpr
arg1 of
Var Var
v1 | Name -> Bool
isInternalName (Var -> Name
idName Var
v1)
-> Var
v1
CoreExpr
_ -> Mult -> Mult -> Var
mkWildValBinder Mult
Many Mult
ty1
mkCoreAppDs SDoc
_ (Var Var
f `App` Type Mult
_r) CoreExpr
arg
| Var
f forall a. Uniquable a => a -> Unique -> Bool
`hasKey` Unique
noinlineIdKey
, (CoreExpr
fun, [CoreExpr]
args) <- forall b. Expr b -> (Expr b, [Expr b])
collectArgs CoreExpr
arg
, Bool -> Bool
not (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [CoreExpr]
args)
= (forall b. Var -> Expr b
Var Var
f forall b. Expr b -> Expr b -> Expr b
`App` forall b. Mult -> Expr b
Type (CoreExpr -> Mult
exprType CoreExpr
fun) forall b. Expr b -> Expr b -> Expr b
`App` CoreExpr
fun)
CoreExpr -> [CoreExpr] -> CoreExpr
`mkCoreApps` [CoreExpr]
args
mkCoreAppDs SDoc
s CoreExpr
fun CoreExpr
arg = SDoc -> CoreExpr -> CoreExpr -> CoreExpr
mkCoreApp SDoc
s CoreExpr
fun CoreExpr
arg
mkCoreAppsDs :: SDoc -> CoreExpr -> [CoreExpr] -> CoreExpr
mkCoreAppsDs :: SDoc -> CoreExpr -> [CoreExpr] -> CoreExpr
mkCoreAppsDs SDoc
s CoreExpr
fun [CoreExpr]
args = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (SDoc -> CoreExpr -> CoreExpr -> CoreExpr
mkCoreAppDs SDoc
s) CoreExpr
fun [CoreExpr]
args
mkCastDs :: CoreExpr -> Coercion -> CoreExpr
mkCastDs :: CoreExpr -> Coercion -> CoreExpr
mkCastDs CoreExpr
e Coercion
co | Coercion -> Bool
isReflCo Coercion
co = CoreExpr
e
| Bool
otherwise = forall b. Expr b -> Coercion -> Expr b
Cast CoreExpr
e Coercion
co
mkSelectorBinds :: [[CoreTickish]]
-> LPat GhcTc
-> CoreExpr
-> DsM (Id,[(Id,CoreExpr)])
mkSelectorBinds :: [[CoreTickish]]
-> XRec GhcTc (Pat GhcTc)
-> CoreExpr
-> DsM (Var, [(Var, CoreExpr)])
mkSelectorBinds [[CoreTickish]]
ticks XRec GhcTc (Pat GhcTc)
pat CoreExpr
val_expr
| L SrcSpanAnnA
_ (VarPat XVarPat GhcTc
_ (L SrcSpanAnnN
_ Var
v)) <- XRec GhcTc (Pat GhcTc)
pat'
= forall (m :: * -> *) a. Monad m => a -> m a
return (Var
v, [(Var
v, CoreExpr
val_expr)])
| XRec GhcTc (Pat GhcTc) -> Bool
is_flat_prod_lpat XRec GhcTc (Pat GhcTc)
pat'
= do { let pat_ty :: Mult
pat_ty = XRec GhcTc (Pat GhcTc) -> Mult
hsLPatType XRec GhcTc (Pat GhcTc)
pat'
; Var
val_var <- Mult -> Mult -> DsM Var
newSysLocalDsNoLP Mult
Many Mult
pat_ty
; let mk_bind :: [CoreTickish]
-> Var -> IOEnv (Env DsGblEnv DsLclEnv) (Var, CoreExpr)
mk_bind [CoreTickish]
tick Var
bndr_var
= do { CoreExpr
rhs_expr <- CoreExpr
-> HsMatchContext GhcRn
-> XRec GhcTc (Pat GhcTc)
-> CoreExpr
-> CoreExpr
-> DsM CoreExpr
matchSimply (forall b. Var -> Expr b
Var Var
val_var) forall p. HsMatchContext p
PatBindRhs XRec GhcTc (Pat GhcTc)
pat'
(forall b. Var -> Expr b
Var Var
bndr_var)
(forall b. Var -> Expr b
Var Var
bndr_var)
; forall (m :: * -> *) a. Monad m => a -> m a
return (Var
bndr_var, [CoreTickish] -> CoreExpr -> CoreExpr
mkOptTickBox [CoreTickish]
tick CoreExpr
rhs_expr) }
; [(Var, CoreExpr)]
binds <- forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM [CoreTickish]
-> Var -> IOEnv (Env DsGblEnv DsLclEnv) (Var, CoreExpr)
mk_bind [[CoreTickish]]
ticks' [IdP GhcTc]
binders
; forall (m :: * -> *) a. Monad m => a -> m a
return ( Var
val_var, (Var
val_var, CoreExpr
val_expr) forall a. a -> [a] -> [a]
: [(Var, CoreExpr)]
binds) }
| Bool
otherwise
= do { Var
tuple_var <- Mult -> Mult -> DsM Var
newSysLocalDs Mult
Many Mult
tuple_ty
; CoreExpr
error_expr <- Var -> Mult -> SDoc -> DsM CoreExpr
mkErrorAppDs Var
pAT_ERROR_ID Mult
tuple_ty (forall a. Outputable a => a -> SDoc
ppr XRec GhcTc (Pat GhcTc)
pat')
; CoreExpr
tuple_expr <- CoreExpr
-> HsMatchContext GhcRn
-> XRec GhcTc (Pat GhcTc)
-> CoreExpr
-> CoreExpr
-> DsM CoreExpr
matchSimply CoreExpr
val_expr forall p. HsMatchContext p
PatBindRhs XRec GhcTc (Pat GhcTc)
pat
CoreExpr
local_tuple CoreExpr
error_expr
; let mk_tup_bind :: [CoreTickish] -> Var -> (Var, CoreExpr)
mk_tup_bind [CoreTickish]
tick Var
binder
= (Var
binder, [CoreTickish] -> CoreExpr -> CoreExpr
mkOptTickBox [CoreTickish]
tick forall a b. (a -> b) -> a -> b
$
[Var] -> Var -> Var -> CoreExpr -> CoreExpr
mkTupleSelector1 [Var]
local_binders Var
binder
Var
tuple_var (forall b. Var -> Expr b
Var Var
tuple_var))
tup_binds :: [(Var, CoreExpr)]
tup_binds = forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith [CoreTickish] -> Var -> (Var, CoreExpr)
mk_tup_bind [[CoreTickish]]
ticks' [IdP GhcTc]
binders
; forall (m :: * -> *) a. Monad m => a -> m a
return (Var
tuple_var, (Var
tuple_var, CoreExpr
tuple_expr) forall a. a -> [a] -> [a]
: [(Var, CoreExpr)]
tup_binds) }
where
pat' :: XRec GhcTc (Pat GhcTc)
pat' = forall (p :: Pass). LPat (GhcPass p) -> LPat (GhcPass p)
strip_bangs XRec GhcTc (Pat GhcTc)
pat
binders :: [IdP GhcTc]
binders = forall p. CollectPass p => CollectFlag p -> LPat p -> [IdP p]
collectPatBinders forall p. CollectFlag p
CollNoDictBinders XRec GhcTc (Pat GhcTc)
pat'
ticks' :: [[CoreTickish]]
ticks' = [[CoreTickish]]
ticks forall a. [a] -> [a] -> [a]
++ forall a. a -> [a]
repeat []
local_binders :: [Var]
local_binders = forall a b. (a -> b) -> [a] -> [b]
map Var -> Var
localiseId [IdP GhcTc]
binders
local_tuple :: CoreExpr
local_tuple = [Var] -> CoreExpr
mkBigCoreVarTup1 [IdP GhcTc]
binders
tuple_ty :: Mult
tuple_ty = CoreExpr -> Mult
exprType CoreExpr
local_tuple
strip_bangs :: LPat (GhcPass p) -> LPat (GhcPass p)
strip_bangs :: forall (p :: Pass). LPat (GhcPass p) -> LPat (GhcPass p)
strip_bangs (L SrcSpanAnnA
_ (ParPat XParPat (GhcPass p)
_ LPat (GhcPass p)
p)) = forall (p :: Pass). LPat (GhcPass p) -> LPat (GhcPass p)
strip_bangs LPat (GhcPass p)
p
strip_bangs (L SrcSpanAnnA
_ (BangPat XBangPat (GhcPass p)
_ LPat (GhcPass p)
p)) = forall (p :: Pass). LPat (GhcPass p) -> LPat (GhcPass p)
strip_bangs LPat (GhcPass p)
p
strip_bangs LPat (GhcPass p)
lp = LPat (GhcPass p)
lp
is_flat_prod_lpat :: LPat GhcTc -> Bool
is_flat_prod_lpat :: XRec GhcTc (Pat GhcTc) -> Bool
is_flat_prod_lpat = Pat GhcTc -> Bool
is_flat_prod_pat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall l e. GenLocated l e -> e
unLoc
is_flat_prod_pat :: Pat GhcTc -> Bool
is_flat_prod_pat :: Pat GhcTc -> Bool
is_flat_prod_pat (ParPat XParPat GhcTc
_ XRec GhcTc (Pat GhcTc)
p) = XRec GhcTc (Pat GhcTc) -> Bool
is_flat_prod_lpat XRec GhcTc (Pat GhcTc)
p
is_flat_prod_pat (TuplePat XTuplePat GhcTc
_ [XRec GhcTc (Pat GhcTc)]
ps Boxity
Boxed) = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all forall (p :: Pass). LPat (GhcPass p) -> Bool
is_triv_lpat [XRec GhcTc (Pat GhcTc)]
ps
is_flat_prod_pat (ConPat { pat_con :: forall p. Pat p -> XRec p (ConLikeP p)
pat_con = L SrcSpanAnnN
_ ConLike
pcon
, pat_args :: forall p. Pat p -> HsConPatDetails p
pat_args = HsConPatDetails GhcTc
ps})
| RealDataCon DataCon
con <- ConLike
pcon
, let tc :: TyCon
tc = DataCon -> TyCon
dataConTyCon DataCon
con
, Just DataCon
_ <- TyCon -> Maybe DataCon
tyConSingleDataCon_maybe TyCon
tc
, TyCon -> Bool
isLiftedAlgTyCon TyCon
tc
= forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all forall (p :: Pass). LPat (GhcPass p) -> Bool
is_triv_lpat (forall p. UnXRec p => HsConPatDetails p -> [LPat p]
hsConPatArgs HsConPatDetails GhcTc
ps)
is_flat_prod_pat Pat GhcTc
_ = Bool
False
is_triv_lpat :: LPat (GhcPass p) -> Bool
is_triv_lpat :: forall (p :: Pass). LPat (GhcPass p) -> Bool
is_triv_lpat = forall (p :: Pass). Pat (GhcPass p) -> Bool
is_triv_pat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall l e. GenLocated l e -> e
unLoc
is_triv_pat :: Pat (GhcPass p) -> Bool
is_triv_pat :: forall (p :: Pass). Pat (GhcPass p) -> Bool
is_triv_pat (VarPat {}) = Bool
True
is_triv_pat (WildPat{}) = Bool
True
is_triv_pat (ParPat XParPat (GhcPass p)
_ LPat (GhcPass p)
p) = forall (p :: Pass). LPat (GhcPass p) -> Bool
is_triv_lpat LPat (GhcPass p)
p
is_triv_pat Pat (GhcPass p)
_ = Bool
False
mkLHsPatTup :: [LPat GhcTc] -> LPat GhcTc
mkLHsPatTup :: [XRec GhcTc (Pat GhcTc)] -> XRec GhcTc (Pat GhcTc)
mkLHsPatTup [] = forall a an. a -> LocatedAn an a
noLocA forall a b. (a -> b) -> a -> b
$ [XRec GhcTc (Pat GhcTc)] -> Boxity -> Pat GhcTc
mkVanillaTuplePat [] Boxity
Boxed
mkLHsPatTup [XRec GhcTc (Pat GhcTc)
lpat] = XRec GhcTc (Pat GhcTc)
lpat
mkLHsPatTup [XRec GhcTc (Pat GhcTc)]
lpats = forall l e. l -> e -> GenLocated l e
L (forall l e. GenLocated l e -> l
getLoc (forall a. [a] -> a
head [XRec GhcTc (Pat GhcTc)]
lpats)) forall a b. (a -> b) -> a -> b
$
[XRec GhcTc (Pat GhcTc)] -> Boxity -> Pat GhcTc
mkVanillaTuplePat [XRec GhcTc (Pat GhcTc)]
lpats Boxity
Boxed
mkVanillaTuplePat :: [LPat GhcTc] -> Boxity -> Pat GhcTc
mkVanillaTuplePat :: [XRec GhcTc (Pat GhcTc)] -> Boxity -> Pat GhcTc
mkVanillaTuplePat [XRec GhcTc (Pat GhcTc)]
pats Boxity
box = forall p. XTuplePat p -> [LPat p] -> Boxity -> Pat p
TuplePat (forall a b. (a -> b) -> [a] -> [b]
map XRec GhcTc (Pat GhcTc) -> Mult
hsLPatType [XRec GhcTc (Pat GhcTc)]
pats) [XRec GhcTc (Pat GhcTc)]
pats Boxity
box
mkBigLHsVarTupId :: [Id] -> LHsExpr GhcTc
mkBigLHsVarTupId :: [Var] -> LHsExpr GhcTc
mkBigLHsVarTupId [Var]
ids = [LHsExpr GhcTc] -> LHsExpr GhcTc
mkBigLHsTupId (forall a b. (a -> b) -> [a] -> [b]
map forall (p :: Pass) a.
IsSrcSpanAnn p a =>
IdP (GhcPass p) -> LHsExpr (GhcPass p)
nlHsVar [Var]
ids)
mkBigLHsTupId :: [LHsExpr GhcTc] -> LHsExpr GhcTc
mkBigLHsTupId :: [LHsExpr GhcTc] -> LHsExpr GhcTc
mkBigLHsTupId = forall a. ([a] -> a) -> [a] -> a
mkChunkified (\[GenLocated SrcSpanAnnA (HsExpr GhcTc)]
e -> forall (p :: Pass).
[LHsExpr (GhcPass p)]
-> XExplicitTuple (GhcPass p) -> LHsExpr (GhcPass p)
mkLHsTupleExpr [GenLocated SrcSpanAnnA (HsExpr GhcTc)]
e NoExtField
noExtField)
mkBigLHsVarPatTupId :: [Id] -> LPat GhcTc
mkBigLHsVarPatTupId :: [Var] -> XRec GhcTc (Pat GhcTc)
mkBigLHsVarPatTupId [Var]
bs = [XRec GhcTc (Pat GhcTc)] -> XRec GhcTc (Pat GhcTc)
mkBigLHsPatTupId (forall a b. (a -> b) -> [a] -> [b]
map forall (p :: Pass) a.
IsSrcSpanAnn p a =>
IdP (GhcPass p) -> LPat (GhcPass p)
nlVarPat [Var]
bs)
mkBigLHsPatTupId :: [LPat GhcTc] -> LPat GhcTc
mkBigLHsPatTupId :: [XRec GhcTc (Pat GhcTc)] -> XRec GhcTc (Pat GhcTc)
mkBigLHsPatTupId = forall a. ([a] -> a) -> [a] -> a
mkChunkified [XRec GhcTc (Pat GhcTc)] -> XRec GhcTc (Pat GhcTc)
mkLHsPatTup
mkFailurePair :: CoreExpr
-> DsM (CoreBind,
CoreExpr)
mkFailurePair :: CoreExpr -> DsM (CoreBind, CoreExpr)
mkFailurePair CoreExpr
expr
= do { Var
fail_fun_var <- Mult -> Mult -> DsM Var
newFailLocalDs Mult
Many (Mult
unboxedUnitTy Mult -> Mult -> Mult
`mkVisFunTyMany` Mult
ty)
; Var
fail_fun_arg <- Mult -> Mult -> DsM Var
newSysLocalDs Mult
Many Mult
unboxedUnitTy
; let real_arg :: Var
real_arg = Var -> Var
setOneShotLambda Var
fail_fun_arg
; forall (m :: * -> *) a. Monad m => a -> m a
return (forall b. b -> Expr b -> Bind b
NonRec Var
fail_fun_var (forall b. b -> Expr b -> Expr b
Lam Var
real_arg CoreExpr
expr),
forall b. Expr b -> Expr b -> Expr b
App (forall b. Var -> Expr b
Var Var
fail_fun_var) (forall b. Var -> Expr b
Var Var
voidPrimId)) }
where
ty :: Mult
ty = CoreExpr -> Mult
exprType CoreExpr
expr
shareFailureHandler :: MatchResult CoreExpr -> MatchResult CoreExpr
shareFailureHandler :: MatchResult CoreExpr -> MatchResult CoreExpr
shareFailureHandler = \case
mr :: MatchResult CoreExpr
mr@(MR_Infallible DsM CoreExpr
_) -> MatchResult CoreExpr
mr
MR_Fallible CoreExpr -> DsM CoreExpr
match_fn -> forall a. (CoreExpr -> DsM a) -> MatchResult a
MR_Fallible forall a b. (a -> b) -> a -> b
$ \CoreExpr
fail_expr -> do
(CoreBind
fail_bind, CoreExpr
shared_failure_handler) <- CoreExpr -> DsM (CoreBind, CoreExpr)
mkFailurePair CoreExpr
fail_expr
CoreExpr
body <- CoreExpr -> DsM CoreExpr
match_fn CoreExpr
shared_failure_handler
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall b. Bind b -> Expr b -> Expr b
Let CoreBind
fail_bind CoreExpr
body
dsHandleMonadicFailure :: HsStmtContext GhcRn -> LPat GhcTc -> MatchResult CoreExpr -> FailOperator GhcTc -> DsM CoreExpr
dsHandleMonadicFailure :: HsStmtContext GhcRn
-> XRec GhcTc (Pat GhcTc)
-> MatchResult CoreExpr
-> FailOperator GhcTc
-> DsM CoreExpr
dsHandleMonadicFailure HsStmtContext GhcRn
ctx XRec GhcTc (Pat GhcTc)
pat MatchResult CoreExpr
match FailOperator GhcTc
m_fail_op =
case MatchResult CoreExpr -> MatchResult CoreExpr
shareFailureHandler MatchResult CoreExpr
match of
MR_Infallible DsM CoreExpr
body -> DsM CoreExpr
body
MR_Fallible CoreExpr -> DsM CoreExpr
body -> do
SyntaxExprTc
fail_op <- case FailOperator GhcTc
m_fail_op of
FailOperator GhcTc
Nothing -> forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"missing fail op" forall a b. (a -> b) -> a -> b
$
String -> SDoc
text String
"Pattern match:" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr XRec GhcTc (Pat GhcTc)
pat SDoc -> SDoc -> SDoc
<+>
String -> SDoc
text String
"is failable, and fail_expr was left unset"
Just SyntaxExpr GhcTc
fail_op -> forall (f :: * -> *) a. Applicative f => a -> f a
pure SyntaxExpr GhcTc
fail_op
DynFlags
dflags <- forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags
CoreExpr
fail_msg <- forall (m :: * -> *). MonadThings m => String -> m CoreExpr
mkStringExpr (forall e. DynFlags -> HsStmtContext GhcRn -> LocatedA e -> String
mk_fail_msg DynFlags
dflags HsStmtContext GhcRn
ctx XRec GhcTc (Pat GhcTc)
pat)
CoreExpr
fail_expr <- SyntaxExpr GhcTc -> [CoreExpr] -> DsM CoreExpr
dsSyntaxExpr SyntaxExprTc
fail_op [CoreExpr
fail_msg]
CoreExpr -> DsM CoreExpr
body CoreExpr
fail_expr
mk_fail_msg :: DynFlags -> HsStmtContext GhcRn -> LocatedA e -> String
mk_fail_msg :: forall e. DynFlags -> HsStmtContext GhcRn -> LocatedA e -> String
mk_fail_msg DynFlags
dflags HsStmtContext GhcRn
ctx LocatedA e
pat
= forall a. Outputable a => DynFlags -> a -> String
showPpr DynFlags
dflags forall a b. (a -> b) -> a -> b
$ String -> SDoc
text String
"Pattern match failure in" SDoc -> SDoc -> SDoc
<+> forall p. (Outputable (IdP p), UnXRec p) => HsStmtContext p -> SDoc
pprStmtContext HsStmtContext GhcRn
ctx
SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
"at" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr (forall a e. GenLocated (SrcSpanAnn' a) e -> SrcSpan
getLocA LocatedA e
pat)
mkOptTickBox :: [CoreTickish] -> CoreExpr -> CoreExpr
mkOptTickBox :: [CoreTickish] -> CoreExpr -> CoreExpr
mkOptTickBox = forall a b c. (a -> b -> c) -> b -> a -> c
flip (forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr forall b. CoreTickish -> Expr b -> Expr b
Tick)
mkBinaryTickBox :: Int -> Int -> CoreExpr -> DsM CoreExpr
mkBinaryTickBox :: ConTag -> ConTag -> CoreExpr -> DsM CoreExpr
mkBinaryTickBox ConTag
ixT ConTag
ixF CoreExpr
e = do
Unique
uq <- forall gbl lcl. TcRnIf gbl lcl Unique
newUnique
Module
this_mod <- forall (m :: * -> *). HasModule m => m Module
getModule
let bndr1 :: Var
bndr1 = FastString -> Unique -> Mult -> Mult -> Var
mkSysLocal (String -> FastString
fsLit String
"t1") Unique
uq Mult
One Mult
boolTy
let
falseBox :: CoreExpr
falseBox = forall b. CoreTickish -> Expr b -> Expr b
Tick (forall (pass :: TickishPass). Module -> ConTag -> GenTickish pass
HpcTick Module
this_mod ConTag
ixF) (forall b. Var -> Expr b
Var Var
falseDataConId)
trueBox :: CoreExpr
trueBox = forall b. CoreTickish -> Expr b -> Expr b
Tick (forall (pass :: TickishPass). Module -> ConTag -> GenTickish pass
HpcTick Module
this_mod ConTag
ixT) (forall b. Var -> Expr b
Var Var
trueDataConId)
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall b. Expr b -> b -> Mult -> [Alt b] -> Expr b
Case CoreExpr
e Var
bndr1 Mult
boolTy
[ forall b. AltCon -> [b] -> Expr b -> Alt b
Alt (DataCon -> AltCon
DataAlt DataCon
falseDataCon) [] CoreExpr
falseBox
, forall b. AltCon -> [b] -> Expr b -> Alt b
Alt (DataCon -> AltCon
DataAlt DataCon
trueDataCon) [] CoreExpr
trueBox
]
decideBangHood :: DynFlags
-> LPat GhcTc
-> LPat GhcTc
decideBangHood :: DynFlags -> XRec GhcTc (Pat GhcTc) -> XRec GhcTc (Pat GhcTc)
decideBangHood DynFlags
dflags XRec GhcTc (Pat GhcTc)
lpat
| Bool -> Bool
not (Extension -> DynFlags -> Bool
xopt Extension
LangExt.Strict DynFlags
dflags)
= XRec GhcTc (Pat GhcTc)
lpat
| Bool
otherwise
= forall {p} {l}.
(XRec p (Pat p) ~ GenLocated l (Pat p), XBangPat p ~ NoExtField) =>
GenLocated l (Pat p) -> GenLocated l (Pat p)
go XRec GhcTc (Pat GhcTc)
lpat
where
go :: GenLocated l (Pat p) -> GenLocated l (Pat p)
go lp :: GenLocated l (Pat p)
lp@(L l
l Pat p
p)
= case Pat p
p of
ParPat XParPat p
x XRec p (Pat p)
p -> forall l e. l -> e -> GenLocated l e
L l
l (forall p. XParPat p -> LPat p -> Pat p
ParPat XParPat p
x (GenLocated l (Pat p) -> GenLocated l (Pat p)
go XRec p (Pat p)
p))
LazyPat XLazyPat p
_ XRec p (Pat p)
lp' -> XRec p (Pat p)
lp'
BangPat XBangPat p
_ XRec p (Pat p)
_ -> GenLocated l (Pat p)
lp
Pat p
_ -> forall l e. l -> e -> GenLocated l e
L l
l (forall p. XBangPat p -> LPat p -> Pat p
BangPat NoExtField
noExtField GenLocated l (Pat p)
lp)
isTrueLHsExpr :: LHsExpr GhcTc -> Maybe (CoreExpr -> DsM CoreExpr)
isTrueLHsExpr :: LHsExpr GhcTc -> Maybe (CoreExpr -> DsM CoreExpr)
isTrueLHsExpr (L SrcSpanAnnA
_ (HsVar XVar GhcTc
_ (L SrcSpanAnnN
_ Var
v)))
| Var
v forall a. Uniquable a => a -> Unique -> Bool
`hasKey` Unique
otherwiseIdKey
Bool -> Bool -> Bool
|| Var
v forall a. Uniquable a => a -> Unique -> Bool
`hasKey` forall a. Uniquable a => a -> Unique
getUnique Var
trueDataConId
= forall a. a -> Maybe a
Just forall (m :: * -> *) a. Monad m => a -> m a
return
isTrueLHsExpr (L SrcSpanAnnA
_ (HsConLikeOut XConLikeOut GhcTc
_ ConLike
con))
| ConLike
con forall a. Uniquable a => a -> Unique -> Bool
`hasKey` forall a. Uniquable a => a -> Unique
getUnique DataCon
trueDataCon = forall a. a -> Maybe a
Just forall (m :: * -> *) a. Monad m => a -> m a
return
isTrueLHsExpr (L SrcSpanAnnA
_ (HsTick XTick GhcTc
_ CoreTickish
tickish LHsExpr GhcTc
e))
| Just CoreExpr -> DsM CoreExpr
ticks <- LHsExpr GhcTc -> Maybe (CoreExpr -> DsM CoreExpr)
isTrueLHsExpr LHsExpr GhcTc
e
= forall a. a -> Maybe a
Just (\CoreExpr
x -> do CoreExpr
wrapped <- CoreExpr -> DsM CoreExpr
ticks CoreExpr
x
forall (m :: * -> *) a. Monad m => a -> m a
return (forall b. CoreTickish -> Expr b -> Expr b
Tick CoreTickish
tickish CoreExpr
wrapped))
isTrueLHsExpr (L SrcSpanAnnA
_ (HsBinTick XBinTick GhcTc
_ ConTag
ixT ConTag
_ LHsExpr GhcTc
e))
| Just CoreExpr -> DsM CoreExpr
ticks <- LHsExpr GhcTc -> Maybe (CoreExpr -> DsM CoreExpr)
isTrueLHsExpr LHsExpr GhcTc
e
= forall a. a -> Maybe a
Just (\CoreExpr
x -> do CoreExpr
e <- CoreExpr -> DsM CoreExpr
ticks CoreExpr
x
Module
this_mod <- forall (m :: * -> *). HasModule m => m Module
getModule
forall (m :: * -> *) a. Monad m => a -> m a
return (forall b. CoreTickish -> Expr b -> Expr b
Tick (forall (pass :: TickishPass). Module -> ConTag -> GenTickish pass
HpcTick Module
this_mod ConTag
ixT) CoreExpr
e))
isTrueLHsExpr (L SrcSpanAnnA
_ (HsPar XPar GhcTc
_ LHsExpr GhcTc
e)) = LHsExpr GhcTc -> Maybe (CoreExpr -> DsM CoreExpr)
isTrueLHsExpr LHsExpr GhcTc
e
isTrueLHsExpr LHsExpr GhcTc
_ = forall a. Maybe a
Nothing