Language.Rust.Data.Position

Everything to do with describing a position or a contiguous region in a file.

Positions in files

data Position

A position in a source file. The row and column information is kept only for its convenience and human-readability. Analogous to the information encoded in a cursor.

Constructors

Position

Fields

• absoluteOffset :: !Int

  absolute offset the source file.

• row :: !Int

  row (line) in the source file.

• col :: !Int

  column in the source file.

NoPosition

Instances

Eq Position

Methods

(==) :: Position -> Position -> Bool

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

Data Position

Methods

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

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

toConstr :: Position -> Constr

dataTypeOf :: Position -> DataType

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

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

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

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

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

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

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

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

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

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

Ord Position

Methods

compare :: Position -> Position -> Ordering

(<) :: Position -> Position -> Bool

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

(>) :: Position -> Position -> Bool

(>=) :: Position -> Position -> Bool

max :: Position -> Position -> Position

min :: Position -> Position -> Position

Show Position

Field names are not shown

Methods

showsPrec :: Int -> Position -> ShowS

show :: Position -> String

showList :: [Position] -> ShowS

Generic Position

Associated Types

type Rep Position :: * -> *

Methods

from :: Position -> Rep Position x

to :: Rep Position x -> Position

NFData Position

Methods

rnf :: Position -> ()

Pretty Position

Methods

prettyUnresolved :: Position -> Doc b

type Rep Position

type Rep Position = D1 * (MetaData "Position" "Language.Rust.Data.Position" "language-rust-0.2.0.27-AdTGPQ0ClkM3k0DGaVHmew" False) ((:+:) * (C1 * (MetaCons "Position" PrefixI True) ((:*:) * (S1 * (MetaSel (Just Symbol "absoluteOffset") SourceUnpack SourceStrict DecidedStrict) (Rec0 * Int)) ((:*:) * (S1 * (MetaSel (Just Symbol "row") SourceUnpack SourceStrict DecidedStrict) (Rec0 * Int)) (S1 * (MetaSel (Just Symbol "col") SourceUnpack SourceStrict DecidedStrict) (Rec0 * Int))))) (C1 * (MetaCons "NoPosition" PrefixI False) (U1 *)))

prettyPosition :: Position -> String

Pretty print a Position

maxPos :: Position -> Position -> Position

Maximum of two positions, bias for actual positions.

>>> maxPos (Position 30 5 8) (Position 37 5 15)
Position 37 5 15

>>> maxPos NoPosition (Position 30 5 8)
Position 30 5 8

minPos :: Position -> Position -> Position

Maximum and minimum positions, bias for actual positions.

>>> minPos (Position 30 5 8) (Position 37 5 15)
Position 30 5 8

>>> minPos NoPosition (Position 30 5 8)
Position 30 5 8

initPos :: Position

Starting position in a file.

incPos :: Position -> Int -> Position

Advance column a certain number of times.

retPos :: Position -> Position

Advance to the next line.

incOffset :: Position -> Int -> Position

Advance only the absolute offset, not the row and column information. Only use this if you know what you are doing!

Spans in files

data Span

Spans represent a contiguous region of code, delimited by two Positions. The endpoints are inclusive. Analogous to the information encoded in a selection.

Constructors

Span

Fields

• lo, hi :: !Position

Instances

Eq Span

Methods

(==) :: Span -> Span -> Bool

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

Data Span

Methods

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

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

toConstr :: Span -> Constr

dataTypeOf :: Span -> DataType

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

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

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

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

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

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

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

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

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

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

Ord Span

Methods

compare :: Span -> Span -> Ordering

(<) :: Span -> Span -> Bool

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

(>) :: Span -> Span -> Bool

(>=) :: Span -> Span -> Bool

max :: Span -> Span -> Span

min :: Span -> Span -> Span

Show Span

Field names are not shown

Methods

showsPrec :: Int -> Span -> ShowS

show :: Span -> String

showList :: [Span] -> ShowS

Generic Span

Associated Types

type Rep Span :: * -> *

Methods

from :: Span -> Rep Span x

to :: Rep Span x -> Span

Semigroup Span

smallest covering Span

Methods

(<>) :: Span -> Span -> Span

