| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Language.Haskell.Tools.AST.Ann
Description
Parts of AST representation for keeping extra data
Synopsis
- data RangeStage
- data NormRangeStage
- data RngTemplateStage
- data SrcTemplateStage
- data Dom name
- data IdDom
- type SemanticInfo (domain :: *) (node :: * -> * -> *) = SemanticInfo' domain (SemaInfoClassify node)
- data SemaInfoNameCls
- data SemaInfoLitCls
- data SemaInfoExprCls
- data SemaInfoImportCls
- data SemaInfoModuleCls
- data SemaInfoDefaultCls
- data SemaInfoWildcardCls
- type family SemaInfoClassify (node :: * -> * -> *) where ...
- type family SemanticInfo' (domain :: *) (nodecls :: *)
- type Domain d = (Typeable d, Data d, SemanticInfo' d SemaInfoDefaultCls ~ NoSemanticInfo, Data (SemanticInfo' d SemaInfoNameCls), Data (SemanticInfo' d SemaInfoLitCls), Data (SemanticInfo' d SemaInfoExprCls), Data (SemanticInfo' d SemaInfoImportCls), Data (SemanticInfo' d SemaInfoModuleCls), Data (SemanticInfo' d SemaInfoWildcardCls))
- type DomainWith e d = (Data (SemanticInfo' d (SemaInfoClassify e)), Domain d)
- class HasRange a where
- class (Typeable stage, Data stage, Data (SpanInfo stage), Data (ListInfo stage), Data (OptionalInfo stage), HasRange (SpanInfo stage), HasRange (ListInfo stage), HasRange (OptionalInfo stage)) => SourceInfo stage where
- shortShowSpan :: SrcSpan -> String
- shortShowSpanWithFile :: SrcSpan -> String
- shortShowLoc :: SrcLoc -> String
- class SourceInfo stage => RangeInfo stage where
- data NodeInfo sema src = NodeInfo {
- _semanticInfo :: sema
- _sourceInfo :: src
- sourceInfo :: forall sema src src'. Lens (NodeInfo sema src) (NodeInfo sema src') src src'
- semanticInfo :: forall sema src sema'. Lens (NodeInfo sema src) (NodeInfo sema' src) sema sema'
- data Ann elem dom stage = Ann {
- _annotation :: NodeInfo (SemanticInfo dom elem) (SpanInfo stage)
- _element :: elem dom stage
- element :: forall elem dom stage. Lens (Ann elem dom stage) (Ann elem dom stage) (elem dom stage) (elem dom stage)
- annotation :: forall elem dom stage. Lens (Ann elem dom stage) (Ann elem dom stage) (NodeInfo (SemanticInfo dom elem) (SpanInfo stage)) (NodeInfo (SemanticInfo dom elem) (SpanInfo stage))
- data AnnListG elem dom stage = AnnListG {
- _annListAnnot :: NodeInfo (SemanticInfo dom (AnnListG elem)) (ListInfo stage)
- _annListElems :: [Ann elem dom stage]
- annListElems :: forall elem dom stage. Lens (AnnListG elem dom stage) (AnnListG elem dom stage) [Ann elem dom stage] [Ann elem dom stage]
- annListAnnot :: forall elem dom stage. Lens (AnnListG elem dom stage) (AnnListG elem dom stage) (NodeInfo (SemanticInfo dom (AnnListG elem)) (ListInfo stage)) (NodeInfo (SemanticInfo dom (AnnListG elem)) (ListInfo stage))
- annList :: Traversal (AnnListG e d s) (AnnListG e d s) (Ann e d s) (Ann e d s)
- data AnnMaybeG elem dom stage = AnnMaybeG {
- _annMaybeAnnot :: NodeInfo (SemanticInfo dom (AnnMaybeG elem)) (OptionalInfo stage)
- _annMaybe :: Maybe (Ann elem dom stage)
- annMaybeAnnot :: forall elem dom stage. Lens (AnnMaybeG elem dom stage) (AnnMaybeG elem dom stage) (NodeInfo (SemanticInfo dom (AnnMaybeG elem)) (OptionalInfo stage)) (NodeInfo (SemanticInfo dom (AnnMaybeG elem)) (OptionalInfo stage))
- annMaybe :: forall elem dom stage. Lens (AnnMaybeG elem dom stage) (AnnMaybeG elem dom stage) (Maybe (Ann elem dom stage)) (Maybe (Ann elem dom stage))
- class HasSourceInfo e where
- type SourceInfoType e :: *
- annJust :: Partial (AnnMaybeG e d s) (AnnMaybeG e d s) (Ann e d s) (Ann e d s)
- annNil :: NodeInfo (SemanticInfo d (AnnListG e)) (ListInfo s) -> AnnListG e d s
- isAnnNothing :: AnnMaybeG e d s -> Bool
- isAnnJust :: AnnMaybeG e d s -> Bool
- annLength :: AnnListG e d s -> Int
- annNothing :: NodeInfo (SemanticInfo d (AnnMaybeG e)) (OptionalInfo s) -> AnnMaybeG e d s
- class ApplySemaChange cls where
- class ApplySemaChange (SemaInfoClassify a) => SemanticTraversal a where
- data SemaTrf f dom1 dom2 = SemaTrf {
- trfSemaNameCls :: SemanticInfo' dom1 SemaInfoNameCls -> f (SemanticInfo' dom2 SemaInfoNameCls)
- trfSemaExprCls :: SemanticInfo' dom1 SemaInfoExprCls -> f (SemanticInfo' dom2 SemaInfoExprCls)
- trfSemaLitCls :: SemanticInfo' dom1 SemaInfoLitCls -> f (SemanticInfo' dom2 SemaInfoLitCls)
- trfSemaImportCls :: SemanticInfo' dom1 SemaInfoImportCls -> f (SemanticInfo' dom2 SemaInfoImportCls)
- trfSemaModuleCls :: SemanticInfo' dom1 SemaInfoModuleCls -> f (SemanticInfo' dom2 SemaInfoModuleCls)
- trfSemaWildcardCls :: SemanticInfo' dom1 SemaInfoWildcardCls -> f (SemanticInfo' dom2 SemaInfoWildcardCls)
- trfSemaDefault :: SemanticInfo' dom1 SemaInfoDefaultCls -> f (SemanticInfo' dom2 SemaInfoDefaultCls)
- class SourceInfoTraversal a where
- data SourceInfoTrf f st1 st2 = SourceInfoTrf {
- trfSpanInfo :: SpanInfo st1 -> f (SpanInfo st2)
- trfListInfo :: ListInfo st1 -> f (ListInfo st2)
- trfOptionalInfo :: OptionalInfo st1 -> f (OptionalInfo st2)
Annotation type resolution
data RangeStage #
A stage in which the nodes are marked with the ranges in the source files which contain the source code of the given AST element.
Instances
data NormRangeStage #
A stage in which the nodes are still marked with ranges, but these ranges are normalized. Optional and list elements also have ranges in that state.
Instances
data RngTemplateStage #
A stage in which AST elements are marked with templates. These templates are hierarchical, and contain the places of the children elements of the node.
Instances
| Data RngTemplateStage # | |
Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RngTemplateStage -> c RngTemplateStage # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RngTemplateStage # toConstr :: RngTemplateStage -> Constr # dataTypeOf :: RngTemplateStage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RngTemplateStage) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RngTemplateStage) # gmapT :: (forall b. Data b => b -> b) -> RngTemplateStage -> RngTemplateStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RngTemplateStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RngTemplateStage -> r # gmapQ :: (forall d. Data d => d -> u) -> RngTemplateStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RngTemplateStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RngTemplateStage -> m RngTemplateStage # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RngTemplateStage -> m RngTemplateStage # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RngTemplateStage -> m RngTemplateStage # | |
data SrcTemplateStage #
A stage where the annotation controls how the original source code can be retrieved from the AST. A source template is assigned to each node. It has holes where the content of an other node should be printed and ranges for the source code of the node.
Instances
| Data SrcTemplateStage # | |
Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcTemplateStage -> c SrcTemplateStage # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcTemplateStage # toConstr :: SrcTemplateStage -> Constr # dataTypeOf :: SrcTemplateStage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcTemplateStage) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcTemplateStage) # gmapT :: (forall b. Data b => b -> b) -> SrcTemplateStage -> SrcTemplateStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcTemplateStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcTemplateStage -> r # gmapQ :: (forall d. Data d => d -> u) -> SrcTemplateStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcTemplateStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcTemplateStage -> m SrcTemplateStage # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcTemplateStage -> m SrcTemplateStage # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcTemplateStage -> m SrcTemplateStage # | |
With this domain, semantic information can be parameterized. In practice it is only used if the compilation cannot proceed past the type checking phase.
Instances
| (Data name, Typeable name) => Data (Dom name) # | |
Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dom name -> c (Dom name) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dom name) # toConstr :: Dom name -> Constr # dataTypeOf :: Dom name -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Dom name)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dom name)) # gmapT :: (forall b. Data b => b -> b) -> Dom name -> Dom name # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dom name -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dom name -> r # gmapQ :: (forall d. Data d => d -> u) -> Dom name -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Dom name -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dom name -> m (Dom name) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dom name -> m (Dom name) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dom name -> m (Dom name) # | |
| type SemanticInfo' (Dom n) SemaInfoDefaultCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' (Dom n) SemaInfoWildcardCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' (Dom n) SemaInfoModuleCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' (Dom n) SemaInfoImportCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' (Dom n) SemaInfoExprCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' (Dom n) SemaInfoLitCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' (Dom n) SemaInfoNameCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
Instances
| Data IdDom # | |
Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IdDom -> c IdDom # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IdDom # dataTypeOf :: IdDom -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IdDom) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IdDom) # gmapT :: (forall b. Data b => b -> b) -> IdDom -> IdDom # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IdDom -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IdDom -> r # gmapQ :: (forall d. Data d => d -> u) -> IdDom -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IdDom -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IdDom -> m IdDom # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IdDom -> m IdDom # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IdDom -> m IdDom # | |
| type SemanticInfo' IdDom SemaInfoWildcardCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' IdDom SemaInfoDefaultCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' IdDom SemaInfoModuleCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' IdDom SemaInfoImportCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' IdDom SemaInfoExprCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' IdDom SemaInfoLitCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' IdDom SemaInfoNameCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
type SemanticInfo (domain :: *) (node :: * -> * -> *) = SemanticInfo' domain (SemaInfoClassify node) #
data SemaInfoNameCls #
Instances
| ApplySemaChange SemaInfoNameCls # | |
Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoNameCls -> f (SemanticInfo' dom2 SemaInfoNameCls) # | |
| type SemanticInfo' IdDom SemaInfoNameCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' (Dom n) SemaInfoNameCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
data SemaInfoLitCls #
Instances
| ApplySemaChange SemaInfoLitCls # | |
Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoLitCls -> f (SemanticInfo' dom2 SemaInfoLitCls) # | |
| type SemanticInfo' IdDom SemaInfoLitCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' (Dom n) SemaInfoLitCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
data SemaInfoExprCls #
Instances
| ApplySemaChange SemaInfoExprCls # | |
Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoExprCls -> f (SemanticInfo' dom2 SemaInfoExprCls) # | |
| type SemanticInfo' IdDom SemaInfoExprCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' (Dom n) SemaInfoExprCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
data SemaInfoImportCls #
Instances
| ApplySemaChange SemaInfoImportCls # | |
Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoImportCls -> f (SemanticInfo' dom2 SemaInfoImportCls) # | |
| type SemanticInfo' IdDom SemaInfoImportCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' (Dom n) SemaInfoImportCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
data SemaInfoModuleCls #
Instances
| ApplySemaChange SemaInfoModuleCls # | |
Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoModuleCls -> f (SemanticInfo' dom2 SemaInfoModuleCls) # | |
| type SemanticInfo' IdDom SemaInfoModuleCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' (Dom n) SemaInfoModuleCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
data SemaInfoDefaultCls #
Instances
| ApplySemaChange SemaInfoDefaultCls # | |
Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoDefaultCls -> f (SemanticInfo' dom2 SemaInfoDefaultCls) # | |
| type SemanticInfo' IdDom SemaInfoDefaultCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' (Dom n) SemaInfoDefaultCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
data SemaInfoWildcardCls #
Instances
| ApplySemaChange SemaInfoWildcardCls # | |
Defined in Language.Haskell.Tools.AST.Ann Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoWildcardCls -> f (SemanticInfo' dom2 SemaInfoWildcardCls) # | |
| type SemanticInfo' IdDom SemaInfoWildcardCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| type SemanticInfo' (Dom n) SemaInfoWildcardCls # | |
Defined in Language.Haskell.Tools.AST.Ann | |
type family SemaInfoClassify (node :: * -> * -> *) where ... #
Equations
type family SemanticInfo' (domain :: *) (nodecls :: *) #
Instances
type Domain d = (Typeable d, Data d, SemanticInfo' d SemaInfoDefaultCls ~ NoSemanticInfo, Data (SemanticInfo' d SemaInfoNameCls), Data (SemanticInfo' d SemaInfoLitCls), Data (SemanticInfo' d SemaInfoExprCls), Data (SemanticInfo' d SemaInfoImportCls), Data (SemanticInfo' d SemaInfoModuleCls), Data (SemanticInfo' d SemaInfoWildcardCls)) #
A semantic domain for the AST. The semantic domain maps semantic information for the different types of nodes in the AST. The kind of semantic domain for an AST depends on which stages of the compilation it passed. However after transforming the GHC representation to our AST, the domain stays the same. The domain is not applied to the AST elements that are generated while refactoring.
type DomainWith e d = (Data (SemanticInfo' d (SemaInfoClassify e)), Domain d) #
Extracts or modifies the concrete range corresponding to a given source info. In case of lists and optional elements, it may not contain the elements inside.
Instances
class (Typeable stage, Data stage, Data (SpanInfo stage), Data (ListInfo stage), Data (OptionalInfo stage), HasRange (SpanInfo stage), HasRange (ListInfo stage), HasRange (OptionalInfo stage)) => SourceInfo stage #
Class for source information stages
Associated Types
UType of source info for normal AST elements
UType of source info for lists of AST elements
data OptionalInfo stage :: * #
UType of source info for optional AST elements
Instances
| SourceInfo NormRangeStage # | |
Defined in Language.Haskell.Tools.AST.Ann Associated Types data SpanInfo NormRangeStage :: * # data ListInfo NormRangeStage :: * # data OptionalInfo NormRangeStage :: * # | |
| SourceInfo RangeStage # | |
Defined in Language.Haskell.Tools.AST.Ann Associated Types data SpanInfo RangeStage :: * # data ListInfo RangeStage :: * # data OptionalInfo RangeStage :: * # | |
shortShowSpan :: SrcSpan -> String #
A short form of showing a range, without file name, for debugging purposes.
shortShowSpanWithFile :: SrcSpan -> String #
shortShowLoc :: SrcLoc -> String #
A short form of showing a range, without file name, for debugging purposes.
class SourceInfo stage => RangeInfo stage where #
A class for marking a source information stage. All programs, regardless of correct Haskell programs or not, must go through these stages to be refactored.
Minimal complete definition
Methods
nodeSpan :: Simple Lens (SpanInfo stage) SrcSpan #
listPos :: Simple Lens (ListInfo stage) SrcLoc #
optionalPos :: Simple Lens (OptionalInfo stage) SrcLoc #
Instances
| RangeInfo RangeStage # | |
Defined in Language.Haskell.Tools.AST.Ann Methods nodeSpan :: Simple Lens (SpanInfo RangeStage) SrcSpan # listPos :: Simple Lens (ListInfo RangeStage) SrcLoc # optionalPos :: Simple Lens (OptionalInfo RangeStage) SrcLoc # | |
Annotations
Semantic and source code related information for an AST node.
Constructors
| NodeInfo | |
Fields
| |
Instances
| (Eq sema, Eq src) => Eq (NodeInfo sema src) # | |
| (Data sema, Data src) => Data (NodeInfo sema src) # | |
Defined in Language.Haskell.Tools.AST.Ann Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NodeInfo sema src -> c (NodeInfo sema src) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NodeInfo sema src) # toConstr :: NodeInfo sema src -> Constr # dataTypeOf :: NodeInfo sema src -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NodeInfo sema src)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NodeInfo sema src)) # gmapT :: (forall b. Data b => b -> b) -> NodeInfo sema src -> NodeInfo sema src # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NodeInfo sema src -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NodeInfo sema src -> r # gmapQ :: (forall d. Data d => d -> u) -> NodeInfo sema src -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NodeInfo sema src -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NodeInfo sema src -> m (NodeInfo sema src) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NodeInfo sema src -> m (NodeInfo sema src) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NodeInfo sema src -> m (NodeInfo sema src) # | |
| (Show sema, Show src) => Show (NodeInfo sema src) # | |
sourceInfo :: forall sema src src'. Lens (NodeInfo sema src) (NodeInfo sema src') src src' #
semanticInfo :: forall sema src sema'. Lens (NodeInfo sema src) (NodeInfo sema' src) sema sema' #
An element of the AST keeping extra information.
Constructors
| Ann | |
Fields
| |
Instances
| (GoodOperationFor c (Ann elem dom stage), ClassyPlate c (elem dom stage)) => ClassyPlate c (Ann elem dom stage) # | |
Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate Methods bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> Ann elem dom stage -> Ann elem dom stage # bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> Ann elem dom stage -> m (Ann elem dom stage) # descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> Ann elem dom stage -> Ann elem dom stage # descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> Ann elem dom stage -> m (Ann elem dom stage) # topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> Ann elem dom stage -> Ann elem dom stage # topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> Ann elem dom stage -> m (Ann elem dom stage) # | |
| SourceInfoTraversal e => SourceInfoTraversal (Ann e) # | |
Defined in Language.Haskell.Tools.AST.Ann Methods sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Ann e dom st1 -> f (Ann e dom st2) # sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Ann e dom st1 -> f (Ann e dom st2) # sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> Ann e dom st1 -> f (Ann e dom st2) # | |
| (ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (Ann e) # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| SourceInfo src => Eq (Ann elem dom src) # | |
| (DomainWith e dom, SourceInfo stage, Typeable e, Data (e dom stage)) => Data (Ann e dom stage) # | |
Defined in Language.Haskell.Tools.AST.Instances.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ann e dom stage -> c (Ann e dom stage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ann e dom stage) # toConstr :: Ann e dom stage -> Constr # dataTypeOf :: Ann e dom stage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ann e dom stage)) # dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (Ann e dom stage)) # gmapT :: (forall b. Data b => b -> b) -> Ann e dom stage -> Ann e dom stage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ann e dom stage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ann e dom stage -> r # gmapQ :: (forall d. Data d => d -> u) -> Ann e dom stage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ann e dom stage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ann e dom stage -> m (Ann e dom stage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ann e dom stage -> m (Ann e dom stage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ann e dom stage -> m (Ann e dom stage) # | |
| Domain dom => Generic (Ann e dom stage) # | |
| SourceInfo stage => HasRange (Ann elem dom stage) # | |
| HasSourceInfo (Ann elem dom stage) # | |
Defined in Language.Haskell.Tools.AST.Ann Associated Types type SourceInfoType (Ann elem dom stage) :: * # | |
| HasImplicitFieldsInfo dom => HasImplicitFieldsInfo' (Ann UFieldWildcard dom st) # | |
Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsImplicitFlds :: Ann UFieldWildcard dom st -> [(Name, Name)] # | |
| HasImportInfo dom => HasImportInfo' (Ann UImportDecl dom st) # | |
Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsImportedModule :: Ann UImportDecl dom st -> Module # semanticsAvailable :: Ann UImportDecl dom st -> [Name] # semanticsImported :: Ann UImportDecl dom st -> [Name] # semanticsTransMods :: Ann UImportDecl dom st -> [Module] # | |
| HasModuleInfo dom => HasModuleInfo' (Ann UModule dom st) # | |
Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsModule :: Ann UModule dom st -> Module # semanticsDynFlags :: Ann UModule dom st -> DynFlags # isBootModule :: Ann UModule dom st -> Bool # semanticsImplicitImports :: Ann UModule dom st -> [Name] # semanticsPrelTransMods :: Ann UModule dom st -> [Module] # | |
| HasDefiningInfo dom => HasDefiningInfo' (Ann UQualifiedName dom st) # | |
Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsDefining :: Ann UQualifiedName dom st -> Bool # | |
| HasScopeInfo dom => HasScopeInfo' (Ann UExpr dom st) # | |
Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsScope :: Ann UExpr dom st -> Scope # | |
| HasScopeInfo dom => HasScopeInfo' (Ann UQualifiedName dom st) # | |
Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsScope :: Ann UQualifiedName dom st -> Scope # | |
| HasFixityInfo dom => HasFixityInfo' (Ann UQualifiedName dom st) # | |
Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsFixity :: Ann UQualifiedName dom st -> Maybe Fixity # | |
| HasIdInfo dom => HasIdInfo' (Ann UQualifiedName dom st) # | |
Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsId :: Ann UQualifiedName dom st -> Id # | |
| HasIdInfo dom => HasIdInfo' (Ann UName dom st) # | |
Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsId :: Ann UName dom st -> Id # | |
| HasLiteralInfo dom => HasLiteralInfo' (Ann ULiteral dom st) # | |
Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsLiteralType :: Ann ULiteral dom st -> Type # | |
| HasNameInfo dom => HasNameInfo' (Ann UQualifiedName dom st) # | |
Defined in Language.Haskell.Tools.AST.SemaInfoClasses Methods semanticsName :: Ann UQualifiedName dom st -> Maybe Name # | |
| HasNameInfo dom => HasNameInfo' (Ann UName dom st) # | |
Defined in Language.Haskell.Tools.AST.SemaInfoClasses | |
| type Rep (Ann e dom stage) # | |
Defined in Language.Haskell.Tools.AST.Instances.Generic type Rep (Ann e dom stage) = D1 (MetaData "Ann" "Language.Haskell.Tools.AST.Ann" "haskell-tools-ast-1.1.0.1-L5h7QWySptBFYFr7nuPbmb" False) (C1 (MetaCons "Ann" PrefixI True) (S1 (MetaSel (Just "_annotation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NodeInfo (SemanticInfo dom e) (SpanInfo stage))) :*: S1 (MetaSel (Just "_element") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (e dom stage)))) | |
| type IgnoredFields (Ann elem dom stage) # | |
| type SourceInfoType (Ann elem dom stage) # | |
Defined in Language.Haskell.Tools.AST.Ann | |
element :: forall elem dom stage. Lens (Ann elem dom stage) (Ann elem dom stage) (elem dom stage) (elem dom stage) #
annotation :: forall elem dom stage. Lens (Ann elem dom stage) (Ann elem dom stage) (NodeInfo (SemanticInfo dom elem) (SpanInfo stage)) (NodeInfo (SemanticInfo dom elem) (SpanInfo stage)) #
data AnnListG elem dom stage #
A list of AST elements
Constructors
| AnnListG | |
Fields
| |
Instances
| (GoodOperationFor c (AnnListG elem dom stage), ClassyPlate c [Ann elem dom stage]) => ClassyPlate c (AnnListG elem dom stage) # | |
Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate Methods bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> AnnListG elem dom stage -> AnnListG elem dom stage # bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> AnnListG elem dom stage -> m (AnnListG elem dom stage) # descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> AnnListG elem dom stage -> AnnListG elem dom stage # descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> AnnListG elem dom stage -> m (AnnListG elem dom stage) # topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> AnnListG elem dom stage -> AnnListG elem dom stage # topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> AnnListG elem dom stage -> m (AnnListG elem dom stage) # | |
| SourceInfoTraversal e => SourceInfoTraversal (AnnListG e) # | |
Defined in Language.Haskell.Tools.AST.Ann Methods sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnListG e dom st1 -> f (AnnListG e dom st2) # sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnListG e dom st1 -> f (AnnListG e dom st2) # sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> AnnListG e dom st1 -> f (AnnListG e dom st2) # | |
| (ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (AnnListG e) # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| (DomainWith e dom, SourceInfo stage, Typeable e, Data (e dom stage)) => Data (AnnListG e dom stage) # | |
Defined in Language.Haskell.Tools.AST.Instances.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnListG e dom stage -> c (AnnListG e dom stage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnListG e dom stage) # toConstr :: AnnListG e dom stage -> Constr # dataTypeOf :: AnnListG e dom stage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnListG e dom stage)) # dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (AnnListG e dom stage)) # gmapT :: (forall b. Data b => b -> b) -> AnnListG e dom stage -> AnnListG e dom stage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnListG e dom stage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnListG e dom stage -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnListG e dom stage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnListG e dom stage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnListG e dom stage -> m (AnnListG e dom stage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnListG e dom stage -> m (AnnListG e dom stage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnListG e dom stage -> m (AnnListG e dom stage) # | |
| Domain dom => Generic (AnnListG e dom stage) # | |
| SourceInfo stage => HasRange (AnnListG elem dom stage) # | |
| HasSourceInfo (AnnListG elem dom stage) # | |
Defined in Language.Haskell.Tools.AST.Ann Associated Types type SourceInfoType (AnnListG elem dom stage) :: * # | |
| type Rep (AnnListG e dom stage) # | |
Defined in Language.Haskell.Tools.AST.Instances.Generic type Rep (AnnListG e dom stage) = D1 (MetaData "AnnListG" "Language.Haskell.Tools.AST.Ann" "haskell-tools-ast-1.1.0.1-L5h7QWySptBFYFr7nuPbmb" False) (C1 (MetaCons "AnnListG" PrefixI True) (S1 (MetaSel (Just "_annListAnnot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NodeInfo (SemanticInfo dom (AnnListG e)) (ListInfo stage))) :*: S1 (MetaSel (Just "_annListElems") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Ann e dom stage]))) | |
| type IgnoredFields (AnnListG elem dom stage) # | |
| type SourceInfoType (AnnListG elem dom stage) # | |
Defined in Language.Haskell.Tools.AST.Ann | |
annListElems :: forall elem dom stage. Lens (AnnListG elem dom stage) (AnnListG elem dom stage) [Ann elem dom stage] [Ann elem dom stage] #
annListAnnot :: forall elem dom stage. Lens (AnnListG elem dom stage) (AnnListG elem dom stage) (NodeInfo (SemanticInfo dom (AnnListG elem)) (ListInfo stage)) (NodeInfo (SemanticInfo dom (AnnListG elem)) (ListInfo stage)) #
data AnnMaybeG elem dom stage #
An optional AST element
Constructors
| AnnMaybeG | |
Fields
| |
Instances
| (GoodOperationFor c (AnnMaybeG elem dom stage), ClassyPlate c (Maybe (Ann elem dom stage))) => ClassyPlate c (AnnMaybeG elem dom stage) # | |
Defined in Language.Haskell.Tools.AST.Instances.ClassyPlate Methods bottomUp_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> AnnMaybeG elem dom stage -> AnnMaybeG elem dom stage # bottomUpM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> AnnMaybeG elem dom stage -> m (AnnMaybeG elem dom stage) # descend_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> AnnMaybeG elem dom stage -> AnnMaybeG elem dom stage # descendM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> AnnMaybeG elem dom stage -> m (AnnMaybeG elem dom stage) # topDown_ :: ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> a) -> AnnMaybeG elem dom stage -> AnnMaybeG elem dom stage # topDownM_ :: Monad m => ClsToken c -> (forall a. (ClassyPlate c a, c a) => a -> m a) -> AnnMaybeG elem dom stage -> m (AnnMaybeG elem dom stage) # | |
| SourceInfoTraversal e => SourceInfoTraversal (AnnMaybeG e) # | |
Defined in Language.Haskell.Tools.AST.Ann Methods sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnMaybeG e dom st1 -> f (AnnMaybeG e dom st2) # sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnMaybeG e dom st1 -> f (AnnMaybeG e dom st2) # sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> AnnMaybeG e dom st1 -> f (AnnMaybeG e dom st2) # | |
| (ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (AnnMaybeG e) # | |
Defined in Language.Haskell.Tools.AST.Ann | |
| (DomainWith e dom, SourceInfo stage, Typeable e, Data (e dom stage)) => Data (AnnMaybeG e dom stage) # | |
Defined in Language.Haskell.Tools.AST.Instances.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnMaybeG e dom stage -> c (AnnMaybeG e dom stage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnMaybeG e dom stage) # toConstr :: AnnMaybeG e dom stage -> Constr # dataTypeOf :: AnnMaybeG e dom stage -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnMaybeG e dom stage)) # dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (AnnMaybeG e dom stage)) # gmapT :: (forall b. Data b => b -> b) -> AnnMaybeG e dom stage -> AnnMaybeG e dom stage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnMaybeG e dom stage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnMaybeG e dom stage -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnMaybeG e dom stage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnMaybeG e dom stage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnMaybeG e dom stage -> m (AnnMaybeG e dom stage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnMaybeG e dom stage -> m (AnnMaybeG e dom stage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnMaybeG e dom stage -> m (AnnMaybeG e dom stage) # | |
| Domain dom => Generic (AnnMaybeG e dom stage) # | |
| SourceInfo stage => HasRange (AnnMaybeG elem dom stage) # | |
| HasSourceInfo (AnnMaybeG elem dom stage) # | |
Defined in Language.Haskell.Tools.AST.Ann Associated Types type SourceInfoType (AnnMaybeG elem dom stage) :: * # | |
| type Rep (AnnMaybeG e dom stage) # | |
Defined in Language.Haskell.Tools.AST.Instances.Generic type Rep (AnnMaybeG e dom stage) = D1 (MetaData "AnnMaybeG" "Language.Haskell.Tools.AST.Ann" "haskell-tools-ast-1.1.0.1-L5h7QWySptBFYFr7nuPbmb" False) (C1 (MetaCons "AnnMaybeG" PrefixI True) (S1 (MetaSel (Just "_annMaybeAnnot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NodeInfo (SemanticInfo dom (AnnMaybeG e)) (OptionalInfo stage))) :*: S1 (MetaSel (Just "_annMaybe") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Ann e dom stage))))) | |
| type IgnoredFields (AnnMaybeG elem dom stage) # | |
| type SourceInfoType (AnnMaybeG elem dom stage) # | |
Defined in Language.Haskell.Tools.AST.Ann | |
annMaybeAnnot :: forall elem dom stage. Lens (AnnMaybeG elem dom stage) (AnnMaybeG elem dom stage) (NodeInfo (SemanticInfo dom (AnnMaybeG elem)) (OptionalInfo stage)) (NodeInfo (SemanticInfo dom (AnnMaybeG elem)) (OptionalInfo stage)) #
annMaybe :: forall elem dom stage. Lens (AnnMaybeG elem dom stage) (AnnMaybeG elem dom stage) (Maybe (Ann elem dom stage)) (Maybe (Ann elem dom stage)) #
class HasSourceInfo e where #
Minimal complete definition
Associated Types
type SourceInfoType e :: * #
Methods
srcInfo :: Simple Lens e (SourceInfoType e) #
Instances
| HasSourceInfo (Ann elem dom stage) # | |
Defined in Language.Haskell.Tools.AST.Ann Associated Types type SourceInfoType (Ann elem dom stage) :: * # | |
| HasSourceInfo (AnnListG elem dom stage) # | |
Defined in Language.Haskell.Tools.AST.Ann Associated Types type SourceInfoType (AnnListG elem dom stage) :: * # | |
| HasSourceInfo (AnnMaybeG elem dom stage) # | |
Defined in Language.Haskell.Tools.AST.Ann Associated Types type SourceInfoType (AnnMaybeG elem dom stage) :: * # | |
annNil :: NodeInfo (SemanticInfo d (AnnListG e)) (ListInfo s) -> AnnListG e d s #
An empty list of AST elements
isAnnNothing :: AnnMaybeG e d s -> Bool #
annNothing :: NodeInfo (SemanticInfo d (AnnMaybeG e)) (OptionalInfo s) -> AnnMaybeG e d s #
A non-existing AST part
Info types
class ApplySemaChange cls where #
A class for changing semantic information throught the AST.
Minimal complete definition
Methods
appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 cls -> f (SemanticInfo' dom2 cls) #
Instances
class ApplySemaChange (SemaInfoClassify a) => SemanticTraversal a where #
A class for traversing semantic information in an AST
Minimal complete definition
Methods
semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> a dom1 st -> f (a dom2 st) #
Instances
A transformation on the possible semantic informations for a given domain
Constructors
| SemaTrf | |
Fields
| |
class SourceInfoTraversal a where #
A class for traversing source information in an AST
Minimal complete definition
sourceInfoTraverseUp, sourceInfoTraverseDown, sourceInfoTraverse
Methods
sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> a dom st1 -> f (a dom st2) #
sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> a dom st1 -> f (a dom st2) #
sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> a dom st1 -> f (a dom st2) #
Instances
data SourceInfoTrf f st1 st2 #
A transformation on the possible source informations
Constructors
| SourceInfoTrf | |
Fields
| |