{-# OPTIONS_HADDOCK hide #-}

{-# LANGUAGE CPP #-}
{-# LANGUAGE TemplateHaskell #-}

module Cubix.Language.Python.Parametric.Common.Cfg () where

#ifndef ONLY_ONE_LANGUAGE
import Control.Monad ( liftM, liftM2 )
import Control.Monad.State ( MonadState )

import Control.Lens ( (%=), makeLenses )

import Data.Traversable ( for )

import Data.Comp.Multi ( (:*:)(..), remA, stripA, project )

import Cubix.Language.Info

import Cubix.Language.Python.Parametric.Common.Types as C
import Cubix.Language.Python.Parametric.Full.Types as F
import Cubix.Language.Parametric.Semantics.Cfg
import Cubix.Language.Parametric.Semantics.SemanticProperties
import Cubix.Language.Parametric.Syntax as P

data PythonCfgState = PythonCfgState {
                   PythonCfgState -> Cfg MPythonSig
_pcs_cfg       :: Cfg MPythonSig
                 , PythonCfgState -> LabelGen
_pcs_labeler   :: LabelGen
                 , PythonCfgState -> LoopStack
_pcs_stack     :: LoopStack
                 , PythonCfgState -> LabelMap
_pcs_goto_labs :: LabelMap
                 }

makeLenses ''PythonCfgState

instance HasCurCfg PythonCfgState MPythonSig where cur_cfg :: Lens' PythonCfgState (Cfg MPythonSig)
cur_cfg = (Cfg MPythonSig -> f (Cfg MPythonSig))
-> PythonCfgState -> f PythonCfgState
Lens' PythonCfgState (Cfg MPythonSig)
pcs_cfg
instance HasLabelGen PythonCfgState where labelGen :: Lens' PythonCfgState LabelGen
labelGen = (LabelGen -> f LabelGen) -> PythonCfgState -> f PythonCfgState
Lens' PythonCfgState LabelGen
pcs_labeler
instance HasLoopStack PythonCfgState where loopStack :: Lens' PythonCfgState LoopStack
loopStack = (LoopStack -> f LoopStack) -> PythonCfgState -> f PythonCfgState
Lens' PythonCfgState LoopStack
pcs_stack
instance HasLabelMap PythonCfgState where labelMap :: Lens' PythonCfgState LabelMap
labelMap = (LabelMap -> f LabelMap) -> PythonCfgState -> f PythonCfgState
Lens' PythonCfgState LabelMap
pcs_goto_labs


type instance ComputationSorts MPythonSig = '[StatementL, ExprL, [BlockItemL], [StatementL]]

type instance SuspendedComputationSorts MPythonSig = '[]
type instance ContainerFunctors MPythonSig = '[PairF, ListF, MaybeF]
type instance CfgState MPythonSig = PythonCfgState


singleton :: a -> [a]
singleton :: forall a. a -> [a]
singleton = a -> [a]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return

constructCfgWhileElse ::
  ( HasLoopStack s
  , MonadState s m
  , CfgComponent gs s
  ) => TermLab gs l -> m (EnterExitPair gs h) -> m (EnterExitPair gs i) -> m (EnterExitPair gs j) -> m (EnterExitPair gs k)
constructCfgWhileElse :: forall s (m :: * -> *) (gs :: Signature) l h i j k.
(HasLoopStack s, MonadState s m, CfgComponent gs s) =>
TermLab gs l
-> m (EnterExitPair gs h)
-> m (EnterExitPair gs i)
-> m (EnterExitPair gs j)
-> m (EnterExitPair gs k)
constructCfgWhileElse TermLab gs l
t m (EnterExitPair gs h)
mExp m (EnterExitPair gs i)
mBody m (EnterExitPair gs j)
mElse = do
  CfgNode gs
enterNode     <- TermLab gs l -> CfgNodeType -> m (CfgNode gs)
forall s (fs :: Signature) (m :: * -> *) l.
(HasCurCfg s fs, HasLabelGen s, MonadState s m) =>
TermLab fs l -> CfgNodeType -> m (CfgNode fs)
addCfgNode TermLab gs l
t CfgNodeType
EnterNode
  CfgNode gs
loopEntryNode <- TermLab gs l -> CfgNodeType -> m (CfgNode gs)
forall s (fs :: Signature) (m :: * -> *) l.
(HasCurCfg s fs, HasLabelGen s, MonadState s m) =>
TermLab fs l -> CfgNodeType -> m (CfgNode fs)
addCfgNode TermLab gs l
t CfgNodeType
LoopEntryNode
  CfgNode gs
exitNode      <- TermLab gs l -> CfgNodeType -> m (CfgNode gs)
forall s (fs :: Signature) (m :: * -> *) l.
(HasCurCfg s fs, HasLabelGen s, MonadState s m) =>
TermLab fs l -> CfgNodeType -> m (CfgNode fs)
addCfgNode TermLab gs l
t CfgNodeType
ExitNode

  EnterExitPair gs Any
exp <- m (EnterExitPair gs h)
mExp m (EnterExitPair gs h)
-> (EnterExitPair gs h -> m (EnterExitPair gs Any))
-> m (EnterExitPair gs Any)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= EnterExitPair gs h -> m (EnterExitPair gs Any)
forall s (fs :: Signature) (m :: * -> *) i j.
(HasCurCfg s fs, All HTraversable fs, All HFoldable fs,
 All HFunctor fs, MonadState s m) =>
EnterExitPair fs i -> m (EnterExitPair fs j)
collapseEnterExit
  CfgNode gs -> CfgNode gs -> m ()
forall s (m :: * -> *) (fs :: Signature).
(MonadState s m, HasLoopStack s) =>
CfgNode fs -> CfgNode fs -> m ()
pushLoopNode CfgNode gs
loopEntryNode CfgNode gs
exitNode
  EnterExitPair gs i
body <- m (EnterExitPair gs i)
mBody
  m ()
forall s (m :: * -> *). (MonadState s m, HasLoopStack s) => m ()
popLoopNode

  EnterExitPair gs Any
els <- m (EnterExitPair gs j)
mElse m (EnterExitPair gs j)
-> (EnterExitPair gs j -> m (EnterExitPair gs Any))
-> m (EnterExitPair gs Any)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= EnterExitPair gs j -> m (EnterExitPair gs Any)
forall s (fs :: Signature) (m :: * -> *) i j.
(HasCurCfg s fs, All HTraversable fs, All HFoldable fs,
 All HFunctor fs, MonadState s m) =>
EnterExitPair fs i -> m (EnterExitPair fs j)
collapseEnterExit

  EnterExitPair gs Any
end <- EnterExitPair gs Any
-> EnterExitPair gs Any -> m (EnterExitPair gs Any)
forall s (fs :: Signature) (m :: * -> *) i j k.
(HasCurCfg s fs, All HTraversable fs, All HFoldable fs,
 All HFunctor fs, MonadState s m) =>
EnterExitPair fs i -> EnterExitPair fs j -> m (EnterExitPair fs k)
combineEnterExit EnterExitPair gs Any
els (CfgNode gs -> EnterExitPair gs Any
forall (fs :: Signature) l. CfgNode fs -> EnterExitPair fs l
identEnterExit CfgNode gs
exitNode)

  (Cfg gs -> Identity (Cfg gs)) -> s -> Identity s
forall c (fs :: Signature). HasCurCfg c fs => Lens' c (Cfg fs)
Lens' s (Cfg gs)
cur_cfg ((Cfg gs -> Identity (Cfg gs)) -> s -> Identity s)
-> (Cfg gs -> Cfg gs) -> m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= CfgNode gs -> CfgNode gs -> Cfg gs -> Cfg gs
forall (fs :: Signature).
CfgNode fs -> CfgNode fs -> Cfg fs -> Cfg fs
addEdge CfgNode gs
enterNode CfgNode gs
loopEntryNode
  (Cfg gs -> Identity (Cfg gs)) -> s -> Identity s
forall c (fs :: Signature). HasCurCfg c fs => Lens' c (Cfg fs)
Lens' s (Cfg gs)
cur_cfg ((Cfg gs -> Identity (Cfg gs)) -> s -> Identity s)
-> (Cfg gs -> Cfg gs) -> m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= CfgNode gs -> CfgNode gs -> Cfg gs -> Cfg gs
forall (fs :: Signature).
CfgNode fs -> CfgNode fs -> Cfg fs -> Cfg fs
addEdge CfgNode gs
loopEntryNode (EnterExitPair gs Any -> CfgNode gs
forall (fs :: Signature) l. EnterExitPair fs l -> CfgNode fs
enter EnterExitPair gs Any
exp)
  (Cfg gs -> Identity (Cfg gs)) -> s -> Identity s
forall c (fs :: Signature). HasCurCfg c fs => Lens' c (Cfg fs)
Lens' s (Cfg gs)
cur_cfg ((Cfg gs -> Identity (Cfg gs)) -> s -> Identity s)
-> (Cfg gs -> Cfg gs) -> m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= CfgNode gs -> CfgNode gs -> Cfg gs -> Cfg gs
forall (fs :: Signature).
CfgNode fs -> CfgNode fs -> Cfg fs -> Cfg fs
addEdge (EnterExitPair gs Any -> CfgNode gs
forall (fs :: Signature) l. EnterExitPair fs l -> CfgNode fs
exit EnterExitPair gs Any
exp) (EnterExitPair gs i -> CfgNode gs
forall (fs :: Signature) l. EnterExitPair fs l -> CfgNode fs
enter EnterExitPair gs i
body)
  (Cfg gs -> Identity (Cfg gs)) -> s -> Identity s
forall c (fs :: Signature). HasCurCfg c fs => Lens' c (Cfg fs)
Lens' s (Cfg gs)
cur_cfg ((Cfg gs -> Identity (Cfg gs)) -> s -> Identity s)
-> (Cfg gs -> Cfg gs) -> m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= CfgNode gs -> CfgNode gs -> Cfg gs -> Cfg gs
forall (fs :: Signature).
CfgNode fs -> CfgNode fs -> Cfg fs -> Cfg fs
addEdge (EnterExitPair gs Any -> CfgNode gs
forall (fs :: Signature) l. EnterExitPair fs l -> CfgNode fs
exit EnterExitPair gs Any
exp) (EnterExitPair gs Any -> CfgNode gs
forall (fs :: Signature) l. EnterExitPair fs l -> CfgNode fs
enter EnterExitPair gs Any
end)
  (Cfg gs -> Identity (Cfg gs)) -> s -> Identity s
forall c (fs :: Signature). HasCurCfg c fs => Lens' c (Cfg fs)
Lens' s (Cfg gs)
cur_cfg ((Cfg gs -> Identity (Cfg gs)) -> s -> Identity s)
-> (Cfg gs -> Cfg gs) -> m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= CfgNode gs -> CfgNode gs -> Cfg gs -> Cfg gs
forall (fs :: Signature).
CfgNode fs -> CfgNode fs -> Cfg fs -> Cfg fs
addEdge (EnterExitPair gs i -> CfgNode gs
forall (fs :: Signature) l. EnterExitPair fs l -> CfgNode fs
exit EnterExitPair gs i
body) CfgNode gs
loopEntryNode

  return $ CfgNode gs -> CfgNode gs -> EnterExitPair gs k
forall (fs :: Signature) l.
CfgNode fs -> CfgNode fs -> EnterExitPair fs l
EnterExitPair CfgNode gs
enterNode CfgNode gs
exitNode

-- Excludes evaluating default arguments from the CFG. I don't remember why I did this.
constructCfgFunctionDef ::
  ( CfgComponent gs s
  , MonadState s m
  ) => TermLab gs l -> m (EnterExitPair gs i) -> m (EnterExitPair gs l)
constructCfgFunctionDef :: forall (gs :: Signature) s (m :: * -> *) l i.
(CfgComponent gs s, MonadState s m) =>
TermLab gs l -> m (EnterExitPair gs i) -> m (EnterExitPair gs l)
constructCfgFunctionDef TermLab gs l
t m (EnterExitPair gs i)
body = m (EnterExitPair gs i)
body m (EnterExitPair gs i)
-> m (EnterExitPair gs l) -> m (EnterExitPair gs l)
forall a b. m a -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TermLab gs l -> m (EnterExitPair gs l)
forall s (m :: * -> *) (gs :: Signature) l.
(MonadState s m, CfgComponent gs s) =>
TermLab gs l -> m (EnterExitPair gs l)
constructCfgEmpty TermLab gs l
t

-- When developing this, I ran afoul of a GHC bug that resulted in my program segfaulting (and changed when
-- I swapped the order of my instance declarations). Luckily, a "stack clean" fixed the problem

instance {-# OVERLAPPING #-} ConstructCfg MPythonSig PythonCfgState Statement where
  constructCfg :: PreRAlg
  (Statement :&: Label)
  (Sum MPythonSig :&: Label)
  (HState PythonCfgState (EnterExitPair MPythonSig))
constructCfg ((:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' -> (AnnTerm Label MPythonSig i
t :*: While HState PythonCfgState (EnterExitPair MPythonSig) ExprL
cond HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
body HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
els)) = State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ AnnTerm Label MPythonSig i
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall s (m :: * -> *) (gs :: Signature) l h i j k.
(HasLoopStack s, MonadState s m, CfgComponent gs s) =>
TermLab gs l
-> m (EnterExitPair gs h)
-> m (EnterExitPair gs i)
-> m (EnterExitPair gs j)
-> m (EnterExitPair gs k)
constructCfgWhileElse AnnTerm Label MPythonSig i
t (HState PythonCfgState (EnterExitPair MPythonSig) ExprL
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) ExprL
cond) (HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
body) (HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
els)
  constructCfg ((:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' -> (AnnTerm Label MPythonSig i
t :*: For HState PythonCfgState (EnterExitPair MPythonSig) [ExprL]
_ HState PythonCfgState (EnterExitPair MPythonSig) ExprL
cond HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
body HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
els)) = State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ AnnTerm Label MPythonSig i
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall s (m :: * -> *) (gs :: Signature) l h i j k.
(HasLoopStack s, MonadState s m, CfgComponent gs s) =>
TermLab gs l
-> m (EnterExitPair gs h)
-> m (EnterExitPair gs i)
-> m (EnterExitPair gs j)
-> m (EnterExitPair gs k)
constructCfgWhileElse AnnTerm Label MPythonSig i
t (HState PythonCfgState (EnterExitPair MPythonSig) ExprL
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) ExprL
cond) (HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
body) (HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
els)

  constructCfg ((:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' -> AnnTerm Label MPythonSig i
t :*: Conditional HState
  PythonCfgState (EnterExitPair MPythonSig) [(ExprL, [StatementL])]
clauses HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
els) = State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ AnnTerm Label MPythonSig i
-> StateT
     PythonCfgState
     Identity
     [(EnterExitPair MPythonSig ExprL,
       EnterExitPair MPythonSig [StatementL])]
-> StateT
     PythonCfgState
     Identity
     (Maybe (EnterExitPair MPythonSig [StatementL]))
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall s (m :: * -> *) (gs :: Signature) l i j k.
(MonadState s m, CfgComponent gs s) =>
TermLab gs l
-> m [(EnterExitPair gs i, EnterExitPair gs j)]
-> m (Maybe (EnterExitPair gs k))
-> m (EnterExitPair gs l)
constructCfgIfElseIfElse AnnTerm Label MPythonSig i
t ((EnterExitPair MPythonSig [(ExprL, [StatementL])]
 -> [(EnterExitPair MPythonSig ExprL,
      EnterExitPair MPythonSig [StatementL])])
-> StateT
     PythonCfgState
     Identity
     (EnterExitPair MPythonSig [(ExprL, [StatementL])])
-> StateT
     PythonCfgState
     Identity
     [(EnterExitPair MPythonSig ExprL,
       EnterExitPair MPythonSig [StatementL])]
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM ((EnterExitPair MPythonSig (ExprL, [StatementL])
 -> (EnterExitPair MPythonSig ExprL,
     EnterExitPair MPythonSig [StatementL]))
-> [EnterExitPair MPythonSig (ExprL, [StatementL])]
-> [(EnterExitPair MPythonSig ExprL,
     EnterExitPair MPythonSig [StatementL])]
forall a b. (a -> b) -> [a] -> [b]
map EnterExitPair MPythonSig (ExprL, [StatementL])
-> (EnterExitPair MPythonSig ExprL,
    EnterExitPair MPythonSig [StatementL])
forall (fs :: Signature) a b.
(PairF :-<: fs) =>
EnterExitPair fs (a, b) -> (EnterExitPair fs a, EnterExitPair fs b)
extractEEPPair ([EnterExitPair MPythonSig (ExprL, [StatementL])]
 -> [(EnterExitPair MPythonSig ExprL,
      EnterExitPair MPythonSig [StatementL])])
-> (EnterExitPair MPythonSig [(ExprL, [StatementL])]
    -> [EnterExitPair MPythonSig (ExprL, [StatementL])])
-> EnterExitPair MPythonSig [(ExprL, [StatementL])]
-> [(EnterExitPair MPythonSig ExprL,
     EnterExitPair MPythonSig [StatementL])]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EnterExitPair MPythonSig [(ExprL, [StatementL])]
-> [EnterExitPair MPythonSig (ExprL, [StatementL])]
forall (fs :: Signature) l.
(ListF :-<: fs, Typeable l) =>
EnterExitPair fs [l] -> [EnterExitPair fs l]
extractEEPList) (StateT
   PythonCfgState
   Identity
   (EnterExitPair MPythonSig [(ExprL, [StatementL])])
 -> StateT
      PythonCfgState
      Identity
      [(EnterExitPair MPythonSig ExprL,
        EnterExitPair MPythonSig [StatementL])])
-> StateT
     PythonCfgState
     Identity
     (EnterExitPair MPythonSig [(ExprL, [StatementL])])
-> StateT
     PythonCfgState
     Identity
     [(EnterExitPair MPythonSig ExprL,
       EnterExitPair MPythonSig [StatementL])]
forall a b. (a -> b) -> a -> b
$ HState
  PythonCfgState (EnterExitPair MPythonSig) [(ExprL, [StatementL])]
-> StateT
     PythonCfgState
     Identity
     (EnterExitPair MPythonSig [(ExprL, [StatementL])])
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState
  PythonCfgState (EnterExitPair MPythonSig) [(ExprL, [StatementL])]
clauses) ((EnterExitPair MPythonSig [StatementL]
 -> Maybe (EnterExitPair MPythonSig [StatementL]))
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
-> StateT
     PythonCfgState
     Identity
     (Maybe (EnterExitPair MPythonSig [StatementL]))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM EnterExitPair MPythonSig [StatementL]
-> Maybe (EnterExitPair MPythonSig [StatementL])
forall a. a -> Maybe a
Just (StateT
   PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
 -> StateT
      PythonCfgState
      Identity
      (Maybe (EnterExitPair MPythonSig [StatementL])))
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
-> StateT
     PythonCfgState
     Identity
     (Maybe (EnterExitPair MPythonSig [StatementL]))
forall a b. (a -> b) -> a -> b
$ HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
els)

  constructCfg ((:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' -> (AnnTerm Label MPythonSig i
t :*: Return HState PythonCfgState (EnterExitPair MPythonSig) (Maybe ExprL)
e)) = State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ AnnTerm Label MPythonSig i
-> StateT
     PythonCfgState Identity (Maybe (EnterExitPair MPythonSig ExprL))
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall s (m :: * -> *) (gs :: Signature) l i.
(MonadState s m, CfgComponent gs s) =>
TermLab gs l
-> m (Maybe (EnterExitPair gs i)) -> m (EnterExitPair gs l)
constructCfgReturn AnnTerm Label MPythonSig i
t (StateT
  PythonCfgState Identity (EnterExitPair MPythonSig (Maybe ExprL))
-> StateT
     PythonCfgState Identity (Maybe (EnterExitPair MPythonSig ExprL))
forall (fs :: Signature) (m :: * -> *) l.
(All (KExtractF' Maybe) fs, Monad m) =>
m (EnterExitPair fs (Maybe l)) -> m (Maybe (EnterExitPair fs l))
extractEEPMaybe (StateT
   PythonCfgState Identity (EnterExitPair MPythonSig (Maybe ExprL))
 -> StateT
      PythonCfgState Identity (Maybe (EnterExitPair MPythonSig ExprL)))
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig (Maybe ExprL))
-> StateT
     PythonCfgState Identity (Maybe (EnterExitPair MPythonSig ExprL))
forall a b. (a -> b) -> a -> b
$ HState PythonCfgState (EnterExitPair MPythonSig) (Maybe ExprL)
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig (Maybe ExprL))
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) (Maybe ExprL)
e)
  constructCfg ((:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' -> (AnnTerm Label MPythonSig i
t :*: Try HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
body HState PythonCfgState (EnterExitPair MPythonSig) [HandlerL]
handlers HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
els HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
finally)) = State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ do
    EnterExitPair MPythonSig [StatementL]
eepBody <- HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
body
    HState PythonCfgState (EnterExitPair MPythonSig) [HandlerL]
-> State PythonCfgState (EnterExitPair MPythonSig [HandlerL])
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) [HandlerL]
handlers
    EnterExitPair MPythonSig [StatementL]
eepElse <- HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
els
    HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
finally

    EnterExitPair MPythonSig Any
eeMain <- EnterExitPair MPythonSig [StatementL]
-> EnterExitPair MPythonSig [StatementL]
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig Any)
forall s (fs :: Signature) (m :: * -> *) i j k.
(HasCurCfg s fs, All HTraversable fs, All HFoldable fs,
 All HFunctor fs, MonadState s m) =>