sconcat :: NonEmpty Span -> Span

stimes :: Integral b => b -> Span -> Span

Monoid Span

Methods

mempty :: Span

mappend :: Span -> Span -> Span

mconcat :: [Span] -> Span

NFData Span

Methods

rnf :: Span -> ()

Located Span

Methods

spanOf :: Span -> Span

Pretty Span

Methods

prettyUnresolved :: Span -> Doc b

Parse (WhereClause Span)

Methods

parser :: P (WhereClause Span)

Parse (TyParam Span)

Methods

parser :: P (TyParam Span)

Parse (Ty Span)

Methods

parser :: P (Ty Span)

Parse (TraitItem Span)

Methods

parser :: P (TraitItem Span)

Parse (Stmt Span)

Methods

parser :: P (Stmt Span)

Parse (Pat Span)

Methods

parser :: P (Pat Span)

Parse (Lit Span)

Methods

parser :: P (Lit Span)

Parse (SourceFile Span)

Methods

parser :: P (SourceFile Span)

Parse (LifetimeDef Span)

Methods

parser :: P (LifetimeDef Span)

Parse (Item Span)

Methods

parser :: P (Item Span)

Parse (ImplItem Span)

Methods

parser :: P (ImplItem Span)

Parse (Generics Span)

Methods

parser :: P (Generics Span)

Parse (Expr Span)

Methods

parser :: P (Expr Span)

Parse (Block Span)

Methods

parser :: P (Block Span)

Parse (Attribute Span)

Methods

parser :: P (Attribute Span)

type Rep Span

type Rep Span = D1 * (MetaData "Span" "Language.Rust.Data.Position" "language-rust-0.2.0.27-AdTGPQ0ClkM3k0DGaVHmew" False) (C1 * (MetaCons "Span" PrefixI True) ((:*:) * (S1 * (MetaSel (Just Symbol "lo") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * Position)) (S1 * (MetaSel (Just Symbol "hi") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * Position))))

unspan :: Spanned a -> a

Extract the wrapped value from Spanned

prettySpan :: Span -> String

Pretty print a Span

subsetOf :: Span -> Span -> Bool

Check if a span is a subset of another span

(#) :: (Located a, Located b) => a -> b -> Span

Convenience function lifting <> to work on all Located things

data Spanned a

A "tagging" of something with a Span that describes its extent.

Constructors

Spanned a !Span

Instances

Monad Spanned

Methods

(>>=) :: Spanned a -> (a -> Spanned b) -> Spanned b

(>>) :: Spanned a -> Spanned b -> Spanned b

return :: a -> Spanned a

fail :: String -> Spanned a

Functor Spanned

Methods

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

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

Applicative Spanned

Methods

pure :: a -> Spanned a

(<*>) :: Spanned (a -> b) -> Spanned a -> Spanned b

liftA2 :: (a -> b -> c) -> Spanned a -> Spanned b -> Spanned c

(*>) :: Spanned a -> Spanned b -> Spanned b

(<*) :: Spanned a -> Spanned b -> Spanned a

Eq a => Eq (Spanned a)

Methods

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

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

Data a => Data (Spanned a)

Methods

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

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

toConstr :: Spanned a -> Constr

dataTypeOf :: Spanned a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Spanned a))

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

gmapT :: (forall b. Data b => b -> b) -> Spanned a -> Spanned a

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

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

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

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

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

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

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

Ord a => Ord (Spanned a)

Methods

compare :: Spanned a -> Spanned a -> Ordering

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

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

(>) :: Spanned a -> Spanned a -> Bool

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

max :: Spanned a -> Spanned a -> Spanned a

min :: Spanned a -> Spanned a -> Spanned a

Show a => Show (Spanned a)

Methods

showsPrec :: Int -> Spanned a -> ShowS

show :: Spanned a -> String

showList :: [Spanned a] -> ShowS

Generic (Spanned a)

Associated Types

type Rep (Spanned a) :: * -> *

Methods

from :: Spanned a -> Rep (Spanned a) x

to :: Rep (Spanned a) x -> Spanned a

NFData a => NFData (Spanned a)

Methods

rnf :: Spanned a -> ()

Located (Spanned a)

Methods

