Compat.HieTypes

Documentation

type Span = RealSrcSpan

hieVersion :: Integer

Current version of .hie files

data HieFile

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

• hie_hs_file :: FilePath

  Initial Haskell source file path

• hie_module :: Module

  The module this HIE file is for

• hie_types :: Array TypeIndex HieTypeFlat

  Types referenced in the hie_asts.

  See Note [Efficient serialization of redundant type info]

• hie_asts :: HieASTs TypeIndex

  Type-annotated abstract syntax trees

• hie_exports :: [AvailInfo]

  The names that this module exports

• hie_hs_src :: ByteString

  Raw bytes of the initial Haskell source

Instances

Binary HieFile

Defined in Compat.HieTypes

Methods

put_ :: BinHandle -> HieFile -> IO ()

put :: BinHandle -> HieFile -> IO (Bin HieFile)

get :: BinHandle -> IO HieFile

type TypeIndex = Int

data HieType a

A flattened version of Type.

See Note [Efficient serialization of redundant type info]

Constructors

HTyVarTy Name

HAppTy a a

HTyConApp IfaceTyCon (HieArgs a)

HForAllTy ((Name, a), ArgFlag) a

HFunTy a a

HQualTy a a

type with constraint: t1 => t2 (see IfaceDFunTy)

HLitTy IfaceTyLit

HCastTy a

HCoercionTy

Instances

Functor HieType

Defined in Compat.HieTypes

Methods

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

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

Foldable HieType

Defined in Compat.HieTypes

Methods

fold :: Monoid m => HieType m -> m

foldMap :: Monoid m => (a -> m) -> HieType a -> m

foldr :: (a -> b -> b) -> b -> HieType a -> b

foldr' :: (a -> b -> b) -> b -> HieType a -> b

foldl :: (b -> a -> b) -> b -> HieType a -> b

foldl' :: (b -> a -> b) -> b -> HieType a -> b

foldr1 :: (a -> a -> a) -> HieType a -> a

foldl1 :: (a -> a -> a) -> HieType a -> a

toList :: HieType a -> [a]

null :: HieType a -> Bool

length :: HieType a -> Int

elem :: Eq a => a -> HieType a -> Bool

maximum :: Ord a => HieType a -> a

minimum :: Ord a => HieType a -> a

sum :: Num a => HieType a -> a

product :: Num a => HieType a -> a

Traversable HieType

Defined in Compat.HieTypes

Methods

traverse :: Applicative f => (a -> f b) -> HieType a -> f (HieType b)

sequenceA :: Applicative f => HieType (f a) -> f (HieType a)

mapM :: Monad m => (a -> m b) -> HieType a -> m (HieType b)

sequence :: Monad m => HieType (m a) -> m (HieType a)

Eq a => Eq (HieType a)

Defined in Compat.HieTypes

Methods

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

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

Binary (HieType TypeIndex)

Defined in Compat.HieTypes

Methods

put_ :: BinHandle -> HieType TypeIndex -> IO ()

put :: BinHandle -> HieType TypeIndex -> IO (Bin (HieType TypeIndex))

get :: BinHandle -> IO (HieType TypeIndex)

type HieTypeFlat = HieType TypeIndex

newtype HieTypeFix

Roughly isomorphic to the original core Type.

Constructors

Roll (HieType HieTypeFix)

newtype HieArgs a

A list of type arguments along with their respective visibilities (ie. is this an argument that would return True for isVisibleArgFlag?).

Constructors

HieArgs [(Bool, a)]

Instances

Functor HieArgs

Defined in Compat.HieTypes

Methods

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

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

Foldable HieArgs

Defined in Compat.HieTypes

Methods

fold :: Monoid m => HieArgs m -> m

foldMap :: Monoid m => (a -> m) -> HieArgs a -> m

foldr :: (a -> b -> b) -> b -> HieArgs a -> b

foldr' :: (a -> b -> b) -> b -> HieArgs a -> b

foldl :: (b -> a -> b) -> b -> HieArgs a -> b

foldl' :: (b -> a -> b) -> b -> HieArgs a -> b

foldr1 :: (a -> a -> a) -> HieArgs a -> a

foldl1 :: (a -> a -> a) -> HieArgs a -> a

toList :: HieArgs a -> [a]

null :: HieArgs a -> Bool

length :: HieArgs a -> Int

elem :: Eq a => a -> HieArgs a -> Bool

maximum :: Ord a => HieArgs a -> a

