Language.Haskell.Tools.AST.FromGHC

The FromGHC module provides a way to transform the GHC AST into our AST. This transformation is done in the Ghc monad. The conversion can be performed from the Parsed and the Renamed GHC AST. If the renamed AST is given, additional semantic information is looked up while traversing the AST.

Documentation

addTypeInfos :: LHsBinds Id -> Ann Module RangeWithName -> Ghc (Ann Module RangeWithType)

getTypeVariables :: TyCon -> [Id]

extractTypes :: LHsBinds Id -> [Id]

extractExprIds :: LHsBinds Id -> [Located Id]

trfModule :: Located (HsModule RdrName) -> Trf (Ann Module RangeInfo)

trfModuleRename :: Module -> Ann Module RangeInfo -> (HsGroup Name, [LImportDecl Name], Maybe [LIE Name], Maybe LHsDocString) -> Located (HsModule RdrName) -> Trf (Ann Module RangeWithName)

trfModuleHead :: TransformName n r => Maybe (Located ModuleName) -> Maybe (Located [LIE n]) -> Maybe (Located WarningTxt) -> Trf (AnnMaybe ModuleHead r)

trfFilePragmas :: RangeAnnot a => Trf (AnnList FilePragma a)

trfLanguagePragma :: RangeAnnot a => Located String -> Trf (Ann FilePragma a)

trfOptionsPragma :: RangeAnnot a => Located String -> Trf (Ann FilePragma a)

trfModulePragma :: RangeAnnot a => Maybe (Located WarningTxt) -> Trf (AnnMaybe ModulePragma a)

trfText' :: RangeAnnot a => StringLiteral -> Trf (StringNode a)

trfExportList :: TransformName n r => SrcLoc -> Maybe (Located [LIE n]) -> Trf (AnnMaybe ExportSpecList r)

trfExportList' :: TransformName n r => [LIE n] -> Trf (ExportSpecList r)

trfExport :: TransformName n r => LIE n -> Trf (Maybe (Ann ExportSpec r))

trfImports :: TransformName n r => [LImportDecl n] -> Trf (AnnList ImportDecl r)

trfImport :: forall n r. TransformName n r => LImportDecl n -> Trf (Ann ImportDecl r)

trfImportSpecs :: TransformName n r => Maybe (Bool, Located [LIE n]) -> Trf (AnnMaybe ImportSpec r)

trfIESpec :: TransformName n r => LIE n -> Trf (Maybe (Ann IESpec r))

trfIESpec' :: TransformName n r => IE n -> Trf (Maybe (IESpec r))

type Trf = ReaderT TrfInput Ghc

The transformation monad type

data TrfInput

The (immutable) data for the transformation

Constructors

TrfInput

Fields

• srcMap :: SourceMap

  The lexical tokens of the source file

• pragmaComms :: Map String [Located String]

  Pragma comments

• contRange :: SrcSpan

  The focus of the transformation

• localsInScope :: [[Name]]

  Local names visible

• defining :: Bool

  True, if names are defined in the transformed AST element.

• definingTypeVars :: Bool

  True, if type variable names are defined in the transformed AST element.

• originalNames :: Map SrcSpan RdrName

  Stores the original format of names.

trfInit :: Map ApiAnnKey [SrcSpan] -> Map String [Located String] -> TrfInput

define :: Trf a -> Trf a

Perform the transformation taking names as defined.

defineTypeVars :: Trf a -> Trf a

Perform the transformation taking type variable names as defined.

typeVarTransform :: Trf a -> Trf a

Transform as type variables

transformingPossibleVar :: HsHasName n => n -> Trf a -> Trf a

Transform a name as a type variable if it is one.

addToScope :: HsHasName e => e -> Trf a -> Trf a

Perform the transformation putting the given definition in a new local scope.

addToCurrentScope :: HsHasName e => e -> Trf a -> Trf a

Perform the transformation putting the given definitions in the current scope.

runTrf :: Map ApiAnnKey [SrcSpan] -> Map String [Located String] -> Trf a -> Ghc a

Performs the transformation given the tokens of the source file

setOriginalNames :: Map SrcSpan RdrName -> Trf a -> Trf a

getOriginalName :: RdrName -> Trf String

