From 88be6ebffe72d7cebe60762df3b9c75316858d81 Mon Sep 17 00:00:00 2001
From: slavek-kucera <53339291+slavek-kucera@users.noreply.github.com>
Date: Fri, 9 Aug 2024 15:41:39 +0200
Subject: [PATCH] perf: Simplify macro operand preprocessing

---
 .../parsing/grammar/hlasmparser_multiline.g4  | 35 +++++++----
 .../parsing/grammar/hlasmparser_singleline.g4 | 43 +++++++++-----
 .../parsing/grammar/macro_operand_rules.g4    | 10 +---
 .../parsing/grammar/operand_field_rules.g4    | 10 +++-
 parser_library/src/parsing/parser_impl.cpp    | 20 ++++---
 parser_library/src/parsing/parser_impl.h      |  5 +-
 .../instruction_sets/ca_processor.cpp         |  3 +-
 .../instruction_sets/macro_processor.cpp      |  2 +-
 .../src/processing/opencode_provider.cpp      | 25 ++++----
 .../occurrence_collector.cpp                  |  4 +-
 .../occurrence_collector.h                    |  3 +-
 .../processing/statement_fields_parser.cpp    | 22 ++++---
 .../macrodef_processor.cpp                    |  2 +-
 .../statement_provider.cpp                    |  5 +-
 parser_library/src/semantics/operand.h        | 16 ++---
 .../src/semantics/operand_impls.cpp           | 59 +------------------
 parser_library/src/semantics/operand_impls.h  | 36 +----------
 .../src/semantics/operand_visitor.h           |  6 +-
 .../test/semantics/operand_test.cpp           | 16 +----
 19 files changed, 121 insertions(+), 201 deletions(-)

diff --git a/parser_library/src/parsing/grammar/hlasmparser_multiline.g4 b/parser_library/src/parsing/grammar/hlasmparser_multiline.g4
index e35e61e77..9fcf9566e 100644
--- a/parser_library/src/parsing/grammar/hlasmparser_multiline.g4
+++ b/parser_library/src/parsing/grammar/hlasmparser_multiline.g4
@@ -589,44 +589,53 @@ op_rem_body_ca_var_def locals [bool pending_empty_op = false, std::vector<range>
     }
 //////////////////////////////////////// mac
 
-op_rem_body_mac returns [op_rem line, range line_range, size_t line_logical_column = 0]
+op_rem_body_mac returns [macop_preprocess_results results, range line_range, size_t line_logical_column = 0]
     :
     SPACE* EOF {$line_range = provider.get_range($ctx->getStart(), _input->LT(-1));}
     |
-    SPACE+ op_rem_body_alt_mac
+    SPACE+ op_rem_body_alt_mac[&$results]
     {
-        $line = std::move($op_rem_body_alt_mac.line);
+        if ($results.text_ranges.empty())
+            $results.total_op_range = provider.get_empty_range($op_rem_body_alt_mac.start);
+        else
+            $results.total_op_range = union_range($results.text_ranges.front(), $results.text_ranges.back());
         $line_range = provider.get_range($op_rem_body_alt_mac.ctx);
         $line_logical_column = static_cast<hlasm_plugin::parser_library::lexing::token*>($op_rem_body_alt_mac.start)->get_logical_column();
     } EOF;
 
