Add try_init_token_kind for tokens that are the root of a syntax tree

Author: kraigher

vhdl_lang/src/syntax/concurrent_statement.rs

@@ -555,7 +555,7 @@ pub fn parse_concurrent_statement(
     diagnostics: &mut dyn DiagnosticHandler,
 ) -> ParseResult<ConcurrentStatement> {
     let statement = {
-        try_token_kind!(
+        try_init_token_kind!(
             token,
             Block => {
                 ConcurrentStatement::Block(parse_block_statement(stream, diagnostics)?)

vhdl_lang/src/syntax/context.rs

@@ -96,7 +96,7 @@ pub fn parse_context(
         let end_ident;
         loop {
             let token = stream.expect()?;
-            try_token_kind!(
+            try_init_token_kind!(
                 token,
                 Library => items.push(parse_library_clause_no_keyword(token, stream)?.map_into(ContextItem::Library)),
                 Use => items.push(parse_use_clause_no_keyword(token, stream)?.map_into(ContextItem::Use)),

vhdl_lang/src/syntax/design_unit.rs

@@ -174,7 +174,7 @@ pub fn parse_design_file(
     let mut design_units = vec![];
 
     while let Some(token) = stream.peek()? {
-        try_token_kind!(
+        try_init_token_kind!(
             token,
             Library => {
                 match parse_library_clause(stream) {

vhdl_lang/src/syntax/names.rs

@@ -281,7 +281,7 @@ fn to_suffix(token: Token) -> ParseResult<WithPos<DesignatorOrAll>> {
 /// Inside of << >>
 fn parse_inner_external_name(stream: &mut TokenStream) -> ParseResult<ExternalName> {
     let token = stream.expect()?;
-    let class = try_token_kind!(
+    let class = try_init_token_kind!(
         token,
         Signal => ExternalObjectClass::Signal,
         Constant => ExternalObjectClass::Constant,

vhdl_lang/src/syntax/object_declaration.rs

@@ -46,7 +46,7 @@ fn parse_object_declaration_kind(
 
 pub fn parse_object_declaration(stream: &mut TokenStream) -> ParseResult<Vec<ObjectDeclaration>> {
     let token = stream.expect()?;
-    let result = try_token_kind!(
+    let result = try_init_token_kind!(
         token,
         Constant => parse_object_declaration_kind(stream, ObjectClass::Constant)?,
         Signal => parse_object_declaration_kind(stream, ObjectClass::Signal)?,

vhdl_lang/src/syntax/sequential_statement.rs

@@ -534,7 +534,7 @@ fn parse_unlabeled_sequential_statement(
     diagnostics: &mut dyn DiagnosticHandler,
 ) -> ParseResult<SequentialStatement> {
     let statement = {
-        try_token_kind!(
+        try_init_token_kind!(
             token,
             Wait => SequentialStatement::Wait(parse_wait_statement_known_keyword(stream)?),
             Assert => SequentialStatement::Assert(parse_assert_statement_known_keyword(stream)?),

vhdl_lang/src/syntax/tokens/tokenizer.rs

@@ -217,6 +217,40 @@ macro_rules! try_token_kind {
     }
 }
 
+/// Expect any number of token kind patterns, return on no match with
+/// error diagnostic based on expected kinds
+///
+/// Unlike the try_token_kind this macro gives errors always on the next token
+/// Example:
+///
+/// entity ent is
+/// end entity;
+///            ~ <- error should not be here
+///
+/// foo
+/// ~~~ <- error should be here
+#[macro_export]
+macro_rules! try_init_token_kind {
+    ($token:expr, $($($kind:ident)|+ => $result:expr),*) => {
+        match $token.kind {
+            $(
+                $($kind)|+ => $result
+            ),*,
+            _ => {
+                let kinds = vec![
+                    $(
+                        $(
+                            $kind,
+                        )*
+                    )*
+                ];
+
+                return Err($token.kinds_error(&kinds));
+            }
+        }
+    }
+}
+
 pub fn kind_str(kind: Kind) -> &'static str {
     match kind {
         // Keywords

vhdl_lang/src/syntax/type_declaration.rs

@@ -124,7 +124,7 @@ pub fn parse_protected_type_declaration(
     loop {
         let token = stream.peek_expect()?;
 
-        try_token_kind!(
+        try_init_token_kind!(
             token,
             Impure | Function | Procedure => items.push(ProtectedTypeDeclarativeItem::Subprogram(
                 parse_subprogram_declaration(stream, diagnostics)?,