{-| An info object contains additional information about a piece of abstract
    syntax that isn't part of the actual syntax. For instance, it might contain
    the source code position of an expression or the concrete syntax that
    an internal expression originates from.
-}

module Agda.Syntax.Info where

import Prelude hiding (null)

import Control.DeepSeq

import Data.Data (Data)
import Data.Semigroup (Semigroup)

import GHC.Generics (Generic)

import qualified Agda.Syntax.Concrete.Name as C
import Agda.Syntax.Common
import Agda.Syntax.Position
import Agda.Syntax.Concrete
import Agda.Syntax.Fixity
import Agda.Syntax.Scope.Base (ScopeInfo, emptyScopeInfo)

import Agda.Utils.Functor
import Agda.Utils.Null

{--------------------------------------------------------------------------
    Meta information
 --------------------------------------------------------------------------}

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

emptyMetaInfo :: MetaInfo
emptyMetaInfo :: MetaInfo
emptyMetaInfo = MetaInfo
  { metaRange :: Range
metaRange          = forall a. Range' a
noRange
  , metaScope :: ScopeInfo
metaScope          = ScopeInfo
emptyScopeInfo
  , metaNumber :: Maybe MetaId
metaNumber         = forall a. Maybe a
Nothing
  , metaNameSuggestion :: String
metaNameSuggestion = String
""
  }

instance HasRange MetaInfo where
  getRange :: MetaInfo -> Range
getRange = MetaInfo -> Range
metaRange

instance KillRange MetaInfo where
  killRange :: MetaInfo -> MetaInfo
killRange MetaInfo
m = MetaInfo
m { metaRange :: Range
metaRange = forall a. Range' a
noRange }

instance NFData MetaInfo

{--------------------------------------------------------------------------
    General expression information
 --------------------------------------------------------------------------}

newtype ExprInfo = ExprRange Range
  deriving (Typeable ExprInfo
ExprInfo -> Constr
ExprInfo -> DataType
(forall b. Data b => b -> b) -> ExprInfo -> ExprInfo
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) -> ExprInfo -> u
forall u. (forall d. Data d => d -> u) -> ExprInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExprInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExprInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExprInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExprInfo -> c ExprInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExprInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExprInfo)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExprInfo -> m ExprInfo
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExprInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExprInfo -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ExprInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ExprInfo -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExprInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExprInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExprInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExprInfo -> r
gmapT :: (forall b. Data b => b -> b) -> ExprInfo -> ExprInfo
$cgmapT :: (forall b. Data b => b -> b) -> ExprInfo -> ExprInfo
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExprInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExprInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExprInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExprInfo)
dataTypeOf :: ExprInfo -> DataType
$cdataTypeOf :: ExprInfo -> DataType
toConstr :: ExprInfo -> Constr
$ctoConstr :: ExprInfo -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExprInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExprInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExprInfo -> c ExprInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExprInfo -> c ExprInfo
Data, Int -> ExprInfo -> ShowS
[ExprInfo] -> ShowS
ExprInfo -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExprInfo] -> ShowS
$cshowList :: [ExprInfo] -> ShowS
show :: ExprInfo -> String
$cshow :: ExprInfo -> String
showsPrec :: Int -> ExprInfo -> ShowS
$cshowsPrec :: Int -> ExprInfo -> ShowS
Show, ExprInfo -> ExprInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExprInfo -> ExprInfo -> Bool
$c/= :: ExprInfo -> ExprInfo -> Bool
== :: ExprInfo -> ExprInfo -> Bool
$c== :: ExprInfo -> ExprInfo -> Bool
Eq, ExprInfo
ExprInfo -> Bool
forall a. a -> (a -> Bool) -> Null a
null :: ExprInfo -> Bool
$cnull :: ExprInfo -> Bool
empty :: ExprInfo
$cempty :: ExprInfo
Null, ExprInfo -> ()
forall a. (a -> ()) -> NFData a
rnf :: ExprInfo -> ()
$crnf :: ExprInfo -> ()
NFData)

exprNoRange :: ExprInfo
exprNoRange :: ExprInfo
exprNoRange = Range -> ExprInfo
ExprRange forall a. Range' a
noRange

instance HasRange ExprInfo where
  getRange :: ExprInfo -> Range
getRange (ExprRange Range
r) = Range
r

instance KillRange ExprInfo where
  killRange :: ExprInfo -> ExprInfo
killRange (ExprRange Range
r) = ExprInfo
exprNoRange

{--------------------------------------------------------------------------
    Application information
 --------------------------------------------------------------------------}

