Skip to content

Commit 1f1dafd

Browse files
tmke8tmke8
committed
Rename some AST nodes slightly
1 parent 90f1fc3 commit 1f1dafd

2 files changed

Lines changed: 48 additions & 48 deletions

File tree

‎crates/math-core/src/parser.rs‎

Lines changed: 21 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -192,8 +192,8 @@ where
192192
// one of the node types for superscripts and subscripts.
193193
let node = self.commit(match bounds {
194194
Bounds(Some(sub), Some(sup)) => Node::SubSup { target, sub, sup },
195-
Bounds(Some(symbol), None) => Node::Subscript { target, symbol },
196-
Bounds(None, Some(symbol)) => Node::Superscript { target, symbol },
195+
Bounds(Some(symbol), None) => Node::Sub { target, symbol },
196+
Bounds(None, Some(symbol)) => Node::Sup { target, symbol },
197197
Bounds(None, None) => {
198198
nodes.push(target);
199199
continue;
@@ -662,9 +662,9 @@ where
662662
Token::Accent(op, is_over, attr) => {
663663
let target = self.parse_next(ParseAs::ArgWithSpace)?;
664664
if is_over {
665-
Ok(Node::OverOp(op.as_op(), attr, target))
665+
Ok(Node::OverAccent(op.as_op(), attr, target))
666666
} else {
667-
Ok(Node::UnderOp(op.as_op(), target))
667+
Ok(Node::UnderAccent(op.as_op(), target))
668668
}
669669
}
670670
Token::Overset | Token::Underset => {
@@ -678,9 +678,9 @@ where
678678
self.state.right_boundary_hack = old_boundary_hack;
679679
class = cls;
680680
if matches!(cur_token, Token::Overset) {
681-
Ok(Node::Overset { symbol, target })
681+
Ok(Node::Over { symbol, target })
682682
} else {
683-
Ok(Node::Underset { symbol, target })
683+
Ok(Node::Under { symbol, target })
684684
}
685685
}
686686
Token::OverUnderBrace(x, is_over) => {
@@ -692,9 +692,9 @@ where
692692
right: None,
693693
});
694694
let base = if is_over {
695-
Node::Overset { symbol, target }
695+
Node::Over { symbol, target }
696696
} else {
697-
Node::Underset { symbol, target }
697+
Node::Under { symbol, target }
698698
};
699699
if (is_over && matches!(self.tokens.peek().token(), Token::Circumflex))
700700
|| (!is_over && matches!(self.tokens.peek().token(), Token::Underscore))
@@ -703,12 +703,12 @@ where
703703
self.next_token()?; // Discard the circumflex or underscore token.
704704
let expl = self.parse_next(ParseAs::Arg)?;
705705
if is_over {
706-
Ok(Node::Overset {
706+
Ok(Node::Over {
707707
symbol: expl,
708708
target,
709709
})
710710
} else {
711-
Ok(Node::Underset {
711+
Ok(Node::Under {
712712
symbol: expl,
713713
target,
714714
})
@@ -751,15 +751,15 @@ where
751751
under,
752752
over,
753753
}),
754-
Bounds(Some(symbol), None) => Ok(Node::Underset { target, symbol }),
755-
Bounds(None, Some(symbol)) => Ok(Node::Overset { target, symbol }),
754+
Bounds(Some(symbol), None) => Ok(Node::Under { target, symbol }),
755+
Bounds(None, Some(symbol)) => Ok(Node::Over { target, symbol }),
756756
Bounds(None, None) => return Ok((class, target)),
757757
}
758758
} else {
759759
match bounds {
760760
Bounds(Some(sub), Some(sup)) => Ok(Node::SubSup { target, sub, sup }),
761-
Bounds(Some(symbol), None) => Ok(Node::Subscript { target, symbol }),
762-
Bounds(None, Some(symbol)) => Ok(Node::Superscript { target, symbol }),
761+
Bounds(Some(symbol), None) => Ok(Node::Sub { target, symbol }),
762+
Bounds(None, Some(symbol)) => Ok(Node::Sup { target, symbol }),
763763
Bounds(None, None) => return Ok((class, target)),
764764
}
765765
}
@@ -792,8 +792,8 @@ where
792792
under,
793793
over,
794794
},
795-
Bounds(Some(symbol), None) => Node::Underset { target: op, symbol },
796-
Bounds(None, Some(symbol)) => Node::Overset { target: op, symbol },
795+
Bounds(Some(symbol), None) => Node::Under { target: op, symbol },
796+
Bounds(None, Some(symbol)) => Node::Over { target: op, symbol },
797797
Bounds(None, None) => {
798798
return Ok((class, op));
799799
}
@@ -1105,8 +1105,8 @@ where
11051105
under,
11061106
over,
11071107
},
1108-
Bounds(Some(symbol), None) => Node::Underset { target: op, symbol },
1109-
Bounds(None, Some(symbol)) => Node::Overset { target: op, symbol },
1108+
Bounds(Some(symbol), None) => Node::Under { target: op, symbol },
1109+
Bounds(None, Some(symbol)) => Node::Over { target: op, symbol },
11101110
Bounds(None, None) => {
11111111
return Ok((Class::Operator, op));
11121112
}
@@ -1235,7 +1235,7 @@ where
12351235
left: None,
12361236
right: None,
12371237
});
1238-
Ok(Node::Superscript { target, symbol })
1238+
Ok(Node::Sup { target, symbol })
12391239
}
12401240
tok @ (Token::Underscore | Token::Circumflex) => {
12411241
let symbol = self.parse_next(ParseAs::Arg)?;
@@ -1256,12 +1256,12 @@ where
12561256
attr: None,
12571257
});
12581258
if matches!(tok, Token::Underscore) {
1259-
Ok(Node::Subscript {
1259+
Ok(Node::Sub {
12601260
target: empty_row,
12611261
symbol,
12621262
})
12631263
} else {
1264-
Ok(Node::Superscript {
1264+
Ok(Node::Sup {
12651265
target: empty_row,
12661266
symbol,
12671267
})

‎crates/mathml-renderer/src/ast.rs‎

Lines changed: 27 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -22,32 +22,32 @@ pub enum Node<'arena> {
2222
Number(&'arena str),
2323
/// `<mi>...</mi>` for a single character.
2424
IdentifierChar(char, LetterAttr),
25-
StretchableOp(StretchableOp, StretchMode, Option<OpAttr>),
25+
/// `<mi>...</mi>` for a string.
26+
IdentifierStr(&'arena str),
2627
/// `<mo>...</mo>` for a single character.
2728
Operator {
2829
op: MathMLOperator,
2930
attr: Option<OpAttr>,
3031
left: Option<MathSpacing>,
3132
right: Option<MathSpacing>,
3233
},
34+
StretchableOp(StretchableOp, StretchMode, Option<OpAttr>),
3335
/// `<mo>...</mo>` for a string.
3436
PseudoOp {
3537
attr: Option<OpAttr>,
3638
left: Option<MathSpacing>,
3739
right: Option<MathSpacing>,
3840
name: &'arena str,
3941
},
40-
/// `<mi>...</mi>` for a string.
41-
IdentifierStr(&'arena str),
4242
/// `<mspace width="..."/>`
4343
Space(Length),
4444
/// `<msub>...</msub>`
45-
Subscript {
45+
Sub {
4646
target: &'arena Node<'arena>,
4747
symbol: &'arena Node<'arena>,
4848
},
4949
/// `<msup>...</msup>`
50-
Superscript {
50+
Sup {
5151
target: &'arena Node<'arena>,
5252
symbol: &'arena Node<'arena>,
5353
},
@@ -58,16 +58,16 @@ pub enum Node<'arena> {
5858
sup: &'arena Node<'arena>,
5959
},
6060
/// `<mover accent="true">...</mover>`
61-
OverOp(MathMLOperator, Option<OpAttr>, &'arena Node<'arena>),
62-
/// `<munder accent="true">...</munder>`
63-
UnderOp(MathMLOperator, &'arena Node<'arena>),
61+
OverAccent(MathMLOperator, Option<OpAttr>, &'arena Node<'arena>),
62+
/// `<munder accentunder="true">...</munder>`
63+
UnderAccent(MathMLOperator, &'arena Node<'arena>),
6464
/// `<mover>...</mover>`
65-
Overset {
65+
Over {
6666
symbol: &'arena Node<'arena>,
6767
target: &'arena Node<'arena>,
6868
},
6969
/// `<munder>...</munder>`
70-
Underset {
70+
Under {
7171
symbol: &'arena Node<'arena>,
7272
target: &'arena Node<'arena>,
7373
},
@@ -266,28 +266,28 @@ impl Node<'_> {
266266
write!(s, "\"/>")?;
267267
}
268268
// The following nodes have exactly two children.
269-
node @ (Node::Subscript {
269+
node @ (Node::Sub {
270270
symbol: second,
271271
target: first,
272272
}
273-
| Node::Superscript {
273+
| Node::Sup {
274274
symbol: second,
275275
target: first,
276276
}
277-
| Node::Overset {
277+
| Node::Over {
278278
symbol: second,
279279
target: first,
280280
}
281-
| Node::Underset {
281+
| Node::Under {
282282
symbol: second,
283283
target: first,
284284
}
285285
| Node::Root(second, first)) => {
286286
let (open, close) = match node {
287-
Node::Subscript { .. } => ("<msub>", "</msub>"),
288-
Node::Superscript { .. } => ("<msup>", "</msup>"),
289-
Node::Overset { .. } => ("<mover>", "</mover>"),
290-
Node::Underset { .. } => ("<munder>", "</munder>"),
287+
Node::Sub { .. } => ("<msub>", "</msub>"),
288+
Node::Sup { .. } => ("<msup>", "</msup>"),
289+
Node::Over { .. } => ("<mover>", "</mover>"),
290+
Node::Under { .. } => ("<munder>", "</munder>"),
291291
Node::Root(_, _) => ("<mroot>", "</mroot>"),
292292
// Compiler is able to infer that this is unreachable.
293293
_ => unreachable!(),
@@ -336,7 +336,7 @@ impl Node<'_> {
336336
}
337337
writeln_indent!(s, base_indent, "</mmultiscripts>");
338338
}
339-
Node::OverOp(op, attr, target) => {
339+
Node::OverAccent(op, attr, target) => {
340340
write!(s, "<mover accent=\"true\">")?;
341341
target.emit(s, child_indent)?;
342342
writeln_indent!(s, child_indent, "<mo");
@@ -346,7 +346,7 @@ impl Node<'_> {
346346
write!(s, ">{}</mo>", char::from(op))?;
347347
writeln_indent!(s, base_indent, "</mover>");
348348
}
349-
Node::UnderOp(op, target) => {
349+
Node::UnderAccent(op, target) => {
350350
write!(s, "<munder accentunder=\"true\">")?;
351351
target.emit(s, child_indent)?;
352352
writeln_indent!(s, child_indent, "<mo>{}</mo>", char::from(op));
@@ -925,7 +925,7 @@ mod tests {
925925
#[test]
926926
fn render_subscript() {
927927
assert_eq!(
928-
render(&Node::Subscript {
928+
render(&Node::Sub {
929929
target: &Node::IdentifierChar('x', LetterAttr::Default),
930930
symbol: &Node::Number("2"),
931931
}),
@@ -936,7 +936,7 @@ mod tests {
936936
#[test]
937937
fn render_superscript() {
938938
assert_eq!(
939-
render(&Node::Superscript {
939+
render(&Node::Sup {
940940
target: &Node::IdentifierChar('x', LetterAttr::Default),
941941
symbol: &Node::Number("2"),
942942
}),
@@ -959,15 +959,15 @@ mod tests {
959959
#[test]
960960
fn render_over_op() {
961961
assert_eq!(
962-
render(&Node::OverOp(
962+
render(&Node::OverAccent(
963963
symbol::MACRON.as_op(),
964964
Some(OpAttr::StretchyFalse),
965965
&Node::IdentifierChar('x', LetterAttr::Default),
966966
)),
967967
"<mover accent=\"true\"><mi>x</mi><mo stretchy=\"false\">¯</mo></mover>"
968968
);
969969
assert_eq!(
970-
render(&Node::OverOp(
970+
render(&Node::OverAccent(
971971
symbol::OVERLINE.as_op(),
972972
None,
973973
&Node::IdentifierChar('x', LetterAttr::Default),
@@ -979,7 +979,7 @@ mod tests {
979979
#[test]
980980
fn render_under_op() {
981981
assert_eq!(
982-
render(&Node::UnderOp(
982+
render(&Node::UnderAccent(
983983
symbol::LOW_LINE.as_op(),
984984
&Node::IdentifierChar('x', LetterAttr::Default),
985985
)),
@@ -990,7 +990,7 @@ mod tests {
990990
#[test]
991991
fn render_overset() {
992992
assert_eq!(
993-
render(&Node::Overset {
993+
render(&Node::Over {
994994
symbol: &Node::Operator {
995995
op: symbol::EXCLAMATION_MARK,
996996
attr: None,
@@ -1011,7 +1011,7 @@ mod tests {
10111011
#[test]
10121012
fn render_underset() {
10131013
assert_eq!(
1014-
render(&Node::Underset {
1014+
render(&Node::Under {
10151015
symbol: &Node::IdentifierChar('θ', LetterAttr::Default),
10161016
target: &Node::PseudoOp {
10171017
attr: Some(OpAttr::ForceMovableLimits),

0 commit comments

Comments
 (0)