{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE TypeFamilies #-}
module GHC.HsToCore.Utils (
EquationInfo(..),
firstPat, shiftEqns, combineEqnRhss,
MatchResult (..), CaseAlt(..),
cantFailMatchResult, alwaysFailMatchResult,
extractMatchResult, combineMatchResults,
adjustMatchResultDs,
shareFailureHandler,
dsHandleMonadicFailure,
mkCoLetMatchResult, mkViewMatchResult, mkGuardedMatchResult,
matchCanFail, mkEvalMatchResult,
mkCoPrimCaseMatchResult, mkCoAlgCaseMatchResult, mkCoSynCaseMatchResult,
wrapBind, wrapBinds,
mkErrorAppDs, mkCastDs, mkFailExpr,
seqVar,
mkLHsPatTup, mkVanillaTuplePat,
mkBigLHsVarTupId, mkBigLHsTupId, mkBigLHsVarPatTupId, mkBigLHsPatTupId,
mkSelectorBinds,
selectSimpleMatchVarL, selectMatchVars, selectMatchVar,
mkOptTickBox, mkBinaryTickBox, decideBangHood,
isTrueLHsExpr,
) where
import GHC.Prelude
import Language.Haskell.Syntax.Basic (Boxity(..))
import {-# SOURCE #-} GHC.HsToCore.Match ( matchSimply )
import {-# SOURCE #-} GHC.HsToCore.Expr ( dsLExpr, dsSyntaxExpr )
import GHC.Hs
import GHC.Hs.Syn.Type
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.Core.TyCo.Rep( Scaled(..) )
import GHC.Builtin.Types
import GHC.Core.ConLike
import GHC.Types.Unique.Set
import GHC.Types.Unique.Supply
import GHC.Unit.Module
import GHC.Builtin.Names
import GHC.Utils.Outputable
import GHC.Utils.Panic
import GHC.Types.SrcLoc
import GHC.Types.Tickish
import GHC.Utils.Misc
import GHC.Driver.DynFlags
import GHC.Driver.Ppr
import qualified GHC.LanguageExtensions as LangExt
import GHC.Rename.Env ( irrefutableConLikeTc )
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 (GenLocated SrcSpanAnnA (Pat GhcTc) -> Pat GhcTc
forall l e. GenLocated l e -> e
unLoc XRec GhcTc (Pat GhcTc)
GenLocated SrcSpanAnnA (Pat GhcTc)
pat)
selectMatchVars :: [(Mult, Pat GhcTc)] -> DsM [Id]
selectMatchVars :: [(Mult, Pat GhcTc)] -> DsM [Var]
selectMatchVars [(Mult, Pat GhcTc)]
ps = ((Mult, Pat GhcTc) -> DsM Var) -> [(Mult, Pat GhcTc)] -> DsM [Var]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((Mult -> Pat GhcTc -> DsM Var) -> (Mult, Pat GhcTc) -> DsM Var
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 (GenLocated SrcSpanAnnA (Pat GhcTc) -> Pat GhcTc
forall l e. GenLocated l e -> e
unLoc XRec GhcTc (Pat GhcTc)
GenLocated SrcSpanAnnA (Pat GhcTc)
pat)
selectMatchVar Mult
w (LazyPat XLazyPat GhcTc
_ XRec GhcTc (Pat GhcTc)
pat) = Mult -> Pat GhcTc -> DsM Var
selectMatchVar Mult
w (GenLocated SrcSpanAnnA (Pat GhcTc) -> Pat GhcTc
forall l e. GenLocated l e -> e
unLoc XRec GhcTc (Pat GhcTc)
GenLocated SrcSpanAnnA (Pat GhcTc)
pat)
selectMatchVar Mult
w (ParPat XParPat GhcTc
_ XRec GhcTc (Pat GhcTc)
pat) = Mult -> Pat GhcTc -> DsM Var
selectMatchVar Mult
w (GenLocated SrcSpanAnnA (Pat GhcTc) -> Pat GhcTc
forall l e. GenLocated l e -> e
unLoc XRec GhcTc (Pat GhcTc)
GenLocated SrcSpanAnnA (Pat GhcTc)
pat)
selectMatchVar Mult
_w (VarPat XVarPat GhcTc
_ LIdP GhcTc
var) = Var -> DsM Var
forall a. a -> IOEnv (Env DsGblEnv DsLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Var -> Var
localiseId (GenLocated SrcSpanAnnN Var -> Var
forall l e. GenLocated l e -> e
unLoc LIdP GhcTc
GenLocated SrcSpanAnnN Var
var))
selectMatchVar Mult
_w (AsPat XAsPat GhcTc
_ LIdP GhcTc
var XRec GhcTc (Pat GhcTc)
_) = Bool -> DsM Var -> DsM Var
forall a. HasCallStack => Bool -> a -> a
assert (Mult -> Bool
isManyTy Mult
_w ) (Var -> DsM Var
forall a. a -> IOEnv (Env DsGblEnv DsLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Var -> Var
localiseId (GenLocated SrcSpanAnnN Var -> Var
forall l e. GenLocated l e -> e
unLoc LIdP GhcTc
GenLocated SrcSpanAnnN Var
var)))
selectMatchVar Mult
w Pat GhcTc
other_pat = Scaled Mult -> DsM Var
newSysLocalDs (Mult -> Mult -> Scaled Mult
forall a. Mult -> a -> Scaled a
Scaled Mult
w (Pat GhcTc -> Mult
hsPatType Pat GhcTc
other_pat))
firstPat :: EquationInfoNE -> Pat GhcTc
firstPat :: EquationInfoNE -> Pat GhcTc
firstPat (EqnMatch { eqn_pat :: EquationInfoNE -> XRec GhcTc (Pat GhcTc)
eqn_pat = XRec GhcTc (Pat GhcTc)
pat }) = GenLocated SrcSpanAnnA (Pat GhcTc) -> Pat GhcTc
forall l e. GenLocated l e -> e
unLoc XRec GhcTc (Pat GhcTc)
GenLocated SrcSpanAnnA (Pat GhcTc)
pat
firstPat (EqnDone {}) = [Char] -> Pat GhcTc
forall a. HasCallStack => [Char] -> a
error [Char]
"firstPat: no patterns"
shiftEqns :: Functor f => f EquationInfoNE -> f EquationInfo
shiftEqns :: forall (f :: * -> *).
Functor f =>
f EquationInfoNE -> f EquationInfoNE
shiftEqns = (EquationInfoNE -> EquationInfoNE)
-> f EquationInfoNE -> f EquationInfoNE
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap EquationInfoNE -> EquationInfoNE
shift
where
shift :: EquationInfoNE -> EquationInfoNE
shift (EqnMatch { eqn_rest :: EquationInfoNE -> EquationInfoNE
eqn_rest = EquationInfoNE
rest }) = EquationInfoNE
rest
shift eqn :: EquationInfoNE
eqn@(EqnDone {}) = [Char] -> SDoc -> EquationInfoNE
forall a. HasCallStack => [Char] -> SDoc -> a
pprPanic [Char]
"shiftEqns" (EquationInfoNE -> SDoc
forall a. Outputable a => a -> SDoc
ppr EquationInfoNE
eqn)
combineEqnRhss :: NonEmpty EquationInfo -> DsM (MatchResult CoreExpr)
combineEqnRhss :: NonEmpty EquationInfoNE -> DsM (MatchResult CoreExpr)
combineEqnRhss NonEmpty EquationInfoNE
eqns = MatchResult CoreExpr -> DsM (MatchResult CoreExpr)
forall a. a -> IOEnv (Env DsGblEnv DsLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return (MatchResult CoreExpr -> DsM (MatchResult CoreExpr))
-> MatchResult CoreExpr -> DsM (MatchResult CoreExpr)
forall a b. (a -> b) -> a -> b
$ (MatchResult CoreExpr
-> MatchResult CoreExpr -> MatchResult CoreExpr)
-> [MatchResult CoreExpr] -> MatchResult CoreExpr
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 MatchResult CoreExpr
-> MatchResult CoreExpr -> MatchResult CoreExpr
combineMatchResults ([MatchResult CoreExpr] -> MatchResult CoreExpr)
-> [MatchResult CoreExpr] -> MatchResult CoreExpr
forall a b. (a -> b) -> a -> b
$ (EquationInfoNE -> MatchResult CoreExpr)
-> [EquationInfoNE] -> [MatchResult CoreExpr]
forall a b. (a -> b) -> [a] -> [b]
map EquationInfoNE -> MatchResult CoreExpr
eqnMatchResult (NonEmpty EquationInfoNE -> [EquationInfoNE]
forall a. NonEmpty a -> [a]
NEL.toList NonEmpty EquationInfoNE
eqns)
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 = (CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr
forall a. (CoreExpr -> DsM a) -> MatchResult a
MR_Fallible ((CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr)
-> (CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr
forall a b. (a -> b) -> a -> b
$ \CoreExpr
fail -> CoreExpr -> DsM CoreExpr
forall a. a -> IOEnv (Env DsGblEnv DsLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return CoreExpr
fail
cantFailMatchResult :: CoreExpr -> MatchResult CoreExpr
cantFailMatchResult :: CoreExpr -> MatchResult CoreExpr
cantFailMatchResult CoreExpr
expr = DsM CoreExpr -> MatchResult CoreExpr
forall a. DsM a -> MatchResult a
MR_Infallible (DsM CoreExpr -> MatchResult CoreExpr)
-> DsM CoreExpr -> MatchResult CoreExpr
forall a b. (a -> b) -> a -> b
$ CoreExpr -> DsM CoreExpr
forall a. a -> IOEnv (Env DsGblEnv DsLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return CoreExpr
expr
extractMatchResult :: MatchResult CoreExpr -> CoreExpr -> DsM CoreExpr
MatchResult CoreExpr
match_result CoreExpr
failure_expr =
CoreExpr -> MatchResult CoreExpr -> DsM CoreExpr
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 -> (CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr
forall a. (CoreExpr -> DsM a) -> MatchResult a
MR_Fallible ((CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr)
-> (CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr
forall a b. (a -> b) -> a -> b
$ \CoreExpr
fail_expr ->
CoreExpr -> DsM CoreExpr
body_fn1 (CoreExpr -> DsM CoreExpr) -> DsM CoreExpr -> DsM CoreExpr
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< CoreExpr -> MatchResult CoreExpr -> DsM CoreExpr
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 -> DsM b -> MatchResult b
forall a. DsM a -> MatchResult a
MR_Infallible (DsM b -> MatchResult b) -> DsM b -> MatchResult b
forall a b. (a -> b) -> a -> b
$
a -> DsM b
encl_fn (a -> DsM b) -> DsM a -> DsM b
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< DsM a
body_fn
MR_Fallible CoreExpr -> DsM a
body_fn -> (CoreExpr -> DsM b) -> MatchResult b
forall a. (CoreExpr -> DsM a) -> MatchResult a
MR_Fallible ((CoreExpr -> DsM b) -> MatchResult b)
-> (CoreExpr -> DsM b) -> MatchResult b
forall a b. (a -> b) -> a -> b
$ \CoreExpr
fail ->
a -> DsM b
encl_fn (a -> DsM b) -> DsM a -> DsM b
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
newVar -> Var -> Bool
forall a. Eq a => a -> a -> Bool
==Var
old = CoreExpr
body
| Bool
otherwise = Bind Var -> CoreExpr -> CoreExpr
forall b. Bind b -> Expr b -> Expr b
Let (Var -> CoreExpr -> Bind Var
forall b. b -> Expr b -> Bind b
NonRec Var
new (Var -> CoreExpr
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 (Var -> CoreExpr
forall b. Var -> Expr b
Var Var
var) Var
var CoreExpr
body
mkCoLetMatchResult :: CoreBind -> MatchResult CoreExpr -> MatchResult CoreExpr
mkCoLetMatchResult :: Bind Var -> MatchResult CoreExpr -> MatchResult CoreExpr
mkCoLetMatchResult Bind Var
bind = (CoreExpr -> CoreExpr)
-> MatchResult CoreExpr -> MatchResult CoreExpr
forall a b. (a -> b) -> MatchResult a -> MatchResult b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Bind Var -> CoreExpr -> CoreExpr
mkCoreLet Bind Var
bind)
mkViewMatchResult :: Id -> CoreExpr -> MatchResult CoreExpr -> MatchResult CoreExpr
mkViewMatchResult :: Var -> CoreExpr -> MatchResult CoreExpr -> MatchResult CoreExpr
mkViewMatchResult Var
var' CoreExpr
viewExpr = (CoreExpr -> CoreExpr)
-> MatchResult CoreExpr -> MatchResult CoreExpr
forall a b. (a -> b) -> MatchResult a -> MatchResult b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((CoreExpr -> CoreExpr)
-> MatchResult CoreExpr -> MatchResult CoreExpr)
-> (CoreExpr -> CoreExpr)
-> MatchResult CoreExpr
-> MatchResult CoreExpr
forall a b. (a -> b) -> a -> b
$ Bind Var -> CoreExpr -> CoreExpr
mkCoreLet (Bind Var -> CoreExpr -> CoreExpr)
-> Bind Var -> CoreExpr -> CoreExpr
forall a b. (a -> b) -> a -> b
$ Var -> CoreExpr -> Bind Var
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 = (CoreExpr -> CoreExpr)
-> MatchResult CoreExpr -> MatchResult CoreExpr
forall a b. (a -> b) -> MatchResult a -> MatchResult b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((CoreExpr -> CoreExpr)
-> MatchResult CoreExpr -> MatchResult CoreExpr)
-> (CoreExpr -> CoreExpr)
-> MatchResult CoreExpr
-> MatchResult CoreExpr
forall a b. (a -> b) -> a -> b
$ \CoreExpr
e ->
CoreExpr -> Var -> Mult -> [Alt Var] -> CoreExpr
forall b. Expr b -> b -> Mult -> [Alt b] -> Expr b
Case (Var -> CoreExpr
forall b. Var -> Expr b
Var Var
var) Var
var Mult
ty [AltCon -> [Var] -> CoreExpr -> Alt Var
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 = (CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr
forall a. (CoreExpr -> DsM a) -> MatchResult a
MR_Fallible ((CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr)
-> (CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr
forall a b. (a -> b) -> a -> b
$ \CoreExpr
fail -> do
body <- CoreExpr -> MatchResult CoreExpr -> DsM CoreExpr
forall a. CoreExpr -> MatchResult a -> DsM a
runMatchResult CoreExpr
fail MatchResult CoreExpr
mr
return (mkIfThenElse pred_expr body 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
= (CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr
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
alts <- ((Literal, MatchResult CoreExpr)
-> IOEnv (Env DsGblEnv DsLclEnv) (Alt Var))
-> [(Literal, MatchResult CoreExpr)]
-> IOEnv (Env DsGblEnv DsLclEnv) [Alt Var]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (CoreExpr
-> (Literal, MatchResult CoreExpr)
-> IOEnv (Env DsGblEnv DsLclEnv) (Alt Var)
forall {b}.
CoreExpr
-> (Literal, MatchResult (Expr b))
-> IOEnv (Env DsGblEnv DsLclEnv) (Alt b)
mk_alt CoreExpr
fail) [(Literal, MatchResult CoreExpr)]
sorted_alts
return (Case (Var var) var ty (Alt DEFAULT [] fail : alts))
sorted_alts :: [(Literal, MatchResult CoreExpr)]
sorted_alts = ((Literal, MatchResult CoreExpr) -> Literal)
-> [(Literal, MatchResult CoreExpr)]
-> [(Literal, MatchResult CoreExpr)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortWith (Literal, MatchResult CoreExpr) -> Literal
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)
= Bool
-> IOEnv (Env DsGblEnv DsLclEnv) (Alt b)
-> IOEnv (Env DsGblEnv DsLclEnv) (Alt b)
forall a. HasCallStack => Bool -> a -> a
assert (Bool -> Bool
not (Literal -> Bool
litIsLifted Literal
lit)) (IOEnv (Env DsGblEnv DsLclEnv) (Alt b)
-> IOEnv (Env DsGblEnv DsLclEnv) (Alt b))
-> IOEnv (Env DsGblEnv DsLclEnv) (Alt b)
-> IOEnv (Env DsGblEnv DsLclEnv) (Alt b)
forall a b. (a -> b) -> a -> b
$
do body <- CoreExpr -> MatchResult (Expr b) -> DsM (Expr b)
forall a. CoreExpr -> MatchResult a -> DsM a
runMatchResult CoreExpr
fail MatchResult (Expr b)
mr
return (Alt (LitAlt lit) [] 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
= Bool -> MatchResult CoreExpr -> MatchResult CoreExpr
forall a. HasCallStack => Bool -> a -> a
assert ([CaseAlt DataCon] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [CaseAlt DataCon]
match_alts_tail Bool -> Bool -> Bool
&& [Var] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([Var] -> [Var]
forall a. HasCallStack => [a] -> [a]
tail [Var]
arg_ids1)) (MatchResult CoreExpr -> MatchResult CoreExpr)
-> MatchResult CoreExpr -> MatchResult CoreExpr
forall a b. (a -> b) -> a -> b
$
Bind Var -> MatchResult CoreExpr -> MatchResult CoreExpr
mkCoLetMatchResult (Var -> CoreExpr -> Bind Var
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 (CaseAlt DataCon -> DataCon
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 = Bool -> Var -> Var
forall a. HasCallStack => Bool -> a -> a
assert ([Var] -> Bool
forall (f :: * -> *) a. Foldable f => f a -> Bool
notNull [Var]
arg_ids1) (Var -> Var) -> Var -> Var
forall a b. (a -> b) -> a -> b
$ [Var] -> Var
forall a. HasCallStack => [a] -> a
head [Var]
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 (Var -> CoreExpr
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 = (CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr
forall a. (CoreExpr -> DsM a) -> MatchResult a
MR_Fallible ((CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr)
-> (CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr
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
matcher_id <- Name -> DsM Var
dsLookupGlobalId Name
matcher_name
matcher <- dsLExpr $ mkLHsWrap wrapper $
nlHsTyApp matcher_id [getRuntimeRep ty, ty]
cont <- mkCoreLams bndrs <$> runMatchResult fail match_result
return $ mkCoreApps matcher [Var var, ensure_unstrict cont, Lam voidArgId 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 = Var -> CoreExpr -> CoreExpr
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]
_)
= (Maybe (Alt Var) -> [Alt Var] -> CoreExpr)
-> MatchResult (Maybe (Alt Var))
-> MatchResult [Alt Var]
-> MatchResult CoreExpr
forall a b c.
(a -> b -> c) -> MatchResult a -> MatchResult b -> MatchResult c
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 = CaseAlt DataCon -> DataCon
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 = (CaseAlt DataCon -> ConTag)
-> [CaseAlt DataCon] -> [CaseAlt DataCon]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortWith (DataCon -> ConTag
dataConTag (DataCon -> ConTag)
-> (CaseAlt DataCon -> DataCon) -> CaseAlt DataCon -> ConTag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CaseAlt DataCon -> DataCon
forall a. CaseAlt a -> a
alt_pat) ([CaseAlt DataCon] -> [CaseAlt DataCon])
-> [CaseAlt DataCon] -> [CaseAlt DataCon]
forall a b. (a -> b) -> a -> b
$ NonEmpty (CaseAlt DataCon) -> [CaseAlt DataCon]
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 (Var -> CoreExpr
forall b. Var -> Expr b
Var Var
var) (Var -> Scaled Mult
idScaledType Var
var) Mult
ty ([Alt Var] -> CoreExpr) -> [Alt Var] -> CoreExpr
forall a b. (a -> b) -> a -> b
$
Maybe (Alt Var) -> [Alt Var]
forall a. Maybe a -> [a]
maybeToList Maybe (Alt Var)
def [Alt Var] -> [Alt Var] -> [Alt Var]
forall a. [a] -> [a] -> [a]
++ [Alt Var]
alts
mk_alts :: MatchResult [CoreAlt]
mk_alts :: MatchResult [Alt Var]
mk_alts = (CaseAlt DataCon -> MatchResult (Alt Var))
-> [CaseAlt DataCon] -> MatchResult [Alt Var]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [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 } =
((CoreExpr -> IOEnv (Env DsGblEnv DsLclEnv) (Alt Var))
-> MatchResult CoreExpr -> MatchResult (Alt Var))
-> MatchResult CoreExpr
-> (CoreExpr -> IOEnv (Env DsGblEnv DsLclEnv) (Alt Var))
-> MatchResult (Alt Var)
forall a b c. (a -> b -> c) -> b -> a -> c
flip (CoreExpr -> IOEnv (Env DsGblEnv DsLclEnv) (Alt Var))
-> MatchResult CoreExpr -> MatchResult (Alt Var)
forall a b. (a -> DsM b) -> MatchResult a -> MatchResult b
adjustMatchResultDs MatchResult CoreExpr
match_result ((CoreExpr -> IOEnv (Env DsGblEnv DsLclEnv) (Alt Var))
-> MatchResult (Alt Var))
-> (CoreExpr -> IOEnv (Env DsGblEnv DsLclEnv) (Alt Var))
-> MatchResult (Alt Var)
forall a b. (a -> b) -> a -> b
$ \CoreExpr
body -> do
case DataCon -> Maybe DataConBoxer
dataConBoxer DataCon
con of
Maybe DataConBoxer
Nothing -> Alt Var -> IOEnv (Env DsGblEnv DsLclEnv) (Alt Var)
forall a. a -> IOEnv (Env DsGblEnv DsLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return (AltCon -> [Var] -> CoreExpr -> Alt Var
forall b. AltCon -> [b] -> Expr b -> Alt b
Alt (DataCon -> AltCon
DataAlt DataCon
con) [Var]
args CoreExpr
body)
Just (DCB [Mult] -> [Var] -> UniqSM ([Var], [Bind Var])
boxer) -> do
us <- TcRnIf DsGblEnv DsLclEnv UniqSupply
forall gbl lcl. TcRnIf gbl lcl UniqSupply
newUniqueSupply
let (rep_ids, binds) = initUs_ us (boxer ty_args args)
let rep_ids' = (Var -> Var) -> [Var] -> [Var]
forall a b. (a -> b) -> [a] -> [b]
map (Mult -> Var -> Var
scaleVarBy (HasDebugCallStack => Var -> Mult
Var -> Mult
idMult Var
var)) [Var]
rep_ids
return (Alt (DataAlt con) rep_ids' (mkLets binds body))
mk_default :: MatchResult (Maybe CoreAlt)
mk_default :: MatchResult (Maybe (Alt Var))
mk_default
| Bool
exhaustive_case = DsM (Maybe (Alt Var)) -> MatchResult (Maybe (Alt Var))
forall a. DsM a -> MatchResult a
MR_Infallible (DsM (Maybe (Alt Var)) -> MatchResult (Maybe (Alt Var)))
-> DsM (Maybe (Alt Var)) -> MatchResult (Maybe (Alt Var))
forall a b. (a -> b) -> a -> b
$ Maybe (Alt Var) -> DsM (Maybe (Alt Var))
forall a. a -> IOEnv (Env DsGblEnv DsLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Alt Var)
forall a. Maybe a
Nothing
| Bool
otherwise = (CoreExpr -> DsM (Maybe (Alt Var)))
-> MatchResult (Maybe (Alt Var))
forall a. (CoreExpr -> DsM a) -> MatchResult a
MR_Fallible ((CoreExpr -> DsM (Maybe (Alt Var)))
-> MatchResult (Maybe (Alt Var)))
-> (CoreExpr -> DsM (Maybe (Alt Var)))
-> MatchResult (Maybe (Alt Var))
forall a b. (a -> b) -> a -> b
$ \CoreExpr
fail -> Maybe (Alt Var) -> DsM (Maybe (Alt Var))
forall a. a -> IOEnv (Env DsGblEnv DsLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (Alt Var) -> DsM (Maybe (Alt Var)))
-> Maybe (Alt Var) -> DsM (Maybe (Alt Var))
forall a b. (a -> b) -> a -> b
$ Alt Var -> Maybe (Alt Var)
forall a. a -> Maybe a
Just (AltCon -> [Var] -> CoreExpr -> Alt Var
forall b. AltCon -> [b] -> Expr b -> Alt b
Alt AltCon
DEFAULT [] CoreExpr
fail)
mentioned_constructors :: UniqSet DataCon
mentioned_constructors = [DataCon] -> UniqSet DataCon
forall a. Uniquable a => [a] -> UniqSet a
mkUniqSet ([DataCon] -> UniqSet DataCon) -> [DataCon] -> UniqSet DataCon
forall a b. (a -> b) -> a -> b
$ (CaseAlt DataCon -> DataCon) -> [CaseAlt DataCon] -> [DataCon]
forall a b. (a -> b) -> [a] -> [b]
map CaseAlt DataCon -> DataCon
forall a. CaseAlt a -> a
alt_pat [CaseAlt DataCon]
sorted_alts
un_mentioned_constructors :: UniqSet DataCon
un_mentioned_constructors
= [DataCon] -> UniqSet DataCon
forall a. Uniquable a => [a] -> UniqSet a
mkUniqSet [DataCon]
data_cons UniqSet DataCon -> UniqSet DataCon -> UniqSet DataCon
forall a. UniqSet a -> UniqSet a -> UniqSet a
`minusUniqSet` UniqSet DataCon
mentioned_constructors
exhaustive_case :: Bool
exhaustive_case = UniqSet DataCon -> Bool
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
src_loc <- DsM SrcSpan
getSrcSpanDs
dflags <- getDynFlags
let full_msg = DynFlags -> SDoc -> [Char]
showSDoc DynFlags
dflags ([SDoc] -> SDoc
forall doc. IsLine doc => [doc] -> doc
hcat [SrcSpan -> SDoc
forall a. Outputable a => a -> SDoc
ppr SrcSpan
src_loc, SDoc
forall doc. IsLine doc => doc
vbar, SDoc
msg])
fail_expr = Var -> Mult -> [Char] -> CoreExpr
mkRuntimeErrorApp Var
err_id Mult
unitTy [Char]
full_msg
return $ mkWildCase fail_expr (unrestricted unitTy) ty []
mkFailExpr :: HsMatchContextRn -> Type -> DsM CoreExpr
mkFailExpr :: HsMatchContextRn -> Mult -> DsM CoreExpr
mkFailExpr HsMatchContextRn
ctxt Mult
ty
= Var -> Mult -> SDoc -> DsM CoreExpr
mkErrorAppDs Var
pAT_ERROR_ID Mult
ty (HsMatchContext (GenLocated SrcSpanAnnN Name) -> SDoc
forall fn. Outputable fn => HsMatchContext fn -> SDoc
matchContextErrString HsMatchContextRn
HsMatchContext (GenLocated SrcSpanAnnN Name)
ctxt)
mkCastDs :: CoreExpr -> Coercion -> CoreExpr
mkCastDs :: CoreExpr -> Coercion -> CoreExpr
mkCastDs CoreExpr
e Coercion
co | Coercion -> Bool
isReflCo Coercion
co = CoreExpr
e
| Bool
otherwise = CoreExpr -> Coercion -> CoreExpr
forall b. Expr b -> Coercion -> Expr b
Cast CoreExpr
e Coercion
co
mkSelectorBinds :: [[CoreTickish]]
-> LPat GhcTc
-> HsMatchContextRn
-> CoreExpr
-> DsM (Id,[(Id,CoreExpr)])
mkSelectorBinds :: [[CoreTickish]]
-> XRec GhcTc (Pat GhcTc)
-> HsMatchContextRn
-> CoreExpr
-> DsM (Var, [(Var, CoreExpr)])
mkSelectorBinds [[CoreTickish]]
ticks XRec GhcTc (Pat GhcTc)
pat HsMatchContextRn
ctx CoreExpr
val_expr
| L SrcSpanAnnA
_ (VarPat XVarPat GhcTc
_ (L SrcSpanAnnN
_ Var
v)) <- XRec GhcTc (Pat GhcTc)
pat'
= (Var, [(Var, CoreExpr)]) -> DsM (Var, [(Var, CoreExpr)])
forall a. a -> IOEnv (Env DsGblEnv DsLclEnv) a
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'
; val_var <- Mult -> DsM Var
newSysLocalMDs Mult
pat_ty
; let mk_bind [CoreTickish]
tick Var
bndr_var
= do { rhs_expr <- CoreExpr
-> HsMatchContextRn
-> Mult
-> XRec GhcTc (Pat GhcTc)
-> CoreExpr
-> CoreExpr
-> DsM CoreExpr
matchSimply (Var -> CoreExpr
forall b. Var -> Expr b
Var Var
val_var) HsMatchContextRn
ctx Mult
ManyTy XRec GhcTc (Pat GhcTc)
pat'
(Var -> CoreExpr
forall b. Var -> Expr b
Var Var
bndr_var)
(Var -> CoreExpr
forall b. Var -> Expr b
Var Var
bndr_var)
; return (bndr_var, mkOptTickBox tick rhs_expr) }
; binds <- zipWithM mk_bind ticks' binders
; return ( val_var, (val_var, val_expr) : binds) }
| Bool
otherwise
= do { tuple_var <- Mult -> DsM Var
newSysLocalMDs Mult
tuple_ty
; error_expr <- mkErrorAppDs pAT_ERROR_ID tuple_ty (ppr pat')
; tuple_expr <- matchSimply val_expr ctx ManyTy pat
local_tuple error_expr
; let mk_tup_bind [CoreTickish]
tick Var
binder
= (Var
binder, [CoreTickish] -> CoreExpr -> CoreExpr
mkOptTickBox [CoreTickish]
tick (CoreExpr -> CoreExpr) -> CoreExpr -> CoreExpr
forall a b. (a -> b) -> a -> b
$
[Var] -> Var -> Var -> CoreExpr -> CoreExpr
mkBigTupleSelectorSolo [Var]
local_binders Var
binder
Var
tuple_var (Var -> CoreExpr
forall b. Var -> Expr b
Var Var
tuple_var))
tup_binds = ([CoreTickish] -> Var -> (Var, CoreExpr))
-> [[CoreTickish]] -> [Var] -> [(Var, CoreExpr)]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith [CoreTickish] -> Var -> (Var, CoreExpr)
mk_tup_bind [[CoreTickish]]
ticks' [IdP GhcTc]
[Var]
binders
; return (tuple_var, (tuple_var, tuple_expr) : tup_binds) }
where
pat' :: XRec GhcTc (Pat GhcTc)
pat' = XRec GhcTc (Pat GhcTc) -> XRec GhcTc (Pat GhcTc)
forall (p :: Pass). LPat (GhcPass p) -> LPat (GhcPass p)
strip_bangs XRec GhcTc (Pat GhcTc)
pat
binders :: [IdP GhcTc]
binders = CollectFlag GhcTc -> XRec GhcTc (Pat GhcTc) -> [IdP GhcTc]
forall p. CollectPass p => CollectFlag p -> LPat p -> [IdP p]
collectPatBinders CollectFlag GhcTc
forall p. CollectFlag p
CollNoDictBinders XRec GhcTc (Pat GhcTc)
pat'
ticks' :: [[CoreTickish]]
ticks' = [[CoreTickish]]
ticks [[CoreTickish]] -> [[CoreTickish]] -> [[CoreTickish]]
forall a. [a] -> [a] -> [a]
++ [CoreTickish] -> [[CoreTickish]]
forall a. a -> [a]
repeat []
local_binders :: [Var]
local_binders = (Var -> Var) -> [Var] -> [Var]
forall a b. (a -> b) -> [a] -> [b]
map Var -> Var
localiseId [IdP GhcTc]
[Var]
binders
local_tuple :: CoreExpr
local_tuple = [Var] -> CoreExpr
mkBigCoreVarTupSolo [IdP GhcTc]
[Var]
binders
tuple_ty :: Mult
tuple_ty = HasDebugCallStack => CoreExpr -> Mult
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)) = LPat (GhcPass p) -> LPat (GhcPass 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)) = LPat (GhcPass p) -> LPat (GhcPass 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 (Pat GhcTc -> Bool)
-> (GenLocated SrcSpanAnnA (Pat GhcTc) -> Pat GhcTc)
-> GenLocated SrcSpanAnnA (Pat GhcTc)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenLocated SrcSpanAnnA (Pat GhcTc) -> Pat GhcTc
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) = (GenLocated SrcSpanAnnA (Pat GhcTc) -> Bool)
-> [GenLocated SrcSpanAnnA (Pat GhcTc)] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all XRec GhcTc (Pat GhcTc) -> Bool
GenLocated SrcSpanAnnA (Pat GhcTc) -> Bool
forall (p :: Pass). LPat (GhcPass p) -> Bool
is_triv_lpat [XRec GhcTc (Pat GhcTc)]
[GenLocated SrcSpanAnnA (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
= (GenLocated SrcSpanAnnA (Pat GhcTc) -> Bool)
-> [GenLocated SrcSpanAnnA (Pat GhcTc)] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all XRec GhcTc (Pat GhcTc) -> Bool
GenLocated SrcSpanAnnA (Pat GhcTc) -> Bool
forall (p :: Pass). LPat (GhcPass p) -> Bool
is_triv_lpat (HsConPatDetails GhcTc -> [XRec GhcTc (Pat GhcTc)]
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 = Pat (GhcPass p) -> Bool
forall (p :: Pass). Pat (GhcPass p) -> Bool
is_triv_pat (Pat (GhcPass p) -> Bool)
-> (GenLocated SrcSpanAnnA (Pat (GhcPass p)) -> Pat (GhcPass p))
-> GenLocated SrcSpanAnnA (Pat (GhcPass p))
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenLocated SrcSpanAnnA (Pat (GhcPass p)) -> Pat (GhcPass p)
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) = LPat (GhcPass p) -> Bool
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 [] = Pat GhcTc -> GenLocated SrcSpanAnnA (Pat GhcTc)
forall e a. HasAnnotation e => a -> GenLocated e a
noLocA (Pat GhcTc -> GenLocated SrcSpanAnnA (Pat GhcTc))
-> Pat GhcTc -> GenLocated SrcSpanAnnA (Pat GhcTc)
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 lpats :: [XRec GhcTc (Pat GhcTc)]
lpats@(L SrcSpanAnnA
l Pat GhcTc
_:[XRec GhcTc (Pat GhcTc)]
_) = SrcSpanAnnA -> Pat GhcTc -> GenLocated SrcSpanAnnA (Pat GhcTc)
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
l (Pat GhcTc -> GenLocated SrcSpanAnnA (Pat GhcTc))
-> Pat GhcTc -> GenLocated SrcSpanAnnA (Pat GhcTc)
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 = XTuplePat GhcTc -> [XRec GhcTc (Pat GhcTc)] -> Boxity -> Pat GhcTc
forall p. XTuplePat p -> [LPat p] -> Boxity -> Pat p
TuplePat ((GenLocated SrcSpanAnnA (Pat GhcTc) -> Mult)
-> [GenLocated SrcSpanAnnA (Pat GhcTc)] -> [Mult]
forall a b. (a -> b) -> [a] -> [b]
map XRec GhcTc (Pat GhcTc) -> Mult
GenLocated SrcSpanAnnA (Pat GhcTc) -> Mult
hsLPatType [XRec GhcTc (Pat GhcTc)]
[GenLocated SrcSpanAnnA (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 ((Var -> GenLocated SrcSpanAnnA (HsExpr GhcTc))
-> [Var] -> [GenLocated SrcSpanAnnA (HsExpr GhcTc)]
forall a b. (a -> b) -> [a] -> [b]
map IdP GhcTc -> LHsExpr GhcTc
Var -> GenLocated SrcSpanAnnA (HsExpr GhcTc)
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 = ([GenLocated SrcSpanAnnA (HsExpr GhcTc)]
-> GenLocated SrcSpanAnnA (HsExpr GhcTc))
-> [GenLocated SrcSpanAnnA (HsExpr GhcTc)]
-> GenLocated SrcSpanAnnA (HsExpr GhcTc)
forall a. ([a] -> a) -> [a] -> a
mkChunkified (\[GenLocated SrcSpanAnnA (HsExpr GhcTc)]
e -> [LHsExpr GhcTc] -> XExplicitTuple GhcTc -> LHsExpr GhcTc
forall (p :: Pass).
[LHsExpr (GhcPass p)]
-> XExplicitTuple (GhcPass p) -> LHsExpr (GhcPass p)
mkLHsTupleExpr [LHsExpr GhcTc]
[GenLocated SrcSpanAnnA (HsExpr GhcTc)]
e XExplicitTuple GhcTc
NoExtField
noExtField)
mkBigLHsVarPatTupId :: [Id] -> LPat GhcTc
mkBigLHsVarPatTupId :: [Var] -> XRec GhcTc (Pat GhcTc)
mkBigLHsVarPatTupId [Var]
bs = [XRec GhcTc (Pat GhcTc)] -> XRec GhcTc (Pat GhcTc)
mkBigLHsPatTupId ((Var -> GenLocated SrcSpanAnnA (Pat GhcTc))
-> [Var] -> [GenLocated SrcSpanAnnA (Pat GhcTc)]
forall a b. (a -> b) -> [a] -> [b]
map IdP GhcTc -> XRec GhcTc (Pat GhcTc)
Var -> GenLocated SrcSpanAnnA (Pat GhcTc)
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 = ([GenLocated SrcSpanAnnA (Pat GhcTc)]
-> GenLocated SrcSpanAnnA (Pat GhcTc))
-> [GenLocated SrcSpanAnnA (Pat GhcTc)]
-> GenLocated SrcSpanAnnA (Pat GhcTc)
forall a. ([a] -> a) -> [a] -> a
mkChunkified [XRec GhcTc (Pat GhcTc)] -> XRec GhcTc (Pat GhcTc)
[GenLocated SrcSpanAnnA (Pat GhcTc)]
-> GenLocated SrcSpanAnnA (Pat GhcTc)
mkLHsPatTup
mkFailurePair :: CoreExpr
-> DsM (CoreBind,
CoreExpr)
mkFailurePair :: CoreExpr -> DsM (Bind Var, CoreExpr)
mkFailurePair CoreExpr
expr
= do { fail_fun_var <- Mult -> DsM Var
newFailLocalMDs (Mult
unboxedUnitTy HasDebugCallStack => Mult -> Mult -> Mult
Mult -> Mult -> Mult
`mkVisFunTyMany` Mult
ty)
; fail_fun_arg <- newSysLocalMDs unboxedUnitTy
; let real_arg = Var -> Var
setOneShotLambda Var
fail_fun_arg
; return (NonRec fail_fun_var (Lam real_arg expr),
App (Var fail_fun_var) unboxedUnitExpr) }
where
ty :: Mult
ty = HasDebugCallStack => CoreExpr -> Mult
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 -> (CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr
forall a. (CoreExpr -> DsM a) -> MatchResult a
MR_Fallible ((CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr)
-> (CoreExpr -> DsM CoreExpr) -> MatchResult CoreExpr
forall a b. (a -> b) -> a -> b
$ \CoreExpr
fail_expr -> do
(fail_bind, shared_failure_handler) <- CoreExpr -> DsM (Bind Var, CoreExpr)
mkFailurePair CoreExpr
fail_expr
body <- match_fn shared_failure_handler
return $ Let fail_bind body
dsHandleMonadicFailure :: HsDoFlavour -> LPat GhcTc -> Type -> MatchResult CoreExpr -> FailOperator GhcTc -> DsM CoreExpr
dsHandleMonadicFailure :: HsDoFlavour
-> XRec GhcTc (Pat GhcTc)
-> Mult
-> MatchResult CoreExpr
-> FailOperator GhcTc
-> DsM CoreExpr
dsHandleMonadicFailure HsDoFlavour
ctx XRec GhcTc (Pat GhcTc)
pat Mult
res_ty 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
dflags <- IOEnv (Env DsGblEnv DsLclEnv) DynFlags
forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags
let strict = Extension -> DynFlags -> Bool
xopt Extension
LangExt.Strict DynFlags
dflags
comps <- dsGetCompleteMatches
fail_expr <- case m_fail_op of
FailOperator GhcTc
Nothing -> do
Bool -> SDoc -> IOEnv (Env DsGblEnv DsLclEnv) ()
forall (m :: * -> *).
(HasCallStack, Applicative m) =>
Bool -> SDoc -> m ()
massertPpr (Bool -> (ConLikeP GhcTc -> Bool) -> XRec GhcTc (Pat GhcTc) -> Bool
forall (p :: Pass).
IsPass p =>
Bool -> (ConLikeP (GhcPass p) -> Bool) -> LPat (GhcPass p) -> Bool
isIrrefutableHsPat Bool
strict (DsCompleteMatches -> ConLike -> Bool
forall con.
NamedThing con =>
[CompleteMatchX con] -> ConLike -> Bool
irrefutableConLikeTc DsCompleteMatches
comps) XRec GhcTc (Pat GhcTc)
pat) (SDoc -> IOEnv (Env DsGblEnv DsLclEnv) ())
-> SDoc -> IOEnv (Env DsGblEnv DsLclEnv) ()
forall a b. (a -> b) -> a -> b
$
[Char] -> SDoc
forall doc. IsLine doc => [Char] -> doc
text [Char]
"Pattern match:" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> GenLocated SrcSpanAnnA (Pat GhcTc) -> SDoc
forall a. Outputable a => a -> SDoc
ppr XRec GhcTc (Pat GhcTc)
GenLocated SrcSpanAnnA (Pat GhcTc)
pat SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+>
[Char] -> SDoc
forall doc. IsLine doc => [Char] -> doc
text [Char]
"is failable, and fail_expr was left unset"
Var -> Mult -> SDoc -> DsM CoreExpr
mkErrorAppDs Var
pAT_ERROR_ID Mult
res_ty (HsDoFlavour -> SDoc
matchDoContextErrString HsDoFlavour
ctx)
Just SyntaxExpr GhcTc
fail_op -> do
fail_msg <- [Char] -> DsM CoreExpr
forall (m :: * -> *). MonadThings m => [Char] -> m CoreExpr
mkStringExpr (DynFlags
-> HsDoFlavour -> GenLocated SrcSpanAnnA (Pat GhcTc) -> [Char]
forall e. DynFlags -> HsDoFlavour -> LocatedA e -> [Char]
mk_fail_msg DynFlags
dflags HsDoFlavour
ctx XRec GhcTc (Pat GhcTc)
GenLocated SrcSpanAnnA (Pat GhcTc)
pat)
dsSyntaxExpr fail_op [fail_msg]
body fail_expr
mk_fail_msg :: DynFlags -> HsDoFlavour -> LocatedA e -> String
mk_fail_msg :: forall e. DynFlags -> HsDoFlavour -> LocatedA e -> [Char]
mk_fail_msg DynFlags
dflags HsDoFlavour
ctx LocatedA e
pat
= DynFlags -> SDoc -> [Char]
forall a. Outputable a => DynFlags -> a -> [Char]
showPpr DynFlags
dflags (SDoc -> [Char]) -> SDoc -> [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> SDoc
forall doc. IsLine doc => [Char] -> doc
text [Char]
"Pattern match failure in" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> HsDoFlavour -> SDoc
pprHsDoFlavour HsDoFlavour
ctx
SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> [Char] -> SDoc
forall doc. IsLine doc => [Char] -> doc
text [Char]
"at" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SrcSpan -> SDoc
forall a. Outputable a => a -> SDoc
ppr (LocatedA e -> SrcSpan
forall a e. HasLoc a => GenLocated a e -> SrcSpan
getLocA LocatedA e
pat)
mkOptTickBox :: [CoreTickish] -> CoreExpr -> CoreExpr
mkOptTickBox :: [CoreTickish] -> CoreExpr -> CoreExpr
mkOptTickBox = (CoreExpr -> [CoreTickish] -> CoreExpr)
-> [CoreTickish] -> CoreExpr -> CoreExpr
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((CoreTickish -> CoreExpr -> CoreExpr)
-> CoreExpr -> [CoreTickish] -> CoreExpr
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr CoreTickish -> CoreExpr -> CoreExpr
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
this_mod <- IOEnv (Env DsGblEnv DsLclEnv) Module
forall (m :: * -> *). HasModule m => m Module
getModule
let trueBox = CoreTickish -> CoreExpr -> CoreExpr
forall b. CoreTickish -> Expr b -> Expr b
Tick (Module -> ConTag -> CoreTickish
forall (pass :: TickishPass). Module -> ConTag -> GenTickish pass
HpcTick Module
this_mod ConTag
ixT) (Var -> CoreExpr
forall b. Var -> Expr b
Var Var
trueDataConId)
falseBox = CoreTickish -> CoreExpr -> CoreExpr
forall b. CoreTickish -> Expr b -> Expr b
Tick (Module -> ConTag -> CoreTickish
forall (pass :: TickishPass). Module -> ConTag -> GenTickish pass
HpcTick Module
this_mod ConTag
ixF) (Var -> CoreExpr
forall b. Var -> Expr b
Var Var
falseDataConId)
return $ mkIfThenElse e trueBox falseBox
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
= GenLocated SrcSpanAnnA (Pat GhcTc)
-> GenLocated SrcSpanAnnA (Pat GhcTc)
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)
GenLocated SrcSpanAnnA (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 -> l -> Pat p -> GenLocated l (Pat p)
forall l e. l -> e -> GenLocated l e
L l
l (XParPat p -> XRec p (Pat p) -> Pat p
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)
GenLocated l (Pat p)
p))
LazyPat XLazyPat p
_ XRec p (Pat p)
lp' -> XRec p (Pat p)
GenLocated l (Pat p)
lp'
BangPat XBangPat p
_ XRec p (Pat p)
_ -> GenLocated l (Pat p)
lp
Pat p
_ -> l -> Pat p -> GenLocated l (Pat p)
forall l e. l -> e -> GenLocated l e
L l
l (XBangPat p -> XRec p (Pat p) -> Pat p
forall p. XBangPat p -> LPat p -> Pat p
BangPat XBangPat p
NoExtField
noExtField XRec p (Pat p)
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 Var -> Unique -> Bool
forall a. Uniquable a => a -> Unique -> Bool
`hasKey` Unique
otherwiseIdKey
Bool -> Bool -> Bool
|| Var
v Var -> Unique -> Bool
forall a. Uniquable a => a -> Unique -> Bool
`hasKey` Var -> Unique
forall a. Uniquable a => a -> Unique
getUnique Var
trueDataConId
= (CoreExpr -> DsM CoreExpr) -> Maybe (CoreExpr -> DsM CoreExpr)
forall a. a -> Maybe a
Just CoreExpr -> DsM CoreExpr
forall a. a -> IOEnv (Env DsGblEnv DsLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return
isTrueLHsExpr (L SrcSpanAnnA
_ (XExpr (ConLikeTc ConLike
con [Var]
_ [Scaled Mult]
_)))
| ConLike
con ConLike -> Unique -> Bool
forall a. Uniquable a => a -> Unique -> Bool
`hasKey` DataCon -> Unique
forall a. Uniquable a => a -> Unique
getUnique DataCon
trueDataCon = (CoreExpr -> DsM CoreExpr) -> Maybe (CoreExpr -> DsM CoreExpr)
forall a. a -> Maybe a
Just CoreExpr -> DsM CoreExpr
forall a. a -> IOEnv (Env DsGblEnv DsLclEnv) a
forall (m :: * -> *) a. Monad m => a -> m a
return
isTrueLHsExpr (L SrcSpanAnnA
_ (XExpr (HsTick CoreTickish
tickish LHsExpr GhcTc
e)))
| Just CoreExpr -> DsM CoreExpr
ticks <- LHsExpr GhcTc -> Maybe (CoreExpr -> DsM CoreExpr)
isTrueLHsExpr LHsExpr GhcTc
e
= (CoreExpr -> DsM CoreExpr) -> Maybe (CoreExpr -> DsM CoreExpr)
forall a. a -> Maybe a
Just (\CoreExpr
x -> do wrapped <- CoreExpr -> DsM CoreExpr
ticks CoreExpr
x
return (Tick tickish wrapped))
isTrueLHsExpr (L SrcSpanAnnA
_ (XExpr (HsBinTick ConTag
ixT ConTag
_ LHsExpr GhcTc
e)))
| Just CoreExpr -> DsM CoreExpr
ticks <- LHsExpr GhcTc -> Maybe (CoreExpr -> DsM CoreExpr)
isTrueLHsExpr LHsExpr GhcTc
e
= (CoreExpr -> DsM CoreExpr) -> Maybe (CoreExpr -> DsM CoreExpr)
forall a. a -> Maybe a
Just (\CoreExpr
x -> do e <- CoreExpr -> DsM CoreExpr
ticks CoreExpr
x
this_mod <- getModule
return (Tick (HpcTick this_mod ixT) e))
isTrueLHsExpr (L SrcSpanAnnA
_ (HsPar XPar GhcTc
_ LHsExpr GhcTc
e)) = LHsExpr GhcTc -> Maybe (CoreExpr -> DsM CoreExpr)
isTrueLHsExpr LHsExpr GhcTc
e
isTrueLHsExpr LHsExpr GhcTc
_ = Maybe (CoreExpr -> DsM CoreExpr)
forall a. Maybe a
Nothing