From 4244948c6b1a62bd0e1ef276d1f0cc22c36f6f66 Mon Sep 17 00:00:00 2001 From: Christopher Durham Date: Sat, 27 Jan 2018 21:36:28 -0500 Subject: Convert SyntaxKind to an enum --- src/bin/gen.rs | 56 +++-- src/lib.rs | 2 - src/parser/event_parser/grammar/mod.rs | 1 - src/parser/event_parser/parser.rs | 3 +- src/parser/mod.rs | 1 - src/syntax_kinds.rs | 402 +++++++++++++++++---------------- src/tree/mod.rs | 21 +- 7 files changed, 243 insertions(+), 243 deletions(-) (limited to 'src') diff --git a/src/bin/gen.rs b/src/bin/gen.rs index 8f6402f5c..4b8a5afec 100644 --- a/src/bin/gen.rs +++ b/src/bin/gen.rs @@ -29,8 +29,10 @@ impl Grammar { fn to_syntax_kinds(&self) -> String { let mut acc = String::new(); - acc.push_str("// Generated from grammar.ron\n"); - acc.push_str("use tree::{SyntaxKind, SyntaxInfo};\n"); + acc.push_str("#![allow(bad_style, missing_docs, unreachable_pub)]\n"); + acc.push_str("#![cfg_attr(rustfmt, rustfmt_skip)]\n"); + acc.push_str("//! Generated from grammar.ron\n"); + acc.push_str("use tree::SyntaxInfo;\n"); acc.push_str("\n"); let syntax_kinds: Vec = self.keywords @@ -40,41 +42,49 @@ impl Grammar { .chain(self.nodes.iter().cloned()) .collect(); - for (idx, kind) in syntax_kinds.iter().enumerate() { - let sname = scream(kind); - write!( - acc, - "pub const {}: SyntaxKind = SyntaxKind({});\n", - sname, idx - ).unwrap(); + // enum SyntaxKind + acc.push_str("/// The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT_DEF`.\n"); + acc.push_str("#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]\n"); + acc.push_str("#[repr(u32)]\n"); + acc.push_str("pub enum SyntaxKind {\n"); + for kind in syntax_kinds.iter() { + write!(acc, " {},\n", scream(kind)).unwrap(); } acc.push_str("\n"); - write!( - acc, - "static INFOS: [SyntaxInfo; {}] = [\n", - syntax_kinds.len() - ).unwrap(); + acc.push_str(" TOMBSTONE = !0 - 1,\n"); + acc.push_str(" EOF = !0,\n"); + acc.push_str("}\n"); + acc.push_str("pub(crate) use self::SyntaxKind::*;\n"); + acc.push_str("\n"); + + // fn info + acc.push_str("impl SyntaxKind {\n"); + acc.push_str(" pub(crate) fn info(self) -> &'static SyntaxInfo {\n"); + acc.push_str(" match self {\n"); for kind in syntax_kinds.iter() { let sname = scream(kind); write!( acc, - " SyntaxInfo {{ name: \"{sname}\" }},\n", + " {sname} => &SyntaxInfo {{ name: \"{sname}\" }},\n", sname = sname ).unwrap(); } - acc.push_str("];\n"); + acc.push_str("\n"); + acc.push_str(" TOMBSTONE => &SyntaxInfo { name: \"TOMBSTONE\" },\n"); + acc.push_str(" EOF => &SyntaxInfo { name: \"EOF\" },\n"); + acc.push_str(" }\n"); + acc.push_str(" }\n"); + acc.push_str("}\n"); acc.push_str("\n"); - acc.push_str("pub(crate) fn syntax_info(kind: SyntaxKind) -> &'static SyntaxInfo {\n"); - acc.push_str(" &INFOS[kind.0 as usize]\n"); - acc.push_str("}\n\n"); + // fn ident_to_keyword acc.push_str("pub(crate) fn ident_to_keyword(ident: &str) -> Option {\n"); - acc.push_str(" match ident {\n"); + acc.push_str(" match ident {\n"); for kw in self.keywords.iter() { - write!(acc, " {:?} => Some({}),\n", kw, kw_token(kw)).unwrap(); + write!(acc, " {:?} => Some({}),\n", kw, kw_token(kw)).unwrap(); } - acc.push_str(" _ => None,\n"); - acc.push_str(" }\n"); + acc.push_str(" _ => None,\n"); + acc.push_str(" }\n"); acc.push_str("}\n"); acc } diff --git a/src/lib.rs b/src/lib.rs index 87a9d11ea..ad333582c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -22,8 +22,6 @@ mod tree; mod lexer; mod parser; -#[cfg_attr(rustfmt, rustfmt_skip)] -#[allow(missing_docs)] pub mod syntax_kinds; pub use text::{TextRange, TextUnit}; pub use tree::{File, FileBuilder, Node, Sink, SyntaxKind, Token}; diff --git a/src/parser/event_parser/grammar/mod.rs b/src/parser/event_parser/grammar/mod.rs index c6ab1fbe2..82f8b7f3e 100644 --- a/src/parser/event_parser/grammar/mod.rs +++ b/src/parser/event_parser/grammar/mod.rs @@ -1,6 +1,5 @@ use super::parser::{Parser, TokenSet}; use SyntaxKind; -use tree::EOF; use syntax_kinds::*; mod items; diff --git a/src/parser/event_parser/parser.rs b/src/parser/event_parser/parser.rs index 5ba3071cb..573e3d73a 100644 --- a/src/parser/event_parser/parser.rs +++ b/src/parser/event_parser/parser.rs @@ -1,8 +1,7 @@ use {SyntaxKind, TextUnit, Token}; use super::Event; use super::super::is_insignificant; -use syntax_kinds::{ERROR, L_CURLY, R_CURLY}; -use tree::{EOF, TOMBSTONE}; +use SyntaxKind::{EOF, ERROR, L_CURLY, R_CURLY, TOMBSTONE}; pub(crate) struct Marker { pos: u32, diff --git a/src/parser/mod.rs b/src/parser/mod.rs index 0f8f2ce0c..c5525ff9c 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -1,7 +1,6 @@ use {File, FileBuilder, Sink, SyntaxKind, Token}; use syntax_kinds::*; -use tree::TOMBSTONE; mod event_parser; use self::event_parser::Event; diff --git a/src/syntax_kinds.rs b/src/syntax_kinds.rs index 5ab8b934b..aa19c2adf 100644 --- a/src/syntax_kinds.rs +++ b/src/syntax_kinds.rs @@ -1,201 +1,215 @@ -// Generated from grammar.ron -use tree::{SyntaxKind, SyntaxInfo}; +#![allow(bad_style, missing_docs, unreachable_pub)] +#![cfg_attr(rustfmt, rustfmt_skip)] +//! Generated from grammar.ron +use tree::SyntaxInfo; -pub const USE_KW: SyntaxKind = SyntaxKind(0); -pub const FN_KW: SyntaxKind = SyntaxKind(1); -pub const STRUCT_KW: SyntaxKind = SyntaxKind(2); -pub const ENUM_KW: SyntaxKind = SyntaxKind(3); -pub const TRAIT_KW: SyntaxKind = SyntaxKind(4); -pub const IMPL_KW: SyntaxKind = SyntaxKind(5); -pub const TRUE_KW: SyntaxKind = SyntaxKind(6); -pub const FALSE_KW: SyntaxKind = SyntaxKind(7); -pub const AS_KW: SyntaxKind = SyntaxKind(8); -pub const EXTERN_KW: SyntaxKind = SyntaxKind(9); -pub const CRATE_KW: SyntaxKind = SyntaxKind(10); -pub const MOD_KW: SyntaxKind = SyntaxKind(11); -pub const PUB_KW: SyntaxKind = SyntaxKind(12); -pub const SELF_KW: SyntaxKind = SyntaxKind(13); -pub const SUPER_KW: SyntaxKind = SyntaxKind(14); -pub const IN_KW: SyntaxKind = SyntaxKind(15); -pub const WHERE_KW: SyntaxKind = SyntaxKind(16); -pub const ERROR: SyntaxKind = SyntaxKind(17); -pub const IDENT: SyntaxKind = SyntaxKind(18); -pub const UNDERSCORE: SyntaxKind = SyntaxKind(19); -pub const WHITESPACE: SyntaxKind = SyntaxKind(20); -pub const INT_NUMBER: SyntaxKind = SyntaxKind(21); -pub const FLOAT_NUMBER: SyntaxKind = SyntaxKind(22); -pub const SEMI: SyntaxKind = SyntaxKind(23); -pub const COMMA: SyntaxKind = SyntaxKind(24); -pub const DOT: SyntaxKind = SyntaxKind(25); -pub const DOTDOT: SyntaxKind = SyntaxKind(26); -pub const DOTDOTDOT: SyntaxKind = SyntaxKind(27); -pub const DOTDOTEQ: SyntaxKind = SyntaxKind(28); -pub const L_PAREN: SyntaxKind = SyntaxKind(29); -pub const R_PAREN: SyntaxKind = SyntaxKind(30); -pub const L_CURLY: SyntaxKind = SyntaxKind(31); -pub const R_CURLY: SyntaxKind = SyntaxKind(32); -pub const L_BRACK: SyntaxKind = SyntaxKind(33); -pub const R_BRACK: SyntaxKind = SyntaxKind(34); -pub const L_ANGLE: SyntaxKind = SyntaxKind(35); -pub const R_ANGLE: SyntaxKind = SyntaxKind(36); -pub const AT: SyntaxKind = SyntaxKind(37); -pub const POUND: SyntaxKind = SyntaxKind(38); -pub const TILDE: SyntaxKind = SyntaxKind(39); -pub const QUESTION: SyntaxKind = SyntaxKind(40); -pub const COLON: SyntaxKind = SyntaxKind(41); -pub const COLONCOLON: SyntaxKind = SyntaxKind(42); -pub const DOLLAR: SyntaxKind = SyntaxKind(43); -pub const EQ: SyntaxKind = SyntaxKind(44); -pub const EQEQ: SyntaxKind = SyntaxKind(45); -pub const FAT_ARROW: SyntaxKind = SyntaxKind(46); -pub const NEQ: SyntaxKind = SyntaxKind(47); -pub const EXCL: SyntaxKind = SyntaxKind(48); -pub const LIFETIME: SyntaxKind = SyntaxKind(49); -pub const CHAR: SyntaxKind = SyntaxKind(50); -pub const BYTE: SyntaxKind = SyntaxKind(51); -pub const STRING: SyntaxKind = SyntaxKind(52); -pub const RAW_STRING: SyntaxKind = SyntaxKind(53); -pub const BYTE_STRING: SyntaxKind = SyntaxKind(54); -pub const RAW_BYTE_STRING: SyntaxKind = SyntaxKind(55); -pub const PLUS: SyntaxKind = SyntaxKind(56); -pub const MINUS: SyntaxKind = SyntaxKind(57); -pub const STAR: SyntaxKind = SyntaxKind(58); -pub const SLASH: SyntaxKind = SyntaxKind(59); -pub const CARET: SyntaxKind = SyntaxKind(60); -pub const PERCENT: SyntaxKind = SyntaxKind(61); -pub const AMPERSAND: SyntaxKind = SyntaxKind(62); -pub const PIPE: SyntaxKind = SyntaxKind(63); -pub const THIN_ARROW: SyntaxKind = SyntaxKind(64); -pub const COMMENT: SyntaxKind = SyntaxKind(65); -pub const DOC_COMMENT: SyntaxKind = SyntaxKind(66); -pub const SHEBANG: SyntaxKind = SyntaxKind(67); -pub const FILE: SyntaxKind = SyntaxKind(68); -pub const STRUCT_ITEM: SyntaxKind = SyntaxKind(69); -pub const NAMED_FIELD: SyntaxKind = SyntaxKind(70); -pub const POS_FIELD: SyntaxKind = SyntaxKind(71); -pub const FN_ITEM: SyntaxKind = SyntaxKind(72); -pub const EXTERN_CRATE_ITEM: SyntaxKind = SyntaxKind(73); -pub const ATTR: SyntaxKind = SyntaxKind(74); -pub const META_ITEM: SyntaxKind = SyntaxKind(75); -pub const MOD_ITEM: SyntaxKind = SyntaxKind(76); -pub const USE_ITEM: SyntaxKind = SyntaxKind(77); -pub const USE_TREE: SyntaxKind = SyntaxKind(78); -pub const PATH: SyntaxKind = SyntaxKind(79); -pub const PATH_SEGMENT: SyntaxKind = SyntaxKind(80); -pub const LITERAL: SyntaxKind = SyntaxKind(81); -pub const ALIAS: SyntaxKind = SyntaxKind(82); -pub const VISIBILITY: SyntaxKind = SyntaxKind(83); +/// The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT_DEF`. +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[repr(u32)] +pub enum SyntaxKind { + USE_KW, + FN_KW, + STRUCT_KW, + ENUM_KW, + TRAIT_KW, + IMPL_KW, + TRUE_KW, + FALSE_KW, + AS_KW, + EXTERN_KW, + CRATE_KW, + MOD_KW, + PUB_KW, + SELF_KW, + SUPER_KW, + IN_KW, + WHERE_KW, + ERROR, + IDENT, + UNDERSCORE, + WHITESPACE, + INT_NUMBER, + FLOAT_NUMBER, + SEMI, + COMMA, + DOT, + DOTDOT, + DOTDOTDOT, + DOTDOTEQ, + L_PAREN, + R_PAREN, + L_CURLY, + R_CURLY, + L_BRACK, + R_BRACK, + L_ANGLE, + R_ANGLE, + AT, + POUND, + TILDE, + QUESTION, + COLON, + COLONCOLON, + DOLLAR, + EQ, + EQEQ, + FAT_ARROW, + NEQ, + EXCL, + LIFETIME, + CHAR, + BYTE, + STRING, + RAW_STRING, + BYTE_STRING, + RAW_BYTE_STRING, + PLUS, + MINUS, + STAR, + SLASH, + CARET, + PERCENT, + AMPERSAND, + PIPE, + THIN_ARROW, + COMMENT, + DOC_COMMENT, + SHEBANG, + FILE, + STRUCT_ITEM, + NAMED_FIELD, + POS_FIELD, + FN_ITEM, + EXTERN_CRATE_ITEM, + ATTR, + META_ITEM, + MOD_ITEM, + USE_ITEM, + USE_TREE, + PATH, + PATH_SEGMENT, + LITERAL, + ALIAS, + VISIBILITY, -static INFOS: [SyntaxInfo; 84] = [ - SyntaxInfo { name: "USE_KW" }, - SyntaxInfo { name: "FN_KW" }, - SyntaxInfo { name: "STRUCT_KW" }, - SyntaxInfo { name: "ENUM_KW" }, - SyntaxInfo { name: "TRAIT_KW" }, - SyntaxInfo { name: "IMPL_KW" }, - SyntaxInfo { name: "TRUE_KW" }, - SyntaxInfo { name: "FALSE_KW" }, - SyntaxInfo { name: "AS_KW" }, - SyntaxInfo { name: "EXTERN_KW" }, - SyntaxInfo { name: "CRATE_KW" }, - SyntaxInfo { name: "MOD_KW" }, - SyntaxInfo { name: "PUB_KW" }, - SyntaxInfo { name: "SELF_KW" }, - SyntaxInfo { name: "SUPER_KW" }, - SyntaxInfo { name: "IN_KW" }, - SyntaxInfo { name: "WHERE_KW" }, - SyntaxInfo { name: "ERROR" }, - SyntaxInfo { name: "IDENT" }, - SyntaxInfo { name: "UNDERSCORE" }, - SyntaxInfo { name: "WHITESPACE" }, - SyntaxInfo { name: "INT_NUMBER" }, - SyntaxInfo { name: "FLOAT_NUMBER" }, - SyntaxInfo { name: "SEMI" }, - SyntaxInfo { name: "COMMA" }, - SyntaxInfo { name: "DOT" }, - SyntaxInfo { name: "DOTDOT" }, - SyntaxInfo { name: "DOTDOTDOT" }, - SyntaxInfo { name: "DOTDOTEQ" }, - SyntaxInfo { name: "L_PAREN" }, - SyntaxInfo { name: "R_PAREN" }, - SyntaxInfo { name: "L_CURLY" }, - SyntaxInfo { name: "R_CURLY" }, - SyntaxInfo { name: "L_BRACK" }, - SyntaxInfo { name: "R_BRACK" }, - SyntaxInfo { name: "L_ANGLE" }, - SyntaxInfo { name: "R_ANGLE" }, - SyntaxInfo { name: "AT" }, - SyntaxInfo { name: "POUND" }, - SyntaxInfo { name: "TILDE" }, - SyntaxInfo { name: "QUESTION" }, - SyntaxInfo { name: "COLON" }, - SyntaxInfo { name: "COLONCOLON" }, - SyntaxInfo { name: "DOLLAR" }, - SyntaxInfo { name: "EQ" }, - SyntaxInfo { name: "EQEQ" }, - SyntaxInfo { name: "FAT_ARROW" }, - SyntaxInfo { name: "NEQ" }, - SyntaxInfo { name: "EXCL" }, - SyntaxInfo { name: "LIFETIME" }, - SyntaxInfo { name: "CHAR" }, - SyntaxInfo { name: "BYTE" }, - SyntaxInfo { name: "STRING" }, - SyntaxInfo { name: "RAW_STRING" }, - SyntaxInfo { name: "BYTE_STRING" }, - SyntaxInfo { name: "RAW_BYTE_STRING" }, - SyntaxInfo { name: "PLUS" }, - SyntaxInfo { name: "MINUS" }, - SyntaxInfo { name: "STAR" }, - SyntaxInfo { name: "SLASH" }, - SyntaxInfo { name: "CARET" }, - SyntaxInfo { name: "PERCENT" }, - SyntaxInfo { name: "AMPERSAND" }, - SyntaxInfo { name: "PIPE" }, - SyntaxInfo { name: "THIN_ARROW" }, - SyntaxInfo { name: "COMMENT" }, - SyntaxInfo { name: "DOC_COMMENT" }, - SyntaxInfo { name: "SHEBANG" }, - SyntaxInfo { name: "FILE" }, - SyntaxInfo { name: "STRUCT_ITEM" }, - SyntaxInfo { name: "NAMED_FIELD" }, - SyntaxInfo { name: "POS_FIELD" }, - SyntaxInfo { name: "FN_ITEM" }, - SyntaxInfo { name: "EXTERN_CRATE_ITEM" }, - SyntaxInfo { name: "ATTR" }, - SyntaxInfo { name: "META_ITEM" }, - SyntaxInfo { name: "MOD_ITEM" }, - SyntaxInfo { name: "USE_ITEM" }, - SyntaxInfo { name: "USE_TREE" }, - SyntaxInfo { name: "PATH" }, - SyntaxInfo { name: "PATH_SEGMENT" }, - SyntaxInfo { name: "LITERAL" }, - SyntaxInfo { name: "ALIAS" }, - SyntaxInfo { name: "VISIBILITY" }, -]; + TOMBSTONE = !0 - 1, + EOF = !0, +} +pub(crate) use self::SyntaxKind::*; + +impl SyntaxKind { + pub(crate) fn info(self) -> &'static SyntaxInfo { + match self { + USE_KW => &SyntaxInfo { name: "USE_KW" }, + FN_KW => &SyntaxInfo { name: "FN_KW" }, + STRUCT_KW => &SyntaxInfo { name: "STRUCT_KW" }, + ENUM_KW => &SyntaxInfo { name: "ENUM_KW" }, + TRAIT_KW => &SyntaxInfo { name: "TRAIT_KW" }, + IMPL_KW => &SyntaxInfo { name: "IMPL_KW" }, + TRUE_KW => &SyntaxInfo { name: "TRUE_KW" }, + FALSE_KW => &SyntaxInfo { name: "FALSE_KW" }, + AS_KW => &SyntaxInfo { name: "AS_KW" }, + EXTERN_KW => &SyntaxInfo { name: "EXTERN_KW" }, + CRATE_KW => &SyntaxInfo { name: "CRATE_KW" }, + MOD_KW => &SyntaxInfo { name: "MOD_KW" }, + PUB_KW => &SyntaxInfo { name: "PUB_KW" }, + SELF_KW => &SyntaxInfo { name: "SELF_KW" }, + SUPER_KW => &SyntaxInfo { name: "SUPER_KW" }, + IN_KW => &SyntaxInfo { name: "IN_KW" }, + WHERE_KW => &SyntaxInfo { name: "WHERE_KW" }, + ERROR => &SyntaxInfo { name: "ERROR" }, + IDENT => &SyntaxInfo { name: "IDENT" }, + UNDERSCORE => &SyntaxInfo { name: "UNDERSCORE" }, + WHITESPACE => &SyntaxInfo { name: "WHITESPACE" }, + INT_NUMBER => &SyntaxInfo { name: "INT_NUMBER" }, + FLOAT_NUMBER => &SyntaxInfo { name: "FLOAT_NUMBER" }, + SEMI => &SyntaxInfo { name: "SEMI" }, + COMMA => &SyntaxInfo { name: "COMMA" }, + DOT => &SyntaxInfo { name: "DOT" }, + DOTDOT => &SyntaxInfo { name: "DOTDOT" }, + DOTDOTDOT => &SyntaxInfo { name: "DOTDOTDOT" }, + DOTDOTEQ => &SyntaxInfo { name: "DOTDOTEQ" }, + L_PAREN => &SyntaxInfo { name: "L_PAREN" }, + R_PAREN => &SyntaxInfo { name: "R_PAREN" }, + L_CURLY => &SyntaxInfo { name: "L_CURLY" }, + R_CURLY => &SyntaxInfo { name: "R_CURLY" }, + L_BRACK => &SyntaxInfo { name: "L_BRACK" }, + R_BRACK => &SyntaxInfo { name: "R_BRACK" }, + L_ANGLE => &SyntaxInfo { name: "L_ANGLE" }, + R_ANGLE => &SyntaxInfo { name: "R_ANGLE" }, + AT => &SyntaxInfo { name: "AT" }, + POUND => &SyntaxInfo { name: "POUND" }, + TILDE => &SyntaxInfo { name: "TILDE" }, + QUESTION => &SyntaxInfo { name: "QUESTION" }, + COLON => &SyntaxInfo { name: "COLON" }, + COLONCOLON => &SyntaxInfo { name: "COLONCOLON" }, + DOLLAR => &SyntaxInfo { name: "DOLLAR" }, + EQ => &SyntaxInfo { name: "EQ" }, + EQEQ => &SyntaxInfo { name: "EQEQ" }, + FAT_ARROW => &SyntaxInfo { name: "FAT_ARROW" }, + NEQ => &SyntaxInfo { name: "NEQ" }, + EXCL => &SyntaxInfo { name: "EXCL" }, + LIFETIME => &SyntaxInfo { name: "LIFETIME" }, + CHAR => &SyntaxInfo { name: "CHAR" }, + BYTE => &SyntaxInfo { name: "BYTE" }, + STRING => &SyntaxInfo { name: "STRING" }, + RAW_STRING => &SyntaxInfo { name: "RAW_STRING" }, + BYTE_STRING => &SyntaxInfo { name: "BYTE_STRING" }, + RAW_BYTE_STRING => &SyntaxInfo { name: "RAW_BYTE_STRING" }, + PLUS => &SyntaxInfo { name: "PLUS" }, + MINUS => &SyntaxInfo { name: "MINUS" }, + STAR => &SyntaxInfo { name: "STAR" }, + SLASH => &SyntaxInfo { name: "SLASH" }, + CARET => &SyntaxInfo { name: "CARET" }, + PERCENT => &SyntaxInfo { name: "PERCENT" }, + AMPERSAND => &SyntaxInfo { name: "AMPERSAND" }, + PIPE => &SyntaxInfo { name: "PIPE" }, + THIN_ARROW => &SyntaxInfo { name: "THIN_ARROW" }, + COMMENT => &SyntaxInfo { name: "COMMENT" }, + DOC_COMMENT => &SyntaxInfo { name: "DOC_COMMENT" }, + SHEBANG => &SyntaxInfo { name: "SHEBANG" }, + FILE => &SyntaxInfo { name: "FILE" }, + STRUCT_ITEM => &SyntaxInfo { name: "STRUCT_ITEM" }, + NAMED_FIELD => &SyntaxInfo { name: "NAMED_FIELD" }, + POS_FIELD => &SyntaxInfo { name: "POS_FIELD" }, + FN_ITEM => &SyntaxInfo { name: "FN_ITEM" }, + EXTERN_CRATE_ITEM => &SyntaxInfo { name: "EXTERN_CRATE_ITEM" }, + ATTR => &SyntaxInfo { name: "ATTR" }, + META_ITEM => &SyntaxInfo { name: "META_ITEM" }, + MOD_ITEM => &SyntaxInfo { name: "MOD_ITEM" }, + USE_ITEM => &SyntaxInfo { name: "USE_ITEM" }, + USE_TREE => &SyntaxInfo { name: "USE_TREE" }, + PATH => &SyntaxInfo { name: "PATH" }, + PATH_SEGMENT => &SyntaxInfo { name: "PATH_SEGMENT" }, + LITERAL => &SyntaxInfo { name: "LITERAL" }, + ALIAS => &SyntaxInfo { name: "ALIAS" }, + VISIBILITY => &SyntaxInfo { name: "VISIBILITY" }, -pub(crate) fn syntax_info(kind: SyntaxKind) -> &'static SyntaxInfo { - &INFOS[kind.0 as usize] + TOMBSTONE => &SyntaxInfo { name: "TOMBSTONE" }, + EOF => &SyntaxInfo { name: "EOF" }, + } + } } pub(crate) fn ident_to_keyword(ident: &str) -> Option { - match ident { - "use" => Some(USE_KW), - "fn" => Some(FN_KW), - "struct" => Some(STRUCT_KW), - "enum" => Some(ENUM_KW), - "trait" => Some(TRAIT_KW), - "impl" => Some(IMPL_KW), - "true" => Some(TRUE_KW), - "false" => Some(FALSE_KW), - "as" => Some(AS_KW), - "extern" => Some(EXTERN_KW), - "crate" => Some(CRATE_KW), - "mod" => Some(MOD_KW), - "pub" => Some(PUB_KW), - "self" => Some(SELF_KW), - "super" => Some(SUPER_KW), - "in" => Some(IN_KW), - "where" => Some(WHERE_KW), - _ => None, - } + match ident { + "use" => Some(USE_KW), + "fn" => Some(FN_KW), + "struct" => Some(STRUCT_KW), + "enum" => Some(ENUM_KW), + "trait" => Some(TRAIT_KW), + "impl" => Some(IMPL_KW), + "true" => Some(TRUE_KW), + "false" => Some(FALSE_KW), + "as" => Some(AS_KW), + "extern" => Some(EXTERN_KW), + "crate" => Some(CRATE_KW), + "mod" => Some(MOD_KW), + "pub" => Some(PUB_KW), + "self" => Some(SELF_KW), + "super" => Some(SUPER_KW), + "in" => Some(IN_KW), + "where" => Some(WHERE_KW), + _ => None, + } } diff --git a/src/tree/mod.rs b/src/tree/mod.rs index aaf048c73..43bda480d 100644 --- a/src/tree/mod.rs +++ b/src/tree/mod.rs @@ -1,5 +1,4 @@ use text::{TextRange, TextUnit}; -use syntax_kinds::syntax_info; use std::fmt; use std::cmp; @@ -7,25 +6,7 @@ use std::cmp; mod file_builder; pub use self::file_builder::{FileBuilder, Sink}; -/// The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT_DEF`. -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub struct SyntaxKind(pub(crate) u32); - -pub(crate) const EOF: SyntaxKind = SyntaxKind(!0); -pub(crate) const EOF_INFO: SyntaxInfo = SyntaxInfo { name: "EOF" }; - -pub(crate) const TOMBSTONE: SyntaxKind = SyntaxKind(!0 - 1); -pub(crate) const TOMBSTONE_INFO: SyntaxInfo = SyntaxInfo { name: "TOMBSTONE" }; - -impl SyntaxKind { - fn info(self) -> &'static SyntaxInfo { - match self { - EOF => &EOF_INFO, - TOMBSTONE => &TOMBSTONE_INFO, - _ => syntax_info(self), - } - } -} +pub use syntax_kinds::SyntaxKind; impl fmt::Debug for SyntaxKind { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { -- cgit v1.2.3