Enum sixtyfps_compilerlib::expression_tree::Expression

pub enum Expression {
    Invalid,
    Uncompiled(SyntaxNode),
    StringLiteral(String),
    NumberLiteral(f64, Unit),
    BoolLiteral(bool),
    CallbackReference(NamedReference),
    PropertyReference(NamedReference),
    BuiltinFunctionReference(BuiltinFunction, Option<SourceLocation>),
    MemberFunction {
        base: Box<Expression>,
        base_node: Option<NodeOrToken>,
        member: Box<Expression>,
    },
    BuiltinMacroReference(BuiltinMacroFunction, Option<NodeOrToken>),
    ElementReference(Weak<RefCell<Element>>),
    RepeaterIndexReference {
        element: Weak<RefCell<Element>>,
    },
    RepeaterModelReference {
        element: Weak<RefCell<Element>>,
    },
    FunctionParameterReference {
        index: usize,
        ty: Type,
    },
    StoreLocalVariable {
        name: String,
        value: Box<Expression>,
    },
    ReadLocalVariable {
        name: String,
        ty: Type,
    },
    StructFieldAccess {
        base: Box<Expression>,
        name: String,
    },
    Cast {
        from: Box<Expression>,
        to: Type,
    },
    CodeBlock(Vec<Expression>),
    FunctionCall {
        function: Box<Expression>,
        arguments: Vec<Expression>,
        source_location: Option<SourceLocation>,
    },
    SelfAssignment {
        lhs: Box<Expression>,
        rhs: Box<Expression>,
        op: char,
    },
    BinaryExpression {
        lhs: Box<Expression>,
        rhs: Box<Expression>,
        op: char,
    },
    UnaryOp {
        sub: Box<Expression>,
        op: char,
    },
    ImageReference {
        resource_ref: ImageReference,
        source_location: Option<SourceLocation>,
    },
    Condition {
        condition: Box<Expression>,
        true_expr: Box<Expression>,
        false_expr: Box<Expression>,
    },
    Array {
        element_ty: Type,
        values: Vec<Expression>,
    },
    Struct {
        ty: Type,
        values: HashMap<String, Expression>,
    },
    PathElements {
        elements: Path,
    },
    EasingCurve(EasingCurve),
    LinearGradient {
        angle: Box<Expression>,
        stops: Vec<(Expression, Expression)>,
    },
    EnumerationValue(EnumerationValue),
    ReturnStatement(Option<Box<Expression>>),
    LayoutCacheAccess {
        layout_cache_prop: NamedReference,
        index: usize,
        repeater_index: Option<Box<Expression>>,
    },
    ComputeLayoutInfo(Layout, Orientation),
    SolveLayout(Layout, Orientation),
}

The Expression is hold by properties, so it should not hold any strong references to node from the object_tree

Variants

Invalid

Something went wrong (and an error will be reported)

Uncompiled(SyntaxNode)

Tuple Fields

0: SyntaxNode

We haven’t done the lookup yet

StringLiteral(String)

Tuple Fields

0: String

A string literal. The .0 is the content of the string, without the quotes

NumberLiteral(f64, Unit)

Tuple Fields

0: f64

1: Unit

Number

BoolLiteral(bool)

Tuple Fields

0: bool

CallbackReference(NamedReference)

Tuple Fields

0: NamedReference

Reference to the callback in the

Note: if we are to separate expression and statement, we probably do not need to have callback reference within expressions

PropertyReference(NamedReference)

Tuple Fields

0: NamedReference

Reference to the callback in the

BuiltinFunctionReference(BuiltinFunction, Option<SourceLocation>)

Tuple Fields

0: BuiltinFunction

1: Option<SourceLocation>

Reference to a function built into the run-time, implemented natively

MemberFunction

Fields

base: Box<Expression>

base_node: Option<NodeOrToken>

member: Box<Expression>

A MemberFunction expression exists only for a short time, for example for item.focus() to be translated to a regular FunctionCall expression where the base becomes the first argument.

BuiltinMacroReference(BuiltinMacroFunction, Option<NodeOrToken>)

Tuple Fields

0: BuiltinMacroFunction

1: Option<NodeOrToken>

Reference to a macro understood by the compiler. These should be transformed to other expression before reaching generation

ElementReference(Weak<RefCell<Element>>)

Tuple Fields

0: Weak<RefCell<Element>>

A reference to a specific element. This isn’t possible to create in .60 syntax itself, but intermediate passes may generate this type of expression.

RepeaterIndexReference

Fields

element: Weak<RefCell<Element>>

Reference to the index variable of a repeater

Example: idx in for xxx[idx] in .... The element is the reference to the element that is repeated

RepeaterModelReference

Fields

element: Weak<RefCell<Element>>

Reference to the model variable of a repeater

Example: xxx in for xxx[idx] in .... The element is the reference to the element that is repeated

FunctionParameterReference

