{- -----------------------------------------------------------------------------
Copyright 2019-2023 Kevin P. Barry

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
----------------------------------------------------------------------------- -}

-- Author: Kevin P. Barry [ta0kira@gmail.com]

{-# LANGUAGE CPP #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE Safe #-}
{-# LANGUAGE ScopedTypeVariables #-}

module Compilation.CompilerState (
  CleanupBlock(..),
  CompilerContext(..),
  CompiledData(..),
  CompilerState,
  DeferVariable(..),
  LoopSetup(..),
  JumpType(..),
  MemberValue(..),
  ReturnVariable(..),
  UsedVariable(..),
  addDeferred,
  autoSelfType,
  branchDeferred,
  checkDeferred,
  concatM,
  csAddRequired,
  csAddTrace,
  csAddUsed,
  csAddVariable,
  csAllFilters,
  csCanForward,
  csCheckValueInit,
  csCheckVariableInit,
  csClearOutput,
  csCurrentScope,
  csDelegateArgs,
  csExprLookup,
  csGetCategoryFunction,
  csGetCleanup,
  csGetLoop,
  csGetNoTrace,
  csGetOutput,
  csGetParamScope,
  csGetTestsOnly,
  csGetTypeFunction,
  csGetVariable,
  csInheritDeferred,
  csInheritStatic,
  csInheritUsed,
  csIsNamedReturns,
  csIsUnreachable,
  csPrimNamedReturns,
  csPushCleanup,
  csRegisterReturn,
  csReleaseExprMacro,
  csReserveExprMacro,
  csResolver,
  csSameType,
  csSelfType,
  csSetDeferred,
  csSetHidden,
  csSetJumpType,
  csSetNoTrace,
  csSetReadOnly,
  csStartCleanup,
  csStartLoop,
  csUpdateAssigned,
  csWrite,
  emptyCleanupBlock,
  emptyDeferred,
  followDeferred,
  getCleanContext,
  removeDeferred,
  runDataCompiler,
) where

import Control.Monad.Trans (lift)
import Control.Monad.Trans.State (StateT(..),execStateT,get,put)
import Data.Functor
import Prelude hiding (foldr)
import qualified Data.Map as Map
import qualified Data.Set as Set

#if MIN_VERSION_base(4,11,0)
#else
import Data.Semigroup
#endif

import Base.CompilerError
import Base.GeneralType
import Base.Positional
import Types.DefinedCategory
import Types.Procedure
import Types.TypeCategory
import Types.TypeInstance


type CompilerState a m = StateT a m

class (Functor m, Monad m) => CompilerContext c m s a | a -> c s where
  ccCurrentScope :: a -> m SymbolScope
  ccResolver :: a -> m AnyTypeResolver
  ccSameType :: a -> TypeInstance -> m Bool
  ccSelfType :: a -> m TypeInstance
  ccAllFilters :: a -> m ParamFilters
  ccGetParamScope :: a -> ParamName -> m SymbolScope
  ccAddRequired :: a -> Set.Set CategoryName -> m a
  ccGetRequired :: a -> m (Set.Set CategoryName)
  ccGetCategoryFunction :: a -> [c] -> Maybe CategoryName -> FunctionName -> m (ScopedFunction c)
  ccGetTypeFunction :: a -> [c] -> Maybe GeneralInstance -> FunctionName -> m (ScopedFunction c)
  ccCheckValueInit :: a -> [c] -> TypeInstance -> ExpressionType -> m ()
  ccGetVariable :: a -> UsedVariable c -> m (VariableValue c)
  ccAddVariable :: a -> UsedVariable c -> VariableValue c -> m a
  ccSetDeferred :: a -> UsedVariable c -> m a
  ccSetReadOnly :: a -> UsedVariable c -> m a
  ccSetHidden :: a -> UsedVariable c -> m a
  ccCheckVariableInit :: a -> [UsedVariable c] -> m ()
  ccWrite :: a -> s -> m a
  ccGetOutput :: a -> m s
  ccClearOutput :: a -> m a
  ccUpdateAssigned :: a -> VariableName -> m a
  ccAddUsed :: a -> UsedVariable c -> m a
  ccInheritUsed :: a -> a -> m a
  ccInheritStatic :: a -> [a] -> m a
  ccInheritDeferred :: a -> DeferVariable c -> m a
  ccRegisterReturn :: a -> [c] -> Maybe ExpressionType -> m a
  ccPrimNamedReturns :: a -> m [ReturnVariable]
  ccIsUnreachable :: a -> m Bool
  ccIsNamedReturns :: a -> m Bool
  ccSetJumpType :: a -> [c] -> JumpType -> m a
  ccStartLoop :: a -> LoopSetup s -> m a
  ccGetLoop :: a -> m (LoopSetup s)
  ccStartCleanup :: a -> [c] -> m a
  ccPushCleanup :: a -> a -> m a
  ccGetCleanup :: a -> JumpType -> m (CleanupBlock c s)
  ccExprLookup :: a -> [c] -> MacroName -> m (Expression c)
  ccReserveExprMacro :: a -> [c] -> MacroName -> m a
  ccReleaseExprMacro :: a -> [c] -> MacroName -> m a
  ccSetNoTrace :: a -> Bool -> m a
  ccGetNoTrace :: a -> m Bool
  ccGetTestsOnly :: a -> m Bool
  ccAddTrace :: a -> String -> m a
  ccGetTraces :: a -> m [String]
  ccCanForward :: a -> [ParamName] -> [VariableName] -> m Bool
  ccDelegateArgs :: a -> m (Positional (Maybe (CallArgLabel c), VariableName))

data MemberValue c =
  MemberValue {
    forall c. MemberValue c -> [c]
mvContext :: [c],
    forall c. MemberValue c -> VariableName
mvName :: VariableName,
    forall c. MemberValue c -> ValueType
mvType :: ValueType
  }
  deriving (Int -> MemberValue c -> ShowS
forall c. Show c => Int -> MemberValue c -> ShowS
forall c. Show c => [MemberValue c] -> ShowS
forall c. Show c => MemberValue c -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MemberValue c] -> ShowS
$cshowList :: forall c. Show c => [MemberValue c] -> ShowS
show :: MemberValue c -> String
$cshow :: forall c. Show c => MemberValue c -> String
showsPrec :: Int -> MemberValue c -> ShowS
$cshowsPrec :: forall c. Show c => Int -> MemberValue c -> ShowS
Show)

data ReturnVariable =
  ReturnVariable {
    ReturnVariable -> Int
rvIndex :: Int,
    ReturnVariable -> VariableName
rvName :: VariableName,
    ReturnVariable -> ValueType
rvType :: ValueType
  }
  deriving (Int -> ReturnVariable -> ShowS
[ReturnVariable] -> ShowS
ReturnVariable -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ReturnVariable] -> ShowS
$cshowList :: [ReturnVariable] -> ShowS
show :: ReturnVariable -> String
$cshow :: ReturnVariable -> String
showsPrec :: Int -> ReturnVariable -> ShowS
$cshowsPrec :: Int -> ReturnVariable -> ShowS
Show)

