Convert SyntaxKind to an enum

diff --git a/src/bin/gen.rs b/src/bin/gen.rs
index 8f6402f5c997286f006bfabc71121cb28c191c91..4b8a5afecf81ed3445667bbf7eb0ab7bd27118fd 100644 (file)
--- a/src/bin/gen.rs
+++ b/src/bin/gen.rs
@@ -29,8 +29,10 @@ fn read() -> 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<String> = self.keywords
@@ -40,41 +42,49 @@ fn to_syntax_kinds(&self) -> String {
             .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<SyntaxKind> {\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 87a9d11eaf5af4b31eeac7a4f890fd64e7cf6258..ad333582cf12bcf2fff99a8bffd88471a792eaa0 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -22,8 +22,6 @@
 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 c6ab1fbe26eb3a68163f20ac82318a210bb74a34..82f8b7f3e77cc62b08b4ba151524d9cd9cbfa6b3 100644 (file)
--- 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 5ba3071cb8eeae43b71ad001acb725c993f68c08..573e3d73a8ecfaae9391961cd4f9a97c69524721 100644 (file)
--- 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 0f8f2ce0cc7126e4581ec14a691fe9b4715e7ac3..c5525ff9cdcdd9ac57c9f5704b81c5f26f9db8ba 100644 (file)
--- 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 5ab8b934b82a6c83776e20be79ee8050e9dce2c4..aa19c2adff172837b3c4bbd33afcd602e056c341 100644 (file)
--- 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<SyntaxKind> {
-   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 aaf048c73415dc5d2e7bb121394bb164aab2fa40..43bda480dbe0a5661183a0f8a80aa3b99e363459 100644 (file)
--- 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 @@
 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 {