Improve position of syntax error of trailing token

Author: kraigher

vhdl_lang/src/data/source.rs

@@ -244,7 +244,7 @@ impl Range {
 pub struct SrcPos {
     /// The referenced source file.
     pub source: Source,
-    range: Range,
+    pub range: Range,
 }
 
 impl Ord for SrcPos {

vhdl_lang/src/syntax/concurrent_statement.rs

@@ -265,11 +265,10 @@ fn parse_assignment_known_target(
 
 fn parse_assignment_or_procedure_call(
     stream: &mut TokenStream,
-    token: &Token,
     target: WithPos<Target>,
 ) -> ParseResult<ConcurrentStatement> {
     match_token_kind!(
-    token,
+    stream.expect()?,
     LTE => {
         parse_assignment_known_target(stream, target)
     },
@@ -613,8 +612,7 @@ pub fn parse_concurrent_statement(
                         ConcurrentStatement::Instance(parse_instantiation_statement(stream, unit)?)
                     }
                     _ => {
-                        stream.move_after(&token);
-                        parse_assignment_or_procedure_call(stream, &token, name.map_into(Target::Name))?
+                        parse_assignment_or_procedure_call(stream, name.map_into(Target::Name))?
                     }
                 }
             },
@@ -625,8 +623,7 @@ pub fn parse_concurrent_statement(
             },
             LeftPar => {
                 let target = parse_aggregate_leftpar_known(stream)?.map_into(Target::Aggregate);
-                let token = stream.expect()?;
-                parse_assignment_or_procedure_call(stream, &token, target)?
+                parse_assignment_or_procedure_call(stream, target)?
             }
         )
     };
@@ -670,15 +667,16 @@ pub fn parse_labeled_concurrent_statement_initial_token(
 ) -> ParseResult<LabeledConcurrentStatement> {
     if token.kind == Identifier {
         let name = parse_name_initial_token(stream, token)?;
-        let token = stream.expect()?;
+        let token = stream.peek_expect()?;
         if token.kind == Colon {
             let label = Some(WithDecl::new(to_simple_name(name)?));
+            stream.move_after(&token);
             let token = stream.expect()?;
             let statement = parse_concurrent_statement(stream, token, diagnostics)?;
             Ok(LabeledConcurrentStatement { label, statement })
         } else {
             let target = name.map_into(Target::Name);
-            let statement = parse_assignment_or_procedure_call(stream, &token, target)?;
+            let statement = parse_assignment_or_procedure_call(stream, target)?;
             Ok(LabeledConcurrentStatement {
                 label: None,
                 statement,

vhdl_lang/src/syntax/expression.rs

@@ -156,14 +156,14 @@ pub fn parse_aggregate_initial_choices(
                     result.push(ElementAssociation::Positional(choice.clone()));
                     return Ok(WithPos::from(result, token))
                 } else {
-                    return Err(Diagnostic::error(&token, "Expected => after others"));
+                    return Err(Diagnostic::error(&token.pos_before(), "Expected => after others"));
                 }
             },
             Comma => {
                 if let [Choice::Expression(ref choice)] = *choices.as_slice() {
                     result.push(ElementAssociation::Positional(choice.clone()));
                 } else {
-                    return Err(Diagnostic::error(&token, "Expected => after others"));
+                    return Err(Diagnostic::error(&token.pos_before(), "Expected => after others"));
                 }
                 choices = parse_choices(stream)?;
             },
@@ -443,7 +443,10 @@ fn parse_primary_initial_token(
                     pos,
                 })
             } else {
-                Err(Diagnostic::error(&token, "Expected {expression}"))
+                Err(Diagnostic::error(
+                    &token.pos_before(),
+                    "Expected {expression}",
+                ))
             }
         }
     }

vhdl_lang/src/syntax/interface_declaration.rs

@@ -245,16 +245,17 @@ fn parse_interface_declaration(
 /// Expect ; for all but the last item
 fn parse_semicolon_separator(stream: &mut TokenStream) -> ParseResult<()> {
     let token = stream.peek_expect()?;
-    try_token_kind!(token,
-                      SemiColon => {
-                          stream.move_after(&token);
-                          if stream.peek_expect()?.kind == RightPar {
-                              return Err(Diagnostic::error(&token,
-                                                        format!("Last interface element may not end with {}",
-                                                    kinds_str(&[SemiColon]))));
-                          }
-                      },
-                      RightPar => {}
+    try_token_kind!(
+    token,
+    SemiColon => {
+        stream.move_after(&token);
+        if stream.peek_expect()?.kind == RightPar {
+            return Err(Diagnostic::error(&token.pos_before(),
+                       format!("Last interface element may not end with {}",
+                       kinds_str(&[SemiColon]))));
+        }
+    },
+    RightPar => {}
     );
     Ok(())
 }

vhdl_lang/src/syntax/subprogram.rs

@@ -9,7 +9,7 @@ use super::declarative_part::parse_declarative_part;
 use super::interface_declaration::parse_parameter_interface_list;
 use super::names::parse_type_mark;
 use super::sequential_statement::parse_labeled_sequential_statements;
-use super::tokens::{kinds_error, Kind::*, TokenStream};
+use super::tokens::{Kind::*, TokenStream};
 use crate::ast::*;
 use crate::data::*;
 
@@ -54,7 +54,7 @@ pub fn parse_signature(stream: &mut TokenStream) -> ParseResult<WithPos<Signatur
                     }
                     _ => {
                         stream.move_after(&token);
-                        return Err(kinds_error(token.pos, &[Identifier]))
+                        return Err(token.kinds_error_before(&[Identifier]))
                     }
                 };
             }

vhdl_lang/src/syntax/subtype_indication.rs

@@ -73,7 +73,7 @@ fn parse_composite_constraint(stream: &mut TokenStream) -> ParseResult<WithPos<S
             RightPar | Comma => {}
             _ => {
                 initial = Err(token
-                    .kinds_error(&[RightPar, Comma])
+                    .kinds_error_before(&[RightPar, Comma])
                     .when("parsing index constraint"));
             }
         }