data LoopSetup s =
  LoopSetup {
    forall s. LoopSetup s -> s
lsUpdate :: s
  } |
  NotInLoop

data UsedVariable c =
  UsedVariable {
    forall c. UsedVariable c -> [c]
uvContext :: [c],
    forall c. UsedVariable c -> VariableName
uvName :: VariableName
  }
  deriving (UsedVariable c -> UsedVariable c -> Bool
forall c. Eq c => UsedVariable c -> UsedVariable c -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UsedVariable c -> UsedVariable c -> Bool
$c/= :: forall c. Eq c => UsedVariable c -> UsedVariable c -> Bool
== :: UsedVariable c -> UsedVariable c -> Bool
$c== :: forall c. Eq c => UsedVariable c -> UsedVariable c -> Bool
Eq,UsedVariable c -> UsedVariable c -> Bool
UsedVariable c -> UsedVariable c -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {c}. Ord c => Eq (UsedVariable c)
forall c. Ord c => UsedVariable c -> UsedVariable c -> Bool
forall c. Ord c => UsedVariable c -> UsedVariable c -> Ordering
forall c.
Ord c =>
UsedVariable c -> UsedVariable c -> UsedVariable c
min :: UsedVariable c -> UsedVariable c -> UsedVariable c
$cmin :: forall c.
Ord c =>
UsedVariable c -> UsedVariable c -> UsedVariable c
max :: UsedVariable c -> UsedVariable c -> UsedVariable c
$cmax :: forall c.
Ord c =>
UsedVariable c -> UsedVariable c -> UsedVariable c
>= :: UsedVariable c -> UsedVariable c -> Bool
$c>= :: forall c. Ord c => UsedVariable c -> UsedVariable c -> Bool
> :: UsedVariable c -> UsedVariable c -> Bool
$c> :: forall c. Ord c => UsedVariable c -> UsedVariable c -> Bool
<= :: UsedVariable c -> UsedVariable c -> Bool
$c<= :: forall c. Ord c => UsedVariable c -> UsedVariable c -> Bool
< :: UsedVariable c -> UsedVariable c -> Bool
$c< :: forall c. Ord c => UsedVariable c -> UsedVariable c -> Bool
compare :: UsedVariable c -> UsedVariable c -> Ordering
$ccompare :: forall c. Ord c => UsedVariable c -> UsedVariable c -> Ordering
Ord,Int -> UsedVariable c -> ShowS
forall c. Show c => Int -> UsedVariable c -> ShowS
forall c. Show c => [UsedVariable c] -> ShowS
forall c. Show c => UsedVariable c -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UsedVariable c] -> ShowS
$cshowList :: forall c. Show c => [UsedVariable c] -> ShowS
show :: UsedVariable c -> String
$cshow :: forall c. Show c => UsedVariable c -> String
showsPrec :: Int -> UsedVariable c -> ShowS
$cshowsPrec :: forall c. Show c => Int -> UsedVariable c -> ShowS
Show)

