caisin/typst
1
0
Fork 0
mirror of https://github.com/typst/typst synced 2025-05-13 20:46:23 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fatal errors

Browse Source 
- Makes errors fatal, so that a phase is only reached when all previous phases were error-free
- Parsing still recovers and can produce multiple errors
- Evaluation fails fast and can thus produce only a single error (except for parse errors due to an import)
- The single error that could occur during execution is removed for now
- Removes Value::Error variant
This commit is contained in:
Laurenz 2021-07-30 18:04:08 +02:00
parent 42a27b48df
commit 1ee1d078e2
84 changed files with 1316 additions and 1473 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
bench/src/clock.rs
View File

@ -4,7 +4,6 @@ use std::rc::Rc;
use criterion::{criterion_group, criterion_main, Criterion};
use typst::diag::Pass;
use typst::eval::{eval, Module};
use typst::exec::exec;
use typst::export::pdf;
@ -25,9 +24,9 @@ fn benchmarks(c: &mut Criterion) {
for case in CASES {
let path = Path::new(TYP_DIR).join(case);
let name = path.file_stem().unwrap().to_string_lossy();
let src_id = loader.resolve(&path).unwrap();
let file = loader.resolve(&path).unwrap();
let src = std::fs::read_to_string(&path).unwrap();
let case = Case::new(src_id, src, ctx.clone());
let case = Case::new(file, src, ctx.clone());
macro_rules! bench {
($step:literal, setup = |$ctx:ident| $setup:expr, code = $code:expr $(,)?) => {
@ -80,7 +79,7 @@ fn benchmarks(c: &mut Criterion) {
/// A test case with prepared intermediate results.
struct Case {
ctx: Rc<RefCell<Context>>,
src_id: FileId,
file: FileId,
src: String,
ast: Rc<SyntaxTree>,
module: Module,
@ -89,16 +88,16 @@ struct Case {
}
impl Case {
fn new(src_id: FileId, src: String, ctx: Rc<RefCell<Context>>) -> Self {
fn new(file: FileId, src: String, ctx: Rc<RefCell<Context>>) -> Self {
let mut borrowed = ctx.borrow_mut();
let ast = Rc::new(parse(&src).output);
let module = eval(&mut borrowed, src_id, Rc::clone(&ast)).output;
let tree = exec(&mut borrowed, &module.template).output;
let ast = Rc::new(parse(file, &src).unwrap());
let module = eval(&mut borrowed, file, Rc::clone(&ast)).unwrap();
let tree = exec(&mut borrowed, &module.template);
let frames = layout(&mut borrowed, &tree);
drop(borrowed);
Self {
ctx,
src_id,
file,
src,
ast,
module,
@ -108,18 +107,14 @@ impl Case {
}
fn parse(&self) -> SyntaxTree {
parse(&self.src).output
parse(self.file, &self.src).unwrap()
}
fn eval(&self) -> Pass<Module> {
eval(
&mut self.ctx.borrow_mut(),
self.src_id,
Rc::clone(&self.ast),
)
fn eval(&self) -> Module {
eval(&mut self.ctx.borrow_mut(), self.file, Rc::clone(&self.ast)).unwrap()
}
fn exec(&self) -> Pass<LayoutTree> {
fn exec(&self) -> LayoutTree {
exec(&mut self.ctx.borrow_mut(), &self.module.template)
}
@ -127,8 +122,8 @@ impl Case {
layout(&mut self.ctx.borrow_mut(), &self.tree)
}
fn typeset(&self) -> Pass<Vec<Rc<Frame>>> {
self.ctx.borrow_mut().typeset(self.src_id, &self.src)
fn typeset(&self) -> Vec<Rc<Frame>> {
self.ctx.borrow_mut().typeset(self.file, &self.src).unwrap()
}
fn pdf(&self) -> Vec<u8> {

7
bench/src/parsing.rs
View File

@ -1,6 +1,7 @@
use iai::{black_box, main};
use typst::diag::Pass;
use typst::diag::TypResult;
use typst::loading::FileId;
use typst::parse::{parse, Scanner, TokenMode, Tokens};
use typst::syntax::SyntaxTree;
@ -30,8 +31,8 @@ fn bench_tokenize() -> usize {
Tokens::new(black_box(SRC), black_box(TokenMode::Markup)).count()
}
fn bench_parse() -> Pass<SyntaxTree> {
parse(black_box(SRC))
fn bench_parse() -> TypResult<SyntaxTree> {
parse(FileId::from_raw(0), black_box(SRC))
}
main!(bench_decode, bench_scan, bench_tokenize, bench_parse);

135
src/diag.rs
View File

@ -1,113 +1,70 @@
//! Diagnostics for source code.
//!
//! Errors are never fatal, the document will always compile and yield a layout.
use std::collections::BTreeSet;
use std::fmt::{self, Display, Formatter};
//! Diagnostics.
use serde::{Deserialize, Serialize};
use crate::loading::FileId;
use crate::syntax::Span;
/// The result of some pass: Some output `T` and diagnostics.
#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub struct Pass<T> {
/// The output of this compilation pass.
pub output: T,
/// User diagnostics accumulated in this pass.
pub diags: DiagSet,
}
/// The result type for typesetting and all its subpasses.
pub type TypResult<T> = Result<T, Box<Vec<Error>>>;
impl<T> Pass<T> {
/// Create a new pass from output and diagnostics.
pub fn new(output: T, diags: DiagSet) -> Self {
Self { output, diags }
}
}
/// A result type with a string error message.
pub type StrResult<T> = Result<T, String>;
/// A set of diagnostics.
///
/// Since this is a [`BTreeSet`], there cannot be two equal (up to span)
/// diagnostics and you can quickly iterate diagnostics in source location
/// order.
pub type DiagSet = BTreeSet<Diag>;
/// A diagnostic with severity level and message.
/// An error in a source file.
#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)]
pub struct Diag {
/// The source code location.
pub struct Error {
/// The file that contains the error.
pub file: FileId,
/// The erronous location in the source code.
pub span: Span,
/// How severe / important the diagnostic is.
pub level: Level,
/// A message describing the diagnostic.
/// A diagnostic message describing the problem.
pub message: String,
}
impl Diag {
/// Create a new diagnostic from message and level.
pub fn new(span: impl Into<Span>, level: Level, message: impl Into<String>) -> Self {
impl Error {
/// Create a new, bare error.
pub fn new(file: FileId, span: impl Into<Span>, message: impl Into<String>) -> Self {
Self {
file,
span: span.into(),
level,
message: message.into(),
}
}
}
impl Display for Diag {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
write!(f, "{}: {}", self.level, self.message)
/// Create a boxed vector containing one error. The return value is suitable
/// as the `Err` variant of a [`TypResult`].
pub fn boxed(
file: FileId,
span: impl Into<Span>,
message: impl Into<String>,
) -> Box<Vec<Self>> {
Box::new(vec![Self::new(file, span, message)])
}
/// Partially build a vec-boxed error, returning a function that just needs
/// the message.
///
/// This is useful in to convert from [`StrResult`] to a [`TypResult`] using
/// [`map_err`](Result::map_err).
pub fn partial(
file: FileId,
span: impl Into<Span>,
) -> impl FnOnce(String) -> Box<Vec<Self>> {
move |message| Self::boxed(file, span, message)
}
}
/// How severe / important a diagnostic is.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum Level {
Warning,
Error,
}
impl Display for Level {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
f.pad(match self {
Self::Warning => "warning",
Self::Error => "error",
})
}
}
/// Construct a diagnostic with [`Error`](Level::Error) level.
///
/// ```
/// # use typst::error;
/// # use typst::syntax::Span;
/// # let span = Span::ZERO;
/// # let thing = "";
/// let error = error!(span, "there is an error with {}", thing);
/// ```
/// Early-return with a vec-boxed [`Error`].
#[macro_export]
macro_rules! error {
($span:expr, $($tts:tt)*) => {
$crate::diag::Diag::new(
$span,
$crate::diag::Level::Error,
format!($($tts)*),
)
};
}
/// Construct a diagnostic with [`Warning`](Level::Warning) level.
///
/// This works exactly like [`error!`].
#[macro_export]
macro_rules! warning {
($span:expr, $($tts:tt)*) => {
$crate::diag::Diag::new(
$span,
$crate::diag::Level::Warning,
format!($($tts)*),
)
macro_rules! bail {
($file:expr, $span:expr, $message:expr $(,)?) => {
return Err(Box::new(vec![$crate::diag::Error::new(
$file, $span, $message,
)]));
};
($file:expr, $span:expr, $fmt:expr, $($arg:expr),+ $(,)?) => {
$crate::bail!($file, $span, format!($fmt, $($arg),+));
};
}

65
src/eval/function.rs
View File

@ -3,8 +3,10 @@ use std::ops::Deref;
use std::rc::Rc;
use super::{Cast, EvalContext, Value};
use crate::util::EcoString;
use crate::diag::{Error, TypResult};
use crate::loading::FileId;
use crate::syntax::{Span, Spanned};
use crate::util::EcoString;
/// An evaluatable function.
#[derive(Clone)]
@ -16,13 +18,13 @@ struct Repr<T: ?Sized> {
func: T,
}
type Func = dyn Fn(&mut EvalContext, &mut FuncArgs) -> Value;
type Func = dyn Fn(&mut EvalContext, &mut FuncArgs) -> TypResult<Value>;
impl Function {
/// Create a new function from a rust closure.
pub fn new<F>(name: Option<EcoString>, func: F) -> Self
where
F: Fn(&mut EvalContext, &mut FuncArgs) -> Value + 'static,
F: Fn(&mut EvalContext, &mut FuncArgs) -> TypResult<Value> + 'static,
{
Self(Rc::new(Repr { name, func }))
}
@ -57,6 +59,8 @@ impl PartialEq for Function {
/// Evaluated arguments to a function.
#[derive(Debug, Clone, PartialEq)]
pub struct FuncArgs {
/// The file in which the function was called.
pub file: FileId,
/// The span of the whole argument list.
pub span: Span,
/// The positional arguments.
@ -80,32 +84,30 @@ impl FuncArgs {
where
T: Cast<Spanned<Value>>,
{
(0 .. self.items.len()).find_map(|index| {
let slot = self.items.get_mut(index)?;
for (i, slot) in self.items.iter().enumerate() {
if slot.name.is_none() {
if T::is(&slot.value) {
let value = self.items.remove(index).value;
let value = self.items.remove(i).value;
return T::cast(value).ok();
}
}
None
})
}
None
}
/// Find and consume the first castable positional argument, producing a
/// Find and consume the first castable positional argument, returning a
/// `missing argument: {what}` error if no match was found.
pub fn expect<T>(&mut self, ctx: &mut EvalContext, what: &str) -> Option<T>
pub fn expect<T>(&mut self, what: &str) -> TypResult<T>
where
T: Cast<Spanned<Value>>,
{
let found = self.eat();
if found.is_none() {
ctx.diag(error!(self.span, "missing argument: {}", what));
match self.eat() {
Some(found) => Ok(found),
None => bail!(self.file, self.span, "missing argument: {}", what),
}
found
}
/// Find, consume and collect all castable positional arguments.
/// Find and consume all castable positional arguments.
pub fn all<T>(&mut self) -> impl Iterator<Item = T> + '_
where
T: Cast<Spanned<Value>>,
@ -113,35 +115,34 @@ impl FuncArgs {
std::iter::from_fn(move || self.eat())
}
/// Cast and remove the value for the given named argument, producing an
/// Cast and remove the value for the given named argument, returning an
/// error if the conversion fails.
pub fn named<T>(&mut self, ctx: &mut EvalContext, name: &str) -> Option<T>
pub fn named<T>(&mut self, name: &str) -> TypResult<Option<T>>
where
T: Cast<Spanned<Value>>,
{
let index = self
let index = match self
.items
.iter()
.position(|arg| arg.name.as_ref().map_or(false, |other| other == name))?;
.filter_map(|arg| arg.name.as_deref())
.position(|other| name == other)
{
Some(index) => index,
None => return Ok(None),
};
let value = self.items.remove(index).value;
let span = value.span;
match T::cast(value) {
Ok(t) => Some(t),
Err(msg) => {
ctx.diag(error!(span, "{}", msg));
None
}
}
T::cast(value).map(Some).map_err(Error::partial(self.file, span))
}
/// Produce "unexpected argument" errors for all remaining arguments.
pub fn finish(self, ctx: &mut EvalContext) {
for arg in &self.items {
if arg.value.v != Value::Error {
ctx.diag(error!(arg.span, "unexpected argument"));
}
/// Return an "unexpected argument" error if there is any remaining
/// argument.
pub fn finish(self) -> TypResult<()> {
if let Some(arg) = self.items.first() {
bail!(self.file, arg.span, "unexpected argument");
}
Ok(())
}
}

589
src/eval/mod.rs
View File

@ -25,22 +25,21 @@ use std::mem;
use std::path::Path;
use std::rc::Rc;
use crate::diag::{Diag, DiagSet, Pass};
use crate::util::EcoString;
use crate::diag::{Error, StrResult, TypResult};
use crate::geom::{Angle, Fractional, Length, Relative};
use crate::image::ImageCache;
use crate::loading::{FileId, Loader};
use crate::parse::parse;
use crate::syntax::visit::Visit;
use crate::syntax::*;
use crate::util::EcoString;
use crate::Context;
/// Evaluate a parsed source file into a module.
pub fn eval(ctx: &mut Context, file: FileId, ast: Rc<SyntaxTree>) -> Pass<Module> {
pub fn eval(ctx: &mut Context, file: FileId, ast: Rc<SyntaxTree>) -> TypResult<Module> {
let mut ctx = EvalContext::new(ctx, file);
let template = ast.eval(&mut ctx);
let module = Module { scope: ctx.scopes.top, template };
Pass::new(module, ctx.diags)
let template = ast.eval(&mut ctx)?;
Ok(Module { scope: ctx.scopes.top, template })
}
/// Caches evaluated modules.
@ -61,7 +60,7 @@ pub trait Eval {
type Output;
/// Evaluate the expression to the output value.
fn eval(&self, ctx: &mut EvalContext) -> Self::Output;
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output>;
}
/// The context for evaluation.
@ -74,10 +73,12 @@ pub struct EvalContext<'a> {
pub modules: &'a mut ModuleCache,
/// The active scopes.
pub scopes: Scopes<'a>,
/// Evaluation diagnostics.
pub diags: DiagSet,
/// The currently evaluated file.
pub file: FileId,
/// The stack of imported files that led to evaluation of the current file.
pub route: Vec<FileId>,
/// The expression map for the currently built template.
pub map: ExprMap,
}
impl<'a> EvalContext<'a> {
@ -88,141 +89,123 @@ impl<'a> EvalContext<'a> {
images: &mut ctx.images,
modules: &mut ctx.modules,
scopes: Scopes::new(Some(&ctx.std)),
diags: DiagSet::new(),
route: vec![file],
file,
route: vec![],
map: ExprMap::new(),
}
}
/// Resolve a path relative to the current file.
///
/// Generates an error if the file is not found.
pub fn resolve(&mut self, path: &str, span: Span) -> Option<FileId> {
let base = *self.route.last()?;
self.loader.resolve_from(base, Path::new(path)).ok().or_else(|| {
self.diag(error!(span, "file not found"));
None
})
/// Returns an error if the file is not found.
pub fn resolve(&mut self, path: &str, span: Span) -> TypResult<FileId> {
self.loader
.resolve_from(self.file, Path::new(path))
.map_err(|_| Error::boxed(self.file, span, "file not found"))
}
/// Process an import of a module relative to the current location.
pub fn import(&mut self, path: &str, span: Span) -> Option<FileId> {
pub fn import(&mut self, path: &str, span: Span) -> TypResult<FileId> {
let id = self.resolve(path, span)?;
// Prevent cyclic importing.
if self.route.contains(&id) {
self.diag(error!(span, "cyclic import"));
return None;
if self.file == id || self.route.contains(&id) {
bail!(self.file, span, "cyclic import");
}
// Check whether the module was already loaded.
if self.modules.get(&id).is_some() {
return Some(id);
return Ok(id);
}
let buffer = self.loader.load_file(id).ok().or_else(|| {
self.diag(error!(span, "failed to load file"));
None
})?;
// Load the source file.
let buffer = self
.loader
.load_file(id)
.map_err(|_| Error::boxed(self.file, span, "failed to load file"))?;
let string = std::str::from_utf8(&buffer).ok().or_else(|| {
self.diag(error!(span, "file is not valid utf-8"));
None
})?;
// Decode UTF-8.
let string = std::str::from_utf8(&buffer)
.map_err(|_| Error::boxed(self.file, span, "file is not valid utf-8"))?;
// Parse the file.
let parsed = parse(string);
let ast = parse(id, string)?;
// Prepare the new context.
let new_scopes = Scopes::new(self.scopes.base);
let old_scopes = mem::replace(&mut self.scopes, new_scopes);
let old_diags = mem::replace(&mut self.diags, parsed.diags);
self.route.push(id);
self.route.push(self.file);
self.file = id;
// Evaluate the module.
let ast = Rc::new(parsed.output);
let template = ast.eval(self);
let template = Rc::new(ast).eval(self)?;
// Restore the old context.
let new_scopes = mem::replace(&mut self.scopes, old_scopes);
let new_diags = mem::replace(&mut self.diags, old_diags);
self.route.pop();
// Put all diagnostics from the module on the import.
for mut diag in new_diags {
diag.span = span;
self.diag(diag);
}
self.file = self.route.pop().unwrap();
// Save the evaluated module.
let module = Module { scope: new_scopes.top, template };
self.modules.insert(id, module);
Some(id)
}
/// Add a diagnostic.
pub fn diag(&mut self, diag: Diag) {
self.diags.insert(diag);
}
/// Cast a value to a type and diagnose a possible error / warning.
pub fn cast<T>(&mut self, value: Value, span: Span) -> Option<T>
where
T: Cast<Value>,
{
if value == Value::Error {
return None;
}
match T::cast(value) {
Ok(value) => Some(value),
Err(msg) => {
self.diag(error!(span, "{}", msg));
None
}
}
}
/// Join with another value.
pub fn join(&mut self, lhs: Value, rhs: Value, span: Span) -> Value {
let (a, b) = (lhs.type_name(), rhs.type_name());
match ops::join(lhs, rhs) {
Ok(joined) => joined,
Err(prev) => {
self.diag(error!(span, "cannot join {} with {}", a, b));
prev
}
}
Ok(id)
}
}
impl Eval for Rc<SyntaxTree> {
type Output = Template;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
struct ExprVisitor<'a, 'b> {
ctx: &'a mut EvalContext<'b>,
map: ExprMap,
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
trait Walk {
fn walk(&self, ctx: &mut EvalContext) -> TypResult<()>;
}
impl<'ast> Visit<'ast> for ExprVisitor<'_, '_> {
fn visit_expr(&mut self, node: &'ast Expr) {
self.map.insert(node as *const _, node.eval(self.ctx));
impl Walk for SyntaxTree {
fn walk(&self, ctx: &mut EvalContext) -> TypResult<()> {
for node in self.iter() {
node.walk(ctx)?;
}
Ok(())
}
}
let mut visitor = ExprVisitor { ctx, map: ExprMap::new() };
visitor.visit_tree(self);
impl Walk for SyntaxNode {
fn walk(&self, ctx: &mut EvalContext) -> TypResult<()> {
match self {
Self::Text(_) => {}
Self::Space => {}
Self::Linebreak(_) => {}
Self::Parbreak(_) => {}
Self::Strong(_) => {}
Self::Emph(_) => {}
Self::Raw(_) => {}
Self::Heading(n) => n.body.walk(ctx)?,
Self::List(n) => n.body.walk(ctx)?,
Self::Enum(n) => n.body.walk(ctx)?,
Self::Expr(n) => {
let value = n.eval(ctx)?;
ctx.map.insert(n as *const _, value);
}
}
Ok(())
}
}
TemplateTree { tree: Rc::clone(self), map: visitor.map }.into()
let map = {
let prev = mem::take(&mut ctx.map);
self.walk(ctx)?;
mem::replace(&mut ctx.map, prev)
};
Ok(TemplateTree { tree: Rc::clone(self), map }.into())
}
}
impl Eval for Expr {
type Output = Value;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
match *self {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
Ok(match *self {
Self::None(_) => Value::None,
Self::Auto(_) => Value::Auto,
Self::Bool(_, v) => Value::Bool(v),
@ -235,35 +218,32 @@ impl Eval for Expr {
Self::Str(_, ref v) => Value::Str(v.clone()),
Self::Ident(ref v) => match ctx.scopes.get(&v) {
Some(slot) => slot.borrow().clone(),
None => {
ctx.diag(error!(v.span, "unknown variable"));
Value::Error
}
None => bail!(ctx.file, v.span, "unknown variable"),
},
Self::Array(ref v) => Value::Array(v.eval(ctx)),
Self::Dict(ref v) => Value::Dict(v.eval(ctx)),
Self::Template(ref v) => Value::Template(v.eval(ctx)),
Self::Group(ref v) => v.eval(ctx),
Self::Block(ref v) => v.eval(ctx),
Self::Call(ref v) => v.eval(ctx),
Self::Closure(ref v) => v.eval(ctx),
Self::With(ref v) => v.eval(ctx),
Self::Unary(ref v) => v.eval(ctx),
Self::Binary(ref v) => v.eval(ctx),
Self::Let(ref v) => v.eval(ctx),
Self::If(ref v) => v.eval(ctx),
Self::While(ref v) => v.eval(ctx),
Self::For(ref v) => v.eval(ctx),
Self::Import(ref v) => v.eval(ctx),
Self::Include(ref v) => v.eval(ctx),
}
Self::Array(ref v) => Value::Array(v.eval(ctx)?),
Self::Dict(ref v) => Value::Dict(v.eval(ctx)?),
Self::Template(ref v) => Value::Template(v.eval(ctx)?),
Self::Group(ref v) => v.eval(ctx)?,
Self::Block(ref v) => v.eval(ctx)?,
Self::Call(ref v) => v.eval(ctx)?,
Self::Closure(ref v) => v.eval(ctx)?,
Self::With(ref v) => v.eval(ctx)?,
Self::Unary(ref v) => v.eval(ctx)?,
Self::Binary(ref v) => v.eval(ctx)?,
Self::Let(ref v) => v.eval(ctx)?,
Self::If(ref v) => v.eval(ctx)?,
Self::While(ref v) => v.eval(ctx)?,
Self::For(ref v) => v.eval(ctx)?,
Self::Import(ref v) => v.eval(ctx)?,
Self::Include(ref v) => v.eval(ctx)?,
})
}
}
impl Eval for ArrayExpr {
type Output = Array;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
self.items.iter().map(|expr| expr.eval(ctx)).collect()
}
}
@ -271,10 +251,10 @@ impl Eval for ArrayExpr {
impl Eval for DictExpr {
type Output = Dict;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
self.items
.iter()
.map(|Named { name, expr }| (name.string.clone(), expr.eval(ctx)))
.map(|Named { name, expr }| Ok((name.string.clone(), expr.eval(ctx)?)))
.collect()
}
}
@ -282,7 +262,7 @@ impl Eval for DictExpr {
impl Eval for TemplateExpr {
type Output = Template;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
self.tree.eval(ctx)
}
}
@ -290,7 +270,7 @@ impl Eval for TemplateExpr {
impl Eval for GroupExpr {
type Output = Value;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
self.expr.eval(ctx)
}
}
@ -298,58 +278,44 @@ impl Eval for GroupExpr {
impl Eval for BlockExpr {
type Output = Value;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
if self.scoping {
ctx.scopes.enter();
}
let mut output = Value::None;
for expr in &self.exprs {
let value = expr.eval(ctx);
output = ctx.join(output, value, expr.span());
let value = expr.eval(ctx)?;
output = ops::join(output, value)
.map_err(Error::partial(ctx.file, expr.span()))?;
}
if self.scoping {
ctx.scopes.exit();
}
output
Ok(output)
}
}
impl Eval for UnaryExpr {
type Output = Value;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
let value = self.expr.eval(ctx);
if value == Value::Error {
return Value::Error;
}
let ty = value.type_name();
let out = match self.op {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
let value = self.expr.eval(ctx)?;
let result = match self.op {
UnOp::Pos => ops::pos(value),
UnOp::Neg => ops::neg(value),
UnOp::Not => ops::not(value),
};
if out == Value::Error {
ctx.diag(error!(
self.span,
"cannot apply '{}' to {}",
self.op.as_str(),
ty,
));
}
out
result.map_err(Error::partial(ctx.file, self.span))
}
}
impl Eval for BinaryExpr {
type Output = Value;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
match self.op {
BinOp::Add => self.apply(ctx, ops::add),
BinOp::Sub => self.apply(ctx, ops::sub),
@ -363,7 +329,7 @@ impl Eval for BinaryExpr {
BinOp::Leq => self.apply(ctx, ops::leq),
BinOp::Gt => self.apply(ctx, ops::gt),
BinOp::Geq => self.apply(ctx, ops::geq),
BinOp::Assign => self.assign(ctx, |_, b| b),
BinOp::Assign => self.assign(ctx, |_, b| Ok(b)),
BinOp::AddAssign => self.assign(ctx, ops::add),
BinOp::SubAssign => self.assign(ctx, ops::sub),
BinOp::MulAssign => self.assign(ctx, ops::mul),
@ -375,131 +341,110 @@ impl Eval for BinaryExpr {
impl BinaryExpr {
/// Apply a basic binary operation.
fn apply<F>(&self, ctx: &mut EvalContext, op: F) -> Value
fn apply<F>(&self, ctx: &mut EvalContext, op: F) -> TypResult<Value>
where
F: FnOnce(Value, Value) -> Value,
F: FnOnce(Value, Value) -> StrResult<Value>,
{
let lhs = self.lhs.eval(ctx)?;
// Short-circuit boolean operations.
let lhs = self.lhs.eval(ctx);
match (self.op, &lhs) {
(BinOp::And, Value::Bool(false)) => return lhs,
(BinOp::Or, Value::Bool(true)) => return lhs,
_ => {}
if (self.op == BinOp::And && lhs == Value::Bool(false))
|| (self.op == BinOp::Or && lhs == Value::Bool(true))
{
return Ok(lhs);
}
let rhs = self.rhs.eval(ctx);
if lhs == Value::Error || rhs == Value::Error {
return Value::Error;
}
// Save type names before we consume the values in case of error.
let types = (lhs.type_name(), rhs.type_name());
let out = op(lhs, rhs);
if out == Value::Error {
self.error(ctx, types);
}
out
let rhs = self.rhs.eval(ctx)?;
op(lhs, rhs).map_err(Error::partial(ctx.file, self.span))
}
/// Apply an assignment operation.
fn assign<F>(&self, ctx: &mut EvalContext, op: F) -> Value
fn assign<F>(&self, ctx: &mut EvalContext, op: F) -> TypResult<Value>
where
F: FnOnce(Value, Value) -> Value,
F: FnOnce(Value, Value) -> StrResult<Value>,
{
let lspan = self.lhs.span();
let slot = if let Expr::Ident(id) = self.lhs.as_ref() {
match ctx.scopes.get(id) {
Some(slot) => Rc::clone(slot),
None => {
ctx.diag(error!(self.lhs.span(), "unknown variable"));
return Value::Error;
}
None => bail!(ctx.file, lspan, "unknown variable"),
}
} else {
ctx.diag(error!(self.lhs.span(), "cannot assign to this expression"));
return Value::Error;
bail!(ctx.file, lspan, "cannot assign to this expression",);
};
let rhs = self.rhs.eval(ctx);
let rhs = self.rhs.eval(ctx)?;
let mut mutable = match slot.try_borrow_mut() {
Ok(mutable) => mutable,
Err(_) => {
ctx.diag(error!(self.lhs.span(), "cannot assign to a constant"));
return Value::Error;
bail!(ctx.file, lspan, "cannot assign to a constant",);
}
};
let lhs = mem::take(&mut *mutable);
let types = (lhs.type_name(), rhs.type_name());
*mutable = op(lhs, rhs);
*mutable = op(lhs, rhs).map_err(Error::partial(ctx.file, self.span))?;
if *mutable == Value::Error {
self.error(ctx, types);
return Value::Error;
}
Value::None
}
fn error(&self, ctx: &mut EvalContext, (a, b): (&str, &str)) {
ctx.diag(error!(self.span, "{}", match self.op {
BinOp::Add => format!("cannot add {} and {}", a, b),
BinOp::Sub => format!("cannot subtract {1} from {0}", a, b),
BinOp::Mul => format!("cannot multiply {} with {}", a, b),
BinOp::Div => format!("cannot divide {} by {}", a, b),
_ => format!("cannot apply '{}' to {} and {}", self.op.as_str(), a, b),
}));
Ok(Value::None)
}
}
impl Eval for CallExpr {
type Output = Value;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
let callee = self.callee.eval(ctx);
if let Some(func) = ctx.cast::<Function>(callee, self.callee.span()) {
let mut args = self.args.eval(ctx);
let returned = func(ctx, &mut args);
args.finish(ctx);
returned
} else {
Value::Error
}
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
let callee = self
.callee
.eval(ctx)?
.cast::<Function>()
.map_err(Error::partial(ctx.file, self.callee.span()))?;
let mut args = self.args.eval(ctx)?;
let returned = callee(ctx, &mut args)?;
args.finish()?;
Ok(returned)
}
}
impl Eval for CallArgs {
type Output = FuncArgs;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
let items = self.items.iter().map(|arg| arg.eval(ctx)).collect();
FuncArgs { span: self.span, items }
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
Ok(FuncArgs {
file: ctx.file,
span: self.span,
items: self
.items
.iter()
.map(|arg| arg.eval(ctx))
.collect::<TypResult<Vec<_>>>()?,
})
}
}
impl Eval for CallArg {
type Output = FuncArg;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
match self {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
Ok(match self {
Self::Pos(expr) => FuncArg {
span: self.span(),
name: None,
value: Spanned::new(expr.eval(ctx), expr.span()),
value: Spanned::new(expr.eval(ctx)?, expr.span()),
},
Self::Named(Named { name, expr }) => FuncArg {
span: self.span(),
name: Some(name.string.clone()),
value: Spanned::new(expr.eval(ctx), expr.span()),
value: Spanned::new(expr.eval(ctx)?, expr.span()),
},
}
})
}
}
impl Eval for ClosureExpr {
type Output = Value;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
let params = Rc::clone(&self.params);
let body = Rc::clone(&self.body);
@ -511,86 +456,92 @@ impl Eval for ClosureExpr {
};
let name = self.name.as_ref().map(|name| name.string.clone());
Value::Func(Function::new(name, move |ctx, args| {
let func = Function::new(name, move |ctx, args| {
// Don't leak the scopes from the call site. Instead, we use the
// scope of captured variables we collected earlier.
let prev = mem::take(&mut ctx.scopes);
ctx.scopes.top = captured.clone();
for param in params.iter() {
// Set the parameter to `none` if the argument is missing.
let value = args.expect::<Value>(ctx, param.as_str()).unwrap_or_default();
let value = args.expect::<Value>(param.as_str())?;
ctx.scopes.def_mut(param.as_str(), value);
}
let value = body.eval(ctx);
let result = body.eval(ctx);
ctx.scopes = prev;
value
}))
result
});
Ok(Value::Func(func))
}
}
impl Eval for WithExpr {
type Output = Value;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
let callee = self.callee.eval(ctx);
if let Some(func) = ctx.cast::<Function>(callee, self.callee.span()) {
let applied = self.args.eval(ctx);
let name = func.name().cloned();
Value::Func(Function::new(name, move |ctx, args| {
// Remove named arguments that were overridden.
let kept: Vec<_> = applied
.items
.iter()
.filter(|arg| {
arg.name.is_none()
|| args.items.iter().all(|other| arg.name != other.name)
})
.cloned()
.collect();
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
let callee = self
.callee
.eval(ctx)?
.cast::<Function>()
.map_err(Error::partial(ctx.file, self.callee.span()))?;
// Preprend the applied arguments so that the positional arguments
// are in the right order.
args.items.splice(.. 0, kept);
let applied = self.args.eval(ctx)?;
// Call the original function.
func(ctx, args)
}))
} else {
Value::Error
}
let name = callee.name().cloned();
let func = Function::new(name, move |ctx, args| {
// Remove named arguments that were overridden.
let kept: Vec<_> = applied
.items
.iter()
.filter(|arg| {
arg.name.is_none()
|| args.items.iter().all(|other| arg.name != other.name)
})
.cloned()
.collect();
// Preprend the applied arguments so that the positional arguments
// are in the right order.
args.items.splice(.. 0, kept);
// Call the original function.
callee(ctx, args)
});
Ok(Value::Func(func))
}
}
impl Eval for LetExpr {
type Output = Value;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
let value = match &self.init {
Some(expr) => expr.eval(ctx),
Some(expr) => expr.eval(ctx)?,
None => Value::None,
};
ctx.scopes.def_mut(self.binding.as_str(), value);
Value::None
Ok(Value::None)
}
}
impl Eval for IfExpr {
type Output = Value;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
let condition = self.condition.eval(ctx);
if let Some(condition) = ctx.cast(condition, self.condition.span()) {
if condition {
self.if_body.eval(ctx)
} else if let Some(else_body) = &self.else_body {
else_body.eval(ctx)
} else {
Value::None
}
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
let condition = self
.condition
.eval(ctx)?
.cast::<bool>()
.map_err(Error::partial(ctx.file, self.condition.span()))?;
if condition {
self.if_body.eval(ctx)
} else if let Some(else_body) = &self.else_body {
else_body.eval(ctx)
} else {
Value::Error
Ok(Value::None)
}
}
}
@ -598,28 +549,28 @@ impl Eval for IfExpr {
impl Eval for WhileExpr {
type Output = Value;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
let mut output = Value::None;
loop {
let condition = self.condition.eval(ctx);
if let Some(condition) = ctx.cast(condition, self.condition.span()) {
if condition {
let value = self.body.eval(ctx);
output = ctx.join(output, value, self.body.span());
} else {
return output;
}
} else {
return Value::Error;
}
while self
.condition
.eval(ctx)?
.cast::<bool>()
.map_err(Error::partial(ctx.file, self.condition.span()))?
{
let value = self.body.eval(ctx)?;
output = ops::join(output, value)
.map_err(Error::partial(ctx.file, self.body.span()))?;
}
Ok(output)
}
}
impl Eval for ForExpr {
type Output = Value;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
macro_rules! iter {
(for ($($binding:ident => $value:ident),*) in $iter:expr) => {{
let mut output = Value::None;
@ -629,17 +580,18 @@ impl Eval for ForExpr {
for ($($value),*) in $iter {
$(ctx.scopes.def_mut($binding.as_str(), $value);)*
let value = self.body.eval(ctx);
output = ctx.join(output, value, self.body.span());
let value = self.body.eval(ctx)?;
output = ops::join(output, value)
.map_err(Error::partial(ctx.file, self.body.span()))?;
}
ctx.scopes.exit();
output
Ok(output)
}};
}
let iter = self.iter.eval(ctx);
match (self.pattern.clone(), iter) {
let iter = self.iter.eval(ctx)?;
match (&self.pattern, iter) {
(ForPattern::Value(v), Value::Str(string)) => {
iter!(for (v => value) in string.chars().map(|c| Value::Str(c.into())))
}
@ -655,22 +607,15 @@ impl Eval for ForExpr {
(ForPattern::KeyValue(k, v), Value::Dict(dict)) => {
iter!(for (k => key, v => value) in dict.into_iter())
}
(ForPattern::KeyValue(_, _), Value::Str(_)) => {
ctx.diag(error!(self.pattern.span(), "mismatched pattern"));
Value::Error
}
(_, iter) => {
if iter != Value::Error {
ctx.diag(error!(
self.iter.span(),
"cannot loop over {}",
iter.type_name(),
));
}
Value::Error
bail!(ctx.file, self.pattern.span(), "mismatched pattern");
}
(_, iter) => bail!(
ctx.file,
self.iter.span(),
"cannot loop over {}",
iter.type_name(),
),
}
}
}
@ -678,50 +623,50 @@ impl Eval for ForExpr {
impl Eval for ImportExpr {
type Output = Value;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
let path = self.path.eval(ctx);
if let Some(path) = ctx.cast::<EcoString>(path, self.path.span()) {
if let Some(hash) = ctx.import(&path, self.path.span()) {
let mut module = &ctx.modules[&hash];
match &self.imports {
Imports::Wildcard => {
for (var, slot) in module.scope.iter() {
let value = slot.borrow().clone();
ctx.scopes.def_mut(var, value);
}
}
Imports::Idents(idents) => {
for ident in idents {
if let Some(slot) = module.scope.get(&ident) {
let value = slot.borrow().clone();
ctx.scopes.def_mut(ident.as_str(), value);
} else {
ctx.diag(error!(ident.span, "unresolved import"));
module = &ctx.modules[&hash];
}
}
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
let path = self
.path
.eval(ctx)?
.cast::<EcoString>()
.map_err(Error::partial(ctx.file, self.path.span()))?;
let id = ctx.import(&path, self.path.span())?;
let module = &ctx.modules[&id];
match &self.imports {
Imports::Wildcard => {
for (var, slot) in module.scope.iter() {
ctx.scopes.def_mut(var, slot.borrow().clone());
}
}
Imports::Idents(idents) => {
for ident in idents {
if let Some(slot) = module.scope.get(&ident) {
ctx.scopes.def_mut(ident.as_str(), slot.borrow().clone());
} else {
bail!(ctx.file, ident.span, "unresolved import");
}
}
return Value::None;
}
}
Value::Error
Ok(Value::None)
}
}
impl Eval for IncludeExpr {
type Output = Value;
fn eval(&self, ctx: &mut EvalContext) -> Self::Output {
let path = self.path.eval(ctx);
if let Some(path) = ctx.cast::<EcoString>(path, self.path.span()) {
if let Some(hash) = ctx.import(&path, self.path.span()) {
return Value::Template(ctx.modules[&hash].template.clone());
}
}
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
let path = self
.path
.eval(ctx)?
.cast::<EcoString>()
.map_err(Error::partial(ctx.file, self.path.span()))?;
Value::Error
let id = ctx.import(&path, self.path.span())?;
let module = &ctx.modules[&id];
Ok(Value::Template(module.template.clone()))
}
}

154
src/eval/ops.rs
View File

@ -1,30 +1,34 @@
use std::cmp::Ordering;
use super::Value;
use crate::diag::StrResult;
use Value::*;
/// Bail with a type mismatch error.
macro_rules! mismatch {
($fmt:expr, $($value:expr),* $(,)?) => {
return Err(format!($fmt, $($value.type_name()),*));
};
}
/// Join a value with another value.
pub fn join(lhs: Value, rhs: Value) -> Result<Value, Value> {
pub fn join(lhs: Value, rhs: Value) -> StrResult<Value> {
Ok(match (lhs, rhs) {
(_, Error) => Error,
(Error, _) => Error,
(a, None) => a,
(None, b) => b,
(Str(a), Str(b)) => Str(a + b),
(Array(a), Array(b)) => Array(a + b),
(Dict(a), Dict(b)) => Dict(a + b),
(Template(a), Template(b)) => Template(a + b),
(Template(a), Str(b)) => Template(a + b),
(Str(a), Template(b)) => Template(a + b),
(lhs, _) => return Err(lhs),
(a, b) => mismatch!("cannot join {} with {}", a, b),
})
}
/// Apply the plus operator to a value.
pub fn pos(value: Value) -> Value {
match value {
pub fn pos(value: Value) -> StrResult<Value> {
Ok(match value {
Int(v) => Int(v),
Float(v) => Float(v),
Length(v) => Length(v),
@ -32,13 +36,13 @@ pub fn pos(value: Value) -> Value {
Relative(v) => Relative(v),
Linear(v) => Linear(v),
Fractional(v) => Fractional(v),
_ => Error,
}
v => mismatch!("cannot apply '+' to {}", v),
})
}
/// Compute the negation of a value.
pub fn neg(value: Value) -> Value {
match value {
pub fn neg(value: Value) -> StrResult<Value> {
Ok(match value {
Int(v) => Int(-v),
Float(v) => Float(-v),
Length(v) => Length(-v),
@ -46,13 +50,13 @@ pub fn neg(value: Value) -> Value {
Relative(v) => Relative(-v),
Linear(v) => Linear(-v),
Fractional(v) => Fractional(-v),
_ => Error,
}
v => mismatch!("cannot apply '-' to {}", v),
})
}
/// Compute the sum of two values.
pub fn add(lhs: Value, rhs: Value) -> Value {
match (lhs, rhs) {
pub fn add(lhs: Value, rhs: Value) -> StrResult<Value> {
Ok(match (lhs, rhs) {
(Int(a), Int(b)) => Int(a + b),
(Int(a), Float(b)) => Float(a as f64 + b),
(Float(a), Int(b)) => Float(a + b as f64),
@ -81,13 +85,13 @@ pub fn add(lhs: Value, rhs: Value) -> Value {
(Template(a), Str(b)) => Template(a + b),
(Str(a), Template(b)) => Template(a + b),
_ => Error,
}
(a, b) => mismatch!("cannot add {} and {}", a, b),
})
}
/// Compute the difference of two values.
pub fn sub(lhs: Value, rhs: Value) -> Value {
match (lhs, rhs) {
pub fn sub(lhs: Value, rhs: Value) -> StrResult<Value> {
Ok(match (lhs, rhs) {
(Int(a), Int(b)) => Int(a - b),
(Int(a), Float(b)) => Float(a as f64 - b),
(Float(a), Int(b)) => Float(a - b as f64),
@ -109,13 +113,13 @@ pub fn sub(lhs: Value, rhs: Value) -> Value {
(Fractional(a), Fractional(b)) => Fractional(a - b),
_ => Error,
}
(a, b) => mismatch!("cannot subtract {1} from {0}", a, b),
})
}
/// Compute the product of two values.
pub fn mul(lhs: Value, rhs: Value) -> Value {
match (lhs, rhs) {
pub fn mul(lhs: Value, rhs: Value) -> StrResult<Value> {
Ok(match (lhs, rhs) {
(Int(a), Int(b)) => Int(a * b),
(Int(a), Float(b)) => Float(a as f64 * b),
(Float(a), Int(b)) => Float(a * b as f64),
@ -150,14 +154,16 @@ pub fn mul(lhs: Value, rhs: Value) -> Value {
(Int(a), Str(b)) => Str(b.repeat(a.max(0) as usize)),
(Array(a), Int(b)) => Array(a.repeat(b.max(0) as usize)),
(Int(a), Array(b)) => Array(b.repeat(a.max(0) as usize)),
(Template(a), Int(b)) => Template(a.repeat(b.max(0) as usize)),
(Int(a), Template(b)) => Template(b.repeat(a.max(0) as usize)),
_ => Error,
}
(a, b) => mismatch!("cannot multiply {} with {}", a, b),
})
}
/// Compute the quotient of two values.
pub fn div(lhs: Value, rhs: Value) -> Value {
match (lhs, rhs) {
pub fn div(lhs: Value, rhs: Value) -> StrResult<Value> {
Ok(match (lhs, rhs) {
(Int(a), Int(b)) => Float(a as f64 / b as f64),
(Int(a), Float(b)) => Float(a as f64 / b),
(Float(a), Int(b)) => Float(a / b as f64),
@ -182,31 +188,67 @@ pub fn div(lhs: Value, rhs: Value) -> Value {
(Linear(a), Int(b)) => Linear(a / b as f64),
(Linear(a), Float(b)) => Linear(a / b),
_ => Error,
}
(a, b) => mismatch!("cannot divide {} by {}", a, b),
})
}
/// Compute the logical "not" of a value.
pub fn not(value: Value) -> Value {
pub fn not(value: Value) -> StrResult<Value> {
match value {
Bool(b) => Bool(!b),
_ => Error,
Bool(b) => Ok(Bool(!b)),
v => mismatch!("cannot apply 'not' to {}", v),
}
}
/// Compute the logical "and" of two values.
pub fn and(lhs: Value, rhs: Value) -> Value {
pub fn and(lhs: Value, rhs: Value) -> StrResult<Value> {
match (lhs, rhs) {
(Bool(a), Bool(b)) => Bool(a && b),
_ => Error,
(Bool(a), Bool(b)) => Ok(Bool(a && b)),
(a, b) => mismatch!("cannot apply 'and' to {} and {}", a, b),
}
}
/// Compute the logical "or" of two values.
pub fn or(lhs: Value, rhs: Value) -> Value {
pub fn or(lhs: Value, rhs: Value) -> StrResult<Value> {
match (lhs, rhs) {
(Bool(a), Bool(b)) => Bool(a || b),
_ => Error,
(Bool(a), Bool(b)) => Ok(Bool(a || b)),
(a, b) => mismatch!("cannot apply 'or' to {} and {}", a, b),
}
}
/// Compute whether two values are equal.
pub fn eq(lhs: Value, rhs: Value) -> StrResult<Value> {
Ok(Bool(equal(&lhs, &rhs)))
}
/// Compute whether two values are equal.
pub fn neq(lhs: Value, rhs: Value) -> StrResult<Value> {
Ok(Bool(!equal(&lhs, &rhs)))
}
macro_rules! comparison {
($name:ident, $op:tt, $($pat:tt)*) => {
/// Compute how a value compares with another value.
pub fn $name(lhs: Value, rhs: Value) -> StrResult<Value> {
if let Some(ordering) = compare(&lhs, &rhs) {
Ok(Bool(matches!(ordering, $($pat)*)))
} else {
mismatch!(concat!("cannot apply '", $op, "' to {} and {}"), lhs, rhs);
}
}
};
}
comparison!(lt, "<", Ordering::Less);
comparison!(leq, "<=", Ordering::Less | Ordering::Equal);
comparison!(gt, ">", Ordering::Greater);
comparison!(geq, ">=", Ordering::Greater | Ordering::Equal);
/// Compute the range from `lhs` to `rhs`.
pub fn range(lhs: Value, rhs: Value) -> StrResult<Value> {
match (lhs, rhs) {
(Int(a), Int(b)) => Ok(Array((a ..= b).map(Int).collect())),
(a, b) => mismatch!("cannot apply '..' to {} and {}", a, b),
}
}
@ -231,7 +273,6 @@ pub fn equal(lhs: &Value, rhs: &Value) -> bool {
(Template(a), Template(b)) => a == b,
(Func(a), Func(b)) => a == b,
(Dyn(a), Dyn(b)) => a == b,
(Error, Error) => true,
// Some technically different things should compare equal.
(&Int(a), &Float(b)) => a as f64 == b,
@ -245,16 +286,6 @@ pub fn equal(lhs: &Value, rhs: &Value) -> bool {
}
}
/// Compute whether two values are equal.
pub fn eq(lhs: Value, rhs: Value) -> Value {
Bool(equal(&lhs, &rhs))
}
/// Compute whether two values are equal.
pub fn neq(lhs: Value, rhs: Value) -> Value {
Bool(!equal(&lhs, &rhs))
}
/// Compare two values.
pub fn compare(lhs: &Value, rhs: &Value) -> Option<Ordering> {
match (lhs, rhs) {
@ -269,26 +300,3 @@ pub fn compare(lhs: &Value, rhs: &Value) -> Option<Ordering> {
_ => Option::None,
}
}
macro_rules! comparison {
($name:ident, $($pat:tt)*) => {
/// Compute how a value compares with another value.
pub fn $name(lhs: Value, rhs: Value) -> Value {
compare(&lhs, &rhs)
.map_or(Error, |x| Bool(matches!(x, $($pat)*)))
}
};
}
comparison!(lt, Ordering::Less);
comparison!(leq, Ordering::Less | Ordering::Equal);
comparison!(gt, Ordering::Greater);
comparison!(geq, Ordering::Greater | Ordering::Equal);
/// Compute the range from `lhs` to `rhs`.
pub fn range(lhs: Value, rhs: Value) -> Value {
match (lhs, rhs) {
(Int(a), Int(b)) => Array((a ..= b).map(Int).collect()),
_ => Error,
}
}

6
src/eval/scope.rs
View File

@ -4,7 +4,9 @@ use std::fmt::{self, Debug, Formatter};
use std::iter;
use std::rc::Rc;
use super::{EcoString, EvalContext, FuncArgs, Function, Value};
use super::{EvalContext, FuncArgs, Function, Value};
use crate::diag::TypResult;
use crate::util::EcoString;
/// A slot where a variable is stored.
pub type Slot = Rc<RefCell<Value>>;
@ -89,7 +91,7 @@ impl Scope {
/// Define a constant function.
pub fn def_func<F>(&mut self, name: impl Into<EcoString>, f: F)
where
F: Fn(&mut EvalContext, &mut FuncArgs) -> Value + 'static,
F: Fn(&mut EvalContext, &mut FuncArgs) -> TypResult<Value> + 'static,
{
let name = name.into();
self.def_const(name.clone(), Function::new(Some(name), f));

9
src/eval/template.rs
View File

@ -21,9 +21,16 @@ impl Template {
}
/// Iterate over the contained template nodes.
pub fn iter(&self) -> impl Iterator<Item = &TemplateNode> + '_ {
pub fn iter(&self) -> std::slice::Iter<TemplateNode> {
self.nodes.iter()
}
/// Repeat this template `n` times.
pub fn repeat(&self, n: usize) -> Self {
let len = self.nodes.len().checked_mul(n).expect("capacity overflow");
let nodes = self.iter().cloned().cycle().take(len).collect();
Self { nodes: Rc::new(nodes) }
}
}
impl From<TemplateTree> for Template {

22
src/eval/value.rs
View File

@ -5,10 +5,11 @@ use std::rc::Rc;
use super::{ops, Array, Dict, Function, Template, TemplateFunc};
use crate::color::{Color, RgbaColor};
use crate::util::EcoString;
use crate::diag::StrResult;
use crate::exec::ExecContext;
use crate::geom::{Angle, Fractional, Length, Linear, Relative};
use crate::syntax::Spanned;
use crate::util::EcoString;
/// A computational value.
#[derive(Debug, Clone)]
@ -47,8 +48,6 @@ pub enum Value {
Func(Function),
/// A dynamic value.
Dyn(Dynamic),
/// The result of invalid operations.
Error,
}
impl Value {
@ -80,7 +79,6 @@ impl Value {
Self::Template(_) => Template::TYPE_NAME,
Self::Func(_) => Function::TYPE_NAME,
Self::Dyn(v) => v.type_name(),
Self::Error => "error",
}
}
@ -93,7 +91,7 @@ impl Value {
}
/// Try to cast the value into a specific type.
pub fn cast<T>(self) -> Result<T, String>
pub fn cast<T>(self) -> StrResult<T>
where
T: Cast<Value>,
{
@ -241,7 +239,7 @@ pub trait Cast<V>: Sized {
fn is(value: &V) -> bool;
/// Try to cast the value into an instance of `Self`.
fn cast(value: V) -> Result<Self, String>;
fn cast(value: V) -> StrResult<Self>;
}
impl Cast<Value> for Value {
@ -249,7 +247,7 @@ impl Cast<Value> for Value {
true
}
fn cast(value: Value) -> Result<Self, String> {
fn cast(value: Value) -> StrResult<Self> {
Ok(value)
}
}
@ -262,7 +260,7 @@ where
T::is(&value.v)
}
fn cast(value: Spanned<Value>) -> Result<Self, String> {
fn cast(value: Spanned<Value>) -> StrResult<Self> {
T::cast(value.v)
}
}
@ -275,7 +273,7 @@ where
T::is(&value.v)
}
fn cast(value: Spanned<Value>) -> Result<Self, String> {
fn cast(value: Spanned<Value>) -> StrResult<Self> {
let span = value.span;
T::cast(value.v).map(|t| Spanned::new(t, span))
}
@ -302,7 +300,7 @@ macro_rules! primitive {
matches!(value, Value::$variant(_) $(| Value::$other(_))*)
}
fn cast(value: Value) -> Result<Self, String> {
fn cast(value: Value) -> StrResult<Self> {
match value {
Value::$variant(v) => Ok(v),
$(Value::$other($binding) => Ok($out),)*
@ -358,7 +356,7 @@ macro_rules! castable {
}
}
fn cast(value: $crate::eval::Value) -> Result<Self, String> {
fn cast(value: $crate::eval::Value) -> $crate::diag::StrResult<Self> {
let found = match value {
$($pattern => return Ok($out),)*
$crate::eval::Value::Dyn(dynamic) => {
@ -387,6 +385,6 @@ primitive! { Color: "color", Color }
primitive! { EcoString: "string", Str }
primitive! { Array: "array", Array }
primitive! { Dict: "dictionary", Dict }
primitive! { Template: "template", Template, Str(v) => v.into() }
primitive! { Template: "template", Template }
primitive! { Function: "function", Func }
primitive! { f64: "float", Float, Int(v) => v as f64 }

21
src/exec/context.rs
View File

@ -2,13 +2,12 @@ use std::mem;
use std::rc::Rc;
use super::{Exec, ExecWithMap, State};
use crate::diag::{Diag, DiagSet, Pass};
use crate::eval::{ExprMap, Template};
use crate::geom::{Align, Dir, Gen, GenAxis, Length, Linear, Sides, Size};
use crate::layout::{
LayoutNode, LayoutTree, PadNode, PageRun, ParChild, ParNode, StackChild, StackNode,
};
use crate::syntax::{Span, SyntaxTree};
use crate::syntax::SyntaxTree;
use crate::util::EcoString;
use crate::Context;
@ -16,8 +15,6 @@ use crate::Context;
pub struct ExecContext {
/// The active execution state.
pub state: State,
/// Execution diagnostics.
pub diags: DiagSet,
/// The tree of finished page runs.
tree: LayoutTree,
/// When we are building the top-level stack, this contains metrics of the
@ -32,18 +29,12 @@ impl ExecContext {
pub fn new(ctx: &mut Context) -> Self {
Self {
state: ctx.state.clone(),
diags: DiagSet::new(),
tree: LayoutTree { runs: vec![] },
page: Some(PageBuilder::new(&ctx.state, true)),
stack: StackBuilder::new(&ctx.state),
}
}
/// Add a diagnostic.
pub fn diag(&mut self, diag: Diag) {
self.diags.insert(diag);
}
/// Execute a template and return the result as a stack node.
pub fn exec_template_stack(&mut self, template: &Template) -> StackNode {
self.exec_stack(|ctx| template.exec(ctx))
@ -127,21 +118,19 @@ impl ExecContext {
}
/// Apply a forced page break.
pub fn pagebreak(&mut self, keep: bool, hard: bool, span: Span) {
pub fn pagebreak(&mut self, keep: bool, hard: bool) {
if let Some(builder) = &mut self.page {
let page = mem::replace(builder, PageBuilder::new(&self.state, hard));
let stack = mem::replace(&mut self.stack, StackBuilder::new(&self.state));
self.tree.runs.extend(page.build(stack.build(), keep));
} else {
self.diag(error!(span, "cannot modify page from here"));
}
}
/// Finish execution and return the created layout tree.
pub fn finish(mut self) -> Pass<LayoutTree> {
pub fn finish(mut self) -> LayoutTree {
assert!(self.page.is_some());
self.pagebreak(true, false, Span::default());
Pass::new(self.tree, self.diags)
self.pagebreak(true, false);
self.tree
}
fn make_text_node(&self, text: impl Into<EcoString>) -> ParChild {

4
src/exec/mod.rs
View File

@ -8,7 +8,6 @@ pub use state::*;
use std::fmt::Write;
use crate::diag::Pass;
use crate::eval::{ExprMap, Template, TemplateFunc, TemplateNode, TemplateTree, Value};
use crate::geom::Gen;
use crate::layout::{LayoutTree, StackChild, StackNode};
@ -18,7 +17,7 @@ use crate::util::EcoString;
use crate::Context;
/// Execute a template to produce a layout tree.
pub fn exec(ctx: &mut Context, template: &Template) -> Pass<LayoutTree> {
pub fn exec(ctx: &mut Context, template: &Template) -> LayoutTree {
let mut ctx = ExecContext::new(ctx);
template.exec(&mut ctx);
ctx.finish()
@ -138,7 +137,6 @@ impl Exec for Value {
Value::Float(v) => ctx.push_text(pretty(v)),
Value::Str(v) => ctx.push_text(v),
Value::Template(v) => v.exec(ctx),
Value::Error => {}
// For values which can't be shown "naturally", we print the
// representation in monospace.
other => ctx.push_monospace_text(pretty(other)),

3
src/font.rs
View File

@ -316,7 +316,8 @@ impl FontCache {
}
/// A unique identifier for a loaded font face.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Serialize, Deserialize)]
pub struct FaceId(u64);
impl FaceId {

3
src/image.rs
View File

@ -103,7 +103,8 @@ impl ImageCache {
}
/// A unique identifier for a loaded image.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Serialize, Deserialize)]
pub struct ImageId(u64);
impl ImageId {

30
src/lib.rs
View File

@ -7,9 +7,9 @@
//! module.
//! - **Evaluation:** The next step is to [evaluate] the syntax tree. This
//! computes the value of each node in the document and produces a [module].
//! - **Execution:** Now, we can [execute] the parsed and evaluated module.
//! This produces a [layout tree], a high-level, fully styled representation
//! of the document. The nodes of this tree are self-contained and
//! - **Execution:** Now, we can [execute] the parsed and evaluated module. This
//! results in a [layout tree], a high-level, fully styled representation of
//! the document. The nodes of this tree are self-contained and
//! order-independent and thus much better suited for layouting than the
//! syntax tree.
//! - **Layouting:** Next, the tree is [layouted] into a portable version of the
@ -49,7 +49,7 @@ pub mod util;
use std::rc::Rc;
use crate::diag::Pass;
use crate::diag::TypResult;
use crate::eval::{ModuleCache, Scope};
use crate::exec::State;
use crate::font::FontCache;
@ -100,19 +100,15 @@ impl Context {
/// The `file` identifies the source file and is used to resolve relative
/// paths (for importing and image loading).
///
/// Returns a vector of frames representing individual pages alongside
/// diagnostic information (errors and warnings).
pub fn typeset(&mut self, file: FileId, src: &str) -> Pass<Vec<Rc<Frame>>> {
let ast = parse::parse(src);
let module = eval::eval(self, file, Rc::new(ast.output));
let tree = exec::exec(self, &module.output.template);
let frames = layout::layout(self, &tree.output);
let mut diags = ast.diags;
diags.extend(module.diags);
diags.extend(tree.diags);
Pass::new(frames, diags)
/// Returns either a vector of frames representing individual pages or
/// diagnostics in the form of a vector of error message with file and span
/// information.
pub fn typeset(&mut self, file: FileId, src: &str) -> TypResult<Vec<Rc<Frame>>> {
let ast = parse::parse(file, src)?;
let module = eval::eval(self, file, Rc::new(ast))?;
let tree = exec::exec(self, &module.template);
let frames = layout::layout(self, &tree);
Ok(frames)
}
}

87
src/library/elements.rs
View File

@ -8,46 +8,44 @@ use crate::layout::{
};
/// `image`: An image.
pub fn image(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
let path = args.expect::<Spanned<EcoString>>(ctx, "path to image file");
let width = args.named(ctx, "width");
let height = args.named(ctx, "height");
pub fn image(ctx: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let path = args.expect::<Spanned<EcoString>>("path to image file")?;
let width = args.named("width")?;
let height = args.named("height")?;
let mut node = None;
if let Some(path) = &path {
if let Some(file) = ctx.resolve(&path.v, path.span) {
if let Some(id) = ctx.images.load(file) {
node = Some(ImageNode { id, width, height });
} else {
ctx.diag(error!(path.span, "failed to load image"));
}
}
}
let file = ctx.resolve(&path.v, path.span)?;
let node = match ctx.images.load(file) {
Some(id) => ImageNode { id, width, height },
None => bail!(args.file, path.span, "failed to load image"),
};
Value::template(move |ctx| {
if let Some(node) = node {
ctx.push_into_par(node);
}
})
Ok(Value::template(move |ctx| ctx.push_into_par(node)))
}
/// `rect`: A rectangle with optional content.
pub fn rect(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
let width = args.named(ctx, "width");
let height = args.named(ctx, "height");
let fill = args.named(ctx, "fill");
pub fn rect(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let width = args.named("width")?;
let height = args.named("height")?;
let fill = args.named("fill")?;
let body = args.eat().unwrap_or_default();
rect_impl(width, height, None, fill, body)
Ok(rect_impl(width, height, None, fill, body))
}
/// `square`: A square with optional content.
pub fn square(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
let length = args.named::<Length>(ctx, "length").map(Linear::from);
let width = length.or_else(|| args.named(ctx, "width"));
let height = width.is_none().then(|| args.named(ctx, "height")).flatten();
let fill = args.named(ctx, "fill");
pub fn square(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let length = args.named::<Length>("length")?.map(Linear::from);
let width = match length {
Some(length) => Some(length),
None => args.named("width")?,
};
let height = match width {
Some(_) => None,
None => args.named("height")?,
};
let aspect = Some(N64::from(1.0));
let fill = args.named("fill")?;
let body = args.eat().unwrap_or_default();
rect_impl(width, height, Some(N64::from(1.0)), fill, body)
Ok(rect_impl(width, height, aspect, fill, body))
}
fn rect_impl(
@ -76,22 +74,29 @@ fn rect_impl(
}
/// `ellipse`: An ellipse with optional content.
pub fn ellipse(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
let width = args.named(ctx, "width");
let height = args.named(ctx, "height");
let fill = args.named(ctx, "fill");
pub fn ellipse(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let width = args.named("width")?;
let height = args.named("height")?;
let fill = args.named("fill")?;
let body = args.eat().unwrap_or_default();
ellipse_impl(width, height, None, fill, body)
Ok(ellipse_impl(width, height, None, fill, body))
}
/// `circle`: A circle with optional content.
pub fn circle(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
let diameter = args.named::<Length>(ctx, "radius").map(|r| 2.0 * Linear::from(r));
let width = diameter.or_else(|| args.named(ctx, "width"));
let height = width.is_none().then(|| args.named(ctx, "height")).flatten();
let fill = args.named(ctx, "fill");
pub fn circle(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let diameter = args.named("radius")?.map(|r: Length| 2.0 * Linear::from(r));
let width = match diameter {
None => args.named("width")?,
diameter => diameter,
};
let height = match width {
None => args.named("height")?,
width => width,
};
let aspect = Some(N64::from(1.0));
let fill = args.named("fill")?;
let body = args.eat().unwrap_or_default();
ellipse_impl(width, height, Some(N64::from(1.0)), fill, body)
Ok(ellipse_impl(width, height, aspect, fill, body))
}
fn ellipse_impl(

147
src/library/layout.rs
View File

@ -3,26 +3,26 @@ use crate::layout::{FixedNode, GridNode, PadNode, StackChild, StackNode, TrackSi
use crate::paper::{Paper, PaperClass};
/// `page`: Configure pages.
pub fn page(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
let span = args.span;
let paper = args.eat::<Spanned<EcoString>>().and_then(|name| {
Paper::from_name(&name.v).or_else(|| {
ctx.diag(error!(name.span, "invalid paper name"));
None
})
});
pub fn page(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let paper = match args.eat::<Spanned<EcoString>>() {
Some(name) => match Paper::from_name(&name.v) {
None => bail!(args.file, name.span, "invalid paper name"),
paper => paper,
},
None => None,
};
let width = args.named(ctx, "width");
let height = args.named(ctx, "height");
let margins = args.named(ctx, "margins");
let left = args.named(ctx, "left");
let top = args.named(ctx, "top");
let right = args.named(ctx, "right");
let bottom = args.named(ctx, "bottom");
let flip = args.named(ctx, "flip");
let body = args.expect::<Template>(ctx, "body").unwrap_or_default();
let width = args.named("width")?;
let height = args.named("height")?;
let margins = args.named("margins")?;
let left = args.named("left")?;
let top = args.named("top")?;
let right = args.named("right")?;
let bottom = args.named("bottom")?;
let flip = args.named("flip")?;
let body = args.expect::<Template>("body")?;
Value::template(move |ctx| {
Ok(Value::template(move |ctx| {
let snapshot = ctx.state.clone();
let state = ctx.state.page_mut();
@ -65,50 +65,45 @@ pub fn page(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
std::mem::swap(&mut state.size.width, &mut state.size.height);
}
ctx.pagebreak(false, true, span);
ctx.pagebreak(false, true);
body.exec(ctx);
ctx.state = snapshot;
ctx.pagebreak(true, false, span);
})
ctx.pagebreak(true, false);
}))
}
/// `pagebreak`: Start a new page.
pub fn pagebreak(_: &mut EvalContext, args: &mut FuncArgs) -> Value {
let span = args.span;
Value::template(move |ctx| {
ctx.pagebreak(true, true, span);
})
pub fn pagebreak(_: &mut EvalContext, _: &mut FuncArgs) -> TypResult<Value> {
Ok(Value::template(move |ctx| ctx.pagebreak(true, true)))
}
/// `h`: Horizontal spacing.
pub fn h(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
spacing_impl(ctx, args, GenAxis::Cross)
pub fn h(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
spacing_impl(args, GenAxis::Cross)
}
/// `v`: Vertical spacing.
pub fn v(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
spacing_impl(ctx, args, GenAxis::Main)
pub fn v(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
spacing_impl(args, GenAxis::Main)
}
fn spacing_impl(ctx: &mut EvalContext, args: &mut FuncArgs, axis: GenAxis) -> Value {
let spacing: Option<Linear> = args.expect(ctx, "spacing");
Value::template(move |ctx| {
if let Some(linear) = spacing {
// TODO: Should this really always be font-size relative?
let amount = linear.resolve(ctx.state.font.size);
ctx.push_spacing(axis, amount);
}
})
fn spacing_impl(args: &mut FuncArgs, axis: GenAxis) -> TypResult<Value> {
let spacing = args.expect::<Linear>("spacing")?;
Ok(Value::template(move |ctx| {
// TODO: Should this really always be font-size relative?
let amount = spacing.resolve(ctx.state.font.size);
ctx.push_spacing(axis, amount);
}))
}
/// `align`: Configure the alignment along the layouting axes.
pub fn align(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
pub fn align(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let mut horizontal = args.named("horizontal")?;
let mut vertical = args.named("vertical")?;
let first = args.eat::<Align>();
let second = args.eat::<Align>();
let mut horizontal = args.named(ctx, "horizontal");
let mut vertical = args.named(ctx, "vertical");
let body = args.expect::<Template>(ctx, "body").unwrap_or_default();
let body = args.expect::<Template>("body")?;
for value in first.into_iter().chain(second) {
match value.axis() {
@ -122,7 +117,7 @@ pub fn align(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
}
}
Value::template(move |ctx| {
Ok(Value::template(move |ctx| {
if let Some(horizontal) = horizontal {
ctx.state.aligns.cross = horizontal;
}
@ -133,37 +128,37 @@ pub fn align(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
}
body.exec(ctx);
})
}))
}
/// `box`: Place content in a rectangular box.
pub fn boxed(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
let width = args.named(ctx, "width");
let height = args.named(ctx, "height");
pub fn boxed(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let width = args.named("width")?;
let height = args.named("height")?;
let body = args.eat().unwrap_or_default();
Value::template(move |ctx| {
Ok(Value::template(move |ctx| {
let child = ctx.exec_template_stack(&body).into();
ctx.push_into_par(FixedNode { width, height, child });
})
}))
}
/// `block`: Place content in a block.
pub fn block(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
let body = args.expect(ctx, "body").unwrap_or_default();
Value::template(move |ctx| {
pub fn block(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let body = args.expect("body")?;
Ok(Value::template(move |ctx| {
let block = ctx.exec_template_stack(&body);
ctx.push_into_stack(block);
})
}))
}
/// `pad`: Pad content at the sides.
pub fn pad(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
pub fn pad(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let all = args.eat();
let left = args.named(ctx, "left");
let top = args.named(ctx, "top");
let right = args.named(ctx, "right");
let bottom = args.named(ctx, "bottom");
let body = args.expect(ctx, "body").unwrap_or_default();
let left = args.named("left")?;
let top = args.named("top")?;
let right = args.named("right")?;
let bottom = args.named("bottom")?;
let body = args.expect("body")?;
let padding = Sides::new(
left.or(all).unwrap_or_default(),
@ -172,18 +167,18 @@ pub fn pad(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
bottom.or(all).unwrap_or_default(),
);
Value::template(move |ctx| {
Ok(Value::template(move |ctx| {
let child = ctx.exec_template_stack(&body).into();
ctx.push_into_stack(PadNode { padding, child });
})
}))
}
/// `stack`: Stack children along an axis.
pub fn stack(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
let dir = args.named(ctx, "dir");
pub fn stack(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let dir = args.named("dir")?;
let children: Vec<_> = args.all().collect();
Value::template(move |ctx| {
Ok(Value::template(move |ctx| {
let children = children
.iter()
.map(|child| {
@ -201,23 +196,23 @@ pub fn stack(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
}
ctx.push_into_stack(StackNode { dirs, aspect: None, children });
})
}))
}
/// `grid`: Arrange children into a grid.
pub fn grid(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
let columns = args.named(ctx, "columns").unwrap_or_default();
let rows = args.named(ctx, "rows").unwrap_or_default();
pub fn grid(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let columns = args.named("columns")?.unwrap_or_default();
let rows = args.named("rows")?.unwrap_or_default();
let gutter_columns = args.named(ctx, "gutter-columns");
let gutter_rows = args.named(ctx, "gutter-rows");
let gutter_columns = args.named("gutter-columns")?;
let gutter_rows = args.named("gutter-rows")?;
let default = args
.named(ctx, "gutter")
.named("gutter")?
.map(|v| vec![TrackSizing::Linear(v)])
.unwrap_or_default();
let column_dir = args.named(ctx, "column-dir");
let row_dir = args.named(ctx, "row-dir");
let column_dir = args.named("column-dir")?;
let row_dir = args.named("row-dir")?;
let children: Vec<_> = args.all().collect();
@ -227,7 +222,7 @@ pub fn grid(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
gutter_rows.unwrap_or(default),
);
Value::template(move |ctx| {
Ok(Value::template(move |ctx| {
let children = children
.iter()
.map(|child| ctx.exec_template_stack(child).into())
@ -257,7 +252,7 @@ pub fn grid(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
gutter: gutter.clone(),
children,
})
})
}))
}
/// Defines size of rows and columns in a grid.

1
src/library/mod.rs
View File

@ -17,6 +17,7 @@ use std::convert::TryFrom;
use std::rc::Rc;
use crate::color::{Color, RgbaColor};
use crate::diag::TypResult;
use crate::eval::{EvalContext, FuncArgs, Scope, Template, Type, Value};
use crate::exec::Exec;
use crate::font::{FontFamily, FontStretch, FontStyle, FontWeight, VerticalFontMetric};

92
src/library/text.rs
View File

@ -4,29 +4,27 @@ use crate::layout::Paint;
use super::*;
/// `font`: Configure the font.
pub fn font(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
let size = args.eat::<Linear>().or_else(|| args.named(ctx, "size"));
let style = args.named(ctx, "style");
let weight = args.named(ctx, "weight");
let stretch = args.named(ctx, "stretch");
let top_edge = args.named(ctx, "top-edge");
let bottom_edge = args.named(ctx, "bottom-edge");
let fill = args.named(ctx, "fill");
pub fn font(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let size = args.named::<Linear>("size")?.or_else(|| args.eat());
let style = args.named("style")?;
let weight = args.named("weight")?;
let stretch = args.named("stretch")?;
let top_edge = args.named("top-edge")?;
let bottom_edge = args.named("bottom-edge")?;
let fill = args.named("fill")?;
let families: Vec<_> = args.all().collect();
let list = if families.is_empty() {
args.named(ctx, "family")
} else {
Some(FontDef(Rc::new(families)))
};
let list = args.named("family")?.or_else(|| {
let families: Vec<_> = args.all().collect();
(!families.is_empty()).then(|| FontDef(Rc::new(families)))
});
let serif = args.named(ctx, "serif");
let sans_serif = args.named(ctx, "sans-serif");
let monospace = args.named(ctx, "monospace");
let serif = args.named("serif")?;
let sans_serif = args.named("sans-serif")?;
let monospace = args.named("monospace")?;
let body = args.expect::<Template>(ctx, "body").unwrap_or_default();
let body = args.expect::<Template>("body")?;
Value::template(move |ctx| {
Ok(Value::template(move |ctx| {
let state = ctx.state.font_mut();
if let Some(size) = size {
@ -74,7 +72,7 @@ pub fn font(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
}
body.exec(ctx);
})
}))
}
struct FontDef(Rc<Vec<FontFamily>>);
@ -106,12 +104,12 @@ castable! {
}
/// `par`: Configure paragraphs.
pub fn par(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
let par_spacing = args.named(ctx, "spacing");
let line_spacing = args.named(ctx, "leading");
let body = args.expect::<Template>(ctx, "body").unwrap_or_default();
pub fn par(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let par_spacing = args.named("spacing")?;
let line_spacing = args.named("leading")?;
let body = args.expect::<Template>("body")?;
Value::template(move |ctx| {
Ok(Value::template(move |ctx| {
let state = ctx.state.par_mut();
if let Some(par_spacing) = par_spacing {
@ -124,33 +122,32 @@ pub fn par(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
ctx.parbreak();
body.exec(ctx);
})
}))
}
/// `lang`: Configure the language.
pub fn lang(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
pub fn lang(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let iso = args.eat::<EcoString>();
let dir = if let Some(dir) = args.named::<Spanned<Dir>>(ctx, "dir") {
let dir = if let Some(dir) = args.named::<Spanned<Dir>>("dir")? {
if dir.v.axis() == SpecAxis::Horizontal {
Some(dir.v)
} else {
ctx.diag(error!(dir.span, "must be horizontal"));
None
bail!(args.file, dir.span, "must be horizontal");
}
} else {
iso.as_deref().map(lang_dir)
};
let body = args.expect::<Template>(ctx, "body").unwrap_or_default();
let body = args.expect::<Template>("body")?;
Value::template(move |ctx| {
Ok(Value::template(move |ctx| {
if let Some(dir) = dir {
ctx.state.dirs.cross = dir;
}
ctx.parbreak();
body.exec(ctx);
})
}))
}
/// The default direction for the language identified by the given `iso` code.
@ -163,30 +160,29 @@ fn lang_dir(iso: &str) -> Dir {
}
/// `strike`: Enable striken-through text.
pub fn strike(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
line_impl(ctx, args, |font| &mut font.strikethrough)
pub fn strike(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
line_impl(args, |font| &mut font.strikethrough)
}
/// `underline`: Enable underlined text.
pub fn underline(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
line_impl(ctx, args, |font| &mut font.underline)
pub fn underline(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
line_impl(args, |font| &mut font.underline)
}
/// `overline`: Add an overline above text.
pub fn overline(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
line_impl(ctx, args, |font| &mut font.overline)
pub fn overline(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
line_impl(args, |font| &mut font.overline)
}
fn line_impl(
ctx: &mut EvalContext,
args: &mut FuncArgs,
substate: fn(&mut FontState) -> &mut Option<Rc<LineState>>,
) -> Value {
let stroke = args.eat().or_else(|| args.named(ctx, "stroke"));
let thickness = args.eat::<Linear>().or_else(|| args.named(ctx, "thickness"));
let offset = args.named(ctx, "offset");
let extent = args.named(ctx, "extent").unwrap_or_default();
let body = args.expect::<Template>(ctx, "body").unwrap_or_default();
) -> TypResult<Value> {
let stroke = args.named("stroke")?.or_else(|| args.eat());
let thickness = args.named::<Linear>("thickness")?.or_else(|| args.eat());
let offset = args.named("offset")?;
let extent = args.named("extent")?.unwrap_or_default();
let body = args.expect::<Template>("body")?;
// Suppress any existing strikethrough if strength is explicitly zero.
let state = thickness.map_or(true, |s| !s.is_zero()).then(|| {
@ -198,8 +194,8 @@ fn line_impl(
})
});
Value::template(move |ctx| {
Ok(Value::template(move |ctx| {
*substate(ctx.state.font_mut()) = state.clone();
body.exec(ctx);
})
}))
}

96
src/library/utility.rs
View File

@ -7,94 +7,78 @@ use crate::pretty::pretty;
use super::*;
/// `type`: The name of a value's type.
pub fn type_(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
match args.expect::<Value>(ctx, "value") {
Some(value) => value.type_name().into(),
None => Value::Error,
}
pub fn type_(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let value = args.expect::<Value>("value")?;
Ok(value.type_name().into())
}
/// `repr`: The string representation of a value.
pub fn repr(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
match args.expect::<Value>(ctx, "value") {
Some(value) => pretty(&value).into(),
None => Value::Error,
}
pub fn repr(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let value = args.expect::<Value>("value")?;
Ok(pretty(&value).into())
}
/// `len`: The length of a string, an array or a dictionary.
pub fn len(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
match args.expect(ctx, "collection") {
Some(Spanned { v: Value::Str(v), .. }) => Value::Int(v.len() as i64),
Some(Spanned { v: Value::Array(v), .. }) => Value::Int(v.len() as i64),
Some(Spanned { v: Value::Dict(v), .. }) => Value::Int(v.len() as i64),
Some(other) if other.v != Value::Error => {
ctx.diag(error!(other.span, "expected string, array or dictionary"));
Value::Error
}
_ => Value::Error,
}
pub fn len(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
let Spanned { v, span } = args.expect("collection")?;
Ok(match v {
Value::Str(v) => Value::Int(v.len() as i64),
Value::Array(v) => Value::Int(v.len() as i64),
Value::Dict(v) => Value::Int(v.len() as i64),
_ => bail!(args.file, span, "expected string, array or dictionary"),
})
}
/// `rgb`: Create an RGB(A) color.
pub fn rgb(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
Value::Color(Color::Rgba(
pub fn rgb(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
Ok(Value::Color(Color::Rgba(
if let Some(string) = args.eat::<Spanned<EcoString>>() {
match RgbaColor::from_str(&string.v) {
Ok(color) => color,
Err(_) => {
ctx.diag(error!(string.span, "invalid color"));
return Value::Error;
}
Err(_) => bail!(args.file, string.span, "invalid color"),
}
} else {
let r = args.expect(ctx, "red component").unwrap_or(0.0);
let g = args.expect(ctx, "green component").unwrap_or(0.0);
let b = args.expect(ctx, "blue component").unwrap_or(0.0);
let r = args.expect("red component")?;
let g = args.expect("green component")?;
let b = args.expect("blue component")?;
let a = args.eat().unwrap_or(1.0);
let f = |v: f64| (v.clamp(0.0, 1.0) * 255.0).round() as u8;
RgbaColor::new(f(r), f(g), f(b), f(a))
},
))
)))
}
/// `min`: The minimum of a sequence of values.
pub fn min(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
minmax(ctx, args, Ordering::Less)
pub fn min(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
minmax(args, Ordering::Less)
}
/// `max`: The maximum of a sequence of values.
pub fn max(ctx: &mut EvalContext, args: &mut FuncArgs) -> Value {
minmax(ctx, args, Ordering::Greater)
pub fn max(_: &mut EvalContext, args: &mut FuncArgs) -> TypResult<Value> {
minmax(args, Ordering::Greater)
}
/// Find the minimum or maximum of a sequence of values.
fn minmax(ctx: &mut EvalContext, args: &mut FuncArgs, goal: Ordering) -> Value {
let span = args.span;
let mut extremum = None;
fn minmax(args: &mut FuncArgs, goal: Ordering) -> TypResult<Value> {
let &mut FuncArgs { file, span, .. } = args;
let mut extremum = args.expect::<Value>("value")?;
for value in args.all::<Value>() {
if let Some(prev) = &extremum {
match value.partial_cmp(&prev) {
Some(ordering) if ordering == goal => extremum = Some(value),
Some(_) => {}
None => {
ctx.diag(error!(
span,
"cannot compare {} with {}",
prev.type_name(),
value.type_name(),
));
return Value::Error;
match value.partial_cmp(&extremum) {
Some(ordering) => {
if ordering == goal {
extremum = value;
}
}
} else {
extremum = Some(value);
None => bail!(
file,
span,
"cannot compare {} with {}",
extremum.type_name(),
value.type_name(),
),
}
}
extremum.unwrap_or_else(|| {
args.expect::<Value>(ctx, "value");
Value::Error
})
Ok(extremum)
}

3
src/loading/mod.rs
View File

@ -34,7 +34,8 @@ pub trait Loader {
/// A file id that can be [resolved](Loader::resolve_from) from a path.
///
/// Should be the same for all paths pointing to the same file.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Serialize, Deserialize)]
pub struct FileId(u64);
impl FileId {

41
src/main.rs
View File

@ -35,32 +35,35 @@ fn main() -> anyhow::Result<()> {
.wrap();
// Resolve the file id of the source file and read the file.
let src_id = loader.resolve(src_path).context("source file not found")?;
let file = loader.resolve(src_path).context("source file not found")?;
let src = fs::read_to_string(&src_path)
.map_err(|_| anyhow!("failed to read source file"))?;
// Typeset.
let mut ctx = typst::Context::new(loader);
let pass = ctx.typeset(src_id, &src);
match ctx.typeset(file, &src) {
// Export the PDF.
Ok(document) => {
let buffer = typst::export::pdf(&ctx, &document);
fs::write(&dest_path, buffer).context("failed to write PDF file")?;
}
// Print diagnostics.
let map = typst::parse::LineMap::new(&src);
for diag in pass.diags {
let start = map.location(diag.span.start).unwrap();
let end = map.location(diag.span.end).unwrap();
println!(
"{}: {}:{}-{}: {}",
diag.level,
src_path.display(),
start,
end,
diag.message,
);
// Print diagnostics.
Err(errors) => {
let map = typst::parse::LineMap::new(&src);
for error in errors.iter() {
let start = map.location(error.span.start).unwrap();
let end = map.location(error.span.end).unwrap();
println!(
"Error: {}:{}-{}: {}",
src_path.display(),
start,
end,
error.message,
);
}
}
}
// Export the PDF.
let buffer = typst::export::pdf(&ctx, &pass.output);
fs::write(&dest_path, buffer).context("failed to write PDF file")?;
Ok(())
}

4
src/parse/lines.rs
View File

@ -77,8 +77,8 @@ impl<'s> LineMap<'s> {
}
}
/// Determine the column at the end of the string.
pub fn search_column(src: &str) -> usize {
/// Count how many column the string would fill.
pub fn count_columns(src: &str) -> usize {
let mut column = 0;
for c in src.chars().rev() {
if is_newline(c) {

56
src/parse/mod.rs
View File

@ -14,14 +14,21 @@ pub use tokens::*;
use std::rc::Rc;
use crate::diag::Pass;
use crate::diag::TypResult;
use crate::loading::FileId;
use crate::syntax::*;
use crate::util::EcoString;
/// Parse a string of source code.
pub fn parse(src: &str) -> Pass<SyntaxTree> {
let mut p = Parser::new(src);
Pass::new(tree(&mut p), p.diags)
pub fn parse(file: FileId, src: &str) -> TypResult<SyntaxTree> {
let mut p = Parser::new(file, src);
let tree = tree(&mut p);
let errors = p.finish();
if errors.is_empty() {
Ok(tree)
} else {
Err(Box::new(errors))
}
}
/// Parse a syntax tree.
@ -126,7 +133,7 @@ fn node(p: &mut Parser, at_start: &mut bool) -> Option<SyntaxNode> {
p.start_group(group, TokenMode::Code);
let expr = expr_with(p, true, 0);
if stmt && expr.is_some() && !p.eof() {
p.expected_at("semicolon or line break", p.prev_end());
p.expected_at(p.prev_end(), "semicolon or line break");
}
p.end_group();
@ -160,12 +167,12 @@ fn unicode_escape(p: &mut Parser, token: UnicodeEscapeToken) -> EcoString {
c.into()
} else {
// Print out the escape sequence verbatim if it is invalid.
p.diag(error!(span, "invalid unicode escape sequence"));
p.error(span, "invalid unicode escape sequence");
p.peek_src().into()
};
if !token.terminated {
p.diag(error!(span.end, "expected closing brace"));
p.error(span.end, "expected closing brace");
}
text
@ -176,7 +183,7 @@ fn raw(p: &mut Parser, token: RawToken) -> SyntaxNode {
let span = p.peek_span();
let raw = resolve::resolve_raw(span, token.text, token.backticks);
if !token.terminated {
p.diag(error!(p.peek_span().end, "expected backtick(s)"));
p.error(span.end, "expected backtick(s)");
}
SyntaxNode::Raw(raw)
}
@ -198,11 +205,7 @@ fn heading(p: &mut Parser) -> SyntaxNode {
let body = tree_indented(p);
SyntaxNode::Heading(HeadingNode {
span: p.span(start),
level,
body: Rc::new(body),
})
SyntaxNode::Heading(HeadingNode { span: p.span(start), level, body })
}
/// Parse a single list item.
@ -356,7 +359,7 @@ fn literal(p: &mut Parser) -> Option<Expr> {
Token::Fraction(p) => Expr::Fractional(span, p),
Token::Str(token) => Expr::Str(span, {
if !token.terminated {
p.expected_at("quote", p.peek_span().end);
p.expected_at(span.end, "quote");
}
resolve::resolve_string(token.string)
}),
@ -421,7 +424,7 @@ fn collection(p: &mut Parser) -> (Vec<CallArg>, bool) {
items.push(arg);
if let Some(pos) = missing_coma.take() {
p.expected_at("comma", pos);
p.expected_at(pos, "comma");
}
if p.eof() {
@ -447,7 +450,7 @@ fn item(p: &mut Parser) -> Option<CallArg> {
if let Expr::Ident(name) = first {
Some(CallArg::Named(Named { name, expr: expr(p)? }))
} else {
p.diag(error!(first.span(), "expected identifier"));
p.error(first.span(), "expected identifier");
expr(p);
None
}
@ -461,7 +464,7 @@ fn array(p: &mut Parser, items: Vec<CallArg>, span: Span) -> Expr {
let items = items.into_iter().filter_map(|item| match item {
CallArg::Pos(expr) => Some(expr),
CallArg::Named(_) => {
p.diag(error!(item.span(), "expected expression, found named pair"));
p.error(item.span(), "expected expression, found named pair");
None
}
});
@ -474,7 +477,7 @@ fn dict(p: &mut Parser, items: Vec<CallArg>, span: Span) -> Expr {
let items = items.into_iter().filter_map(|item| match item {
CallArg::Named(named) => Some(named),
CallArg::Pos(_) => {
p.diag(error!(item.span(), "expected named pair, found expression"));
p.error(item.span(), "expected named pair, found expression");
None
}
});
@ -488,7 +491,7 @@ fn idents(p: &mut Parser, items: Vec<CallArg>) -> Vec<Ident> {
let items = items.into_iter().filter_map(|item| match item {
CallArg::Pos(Expr::Ident(id)) => Some(id),
_ => {
p.diag(error!(item.span(), "expected identifier"));
p.error(item.span(), "expected identifier");
None
}
});
@ -512,7 +515,7 @@ fn block(p: &mut Parser, scoping: bool) -> Expr {
if let Some(expr) = expr(p) {
exprs.push(expr);
if !p.eof() {
p.expected_at("semicolon or line break", p.prev_end());
p.expected_at(p.prev_end(), "semicolon or line break");
}
}
p.end_group();
@ -529,10 +532,7 @@ fn call(p: &mut Parser, callee: Expr) -> Option<Expr> {
let mut wide = p.eat_if(Token::Excl);
if wide && p.outer_mode() == TokenMode::Code {
let span = p.span(callee.span().start);
p.diag(error!(
span,
"wide calls are only allowed directly in templates",
));
p.error(span, "wide calls are only allowed directly in templates");
wide = false;
}
@ -548,7 +548,7 @@ fn call(p: &mut Parser, callee: Expr) -> Option<Expr> {
items: vec![],
},
_ => {
p.expected_at("argument list", p.prev_end());
p.expected_at(p.prev_end(), "argument list");
return None;
}
};
@ -616,7 +616,7 @@ fn let_expr(p: &mut Parser) -> Option<Expr> {
init = expr(p);
} else if params.is_some() {
// Function definitions must have a body.
p.expected_at("body", p.prev_end());
p.expected_at(p.prev_end(), "body");
}
// Rewrite into a closure expression if it's a function definition.
@ -738,7 +738,7 @@ fn import_expr(p: &mut Parser) -> Option<Expr> {
p.start_group(Group::Imports, TokenMode::Code);
let items = collection(p).0;
if items.is_empty() {
p.expected_at("import items", p.prev_end());
p.expected_at(p.prev_end(), "import items");
}
p.end_group();
Imports::Idents(idents(p, items))
@ -790,7 +790,7 @@ fn body(p: &mut Parser) -> Option<Expr> {
Some(Token::LeftBracket) => Some(template(p)),
Some(Token::LeftBrace) => Some(block(p, true)),
_ => {
p.expected_at("body", p.prev_end());
p.expected_at(p.prev_end(), "body");
None
}
}

64
src/parse/parser.rs
View File

@ -1,14 +1,17 @@
use std::fmt::{self, Debug, Formatter};
use std::ops::Range;
use super::{search_column, TokenMode, Tokens};
use crate::diag::{Diag, DiagSet};
use super::{count_columns, TokenMode, Tokens};
use crate::diag::Error;
use crate::loading::FileId;
use crate::syntax::{Pos, Span, Token};
/// A convenient token-based parser.
pub struct Parser<'s> {
/// Parsing diagnostics.
pub diags: DiagSet,
/// The id of the parsed file.
file: FileId,
/// Parsing errors.
errors: Vec<Error>,
/// An iterator over the source tokens.
tokens: Tokens<'s>,
/// The stack of open groups.
@ -57,11 +60,12 @@ pub enum Group {
impl<'s> Parser<'s> {
/// Create a new parser for the source string.
pub fn new(src: &'s str) -> Self {
pub fn new(file: FileId, src: &'s str) -> Self {
let mut tokens = Tokens::new(src, TokenMode::Markup);
let next = tokens.next();
Self {
diags: DiagSet::new(),
file,
errors: vec![],
tokens,
groups: vec![],
next,
@ -71,39 +75,45 @@ impl<'s> Parser<'s> {
}
}
/// Add a diagnostic.
pub fn diag(&mut self, diag: Diag) {
self.diags.insert(diag);
/// Finish parsing and return all errors.
pub fn finish(self) -> Vec<Error> {
self.errors
}
/// Eat the next token and add a diagnostic that it is not the expected
/// `thing`.
/// Add an error with location and message.
pub fn error(&mut self, span: impl Into<Span>, message: impl Into<String>) {
self.errors.push(Error {
file: self.file,
span: span.into(),
message: message.into(),
});
}
/// Eat the next token and add an error that it is not the expected `thing`.
pub fn expected(&mut self, what: &str) {
let before = self.next_start();
if let Some(found) = self.eat() {
let after = self.prev_end();
self.diag(error!(
self.error(
before .. after,
"expected {}, found {}",
what,
found.name(),
));
format!("expected {}, found {}", what, found.name()),
);
} else {
self.expected_at(what, self.next_start());
self.expected_at(self.next_start(), what);
}
}
/// Add a diagnostic that `what` was expected at the given position.
pub fn expected_at(&mut self, what: &str, pos: impl Into<Pos>) {
self.diag(error!(pos.into(), "expected {}", what));
/// Add an error that `what` was expected at the given position.
pub fn expected_at(&mut self, pos: impl Into<Pos>, what: &str) {
self.error(pos.into(), format!("expected {}", what));
}
/// Eat the next token and add a diagnostic that it is unexpected.
/// Eat the next token and add an error that it is unexpected.
pub fn unexpected(&mut self) {
let before = self.next_start();
if let Some(found) = self.eat() {
let after = self.prev_end();
self.diag(error!(before .. after, "unexpected {}", found.name()));
self.error(before .. after, format!("unexpected {}", found.name()));
}
}
@ -159,7 +169,7 @@ impl<'s> Parser<'s> {
self.bump();
rescan = false;
} else if required {
self.diag(error!(self.next_start(), "expected {}", end.name()));
self.error(self.next_start(), format!("expected {}", end.name()));
}
}
@ -276,12 +286,12 @@ impl<'s> Parser<'s> {
Span::new(start, self.prev_end())
}
/// Consume the next token if it is the given one and produce a diagnostic
/// if not.
/// Consume the next token if it is the given one and produce an error if
/// not.
pub fn expect(&mut self, t: Token) -> bool {
let eaten = self.eat_if(t);
if !eaten {
self.expected_at(t.name(), self.prev_end());
self.expected_at(self.prev_end(), t.name());
}
eaten
}
@ -314,7 +324,7 @@ impl<'s> Parser<'s> {
/// Determine the column for the given index in the source.
pub fn column(&self, index: usize) -> usize {
search_column(self.tokens.scanner().get(.. index))
count_columns(self.tokens.scanner().get(.. index))
}
/// The span from `start` to [`self.prev_end()`](Self::prev_end).

16
src/pretty.rs
View File

@ -488,7 +488,6 @@ impl Pretty for Value {
Self::Template(v) => v.pretty(p),
Self::Func(v) => v.pretty(p),
Self::Dyn(v) => v.pretty(p),
Self::Error => p.push_str("<error>"),
}
}
}
@ -609,6 +608,7 @@ pretty_display! {
#[cfg(test)]
mod tests {
use super::*;
use crate::loading::FileId;
use crate::parse::parse;
#[track_caller]
@ -618,7 +618,7 @@ mod tests {
#[track_caller]
fn test_parse(src: &str, exp: &str) {
let ast = parse(src).output;
let ast = parse(FileId::from_raw(0), src).unwrap();
let found = pretty(&ast);
if exp != found {
println!("tree: {:#?}", ast);
@ -732,6 +732,7 @@ mod tests {
#[test]
fn test_pretty_print_value() {
// Primitives.
test_value(Value::None, "none");
test_value(false, "false");
test_value(12i64, "12");
@ -742,6 +743,8 @@ mod tests {
test_value(Relative::new(0.3) + Length::cm(2.0), "30% + 2cm");
test_value(Fractional::one() * 7.55, "7.55fr");
test_value(Color::Rgba(RgbaColor::new(1, 1, 1, 0xff)), "#010101");
// Collections.
test_value("hello", r#""hello""#);
test_value("\n", r#""\n""#);
test_value("\\", r#""\\""#);
@ -752,12 +755,15 @@ mod tests {
test_value(dict![], "(:)");
test_value(dict!["one" => 1], "(one: 1)");
test_value(dict!["two" => false, "one" => 1], "(one: 1, two: false)");
test_value(Function::new(None, |_, _| Value::None), "<function>");
// Functions.
test_value(Function::new(None, |_, _| Ok(Value::None)), "<function>");
test_value(
Function::new(Some("nil".into()), |_, _| Value::None),
Function::new(Some("nil".into()), |_, _| Ok(Value::None)),
"<function nil>",
);
// Dynamics.
test_value(Dynamic::new(1), "1");
test_value(Value::Error, "<error>");
}
}

4
src/syntax/node.rs
View File

@ -1,5 +1,3 @@
use std::rc::Rc;
use super::*;
/// A syntax node, encompassing a single logical entity of parsed source code.
@ -52,7 +50,7 @@ pub struct HeadingNode {
/// The section depth (numer of equals signs).
pub level: usize,
/// The contents of the heading.
pub body: Rc<SyntaxTree>,
pub body: SyntaxTree,
}
/// An item in an unordered list: `- ...`.

2
src/syntax/visit.rs
View File

@ -102,7 +102,7 @@ impl_visitors! {
}
visit_heading(v, heading: HeadingNode) {
v.visit_tree(r!(rc: heading.body));
v.visit_tree(r!(heading.body));
}
visit_list(v, item: ListItem) {

2
src/util/mod.rs
View File

@ -73,7 +73,7 @@ impl<T> SliceExt<T> for [T] {
}
}
/// This struct is produced by [`SliceExt::group_by_key`].
/// This struct is created by [`SliceExt::group_by_key`].
pub struct GroupByKey<'a, T, F> {
slice: &'a [T],
f: F,

BIN
tests/ref/code/array.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 3.3 KiB

After

Width:  |  Height:  |  Size: 1.9 KiB

BIN
tests/ref/code/block-invalid.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 512 B

BIN
tests/ref/code/block.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 3.1 KiB

After

Width:  |  Height:  |  Size: 1.4 KiB

BIN
tests/ref/code/call-invalid.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 2.9 KiB

BIN
tests/ref/code/call-wide.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 2.6 KiB

BIN
tests/ref/code/call.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.0 KiB

After

Width:  |  Height:  |  Size: 3.6 KiB

BIN
tests/ref/code/closure.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 657 B

BIN
tests/ref/code/comment.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 1.9 KiB

After

Width:  |  Height:  |  Size: 1.8 KiB

BIN
tests/ref/code/dict.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 1.6 KiB

After

Width:  |  Height:  |  Size: 884 B

BIN
tests/ref/code/for.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 4.0 KiB

After

Width:  |  Height:  |  Size: 2.3 KiB

BIN
tests/ref/code/if.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 2.7 KiB

After

Width:  |  Height:  |  Size: 1.8 KiB

BIN
tests/ref/code/import.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 4.2 KiB

After

Width:  |  Height:  |  Size: 1.8 KiB

BIN
tests/ref/code/let.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 2.2 KiB

After

Width:  |  Height:  |  Size: 1.4 KiB

BIN
tests/ref/code/while.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 1.5 KiB

After

Width:  |  Height:  |  Size: 811 B

BIN
tests/ref/insert/circle.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 13 KiB

After

Width:  |  Height:  |  Size: 13 KiB

BIN
tests/ref/insert/square.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 7.0 KiB

After

Width:  |  Height:  |  Size: 6.9 KiB

BIN
tests/ref/layout/spacing.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 3.2 KiB

After

Width:  |  Height:  |  Size: 2.5 KiB

BIN
tests/ref/markup/escape.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 9.6 KiB

After

Width:  |  Height:  |  Size: 5.4 KiB

BIN
tests/ref/markup/raw.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 7.1 KiB

After

Width:  |  Height:  |  Size: 6.7 KiB

BIN
tests/ref/text/decorations.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 11 KiB

After

Width:  |  Height:  |  Size: 11 KiB

BIN
tests/ref/text/whitespace.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 7.0 KiB

After

Width:  |  Height:  |  Size: 6.7 KiB

1
tests/typ/code/array.typ
View File

@ -18,6 +18,7 @@
, rgb("002")
,)}
---
// Error: 3 expected closing paren
{(}

38
tests/typ/code/block-invalid.typ
View File

@ -1,38 +0,0 @@
// Test invalid code block syntax.
---
// Multiple unseparated expressions in one line.
// Error: 2-4 expected expression, found invalid token
{1u}
// Should output `1`.
// Error: 3 expected semicolon or line break
// Error: 4-5 cannot join integer with integer
{1 2}
// Should output `2`.
// Error: 12 expected semicolon or line break
// Error: 22 expected semicolon or line break
{let x = -1 let y = 3 x + y}
// Should output `3`.
{
// Error: 9-12 expected identifier, found string
for "v"
// Error: 10 expected keyword `in`
for v let z = 1 + 2
z
}
---
// Ref: false
// Error: 2:1 expected closing brace
{
---
// Ref: false
// Error: 1-2 unexpected closing brace
}

45
tests/typ/code/block-scoping.typ
View File

@ -1,45 +0,0 @@
// Test scoping with blocks.
// Ref: false
---
// Block in template does not create a scope.
{ let x = 1 }
#test(x, 1)
---
// Block in expression does create a scope.
#let a = {
let b = 1
b
}
#test(a, 1)
// Error: 2-3 unknown variable
{b}
---
// Double block creates a scope.
{{
import b from "target.typ"
test(b, 1)
}}
// Error: 2-3 unknown variable
{b}
---
// Multiple nested scopes.
{
let a = "a1"
{
let a = "a2"
{
test(a, "a2")
let a = "a3"
test(a, "a3")
}
test(a, "a2")
}
test(a, "a1")
}

145
tests/typ/code/block.typ
View File

@ -1,46 +1,55 @@
// Test code blocks.
// Ref: false
---
All none
// Ref: true
// Nothing evaluates to none.
{}
// Let evaluates to none.
{ let v = 0 }
// Type is joined with trailing none, evaluates to string.
// Evaluates to join of none, [My ] and the two loop bodies.
{
type("")
none
}
---
// Evaluates to single expression.
{ "Hello" }
// Evaluates to string.
{ let x = "Hel"; x + "lo" }
// Evaluates to join of none, [He] and the two loop bodies.
{
let parts = ("l", "lo")
[He]
let parts = ("my fri", "end.")
[Hello, ]
for s in parts [{s}]
}
---
// Evaluates to join of the templates and strings.
{
[Hey, ]
[How]
if true {
"there!"
" are"
}
[ ]
if false [Nope]
[How are ] + "you?"
[you] + "?"
}
---
// Nothing evaluates to none.
#test({}, none)
// Let evaluates to none.
#test({ let v = 0 }, none)
// Evaluates to single expression.
#test({ "hello" }, "hello")
// Evaluates to string.
#test({ let x = "m"; x + "y" }, "my")
// Evaluated to int.
#test({
let x = 1
let y = 2
x + y
}, 3)
// String is joined with trailing none, evaluates to string.
#test({
type("")
none
}, "string")
---
// Some things can't be joined.
{
[A]
// Error: 5-6 cannot join template with integer
@ -49,10 +58,78 @@ All none
}
---
// Works the same way in code environment.
// Ref: false
#test(3, {
let x = 1
let y = 2
x + y
})
// Block in template does not create a scope.
{ let x = 1 }
#test(x, 1)
---
// Block in expression does create a scope.
#let a = {
let b = 1
b
}
#test(a, 1)
// Error: 2-3 unknown variable
{b}
---
// Double block creates a scope.
{{
import b from "target.typ"
test(b, 1)
}}
// Error: 2-3 unknown variable
{b}
---
// Multiple nested scopes.
{
let a = "a1"
{
let a = "a2"
{
test(a, "a2")
let a = "a3"
test(a, "a3")
}
test(a, "a2")
}
test(a, "a1")
}
---
// Multiple unseparated expressions in one line.
// Error: 2-4 expected expression, found invalid token
{1u}
// Should output `1`.
// Error: 3 expected semicolon or line break
{1 2}
// Should output `2`.
// Error: 12 expected semicolon or line break
// Error: 22 expected semicolon or line break
{let x = -1 let y = 3 x + y}
// Should output `3`.
{
// Error: 9-12 expected identifier, found string
for "v"
// Error: 10 expected keyword `in`
for v let z = 1 + 2
z
}
---
// Error: 2:1 expected closing brace
{
---
// Error: 1-2 unexpected closing brace
}

39
tests/typ/code/call-invalid.typ
View File

@ -1,39 +0,0 @@
// Test invalid function calls.
---
// Error: 7-8 expected expression, found colon
#args(:)
// Error: 10-12 expected expression, found end of block comment
#args(a:1*/)
// Error: 8 expected comma
#args(1 2)
// Error: 7-8 expected identifier
// Error: 9 expected expression
#args(1:)
// Error: 7-8 expected identifier
#args(1:2)
// Error: 7-10 expected identifier
{args((x):1)}
---
#let x = "string"
// Error: 1-3 expected function, found string
#x()
// Error: 2:1 expected closing bracket
#args[`a]`
---
// Error: 7 expected closing paren
{args(}
---
// Error: 2:1 expected quote
// Error: 2:1 expected closing paren
#args("]

40
tests/typ/code/call-wide.typ
View File

@ -1,40 +0,0 @@
// Test wide calls.
---
// Test multiple wide calls in separate expressions.
#font!(fill: eastern) - First
#font!(fill: forest) - Second
---
// Test in heading.
= A #align!(right) B
C
---
// Test evaluation semantics.
#let x = 1
#let f(x, body) = (x, body)
#f!(x)
{ x = 2 }
---
// Test multiple wide calls in one expression.
// Ref: false
#let f() = []
#let g(x, y) = []
// Error: 2-4 wide calls are only allowed directly in templates
{f!()}
// Test nested wide calls.
// Error: 5-7 wide calls are only allowed directly in templates
#g!(f!())
---
// Test missing parentheses.
// Ref: false
// Error: 4 expected argument list
#f!

146
tests/typ/code/call.typ
View File

@ -1,34 +1,64 @@
// Test function calls.
---
// One argument.
#args(bold)
// One argument and trailing comma.
#args(1,)
// One named argument.
#args(a:2)
// Mixed arguments.
{args(1, b: "2", 3)}
// Should output `() + 2`.
#args() + 2
---
// Ref: false
---
// Ref: true
// Ommitted space.
#font(weight:bold)[Bold]
// Call return value of function with body.
#let f(x, body) = (y) => [#x] + body + [#y]
#f(1)[2](3)
// Don't parse this as a function.
// Should output `<function test> (it)`.
#test (it)
#let f(body) = body
#f[A]
#f()[A]
#f([A])
---
// Ref: true
// Test multiple wide calls in separate expressions inside a template.
[
#font!(fill: eastern) - First
#font!(fill: forest) - Second
]
// Test wide call in heading.
= A #align!(right) B
C
---
// Test wide call in expression.
// Error: 2-4 wide calls are only allowed directly in templates
{f!()}
// Error: 5-7 wide calls are only allowed directly in templates
#g!(f!())
---
// Test wide call evaluation semantics.
#let x = 1
#let f(x, body) = test(x, 1)
#f!(x)
{ x = 2 }
---
// Trailing comma.
#test(1 + 1, 2,)
// Call function assigned to variable.
#let alias = type
#test(alias(alias), "function")
---
// Callee expressions.
{
// Error: 5-9 expected function, found boolean
true()
// Wrapped in parens.
test((type)("hi"), "string")
@ -37,30 +67,60 @@
test(adder(2)(5), 7)
}
#let f(x, body) = (y) => {
[{x}] + body + [{y}]
}
// Call return value of function with body.
#f(1)[2](3)
// Don't allow this to be a closure.
// Should output `x => "hi"`.
#let x = "x"
#x => "hi"
---
// Error: 2-6 expected function, found boolean
{true()}
---
// Different forms of template arguments.
#let x = "x"
#let a = "a"
// Error: 1-3 expected function, found string
#x()
#args(a) \
#args[a] \
#args(a, [b])
---
#let f(x) = x
// Template can be argument or body depending on whitespace.
#if "template" == type[b] [Sure ]
#if "template" == type [Nope.] #else [thing.]
// Error: 1-6 expected function, found integer
#f(1)(2)
// Should output `<function args> (Okay.)`.
#args (Okay.)
---
#let f(x) = x
// Error: 1-6 expected function, found template
#f[1](2)
---
// Error: 7 expected argument list
#func!
// Error: 7-8 expected expression, found colon
#func(:)
// Error: 10-12 expected expression, found end of block comment
#func(a:1*/)
// Error: 8 expected comma
#func(1 2)
// Error: 7-8 expected identifier
// Error: 9 expected expression
#func(1:)
// Error: 7-8 expected identifier
#func(1:2)
// Error: 7-10 expected identifier
{func((x):1)}
---
// Error: 2:1 expected closing bracket
#func[`a]`
---
// Error: 7 expected closing paren
{func(}
---
// Error: 2:1 expected quote
// Error: 2:1 expected closing paren
#func("]

31
tests/typ/code/closure.typ
View File

@ -2,13 +2,22 @@
// Ref: false
---
// Don't parse closure directly in template.
// Ref: true
#let x = "\"hi\""
// Should output `"hi" => "bye"`.
#x => "bye"
---
// Basic closure without captures.
{
let adder = (x, y) => x + y
test(adder(2, 3), 5)
}
---
// Pass closure as argument and return closure.
// Also uses shorthand syntax for a single argument.
{
@ -19,6 +28,7 @@
test(h(2), 5)
}
---
// Capture environment.
{
let mark = "?"
@ -35,15 +45,7 @@
test(greet("Typst"), "Hi, Typst!")
}
// Don't leak environment.
{
// Error: 18-19 unknown variable
let func() = x
let x = "hi"
test(func(), error)
}
---
// Redefined variable.
{
let x = 1
@ -54,6 +56,15 @@
test(f(), 3)
}
---
// Don't leak environment.
{
// Error: 18-19 unknown variable
let func() = x
let x = "hi"
func()
}
---
// Too few arguments.
{
@ -64,11 +75,11 @@
test(types("nope"), "[string, none]")
}
---
// Too many arguments.
{
let f(x) = x + 1
// Error: 10-15 unexpected argument
// Error: 17-24 unexpected argument
f(1, "two", () => x)
}

35
tests/typ/code/for-pattern.typ
View File

@ -1,35 +0,0 @@
// Test for loop patterns.
// Ref: false
---
#let out = ()
// Values of array.
#for v in (1, 2, 3) {
out += (v,)
}
// Indices and values of array.
#for i, v in ("1", "2", "3") {
test(repr(i + 1), v)
}
// Values of dictionary.
#for v in (a: 4, b: 5) {
out += (v,)
}
// Keys and values of dictionary.
#for k, v in (a: 6, b: 7) {
out += (k,)
out += (v,)
}
#test(out, (1, 2, 3, 4, 5, "a", 6, "b", 7))
---
// Keys and values of strings.
// Error: 6-10 mismatched pattern
#for k, v in "hi" {
dont-care
}

91
tests/typ/code/for.typ
View File

@ -1,42 +1,23 @@
// Test for loops.
// Ref: false
---
// Ref: true
// Empty array.
#for x in () [Nope]
// Array.
#let sum = 0
#for x in (1, 2, 3, 4, 5) {
sum += x
}
#test(sum, 15)
// Dictionary is not traversed in insertion order.
// Should output `age: 1, name: Typst,`.
// Should output `Age: 2. Name: Typst.`.
#for k, v in (Name: "Typst", Age: 2) [
{k}: {v}.
]
// String.
{
let first = true
let out = for c in "abc" {
if not first {
", "
}
c
first = false
}
test(out, "a, b, c")
}
---
// Block body.
// Should output `[1st, 2nd, 3rd, 4th, 5th, 6th]`.
// Should output `[1st, 2nd, 3rd, 4th, 5th]`.
{
"["
for v in (1, 2, 3, 4, 5, 6) {
for v in (1, 2, 3, 4, 5) {
if v > 1 [, ]
[#v]
if v == 1 [st]
@ -48,30 +29,60 @@
}
// Template body.
// Should output `234`.
// Should output `2345`.
#for v in (1, 2, 3, 4, 5, 6, 7) [#if v >= 2 and v <= 5 { repr(v) }]
---
// Value of for loops.
// Ref: false
#let out = ()
// Values of array.
#for v in (1, 2, 3) {
out += (v,)
}
// Indices and values of array.
#for i, v in ("1", "2", "3") {
test(repr(i + 1), v)
}
// Values of dictionary.
#for v in (a: 4, b: 5) {
out += (v,)
}
// Keys and values of dictionary.
#for k, v in (a: 6, b: 7) {
out += (k,)
out += (v,)
}
#test(out, (1, 2, 3, 4, 5, "a", 6, "b", 7))
// Chars of string.
#let first = true
#let joined = for c in "abc" {
if not first { ", " }
first = false
c
}
#test(joined, "a, b, c")
// Return value.
#test(for v in "" [], none)
#test(type(for v in "1" []), "template")
---
// Ref: false
// Uniterable expression.
// Error: 11-15 cannot loop over boolean
#for v in true {}
// Make sure that we don't complain twice.
// Error: 11-18 cannot add integer and string
#for v in 1 + "2" {}
// Errors taint everything.
#test(error, for v in (1, 2, 3) {
if v < 2 [Ok] else {error}
})
---
// Keys and values of strings.
// Error: 6-10 mismatched pattern
#for k, v in "hi" {
dont-care
}
---
// Error: 5 expected identifier
@ -89,19 +100,15 @@
// Error: 15 expected body
#for v in iter
// Should output `v in iter`.
// Error: 5 expected identifier
#for
v in iter {}
// Should output `A thing`.
// Error: 7-10 expected identifier, found string
A#for "v" thing
// Should output `in iter`.
// Error: 6-9 expected identifier, found string
#for "v" in iter {}
// Should output `+ b in iter`.
// Error: 7 expected keyword `in`
#for a + b in iter {}

10
tests/typ/code/if.typ
View File

@ -39,9 +39,16 @@
"Four" + point
}
// Template can be argument or body depending on whitespace.
{
if "template" == type[b] [Fi] else [Nope]
if "template" == type [Nope] else [ve.]
}
---
// Value of if expressions.
// Ref: false
{
let x = 1
let y = 2
@ -61,13 +68,12 @@
}
---
// Ref: false
// Condition must be boolean.
// If it isn't, neither branch is evaluated.
// Error: 5-14 expected boolean, found string
#if "a" + "b" { nope } #else { nope }
---
// Make sure that we don't complain twice.
// Error: 5-12 cannot add integer and string
#if 1 + "2" {}

27
tests/typ/code/import.typ
View File

@ -11,8 +11,7 @@
#let value = [foo]
// Import multiple things.
// Error: 9-10 expected expression, found comma
#import ,fn, value from "target.typ"
#import fn, value from "target.typ"
#fn[Like and Subscribe!]
#value
@ -24,10 +23,6 @@
#test(b, 1)
// This should not exist yet
// Error: 1-3 unknown variable
#d
// A wildcard import.
#import * from "target.typ"
@ -45,30 +40,35 @@
#import a, c, from "target.typ"
---
// Test bad imports.
// Ref: false
// Error: 19-21 file not found
#import name from ""
---
// Error: 16-27 file not found
#import * from "lib/0.2.1"
---
// Some non-text stuff.
// Error: 16-37 file is not valid utf-8
#import * from "../../res/rhino.png"
---
// Unresolved import.
// Error: 9-21 unresolved import
#import non_existing from "target.typ"
// Cyclic import.
// Error: 16-41 cyclic import
#import * from "./importable/cycle1.typ"
---
// Cyclic import of this very file.
// Error: 16-30 cyclic import
#import * from "./import.typ"
---
// Test bad syntax.
// Cyclic import in other file.
#import * from "./importable/cycle1.typ"
This is never reached.
---
// Error: 8 expected import items
// Error: 8 expected keyword `from`
#import
@ -100,7 +100,6 @@
#from "target.typ"
// Should output `target`.
// Error: 1:16-2:2 file not found
// Error: 2:2 expected semicolon or line break
#import * from "target.typ
"target

1
tests/typ/code/importable/cycle1.typ
View File

@ -1,6 +1,5 @@
// Ref: false
// Error: 16-28 cyclic import
#import * from "cycle2.typ"
#let inaccessible = "wow"

1
tests/typ/code/importable/cycle2.typ
View File

@ -1,6 +1,5 @@
// Ref: false
// Error: 16-28 cyclic import
#import * from "cycle1.typ"
#let val = "much cycle"

13
tests/typ/code/include.typ
View File

@ -6,18 +6,21 @@
// Include a file
#include "importable/chap1.typ"
// The variables of the file should not appear in this scope.
// Error: 1-6 unknown variable
#name
// Expression as a file name.
#let chap2 = include "import" + "able/chap" + "2.typ"
-- _Intermission_ --
#chap2
---
{
// Expressions, code mode.
// Error: 21-43 file not found
let x = include "importable/chap3.typ"
}
---
#include "importable/chap1.typ"
// The variables of the file should not appear in this scope.
// Error: 1-6 unknown variable
#name

48
tests/typ/code/let.typ
View File

@ -1,38 +1,19 @@
// Test let bindings.
---
// Ref: false
// Automatically initialized with none.
#let x
#test(x, none)
// Error: 9 expected expression
#let y =
#test(y, none)
// Manually initialized with one.
#let z = 1
#test(z, 1)
---
// Syntax sugar for function definitions.
#let fill = conifer
#let rect(body) = rect(width: 2cm, fill: fill, pad(5pt, body))
#rect[Hi!]
// Error: 13 expected body
#let func(x)
// Error: 2-6 unknown variable
{func}
// Error: 15 expected expression
#let func(x) =
// Error: 2-6 unknown variable
{func}
---
// Termination.
@ -47,20 +28,9 @@ One
#let v3 = 3;
Three
// Terminated because expression ends.
// Error: 12 expected semicolon or line break
#let v4 = 4 Four
// Terminated by semicolon even though we are in a paren group.
// Error: 19 expected expression
// Error: 19 expected closing paren
#let v5 = (1, 2 + ; Five
#test(v1, 1)
#test(v2, 2)
#test(v3, 3)
#test(v4, 4)
#test(v5, (1, 2))
---
// Error: 5 expected identifier
@ -72,13 +42,27 @@ Three
// Error: 6-9 expected identifier, found string
#let "v"
// Should output `1`.
// Error: 7 expected semicolon or line break
#let v 1
// Error: 9 expected expression
#let v =
// Should output a heading `1`.
// Error: 6-9 expected identifier, found string
#let "v" = 1
// Terminated because expression ends.
// Error: 12 expected semicolon or line break
#let v4 = 4 Four
// Terminated by semicolon even though we are in a paren group.
// Error: 19 expected expression
// Error: 19 expected closing paren
#let v5 = (1, 2 + ; Five
---
// Error: 13 expected body
#let func(x)
// Error: 15 expected expression
#let func(x) =

41
tests/typ/code/ops-invalid.typ
View File

@ -1,67 +1,84 @@
// Test invalid expressions.
// Test invalid operations.
// Ref: false
---
// Missing expressions.
// Error: 3 expected expression
{-}
---
// Error: 10 expected expression
#test({1+}, 1)
---
// Error: 10 expected expression
#test({2*}, 2)
---
// Mismatched types.
// Error: 2-12 cannot apply '+' to template
{+([] + [])}
---
// Error: 2-5 cannot apply '-' to string
{-""}
---
// Error: 2-8 cannot apply 'not' to array
{not ()}
---
// Error: 2-12 cannot apply '<=' to relative and relative
{30% <= 40%}
---
// Special messages for +, -, * and /.
// Error: 03-10 cannot add integer and string
// Error: 12-19 cannot subtract integer from relative
// Error: 21-29 cannot multiply integer with boolean
// Error: 31-39 cannot divide integer by length
{(1 + "2", 40% - 1, 2 * true, 3 / 12pt)}
{(1 + "2", 40% - 1)}
// Error: 14-22 cannot apply '+=' to integer and string
---
// Error: 12-19 cannot subtract integer from relative
{(1234567, 40% - 1)}
---
// Error: 2-10 cannot multiply integer with boolean
{2 * true}
---
// Error: 2-10 cannot divide integer by length
{3 / 12pt}
---
// Error: 14-22 cannot add integer and string
{ let x = 1; x += "2" }
---
// Error: 13-14 expected argument list, found integer
{ test with 2 }
---
// Error: 3-4 expected function, found integer
{ 1 with () }
---
// Error: 3-10 cannot apply '..' to integer and string
{ 1 .. "" }
---
// Bad left-hand sides of assignment.
// Error: 3-6 cannot assign to this expression
{ (x) = "" }
---
// Error: 3-8 cannot assign to this expression
{ 1 + 2 += 3 }
---
// Error: 3-4 unknown variable
{ z = 1 }
---
// Error: 3-7 cannot assign to a constant
{ rect = "hi" }
---
// Works if we define rect beforehand
// (since then it doesn't resolve to the standard library version anymore).
#let rect = ""

3
tests/typ/code/repr.typ
View File

@ -10,9 +10,6 @@
{ke-bab} \
{α}
// Error: 2-3 unknown variable
{_}
---
// Literal values.
{none} (empty) \

21
tests/typ/code/while.typ
View File

@ -29,23 +29,16 @@
#test(type(while i < 1 [{ i += 1 }]), "template")
---
// Ref: false
// Condition must be boolean.
// Error: 8-14 expected boolean, found template
#while [nope] [nope]
// Make sure that we don't complain twice.
// Error: 8-15 unknown variable
#while nothing {}
// Errors taint everything.
#let i = 0
#test(error, while i < 10 {
i += 1
if i < 5 [nope] else { error }
})
#test(i, 10)
---
// Make sure that we terminate and don't complain multiple times.
#while true {
// Error: 5-9 unknown variable
nope
}
---
// Error: 7 expected expression
@ -57,11 +50,9 @@
// Error: 9 expected body
#while x
// Should output `x`.
// Error: 7 expected expression
#while
x {}
// Should output `something`.
// Error: 9 expected body
#while x something

6
tests/typ/insert/circle.typ
View File

@ -39,9 +39,9 @@ Expanded by height.
---
// Radius wins over width and height.
// Error: 23-34 unexpected argument
// Error: 36-49 unexpected argument
#circle(radius: 10pt, width: 50pt, height: 100pt, fill: eastern)
---
// Width wins over height.
// Error: 22-34 unexpected argument
#circle(width: 20pt, height: 50pt, fill: eastern)
// Error: 9-21 unexpected argument
#circle(height: 50pt, width: 20pt, fill: eastern)

14
tests/typ/insert/image.typ
View File

@ -10,12 +10,6 @@
// Load an RGB JPEG image.
#image("../../res/tiger.jpg")
// Error: 8-29 file not found
#image("path/does/not/exist")
// Error: 8-21 failed to load image
#image("./image.typ")
---
// Test configuring the size and fitting behaviour of images.
@ -36,3 +30,11 @@
// Make sure the bounding-box of the image is correct.
#align(bottom, right, image("../../res/tiger.jpg", width: 60pt))
---
// Error: 8-29 file not found
#image("path/does/not/exist")
---
// Error: 8-21 failed to load image
#image("./image.typ")

11
tests/typ/insert/square.typ
View File

@ -9,12 +9,6 @@ Auto-sized square. \
Typst
]
---
// Length wins over width and height.
// Error: 09-20 unexpected argument
// Error: 22-34 unexpected argument
#square(width: 10cm, height: 20cm, length: 1cm, fill: rgb("eb5278"))
---
// Test height overflow.
#page!(width: 75pt, height: 100pt)
@ -28,3 +22,8 @@ Auto-sized square. \
#square(fill: conifer)[
But, soft! what light through yonder window breaks?
]
---
// Length wins over width and height.
// Error: 09-20 unexpected argument
#square(width: 10cm, height: 20cm, length: 1cm, fill: rgb("eb5278"))

18
tests/typ/layout/grid-3.typ
View File

@ -25,9 +25,9 @@
gutter-columns: (0pt, 10%),
image("../../res/rhino.png"),
align(right, rect(width: 100%, fill: eastern)[LoL]),
"rofl",
"\nA" * 3,
"Ha!\n" * 3,
[rofl],
[\ A] * 3,
[Ha!\ ] * 3,
)
---
@ -38,9 +38,9 @@
gutter-rows: (8pt,),
gutter-columns: (0pt, 10%),
[A], [B], [C],
"Ha!\n" * 6,
"rofl",
"\nA" * 3,
[Ha!\ ] * 6,
[rofl],
[\ A] * 3,
[hello],
[darkness],
[my old]
@ -54,10 +54,10 @@
gutter-rows: (10pt,),
gutter-columns: (0pt, 10%),
[A], [B], [C], [D],
grid(columns: 2, [A], [B], "C\n"*3, [D]),
grid(columns: 2, [A], [B], [C\ ]*3, [D]),
align(right, rect(width: 100%, fill: eastern)[LoL]),
"rofl",
"E\n"*4,
[rofl],
[E\ ]*4,
)
---

3
tests/typ/layout/pad.typ
View File

@ -10,8 +10,7 @@
#rect(width: 20pt, height: 20pt, fill: rgb("eb5278"))
]
// Error: 13-23 missing argument: body
Hi #box(pad(left: 10pt)) there
Hi #box(pad(left: 10pt)[]) there
---
#let pad(body) = pad(left: 10pt, right: 10pt, body)

3
tests/typ/layout/page.typ
View File

@ -22,9 +22,6 @@
// Ensure that specific margins override general margins.
#page(margins: 0pt, left: 20pt)[Overriden]
// Error: 8-19 unknown variable
#page!(nonexistant)
// Flipped predefined paper.
#page("a11", flip: true)[Flipped A11]

3
tests/typ/layout/pagebreak.typ
View File

@ -10,10 +10,7 @@ First of two
A
#box[
B
// Error: 16 cannot modify page from here
#pagebreak()
// Error: 11-15 cannot modify page from here
#page("a4")[]
]
C

1
tests/typ/layout/spacing.typ
View File

@ -13,6 +13,7 @@ Add #h(10pt) #h(10pt) up
// Relative to font size.
Relative #h(100%) spacing
---
// Missing spacing.
// Error: 12 missing argument: spacing
Totally #h() ignored

9
tests/typ/markup/escape.typ
View File

@ -21,14 +21,15 @@
// Escaped escape sequence.
\u{41} vs. \\u\{41\}
// Some code stuff in text.
let f() , ; : | + - /= == 12 "string"
---
// Unicode codepoint does not exist.
// Error: 1-11 invalid unicode escape sequence
\u{FFFFFF}
---
// Unterminated.
// Error: 6 expected closing brace
\u{41*Bold*
---
// Some code stuff in text.
let f() , ; : | + - /= == 12 "string"

31
tests/typ/text/decorations.typ
View File

@ -1,19 +1,34 @@
// Test text decorations.
---
#strike[Statements dreamt up by the utterly deranged.]
Sometimes, we work #strike(10pt, extent: 5%)[in secret].
There might be #strike(stroke: rgb("abcdef88"), thickness: 10pt, extent: 5%)[redacted]
things.
// Basic strikethrough.
#strike[
Statements dreamt up by the utterly deranged.
]
// Move underline down.
#underline(offset: 5pt)[Further below.]
---
// Different color.
#underline(rgb("fc0030"))[Critical information is conveyed here.]
#underline[Still important, but not #underline(0pt)[mission ]critical.]
// Inherits font color.
#font(fill: rgb("fc0030"), underline[Change with the wind.])
---
// Both over- and underline.
#overline(underline[Running amongst the wolves.])
// Disable underline by setting it back to 0pt.
#underline[Still important, but not #underline(0pt)[mission ]critical.]
---
#let redact = strike with (10pt, extent: 5%)
#let highlight = strike with (
stroke: rgb("abcdef88"),
thickness: 10pt,
extent: 5%,
)
// Abuse thickness and transparency for redacting and highlighting stuff.
Sometimes, we work #redact[in secret].
There might be #highlight[redacted] things.

26
tests/typ/text/font.typ
View File

@ -54,21 +54,25 @@ Emoji: 🐪, 🌋, 🏞
#font(monospace, monospace: ("Nope", "Latin Modern Math"))[Math.]
---
// Ref: false
// Error: 7-12 unexpected argument
#font(false)[]
---
// Error: 14-18 expected font style, found font weight
// Error: 28-34 expected font weight, found string
// Error: 43-44 expected string or array of strings, found integer
#font(style: bold, weight: "thin", serif: 0)[]
#font(style: bold, weight: "thin")[]
---
// Error: 14-15 expected string or array of strings, found integer
#font(serif: 0)[]
---
// Error: 19-23 unexpected argument
#font(size: 10pt, 12pt)[]
---
// Error: 28-35 unexpected argument
#font(family: "Helvetica", "Arial")[]
---
// Error: 7-27 unexpected argument
#font(something: "invalid")[]
// Error: 13-23 unexpected argument
#font(12pt, size: 10pt)[]
// Error: 16-35 unexpected argument
#font("Arial", family: "Helvetica")[]

6
tests/typ/text/whitespace.typ
View File

@ -2,16 +2,12 @@
---
// Spacing around let.
// Error: 6 expected identifier
A#let;B \
A#let x = 1;B #test(x, 1) \
A #let x = 2;B #test(x, 2) \
A#let x = 3; B #test(x, 3)
---
// Spacing around if-else.
A#if true [B]C \
A#if true [B] C \
A #if true{"B"}C \
@ -21,7 +17,6 @@ A#if true [B] #else [] C
---
// Spacing around while loop.
#let c = true; A#while c [{c = false}B]C \
#let c = true; A#while c [{c = false}B] C \
#let c = true; A #while c { c = false; "B" }C \
@ -29,7 +24,6 @@ A#if true [B] #else [] C
---
// Spacing around for loop.
A#for _ in (none,) [B]C \
A#for _ in (none,) [B] C \
A #for _ in (none,) {"B"}C

3
tests/typ/utility/basics.typ
View File

@ -3,14 +3,15 @@
---
// Test the `len` function.
#test(len(()), 0)
#test(len(("A", "B", "C")), 3)
#test(len("Hello World!"), 12)
#test(len((a: 1, b: 2)), 2)
---
// Error: 6 missing argument: collection
#len()
---
// Error: 6-10 expected string, array or dictionary
#len(12pt)

17
tests/typ/utility/color.typ
View File

@ -11,13 +11,14 @@
// Clamped.
#test(rgb(-30, 15.5, 0.5), rgb("00ff80"))
// Error: 11-15 missing argument: blue component
#test(rgb(0, 1), rgb("00ff00"))
---
// Error: 6-11 invalid color
#rgb("lol")
// Error: 11-16 invalid color
#test(rgb("lol"), error)
---
// Error: 6 missing argument: red component
#rgb()
// Error: 11 missing argument: red component
// Error: 11 missing argument: green component
// Error: 11 missing argument: blue component
#test(rgb(), black)
---
// Error: 6-10 missing argument: blue component
#rgb(0, 1)

2
tests/typ/utility/math.typ
View File

@ -8,8 +8,10 @@
#test(max(-3, 11), 11)
#test(min("hi"), "hi")
---
// Error: 6 missing argument: value
#min()
---
// Error: 11-18 cannot compare integer with string
#test(min(1, "hi"), error)

164
tests/typeset.rs
View File

@ -1,4 +1,3 @@
use std::cell::RefCell;
use std::env;
use std::ffi::OsStr;
use std::fs;
@ -11,20 +10,17 @@ use ttf_parser::{GlyphId, OutlineBuilder};
use walkdir::WalkDir;
use typst::color::Color;
use typst::diag::{Diag, DiagSet, Level};
use typst::eval::{eval, Scope, Value};
use typst::diag::{Error, TypResult};
use typst::eval::{eval, Value};
use typst::exec::{exec, State};
use typst::geom::{self, Length, PathElement, Point, Sides, Size};
use typst::image::ImageId;
use typst::layout::{layout, Element, Frame, Geometry, Paint, Text};
use typst::layout::{layout, Element, Frame, Geometry, LayoutTree, Paint, Text};
use typst::loading::{FileId, FsLoader};
use typst::parse::{parse, LineMap, Scanner};
use typst::syntax::{Location, Pos};
use typst::Context;
#[cfg(feature = "layout-cache")]
use typst::layout::LayoutTree;
const TYP_DIR: &str = "./typ";
const REF_DIR: &str = "./ref";
const PNG_DIR: &str = "./png";
@ -67,10 +63,22 @@ fn main() {
page.size = Size::new(Length::pt(120.0), Length::inf());
page.margins = Sides::splat(Some(Length::pt(10.0).into()));
// We hook up some extra test helpers into the global scope.
// Hook up an assert function into the global scope.
let mut std = typst::library::new();
let panics = Rc::new(RefCell::new(vec![]));
register_helpers(&mut std, Rc::clone(&panics));
std.def_func("test", move |_, args| {
let lhs = args.expect::<Value>("left-hand side")?;
let rhs = args.expect::<Value>("right-hand side")?;
if lhs != rhs {
typst::bail!(
args.file,
args.span,
"Assertion failed: {:?} != {:?}",
lhs,
rhs
);
}
Ok(Value::None)
});
// Create loader and context.
let loader = FsLoader::new().with_path(FONT_DIR).wrap();
@ -88,7 +96,6 @@ fn main() {
ok &= test(
&mut ctx,
loader.as_ref(),
&panics,
&src_path,
&png_path,
&ref_path,
@ -134,35 +141,9 @@ impl Args {
}
}
type Panics = Rc<RefCell<Vec<Panic>>>;
struct Panic {
pos: Pos,
lhs: Option<Value>,
rhs: Option<Value>,
}
fn register_helpers(scope: &mut Scope, panics: Rc<RefCell<Vec<Panic>>>) {
scope.def_const("error", Value::Error);
scope.def_func("args", |_, args| {
let repr = typst::pretty::pretty(args);
args.items.clear();
Value::template(move |ctx| ctx.push_monospace_text(&repr))
});
scope.def_func("test", move |ctx, args| {
let lhs = args.expect::<Value>(ctx, "left-hand side");
let rhs = args.expect::<Value>(ctx, "right-hand side");
if lhs != rhs {
panics.borrow_mut().push(Panic { pos: args.span.start, lhs, rhs });
}
Value::None
});
}
fn test(
ctx: &mut Context,
loader: &FsLoader,
panics: &Panics,
src_path: &Path,
png_path: &Path,
ref_path: &Path,
@ -171,8 +152,8 @@ fn test(
let name = src_path.strip_prefix(TYP_DIR).unwrap_or(src_path);
println!("Testing {}", name.display());
let file = loader.resolve(src_path).unwrap();
let src = fs::read_to_string(src_path).unwrap();
let src_id = loader.resolve(src_path).unwrap();
let mut ok = true;
let mut frames = vec![];
@ -196,7 +177,7 @@ fn test(
}
} else {
let (part_ok, compare_here, part_frames) =
test_part(ctx, panics, src_id, part, i, compare_ref, lines);
test_part(ctx, file, part, i, compare_ref, lines);
ok &= part_ok;
compare_ever |= compare_here;
frames.extend(part_frames);
@ -221,7 +202,7 @@ fn test(
println!(" Does not match reference image. ❌");
ok = false;
}
} else {
} else if !frames.is_empty() {
println!(" Failed to open reference image. ❌");
ok = false;
}
@ -236,71 +217,58 @@ fn test(
fn test_part(
ctx: &mut Context,
panics: &Panics,
src_id: FileId,
file: FileId,
src: &str,
i: usize,
compare_ref: bool,
lines: u32,
) -> (bool, bool, Vec<Rc<Frame>>) {
let map = LineMap::new(src);
let (local_compare_ref, ref_diags) = parse_metadata(src, &map);
let (local_compare_ref, mut ref_errors) = parse_metadata(file, src, &map);
let compare_ref = local_compare_ref.unwrap_or(compare_ref);
// Clear the module cache between tests.
ctx.modules.clear();
let ast = parse(src);
let module = eval(ctx, src_id, Rc::new(ast.output));
let tree = exec(ctx, &module.output.template);
let mut frames = layout(ctx, &tree.output);
let mut diags = ast.diags;
diags.extend(module.diags);
diags.extend(tree.diags);
let mut ok = true;
for panic in panics.borrow().iter() {
let line = map.location(panic.pos).unwrap().line;
println!(" Assertion failed in line {} ❌", lines + line);
if let (Some(lhs), Some(rhs)) = (&panic.lhs, &panic.rhs) {
println!(" Left: {:?}", lhs);
println!(" Right: {:?}", rhs);
} else {
println!(" Missing argument.");
let result = typeset(ctx, file, src);
let (frames, mut errors) = match result {
#[allow(unused_variables)]
Ok((tree, mut frames)) => {
#[cfg(feature = "layout-cache")]
(ok &= test_incremental(ctx, i, &tree, &frames));
if !compare_ref {
frames.clear();
}
(frames, vec![])
}
ok = false;
}
Err(errors) => (vec![], *errors),
};
panics.borrow_mut().clear();
// TODO: Also handle errors from other files.
errors.retain(|error| error.file == file);
ref_errors.sort();
errors.sort();
if diags != ref_diags {
println!(" Subtest {} does not match expected diagnostics. ❌", i);
if errors != ref_errors {
println!(" Subtest {} does not match expected errors. ❌", i);
ok = false;
for diag in &diags {
if !ref_diags.contains(diag) {
for error in errors.iter() {
if error.file == file && !ref_errors.contains(error) {
print!(" Not annotated | ");
print_diag(diag, &map, lines);
print_error(error, &map, lines);
}
}
for diag in &ref_diags {
if !diags.contains(diag) {
for error in ref_errors.iter() {
if !errors.contains(error) {
print!(" Not emitted | ");
print_diag(diag, &map, lines);
print_error(error, &map, lines);
}
}
}
#[cfg(feature = "layout-cache")]
(ok &= test_incremental(ctx, i, &tree.output, &frames));
if !compare_ref {
frames.clear();
}
(ok, compare_ref, frames)
}
@ -350,9 +318,9 @@ fn test_incremental(
ok
}
fn parse_metadata(src: &str, map: &LineMap) -> (Option<bool>, DiagSet) {
let mut diags = DiagSet::new();
fn parse_metadata(file: FileId, src: &str, map: &LineMap) -> (Option<bool>, Vec<Error>) {
let mut compare_ref = None;
let mut errors = vec![];
let lines: Vec<_> = src.lines().map(str::trim).collect();
for (i, line) in lines.iter().enumerate() {
@ -364,10 +332,8 @@ fn parse_metadata(src: &str, map: &LineMap) -> (Option<bool>, DiagSet) {
compare_ref = Some(true);
}
let (level, rest) = if let Some(rest) = line.strip_prefix("// Warning: ") {
(Level::Warning, rest)
} else if let Some(rest) = line.strip_prefix("// Error: ") {
(Level::Error, rest)
let rest = if let Some(rest) = line.strip_prefix("// Error: ") {
rest
} else {
continue;
};
@ -391,18 +357,30 @@ fn parse_metadata(src: &str, map: &LineMap) -> (Option<bool>, DiagSet) {
let start = pos(&mut s);
let end = if s.eat_if('-') { pos(&mut s) } else { start };
diags.insert(Diag::new(start .. end, level, s.rest().trim()));
errors.push(Error::new(file, start .. end, s.rest().trim()));
}
(compare_ref, diags)
(compare_ref, errors)
}
fn print_diag(diag: &Diag, map: &LineMap, lines: u32) {
let mut start = map.location(diag.span.start).unwrap();
let mut end = map.location(diag.span.end).unwrap();
fn typeset(
ctx: &mut Context,
file: FileId,
src: &str,
) -> TypResult<(LayoutTree, Vec<Rc<Frame>>)> {
let ast = parse(file, src)?;
let module = eval(ctx, file, Rc::new(ast))?;
let tree = exec(ctx, &module.template);
let frames = layout(ctx, &tree);
Ok((tree, frames))
}
fn print_error(error: &Error, map: &LineMap, lines: u32) {
let mut start = map.location(error.span.start).unwrap();
let mut end = map.location(error.span.end).unwrap();
start.line += lines;
end.line += lines;
println!("{}: {}-{}: {}", diag.level, start, end, diag.message);
println!("Error: {}-{}: {}", start, end, error.message);
}
fn draw(ctx: &Context, frames: &[Rc<Frame>], dpi: f32) -> sk::Pixmap {