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 #

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 #
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 #
Methods nodeSpan :: Simple Lens (SpanInfo RangeStage) SrcSpan # listPos :: Simple Lens (ListInfo RangeStage) SrcLoc # optionalPos :: Simple Lens (OptionalInfo RangeStage) SrcLoc #
SourceInfo RangeStage #
Associated Types data SpanInfo RangeStage :: * # data ListInfo RangeStage :: * # data OptionalInfo RangeStage :: * #
Data (SpanInfo RangeStage) #
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) #
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) #
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) #
Methods showsPrec :: Int -> SpanInfo RangeStage -> ShowS # show :: SpanInfo RangeStage -> String # showList :: [SpanInfo RangeStage] -> ShowS #
Show (ListInfo RangeStage) #
Methods showsPrec :: Int -> ListInfo RangeStage -> ShowS # show :: ListInfo RangeStage -> String # showList :: [ListInfo RangeStage] -> ShowS #
Show (OptionalInfo RangeStage) #
Methods showsPrec :: Int -> OptionalInfo RangeStage -> ShowS # show :: OptionalInfo RangeStage -> String # showList :: [OptionalInfo RangeStage] -> ShowS #
HasRange (SpanInfo RangeStage) #
Methods getRange :: SpanInfo RangeStage -> SrcSpan # setRange :: SrcSpan -> SpanInfo RangeStage -> SpanInfo RangeStage #
HasRange (ListInfo RangeStage) #
Methods getRange :: ListInfo RangeStage -> SrcSpan # setRange :: SrcSpan -> ListInfo RangeStage -> ListInfo RangeStage #
HasRange (OptionalInfo RangeStage) #
Methods getRange :: OptionalInfo RangeStage -> SrcSpan # setRange :: SrcSpan -> OptionalInfo RangeStage -> OptionalInfo RangeStage #
data SpanInfo RangeStage #
data SpanInfo RangeStage = NodeSpan { _nodeSpan :: SrcSpan }
data ListInfo RangeStage #
data ListInfo RangeStage = ListPos { _listBefore :: String _listAfter :: String _listDefaultSep :: String _listIndented :: Maybe [Bool] _listPos :: SrcLoc }
data OptionalInfo RangeStage #
data OptionalInfo RangeStage = OptionalPos { _optionalBefore :: String _optionalAfter :: String _optionalPos :: SrcLoc }

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 NormRangeStage #
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 #
Associated Types data SpanInfo NormRangeStage :: * # data ListInfo NormRangeStage :: * # data OptionalInfo NormRangeStage :: * #
Data (SpanInfo NormRangeStage) #
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) #
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) #
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) #
Methods showsPrec :: Int -> SpanInfo NormRangeStage -> ShowS # show :: SpanInfo NormRangeStage -> String # showList :: [SpanInfo NormRangeStage] -> ShowS #
Show (ListInfo NormRangeStage) #
Methods showsPrec :: Int -> ListInfo NormRangeStage -> ShowS # show :: ListInfo NormRangeStage -> String # showList :: [ListInfo NormRangeStage] -> ShowS #
Show (OptionalInfo NormRangeStage) #
Methods showsPrec :: Int -> OptionalInfo NormRangeStage -> ShowS # show :: OptionalInfo NormRangeStage -> String # showList :: [OptionalInfo NormRangeStage] -> ShowS #
HasRange (SpanInfo NormRangeStage) #
Methods getRange :: SpanInfo NormRangeStage -> SrcSpan # setRange :: SrcSpan -> SpanInfo NormRangeStage -> SpanInfo NormRangeStage #
HasRange (ListInfo NormRangeStage) #
Methods getRange :: ListInfo NormRangeStage -> SrcSpan # setRange :: SrcSpan -> ListInfo NormRangeStage -> ListInfo NormRangeStage #
HasRange (OptionalInfo NormRangeStage) #
Methods getRange :: OptionalInfo NormRangeStage -> SrcSpan # setRange :: SrcSpan -> OptionalInfo NormRangeStage -> OptionalInfo NormRangeStage #
data SpanInfo NormRangeStage #
data SpanInfo NormRangeStage = NormNodeInfo { _normNodeSpan :: SrcSpan }
data ListInfo NormRangeStage #
data ListInfo NormRangeStage = NormListInfo { _normListBefore :: String _normListAfter :: String _normListDefaultSep :: String _normListIndented :: Maybe [Bool] _normListSpan :: SrcSpan }
data OptionalInfo NormRangeStage #
data OptionalInfo NormRangeStage = NormOptInfo { _normOptBefore :: String _normOptAfter :: String _normOptSpan :: SrcSpan }

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 #

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 #

data Dom name #

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

data IdDom #

Instances

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

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

data SemaInfoNameCls #

Instances

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

data SemaInfoLitCls #

Instances

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

data SemaInfoExprCls #

Instances

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

data SemaInfoImportCls #

Instances

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

data SemaInfoModuleCls #

Instances

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

data SemaInfoDefaultCls #

Instances

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

data SemaInfoWildcardCls #

Instances

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

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

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

Instances

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

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

class HasRange a where #

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 #

setRange :: SrcSpan -> a -> a #

Instances

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

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

data SpanInfo stage :: * #

UType of source info for normal AST elements

data ListInfo stage :: * #

UType of source info for lists of AST elements

data OptionalInfo stage :: * #

UType of source info for optional AST elements

Instances

SourceInfo NormRangeStage #
Associated Types data SpanInfo NormRangeStage :: * # data ListInfo NormRangeStage :: * # data OptionalInfo NormRangeStage :: * #
SourceInfo RangeStage #
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