data CleanupBlock c s =
  CleanupBlock {
    forall c s. CleanupBlock c s -> s
csCleanup :: s,
    forall c s. CleanupBlock c s -> DeferVariable c
csDeferred :: DeferVariable c,
    forall c s. CleanupBlock c s -> [UsedVariable c]
csUsesVars :: [UsedVariable c],
    forall c s. CleanupBlock c s -> JumpType
csJumpType :: JumpType,
    forall c s. CleanupBlock c s -> Set CategoryName
csRequires :: Set.Set CategoryName
  }
  deriving (Int -> CleanupBlock c s -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall c s. (Show s, Show c) => Int -> CleanupBlock c s -> ShowS
forall c s. (Show s, Show c) => [CleanupBlock c s] -> ShowS
forall c s. (Show s, Show c) => CleanupBlock c s -> String
showList :: [CleanupBlock c s] -> ShowS
$cshowList :: forall c s. (Show s, Show c) => [CleanupBlock c s] -> ShowS
show :: CleanupBlock c s -> String
$cshow :: forall c s. (Show s, Show c) => CleanupBlock c s -> String
showsPrec :: Int -> CleanupBlock c s -> ShowS
$cshowsPrec :: forall c s. (Show s, Show c) => Int -> CleanupBlock c s -> ShowS
Show)

emptyCleanupBlock :: Monoid s => CleanupBlock c s
emptyCleanupBlock :: forall s c. Monoid s => CleanupBlock c s
emptyCleanupBlock = forall c s.
s
-> DeferVariable c
-> [UsedVariable c]
-> JumpType
-> Set CategoryName
-> CleanupBlock c s
CleanupBlock forall a. Monoid a => a
mempty forall c. DeferVariable c
emptyDeferred [] JumpType
NextStatement forall a. Set a
Set.empty

