Simplify attribute designator parsing

Author: kraigher

vhdl_lang/src/syntax/names.rs

@@ -9,7 +9,7 @@ use super::common::ParseResult;
 use super::expression::{parse_expression, parse_expression_initial_token};
 use super::subprogram::parse_signature;
 use super::subtype_indication::parse_subtype_indication;
-use super::tokens::{Kind::*, Token, TokenStream, Value};
+use super::tokens::{Kind::*, Token, TokenStream};
 use crate::ast;
 use crate::ast::*;
 use crate::data::{Diagnostic, WithPos};
@@ -53,26 +53,18 @@ pub fn parse_type_mark_starting_with_name(
     // Check if it is a type mark with a subtype or element attribute:
     // Example: signal sig0 : sig1'subtype;
     if stream.pop_if_kind(Tick)?.is_some() {
-        let subtype_token = stream.expect()?;
-        if subtype_token.kind == Subtype {
-            return Ok(WithPos {
-                pos: subtype_token.pos.combine_into(&name.pos),
-                item: TypeMark {
-                    name,
-                    attr: Some(TypeAttribute::Subtype),
-                },
-            });
-        } else if subtype_token.kind == Identifier
-            && matches!(subtype_token.value, Value::Identifier(ref sym) if sym == stream.element_sym())
-        {
-            return Ok(WithPos {
-                pos: subtype_token.pos.combine_into(&name.pos),
-                item: TypeMark {
-                    name,
-                    attr: Some(TypeAttribute::Element),
-                },
-            });
+        if let Ok(attr) = stream.expect_attribute_designator() {
+            if let AttributeDesignator::Type(typattr) = attr.item {
+                return Ok(WithPos {
+                    pos: attr.pos.combine_into(&name.pos),
+                    item: TypeMark {
+                        name,
+                        attr: Some(typattr),
+                    },
+                });
+            }
         }
+
         stream.set_state(state);
     };
 

vhdl_lang/src/syntax/tokens/tokenizer.rs

@@ -4,7 +4,9 @@
 //
 // Copyright (c) 2018, Olof Kraigher olof.kraigher@gmail.com
 
-use crate::ast::{self, Operator};
+use fnv::FnvHashMap;
+
+use crate::ast::{self, AttributeDesignator, Operator};
 use crate::ast::{BaseSpecifier, Ident};
 use crate::data::*;
 
@@ -1211,6 +1213,7 @@ fn get_trailing_comment(reader: &mut ContentReader) -> Result<Option<Comment>, T
 pub struct Symbols {
     symtab: SymbolTable,
     keywords: Vec<Kind>,
+    attributes: FnvHashMap<Symbol, AttributeDesignator>,
 }
 
 impl Symbols {
@@ -1330,6 +1333,17 @@ impl std::default::Default for Symbols {
             ("vunit", Vunit),
         ];
 
+        let attributes = [
+            (
+                "reverse_range",
+                AttributeDesignator::Range(ast::RangeAttribute::ReverseRange),
+            ),
+            (
+                "element",
+                AttributeDesignator::Type(ast::TypeAttribute::Element),
+            ),
+        ];
+
         let symtab = SymbolTable::default();
         let mut keywords = Vec::with_capacity(keywords_init.len());
 
@@ -1342,7 +1356,16 @@ impl std::default::Default for Symbols {
             keywords.push(*kind);
         }
 
-        Symbols { symtab, keywords }
+        let attributes = attributes
+            .into_iter()
+            .map(|(name, des)| (symtab.insert_utf8(name), des))
+            .collect();
+
+        Symbols {
+            symtab,
+            keywords,
+            attributes,
+        }
     }
 }
 
@@ -1353,8 +1376,6 @@ pub struct Tokenizer<'a> {
     source: &'a Source,
     reader: ContentReader<'a>,
     final_comments: Option<Vec<Comment>>,
-    reverse_range_sym: Symbol,
-    element_sym: Symbol,
 }
 
 impl<'a> Tokenizer<'a> {
@@ -1363,20 +1384,13 @@ impl<'a> Tokenizer<'a> {
         source: &'a Source,
         reader: ContentReader<'a>,
     ) -> Tokenizer<'a> {
-        let reverse_range_sym = symbols
-            .symtab()
-            .insert(&Latin1String::new(b"reverse_range"));
-        let element_sym = symbols.symtab().insert(&Latin1String::new(b"element"));
-
         Tokenizer {
             symbols,
             state: TokenState::new(reader.state()),
             buffer: Latin1String::empty(),
             source,
             reader,
             final_comments: None,
-            reverse_range_sym,
-            element_sym,
         }
     }
 
@@ -1402,12 +1416,12 @@ impl<'a> Tokenizer<'a> {
         self.reader.set_state(self.state.start);
     }
 
-    pub fn reverse_range_sym(&self) -> &Symbol {
-        &self.reverse_range_sym
-    }
-
-    pub fn element_sym(&self) -> &Symbol {
-        &self.element_sym
+    pub fn attribute(&self, sym: Symbol) -> AttributeDesignator {
+        self.symbols
+            .attributes
+            .get(&sym)
+            .cloned()
+            .unwrap_or_else(|| AttributeDesignator::Ident(sym))
     }
 
     fn parse_token(&mut self) -> Result<Option<(Kind, Value)>, TokenError> {

vhdl_lang/src/syntax/tokens/tokenstream.rs

@@ -7,7 +7,7 @@
 use super::tokenizer::Kind::*;
 use super::tokenizer::*;
 use crate::ast::{AttributeDesignator, Ident, RangeAttribute, TypeAttribute};
-use crate::data::{DiagnosticHandler, DiagnosticResult, Symbol, WithPos};
+use crate::data::{DiagnosticHandler, DiagnosticResult, WithPos};
 
 pub struct TokenStream<'a> {
     tokenizer: Tokenizer<'a>,
@@ -18,14 +18,6 @@ impl<'a> TokenStream<'a> {
         TokenStream { tokenizer }
     }
 
-    pub fn reverse_range_sym(&self) -> &Symbol {
-        self.tokenizer.reverse_range_sym()
-    }
-
-    pub fn element_sym(&self) -> &Symbol {
-        self.tokenizer.element_sym()
-    }
-
     pub fn state(&self) -> TokenState {
         self.tokenizer.state()
     }
@@ -144,13 +136,7 @@ impl<'a> TokenStream<'a> {
             token,
             Identifier => {
                 let ident = token.expect_ident()?;
-                if &ident.item == self.reverse_range_sym() {
-                    ident.map_into(|_| AttributeDesignator::Range(RangeAttribute::ReverseRange))
-                } else if &ident.item == self.element_sym() {
-                        ident.map_into(|_| AttributeDesignator::Type(TypeAttribute::Element))
-                } else {
-                    ident.map_into(AttributeDesignator::Ident)
-                }
+                ident.map_into(|sym| self.tokenizer.attribute(sym))
             },
             Subtype => WithPos::new(AttributeDesignator::Type(TypeAttribute::Subtype), token.pos),
             Range => WithPos::new(AttributeDesignator::Range(RangeAttribute::Range), token.pos)