spanOf :: Spanned a -> Span

type Rep (Spanned a)

type Rep (Spanned a) = D1 * (MetaData "Spanned" "Language.Rust.Data.Position" "language-rust-0.2.0.27-AdTGPQ0ClkM3k0DGaVHmew" False) (C1 * (MetaCons "Spanned" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Span))))

class Located a where

Describes nodes that can be located - their span can be extracted from them. In general, we expect that for a value constructed as Con x y z where Con is an arbitrary constructor

(spanOf x <> spanOf y <> spanOf z) `subsetOf` spanOf (Con x y z) == True

Minimal complete definition

spanOf

Methods

spanOf :: a -> Span

Instances

Located Span

Methods

spanOf :: Span -> Span

Located TokenTree

Methods

spanOf :: TokenTree -> Span

Located TokenStream

Span is not stored on TokenStream - it is computed

Methods

spanOf :: TokenStream -> Span

Located a => Located [a]

O(n) time complexity

Methods

spanOf :: [a] -> Span

Located a => Located (Maybe a)

Methods

spanOf :: Maybe a -> Span

Located a => Located (NonEmpty a)

O(n) time complexity

Methods

spanOf :: NonEmpty a -> Span

Located (Spanned a)

Methods

spanOf :: Spanned a -> Span

Located a => Located (WherePredicate a)

Methods

spanOf :: WherePredicate a -> Span

Located a => Located (WhereClause a)

Methods

spanOf :: WhereClause a -> Span

Located a => Located (UseTree a)

Methods

spanOf :: UseTree a -> Span

Located a => Located (VariantData a)

Methods

spanOf :: VariantData a -> Span

Located a => Located (Variant a)

Methods

spanOf :: Variant a -> Span

Located a => Located (TyParamBound a)

Methods

spanOf :: TyParamBound a -> Span

Located a => Located (TyParam a)

Methods

spanOf :: TyParam a -> Span

Located a => Located (Ty a)

Methods

spanOf :: Ty a -> Span

Located a => Located (TraitRef a)

Methods

spanOf :: TraitRef a -> Span

Located a => Located (TraitItem a)

Methods

spanOf :: TraitItem a -> Span

Located a => Located (StructField a)

Methods

spanOf :: StructField a -> Span

Located a => Located (Stmt a)

Methods

spanOf :: Stmt a -> Span

Located a => Located (PolyTraitRef a)

Methods

spanOf :: PolyTraitRef a -> Span

Located a => Located (PathSegment a)

Methods

spanOf :: PathSegment a -> Span

Located a => Located (PathParameters a)

Methods

spanOf :: PathParameters a -> Span

Located a => Located (Path a)

Methods

spanOf :: Path a -> Span

Located a => Located (Pat a)

Methods

spanOf :: Pat a -> Span

Located a => Located (Mac a)

Methods

spanOf :: Mac a -> Span

Located a => Located (Lit a)

Methods

spanOf :: Lit a -> Span

Located a => Located (LifetimeDef a)

Methods

spanOf :: LifetimeDef a -> Span

Located a => Located (Lifetime a)

Methods

spanOf :: Lifetime a -> Span

Located a => Located (Label a)

Methods

spanOf :: Label a -> Span

Located a => Located (Item a)

Methods

spanOf :: Item a -> Span

Located a => Located (ImplItem a)

Methods

spanOf :: ImplItem a -> Span

Located a => Located (Generics a)

Methods

spanOf :: Generics a -> Span

Located a => Located (ForeignItem a)

Methods

spanOf :: ForeignItem a -> Span

Located a => Located (FnDecl a)

Methods

spanOf :: FnDecl a -> Span

Located a => Located (FieldPat a)

Methods

spanOf :: FieldPat a -> Span

Located a => Located (Field a)

Methods

spanOf :: Field a -> Span

Located a => Located (Expr a)

Methods

spanOf :: Expr a -> Span

Located a => Located (Block a)

Methods

spanOf :: Block a -> Span

Located a => Located (Attribute a)

Methods

spanOf :: Attribute a -> Span

Located a => Located (Arm a)

Methods

spanOf :: Arm a -> Span

Located a => Located (Arg a)

Methods

spanOf :: Arg a -> Span