haskell-tools-ast-0.4.1.2: Haskell AST for efficient tooling

Safe HaskellNone
LanguageHaskell2010

Language.Haskell.Tools.AST.SemaInfoTypes

Contents

Synopsis

Documentation

data NoSemanticInfo Source #

Semantic info type for any node not carrying additional semantic information

Instances

Eq NoSemanticInfo Source # 
Data NoSemanticInfo Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NoSemanticInfo -> c NoSemanticInfo #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NoSemanticInfo #

toConstr :: NoSemanticInfo -> Constr #

dataTypeOf :: NoSemanticInfo -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c NoSemanticInfo) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NoSemanticInfo) #

gmapT :: (forall b. Data b => b -> b) -> NoSemanticInfo -> NoSemanticInfo #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NoSemanticInfo -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NoSemanticInfo -> r #

gmapQ :: (forall d. Data d => d -> u) -> NoSemanticInfo -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NoSemanticInfo -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NoSemanticInfo -> m NoSemanticInfo #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NoSemanticInfo -> m NoSemanticInfo #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NoSemanticInfo -> m NoSemanticInfo #

Show NoSemanticInfo Source # 

data ScopeInfo Source #

Info for expressions that tells which definitions are in scope

Instances

Eq ScopeInfo Source # 
Data ScopeInfo Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ScopeInfo -> c ScopeInfo #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ScopeInfo #

toConstr :: ScopeInfo -> Constr #

dataTypeOf :: ScopeInfo -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ScopeInfo) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ScopeInfo) #

gmapT :: (forall b. Data b => b -> b) -> ScopeInfo -> ScopeInfo #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ScopeInfo -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ScopeInfo -> r #

gmapQ :: (forall d. Data d => d -> u) -> ScopeInfo -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ScopeInfo -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ScopeInfo -> m ScopeInfo #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ScopeInfo -> m ScopeInfo #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ScopeInfo -> m ScopeInfo #

Show ScopeInfo Source # 
HasScopeInfo' ScopeInfo Source # 

data NameInfo n Source #

Info corresponding to a name

Instances

Functor NameInfo Source # 

Methods

fmap :: (a -> b) -> NameInfo a -> NameInfo b #

(<$) :: a -> NameInfo b -> NameInfo a #

Foldable NameInfo Source # 

Methods

fold :: Monoid m => NameInfo m -> m #

foldMap :: Monoid m => (a -> m) -> NameInfo a -> m #

foldr :: (a -> b -> b) -> b -> NameInfo a -> b #

foldr' :: (a -> b -> b) -> b -> NameInfo a -> b #

foldl :: (b -> a -> b) -> b -> NameInfo a -> b #

foldl' :: (b -> a -> b) -> b -> NameInfo a -> b #

foldr1 :: (a -> a -> a) -> NameInfo a -> a #

foldl1 :: (a -> a -> a) -> NameInfo a -> a #

toList :: NameInfo a -> [a] #

null :: NameInfo a -> Bool #

length :: NameInfo a -> Int #

elem :: Eq a => a -> NameInfo a -> Bool #

maximum :: Ord a => NameInfo a -> a #

minimum :: Ord a => NameInfo a -> a #

sum :: Num a => NameInfo a -> a #

product :: Num a => NameInfo a -> a #

Traversable NameInfo Source # 

Methods

traverse :: Applicative f => (a -> f b) -> NameInfo a -> f (NameInfo b) #

sequenceA :: Applicative f => NameInfo (f a) -> f (NameInfo a) #

mapM :: Monad m => (a -> m b) -> NameInfo a -> m (NameInfo b) #

sequence :: Monad m => NameInfo (m a) -> m (NameInfo a) #

Eq n => Eq (NameInfo n) Source # 

Methods

(==) :: NameInfo n -> NameInfo n -> Bool #

(/=) :: NameInfo n -> NameInfo n -> Bool #

Data n => Data (NameInfo n) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameInfo n -> c (NameInfo n) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NameInfo n) #

toConstr :: NameInfo n -> Constr #

dataTypeOf :: NameInfo n -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (NameInfo n)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NameInfo n)) #

gmapT :: (forall b. Data b => b -> b) -> NameInfo n -> NameInfo n #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameInfo n -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameInfo n -> r #

gmapQ :: (forall d. Data d => d -> u) -> NameInfo n -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NameInfo n -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameInfo n -> m (NameInfo n) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameInfo n -> m (NameInfo n) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameInfo n -> m (NameInfo n) #

Outputable n => Show (NameInfo n) Source # 

Methods

showsPrec :: Int -> NameInfo n -> ShowS #

show :: NameInfo n -> String #

showList :: [NameInfo n] -> ShowS #

HasSourceInfoInSema' (NameInfo n) Source # 
HasDefiningInfo' (NameInfo n) Source # 
HasScopeInfo' (NameInfo n) Source # 
HasNameInfo' (NameInfo Name) Source # 

data CNameInfo Source #

