Struct Expr

pub struct Expr {
    pub id: NodeId,
    pub kind: ExprKind,
    pub span: Span,
    pub attrs: AttrVec,
    pub tokens: Option<LazyAttrTokenStream>,
}

An expression.

Fields

id: NodeId

kind: ExprKind

span: Span

attrs: AttrVec

tokens: Option<LazyAttrTokenStream>

Implementations

impl Expr

pub fn is_potential_trivial_const_arg(&self) -> bool

Could this expr be either N, or { N }, where N is a const parameter.

If this is not the case, name resolution does not resolve N when using min_const_generics as more complex expressions are not supported.

Does not ensure that the path resolves to a const param, the caller should check this. This also does not consider macros, so it’s only correct after macro-expansion.

pub fn maybe_unwrap_block(&self) -> &Expr

Returns an expression with (when possible) one outter brace removed

pub fn optionally_braced_mac_call( &self, already_stripped_block: bool, ) -> Option<(bool, NodeId)>

Determines whether this expression is a macro call optionally wrapped in braces . If already_stripped_block is set then we do not attempt to peel off a layer of braces.

Returns the NodeId of the macro call and whether a layer of braces has been peeled either before, or part of, this function.

pub fn to_bound(&self) -> Option<GenericBound>

pub fn peel_parens(&self) -> &Expr

pub fn peel_parens_and_refs(&self) -> &Expr

pub fn to_ty(&self) -> Option<P<Ty>>

Attempts to reparse as Ty (for diagnostic purposes).

pub fn precedence(&self) -> ExprPrecedence

pub fn is_approximately_pattern(&self) -> bool

To a first-order approximation, is this a pattern?

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl<__D: SpanDecoder> Decodable<__D> for Expr

fn decode(__decoder: &mut __D) -> Self

impl DummyAstNode for Expr

fn dummy() -> Self

impl<__E: SpanEncoder> Encodable<__E> for Expr

fn encode(&self, __encoder: &mut __E)

impl HasAttrs for Expr

const SUPPORTS_CUSTOM_INNER_ATTRS: bool = false

This is true if this HasAttrs might support ‘custom’ (proc-macro) inner attributes. Attributes like #![cfg] and #![cfg_attr] are not considered ‘custom’ attributes.

fn attrs(&self) -> &[Attribute]

fn visit_attrs(&mut self, f: impl FnOnce(&mut AttrVec))

impl HasNodeId for Expr

fn node_id(&self) -> NodeId

fn node_id_mut(&mut self) -> &mut NodeId

impl HasTokens for Expr

fn tokens(&self) -> Option<&LazyAttrTokenStream>

fn tokens_mut(&mut self) -> Option<&mut Option<LazyAttrTokenStream>>

impl !AstDeref for Expr

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 72 bytes