-- | Information about application
data AppInfo = AppInfo
  { AppInfo -> Range
appRange  :: Range
  , AppInfo -> Origin
appOrigin :: Origin
  , AppInfo -> ParenPreference
appParens :: ParenPreference -- ^ Do we prefer a lambda argument with or without parens?
  }
  deriving (Typeable AppInfo
AppInfo -> Constr
AppInfo -> DataType
(forall b. Data b => b -> b) -> AppInfo -> AppInfo
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) -> AppInfo -> u
forall u. (forall d. Data d => d -> u) -> AppInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AppInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AppInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AppInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AppInfo -> c AppInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AppInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AppInfo)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AppInfo -> m AppInfo
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AppInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AppInfo -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> AppInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AppInfo -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AppInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AppInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AppInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AppInfo -> r
gmapT :: (forall b. Data b => b -> b) -> AppInfo -> AppInfo
$cgmapT :: (forall b. Data b => b -> b) -> AppInfo -> AppInfo
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AppInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AppInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AppInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AppInfo)
dataTypeOf :: AppInfo -> DataType
$cdataTypeOf :: AppInfo -> DataType
toConstr :: AppInfo -> Constr
$ctoConstr :: AppInfo -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AppInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AppInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AppInfo -> c AppInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AppInfo -> c AppInfo
Data, Int -> AppInfo -> ShowS
[AppInfo] -> ShowS
AppInfo -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AppInfo] -> ShowS
$cshowList :: [AppInfo] -> ShowS
show :: AppInfo -> String
$cshow :: AppInfo -> String
showsPrec :: Int -> AppInfo -> ShowS
$cshowsPrec :: Int -> AppInfo -> ShowS
Show, AppInfo -> AppInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AppInfo -> AppInfo -> Bool
$c/= :: AppInfo -> AppInfo -> Bool
== :: AppInfo -> AppInfo -> Bool
$c== :: AppInfo -> AppInfo -> Bool
Eq, Eq AppInfo
AppInfo -> AppInfo -> Bool
AppInfo -> AppInfo -> Ordering
AppInfo -> AppInfo -> AppInfo
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 :: AppInfo -> AppInfo -> AppInfo
$cmin :: AppInfo -> AppInfo -> AppInfo
max :: AppInfo -> AppInfo -> AppInfo
$cmax :: AppInfo -> AppInfo -> AppInfo
>= :: AppInfo -> AppInfo -> Bool
$c>= :: AppInfo -> AppInfo -> Bool
> :: AppInfo -> AppInfo -> Bool
$c> :: AppInfo -> AppInfo -> Bool
<= :: AppInfo -> AppInfo -> Bool
$c<= :: AppInfo -> AppInfo -> Bool
< :: AppInfo -> AppInfo -> Bool
$c< :: AppInfo -> AppInfo -> Bool
compare :: AppInfo -> AppInfo -> Ordering
$ccompare :: AppInfo -> AppInfo -> Ordering
Ord, forall x. Rep AppInfo x -> AppInfo
forall x. AppInfo -> Rep AppInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep AppInfo x -> AppInfo
$cfrom :: forall x. AppInfo -> Rep AppInfo x
Generic)

-- | Default is system inserted and prefer parens.
defaultAppInfo :: Range -> AppInfo
defaultAppInfo :: Range -> AppInfo
defaultAppInfo Range
r = AppInfo{ appRange :: Range
appRange = Range
r, appOrigin :: Origin
appOrigin = Origin
Inserted, appParens :: ParenPreference
appParens = ParenPreference
PreferParen }

-- | `AppInfo` with no range information.
defaultAppInfo_ :: AppInfo
defaultAppInfo_ :: AppInfo
defaultAppInfo_ = Range -> AppInfo
defaultAppInfo forall a. Range' a
noRange

instance HasRange AppInfo where
  getRange :: AppInfo -> Range
getRange = AppInfo -> Range
appRange

instance KillRange AppInfo where
  killRange :: AppInfo -> AppInfo
killRange (AppInfo Range
r Origin
o ParenPreference
p) = Range -> Origin -> ParenPreference -> AppInfo
AppInfo (forall a. KillRange a => KillRangeT a
killRange Range
r) Origin
o ParenPreference
p

instance LensOrigin AppInfo where
  getOrigin :: AppInfo -> Origin
getOrigin = AppInfo -> Origin
appOrigin
  mapOrigin :: (Origin -> Origin) -> AppInfo -> AppInfo
mapOrigin Origin -> Origin
f AppInfo
i = AppInfo
i { appOrigin :: Origin
appOrigin = Origin -> Origin
f (AppInfo -> Origin
appOrigin AppInfo
i) }

instance NFData AppInfo

{--------------------------------------------------------------------------
    Module information
 --------------------------------------------------------------------------}

