Enum sixtyfps_compilerlib::expression_tree::Expression [−][src]
pub enum Expression {
Show 35 variants
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(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),
}
Expand description
The Expression is hold by properties, so it should not hold any strong references to node from the object_tree
Variants
Something went wrong (and an error will be reported)
Uncompiled(SyntaxNode)
We haven’t done the lookup yet
Tuple Fields of Uncompiled
0: SyntaxNode
StringLiteral(String)
A string literal. The .0 is the content of the string, without the quotes
Tuple Fields of StringLiteral
0: String
Number
BoolLiteral(bool)
Tuple Fields of BoolLiteral
0: bool
CallbackReference(NamedReference)
Reference to the callback
Note: if we are to separate expression and statement, we probably do not need to have callback reference within expressions
Tuple Fields of CallbackReference
PropertyReference(NamedReference)
Reference to the callback
Tuple Fields of PropertyReference
BuiltinFunctionReference(BuiltinFunction, Option<SourceLocation>)
Reference to a function built into the run-time, implemented natively
Tuple Fields of BuiltinFunctionReference
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
BuiltinMacroReference(BuiltinMacroFunction, Option<NodeOrToken>)
Reference to a macro understood by the compiler. These should be transformed to other expression before reaching generation
Tuple Fields of BuiltinMacroReference
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.
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
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
Reference the parameter at the given index of the current function.
Should be directly within a CodeBlock expression, and store the value of the expression in a local variable
Fields of StoreLocalVariable
name: String
value: Box<Expression>
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
Access to a field of the given name within a struct.
Fields of StructFieldAccess
Cast an expression to the given type
Fields of Cast
from: Box<Expression>
to: Type
CodeBlock(Vec<Expression>)
a code block with different expression
Tuple Fields of CodeBlock
0: Vec<Expression>
A function call
Fields of FunctionCall
A SelfAssignment or an Assignment. When op is ‘=’ this is a signal assignment.
Fields of SelfAssignment
Fields of BinaryExpression
lhs: Box<Expression>
rhs: Box<Expression>
op: char
‘+’, ‘-’, ‘/’, ‘*’, ‘=’, ‘!’, ‘<’, ‘>’, ‘≤’, ‘≥’, ‘&’, ‘|’
Fields of UnaryOp
ImageReference(ImageReference)
Tuple Fields of ImageReference
Fields of Condition
Fields of Array
element_ty: Type
values: Vec<Expression>
Fields of Struct
ty: Type
values: HashMap<String, Expression>
Fields of PathElements
elements: Path
EasingCurve(EasingCurve)
Tuple Fields of EasingCurve
0: EasingCurve
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)
Tuple Fields of EnumerationValue
ReturnStatement(Option<Box<Expression>>)
Tuple Fields of ReturnStatement
0: Option<Box<Expression>>
Fields of LayoutCacheAccess
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)
Compute the LayoutInfo for the given layout. The orientation is the orientation of the cache, not the orientation of the layout
Tuple Fields of ComputeLayoutInfo
0: Layout
1: Orientation
SolveLayout(Layout, Orientation)
Tuple Fields of SolveLayout
0: Layout
1: Orientation
Implementations
Call the visitor for each sub-expression. (note: this function does not recurse)
Visit itself and each sub expression recursively
Visit itself and each sub expression recursively
pub fn maybe_convert_to(
self,
target_type: Type,
node: &impl Spanned,
diag: &mut BuildDiagnostics
) -> Expression
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
Return the default value for the given type
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
Trait Implementations
Performs the conversion.
fn for_each_entry<R>(
&self,
ctx: &LookupCtx<'_>,
f: &mut impl FnMut(&str, Expression) -> Option<R>
) -> Option<R>
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 Read more
Auto Trait Implementations
impl !RefUnwindSafe for Expression
impl !Send for Expression
impl !Sync for Expression
impl Unpin for Expression
impl !UnwindSafe for Expression
Blanket Implementations
Mutably borrows from an owned value. Read more