Safe Haskell	None
Language	Haskell2010

Language.Haskell.Tools.AST.Ann

Contents

Annotation type resolution
Annotations
Info types

Description

Parts of AST representation for keeping extra data

Synopsis

Annotation type resolution

data RangeStage Source #

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 RangeStage Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RangeStage -> c RangeStage # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RangeStage # toConstr :: RangeStage -> Constr # dataTypeOf :: RangeStage -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c RangeStage) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RangeStage) # gmapT :: (forall b. Data b => b -> b) -> RangeStage -> RangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> RangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RangeStage -> m RangeStage # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RangeStage -> m RangeStage # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RangeStage -> m RangeStage #
RangeInfo RangeStage Source #
Methods nodeSpan :: Simple Lens (SpanInfo RangeStage) SrcSpan Source # listPos :: Simple Lens (ListInfo RangeStage) SrcLoc Source # optionalPos :: Simple Lens (OptionalInfo RangeStage) SrcLoc Source #
SourceInfo RangeStage Source #
Associated Types data SpanInfo RangeStage :: * Source # data ListInfo RangeStage :: * Source # data OptionalInfo RangeStage :: * Source #
Data (SpanInfo RangeStage) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpanInfo RangeStage -> c (SpanInfo RangeStage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SpanInfo RangeStage) # toConstr :: SpanInfo RangeStage -> Constr # dataTypeOf :: SpanInfo RangeStage -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (SpanInfo RangeStage)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SpanInfo RangeStage)) # gmapT :: (forall b. Data b => b -> b) -> SpanInfo RangeStage -> SpanInfo RangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpanInfo RangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpanInfo RangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> SpanInfo RangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SpanInfo RangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpanInfo RangeStage -> m (SpanInfo RangeStage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpanInfo RangeStage -> m (SpanInfo RangeStage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpanInfo RangeStage -> m (SpanInfo RangeStage) #
Data (ListInfo RangeStage) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ListInfo RangeStage -> c (ListInfo RangeStage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ListInfo RangeStage) # toConstr :: ListInfo RangeStage -> Constr # dataTypeOf :: ListInfo RangeStage -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (ListInfo RangeStage)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ListInfo RangeStage)) # gmapT :: (forall b. Data b => b -> b) -> ListInfo RangeStage -> ListInfo RangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ListInfo RangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ListInfo RangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> ListInfo RangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ListInfo RangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ListInfo RangeStage -> m (ListInfo RangeStage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ListInfo RangeStage -> m (ListInfo RangeStage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ListInfo RangeStage -> m (ListInfo RangeStage) #
Data (OptionalInfo RangeStage) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OptionalInfo RangeStage -> c (OptionalInfo RangeStage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (OptionalInfo RangeStage) # toConstr :: OptionalInfo RangeStage -> Constr # dataTypeOf :: OptionalInfo RangeStage -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (OptionalInfo RangeStage)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (OptionalInfo RangeStage)) # gmapT :: (forall b. Data b => b -> b) -> OptionalInfo RangeStage -> OptionalInfo RangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OptionalInfo RangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OptionalInfo RangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> OptionalInfo RangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OptionalInfo RangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OptionalInfo RangeStage -> m (OptionalInfo RangeStage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OptionalInfo RangeStage -> m (OptionalInfo RangeStage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OptionalInfo RangeStage -> m (OptionalInfo RangeStage) #
Show (SpanInfo RangeStage) Source #
Methods showsPrec :: Int -> SpanInfo RangeStage -> ShowS # show :: SpanInfo RangeStage -> String # showList :: [SpanInfo RangeStage] -> ShowS #
Show (ListInfo RangeStage) Source #
Methods showsPrec :: Int -> ListInfo RangeStage -> ShowS # show :: ListInfo RangeStage -> String # showList :: [ListInfo RangeStage] -> ShowS #
Show (OptionalInfo RangeStage) Source #
Methods showsPrec :: Int -> OptionalInfo RangeStage -> ShowS # show :: OptionalInfo RangeStage -> String # showList :: [OptionalInfo RangeStage] -> ShowS #
HasRange (SpanInfo RangeStage) Source #
Methods getRange :: SpanInfo RangeStage -> SrcSpan Source # setRange :: SrcSpan -> SpanInfo RangeStage -> SpanInfo RangeStage Source #
HasRange (ListInfo RangeStage) Source #
Methods getRange :: ListInfo RangeStage -> SrcSpan Source # setRange :: SrcSpan -> ListInfo RangeStage -> ListInfo RangeStage Source #
HasRange (OptionalInfo RangeStage) Source #
Methods getRange :: OptionalInfo RangeStage -> SrcSpan Source # setRange :: SrcSpan -> OptionalInfo RangeStage -> OptionalInfo RangeStage Source #
data SpanInfo RangeStage Source #
data SpanInfo RangeStage = NodeSpan { _nodeSpan :: SrcSpan }
data ListInfo RangeStage Source #
data ListInfo RangeStage = ListPos { _listBefore :: String _listAfter :: String _listDefaultSep :: String _listIndented :: Maybe [Bool] _listPos :: SrcLoc }
data OptionalInfo RangeStage Source #
data OptionalInfo RangeStage = OptionalPos { _optionalBefore :: String _optionalAfter :: String _optionalPos :: SrcLoc }

data NormRangeStage Source #

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 NormRangeStage Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NormRangeStage -> c NormRangeStage # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NormRangeStage # toConstr :: NormRangeStage -> Constr # dataTypeOf :: NormRangeStage -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c NormRangeStage) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NormRangeStage) # gmapT :: (forall b. Data b => b -> b) -> NormRangeStage -> NormRangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NormRangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NormRangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> NormRangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NormRangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NormRangeStage -> m NormRangeStage # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NormRangeStage -> m NormRangeStage # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NormRangeStage -> m NormRangeStage #
SourceInfo NormRangeStage Source #
Associated Types data SpanInfo NormRangeStage :: * Source # data ListInfo NormRangeStage :: * Source # data OptionalInfo NormRangeStage :: * Source #
Data (SpanInfo NormRangeStage) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpanInfo NormRangeStage -> c (SpanInfo NormRangeStage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SpanInfo NormRangeStage) # toConstr :: SpanInfo NormRangeStage -> Constr # dataTypeOf :: SpanInfo NormRangeStage -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (SpanInfo NormRangeStage)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SpanInfo NormRangeStage)) # gmapT :: (forall b. Data b => b -> b) -> SpanInfo NormRangeStage -> SpanInfo NormRangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpanInfo NormRangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpanInfo NormRangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> SpanInfo NormRangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SpanInfo NormRangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpanInfo NormRangeStage -> m (SpanInfo NormRangeStage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpanInfo NormRangeStage -> m (SpanInfo NormRangeStage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpanInfo NormRangeStage -> m (SpanInfo NormRangeStage) #
Data (ListInfo NormRangeStage) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ListInfo NormRangeStage -> c (ListInfo NormRangeStage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ListInfo NormRangeStage) # toConstr :: ListInfo NormRangeStage -> Constr # dataTypeOf :: ListInfo NormRangeStage -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (ListInfo NormRangeStage)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ListInfo NormRangeStage)) # gmapT :: (forall b. Data b => b -> b) -> ListInfo NormRangeStage -> ListInfo NormRangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ListInfo NormRangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ListInfo NormRangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> ListInfo NormRangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ListInfo NormRangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ListInfo NormRangeStage -> m (ListInfo NormRangeStage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ListInfo NormRangeStage -> m (ListInfo NormRangeStage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ListInfo NormRangeStage -> m (ListInfo NormRangeStage) #
Data (OptionalInfo NormRangeStage) Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OptionalInfo NormRangeStage -> c (OptionalInfo NormRangeStage) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (OptionalInfo NormRangeStage) # toConstr :: OptionalInfo NormRangeStage -> Constr # dataTypeOf :: OptionalInfo NormRangeStage -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (OptionalInfo NormRangeStage)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (OptionalInfo NormRangeStage)) # gmapT :: (forall b. Data b => b -> b) -> OptionalInfo NormRangeStage -> OptionalInfo NormRangeStage # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OptionalInfo NormRangeStage -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OptionalInfo NormRangeStage -> r # gmapQ :: (forall d. Data d => d -> u) -> OptionalInfo NormRangeStage -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OptionalInfo NormRangeStage -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OptionalInfo NormRangeStage -> m (OptionalInfo NormRangeStage) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OptionalInfo NormRangeStage -> m (OptionalInfo NormRangeStage) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OptionalInfo NormRangeStage -> m (OptionalInfo NormRangeStage) #
Show (SpanInfo NormRangeStage) Source #
Methods showsPrec :: Int -> SpanInfo NormRangeStage -> ShowS # show :: SpanInfo NormRangeStage -> String # showList :: [SpanInfo NormRangeStage] -> ShowS #
Show (ListInfo NormRangeStage) Source #
Methods showsPrec :: Int -> ListInfo NormRangeStage -> ShowS # show :: ListInfo NormRangeStage -> String # showList :: [ListInfo NormRangeStage] -> ShowS #
Show (OptionalInfo NormRangeStage) Source #
Methods showsPrec :: Int -> OptionalInfo NormRangeStage -> ShowS # show :: OptionalInfo NormRangeStage -> String # showList :: [OptionalInfo NormRangeStage] -> ShowS #
HasRange (SpanInfo NormRangeStage) Source #
Methods getRange :: SpanInfo NormRangeStage -> SrcSpan Source # setRange :: SrcSpan -> SpanInfo NormRangeStage -> SpanInfo NormRangeStage Source #
HasRange (ListInfo NormRangeStage) Source #
Methods getRange :: ListInfo NormRangeStage -> SrcSpan Source # setRange :: SrcSpan -> ListInfo NormRangeStage -> ListInfo NormRangeStage Source #
HasRange (OptionalInfo NormRangeStage) Source #
Methods getRange :: OptionalInfo NormRangeStage -> SrcSpan Source # setRange :: SrcSpan -> OptionalInfo NormRangeStage -> OptionalInfo NormRangeStage Source #
data SpanInfo NormRangeStage Source #
data SpanInfo NormRangeStage = NormNodeInfo { _normNodeSpan :: SrcSpan }
data ListInfo NormRangeStage Source #
data ListInfo NormRangeStage = NormListInfo { _normListBefore :: String _normListAfter :: String _normListDefaultSep :: String _normListIndented :: Maybe [Bool] _normListSpan :: SrcSpan }
data OptionalInfo NormRangeStage Source #
data OptionalInfo NormRangeStage = NormOptInfo { _normOptBefore :: String _normOptAfter :: String _normOptSpan :: SrcSpan }

data RngTemplateStage Source #

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 Source #

data SrcTemplateStage Source #

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 Source #

data Dom name Source #

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) Source #
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 Source #
type SemanticInfo' (Dom n) SemaInfoDefaultCls = NoSemanticInfo
type SemanticInfo' (Dom n) SemaInfoWildcardCls Source #
type SemanticInfo' (Dom n) SemaInfoWildcardCls = ImplicitFieldInfo
type SemanticInfo' (Dom n) SemaInfoModuleCls Source #
type SemanticInfo' (Dom n) SemaInfoModuleCls = ModuleInfo Name
type SemanticInfo' (Dom n) SemaInfoImportCls Source #
type SemanticInfo' (Dom n) SemaInfoImportCls = ImportInfo n
type SemanticInfo' (Dom n) SemaInfoExprCls Source #
type SemanticInfo' (Dom n) SemaInfoExprCls = ScopeInfo
type SemanticInfo' (Dom n) SemaInfoLitCls Source #
type SemanticInfo' (Dom n) SemaInfoLitCls = PreLiteralInfo
type SemanticInfo' (Dom n) SemaInfoNameCls Source #
type SemanticInfo' (Dom n) SemaInfoNameCls = NameInfo n

