rust-lang
diff --git a/‎gcc/diagnostic-buffer.h
+109 b/‎gcc/diagnostic-buffer.h
+109
diff --git a/‎gcc/diagnostic-format-json.cc
+109-14 b/‎gcc/diagnostic-format-json.cc
+109-14
@@ -0,0 +1,109 @@
+/* Support for buffering diagnostics before flushing them to output format.
+   Copyright (C) 2024 Free Software Foundation, Inc.
+   Contributed by David Malcolm <[email protected]>.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#ifndef GCC_DIAGNOSTIC_BUFFER_H
+#define GCC_DIAGNOSTIC_BUFFER_H
+
+#include "diagnostic.h"
+
+class diagnostic_per_format_buffer;
+class diagnostic_output_format;
+  class diagnostic_text_output_format;
+
+/* Class representing a buffer of zero or more diagnostics that
+   have been reported to a diagnostic_context, but which haven't
+   yet been flushed.
+
+   A diagnostic_buffer can be:
+
+   * flushed to the diagnostic_context, which issues
+   the diagnostics within the buffer to the output format
+   and checks for limits such as -fmax-errors=, or
+
+   * moved to another diagnostic_buffer, which moves the diagnostics
+   within the first buffer to the other buffer, appending them after any
+   existing diagnostics within the destination buffer, emptying the
+   source buffer, or
+
+   * cleared, which discards any diagnostics within the buffer
+   without issuing them to the output format.
+
+   Since a buffer needs to contain output-format-specific data,
+   it's not possible to change the output format of the
+   diagnostic_context once any buffers are non-empty.
+
+   To simplify implementing output formats, it's not possible
+   to change buffering on a diagnostic_context whilst within a
+   diagnostic group.  */
+
+class diagnostic_buffer
+{
+ public:
+  friend class diagnostic_context;
+
+  diagnostic_buffer (diagnostic_context &ctxt);
+  ~diagnostic_buffer ();
+
+  void dump (FILE *out, int indent) const;
+  void DEBUG_FUNCTION dump () const { dump (stderr, 0); }
+
+  int diagnostic_count (diagnostic_t kind) const
+  {
+    return m_diagnostic_counters.get_count (kind);
+  }
+
+  bool empty_p () const;
+
+  void move_to (diagnostic_buffer &dest);
+
+ private:
+  void ensure_per_format_buffer ();
+
+  diagnostic_context &m_ctxt;
+  diagnostic_per_format_buffer *m_per_format_buffer;
+
+  /* The number of buffered diagnostics of each kind.  */
+  diagnostic_counters m_diagnostic_counters;
+};
+
+/* Implementation detail of diagnostic_buffer.
+
+   Abstract base class describing how to represent zero of more
+   buffered diagnostics for a particular diagnostic_output_format
+   (e.g. text vs SARIF).
+
+   Each diagnostic_output_format subclass should implement its own
+   subclass for handling diagnostic_buffer.  */
+
+class diagnostic_per_format_buffer
+{
+public:
+  virtual ~diagnostic_per_format_buffer () {}
+
+  virtual void dump (FILE *out, int indent) const = 0;
+  void DEBUG_FUNCTION dump () const { dump (stderr, 0); }
+
+  virtual bool empty_p () const = 0;
+  virtual void move_to (diagnostic_per_format_buffer &dest) = 0;
+  virtual void clear () = 0;
+  virtual void flush () = 0;
+};
+
+#endif /* ! GCC_DIAGNOSTIC_BUFFER_H */
@@ -21,29 +21,68 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "config.h"
 #define INCLUDE_MEMORY
+#define INCLUDE_VECTOR
 #include "system.h"
 #include "coretypes.h"
 #include "diagnostic.h"
 #include "selftest-diagnostic.h"
 #include "diagnostic-metadata.h"
 #include "diagnostic-path.h"
 #include "diagnostic-format.h"
+#include "diagnostic-buffer.h"
 #include "json.h"
 #include "selftest.h"
 #include "logical-location.h"
 #include "make-unique.h"
 
