Enum MdNodeAttr 

pub enum MdNodeAttr {
    Tuple {
        distinct: bool,
        operands: Vec<MdOperandAttr>,
    },
}

A metadata node: an entry in the module’s metadata table (MdTableAttr).

TODO: Only LLVM’s generic MDTuple is modelled. Typed support for LLVM’s specialized debug info nodes would be added as further variants of this enum, holding the scalar fields that those nodes keep outside their operand list.

Variants

Tuple

LLVM’s MDTuple: !{ op, op, ... }, or distinct !{ op, op, ... } for a node that LLVM must not unique with a structurally identical one.

Fields

distinct: bool

operands: Vec<MdOperandAttr>

Implementations

impl MdNodeAttr

pub fn new_tuple(operands: Vec<MdOperandAttr>) -> Self

A uniqued MDTuple with the given operands.

pub fn new_distinct_tuple(operands: Vec<MdOperandAttr>) -> Self

A distinct MDTuple with the given operands.

pub fn is_distinct(&self) -> bool

Is this a distinct node?

pub fn operands(&self) -> &[MdOperandAttr]

This node’s operands.

Trait Implementations

impl Clone for MdNodeAttr

fn clone(&self) -> MdNodeAttr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MdNodeAttr

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

Formats the value using the given formatter.

impl Eq for MdNodeAttr

impl Hash for MdNodeAttr

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Parsable for MdNodeAttr

type Arg = ()

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

type Parsed = MdNodeAttr

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<Stream<Stream<Stream<Stream<IteratorStream<CharIterator<'a>>, SourcePosition>>>, State<'a>>, PartialState = (), Output = Self::Parsed> + 'a>

where Self::Parsed: 'a,

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

impl PartialEq for MdNodeAttr

fn eq(&self, other: &MdNodeAttr) -> 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 MdNodeAttr

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 StructuralPartialEq for MdNodeAttr