Enum dora_parser::ast::Expr

pub enum Expr {
    ExprUn(ExprUnType),
    ExprBin(ExprBinType),
    ExprLitChar(ExprLitCharType),
    ExprLitInt(ExprLitIntType),
    ExprLitFloat(ExprLitFloatType),
    ExprLitStr(ExprLitStrType),
    ExprTemplate(ExprTemplateType),
    ExprLitBool(ExprLitBoolType),
    ExprIdent(ExprIdentType),
    ExprCall(ExprCallType),
    ExprTypeParam(ExprTypeParamType),
    ExprPath(ExprPathType),
    ExprDelegation(ExprDelegationType),
    ExprDot(ExprDotType),
    ExprSelf(ExprSelfType),
    ExprSuper(ExprSuperType),
    ExprNil(ExprNilType),
    ExprConv(ExprConvType),
    ExprTry(ExprTryType),
    ExprLambda(ExprLambdaType),
}

Variants

ExprUn(ExprUnType)

ExprBin(ExprBinType)

ExprLitChar(ExprLitCharType)

ExprLitInt(ExprLitIntType)

ExprLitFloat(ExprLitFloatType)

ExprLitStr(ExprLitStrType)

ExprTemplate(ExprTemplateType)

ExprLitBool(ExprLitBoolType)

ExprIdent(ExprIdentType)

ExprCall(ExprCallType)

ExprTypeParam(ExprTypeParamType)

ExprPath(ExprPathType)

ExprDelegation(ExprDelegationType)

ExprDot(ExprDotType)

ExprSelf(ExprSelfType)

ExprSuper(ExprSuperType)

ExprNil(ExprNilType)

ExprConv(ExprConvType)

ExprTry(ExprTryType)

ExprLambda(ExprLambdaType)

Methods

impl Expr

pub fn create_un(
    id: NodeId,
    pos: Position,
    span: Span,
    op: UnOp,
    opnd: Box<Expr>
) -> Expr

pub fn create_try(
    id: NodeId,
    pos: Position,
    span: Span,
    expr: Box<Expr>,
    mode: TryMode
) -> Expr

pub fn create_bin(
    id: NodeId,
    pos: Position,
    span: Span,
    op: BinOp,
    lhs: Box<Expr>,
    rhs: Box<Expr>
) -> Expr

pub fn create_conv(
    id: NodeId,
    pos: Position,
    span: Span,
    object: Box<Expr>,
    data_type: Box<Type>,
    is: bool
) -> Expr

pub fn create_lit_char(
    id: NodeId,
    pos: Position,
    span: Span,
    value: char
) -> Expr

pub fn create_lit_int(
    id: NodeId,
    pos: Position,
    span: Span,
    value: u64,
    base: IntBase,
    suffix: IntSuffix
) -> Expr

pub fn create_lit_float(
    id: NodeId,
    pos: Position,
    span: Span,
    value: f64,
    suffix: FloatSuffix
) -> Expr

pub fn create_lit_str(
    id: NodeId,
    pos: Position,
    span: Span,
    value: String
) -> Expr

pub fn create_template(
    id: NodeId,
    pos: Position,
    span: Span,
    parts: Vec<Box<Expr>>
) -> Expr

pub fn create_lit_bool(
    id: NodeId,
    pos: Position,
    span: Span,
    value: bool
) -> Expr

pub fn create_this(id: NodeId, pos: Position, span: Span) -> Expr

pub fn create_super(id: NodeId, pos: Position, span: Span) -> Expr

pub fn create_nil(id: NodeId, pos: Position, span: Span) -> Expr

pub fn create_ident(
    id: NodeId,
    pos: Position,
    span: Span,
    name: Name,
    type_params: Option<Vec<Type>>
) -> Expr

pub fn create_call(
    id: NodeId,
    pos: Position,
    span: Span,
    callee: Box<Expr>,
    args: Vec<Box<Expr>>
) -> Expr

pub fn create_type_param(
    id: NodeId,
    pos: Position,
    span: Span,
    callee: Box<Expr>,
    args: Vec<Type>
) -> Expr

pub fn create_path(
    id: NodeId,
    pos: Position,
    span: Span,
    lhs: Box<Expr>,
    rhs: Box<Expr>
) -> Expr

pub fn create_delegation(
    id: NodeId,
    pos: Position,
    span: Span,
    ty: DelegationType,
    args: Vec<Box<Expr>>
) -> Expr

pub fn create_dot(
    id: NodeId,
    pos: Position,
    span: Span,
    object: Box<Expr>,
    name: Name
) -> Expr

pub fn create_lambda(
    id: NodeId,
    pos: Position,
    span: Span,
    params: Vec<Param>,
    ret: Option<Box<Type>>,
    block: Box<Stmt>
) -> Expr

pub fn to_un(&self) -> Option<&ExprUnType>

pub fn is_un(&self) -> bool

pub fn to_bin(&self) -> Option<&ExprBinType>

pub fn is_bin(&self) -> bool

pub fn to_ident(&self) -> Option<&ExprIdentType>

pub fn is_ident(&self) -> bool

pub fn to_call(&self) -> Option<&ExprCallType>

pub fn is_call(&self) -> bool

pub fn to_path(&self) -> Option<&ExprPathType>

pub fn is_path(&self) -> bool

pub fn to_type_param(&self) -> Option<&ExprTypeParamType>

pub fn is_type_param(&self) -> bool

pub fn to_lit_char(&self) -> Option<&ExprLitCharType>

pub fn is_lit_char(&self) -> bool

pub fn to_lit_int(&self) -> Option<&ExprLitIntType>

pub fn is_lit_int(&self) -> bool

pub fn to_template(&self) -> Option<&ExprTemplateType>

pub fn is_template(&self) -> bool

pub fn to_lit_float(&self) -> Option<&ExprLitFloatType>

pub fn is_lit_float(&self) -> bool

pub fn to_lit_str(&self) -> Option<&ExprLitStrType>

pub fn is_lit_str(&self) -> bool

pub fn to_lit_bool(&self) -> Option<&ExprLitBoolType>

pub fn is_lit_bool(&self) -> bool

pub fn is_lit_true(&self) -> bool

pub fn to_dot(&self) -> Option<&ExprDotType>

pub fn is_dot(&self) -> bool

pub fn to_delegation(&self) -> Option<&ExprDelegationType>

pub fn is_delegation(&self) -> bool

pub fn is_this(&self) -> bool

pub fn is_super(&self) -> bool

pub fn to_super(&self) -> Option<&ExprSuperType>

pub fn is_nil(&self) -> bool

pub fn to_conv(&self) -> Option<&ExprConvType>

pub fn is_conv(&self) -> bool

pub fn to_try(&self) -> Option<&ExprTryType>

pub fn is_try(&self) -> bool

pub fn to_lambda(&self) -> Option<&ExprLambdaType>

pub fn is_lambda(&self) -> bool

pub fn pos(&self) -> Position

pub fn span(&self) -> Span

pub fn id(&self) -> NodeId

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.