EnterExitPair fs i -> EnterExitPair fs j -> m (EnterExitPair fs k)
combineEnterExit EnterExitPair MPythonSig [StatementL]
eepBody EnterExitPair MPythonSig [StatementL]
eepElse

    CfgNode MPythonSig
enterNode <- AnnTerm Label MPythonSig i
-> CfgNodeType
-> StateT PythonCfgState Identity (CfgNode MPythonSig)
forall s (fs :: Signature) (m :: * -> *) l.
(HasCurCfg s fs, HasLabelGen s, MonadState s m) =>
TermLab fs l -> CfgNodeType -> m (CfgNode fs)
addCfgNode AnnTerm Label MPythonSig i
t CfgNodeType
EnterNode
    CfgNode MPythonSig
exitNode  <- AnnTerm Label MPythonSig i
-> CfgNodeType
-> StateT PythonCfgState Identity (CfgNode MPythonSig)
forall s (fs :: Signature) (m :: * -> *) l.
(HasCurCfg s fs, HasLabelGen s, MonadState s m) =>
TermLab fs l -> CfgNodeType -> m (CfgNode fs)
addCfgNode AnnTerm Label MPythonSig i
t CfgNodeType
ExitNode

    EnterExitPair MPythonSig Any
p <- EnterExitPair MPythonSig Any
-> EnterExitPair MPythonSig Any
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig Any)
forall s (fs :: Signature) (m :: * -> *) i j k.
(HasCurCfg s fs, All HTraversable fs, All HFoldable fs,
 All HFunctor fs, MonadState s m) =>