data ModuleInfo = ModuleInfo
  { ModuleInfo -> Range
minfoRange    :: Range
  , ModuleInfo -> Range
minfoAsTo     :: Range
    -- ^ The range of the \"as\" and \"to\" keywords,
    -- if any. Retained for highlighting purposes.
  , ModuleInfo -> Maybe Name
minfoAsName   :: Maybe C.Name
    -- ^ The \"as\" module name, if any. Retained for highlighting purposes.
  , ModuleInfo -> Maybe OpenShortHand
minfoOpenShort :: Maybe OpenShortHand
  , ModuleInfo -> Maybe ImportDirective
minfoDirective :: Maybe ImportDirective
    -- ^ Retained for @abstractToConcrete@ of 'ModuleMacro'.
  }
  deriving (Typeable ModuleInfo
ModuleInfo -> Constr
ModuleInfo -> DataType
(forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo
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) -> ModuleInfo -> u
forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
gmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo
$cgmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)
dataTypeOf :: ModuleInfo -> DataType
$cdataTypeOf :: ModuleInfo -> DataType
toConstr :: ModuleInfo -> Constr
$ctoConstr :: ModuleInfo -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
Data, ModuleInfo -> ModuleInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModuleInfo -> ModuleInfo -> Bool
$c/= :: ModuleInfo -> ModuleInfo -> Bool
== :: ModuleInfo -> ModuleInfo -> Bool
$c== :: ModuleInfo -> ModuleInfo -> Bool
Eq, Int -> ModuleInfo -> ShowS
[ModuleInfo] -> ShowS
ModuleInfo -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModuleInfo] -> ShowS
$cshowList :: [ModuleInfo] -> ShowS
show :: ModuleInfo -> String
$cshow :: ModuleInfo -> String
showsPrec :: Int -> ModuleInfo -> ShowS
$cshowsPrec :: Int -> ModuleInfo -> ShowS
Show, forall x. Rep ModuleInfo x -> ModuleInfo
forall x. ModuleInfo -> Rep ModuleInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ModuleInfo x -> ModuleInfo
$cfrom :: forall x. ModuleInfo -> Rep ModuleInfo x
Generic)

instance HasRange ModuleInfo where
  getRange :: ModuleInfo -> Range
getRange = ModuleInfo -> Range
minfoRange

instance SetRange ModuleInfo where
  setRange :: Range -> ModuleInfo -> ModuleInfo
setRange Range
r ModuleInfo
i = ModuleInfo
i { minfoRange :: Range
minfoRange = Range
r }

instance KillRange ModuleInfo where
  killRange :: ModuleInfo -> ModuleInfo
killRange ModuleInfo
m = ModuleInfo
m { minfoRange :: Range
minfoRange = forall a. Range' a
noRange }

instance NFData ModuleInfo

---------------------------------------------------------------------------
-- Let info
---------------------------------------------------------------------------

newtype LetInfo = LetRange Range
  deriving (Typeable LetInfo
LetInfo -> Constr
LetInfo -> DataType
(forall b. Data b => b -> b) -> LetInfo -> LetInfo
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) -> LetInfo -> u
forall u. (forall d. Data d => d -> u) -> LetInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LetInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LetInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LetInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LetInfo -> c LetInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LetInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LetInfo)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LetInfo -> m LetInfo
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LetInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LetInfo -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> LetInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LetInfo -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LetInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LetInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LetInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LetInfo -> r
gmapT :: (forall b. Data b => b -> b) -> LetInfo -> LetInfo
$cgmapT :: (forall b. Data b => b -> b) -> LetInfo -> LetInfo
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LetInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LetInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LetInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LetInfo)
dataTypeOf :: LetInfo -> DataType
$cdataTypeOf :: LetInfo -> DataType
toConstr :: LetInfo -> Constr
$ctoConstr :: LetInfo -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LetInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LetInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LetInfo -> c LetInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LetInfo -> c LetInfo
Data, Int -> LetInfo -> ShowS
[LetInfo] -> ShowS
LetInfo -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LetInfo] -> ShowS
$cshowList :: [LetInfo] -> ShowS
show :: LetInfo -> String
$cshow :: LetInfo -> String
showsPrec :: Int -> LetInfo -> ShowS
$cshowsPrec :: Int -> LetInfo -> ShowS
Show, LetInfo -> LetInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LetInfo -> LetInfo -> Bool
$c/= :: LetInfo -> LetInfo -> Bool
== :: LetInfo -> LetInfo -> Bool
$c== :: LetInfo -> LetInfo -> Bool
Eq, LetInfo
LetInfo -> Bool
forall a. a -> (a -> Bool) -> Null a
null :: LetInfo -> Bool
$cnull :: LetInfo -> Bool
empty :: LetInfo
$cempty :: LetInfo
Null, LetInfo -> ()
forall a. (a -> ()) -> NFData a
rnf :: LetInfo -> ()
$crnf :: LetInfo -> ()
NFData)

instance HasRange LetInfo where
  getRange :: LetInfo -> Range
getRange (LetRange Range
r)   = Range
r

instance KillRange LetInfo where
  killRange :: LetInfo -> LetInfo
killRange (LetRange Range
r) = Range -> LetInfo
LetRange forall a. Range' a
noRange

{--------------------------------------------------------------------------
    Definition information (declarations that actually define something)
 --------------------------------------------------------------------------}