nodeSpan, listPos, optionalPos

Methods

nodeSpan :: Simple Lens (SpanInfo stage) SrcSpan #

listPos :: Simple Lens (ListInfo stage) SrcLoc #

optionalPos :: Simple Lens (OptionalInfo stage) SrcLoc #

Instances

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

Annotations

data NodeInfo sema src #

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) #
Methods (==) :: NodeInfo sema src -> NodeInfo sema src -> Bool # (/=) :: NodeInfo sema src -> NodeInfo sema src -> Bool #
(Data src, Data sema) => Data (NodeInfo sema src) #
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) #
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' #

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

data Ann elem dom stage #

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) #
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) #
Methods semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> Ann e dom1 st -> f (Ann e dom2 st) #
SourceInfo src => Eq (Ann elem dom src) #
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) #
Methods getRange :: Ann elem dom stage -> SrcSpan # setRange :: SrcSpan -> Ann elem dom stage -> Ann elem dom stage #
HasSourceInfo (Ann elem dom stage) #
Associated Types type SourceInfoType (Ann elem dom stage) :: * # Methods srcInfo :: Simple Lens (Ann elem dom stage) (SourceInfoType (Ann elem dom stage)) #
HasImplicitFieldsInfo dom => HasImplicitFieldsInfo' (Ann UFieldWildcard dom st) #
Methods semanticsImplicitFlds :: Ann UFieldWildcard dom st -> [(Name, Name)] #
HasImportInfo dom => HasImportInfo' (Ann UImportDecl dom st) #
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) #
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) #
Methods semanticsDefining :: Ann UQualifiedName dom st -> Bool #
HasScopeInfo dom => HasScopeInfo' (Ann UExpr dom st) #
Methods semanticsScope :: Ann UExpr dom st -> Scope #
HasScopeInfo dom => HasScopeInfo' (Ann UQualifiedName dom st) #
Methods semanticsScope :: Ann UQualifiedName dom st -> Scope #
HasFixityInfo dom => HasFixityInfo' (Ann UQualifiedName dom st) #
Methods semanticsFixity :: Ann UQualifiedName dom st -> Maybe Fixity #
HasIdInfo dom => HasIdInfo' (Ann UQualifiedName dom st) #
Methods semanticsId :: Ann UQualifiedName dom st -> Id #
HasIdInfo dom => HasIdInfo' (Ann UName dom st) #
Methods semanticsId :: Ann UName dom st -> Id #
HasLiteralInfo dom => HasLiteralInfo' (Ann ULiteral dom st) #
Methods semanticsLiteralType :: Ann ULiteral dom st -> Type #
HasNameInfo dom => HasNameInfo' (Ann UQualifiedName dom st) #
Methods semanticsName :: Ann UQualifiedName dom st -> Maybe Name #
HasNameInfo dom => HasNameInfo' (Ann UName dom st) #
Methods semanticsName :: Ann UName dom st -> Maybe Name #
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-9s02iY9BsSR4gntjKFp7Ge" 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) #
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) #

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 _annListAnnot :: NodeInfo (SemanticInfo dom (AnnListG elem)) (ListInfo stage) _annListElems :: [Ann elem dom stage]

Instances

SourceInfoTraversal e => SourceInfoTraversal (AnnListG e) #
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) #
Methods semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> AnnListG e dom1 st -> f (AnnListG e dom2 st) #
SourceInfo stage => HasRange (AnnListG elem dom stage) #
Methods getRange :: AnnListG elem dom stage -> SrcSpan # setRange :: SrcSpan -> AnnListG elem dom stage -> AnnListG elem dom stage #
HasSourceInfo (AnnListG elem dom stage) #
Associated Types type SourceInfoType (AnnListG elem dom stage) :: * # Methods srcInfo :: Simple Lens (AnnListG elem dom stage) (SourceInfoType (AnnListG elem dom stage)) #
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-9s02iY9BsSR4gntjKFp7Ge" 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) #
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] #

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 #

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) #
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) #
Methods semaTraverse :: Monad f => SemaTrf f dom1 dom2 -> AnnMaybeG e dom1 st -> f (AnnMaybeG e dom2 st) #
SourceInfo stage => HasRange (AnnMaybeG elem dom stage) #
Methods getRange :: AnnMaybeG elem dom stage -> SrcSpan # setRange :: SrcSpan -> AnnMaybeG elem dom stage -> AnnMaybeG elem dom stage #
HasSourceInfo (AnnMaybeG elem dom stage) #
Associated Types type SourceInfoType (AnnMaybeG elem dom stage) :: * # Methods srcInfo :: Simple Lens (AnnMaybeG elem dom stage) (SourceInfoType (AnnMaybeG elem dom stage)) #
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-9s02iY9BsSR4gntjKFp7Ge" 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) #
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)) #

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

srcInfo

Associated Types

type SourceInfoType e :: * #

Methods

srcInfo :: Simple Lens e (SourceInfoType e) #

Instances

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

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 #

An empty list of AST elements

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 #

A non-existing AST part

Info types

class ApplySemaChange cls where #

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

Instances

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

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

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

Instances

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

data SemaTrf f dom1 dom2 #

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 #

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

SourceInfoTraversal e => SourceInfoTraversal (Ann e) #
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) #
SourceInfoTraversal e => SourceInfoTraversal (AnnListG e) #
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) #
SourceInfoTraversal e => SourceInfoTraversal (AnnMaybeG e) #
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) #

data SourceInfoTrf f st1 st2 #

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