minimum :: Ord a => HieArgs a -> a

sum :: Num a => HieArgs a -> a

product :: Num a => HieArgs a -> a

Traversable HieArgs

Defined in Compat.HieTypes

Methods

traverse :: Applicative f => (a -> f b) -> HieArgs a -> f (HieArgs b)

sequenceA :: Applicative f => HieArgs (f a) -> f (HieArgs a)

mapM :: Monad m => (a -> m b) -> HieArgs a -> m (HieArgs b)

sequence :: Monad m => HieArgs (m a) -> m (HieArgs a)

Eq a => Eq (HieArgs a)

Defined in Compat.HieTypes

Methods

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

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

Binary (HieArgs TypeIndex)

Defined in Compat.HieTypes

Methods

put_ :: BinHandle -> HieArgs TypeIndex -> IO ()

put :: BinHandle -> HieArgs TypeIndex -> IO (Bin (HieArgs TypeIndex))

get :: BinHandle -> IO (HieArgs TypeIndex)

newtype HieASTs a

Mapping from filepaths (represented using FastString) to the corresponding AST

Constructors

HieASTs

Fields

• getAsts :: Map FastString (HieAST a)

Instances

Functor HieASTs

Defined in Compat.HieTypes

Methods

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

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

Foldable HieASTs

Defined in Compat.HieTypes

Methods

fold :: Monoid m => HieASTs m -> m

foldMap :: Monoid m => (a -> m) -> HieASTs a -> m

foldr :: (a -> b -> b) -> b -> HieASTs a -> b

foldr' :: (a -> b -> b) -> b -> HieASTs a -> b

foldl :: (b -> a -> b) -> b -> HieASTs a -> b

foldl' :: (b -> a -> b) -> b -> HieASTs a -> b

foldr1 :: (a -> a -> a) -> HieASTs a -> a

foldl1 :: (a -> a -> a) -> HieASTs a -> a

toList :: HieASTs a -> [a]

null :: HieASTs a -> Bool

length :: HieASTs a -> Int

elem :: Eq a => a -> HieASTs a -> Bool

maximum :: Ord a => HieASTs a -> a

minimum :: Ord a => HieASTs a -> a

sum :: Num a => HieASTs a -> a

product :: Num a => HieASTs a -> a

Traversable HieASTs

Defined in Compat.HieTypes

Methods

traverse :: Applicative f => (a -> f b) -> HieASTs a -> f (HieASTs b)

sequenceA :: Applicative f => HieASTs (f a) -> f (HieASTs a)

mapM :: Monad m => (a -> m b) -> HieASTs a -> m (HieASTs b)

sequence :: Monad m => HieASTs (m a) -> m (HieASTs a)

Binary (HieASTs TypeIndex)

Defined in Compat.HieTypes

Methods

put_ :: BinHandle -> HieASTs TypeIndex -> IO ()

put :: BinHandle -> HieASTs TypeIndex -> IO (Bin (HieASTs TypeIndex))

get :: BinHandle -> IO (HieASTs TypeIndex)

data HieAST a

Constructors

Node

Fields

• nodeInfo :: NodeInfo a
• nodeSpan :: Span
• nodeChildren :: [HieAST a]

Instances

Functor HieAST

Defined in Compat.HieTypes

Methods

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

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

Foldable HieAST

Defined in Compat.HieTypes

Methods

fold :: Monoid m => HieAST m -> m

foldMap :: Monoid m => (a -> m) -> HieAST a -> m

foldr :: (a -> b -> b) -> b -> HieAST a -> b

foldr' :: (a -> b -> b) -> b -> HieAST a -> b

foldl :: (b -> a -> b) -> b -> HieAST a -> b

foldl' :: (b -> a -> b) -> b -> HieAST a -> b

foldr1 :: (a -> a -> a) -> HieAST a -> a

foldl1 :: (a -> a -> a) -> HieAST a -> a

toList :: HieAST a -> [a]

null :: HieAST a -> Bool

length :: HieAST a -> Int

elem :: Eq a => a -> HieAST a -> Bool

maximum :: Ord a => HieAST a -> a

minimum :: Ord a => HieAST a -> a

sum :: Num a => HieAST a -> a

product :: Num a => HieAST a -> a

Traversable HieAST

Defined in Compat.HieTypes

Methods

traverse :: Applicative f => (a -> f b) -> HieAST a -> f (HieAST b)

sequenceA :: Applicative f => HieAST (f a) -> f (HieAST a)