-op_rem_body_alt_mac returns [op_rem line]
+op_rem_body_alt_mac [macop_preprocess_results* results]
     :
     (
         (
-            mac_op? comma
+            mac_preproc? comma
             {
-                if ($mac_op.ctx && $mac_op.op)
-                    $line.operands.push_back(std::move($mac_op.op));
-                $line.operands.push_back(std::make_unique<semantics::empty_operand>(provider.get_range($comma.ctx->getStart())));
+                if ($mac_preproc.ctx) {
+                   append_context_text($results->text, $mac_preproc.ctx);
+                   $results->text_ranges.push_back(provider.get_range($mac_preproc.ctx));
+                   $mac_preproc.ctx = nullptr;
+                }
+                $results->text.push_back(',');
+                $results->text_ranges.push_back(provider.get_range($comma.ctx));
             }
         )+
         {enable_continuation();}
         (
             r1=remark_o CONTINUATION
             {
-                if($r1.value) $line.remarks.push_back(std::move(*$r1.value));
+                if($r1.value) $results->remarks.push_back(std::move(*$r1.value));
             }
         )?
         {disable_continuation();}
     )*
     (
-        last_mac_op=mac_op? last_remark=remark_o
+        last_mac_op=mac_preproc? last_remark=remark_o
         {
-            if ($last_mac_op.ctx && $last_mac_op.op)
-                $line.operands.push_back(std::move($last_mac_op.op));
+            if ($last_mac_op.ctx) {
+               append_context_text($results->text, $last_mac_op.ctx);
+               $results->text_ranges.push_back(provider.get_range($last_mac_op.ctx));
+            }
             if ($last_remark.value)
-                $line.remarks.push_back(std::move(*$last_remark.value));
+                $results->remarks.push_back(std::move(*$last_remark.value));
         }
     );
     finally
diff --git a/parser_library/src/parsing/grammar/hlasmparser_singleline.g4 b/parser_library/src/parsing/grammar/hlasmparser_singleline.g4
index 58410d757..6a1ffd6c4 100644
--- a/parser_library/src/parsing/grammar/hlasmparser_singleline.g4
+++ b/parser_library/src/parsing/grammar/hlasmparser_singleline.g4
@@ -456,33 +456,46 @@ op_rem_body_ca_var_def locals [bool pending_empty_op = true, std::vector<range>
 
 //////////////////////////////////////// mac
 
-op_rem_body_mac returns [op_rem line, range line_range, size_t line_logical_column = 0]
+op_rem_body_mac returns [macop_preprocess_results results, range line_range, size_t line_logical_column = 0]
     :
     SPACE* EOF {$line_range = provider.get_range($ctx->getStart(), _input->LT(-1));}
     |
-    SPACE+ op_rem_body_alt_mac
+    SPACE+ op_rem_body_alt_mac[&$results]
     {
-        $line = std::move($op_rem_body_alt_mac.line);
+        if ($results.text_ranges.empty())
+            $results.total_op_range = provider.get_empty_range($op_rem_body_alt_mac.start);
+        else
+            $results.total_op_range = union_range($results.text_ranges.front(), $results.text_ranges.back());
         $line_range = provider.get_range($op_rem_body_alt_mac.ctx);
         $line_logical_column = static_cast<hlasm_plugin::parser_library::lexing::token*>($op_rem_body_alt_mac.start)->get_logical_column();
     } EOF;
 
-op_rem_body_alt_mac returns [op_rem line]
+op_rem_body_alt_mac [macop_preprocess_results* results]
     :
     (
-        mac_op? COMMA
+        mac_preproc
         {
-            if ($mac_op.ctx && $mac_op.op)
-                $line.operands.push_back(std::move($mac_op.op));
-            $line.operands.push_back(std::make_unique<semantics::empty_operand>(provider.get_range($COMMA)));
+            append_context_text($results->text, $mac_preproc.ctx);
+            $results->text_ranges.push_back(provider.get_range($mac_preproc.ctx));
         }
-    )*
+    )?
     (
-        last_mac_op=mac_op? last_remark=remark_o
+        COMMA
         {
-            if ($last_mac_op.ctx && $last_mac_op.op)
-                $line.operands.push_back(std::move($last_mac_op.op));
-            if ($last_remark.value)
-                $line.remarks.push_back(std::move(*$last_remark.value));
+            $results->text.push_back(',');
+            $results->text_ranges.push_back(provider.get_range($COMMA));
         }
-    );
+        (
+        mac_preproc
+        {
+            append_context_text($results->text, $mac_preproc.ctx);
+            $results->text_ranges.push_back(provider.get_range($mac_preproc.ctx));
+        }
+        )?
+    )*
+    last_remark=remark_o
+    {
+        if ($last_remark.value)
+            $results->remarks.push_back(std::move(*$last_remark.value));
+    }
+    ;
diff --git a/parser_library/src/parsing/grammar/macro_operand_rules.g4 b/parser_library/src/parsing/grammar/macro_operand_rules.g4
index 929a3a4f4..f63284ddf 100644
--- a/parser_library/src/parsing/grammar/macro_operand_rules.g4
+++ b/parser_library/src/parsing/grammar/macro_operand_rules.g4
@@ -16,17 +16,11 @@
 parser grammar macro_operand_rules;
 
 