Info corresponding to a name that is correctly identified

Instances

Eq CNameInfo Source # 
Data CNameInfo Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CNameInfo -> c CNameInfo #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CNameInfo #

toConstr :: CNameInfo -> Constr #

dataTypeOf :: CNameInfo -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CNameInfo) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CNameInfo) #

gmapT :: (forall b. Data b => b -> b) -> CNameInfo -> CNameInfo #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CNameInfo -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CNameInfo -> r #

gmapQ :: (forall d. Data d => d -> u) -> CNameInfo -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CNameInfo -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CNameInfo -> m CNameInfo #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CNameInfo -> m CNameInfo #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CNameInfo -> m CNameInfo #

Show CNameInfo Source # 
HasDefiningInfo' CNameInfo Source # 
HasScopeInfo' CNameInfo Source # 
HasFixityInfo' CNameInfo Source # 
HasIdInfo' CNameInfo Source # 
HasNameInfo' CNameInfo Source # 

data ModuleInfo n Source #

Info for the module element

Instances

Functor ModuleInfo Source # 

Methods

fmap :: (a -> b) -> ModuleInfo a -> ModuleInfo b #

(<$) :: a -> ModuleInfo b -> ModuleInfo a #

Foldable ModuleInfo Source # 

Methods

fold :: Monoid m => ModuleInfo m -> m #

foldMap :: Monoid m => (a -> m) -> ModuleInfo a -> m #

foldr :: (a -> b -> b) -> b -> ModuleInfo a -> b #

foldr' :: (a -> b -> b) -> b -> ModuleInfo a -> b #

foldl :: (b -> a -> b) -> b -> ModuleInfo a -> b #

foldl' :: (b -> a -> b) -> b -> ModuleInfo a -> b #

foldr1 :: (a -> a -> a) -> ModuleInfo a -> a #

foldl1 :: (a -> a -> a) -> ModuleInfo a -> a #

toList :: ModuleInfo a -> [a] #

null :: ModuleInfo a -> Bool #

length :: ModuleInfo a -> Int #

elem :: Eq a => a -> ModuleInfo a -> Bool #

maximum :: Ord a => ModuleInfo a -> a #

minimum :: Ord a => ModuleInfo a -> a #

sum :: Num a => ModuleInfo a -> a #

product :: Num a => ModuleInfo a -> a #

Traversable ModuleInfo Source # 

Methods

traverse :: Applicative f => (a -> f b) -> ModuleInfo a -> f (ModuleInfo b) #

sequenceA :: Applicative f => ModuleInfo (f a) -> f (ModuleInfo a) #

mapM :: Monad m => (a -> m b) -> ModuleInfo a -> m (ModuleInfo b) #

sequence :: Monad m => ModuleInfo (m a) -> m (ModuleInfo a) #

Data n => Data (ModuleInfo n) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleInfo n -> c (ModuleInfo n) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ModuleInfo n) #

toConstr :: ModuleInfo n -> Constr #

dataTypeOf :: ModuleInfo n -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ModuleInfo n)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ModuleInfo n)) #

gmapT :: (forall b. Data b => b -> b) -> ModuleInfo n -> ModuleInfo n #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo n -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo n -> r #

gmapQ :: (forall d. Data d => d -> u) -> ModuleInfo n -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleInfo n -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleInfo n -> m (ModuleInfo n) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo n -> m (ModuleInfo n) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo n -> m (ModuleInfo n) #

Outputable n => Show (ModuleInfo n) Source # 
HasModuleInfo' (ModuleInfo Id) Source # 
HasModuleInfo' (ModuleInfo Name) Source # 

data ImportInfo n Source #

Info corresponding to an import declaration

Instances

Functor ImportInfo Source # 

Methods

fmap :: (a -> b) -> ImportInfo a -> ImportInfo b #

(<$) :: a -> ImportInfo b -> ImportInfo a #

Foldable ImportInfo Source # 

Methods

fold :: Monoid m => ImportInfo m -> m #

foldMap :: Monoid m => (a -> m) -> ImportInfo a -> m #

foldr :: (a -> b -> b) -> b -> ImportInfo a -> b #

foldr' :: (a -> b -> b) -> b -> ImportInfo a -> b #

foldl :: (b -> a -> b) -> b -> ImportInfo a -> b #

foldl' :: (b -> a -> b) -> b -> ImportInfo a -> b #

foldr1 :: (a -> a -> a) -> ImportInfo a -> a #

foldl1 :: (a -> a -> a) -> ImportInfo a -> a #

toList :: ImportInfo a -> [a] #

null :: ImportInfo a -> Bool #

length :: ImportInfo a -> Int #

elem :: Eq a => a -> ImportInfo a -> Bool #

maximum :: Ord a => ImportInfo a -> a #

minimum :: Ord a => ImportInfo a -> a #

sum :: Num a => ImportInfo a -> a #

product :: Num a => ImportInfo a -> a #

Traversable ImportInfo Source # 

Methods

