fix #497

Author: burrbull

src/generate/register.rs

@@ -494,7 +494,7 @@ pub fn fields(
 
                         for v in &variants {
                             let pc = &v.pc;
-                            let sc = &v.sc;
+                            let sc = &v.nksc;
 
                             let is_variant = Ident::new(
                                 &if sc.to_string().starts_with('_') {
@@ -762,6 +762,7 @@ fn unsafety(write_constraint: Option<&WriteConstraint>, width: u32) -> Option<Id
 struct Variant {
     doc: String,
     pc: Ident,
+    nksc: Ident,
     sc: Ident,
     value: u64,
 }
@@ -779,13 +780,16 @@ impl Variant {
                     anyhow!("EnumeratedValue {} has no `<value>` field", ev.name)
                 })?);
 
+                let nksc = ev.name.to_sanitized_not_keyword_snake_case();
+                let sc = util::sanitize_keyword(nksc.clone());
                 Ok(Variant {
                     doc: ev
                         .description
                         .clone()
                         .unwrap_or_else(|| format!("`{:b}`", value)),
                     pc: Ident::new(&ev.name.to_sanitized_upper_case(), span),
-                    sc: Ident::new(&ev.name.to_sanitized_snake_case(), span),
+                    nksc: Ident::new(&nksc, span),
+                    sc: Ident::new(&sc, span),
                     value,
                 })
             })

src/util.rs

@@ -47,91 +47,96 @@ pub trait ToSanitizedUpperCase {
 }
 
 pub trait ToSanitizedSnakeCase {
-    fn to_sanitized_snake_case(&self) -> Cow<str>;
+    fn to_sanitized_not_keyword_snake_case(&self) -> Cow<str>;
+    fn to_sanitized_snake_case(&self) -> Cow<str> {
+        let s = self.to_sanitized_not_keyword_snake_case();
+        sanitize_keyword(s)
+    }
 }
 
 impl ToSanitizedSnakeCase for str {
-    fn to_sanitized_snake_case(&self) -> Cow<str> {
-        macro_rules! keywords {
-            ($s:expr, $($kw:ident),+,) => {
-                Cow::from(match &$s.to_lowercase()[..] {
-                    $(stringify!($kw) => concat!(stringify!($kw), "_")),+,
-                    _ => return Cow::from($s.to_snake_case())
-                })
-            }
-        }
-
+    fn to_sanitized_not_keyword_snake_case(&self) -> Cow<str> {
         let s = self.replace(BLACKLIST_CHARS, "");
-
         match s.chars().next().unwrap_or('\0') {
             '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' => {
                 Cow::from(format!("_{}", s.to_snake_case()))
             }
-            _ => {
-                keywords! {
-                    s,
-                    abstract,
-                    alignof,
-                    as,
-                    async,
-                    await,
-                    become,
-                    box,
-                    break,
-                    const,
-                    continue,
-                    crate,
-                    do,
-                    else,
-                    enum,
-                    extern,
-                    false,
-                    final,
-                    fn,
-                    for,
-                    if,
-                    impl,
-                    in,
-                    let,
-                    loop,
-                    macro,
-                    match,
-                    mod,
-                    move,
-                    mut,
-                    offsetof,
-                    override,
-                    priv,
-                    proc,
-                    pub,
-                    pure,
-                    ref,
-                    return,
-                    self,
-                    sizeof,
-                    static,
-                    struct,
-                    super,
-                    trait,
-                    true,
-                    try,
-                    type,
-                    typeof,
-                    unsafe,
-                    unsized,
-                    use,
-                    virtual,
-                    where,
-                    while,
-                    yield,
-                    set_bit,
-                    clear_bit,
-                    bit,
-                    bits,
-                }
-            }
+            _ => Cow::from(s.to_snake_case()),
+        }
+    }
+}
+
+pub fn sanitize_keyword<'a>(s: Cow<'a, str>) -> Cow<'a, str> {
+    macro_rules! keywords {
+        ($s:expr, $($kw:ident),+,) => {
+            Cow::from(match &$s.to_lowercase()[..] {
+                $(stringify!($kw) => concat!(stringify!($kw), "_")),+,
+                _ => return s,
+            })
         }
     }
+
+    keywords! {
+        s,
+        abstract,
+        alignof,
+        as,
+        async,
+        await,
+        become,
+        box,
+        break,
+        const,
+        continue,
+        crate,
+        do,
+        else,
+        enum,
+        extern,
+        false,
+        final,
+        fn,
+        for,
+        if,
+        impl,
+        in,
+        let,
+        loop,
+        macro,
+        match,
+        mod,
+        move,
+        mut,
+        offsetof,
+        override,
+        priv,
+        proc,
+        pub,
+        pure,
+        ref,
+        return,
+        self,
+        sizeof,
+        static,
+        struct,
+        super,
+        trait,
+        true,
+        try,
+        type,
+        typeof,
+        unsafe,
+        unsized,
+        use,
+        virtual,
+        where,
+        while,
+        yield,
+        set_bit,
+        clear_bit,
+        bit,
+        bits,
+    }
 }
 
 impl ToSanitizedUpperCase for str {