-mac_op returns [operand_ptr op]
-    : mac_preproc
-    {
-        $op = std::make_unique<macro_operand_string>(get_context_text($mac_preproc.ctx),provider.get_range($mac_preproc.ctx));
-    };
-
 mac_op_o returns [operand_ptr op]
     : mac_entry?
     {
         if($mac_entry.ctx)
-            $op = std::make_unique<macro_operand_chain>(std::move($mac_entry.chain),provider.get_range($mac_entry.ctx));
+            $op = std::make_unique<macro_operand>(std::move($mac_entry.chain),provider.get_range($mac_entry.ctx));
         else
             $op = std::make_unique<semantics::empty_operand>(provider.original_range);
     };
@@ -51,7 +45,7 @@ mac_preproc
         | DOT
         | AMPERSAND
         (
-            ORDSYMBOL (ORDSYMBOL|NUM)*
+            ORDSYMBOL
             |
             LPAR
             |
diff --git a/parser_library/src/parsing/grammar/operand_field_rules.g4 b/parser_library/src/parsing/grammar/operand_field_rules.g4
index 2b562f378..13e3cd879 100644
--- a/parser_library/src/parsing/grammar/operand_field_rules.g4
+++ b/parser_library/src/parsing/grammar/operand_field_rules.g4
@@ -196,13 +196,17 @@ op_rem_body_asm_r returns [op_rem line]
 
 //////////////////////////////////////// mac_r
 
-op_rem_body_mac_r returns [op_rem line]
+op_rem_body_mac_r returns [macop_preprocess_results results]
     :
     SPACE* EOF
     |
-    op_rem_body_alt_mac
+    op_rem_body_alt_mac[&$results]
     {
-        $line = std::move($op_rem_body_alt_mac.line);
+        auto& results = $results;
+        if (results.text_ranges.empty())
+            results.total_op_range = provider.get_empty_range($op_rem_body_alt_mac.start);
+        else
+            results.total_op_range = union_range(results.text_ranges.front(), results.text_ranges.back());
     } EOF;
 
 op_rem_body_noop_r
diff --git a/parser_library/src/parsing/parser_impl.cpp b/parser_library/src/parsing/parser_impl.cpp
index 2b8f66a81..accba27ba 100644
--- a/parser_library/src/parsing/parser_impl.cpp
+++ b/parser_library/src/parsing/parser_impl.cpp
@@ -99,7 +99,10 @@ struct parser_holder_impl final : parser_holder
     void lookahead_operands_and_remarks_asm() const override { get_parser().lookahead_operands_and_remarks_asm(); }
     void lookahead_operands_and_remarks_dat() const override { get_parser().lookahead_operands_and_remarks_dat(); }
 
-    semantics::op_rem op_rem_body_mac_r() const override { return std::move(get_parser().op_rem_body_mac_r()->line); }
+    semantics::macop_preprocess_results op_rem_body_mac_r() const override
+    {
+        return std::move(get_parser().op_rem_body_mac_r()->results);
+    }
     semantics::operand_list macro_ops() const override { return std::move(get_parser().macro_ops()->list); }
     semantics::op_rem op_rem_body_asm_r() const override { return std::move(get_parser().op_rem_body_asm_r()->line); }
     semantics::op_rem op_rem_body_mach_r() const override { return std::move(get_parser().op_rem_body_mach_r()->line); }
@@ -117,7 +120,7 @@ struct parser_holder_impl final : parser_holder
     mac_op_data op_rem_body_mac() const override
     {
         auto rule = get_parser().op_rem_body_mac();
-        return { std::move(rule->line), rule->line_range, rule->line_logical_column };
+        return { std::move(rule->results), rule->line_range, rule->line_logical_column };
     }
 
     operand_ptr ca_op_expr() const override { return std::move(get_parser().ca_op_expr()->op); }
@@ -418,6 +421,13 @@ void parser_impl::add_label_component(
 }
 
 std::string parser_impl::get_context_text(const antlr4::ParserRuleContext* ctx) const
+{
+    std::string result;
+    append_context_text(result, ctx);
+    return result;
+}
+
+void parser_impl::append_context_text(std::string& s, const antlr4::ParserRuleContext* ctx) const
 {
     auto start = ctx->start;
     auto stop = ctx->stop;
@@ -428,14 +438,10 @@ std::string parser_impl::get_context_text(const antlr4::ParserRuleContext* ctx)
     auto startId = start->getTokenIndex();
     auto stopId = stop->getTokenIndex();
 
-    std::string result;
-
     for (auto id = startId; id <= stopId; ++id)
         if (auto token = input.get(id);
             token->getChannel() == lexing::lexer::Channels::DEFAULT_CHANNEL && token->getType() != antlr4::Token::EOF)
-            result.append(token->getText());
-
-    return result;
+            s.append(token->getText());
 }
 
 bool parser_impl::goff() const noexcept { return hlasm_ctx->goff(); }
diff --git a/parser_library/src/parsing/parser_impl.h b/parser_library/src/parsing/parser_impl.h
index 07a4bf8f2..bd9c61d01 100644
--- a/parser_library/src/parsing/parser_impl.h
+++ b/parser_library/src/parsing/parser_impl.h
@@ -168,6 +168,7 @@ class parser_impl : public antlr4::Parser
         semantics::vs_ptr s, semantics::concat_chain& chain, std::string& buffer, bool& has_variables) const;
 
     std::string get_context_text(const antlr4::ParserRuleContext* ctx) const;
