Merge pull request #73 from Bochlin/72-postponed-process-not-fully-supported

Check for postponed at end of process

Author: kraigher

vhdl_lang/src/project.rs

@@ -208,7 +208,7 @@ pub struct SourceFile {
 
 impl SourceFile {
     fn take_design_file(&mut self) -> DesignFile {
-        std::mem::replace(&mut self.design_file, DesignFile::default())
+        std::mem::take(&mut self.design_file)
     }
 
     pub fn num_lines(&self) -> usize {

vhdl_lang/src/syntax/concurrent_statement.rs

@@ -196,6 +196,14 @@ pub fn parse_process_statement(
     let decl = parse_declarative_part(stream, diagnostics, true)?;
     let (statements, end_token) = parse_labeled_sequential_statements(stream, diagnostics)?;
     try_token_kind!(end_token, End => {});
+    if let Some(token) = stream.pop_if_kind(Postponed)? {
+        if !postponed {
+            diagnostics.push(Diagnostic::error(
+                token,
+                "'postponed' at the end of non-postponed process.",
+            ));
+        }
+    }
     stream.expect_kind(Process)?;
     // @TODO check name
     stream.pop_if_kind(Identifier)?;
@@ -961,6 +969,52 @@ end process;
         assert_eq!(stmt.statement, ConcurrentStatement::Process(process));
     }
 
+    #[test]
+    fn test_postponed_process_statement_end_postponed() {
+        let code = Code::new(
+            "\
+postponed process
+begin
+end postponed process;
+",
+        );
+        let process = ProcessStatement {
+            postponed: true,
+            sensitivity_list: None,
+            decl: vec![],
+            statements: vec![],
+        };
+        let stmt = code.with_stream_no_diagnostics(parse_labeled_concurrent_statement);
+        assert_eq!(stmt.label, None);
+        assert_eq!(stmt.statement, ConcurrentStatement::Process(process));
+    }
+
+    #[test]
+    fn test_process_statement_end_postponed() {
+        let code = Code::new(
+            "\
+process is
+begin
+end postponed process;
+",
+        );
+        let (stmt, diagnostics) = code.with_stream_diagnostics(parse_labeled_concurrent_statement);
+        let process = ProcessStatement {
+            postponed: false,
+            sensitivity_list: None,
+            decl: Vec::new(),
+            statements: Vec::new(),
+        };
+        assert_eq!(
+            diagnostics,
+            vec![Diagnostic::error(
+                code.s1("postponed"),
+                "'postponed' at the end of non-postponed process."
+            )]
+        );
+        assert_eq!(stmt.statement, ConcurrentStatement::Process(process));
+    }
+
     #[test]
     fn test_process_statement_sensitivity() {
         let code = Code::new(

vhdl_lang/src/syntax/design_unit.rs

@@ -153,7 +153,7 @@ pub fn parse_package_body(
 }
 
 fn take_context_clause(context_clause: &mut ContextClause) -> ContextClause {
-    std::mem::replace(context_clause, ContextClause::default())
+    std::mem::take(context_clause)
 }
 
 fn context_item_message(context_item: &ContextItem, message: impl AsRef<str>) -> String {

vhdl_ls/src/vhdl_server.rs

@@ -228,8 +228,7 @@ impl<T: RpcChannel + Clone> InitializedVHDLServer<T> {
             }
         };
 
-        let mut files_with_notifications =
-            std::mem::replace(&mut self.files_with_notifications, FnvHashMap::default());
+        let mut files_with_notifications = std::mem::take(&mut self.files_with_notifications);
         for (file_uri, diagnostics) in diagnostics_by_uri(diagnostics).into_iter() {
             let mut lsp_diagnostics = Vec::new();
             for diagnostic in diagnostics {