EnterExitPair fs i -> EnterExitPair fs j -> m (EnterExitPair fs k)
combineEnterExit (CfgNode MPythonSig -> EnterExitPair MPythonSig Any
forall (fs :: Signature) l. CfgNode fs -> EnterExitPair fs l
identEnterExit CfgNode MPythonSig
enterNode) EnterExitPair MPythonSig Any
eeMain
    EnterExitPair MPythonSig Any
-> EnterExitPair MPythonSig Any
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall s (fs :: Signature) (m :: * -> *) i j k.
(HasCurCfg s fs, All HTraversable fs, All HFoldable fs,
 All HFunctor fs, MonadState s m) =>
EnterExitPair fs i -> EnterExitPair fs j -> m (EnterExitPair fs k)
combineEnterExit EnterExitPair MPythonSig Any
p (CfgNode MPythonSig -> EnterExitPair MPythonSig Any
forall (fs :: Signature) l. CfgNode fs -> EnterExitPair fs l
identEnterExit CfgNode MPythonSig
exitNode)

  constructCfg ((:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' -> (AnnTerm Label MPythonSig i
t :*: Raise HState PythonCfgState (EnterExitPair MPythonSig) RaiseExprL
e)) = State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ AnnTerm Label MPythonSig i
-> StateT
     PythonCfgState
     Identity
     (Maybe (EnterExitPair MPythonSig RaiseExprL))
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall s (m :: * -> *) (gs :: Signature) l i.
(MonadState s m, CfgComponent gs s) =>
TermLab gs l
-> m (Maybe (EnterExitPair gs i)) -> m (EnterExitPair gs l)
constructCfgReturn AnnTerm Label MPythonSig i
t ((EnterExitPair MPythonSig RaiseExprL
 -> Maybe (EnterExitPair MPythonSig RaiseExprL))
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig RaiseExprL)
-> StateT
     PythonCfgState
     Identity
     (Maybe (EnterExitPair MPythonSig RaiseExprL))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM EnterExitPair MPythonSig RaiseExprL