data JumpType =
  NextStatement |
  JumpContinue |
  JumpBreak |
  JumpReturn |
  JumpImmediateExit |
  JumpMax  -- Max value for use as initial state in folds.
  deriving (JumpType -> JumpType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JumpType -> JumpType -> Bool
$c/= :: JumpType -> JumpType -> Bool
== :: JumpType -> JumpType -> Bool
$c== :: JumpType -> JumpType -> Bool
Eq,Eq JumpType
JumpType -> JumpType -> Bool
JumpType -> JumpType -> Ordering
JumpType -> JumpType -> JumpType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: JumpType -> JumpType -> JumpType
$cmin :: JumpType -> JumpType -> JumpType
max :: JumpType -> JumpType -> JumpType
$cmax :: JumpType -> JumpType -> JumpType
>= :: JumpType -> JumpType -> Bool
$c>= :: JumpType -> JumpType -> Bool
> :: JumpType -> JumpType -> Bool
$c> :: JumpType -> JumpType -> Bool
<= :: JumpType -> JumpType -> Bool
$c<= :: JumpType -> JumpType -> Bool
< :: JumpType -> JumpType -> Bool
$c< :: JumpType -> JumpType -> Bool
compare :: JumpType -> JumpType -> Ordering
$ccompare :: JumpType -> JumpType -> Ordering
Ord,Int -> JumpType -> ShowS
[JumpType] -> ShowS
JumpType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JumpType] -> ShowS
$cshowList :: [JumpType] -> ShowS
show :: JumpType -> String
$cshow :: JumpType -> String
showsPrec :: Int -> JumpType -> ShowS
$cshowsPrec :: Int -> JumpType -> ShowS
Show)

newtype DeferVariable c =
  DeferVariable {
    forall c. DeferVariable c -> Map VariableName (PassedValue c)
dvDeferred :: Map.Map VariableName (PassedValue c)
  }
  deriving (Int -> DeferVariable c -> ShowS
forall c. Show c => Int -> DeferVariable c -> ShowS
forall c. Show c => [DeferVariable c] -> ShowS
forall c. Show c => DeferVariable c -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeferVariable c] -> ShowS
$cshowList :: forall c. Show c => [DeferVariable c] -> ShowS
show :: DeferVariable c -> String
$cshow :: forall c. Show c => DeferVariable c -> String
showsPrec :: Int -> DeferVariable c -> ShowS
$cshowsPrec :: forall c. Show c => Int -> DeferVariable c -> ShowS
Show)

branchDeferred :: [DeferVariable c] -> DeferVariable c
branchDeferred :: forall c. [DeferVariable c] -> DeferVariable c
branchDeferred = forall c. Map VariableName (PassedValue c) -> DeferVariable c
DeferVariable forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) k a.
(Foldable f, Ord k) =>
f (Map k a) -> Map k a
Map.unions forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall c. DeferVariable c -> Map VariableName (PassedValue c)
dvDeferred

followDeferred :: DeferVariable c -> DeferVariable c -> DeferVariable c
followDeferred :: forall c. DeferVariable c -> DeferVariable c -> DeferVariable c
followDeferred (DeferVariable Map VariableName (PassedValue c)
xa) (DeferVariable Map VariableName (PassedValue c)
ya) = forall c. Map VariableName (PassedValue c) -> DeferVariable c
DeferVariable forall a b. (a -> b) -> a -> b
$ forall k a b. Ord k => Map k a -> Map k b -> Map k a
Map.intersection Map VariableName (PassedValue c)
xa Map VariableName (PassedValue c)
ya

emptyDeferred :: DeferVariable c
emptyDeferred :: forall c. DeferVariable c
emptyDeferred = forall c. Map VariableName (PassedValue c) -> DeferVariable c
DeferVariable forall k a. Map k a
Map.empty

checkDeferred :: VariableName -> DeferVariable c -> Bool
checkDeferred :: forall c. VariableName -> DeferVariable c -> Bool
checkDeferred VariableName
n (DeferVariable Map VariableName (PassedValue c)
va) = VariableName
n forall k a. Ord k => k -> Map k a -> Bool
`Map.member` Map VariableName (PassedValue c)
va

removeDeferred :: VariableName -> DeferVariable c -> DeferVariable c
removeDeferred :: forall c. VariableName -> DeferVariable c -> DeferVariable c
removeDeferred VariableName
n (DeferVariable Map VariableName (PassedValue c)
va) = forall c. Map VariableName (PassedValue c) -> DeferVariable c
DeferVariable (VariableName
n forall k a. Ord k => k -> Map k a -> Map k a
`Map.delete` Map VariableName (PassedValue c)
va)

addDeferred :: VariableName -> PassedValue c -> DeferVariable c -> DeferVariable c
addDeferred :: forall c.
VariableName -> PassedValue c -> DeferVariable c -> DeferVariable c
addDeferred VariableName
n PassedValue c
v (DeferVariable Map VariableName (PassedValue c)
va) = forall c. Map VariableName (PassedValue c) -> DeferVariable c
DeferVariable (forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert VariableName
n PassedValue c
v Map VariableName (PassedValue c)
va)