+class json_output_format;
+
+/* Concrete buffering implementation subclass for JSON output.  */
+
+class diagnostic_json_format_buffer : public diagnostic_per_format_buffer
+{
+public:
+  friend class json_output_format;
+
+  diagnostic_json_format_buffer (json_output_format &format)
+  : m_format (format)
+  {}
+
+  void dump (FILE *out, int indent) const final override;
+  bool empty_p () const final override;
+  void move_to (diagnostic_per_format_buffer &dest) final override;
+  void clear () final override;
+  void flush () final override;
+
+private:
+  json_output_format &m_format;
+  std::vector<std::unique_ptr<json::object>> m_results;
+};
+
 /* Subclass of diagnostic_output_format for JSON output.  */
 
 class json_output_format : public diagnostic_output_format
 {
 public:
+  friend class diagnostic_json_format_buffer;
+
   void dump (FILE *out, int indent) const override
   {
     fprintf (out, "%*sjson_output_format\n", indent, "");
     diagnostic_output_format::dump (out, indent);
   }
 
+  diagnostic_per_format_buffer *make_per_format_buffer () final override
+  {
+    return new diagnostic_json_format_buffer (*this);
+  }
+  void set_buffer (diagnostic_per_format_buffer *base_buffer) final override
+  {
+    diagnostic_json_format_buffer *buffer
+      = static_cast<diagnostic_json_format_buffer *> (base_buffer);
+    m_buffer = buffer;
+  }
+
   void on_begin_group () final override
   {
     /* No-op.  */
@@ -69,6 +108,7 @@ class json_output_format : public diagnostic_output_format
   json_output_format (diagnostic_context &context,
 		      bool formatted)
   : diagnostic_output_format (context),
+    m_buffer (nullptr),
     m_toplevel_array (::make_unique<json::array> ()),
     m_cur_group (nullptr),
     m_cur_children_array (nullptr),
@@ -86,6 +126,8 @@ class json_output_format : public diagnostic_output_format
   }
 
 private:
+  diagnostic_json_format_buffer *m_buffer;
+
   /* The top-level JSON array of pending diagnostics.  */
   std::unique_ptr<json::array> m_toplevel_array;
 
@@ -231,6 +273,51 @@ make_json_for_path (diagnostic_context &context,
   return path_array;
 }
 
+/* class diagnostic_json_format_buffer : public diagnostic_per_format_buffer.  */
+
+void
+diagnostic_json_format_buffer::dump (FILE *out, int indent) const
+{
+  fprintf (out, "%*sdiagnostic_json_format_buffer:\n", indent, "");
+  int idx = 0;
+  for (auto &result : m_results)
+    {
+      fprintf (out, "%*sresult[%i]:\n", indent + 2, "", idx);
+      result->dump (out, true);
+      fprintf (out, "\n");
+      ++idx;
+    }
+}
+
+bool
+diagnostic_json_format_buffer::empty_p () const
+{
+  return m_results.empty ();
+}
+
+void
+diagnostic_json_format_buffer::move_to (diagnostic_per_format_buffer &base)
+{
+  diagnostic_json_format_buffer &dest
+    = static_cast<diagnostic_json_format_buffer &> (base);
+  for (auto &&result : m_results)
+    dest.m_results.push_back (std::move (result));
+  m_results.clear ();
+}
+
+void
+diagnostic_json_format_buffer::clear ()
+{
+  m_results.clear ();
+}
+
+void
+diagnostic_json_format_buffer::flush ()
+{
+  for (auto &&result : m_results)
+    m_format.m_toplevel_array->append (std::move (result));
+  m_results.clear ();
+}
 
 /* Implementation of "on_report_diagnostic" vfunc for JSON output.
    Generate a JSON object for DIAGNOSTIC, and store for output
@@ -277,24 +364,32 @@ json_output_format::on_report_diagnostic (const diagnostic_info &diagnostic,
       free (option_url);
     }
 
-  /* If we've already emitted a diagnostic within this auto_diagnostic_group,
-     then add diag_obj to its "children" array.  */
-  if (m_cur_group)
+  if (m_buffer)
     {
-      gcc_assert (m_cur_children_array);
-      m_cur_children_array->append (diag_obj);
+      gcc_assert (!m_cur_group);
+      m_buffer->m_results.push_back (std::unique_ptr<json::object> (diag_obj));
     }
   else
     {
-      /* Otherwise, make diag_obj be the top-level object within the group;
-	 add a "children" array and record the column origin.  */
-      m_cur_group = diag_obj;
-      std::unique_ptr<json::array> children_array
-	= ::make_unique<json::array> ();
-      m_cur_children_array = children_array.get (); // borrowed
-      diag_obj->set ("children", std::move (children_array));
-      diag_obj->set_integer ("column-origin", m_context.m_column_origin);
-      m_toplevel_array->append (diag_obj);
+      /* If we've already emitted a diagnostic within this auto_diagnostic_group,
+	 then add diag_obj to its "children" array.  */
+      if (m_cur_group)
+	{
+	  gcc_assert (m_cur_children_array);
+	  m_cur_children_array->append (diag_obj);
+	}
+      else
+	{
+	  /* Otherwise, make diag_obj be the top-level object within the group;
+	     add a "children" array and record the column origin.  */
+	  m_cur_group = diag_obj;
+	  std::unique_ptr<json::array> children_array
+	    = ::make_unique<json::array> ();
+	  m_cur_children_array = children_array.get (); // borrowed
+	  diag_obj->set ("children", std::move (children_array));
+	  diag_obj->set_integer ("column-origin", m_context.m_column_origin);
+	  m_toplevel_array->append (diag_obj);
+	}
     }
 
   /* diag_obj is now owned by either m_cur_children_array or