{-# OPTIONS_GHC -Wno-orphans #-}

-- |
-- Common data structures and functions supporting analysis of the AST.
module Language.Fortran.Analysis
  ( initAnalysis, stripAnalysis, Analysis(..), Constant(..)
  , varName, srcName, lvVarName, lvSrcName, isNamedExpression
  , genVar, puName, puSrcName, blockRhsExprs, rhsExprs
  , ModEnv, NameType(..), IDType(..), ConstructType(..)
  , lhsExprs, isLExpr, allVars, analyseAllLhsVars, analyseAllLhsVars1, allLhsVars
  , blockVarUses, blockVarDefs
  , BB, BBNode, BBGr(..), bbgrMap, bbgrMapM, bbgrEmpty
  , TransFunc, TransFuncM )
where

import Prelude hiding (exp)
import Language.Fortran.Util.Position (SrcSpan)
import Data.Generics.Uniplate.Data
import Data.Data
import Language.Fortran.AST
import Language.Fortran.LValue
import Data.Graph.Inductive (Node, empty)
import Data.Graph.Inductive.PatriciaTree (Gr)
import Text.PrettyPrint.GenericPretty
import Text.PrettyPrint hiding (empty, isEmpty)
import qualified Data.Map.Strict as M
import Data.Maybe
import Data.Binary
import Language.Fortran.Intrinsics (getIntrinsicDefsUses, allIntrinsics)
import Data.Bifunctor (first)

import           Language.Fortran.Analysis.SemanticTypes (SemType(..))

--------------------------------------------------

-- | Basic block
type BB a = [Block a]

-- | Basic block graph.
data BBGr a = BBGr { forall a. BBGr a -> Gr (BB a) ()
bbgrGr :: Gr (BB a) () -- ^ the underlying graph
                   , forall a. BBGr a -> [Int]
bbgrEntries :: [Node]  -- ^ the entry node(s)
                   , forall a. BBGr a -> [Int]
bbgrExits :: [Node]    -- ^ the exit node(s)
                   }
  deriving (BBGr a -> DataType
BBGr a -> Constr
forall {a}. Data a => Typeable (BBGr a)
forall a. Data a => BBGr a -> DataType
forall a. Data a => BBGr a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> BBGr a -> BBGr a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> BBGr a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> BBGr a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BBGr a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BBGr a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> BBGr a -> m (BBGr a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> BBGr a -> m (BBGr a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BBGr a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BBGr a -> c (BBGr a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BBGr a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BBGr a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BBGr a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BBGr a -> c (BBGr a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (BBGr a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BBGr a -> m (BBGr a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> BBGr a -> m (BBGr a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BBGr a -> m (BBGr a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> BBGr a -> m (BBGr a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BBGr a -> m (BBGr a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> BBGr a -> m (BBGr a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BBGr a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> BBGr a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> BBGr a -> [u]
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> BBGr a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BBGr a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BBGr a -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BBGr a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BBGr a -> r
gmapT :: (forall b. Data b => b -> b) -> BBGr a -> BBGr a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> BBGr a -> BBGr a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BBGr a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BBGr a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (BBGr a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BBGr a))
dataTypeOf :: BBGr a -> DataType
$cdataTypeOf :: forall a. Data a => BBGr a -> DataType
toConstr :: BBGr a -> Constr
$ctoConstr :: forall a. Data a => BBGr a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BBGr a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BBGr a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BBGr a -> c (BBGr a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BBGr a -> c (BBGr a)
Data, Int -> BBGr a -> ShowS
forall a. Show a => Int -> BBGr a -> ShowS
forall a. Show a => [BBGr a] -> ShowS
forall a. Show a => BBGr a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BBGr a] -> ShowS
$cshowList :: forall a. Show a => [BBGr a] -> ShowS
show :: BBGr a -> String
$cshow :: forall a. Show a => BBGr a -> String
showsPrec :: Int -> BBGr a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> BBGr a -> ShowS
Show, BBGr a -> BBGr a -> Bool
forall a. Eq a => BBGr a -> BBGr a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BBGr a -> BBGr a -> Bool
$c/= :: forall a. Eq a => BBGr a -> BBGr a -> Bool
== :: BBGr a -> BBGr a -> Bool
$c== :: forall a. Eq a => BBGr a -> BBGr a -> Bool
Eq, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (BBGr a) x -> BBGr a
forall a x. BBGr a -> Rep (BBGr a) x
$cto :: forall a x. Rep (BBGr a) x -> BBGr a
$cfrom :: forall a x. BBGr a -> Rep (BBGr a) x
Generic)

type BBNode = Int

-- | Empty basic block graph
bbgrEmpty :: BBGr a
bbgrEmpty :: forall a. BBGr a
bbgrEmpty = forall a. Gr (BB a) () -> [Int] -> [Int] -> BBGr a
BBGr forall (gr :: * -> * -> *) a b. Graph gr => gr a b
empty [] []

-- | Call function on the underlying graph
bbgrMap :: (Gr (BB a) () -> Gr (BB b) ()) -> BBGr a -> BBGr b
bbgrMap :: forall a b. (Gr (BB a) () -> Gr (BB b) ()) -> BBGr a -> BBGr b
bbgrMap Gr (BB a) () -> Gr (BB b) ()
f BBGr a
bb = BBGr a
bb { bbgrGr :: Gr (BB b) ()
bbgrGr = Gr (BB a) () -> Gr (BB b) ()
f (forall a. BBGr a -> Gr (BB a) ()
bbgrGr BBGr a
bb) }

-- | Monadically call function on the underlying graph
bbgrMapM :: Monad m => (Gr (BB a1) () -> m (Gr (BB a2) ())) -> BBGr a1 -> m (BBGr a2)
bbgrMapM :: forall (m :: * -> *) a1 a2.
Monad m =>
(Gr (BB a1) () -> m (Gr (BB a2) ())) -> BBGr a1 -> m (BBGr a2)
bbgrMapM Gr (BB a1) () -> m (Gr (BB a2) ())
f BBGr a1
bb = do
  Gr (BB a2) ()
x <- Gr (BB a1) () -> m (Gr (BB a2) ())
f (forall a. BBGr a -> Gr (BB a) ()
bbgrGr BBGr a1
bb)
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ BBGr a1
bb { bbgrGr :: Gr (BB a2) ()
bbgrGr = Gr (BB a2) ()
x }

-- Allow graphs to reside inside of annotations
deriving instance (Typeable a, Typeable b) => Typeable (Gr a b)
instance (Typeable a, Typeable b) => Data (Gr a b) where
    gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Gr a b -> c (Gr a b)
gfoldl forall d b. Data d => c (d -> b) -> d -> c b
_k forall g. g -> c g
z   = forall g. g -> c g
z -- make graphs opaque to Uniplate
    toConstr :: Gr a b -> Constr
toConstr Gr a b
_    = forall a. HasCallStack => String -> a
error String
"toConstr"
    gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Gr a b)
gunfold forall b r. Data b => c (b -> r) -> c r
_ forall r. r -> c r
_   = forall a. HasCallStack => String -> a
error String
"gunfold"
    dataTypeOf :: Gr a b -> DataType
dataTypeOf Gr a b
_  = String -> DataType
mkNoRepType String
"Gr"

--------------------------------------------------

-- | The type of "transformBi"-family functions
type TransFunc f g a = (f (Analysis a) -> f (Analysis a)) -> g (Analysis a) -> g (Analysis a)
-- | The type of "transformBiM"-family functions
type TransFuncM m f g a = (f (Analysis a) -> m (f (Analysis a))) -> g (Analysis a) -> m (g (Analysis a))

-- Describe a Fortran name as either a program unit or a variable.
data NameType = NTSubprogram | NTVariable | NTIntrinsic deriving (Int -> NameType -> ShowS
[NameType] -> ShowS
NameType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NameType] -> ShowS
$cshowList :: [NameType] -> ShowS
show :: NameType -> String
$cshow :: NameType -> String
showsPrec :: Int -> NameType -> ShowS
$cshowsPrec :: Int -> NameType -> ShowS
Show, NameType -> NameType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NameType -> NameType -> Bool
$c/= :: NameType -> NameType -> Bool
== :: NameType -> NameType -> Bool
$c== :: NameType -> NameType -> Bool
Eq, Eq NameType
NameType -> NameType -> Bool
NameType -> NameType -> Ordering
NameType -> NameType -> NameType
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 :: NameType -> NameType -> NameType
$cmin :: NameType -> NameType -> NameType
max :: NameType -> NameType -> NameType
$cmax :: NameType -> NameType -> NameType
>= :: NameType -> NameType -> Bool
$c>= :: NameType -> NameType -> Bool
> :: NameType -> NameType -> Bool
$c> :: NameType -> NameType -> Bool
<= :: NameType -> NameType -> Bool
$c<= :: NameType -> NameType -> Bool
< :: NameType -> NameType -> Bool
$c< :: NameType -> NameType -> Bool
compare :: NameType -> NameType -> Ordering
$ccompare :: NameType -> NameType -> Ordering
Ord, Typeable NameType
NameType -> DataType
NameType -> Constr
(forall b. Data b => b -> b) -> NameType -> NameType
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> NameType -> u
forall u. (forall d. Data d => d -> u) -> NameType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameType -> c NameType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameType)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameType -> m NameType
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameType -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> NameType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NameType -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameType -> r
gmapT :: (forall b. Data b => b -> b) -> NameType -> NameType
$cgmapT :: (forall b. Data b => b -> b) -> NameType -> NameType
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameType)
dataTypeOf :: NameType -> DataType
$cdataTypeOf :: NameType -> DataType
toConstr :: NameType -> Constr
$ctoConstr :: NameType -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameType -> c NameType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameType -> c NameType
Data, Typeable, forall x. Rep NameType x -> NameType
forall x. NameType -> Rep NameType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NameType x -> NameType
$cfrom :: forall x. NameType -> Rep NameType x
Generic)
instance Binary NameType
instance Out NameType

-- Module environments are associations between source name and
-- (unique name, name type) in a specific module.
type ModEnv = M.Map String (String, NameType)

-- Fortran data types are broken down into 'construct type' and 'base type'.
data ConstructType =
    CTFunction
  | CTSubroutine
  | CTExternal
  | CTVariable
  | CTArray [(Maybe Int, Maybe Int)]
  | CTParameter
  | CTIntrinsic
  deriving (Eq ConstructType
ConstructType -> ConstructType -> Bool
ConstructType -> ConstructType -> Ordering
ConstructType -> ConstructType -> ConstructType
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 :: ConstructType -> ConstructType -> ConstructType
$cmin :: ConstructType -> ConstructType -> ConstructType
max :: ConstructType -> ConstructType -> ConstructType
$cmax :: ConstructType -> ConstructType -> ConstructType
>= :: ConstructType -> ConstructType -> Bool
$c>= :: ConstructType -> ConstructType -> Bool
> :: ConstructType -> ConstructType -> Bool
$c> :: ConstructType -> ConstructType -> Bool
<= :: ConstructType -> ConstructType -> Bool
$c<= :: ConstructType -> ConstructType -> Bool
< :: ConstructType -> ConstructType -> Bool
$c< :: ConstructType -> ConstructType -> Bool
compare :: ConstructType -> ConstructType -> Ordering
$ccompare :: ConstructType -> ConstructType -> Ordering
Ord, ConstructType -> ConstructType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstructType -> ConstructType -> Bool
$c/= :: ConstructType -> ConstructType -> Bool
== :: ConstructType -> ConstructType -> Bool
$c== :: ConstructType -> ConstructType -> Bool
Eq, Int -> ConstructType -> ShowS
[ConstructType] -> ShowS
ConstructType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstructType] -> ShowS
$cshowList :: [ConstructType] -> ShowS
show :: ConstructType -> String
$cshow :: ConstructType -> String
showsPrec :: Int -> ConstructType -> ShowS
$cshowsPrec :: Int -> ConstructType -> ShowS
Show, Typeable ConstructType
ConstructType -> DataType
ConstructType -> Constr
(forall b. Data b => b -> b) -> ConstructType -> ConstructType
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ConstructType -> u
forall u. (forall d. Data d => d -> u) -> ConstructType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstructType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstructType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConstructType -> m ConstructType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstructType -> m ConstructType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstructType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstructType -> c ConstructType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConstructType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ConstructType)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstructType -> m ConstructType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstructType -> m ConstructType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstructType -> m ConstructType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstructType -> m ConstructType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConstructType -> m ConstructType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConstructType -> m ConstructType
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConstructType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConstructType -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ConstructType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ConstructType -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstructType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstructType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstructType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstructType -> r
gmapT :: (forall b. Data b => b -> b) -> ConstructType -> ConstructType
$cgmapT :: (forall b. Data b => b -> b) -> ConstructType -> ConstructType
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ConstructType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ConstructType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConstructType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConstructType)
dataTypeOf :: ConstructType -> DataType
$cdataTypeOf :: ConstructType -> DataType
toConstr :: ConstructType -> Constr
$ctoConstr :: ConstructType -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstructType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstructType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstructType -> c ConstructType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstructType -> c ConstructType
Data, Typeable, forall x. Rep ConstructType x -> ConstructType
forall x. ConstructType -> Rep ConstructType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ConstructType x -> ConstructType
$cfrom :: forall x. ConstructType -> Rep ConstructType x
Generic)

instance Out ConstructType
instance Binary ConstructType

data IDType = IDType
  { IDType -> Maybe SemType
idVType :: Maybe SemType
  , IDType -> Maybe ConstructType
idCType :: Maybe ConstructType }
  deriving (Eq IDType
IDType -> IDType -> Bool
IDType -> IDType -> Ordering
IDType -> IDType -> IDType
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 :: IDType -> IDType -> IDType
$cmin :: IDType -> IDType -> IDType
max :: IDType -> IDType -> IDType
$cmax :: IDType -> IDType -> IDType
>= :: IDType -> IDType -> Bool
$c>= :: IDType -> IDType -> Bool
> :: IDType -> IDType -> Bool
$c> :: IDType -> IDType -> Bool
<= :: IDType -> IDType -> Bool
$c<= :: IDType -> IDType -> Bool
< :: IDType -> IDType -> Bool
$c< :: IDType -> IDType -> Bool
compare :: IDType -> IDType -> Ordering
$ccompare :: IDType -> IDType -> Ordering
Ord, IDType -> IDType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IDType -> IDType -> Bool
$c/= :: IDType -> IDType -> Bool
== :: IDType -> IDType -> Bool
$c== :: IDType -> IDType -> Bool
Eq, Int -> IDType -> ShowS
[IDType] -> ShowS
IDType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IDType] -> ShowS
$cshowList :: [IDType] -> ShowS
show :: IDType -> String
$cshow :: IDType -> String
showsPrec :: Int -> IDType -> ShowS
$cshowsPrec :: Int -> IDType -> ShowS
Show, Typeable IDType
IDType -> DataType
IDType -> Constr
(forall b. Data b => b -> b) -> IDType -> IDType
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> IDType -> u
forall u. (forall d. Data d => d -> u) -> IDType -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IDType -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IDType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IDType -> m IDType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IDType -> m IDType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IDType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IDType -> c IDType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IDType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IDType)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IDType -> m IDType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IDType -> m IDType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IDType -> m IDType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IDType -> m IDType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IDType -> m IDType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IDType -> m IDType
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IDType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IDType -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> IDType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IDType -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IDType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IDType -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IDType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IDType -> r
gmapT :: (forall b. Data b => b -> b) -> IDType -> IDType
$cgmapT :: (forall b. Data b => b -> b) -> IDType -> IDType
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IDType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IDType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IDType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IDType)
dataTypeOf :: IDType -> DataType
$cdataTypeOf :: IDType -> DataType
toConstr :: IDType -> Constr
$ctoConstr :: IDType -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IDType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IDType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IDType -> c IDType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IDType -> c IDType
Data, Typeable, forall x. Rep IDType x -> IDType
forall x. IDType -> Rep IDType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep IDType x -> IDType
$cfrom :: forall x. IDType -> Rep IDType x
Generic)

instance Out IDType
instance Binary IDType

-- | Information about potential / actual constant expressions.
data Constant
  = ConstInt Integer            -- ^ interpreted integer
  | ConstUninterpInt String     -- ^ uninterpreted integer
  | ConstUninterpReal String    -- ^ uninterpreted real
  | ConstBinary BinaryOp Constant Constant -- ^ binary operation on potential constants
  | ConstUnary UnaryOp Constant -- ^ unary operation on potential constants
  deriving (Int -> Constant -> ShowS
[Constant] -> ShowS
Constant -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Constant] -> ShowS
$cshowList :: [Constant] -> ShowS
show :: Constant -> String
$cshow :: Constant -> String
showsPrec :: Int -> Constant -> ShowS
$cshowsPrec :: Int -> Constant -> ShowS
Show, Eq Constant
Constant -> Constant -> Bool
Constant -> Constant -> Ordering
Constant -> Constant -> Constant
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 :: Constant -> Constant -> Constant
$cmin :: Constant -> Constant -> Constant
max :: Constant -> Constant -> Constant
$cmax :: Constant -> Constant -> Constant
>= :: Constant -> Constant -> Bool
$c>= :: Constant -> Constant -> Bool
> :: Constant -> Constant -> Bool
$c> :: Constant -> Constant -> Bool
<= :: Constant -> Constant -> Bool
$c<= :: Constant -> Constant -> Bool
< :: Constant -> Constant -> Bool
$c< :: Constant -> Constant -> Bool
compare :: Constant -> Constant -> Ordering
$ccompare :: Constant -> Constant -> Ordering
Ord, Constant -> Constant -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Constant -> Constant -> Bool
$c/= :: Constant -> Constant -> Bool
== :: Constant -> Constant -> Bool
$c== :: Constant -> Constant -> Bool
Eq, Typeable, forall x. Rep Constant x -> Constant
forall x. Constant -> Rep Constant x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Constant x -> Constant
$cfrom :: forall x. Constant -> Rep Constant x
Generic, Typeable Constant
Constant -> DataType
Constant -> Constr
(forall b. Data b => b -> b) -> Constant -> Constant
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Constant -> u
forall u. (forall d. Data d => d -> u) -> Constant -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Constant -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Constant -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Constant -> m Constant
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constant -> m Constant
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Constant
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Constant -> c Constant
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Constant)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Constant)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constant -> m Constant
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constant -> m Constant
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constant -> m Constant
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Constant -> m Constant
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Constant -> m Constant
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Constant -> m Constant
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Constant -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Constant -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Constant -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Constant -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Constant -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Constant -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Constant -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Constant -> r
gmapT :: (forall b. Data b => b -> b) -> Constant -> Constant
$cgmapT :: (forall b. Data b => b -> b) -> Constant -> Constant
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Constant)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Constant)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Constant)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Constant)
dataTypeOf :: Constant -> DataType
$cdataTypeOf :: Constant -> DataType
toConstr :: Constant -> Constr
$ctoConstr :: Constant -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Constant
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Constant
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Constant -> c Constant
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Constant -> c Constant
Data)