data DefInfo' t = DefInfo
  { forall t. DefInfo' t -> Fixity'
defFixity   :: Fixity'
  , forall t. DefInfo' t -> Access
defAccess   :: Access
  , forall t. DefInfo' t -> IsAbstract
defAbstract :: IsAbstract
  , forall t. DefInfo' t -> IsInstance
defInstance :: IsInstance
  , forall t. DefInfo' t -> IsMacro
defMacro    :: IsMacro
  , forall t. DefInfo' t -> DeclInfo
defInfo     :: DeclInfo
  , forall t. DefInfo' t -> Maybe t
defTactic   :: Maybe t
  }
  deriving (DefInfo' t -> Constr
DefInfo' t -> DataType
forall {t}. Data t => Typeable (DefInfo' t)
forall t. Data t => DefInfo' t -> Constr
forall t. Data t => DefInfo' t -> DataType
forall t.
Data t =>
(forall b. Data b => b -> b) -> DefInfo' t -> DefInfo' t
forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> DefInfo' t -> u
forall t u.
Data t =>
(forall d. Data d => d -> u) -> DefInfo' t -> [u]
forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r
forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r
forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DefInfo' t)
forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefInfo' t -> c (DefInfo' t)
forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DefInfo' t))
forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DefInfo' t))
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 (DefInfo' t)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefInfo' t -> c (DefInfo' t)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DefInfo' t))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
$cgmapMo :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
$cgmapMp :: forall t (m :: * -> *).
(Data t, MonadPlus m) =>
(forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
$cgmapM :: forall t (m :: * -> *).
(Data t, Monad m) =>
(forall d. Data d => d -> m d) -> DefInfo' t -> m (DefInfo' t)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DefInfo' t -> u
$cgmapQi :: forall t u.
Data t =>
Int -> (forall d. Data d => d -> u) -> DefInfo' t -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> DefInfo' t -> [u]
$cgmapQ :: forall t u.
Data t =>
(forall d. Data d => d -> u) -> DefInfo' t -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r
$cgmapQr :: forall t r r'.
Data t =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r
$cgmapQl :: forall t r r'.
Data t =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DefInfo' t -> r
gmapT :: (forall b. Data b => b -> b) -> DefInfo' t -> DefInfo' t
$cgmapT :: forall t.
Data t =>
(forall b. Data b => b -> b) -> DefInfo' t -> DefInfo' t
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DefInfo' t))
$cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (DefInfo' t))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (DefInfo' t))
$cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
(Data t, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (DefInfo' t))
dataTypeOf :: DefInfo' t -> DataType
$cdataTypeOf :: forall t. Data t => DefInfo' t -> DataType
toConstr :: DefInfo' t -> Constr
$ctoConstr :: forall t. Data t => DefInfo' t -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DefInfo' t)
$cgunfold :: forall t (c :: * -> *).
Data t =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (DefInfo' t)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefInfo' t -> c (DefInfo' t)
$cgfoldl :: forall t (c :: * -> *).
Data t =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DefInfo' t -> c (DefInfo' t)
Data, Int -> DefInfo' t -> ShowS
forall t. Show t => Int -> DefInfo' t -> ShowS
forall t. Show t => [DefInfo' t] -> ShowS
forall t. Show t => DefInfo' t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DefInfo' t] -> ShowS
$cshowList :: forall t. Show t => [DefInfo' t] -> ShowS
show :: DefInfo' t -> String
$cshow :: forall t. Show t => DefInfo' t -> String
showsPrec :: Int -> DefInfo' t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> DefInfo' t -> ShowS
Show, DefInfo' t -> DefInfo' t -> Bool
forall t. Eq t => DefInfo' t -> DefInfo' t -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DefInfo' t -> DefInfo' t -> Bool
$c/= :: forall t. Eq t => DefInfo' t -> DefInfo' t -> Bool
== :: DefInfo' t -> DefInfo' t -> Bool
$c== :: forall t. Eq t => DefInfo' t -> DefInfo' t -> Bool
Eq, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall t x. Rep (DefInfo' t) x -> DefInfo' t
forall t x. DefInfo' t -> Rep (DefInfo' t) x
$cto :: forall t x. Rep (DefInfo' t) x -> DefInfo' t
$cfrom :: forall t x. DefInfo' t -> Rep (DefInfo' t) x
Generic)

mkDefInfo :: Name -> Fixity' -> Access -> IsAbstract -> Range -> DefInfo' t
mkDefInfo :: forall t.
Name -> Fixity' -> Access -> IsAbstract -> Range -> DefInfo' t
mkDefInfo Name
x Fixity'
f Access
a IsAbstract
ab Range
r = forall t.
Name
-> Fixity'
-> Access
-> IsAbstract
-> IsInstance
-> IsMacro
-> Range
-> DefInfo' t
mkDefInfoInstance Name
x Fixity'
f Access
a IsAbstract
ab IsInstance
NotInstanceDef IsMacro
NotMacroDef Range
r

-- | Same as @mkDefInfo@ but where we can also give the @IsInstance@
mkDefInfoInstance :: Name -> Fixity' -> Access -> IsAbstract -> IsInstance -> IsMacro -> Range -> DefInfo' t
mkDefInfoInstance :: forall t.
Name
-> Fixity'
-> Access
-> IsAbstract
-> IsInstance
-> IsMacro
-> Range
-> DefInfo' t
mkDefInfoInstance Name
x Fixity'
f Access
a IsAbstract
ab IsInstance
i IsMacro
m Range
r = forall t.
Fixity'
-> Access
-> IsAbstract
-> IsInstance
-> IsMacro
-> DeclInfo
-> Maybe t
-> DefInfo' t
DefInfo Fixity'
f Access
a IsAbstract
ab IsInstance
i IsMacro
m (Name -> Range -> DeclInfo
DeclInfo Name
x Range
r) forall a. Maybe a
Nothing

instance HasRange (DefInfo' t) where
  getRange :: DefInfo' t -> Range
getRange = forall a. HasRange a => a -> Range
getRange forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t. DefInfo' t -> DeclInfo
defInfo

instance SetRange (DefInfo' t) where
  setRange :: Range -> DefInfo' t -> DefInfo' t
setRange Range
r DefInfo' t
i = DefInfo' t
i { defInfo :: DeclInfo
defInfo = forall a. SetRange a => Range -> a -> a
setRange Range
r (forall t. DefInfo' t -> DeclInfo
defInfo DefInfo' t
i) }

instance KillRange t => KillRange (DefInfo' t) where
  killRange :: KillRangeT (DefInfo' t)
killRange DefInfo' t
i = DefInfo' t
i { defInfo :: DeclInfo
defInfo   = forall a. KillRange a => KillRangeT a
killRange forall a b. (a -> b) -> a -> b
$ forall t. DefInfo' t -> DeclInfo
defInfo DefInfo' t
i,
                    defTactic :: Maybe t
defTactic = forall a. KillRange a => KillRangeT a
killRange forall a b. (a -> b) -> a -> b
$ forall t. DefInfo' t -> Maybe t
defTactic DefInfo' t
i }

instance LensIsAbstract (DefInfo' t) where
  lensIsAbstract :: Lens' IsAbstract (DefInfo' t)
lensIsAbstract IsAbstract -> f IsAbstract
f DefInfo' t
i = (IsAbstract -> f IsAbstract
f forall a b. (a -> b) -> a -> b
$! forall t. DefInfo' t -> IsAbstract
defAbstract DefInfo' t
i) forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
<&> \ IsAbstract
a -> DefInfo' t
i { defAbstract :: IsAbstract
defAbstract = IsAbstract
a }

instance AnyIsAbstract (DefInfo' t) where
  anyIsAbstract :: DefInfo' t -> IsAbstract
anyIsAbstract = forall t. DefInfo' t -> IsAbstract
defAbstract

instance NFData t => NFData (DefInfo' t)

{--------------------------------------------------------------------------
    General declaration information
 --------------------------------------------------------------------------}

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

instance HasRange DeclInfo where
  getRange :: DeclInfo -> Range
getRange = DeclInfo -> Range
declRange

instance SetRange DeclInfo where
  setRange :: Range -> DeclInfo -> DeclInfo
setRange Range
r DeclInfo
i = DeclInfo
i { declRange :: Range
declRange = Range
r }

instance KillRange DeclInfo where
  killRange :: DeclInfo -> DeclInfo
killRange DeclInfo
i = DeclInfo
i { declRange :: Range
declRange = forall a. Range' a
noRange }

instance NFData DeclInfo

{--------------------------------------------------------------------------
    Mutual block information
 --------------------------------------------------------------------------}

data MutualInfo = MutualInfo
  { MutualInfo -> TerminationCheck Name
mutualTerminationCheck :: TerminationCheck Name
  , MutualInfo -> CoverageCheck
mutualCoverageCheck    :: CoverageCheck
  , MutualInfo -> PositivityCheck
mutualPositivityCheck  :: PositivityCheck
  , MutualInfo -> Range
mutualRange            :: Range
  }
  deriving (Typeable MutualInfo
MutualInfo -> Constr
MutualInfo -> DataType
(forall b. Data b => b -> b) -> MutualInfo -> MutualInfo
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) -> MutualInfo -> u
forall u. (forall d. Data d => d -> u) -> MutualInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MutualInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MutualInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MutualInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MutualInfo -> c MutualInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MutualInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MutualInfo)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MutualInfo -> m MutualInfo
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MutualInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MutualInfo -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> MutualInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MutualInfo -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MutualInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MutualInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MutualInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MutualInfo -> r
gmapT :: (forall b. Data b => b -> b) -> MutualInfo -> MutualInfo
$cgmapT :: (forall b. Data b => b -> b) -> MutualInfo -> MutualInfo
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MutualInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MutualInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MutualInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MutualInfo)
dataTypeOf :: MutualInfo -> DataType
$cdataTypeOf :: MutualInfo -> DataType
toConstr :: MutualInfo -> Constr
$ctoConstr :: MutualInfo -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MutualInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MutualInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MutualInfo -> c MutualInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MutualInfo -> c MutualInfo
Data, Int -> MutualInfo -> ShowS
[MutualInfo] -> ShowS
MutualInfo -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MutualInfo] -> ShowS
$cshowList :: [MutualInfo] -> ShowS
show :: MutualInfo -> String
$cshow :: MutualInfo -> String
showsPrec :: Int -> MutualInfo -> ShowS
$cshowsPrec :: Int -> MutualInfo -> ShowS
Show, MutualInfo -> MutualInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MutualInfo -> MutualInfo -> Bool
$c/= :: MutualInfo -> MutualInfo -> Bool
== :: MutualInfo -> MutualInfo -> Bool
$c== :: MutualInfo -> MutualInfo -> Bool
Eq, forall x. Rep MutualInfo x -> MutualInfo
forall x. MutualInfo -> Rep MutualInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MutualInfo x -> MutualInfo
$cfrom :: forall x. MutualInfo -> Rep MutualInfo x
Generic)

-- | Default value for 'MutualInfo'.
instance Null MutualInfo where
  empty :: MutualInfo
empty = TerminationCheck Name
-> CoverageCheck -> PositivityCheck -> Range -> MutualInfo
MutualInfo forall m. TerminationCheck m
TerminationCheck CoverageCheck
YesCoverageCheck PositivityCheck
YesPositivityCheck forall a. Range' a
noRange

instance HasRange MutualInfo where
  getRange :: MutualInfo -> Range
getRange = MutualInfo -> Range
mutualRange

instance KillRange MutualInfo where
  killRange :: MutualInfo -> MutualInfo
killRange MutualInfo
i = MutualInfo
i { mutualRange :: Range
mutualRange = forall a. Range' a
noRange }

instance NFData MutualInfo

{--------------------------------------------------------------------------
    Left hand side information
 --------------------------------------------------------------------------}

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

instance HasRange LHSInfo where
  getRange :: LHSInfo -> Range
getRange (LHSInfo Range
r ExpandedEllipsis
_) = Range
r

instance KillRange LHSInfo where
  killRange :: LHSInfo -> LHSInfo
killRange (LHSInfo Range
r ExpandedEllipsis
ell) = Range -> ExpandedEllipsis -> LHSInfo
LHSInfo forall a. Range' a
noRange ExpandedEllipsis
ell

instance Null LHSInfo where
  null :: LHSInfo -> Bool
null LHSInfo
i = forall a. Null a => a -> Bool
null (LHSInfo -> Range
lhsRange LHSInfo
i) Bool -> Bool -> Bool
&& forall a. Null a => a -> Bool
null (LHSInfo -> ExpandedEllipsis
lhsEllipsis LHSInfo
i)
  empty :: LHSInfo
empty  = Range -> ExpandedEllipsis -> LHSInfo
LHSInfo forall a. Null a => a
empty forall a. Null a => a
empty

instance NFData LHSInfo

{--------------------------------------------------------------------------
    Pattern information
 --------------------------------------------------------------------------}

-- | For a general pattern we remember the source code position.
newtype PatInfo
  = PatRange Range
  deriving (Typeable PatInfo
PatInfo -> Constr
PatInfo -> DataType
(forall b. Data b => b -> b) -> PatInfo -> PatInfo
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) -> PatInfo -> u
forall u. (forall d. Data d => d -> u) -> PatInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatInfo -> c PatInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PatInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatInfo)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PatInfo -> m PatInfo
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PatInfo -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> PatInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PatInfo -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PatInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PatInfo -> r
gmapT :: (forall b. Data b => b -> b) -> PatInfo -> PatInfo
$cgmapT :: (forall b. Data b => b -> b) -> PatInfo -> PatInfo
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PatInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PatInfo)
dataTypeOf :: PatInfo -> DataType
$cdataTypeOf :: PatInfo -> DataType
toConstr :: PatInfo -> Constr
$ctoConstr :: PatInfo -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PatInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatInfo -> c PatInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PatInfo -> c PatInfo
Data, PatInfo -> PatInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PatInfo -> PatInfo -> Bool
$c/= :: PatInfo -> PatInfo -> Bool
== :: PatInfo -> PatInfo -> Bool
$c== :: PatInfo -> PatInfo -> Bool
Eq, PatInfo
PatInfo -> Bool
forall a. a -> (a -> Bool) -> Null a
null :: PatInfo -> Bool
$cnull :: PatInfo -> Bool
empty :: PatInfo
$cempty :: PatInfo
Null, NonEmpty PatInfo -> PatInfo
PatInfo -> PatInfo -> PatInfo
forall b. Integral b => b -> PatInfo -> PatInfo
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: forall b. Integral b => b -> PatInfo -> PatInfo
$cstimes :: forall b. Integral b => b -> PatInfo -> PatInfo
sconcat :: NonEmpty PatInfo -> PatInfo
$csconcat :: NonEmpty PatInfo -> PatInfo
<> :: PatInfo -> PatInfo -> PatInfo
$c<> :: PatInfo -> PatInfo -> PatInfo
Semigroup, Semigroup PatInfo
PatInfo
[PatInfo] -> PatInfo
PatInfo -> PatInfo -> PatInfo
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
mconcat :: [PatInfo] -> PatInfo
$cmconcat :: [PatInfo] -> PatInfo
mappend :: PatInfo -> PatInfo -> PatInfo
$cmappend :: PatInfo -> PatInfo -> PatInfo
mempty :: PatInfo
$cmempty :: PatInfo
Monoid, Int -> PatInfo -> ShowS
[PatInfo] -> ShowS
PatInfo -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PatInfo] -> ShowS
$cshowList :: [PatInfo] -> ShowS
show :: PatInfo -> String
$cshow :: PatInfo -> String
showsPrec :: Int -> PatInfo -> ShowS
$cshowsPrec :: Int -> PatInfo -> ShowS
Show, HasRange PatInfo
Range -> PatInfo -> PatInfo
forall a. HasRange a -> (Range -> a -> a) -> SetRange a
setRange :: Range -> PatInfo -> PatInfo
$csetRange :: Range -> PatInfo -> PatInfo
SetRange, PatInfo -> Range
forall a. (a -> Range) -> HasRange a
getRange :: PatInfo -> Range
$cgetRange :: PatInfo -> Range
HasRange,
            PatInfo -> PatInfo
forall a. KillRangeT a -> KillRange a
killRange :: PatInfo -> PatInfo
$ckillRange :: PatInfo -> PatInfo
KillRange, PatInfo -> ()
forall a. (a -> ()) -> NFData a
rnf :: PatInfo -> ()
$crnf :: PatInfo -> ()
NFData)