data IdDom Source #

Instances

Data IdDom Source #
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 # toConstr :: IdDom -> Constr # 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 Source #
type SemanticInfo' IdDom SemaInfoWildcardCls = ImplicitFieldInfo
type SemanticInfo' IdDom SemaInfoDefaultCls Source #
type SemanticInfo' IdDom SemaInfoDefaultCls = NoSemanticInfo
type SemanticInfo' IdDom SemaInfoModuleCls Source #
type SemanticInfo' IdDom SemaInfoModuleCls = ModuleInfo Id
type SemanticInfo' IdDom SemaInfoImportCls Source #
type SemanticInfo' IdDom SemaInfoImportCls = ImportInfo Id
type SemanticInfo' IdDom SemaInfoExprCls Source #
type SemanticInfo' IdDom SemaInfoExprCls = ScopeInfo
type SemanticInfo' IdDom SemaInfoLitCls Source #
type SemanticInfo' IdDom SemaInfoLitCls = LiteralInfo
type SemanticInfo' IdDom SemaInfoNameCls Source #
type SemanticInfo' IdDom SemaInfoNameCls = CNameInfo

type SemanticInfo (domain :: *) (node :: * -> * -> *) = SemanticInfo' domain (SemaInfoClassify node) Source #

data SemaInfoNameCls Source #