csCurrentScope :: CompilerContext c m s a => CompilerState a m SymbolScope
csCurrentScope :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m SymbolScope
csCurrentScope = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m SymbolScope
ccCurrentScope forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csResolver :: CompilerContext c m s a => CompilerState a m AnyTypeResolver
csResolver :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m AnyTypeResolver
csResolver = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m AnyTypeResolver
ccResolver forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csSameType :: CompilerContext c m s a => TypeInstance -> CompilerState a m Bool
csSameType :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
TypeInstance -> CompilerState a m Bool
csSameType TypeInstance
t = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> TypeInstance -> m Bool
ccSameType a
x TypeInstance
t) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csSelfType :: CompilerContext c m s a => CompilerState a m TypeInstance
csSelfType :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m TypeInstance
csSelfType = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m TypeInstance
ccSelfType forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csAllFilters :: CompilerContext c m s a => CompilerState a m ParamFilters
csAllFilters :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m ParamFilters
csAllFilters = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m ParamFilters
ccAllFilters forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csGetParamScope :: CompilerContext c m s a => ParamName -> CompilerState a m SymbolScope
csGetParamScope :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
ParamName -> CompilerState a m SymbolScope
csGetParamScope ParamName
n = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> ParamName -> m SymbolScope
ccGetParamScope a
x ParamName
n) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csAddRequired :: CompilerContext c m s a => Set.Set CategoryName -> CompilerState a m ()
csAddRequired :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
Set CategoryName -> CompilerState a m ()
csAddRequired Set CategoryName
ns = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> Set CategoryName -> m a
ccAddRequired a
x Set CategoryName
ns) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csGetRequired :: CompilerContext c m s a => CompilerState a m (Set.Set CategoryName)
csGetRequired :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m (Set CategoryName)
csGetRequired = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m (Set CategoryName)
ccGetRequired forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csGetCategoryFunction :: CompilerContext c m s a =>
  [c] -> Maybe CategoryName -> FunctionName -> CompilerState a m (ScopedFunction c)
csGetCategoryFunction :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c]
-> Maybe CategoryName
-> FunctionName
-> CompilerState a m (ScopedFunction c)
csGetCategoryFunction [c]
c Maybe CategoryName
t FunctionName
n = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a
-> [c]
-> Maybe CategoryName
-> FunctionName
-> m (ScopedFunction c)
ccGetCategoryFunction a
x [c]
c Maybe CategoryName
t FunctionName
n) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csGetTypeFunction :: CompilerContext c m s a =>
  [c] -> Maybe GeneralInstance -> FunctionName -> CompilerState a m (ScopedFunction c)
csGetTypeFunction :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c]
-> Maybe GeneralInstance
-> FunctionName
-> CompilerState a m (ScopedFunction c)
csGetTypeFunction [c]
c Maybe GeneralInstance
t FunctionName
n = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a
-> [c]
-> Maybe GeneralInstance
-> FunctionName
-> m (ScopedFunction c)
ccGetTypeFunction a
x [c]
c Maybe GeneralInstance
t FunctionName
n) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csCheckValueInit :: CompilerContext c m s a =>
  [c] -> TypeInstance -> ExpressionType -> CompilerState a m ()
csCheckValueInit :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c] -> TypeInstance -> ExpressionType -> CompilerState a m ()
csCheckValueInit [c]
c TypeInstance
t ExpressionType
as = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [c] -> TypeInstance -> ExpressionType -> m ()
ccCheckValueInit a
x [c]
c TypeInstance
t ExpressionType
as) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csGetVariable :: CompilerContext c m s a =>
  UsedVariable c -> CompilerState a m (VariableValue c)
csGetVariable :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
UsedVariable c -> CompilerState a m (VariableValue c)
csGetVariable UsedVariable c
v = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> UsedVariable c -> m (VariableValue c)
ccGetVariable a
x UsedVariable c
v) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csAddVariable :: CompilerContext c m s a =>
  UsedVariable c -> VariableValue c -> CompilerState a m ()
