Add attribute designator

Author: kraigher

vhdl_lang/src/ast.rs

@@ -90,10 +90,18 @@ pub enum Operator {
 pub struct AttributeName {
     pub name: WithPos<Name>,
     pub signature: Option<WithPos<Signature>>,
-    pub attr: Ident,
+    pub attr: WithPos<AttributeDesignator>,
     pub expr: Option<Box<WithPos<Expression>>>,
 }
 
+#[derive(PartialEq, Debug, Clone, Eq)]
+pub enum AttributeDesignator {
+    Subtype,
+    Range,
+    ReverseRange,
+    Ident(Symbol),
+}
+
 /// LRM 8.7 External names
 #[derive(PartialEq, Eq, Debug, Clone, Copy)]
 pub enum ExternalObjectClass {

vhdl_lang/src/ast/display.rs

@@ -95,6 +95,17 @@ impl Display for AttributeName {
     }
 }
 
+impl Display for AttributeDesignator {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        match self {
+            AttributeDesignator::Ident(sym) => write!(f, "{}", sym),
+            AttributeDesignator::Range => write!(f, "range"),
+            AttributeDesignator::ReverseRange => write!(f, "reverse_range"),
+            AttributeDesignator::Subtype => write!(f, "subtype"),
+        }
+    }
+}
+
 impl Display for ExternalObjectClass {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result {
         match self {

vhdl_lang/src/syntax/expression.rs

@@ -10,7 +10,7 @@ use super::subtype_indication::parse_subtype_constraint;
 use super::tokens::{Kind, Kind::*, Token, TokenStream};
 use crate::ast;
 use crate::ast::*;
-use crate::data::{Diagnostic, Symbol, WithPos};
+use crate::data::{Diagnostic, WithPos};
 
 fn name_to_expression(name: WithPos<Name>) -> WithPos<Expression> {
     WithPos {
@@ -281,12 +281,14 @@ fn parse_allocator(stream: &mut TokenStream) -> ParseResult<WithPos<Allocator>>
     }
 }
 
-fn name_to_type_mark(name: WithPos<Name>, subtype_sym: &Symbol) -> ParseResult<WithPos<TypeMark>> {
+fn name_to_type_mark(name: WithPos<Name>) -> ParseResult<WithPos<TypeMark>> {
     let pos = name.pos.clone();
     let type_mark = name
         .try_map_into(|name| match name {
             Name::Attribute(attr) => {
-                if attr.signature.is_none() && attr.expr.is_none() && attr.attr.item == *subtype_sym
+                if attr.signature.is_none()
+                    && attr.expr.is_none()
+                    && attr.attr.item == AttributeDesignator::Subtype
                 {
                     Some(TypeMark {
                         name: attr.name.try_map_into(name_to_selected_name)?,
@@ -370,7 +372,7 @@ fn parse_primary_initial_token(
                 let pos = name.pos.combine(&expr);
                 Ok(WithPos {
                     item: Expression::Qualified(Box::new(QualifiedExpression {
-                        type_mark: name_to_type_mark(name, stream.subtype_sym())?,
+                        type_mark: name_to_type_mark(name)?,
                         expr,
                     })),
                     pos,

vhdl_lang/src/syntax/names.rs

@@ -670,7 +670,7 @@ mod tests {
         let attr = WithPos {
             item: Name::Attribute(Box::new(AttributeName {
                 name: prefix,
-                attr: code.s1("foo").ident(),
+                attr: code.s1("foo").ident().map_into(AttributeDesignator::Ident),
                 signature: None,
                 expr: None,
             })),
@@ -690,7 +690,7 @@ mod tests {
             item: Name::Attribute(Box::new(AttributeName {
                 name: prefix,
                 attr: WithPos {
-                    item: code.symbol("range"),
+                    item: AttributeDesignator::Range,
                     pos: code.s1("range").pos(),
                 },
                 signature: None,
@@ -712,7 +712,7 @@ mod tests {
             item: Name::Attribute(Box::new(AttributeName {
                 name: prefix,
                 attr: WithPos {
-                    item: code.symbol("subtype"),
+                    item: AttributeDesignator::Subtype,
                     pos: code.s1("subtype").pos(),
                 },
                 signature: None,
@@ -766,7 +766,7 @@ mod tests {
         let attr = WithPos {
             item: Name::Attribute(Box::new(AttributeName {
                 name: prefix,
-                attr: code.s1("foo").ident(),
+                attr: code.s1("foo").ident().map_into(AttributeDesignator::Ident),
                 signature: None,
                 expr: Some(Box::new(code.s1("expr+1").expr())),
             })),
@@ -785,7 +785,7 @@ mod tests {
         let attr = WithPos {
             item: Name::Attribute(Box::new(AttributeName {
                 name: prefix,
-                attr: code.s1("foo").ident(),
+                attr: code.s1("foo").ident().map_into(AttributeDesignator::Ident),
                 signature: Some(code.s1("[return natural]").signature()),
                 expr: Some(Box::new(code.s1("expr+1").expr())),
             })),

vhdl_lang/src/syntax/range.rs

@@ -52,9 +52,10 @@ fn parse_name_or_range(stream: &mut TokenStream) -> ParseResult<NameOrRange> {
     } = expr
     {
         if let Name::Attribute(ref attribute_name) = *name.as_ref() {
-            if &attribute_name.attr.item == stream.range_sym()
-                || &attribute_name.attr.item == stream.reverse_range_sym()
-            {
+            if matches!(
+                attribute_name.attr.item,
+                AttributeDesignator::Range | AttributeDesignator::ReverseRange
+            ) {
                 // @TODO avoid clone
                 let range = ast::Range::Attribute(attribute_name.clone());
                 return Ok(NameOrRange::Range(WithPos::from(range, pos)));

vhdl_lang/src/syntax/tokens/tokenizer.rs

@@ -1353,8 +1353,6 @@ pub struct Tokenizer<'a> {
     source: &'a Source,
     reader: ContentReader<'a>,
     final_comments: Option<Vec<Comment>>,
-    range_sym: Symbol,
-    subtype_sym: Symbol,
     reverse_range_sym: Symbol,
 }
 
@@ -1364,8 +1362,6 @@ impl<'a> Tokenizer<'a> {
         source: &'a Source,
         reader: ContentReader<'a>,
     ) -> Tokenizer<'a> {
-        let subtype_sym = symbols.symtab().insert(&Latin1String::new(b"subtype"));
-        let range_sym = symbols.symtab().insert(&Latin1String::new(b"range"));
         let reverse_range_sym = symbols
             .symtab()
             .insert(&Latin1String::new(b"reverse_range"));
@@ -1377,8 +1373,6 @@ impl<'a> Tokenizer<'a> {
             source,
             reader,
             final_comments: None,
-            subtype_sym,
-            range_sym,
             reverse_range_sym,
         }
     }
@@ -1405,14 +1399,6 @@ impl<'a> Tokenizer<'a> {
         self.reader.set_state(self.state.start);
     }
 
-    pub fn subtype_sym(&self) -> &Symbol {
-        &self.subtype_sym
-    }
-
-    pub fn range_sym(&self) -> &Symbol {
-        &self.range_sym
-    }
-
     pub fn reverse_range_sym(&self) -> &Symbol {
         &self.reverse_range_sym
     }

vhdl_lang/src/syntax/tokens/tokenstream.rs

@@ -6,8 +6,8 @@
 
 use super::tokenizer::Kind::*;
 use super::tokenizer::*;
-use crate::ast::Ident;
-use crate::data::{DiagnosticHandler, DiagnosticResult, Symbol};
+use crate::ast::{AttributeDesignator, Ident};
+use crate::data::{DiagnosticHandler, DiagnosticResult, Symbol, WithPos};
 
 pub struct TokenStream<'a> {
     tokenizer: Tokenizer<'a>,
@@ -18,14 +18,6 @@ impl<'a> TokenStream<'a> {
         TokenStream { tokenizer }
     }
 
-    pub fn subtype_sym(&self) -> &Symbol {
-        self.tokenizer.subtype_sym()
-    }
-
-    pub fn range_sym(&self) -> &Symbol {
-        self.tokenizer.range_sym()
-    }
-
     pub fn reverse_range_sym(&self) -> &Symbol {
         self.tokenizer.reverse_range_sym()
     }
@@ -140,16 +132,24 @@ impl<'a> TokenStream<'a> {
 
     /// Expect identifier or subtype/range keywords
     /// foo'subtype or foo'range
-    pub fn expect_attribute_designator(&mut self) -> DiagnosticResult<Ident> {
+    pub fn expect_attribute_designator(
+        &mut self,
+    ) -> DiagnosticResult<WithPos<AttributeDesignator>> {
         let token = self.expect()?;
-        match_token_kind!(
+        let des = try_token_kind!(
             token,
-            Identifier => token.expect_ident(),
-            Subtype => Ok(Ident {item: self.tokenizer.subtype_sym().clone(),
-                                 pos: token.pos}),
-            Range => Ok(Ident {item: self.range_sym().clone(),
-                               pos: token.pos})
-        )
+            Identifier => {
+                let ident = token.expect_ident()?;
+                if &ident.item == self.reverse_range_sym() {
+                    ident.map_into(|_| AttributeDesignator::ReverseRange)
+                } else {
+                    ident.map_into(AttributeDesignator::Ident)
+                }
+            },
+            Subtype => WithPos::new(AttributeDesignator::Subtype, token.pos),
+            Range => WithPos::new(AttributeDesignator::Range, token.pos)
+        );
+        Ok(des)
     }
 }