Fields

index: usize

ty: Type

Reference the parameter at the given index of the current function.

StoreLocalVariable

Fields

name: String

value: Box<Expression>

Should be directly within a CodeBlock expression, and store the value of the expression in a local variable

ReadLocalVariable

Fields

name: String

ty: Type

a reference to the local variable with the given name. The type system should ensure that a variable has been stored with this name and this type before in one of the statement of an enclosing codeblock

StructFieldAccess

Fields

base: Box<Expression>

This expression should have Type::Struct type

name: String

Access to a field of the given name within a struct.

Cast

Fields

from: Box<Expression>

to: Type

Cast an expression to the given type

CodeBlock(Vec<Expression>)

Tuple Fields

0: Vec<Expression>

a code block with different expression

FunctionCall

Fields

function: Box<Expression>

arguments: Vec<Expression>

source_location: Option<SourceLocation>

A function call

SelfAssignment

Fields

lhs: Box<Expression>

rhs: Box<Expression>

op: char

‘+’, ‘-’, ‘/’, ‘*’, or ‘=’

A SelfAssignment or an Assignment. When op is ‘=’ this is a signal assignment.

BinaryExpression

Fields

lhs: Box<Expression>

rhs: Box<Expression>

op: char

‘+’, ‘-’, ‘/’, ‘*’, ‘=’, ‘!’, ‘<’, ‘>’, ‘≤’, ‘≥’, ‘&’, ‘|’

UnaryOp

Fields

sub: Box<Expression>

op: char

‘+’, ‘-’, ‘!’

ImageReference

Fields

resource_ref: ImageReference

source_location: Option<SourceLocation>

Condition

Fields

condition: Box<Expression>

true_expr: Box<Expression>

false_expr: Box<Expression>

Array

Fields

element_ty: Type

values: Vec<Expression>

Struct

Fields

ty: Type

values: HashMap<String, Expression>

PathElements

Fields

elements: Path

EasingCurve(EasingCurve)

Tuple Fields

0: EasingCurve

LinearGradient

Fields

angle: Box<Expression>

stops: Vec<(Expression, Expression)>

First expression in the tuple is a color, second expression is the stop position

EnumerationValue(EnumerationValue)

Tuple Fields

0: EnumerationValue

ReturnStatement(Option<Box<Expression>>)

Tuple Fields

0: Option<Box<Expression>>

LayoutCacheAccess

Fields

layout_cache_prop: NamedReference

index: usize

repeater_index: Option<Box<Expression>>

When set, this is the index within a repeater, and the index is then the location of another offset. So this looks like layout_cache_prop[layout_cache_prop[index] + repeater_index]

ComputeLayoutInfo(Layout, Orientation)

Tuple Fields

0: Layout

1: Orientation

Compute the LayoutInfo for the given layout. The orientation is the orientation of the cache, not the orientation of the layout

SolveLayout(Layout, Orientation)

Tuple Fields

0: Layout

1: Orientation

Implementations

impl Expression

pub fn ty(&self) -> Type

Return the type of this property

pub fn visit(&self, visitor: impl FnMut(&Self))

Call the visitor for each sub-expression. (note: this function does not recurse)

pub fn visit_mut(&mut self, visitor: impl FnMut(&mut Self))

pub fn visit_recursive(&self, visitor: &mut dyn FnMut(&Self))

Visit itself and each sub expression recursively

pub fn visit_recursive_mut(&mut self, visitor: &mut dyn FnMut(&mut Self))

Visit itself and each sub expression recursively

pub fn is_constant(&self) -> bool

pub fn maybe_convert_to(
    self,
    target_type: Type,
    node: &impl Spanned,
    diag: &mut BuildDiagnostics
) -> Expression

Create a conversion node if needed, or throw an error if the type is not matching

pub fn default_value_for_type(ty: &Type) -> Expression

Return the default value for the given type

pub fn try_set_rw(&mut self) -> bool

Try to mark this expression to a lvalue that can be assigned to.

Return true if the expression is a “lvalue” that can be used as the left hand side of a = or += or similar

impl Expression

pub fn from_binding_expression_node(
    node: SyntaxNode,
    ctx: &mut LookupCtx<'_>
) -> Self

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl Default for Expression

fn default() -> Self

Returns the “default value” for a type.

impl From<Expression> for BindingExpression

fn from(expression: Expression) -> Self

Performs the conversion.

impl LookupObject for Expression

fn for_each_entry<R>(
    &self,
    ctx: &LookupCtx<'_>,
    f: &mut impl FnMut(&str, Expression) -> Option<R>
) -> Option<R>

Will call the function for each entry (useful for completion) If the function return Some, it will immediately be returned and not called further

fn lookup(&self, ctx: &LookupCtx<'_>, name: &str) -> Option<LookupResult>

Perform a lookup of a given identifier. One does not have to re-implement unless we can make it faster