csAddVariable :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
UsedVariable c -> VariableValue c -> CompilerState a m ()
csAddVariable UsedVariable c
v VariableValue c
t = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> UsedVariable c -> VariableValue c -> m a
ccAddVariable a
x UsedVariable c
v VariableValue c
t) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csSetDeferred :: CompilerContext c m s a =>
  UsedVariable c -> CompilerState a m ()
csSetDeferred :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
UsedVariable c -> CompilerState a m ()
csSetDeferred UsedVariable c
v = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> UsedVariable c -> m a
ccSetDeferred a
x UsedVariable c
v) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csSetReadOnly :: CompilerContext c m s a =>
  UsedVariable c -> CompilerState a m ()
csSetReadOnly :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
UsedVariable c -> CompilerState a m ()
csSetReadOnly UsedVariable c
v = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> UsedVariable c -> m a
ccSetReadOnly a
x UsedVariable c
v) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csSetHidden :: CompilerContext c m s a =>
  UsedVariable c -> CompilerState a m ()
csSetHidden :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
UsedVariable c -> CompilerState a m ()
csSetHidden UsedVariable c
v = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> UsedVariable c -> m a
ccSetHidden a
x UsedVariable c
v) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csCheckVariableInit :: CompilerContext c m s a =>
  [UsedVariable c] -> CompilerState a m ()
csCheckVariableInit :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[UsedVariable c] -> CompilerState a m ()
csCheckVariableInit [UsedVariable c]
vs = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [UsedVariable c] -> m ()
ccCheckVariableInit a
x [UsedVariable c]
vs) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csWrite :: CompilerContext c m s a => s -> CompilerState a m ()
csWrite :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
s -> CompilerState a m ()
csWrite s
o = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> s -> m a
ccWrite a
x s
o) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csClearOutput :: CompilerContext c m s a => CompilerState a m ()
csClearOutput :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m ()
csClearOutput = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m a
ccClearOutput a
x) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csGetOutput :: CompilerContext c m s a => CompilerState a m s
csGetOutput :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m s
csGetOutput = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m s
ccGetOutput forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csUpdateAssigned :: CompilerContext c m s a => VariableName -> CompilerState a m ()
csUpdateAssigned :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
VariableName -> CompilerState a m ()
csUpdateAssigned VariableName
n = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> VariableName -> m a
ccUpdateAssigned a
x VariableName
n) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csAddUsed :: CompilerContext c m s a => UsedVariable c -> CompilerState a m ()
csAddUsed :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
UsedVariable c -> CompilerState a m ()
csAddUsed UsedVariable c
n = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> UsedVariable c -> m a
ccAddUsed a
x UsedVariable c
n) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csInheritUsed :: CompilerContext c m s a => a -> CompilerState a m ()
csInheritUsed :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> CompilerState a m ()
csInheritUsed a
c = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> a -> m a
ccInheritUsed a
x a
c) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csInheritStatic :: CompilerContext c m s a => [a] -> CompilerState a m ()
csInheritStatic :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[a] -> CompilerState a m ()
csInheritStatic [a]
xs = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [a] -> m a
ccInheritStatic a
x [a]
xs) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csInheritDeferred :: CompilerContext c m s a => DeferVariable c -> CompilerState a m ()
csInheritDeferred :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
DeferVariable c -> CompilerState a m ()
csInheritDeferred DeferVariable c
xs = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> DeferVariable c -> m a
ccInheritDeferred a
x DeferVariable c
xs) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csRegisterReturn :: CompilerContext c m s a =>
  [c] -> Maybe ExpressionType -> CompilerState a m ()
