refactor sequence message -- parser part

Author: melodyoncode

plantuml/parser/puml_parser/src/grammar/sequence.pest

@@ -168,38 +168,58 @@ sequence_arrow = {
 
 // Messages
 message = {
-    async_marker? ~
-    message_participant? ~ sequence_arrow ~ message_participant? ~
-    activation_marker? ~ sequence_description?
+    parallel_marker? ~
+    message_endpoint ~ sequence_arrow ~ message_endpoint ~
+    message_suffix? ~ sequence_description?
 }
 
-async_marker = { "&" }
-message_participant = {
-    lost_found_marker |
-    quoted_display_with_alias |
-    display_with_alias |
-    alias_with_quoted_display |
-    participant_ref |
-    quoted_string
+parallel_marker = { "&" }
+message_endpoint = {
+      lost_found_marker
+    | inline_participant
+}
+
+inline_participant = {
+      quoted_display_with_alias
+    | alias_with_quoted_display
+    | quoted_display
+    | alias_only
 }
-lost_found_marker = { "[" ~ ("o" | "x")? | ("o" | "x")? ~ ("[" | "]") }
-participant_ref = { CNAME | quoted_string }
 
-activation_marker = { "+"+ | "-"+ | "*"+ | "!"+ }
+lost_found_marker = {
+      left_lost_found
+    | right_lost_found
+}
+//  '[',  '[o',  '[x'
+left_lost_found = { "[" ~ ("o" | "x")? }
+//  ']',  'o]',  'x]'
+right_lost_found = { ("o" | "x")? ~ "]" }
+
+message_suffix = {
+      activate_suffix
+    | deactivate_suffix
+    | create_suffix
+    | destroy_suffix
+}
+activate_suffix = { "++" ~ color_spec? }
+deactivate_suffix = { "--" }
+create_suffix = { "**" }
+destroy_suffix = { "!!" }
 
 // Short activation syntax
 activation_short = { participant_ref ~ ("++" | "--") }
+participant_ref = { CNAME | quoted_string }
 
 // Return
-return_cmd = { async_marker? ~ ^"return" ~ sequence_text_content? }
+return_cmd = { parallel_marker? ~ ^"return" ~ sequence_text_content? }
 
 // Box
 box_start = { "box" ~ quoted_string? ~ color_spec? }
 box_end = { ^"end" ~ WHITESPACE? ~ ^"box" }
 
 // Group commands (alt, opt, loop, etc.)
 group_cmd = {
-    async_marker? ~ group_type ~ group_condition?
+    parallel_marker? ~ group_type ~ group_condition?
 }
 
 group_condition = @{ (!EOL ~ ANY)+ }

plantuml/parser/puml_parser/src/sequence_diagram/src/lib.rs

@@ -15,26 +15,9 @@ pub mod sequence_ast;
 mod sequence_parser;
 
 pub use sequence_ast::{
-    ActivateCmd, Arrow, CreateCmd, DeactivateCmd, DestroyCmd, ExternalEndpoint, GroupCmd,
-    GroupType, Message, MessageContent, ParticipantDef, ParticipantIdentifier, ParticipantType,
-    SeqPumlDocument, Statement,
+    ActivateCmd, Arrow, CreateCmd, DeactivateCmd, DestroyCmd, GroupCmd, GroupType, Message,
+    MessageEndpoint, MessageSuffix, ParticipantIdentifier, ParticipantType, SeqPumlDocument,
+    Statement,
 };
 
 pub use sequence_parser::{PumlSequenceParser, SequenceError};
-
-/// Parse a PlantUML sequence diagram and return the document name and statements
-/// This is a convenience function for backwards compatibility with tests
-pub fn parse_sequence_diagram(
-    input: &str,
-) -> Result<(Option<String>, Vec<Statement>), Box<dyn std::error::Error>> {
-    use parser_core::DiagramParser;
-    use puml_utils::LogLevel;
-    use std::path::PathBuf;
-    use std::rc::Rc;
-
-    let mut parser = PumlSequenceParser;
-    let dummy_path = Rc::new(PathBuf::from("<input>"));
-    let document = parser.parse_file(&dummy_path, input, LogLevel::Error)?;
-
-    Ok((document.name, document.statements))
-}

plantuml/parser/puml_parser/src/sequence_diagram/src/sequence_ast.rs

@@ -14,7 +14,6 @@
 
 use serde::{Deserialize, Serialize};
 use source_location::SourceLocation;
-use std::str::FromStr;
 
 pub use parser_core::common_ast::Arrow;
 
@@ -27,6 +26,9 @@ pub struct SeqPumlDocument {
 
 // Statement types used during parsing
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+// Keep `Message` unboxed for now because the statement representation is
+// expected to be revisited as the sequence parser/resolver model settles.
+#[allow(clippy::large_enum_variant)]
 pub enum Statement {
     DestroyCmd(DestroyCmd),
     CreateCmd(CreateCmd),
@@ -48,26 +50,6 @@ pub struct ParticipantDef {
     pub source_location: SourceLocation,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-pub struct ExternalEndpoint;
-
-impl FromStr for ExternalEndpoint {
-    type Err = ();
-
-    fn from_str(value: &str) -> Result<Self, Self::Err> {
-        match value {
-            "[" | "[o" | "[x" | "]" | "o]" | "x]" => Ok(ExternalEndpoint),
-            _ => Err(()),
-        }
-    }
-}
-
-impl ExternalEndpoint {
-    pub fn as_name(self) -> &'static str {
-        "ExternalEndpoint"
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub enum ParticipantType {
     Participant,
@@ -111,20 +93,26 @@ pub struct DeactivateCmd {
 // Messages (internal parsing structure)
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct Message {
-    pub content: MessageContent,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub activation_marker: Option<String>,
+    pub left: MessageEndpoint,
+    pub arrow: Arrow,
+    pub right: MessageEndpoint,
+    pub suffix: Option<MessageSuffix>,
     pub description: Option<String>,
     pub source_location: SourceLocation,
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub enum MessageContent {
-    WithTargets {
-        left: String,
-        arrow: Arrow,
-        right: String,
-    },
+pub enum MessageEndpoint {
+    Participant(ParticipantIdentifier),
+    LostFound(String),
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum MessageSuffix {
+    Activate,   // ++
+    Deactivate, // --
+    Create,     // **
+    Destroy,    // !!
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]

plantuml/parser/puml_parser/src/sequence_diagram/src/sequence_parser.rs

@@ -243,28 +243,28 @@ impl PumlSequenceParser {
         pair: pest::iterators::Pair<Rule>,
         source_location: SourceLocation,
     ) -> Result<Message, SequenceError> {
-        let mut left: Option<String> = None;
+        let mut left: Option<MessageEndpoint> = None;
         let mut arrow: Option<Arrow> = None;
-        let mut right: Option<String> = None;
-        let mut activation_marker: Option<String> = None;
+        let mut right: Option<MessageEndpoint> = None;
+        let mut suffix: Option<MessageSuffix> = None;
         let mut description: Option<String> = None;
 
         for inner in pair.into_inner() {
             match inner.as_rule() {
-                Rule::message_participant => {
-                    let participant = Self::extract_participant_ref(inner);
+                Rule::message_endpoint => {
+                    let endpoint = Self::parse_message_endpoint(inner)?;
                     // First participant goes to left, second to right
                     if arrow.is_none() {
-                        left = Some(participant);
+                        left = Some(endpoint);
                     } else {
-                        right = Some(participant);
+                        right = Some(endpoint);
                     }
                 }
                 Rule::sequence_arrow => {
                     arrow = Some(Self::parse_arrow(inner)?);
                 }
-                Rule::activation_marker => {
-                    activation_marker = Some(inner.as_str().to_string());
+                Rule::message_suffix => {
+                    suffix = Some(Self::parse_message_suffix(inner));
                 }
                 Rule::sequence_description => {
                     description = inner
@@ -276,22 +276,73 @@ impl PumlSequenceParser {
             }
         }
 
-        let content = MessageContent::WithTargets {
-            left: left.unwrap_or_default(),
+        Ok(Message {
+            left: left.expect("message must contain left endpoint"),
             arrow: arrow.ok_or_else(|| {
                 SequenceError::InvalidStatement("missing arrow in message".to_string())
             })?,
-            right: right.unwrap_or_default(),
-        };
-
-        Ok(Message {
-            content,
-            activation_marker,
+            right: right.expect("message must contain right endpoint"),
+            suffix,
             description,
             source_location,
         })
     }
 
+    fn parse_message_endpoint(
+        pair: pest::iterators::Pair<Rule>,
+    ) -> Result<MessageEndpoint, SequenceError> {
+        let endpoint = pair
+            .into_inner()
+            .next()
+            .expect("message_endpoint must contain an endpoint");
+
+        Ok(match endpoint.as_rule() {
+            Rule::inline_participant => {
+                MessageEndpoint::Participant(Self::parse_participant_identifier(endpoint)?)
+            }
+            Rule::lost_found_marker => {
+                MessageEndpoint::LostFound(Self::parse_lost_found_marker(endpoint))
+            }
+            _ => unreachable!(
+                "message_endpoint grammar produced unsupported value: {:?}",
+                endpoint.as_rule()
+            ),
+        })
+    }
+
+    fn parse_lost_found_marker(pair: pest::iterators::Pair<Rule>) -> String {
+        let marker = pair
+            .into_inner()
+            .next()
+            .expect("lost_found_marker must contain a lost-found endpoint");
+
+        match marker.as_rule() {
+            Rule::left_lost_found | Rule::right_lost_found => marker.as_str().trim().to_string(),
+            _ => unreachable!(
+                "lost_found_marker grammar produced unsupported value: {:?}",
+                marker.as_rule()
+            ),
+        }
+    }
+
+    fn parse_message_suffix(pair: pest::iterators::Pair<Rule>) -> MessageSuffix {
+        let suffix = pair
+            .into_inner()
+            .next()
+            .expect("message_suffix must contain a suffix");
+
+        match suffix.as_rule() {
+            Rule::activate_suffix => MessageSuffix::Activate,
+            Rule::deactivate_suffix => MessageSuffix::Deactivate,
+            Rule::create_suffix => MessageSuffix::Create,
+            Rule::destroy_suffix => MessageSuffix::Destroy,
+            _ => unreachable!(
+                "message_suffix grammar produced unsupported value: {:?}",
+                suffix.as_rule()
+            ),
+        }
+    }
+
     fn parse_arrow(pair: pest::iterators::Pair<Rule>) -> Result<Arrow, SequenceError> {
         common_parse_arrow(pair)
             .map_err(|e| SequenceError::InvalidStatement(format!("invalid arrow: {}", e)))
@@ -433,12 +484,6 @@ impl PumlSequenceParser {
 
     fn extract_participant_ref(pair: pest::iterators::Pair<Rule>) -> String {
         match pair.as_rule() {
-            Rule::message_participant => pair
-                .into_inner()
-                .next()
-                .map(Self::extract_participant_ref)
-                .unwrap_or_default(),
-
             Rule::participant_ref => {
                 let fallback = pair.as_str().trim();
 

plantuml/parser/puml_parser/src/sequence_diagram/test/sequence_integration_test.rs

@@ -65,3 +65,13 @@ fn run_sequence_diagram_parser_case(case_name: &str) {
 fn test_participant_identifiers() {
     run_sequence_diagram_parser_case("participant_identifiers");
 }
+
+#[test]
+fn test_message_participants() {
+    run_sequence_diagram_parser_case("message_participants");
+}
+
+#[test]
+fn test_message_lost_found() {
+    run_sequence_diagram_parser_case("message_lost_found");
+}

plantuml/parser/puml_parser/tests/sequence_diagram/message_lost_found/message_lost_found.puml

@@ -0,0 +1,22 @@
+' *******************************************************************************
+' Copyright (c) 2026 Contributors to the Eclipse Foundation
+'
+' See the NOTICE file(s) distributed with this work for additional
+' information regarding copyright ownership.
+'
+' This program and the accompanying materials are made available under the
+' terms of the Apache License Version 2.0 which is available at
+' https://www.apache.org/licenses/LICENSE-2.0
+'
+' SPDX-License-Identifier: Apache-2.0
+' *******************************************************************************
+@startuml message_lost_found
+
+[ -> Service : left lost bracket
+[o -> Service ++ : left lost bracket o
+[x -> Service ** : left lost bracket x
+Worker -> ] : right lost bracket
+Worker -> o] -- : right lost o bracket
+Worker -> x] !! : right lost x bracket
+
+@enduml