+    void append_context_text(std::string& s, const antlr4::ParserRuleContext* ctx) const;
 
     bool goff() const noexcept;
 
@@ -207,7 +208,7 @@ struct parser_holder
     virtual void lookahead_operands_and_remarks_asm() const = 0;
     virtual void lookahead_operands_and_remarks_dat() const = 0;
 
-    virtual semantics::op_rem op_rem_body_mac_r() const = 0;
+    virtual semantics::macop_preprocess_results op_rem_body_mac_r() const = 0;
     virtual semantics::operand_list macro_ops() const = 0;
     virtual semantics::op_rem op_rem_body_asm_r() const = 0;
     virtual semantics::op_rem op_rem_body_mach_r() const = 0;
@@ -226,7 +227,7 @@ struct parser_holder
 
     struct mac_op_data
     {
-        semantics::op_rem operands;
+        semantics::macop_preprocess_results operands;
         range op_range;
         size_t op_logical_column;
     };
diff --git a/parser_library/src/processing/instruction_sets/ca_processor.cpp b/parser_library/src/processing/instruction_sets/ca_processor.cpp
index 2124c6584..cbf589c45 100644
--- a/parser_library/src/processing/instruction_sets/ca_processor.cpp
+++ b/parser_library/src/processing/instruction_sets/ca_processor.cpp
@@ -479,8 +479,7 @@ struct AREAD_operand_visitor final : public semantics::operand_visitor
     }
     void visit(const semantics::seq_ca_operand&) override {}
     void visit(const semantics::branch_ca_operand&) override {}
-    void visit(const semantics::macro_operand_chain&) override {}
-    void visit(const semantics::macro_operand_string&) override {}
+    void visit(const semantics::macro_operand&) override {}
 };
 } // namespace
 
diff --git a/parser_library/src/processing/instruction_sets/macro_processor.cpp b/parser_library/src/processing/instruction_sets/macro_processor.cpp
index e3b11a84b..2ecc22d87 100644
--- a/parser_library/src/processing/instruction_sets/macro_processor.cpp
+++ b/parser_library/src/processing/instruction_sets/macro_processor.cpp
@@ -298,7 +298,7 @@ std::vector<context::macro_arg> macro_processor::get_operand_args(const resolved
             continue;
         }
 
-        auto tmp = op->access_mac()->access_chain();
+        auto tmp = op->access_mac();
         assert(tmp);
 
         auto& tmp_chain = tmp->chain;