csRegisterReturn :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c] -> Maybe ExpressionType -> CompilerState a m ()
csRegisterReturn [c]
c Maybe ExpressionType
rs = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [c] -> Maybe ExpressionType -> m a
ccRegisterReturn a
x [c]
c Maybe ExpressionType
rs) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csPrimNamedReturns :: CompilerContext c m s a => CompilerState a m [ReturnVariable]
csPrimNamedReturns :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m [ReturnVariable]
csPrimNamedReturns = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m [ReturnVariable]
ccPrimNamedReturns forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csIsUnreachable :: CompilerContext c m s a => CompilerState a m Bool
csIsUnreachable :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m Bool
csIsUnreachable = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m Bool
ccIsUnreachable forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csIsNamedReturns :: CompilerContext c m s a => CompilerState a m Bool
csIsNamedReturns :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m Bool
csIsNamedReturns = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m Bool
ccIsNamedReturns forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csSetJumpType :: CompilerContext c m s a => [c] -> JumpType -> CompilerState a m ()
csSetJumpType :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c] -> JumpType -> CompilerState a m ()
csSetJumpType [c]
c JumpType
j = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [c] -> JumpType -> m a
ccSetJumpType a
x [c]
c JumpType
j) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csStartLoop :: CompilerContext c m s a => LoopSetup s -> CompilerState a m ()
csStartLoop :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
LoopSetup s -> CompilerState a m ()
csStartLoop LoopSetup s
l = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> LoopSetup s -> m a
ccStartLoop a
x LoopSetup s
l) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csStartCleanup :: CompilerContext c m s a => [c] -> CompilerState a m ()
csStartCleanup :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c] -> CompilerState a m ()
csStartCleanup [c]
c = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [c] -> m a
ccStartCleanup a
x [c]
c) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csGetLoop :: CompilerContext c m s a => CompilerState a m (LoopSetup s)
csGetLoop :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m (LoopSetup s)
csGetLoop = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m (LoopSetup s)
ccGetLoop forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csPushCleanup :: CompilerContext c m s a => a -> CompilerState a m ()
csPushCleanup :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> CompilerState a m ()
csPushCleanup a
l = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> a -> m a
ccPushCleanup a
x a
l) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csGetCleanup :: CompilerContext c m s a => JumpType -> CompilerState a m (CleanupBlock c s)
csGetCleanup :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
JumpType -> CompilerState a m (CleanupBlock c s)
csGetCleanup JumpType
j = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> JumpType -> m (CleanupBlock c s)
ccGetCleanup a
x JumpType
j) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csExprLookup :: CompilerContext c m s a => [c] -> MacroName -> CompilerState a m (Expression c)
csExprLookup :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c] -> MacroName -> CompilerState a m (Expression c)
csExprLookup [c]
c MacroName
n = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [c] -> MacroName -> m (Expression c)
ccExprLookup a
x [c]
c MacroName
n) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csReserveExprMacro :: CompilerContext c m s a => [c] -> MacroName -> CompilerState a m ()
csReserveExprMacro :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c] -> MacroName -> CompilerState a m ()
csReserveExprMacro [c]
c MacroName
n = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [c] -> MacroName -> m a
ccReserveExprMacro a
x [c]
c MacroName
n) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csReleaseExprMacro :: CompilerContext c m s a => [c] -> MacroName -> CompilerState a m ()
csReleaseExprMacro :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[c] -> MacroName -> CompilerState a m ()
csReleaseExprMacro [c]
c MacroName
n = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [c] -> MacroName -> m a
ccReleaseExprMacro a
x [c]
c MacroName
n) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csSetNoTrace :: CompilerContext c m s a => Bool -> CompilerState a m ()
csSetNoTrace :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
Bool -> CompilerState a m ()
csSetNoTrace Bool
t = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> Bool -> m a
ccSetNoTrace a
x Bool
t) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csGetNoTrace :: CompilerContext c m s a => CompilerState a m Bool
csGetNoTrace :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m Bool
csGetNoTrace = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m Bool
ccGetNoTrace forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csGetTestsOnly :: CompilerContext c m s a => CompilerState a m Bool
csGetTestsOnly :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m Bool
csGetTestsOnly = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m Bool
ccGetTestsOnly forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csAddTrace :: CompilerContext c m s a => String -> CompilerState a m ()
csAddTrace :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
String -> CompilerState a m ()
csAddTrace String
t = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> String -> m a
ccAddTrace a
x String
t) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put

csCanForward :: CompilerContext c m s a => [ParamName] -> [VariableName] -> CompilerState a m Bool
csCanForward :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
[ParamName] -> [VariableName] -> CompilerState a m Bool
csCanForward [ParamName]
ps [VariableName]
as = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> [ParamName] -> [VariableName] -> m Bool
ccCanForward a
x [ParamName]
ps [VariableName]
as) forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

