GHC.Iface.Ext.Utils

Documentation

type RefMap a = Map Identifier [(Span, IdentifierDetails a)]

generateReferencesMap :: Foldable f => f (HieAST a) -> RefMap a

renderHieType :: DynFlags -> HieTypeFix -> String

resolveVisibility :: Type -> [Type] -> [(Bool, Type)]

foldType :: (HieType a -> a) -> HieTypeFix -> a

selectPoint :: HieFile -> (Int, Int) -> Maybe (HieAST Int)

findEvidenceUse :: NodeIdentifiers a -> [Name]

data EvidenceInfo a

Constructors

EvidenceInfo

Fields

• evidenceVar :: Name
• evidenceSpan :: RealSrcSpan
• evidenceType :: a
• evidenceDetails :: Maybe (EvVarSource, Scope, Maybe Span)

Instances

Functor EvidenceInfo

Defined in GHC.Iface.Ext.Utils

Methods

fmap :: (a -> b) -> EvidenceInfo a -> EvidenceInfo b

(<$) :: a -> EvidenceInfo b -> EvidenceInfo a

Outputable a => Outputable (EvidenceInfo a)

Defined in GHC.Iface.Ext.Utils

Methods

ppr :: EvidenceInfo a -> SDoc

Eq a => Eq (EvidenceInfo a)

Defined in GHC.Iface.Ext.Utils

Methods

(==) :: EvidenceInfo a -> EvidenceInfo a -> Bool

(/=) :: EvidenceInfo a -> EvidenceInfo a -> Bool

Ord a => Ord (EvidenceInfo a)

Defined in GHC.Iface.Ext.Utils

Methods

compare :: EvidenceInfo a -> EvidenceInfo a -> Ordering

(<) :: EvidenceInfo a -> EvidenceInfo a -> Bool

(<=) :: EvidenceInfo a -> EvidenceInfo a -> Bool

(>) :: EvidenceInfo a -> EvidenceInfo a -> Bool

(>=) :: EvidenceInfo a -> EvidenceInfo a -> Bool

max :: EvidenceInfo a -> EvidenceInfo a -> EvidenceInfo a

min :: EvidenceInfo a -> EvidenceInfo a -> EvidenceInfo a

getEvidenceTreesAtPoint :: HieFile -> RefMap a -> (Int, Int) -> Forest (EvidenceInfo a)

getEvidenceTree :: RefMap a -> Name -> Maybe (Tree (EvidenceInfo a))

hieTypeToIface :: HieTypeFix -> IfaceType

data HieTypeState

Constructors

HTS

Fields

• tyMap :: !(TypeMap TypeIndex)
• htyTable :: !(IntMap HieTypeFlat)
• freshIndex :: !TypeIndex

initialHTS :: HieTypeState

freshTypeIndex :: State HieTypeState TypeIndex

compressTypes :: HieASTs Type -> (HieASTs TypeIndex, Array TypeIndex HieTypeFlat)

recoverFullType :: TypeIndex -> Array TypeIndex HieTypeFlat -> HieTypeFix

getTypeIndex :: Type -> State HieTypeState TypeIndex

resolveTyVarScopes :: Map HiePath (HieAST a) -> Map HiePath (HieAST a)

resolveTyVarScopeLocal :: HieAST a -> Map HiePath (HieAST a) -> HieAST a

getNameBinding :: Name -> Map HiePath (HieAST a) -> Maybe Span

getNameScope :: Name -> Map HiePath (HieAST a) -> Maybe [Scope]

getNameBindingInClass :: Name -> Span -> Map HiePath (HieAST a) -> Maybe Span

getNameScopeAndBinding :: Name -> Map HiePath (HieAST a) -> Maybe ([Scope], Maybe Span)

getScopeFromContext :: ContextInfo -> Maybe [Scope]

getBindSiteFromContext :: ContextInfo -> Maybe Span

flattenAst :: HieAST a -> [HieAST a]

smallestContainingSatisfying :: Span -> (HieAST a -> Bool) -> HieAST a -> Maybe (HieAST a)