mapM :: Monad m => (a -> m b) -> HieAST a -> m (HieAST b)

sequence :: Monad m => HieAST (m a) -> m (HieAST a)

Binary (HieAST TypeIndex)

Defined in Compat.HieTypes

Methods

put_ :: BinHandle -> HieAST TypeIndex -> IO ()

put :: BinHandle -> HieAST TypeIndex -> IO (Bin (HieAST TypeIndex))

get :: BinHandle -> IO (HieAST TypeIndex)

data NodeInfo a

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

• nodeAnnotations :: Set (FastString, FastString)

  (name of the AST node constructor, name of the AST node Type)

• nodeType :: [a]

  The Haskell types of this node, if any.

• nodeIdentifiers :: NodeIdentifiers a

  All the identifiers and their details

Instances

Functor NodeInfo

Defined in Compat.HieTypes

Methods

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

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

Foldable NodeInfo

Defined in Compat.HieTypes

Methods

fold :: Monoid m => NodeInfo m -> m

foldMap :: Monoid m => (a -> m) -> NodeInfo a -> m

foldr :: (a -> b -> b) -> b -> NodeInfo a -> b

foldr' :: (a -> b -> b) -> b -> NodeInfo a -> b

foldl :: (b -> a -> b) -> b -> NodeInfo a -> b

foldl' :: (b -> a -> b) -> b -> NodeInfo a -> b

foldr1 :: (a -> a -> a) -> NodeInfo a -> a

foldl1 :: (a -> a -> a) -> NodeInfo a -> a

toList :: NodeInfo a -> [a]

null :: NodeInfo a -> Bool

length :: NodeInfo a -> Int

elem :: Eq a => a -> NodeInfo a -> Bool

maximum :: Ord a => NodeInfo a -> a

minimum :: Ord a => NodeInfo a -> a

sum :: Num a => NodeInfo a -> a

product :: Num a => NodeInfo a -> a

Traversable NodeInfo

Defined in Compat.HieTypes

Methods

traverse :: Applicative f => (a -> f b) -> NodeInfo a -> f (NodeInfo b)

sequenceA :: Applicative f => NodeInfo (f a) -> f (NodeInfo a)

mapM :: Monad m => (a -> m b) -> NodeInfo a -> m (NodeInfo b)

sequence :: Monad m => NodeInfo (m a) -> m (NodeInfo a)

Binary (NodeInfo TypeIndex)

Defined in Compat.HieTypes

Methods

put_ :: BinHandle -> NodeInfo TypeIndex -> IO ()

put :: BinHandle -> NodeInfo TypeIndex -> IO (Bin (NodeInfo TypeIndex))

get :: BinHandle -> IO (NodeInfo TypeIndex)

type Identifier = Either ModuleName Name

type NodeIdentifiers a = Map Identifier (IdentifierDetails a)

data IdentifierDetails a

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

• identType :: Maybe a
• identInfo :: Set ContextInfo

Instances

Functor IdentifierDetails

Defined in Compat.HieTypes

Methods

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

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

Foldable IdentifierDetails

Defined in Compat.HieTypes

Methods

fold :: Monoid m => IdentifierDetails m -> m

foldMap :: Monoid m => (a -> m) -> IdentifierDetails a -> m

foldr :: (a -> b -> b) -> b -> IdentifierDetails a -> b

foldr' :: (a -> b -> b) -> b -> IdentifierDetails a -> b

foldl :: (b -> a -> b) -> b -> IdentifierDetails a -> b

foldl' :: (b -> a -> b) -> b -> IdentifierDetails a -> b

foldr1 :: (a -> a -> a) -> IdentifierDetails a -> a

foldl1 :: (a -> a -> a) -> IdentifierDetails a -> a

toList :: IdentifierDetails a -> [a]

null :: IdentifierDetails a -> Bool

length :: IdentifierDetails a -> Int

elem :: Eq a => a -> IdentifierDetails a -> Bool

maximum :: Ord a => IdentifierDetails a -> a

minimum :: Ord a => IdentifierDetails a -> a

sum :: Num a => IdentifierDetails a -> a

product :: Num a => IdentifierDetails a -> a

Traversable IdentifierDetails

Defined in Compat.HieTypes

Methods

traverse :: Applicative f => (a -> f b) -> IdentifierDetails a -> f (IdentifierDetails b)

sequenceA :: Applicative f => IdentifierDetails (f a) -> f (IdentifierDetails a)