-> Maybe (EnterExitPair MPythonSig RaiseExprL)
forall a. a -> Maybe a
Just (StateT
   PythonCfgState Identity (EnterExitPair MPythonSig RaiseExprL)
 -> StateT
      PythonCfgState
      Identity
      (Maybe (EnterExitPair MPythonSig RaiseExprL)))
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig RaiseExprL)
-> StateT
     PythonCfgState
     Identity
     (Maybe (EnterExitPair MPythonSig RaiseExprL))
forall a b. (a -> b) -> a -> b
$ HState PythonCfgState (EnterExitPair MPythonSig) RaiseExprL
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig RaiseExprL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) RaiseExprL
e)
  constructCfg ((:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' -> (AnnTerm Label MPythonSig i
t :*: Statement (HState PythonCfgState (EnterExitPair MPythonSig)) i
Break)) = State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ AnnTerm Label MPythonSig i
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall s (m :: * -> *) (gs :: Signature) l i.
(HasLoopStack s, MonadState s m, CfgComponent gs s) =>
TermLab gs l -> m (EnterExitPair gs i)
constructCfgBreak AnnTerm Label MPythonSig i
t
  constructCfg ((:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: Statement (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' -> (AnnTerm Label MPythonSig i
t :*: Statement (HState PythonCfgState (EnterExitPair MPythonSig)) i
Continue)) = State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ AnnTerm Label MPythonSig i
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall s (m :: * -> *) (gs :: Signature) l i.
(HasLoopStack s, MonadState s m, CfgComponent gs s) =>
TermLab gs l -> m (EnterExitPair gs i)
constructCfgContinue AnnTerm Label MPythonSig i
t

  constructCfg (:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
t = (:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> HState PythonCfgState (EnterExitPair MPythonSig) i
PreRAlg
  (Statement :&: Label)
  (Sum MPythonSig :&: Label)
  (HState PythonCfgState (EnterExitPair MPythonSig))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) s.
(f :-<: gs, HTraversable f, CfgComponent gs s, SortChecks gs) =>
PreRAlg
  (f :&: Label) (Sum gs :&: Label) (HState s (EnterExitPair gs))
constructCfgDefault (:&:)
  Statement
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
t

instance {-# OVERLAPPING #-} ConstructCfg MPythonSig PythonCfgState FunctionDef where
  constructCfg :: PreRAlg
  (FunctionDef :&: Label)
  (Sum MPythonSig :&: Label)
  (HState PythonCfgState (EnterExitPair MPythonSig))
constructCfg ((:&:)
  FunctionDef
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (FunctionDef (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  FunctionDef
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: FunctionDef (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' -> AnnTerm Label MPythonSig i
t :*: FunctionDef HState PythonCfgState (EnterExitPair MPythonSig) FunctionDefAttrsL
_ HState PythonCfgState (EnterExitPair MPythonSig) IdentL
_ HState
  PythonCfgState (EnterExitPair MPythonSig) [FunctionParameterL]
_ HState PythonCfgState (EnterExitPair MPythonSig) FunctionBodyL
body) = State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$
    AnnTerm Label MPythonSig i
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig FunctionBodyL)
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall (gs :: Signature) s (m :: * -> *) l i.
(CfgComponent gs s, MonadState s m) =>
TermLab gs l -> m (EnterExitPair gs i) -> m (EnterExitPair gs l)
constructCfgFunctionDef AnnTerm Label MPythonSig i
t (HState PythonCfgState (EnterExitPair MPythonSig) FunctionBodyL
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig FunctionBodyL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) FunctionBodyL
body)

-- | Control flow actually does flow through for classes; it's not a suspended computation.
-- This is a bit of a hack, used to prevent "del" statements in TAC from crossing a scope boundary,
-- so that "@foo(1+1) class Bar: pass" transforms to "t=1+1; @foo(t) class Bar: pass; del t" instead
-- of "t = 1+1; @foo(t) class Bar: del t; pass" . My overall conclusion is that we need a much
-- smarter architecture for building program transformations, but, in this case, we could do this
-- better by integrating the boundary condition of the CFG inserter with some name machinery

instance {-# OVERLAPPING #-} ConstructCfg MPythonSig PythonCfgState PyClass where
  constructCfg :: PreRAlg
  (PyClass :&: Label)
  (Sum MPythonSig :&: Label)
  (HState PythonCfgState (EnterExitPair MPythonSig))
constructCfg ((:&:)
  PyClass
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (PyClass (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  PyClass
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: PyClass (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' -> AnnTerm Label MPythonSig i
t :*: PyClass HState PythonCfgState (EnterExitPair MPythonSig) IdentL
_ HState PythonCfgState (EnterExitPair MPythonSig) [ArgumentL]
args HState PythonCfgState (EnterExitPair MPythonSig) PyBlockL
body) = State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ do
    HState PythonCfgState (EnterExitPair MPythonSig) PyBlockL
-> State PythonCfgState (EnterExitPair MPythonSig PyBlockL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) PyBlockL
body
    EnterExitPair MPythonSig Any
a <- EnterExitPair MPythonSig [ArgumentL]
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig Any)
forall s (fs :: Signature) (m :: * -> *) i j.
(HasCurCfg s fs, All HTraversable fs, All HFoldable fs,
 All HFunctor fs, MonadState s m) =>
EnterExitPair fs i -> m (EnterExitPair fs j)
collapseEnterExit (EnterExitPair MPythonSig [ArgumentL]
 -> StateT PythonCfgState Identity (EnterExitPair MPythonSig Any))
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [ArgumentL])
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig Any)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< HState PythonCfgState (EnterExitPair MPythonSig) [ArgumentL]
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [ArgumentL])
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) [ArgumentL]
args
    CfgNode MPythonSig
enterNode <- AnnTerm Label MPythonSig i
-> CfgNodeType
-> StateT PythonCfgState Identity (CfgNode MPythonSig)
forall s (fs :: Signature) (m :: * -> *) l.
(HasCurCfg s fs, HasLabelGen s, MonadState s m) =>
TermLab fs l -> CfgNodeType -> m (CfgNode fs)
addCfgNode AnnTerm Label MPythonSig i
t CfgNodeType
EnterNode
    CfgNode MPythonSig
exitNode  <- AnnTerm Label MPythonSig i
-> CfgNodeType
-> StateT PythonCfgState Identity (CfgNode MPythonSig)
forall s (fs :: Signature) (m :: * -> *) l.
(HasCurCfg s fs, HasLabelGen s, MonadState s m) =>
TermLab fs l -> CfgNodeType -> m (CfgNode fs)
addCfgNode AnnTerm Label MPythonSig i
t CfgNodeType
ExitNode

    EnterExitPair MPythonSig Any
p <- EnterExitPair MPythonSig Any
-> EnterExitPair MPythonSig Any
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig Any)
forall s (fs :: Signature) (m :: * -> *) i j k.
(HasCurCfg s fs, All HTraversable fs, All HFoldable fs,
 All HFunctor fs, MonadState s m) =>
EnterExitPair fs i -> EnterExitPair fs j -> m (EnterExitPair fs k)
combineEnterExit (CfgNode MPythonSig -> EnterExitPair MPythonSig Any
forall (fs :: Signature) l. CfgNode fs -> EnterExitPair fs l
identEnterExit CfgNode MPythonSig
enterNode) EnterExitPair MPythonSig Any
a
    EnterExitPair MPythonSig Any
-> EnterExitPair MPythonSig Any
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall s (fs :: Signature) (m :: * -> *) i j k.
(HasCurCfg s fs, All HTraversable fs, All HFoldable fs,
 All HFunctor fs, MonadState s m) =>
EnterExitPair fs i -> EnterExitPair fs j -> m (EnterExitPair fs k)
combineEnterExit EnterExitPair MPythonSig Any
p (CfgNode MPythonSig -> EnterExitPair MPythonSig Any
forall (fs :: Signature) l. CfgNode fs -> EnterExitPair fs l
identEnterExit CfgNode MPythonSig
exitNode)

instance {-# OVERLAPPING #-} ConstructCfg MPythonSig PythonCfgState PyWith where
  constructCfg :: PreRAlg
  (PyWith :&: Label)
  (Sum MPythonSig :&: Label)
  (HState PythonCfgState (EnterExitPair MPythonSig))
constructCfg ((:&:)
  PyWith
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (PyWith (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  PyWith
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: PyWith (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' -> AnnTerm Label MPythonSig i
t :*: PyWith HState PythonCfgState (EnterExitPair MPythonSig) [PyWithBinderL]
hBinders HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
hBody) = State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ do
    CfgNode MPythonSig
enterNode <- AnnTerm Label MPythonSig i
-> CfgNodeType
-> StateT PythonCfgState Identity (CfgNode MPythonSig)
forall s (fs :: Signature) (m :: * -> *) l.
(HasCurCfg s fs, HasLabelGen s, MonadState s m) =>
TermLab fs l -> CfgNodeType -> m (CfgNode fs)
addCfgNode AnnTerm Label MPythonSig i
t CfgNodeType
EnterNode

    [EnterExitPair MPythonSig PyWithBinderL]
binders <- EnterExitPair MPythonSig [PyWithBinderL]
-> [EnterExitPair MPythonSig PyWithBinderL]
forall (fs :: Signature) l.
(ListF :-<: fs, Typeable l) =>
EnterExitPair fs [l] -> [EnterExitPair fs l]
extractEEPList (EnterExitPair MPythonSig [PyWithBinderL]
 -> [EnterExitPair MPythonSig PyWithBinderL])
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [PyWithBinderL])
-> StateT
     PythonCfgState Identity [EnterExitPair MPythonSig PyWithBinderL]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HState PythonCfgState (EnterExitPair MPythonSig) [PyWithBinderL]
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [PyWithBinderL])
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) [PyWithBinderL]
hBinders
    [CfgNode MPythonSig]
midNodes <- [Int]
-> (Int -> StateT PythonCfgState Identity (CfgNode MPythonSig))
-> StateT PythonCfgState Identity [CfgNode MPythonSig]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for [Int
0..([EnterExitPair MPythonSig PyWithBinderL] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [EnterExitPair MPythonSig PyWithBinderL]
binders Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)] ((Int -> StateT PythonCfgState Identity (CfgNode MPythonSig))
 -> StateT PythonCfgState Identity [CfgNode MPythonSig])
-> (Int -> StateT PythonCfgState Identity (CfgNode MPythonSig))
-> StateT PythonCfgState Identity [CfgNode MPythonSig]
forall a b. (a -> b) -> a -> b
$ \Int
i ->
                          AnnTerm Label MPythonSig i
-> CfgNodeType
-> StateT PythonCfgState Identity (CfgNode MPythonSig)
forall s (fs :: Signature) (m :: * -> *) l.
(HasCurCfg s fs, HasLabelGen s, MonadState s m) =>
TermLab fs l -> CfgNodeType -> m (CfgNode fs)
addCfgNode AnnTerm Label MPythonSig i
t (NodeEvaluationPoint -> CfgNodeType
evalPointToNodeType (Int -> NodeEvaluationPoint
BeforeIntermediateEvalPoint Int
i))

    CfgNode MPythonSig
exitNode <- AnnTerm Label MPythonSig i
-> CfgNodeType
-> StateT PythonCfgState Identity (CfgNode MPythonSig)
forall s (fs :: Signature) (m :: * -> *) l.
(HasCurCfg s fs, HasLabelGen s, MonadState s m) =>
TermLab fs l -> CfgNodeType -> m (CfgNode fs)
addCfgNode AnnTerm Label MPythonSig i
t CfgNodeType
ExitNode

    EnterExitPair MPythonSig Any
body <- EnterExitPair MPythonSig [StatementL]
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig Any)
forall s (fs :: Signature) (m :: * -> *) i j.
(HasCurCfg s fs, All HTraversable fs, All HFoldable fs,
 All HFunctor fs, MonadState s m) =>
EnterExitPair fs i -> m (EnterExitPair fs j)
collapseEnterExit (EnterExitPair MPythonSig [StatementL]
 -> StateT PythonCfgState Identity (EnterExitPair MPythonSig Any))
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig Any)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig [StatementL])
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) [StatementL]
hBody

    (Cfg MPythonSig -> Identity (Cfg MPythonSig))