Get the original format of a name (before scoping).

trfOperator :: TransformName name res => Located name -> Trf (Ann Operator res)

trfOperator' :: TransformName name res => name -> Trf (Operator res)

trfName :: TransformName name res => Located name -> Trf (Ann Name res)

trfName' :: TransformName name res => name -> Trf (Name res)

trfAmbiguousFieldName :: TransformName n res => Located (AmbiguousFieldOcc n) -> Trf (Ann Name res)

trfAmbiguousFieldName' :: forall n res. TransformName n res => SrcSpan -> AmbiguousFieldOcc n -> Trf (Ann Name res)

class (DataId n, Eq n, GHCName n) => TransformableName n where

Minimal complete definition

correctNameString

Methods

correctNameString :: n -> Trf String

Instances

TransformableName RdrName

Methods

correctNameString :: RdrName -> Trf String

TransformableName Name

Methods

correctNameString :: Name -> Trf String

class (RangeAnnot res, SemanticAnnot res name, SemanticAnnot res Name, TransformableName name, HsHasName name) => TransformName name res

This class allows us to use the same transformation code for multiple variants of the GHC AST. GHC Name annotated with name can be transformed to our representation with semantic annotations of res.

Instances

TransformName RdrName RangeInfo

(RangeAnnot r, SemanticAnnot r Name) => TransformName Name r

addNameInfo :: TransformName n r => n -> Ann SimpleName r -> Trf (Ann SimpleName r)

trfSimpleName :: TransformName name res => Located name -> Trf (Ann SimpleName res)

trfSimpleName' :: TransformName name res => name -> Trf (SimpleName res)

trfNameStr :: RangeAnnot a => String -> Trf (AnnList UnqualName a)

Creates a qualified name from a name string

trfNameStr' :: RangeAnnot a => String -> SrcLoc -> [Ann UnqualName a]

trfModuleName :: RangeAnnot a => Located ModuleName -> Trf (Ann SimpleName a)

trfModuleName' :: RangeAnnot a => ModuleName -> Trf (SimpleName a)

trfFastString :: RangeAnnot a => Located FastString -> Trf (Ann StringNode a)

trfDataKeyword :: RangeAnnot a => NewOrData -> Trf (Ann DataOrNewtypeKeyword a)

trfCallConv :: RangeAnnot a => Located CCallConv -> Trf (Ann CallConv a)

trfCallConv' :: RangeAnnot a => CCallConv -> Trf (CallConv a)

trfSafety :: RangeAnnot a => SrcSpan -> Located Safety -> Trf (AnnMaybe Safety a)

trfOverlap :: RangeAnnot a => Located OverlapMode -> Trf (Ann OverlapPragma a)

trfRole :: RangeAnnot a => Located (Maybe Role) -> Trf (Ann Role a)

trfPhase :: RangeAnnot a => Trf SrcLoc -> Activation -> Trf (AnnMaybe PhaseControl a)

trfPhaseNum :: RangeAnnot a => PhaseNum -> Trf (Ann PhaseNumber a)

class HasRange annot => RangeAnnot annot where

Annotations that is made up from ranges

Minimal complete definition

toNodeAnnot, toListAnnot, toIndentedListAnnot, toOptAnnot

Methods

toNodeAnnot :: SrcSpan -> annot

toListAnnot :: String -> String -> String -> SrcLoc -> annot

toIndentedListAnnot :: String -> String -> String -> SrcLoc -> annot

toOptAnnot :: String -> String -> SrcLoc -> annot

Instances

RangeAnnot (NodeInfo (SemanticInfo n) SpanInfo)

Methods

toNodeAnnot :: SrcSpan -> NodeInfo (SemanticInfo n) SpanInfo

toListAnnot :: String -> String -> String -> SrcLoc -> NodeInfo (SemanticInfo n) SpanInfo

toIndentedListAnnot :: String -> String -> String -> SrcLoc -> NodeInfo (SemanticInfo n) SpanInfo

toOptAnnot :: String -> String -> SrcLoc -> NodeInfo (SemanticInfo n) SpanInfo

class SemanticAnnot annot n where

Annotations that carry semantic information

Minimal complete definition

addSemanticInfo, addScopeData, addImportData

