Small refactoring in CAPTURE parsing

Together with the previous change, this means that `ScopedMessage`
only needs to keep around a single unsigned int.

src/catch2/catch_message.cpp

@@ -19,20 +19,19 @@ namespace Catch {
 
 
     ScopedMessage::ScopedMessage( MessageBuilder&& builder ):
-        m_info( CATCH_MOVE(builder.m_info) ) {
-        m_info.message = builder.m_stream.str();
-        getResultCapture().pushScopedMessage( m_info );
+        m_messageId( builder.m_info.sequence ) {
+        MessageInfo info( CATCH_MOVE( builder.m_info ) );
+        info.message = builder.m_stream.str();
+        getResultCapture().pushScopedMessage( CATCH_MOVE(info) );
     }
 
     ScopedMessage::ScopedMessage( ScopedMessage&& old ) noexcept:
-        m_info( CATCH_MOVE( old.m_info ) ) {
+        m_messageId( old.m_messageId ) {
         old.m_moved = true;
     }
 
     ScopedMessage::~ScopedMessage() {
-        if ( !m_moved ){
-            getResultCapture().popScopedMessage(m_info);
-        }
+        if ( !m_moved ) { getResultCapture().popScopedMessage( m_messageId ); }
     }
 
 
@@ -86,8 +85,8 @@ namespace Catch {
             case ',':
                 if (start != pos && openings.empty()) {
                     m_messages.emplace_back(macroName, lineInfo, resultType);
-                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
-                    m_messages.back().message += " := ";
+                    m_messages.back().message += trimmed(start, pos);
+                    m_messages.back().message += " := "_sr;
                     start = pos;
                 }
                 break;
@@ -96,20 +95,20 @@ namespace Catch {
         }
         assert(openings.empty() && "Mismatched openings");
         m_messages.emplace_back(macroName, lineInfo, resultType);
-        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
-        m_messages.back().message += " := ";
+        m_messages.back().message += trimmed(start, names.size() - 1);
+        m_messages.back().message += " := "_sr;
     }
     Capturer::~Capturer() {
         assert( m_captured == m_messages.size() );
-        for ( size_t i = 0; i < m_captured; ++i ) {
-            m_resultCapture.popScopedMessage( m_messages[i] );
+        for (auto const& message : m_messages) {
+            m_resultCapture.popScopedMessage( message.sequence );
         }
     }
 
     void Capturer::captureValue( size_t index, std::string const& value ) {
         assert( index < m_messages.size() );
         m_messages[index].message += value;
-        m_resultCapture.pushScopedMessage( m_messages[index] );
+        m_resultCapture.pushScopedMessage( CATCH_MOVE(m_messages[index]) );
         m_captured++;
     }
 

src/catch2/catch_message.hpp

@@ -57,7 +57,7 @@ namespace Catch {
         ScopedMessage( ScopedMessage&& old ) noexcept;
         ~ScopedMessage();
 
-        MessageInfo m_info;
+        unsigned int m_messageId;
         bool m_moved = false;
     };
 

src/catch2/interfaces/catch_interfaces_capture.hpp

@@ -62,8 +62,8 @@ namespace Catch {
         virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
         virtual void benchmarkFailed( StringRef error ) = 0;
 
-        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
-        virtual void popScopedMessage( MessageInfo const& message ) = 0;
+        virtual void pushScopedMessage( MessageInfo&& message ) = 0;
+        virtual void popScopedMessage( unsigned int messageId ) = 0;
 
         virtual void emplaceUnscopedMessage( MessageBuilder&& builder ) = 0;
 

src/catch2/internal/catch_message_info.hpp

@@ -26,6 +26,7 @@ namespace Catch {
         std::string message;
         SourceLineInfo lineInfo;
         ResultWas::OfType type;
+        // The "ID" of the message, used to know when to remove it from reporter context.
         unsigned int sequence;
 
         DEPRECATED( "Explicitly use the 'sequence' member instead" )

src/catch2/internal/catch_run_context.cpp

@@ -483,11 +483,11 @@ namespace Catch {
         m_reporter->benchmarkFailed( error );
     }
 
-    void RunContext::pushScopedMessage( MessageInfo const& message ) {
-        Detail::g_messages.push_back( message );
+    void RunContext::pushScopedMessage( MessageInfo&& message ) {
+        Detail::g_messages.push_back( CATCH_MOVE(message) );
     }
 
-    void RunContext::popScopedMessage( MessageInfo const& message ) {
+    void RunContext::popScopedMessage( unsigned int messageId ) {
         // Note: On average, it would probably be better to look for the message
         //       backwards. However, we do not expect to have to deal with more
         //       messages than low single digits, so the optimization is tiny,
@@ -496,8 +496,8 @@ namespace Catch {
         Detail::g_messages.erase(
             std::find_if( Detail::g_messages.begin(),
                           Detail::g_messages.end(),
-                          [id = message.sequence]( MessageInfo const& msg ) {
-                              return msg.sequence == id;
+                          [=]( MessageInfo const& msg ) {
+                              return msg.sequence == messageId;
                           } ) );
     }
 

src/catch2/internal/catch_run_context.hpp

@@ -94,8 +94,8 @@ namespace Catch {
         void benchmarkEnded( BenchmarkStats<> const& stats ) override;
         void benchmarkFailed( StringRef error ) override;
 
-        void pushScopedMessage( MessageInfo const& message ) override;
-        void popScopedMessage( MessageInfo const& message ) override;
+        void pushScopedMessage( MessageInfo&& message ) override;
+        void popScopedMessage( unsigned int messageId ) override;
 
         void emplaceUnscopedMessage( MessageBuilder&& builder ) override;