path: root/gcc/diagnostic-format-json.cc

/* JSON output for diagnostics
   Copyright (C) 2018-2024 Free Software Foundation, Inc.
   Contributed by David Malcolm <dmalcolm@redhat.com>.

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/>.  */


#include "config.h"
#define INCLUDE_MEMORY
#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 "json.h"
#include "selftest.h"
#include "logical-location.h"
#include "make-unique.h"

/* Subclass of diagnostic_output_format for JSON output.  */

class json_output_format : public diagnostic_output_format
{
public:
  void on_begin_group () final override
  {
    /* No-op.  */
  }
  void on_end_group () final override
  {
    m_cur_group = nullptr;
    m_cur_children_array = nullptr;
  }
  void
  on_report_diagnostic (const diagnostic_info &diagnostic,
			diagnostic_t orig_diag_kind) final override;
  void on_diagram (const diagnostic_diagram &) final override
  {
    /* No-op.  */
  }
  void after_diagnostic (const diagnostic_info &) final override
  {
    /* No-op.  */
  }

protected:
  json_output_format (diagnostic_context &context,
		      bool formatted)
  : diagnostic_output_format (context),
    m_toplevel_array (::make_unique<json::array> ()),
    m_cur_group (nullptr),
    m_cur_children_array (nullptr),
    m_formatted (formatted)
  {
  }

  /* Flush the top-level array to OUTF.  */
  void
  flush_to_file (FILE *outf)
  {
    m_toplevel_array->dump (outf, m_formatted);
    fprintf (outf, "\n");
    m_toplevel_array = nullptr;
  }

private:
  /* The top-level JSON array of pending diagnostics.  */
  std::unique_ptr<json::array> m_toplevel_array;

  /* The JSON object for the current diagnostic group.  */
  json::object *m_cur_group; // borrowed

  /* The JSON array for the "children" array within the current diagnostic
     group.  */
  json::array *m_cur_children_array; // borrowed

  bool m_formatted;
};

/* Generate a JSON object for LOC.  */

static std::unique_ptr<json::object>
json_from_expanded_location (diagnostic_context &context, location_t loc)
{
  expanded_location exploc = expand_location (loc);
  std::unique_ptr<json::object> result = ::make_unique <json::object> ();
  if (exploc.file)
    result->set_string ("file", exploc.file);
  result->set_integer ("line", exploc.line);

  const enum diagnostics_column_unit orig_unit = context.m_column_unit;
  struct
  {
    const char *name;
    enum diagnostics_column_unit unit;
  } column_fields[] = {
    {"display-column", DIAGNOSTICS_COLUMN_UNIT_DISPLAY},
    {"byte-column", DIAGNOSTICS_COLUMN_UNIT_BYTE}
  };
  int the_column = INT_MIN;
  for (int i = 0; i != ARRAY_SIZE (column_fields); ++i)
    {
      context.m_column_unit = column_fields[i].unit;
      diagnostic_column_policy col_policy (context);
      const int col = col_policy.converted_column (exploc);
      result->set_integer (column_fields[i].name, col);
      if (column_fields[i].unit == orig_unit)
	the_column = col;
    }
  gcc_assert (the_column != INT_MIN);
  result->set_integer ("column", the_column);
  context.m_column_unit = orig_unit;
  return result;
}

/* Generate a JSON object for LOC_RANGE.  */

static std::unique_ptr<json::object>
json_from_location_range (diagnostic_context &context,
			  const location_range *loc_range, unsigned range_idx)
{
  location_t caret_loc = get_pure_location (loc_range->m_loc);

  if (caret_loc == UNKNOWN_LOCATION)
    return nullptr;

  location_t start_loc = get_start (loc_range->m_loc);
  location_t finish_loc = get_finish (loc_range->m_loc);

  std::unique_ptr<json::object> result = ::make_unique <json::object> ();
  result->set ("caret",
	       json_from_expanded_location (context, caret_loc));
  if (start_loc != caret_loc
      && start_loc != UNKNOWN_LOCATION)
    result->set ("start",
		 json_from_expanded_location (context, start_loc));
  if (finish_loc != caret_loc
      && finish_loc != UNKNOWN_LOCATION)
    result->set ("finish",
		 json_from_expanded_location (context, finish_loc));

  if (loc_range->m_label)
    {
      label_text text (loc_range->m_label->get_text (range_idx));
      if (text.get ())
	result->set_string ("label", text.get ());
    }

  return result;
}

/* Generate a JSON object for HINT.  */

