Enum cairo_lang_syntax::node::ast::Expr

pub enum Expr {
    Path(ExprPath),
    Literal(TerminalLiteralNumber),
    ShortString(TerminalShortString),
    String(TerminalString),
    False(TerminalFalse),
    True(TerminalTrue),
    Parenthesized(ExprParenthesized),
    Unary(ExprUnary),
    Binary(ExprBinary),
    Tuple(ExprListParenthesized),
    FunctionCall(ExprFunctionCall),
    StructCtorCall(ExprStructCtorCall),
    Block(ExprBlock),
    Match(ExprMatch),
    If(ExprIf),
    Loop(ExprLoop),
    ErrorPropagate(ExprErrorPropagate),
    FieldInitShorthand(ExprFieldInitShorthand),
    Indexed(ExprIndexed),
    InlineMacro(ExprInlineMacro),
    Missing(ExprMissing),
}

Variants

Path(ExprPath)

Literal(TerminalLiteralNumber)

ShortString(TerminalShortString)

String(TerminalString)

False(TerminalFalse)

True(TerminalTrue)

Parenthesized(ExprParenthesized)

Unary(ExprUnary)

Binary(ExprBinary)

Tuple(ExprListParenthesized)

FunctionCall(ExprFunctionCall)

StructCtorCall(ExprStructCtorCall)

Block(ExprBlock)

Match(ExprMatch)

If(ExprIf)

Loop(ExprLoop)

ErrorPropagate(ExprErrorPropagate)

FieldInitShorthand(ExprFieldInitShorthand)

Indexed(ExprIndexed)

InlineMacro(ExprInlineMacro)

Missing(ExprMissing)

Implementations

impl Expr

pub fn is_variant(kind: SyntaxKind) -> bool

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 Hash for Expr

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 PartialEq<Expr> for Expr

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl TypedSyntaxNode for Expr

const OPTIONAL_KIND: Option<SyntaxKind> = None

The relevant SyntaxKind. None for enums.

type StablePtr = ExprPtr

type Green = ExprGreen

fn missing(db: &dyn SyntaxGroup) -> Self::Green

fn from_syntax_node(db: &dyn SyntaxGroup, node: SyntaxNode) -> Self

fn as_syntax_node(&self) -> SyntaxNode

fn stable_ptr(&self) -> Self::StablePtr

impl Eq for Expr

impl StructuralEq for Expr

impl StructuralPartialEq for Expr