-> PythonCfgState -> Identity PythonCfgState
forall c (fs :: Signature). HasCurCfg c fs => Lens' c (Cfg fs)
Lens' PythonCfgState (Cfg MPythonSig)
cur_cfg ((Cfg MPythonSig -> Identity (Cfg MPythonSig))
 -> PythonCfgState -> Identity PythonCfgState)
-> (Cfg MPythonSig -> Cfg MPythonSig)
-> StateT PythonCfgState Identity ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= CfgNode MPythonSig
-> CfgNode MPythonSig -> Cfg MPythonSig -> Cfg MPythonSig
forall (fs :: Signature).
CfgNode fs -> CfgNode fs -> Cfg fs -> Cfg fs
addEdge CfgNode MPythonSig
enterNode ([CfgNode MPythonSig] -> CfgNode MPythonSig
forall a. HasCallStack => [a] -> a
head [CfgNode MPythonSig]
midNodes)
    (Cfg MPythonSig -> Identity (Cfg MPythonSig))
-> PythonCfgState -> Identity PythonCfgState
forall c (fs :: Signature). HasCurCfg c fs => Lens' c (Cfg fs)
Lens' PythonCfgState (Cfg MPythonSig)
cur_cfg ((Cfg MPythonSig -> Identity (Cfg MPythonSig))
 -> PythonCfgState -> Identity PythonCfgState)