Methods

addSemanticInfo :: SemanticInfo n -> annot -> annot

addScopeData :: annot -> Trf annot

addImportData :: Ann ImportDecl annot -> Trf (Ann ImportDecl annot)

Instances

SemanticAnnot RangeWithName Name

Methods

addSemanticInfo :: SemanticInfo Name -> RangeWithName -> RangeWithName

addScopeData :: RangeWithName -> Trf RangeWithName

addImportData :: Ann ImportDecl RangeWithName -> Trf (Ann ImportDecl RangeWithName)

SemanticAnnot RangeInfo n

Methods

addSemanticInfo :: SemanticInfo n -> RangeInfo -> RangeInfo

addScopeData :: RangeInfo -> Trf RangeInfo

addImportData :: Ann ImportDecl RangeInfo -> Trf (Ann ImportDecl RangeInfo)

SemanticAnnot RangeInfo RdrName

Methods

addSemanticInfo :: SemanticInfo RdrName -> RangeInfo -> RangeInfo

addScopeData :: RangeInfo -> Trf RangeInfo

addImportData :: Ann ImportDecl RangeInfo -> Trf (Ann ImportDecl RangeInfo)

addImportData' :: Ann ImportDecl RangeWithName -> Trf (Ann ImportDecl RangeWithName)

Adds semantic information to an impord declaration. See ImportInfo.

getImportedNames :: String -> Maybe String -> Trf (Module, [Name])

Get names that are imported from a given import

checkImportVisible :: GhcMonad m => ImportDecl RangeWithName -> Name -> m Bool

Check is a given name is imported from an import with given import specification.

ieSpecMatches :: GhcMonad m => IESpec RangeWithName -> Name -> m Bool

nothing :: RangeAnnot a => String -> String -> Trf SrcLoc -> Trf (AnnMaybe e a)

Creates a place for a missing node with a default location

emptyList :: RangeAnnot a => String -> Trf SrcLoc -> Trf (AnnList e a)

makeList :: RangeAnnot a => String -> Trf SrcLoc -> Trf [Ann e a] -> Trf (AnnList e a)

Creates a place for a list of nodes with a default place if the list is empty.

makeListBefore :: RangeAnnot a => String -> String -> Trf SrcLoc -> Trf [Ann e a] -> Trf (AnnList e a)

makeListAfter :: RangeAnnot a => String -> String -> Trf SrcLoc -> Trf [Ann e a] -> Trf (AnnList e a)

makeNonemptyList :: RangeAnnot a => String -> Trf [Ann e a] -> Trf (AnnList e a)

makeIndentedList :: RangeAnnot a => Trf SrcLoc -> Trf [Ann e a] -> Trf (AnnList e a)

Creates a place for an indented list of nodes with a default place if the list is empty.

makeIndentedListNewlineBefore :: RangeAnnot a => Trf SrcLoc -> Trf [Ann e a] -> Trf (AnnList e a)

makeIndentedListBefore :: RangeAnnot a => String -> Trf SrcLoc -> Trf [Ann e a] -> Trf (AnnList e a)

makeNonemptyIndentedList :: RangeAnnot a => Trf [Ann e a] -> Trf (AnnList e a)

trfLoc :: RangeAnnot i => (a -> Trf (b i)) -> Located a -> Trf (Ann b i)

Transform a located part of the AST by automatically transforming the location. Sets the source range for transforming children.

trfMaybe :: RangeAnnot i => String -> String -> (Located a -> Trf (Ann e i)) -> Maybe (Located a) -> Trf (AnnMaybe e i)

Transforms a possibly-missing node with the default location of the end of the focus.

trfMaybeDefault :: RangeAnnot i => String -> String -> (Located a -> Trf (Ann e i)) -> Trf SrcLoc -> Maybe (Located a) -> Trf (AnnMaybe e i)

Transforms a possibly-missing node with a default location

trfLocCorrect :: RangeAnnot i => (SrcSpan -> Trf SrcSpan) -> (a -> Trf (b i)) -> Located a -> Trf (Ann b i)

Transform a located part of the AST by automatically transforming the location with correction by applying the given function. Sets the source range for transforming children.

