caisin/typst
1
0
Fork 0
mirror of https://github.com/typst/typst synced 2025-05-14 04:56:26 +08:00
Code Issues Packages Projects Releases Wiki Activity

Style nits 🎈

Browse Source
This commit is contained in:
Laurenz 2020-10-04 19:21:35 +02:00
parent 0f7c70fd93
commit f4460f8abd
15 changed files with 161 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/eval/dict.rs
View File

@ -351,7 +351,7 @@ impl<V> SpannedEntry<V> {
}
/// Create an entry with the same span for key and value.
pub fn val(val: Spanned<V>) -> Self {
pub fn value(val: Spanned<V>) -> Self {
Self { key_span: val.span, value: val }
}

8
src/eval/scope.rs
View File

@ -3,12 +3,12 @@
use std::collections::HashMap;
use std::fmt::{self, Debug, Formatter};
use super::value::FuncValue;
use super::value::ValueFunc;
/// A map from identifiers to functions.
#[derive(Clone, PartialEq)]
pub struct Scope {
functions: HashMap<String, FuncValue>,
functions: HashMap<String, ValueFunc>,
}
impl Scope {
@ -19,12 +19,12 @@ impl Scope {
}
/// Associate the given name with the function.
pub fn insert(&mut self, name: impl Into<String>, function: FuncValue) {
pub fn insert(&mut self, name: impl Into<String>, function: ValueFunc) {
self.functions.insert(name.into(), function);
}
/// Return the function with the given name if there is one.
pub fn func(&self, name: &str) -> Option<&FuncValue> {
pub fn func(&self, name: &str) -> Option<&ValueFunc> {
self.functions.get(name)
}
}

154
src/eval/value.rs
View File

@ -17,8 +17,6 @@ use crate::{DynFuture, Feedback};
/// A computational value.
#[derive(Clone, PartialEq)]
pub enum Value {
/// The result of invalid operations.
Error,
/// An identifier: `ident`.
Ident(Ident),
/// A boolean: `true, false`.
@ -36,27 +34,29 @@ pub enum Value {
///
/// [literal]: ../syntax/ast/enum.Lit.html#variant.Percent
Relative(f64),
/// A combination of an absolute length and a relative value.
/// A combination of an absolute length and a relative value: `20% + 5cm`.
Linear(Linear),
/// A color value with alpha channel: `#f79143ff`.
Color(RgbaColor),
/// A string: `"string"`.
Str(String),
/// A dictionary value: `(false, 12cm, greeting="hi")`.
Dict(DictValue),
/// A syntax tree containing typesetting content.
Tree(SynTree),
Dict(ValueDict),
/// A content value: `{*Hi* there}`.
Content(SynTree),
/// An executable function.
Func(FuncValue),
Func(ValueFunc),
/// Layouting commands.
Commands(Commands),
/// The result of invalid operations.
Error,
}
impl Value {
/// The natural-language name of this value for use in error messages.
pub fn name(&self) -> &'static str {
/// The natural-language name of this value's type for use in error
/// messages.
pub fn ty(&self) -> &'static str {
match self {
Self::Error => "error",
Self::Ident(_) => "identifier",
Self::Bool(_) => "bool",
Self::Int(_) => "integer",
@ -67,9 +67,10 @@ impl Value {
Self::Color(_) => "color",
Self::Str(_) => "string",
Self::Dict(_) => "dict",
Self::Tree(_) => "syntax tree",
Self::Content(_) => "content",
Self::Func(_) => "function",
Self::Commands(_) => "commands",
Self::Error => "error",
}
}
}
@ -98,7 +99,7 @@ impl Spanned<Value> {
commands
}
Value::Tree(tree) => vec![Command::LayoutSyntaxTree(tree)],
Value::Content(tree) => vec![Command::LayoutSyntaxTree(tree)],
Value::Commands(commands) => commands,
// Format with debug.
@ -115,69 +116,67 @@ impl Debug for Value {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
match self {
Self::Error => f.pad("<error>"),
Self::Ident(i) => i.fmt(f),
Self::Bool(b) => b.fmt(f),
Self::Int(i) => i.fmt(f),
Self::Float(n) => n.fmt(f),
Self::Length(l) => l.fmt(f),
Self::Relative(r) => r.fmt(f),
Self::Linear(l) => l.fmt(f),
Self::Color(c) => c.fmt(f),
Self::Str(s) => s.fmt(f),
Self::Dict(d) => d.fmt(f),
Self::Tree(t) => t.fmt(f),
Self::Func(c) => c.fmt(f),
Self::Commands(c) => c.fmt(f),
Self::Ident(v) => v.fmt(f),
Self::Bool(v) => v.fmt(f),
Self::Int(v) => v.fmt(f),
Self::Float(v) => v.fmt(f),
Self::Length(v) => v.fmt(f),
Self::Relative(v) => v.fmt(f),
Self::Linear(v) => v.fmt(f),
Self::Color(v) => v.fmt(f),
Self::Str(v) => v.fmt(f),
Self::Dict(v) => v.fmt(f),
Self::Content(v) => v.fmt(f),
Self::Func(v) => v.fmt(f),
Self::Commands(v) => v.fmt(f),
}
}
}
/// An executable function value.
///
/// The first argument is a dictionary containing the arguments passed to the
/// function. The function may be asynchronous (as such it returns a dynamic
/// future) and it may emit diagnostics, which are contained in the returned
/// `Pass`. In the end, the function must evaluate to [`Value`]. A typical
/// typesetting function will return a `Commands` value which will instruct the
/// layouting engine to do what the function pleases.
/// An wrapper around a reference-counted executable function value.
///
/// The dynamic function object is wrapped in an `Rc` to keep [`Value`]
/// clonable.
///
/// _Note_: This is needed because the compiler can't `derive(PartialEq)`
/// for `Value` when directly putting the boxed function in there,
/// see the [Rust Issue].
///
/// [`Value`]: enum.Value.html
/// [Rust Issue]: https://github.com/rust-lang/rust/issues/31740
#[derive(Clone)]
pub struct FuncValue(pub Rc<FuncType>);
pub struct ValueFunc(pub Rc<Func>);
/// The signature of executable functions.
type FuncType = dyn Fn(DictValue, &mut LayoutContext) -> DynFuture<Value>;
pub type Func = dyn Fn(ValueDict, &mut LayoutContext) -> DynFuture<Value>;
impl FuncValue {
impl ValueFunc {
/// Create a new function value from a rust function or closure.
pub fn new<F: 'static>(f: F) -> Self
where
F: Fn(DictValue, &mut LayoutContext) -> DynFuture<Value>,
F: Fn(ValueDict, &mut LayoutContext) -> DynFuture<Value>,
{
Self(Rc::new(f))
}
}
impl Eq for FuncValue {}
impl Eq for ValueFunc {}
impl PartialEq for FuncValue {
impl PartialEq for ValueFunc {
fn eq(&self, other: &Self) -> bool {
Rc::ptr_eq(&self.0, &other.0)
}
}
impl Deref for FuncValue {
type Target = FuncType;
impl Deref for ValueFunc {
type Target = Func;
fn deref(&self) -> &Self::Target {
self.0.as_ref()
}
}
impl Debug for FuncValue {
impl Debug for ValueFunc {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
f.pad("<function>")
}
@ -189,9 +188,9 @@ impl Debug for FuncValue {
/// ```typst
/// (false, 12cm, greeting="hi")
/// ```
pub type DictValue = Dict<SpannedEntry<Value>>;
pub type ValueDict = Dict<SpannedEntry<Value>>;
impl DictValue {
impl ValueDict {
/// Retrieve and remove the matching value with the lowest number key,
/// skipping and ignoring all non-matching entries with lower keys.
pub fn take<T: TryFromValue>(&mut self) -> Option<T> {
@ -331,7 +330,7 @@ macro_rules! impl_match {
other => {
error!(
@f, value.span,
"expected {}, found {}", $name, other.name()
"expected {}, found {}", $name, other.ty()
);
None
}
@ -354,7 +353,7 @@ macro_rules! impl_ident {
} else {
error!(
@f, value.span,
"expected {}, found {}", $name, value.v.name()
"expected {}, found {}", $name, value.v.ty()
);
None
}
@ -370,33 +369,13 @@ impl<T: TryFromValue> TryFromValue for Spanned<T> {
}
}
impl_match!(Value, "value", v => v.clone());
impl_match!(Ident, "identifier", Value::Ident(i) => i.clone());
impl_match!(bool, "bool", &Value::Bool(b) => b);
impl_match!(i64, "integer", &Value::Int(i) => i);
impl_match!(f64, "float",
&Value::Int(i) => i as f64,
&Value::Float(f) => f,
);
impl_match!(Abs, "length", &Value::Length(l) => Abs(l));
impl_match!(Rel, "relative", &Value::Relative(r) => Rel(r));
impl_match!(Linear, "linear",
&Value::Linear(l) => l,
&Value::Length(l) => Linear::abs(l),
&Value::Relative(r) => Linear::rel(r),
);
impl_match!(String, "string", Value::Str(s) => s.clone());
impl_match!(SynTree, "tree", Value::Tree(t) => t.clone());
impl_match!(DictValue, "dict", Value::Dict(t) => t.clone());
impl_match!(FuncValue, "function", Value::Func(f) => f.clone());
/// A value type that matches [length] values.
///
/// [length]: enum.Value.html#variant.Length
pub struct Abs(pub f64);
pub struct Absolute(pub f64);
impl From<Abs> for f64 {
fn from(abs: Abs) -> f64 {
impl From<Absolute> for f64 {
fn from(abs: Absolute) -> f64 {
abs.0
}
}
@ -404,10 +383,10 @@ impl From<Abs> for f64 {
/// A value type that matches [relative] values.
///
/// [relative]: enum.Value.html#variant.Relative
pub struct Rel(pub f64);
pub struct Relative(pub f64);
impl From<Rel> for f64 {
fn from(rel: Rel) -> f64 {
impl From<Relative> for f64 {
fn from(rel: Relative) -> f64 {
rel.0
}
}
@ -432,12 +411,31 @@ impl Deref for StringLike {
}
}
impl_match!(Value, "value", v => v.clone());
impl_match!(Ident, "identifier", Value::Ident(v) => v.clone());
impl_match!(bool, "bool", &Value::Bool(v) => v);
impl_match!(i64, "integer", &Value::Int(v) => v);
impl_match!(f64, "float",
&Value::Int(v) => v as f64,
&Value::Float(v) => v,
);
impl_match!(Absolute, "length", &Value::Length(v) => Absolute(v));
impl_match!(Relative, "relative", &Value::Relative(v) => Relative(v));
impl_match!(Linear, "linear",
&Value::Linear(v) => v,
&Value::Length(v) => Linear::abs(v),
&Value::Relative(v) => Linear::rel(v),
);
impl_match!(String, "string", Value::Str(v) => v.clone());
impl_match!(SynTree, "tree", Value::Content(v) => v.clone());
impl_match!(ValueDict, "dict", Value::Dict(v) => v.clone());
impl_match!(ValueFunc, "function", Value::Func(v) => v.clone());
impl_match!(StringLike, "identifier or string",
Value::Ident(Ident(s)) => StringLike(s.clone()),
Value::Str(s) => StringLike(s.clone()),
Value::Ident(Ident(v)) => StringLike(v.clone()),
Value::Str(v) => StringLike(v.clone()),
);
impl_ident!(Dir, "direction", |s| match s {
impl_ident!(Dir, "direction", |v| match v {
"ltr" => Some(Self::LTR),
"rtl" => Some(Self::RTL),
"ttb" => Some(Self::TTB),
@ -445,7 +443,7 @@ impl_ident!(Dir, "direction", |s| match s {
_ => None,
});
impl_ident!(SpecAlign, "alignment", |s| match s {
impl_ident!(SpecAlign, "alignment", |v| match v {
"left" => Some(Self::Left),
"right" => Some(Self::Right),
"top" => Some(Self::Top),
@ -486,7 +484,7 @@ impl TryFromValue for FontWeight {
error!(
@f, value.span,
"expected font weight (name or integer), found {}",
other.name(),
other.ty(),
);
None
}
@ -499,7 +497,7 @@ mod tests {
use super::*;
fn entry(value: Value) -> SpannedEntry<Value> {
SpannedEntry::val(Spanned::zero(value))
SpannedEntry::value(Spanned::zero(value))
}
#[test]

2
src/library/align.rs
View File

@ -14,7 +14,7 @@ use super::*;
/// - `vertical`: Any of `top`, `bottom` or `center`.
///
/// There may not be two alignment specifications for the same axis.
pub async fn align(mut args: DictValue, ctx: &mut LayoutContext) -> Value {
pub async fn align(mut args: ValueDict, ctx: &mut LayoutContext) -> Value {
let content = args.take::<SynTree>();
let h = args.take_key::<Spanned<SpecAlign>>("horizontal", &mut ctx.f);
let v = args.take_key::<Spanned<SpecAlign>>("vertical", &mut ctx.f);

2
src/library/boxed.rs
View File

@ -6,7 +6,7 @@ use crate::geom::Linear;
/// # Keyword arguments
/// - `width`: The width of the box (length or relative to parent's width).
/// - `height`: The height of the box (length or relative to parent's height).
pub async fn boxed(mut args: DictValue, ctx: &mut LayoutContext) -> Value {
pub async fn boxed(mut args: ValueDict, ctx: &mut LayoutContext) -> Value {
let content = args.take::<SynTree>().unwrap_or_default();
let constraints = &mut ctx.constraints;

2
src/library/color.rs
View File

@ -2,7 +2,7 @@ use super::*;
use crate::color::RgbaColor;
/// `rgb`: Create an RGB(A) color.
pub async fn rgb(mut args: DictValue, ctx: &mut LayoutContext) -> Value {
pub async fn rgb(mut args: ValueDict, ctx: &mut LayoutContext) -> Value {
let mut f = Feedback::new();
let r = args.expect::<Spanned<i64>>("red value", Span::ZERO, &mut f);

4
src/library/font.rs
View File

@ -49,7 +49,7 @@ use crate::geom::Linear;
/// ```typst
/// [font: "My Serif", serif]
/// ```
pub async fn font(mut args: DictValue, ctx: &mut LayoutContext) -> Value {
pub async fn font(mut args: ValueDict, ctx: &mut LayoutContext) -> Value {
let mut text = ctx.state.text.clone();
let mut updated_fallback = false;
@ -86,7 +86,7 @@ pub async fn font(mut args: DictValue, ctx: &mut LayoutContext) -> Value {
text.variant.stretch = stretch;
}
for (class, mut dict) in args.take_all_str::<DictValue>() {
for (class, mut dict) in args.take_all_str::<ValueDict>() {
let fallback = dict
.take_all_num_vals::<StringLike>()
.map(|s| s.to_lowercase())

4
src/library/mod.rs
View File

@ -14,7 +14,7 @@ pub use font::*;
pub use page::*;
pub use spacing::*;
use crate::eval::{FuncValue, Scope};
use crate::eval::{Scope, ValueFunc};
use crate::prelude::*;
macro_rules! std {
@ -30,7 +30,7 @@ macro_rules! std {
macro_rules! wrap {
($func:expr) => {
FuncValue::new(|args, ctx| Box::pin($func(args, ctx)))
ValueFunc::new(|args, ctx| Box::pin($func(args, ctx)))
};
}

10
src/library/page.rs
View File

@ -1,7 +1,7 @@
use std::mem;
use super::*;
use crate::eval::Abs;
use crate::eval::Absolute;
use crate::geom::{Linear, Sides};
use crate::paper::{Paper, PaperClass};
@ -19,7 +19,7 @@ use crate::paper::{Paper, PaperClass};
/// - `top`: The top margin (length or relative to height).
/// - `bottom`: The bottom margin (length or relative to height).
/// - `flip`: Flips custom or paper-defined width and height (boolean).
pub async fn page(mut args: DictValue, ctx: &mut LayoutContext) -> Value {
pub async fn page(mut args: ValueDict, ctx: &mut LayoutContext) -> Value {
let mut page = ctx.state.page.clone();
if let Some(paper) = args.take::<Paper>() {
@ -27,12 +27,12 @@ pub async fn page(mut args: DictValue, ctx: &mut LayoutContext) -> Value {
page.size = paper.size();
}
if let Some(Abs(width)) = args.take_key::<Abs>("width", &mut ctx.f) {
if let Some(Absolute(width)) = args.take_key::<Absolute>("width", &mut ctx.f) {
page.class = PaperClass::Custom;
page.size.width = width;
}
if let Some(Abs(height)) = args.take_key::<Abs>("height", &mut ctx.f) {
if let Some(Absolute(height)) = args.take_key::<Absolute>("height", &mut ctx.f) {
page.class = PaperClass::Custom;
page.size.height = height;
}
@ -66,7 +66,7 @@ pub async fn page(mut args: DictValue, ctx: &mut LayoutContext) -> Value {
}
/// `pagebreak`: Ends the current page.
pub async fn pagebreak(args: DictValue, ctx: &mut LayoutContext) -> Value {
pub async fn pagebreak(args: ValueDict, ctx: &mut LayoutContext) -> Value {
args.unexpected(&mut ctx.f);
Value::Commands(vec![BreakPage])
}

6
src/library/spacing.rs
View File

@ -6,7 +6,7 @@ use crate::layout::SpacingKind;
///
/// # Positional arguments
/// - The spacing (length or relative to font size).
pub async fn h(args: DictValue, ctx: &mut LayoutContext) -> Value {
pub async fn h(args: ValueDict, ctx: &mut LayoutContext) -> Value {
spacing(args, ctx, SpecAxis::Horizontal)
}
@ -14,11 +14,11 @@ pub async fn h(args: DictValue, ctx: &mut LayoutContext) -> Value {
///
/// # Positional arguments
/// - The spacing (length or relative to font size).
pub async fn v(args: DictValue, ctx: &mut LayoutContext) -> Value {
pub async fn v(args: ValueDict, ctx: &mut LayoutContext) -> Value {
spacing(args, ctx, SpecAxis::Vertical)
}
fn spacing(mut args: DictValue, ctx: &mut LayoutContext, axis: SpecAxis) -> Value {
fn spacing(mut args: ValueDict, ctx: &mut LayoutContext, axis: SpecAxis) -> Value {
let spacing = args.expect::<Linear>("spacing", Span::ZERO, &mut ctx.f);
args.unexpected(&mut ctx.f);
Value::Commands(if let Some(spacing) = spacing {

2
src/prelude.rs
View File

@ -1,7 +1,7 @@
//! A prelude for building custom functions.
#[doc(no_inline)]
pub use crate::eval::{Dict, DictValue, Value};
pub use crate::eval::{Dict, Value, ValueDict};
pub use crate::layout::primitive::*;
#[doc(no_inline)]
pub use crate::layout::{layout_tree, Command, Commands, LayoutContext};

91
src/syntax/ast/expr.rs
View File

@ -1,8 +1,8 @@
//! Expressions.
use super::*;
use crate::eval::Value;
use crate::layout::LayoutContext;
use crate::syntax::{Decoration, Ident, Lit, LitDict, SpanWith, Spanned};
use crate::DynFuture;
/// An expression.
@ -10,12 +10,12 @@ use crate::DynFuture;
pub enum Expr {
/// A literal: `true`, `1cm`, `"hi"`, `{_Hey!_}`.
Lit(Lit),
/// An invocation of a function: `[foo: ...]`, `foo(...)`.
Call(ExprCall),
/// A unary operation: `-x`.
Unary(ExprUnary),
/// A binary operation: `a + b`, `a / b`.
Binary(ExprBinary),
/// An invocation of a function: `[foo: ...]`, `foo(...)`.
Call(ExprCall),
}
impl Expr {
@ -24,14 +24,43 @@ impl Expr {
Box::pin(async move {
match self {
Self::Lit(lit) => lit.eval(ctx).await,
Self::Call(call) => call.eval(ctx).await,
Self::Unary(unary) => unary.eval(ctx).await,
Self::Binary(binary) => binary.eval(ctx).await,
Self::Call(call) => call.eval(ctx).await,
}
})
}
}
/// An invocation of a function: `[foo: ...]`, `foo(...)`.
#[derive(Debug, Clone, PartialEq)]
pub struct ExprCall {
/// The name of the function.
pub name: Spanned<Ident>,
/// The arguments to the function.
pub args: LitDict,
}
impl ExprCall {
/// Evaluate the call expression to a value.
pub async fn eval(&self, ctx: &mut LayoutContext) -> Value {
let name = &self.name.v;
let span = self.name.span;
let args = self.args.eval(ctx).await;
if let Some(func) = ctx.state.scope.func(name) {
ctx.f.decorations.push(Decoration::Resolved.span_with(span));
(func.clone())(args, ctx).await
} else {
if !name.is_empty() {
error!(@ctx.f, span, "unknown function");
ctx.f.decorations.push(Decoration::Unresolved.span_with(span));
}
Value::Dict(args)
}
}
}
/// A unary operation: `-x`.
#[derive(Debug, Clone, PartialEq)]
pub struct ExprUnary {
@ -54,13 +83,13 @@ impl ExprUnary {
let span = self.op.span.join(self.expr.span);
match self.op.v {
UnOp::Neg => match value {
Int(x) => Int(-x),
Float(x) => Float(-x),
Length(x) => Length(-x),
Relative(x) => Relative(-x),
Linear(x) => Linear(-x),
Int(v) => Int(-v),
Float(v) => Float(-v),
Length(v) => Length(-v),
Relative(v) => Relative(-v),
Linear(v) => Linear(-v),
v => {
error!(@ctx.f, span, "cannot negate {}", v.name());
error!(@ctx.f, span, "cannot negate {}", v.ty());
Value::Error
}
},
@ -104,7 +133,8 @@ impl ExprBinary {
BinOp::Add => match (lhs, rhs) {
// Numbers to themselves.
(Int(a), Int(b)) => Int(a + b),
(Int(i), Float(f)) | (Float(f), Int(i)) => Float(i as f64 + f),
(Int(a), Float(b)) => Float(a as f64 + b),
(Float(a), Int(b)) => Float(a + b as f64),
(Float(a), Float(b)) => Float(a + b),
// Lengths, relatives and linears to themselves.
@ -123,11 +153,11 @@ impl ExprBinary {
// Complex data types to themselves.
(Str(a), Str(b)) => Str(a + &b),
(Dict(a), Dict(b)) => Dict(concat(a, b)),
(Tree(a), Tree(b)) => Tree(concat(a, b)),
(Content(a), Content(b)) => Content(concat(a, b)),
(Commands(a), Commands(b)) => Commands(concat(a, b)),
(a, b) => {
error!(@ctx.f, span, "cannot add {} and {}", a.name(), b.name());
error!(@ctx.f, span, "cannot add {} and {}", a.ty(), b.ty());
Value::Error
}
},
@ -151,7 +181,7 @@ impl ExprBinary {
(Linear(a), Linear(b)) => Linear(a - b),
(a, b) => {
error!(@ctx.f, span, "cannot subtract {1} from {0}", a.name(), b.name());
error!(@ctx.f, span, "cannot subtract {1} from {0}", a.ty(), b.ty());
Value::Error
}
},
@ -182,7 +212,7 @@ impl ExprBinary {
(Str(a), Int(b)) => Str(a.repeat(b.max(0) as usize)),
(a, b) => {
error!(@ctx.f, span, "cannot multiply {} with {}", a.name(), b.name());
error!(@ctx.f, span, "cannot multiply {} with {}", a.ty(), b.ty());
Value::Error
}
},
@ -203,7 +233,7 @@ impl ExprBinary {
(Linear(a), Float(b)) => Linear(a / b),
(a, b) => {
error!(@ctx.f, span, "cannot divide {} by {}", a.name(), b.name());
error!(@ctx.f, span, "cannot divide {} by {}", a.ty(), b.ty());
Value::Error
}
},
@ -232,32 +262,3 @@ pub enum BinOp {
/// The division operator: `/`.
Div,
}
/// An invocation of a function: `[foo: ...]`, `foo(...)`.
#[derive(Debug, Clone, PartialEq)]
pub struct ExprCall {
/// The name of the function.
pub name: Spanned<Ident>,
/// The arguments to the function.
pub args: LitDict,
}
impl ExprCall {
/// Evaluate the call expression to a value.
pub async fn eval(&self, ctx: &mut LayoutContext) -> Value {
let name = &self.name.v;
let span = self.name.span;
let args = self.args.eval(ctx).await;
if let Some(func) = ctx.state.scope.func(name) {
ctx.f.decorations.push(Decoration::Resolved.span_with(span));
(func.clone())(args, ctx).await
} else {
if !name.is_empty() {
error!(@ctx.f, span, "unknown function");
ctx.f.decorations.push(Decoration::Unresolved.span_with(span));
}
Value::Dict(args)
}
}
}

30
src/syntax/ast/lit.rs
View File

@ -1,10 +1,10 @@
//! Literals.
use super::*;
use crate::color::RgbaColor;
use crate::eval::{DictKey, DictValue, SpannedEntry, Value};
use crate::eval::{DictKey, SpannedEntry, Value, ValueDict};
use crate::layout::LayoutContext;
use crate::length::Length;
use crate::syntax::{Expr, Ident, SpanWith, Spanned, SynTree};
use crate::DynFuture;
/// A literal.
@ -41,16 +41,16 @@ impl Lit {
/// Evaluate the dictionary literal to a dictionary value.
pub async fn eval(&self, ctx: &mut LayoutContext) -> Value {
match *self {
Lit::Ident(ref i) => Value::Ident(i.clone()),
Lit::Bool(b) => Value::Bool(b),
Lit::Int(i) => Value::Int(i),
Lit::Float(f) => Value::Float(f),
Lit::Length(l) => Value::Length(l.as_raw()),
Lit::Percent(p) => Value::Relative(p / 100.0),
Lit::Color(c) => Value::Color(c),
Lit::Str(ref s) => Value::Str(s.clone()),
Lit::Dict(ref d) => Value::Dict(d.eval(ctx).await),
Lit::Content(ref c) => Value::Tree(c.clone()),
Lit::Ident(ref v) => Value::Ident(v.clone()),
Lit::Bool(v) => Value::Bool(v),
Lit::Int(v) => Value::Int(v),
Lit::Float(v) => Value::Float(v),
Lit::Length(v) => Value::Length(v.as_raw()),
Lit::Percent(v) => Value::Relative(v / 100.0),
Lit::Color(v) => Value::Color(v),
Lit::Str(ref v) => Value::Str(v.clone()),
Lit::Dict(ref v) => Value::Dict(v.eval(ctx).await),
Lit::Content(ref v) => Value::Content(v.clone()),
}
}
}
@ -66,9 +66,9 @@ impl LitDict {
}
/// Evaluate the dictionary literal to a dictionary value.
pub fn eval<'a>(&'a self, ctx: &'a mut LayoutContext) -> DynFuture<'a, DictValue> {
pub fn eval<'a>(&'a self, ctx: &'a mut LayoutContext) -> DynFuture<'a, ValueDict> {
Box::pin(async move {
let mut dict = DictValue::new();
let mut dict = ValueDict::new();
for entry in &self.0 {
let val = entry.expr.v.eval(ctx).await;
@ -76,7 +76,7 @@ impl LitDict {
if let Some(key) = &entry.key {
dict.insert(&key.v, SpannedEntry::new(key.span, spanned));
} else {
dict.push(SpannedEntry::val(spanned));
dict.push(SpannedEntry::value(spanned));
}
}

2
src/syntax/ast/mod.rs
View File

@ -7,3 +7,5 @@ mod tree;
pub use expr::*;
pub use lit::*;
pub use tree::*;
use super::*;

2
src/syntax/ast/tree.rs
View File

@ -1,6 +1,6 @@
//! The syntax tree.
use crate::syntax::{Expr, Ident, SpanVec, Spanned};
use super::*;
/// A collection of nodes which form a tree together with the nodes' children.
pub type SynTree = SpanVec<SynNode>;