static std::unique_ptr<json::object>
json_from_fixit_hint (diagnostic_context &context, const fixit_hint *hint)
{
  std::unique_ptr<json::object> fixit_obj = ::make_unique <json::object> ();

  location_t start_loc = hint->get_start_loc ();
  fixit_obj->set ("start",
		  json_from_expanded_location (context, start_loc));
  location_t next_loc = hint->get_next_loc ();
  fixit_obj->set ("next",
		  json_from_expanded_location (context, next_loc). release ());
  fixit_obj->set_string ("string", hint->get_string ());

  return fixit_obj;
}

/* Generate a JSON object for METADATA.  */

static std::unique_ptr<json::object>
json_from_metadata (const diagnostic_metadata *metadata)
{
  std::unique_ptr<json::object> metadata_obj = ::make_unique <json::object> ();

  if (metadata->get_cwe ())
    metadata_obj->set_integer ("cwe", metadata->get_cwe ());

  return metadata_obj;
}

/* Make a JSON value for PATH.  */

static std::unique_ptr<json::array>
make_json_for_path (diagnostic_context &context,
		    const diagnostic_path *path)
{
  std::unique_ptr<json::array> path_array = ::make_unique<json::array> ();
  for (unsigned i = 0; i < path->num_events (); i++)
    {
      const diagnostic_event &event = path->get_event (i);

      std::unique_ptr<json::object> event_obj = ::make_unique <json::object> ();
      if (event.get_location ())
	event_obj->set ("location",
			json_from_expanded_location (context,
						     event.get_location ()));
      label_text event_text (event.get_desc (false));
      event_obj->set_string ("description", event_text.get ());
      if (const logical_location *logical_loc = event.get_logical_location ())
	{
	  label_text name (logical_loc->get_name_for_path_output ());
	  event_obj->set_string ("function", name.get ());
	}
      event_obj->set_integer ("depth", event.get_stack_depth ());
      path_array->append (std::move (event_obj));
    }
  return path_array;
}


/* Implementation of "on_report_diagnostic" vfunc for JSON output.
   Generate a JSON object for DIAGNOSTIC, and store for output
   within current diagnostic group.  */