-> (Cfg MPythonSig -> Cfg MPythonSig)
-> StateT PythonCfgState Identity ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= CfgNode MPythonSig
-> CfgNode MPythonSig -> Cfg MPythonSig -> Cfg MPythonSig
forall (fs :: Signature).
CfgNode fs -> CfgNode fs -> Cfg fs -> Cfg fs
addEdge (EnterExitPair MPythonSig PyWithBinderL -> CfgNode MPythonSig
forall (fs :: Signature) l. EnterExitPair fs l -> CfgNode fs
exit ([EnterExitPair MPythonSig PyWithBinderL]
-> EnterExitPair MPythonSig PyWithBinderL
forall a. HasCallStack => [a] -> a
last [EnterExitPair MPythonSig PyWithBinderL]
binders)) (EnterExitPair MPythonSig Any -> CfgNode MPythonSig
forall (fs :: Signature) l. EnterExitPair fs l -> CfgNode fs
enter EnterExitPair MPythonSig Any
body)
    (Cfg MPythonSig -> Identity (Cfg MPythonSig))
-> PythonCfgState -> Identity PythonCfgState
forall c (fs :: Signature). HasCurCfg c fs => Lens' c (Cfg fs)
Lens' PythonCfgState (Cfg MPythonSig)
cur_cfg ((Cfg MPythonSig -> Identity (Cfg MPythonSig))
 -> PythonCfgState -> Identity PythonCfgState)
-> (Cfg MPythonSig -> Cfg MPythonSig)
-> StateT PythonCfgState Identity ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= CfgNode MPythonSig
-> CfgNode MPythonSig -> Cfg MPythonSig -> Cfg MPythonSig
forall (fs :: Signature).
CfgNode fs -> CfgNode fs -> Cfg fs -> Cfg fs
addEdge (EnterExitPair MPythonSig Any -> CfgNode MPythonSig
forall (fs :: Signature) l. EnterExitPair fs l -> CfgNode fs
exit EnterExitPair MPythonSig Any
body) CfgNode MPythonSig
exitNode

    [(CfgNode MPythonSig, EnterExitPair MPythonSig PyWithBinderL)]
-> ((CfgNode MPythonSig, EnterExitPair MPythonSig PyWithBinderL)
    -> StateT PythonCfgState Identity ())
-> StateT PythonCfgState Identity [()]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for ([CfgNode MPythonSig]
-> [EnterExitPair MPythonSig PyWithBinderL]
-> [(CfgNode MPythonSig, EnterExitPair MPythonSig PyWithBinderL)]
forall a b. [a] -> [b] -> [(a, b)]
zip [CfgNode MPythonSig]
midNodes [EnterExitPair MPythonSig PyWithBinderL]
binders) (((CfgNode MPythonSig, EnterExitPair MPythonSig PyWithBinderL)
  -> StateT PythonCfgState Identity ())
 -> StateT PythonCfgState Identity [()])
-> ((CfgNode MPythonSig, EnterExitPair MPythonSig PyWithBinderL)
    -> StateT PythonCfgState Identity ())
-> StateT PythonCfgState Identity [()]
forall a b. (a -> b) -> a -> b
$ \(CfgNode MPythonSig
n, EnterExitPair MPythonSig PyWithBinderL
b) -> (Cfg MPythonSig -> Identity (Cfg MPythonSig))
-> PythonCfgState -> Identity PythonCfgState
forall c (fs :: Signature). HasCurCfg c fs => Lens' c (Cfg fs)
Lens' PythonCfgState (Cfg MPythonSig)
cur_cfg ((Cfg MPythonSig -> Identity (Cfg MPythonSig))
 -> PythonCfgState -> Identity PythonCfgState)
-> (Cfg MPythonSig -> Cfg MPythonSig)
-> StateT PythonCfgState Identity ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= CfgNode MPythonSig
-> CfgNode MPythonSig -> Cfg MPythonSig -> Cfg MPythonSig
forall (fs :: Signature).
CfgNode fs -> CfgNode fs -> Cfg fs -> Cfg fs
addEdge CfgNode MPythonSig
n (EnterExitPair MPythonSig PyWithBinderL -> CfgNode MPythonSig
forall (fs :: Signature) l. EnterExitPair fs l -> CfgNode fs
enter EnterExitPair MPythonSig PyWithBinderL
b)
    [(EnterExitPair MPythonSig PyWithBinderL, CfgNode MPythonSig)]
-> ((EnterExitPair MPythonSig PyWithBinderL, CfgNode MPythonSig)
    -> StateT PythonCfgState Identity ())
-> StateT PythonCfgState Identity [()]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for ([EnterExitPair MPythonSig PyWithBinderL]
-> [CfgNode MPythonSig]
-> [(EnterExitPair MPythonSig PyWithBinderL, CfgNode MPythonSig)]
forall a b. [a] -> [b] -> [(a, b)]
zip [EnterExitPair MPythonSig PyWithBinderL]
binders ([CfgNode MPythonSig] -> [CfgNode MPythonSig]
forall a. HasCallStack => [a] -> [a]
tail [CfgNode MPythonSig]
midNodes)) (((EnterExitPair MPythonSig PyWithBinderL, CfgNode MPythonSig)
  -> StateT PythonCfgState Identity ())
 -> StateT PythonCfgState Identity [()])
-> ((EnterExitPair MPythonSig PyWithBinderL, CfgNode MPythonSig)
    -> StateT PythonCfgState Identity ())
-> StateT PythonCfgState Identity [()]
forall a b. (a -> b) -> a -> b
$ \(EnterExitPair MPythonSig PyWithBinderL
b, CfgNode MPythonSig
n) -> (Cfg MPythonSig -> Identity (Cfg MPythonSig))
-> PythonCfgState -> Identity PythonCfgState
forall c (fs :: Signature). HasCurCfg c fs => Lens' c (Cfg fs)
Lens' PythonCfgState (Cfg MPythonSig)
cur_cfg ((Cfg MPythonSig -> Identity (Cfg MPythonSig))
 -> PythonCfgState -> Identity PythonCfgState)
-> (Cfg MPythonSig -> Cfg MPythonSig)
-> StateT PythonCfgState Identity ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= CfgNode MPythonSig
-> CfgNode MPythonSig -> Cfg MPythonSig -> Cfg MPythonSig
forall (fs :: Signature).
CfgNode fs -> CfgNode fs -> Cfg fs -> Cfg fs
addEdge (EnterExitPair MPythonSig PyWithBinderL -> CfgNode MPythonSig
forall (fs :: Signature) l. EnterExitPair fs l -> CfgNode fs
exit EnterExitPair MPythonSig PyWithBinderL
b) CfgNode MPythonSig
n

    return $ CfgNode MPythonSig