selectLargestContainedBy :: Span -> HieAST a -> Maybe (HieAST a)

selectSmallestContaining :: Span -> HieAST a -> Maybe (HieAST a)

definedInAsts :: Map HiePath (HieAST a) -> Name -> Bool

getEvidenceBindDeps :: ContextInfo -> [Name]

isEvidenceBind :: ContextInfo -> Bool

isEvidenceContext :: ContextInfo -> Bool

isEvidenceUse :: ContextInfo -> Bool

isOccurrence :: ContextInfo -> Bool

scopeContainsSpan :: Scope -> Span -> Bool

combineAst :: HieAST Type -> HieAST Type -> HieAST Type

One must contain the other. Leaf nodes cannot contain anything

insertAst :: HieAST Type -> [HieAST Type] -> [HieAST Type]

Insert an AST in a sorted list of disjoint Asts

nodeInfo :: HieAST Type -> NodeInfo Type

emptyNodeInfo :: NodeInfo a

sourcedNodeIdents :: SourcedNodeInfo a -> NodeIdentifiers a

combineSourcedNodeInfo :: SourcedNodeInfo Type -> SourcedNodeInfo Type -> SourcedNodeInfo Type

combineNodeInfo :: NodeInfo Type -> NodeInfo Type -> NodeInfo Type

Merge two nodes together.

Precondition and postcondition: elements in nodeType are ordered.

mergeAsts :: [HieAST Type] -> [HieAST Type] -> [HieAST Type]

Merge two sorted, disjoint lists of ASTs, combining when necessary.

In the absence of position-altering pragmas (ex: # line "file.hs" 3), different nodes in an AST tree should either have disjoint spans (in which case you can say for sure which one comes first) or one span should be completely contained in the other (in which case the contained span corresponds to some child node).

However, since Haskell does have position-altering pragmas it is possible for spans to be overlapping. Here is an example of a source file in which foozball and quuuuuux have overlapping spans:

module Baz where

# line 3 "Baz.hs"
foozball :: Int
foozball = 0

# line 3 "Baz.hs"
bar, quuuuuux :: Int
bar = 1
quuuuuux = 2

In these cases, we just do our best to produce sensible HieAST's. The blame should be laid at the feet of whoever wrote the line pragmas in the first place (usually the C preprocessor...).

rightOf :: Span -> Span -> Bool

leftOf :: Span -> Span -> Bool

startsRightOf :: Span -> Span -> Bool

mergeSortAsts :: [HieAST Type] -> [HieAST Type]

combines and sorts ASTs using a merge sort

simpleNodeInfo :: FastString -> FastString -> NodeInfo a

locOnly :: Monad m => SrcSpan -> ReaderT NodeOrigin m [HieAST a]

locOnlyE :: Monad m => EpaLocation -> ReaderT NodeOrigin m [HieAST a]

mkScope :: HasLoc a => a -> Scope

combineScopes :: Scope -> Scope -> Scope

mkSourcedNodeInfo :: NodeOrigin -> NodeInfo a -> SourcedNodeInfo a

makeNodeA

Arguments

:: (Monad m, Data a)

=> a

helps fill in nodeAnnotations (with Data)

-> EpAnn ann

return an empty list if this is unhelpful

-> ReaderT NodeOrigin m [HieAST b]

makeNode

Arguments

:: (Monad m, Data a)

=> a

helps fill in nodeAnnotations (with Data)

-> SrcSpan

return an empty list if this is unhelpful

-> ReaderT NodeOrigin m [HieAST b]

makeTypeNodeA

Arguments

:: (Monad m, Data a)

=> a

helps fill in nodeAnnotations (with Data)

-> SrcSpanAnnA

return an empty list if this is unhelpful

-> Type

type to associate with the node

-> ReaderT NodeOrigin m [HieAST Type]

makeTypeNode

Arguments

:: (Monad m, Data a)

=> a

helps fill in nodeAnnotations (with Data)

-> SrcSpan

return an empty list if this is unhelpful

-> Type

type to associate with the node

-> ReaderT NodeOrigin m [HieAST Type]