void
json_output_format::on_report_diagnostic (const diagnostic_info &diagnostic,
					  diagnostic_t orig_diag_kind)
{
  pretty_printer *const pp = get_printer ();
  pp_output_formatted_text (pp, m_context.get_urlifier ());

  json::object *diag_obj = new json::object ();

  /* Get "kind" of diagnostic.  */
  {
    /* Lose the trailing ": ".  */
    const char *kind_text = get_diagnostic_kind_text (diagnostic.kind);
    size_t len = strlen (kind_text);
    gcc_assert (len > 2);
    gcc_assert (kind_text[len - 2] == ':');
    gcc_assert (kind_text[len - 1] == ' ');
    char *rstrip = xstrdup (kind_text);
    rstrip[len - 2] = '\0';
    diag_obj->set_string ("kind", rstrip);
    free (rstrip);
  }

  // FIXME: encoding of the message (json::string requires UTF-8)
  diag_obj->set_string ("message", pp_formatted_text (pp));
  pp_clear_output_area (pp);

  if (char *option_text = m_context.make_option_name (diagnostic.option_id,
						      orig_diag_kind,
						      diagnostic.kind))
    {
      diag_obj->set_string ("option", option_text);
      free (option_text);
    }

  if (char *option_url = m_context.make_option_url (diagnostic.option_id))
    {
      diag_obj->set_string ("option_url", option_url);
      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)
    {
      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
     m_toplevel_array; further uses of diag_obj are borrowing it.  */

  const rich_location *richloc = diagnostic.richloc;

  {
    std::unique_ptr<json::array> loc_array = ::make_unique<json::array> ();
    for (unsigned int i = 0; i < richloc->get_num_locations (); i++)
      {
	const location_range *loc_range = richloc->get_range (i);
	if (std::unique_ptr<json::object> loc_obj
	      = json_from_location_range (m_context, loc_range, i))
	  loc_array->append (std::move (loc_obj));
      }
    diag_obj->set ("locations", std::move (loc_array));
  }

  if (richloc->get_num_fixit_hints ())
    {
      std::unique_ptr<json::array> fixit_array = ::make_unique<json::array> ();
      for (unsigned int i = 0; i < richloc->get_num_fixit_hints (); i++)
	{
	  const fixit_hint *hint = richloc->get_fixit_hint (i);
	  fixit_array->append (json_from_fixit_hint (m_context, hint));
	}
      diag_obj->set ("fixits", std::move (fixit_array));
    }

  /* TODO: tree-ish things:
     TODO: functions
     TODO: inlining information
     TODO: macro expansion information.  */

  if (diagnostic.metadata)
    diag_obj->set ("metadata", json_from_metadata (diagnostic.metadata));

  const diagnostic_path *path = richloc->get_path ();
  if (path)
    diag_obj->set ("path", make_json_for_path (m_context, path));

  diag_obj->set_bool ("escape-source", richloc->escape_on_output_p ());
}

class json_stderr_output_format : public json_output_format
{
public:
  json_stderr_output_format (diagnostic_context &context,
			     bool formatted)
    : json_output_format (context, formatted)
  {
  }
  ~json_stderr_output_format ()
  {
    flush_to_file (stderr);
  }
  bool machine_readable_stderr_p () const final override
  {
    return true;
  }
};

class json_file_output_format : public json_output_format
{
public:
  json_file_output_format (diagnostic_context &context,
			   bool formatted,
			   const char *base_file_name)
  : json_output_format (context, formatted),
    m_base_file_name (xstrdup (base_file_name))
  {
  }

  ~json_file_output_format ()
  {
    char *filename = concat (m_base_file_name, ".gcc.json", nullptr);
    free (m_base_file_name);
    m_base_file_name = nullptr;
    FILE *outf = fopen (filename, "w");
    if (!outf)
      {
	const char *errstr = xstrerror (errno);
	fnotice (stderr, "error: unable to open '%s' for writing: %s\n",
		 filename, errstr);
	free (filename);
	return;
      }
    flush_to_file (outf);
    fclose (outf);
    free (filename);
  }
  bool machine_readable_stderr_p () const final override
  {
    return false;
  }

private:
  char *m_base_file_name;
};

/* Populate CONTEXT in preparation for JSON output (either to stderr, or
   to a file).  */

static void
diagnostic_output_format_init_json (diagnostic_context &context,
				    std::unique_ptr<json_output_format> fmt)
{
  /* Suppress normal textual path output.  */
  context.set_path_format (DPF_NONE);

  /* Don't colorize the text.  */
  pp_show_color (fmt->get_printer ()) = false;
  context.set_show_highlight_colors (false);

  context.set_output_format (fmt.release ());
}

/* Populate CONTEXT in preparation for JSON output to stderr.  */

void
diagnostic_output_format_init_json_stderr (diagnostic_context &context,
					   bool formatted)
{
  diagnostic_output_format_init_json
    (context,
     ::make_unique<json_stderr_output_format> (context,
					       formatted));
}

/* Populate CONTEXT in preparation for JSON output to a file named
   BASE_FILE_NAME.gcc.json.  */

void
diagnostic_output_format_init_json_file (diagnostic_context &context,
					 bool formatted,
					 const char *base_file_name)
{
  diagnostic_output_format_init_json
    (context,
     ::make_unique<json_file_output_format> (context,
					     formatted,
					     base_file_name));
}

#if CHECKING_P

namespace selftest {

/* We shouldn't call json_from_expanded_location on UNKNOWN_LOCATION,
   but verify that we handle this gracefully.  */

static void
test_unknown_location ()
{
  test_diagnostic_context dc;
  json_from_expanded_location (dc, UNKNOWN_LOCATION);
}

/* Verify that we gracefully handle attempts to serialize bad
   compound locations.  */

static void
test_bad_endpoints ()
{
  location_t bad_endpoints
    = make_location (BUILTINS_LOCATION,
		     UNKNOWN_LOCATION, UNKNOWN_LOCATION);

  location_range loc_range;
  loc_range.m_loc = bad_endpoints;
  loc_range.m_range_display_kind = SHOW_RANGE_WITH_CARET;
  loc_range.m_label = nullptr;

  test_diagnostic_context dc;
  std::unique_ptr<json::object> obj
    = json_from_location_range (dc, &loc_range, 0);
  /* We should have a "caret" value, but no "start" or "finish" values.  */
  ASSERT_TRUE (obj != nullptr);
  ASSERT_TRUE (obj->get ("caret") != nullptr);
  ASSERT_TRUE (obj->get ("start") == nullptr);
  ASSERT_TRUE (obj->get ("finish") == nullptr);
}

/* Run all of the selftests within this file.  */

void
diagnostic_format_json_cc_tests ()
{
  test_unknown_location ();
  test_bad_endpoints ();
}

} // namespace selftest

#endif /* #if CHECKING_P */