-- | Empty range for patterns.
patNoRange :: PatInfo
patNoRange :: PatInfo
patNoRange = Range -> PatInfo
PatRange forall a. Range' a
noRange

-- | Constructor pattern info.
data ConPatInfo = ConPatInfo
  { ConPatInfo -> ConOrigin
conPatOrigin   :: ConOrigin
    -- ^ Does this pattern come form the eta-expansion of an implicit pattern?
    ---  Or from a user written constructor or record pattern?
  , ConPatInfo -> PatInfo
conPatInfo     :: PatInfo
  , ConPatInfo -> ConPatLazy
conPatLazy     :: ConPatLazy
  }
  deriving (Typeable ConPatInfo
ConPatInfo -> Constr
ConPatInfo -> DataType
(forall b. Data b => b -> b) -> ConPatInfo -> ConPatInfo
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) -> ConPatInfo -> u
forall u. (forall d. Data d => d -> u) -> ConPatInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConPatInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConPatInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConPatInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConPatInfo -> c ConPatInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConPatInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConPatInfo)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConPatInfo -> m ConPatInfo
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConPatInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConPatInfo -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ConPatInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ConPatInfo -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConPatInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConPatInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConPatInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConPatInfo -> r
gmapT :: (forall b. Data b => b -> b) -> ConPatInfo -> ConPatInfo
$cgmapT :: (forall b. Data b => b -> b) -> ConPatInfo -> ConPatInfo
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConPatInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConPatInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConPatInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConPatInfo)
dataTypeOf :: ConPatInfo -> DataType
$cdataTypeOf :: ConPatInfo -> DataType
toConstr :: ConPatInfo -> Constr
$ctoConstr :: ConPatInfo -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConPatInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConPatInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConPatInfo -> c ConPatInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConPatInfo -> c ConPatInfo
Data, ConPatInfo -> ConPatInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConPatInfo -> ConPatInfo -> Bool
$c/= :: ConPatInfo -> ConPatInfo -> Bool
== :: ConPatInfo -> ConPatInfo -> Bool
$c== :: ConPatInfo -> ConPatInfo -> Bool
Eq, Int -> ConPatInfo -> ShowS
[ConPatInfo] -> ShowS
ConPatInfo -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConPatInfo] -> ShowS
$cshowList :: [ConPatInfo] -> ShowS
show :: ConPatInfo -> String
$cshow :: ConPatInfo -> String
showsPrec :: Int -> ConPatInfo -> ShowS
$cshowsPrec :: Int -> ConPatInfo -> ShowS
Show, forall x. Rep ConPatInfo x -> ConPatInfo
forall x. ConPatInfo -> Rep ConPatInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ConPatInfo x -> ConPatInfo
$cfrom :: forall x. ConPatInfo -> Rep ConPatInfo x
Generic)

