From cd089b6194c57b2e8dff70efaa7cbd53035f7327 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Fri, 9 Dec 2022 10:21:11 +0100
Subject: Align set rule

---
 src/syntax/ast.rs       | 14 +++++++-------
 src/syntax/highlight.rs |  2 +-
 src/syntax/kind.rs      |  8 ++++----
 src/syntax/parsing.rs   |  2 +-
 4 files changed, 13 insertions(+), 13 deletions(-)

(limited to 'src/syntax')

diff --git a/src/syntax/ast.rs b/src/syntax/ast.rs
index 3661c156..4db00593 100644
--- a/src/syntax/ast.rs
+++ b/src/syntax/ast.rs
@@ -453,8 +453,8 @@ pub enum MathNode {
     Script(Script),
     /// A fraction: `x/2`.
     Frac(Frac),
-    /// An alignment indicator: `&`, `&&`.
-    Align(Align),
+    /// An alignment point: `&`, `&&`.
+    AlignPoint(AlignPoint),
     /// Grouped mathematical material.
     Group(Math),
     /// An expression.
@@ -472,7 +472,7 @@ impl AstNode for MathNode {
             SyntaxKind::Symbol(_) => node.cast().map(Self::Symbol),
             SyntaxKind::Script => node.cast().map(Self::Script),
             SyntaxKind::Frac => node.cast().map(Self::Frac),
-            SyntaxKind::Align => node.cast().map(Self::Align),
+            SyntaxKind::AlignPoint => node.cast().map(Self::AlignPoint),
             SyntaxKind::Math => node.cast().map(Self::Group),
             _ => node.cast().map(Self::Expr),
         }
@@ -488,7 +488,7 @@ impl AstNode for MathNode {
             Self::Symbol(v) => v.as_untyped(),
             Self::Script(v) => v.as_untyped(),
             Self::Frac(v) => v.as_untyped(),
-            Self::Align(v) => v.as_untyped(),
+            Self::AlignPoint(v) => v.as_untyped(),
             Self::Group(v) => v.as_untyped(),
             Self::Expr(v) => v.as_untyped(),
         }
@@ -558,11 +558,11 @@ impl Frac {
 }
 
 node! {
-    /// An alignment indicator in a formula: `&`, `&&`.
-    Align
+    /// An alignment point in a formula: `&`, `&&`.
+    AlignPoint
 }
 
-impl Align {
+impl AlignPoint {
     /// The number of ampersands.
     pub fn count(&self) -> usize {
         self.0.children().filter(|n| n.kind() == &SyntaxKind::Amp).count()
diff --git a/src/syntax/highlight.rs b/src/syntax/highlight.rs
index 3fed905f..f9f35944 100644
--- a/src/syntax/highlight.rs
+++ b/src/syntax/highlight.rs
@@ -302,7 +302,7 @@ impl Category {
             SyntaxKind::Atom(_) => None,
             SyntaxKind::Script => None,
             SyntaxKind::Frac => None,
-            SyntaxKind::Align => None,
+            SyntaxKind::AlignPoint => None,
 
             SyntaxKind::Ident(_) => match parent.kind() {
                 SyntaxKind::Markup { .. }
diff --git a/src/syntax/kind.rs b/src/syntax/kind.rs
index a4eb317b..d5fda7f8 100644
--- a/src/syntax/kind.rs
+++ b/src/syntax/kind.rs
@@ -179,8 +179,8 @@ pub enum SyntaxKind {
     Script,
     /// A fraction in a formula: `x/2`.
     Frac,
-    /// An alignment indicator in a formula: `&`, `&&`.
-    Align,
+    /// An alignment point in a formula: `&`, `&&`.
+    AlignPoint,
 
     /// An identifier: `it`.
     Ident(EcoString),
@@ -408,7 +408,7 @@ impl SyntaxKind {
             Self::Atom(_) => "math atom",
             Self::Script => "script",
             Self::Frac => "fraction",
-            Self::Align => "alignment indicator",
+            Self::AlignPoint => "alignment point",
             Self::Ident(_) => "identifier",
             Self::Bool(_) => "boolean",
             Self::Int(_) => "integer",
@@ -528,7 +528,7 @@ impl Hash for SyntaxKind {
             Self::Atom(c) => c.hash(state),
             Self::Script => {}
             Self::Frac => {}
-            Self::Align => {}
+            Self::AlignPoint => {}
             Self::Ident(v) => v.hash(state),
             Self::Bool(v) => v.hash(state),
             Self::Int(v) => v.hash(state),
diff --git a/src/syntax/parsing.rs b/src/syntax/parsing.rs
index 97570950..d751b6aa 100644
--- a/src/syntax/parsing.rs
+++ b/src/syntax/parsing.rs
@@ -499,7 +499,7 @@ fn math_group(p: &mut Parser, group: Group) {
 }
 
 fn math_align(p: &mut Parser) {
-    p.perform(SyntaxKind::Align, |p| {
+    p.perform(SyntaxKind::AlignPoint, |p| {
         p.assert(SyntaxKind::Amp);
         while p.eat_if(SyntaxKind::Amp) {}
     })
-- 
cgit v1.2.3