macro_rules! syntax_kinds {
($($(#[doc = $doc:literal])* $name:ident),* $(,)?) => {
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u16)]
#[allow(non_camel_case_types, reason = "rust-analyzer style SCREAMING_CASE kinds")]
pub enum SyntaxKind {
$($(#[doc = $doc])* $name),*
}
impl SyntaxKind {
const ALL: &'static [SyntaxKind] = &[$(SyntaxKind::$name),*];
#[must_use]
pub fn name(self) -> &'static str {
match self {
$(SyntaxKind::$name => stringify!($name)),*
}
}
}
};
}
syntax_kinds! {
WHITESPACE,
LINE_COMMENT,
BLOCK_COMMENT,
PRELUDE,
TRAILER,
BEGIN_MODULE,
SEPARATOR,
END_MODULE,
PRAGMA_START,
ACTION_KW,
ASSUME_KW,
BOX_ASSUME_KW,
ASSUMPTION_KW,
CASE_KW,
CHOOSE_KW,
CONSTANT_KW,
ELSE_KW,
EXCEPT_KW,
EXISTS_KW,
EXTENDS_KW,
FORALL_KW,
IF_KW,
INSTANCE_KW,
LET_KW,
IN_KW,
LOCAL_KW,
MODULE_KW,
NEW_KW,
OTHER_KW,
PROPOSITION_KW,
SF_KW,
TEMPORAL_EXISTS_KW,
TEMPORAL_FORALL_KW,
THEN_KW,
BY_KW,
ONLY_KW,
DEFINE_KW,
DEF_KW,
THEOREM_KW,
USE_KW,
HIDE_KW,
HAVE_KW,
OBVIOUS_KW,
OMITTED_KW,
LAMBDA_KW,
TAKE_KW,
PROOF_KW,
PROVE_KW,
BOX_PROVE_KW,
QED_KW,
RECURSIVE_KW,
STATE_KW,
TEMPORAL_KW,
PICK_KW,
WITNESS_KW,
SUFFICES_KW,
VARIABLE_KW,
WF_KW,
WITH_KW,
COMMA,
COLON,
COLON_COLON,
DOT,
UNDERSCORE,
DEF_EQ,
L_PAREN,
R_PAREN,
DEFBREAK_LIT,
L_BRACK,
R_BRACK_UNDERSCORE,
R_BRACK,
L_BRACE,
R_BRACE,
L_ANGLE,
R_ANGLE_UNDERSCORE,
R_ANGLE,
BANG,
ARROW,
LEFT_ARROW,
MAPS_TO,
NUMBER,
STRING,
IDENT,
BAD_JUNCTION,
LEX_ERROR,
STEP_NUMBER,
STEP_IMPLICIT,
STEP_DOT,
STEP_BARE,
STEP_UNNUMBERED,
PREFIX_OP,
BOX_OP,
DIAMOND_OP,
NEG_DOT_OP,
POSTFIX_OP,
INFIX_OP,
AND_OP,
OR_OP,
IN_OP,
EQ_OP,
MINUS_OP,
EOF,
SOURCE_FILE,
MODULE,
MODULE_HEADER,
EXTENDS,
PRAGMA,
VARIABLE_DECL,
CONSTANT_DECL,
RECURSIVE_DECL,
IDENT_DECL,
PREFIX_DECL,
INFIX_DECL,
POSTFIX_DECL,
OPERATOR_DEF,
FUNCTION_DEF,
MODULE_DEF,
IDENT_LHS,
PREFIX_LHS,
INFIX_LHS,
POSTFIX_LHS,
INSTANCE,
INSTANTIATION,
SUBSTITUTION,
ASSUMPTION,
THEOREM,
USE_OR_HIDE,
MODULE_REF,
PROOF,
TERMINAL_PROOF,
PROOF_STEP,
QED_STEP,
DEF_STEP,
HAVE_STEP,
TAKE_STEP,
WITNESS_STEP,
PICK_STEP,
CASE_STEP,
ASSERT_STEP,
ASSUME_PROVE,
NEW_DECL,
GENERAL_ID,
ID_PREFIX,
ID_PREFIX_ELEMENT,
STRUCT_OP,
OP_APPLICATION,
OP_ARGS,
OP_REF,
NUMBER_LIT,
DECIMAL_LIT,
STRING_LIT,
PREFIX_EXPR,
INFIX_EXPR,
POSTFIX_EXPR,
CARTESIAN_PRODUCT,
PAREN_EXPR,
RECORD_FIELD,
FCN_APPL,
TUPLE,
SET_ENUM,
SET_FILTER,
SET_MAP,
FCN_CONSTRUCTOR,
SET_OF_FCNS,
RECORD,
FIELD_VAL,
SET_OF_RECORDS,
FIELD_SET,
EXCEPT,
EXCEPT_SPEC,
EXCEPT_COMPONENT,
ACTION_EXPR,
FAIRNESS_EXPR,
IF_EXPR,
CASE_EXPR,
CASE_ARM,
OTHER_ARM,
LET_EXPR,
LET_DEFS,
CONJ_LIST,
CONJ_ITEM,
DISJ_LIST,
DISJ_ITEM,
BOUNDED_QUANT,
UNBOUNDED_QUANT,
TEMPORAL_QUANT,
QUANT_BOUND,
IDENT_TUPLE,
CHOOSE,
LAMBDA,
LABEL,
ERROR,
}
impl SyntaxKind {
#[must_use]
pub fn from_raw(raw: u16) -> Option<Self> {
Self::ALL.get(usize::from(raw)).copied()
}
#[must_use]
pub fn to_raw(self) -> u16 {
self as u16
}
#[must_use]
pub fn is_trivia(self) -> bool {
matches!(
self,
Self::WHITESPACE
| Self::LINE_COMMENT
| Self::BLOCK_COMMENT
| Self::PRELUDE
| Self::TRAILER
)
}
#[must_use]
pub fn is_keyword(self) -> bool {
(Self::ACTION_KW..=Self::WITH_KW).contains(&self)
}
#[must_use]
pub fn is_operator(self) -> bool {
(Self::PREFIX_OP..=Self::MINUS_OP).contains(&self)
}
#[must_use]
pub fn is_node(self) -> bool {
self >= Self::SOURCE_FILE
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum TlaLanguage {}
impl rowan::Language for TlaLanguage {
type Kind = SyntaxKind;
fn kind_from_raw(raw: rowan::SyntaxKind) -> SyntaxKind {
SyntaxKind::from_raw(raw.0).unwrap_or(SyntaxKind::ERROR)
}
fn kind_to_raw(kind: SyntaxKind) -> rowan::SyntaxKind {
rowan::SyntaxKind(kind.to_raw())
}
}
impl From<SyntaxKind> for rowan::SyntaxKind {
fn from(kind: SyntaxKind) -> Self {
rowan::SyntaxKind(kind.to_raw())
}
}
pub type SyntaxNode = rowan::SyntaxNode<TlaLanguage>;
pub type SyntaxToken = rowan::SyntaxToken<TlaLanguage>;
pub type SyntaxElement = rowan::SyntaxElement<TlaLanguage>;
#[cfg(test)]
mod tests {
use super::SyntaxKind;
#[test]
fn raw_round_trip() {
for (i, k) in SyntaxKind::ALL.iter().enumerate() {
assert_eq!(usize::from(k.to_raw()), i);
assert_eq!(SyntaxKind::from_raw(k.to_raw()), Some(*k));
}
assert_eq!(SyntaxKind::from_raw(u16::MAX), None);
}
#[test]
fn classes() {
assert!(SyntaxKind::WHITESPACE.is_trivia());
assert!(SyntaxKind::THEOREM_KW.is_keyword());
assert!(SyntaxKind::AND_OP.is_operator());
assert!(SyntaxKind::MODULE.is_node());
assert!(!SyntaxKind::EOF.is_node());
}
}