instance HasRange ConPatInfo where
  getRange :: ConPatInfo -> Range
getRange = forall a. HasRange a => a -> Range
getRange forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConPatInfo -> PatInfo
conPatInfo

instance KillRange ConPatInfo where
  killRange :: ConPatInfo -> ConPatInfo
killRange (ConPatInfo ConOrigin
b PatInfo
i ConPatLazy
l) = ConOrigin -> PatInfo -> ConPatLazy -> ConPatInfo
ConPatInfo ConOrigin
b (forall a. KillRange a => KillRangeT a
killRange PatInfo
i) ConPatLazy
l

instance SetRange ConPatInfo where
  setRange :: Range -> ConPatInfo -> ConPatInfo
setRange Range
r (ConPatInfo ConOrigin
b PatInfo
i ConPatLazy
l) = ConOrigin -> PatInfo -> ConPatLazy -> ConPatInfo
ConPatInfo ConOrigin
b (Range -> PatInfo
PatRange Range
r) ConPatLazy
l

instance NFData ConPatInfo

-- | Has the constructor pattern a dotted (forced) constructor?
data ConPatLazy
  = ConPatLazy   -- ^ Dotted constructor.
  | ConPatEager  -- ^ Ordinary constructor.
  deriving (Typeable ConPatLazy
ConPatLazy -> Constr
ConPatLazy -> DataType
(forall b. Data b => b -> b) -> ConPatLazy -> ConPatLazy
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) -> ConPatLazy -> u
forall u. (forall d. Data d => d -> u) -> ConPatLazy -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConPatLazy -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConPatLazy -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConPatLazy
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConPatLazy -> c ConPatLazy
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConPatLazy)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConPatLazy)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConPatLazy -> m ConPatLazy
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConPatLazy -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConPatLazy -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ConPatLazy -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ConPatLazy -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConPatLazy -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConPatLazy -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConPatLazy -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConPatLazy -> r
gmapT :: (forall b. Data b => b -> b) -> ConPatLazy -> ConPatLazy
$cgmapT :: (forall b. Data b => b -> b) -> ConPatLazy -> ConPatLazy
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConPatLazy)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConPatLazy)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConPatLazy)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConPatLazy)
dataTypeOf :: ConPatLazy -> DataType
$cdataTypeOf :: ConPatLazy -> DataType
toConstr :: ConPatLazy -> Constr
$ctoConstr :: ConPatLazy -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConPatLazy
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConPatLazy
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConPatLazy -> c ConPatLazy
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConPatLazy -> c ConPatLazy
Data, ConPatLazy -> ConPatLazy -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConPatLazy -> ConPatLazy -> Bool
$c/= :: ConPatLazy -> ConPatLazy -> Bool
== :: ConPatLazy -> ConPatLazy -> Bool
$c== :: ConPatLazy -> ConPatLazy -> Bool
Eq, Eq ConPatLazy
ConPatLazy -> ConPatLazy -> Bool
ConPatLazy -> ConPatLazy -> Ordering
ConPatLazy -> ConPatLazy -> ConPatLazy
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 :: ConPatLazy -> ConPatLazy -> ConPatLazy
$cmin :: ConPatLazy -> ConPatLazy -> ConPatLazy
max :: ConPatLazy -> ConPatLazy -> ConPatLazy
$cmax :: ConPatLazy -> ConPatLazy -> ConPatLazy
>= :: ConPatLazy -> ConPatLazy -> Bool
$c>= :: ConPatLazy -> ConPatLazy -> Bool
> :: ConPatLazy -> ConPatLazy -> Bool
$c> :: ConPatLazy -> ConPatLazy -> Bool
<= :: ConPatLazy -> ConPatLazy -> Bool
$c<= :: ConPatLazy -> ConPatLazy -> Bool
< :: ConPatLazy -> ConPatLazy -> Bool
$c< :: ConPatLazy -> ConPatLazy -> Bool
compare :: ConPatLazy -> ConPatLazy -> Ordering
$ccompare :: ConPatLazy -> ConPatLazy -> Ordering
Ord, Int -> ConPatLazy -> ShowS
[ConPatLazy] -> ShowS
ConPatLazy -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConPatLazy] -> ShowS
$cshowList :: [ConPatLazy] -> ShowS
show :: ConPatLazy -> String
$cshow :: ConPatLazy -> String
showsPrec :: Int -> ConPatLazy -> ShowS
$cshowsPrec :: Int -> ConPatLazy -> ShowS
Show, ConPatLazy
forall a. a -> a -> Bounded a
maxBound :: ConPatLazy
$cmaxBound :: ConPatLazy
minBound :: ConPatLazy
$cminBound :: ConPatLazy
Bounded, Int -> ConPatLazy
ConPatLazy -> Int
ConPatLazy -> [ConPatLazy]
ConPatLazy -> ConPatLazy
ConPatLazy -> ConPatLazy -> [ConPatLazy]
ConPatLazy -> ConPatLazy -> ConPatLazy -> [ConPatLazy]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: ConPatLazy -> ConPatLazy -> ConPatLazy -> [ConPatLazy]
$cenumFromThenTo :: ConPatLazy -> ConPatLazy -> ConPatLazy -> [ConPatLazy]
enumFromTo :: ConPatLazy -> ConPatLazy -> [ConPatLazy]
$cenumFromTo :: ConPatLazy -> ConPatLazy -> [ConPatLazy]
enumFromThen :: ConPatLazy -> ConPatLazy -> [ConPatLazy]
$cenumFromThen :: ConPatLazy -> ConPatLazy -> [ConPatLazy]
enumFrom :: ConPatLazy -> [ConPatLazy]
$cenumFrom :: ConPatLazy -> [ConPatLazy]
fromEnum :: ConPatLazy -> Int
$cfromEnum :: ConPatLazy -> Int
toEnum :: Int -> ConPatLazy
$ctoEnum :: Int -> ConPatLazy
pred :: ConPatLazy -> ConPatLazy
$cpred :: ConPatLazy -> ConPatLazy
succ :: ConPatLazy -> ConPatLazy
$csucc :: ConPatLazy -> ConPatLazy
Enum, forall x. Rep ConPatLazy x -> ConPatLazy
forall x. ConPatLazy -> Rep ConPatLazy x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ConPatLazy x -> ConPatLazy
$cfrom :: forall x. ConPatLazy -> Rep ConPatLazy x
Generic)

instance NFData ConPatLazy