instance Out Constant
instance Binary Constant

data Analysis a = Analysis
  { forall a. Analysis a -> a
prevAnnotation :: a -- ^ original annotation
  , forall a. Analysis a -> Maybe String
uniqueName     :: Maybe String -- ^ unique name for function/variable, after variable renaming phase
  , forall a. Analysis a -> Maybe String
sourceName     :: Maybe String -- ^ original name for function/variable found in source text
  , forall a. Analysis a -> Maybe (BBGr (Analysis a))
bBlocks        :: Maybe (BBGr (Analysis a)) -- ^ basic block graph
  , forall a. Analysis a -> Maybe Int
insLabel       :: Maybe Int -- ^ unique number for each block during dataflow analysis
  , forall a. Analysis a -> Maybe ModEnv
moduleEnv      :: Maybe ModEnv
  , forall a. Analysis a -> Maybe IDType
idType         :: Maybe IDType
  , forall a. Analysis a -> [String]
allLhsVarsAnn  :: [Name]
  , forall a. Analysis a -> Maybe Constant
constExp       :: Maybe Constant
  }
  deriving (Analysis a -> DataType
Analysis a -> Constr
forall {a}. Data a => Typeable (Analysis a)
forall a. Data a => Analysis a -> DataType
forall a. Data a => Analysis a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Analysis a -> Analysis a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Analysis a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Analysis a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Analysis a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Analysis a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Analysis a -> m (Analysis a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Analysis a -> m (Analysis a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Analysis a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Analysis a -> c (Analysis a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Analysis a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Analysis a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Analysis a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Analysis a -> c (Analysis a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Analysis a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Analysis a -> m (Analysis a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Analysis a -> m (Analysis a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Analysis a -> m (Analysis a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Analysis a -> m (Analysis a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Analysis a -> m (Analysis a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Analysis a -> m (Analysis a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Analysis a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Analysis a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Analysis a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Analysis a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Analysis a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Analysis a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Analysis a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Analysis a -> r
gmapT :: (forall b. Data b => b -> b) -> Analysis a -> Analysis a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Analysis a -> Analysis a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Analysis a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Analysis a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Analysis a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Analysis a))
dataTypeOf :: Analysis a -> DataType
$cdataTypeOf :: forall a. Data a => Analysis a -> DataType
toConstr :: Analysis a -> Constr
$ctoConstr :: forall a. Data a => Analysis a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Analysis a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Analysis a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Analysis a -> c (Analysis a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Analysis a -> c (Analysis a)
Data, Int -> Analysis a -> ShowS
forall a. Show a => Int -> Analysis a -> ShowS
forall a. Show a => [Analysis a] -> ShowS
forall a. Show a => Analysis a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Analysis a] -> ShowS
$cshowList :: forall a. Show a => [Analysis a] -> ShowS
show :: Analysis a -> String
$cshow :: forall a. Show a => Analysis a -> String
showsPrec :: Int -> Analysis a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Analysis a -> ShowS
Show, Analysis a -> Analysis a -> Bool
forall a. Eq a => Analysis a -> Analysis a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Analysis a -> Analysis a -> Bool
$c/= :: forall a. Eq a => Analysis a -> Analysis a -> Bool
== :: Analysis a -> Analysis a -> Bool
$c== :: forall a. Eq a => Analysis a -> Analysis a -> Bool
Eq, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Analysis a) x -> Analysis a
forall a x. Analysis a -> Rep (Analysis a) x
$cto :: forall a x. Rep (Analysis a) x -> Analysis a
$cfrom :: forall a x. Analysis a -> Rep (Analysis a) x
Generic)

instance Functor Analysis where
  fmap :: forall a b. (a -> b) -> Analysis a -> Analysis b
fmap a -> b
f Analysis a
analysis =
    Analysis
    { prevAnnotation :: b
prevAnnotation = a -> b
f (forall a. Analysis a -> a
prevAnnotation Analysis a
analysis)
    , uniqueName :: Maybe String
uniqueName = forall a. Analysis a -> Maybe String
uniqueName Analysis a
analysis
    , sourceName :: Maybe String
sourceName = forall a. Analysis a -> Maybe String
sourceName Analysis a
analysis
    , bBlocks :: Maybe (BBGr (Analysis b))
bBlocks = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b. (Gr (BB a) () -> Gr (BB b) ()) -> BBGr a -> BBGr b
bbgrMap (forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a -> b) -> a -> b
$ a -> b
f)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Analysis a -> Maybe (BBGr (Analysis a))
bBlocks forall a b. (a -> b) -> a -> b
$ Analysis a
analysis
    , insLabel :: Maybe Int
insLabel = forall a. Analysis a -> Maybe Int
insLabel Analysis a
analysis
    , moduleEnv :: Maybe ModEnv
moduleEnv = forall a. Analysis a -> Maybe ModEnv
moduleEnv Analysis a
analysis
    , idType :: Maybe IDType
idType = forall a. Analysis a -> Maybe IDType
idType Analysis a
analysis
    , allLhsVarsAnn :: [String]
allLhsVarsAnn = forall a. Analysis a -> [String]
allLhsVarsAnn Analysis a
analysis
    , constExp :: Maybe Constant
constExp = forall a. Analysis a -> Maybe Constant
constExp Analysis a
analysis
    }

instance Out (Analysis a) where
  doc :: Analysis a -> Doc
doc Analysis a
a = Doc -> Doc
parens forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> String
unwords forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall a. [a] -> [a] -> [a]
(++) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. HasCallStack => Maybe a -> a
fromJust) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
filter (forall a. Maybe a -> Bool
isJust forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd) forall a b. (a -> b) -> a -> b
$
            [ (String
"uniqueName: ", forall a. Analysis a -> Maybe String
uniqueName Analysis a
a)
            , (String
"sourceName: ", forall a. Analysis a -> Maybe String
sourceName Analysis a
a)
            , (String
"insLabel: ", forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Show a => a -> String
show (forall a. Analysis a -> Maybe Int
insLabel Analysis a
a))
            , (String
"idType: ", forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Show a => a -> String
show (forall a. Analysis a -> Maybe IDType
idType Analysis a
a)) ]
  docPrec :: Int -> Analysis a -> Doc
docPrec Int
_ = forall a. Out a => a -> Doc
doc

analysis0 :: a -> Analysis a
analysis0 :: forall a. a -> Analysis a
analysis0 a
a = Analysis { prevAnnotation :: a
prevAnnotation = a
a
                       , uniqueName :: Maybe String
uniqueName     = forall a. Maybe a
Nothing
                       , sourceName :: Maybe String
sourceName     = forall a. Maybe a
Nothing
                       , bBlocks :: Maybe (BBGr (Analysis a))
bBlocks        = forall a. Maybe a
Nothing
                       , insLabel :: Maybe Int
insLabel       = forall a. Maybe a
Nothing
                       , moduleEnv :: Maybe ModEnv
moduleEnv      = forall a. Maybe a
Nothing
                       , idType :: Maybe IDType
idType         = forall a. Maybe a
Nothing
                       , allLhsVarsAnn :: [String]
allLhsVarsAnn  = []
                       , constExp :: Maybe Constant
constExp       = forall a. Maybe a
Nothing }

-- | True iff the expression can be used with varName or srcName
isNamedExpression :: Expression a -> Bool
isNamedExpression :: forall a. Expression a -> Bool
isNamedExpression (ExpValue a
_ SrcSpan
_ (ValVariable String
_))  = Bool
True
isNamedExpression (ExpValue a
_ SrcSpan
_ (ValIntrinsic String
_)) = Bool
True
isNamedExpression Expression a
_                               = Bool
False

-- | Obtain either 'uniqueName' or 'sourceName' from an 'ExpValue' variable, or
--   an 'ExpDataRef'.
--
-- Precedence is as follows:
--
--   * if 'uniqueName' is present, it is returned
--   * else if 'sourceName' is present, it is returned
--   * else the variable name itself is returned
--
-- Crashes on 'Expression's which don't define a variable.
varName :: Expression (Analysis a) -> Name
varName :: forall a. Expression (Analysis a) -> String
varName (ExpValue Analysis { uniqueName :: forall a. Analysis a -> Maybe String
uniqueName = Just String
n } SrcSpan
_ ValVariable{})  = String
n
varName (ExpValue Analysis { sourceName :: forall a. Analysis a -> Maybe String
sourceName = Just String
n } SrcSpan
_ ValVariable{})  = String
n
varName (ExpValue Analysis a
_ SrcSpan
_ (ValVariable String
n))                               = String
n
varName (ExpValue Analysis { uniqueName :: forall a. Analysis a -> Maybe String
uniqueName = Just String
n } SrcSpan
_ ValIntrinsic{}) = String
n
varName (ExpValue Analysis { sourceName :: forall a. Analysis a -> Maybe String
sourceName = Just String
n } SrcSpan
_ ValIntrinsic{}) = String
n
varName (ExpValue Analysis a
_ SrcSpan
_ (ValIntrinsic String
n))                              = String
n

-- | Recursively apply to the left for data refs e.g. @var%field@ -> @var@
varName (ExpDataRef Analysis a
_ SrcSpan
_ Expression (Analysis a)
e Expression (Analysis a)
_) = forall a. Expression (Analysis a) -> String
varName Expression (Analysis a)
e

varName Expression (Analysis a)
_                                                            = forall a. HasCallStack => String -> a
error String
"Use of varName on non-variable."

-- | Obtain the source name from an ExpValue variable.
srcName :: Expression (Analysis a) -> Name
srcName :: forall a. Expression (Analysis a) -> String
srcName (ExpValue Analysis { sourceName :: forall a. Analysis a -> Maybe String
sourceName = Just String
n } SrcSpan
_ ValVariable{})  = String
n
srcName (ExpValue Analysis a
_ SrcSpan
_ (ValVariable String
n))                               = String
n
srcName (ExpValue Analysis { sourceName :: forall a. Analysis a -> Maybe String
sourceName = Just String
n } SrcSpan
_ ValIntrinsic{}) = String
n
srcName (ExpValue Analysis a
_ SrcSpan
_ (ValIntrinsic String
n))                              = String
n
srcName Expression (Analysis a)
_                                                            = forall a. HasCallStack => String -> a
error String
"Use of srcName on non-variable."

-- | Obtain either uniqueName or source name from an LvSimpleVar variable.
lvVarName :: LValue (Analysis a) -> Name
lvVarName :: forall a. LValue (Analysis a) -> String
lvVarName (LvSimpleVar Analysis { uniqueName :: forall a. Analysis a -> Maybe String
uniqueName = Just String
n } SrcSpan
_ String
_)  = String
n
lvVarName (LvSimpleVar Analysis { sourceName :: forall a. Analysis a -> Maybe String
sourceName = Just String
n } SrcSpan
_ String
_)  = String
n
lvVarName (LvSimpleVar Analysis a
_ SrcSpan
_ String
n)                                 = String
n
lvVarName LValue (Analysis a)
_                                                   = forall a. HasCallStack => String -> a
error String
"Use of lvVarName on non-variable."

-- | Obtain the source name from an LvSimpleVar variable.
lvSrcName :: LValue (Analysis a) -> Name
lvSrcName :: forall a. LValue (Analysis a) -> String
lvSrcName (LvSimpleVar Analysis { sourceName :: forall a. Analysis a -> Maybe String
sourceName = Just String
n } SrcSpan
_ String
_) = String
n
lvSrcName (LvSimpleVar Analysis a
_ SrcSpan
_ String
n) = String
n
lvSrcName LValue (Analysis a)
_ = forall a. HasCallStack => String -> a
error String
"Use of lvSrcName on a non-variable"

-- | Generate an ExpValue variable with its source name == to its uniqueName.
genVar :: Analysis a -> SrcSpan -> Name -> Expression (Analysis a)
genVar :: forall a.
Analysis a -> SrcSpan -> String -> Expression (Analysis a)
genVar Analysis a
a SrcSpan
s String
n = forall a. a -> SrcSpan -> Value a -> Expression a
ExpValue (Analysis a
a { uniqueName :: Maybe String
uniqueName = forall a. a -> Maybe a
Just String
n, sourceName :: Maybe String
sourceName = forall a. a -> Maybe a
Just String
n }) SrcSpan
s Value (Analysis a)
v
  where
    v :: Value (Analysis a)
v | Just ConstructType
CTIntrinsic <- IDType -> Maybe ConstructType
idCType forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a. Analysis a -> Maybe IDType
idType Analysis a
a = forall a. String -> Value a
ValIntrinsic String
n
      | Bool
otherwise                                = forall a. String -> Value a
ValVariable String
n

-- | Obtain either ProgramUnit uniqueName or whatever is in the AST.
puName :: ProgramUnit (Analysis a) -> ProgramUnitName
puName :: forall a. ProgramUnit (Analysis a) -> ProgramUnitName
puName ProgramUnit (Analysis a)
pu
  | Just String
n <- forall a. Analysis a -> Maybe String
uniqueName (forall (f :: * -> *) a. Annotated f => f a -> a
getAnnotation ProgramUnit (Analysis a)
pu) = String -> ProgramUnitName
Named String
n
  | Bool
otherwise                               = forall a. Named a => a -> ProgramUnitName
getName ProgramUnit (Analysis a)
pu

-- | Obtain either ProgramUnit sourceName or whatever is in the AST.
puSrcName :: ProgramUnit (Analysis a) -> ProgramUnitName
puSrcName :: forall a. ProgramUnit (Analysis a) -> ProgramUnitName
puSrcName ProgramUnit (Analysis a)
pu
  | Just String
n <- forall a. Analysis a -> Maybe String
sourceName (forall (f :: * -> *) a. Annotated f => f a -> a
getAnnotation ProgramUnit (Analysis a)
pu) = String -> ProgramUnitName
Named String
n
  | Bool
otherwise                               = forall a. Named a => a -> ProgramUnitName
getName ProgramUnit (Analysis a)
pu

-- | Create analysis annotations for the program, saving the original
-- annotations.
initAnalysis :: Functor b => b a -> b (Analysis a)
initAnalysis :: forall (b :: * -> *) a. Functor b => b a -> b (Analysis a)
initAnalysis = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Analysis a
analysis0

-- | Remove analysis annotations from the program, restoring the
-- original annotations.
stripAnalysis :: Functor b => b (Analysis a) -> b a
stripAnalysis :: forall (b :: * -> *) a. Functor b => b (Analysis a) -> b a
stripAnalysis = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Analysis a -> a
prevAnnotation

--------------------------------------------------

-- | Return list of expressions used as the left-hand-side of
-- assignment statements (including for-loops and function-calls by reference).
lhsExprs :: forall a b . (Data a, Data (b a)) => b a -> [Expression a]
lhsExprs :: forall a (b :: * -> *).
(Data a, Data (b a)) =>
b a -> [Expression a]
lhsExprs b a
x = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Statement a -> [Expression a]
lhsOfStmt (forall from to. Biplate from to => from -> [to]
universeBi b a
x)
  where
    lhsOfStmt :: Statement a -> [Expression a]
    lhsOfStmt :: Statement a -> [Expression a]
lhsOfStmt (StExpressionAssign a
_ SrcSpan
_ Expression a
e Expression a
e') = Expression a
e forall a. a -> [a] -> [a]
: forall (c :: * -> *). (Data a, Data (c a)) => c a -> [Expression a]
onExprs Expression a
e'
    lhsOfStmt (StCall a
_ SrcSpan
_ Expression a
_ AList Argument a
aexps) = forall a. (a -> Bool) -> [a] -> [a]
filter forall a. Expression a -> Bool
isLExpr [Expression a]
argExps forall a. [a] -> [a] -> [a]
++ forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall (c :: * -> *). (Data a, Data (c a)) => c a -> [Expression a]
onExprs [Expression a]
argExps
       where argExps :: [Expression a]
argExps = forall a b. (a -> b) -> [a] -> [b]
map forall a. Argument a -> Expression a
argExtractExpr forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. AList t a -> [t a]
aStrip forall a b. (a -> b) -> a -> b
$ AList Argument a
aexps
    lhsOfStmt Statement a
s =  forall (c :: * -> *). (Data a, Data (c a)) => c a -> [Expression a]
onExprs Statement a
s

    onExprs :: (Data a, Data (c a)) => c a -> [Expression a]
    onExprs :: forall (c :: * -> *). (Data a, Data (c a)) => c a -> [Expression a]
onExprs = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Expression a -> [Expression a]
lhsOfExp forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall from to. Biplate from to => from -> [to]
universeBi
    lhsOfExp :: Expression a -> [Expression a]
    lhsOfExp :: Expression a -> [Expression a]
lhsOfExp (ExpFunctionCall a
_ SrcSpan
_ Expression a
_ AList Argument a
aexps) = forall {a}. AList Argument a -> [Expression a]
fstLvl AList Argument a
aexps
    lhsOfExp Expression a
_ = []

    fstLvl :: AList Argument a -> [Expression a]
fstLvl = forall a. (a -> Bool) -> [a] -> [a]
filter forall a. Expression a -> Bool
isLExpr forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall a. Argument a -> Expression a
argExtractExpr forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. AList t a -> [t a]
aStrip

-- | Return list of expressions that are not "left-hand-side" of
-- assignment statements.
rhsExprs :: (Data a, Data (b a)) => b a -> [Expression a]
rhsExprs :: forall a (b :: * -> *).
(Data a, Data (b a)) =>
b a -> [Expression a]
rhsExprs b a
x = forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [ forall a. Data a => Block a -> [Expression a]
blockRhsExprs Block a
b | Block a
b <- forall from to. Biplate from to => from -> [to]
universeBi b a
x ]

-- | Is this an expression capable of assignment?
isLExpr :: Expression a -> Bool
isLExpr :: forall a. Expression a -> Bool
isLExpr (ExpValue a
_ SrcSpan
_ ValVariable {}) = Bool
True
isLExpr ExpSubscript{}                = Bool
True
isLExpr Expression a
_                             = Bool
False

-- | Set of names found in an AST node.
allVars :: forall a b. (Data a, Data (b (Analysis a))) => b (Analysis a) -> [Name]
allVars :: forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars b (Analysis a)
b = [ forall a. Expression (Analysis a) -> String
varName Expression (Analysis a)
v | v :: Expression (Analysis a)
v@(ExpValue Analysis a
_ SrcSpan
_ (ValVariable String
_)) <- b (Analysis a) -> [Expression (Analysis a)]
uniBi b (Analysis a)
b ]
  where
    uniBi :: b (Analysis a) -> [Expression (Analysis a)]
uniBi b (Analysis a)
x = forall from to. Biplate from to => from -> [to]
universeBi b (Analysis a)
x :: [Expression (Analysis a)]

-- | Initiate (lazy) computation of all LHS variables for each node of
-- the AST so that it may be accessed later.
analyseAllLhsVars :: forall a . Data a => ProgramFile (Analysis a) -> ProgramFile (Analysis a)
analyseAllLhsVars :: forall a.
Data a =>
ProgramFile (Analysis a) -> ProgramFile (Analysis a)
analyseAllLhsVars = (forall from to. Biplate from to => (to -> to) -> from -> from
transformBi :: TransFunc Block ProgramFile a) forall (f :: * -> *) a.
(Annotated f, Data (f (Analysis a)), Data a) =>
f (Analysis a) -> f (Analysis a)
analyseAllLhsVars1 forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                    (forall from to. Biplate from to => (to -> to) -> from -> from
transformBi :: TransFunc Statement ProgramFile a) forall (f :: * -> *) a.
(Annotated f, Data (f (Analysis a)), Data a) =>
f (Analysis a) -> f (Analysis a)
analyseAllLhsVars1 forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                    (forall from to. Biplate from to => (to -> to) -> from -> from
transformBi :: TransFunc DoSpecification ProgramFile a) forall (f :: * -> *) a.
(Annotated f, Data (f (Analysis a)), Data a) =>
f (Analysis a) -> f (Analysis a)
analyseAllLhsVars1

analyseAllLhsVars1 :: (Annotated f, Data (f (Analysis a)), Data a) => f (Analysis a) -> f (Analysis a)
analyseAllLhsVars1 :: forall (f :: * -> *) a.
(Annotated f, Data (f (Analysis a)), Data a) =>
f (Analysis a) -> f (Analysis a)
analyseAllLhsVars1 f (Analysis a)
x = forall (f :: * -> *) a. Annotated f => (a -> a) -> f a -> f a
modifyAnnotation (\ Analysis a
a -> Analysis a
a { allLhsVarsAnn :: [String]
allLhsVarsAnn = forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
computeAllLhsVars f (Analysis a)
x }) f (Analysis a)
x

-- | Set of names found in the parts of an AST that are the target of
-- an assignment statement.
-- allLhsVars :: (Annotated b, Data a, Data (b (Analysis a))) => b (Analysis a) -> [Name]
allLhsVars :: Data a => Block (Analysis a) -> [Name]
allLhsVars :: forall a. Data a => Block (Analysis a) -> [String]
allLhsVars = forall a. Analysis a -> [String]
allLhsVarsAnn forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Annotated f => f a -> a
getAnnotation

allLhsVarsDoSpec :: Data a => DoSpecification (Analysis a) -> [Name]
allLhsVarsDoSpec :: forall a. Data a => DoSpecification (Analysis a) -> [String]
allLhsVarsDoSpec = forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
computeAllLhsVars

-- | Set of names found in the parts of an AST that are the target of
-- an assignment statement.
computeAllLhsVars :: forall a b . (Data a, Data (b (Analysis a))) => b (Analysis a) -> [Name]
computeAllLhsVars :: forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
computeAllLhsVars = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Statement (Analysis a) -> [String]
lhsOfStmt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall from to. Biplate from to => from -> [to]
universeBi
  where
    lhsOfStmt :: Statement (Analysis a) -> [Name]
    lhsOfStmt :: Statement (Analysis a) -> [String]
lhsOfStmt (StExpressionAssign Analysis a
_ SrcSpan
_ Expression (Analysis a)
e Expression (Analysis a)
e') = forall a. Expression (Analysis a) -> String
match' Expression (Analysis a)
e forall a. a -> [a] -> [a]
: forall (c :: * -> *).
Data (c (Analysis a)) =>
c (Analysis a) -> [String]
onExprs Expression (Analysis a)
e'
    lhsOfStmt (StDeclaration Analysis a
_ SrcSpan
_ TypeSpec (Analysis a)
_ Maybe (AList Attribute (Analysis a))
_ AList Declarator (Analysis a)
decls) = forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [ Declarator (Analysis a) -> [String]
lhsOfDecls Declarator (Analysis a)
decl | Declarator (Analysis a)
decl <- forall from to. Biplate from to => from -> [to]
universeBi AList Declarator (Analysis a)
decls ]
    lhsOfStmt (StCall Analysis a
_ SrcSpan
_ f :: Expression (Analysis a)
f@(ExpValue Analysis a
_ SrcSpan
_ (ValIntrinsic String
_)) AList Argument (Analysis a)
_)
      | Just [String]
defs <- forall a. Expression (Analysis a) -> Maybe [String]
intrinsicDefs Expression (Analysis a)
f = [String]
defs
    lhsOfStmt (StCall Analysis a
_ SrcSpan
_ Expression (Analysis a)
_ AList Argument (Analysis a)
aexps) = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Expression (Analysis a) -> [String]
match'' forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Argument a -> Expression a
argExtractExpr) (forall (t :: * -> *) a. AList t a -> [t a]
aStrip AList Argument (Analysis a)
aexps)
    lhsOfStmt Statement (Analysis a)
s = forall (c :: * -> *).
Data (c (Analysis a)) =>
c (Analysis a) -> [String]
onExprs Statement (Analysis a)
s

    lhsOfDecls :: Declarator (Analysis a) -> [String]
lhsOfDecls (Declarator Analysis a
_ SrcSpan
_ Expression (Analysis a)
e DeclaratorType (Analysis a)
_ Maybe (Expression (Analysis a))
_ (Just Expression (Analysis a)
e')) = forall a. Expression (Analysis a) -> String
match' Expression (Analysis a)
e forall a. a -> [a] -> [a]
: forall (c :: * -> *).
Data (c (Analysis a)) =>
c (Analysis a) -> [String]
onExprs Expression (Analysis a)
e'
    lhsOfDecls Declarator (Analysis a)
_ = []

    onExprs :: (Data (c (Analysis a))) => c (Analysis a) -> [Name]
    onExprs :: forall (c :: * -> *).
Data (c (Analysis a)) =>
c (Analysis a) -> [String]
onExprs = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Expression (Analysis a) -> [String]
lhsOfExp forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall from to. Biplate from to => from -> [to]
universeBi

    lhsOfExp :: Expression (Analysis a) -> [Name]
    lhsOfExp :: Expression (Analysis a) -> [String]
lhsOfExp (ExpFunctionCall Analysis a
_ SrcSpan
_ Expression (Analysis a)
_ AList Argument (Analysis a)
aexps) = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Expression (Analysis a) -> [String]
match forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Argument a -> Expression a
argExtractExpr) (forall (t :: * -> *) a. AList t a -> [t a]
aStrip AList Argument (Analysis a)
aexps)
    lhsOfExp Expression (Analysis a)
_ = []

    -- Match and give the varname for LHS of statement
    match' :: Expression (Analysis a) -> String
match' v :: Expression (Analysis a)
v@(ExpValue Analysis a
_ SrcSpan
_ ValVariable{}) = forall a. Expression (Analysis a) -> String
varName Expression (Analysis a)
v
    match' (ExpSubscript Analysis a
_ SrcSpan
_ Expression (Analysis a)
e AList Index (Analysis a)
_)         = Expression (Analysis a) -> String
match' Expression (Analysis a)
e
    match' (ExpDataRef Analysis a
_ SrcSpan
_ Expression (Analysis a)
v Expression (Analysis a)
_)           = Expression (Analysis a) -> String
match' Expression (Analysis a)
v
    match' Expression (Analysis a)
e                              = forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
"An unexpected LHS to an expression assign: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b. a -> b -> a
const ()) Expression (Analysis a)
e)

    -- Match and give the varname of LHSes which occur in subroutine calls
    match'' :: Expression (Analysis a) -> [String]
match'' v :: Expression (Analysis a)
v@(ExpValue Analysis a
_ SrcSpan
_ ValVariable{}) = [forall a. Expression (Analysis a) -> String
varName Expression (Analysis a)
v]
    match'' (ExpSubscript Analysis a
_ SrcSpan
_ Expression (Analysis a)
e AList Index (Analysis a)
_)         = Expression (Analysis a) -> [String]
match'' Expression (Analysis a)
e
    match'' (ExpDataRef Analysis a
_ SrcSpan
_ Expression (Analysis a)
v Expression (Analysis a)
_)           = Expression (Analysis a) -> [String]
match'' Expression (Analysis a)
v
    match'' Expression (Analysis a)
e                              = forall (c :: * -> *).
Data (c (Analysis a)) =>
c (Analysis a) -> [String]
onExprs Expression (Analysis a)
e

   -- Match and give the varname of LHSes which occur in function calls
    match :: Expression (Analysis a) -> [String]
match v :: Expression (Analysis a)
v@(ExpValue Analysis a
_ SrcSpan
_ ValVariable{}) = [forall a. Expression (Analysis a) -> String
varName Expression (Analysis a)
v]
    match (ExpSubscript Analysis a
_ SrcSpan
_ Expression (Analysis a)
e AList Index (Analysis a)
_)         = Expression (Analysis a) -> [String]
match Expression (Analysis a)
e
    match (ExpDataRef Analysis a
_ SrcSpan
_ Expression (Analysis a)
e Expression (Analysis a)
_)           = Expression (Analysis a) -> [String]
match Expression (Analysis a)
e
    match Expression (Analysis a)
e                              = forall (c :: * -> *).
Data (c (Analysis a)) =>
c (Analysis a) -> [String]
onExprs Expression (Analysis a)
e

-- | Set of expressions used -- not defined -- by an AST-block.
blockRhsExprs :: Data a => Block a -> [Expression a]
blockRhsExprs :: forall a. Data a => Block a -> [Expression a]
blockRhsExprs (BlStatement a
_ SrcSpan
_ Maybe (Expression a)
_ Statement a
s) = forall a. Data a => Statement a -> [Expression a]
statementRhsExprs Statement a
s
blockRhsExprs (BlDo a
_ SrcSpan
_ Maybe (Expression a)
_ Maybe String
_ Maybe (Expression a)
_ (Just (DoSpecification a
_ SrcSpan
_ (StExpressionAssign a
_ SrcSpan
_ Expression a
lhs Expression a
rhs) Expression a
e1 Maybe (Expression a)
e2)) [Block a]
_ Maybe (Expression a)
_)
  | ExpSubscript a
_ SrcSpan
_ Expression a
_ AList Index a
subs <- Expression a
lhs = forall from to. Biplate from to => from -> [to]
universeBi (Expression a
rhs, Expression a
e1, Maybe (Expression a)
e2) forall a. [a] -> [a] -> [a]
++ forall from to. Biplate from to => from -> [to]
universeBi AList Index a
subs
  | Bool
otherwise                      = forall from to. Biplate from to => from -> [to]
universeBi (Expression a
rhs, Expression a
e1, Maybe (Expression a)
e2)
blockRhsExprs (BlDoWhile a
_ SrcSpan
_ Maybe (Expression a)
e1 Maybe String
_ Maybe (Expression a)
_ Expression a
e2 [Block a]
_ Maybe (Expression a)
_) = forall from to. Biplate from to => from -> [to]
universeBi (Maybe (Expression a)
e1, Expression a
e2)
blockRhsExprs (BlIf a
_ SrcSpan
_ Maybe (Expression a)
e1 Maybe String
_ NonEmpty (Expression a, [Block a])
e2 Maybe [Block a]
_ Maybe (Expression a)
_)        = forall from to. Biplate from to => from -> [to]
universeBi (Maybe (Expression a)
e1, NonEmpty (Expression a, [Block a])
e2)
blockRhsExprs Block a
b                             = forall from to. Biplate from to => from -> [to]
universeBi Block a
b

-- | Set of expression used -- not defined -- by a statement
statementRhsExprs :: Data a => Statement a -> [Expression a]
statementRhsExprs :: forall a. Data a => Statement a -> [Expression a]
statementRhsExprs (StExpressionAssign a
_ SrcSpan
_ Expression a
lhs Expression a
rhs)
 | ExpSubscript a
_ SrcSpan
_ Expression a
_ AList Index a
subs <- Expression a
lhs = forall from to. Biplate from to => from -> [to]
universeBi Expression a
rhs forall a. [a] -> [a] -> [a]
++ forall from to. Biplate from to => from -> [to]
universeBi AList Index a
subs
 | Bool
otherwise                      = forall from to. Biplate from to => from -> [to]
universeBi Expression a
rhs
statementRhsExprs StDeclaration{} = []
statementRhsExprs (StIfLogical a
_ SrcSpan
_ Expression a
_ Statement a
s) = forall a. Data a => Statement a -> [Expression a]
statementRhsExprs Statement a
s
statementRhsExprs (StDo a
_ SrcSpan
_ Maybe String
_ Maybe (Expression a)
l Maybe (DoSpecification a)
s') = forall from to. Biplate from to => from -> [to]
universeBi Maybe (Expression a)
l forall a. [a] -> [a] -> [a]
++ forall {a}. Data a => Maybe (DoSpecification a) -> [Expression a]
doSpecRhsExprs Maybe (DoSpecification a)
s'
  where doSpecRhsExprs :: Maybe (DoSpecification a) -> [Expression a]
doSpecRhsExprs (Just (DoSpecification a
_ SrcSpan
_ Statement a
s Expression a
e1 Maybe (Expression a)
e2)) =
           (Expression a
e1 forall a. a -> [a] -> [a]
: forall from to. Biplate from to => from -> [to]
universeBi Maybe (Expression a)
e2) forall a. [a] -> [a] -> [a]
++ forall a. Data a => Statement a -> [Expression a]
statementRhsExprs Statement a
s
        doSpecRhsExprs Maybe (DoSpecification a)
Nothing = []
statementRhsExprs Statement a
s = forall from to. Biplate from to => from -> [to]
universeBi Statement a
s

-- | Set of names used -- not defined -- by an AST-block.
blockVarUses :: forall a. Data a => Block (Analysis a) -> [Name]
blockVarUses :: forall a. Data a => Block (Analysis a) -> [String]
blockVarUses (BlStatement Analysis a
_ SrcSpan
_ Maybe (Expression (Analysis a))
_ (StExpressionAssign Analysis a
_ SrcSpan
_ Expression (Analysis a)
lhs Expression (Analysis a)
rhs))
  | ExpSubscript Analysis a
_ SrcSpan
_ Expression (Analysis a)
_ AList Index (Analysis a)
subs <- Expression (Analysis a)
lhs = forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars Expression (Analysis a)
rhs forall a. [a] -> [a] -> [a]
++ forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars (forall (t :: * -> *) a. AList t a -> [t a]
aStrip AList Index (Analysis a)
subs)
  | Bool
otherwise                      = forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars Expression (Analysis a)
rhs
blockVarUses (BlDo Analysis a
_ SrcSpan
_ Maybe (Expression (Analysis a))
_ Maybe String
_ Maybe (Expression (Analysis a))
_ (Just (DoSpecification Analysis a
_ SrcSpan
_ (StExpressionAssign Analysis a
_ SrcSpan
_ Expression (Analysis a)
lhs Expression (Analysis a)
rhs) Expression (Analysis a)
e1 Maybe (Expression (Analysis a))
e2)) [Block (Analysis a)]
_ Maybe (Expression (Analysis a))
_)
  | ExpSubscript Analysis a
_ SrcSpan
_ Expression (Analysis a)
_ AList Index (Analysis a)
subs <- Expression (Analysis a)
lhs = forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars Expression (Analysis a)
rhs forall a. [a] -> [a] -> [a]
++ forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars Expression (Analysis a)
e1 forall a. [a] -> [a] -> [a]
++ forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars Maybe (Expression (Analysis a))
e2 forall a. [a] -> [a] -> [a]
++ forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars (forall (t :: * -> *) a. AList t a -> [t a]
aStrip AList Index (Analysis a)
subs)
  | Bool
otherwise                      = forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars Expression (Analysis a)
rhs forall a. [a] -> [a] -> [a]
++ forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars Expression (Analysis a)
e1 forall a. [a] -> [a] -> [a]
++ forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars Maybe (Expression (Analysis a))
e2
blockVarUses (BlStatement Analysis a
_ SrcSpan
_ Maybe (Expression (Analysis a))
_ st :: Statement (Analysis a)
st@StDeclaration{}) = forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [ Data a => Declarator (Analysis a) -> [String]
rhsOfDecls Declarator (Analysis a)
d | Declarator (Analysis a)
d <- forall from to. Biplate from to => from -> [to]
universeBi Statement (Analysis a)
st ]
  where
    rhsOfDecls :: Data a => Declarator (Analysis a) -> [Name]
    rhsOfDecls :: Data a => Declarator (Analysis a) -> [String]
rhsOfDecls (Declarator Analysis a
_ SrcSpan
_ Expression (Analysis a)
_ DeclaratorType (Analysis a)
_ Maybe (Expression (Analysis a))
_ (Just Expression (Analysis a)
e)) = forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars Expression (Analysis a)
e
    rhsOfDecls Declarator (Analysis a)
_ = []
blockVarUses (BlStatement Analysis a
_ SrcSpan
_ Maybe (Expression (Analysis a))
_ (StCall Analysis a
_ SrcSpan
_ f :: Expression (Analysis a)
f@(ExpValue Analysis a
_ SrcSpan
_ (ValIntrinsic String
_)) AList Argument (Analysis a)
_))
  | Just [String]
uses <- forall a. Expression (Analysis a) -> Maybe [String]
intrinsicUses Expression (Analysis a)
f = [String]
uses
blockVarUses (BlStatement Analysis a
_ SrcSpan
_ Maybe (Expression (Analysis a))
_ (StCall Analysis a
_ SrcSpan
_ Expression (Analysis a)
_ AList Argument (Analysis a)
aexps)) = forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars AList Argument (Analysis a)
aexps
blockVarUses (BlDoWhile Analysis a
_ SrcSpan
_ Maybe (Expression (Analysis a))
e1 Maybe String
_ Maybe (Expression (Analysis a))
_ Expression (Analysis a)
e2 [Block (Analysis a)]
_ Maybe (Expression (Analysis a))
_) = forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars Maybe (Expression (Analysis a))
e1 forall a. [a] -> [a] -> [a]
++ forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars Expression (Analysis a)
e2
blockVarUses (BlIf Analysis a
_ SrcSpan
_ Maybe (Expression (Analysis a))
eLabel Maybe String
_ NonEmpty (Expression (Analysis a), [Block (Analysis a)])
clauses Maybe [Block (Analysis a)]
_ Maybe (Expression (Analysis a))
_) =
    forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars Maybe (Expression (Analysis a))
eLabel forall a. [a] -> [a] -> [a]
++ forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> a
fst NonEmpty (Expression (Analysis a), [Block (Analysis a)])
clauses)
blockVarUses Block (Analysis a)
b                             = forall a (b :: * -> *).
(Data a, Data (b (Analysis a))) =>
b (Analysis a) -> [String]
allVars Block (Analysis a)
b

-- | Set of names defined by an AST-block.
blockVarDefs :: Data a => Block (Analysis a) -> [Name]
blockVarDefs :: forall a. Data a => Block (Analysis a) -> [String]
blockVarDefs b :: Block (Analysis a)
b@BlStatement{} = forall a. Data a => Block (Analysis a) -> [String]
allLhsVars Block (Analysis a)
b
blockVarDefs (BlDo Analysis a
_ SrcSpan
_ Maybe (Expression (Analysis a))
_ Maybe String
_ Maybe (Expression (Analysis a))
_ (Just DoSpecification (Analysis a)
doSpec) [Block (Analysis a)]
_ Maybe (Expression (Analysis a))
_)  = forall a. Data a => DoSpecification (Analysis a) -> [String]
allLhsVarsDoSpec DoSpecification (Analysis a)
doSpec
blockVarDefs Block (Analysis a)
_                      = []

-- form name: n[i]
dummyArg :: Name -> Int -> Name
dummyArg :: String -> Int -> String
dummyArg String
n Int
i = String
n forall a. [a] -> [a] -> [a]
++ String
"[" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
i forall a. [a] -> [a] -> [a]
++ String
"]"

-- return dummy arg names defined by intrinsic
intrinsicDefs :: Expression (Analysis a) -> Maybe [Name]
intrinsicDefs :: forall a. Expression (Analysis a) -> Maybe [String]
intrinsicDefs = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Expression (Analysis a) -> Maybe ([String], [String])
intrinsicDefsUses

-- return dummy arg names used by intrinsic
intrinsicUses :: Expression (Analysis a) -> Maybe [Name]
intrinsicUses :: forall a. Expression (Analysis a) -> Maybe [String]
intrinsicUses = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Expression (Analysis a) -> Maybe ([String], [String])
intrinsicDefsUses

-- return dummy arg names (defined, used) by intrinsic
intrinsicDefsUses :: Expression (Analysis a) -> Maybe ([Name], [Name])
intrinsicDefsUses :: forall a. Expression (Analysis a) -> Maybe ([String], [String])
intrinsicDefsUses Expression (Analysis a)
f = forall {t} {b}. (t -> b) -> (t, t) -> (b, b)
both (forall a b. (a -> b) -> [a] -> [b]
map (String -> Int -> String
dummyArg (forall a. Expression (Analysis a) -> String
varName Expression (Analysis a)
f))) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> IntrinsicsTable -> Maybe ([Int], [Int])
getIntrinsicDefsUses (forall a. Expression (Analysis a) -> String
srcName Expression (Analysis a)
f) IntrinsicsTable
allIntrinsics
  where both :: (t -> b) -> (t, t) -> (b, b)
both t -> b
f' (t
x, t
y) = (t -> b
f' t
x, t -> b
f' t
y)

-- Local variables:
-- mode: haskell
-- haskell-program-name: "cabal repl"
-- End: