Enum Location 

pub enum Location {
    SrcPos {
        src: Source,
        pos: SourcePosition,
    },
    Fused {
        metadata: Option<AttrObj>,
        locations: Vec<Location>,
    },
    Named {
        name: String,
        child_loc: Box<Location>,
    },
    CallSite {
        callee: Box<Location>,
        caller: Box<Location>,
    },
    Unknown,
}

Represents a (combination of) program source locations. This captures more or less the functionality of MLIR’s BuiltinLocationAttributes. For simplicity, unlike in MLIR, Location is not extensible.

Variants

SrcPos

A Source along with a position within it. This is same as MLIR’s FileLineColLoc.

Fields

src: Source

pos: SourcePosition

Fused

A collection of other source locations. This is same as MLIR’s FusedLoc.

Fields

metadata: Option<AttrObj>

locations: Vec<Location>

Named

Location with a name. See NameLoc.

Fields

name: String

child_loc: Box<Location>

CallSite

Connects the location of a callee with the location of the caller. See CallSiteLoc.

Fields

callee: Box<Location>

caller: Box<Location>

Unknown

Location unknown. See UnknownLoc.

Implementations

impl Location

pub fn source(&self) -> Option<Source>

If the location is from exactly one source, get that source.

pub fn sources(&self) -> Vec<Source>

Get all sources that this location is associated with.

pub fn is_unknown(&self) -> bool

Is this unknown?

Trait Implementations

impl Clone for Location

fn clone(&self) -> Location

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Location

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Parsable for Location

type Arg = ()

Type of the argument that must be passed to the parser.

type Parsed = Location

The type of the parsed entity.

fn parse<'a>( state_stream: &mut StateStream<'a>, _arg: Self::Arg, ) -> ParseResult<'a, Self::Parsed>

Define a parser using existing combinators and call into on [Parser::parse_stream] to get the final ParseResult. Use state_stream.state as necessary.

fn parser<'a>( arg: Self::Arg, ) -> Box<dyn Parser<StateStream<'a>, Output = Self::Parsed, PartialState = ()> + 'a>

Get a parser combinator that can work on StateStream as its input.

impl PartialEq for Location

fn eq(&self, other: &Location) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Printable for Location

fn fmt(&self, ctx: &Context, _state: &State, f: &mut Formatter<'_>) -> Result

fn disp<'t, 'c>(&'t self, ctx: &'c Context) -> Box<dyn Display + 'c>

where 't: 'c,

Get a Display’able object from the given Context and default State.

fn print<'t, 'c>( &'t self, ctx: &'c Context, state: &State, ) -> Box<dyn Display + 'c>

where 't: 'c,

Get a Display’able object from the given Context and State.

impl Eq for Location

impl StructuralPartialEq for Location