Align parser with V1 language reference; remove non-spec constructs; bump to 0.1.8

Add canonical V1 language reference and patterns reference to docs/.

Remove parser support for constructs not in the V1 spec: system blocks,
module declarations, module-level guidance, for each (only bare for),
double-equals, includes/excludes operators, range literals, suffix
predicates. Strip dead AST variants, token kinds and lexer rules.

Update test fixtures and spec conformance tests.

Author: henrygarner

Cargo.lock

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/allium-parser", "crates/allium"]
 
 [workspace.package]
-version = "0.1.7"
+version = "0.1.8"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/juxt/allium-tools"

Cargo.toml

@@ -30,22 +30,13 @@ pub struct Module {
 #[derive(Debug, Clone)]
 pub enum Decl {
     Use(UseDecl),
-    ModuleDecl(ModuleDecl),
     Block(BlockDecl),
-    Guidance(GuidanceDecl),
     Default(DefaultDecl),
     Variant(VariantDecl),
     Deferred(DeferredDecl),
     OpenQuestion(OpenQuestionDecl),
 }
 
-/// `module name`
-#[derive(Debug, Clone)]
-pub struct ModuleDecl {
-    pub span: Span,
-    pub name: Ident,
-}
-
 /// `use "path" as alias`
 #[derive(Debug, Clone)]
 pub struct UseDecl {
@@ -75,7 +66,6 @@ pub enum BlockKind {
     Rule,
     Surface,
     Actor,
-    System,
 }
 
 /// `default [Type] name = value`
@@ -103,13 +93,6 @@ pub struct DeferredDecl {
     pub path: Expr,
 }
 
-/// `guidance: value` at module level
-#[derive(Debug, Clone)]
-pub struct GuidanceDecl {
-    pub span: Span,
-    pub value: Expr,
-}
-
 /// `open question "text"`
 #[derive(Debug, Clone)]
 pub struct OpenQuestionDecl {
@@ -210,18 +193,6 @@ pub enum Expr {
         args: Vec<Expr>,
     },
 
-    /// `expr includes expr` / `expr excludes expr`
-    Includes {
-        span: Span,
-        collection: Box<Expr>,
-        element: Box<Expr>,
-    },
-    Excludes {
-        span: Span,
-        collection: Box<Expr>,
-        element: Box<Expr>,
-    },
-
     /// `a.b`
     MemberAccess {
         span: Span,
@@ -402,21 +373,6 @@ pub enum Expr {
     /// A sequence of expressions from a multi-line block.
     Block { span: Span, items: Vec<Expr> },
 
-    /// `subject word [args...]` — prose-style predicate in clause values.
-    /// Captures remaining same-line tokens after a primary expression.
-    /// The `tail` contains the predicate word(s) and argument(s) in order.
-    Predicate {
-        span: Span,
-        subject: Box<Expr>,
-        tail: Vec<Expr>,
-    },
-
-    /// `start..end` — range expression
-    Range {
-        span: Span,
-        start: Box<Expr>,
-        end: Box<Expr>,
-    },
 }
 
 impl Expr {
@@ -435,8 +391,6 @@ impl Expr {
             | Expr::ListLiteral { span, .. }
             | Expr::ObjectLiteral { span, .. }
             | Expr::GenericType { span, .. }
-            | Expr::Includes { span, .. }
-            | Expr::Excludes { span, .. }
             | Expr::MemberAccess { span, .. }
             | Expr::OptionalAccess { span, .. }
             | Expr::NullCoalesce { span, .. }
@@ -463,9 +417,7 @@ impl Expr {
             | Expr::WhenGuard { span, .. }
             | Expr::TypeOptional { span, .. }
             | Expr::LetExpr { span, .. }
-            | Expr::Block { span, .. }
-            | Expr::Predicate { span, .. }
-            | Expr::Range { span, .. } => *span,
+            | Expr::Block { span, .. } => *span,
             Expr::QualifiedName(q) => q.span,
         }
     }
@@ -486,7 +438,7 @@ pub struct CondBlockBranch {
     pub items: Vec<BlockItem>,
 }
 
-/// Binding in a `for each` loop — either a single identifier or a
+/// Binding in a `for` loop — either a single identifier or a
 /// destructured tuple like `(a, b)`.
 #[derive(Debug, Clone)]
 pub enum ForBinding {

crates/allium-parser/src/ast.rs

@@ -32,8 +32,6 @@ pub enum TokenKind {
     Question,
     Use,
     As,
-    Module,
-    System,
 
     // Clause / expression keywords
     When,
@@ -51,11 +49,9 @@ pub enum TokenKind {
     Or,
     Exists,
 
-    // Trigger / predicate keywords
+    // Trigger keywords
     TransitionsTo,
     Becomes,
-    Includes,
-    Excludes,
 
     // Context-sensitive identifiers treated as keywords
     Now,
@@ -64,7 +60,6 @@ pub enum TokenKind {
 
     // Operators
     Eq,              // =
-    EqEq,            // ==
     BangEq,          // !=
     Lt,              // <
     LtEq,            // <=
@@ -80,7 +75,6 @@ pub enum TokenKind {
     QuestionQuestion, // ??
     QuestionDot,     // ?.
     Dot,             // .
-    DotDot,          // ..
 
     // Delimiters
     LBrace,
@@ -126,8 +120,6 @@ impl std::fmt::Display for TokenKind {
             TokenKind::Question => write!(f, "'question'"),
             TokenKind::Use => write!(f, "'use'"),
             TokenKind::As => write!(f, "'as'"),
-            TokenKind::Module => write!(f, "'module'"),
-            TokenKind::System => write!(f, "'system'"),
             TokenKind::When => write!(f, "'when'"),
             TokenKind::Requires => write!(f, "'requires'"),
             TokenKind::Ensures => write!(f, "'ensures'"),
@@ -144,13 +136,10 @@ impl std::fmt::Display for TokenKind {
             TokenKind::Exists => write!(f, "'exists'"),
             TokenKind::TransitionsTo => write!(f, "'transitions_to'"),
             TokenKind::Becomes => write!(f, "'becomes'"),
-            TokenKind::Includes => write!(f, "'includes'"),
-            TokenKind::Excludes => write!(f, "'excludes'"),
             TokenKind::Now => write!(f, "'now'"),
             TokenKind::This => write!(f, "'this'"),
             TokenKind::Within => write!(f, "'within'"),
             TokenKind::Eq => write!(f, "'='"),
-            TokenKind::EqEq => write!(f, "'=='"),
             TokenKind::BangEq => write!(f, "'!='"),
             TokenKind::Lt => write!(f, "'<'"),
             TokenKind::LtEq => write!(f, "'<='"),
@@ -166,7 +155,6 @@ impl std::fmt::Display for TokenKind {
             TokenKind::QuestionQuestion => write!(f, "'??'"),
             TokenKind::QuestionDot => write!(f, "'?.'"),
             TokenKind::Dot => write!(f, "'.'"),
-            TokenKind::DotDot => write!(f, "'..'"),
             TokenKind::LBrace => write!(f, "'{{'"),
             TokenKind::RBrace => write!(f, "'}}'"),
             TokenKind::LParen => write!(f, "'('"),
@@ -207,8 +195,6 @@ impl TokenKind {
                 | TokenKind::Question
                 | TokenKind::Use
                 | TokenKind::As
-                | TokenKind::Module
-                | TokenKind::System
                 | TokenKind::When
                 | TokenKind::Requires
                 | TokenKind::Ensures
@@ -225,8 +211,6 @@ impl TokenKind {
                 | TokenKind::Exists
                 | TokenKind::TransitionsTo
                 | TokenKind::Becomes
-                | TokenKind::Includes
-                | TokenKind::Excludes
                 | TokenKind::Now
                 | TokenKind::This
                 | TokenKind::Within
@@ -499,7 +483,6 @@ impl<'s> Lexer<'s> {
 
         let (kind, len) = match (b, next) {
             (b'=', b'>') => (TokenKind::FatArrow, 2),
-            (b'=', b'=') => (TokenKind::EqEq, 2),
             (b'=', _) => (TokenKind::Eq, 1),
             (b'!', b'=') => (TokenKind::BangEq, 2),
             (b'<', b'=') => (TokenKind::LtEq, 2),
@@ -515,7 +498,6 @@ impl<'s> Lexer<'s> {
             (b'?', b'?') => (TokenKind::QuestionQuestion, 2),
             (b'?', b'.') => (TokenKind::QuestionDot, 2),
             (b'?', _) => (TokenKind::QuestionMark, 1),
-            (b'.', b'.') => (TokenKind::DotDot, 2),
             (b'.', _) => (TokenKind::Dot, 1),
             (b'{', _) => (TokenKind::LBrace, 1),
             (b'}', _) => (TokenKind::RBrace, 1),
@@ -566,8 +548,6 @@ fn classify_keyword(text: &str) -> TokenKind {
         "question" => TokenKind::Question,
         "use" => TokenKind::Use,
         "as" => TokenKind::As,
-        "module" => TokenKind::Module,
-        "system" => TokenKind::System,
         "when" => TokenKind::When,
         "requires" => TokenKind::Requires,
         "ensures" => TokenKind::Ensures,
@@ -584,8 +564,6 @@ fn classify_keyword(text: &str) -> TokenKind {
         "exists" => TokenKind::Exists,
         "transitions_to" => TokenKind::TransitionsTo,
         "becomes" => TokenKind::Becomes,
-        "includes" => TokenKind::Includes,
-        "excludes" => TokenKind::Excludes,
         "true" => TokenKind::True,
         "false" => TokenKind::False,
         "null" => TokenKind::Null,