diff --git a/parser_library/src/processing/opencode_provider.cpp b/parser_library/src/processing/opencode_provider.cpp
index 7ea1494bc..ff8af6a4a 100644
--- a/parser_library/src/processing/opencode_provider.cpp
+++ b/parser_library/src/processing/opencode_provider.cpp
@@ -422,29 +422,26 @@ std::shared_ptr<const context::hlasm_statement> opencode_provider::process_ordin
                     h.op_rem_body_dat();
                     break;
                 default: {
-                    auto [line, line_range, line_logical_column] = h.op_rem_body_mac();
+                    auto [reparse_data, line_range, line_logical_column] = h.op_rem_body_mac();
 
-                    if (h.error_handler->error_reported())
+                    semantics::operand_list op_list;
+                    if (!h.error_handler->error_reported() && !reparse_data.text.empty())
                     {
-                        line.operands.clear();
-                    }
-                    else if (line.operands.size())
-                    {
-                        auto [to_parse, ranges, r] = join_operands(line.operands);
-
-                        semantics::range_provider tmp_provider(
-                            r, ranges, semantics::adjusting_state::MACRO_REPARSE, h.lex->get_line_limits());
+                        semantics::range_provider tmp_provider(reparse_data.total_op_range,
+                            std::move(reparse_data.text_ranges),
+                            semantics::adjusting_state::MACRO_REPARSE,
+                            h.lex->get_line_limits());
 
-                        const auto& h_second = prepare_operand_parser(to_parse,
+                        const auto& h_second = prepare_operand_parser(reparse_data.text,
                             *m_ctx.hlasm_ctx,
                             format.form == processing_form::UNKNOWN ? &diags_filter : diags,
                             std::move(tmp_provider),
-                            r,
+                            reparse_data.total_op_range,
                             line_logical_column,
                             proc_status,
                             true);
 
-                        line.operands = h_second.macro_ops();
+                        op_list = h_second.macro_ops();
 
                         auto& c = h.parser->get_collector();
                         auto& c_s = h_second.parser->get_collector();
@@ -456,7 +453,7 @@ std::shared_ptr<const context::hlasm_statement> opencode_provider::process_ordin
                     }
 
                     h.parser->get_collector().set_operand_remark_field(
-                        std::move(line.operands), std::move(line.remarks), line_range);
+                        std::move(op_list), std::move(reparse_data.remarks), line_range);
 
                     break;
                 }
diff --git a/parser_library/src/processing/statement_analyzers/occurrence_collector.cpp b/parser_library/src/processing/statement_analyzers/occurrence_collector.cpp
index c10091236..b048bdd67 100644
--- a/parser_library/src/processing/statement_analyzers/occurrence_collector.cpp
+++ b/parser_library/src/processing/statement_analyzers/occurrence_collector.cpp
@@ -93,9 +93,7 @@ void occurrence_collector::visit(const semantics::branch_ca_operand& op)
     get_occurrence(op.sequence_symbol);
 }
 