trfMaybeLoc :: RangeAnnot i => (a -> Trf (Maybe (b i))) -> Located a -> Trf (Maybe (Ann b i))

Transform a located part of the AST by automatically transforming the location. Sets the source range for transforming children.

trfAnnList :: RangeAnnot i => String -> (a -> Trf (b i)) -> [Located a] -> Trf (AnnList b i)

Creates a place for a list of nodes with the default place at the end of the focus if the list is empty.

trfAnnList' :: RangeAnnot i => String -> (Located a -> Trf (Ann b i)) -> [Located a] -> Trf (AnnList b i)

nonemptyAnnList :: RangeAnnot i => [Ann e i] -> AnnList e i

Creates a place for a list of nodes that cannot be empty.

makeJust :: RangeAnnot a => Ann e a -> AnnMaybe e a

Creates an optional node from an existing element

annLoc :: RangeAnnot a => Trf SrcSpan -> Trf (b a) -> Trf (Ann b a)

Annotates a node with the given location and focuses on the given source span.

Focus manipulation

focusOn :: SrcSpan -> Trf a -> Trf a

between :: AnnKeywordId -> AnnKeywordId -> Trf a -> Trf a

Focuses the transformation to go between tokens. The tokens must be found inside the current range.

betweenIfPresent :: AnnKeywordId -> AnnKeywordId -> Trf a -> Trf a

Focuses the transformation to go between tokens if they are present

focusAfter :: AnnKeywordId -> Trf a -> Trf a

Focuses the transformation to be performed after the given token. The token must be found inside the current range.

focusAfterIfPresent :: AnnKeywordId -> Trf a -> Trf a

focusBefore :: AnnKeywordId -> Trf a -> Trf a

Focuses the transformation to be performed after the given token. The token must be found inside the current range.

focusBeforeIfPresent :: AnnKeywordId -> Trf a -> Trf a

before :: AnnKeywordId -> Trf SrcLoc

Gets the position before the given token

after :: AnnKeywordId -> Trf SrcLoc

Gets the position after the given token

annFrom :: RangeAnnot a => AnnKeywordId -> Trf (e a) -> Trf (Ann e a)

The element should span from the given token to the end of focus

atTheStart :: Trf SrcLoc

Gets the position at the beginning of the focus

atTheEnd :: Trf SrcLoc

Gets the position at the end of the focus

tokenLoc :: AnnKeywordId -> Trf SrcSpan

Searches for a token inside the focus and retrieves its location

allTokenLoc :: AnnKeywordId -> Trf [SrcSpan]

tokenLocBack :: AnnKeywordId -> Trf SrcSpan

Searches for a token backward inside the focus and retrieves its location

tokenBefore :: SrcLoc -> AnnKeywordId -> Trf SrcSpan

tokensLoc :: [AnnKeywordId] -> Trf SrcSpan

Searches for tokens in the given order inside the parent element and returns their combined location

uniqueTokenAnywhere :: AnnKeywordId -> Trf SrcSpan

Searches for a token and retrieves its location anywhere

annCont :: RangeAnnot a => Trf (e a) -> Trf (Ann e a)

Annotates the given element with the current focus as a location.

copyAnnot :: (Ann a i -> b i) -> Trf (Ann a i) -> Trf (Ann b i)

Annotates the element with the same annotation that is on the other element

foldLocs :: [SrcSpan] -> SrcSpan

Combine source spans into one that contains them all

advanceStr :: String -> SrcLoc -> SrcLoc

The location after the given string

updateCol :: (Int -> Int) -> SrcLoc -> SrcLoc

Update column information in a source location

collectLocs :: [Located e] -> SrcSpan

Combine source spans of elements into one that contains them all

orderDefs :: RangeAnnot i => [Ann e i] -> [Ann e i]

Rearrange definitions to appear in the order they are defined in the source file.

orderAnnList :: RangeAnnot i => AnnList e i -> AnnList e i

Orders a list of elements to the order they are defined in the source file.

trfScopedSequence :: HsHasName d => (d -> Trf e) -> [d] -> Trf [e]

Transform a list of definitions where the defined names are in scope for subsequent definitions

splitLocated :: Located String -> [Located String]

Splits a given string at whitespaces while calculating the source location of the fragments