Enum sixtyfps_compilerlib::expression_tree::Expression

pub enum Expression {
    Invalid,
    Uncompiled(SyntaxNode),
    TwoWayBinding(NamedReference, Option<Box<Expression>>),
    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(ImageReference),
    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)

We haven’t done the lookup yet

TwoWayBinding(NamedReference, Option<Box<Expression>>)

Special expression that can be the value of a two way binding

The named reference is what it is aliased to, and the optional Expression is the initialization expression, if any. That expression can be a TwoWayBinding as well

StringLiteral(String)

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

NumberLiteral(f64, Unit)

Number

BoolLiteral(bool)

CallbackReference(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)

Reference to the callback in the

BuiltinFunctionReference(BuiltinFunction, Option<SourceLocation>)

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

MemberFunction

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.

Fields of MemberFunction

base: Box<Expression>base_node: Option<NodeOrToken>member: Box<Expression>

BuiltinMacroReference(BuiltinMacroFunction, Option<NodeOrToken>)

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

ElementReference(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

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

Fields of RepeaterIndexReference

element: Weak<RefCell<Element>>

RepeaterModelReference

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

Fields of RepeaterModelReference

element: Weak<RefCell<Element>>

FunctionParameterReference

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

Fields of FunctionParameterReference

index: usizety: Type

StoreLocalVariable

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

Fields of StoreLocalVariable

name: Stringvalue: Box<Expression>

ReadLocalVariable

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

Fields of ReadLocalVariable

name: Stringty: Type

StructFieldAccess

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

Fields of StructFieldAccess

base: Box<Expression>

This expression should have Type::Struct type

name: String

Cast

Cast an expression to the given type

Fields of Cast

from: Box<Expression>to: Type

CodeBlock(Vec<Expression>)

a code block with different expression

FunctionCall

A function call

Fields of FunctionCall

function: Box<Expression>arguments: Vec<Expression>source_location: Option<SourceLocation>

SelfAssignment

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

Fields of SelfAssignment

lhs: Box<Expression>rhs: Box<Expression>op: char

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

BinaryExpression

Fields of BinaryExpression

lhs: Box<Expression>rhs: Box<Expression>op: char

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

UnaryOp

Fields of UnaryOp

sub: Box<Expression>op: char

‘+’, ‘-’, ‘!’

ImageReference(ImageReference)

Condition

Fields of Condition

condition: Box<Expression>true_expr: Box<Expression>false_expr: Box<Expression>

Array

Fields of Array

element_ty: Typevalues: Vec<Expression>

Struct

Fields of Struct

ty: Typevalues: HashMap<String, Expression>

PathElements

Fields of PathElements

elements: Path

EasingCurve(EasingCurve)

LinearGradient

Fields of LinearGradient

angle: Box<Expression>stops: Vec<(Expression, Expression)>

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

EnumerationValue(EnumerationValue)

ReturnStatement(Option<Box<Expression>>)

LayoutCacheAccess

Fields of LayoutCacheAccess

layout_cache_prop: NamedReferenceindex: usizerepeater_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)

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

SolveLayout(Layout, 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 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

pub fn from_two_way_binding(
    node: TwoWayBinding,
    ctx: &mut LookupCtx<'_>
) -> Expression

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