mapM :: Monad m => (a -> m b) -> IdentifierDetails a -> m (IdentifierDetails b)

sequence :: Monad m => IdentifierDetails (m a) -> m (IdentifierDetails a)

Eq a => Eq (IdentifierDetails a)

Defined in Compat.HieTypes

Methods

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

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

Semigroup (IdentifierDetails a)

Defined in Compat.HieTypes

Methods

(<>) :: IdentifierDetails a -> IdentifierDetails a -> IdentifierDetails a

sconcat :: NonEmpty (IdentifierDetails a) -> IdentifierDetails a

stimes :: Integral b => b -> IdentifierDetails a -> IdentifierDetails a

Monoid (IdentifierDetails a)

Defined in Compat.HieTypes

Methods

mempty :: IdentifierDetails a

mappend :: IdentifierDetails a -> IdentifierDetails a -> IdentifierDetails a

mconcat :: [IdentifierDetails a] -> IdentifierDetails a

Binary (IdentifierDetails TypeIndex)

Defined in Compat.HieTypes

Methods

put_ :: BinHandle -> IdentifierDetails TypeIndex -> IO ()

put :: BinHandle -> IdentifierDetails TypeIndex -> IO (Bin (IdentifierDetails TypeIndex))

get :: BinHandle -> IO (IdentifierDetails TypeIndex)

Outputable a => Outputable (IdentifierDetails a)

Defined in Compat.HieTypes

Methods

ppr :: IdentifierDetails a -> SDoc

pprPrec :: Rational -> IdentifierDetails a -> SDoc

data ContextInfo

Different contexts under which identifiers exist

Constructors

Use

regular variable

MatchBind

IEThing IEType

import/export

TyDecl

ValBind

Value binding

Fields

• BindType

  whether or not the binding is in an instance

• Scope

  scope over which the value is bound

• (Maybe Span)

  span of entire binding

PatternBind

Pattern binding

This case is tricky because the bound identifier can be used in two distinct scopes. Consider the following example (with -XViewPatterns)

do (b, a, (a -> True)) <- bar
   foo a

The identifier a has two scopes: in the view pattern (a -> True) and in the rest of the do-block in foo a.

Fields

• Scope

  scope in the pattern (the variable bound can be used further in the pattern)

• Scope

  rest of the scope outside the pattern

• (Maybe Span)

  span of entire binding

ClassTyDecl (Maybe Span)

Decl

Declaration

Fields

• DeclType

  type of declaration

• (Maybe Span)

  span of entire binding

TyVarBind Scope TyVarScope

Type variable

RecField RecFieldContext (Maybe Span)

Record field

Instances

Eq ContextInfo

Defined in Compat.HieTypes

Methods

(==) :: ContextInfo -> ContextInfo -> Bool

(/=) :: ContextInfo -> ContextInfo -> Bool

Ord ContextInfo

Defined in Compat.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

Defined in Compat.HieTypes

Methods

showsPrec :: Int -> ContextInfo -> ShowS

show :: ContextInfo -> String

showList :: [ContextInfo] -> ShowS

Binary ContextInfo

Defined in Compat.HieTypes

Methods

put_ :: BinHandle -> ContextInfo -> IO ()

put :: BinHandle -> ContextInfo -> IO (Bin ContextInfo)

get :: BinHandle -> IO ContextInfo

Outputable ContextInfo

Defined in Compat.HieTypes

Methods

ppr :: ContextInfo -> SDoc

pprPrec :: Rational -> ContextInfo -> SDoc

data IEType

Types of imports and exports

Constructors

Import

ImportAs

ImportHiding

Export

Instances

Enum IEType

Defined in Compat.HieTypes

Methods

succ :: IEType -> IEType

pred :: IEType -> IEType

toEnum :: Int -> IEType

fromEnum :: IEType -> Int

enumFrom :: IEType -> [IEType]

enumFromThen :: IEType -> IEType -> [IEType]

enumFromTo :: IEType -> IEType -> [IEType]

enumFromThenTo :: IEType -> IEType -> IEType -> [IEType]

Eq IEType

Defined in Compat.HieTypes

Methods

(==) :: IEType -> IEType -> Bool

(/=) :: IEType -> IEType -> Bool

Ord IEType

Defined in Compat.HieTypes

Methods

compare :: IEType -> IEType -> Ordering

(<) :: IEType -> IEType -> Bool

(<=) :: IEType -> IEType -> Bool

(>) :: IEType -> IEType -> Bool

