feat: evaluate simple constant expressions for columns

Author: QuadnucYard

crates/typstyle-core/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod attr;
 pub mod ext;
+pub mod liteval;
 pub mod partial;
 pub mod pretty;
 

crates/typstyle-core/src/liteval/mod.rs

@@ -0,0 +1,145 @@
+//! Evaluate simple constant Typst expressions in code mode without scopes or VMs.
+//!
+//! Currently, this is only used for determine table columns.
+
+use typst_syntax::ast::*;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Value {
+    None,
+    Auto,
+    Int(i64),
+    /// Only represented by length.
+    Array(usize),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum EvalError {
+    NotSupported,
+    InvalidOperation,
+}
+
+pub type EvalResult = Result<Value, EvalError>;
+
+pub trait Liteval {
+    fn liteval(&self) -> EvalResult;
+}
+
+impl Liteval for Expr<'_> {
+    fn liteval(&self) -> EvalResult {
+        match self {
+            Expr::None(v) => v.liteval(),
+            Expr::Auto(v) => v.liteval(),
+            Expr::Int(v) => v.liteval(),
+            Expr::Parenthesized(v) => v.liteval(),
+            Expr::Array(v) => v.liteval(),
+            Expr::Unary(v) => v.liteval(),
+            Expr::Binary(v) => v.liteval(),
+            _ => Err(EvalError::NotSupported),
+        }
+    }
+}
+
+impl Liteval for None<'_> {
+    fn liteval(&self) -> EvalResult {
+        Ok(Value::None)
+    }
+}
+
+impl Liteval for Auto<'_> {
+    fn liteval(&self) -> EvalResult {
+        Ok(Value::Auto)
+    }
+}
+
+impl Liteval for Int<'_> {
+    fn liteval(&self) -> EvalResult {
+        Ok(Value::Int(self.get()))
+    }
+}
+
+impl Liteval for Parenthesized<'_> {
+    fn liteval(&self) -> EvalResult {
+        self.expr().liteval()
+    }
+}
+
+impl Liteval for Array<'_> {
+    fn liteval(&self) -> EvalResult {
+        Ok(Value::Array(self.items().count()))
+    }
+}
+
+impl Liteval for Unary<'_> {
+    fn liteval(&self) -> EvalResult {
+        let expr = self.expr().liteval()?;
+        match self.op() {
+            UnOp::Pos => match expr {
+                Value::Int(i) => Ok(Value::Int(i)),
+                _ => Err(EvalError::InvalidOperation),
+            },
+            UnOp::Neg => match expr {
+                Value::Int(i) => Ok(Value::Int(-i)),
+                _ => Err(EvalError::InvalidOperation),
+            },
+            UnOp::Not => Err(EvalError::NotSupported),
+        }
+    }
+}
+impl Liteval for Binary<'_> {
+    fn liteval(&self) -> EvalResult {
+        let lhs = self.lhs().liteval()?;
+        let rhs = self.rhs().liteval()?;
+        match self.op() {
+            BinOp::Add => match (lhs, rhs) {
+                (Value::Int(l), Value::Int(r)) => Ok(Value::Int(l + r)),
+                (Value::Array(l), Value::Array(r)) => Ok(Value::Array(l + r)),
+                _ => Err(EvalError::InvalidOperation),
+            },
+            BinOp::Sub => match (lhs, rhs) {
+                (Value::Int(l), Value::Int(r)) => Ok(Value::Int(l - r)),
+                _ => Err(EvalError::InvalidOperation),
+            },
+            BinOp::Mul => match (lhs, rhs) {
+                (Value::Int(l), Value::Int(r)) => Ok(Value::Int(l * r)),
+                (Value::Array(l), Value::Int(r)) if r >= 0 => Ok(Value::Array(l * r as usize)),
+                (Value::Int(l), Value::Array(r)) if l >= 0 => Ok(Value::Array(l as usize * r)),
+                _ => Err(EvalError::InvalidOperation),
+            },
+            BinOp::Div => match (lhs, rhs) {
+                (Value::Int(l), Value::Int(r)) if r != 0 => Ok(Value::Int(l / r)),
+                _ => Err(EvalError::InvalidOperation),
+            },
+            _ => Err(EvalError::NotSupported),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn test_liteval(code: &str, expected: Value) {
+        let root = typst_syntax::parse_code(code);
+        let expr = root.cast::<Code>().unwrap().exprs().next().unwrap();
+        assert_eq!(expr.liteval(), Ok(expected), "expr: {expr:#?}");
+    }
+
+    #[test]
+    fn test_simple_expr() {
+        use Value::*;
+
+        test_liteval("none", None);
+        test_liteval("auto", Auto);
+        test_liteval("0", Int(0));
+        test_liteval("1 + 2", Int(3));
+        test_liteval("1 * 2", Int(2));
+        test_liteval("1 - 2", Int(-1));
+        test_liteval("(1 + 2) * 3", Int(9));
+        test_liteval("(1fr,)", Array(1));
+        test_liteval("(1pt, 2em) * 3", Array(6));
+        test_liteval("(1, 2) + (3, 4, 5)", Array(5));
+        test_liteval("(1,) * 2 + 2 * (3, 4)", Array(6));
+        test_liteval("((1,) * 2 + 2 * (3,)) * 4", Array(16));
+    }
+}

crates/typstyle-core/src/pretty/table.rs

@@ -93,6 +93,8 @@ fn is_table_formattable(func_call: FuncCall<'_>) -> bool {
 }
 
 fn get_table_columns(func_call: FuncCall<'_>) -> Option<usize> {
+    use crate::liteval::{Liteval, Value};
+
     let Some(columns_expr) = func_call.args().items().find_map(|node| {
         if let Arg::Named(named) = node {
             if named.name().as_str() == "columns" {
@@ -107,10 +109,10 @@ fn get_table_columns(func_call: FuncCall<'_>) -> Option<usize> {
             Some(1) // if not `columns` is provided, regard as 1.
         };
     };
-    match columns_expr {
-        Expr::Auto(_) => Some(1),
-        Expr::Int(int) => Some(int.get() as usize),
-        Expr::Array(array) => Some(array.items().count()),
+    match columns_expr.liteval() {
+        Ok(Value::Auto) => Some(1),
+        Ok(Value::Int(i)) => Some(i as usize),
+        Ok(Value::Array(a)) => Some(a),
         _ => None,
     }
 }

docs/limitations.md

@@ -1,3 +1,5 @@
+# Limitations
+
 To ensure that source code remains valid, typstyle refrains from formatting in certain scenarios. The following cases outline situations where typstyle either does not apply formatting or applies only conservative changes.
 
 ## Overall
@@ -8,7 +10,8 @@ This directive explicitly disables formatting.
 
 ### Expressions with Comments
 
-After months of work, we can now proudly format everything with comments!
+Currently, we are capable of formatting everything with comments.
+However, when expressions contain comments, typstyle may not be able to preserve a visually pleasing layout or may even refuse to format the code. Embedded comments can interrupt alignment and grouping, making it difficult to apply standard formatting rules without altering the intended structure. In such cases, typstyle falls back to conservative formatting or skips formatting entirely to avoid breaking the code’s semantics.
 
 We guarantee that in all supported cases the source will be formatted correctly and no comments will be lost.
 If you find that a comment is lost or the formatting result is unsatisfactory due to comments, please submit a PR to present the issue.
@@ -23,12 +26,30 @@ Additionally, typstyle will not convert spaces into line breaks (or vice versa)
 
 ### Tables
 
-Typstyle attempts to format tables into a neat, rectangular layout—but only when the table is simple enough. A table is considered "simple" if it meets all of the following conditions:
-
-1. No comments.
-2. No spread args.
-3. No named args, or named args appears before all pos args.
-4. No `{table,grid}.{vline,hline,cell}`.
-5. `columns` is int or array.
-
-Note that we can only recognize functions named `table` and `grid`, and `{table,grid}.{header,footer}` as args. Aliases or wrappers of `std.{table,grid}` are not supported.
+Typstyle attempts to format tables into neat, rectangular layouts—only when the table is simple enough.
+
+Since there is no runtime function-signature provider, we treat any call named `table` or `grid` as a table and apply table layout.
+
+We fall back to a plain layout (structure preserved) in these cases:
+
+- The table contains a block comment or has no positional arguments.
+- It lacks a `columns` argument or uses spread arguments which possibly define columns.
+- The `columns` argument is not a simple constant expression. Allowed expressions are integer literals, array literals, or arithmetic combinations thereof (for example, `(auto,) * 2 + (1fr, 2fr)`).
+
+#### Formatting Behavior
+
+1. General Rules
+   - `header`, `footer`, and line comments (`//`) always occupy their own lines.
+   - Block comments disable table formatting entirely.
+   - Blank lines are preserved and prevent reflow across them.
+2. Header & Footer
+   - Both follow the table’s defined column layout.
+3. Cell Reflow
+   - Reflow applies only when **no special cells** are present.
+     Special cells include:
+     - `cell`
+     - `hline`
+     - `vline`
+     - Spread args (`..`)
+   - If no special cells exist, typstyle reflows all cells to fit the columns.
+   - Otherwise, the original grid structure is preserved.