konevsa/typst
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge Parsed and Layouted types into Pass with Feedback 🌝🎢🌚

Browse Source
This commit is contained in:
Laurenz 2020-02-04 19:22:23 +01:00
parent 5c11aa7223
commit e63ce52ae0
16 changed files with 233 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/bin/main.rs
View File

@ -42,7 +42,7 @@ fn run() -> Result<(), Box<dyn Error>> {
let provider = DebugErrorProvider::new(fs);
let typesetter = Typesetter::new((Box::new(provider), entries));
let layouts = block_on(typesetter.typeset(&src));
let layouts = block_on(typesetter.typeset(&src)).output;
let writer = BufWriter::new(File::create(&dest)?);
pdf::export(&layouts, typesetter.loader(), writer)?;

53
src/func.rs
View File

@ -1,6 +1,7 @@
//! Trait and prelude for custom functions.
use crate::syntax::{ParseContext, Parsed};
use crate::Pass;
use crate::syntax::ParseContext;
use crate::syntax::func::FuncHeader;
use crate::syntax::span::Spanned;
@ -36,7 +37,7 @@ pub trait ParseFunc {
body: Option<Spanned<&str>>,
ctx: ParseContext,
metadata: Self::Meta,
) -> Parsed<Self> where Self: Sized;
) -> Pass<Self> where Self: Sized;
}
/// Allows to implement a function type concisely.
@ -103,17 +104,16 @@ macro_rules! function {
// Parse trait.
(@parse($($a:tt)*) parse(default) $($r:tt)*) => {
function!(@parse($($a)*) parse(_h, _b, _c, _e, _d, _m) {Default::default() } $($r)*);
function!(@parse($($a)*) parse(_h, _b, _c, _f, _m) {Default::default() } $($r)*);
};
(@parse($($a:tt)*) parse($h:ident, $b:ident, $c:ident, $e:ident, $d:ident) $($r:tt)* ) => {
function!(@parse($($a)*) parse($h, $b, $c, $e, $d, _metadata) $($r)*);
(@parse($($a:tt)*) parse($h:ident, $b:ident, $c:ident, $f:ident) $($r:tt)* ) => {
function!(@parse($($a)*) parse($h, $b, $c, $f, _metadata) $($r)*);
};
(@parse($name:ident, $meta:ty) parse(
$header:ident,
$body:ident,
$ctx:ident,
$errors:ident,
$decos:ident,
$feedback:ident,
$metadata:ident
) $code:block $($r:tt)*) => {
impl $crate::func::ParseFunc for $name {
@ -124,42 +124,40 @@ macro_rules! function {
#[allow(unused)] $body: Option<$crate::syntax::span::Spanned<&str>>,
#[allow(unused)] $ctx: $crate::syntax::ParseContext,
#[allow(unused)] $metadata: Self::Meta,
) -> $crate::syntax::Parsed<Self> where Self: Sized {
let mut errors = vec![];
let mut decorations = vec![];
) -> $crate::Pass<Self> where Self: Sized {
let mut feedback = $crate::Feedback::new();
#[allow(unused)] let $header = &mut header;
#[allow(unused)] let $errors = &mut errors;
#[allow(unused)] let $decos = &mut decorations;
let output = $code;
#[allow(unused)] let $feedback = &mut feedback;
let func = $code;
for arg in header.args.into_iter() {
errors.push(err!(arg.span(); "unexpected argument"));
feedback.errors.push(err!(arg.span(); "unexpected argument"));
}
$crate::syntax::Parsed { output, errors, decorations }
$crate::Pass::new(func, feedback)
}
}
function!(@layout($name) $($r)*);
};
(@layout($name:ident) layout($this:ident, $ctx:ident, $errors:ident) $code:block) => {
(@layout($name:ident) layout($this:ident, $ctx:ident, $feedback:ident) $code:block) => {
impl $crate::syntax::Model for $name {
fn layout<'a, 'b, 't>(
#[allow(unused)] &'a $this,
#[allow(unused)] mut $ctx: $crate::layout::LayoutContext<'b>,
) -> $crate::layout::DynFuture<'t, $crate::layout::Layouted<
$crate::layout::Commands<'a>>
> where
) -> $crate::layout::DynFuture<'t, $crate::Pass<$crate::layout::Commands<'a>>>
where
'a: 't,
'b: 't,
Self: 't,
{
Box::pin(async move {
let mut errors = vec![];
#[allow(unused)] let $errors = &mut errors;
let output = $code;
$crate::layout::Layouted { output, errors }
let mut feedback = $crate::Feedback::new();
#[allow(unused)] let $feedback = &mut feedback;
let commands = $code;
$crate::Pass::new(commands, feedback)
})
}
}
@ -179,22 +177,21 @@ macro_rules! function {
/// from parsing.
#[macro_export]
macro_rules! body {
(opt: $body:expr, $ctx:expr, $errors:expr, $decos:expr) => ({
(opt: $body:expr, $ctx:expr, $feedback:expr) => ({
$body.map(|body| {
// Since the body span starts at the opening bracket of the body, we
// need to add 1 column to find out the start position of body
// content.
let start = body.span.start + $crate::syntax::span::Position::new(0, 1);
let parsed = $crate::syntax::parse(start, body.v, $ctx);
$errors.extend(parsed.errors);
$decos.extend(parsed.decorations);
$feedback.extend(parsed.feedback);
parsed.output
})
});
(nope: $body:expr, $errors:expr) => {
(nope: $body:expr, $feedback:expr) => {
if let Some(body) = $body {
$errors.push($crate::err!(body.span; "unexpected body"));
$feedback.errors.push($crate::err!(body.span; "unexpected body"));
}
};
}

3
src/layout/mod.rs
View File

@ -18,8 +18,7 @@ pub_use_mod!(model);
/// Basic types used across the layouting engine.
pub mod prelude {
pub use super::{
LayoutContext, layout, LayoutSpace,
Layouted, Commands,
LayoutContext, layout, LayoutSpace, Commands,
LayoutAxes, LayoutAlignment, LayoutExpansion
};
pub use super::GenericAxis::{self, *};

32
src/layout/model.rs
View File

@ -6,12 +6,12 @@ use std::future::Future;
use std::pin::Pin;
use smallvec::smallvec;
use crate::{Pass, Feedback};
use crate::GlobalFontLoader;
use crate::error::Errors;
use crate::style::{LayoutStyle, PageStyle, TextStyle};
use crate::size::{Size, Size2D};
use crate::syntax::{Model, SyntaxModel, Node};
use crate::syntax::span::{Spanned, Span, offset_spans};
use crate::syntax::span::{Span, Spanned};
use super::line::{LineLayouter, LineContext};
use super::text::{layout_text, TextContext};
use super::*;
@ -23,7 +23,7 @@ pub struct ModelLayouter<'a> {
ctx: LayoutContext<'a>,
layouter: LineLayouter,
style: LayoutStyle,
errors: Errors,
feedback: Feedback,
}
/// The context for layouting.
@ -51,15 +51,6 @@ pub struct LayoutContext<'a> {
pub debug: bool,
}
/// The result of layouting: Some layouted things and a list of errors.
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Layouted<T> {
/// The result of the layouting process.
pub output: T,
/// Errors that arose in the process of layouting.
pub errors: Errors,
}
/// A sequence of layouting commands.
pub type Commands<'a> = Vec<Command<'a>>;
@ -107,7 +98,7 @@ pub enum Command<'a> {
}
/// Layout a syntax model into a list of boxes.
pub async fn layout(model: &SyntaxModel, ctx: LayoutContext<'_>) -> Layouted<MultiLayout> {
pub async fn layout(model: &SyntaxModel, ctx: LayoutContext<'_>) -> Pass<MultiLayout> {
let mut layouter = ModelLayouter::new(ctx);
layouter.layout_syntax_model(model).await;
layouter.finish()
@ -132,7 +123,7 @@ impl<'a> ModelLayouter<'a> {
}),
style: ctx.style.clone(),
ctx,
errors: vec![],
feedback: Feedback::new(),
}
}
@ -151,7 +142,7 @@ impl<'a> ModelLayouter<'a> {
}).await;
// Add the errors generated by the model to the error list.
self.errors.extend(offset_spans(layouted.errors, model.span.start));
self.feedback.extend_offset(model.span.start, layouted.feedback);
for command in layouted.output {
self.execute_command(command, model.span).await;
@ -195,11 +186,8 @@ impl<'a> ModelLayouter<'a> {
}) }
/// Compute the finished list of boxes.
pub fn finish(self) -> Layouted<MultiLayout> {
Layouted {
output: self.layouter.finish(),
errors: self.errors,
}
pub fn finish(self) -> Pass<MultiLayout> {
Pass::new(self.layouter.finish(), self.feedback)
}
/// Execute a command issued by a model. When the command is errorful, the
@ -225,7 +213,7 @@ impl<'a> ModelLayouter<'a> {
BreakParagraph => self.layout_paragraph(),
BreakPage => {
if self.ctx.nested {
self.errors.push(err!(span;
self.feedback.errors.push(err!(span;
"page break cannot be issued from nested context"));
} else {
self.layouter.finish_space(true)
@ -238,7 +226,7 @@ impl<'a> ModelLayouter<'a> {
}
SetPageStyle(style) => {
if self.ctx.nested {
self.errors.push(err!(span;
self.feedback.errors.push(err!(span;
"page style cannot be changed from nested context"));
} else {
self.style.page = style;

81
src/lib.rs
View File

@ -26,10 +26,11 @@ use smallvec::smallvec;
use toddle::{Font, OwnedData};
use toddle::query::{FontLoader, FontProvider, SharedFontLoader, FontDescriptor};
use crate::layout::{Layouted, MultiLayout};
use crate::error::Error;
use crate::layout::MultiLayout;
use crate::style::{LayoutStyle, PageStyle, TextStyle};
use crate::syntax::{SyntaxModel, Scope, ParseContext, Parsed, parse};
use crate::syntax::span::Position;
use crate::syntax::{SyntaxModel, Scope, Decoration, ParseContext, parse};
use crate::syntax::span::{Position, SpanVec, offset_spans};
/// Declare a module and reexport all its contents.
@ -100,12 +101,12 @@ impl Typesetter {
}
/// Parse source code into a syntax tree.
pub fn parse(&self, src: &str) -> Parsed<SyntaxModel> {
pub fn parse(&self, src: &str) -> Pass<SyntaxModel> {
parse(Position::ZERO, src, ParseContext { scope: &self.scope })
}
/// Layout a syntax tree and return the produced layout.
pub async fn layout(&self, model: &SyntaxModel) -> Layouted<MultiLayout> {
pub async fn layout(&self, model: &SyntaxModel) -> Pass<MultiLayout> {
use crate::layout::prelude::*;
let margins = self.style.page.margins();
@ -130,9 +131,73 @@ impl Typesetter {
}
/// Process source code directly into a collection of layouts.
pub async fn typeset(&self, src: &str) -> MultiLayout {
let tree = self.parse(src).output;
self.layout(&tree).await.output
pub async fn typeset(&self, src: &str) -> Pass<MultiLayout> {
let parsed = self.parse(src);
let layouted = self.layout(&parsed.output).await;
let feedback = Feedback::merge(parsed.feedback, layouted.feedback);
Pass::new(layouted.output, feedback)
}
}
/// The result of some pass: Some output `T` and feedback data.
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Pass<T> {
/// The output of this compilation pass.
pub output: T,
/// User feedback data accumulated in this pass.
pub feedback: Feedback,
}
impl<T> Pass<T> {
/// Create a new pass from output and feedback data.
pub fn new(output: T, feedback: Feedback) -> Pass<T> {
Pass { output, feedback }
}
/// Map the output type and keep the feedback data.
pub fn map<F, U>(self, f: F) -> Pass<U> where F: FnOnce(T) -> U {
Pass {
output: f(self.output),
feedback: self.feedback,
}
}
}
/// User feedback data accumulated during a compilation pass.
#[derive(Debug, Default, Clone, Eq, PartialEq)]
pub struct Feedback {
/// Errors in the source.
pub errors: SpanVec<Error>,
/// Decorations of the source code for semantic syntax highlighting.
pub decos: SpanVec<Decoration>,
}
impl Feedback {
/// Create a new feedback instance without errors and decos.
pub fn new() -> Feedback {
Feedback {
errors: vec![],
decos: vec![],
}
}
/// Merged two feedbacks into one.
pub fn merge(mut a: Feedback, b: Feedback) -> Feedback {
a.extend(b);
a
}
/// Add other feedback data to this feedback.
pub fn extend(&mut self, other: Feedback) {
self.errors.extend(other.errors);
self.decos.extend(other.decos);
}
/// Add more feedback whose spans are local and need to be offset by an
/// `offset` to be correct for this feedbacks context.
pub fn extend_offset(&mut self, offset: Position, other: Feedback) {
self.errors.extend(offset_spans(offset, other.errors));
self.decos.extend(offset_spans(offset, other.decos));
}
}

32
src/library/font.rs
View File

@ -11,10 +11,10 @@ function! {
list: Vec<String>,
}
parse(header, body, ctx, errors, decos) {
parse(header, body, ctx, f) {
FontFamilyFunc {
body: body!(opt: body, ctx, errors, decos),
list: header.args.pos.get_all::<StringLike>(errors)
body: body!(opt: body, ctx, f),
list: header.args.pos.get_all::<StringLike>(&mut f.errors)
.map(|s| s.0.to_lowercase())
.collect(),
}
@ -37,11 +37,11 @@ function! {
style: Option<FontStyle>,
}
parse(header, body, ctx, errors, decos) {
parse(header, body, ctx, f) {
FontStyleFunc {
body: body!(opt: body, ctx, errors, decos),
style: header.args.pos.get::<FontStyle>(errors)
.or_missing(errors, header.name.span, "style"),
body: body!(opt: body, ctx, f),
style: header.args.pos.get::<FontStyle>(&mut f.errors)
.or_missing(&mut f.errors, header.name.span, "style"),
}
}
@ -58,19 +58,19 @@ function! {
weight: Option<FontWeight>,
}
parse(header, body, ctx, errors, decos) {
let body = body!(opt: body, ctx, errors, decos);
let weight = header.args.pos.get::<Spanned<(FontWeight, bool)>>(errors)
parse(header, body, ctx, f) {
let body = body!(opt: body, ctx, f);
let weight = header.args.pos.get::<Spanned<(FontWeight, bool)>>(&mut f.errors)
.map(|Spanned { v: (weight, is_clamped), span }| {
if is_clamped {
errors.push(err!(@Warning: span;
f.errors.push(err!(@Warning: span;
"weight should be between \
100 and 900, clamped to {}", weight.0));
}
weight
})
.or_missing(errors, header.name.span, "weight");
.or_missing(&mut f.errors, header.name.span, "weight");
FontWeightFunc { body, weight }
}
@ -88,11 +88,11 @@ function! {
size: Option<FSize>,
}
parse(header, body, ctx, errors, decos) {
parse(header, body, ctx, f) {
FontSizeFunc {
body: body!(opt: body, ctx, errors, decos),
size: header.args.pos.get::<FSize>(errors)
.or_missing(errors, header.name.span, "size")
body: body!(opt: body, ctx, f),
size: header.args.pos.get::<FSize>(&mut f.errors)
.or_missing(&mut f.errors, header.name.span, "size")
}
}

42
src/library/layout.rs
View File

@ -10,17 +10,17 @@ function! {
map: PosAxisMap<AlignmentValue>,
}
parse(header, body, ctx, errors, decos) {
parse(header, body, ctx, f) {
AlignFunc {
body: body!(opt: body, ctx, errors, decos),
map: PosAxisMap::parse::<AxisKey>(errors, &mut header.args),
body: body!(opt: body, ctx, f),
map: PosAxisMap::parse::<AxisKey>(&mut f.errors, &mut header.args),
}
}
layout(self, ctx, errors) {
layout(self, ctx, f) {
ctx.base = ctx.spaces[0].dimensions;
let map = self.map.dedup(errors, ctx.axes, |alignment| {
let map = self.map.dedup(&mut f.errors, ctx.axes, |alignment| {
alignment.axis().map(|s| s.to_generic(ctx.axes))
});
@ -29,7 +29,7 @@ function! {
if let Some(generic) = alignment.to_generic(ctx.axes, axis) {
*ctx.alignment.get_mut(axis) = generic;
} else {
errors.push(err!(span;
f.errors.push(err!(span;
"invalid alignment `{}` for {} axis", alignment, axis));
}
}
@ -38,7 +38,7 @@ function! {
match &self.body {
Some(body) => {
let layouted = layout(body, ctx).await;
errors.extend(layouted.errors);
f.extend(layouted.feedback);
vec![AddMultiple(layouted.output)]
}
None => vec![SetAlignment(ctx.alignment)],
@ -55,18 +55,18 @@ function! {
map: PosAxisMap<Direction>,
}
parse(header, body, ctx, errors, decos) {
parse(header, body, ctx, f) {
DirectionFunc {
name_span: header.name.span,
body: body!(opt: body, ctx, errors, decos),
map: PosAxisMap::parse::<AxisKey>(errors, &mut header.args),
body: body!(opt: body, ctx, f),
map: PosAxisMap::parse::<AxisKey>(&mut f.errors, &mut header.args),
}
}
layout(self, ctx, errors) {
layout(self, ctx, f) {
ctx.base = ctx.spaces[0].dimensions;
let map = self.map.dedup(errors, ctx.axes, |direction| {
let map = self.map.dedup(&mut f.errors, ctx.axes, |direction| {
Some(direction.axis().to_generic(ctx.axes))
});
@ -76,7 +76,7 @@ function! {
map.with(Secondary, |&dir| axes.secondary = dir);
if axes.primary.axis() == axes.secondary.axis() {
errors.push(err!(self.name_span;
f.errors.push(err!(self.name_span;
"invalid aligned primary and secondary axes: `{}`, `{}`",
ctx.axes.primary, ctx.axes.secondary));
} else {
@ -86,7 +86,7 @@ function! {
match &self.body {
Some(body) => {
let layouted = layout(body, ctx).await;
errors.extend(layouted.errors);
f.extend(layouted.feedback);
vec![AddMultiple(layouted.output)]
}
None => vec![SetAxes(ctx.axes)],
@ -103,15 +103,15 @@ function! {
debug: Option<bool>,
}
parse(header, body, ctx, errors, decos) {
parse(header, body, ctx, f) {
BoxFunc {
body: body!(opt: body, ctx, errors, decos).unwrap_or(SyntaxModel::new()),
extents: AxisMap::parse::<ExtentKey>(errors, &mut header.args.key),
debug: header.args.key.get::<bool>(errors, "debug"),
body: body!(opt: body, ctx, f).unwrap_or(SyntaxModel::new()),
extents: AxisMap::parse::<ExtentKey>(&mut f.errors, &mut header.args.key),
debug: header.args.key.get::<bool>(&mut f.errors, "debug"),
}
}
layout(self, ctx, errors) {
layout(self, ctx, f) {
ctx.repeat = false;
ctx.spaces.truncate(1);
@ -119,7 +119,7 @@ function! {
ctx.debug = debug;
}
let map = self.extents.dedup(errors, ctx.axes);
let map = self.extents.dedup(&mut f.errors, ctx.axes);
for &axis in &[Horizontal, Vertical] {
if let Some(psize) = map.get(axis) {
let size = psize.scaled(ctx.base.get(axis));
@ -131,7 +131,7 @@ function! {
let layouted = layout(&self.body, ctx).await;
let layout = layouted.output.into_iter().next().unwrap();
errors.extend(layouted.errors);
f.extend(layouted.feedback);
vec![Add(layout)]
}

4
src/library/mod.rs
View File

@ -53,8 +53,8 @@ function! {
body: Option<SyntaxModel>,
}
parse(header, body, ctx, errors, decos) {
ValFunc { body: body!(opt: body, ctx, errors, decos) }
parse(header, body, ctx, f) {
ValFunc { body: body!(opt: body, ctx, f) }
}
layout(self, ctx, errors) {

24
src/library/page.rs
View File

@ -12,16 +12,16 @@ function! {
flip: bool,
}
parse(header, body, ctx, errors, decos) {
body!(nope: body, errors);
parse(header, body, ctx, f) {
body!(nope: body, f);
PageSizeFunc {
paper: header.args.pos.get::<Paper>(errors),
extents: AxisMap::parse::<ExtentKey>(errors, &mut header.args.key),
flip: header.args.key.get::<bool>(errors, "flip").unwrap_or(false),
paper: header.args.pos.get::<Paper>(&mut f.errors),
extents: AxisMap::parse::<ExtentKey>(&mut f.errors, &mut header.args.key),
flip: header.args.key.get::<bool>(&mut f.errors, "flip").unwrap_or(false),
}
}
layout(self, ctx, errors) {
layout(self, ctx, f) {
let mut style = ctx.style.page;
if let Some(paper) = self.paper {
@ -31,7 +31,7 @@ function! {
style.class = PaperClass::Custom;
}
let map = self.extents.dedup(errors, ctx.axes);
let map = self.extents.dedup(&mut f.errors, ctx.axes);
map.with(Horizontal, |&width| style.dimensions.x = width);
map.with(Vertical, |&height| style.dimensions.y = height);
@ -50,16 +50,16 @@ function! {
padding: PaddingMap,
}
parse(header, body, ctx, errors, decos) {
body!(nope: body, errors);
parse(header, body, ctx, f) {
body!(nope: body, f);
PageMarginsFunc {
padding: PaddingMap::parse(errors, &mut header.args),
padding: PaddingMap::parse(&mut f.errors, &mut header.args),
}
}
layout(self, ctx, errors) {
layout(self, ctx, f) {
let mut style = ctx.style.page;
self.padding.apply(errors, ctx.axes, &mut style.margins);
self.padding.apply(&mut f.errors, ctx.axes, &mut style.margins);
vec![SetPageStyle(style)]
}
}

18
src/library/spacing.rs
View File

@ -46,13 +46,13 @@ function! {
type Meta = ContentKind;
parse(header, body, ctx, errors, decos, meta) {
parse(header, body, ctx, f, meta) {
ContentSpacingFunc {
body: body!(opt: body, ctx, errors, decos),
body: body!(opt: body, ctx, f),
content: meta,
spacing: header.args.pos.get::<f64>(errors)
spacing: header.args.pos.get::<f64>(&mut f.errors)
.map(|num| num as f32)
.or_missing(errors, header.name.span, "spacing"),
.or_missing(&mut f.errors, header.name.span, "spacing"),
}
}
@ -84,15 +84,15 @@ function! {
type Meta = Option<SpecificAxis>;
parse(header, body, ctx, errors, decos, meta) {
body!(nope: body, errors);
parse(header, body, ctx, f, meta) {
body!(nope: body, f);
SpacingFunc {
spacing: if let Some(axis) = meta {
header.args.pos.get::<FSize>(errors)
header.args.pos.get::<FSize>(&mut f.errors)
.map(|s| (AxisKey::Specific(axis), s))
} else {
header.args.key.get_with_key::<AxisKey, FSize>(errors)
}.or_missing(errors, header.name.span, "spacing"),
header.args.key.get_with_key::<AxisKey, FSize>(&mut f.errors)
}.or_missing(&mut f.errors, header.name.span, "spacing"),
}
}

18
src/syntax/mod.rs
View File

@ -5,7 +5,8 @@ use std::fmt::Debug;
use async_trait::async_trait;
use serde::Serialize;
use crate::layout::{LayoutContext, Layouted, Commands, Command};
use crate::{Pass, Feedback};
use crate::layout::{LayoutContext, Commands, Command};
use self::span::{Spanned, SpanVec};
pub mod expr;
@ -25,10 +26,7 @@ mod test;
pub trait Model: Debug + ModelBounds {
/// Layout the model into a sequence of commands processed by a
/// [`ModelLayouter`](crate::layout::ModelLayouter).
async fn layout<'a>(
&'a self,
ctx: LayoutContext<'_>,
) -> Layouted<Commands<'a>>;
async fn layout<'a>(&'a self, ctx: LayoutContext<'_>) -> Pass<Commands<'a>>;
}
/// A tree representation of source code.
@ -52,14 +50,8 @@ impl SyntaxModel {
#[async_trait(?Send)]
impl Model for SyntaxModel {
async fn layout<'a>(
&'a self,
_: LayoutContext<'_>,
) -> Layouted<Commands<'a>> {
Layouted {
output: vec![Command::LayoutSyntaxModel(self)],
errors: vec![],
}
async fn layout<'a>(&'a self, _: LayoutContext<'_>) -> Pass<Commands<'a>> {
Pass::new(vec![Command::LayoutSyntaxModel(self)], Feedback::new())
}
}

78
src/syntax/parsing.rs
View File

@ -1,10 +1,10 @@
//! Parsing of source code into syntax models.
use crate::error::Errors;
use crate::{Pass, Feedback};
use super::expr::*;
use super::func::{FuncHeader, FuncArgs, FuncArg};
use super::scope::Scope;
use super::span::{Position, Span, Spanned, SpanVec, offset_spans};
use super::span::{Position, Span, Spanned};
use super::tokens::{Token, Tokens, TokenizationMode};
use super::*;
@ -16,36 +16,12 @@ pub struct ParseContext<'a> {
pub scope: &'a Scope,
}
/// The result of parsing: Some parsed thing, errors and decorations for syntax
/// highlighting.
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Parsed<T> {
/// The result of the parsing process.
pub output: T,
/// Errors that arose in the parsing process.
pub errors: Errors,
/// Decorations for semantic syntax highlighting.
pub decorations: SpanVec<Decoration>,
}
impl<T> Parsed<T> {
/// Map the output type and keep errors and decorations.
pub fn map<F, U>(self, f: F) -> Parsed<U> where F: FnOnce(T) -> U {
Parsed {
output: f(self.output),
errors: self.errors,
decorations: self.decorations,
}
}
}
/// Parse source code into a syntax model.
///
/// All errors and decorations are offset by the `start` position.
pub fn parse(start: Position, src: &str, ctx: ParseContext) -> Parsed<SyntaxModel> {
pub fn parse(start: Position, src: &str, ctx: ParseContext) -> Pass<SyntaxModel> {
let mut model = SyntaxModel::new();
let mut errors = Vec::new();
let mut decorations = Vec::new();
let mut feedback = Feedback::new();
// We always start in body mode. The header tokenization mode is only used
// in the `FuncParser`.
@ -64,16 +40,12 @@ pub fn parse(start: Position, src: &str, ctx: ParseContext) -> Parsed<SyntaxMode
},
Token::Function { header, body, terminated } => {
let parsed: Parsed<Node> = FuncParser::new(header, body, ctx).parse();
// Collect the errors and decorations from the function parsing,
// but offset their spans by the start of the function since
// they are function-local.
errors.extend(offset_spans(parsed.errors, span.start));
decorations.extend(offset_spans(parsed.decorations, span.start));
let parsed = FuncParser::new(header, body, ctx).parse();
feedback.extend_offset(span.start, parsed.feedback);
if !terminated {
errors.push(err!(Span::at(span.end); "expected closing bracket"));
feedback.errors.push(err!(Span::at(span.end);
"expected closing bracket"));
}
parsed.output
@ -87,7 +59,7 @@ pub fn parse(start: Position, src: &str, ctx: ParseContext) -> Parsed<SyntaxMode
Token::LineComment(_) | Token::BlockComment(_) => continue,
other => {
errors.push(err!(span; "unexpected {}", other.name()));
feedback.errors.push(err!(span; "unexpected {}", other.name()));
continue;
}
};
@ -95,14 +67,13 @@ pub fn parse(start: Position, src: &str, ctx: ParseContext) -> Parsed<SyntaxMode
model.add(Spanned { v: node, span: token.span });
}
Parsed { output: model, errors, decorations }
Pass::new(model, feedback)
}
/// Performs the function parsing.
struct FuncParser<'s> {
ctx: ParseContext<'s>,
errors: Errors,
decorations: SpanVec<Decoration>,
feedback: Feedback,
/// ```typst
/// [tokens][body]
@ -129,8 +100,7 @@ impl<'s> FuncParser<'s> {
) -> FuncParser<'s> {
FuncParser {
ctx,
errors: vec![],
decorations: vec![],
feedback: Feedback::new(),
tokens: Tokens::new(Position::new(0, 1), header, TokenizationMode::Header),
peeked: None,
body,
@ -138,7 +108,7 @@ impl<'s> FuncParser<'s> {
}
/// Do the parsing.
fn parse(mut self) -> Parsed<Node> {
fn parse(mut self) -> Pass<Node> {
let parsed = if let Some(header) = self.parse_func_header() {
let name = header.name.v.as_str();
let (parser, deco) = match self.ctx.scope.get_parser(name) {
@ -147,12 +117,12 @@ impl<'s> FuncParser<'s> {
// The fallback parser was returned. Invalid function.
Err(parser) => {
self.errors.push(err!(header.name.span; "unknown function"));
self.feedback.errors.push(err!(header.name.span; "unknown function"));
(parser, Decoration::InvalidFuncName)
}
};
self.decorations.push(Spanned::new(deco, header.name.span));
self.feedback.decos.push(Spanned::new(deco, header.name.span));
parser(header, self.body, self.ctx)
} else {
@ -166,14 +136,9 @@ impl<'s> FuncParser<'s> {
self.ctx.scope.get_fallback_parser()(default, self.body, self.ctx)
};
self.errors.extend(parsed.errors);
self.decorations.extend(parsed.decorations);
self.feedback.extend(parsed.feedback);
Parsed {
output: Node::Model(parsed.output),
errors: self.errors,
decorations: self.decorations,
}
Pass::new(Node::Model(parsed.output), self.feedback)
}
/// Parse the header tokens.
@ -235,7 +200,7 @@ impl<'s> FuncParser<'s> {
self.eat();
self.skip_whitespace();
self.decorations.push(Spanned::new(Decoration::ArgumentKey, span));
self.feedback.decos.push(Spanned::new(Decoration::ArgumentKey, span));
self.parse_expr().map(|value| {
FuncArg::Key(Pair {
@ -332,14 +297,14 @@ impl<'s> FuncParser<'s> {
/// Add an error about an expected `thing` which was not found, showing
/// what was found instead.
fn expected_found(&mut self, thing: &str, found: Spanned<Token>) {
self.errors.push(err!(found.span;
self.feedback.errors.push(err!(found.span;
"expected {}, found {}", thing, found.v.name()));
}
/// Add an error about an `thing` which was expected but not found at the
/// given position.
fn expected_at(&mut self, thing: &str, pos: Position) {
self.errors.push(err!(Span::at(pos); "expected {}", thing));
self.feedback.errors.push(err!(Span::at(pos); "expected {}", thing));
}
/// Add a expected-found-error if `found` is `Some` and an expected-error
@ -434,7 +399,8 @@ mod tests {
macro_rules! e {
($s:expr => [$(($sl:tt:$sc:tt, $el:tt:$ec:tt, $e:expr)),* $(,)?]) => {
let ctx = ParseContext { scope: &scope() };
let errors = parse(Position::ZERO, $s, ctx).errors
let errors = parse(Position::ZERO, $s, ctx).feedback
.errors
.into_iter()
.map(|s| s.map(|e| e.message))
.collect::<Vec<_>>();

5
src/syntax/scope.rs
View File

@ -3,9 +3,10 @@
use std::collections::HashMap;
use std::fmt::{self, Debug, Formatter};
use crate::Pass;
use crate::func::ParseFunc;
use super::func::FuncHeader;
use super::parsing::{ParseContext, Parsed};
use super::parsing::ParseContext;
use super::span::Spanned;
use super::Model;
@ -75,7 +76,7 @@ type Parser = dyn Fn(
FuncHeader,
Option<Spanned<&str>>,
ParseContext,
) -> Parsed<Box<dyn Model>>;
) -> Pass<Box<dyn Model>>;
fn parser<F>(metadata: <F as ParseFunc>::Meta) -> Box<Parser>
where F: ParseFunc + Model + 'static {

5
src/syntax/span.rs
View File

@ -160,6 +160,7 @@ pub type SpanVec<T> = Vec<Spanned<T>>;
/// [Offset](Span::offset) all spans in a vector of spanned things by a start
/// position.
pub fn offset_spans<T>(vec: SpanVec<T>, start: Position) -> impl Iterator<Item=Spanned<T>> {
vec.into_iter().map(move |s| s.map_span(|span| span.offset(start)))
pub fn offset_spans<T>(start: Position, vec: SpanVec<T>) -> impl Iterator<Item=Spanned<T>> {
vec.into_iter()
.map(move |s| s.map_span(|span| span.offset(start)))
}

4
src/syntax/test.rs
View File

@ -12,13 +12,13 @@ function! {
pub body: Option<SyntaxModel>,
}
parse(header, body, ctx, errors, decos) {
parse(header, body, ctx, f) {
let cloned = header.clone();
header.args.pos.items.clear();
header.args.key.pairs.clear();
DebugFn {
header: cloned,
body: body!(opt: body, ctx, errors, decos),
body: body!(opt: body, ctx, f),
}
}

60
tests/src/typeset.rs
View File

@ -5,6 +5,7 @@ use std::fs::{File, create_dir_all, read_dir, read_to_string};
use std::io::{BufWriter, Write};
use std::panic;
use std::process::Command;
use std::time::{Instant, Duration};
use futures_executor::block_on;
@ -55,8 +56,6 @@ fn main() -> DynResult<()> {
}).ok();
}
println!();
Ok(())
}
@ -121,43 +120,40 @@ fn test(name: &str, src: &str) -> DynResult<()> {
/// Compile the source code with the typesetter.
fn compile(typesetter: &Typesetter, src: &str) -> MultiLayout {
#![allow(unused_variables)]
use std::time::Instant;
if cfg!(debug_assertions) {
let typeset = block_on(typesetter.typeset(src));
let errors = typeset.feedback.errors;
// Warmup.
#[cfg(not(debug_assertions))]
let warmup = {
let warmup_start = Instant::now();
block_on(typesetter.typeset(&src));
Instant::now() - warmup_start
};
if !errors.is_empty() {
for error in errors {
println!(" {:?} {:?}: {}",
error.v.severity,
error.span,
error.v.message
);
}
}
let start = Instant::now();
let parsed = typesetter.parse(&src);
let parse = Instant::now() - start;
typeset.output
} else {
fn measure<T>(f: impl FnOnce() -> T) -> (T, Duration) {
let start = Instant::now();
let output = f();
let duration = Instant::now() - start;
(output, duration)
};
if !parsed.errors.is_empty() {
println!("parse errors: {:#?}", parsed.errors);
}
let (_, cold) = measure(|| block_on(typesetter.typeset(src)));
let (model, parse) = measure(|| typesetter.parse(src).output);
let (layouts, layout) = measure(|| block_on(typesetter.layout(&model)).output);
let start_layout = Instant::now();
let layouted = block_on(typesetter.layout(&parsed.output));
let layout = Instant::now() - start_layout;
let total = Instant::now() - start;
if !layouted.errors.is_empty() {
println!("layout errors: {:#?}", layouted.errors);
}
#[cfg(not(debug_assertions))] {
println!(" - cold start: {:?}", warmup);
println!(" - warmed up: {:?}", total);
println!(" - cold start: {:?}", cold);
println!(" - warmed up: {:?}", parse + layout);
println!(" - parsing: {:?}", parse);
println!(" - layouting: {:?}", layout);
println!();
}
layouted.output
layouts
}
}
/// Command line options.