(>=) :: IEType -> IEType -> Bool

max :: IEType -> IEType -> IEType

min :: IEType -> IEType -> IEType

Show IEType

Defined in Compat.HieTypes

Methods

showsPrec :: Int -> IEType -> ShowS

show :: IEType -> String

showList :: [IEType] -> ShowS

Binary IEType

Defined in Compat.HieTypes

Methods

put_ :: BinHandle -> IEType -> IO ()

put :: BinHandle -> IEType -> IO (Bin IEType)

get :: BinHandle -> IO IEType

data RecFieldContext

Constructors

RecFieldDecl

RecFieldAssign

RecFieldMatch

RecFieldOcc

Instances

Enum RecFieldContext

Defined in Compat.HieTypes

Methods

succ :: RecFieldContext -> RecFieldContext

pred :: RecFieldContext -> RecFieldContext

toEnum :: Int -> RecFieldContext

fromEnum :: RecFieldContext -> Int

enumFrom :: RecFieldContext -> [RecFieldContext]

enumFromThen :: RecFieldContext -> RecFieldContext -> [RecFieldContext]

enumFromTo :: RecFieldContext -> RecFieldContext -> [RecFieldContext]

enumFromThenTo :: RecFieldContext -> RecFieldContext -> RecFieldContext -> [RecFieldContext]

Eq RecFieldContext

Defined in Compat.HieTypes

Methods

(==) :: RecFieldContext -> RecFieldContext -> Bool

(/=) :: RecFieldContext -> RecFieldContext -> Bool

Ord RecFieldContext

Defined in Compat.HieTypes

Methods

compare :: RecFieldContext -> RecFieldContext -> Ordering

(<) :: RecFieldContext -> RecFieldContext -> Bool

(<=) :: RecFieldContext -> RecFieldContext -> Bool

(>) :: RecFieldContext -> RecFieldContext -> Bool

(>=) :: RecFieldContext -> RecFieldContext -> Bool

max :: RecFieldContext -> RecFieldContext -> RecFieldContext

min :: RecFieldContext -> RecFieldContext -> RecFieldContext

Show RecFieldContext

Defined in Compat.HieTypes

Methods

showsPrec :: Int -> RecFieldContext -> ShowS

show :: RecFieldContext -> String

showList :: [RecFieldContext] -> ShowS

Binary RecFieldContext

Defined in Compat.HieTypes

Methods

put_ :: BinHandle -> RecFieldContext -> IO ()

put :: BinHandle -> RecFieldContext -> IO (Bin RecFieldContext)

get :: BinHandle -> IO RecFieldContext

data BindType

Constructors

RegularBind

InstanceBind

Instances

Enum BindType

Defined in Compat.HieTypes

Methods

succ :: BindType -> BindType

pred :: BindType -> BindType

toEnum :: Int -> BindType

fromEnum :: BindType -> Int

enumFrom :: BindType -> [BindType]

enumFromThen :: BindType -> BindType -> [BindType]

enumFromTo :: BindType -> BindType -> [BindType]

enumFromThenTo :: BindType -> BindType -> BindType -> [BindType]

Eq BindType

Defined in Compat.HieTypes

Methods

(==) :: BindType -> BindType -> Bool

(/=) :: BindType -> BindType -> Bool

Ord BindType

Defined in Compat.HieTypes

Methods

compare :: BindType -> BindType -> Ordering

(<) :: BindType -> BindType -> Bool

(<=) :: BindType -> BindType -> Bool

(>) :: BindType -> BindType -> Bool

(>=) :: BindType -> BindType -> Bool

max :: BindType -> BindType -> BindType

min :: BindType -> BindType -> BindType

Show BindType

Defined in Compat.HieTypes

Methods

showsPrec :: Int -> BindType -> ShowS

show :: BindType -> String

showList :: [BindType] -> ShowS

Binary BindType

Defined in Compat.HieTypes

Methods

put_ :: BinHandle -> BindType -> IO ()

put :: BinHandle -> BindType -> IO (Bin BindType)

get :: BinHandle -> IO BindType

data DeclType

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 Compat.HieTypes

Methods

succ :: DeclType -> DeclType

pred :: DeclType -> DeclType

toEnum :: Int -> DeclType

fromEnum :: DeclType -> Int

enumFrom :: DeclType -> [DeclType]

enumFromThen :: DeclType -> DeclType -> [DeclType]

enumFromTo :: DeclType -> DeclType -> [DeclType]

