Safe Haskell | None |
---|---|
Language | Haskell2010 |
HieTypes
Synopsis
- type Span = RealSrcSpan
- hieVersion :: Integer
- data HieFile = HieFile {}
- type TypeIndex = Int
- data HieType a
- type HieTypeFlat = HieType TypeIndex
- newtype HieTypeFix = Roll (HieType HieTypeFix)
- newtype HieArgs a = HieArgs [(Bool, a)]
- newtype HieASTs a = HieASTs {
- getAsts :: Map FastString (HieAST a)
- data HieAST a = Node {}
- data NodeInfo a = NodeInfo {
- nodeAnnotations :: Set (FastString, FastString)
- nodeType :: [a]
- nodeIdentifiers :: NodeIdentifiers a
- type Identifier = Either ModuleName Name
- type NodeIdentifiers a = Map Identifier (IdentifierDetails a)
- data IdentifierDetails a = IdentifierDetails {
- identType :: Maybe a
- identInfo :: Set ContextInfo
- data ContextInfo
- data IEType
- = Import
- | ImportAs
- | ImportHiding
- | Export
- data RecFieldContext
- data BindType
- data DeclType
- data Scope
- data TyVarScope
- = ResolvedScopes [Scope]
- | UnresolvedScope [Name] (Maybe Span)
Documentation
type Span = RealSrcSpan Source #
hieVersion :: Integer Source #
Current version of .hie
files
GHC builds up a wealth of information about Haskell source as it compiles it.
.hie
files are a way of persisting some of this information to disk so that
external tools that need to work with haskell source don't need to parse,
typecheck, and rename all over again. These files contain:
a simplified AST
- nodes are annotated with source positions and types
- identifiers are annotated with scope information
- the raw bytes of the initial Haskell source
Besides saving compilation cycles, .hie
files also offer a more stable
interface than the GHC API.
Constructors
HieFile | |
Fields
|
A flattened version of Type
.
See Note [Efficient serialization of redundant type info]
Constructors
HTyVarTy Name | |
HAppTy a (HieArgs a) | |
HTyConApp IfaceTyCon (HieArgs a) | |
HForAllTy ((Name, a), ArgFlag) a | |
HFunTy a a | |
HQualTy a a | type with constraint: |
HLitTy IfaceTyLit | |
HCastTy a | |
HCoercionTy |
Instances
Functor HieType # | |
Foldable HieType # | |
Defined in HieTypes Methods fold :: Monoid m => HieType m -> m Source # foldMap :: Monoid m => (a -> m) -> HieType a -> m Source # foldMap' :: Monoid m => (a -> m) -> HieType a -> m Source # foldr :: (a -> b -> b) -> b -> HieType a -> b Source # foldr' :: (a -> b -> b) -> b -> HieType a -> b Source # foldl :: (b -> a -> b) -> b -> HieType a -> b Source # foldl' :: (b -> a -> b) -> b -> HieType a -> b Source # foldr1 :: (a -> a -> a) -> HieType a -> a Source # foldl1 :: (a -> a -> a) -> HieType a -> a Source # toList :: HieType a -> [a] Source # null :: HieType a -> Bool Source # length :: HieType a -> Int Source # elem :: Eq a => a -> HieType a -> Bool Source # maximum :: Ord a => HieType a -> a Source # minimum :: Ord a => HieType a -> a Source # | |
Traversable HieType # | |
Defined in HieTypes | |
Eq a => Eq (HieType a) # | |
Binary (HieType TypeIndex) # | |
type HieTypeFlat = HieType TypeIndex Source #
newtype HieTypeFix Source #
Roughly isomorphic to the original core Type
.
Constructors
Roll (HieType HieTypeFix) |
A list of type arguments along with their respective visibilities (ie. is
this an argument that would return True
for isVisibleArgFlag
?).
Instances
Functor HieArgs # | |
Foldable HieArgs # | |
Defined in HieTypes Methods fold :: Monoid m => HieArgs m -> m Source # foldMap :: Monoid m => (a -> m) -> HieArgs a -> m Source # foldMap' :: Monoid m => (a -> m) -> HieArgs a -> m Source # foldr :: (a -> b -> b) -> b -> HieArgs a -> b Source # foldr' :: (a -> b -> b) -> b -> HieArgs a -> b Source # foldl :: (b -> a -> b) -> b -> HieArgs a -> b Source # foldl' :: (b -> a -> b) -> b -> HieArgs a -> b Source # foldr1 :: (a -> a -> a) -> HieArgs a -> a Source # foldl1 :: (a -> a -> a) -> HieArgs a -> a Source # toList :: HieArgs a -> [a] Source # null :: HieArgs a -> Bool Source # length :: HieArgs a -> Int Source # elem :: Eq a => a -> HieArgs a -> Bool Source # maximum :: Ord a => HieArgs a -> a Source # minimum :: Ord a => HieArgs a -> a Source # | |
Traversable HieArgs # | |
Defined in HieTypes | |
Eq a => Eq (HieArgs a) # | |
Binary (HieArgs TypeIndex) # | |
Mapping from filepaths (represented using FastString
) to the
corresponding AST
Constructors
HieASTs | |
Fields
|
Instances
Functor HieASTs # | |
Foldable HieASTs # | |
Defined in HieTypes Methods fold :: Monoid m => HieASTs m -> m Source # foldMap :: Monoid m => (a -> m) -> HieASTs a -> m Source # foldMap' :: Monoid m => (a -> m) -> HieASTs a -> m Source # foldr :: (a -> b -> b) -> b -> HieASTs a -> b Source # foldr' :: (a -> b -> b) -> b -> HieASTs a -> b Source # foldl :: (b -> a -> b) -> b -> HieASTs a -> b Source # foldl' :: (b -> a -> b) -> b -> HieASTs a -> b Source # foldr1 :: (a -> a -> a) -> HieASTs a -> a Source # foldl1 :: (a -> a -> a) -> HieASTs a -> a Source # toList :: HieASTs a -> [a] Source # null :: HieASTs a -> Bool Source # length :: HieASTs a -> Int Source # elem :: Eq a => a -> HieASTs a -> Bool Source # maximum :: Ord a => HieASTs a -> a Source # minimum :: Ord a => HieASTs a -> a Source # | |
Traversable HieASTs # | |
Defined in HieTypes | |
Binary (HieASTs TypeIndex) # | |
Instances
Functor HieAST # | |
Foldable HieAST # | |
Defined in HieTypes Methods fold :: Monoid m => HieAST m -> m Source # foldMap :: Monoid m => (a -> m) -> HieAST a -> m Source # foldMap' :: Monoid m => (a -> m) -> HieAST a -> m Source # foldr :: (a -> b -> b) -> b -> HieAST a -> b Source # foldr' :: (a -> b -> b) -> b -> HieAST a -> b Source # foldl :: (b -> a -> b) -> b -> HieAST a -> b Source # foldl' :: (b -> a -> b) -> b -> HieAST a -> b Source # foldr1 :: (a -> a -> a) -> HieAST a -> a Source # foldl1 :: (a -> a -> a) -> HieAST a -> a Source # toList :: HieAST a -> [a] Source # null :: HieAST a -> Bool Source # length :: HieAST a -> Int Source # elem :: Eq a => a -> HieAST a -> Bool Source # maximum :: Ord a => HieAST a -> a Source # minimum :: Ord a => HieAST a -> a Source # | |
Traversable HieAST # | |
Binary (HieAST TypeIndex) # | |
The information stored in one AST node.
The type parameter exists to provide flexibility in representation of types (see Note [Efficient serialization of redundant type info]).
Constructors
NodeInfo | |
Fields
|
Instances
Functor NodeInfo # | |
Foldable NodeInfo # | |
Defined in HieTypes Methods fold :: Monoid m => NodeInfo m -> m Source # foldMap :: Monoid m => (a -> m) -> NodeInfo a -> m Source # foldMap' :: Monoid m => (a -> m) -> NodeInfo a -> m Source # foldr :: (a -> b -> b) -> b -> NodeInfo a -> b Source # foldr' :: (a -> b -> b) -> b -> NodeInfo a -> b Source # foldl :: (b -> a -> b) -> b -> NodeInfo a -> b Source # foldl' :: (b -> a -> b) -> b -> NodeInfo a -> b Source # foldr1 :: (a -> a -> a) -> NodeInfo a -> a Source # foldl1 :: (a -> a -> a) -> NodeInfo a -> a Source # toList :: NodeInfo a -> [a] Source # null :: NodeInfo a -> Bool Source # length :: NodeInfo a -> Int Source # elem :: Eq a => a -> NodeInfo a -> Bool Source # maximum :: Ord a => NodeInfo a -> a Source # minimum :: Ord a => NodeInfo a -> a Source # | |
Traversable NodeInfo # | |
Defined in HieTypes | |
Binary (NodeInfo TypeIndex) # | |
type Identifier = Either ModuleName Name Source #
type NodeIdentifiers a = Map Identifier (IdentifierDetails a) Source #
data IdentifierDetails a Source #
Information associated with every identifier
We need to include types with identifiers because sometimes multiple identifiers occur in the same span(Overloaded Record Fields and so on)
Constructors
IdentifierDetails | |
Fields
|
Instances
data ContextInfo Source #
Different contexts under which identifiers exist
Constructors
Use | regular variable |
MatchBind | |
IEThing IEType | import/export |
TyDecl | |
ValBind | Value binding |
PatternBind | Pattern binding This case is tricky because the bound identifier can be used in two
distinct scopes. Consider the following example (with do (b, a, (a -> True)) <- bar foo a The identifier |
ClassTyDecl (Maybe Span) | |
Decl | Declaration |
TyVarBind Scope TyVarScope | Type variable |
RecField RecFieldContext (Maybe Span) | Record field |
Instances
Eq ContextInfo # | |
Defined in HieTypes | |
Ord ContextInfo # | |
Defined in HieTypes Methods compare :: ContextInfo -> ContextInfo -> Ordering # (<) :: ContextInfo -> ContextInfo -> Bool # (<=) :: ContextInfo -> ContextInfo -> Bool # (>) :: ContextInfo -> ContextInfo -> Bool # (>=) :: ContextInfo -> ContextInfo -> Bool # max :: ContextInfo -> ContextInfo -> ContextInfo # min :: ContextInfo -> ContextInfo -> ContextInfo # | |
Show ContextInfo # | |
Outputable ContextInfo # | |
Binary ContextInfo # | |
Types of imports and exports
Constructors
Import | |
ImportAs | |
ImportHiding | |
Export |
Instances
Enum IEType # | |
Defined in HieTypes Methods succ :: IEType -> IEType Source # pred :: IEType -> IEType Source # toEnum :: Int -> IEType Source # fromEnum :: IEType -> Int Source # enumFrom :: IEType -> [IEType] Source # enumFromThen :: IEType -> IEType -> [IEType] Source # enumFromTo :: IEType -> IEType -> [IEType] Source # enumFromThenTo :: IEType -> IEType -> IEType -> [IEType] Source # | |
Eq IEType # | |
Ord IEType # | |
Show IEType # | |
Binary IEType # | |
data RecFieldContext Source #
Constructors
RecFieldDecl | |
RecFieldAssign | |
RecFieldMatch | |
RecFieldOcc |
Instances
Constructors
RegularBind | |
InstanceBind |
Instances
Enum BindType # | |
Defined in HieTypes Methods succ :: BindType -> BindType Source # pred :: BindType -> BindType Source # toEnum :: Int -> BindType Source # fromEnum :: BindType -> Int Source # enumFrom :: BindType -> [BindType] Source # enumFromThen :: BindType -> BindType -> [BindType] Source # enumFromTo :: BindType -> BindType -> [BindType] Source # enumFromThenTo :: BindType -> BindType -> BindType -> [BindType] Source # | |
Eq BindType # | |
Ord BindType # | |
Defined in HieTypes | |
Show BindType # | |
Binary BindType # | |
Constructors
FamDec | type or data family |
SynDec | type synonym |
DataDec | data declaration |
ConDec | constructor declaration |
PatSynDec | pattern synonym |
ClassDec | class declaration |
InstDec | instance declaration |
Instances
Enum DeclType # | |
Defined in HieTypes Methods succ :: DeclType -> DeclType Source # pred :: DeclType -> DeclType Source # toEnum :: Int -> DeclType Source # fromEnum :: DeclType -> Int Source # enumFrom :: DeclType -> [DeclType] Source # enumFromThen :: DeclType -> DeclType -> [DeclType] Source # enumFromTo :: DeclType -> DeclType -> [DeclType] Source # enumFromThenTo :: DeclType -> DeclType -> DeclType -> [DeclType] Source # | |
Eq DeclType # | |
Ord DeclType # | |
Defined in HieTypes | |
Show DeclType # | |
Binary DeclType # | |
Constructors
NoScope | |
LocalScope Span | |
ModuleScope |
Instances
Eq Scope # | |
Data Scope # | |
Defined in HieTypes Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Scope -> c Scope Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Scope Source # toConstr :: Scope -> Constr Source # dataTypeOf :: Scope -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Scope) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scope) Source # gmapT :: (forall b. Data b => b -> b) -> Scope -> Scope Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Scope -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Scope -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Scope -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Scope -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Scope -> m Scope Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Scope -> m Scope Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Scope -> m Scope Source # | |
Ord Scope # | |
Show Scope # | |
Outputable Scope # | |
Binary Scope # | |
data TyVarScope Source #
Scope of a type variable.
This warrants a data type apart from Scope
because of complexities
introduced by features like -XScopedTypeVariables
and -XInstanceSigs
. For
example, consider:
foo, bar, baz :: forall a. a -> a
Here a
is in scope in all the definitions of foo
, bar
, and baz
, so we
need a list of scopes to keep track of this. Furthermore, this list cannot be
computed until we resolve the binding sites of foo
, bar
, and baz
.
Consequently, a
starts with an
which later gets resolved into a UnresolvedScope
[foo, bar, baz] NothingResolvedScopes
.
Constructors
ResolvedScopes [Scope] | |
UnresolvedScope | Unresolved scopes should never show up in the final |
Instances
Eq TyVarScope # | |
Defined in HieTypes | |
Ord TyVarScope # | |
Defined in HieTypes Methods compare :: TyVarScope -> TyVarScope -> Ordering # (<) :: TyVarScope -> TyVarScope -> Bool # (<=) :: TyVarScope -> TyVarScope -> Bool # (>) :: TyVarScope -> TyVarScope -> Bool # (>=) :: TyVarScope -> TyVarScope -> Bool # max :: TyVarScope -> TyVarScope -> TyVarScope # min :: TyVarScope -> TyVarScope -> TyVarScope # | |
Show TyVarScope # | |
Binary TyVarScope # | |