Instances

ApplySemaChange SemaInfoNameCls Source #
Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoNameCls -> f (SemanticInfo' dom2 SemaInfoNameCls) Source #
type SemanticInfo' IdDom SemaInfoNameCls Source #
type SemanticInfo' IdDom SemaInfoNameCls = CNameInfo
type SemanticInfo' (Dom n) SemaInfoNameCls Source #
type SemanticInfo' (Dom n) SemaInfoNameCls = NameInfo n

data SemaInfoLitCls Source #

Instances

ApplySemaChange SemaInfoLitCls Source #
Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoLitCls -> f (SemanticInfo' dom2 SemaInfoLitCls) Source #
type SemanticInfo' IdDom SemaInfoLitCls Source #
type SemanticInfo' IdDom SemaInfoLitCls = LiteralInfo
type SemanticInfo' (Dom n) SemaInfoLitCls Source #
type SemanticInfo' (Dom n) SemaInfoLitCls = PreLiteralInfo

data SemaInfoExprCls Source #

Instances

ApplySemaChange SemaInfoExprCls Source #
Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoExprCls -> f (SemanticInfo' dom2 SemaInfoExprCls) Source #
type SemanticInfo' IdDom SemaInfoExprCls Source #
type SemanticInfo' IdDom SemaInfoExprCls = ScopeInfo
type SemanticInfo' (Dom n) SemaInfoExprCls Source #
type SemanticInfo' (Dom n) SemaInfoExprCls = ScopeInfo

data SemaInfoImportCls Source #

Instances

ApplySemaChange SemaInfoImportCls Source #
Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoImportCls -> f (SemanticInfo' dom2 SemaInfoImportCls) Source #
type SemanticInfo' IdDom SemaInfoImportCls Source #
type SemanticInfo' IdDom SemaInfoImportCls = ImportInfo Id
type SemanticInfo' (Dom n) SemaInfoImportCls Source #
type SemanticInfo' (Dom n) SemaInfoImportCls = ImportInfo n

data SemaInfoModuleCls Source #

Instances

ApplySemaChange SemaInfoModuleCls Source #
Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoModuleCls -> f (SemanticInfo' dom2 SemaInfoModuleCls) Source #
type SemanticInfo' IdDom SemaInfoModuleCls Source #
type SemanticInfo' IdDom SemaInfoModuleCls = ModuleInfo Id
type SemanticInfo' (Dom n) SemaInfoModuleCls Source #
type SemanticInfo' (Dom n) SemaInfoModuleCls = ModuleInfo Name

data SemaInfoDefaultCls Source #

Instances

ApplySemaChange SemaInfoDefaultCls Source #
Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoDefaultCls -> f (SemanticInfo' dom2 SemaInfoDefaultCls) Source #
type SemanticInfo' IdDom SemaInfoDefaultCls Source #
type SemanticInfo' IdDom SemaInfoDefaultCls = NoSemanticInfo
type SemanticInfo' (Dom n) SemaInfoDefaultCls Source #
type SemanticInfo' (Dom n) SemaInfoDefaultCls = NoSemanticInfo

data SemaInfoWildcardCls Source #

Instances

ApplySemaChange SemaInfoWildcardCls Source #
Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoWildcardCls -> f (SemanticInfo' dom2 SemaInfoWildcardCls) Source #
type SemanticInfo' IdDom SemaInfoWildcardCls Source #
type SemanticInfo' IdDom SemaInfoWildcardCls = ImplicitFieldInfo
type SemanticInfo' (Dom n) SemaInfoWildcardCls Source #
type SemanticInfo' (Dom n) SemaInfoWildcardCls = ImplicitFieldInfo

type family SemaInfoClassify (node :: * -> * -> *) where ... Source #

type family SemanticInfo' (domain :: *) (nodecls :: *) Source #

Instances

type SemanticInfo' IdDom SemaInfoWildcardCls Source #
type SemanticInfo' IdDom SemaInfoWildcardCls = ImplicitFieldInfo
type SemanticInfo' IdDom SemaInfoDefaultCls Source #
type SemanticInfo' IdDom SemaInfoDefaultCls = NoSemanticInfo
type SemanticInfo' IdDom SemaInfoModuleCls Source #
type SemanticInfo' IdDom SemaInfoModuleCls = ModuleInfo Id
type SemanticInfo' IdDom SemaInfoImportCls Source #
type SemanticInfo' IdDom SemaInfoImportCls = ImportInfo Id
type SemanticInfo' IdDom SemaInfoExprCls Source #
type SemanticInfo' IdDom SemaInfoExprCls = ScopeInfo
type SemanticInfo' IdDom SemaInfoLitCls Source #
type SemanticInfo' IdDom SemaInfoLitCls = LiteralInfo
type SemanticInfo' IdDom SemaInfoNameCls Source #
type SemanticInfo' IdDom SemaInfoNameCls = CNameInfo
type SemanticInfo' (Dom n) SemaInfoDefaultCls Source #
type SemanticInfo' (Dom n) SemaInfoDefaultCls = NoSemanticInfo
type SemanticInfo' (Dom n) SemaInfoWildcardCls Source #
type SemanticInfo' (Dom n) SemaInfoWildcardCls = ImplicitFieldInfo
type SemanticInfo' (Dom n) SemaInfoModuleCls Source #
type SemanticInfo' (Dom n) SemaInfoModuleCls = ModuleInfo Name
type SemanticInfo' (Dom n) SemaInfoImportCls Source #
type SemanticInfo' (Dom n) SemaInfoImportCls = ImportInfo n
type SemanticInfo' (Dom n) SemaInfoExprCls Source #
type SemanticInfo' (Dom n) SemaInfoExprCls = ScopeInfo
type SemanticInfo' (Dom n) SemaInfoLitCls Source #
type SemanticInfo' (Dom n) SemaInfoLitCls = PreLiteralInfo
type SemanticInfo' (Dom n) SemaInfoNameCls Source #
type SemanticInfo' (Dom n) SemaInfoNameCls = NameInfo n

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)) Source #

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) Source #

class HasRange a where Source #

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.

Minimal complete definition

getRange, setRange

Methods

getRange :: a -> SrcSpan Source #

setRange :: SrcSpan -> a -> a Source #

Instances

HasRange (SpanInfo NormRangeStage) Source #
Methods getRange :: SpanInfo NormRangeStage -> SrcSpan Source # setRange :: SrcSpan -> SpanInfo NormRangeStage -> SpanInfo NormRangeStage Source #
HasRange (SpanInfo RangeStage) Source #
Methods getRange :: SpanInfo RangeStage -> SrcSpan Source # setRange :: SrcSpan -> SpanInfo RangeStage -> SpanInfo RangeStage Source #
HasRange (ListInfo NormRangeStage) Source #
Methods getRange :: ListInfo NormRangeStage -> SrcSpan Source # setRange :: SrcSpan -> ListInfo NormRangeStage -> ListInfo NormRangeStage Source #
HasRange (ListInfo RangeStage) Source #
Methods getRange :: ListInfo RangeStage -> SrcSpan Source # setRange :: SrcSpan -> ListInfo RangeStage -> ListInfo RangeStage Source #
HasRange (OptionalInfo NormRangeStage) Source #
Methods getRange :: OptionalInfo NormRangeStage -> SrcSpan Source # setRange :: SrcSpan -> OptionalInfo NormRangeStage -> OptionalInfo NormRangeStage Source #
HasRange (OptionalInfo RangeStage) Source #
Methods getRange :: OptionalInfo RangeStage -> SrcSpan Source # setRange :: SrcSpan -> OptionalInfo RangeStage -> OptionalInfo RangeStage Source #
SourceInfo stage => HasRange (Ann elem dom stage) Source #
Methods getRange :: Ann elem dom stage -> SrcSpan Source # setRange :: SrcSpan -> Ann elem dom stage -> Ann elem dom stage Source #
SourceInfo stage => HasRange (AnnListG elem dom stage) Source #
Methods getRange :: AnnListG elem dom stage -> SrcSpan Source # setRange :: SrcSpan -> AnnListG elem dom stage -> AnnListG elem dom stage Source #
SourceInfo stage => HasRange (AnnMaybeG elem dom stage) Source #
Methods getRange :: AnnMaybeG elem dom stage -> SrcSpan Source # setRange :: SrcSpan -> AnnMaybeG elem dom stage -> AnnMaybeG elem dom stage Source #

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 Source #

Class for source information stages

Associated Types

data SpanInfo stage :: * Source #

UType of source info for normal AST elements

data ListInfo stage :: * Source #

UType of source info for lists of AST elements

data OptionalInfo stage :: * Source #

UType of source info for optional AST elements

Instances

SourceInfo NormRangeStage Source #
Associated Types data SpanInfo NormRangeStage :: * Source # data ListInfo NormRangeStage :: * Source # data OptionalInfo NormRangeStage :: * Source #
SourceInfo RangeStage Source #
Associated Types data SpanInfo RangeStage :: * Source # data ListInfo RangeStage :: * Source # data OptionalInfo RangeStage :: * Source #

shortShowSpan :: SrcSpan -> String Source #

A short form of showing a range, without file name, for debugging purposes.

shortShowSpanWithFile :: SrcSpan -> String Source #

shortShowLoc :: SrcLoc -> String Source #

A short form of showing a range, without file name, for debugging purposes.

class SourceInfo stage => RangeInfo stage where Source #

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

nodeSpan, listPos, optionalPos

Methods

nodeSpan :: Simple Lens (SpanInfo stage) SrcSpan Source #

listPos :: Simple Lens (ListInfo stage) SrcLoc Source #

optionalPos :: Simple Lens (OptionalInfo stage) SrcLoc Source #

Instances

RangeInfo RangeStage Source #
Methods nodeSpan :: Simple Lens (SpanInfo RangeStage) SrcSpan Source # listPos :: Simple Lens (ListInfo RangeStage) SrcLoc Source # optionalPos :: Simple Lens (OptionalInfo RangeStage) SrcLoc Source #

Annotations

data NodeInfo sema src Source #

Semantic and source code related information for an AST node.

Constructors

NodeInfo
Fields _semanticInfo :: sema _sourceInfo :: src

Instances

(Eq src, Eq sema) => Eq (NodeInfo sema src) Source #
Methods (==) :: NodeInfo sema src -> NodeInfo sema src -> Bool # (/=) :: NodeInfo sema src -> NodeInfo sema src -> Bool #
(Data src, Data sema) => Data (NodeInfo sema src) Source #
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 src, Show sema) => Show (NodeInfo sema src) Source #
Methods showsPrec :: Int -> NodeInfo sema src -> ShowS # show :: NodeInfo sema src -> String # showList :: [NodeInfo sema src] -> ShowS #

sourceInfo :: forall sema src src'. Lens (NodeInfo sema src) (NodeInfo sema src') src src' Source #

semanticInfo :: forall sema src sema'. Lens (NodeInfo sema src) (NodeInfo sema' src) sema sema' Source #

data Ann elem dom stage Source #

An element of the AST keeping extra information.

Constructors

Ann
Fields _annotation :: NodeInfo (SemanticInfo dom elem) (SpanInfo stage) The extra information for the AST part _element :: elem dom stage The original AST part

Instances

SourceInfoTraversal e => SourceInfoTraversal (Ann e) Source #
Methods sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Ann e dom st1 -> f (Ann e dom st2) Source # sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Ann e dom st1 -> f (Ann e dom st2) Source # sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> Ann e dom st1 -> f (Ann e dom st2) Source #
(ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (Ann e) Source #
Methods semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> Ann e dom1 st -> f (Ann e dom2 st) Source #
SourceInfo src => Eq (Ann elem dom src) Source #
Methods (==) :: Ann elem dom src -> Ann elem dom src -> Bool # (/=) :: Ann elem dom src -> Ann elem dom src -> Bool #
SourceInfo stage => HasRange (Ann elem dom stage) Source #
Methods getRange :: Ann elem dom stage -> SrcSpan Source # setRange :: SrcSpan -> Ann elem dom stage -> Ann elem dom stage Source #
HasSourceInfo (Ann elem dom stage) Source #
Associated Types type SourceInfoType (Ann elem dom stage) :: * Source # Methods srcInfo :: Simple Lens (Ann elem dom stage) (SourceInfoType (Ann elem dom stage)) Source #
HasImplicitFieldsInfo dom => HasImplicitFieldsInfo' (Ann UFieldWildcard dom st) Source #
Methods semanticsImplicitFlds :: Ann UFieldWildcard dom st -> [(Name, Name)] Source #
HasImportInfo dom => HasImportInfo' (Ann UImportDecl dom st) Source #
Methods semanticsImportedModule :: Ann UImportDecl dom st -> Module Source # semanticsAvailable :: Ann UImportDecl dom st -> [Name] Source # semanticsImported :: Ann UImportDecl dom st -> [Name] Source # semanticsTransMods :: Ann UImportDecl dom st -> [Module] Source #
HasModuleInfo dom => HasModuleInfo' (Ann UModule dom st) Source #
Methods semanticsModule :: Ann UModule dom st -> Module Source # semanticsDynFlags :: Ann UModule dom st -> DynFlags Source # isBootModule :: Ann UModule dom st -> Bool Source # semanticsImplicitImports :: Ann UModule dom st -> [Name] Source # semanticsPrelTransMods :: Ann UModule dom st -> [Module] Source #
HasDefiningInfo dom => HasDefiningInfo' (Ann UQualifiedName dom st) Source #
Methods semanticsDefining :: Ann UQualifiedName dom st -> Bool Source #
HasScopeInfo dom => HasScopeInfo' (Ann UExpr dom st) Source #
Methods semanticsScope :: Ann UExpr dom st -> Scope Source #
HasScopeInfo dom => HasScopeInfo' (Ann UQualifiedName dom st) Source #
Methods semanticsScope :: Ann UQualifiedName dom st -> Scope Source #
HasFixityInfo dom => HasFixityInfo' (Ann UQualifiedName dom st) Source #
Methods semanticsFixity :: Ann UQualifiedName dom st -> Maybe Fixity Source #
HasIdInfo dom => HasIdInfo' (Ann UQualifiedName dom st) Source #
Methods semanticsId :: Ann UQualifiedName dom st -> Id Source #
HasIdInfo dom => HasIdInfo' (Ann UName dom st) Source #
Methods semanticsId :: Ann UName dom st -> Id Source #
HasLiteralInfo dom => HasLiteralInfo' (Ann ULiteral dom st) Source #
Methods semanticsLiteralType :: Ann ULiteral dom st -> Type Source #
HasNameInfo dom => HasNameInfo' (Ann UQualifiedName dom st) Source #
Methods semanticsName :: Ann UQualifiedName dom st -> Maybe Name Source #
HasNameInfo dom => HasNameInfo' (Ann UName dom st) Source #
Methods semanticsName :: Ann UName dom st -> Maybe Name Source #
type Rep (Ann e dom stage) #
type Rep (Ann e dom stage) = D1 * (MetaData "Ann" "Language.Haskell.Tools.AST.Ann" "haskell-tools-ast-1.0.1.1-CHm5EkQXa6DBsvSfe3HZSm" False) (C1 * (MetaCons "Ann" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "_annotation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (NodeInfo (SemanticInfo dom e) (SpanInfo stage)))) (S1 * (MetaSel (Just Symbol "_element") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (e dom stage)))))
type IgnoredFields (Ann elem dom stage) #
type IgnoredFields (Ann elem dom stage) = (:) (Either (Symbol, Nat) Symbol) (Right (Symbol, Nat) Symbol "_annotation") ([] (Either (Symbol, Nat) Symbol))
type SourceInfoType (Ann elem dom stage) Source #
type SourceInfoType (Ann elem dom stage) = SpanInfo stage

element :: forall elem dom stage. Lens (Ann elem dom stage) (Ann elem dom stage) (elem dom stage) (elem dom stage) Source #

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)) Source #

data AnnListG elem dom stage Source #

A list of AST elements

Constructors

AnnListG
Fields _annListAnnot :: NodeInfo (SemanticInfo dom (AnnListG elem)) (ListInfo stage) _annListElems :: [Ann elem dom stage]

Instances

SourceInfoTraversal e => SourceInfoTraversal (AnnListG e) Source #
Methods sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnListG e dom st1 -> f (AnnListG e dom st2) Source # sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnListG e dom st1 -> f (AnnListG e dom st2) Source # sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> AnnListG e dom st1 -> f (AnnListG e dom st2) Source #
(ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (AnnListG e) Source #
Methods semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> AnnListG e dom1 st -> f (AnnListG e dom2 st) Source #
SourceInfo stage => HasRange (AnnListG elem dom stage) Source #
Methods getRange :: AnnListG elem dom stage -> SrcSpan Source # setRange :: SrcSpan -> AnnListG elem dom stage -> AnnListG elem dom stage Source #
HasSourceInfo (AnnListG elem dom stage) Source #
Associated Types type SourceInfoType (AnnListG elem dom stage) :: * Source # Methods srcInfo :: Simple Lens (AnnListG elem dom stage) (SourceInfoType (AnnListG elem dom stage)) Source #
type Rep (AnnListG e dom stage) #
type Rep (AnnListG e dom stage) = D1 * (MetaData "AnnListG" "Language.Haskell.Tools.AST.Ann" "haskell-tools-ast-1.0.1.1-CHm5EkQXa6DBsvSfe3HZSm" False) (C1 * (MetaCons "AnnListG" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "_annListAnnot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (NodeInfo (SemanticInfo dom (AnnListG e)) (ListInfo stage)))) (S1 * (MetaSel (Just Symbol "_annListElems") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Ann e dom stage]))))
type IgnoredFields (AnnListG elem dom stage) #
type IgnoredFields (AnnListG elem dom stage) = (:) (Either (Symbol, Nat) Symbol) (Right (Symbol, Nat) Symbol "_annListAnnot") ([] (Either (Symbol, Nat) Symbol))
type SourceInfoType (AnnListG elem dom stage) Source #
type SourceInfoType (AnnListG elem dom stage) = ListInfo stage

annListElems :: forall elem dom stage. Lens (AnnListG elem dom stage) (AnnListG elem dom stage) [Ann elem dom stage] [Ann elem dom stage] Source #

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)) Source #

annList :: Traversal (AnnListG e d s) (AnnListG e d s) (Ann e d s) (Ann e d s) Source #

data AnnMaybeG elem dom stage Source #

An optional AST element

Constructors

AnnMaybeG
Fields _annMaybeAnnot :: NodeInfo (SemanticInfo dom (AnnMaybeG elem)) (OptionalInfo stage) _annMaybe :: Maybe (Ann elem dom stage)

Instances

SourceInfoTraversal e => SourceInfoTraversal (AnnMaybeG e) Source #
Methods sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnMaybeG e dom st1 -> f (AnnMaybeG e dom st2) Source # sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnMaybeG e dom st1 -> f (AnnMaybeG e dom st2) Source # sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> AnnMaybeG e dom st1 -> f (AnnMaybeG e dom st2) Source #
(ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (AnnMaybeG e) Source #
Methods semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> AnnMaybeG e dom1 st -> f (AnnMaybeG e dom2 st) Source #
SourceInfo stage => HasRange (AnnMaybeG elem dom stage) Source #
Methods getRange :: AnnMaybeG elem dom stage -> SrcSpan Source # setRange :: SrcSpan -> AnnMaybeG elem dom stage -> AnnMaybeG elem dom stage Source #
HasSourceInfo (AnnMaybeG elem dom stage) Source #
Associated Types type SourceInfoType (AnnMaybeG elem dom stage) :: * Source # Methods srcInfo :: Simple Lens (AnnMaybeG elem dom stage) (SourceInfoType (AnnMaybeG elem dom stage)) Source #
type Rep (AnnMaybeG e dom stage) #
type Rep (AnnMaybeG e dom stage) = D1 * (MetaData "AnnMaybeG" "Language.Haskell.Tools.AST.Ann" "haskell-tools-ast-1.0.1.1-CHm5EkQXa6DBsvSfe3HZSm" False) (C1 * (MetaCons "AnnMaybeG" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "_annMaybeAnnot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (NodeInfo (SemanticInfo dom (AnnMaybeG e)) (OptionalInfo stage)))) (S1 * (MetaSel (Just Symbol "_annMaybe") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe (Ann e dom stage))))))
type IgnoredFields (AnnMaybeG elem dom stage) #
type IgnoredFields (AnnMaybeG elem dom stage) = (:) (Either (Symbol, Nat) Symbol) (Right (Symbol, Nat) Symbol "_annMaybeAnnot") ([] (Either (Symbol, Nat) Symbol))
type SourceInfoType (AnnMaybeG elem dom stage) Source #
type SourceInfoType (AnnMaybeG elem dom stage) = OptionalInfo 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)) Source #

annMaybe :: forall elem dom stage. Lens (AnnMaybeG elem dom stage) (AnnMaybeG elem dom stage) (Maybe (Ann elem dom stage)) (Maybe (Ann elem dom stage)) Source #

class HasSourceInfo e where Source #

Minimal complete definition

srcInfo

Associated Types

type SourceInfoType e :: * Source #

Methods

srcInfo :: Simple Lens e (SourceInfoType e) Source #

Instances

HasSourceInfo (Ann elem dom stage) Source #
Associated Types type SourceInfoType (Ann elem dom stage) :: * Source # Methods srcInfo :: Simple Lens (Ann elem dom stage) (SourceInfoType (Ann elem dom stage)) Source #
HasSourceInfo (AnnListG elem dom stage) Source #
Associated Types type SourceInfoType (AnnListG elem dom stage) :: * Source # Methods srcInfo :: Simple Lens (AnnListG elem dom stage) (SourceInfoType (AnnListG elem dom stage)) Source #
HasSourceInfo (AnnMaybeG elem dom stage) Source #
Associated Types type SourceInfoType (AnnMaybeG elem dom stage) :: * Source # Methods srcInfo :: Simple Lens (AnnMaybeG elem dom stage) (SourceInfoType (AnnMaybeG elem dom stage)) Source #

annJust :: Partial (AnnMaybeG e d s) (AnnMaybeG e d s) (Ann e d s) (Ann e d s) Source #

annNil :: NodeInfo (SemanticInfo d (AnnListG e)) (ListInfo s) -> AnnListG e d s Source #

An empty list of AST elements

isAnnNothing :: AnnMaybeG e d s -> Bool Source #

isAnnJust :: AnnMaybeG e d s -> Bool Source #

annLength :: AnnListG e d s -> Int Source #

annNothing :: NodeInfo (SemanticInfo d (AnnMaybeG e)) (OptionalInfo s) -> AnnMaybeG e d s Source #

A non-existing AST part

Info types

class ApplySemaChange cls where Source #

A class for changing semantic information throught the AST.

Minimal complete definition

appSemaChange

Methods

appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 cls -> f (SemanticInfo' dom2 cls) Source #

Instances

ApplySemaChange SemaInfoWildcardCls Source #
Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoWildcardCls -> f (SemanticInfo' dom2 SemaInfoWildcardCls) Source #
ApplySemaChange SemaInfoDefaultCls Source #
Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoDefaultCls -> f (SemanticInfo' dom2 SemaInfoDefaultCls) Source #
ApplySemaChange SemaInfoModuleCls Source #
Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoModuleCls -> f (SemanticInfo' dom2 SemaInfoModuleCls) Source #
ApplySemaChange SemaInfoImportCls Source #
Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoImportCls -> f (SemanticInfo' dom2 SemaInfoImportCls) Source #
ApplySemaChange SemaInfoExprCls Source #
Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoExprCls -> f (SemanticInfo' dom2 SemaInfoExprCls) Source #
ApplySemaChange SemaInfoLitCls Source #
Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoLitCls -> f (SemanticInfo' dom2 SemaInfoLitCls) Source #
ApplySemaChange SemaInfoNameCls Source #
Methods appSemaChange :: SemaTrf f dom1 dom2 -> SemanticInfo' dom1 SemaInfoNameCls -> f (SemanticInfo' dom2 SemaInfoNameCls) Source #

class ApplySemaChange (SemaInfoClassify a) => SemanticTraversal a where Source #

A class for traversing semantic information in an AST

Minimal complete definition

semaTraverse

Methods

semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> a dom1 st -> f (a dom2 st) Source #

Instances

(ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (Ann e) Source #
Methods semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> Ann e dom1 st -> f (Ann e dom2 st) Source #
(ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (AnnListG e) Source #
Methods semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> AnnListG e dom1 st -> f (AnnListG e dom2 st) Source #
(ApplySemaChange (SemaInfoClassify e), SemanticTraversal e) => SemanticTraversal (AnnMaybeG e) Source #
Methods semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> AnnMaybeG e dom1 st -> f (AnnMaybeG e dom2 st) Source #

data SemaTrf f dom1 dom2 Source #

A transformation on the possible semantic informations for a given domain

Constructors

SemaTrf

Fields

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 Source #

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) Source #

sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> a dom st1 -> f (a dom st2) Source #

sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> a dom st1 -> f (a dom st2) Source #

Instances

SourceInfoTraversal e => SourceInfoTraversal (Ann e) Source #
Methods sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Ann e dom st1 -> f (Ann e dom st2) Source # sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> Ann e dom st1 -> f (Ann e dom st2) Source # sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> Ann e dom st1 -> f (Ann e dom st2) Source #
SourceInfoTraversal e => SourceInfoTraversal (AnnListG e) Source #
Methods sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnListG e dom st1 -> f (AnnListG e dom st2) Source # sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnListG e dom st1 -> f (AnnListG e dom st2) Source # sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> AnnListG e dom st1 -> f (AnnListG e dom st2) Source #
SourceInfoTraversal e => SourceInfoTraversal (AnnMaybeG e) Source #
Methods sourceInfoTraverseUp :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnMaybeG e dom st1 -> f (AnnMaybeG e dom st2) Source # sourceInfoTraverseDown :: Monad f => SourceInfoTrf f st1 st2 -> f () -> f () -> AnnMaybeG e dom st1 -> f (AnnMaybeG e dom st2) Source # sourceInfoTraverse :: Monad f => SourceInfoTrf f st1 st2 -> AnnMaybeG e dom st1 -> f (AnnMaybeG e dom st2) Source #

data SourceInfoTrf f st1 st2 Source #

A transformation on the possible source informations

Constructors

SourceInfoTrf
Fields trfSpanInfo :: SpanInfo st1 -> f (SpanInfo st2) trfListInfo :: ListInfo st1 -> f (ListInfo st2) trfOptionalInfo :: OptionalInfo st1 -> f (OptionalInfo st2)

SemaInfoClassify UQualifiedName = SemaInfoNameCls
SemaInfoClassify ULiteral = SemaInfoLitCls
SemaInfoClassify UExpr = SemaInfoExprCls
SemaInfoClassify UImportDecl = SemaInfoImportCls
SemaInfoClassify UModule = SemaInfoModuleCls
SemaInfoClassify UFieldWildcard = SemaInfoWildcardCls
SemaInfoClassify a = SemaInfoDefaultCls