enumFromThenTo :: DeclType -> DeclType -> DeclType -> [DeclType]

Eq DeclType

Defined in Compat.HieTypes

Methods

(==) :: DeclType -> DeclType -> Bool

(/=) :: DeclType -> DeclType -> Bool

Ord DeclType

Defined in Compat.HieTypes

Methods

compare :: DeclType -> DeclType -> Ordering

(<) :: DeclType -> DeclType -> Bool

(<=) :: DeclType -> DeclType -> Bool

(>) :: DeclType -> DeclType -> Bool

(>=) :: DeclType -> DeclType -> Bool

max :: DeclType -> DeclType -> DeclType

min :: DeclType -> DeclType -> DeclType

Show DeclType

Defined in Compat.HieTypes

Methods

showsPrec :: Int -> DeclType -> ShowS

show :: DeclType -> String

showList :: [DeclType] -> ShowS

Binary DeclType

Defined in Compat.HieTypes

Methods

put_ :: BinHandle -> DeclType -> IO ()

put :: BinHandle -> DeclType -> IO (Bin DeclType)

get :: BinHandle -> IO DeclType

data Scope

Constructors

NoScope

LocalScope Span

ModuleScope

Instances

Eq Scope

Defined in Compat.HieTypes

Methods

(==) :: Scope -> Scope -> Bool

(/=) :: Scope -> Scope -> Bool

Data Scope

Defined in Compat.HieTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Scope -> c Scope

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Scope

toConstr :: Scope -> Constr

dataTypeOf :: Scope -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Scope)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scope)

gmapT :: (forall b. Data b => b -> b) -> Scope -> Scope

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Scope -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Scope -> r

gmapQ :: (forall d. Data d => d -> u) -> Scope -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Scope -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Scope -> m Scope

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Scope -> m Scope

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Scope -> m Scope

Ord Scope

Defined in Compat.HieTypes

Methods

compare :: Scope -> Scope -> Ordering

(<) :: Scope -> Scope -> Bool

(<=) :: Scope -> Scope -> Bool

(>) :: Scope -> Scope -> Bool

(>=) :: Scope -> Scope -> Bool

max :: Scope -> Scope -> Scope

min :: Scope -> Scope -> Scope

Show Scope

Defined in Compat.HieTypes

Methods

showsPrec :: Int -> Scope -> ShowS

show :: Scope -> String

showList :: [Scope] -> ShowS

Binary Scope

Defined in Compat.HieTypes

Methods

put_ :: BinHandle -> Scope -> IO ()

put :: BinHandle -> Scope -> IO (Bin Scope)

get :: BinHandle -> IO Scope

Outputable Scope

Defined in Compat.HieTypes

Methods

ppr :: Scope -> SDoc

pprPrec :: Rational -> Scope -> SDoc

data TyVarScope

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 UnresolvedScope [foo, bar, baz] Nothing which later gets resolved into a ResolvedScopes.

Constructors

ResolvedScopes [Scope]

UnresolvedScope

Unresolved scopes should never show up in the final .hie file

Fields

• [Name]

  names of the definitions over which the scope spans

• (Maybe Span)

  the location of the instance/class declaration for the case where the type variable is declared in a method type signature

Instances

Eq TyVarScope

Defined in Compat.HieTypes

Methods

(==) :: TyVarScope -> TyVarScope -> Bool

(/=) :: TyVarScope -> TyVarScope -> Bool

Ord TyVarScope

Defined in Compat.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

Defined in Compat.HieTypes

Methods

showsPrec :: Int -> TyVarScope -> ShowS

show :: TyVarScope -> String

showList :: [TyVarScope] -> ShowS

Binary TyVarScope

Defined in Compat.HieTypes

Methods

put_ :: BinHandle -> TyVarScope -> IO ()

put :: BinHandle -> TyVarScope -> IO (Bin TyVarScope)

get :: BinHandle -> IO TyVarScope

Orphan instances

Binary RealSrcSpan

Methods

put_ :: BinHandle -> RealSrcSpan -> IO ()

put :: BinHandle -> RealSrcSpan -> IO (Bin RealSrcSpan)

get :: BinHandle -> IO RealSrcSpan

(Ix a, Binary a, Binary b) => Binary (Array a b)

Methods

put_ :: BinHandle -> Array a b -> IO ()

put :: BinHandle -> Array a b -> IO (Bin (Array a b))

get :: BinHandle -> IO (Array a b)