-> CfgNode MPythonSig -> EnterExitPair MPythonSig i
forall (fs :: Signature) l.
CfgNode fs -> CfgNode fs -> EnterExitPair fs l
EnterExitPair CfgNode MPythonSig
enterNode CfgNode MPythonSig
exitNode

instance {-# OVERLAPPING #-} ConstructCfg MPythonSig PythonCfgState Expr where
  constructCfg :: PreRAlg
  (Expr :&: Label)
  (Sum MPythonSig :&: Label)
  (HState PythonCfgState (EnterExitPair MPythonSig))
constructCfg t' :: (:&:)
  Expr
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
t'@((:&:)
  Expr
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> Expr
     (HFix (Sum MPythonSig :&: Label)
      :*: HState PythonCfgState (EnterExitPair MPythonSig))
     i
forall (a :: * -> *). (:&:) Expr Label a :-> Expr a
forall (s :: (* -> *) -> * -> *) (s' :: (* -> *) -> * -> *)
       (a :: * -> *).
RemA s s' =>
s a :-> s' a
remA -> (BinaryOp (HFix (Sum MPythonSig :&: Label) OpL
op :*: HState PythonCfgState (EnterExitPair MPythonSig) OpL
_) (:*:)
  (HFix (Sum MPythonSig :&: Label))
  (HState PythonCfgState (EnterExitPair MPythonSig))
  ExprL
_ (:*:)
  (HFix (Sum MPythonSig :&: Label))
  (HState PythonCfgState (EnterExitPair MPythonSig))
  ExprL
_)) = do
    let (AnnTerm Label MPythonSig i
t :*: (BinaryOp HState PythonCfgState (EnterExitPair MPythonSig) OpL
_ HState PythonCfgState (EnterExitPair MPythonSig) ExprL
el HState PythonCfgState (EnterExitPair MPythonSig) ExprL
er)) = (:&:)
  Expr
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (Expr (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  Expr
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: Expr (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' (:&:)
  Expr
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
t'
    case HFix (Sum MPythonSig :&: Label) OpL -> Op (Term MPythonSig) OpL
extractOp HFix (Sum MPythonSig :&: Label) OpL
op of
      And {} -> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ AnnTerm Label MPythonSig i
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall s (m :: * -> *) (fs :: Signature) l ls rs es.
(MonadState s m, CfgComponent fs s) =>
TermLab fs l
-> m (EnterExitPair fs ls)
-> m (EnterExitPair fs rs)
-> m (EnterExitPair fs es)
constructCfgShortCircuitingBinOp AnnTerm Label MPythonSig i
t (HState PythonCfgState (EnterExitPair MPythonSig) ExprL
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) ExprL
el) (HState PythonCfgState (EnterExitPair MPythonSig) ExprL
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) ExprL
er)
      Or {}  -> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ AnnTerm Label MPythonSig i
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall s (m :: * -> *) (fs :: Signature) l ls rs es.
(MonadState s m, CfgComponent fs s) =>
TermLab fs l
-> m (EnterExitPair fs ls)
-> m (EnterExitPair fs rs)
-> m (EnterExitPair fs es)
constructCfgShortCircuitingBinOp AnnTerm Label MPythonSig i
t (HState PythonCfgState (EnterExitPair MPythonSig) ExprL
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) ExprL
el) (HState PythonCfgState (EnterExitPair MPythonSig) ExprL
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) ExprL
er)
      Op (Term MPythonSig) OpL
_   -> (:&:)
  Expr
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> HState PythonCfgState (EnterExitPair MPythonSig) i
PreRAlg
  (Expr :&: Label)
  (Sum MPythonSig :&: Label)
  (HState PythonCfgState (EnterExitPair MPythonSig))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) s.
(f :-<: gs, HTraversable f, CfgComponent gs s, SortChecks gs) =>
PreRAlg
  (f :&: Label) (Sum gs :&: Label) (HState s (EnterExitPair gs))
constructCfgDefault (:&:)
  Expr
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
t'

    where extractOp :: MPythonTermLab OpL -> Op MPythonTerm OpL
          extractOp :: HFix (Sum MPythonSig :&: Label) OpL -> Op (Term MPythonSig) OpL
extractOp (HFix (Sum MPythonSig :&: Label) OpL
-> Cxt NoHole (Sum MPythonSig) (K ()) OpL
CxtFun (Sum MPythonSig :&: Label) (Sum MPythonSig)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *).
(RemA g f, HFunctor g) =>
CxtFun g f
stripA -> Cxt NoHole (Sum MPythonSig) (K ()) OpL
-> Maybe (Op (Term MPythonSig) OpL)
NatM Maybe (Term MPythonSig) (Op (Term MPythonSig))
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just Op (Term MPythonSig) OpL
bp) = Op (Term MPythonSig) OpL
bp

  constructCfg ((:&:)
  Expr
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (Expr (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  Expr
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: Expr (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' -> (AnnTerm Label MPythonSig i
t :*: (Lambda HState PythonCfgState (EnterExitPair MPythonSig) [ParameterL]
_ HState PythonCfgState (EnterExitPair MPythonSig) ExprL
e))) = State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ do
    AnnTerm Label MPythonSig i
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall (gs :: Signature) s (m :: * -> *) l i.
(CfgComponent gs s, MonadState s m) =>
TermLab gs l -> m (EnterExitPair gs i) -> m (EnterExitPair gs l)
constructCfgFunctionDef AnnTerm Label MPythonSig i
t (HState PythonCfgState (EnterExitPair MPythonSig) ExprL
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) ExprL
e)

  constructCfg (:&:)
  Expr
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
t = (:&:)
  Expr
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> HState PythonCfgState (EnterExitPair MPythonSig) i
PreRAlg
  (Expr :&: Label)
  (Sum MPythonSig :&: Label)
  (HState PythonCfgState (EnterExitPair MPythonSig))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) s.
(f :-<: gs, HTraversable f, CfgComponent gs s, SortChecks gs) =>
PreRAlg
  (f :&: Label) (Sum gs :&: Label) (HState s (EnterExitPair gs))
constructCfgDefault (:&:)
  Expr
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
t

instance {-# OVERLAPPING #-} ConstructCfg MPythonSig PythonCfgState PyCondExpr where
  constructCfg :: PreRAlg
  (PyCondExpr :&: Label)
  (Sum MPythonSig :&: Label)
  (HState PythonCfgState (EnterExitPair MPythonSig))
constructCfg ((:&:)
  PyCondExpr
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (PyCondExpr (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  PyCondExpr
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: PyCondExpr (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' -> (AnnTerm Label MPythonSig i
t :*: (PyCondExpr HState PythonCfgState (EnterExitPair MPythonSig) ExprL
test HState PythonCfgState (EnterExitPair MPythonSig) ExprL
succ HState PythonCfgState (EnterExitPair MPythonSig) ExprL
fail))) = State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ do
    AnnTerm Label MPythonSig i
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall s (m :: * -> *) (fs :: Signature) l ls rs es.
(MonadState s m, CfgComponent fs s) =>
TermLab fs l
-> m (EnterExitPair fs ls)
-> m (EnterExitPair fs rs)
-> m (EnterExitPair fs es)
-> m (EnterExitPair fs es)
constructCfgCondOp AnnTerm Label MPythonSig i
t (HState PythonCfgState (EnterExitPair MPythonSig) ExprL
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) ExprL
test) (HState PythonCfgState (EnterExitPair MPythonSig) ExprL
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) ExprL
succ) (HState PythonCfgState (EnterExitPair MPythonSig) i
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) i
HState PythonCfgState (EnterExitPair MPythonSig) ExprL
fail)