-void occurrence_collector::visit(const semantics::macro_operand_chain& op) { get_occurrence(op.chain); }
-
-void occurrence_collector::visit(const semantics::macro_operand_string&) {}
+void occurrence_collector::visit(const semantics::macro_operand& op) { get_occurrence(op.chain); }
 
 void occurrence_collector::get_occurrence(const semantics::variable_symbol& var)
 {
diff --git a/parser_library/src/processing/statement_analyzers/occurrence_collector.h b/parser_library/src/processing/statement_analyzers/occurrence_collector.h
index 415f5ba59..56609eb16 100644
--- a/parser_library/src/processing/statement_analyzers/occurrence_collector.h
+++ b/parser_library/src/processing/statement_analyzers/occurrence_collector.h
@@ -55,8 +55,7 @@ class occurrence_collector final : public semantics::operand_visitor,
     void visit(const semantics::expr_ca_operand& op) override;
     void visit(const semantics::seq_ca_operand& op) override;
     void visit(const semantics::branch_ca_operand& op) override;
-    void visit(const semantics::macro_operand_chain& op) override;
-    void visit(const semantics::macro_operand_string& op) override;
+    void visit(const semantics::macro_operand& op) override;
 
     void get_occurrence(const semantics::variable_symbol& var);
     void get_occurrence(const semantics::seq_sym& seq);
diff --git a/parser_library/src/processing/statement_fields_parser.cpp b/parser_library/src/processing/statement_fields_parser.cpp
index 1edc168fb..3e908b163 100644
--- a/parser_library/src/processing/statement_fields_parser.cpp
+++ b/parser_library/src/processing/statement_fields_parser.cpp
@@ -78,24 +78,21 @@ statement_fields_parser::parse_result statement_fields_parser::parse_operand_fie
     {
         switch (format.form)
         {
-            case processing::processing_form::MAC:
-                line = h.op_rem_body_mac_r();
+            case processing::processing_form::MAC: {
+                auto reparse_data = h.op_rem_body_mac_r();
                 literals = h.parser->get_collector().take_literals();
 
-                if (h.error_handler->error_reported())
+                line.remarks = std::move(reparse_data.remarks);
+                if (!h.error_handler->error_reported() && !reparse_data.text.empty())
                 {
-                    line.operands.clear();
-                }
-                else if (line.operands.size())
-                {
-                    auto [to_parse, ranges, r] = join_operands(line.operands);
-
                     const auto& h_second = *m_parser_singleline;
-                    h_second.prepare_parser(to_parse,
+                    h_second.prepare_parser(reparse_data.text,
                         m_hlasm_ctx,
                         &add_diag_subst,
-                        semantics::range_provider(
-                            r, std::move(ranges), semantics::adjusting_state::MACRO_REPARSE, h.lex->get_line_limits()),
+                        semantics::range_provider(reparse_data.total_op_range,
+                            std::move(reparse_data.text_ranges),
+                            semantics::adjusting_state::MACRO_REPARSE,
+                            h.lex->get_line_limits()),
                         original_range,
                         logical_column,
                         status,
@@ -105,6 +102,7 @@ statement_fields_parser::parse_result statement_fields_parser::parse_operand_fie
                     literals = h.parser->get_collector().take_literals();
                 }
                 break;
+            }
             case processing::processing_form::ASM:
                 line = h.op_rem_body_asm_r();
                 literals = h.parser->get_collector().take_literals();
diff --git a/parser_library/src/processing/statement_processors/macrodef_processor.cpp b/parser_library/src/processing/statement_processors/macrodef_processor.cpp
index 0b1b6ee7f..78f000fe9 100644
--- a/parser_library/src/processing/statement_processors/macrodef_processor.cpp
+++ b/parser_library/src/processing/statement_processors/macrodef_processor.cpp
@@ -267,7 +267,7 @@ void macrodef_processor::process_prototype_operand(
             continue;
         }
 
-        auto tmp = op->access_mac()->access_chain();
+        auto tmp = op->access_mac();
         assert(tmp);
 
         auto& tmp_chain = tmp->chain;
diff --git a/parser_library/src/processing/statement_providers/statement_provider.cpp b/parser_library/src/processing/statement_providers/statement_provider.cpp
index 0d032365e..75625fb92 100644
--- a/parser_library/src/processing/statement_providers/statement_provider.cpp
+++ b/parser_library/src/processing/statement_providers/statement_provider.cpp
@@ -128,9 +128,8 @@ bool statement_provider::process_operands(std::vector<context::id_index>& symbol
                     symbols, op->access_model()->chain, eval_ctx);
                 break;
             case semantics::operand_type::MAC:
-                if (op->access_mac()->kind == semantics::mac_kind::CHAIN)
-                    result |= semantics::concatenation_point::get_undefined_attributed_symbols(
-                        symbols, op->access_mac()->access_chain()->chain, eval_ctx);
+                result |= semantics::concatenation_point::get_undefined_attributed_symbols(
+                    symbols, op->access_mac()->chain, eval_ctx);
                 break;
             case semantics::operand_type::CA:
                 result |= op->access_ca()->get_undefined_attributed_symbols(symbols, eval_ctx);
diff --git a/parser_library/src/semantics/operand.h b/parser_library/src/semantics/operand.h
index 9e51f30c2..9fa6e0cdd 100644
--- a/parser_library/src/semantics/operand.h
+++ b/parser_library/src/semantics/operand.h
@@ -55,6 +55,14 @@ struct op_rem
     std::vector<range> remarks;
 };
 
+struct macop_preprocess_results
+{
+    std::string text;
+    std::vector<range> text_ranges;
+    range total_op_range;
+    std::vector<range> remarks;
+};
+
 // sequence symbol structure
 struct seq_sym
 {
@@ -91,14 +99,6 @@ struct operand
     virtual ~operand() = default;
 };
 
-struct join_operands_result
-{
-    std::string text;
-    std::vector<range> ranges;
-    range total_range;
-};
-
-join_operands_result join_operands(const operand_list&);
 void transform_reloc_imm_operands(semantics::operand_list& op_list, context::id_index instruction);
 
 } // namespace hlasm_plugin::parser_library::semantics
diff --git a/parser_library/src/semantics/operand_impls.cpp b/parser_library/src/semantics/operand_impls.cpp
index fdff4b23c..dca00265b 100644
--- a/parser_library/src/semantics/operand_impls.cpp
+++ b/parser_library/src/semantics/operand_impls.cpp
@@ -650,14 +650,12 @@ bool branch_ca_operand::get_undefined_attributed_symbols(
 
 void branch_ca_operand::apply(operand_visitor& visitor) const { visitor.visit(*this); }
 
-
-
-macro_operand_chain::macro_operand_chain(concat_chain chain, range operand_range)
-    : macro_operand(mac_kind::CHAIN, std::move(operand_range))
+macro_operand::macro_operand(concat_chain chain, range operand_range)
+    : operand(operand_type::MAC, std::move(operand_range))
     , chain(std::move(chain))
 {}
 
-void macro_operand_chain::apply(operand_visitor& visitor) const { visitor.visit(*this); }
+void macro_operand::apply(operand_visitor& visitor) const { visitor.visit(*this); }
 
 data_def_operand::data_def_operand(std::shared_ptr<const expressions::data_definition> dd_ptr, range operand_range)
     : evaluable_operand(operand_type::DAT, std::move(operand_range))
@@ -774,57 +772,6 @@ std::unique_ptr<checking::operand> string_assembler_operand::get_operand_value(
 void string_assembler_operand::apply(operand_visitor& visitor) const { visitor.visit(*this); }
 void string_assembler_operand::apply_mach_visitor(expressions::mach_expr_visitor&) const {}
 
-macro_operand_string::macro_operand_string(std::string value, const range operand_range)
-    : macro_operand(mac_kind::STRING, operand_range)
-    , value(std::move(value))
-{}
-
-void macro_operand_string::apply(operand_visitor& visitor) const { visitor.visit(*this); }
-
-macro_operand_chain* macro_operand::access_chain()
-{
-    return kind == mac_kind::CHAIN ? static_cast<macro_operand_chain*>(this) : nullptr;
-}
-
-macro_operand_string* macro_operand::access_string()
-{
-    return kind == mac_kind::STRING ? static_cast<macro_operand_string*>(this) : nullptr;
-}
-
-macro_operand::macro_operand(mac_kind kind, range operand_range)
-    : operand(operand_type::MAC, std::move(operand_range))
-    , kind(kind)
-{}
-
-
-join_operands_result join_operands(const operand_list& operands)
-{
-    if (operands.empty())
-        return {};
-
-    join_operands_result result;
-    size_t string_size = operands.size();
-
-    for (const auto& op : operands)
-        if (auto m_op = dynamic_cast<semantics::macro_operand_string*>(op.get()))
-            string_size += m_op->value.size();
-
-    result.text.reserve(string_size);
-
-    for (const auto& op : operands)
-    {
-        if (auto m_op = dynamic_cast<semantics::macro_operand_string*>(op.get()))
-            result.text.append(m_op->value);
-        else
-            result.text.push_back(',');
-
-        result.ranges.push_back(op->operand_range);
-    }
-    result.total_range = union_range(operands.front()->operand_range, operands.back()->operand_range);
-
-    return result;
-}
-
 struct request_halfword_alignment final : public expressions::mach_expr_visitor
 {
     // Inherited via mach_expr_visitor
diff --git a/parser_library/src/semantics/operand_impls.h b/parser_library/src/semantics/operand_impls.h
index 9fba5c4ba..a80405111 100644
--- a/parser_library/src/semantics/operand_impls.h
+++ b/parser_library/src/semantics/operand_impls.h
@@ -488,47 +488,15 @@ struct branch_ca_operand final : ca_operand
     void apply(operand_visitor& visitor) const override;
 };
 
-
-enum class mac_kind
-{
-    CHAIN,
-    STRING
-};
-
-struct macro_operand_chain;
-struct macro_operand_string;
-
-struct macro_operand : operand
+struct macro_operand final : operand
 {
-    const mac_kind kind;
-
-    macro_operand_chain* access_chain();
-    macro_operand_string* access_string();
-
-protected:
-    macro_operand(mac_kind kind, range operand_range);
-};
-
-// macro instruction operand
-struct macro_operand_chain final : macro_operand
-{
-    macro_operand_chain(concat_chain chain, const range operand_range);
+    macro_operand(concat_chain chain, range operand_range);
 
     concat_chain chain;
 
     void apply(operand_visitor& visitor) const override;
 };
 
-// macro instruction operand
-struct macro_operand_string final : macro_operand
-{
-    macro_operand_string(std::string value, const range operand_range);
-
-    std::string value;
-
-    void apply(operand_visitor& visitor) const override;
-};
-
 } // namespace hlasm_plugin::parser_library::semantics
 
 #endif
diff --git a/parser_library/src/semantics/operand_visitor.h b/parser_library/src/semantics/operand_visitor.h
index 45137a88f..b422887f7 100644
--- a/parser_library/src/semantics/operand_visitor.h
+++ b/parser_library/src/semantics/operand_visitor.h
@@ -30,8 +30,7 @@ struct var_ca_operand;
 struct expr_ca_operand;
 struct seq_ca_operand;
 struct branch_ca_operand;
-struct macro_operand_chain;
-struct macro_operand_string;
+struct macro_operand;
 
 // base class for a visitor pattern over operand structures
 class operand_visitor
@@ -53,8 +52,7 @@ class operand_visitor
     virtual void visit(const expr_ca_operand& op) = 0;
     virtual void visit(const seq_ca_operand& op) = 0;
     virtual void visit(const branch_ca_operand& op) = 0;
-    virtual void visit(const macro_operand_chain& op) = 0;
-    virtual void visit(const macro_operand_string& op) = 0;
+    virtual void visit(const macro_operand& op) = 0;
 };
 
 } // namespace hlasm_plugin::parser_library::semantics
diff --git a/parser_library/test/semantics/operand_test.cpp b/parser_library/test/semantics/operand_test.cpp
index ae27bb1e1..e5777333b 100644
--- a/parser_library/test/semantics/operand_test.cpp
+++ b/parser_library/test/semantics/operand_test.cpp
@@ -96,15 +96,8 @@ bool access_ca_op(ca_kind kind, ca_operand* o)
     return access_op(operand_type::CA, op);
 }
 
-bool access_mac_op(mac_kind kind, macro_operand* o)
+bool access_mac_op(macro_operand* o)
 {
-    auto chain_op = o->access_chain();
-    if ((kind == mac_kind::CHAIN) != (chain_op != nullptr))
-        return false;
-    auto string_op = o->access_string();
-    if ((kind == mac_kind::STRING) != (string_op != nullptr))
-        return false;
-
     operand* op = o;
     return access_op(operand_type::MAC, op);
 }
@@ -157,11 +150,8 @@ TEST(operand, access_operand)
 
     // macro operand
     // chain
-    macro_operand_chain moc({}, range());
-    EXPECT_TRUE(access_mac_op(mac_kind::CHAIN, &moc));
-    // string
-    macro_operand_string mos("", range());
-    EXPECT_TRUE(access_mac_op(mac_kind::STRING, &mos));
+    macro_operand moc({}, range());
+    EXPECT_TRUE(access_mac_op(&moc));
 }
 
 TEST(operand, resolve_model)