csDelegateArgs :: CompilerContext c m s a => CompilerState a m (Positional (Maybe (CallArgLabel c), VariableName))
csDelegateArgs :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState
  a m (Positional (Maybe (CallArgLabel c), VariableName))
csDelegateArgs = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m (Positional (Maybe (CallArgLabel c), VariableName))
ccDelegateArgs forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

data CompiledData s =
  CompiledData {
    forall s. CompiledData s -> Set CategoryName
cdRequired :: Set.Set CategoryName,
    forall s. CompiledData s -> Set String
cdTraces :: Set.Set String,
    forall s. CompiledData s -> s
cdOutput :: s
  }

instance Semigroup s => Semigroup (CompiledData s) where
  (CompiledData Set CategoryName
r1 Set String
t1 s
s1) <> :: CompiledData s -> CompiledData s -> CompiledData s
<> (CompiledData Set CategoryName
r2 Set String
t2 s
s2) =
    forall s. Set CategoryName -> Set String -> s -> CompiledData s
CompiledData (Set CategoryName
r1 forall a. Ord a => Set a -> Set a -> Set a
`Set.union` Set CategoryName
r2) (Set String
t1 forall a. Ord a => Set a -> Set a -> Set a
`Set.union` Set String
t2) (s
s1 forall a. Semigroup a => a -> a -> a
<> s
s2)

instance (Semigroup s, Monoid s) => Monoid (CompiledData s) where
  mempty :: CompiledData s
mempty = forall s. Set CategoryName -> Set String -> s -> CompiledData s
CompiledData forall a. Set a
Set.empty forall a. Set a
Set.empty forall a. Monoid a => a
mempty
  mappend :: CompiledData s -> CompiledData s -> CompiledData s
mappend = forall a. Semigroup a => a -> a -> a
(<>)

runDataCompiler :: CompilerContext c m s a =>
  CompilerState a m b -> a -> m (CompiledData s)
runDataCompiler :: forall c (m :: * -> *) s a b.
CompilerContext c m s a =>
CompilerState a m b -> a -> m (CompiledData s)
runDataCompiler CompilerState a m b
x a
ctx = do
  a
ctx' <- forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m s
execStateT CompilerState a m b
x a
ctx
  Set CategoryName
required <- forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m (Set CategoryName)
ccGetRequired a
ctx'
  s
output <- forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m s
ccGetOutput a
ctx'
  [String]
traces <- forall c (m :: * -> *) s a.
CompilerContext c m s a =>
a -> m [String]
ccGetTraces a
ctx'
  forall (m :: * -> *) a. Monad m => a -> m a
return CompiledData {
      cdRequired :: Set CategoryName
cdRequired = Set CategoryName
required,
      cdTraces :: Set String
cdTraces = forall a. Ord a => [a] -> Set a
Set.fromList [String]
traces,
      cdOutput :: s
cdOutput = s
output
    }

concatM :: (Semigroup s, Monoid s, CollectErrorsM m) => [m (CompiledData s)] -> m (CompiledData s)
concatM :: forall s (m :: * -> *).
(Semigroup s, Monoid s, CollectErrorsM m) =>
[m (CompiledData s)] -> m (CompiledData s)
concatM = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Monoid a => [a] -> a
mconcat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
collectAllM

getCleanContext :: CompilerContext c m s a => CompilerState a m a
getCleanContext :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m a
getCleanContext = forall (m :: * -> *) s. Monad m => StateT s m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall c (m :: * -> *) s a. CompilerContext c m s a => a -> m a
ccClearOutput

autoSelfType :: CompilerContext c m s a => CompilerState a m GeneralInstance
autoSelfType :: forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m GeneralInstance
autoSelfType = do
  SymbolScope
scope <- forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m SymbolScope
csCurrentScope
  case SymbolScope
scope of
       SymbolScope
CategoryScope -> forall (m :: * -> *) a. Monad m => a -> m a
return GeneralInstance
selfType
       SymbolScope
_ -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. (Eq a, Ord a) => a -> GeneralType a
singleType forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeInstance -> TypeInstanceOrParam
JustTypeInstance) forall c (m :: * -> *) s a.
CompilerContext c m s a =>
CompilerState a m TypeInstance
csSelfType