traverse :: Applicative f => (a -> f b) -> ImportInfo a -> f (ImportInfo b) #

sequenceA :: Applicative f => ImportInfo (f a) -> f (ImportInfo a) #

mapM :: Monad m => (a -> m b) -> ImportInfo a -> m (ImportInfo b) #

sequence :: Monad m => ImportInfo (m a) -> m (ImportInfo a) #

Data n => Data (ImportInfo n) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportInfo n -> c (ImportInfo n) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportInfo n) #

toConstr :: ImportInfo n -> Constr #

dataTypeOf :: ImportInfo n -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ImportInfo n)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportInfo n)) #

gmapT :: (forall b. Data b => b -> b) -> ImportInfo n -> ImportInfo n #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportInfo n -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportInfo n -> r #

gmapQ :: (forall d. Data d => d -> u) -> ImportInfo n -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportInfo n -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportInfo n -> m (ImportInfo n) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportInfo n -> m (ImportInfo n) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportInfo n -> m (ImportInfo n) #

Outputable n => Show (ImportInfo n) Source # 
HasImportInfo' (ImportInfo Id) Source # 
HasImportInfo' (ImportInfo Name) Source # 

data ImplicitFieldInfo Source #

Info corresponding to an record-wildcard

Instances

Eq ImplicitFieldInfo Source # 
Data ImplicitFieldInfo Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImplicitFieldInfo -> c ImplicitFieldInfo #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImplicitFieldInfo #

toConstr :: ImplicitFieldInfo -> Constr #

dataTypeOf :: ImplicitFieldInfo -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ImplicitFieldInfo) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImplicitFieldInfo) #

gmapT :: (forall b. Data b => b -> b) -> ImplicitFieldInfo -> ImplicitFieldInfo #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImplicitFieldInfo -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImplicitFieldInfo -> r #

gmapQ :: (forall d. Data d => d -> u) -> ImplicitFieldInfo -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImplicitFieldInfo -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImplicitFieldInfo -> m ImplicitFieldInfo #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImplicitFieldInfo -> m ImplicitFieldInfo #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImplicitFieldInfo -> m ImplicitFieldInfo #

Show ImplicitFieldInfo Source # 
HasImplicitFieldsInfo' ImplicitFieldInfo Source # 

type Scope = [[Name]] Source #

nameInfo :: forall n n'. Partial (NameInfo n) (NameInfo n') n n' Source #

implicitNames :: forall n n'. Lens (ModuleInfo n) (ModuleInfo n') [n] [n'] Source #

availableNames :: forall n. Lens (ImportInfo n) (ImportInfo n) [n] [n] Source #

importedNames :: forall n. Lens (ImportInfo n) (ImportInfo n) [n] [n] Source #

mkScopeInfo :: Scope -> ScopeInfo Source #

Creates the information about the definitions in scope

mkNameInfo :: Scope -> Bool -> n -> NameInfo n Source #

Creates semantic information for an unambiguous name

mkAmbiguousNameInfo :: Scope -> Bool -> RdrName -> SrcSpan -> NameInfo n Source #

Creates semantic information for a name that is ambiguous because the lack of type info

mkImplicitNameInfo :: Scope -> Bool -> String -> SrcSpan -> NameInfo n Source #

Creates semantic information for an implicit name

mkCNameInfo :: Scope -> Bool -> Id -> Maybe Fixity -> CNameInfo Source #

Create a typed name semantic information

mkModuleInfo :: Module -> Bool -> [n] -> [ClsInst] -> [FamInst] -> ModuleInfo n Source #

Creates semantic information for the module element

mkImportInfo :: Module -> [n] -> [n] -> [ClsInst] -> [FamInst] -> ImportInfo n Source #

Creates semantic information for an import declaration

mkImplicitFieldInfo :: [(Name, Name)] -> ImplicitFieldInfo Source #

Creates semantic information for a wildcard field binding

Orphan instances

Data FamInst Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamInst -> c FamInst #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FamInst #

toConstr :: FamInst -> Constr #

dataTypeOf :: FamInst -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FamInst) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FamInst) #

gmapT :: (forall b. Data b => b -> b) -> FamInst -> FamInst #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamInst -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamInst -> r #

gmapQ :: (forall d. Data d => d -> u) -> FamInst -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamInst -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamInst -> m FamInst #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamInst -> m FamInst #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamInst -> m FamInst #

Data FamFlavor Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamFlavor -> c FamFlavor #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FamFlavor #

toConstr :: FamFlavor -> Constr #

dataTypeOf :: FamFlavor -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FamFlavor) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FamFlavor) #

gmapT :: (forall b. Data b => b -> b) -> FamFlavor -> FamFlavor #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamFlavor -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamFlavor -> r #

gmapQ :: (forall d. Data d => d -> u) -> FamFlavor -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamFlavor -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamFlavor -> m FamFlavor #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamFlavor -> m FamFlavor #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamFlavor -> m FamFlavor #