instance {-# OVERLAPPING #-} ConstructCfg MPythonSig PythonCfgState PyComprehension where
  constructCfg :: PreRAlg
  (PyComprehension :&: Label)
  (Sum MPythonSig :&: Label)
  (HState PythonCfgState (EnterExitPair MPythonSig))
constructCfg ((:&:)
  PyComprehension
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (PyComprehension
        (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  PyComprehension
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: PyComprehension
           (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' -> (AnnTerm Label MPythonSig i
t :*: (PyComprehensionFor Bool
_ HState PythonCfgState (EnterExitPair MPythonSig) [ExprL]
_ HState PythonCfgState (EnterExitPair MPythonSig) ExprL
e HState PythonCfgState (EnterExitPair MPythonSig) PyComprehensionL
body))) = State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ do
    AnnTerm Label MPythonSig i
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig PyComprehensionL)
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall s (m :: * -> *) (gs :: Signature) l i j k.
(HasLoopStack s, MonadState s m, CfgComponent gs s) =>
TermLab gs l
-> m (EnterExitPair gs i)
-> m (EnterExitPair gs j)
-> m (EnterExitPair gs k)
constructCfgWhile AnnTerm Label MPythonSig i
t (HState PythonCfgState (EnterExitPair MPythonSig) ExprL
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) ExprL
e) (HState PythonCfgState (EnterExitPair MPythonSig) PyComprehensionL
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig PyComprehensionL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) PyComprehensionL
body)
  constructCfg ((:&:)
  PyComprehension
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> (:*:)
     (HFix (Sum MPythonSig :&: Label))
     (PyComprehension
        (HState PythonCfgState (EnterExitPair MPythonSig)))
     i
(:&:)
  PyComprehension
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
:-> (HFix (Sum MPythonSig :&: Label)
     :*: PyComprehension
           (HState PythonCfgState (EnterExitPair MPythonSig)))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) a (t :: * -> *).
(HFunctor f, f :-<: gs) =>
(:&:) f a (AnnTerm a gs :*: t) :-> (AnnTerm a gs :*: f t)
collapseFProd' -> (AnnTerm Label MPythonSig i
t :*: (PyComprehensionIf HState PythonCfgState (EnterExitPair MPythonSig) ExprL
cond HState PythonCfgState (EnterExitPair MPythonSig) PyComprehensionL
body))) = State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall s (f :: * -> *) l. State s (f l) -> HState s f l
HState (State PythonCfgState (EnterExitPair MPythonSig i)
 -> HState PythonCfgState (EnterExitPair MPythonSig) i)
-> State PythonCfgState (EnterExitPair MPythonSig i)
-> HState PythonCfgState (EnterExitPair MPythonSig) i
forall a b. (a -> b) -> a -> b
$ do
     AnnTerm Label MPythonSig i
-> StateT
     PythonCfgState
     Identity
     [(EnterExitPair MPythonSig ExprL,
       EnterExitPair MPythonSig PyComprehensionL)]
-> StateT
     PythonCfgState Identity (Maybe (EnterExitPair MPythonSig Any))
-> State PythonCfgState (EnterExitPair MPythonSig i)
forall s (m :: * -> *) (gs :: Signature) l i j k.
(MonadState s m, CfgComponent gs s) =>
TermLab gs l
-> m [(EnterExitPair gs i, EnterExitPair gs j)]
-> m (Maybe (EnterExitPair gs k))
-> m (EnterExitPair gs l)
constructCfgIfElseIfElse AnnTerm Label MPythonSig i
t (((EnterExitPair MPythonSig ExprL,
  EnterExitPair MPythonSig PyComprehensionL)
 -> [(EnterExitPair MPythonSig ExprL,
      EnterExitPair MPythonSig PyComprehensionL)])
-> StateT
     PythonCfgState
     Identity
     (EnterExitPair MPythonSig ExprL,
      EnterExitPair MPythonSig PyComprehensionL)
-> StateT
     PythonCfgState
     Identity
     [(EnterExitPair MPythonSig ExprL,
       EnterExitPair MPythonSig PyComprehensionL)]
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (EnterExitPair MPythonSig ExprL,
 EnterExitPair MPythonSig PyComprehensionL)
-> [(EnterExitPair MPythonSig ExprL,
     EnterExitPair MPythonSig PyComprehensionL)]
forall a. a -> [a]
singleton (StateT
   PythonCfgState
   Identity
   (EnterExitPair MPythonSig ExprL,
    EnterExitPair MPythonSig PyComprehensionL)
 -> StateT
      PythonCfgState
      Identity
      [(EnterExitPair MPythonSig ExprL,
        EnterExitPair MPythonSig PyComprehensionL)])
-> StateT
     PythonCfgState
     Identity
     (EnterExitPair MPythonSig ExprL,
      EnterExitPair MPythonSig PyComprehensionL)
-> StateT
     PythonCfgState
     Identity
     [(EnterExitPair MPythonSig ExprL,
       EnterExitPair MPythonSig PyComprehensionL)]
forall a b. (a -> b) -> a -> b
$ (EnterExitPair MPythonSig ExprL
 -> EnterExitPair MPythonSig PyComprehensionL
 -> (EnterExitPair MPythonSig ExprL,
     EnterExitPair MPythonSig PyComprehensionL))
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig PyComprehensionL)
-> StateT
     PythonCfgState
     Identity
     (EnterExitPair MPythonSig ExprL,
      EnterExitPair MPythonSig PyComprehensionL)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,) (HState PythonCfgState (EnterExitPair MPythonSig) ExprL
-> StateT PythonCfgState Identity (EnterExitPair MPythonSig ExprL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) ExprL
cond) (HState PythonCfgState (EnterExitPair MPythonSig) PyComprehensionL
-> StateT
     PythonCfgState Identity (EnterExitPair MPythonSig PyComprehensionL)
forall s (f :: * -> *) l. HState s f l -> State s (f l)
unHState HState PythonCfgState (EnterExitPair MPythonSig) PyComprehensionL
body)) (Maybe (EnterExitPair MPythonSig Any)
-> StateT
     PythonCfgState Identity (Maybe (EnterExitPair MPythonSig Any))
forall a. a -> StateT PythonCfgState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (EnterExitPair MPythonSig Any)
forall a. Maybe a
Nothing)
  constructCfg (:&:)
  PyComprehension
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
t = (:&:)
  PyComprehension
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
-> HState PythonCfgState (EnterExitPair MPythonSig) i
PreRAlg
  (PyComprehension :&: Label)
  (Sum MPythonSig :&: Label)
  (HState PythonCfgState (EnterExitPair MPythonSig))
forall (f :: (* -> *) -> * -> *) (gs :: Signature) s.
(f :-<: gs, HTraversable f, CfgComponent gs s, SortChecks gs) =>
PreRAlg
  (f :&: Label) (Sum gs :&: Label) (HState s (EnterExitPair gs))
constructCfgDefault (:&:)
  PyComprehension
  Label
  (HFix (Sum MPythonSig :&: Label)
   :*: HState PythonCfgState (EnterExitPair MPythonSig))
  i
t

instance CfgInitState MPythonSig where
  cfgInitState :: Proxy MPythonSig -> CfgState MPythonSig
cfgInitState Proxy MPythonSig
_ = Cfg MPythonSig
-> LabelGen -> LoopStack -> LabelMap -> PythonCfgState
PythonCfgState Cfg MPythonSig
forall (fs :: Signature). Cfg fs
emptyCfg (() -> LabelGen
unsafeMkConcurrentSupplyLabelGen ()) LoopStack
emptyLoopStack LabelMap
emptyLabelMap
#endif