This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[committed] Introduce class edit_context (v3)
- From: David Malcolm <dmalcolm at redhat dot com>
- To: gcc-patches at gcc dot gnu dot org
- Cc: David Malcolm <dmalcolm at redhat dot com>
- Date: Fri, 2 Sep 2016 14:36:03 -0400
- Subject: [committed] Introduce class edit_context (v3)
- Authentication-results: sourceware.org; auth=none
Changes in v3:
- Updated doc/invoke.texi.
- Renamed line_state to edited_line
- I rewrote content-tracking in terms of edited lines, rather than
tracking the whole file. This avoids the need to load the whole file,
instead fetching it as needed from input.c's cache. This required a
little fiddly code to handle empty files, and whether or not a file
has a trailing newline.
- Added validation of columns, and rejection of rich_locations that have
rejected fix-it hints.
Successfully bootstrapped®rtested on x86_64-pc-linux-gnu.
Committed to trunk as r239963.
gcc/ChangeLog:
* Makefile.in (OBJS-libcommon): Add edit-context.o.
* diagnostic-color.c (color_dict): Add "diff-filename",
"diff-hunk", "diff-delete", and "diff-insert".
(parse_gcc_colors): Update default value of GCC_COLORS in comment
to reflect above changes.
* doc/invoke.texi (-fdiagnostics-color): Update description of
default GCC_COLORS, and of the supported capabilities.
* edit-context.c: New file.
* edit-context.h: New file.
* input.c (struct fcache): Add field "missing_trailing_newline".
(diagnostics_file_cache_forcibly_evict_file): Initialize it to
true.
(add_file_to_cache_tab): Likewise.
(fcache::fcache): Likewise.
(get_next_line): Update c->missing_trailing_newline.
(location_missing_trailing_newline): New function.
* input.h (location_missing_trailing_newline): New decl.
* selftest-run-tests.c (selftest::run_tests): Call
edit_context_c_tests.
* selftest.h (edit_context_c_tests): New decl.
libcpp/ChangeLog:
* include/line-map.h (rich_location::seen_impossible_fixit_p): New
accessor.
---
gcc/Makefile.in | 1 +
gcc/diagnostic-color.c | 7 +-
gcc/doc/invoke.texi | 20 +-
gcc/edit-context.c | 1511 +++++++++++++++++++++++++++++++++++++++++++++
gcc/edit-context.h | 68 ++
gcc/input.c | 47 +-
gcc/input.h | 1 +
gcc/selftest-run-tests.c | 1 +
gcc/selftest.h | 1 +
libcpp/include/line-map.h | 1 +
10 files changed, 1647 insertions(+), 11 deletions(-)
create mode 100644 gcc/edit-context.c
create mode 100644 gcc/edit-context.h
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index b38a0c1..7c18285 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -1561,6 +1561,7 @@ OBJS = \
# Objects in libcommon.a, potentially used by all host binaries and with
# no target dependencies.
OBJS-libcommon = diagnostic.o diagnostic-color.o diagnostic-show-locus.o \
+ edit-context.o \
pretty-print.o intl.o \
vec.o input.o version.o hash-table.o ggc-none.o memory-block.o \
selftest.o
diff --git a/gcc/diagnostic-color.c b/gcc/diagnostic-color.c
index 42aa1b6..0bd8170 100644
--- a/gcc/diagnostic-color.c
+++ b/gcc/diagnostic-color.c
@@ -170,6 +170,10 @@ static struct color_cap color_dict[] =
{ "quote", SGR_SEQ (COLOR_BOLD), 5, false },
{ "fixit-insert", SGR_SEQ (COLOR_FG_GREEN), 12, false },
{ "fixit-delete", SGR_SEQ (COLOR_FG_RED), 12, false },
+ { "diff-filename", SGR_SEQ (COLOR_BOLD), 13, false },
+ { "diff-hunk", SGR_SEQ (COLOR_FG_CYAN), 9, false },
+ { "diff-delete", SGR_SEQ (COLOR_FG_RED), 11, false },
+ { "diff-insert", SGR_SEQ (COLOR_FG_GREEN), 11, false },
{ NULL, NULL, 0, false }
};
@@ -200,7 +204,8 @@ colorize_stop (bool show_color)
/* Parse GCC_COLORS. The default would look like:
GCC_COLORS='error=01;31:warning=01;35:note=01;36:\
range1=32:range2=34:locus=01:quote=01:\
- fixit-insert=32:fixit-delete=31'
+ fixit-insert=32:fixit-delete=31'\
+ diff-filename=01:diff-hunk=32:diff-delete=31:diff-insert=32'
No character escaping is needed or supported. */
static bool
parse_gcc_colors (void)
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index 87da1f1..986ab43 100644
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -3343,7 +3343,9 @@ for 88-color and 256-color modes background colors.
The default @env{GCC_COLORS} is
@smallexample
-error=01;31:warning=01;35:note=01;36:range1=32:range2=34:locus=01:quote=01:fixit-insert=32:fixit-delete=31
+error=01;31:warning=01;35:note=01;36:range1=32:range2=34:locus=01:quote=01:\
+fixit-insert=32:fixit-delete=31:\
+diff-filename=01:diff-hunk=32:diff-delete=31:diff-insert=32
@end smallexample
@noindent
where @samp{01;31} is bold red, @samp{01;35} is bold magenta,
@@ -3391,6 +3393,22 @@ be inserted or replaced.
@vindex fixit-delete GCC_COLORS @r{capability}
SGR substring for fix-it hints suggesting text to
be deleted.
+
+@item diff-filename=
+@vindex diff-filename GCC_COLORS @r{capability}
+SGR substring for filename headers within generated patches.
+
+@item diff-hunk=
+@vindex diff-hunk GCC_COLORS @r{capability}
+SGR substring for the starts of hunks within generated patches.
+
+@item diff-delete=
+@vindex diff-delete GCC_COLORS @r{capability}
+SGR substring for deleted lines within generated patches.
+
+@item diff-insert=
+@vindex diff-insert GCC_COLORS @r{capability}
+SGR substring for inserted lines within generated patches.
@end table
@item -fno-diagnostics-show-option
diff --git a/gcc/edit-context.c b/gcc/edit-context.c
new file mode 100644
index 0000000..515833c
--- /dev/null
+++ b/gcc/edit-context.c
@@ -0,0 +1,1511 @@
+/* Determining the results of applying fix-it hints.
+ Copyright (C) 2016 Free Software Foundation, Inc.
+
+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"
+#include "system.h"
+#include "coretypes.h"
+#include "line-map.h"
+#include "edit-context.h"
+#include "pretty-print.h"
+#include "diagnostic-color.h"
+#include "selftest.h"
+
+/* This file implements a way to track the effect of fix-its,
+ via a class edit_context; the other classes are support classes for
+ edit_context.
+
+ A complication here is that fix-its are expressed relative to coordinates
+ in the file when it was parsed, before any changes have been made, and
+ so if there's more that one fix-it to be applied, we have to adjust
+ later fix-its to allow for the changes made by earlier ones. This
+ is done by the various "get_effective_column" methods.
+
+ The "filename" params are required to outlive the edit_context (no
+ copy of the underlying str is taken, just the ptr). */
+
+/* Forward decls. class edit_context is declared within edit-context.h.
+ The other types are declared here. */
+class edit_context;
+class edited_file;
+class edited_line;
+class line_event;
+ class insert_event;
+ class replace_event;
+
+/* A struct to hold the params of a print_diff call. */
+
+struct diff
+{
+ diff (pretty_printer *pp, bool show_filenames)
+ : m_pp (pp), m_show_filenames (show_filenames) {}
+
+ pretty_printer *m_pp;
+ bool m_show_filenames;
+};
+
+/* The state of one named file within an edit_context: the filename,
+ and the lines that have been edited so far. */
+
+class edited_file
+{
+ public:
+ edited_file (const char *filename);
+ static void delete_cb (edited_file *file);
+
+ const char *get_filename () const { return m_filename; }
+ char *get_content ();
+
+ bool apply_insert (int line, int column, const char *str, int len);
+ bool apply_replace (int line, int start_column,
+ int finish_column,
+ const char *replacement_str,
+ int replacement_len);
+ int get_effective_column (int line, int column);
+
+ static int call_print_diff (const char *, edited_file *file,
+ void *user_data)
+ {
+ diff *d = (diff *)user_data;
+ file->print_diff (d->m_pp, d->m_show_filenames);
+ return 0;
+ }
+
+ private:
+ bool print_content (pretty_printer *pp);
+ void print_diff (pretty_printer *pp, bool show_filenames);
+ edited_line *get_line (int line);
+ edited_line *get_or_insert_line (int line);
+ int get_num_lines (bool *missing_trailing_newline);
+
+ const char *m_filename;
+ typed_splay_tree<int, edited_line *> m_edited_lines;
+ int m_num_lines;
+};
+
+/* The state of one edited line within an edited_file.
+ As well as the current content of the line, it contains a record of
+ the changes, so that further changes can be applied in the correct
+ place. */
+
+class edited_line
+{
+ public:
+ edited_line (const char *filename, int line_num);
+ ~edited_line ();
+ static void delete_cb (edited_line *el);
+
+ int get_line_num () const { return m_line_num; }
+ const char *get_content () const { return m_content; }
+
+ int get_effective_column (int orig_column) const;
+ bool apply_insert (int column, const char *str, int len);
+ bool apply_replace (int start_column,
+ int finish_column,
+ const char *replacement_str,
+ int replacement_len);
+
+ private:
+ void ensure_capacity (int len);
+ void ensure_terminated ();
+ void print_content (pretty_printer *pp) const;
+
+ int m_line_num;
+ char *m_content;
+ int m_len;
+ int m_alloc_sz;
+ auto_vec <line_event *> m_line_events;
+};
+
+/* Abstract base class for representing events that have occurred
+ on one line of one file. */
+
+class line_event
+{
+ public:
+ virtual ~line_event () {}
+ virtual int get_effective_column (int orig_column) const = 0;
+};
+
+/* Concrete subclass of line_event: an insertion of some text
+ at some column on the line.
+
+ Subsequent events will need their columns adjusting if they're
+ are on this line and their column is >= the insertion point. */
+
+class insert_event : public line_event
+{
+ public:
+ insert_event (int column, int len) : m_column (column), m_len (len) {}
+ int get_effective_column (int orig_column) const FINAL OVERRIDE
+ {
+ if (orig_column >= m_column)
+ return orig_column + m_len;
+ else
+ return orig_column;
+ }
+
+ private:
+ int m_column;
+ int m_len;
+};
+
+/* Concrete subclass of line_event: the replacement of some text
+ betweeen some columns on the line.
+
+ Subsequent events will need their columns adjusting if they're
+ are on this line and their column is >= the finish point. */
+
+class replace_event : public line_event
+{
+ public:
+ replace_event (int start, int finish, int len) : m_start (start),
+ m_finish (finish), m_delta (len - (finish + 1 - start)) {}
+
+ int get_effective_column (int orig_column) const FINAL OVERRIDE
+ {
+ if (orig_column >= m_start)
+ return orig_column += m_delta;
+ else
+ return orig_column;
+ }
+
+ private:
+ int m_start;
+ int m_finish;
+ int m_delta;
+};
+
+/* Implementation of class edit_context. */
+
+/* edit_context's ctor. */
+
+edit_context::edit_context ()
+: m_valid (true),
+ m_files (strcmp, NULL, edited_file::delete_cb)
+{}
+
+/* Add any fixits within RICHLOC to this context, recording the
+ changes that they make. */
+
+void
+edit_context::add_fixits (rich_location *richloc)
+{
+ if (!m_valid)
+ return;
+ if (richloc->seen_impossible_fixit_p ())
+ {
+ m_valid = false;
+ return;
+ }
+ for (unsigned i = 0; i < richloc->get_num_fixit_hints (); i++)
+ {
+ const fixit_hint *hint = richloc->get_fixit_hint (i);
+ switch (hint->get_kind ())
+ {
+ case fixit_hint::INSERT:
+ if (!apply_insert ((const fixit_insert *)hint))
+ {
+ /* Failure. */
+ m_valid = false;
+ return;
+ }
+ break;
+ case fixit_hint::REPLACE:
+ if (!apply_replace ((const fixit_replace *)hint))
+ {
+ /* Failure. */
+ m_valid = false;
+ return;
+ }
+ break;
+ default:
+ gcc_unreachable ();
+ }
+ }
+}
+
+/* Get the content of the given file, with fix-its applied.
+ If any errors occurred in this edit_context, return NULL.
+ The ptr should be freed by the caller. */
+
+char *
+edit_context::get_content (const char *filename)
+{
+ if (!m_valid)
+ return NULL;
+ edited_file &file = get_or_insert_file (filename);
+ return file.get_content ();
+}
+
+/* Map a location before the edits to a column number after the edits.
+ This method is for the selftests. */
+
+int
+edit_context::get_effective_column (const char *filename, int line,
+ int column)
+{
+ edited_file *file = get_file (filename);
+ if (!file)
+ return column;
+ return file->get_effective_column (line, column);
+}
+
+/* Generate a unified diff. The resulting string should be freed by the
+ caller. Primarily for selftests.
+ If any errors occurred in this edit_context, return NULL. */
+
+char *
+edit_context::generate_diff (bool show_filenames)
+{
+ if (!m_valid)
+ return NULL;
+
+ pretty_printer pp;
+ print_diff (&pp, show_filenames);
+ return xstrdup (pp_formatted_text (&pp));
+}
+
+/* Print a unified diff to PP, showing the changes made within the
+ context. */
+
+void
+edit_context::print_diff (pretty_printer *pp, bool show_filenames)
+{
+ if (!m_valid)
+ return;
+ diff d (pp, show_filenames);
+ m_files.foreach (edited_file::call_print_diff, &d);
+}
+
+/* Attempt to apply the given fixit. Return true if it can be
+ applied, or false otherwise. */
+
+bool
+edit_context::apply_insert (const fixit_insert *insert)
+{
+ expanded_location exploc = expand_location (insert->get_location ());
+
+ if (exploc.column == 0)
+ return false;
+
+ edited_file &file = get_or_insert_file (exploc.file);
+ if (!m_valid)
+ return false;
+ return file.apply_insert (exploc.line, exploc.column, insert->get_string (),
+ insert->get_length ());
+}
+
+/* Attempt to apply the given fixit. Return true if it can be
+ applied, or false otherwise. */
+
+bool
+edit_context::apply_replace (const fixit_replace *replace)
+{
+ source_range range = replace->get_range ();
+
+ expanded_location start = expand_location (range.m_start);
+ expanded_location finish = expand_location (range.m_finish);
+ if (start.file != finish.file)
+ return false;
+ if (start.line != finish.line)
+ return false;
+ if (start.column == 0)
+ return false;
+ if (finish.column == 0)
+ return false;
+
+ edited_file &file = get_or_insert_file (start.file);
+ if (!m_valid)
+ return false;
+ return file.apply_replace (start.line, start.column, finish.column,
+ replace->get_string (),
+ replace->get_length ());
+}
+
+/* Locate the edited_file * for FILENAME, if any
+ Return NULL if there isn't one. */
+
+edited_file *
+edit_context::get_file (const char *filename)
+{
+ gcc_assert (filename);
+ return m_files.lookup (filename);
+}
+
+/* Locate the edited_file for FILENAME, adding one if there isn't one. */
+
+edited_file &
+edit_context::get_or_insert_file (const char *filename)
+{
+ gcc_assert (filename);
+
+ edited_file *file = get_file (filename);
+ if (file)
+ return *file;
+
+ /* Not found. */
+ file = new edited_file (filename);
+ m_files.insert (filename, file);
+ return *file;
+}
+
+/* Implementation of class edited_file. */
+
+/* Callback for m_edited_lines, for comparing line numbers. */
+
+static int line_comparator (int a, int b)
+{
+ return a - b;
+}
+
+/* edited_file's constructor. */
+
+edited_file::edited_file (const char *filename)
+: m_filename (filename),
+ m_edited_lines (line_comparator, NULL, edited_line::delete_cb),
+ m_num_lines (-1)
+{
+}
+
+/* A callback for deleting edited_file *, for use as a
+ delete_value_fn for edit_context::m_files. */
+
+void
+edited_file::delete_cb (edited_file *file)
+{
+ delete file;
+}
+
+/* Get the content of the file, with fix-its applied.
+ The ptr should be freed by the caller. */
+
+char *
+edited_file::get_content ()
+{
+ pretty_printer pp;
+ if (!print_content (&pp))
+ return NULL;
+ return xstrdup (pp_formatted_text (&pp));
+}
+
+/* Attempt to insert the string INSERT_STR with length INSERT_LEN
+ at LINE and COLUMN, updating the in-memory copy of the line, and
+ the record of edits to the line. */
+
+bool
+edited_file::apply_insert (int line, int column,
+ const char *insert_str,
+ int insert_len)
+{
+ edited_line *el = get_or_insert_line (line);
+ if (!el)
+ return false;
+ return el->apply_insert (column, insert_str, insert_len);
+}
+
+/* Attempt to replace columns START_COLUMN through FINISH_COLUMN of LINE
+ with the string REPLACEMENT_STR of length REPLACEMENT_LEN,
+ updating the in-memory copy of the line, and the record of edits to
+ the line. */
+
+bool
+edited_file::apply_replace (int line, int start_column,
+ int finish_column,
+ const char *replacement_str,
+ int replacement_len)
+{
+ edited_line *el = get_or_insert_line (line);
+ if (!el)
+ return false;
+ return el->apply_replace (start_column, finish_column, replacement_str,
+ replacement_len);
+}
+
+/* Given line LINE, map from COLUMN in the input file to its current
+ column after edits have been applied. */
+
+int
+edited_file::get_effective_column (int line, int column)
+{
+ const edited_line *el = get_line (line);
+ if (!el)
+ return column;
+ return el->get_effective_column (column);
+}
+
+/* Attempt to print the content of the file to PP, with edits applied.
+ Return true if successful, false otherwise. */
+
+bool
+edited_file::print_content (pretty_printer *pp)
+{
+ bool missing_trailing_newline;
+ int line_count = get_num_lines (&missing_trailing_newline);
+ for (int line_num = 1; line_num <= line_count; line_num++)
+ {
+ edited_line *el = get_line (line_num);
+ if (el)
+ pp_string (pp, el->get_content ());
+ else
+ {
+ int len;
+ const char *line
+ = location_get_source_line (m_filename, line_num, &len);
+ if (!line)
+ return false;
+ for (int i = 0; i < len; i++)
+ pp_character (pp, line[i]);
+ }
+ if (line_num < line_count)
+ pp_character (pp, '\n');
+ }
+
+ if (!missing_trailing_newline)
+ pp_character (pp, '\n');
+
+ return true;
+}
+
+/* Print a unified diff to PP, showing any changes that have occurred
+ to this file. */
+
+void
+edited_file::print_diff (pretty_printer *pp, bool show_filenames)
+{
+ if (show_filenames)
+ {
+ pp_string (pp, colorize_start (pp_show_color (pp), "diff-filename"));
+ pp_printf (pp, "--- %s\n", m_filename);
+ pp_printf (pp, "+++ %s\n", m_filename);
+ pp_string (pp, colorize_stop (pp_show_color (pp)));
+ }
+
+ edited_line *el = m_edited_lines.min ();
+
+ bool missing_trailing_newline;
+ int line_count = get_num_lines (&missing_trailing_newline);
+
+ const int context_lines = 3;
+
+ while (el)
+ {
+ int start_of_hunk = el->get_line_num ();
+ start_of_hunk -= context_lines;
+ if (start_of_hunk < 1)
+ start_of_hunk = 1;
+
+ /* Locate end of hunk, merging in changed lines
+ that are sufficiently close. */
+ while (true)
+ {
+ edited_line *next_el
+ = m_edited_lines.successor (el->get_line_num ());
+ if (!next_el)
+ break;
+ if (el->get_line_num () + context_lines
+ >= next_el->get_line_num () - context_lines)
+ el = next_el;
+ else
+ break;
+ }
+ int end_of_hunk = el->get_line_num ();
+ end_of_hunk += context_lines;
+ if (end_of_hunk > line_count)
+ end_of_hunk = line_count;
+
+ int num_lines = end_of_hunk - start_of_hunk + 1;
+
+ pp_string (pp, colorize_start (pp_show_color (pp), "diff-hunk"));
+ pp_printf (pp, "@@ -%i,%i +%i,%i @@\n", start_of_hunk, num_lines,
+ start_of_hunk, num_lines);
+ pp_string (pp, colorize_stop (pp_show_color (pp)));
+
+ int line_num = start_of_hunk;
+ while (line_num <= end_of_hunk)
+ {
+ edited_line *el = get_line (line_num);
+ if (el)
+ {
+ /* We have an edited line.
+ Consolidate into runs of changed lines. */
+ const int first_changed_line_in_run = line_num;
+ while (get_line (line_num))
+ line_num++;
+ const int last_changed_line_in_run = line_num - 1;
+
+ pp_string (pp, colorize_start (pp_show_color (pp),
+ "diff-delete"));
+
+ /* Show old version of lines. */
+ for (line_num = first_changed_line_in_run;
+ line_num <= last_changed_line_in_run;
+ line_num++)
+ {
+ int line_size;
+ const char *old_line
+ = location_get_source_line (m_filename, line_num,
+ &line_size);
+ pp_character (pp, '-');
+ for (int i = 0; i < line_size; i++)
+ pp_character (pp, old_line[i]);
+ pp_character (pp, '\n');
+ }
+
+ pp_string (pp, colorize_stop (pp_show_color (pp)));
+
+ pp_string (pp, colorize_start (pp_show_color (pp),
+ "diff-insert"));
+
+ /* Show new version of lines. */
+ for (line_num = first_changed_line_in_run;
+ line_num <= last_changed_line_in_run;
+ line_num++)
+ {
+ edited_line *el_in_run = get_line (line_num);
+ gcc_assert (el_in_run);
+ pp_character (pp, '+');
+ pp_string (pp, el_in_run->get_content ());
+ pp_character (pp, '\n');
+ }
+
+ pp_string (pp, colorize_stop (pp_show_color (pp)));
+ }
+ else
+ {
+ /* Unchanged line. */
+ int line_size;
+ const char *old_line
+ = location_get_source_line (m_filename, line_num,
+ &line_size);
+ pp_character (pp, ' ');
+ for (int i = 0; i < line_size; i++)
+ pp_character (pp, old_line[i]);
+ pp_character (pp, '\n');
+ line_num++;
+ }
+ }
+
+ el = m_edited_lines.successor (el->get_line_num ());
+ }
+}
+
+/* Get the state of LINE within the file, or NULL if it is untouched. */
+
+edited_line *
+edited_file::get_line (int line)
+{
+ return m_edited_lines.lookup (line);
+}
+
+/* Get the state of LINE within the file, creating a state for it
+ if necessary. Return NULL if an error occurs. */
+
+edited_line *
+edited_file::get_or_insert_line (int line)
+{
+ edited_line *el = get_line (line);
+ if (el)
+ return el;
+ el = new edited_line (m_filename, line);
+ if (el->get_content () == NULL)
+ {
+ delete el;
+ return NULL;
+ }
+ m_edited_lines.insert (line, el);
+ return el;
+}
+
+/* Get the total number of lines in m_content, writing
+ true to *MISSING_TRAILING_NEWLINE if the final line
+ if missing a newline, false otherwise. */
+
+int
+edited_file::get_num_lines (bool *missing_trailing_newline)
+{
+ gcc_assert (missing_trailing_newline);
+ if (m_num_lines == -1)
+ {
+ m_num_lines = 0;
+ while (true)
+ {
+ int line_size;
+ const char *line
+ = location_get_source_line (m_filename, m_num_lines + 1,
+ &line_size);
+ if (line)
+ m_num_lines++;
+ else
+ break;
+ }
+ }
+ *missing_trailing_newline = location_missing_trailing_newline (m_filename);
+ return m_num_lines;
+}
+
+/* Implementation of class edited_line. */
+
+/* edited_line's ctor. */
+
+edited_line::edited_line (const char *filename, int line_num)
+: m_line_num (line_num),
+ m_content (NULL), m_len (0), m_alloc_sz (0),
+ m_line_events ()
+{
+ const char *line = location_get_source_line (filename, line_num,
+ &m_len);
+ if (!line)
+ return;
+ ensure_capacity (m_len);
+ memcpy (m_content, line, m_len);
+ ensure_terminated ();
+}
+
+/* edited_line's dtor. */
+
+edited_line::~edited_line ()
+{
+ free (m_content);
+
+ int i;
+ line_event *event;
+ FOR_EACH_VEC_ELT (m_line_events, i, event)
+ delete event;
+}
+
+/* A callback for deleting edited_line *, for use as a
+ delete_value_fn for edited_file::m_edited_lines. */
+
+void
+edited_line::delete_cb (edited_line *el)
+{
+ delete el;
+}
+
+/* Map a location before the edits to a column number after the edits,
+ within a specific line. */
+
+int
+edited_line::get_effective_column (int orig_column) const
+{
+ int i;
+ line_event *event;
+ FOR_EACH_VEC_ELT (m_line_events, i, event)
+ orig_column = event->get_effective_column (orig_column);
+ return orig_column;
+}
+
+/* Attempt to insert the string INSERT_STR with length INSERT_LEN at COLUMN
+ of this line, updating the in-memory copy of the line, and the record
+ of edits to it.
+ Return true if successful; false if an error occurred. */
+
+bool
+edited_line::apply_insert (int column, const char *insert_str,
+ int insert_len)
+{
+ column = get_effective_column (column);
+
+ int start_offset = column - 1;
+ gcc_assert (start_offset >= 0);
+ if (start_offset > m_len)
+ return false;
+
+ /* Ensure buffer is big enough. */
+ size_t new_len = m_len + insert_len;
+ ensure_capacity (new_len);
+
+ char *suffix = m_content + start_offset;
+ gcc_assert (suffix <= m_content + m_len);
+ size_t len_suffix = (m_content + m_len) - suffix;
+
+ /* Move successor content into position. They overlap, so use memmove. */
+ memmove (m_content + start_offset + insert_len,
+ suffix, len_suffix);
+
+ /* Replace target content. They don't overlap, so use memcpy. */
+ memcpy (m_content + start_offset,
+ insert_str,
+ insert_len);
+
+ m_len = new_len;
+
+ ensure_terminated ();
+
+ /* Record the insertion, so that future changes to the line can have
+ their column information adjusted accordingly. */
+ m_line_events.safe_push (new insert_event (column, insert_len));
+
+ return true;
+}
+
+/* Attempt to replace columns START_COLUMN through FINISH_COLUMN of the line
+ with the string REPLACEMENT_STR of length REPLACEMENT_LEN,
+ updating the in-memory copy of the line, and the record of edits to
+ the line.
+ Return true if successful; false if an error occurred. */
+
+bool
+edited_line::apply_replace (int start_column,
+ int finish_column,
+ const char *replacement_str,
+ int replacement_len)
+{
+ start_column = get_effective_column (start_column);
+ finish_column = get_effective_column (finish_column);
+
+ int start_offset = start_column - 1;
+ int end_offset = finish_column - 1;
+
+ gcc_assert (start_offset >= 0);
+ gcc_assert (end_offset >= 0);
+
+ if (start_column > finish_column)
+ return false;
+ if (start_offset >= m_len)
+ return false;
+ if (end_offset >= m_len)
+ return false;
+
+ size_t victim_len = end_offset - start_offset + 1;
+
+ /* Ensure buffer is big enough. */
+ size_t new_len = m_len + replacement_len - victim_len;
+ ensure_capacity (new_len);
+
+ char *suffix = m_content + end_offset + 1;
+ gcc_assert (suffix <= m_content + m_len);
+ size_t len_suffix = (m_content + m_len) - suffix;
+
+ /* Move successor content into position. They overlap, so use memmove. */
+ memmove (m_content + start_offset + replacement_len,
+ suffix, len_suffix);
+
+ /* Replace target content. They don't overlap, so use memcpy. */
+ memcpy (m_content + start_offset,
+ replacement_str,
+ replacement_len);
+
+ m_len = new_len;
+
+ ensure_terminated ();
+
+ /* Record the replacement, so that future changes to the line can have
+ their column information adjusted accordingly. */
+ m_line_events.safe_push (new replace_event (start_column, finish_column,
+ replacement_len));
+ return true;
+}
+
+/* Ensure that the buffer for m_content is at least large enough to hold
+ a string of length LEN and its 0-terminator, doubling on repeated
+ allocations. */
+
+void
+edited_line::ensure_capacity (int len)
+{
+ /* Allow 1 extra byte for 0-termination. */
+ if (m_alloc_sz < (len + 1))
+ {
+ size_t new_alloc_sz = (len + 1) * 2;
+ m_content = (char *)xrealloc (m_content, new_alloc_sz);
+ m_alloc_sz = new_alloc_sz;
+ }
+}
+
+/* Ensure that m_content is 0-terminated. */
+
+void
+edited_line::ensure_terminated ()
+{
+ /* 0-terminate the buffer. */
+ gcc_assert (m_len < m_alloc_sz);
+ m_content[m_len] = '\0';
+}
+
+#if CHECKING_P
+
+/* Selftests of code-editing. */
+
+namespace selftest {
+
+/* A wrapper class for ensuring that the underlying pointer is freed. */
+
+template <typename POINTER_T>
+class auto_free
+{
+ public:
+ auto_free (POINTER_T p) : m_ptr (p) {}
+ ~auto_free () { free (m_ptr); }
+
+ operator POINTER_T () { return m_ptr; }
+
+ private:
+ POINTER_T m_ptr;
+};
+
+/* Verify that edit_context::get_content works for unedited files. */
+
+static void
+test_get_content ()
+{
+ /* Test of empty file. */
+ {
+ const char *content = ("");
+ temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
+ edit_context edit;
+ auto_free <char *> result = edit.get_content (tmp.get_filename ());
+ ASSERT_STREQ ("", result);
+ }
+
+ /* Test of simple content. */
+ {
+ const char *content = ("/* before */\n"
+ "foo = bar.field;\n"
+ "/* after */\n");
+ temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
+ edit_context edit;
+ auto_free <char *> result = edit.get_content (tmp.get_filename ());
+ ASSERT_STREQ ("/* before */\n"
+ "foo = bar.field;\n"
+ "/* after */\n", result);
+ }
+
+ /* Test of omitting the trailing newline on the final line. */
+ {
+ const char *content = ("/* before */\n"
+ "foo = bar.field;\n"
+ "/* after */");
+ temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
+ edit_context edit;
+ auto_free <char *> result = edit.get_content (tmp.get_filename ());
+ /* We should respect the omitted trailing newline. */
+ ASSERT_STREQ ("/* before */\n"
+ "foo = bar.field;\n"
+ "/* after */", result);
+ }
+}
+
+/* Test applying an "insert" fixit. */
+
+static void
+test_applying_fixits_insert (const line_table_case &case_)
+{
+ /* Create a tempfile and write some text to it.
+ .........................0000000001111111.
+ .........................1234567890123456. */
+ const char *old_content = ("/* before */\n"
+ "foo = bar.field;\n"
+ "/* after */\n");
+ temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
+ const char *filename = tmp.get_filename ();
+ line_table_test ltt (case_);
+ linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 2);
+
+ /* Add a comment in front of "bar.field". */
+ location_t start = linemap_position_for_column (line_table, 7);
+ rich_location richloc (line_table, start);
+ richloc.add_fixit_insert ("/* inserted */");
+
+ if (start > LINE_MAP_MAX_LOCATION_WITH_COLS)
+ return;
+
+ edit_context edit;
+ edit.add_fixits (&richloc);
+ auto_free <char *> new_content = edit.get_content (filename);
+ if (start <= LINE_MAP_MAX_LOCATION_WITH_COLS)
+ ASSERT_STREQ ("/* before */\n"
+ "foo = /* inserted */bar.field;\n"
+ "/* after */\n", new_content);
+
+ /* Verify that locations on other lines aren't affected by the change. */
+ ASSERT_EQ (100, edit.get_effective_column (filename, 1, 100));
+ ASSERT_EQ (100, edit.get_effective_column (filename, 3, 100));
+
+ /* Verify locations on the line before the change. */
+ ASSERT_EQ (1, edit.get_effective_column (filename, 2, 1));
+ ASSERT_EQ (6, edit.get_effective_column (filename, 2, 6));
+
+ /* Verify locations on the line at and after the change. */
+ ASSERT_EQ (21, edit.get_effective_column (filename, 2, 7));
+ ASSERT_EQ (22, edit.get_effective_column (filename, 2, 8));
+
+ /* Verify diff. */
+ auto_free <char *> diff = edit.generate_diff (false);
+ ASSERT_STREQ ("@@ -1,3 +1,3 @@\n"
+ " /* before */\n"
+ "-foo = bar.field;\n"
+ "+foo = /* inserted */bar.field;\n"
+ " /* after */\n", diff);
+}
+
+/* Test applying a "replace" fixit that grows the affected line. */
+
+static void
+test_applying_fixits_growing_replace (const line_table_case &case_)
+{
+ /* Create a tempfile and write some text to it.
+ .........................0000000001111111.
+ .........................1234567890123456. */
+ const char *old_content = ("/* before */\n"
+ "foo = bar.field;\n"
+ "/* after */\n");
+ temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
+ const char *filename = tmp.get_filename ();
+ line_table_test ltt (case_);
+ linemap_add (line_table, LC_ENTER, false, filename, 2);
+
+ /* Replace "field" with "m_field". */
+ location_t start = linemap_position_for_column (line_table, 11);
+ location_t finish = linemap_position_for_column (line_table, 15);
+ location_t field = make_location (start, start, finish);
+ rich_location richloc (line_table, field);
+ richloc.add_fixit_replace ("m_field");
+
+ edit_context edit;
+ edit.add_fixits (&richloc);
+ auto_free <char *> new_content = edit.get_content (filename);
+ if (finish <= LINE_MAP_MAX_LOCATION_WITH_COLS)
+ {
+ ASSERT_STREQ ("/* before */\n"
+ "foo = bar.m_field;\n"
+ "/* after */\n", new_content);
+
+ /* Verify location of ";" after the change. */
+ ASSERT_EQ (18, edit.get_effective_column (filename, 2, 16));
+
+ /* Verify diff. */
+ auto_free <char *> diff = edit.generate_diff (false);
+ ASSERT_STREQ ("@@ -1,3 +1,3 @@\n"
+ " /* before */\n"
+ "-foo = bar.field;\n"
+ "+foo = bar.m_field;\n"
+ " /* after */\n", diff);
+ }
+}
+
+/* Test applying a "replace" fixit that shrinks the affected line. */
+
+static void
+test_applying_fixits_shrinking_replace (const line_table_case &case_)
+{
+ /* Create a tempfile and write some text to it.
+ .........................000000000111111111.
+ .........................123456789012345678. */
+ const char *old_content = ("/* before */\n"
+ "foo = bar.m_field;\n"
+ "/* after */\n");
+ temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
+ const char *filename = tmp.get_filename ();
+ line_table_test ltt (case_);
+ linemap_add (line_table, LC_ENTER, false, filename, 2);
+
+ /* Replace "field" with "m_field". */
+ location_t start = linemap_position_for_column (line_table, 11);
+ location_t finish = linemap_position_for_column (line_table, 17);
+ location_t m_field = make_location (start, start, finish);
+ rich_location richloc (line_table, m_field);
+ richloc.add_fixit_replace ("field");
+
+ edit_context edit;
+ edit.add_fixits (&richloc);
+ auto_free <char *> new_content = edit.get_content (filename);
+ if (finish <= LINE_MAP_MAX_LOCATION_WITH_COLS)
+ {
+ ASSERT_STREQ ("/* before */\n"
+ "foo = bar.field;\n"
+ "/* after */\n", new_content);
+
+ /* Verify location of ";" after the change. */
+ ASSERT_EQ (16, edit.get_effective_column (filename, 2, 18));
+
+ /* Verify diff. */
+ auto_free <char *> diff = edit.generate_diff (false);
+ ASSERT_STREQ ("@@ -1,3 +1,3 @@\n"
+ " /* before */\n"
+ "-foo = bar.m_field;\n"
+ "+foo = bar.field;\n"
+ " /* after */\n", diff);
+ }
+}
+
+/* Test applying a "remove" fixit. */
+
+static void
+test_applying_fixits_remove (const line_table_case &case_)
+{
+ /* Create a tempfile and write some text to it.
+ .........................000000000111111111.
+ .........................123456789012345678. */
+ const char *old_content = ("/* before */\n"
+ "foo = bar.m_field;\n"
+ "/* after */\n");
+ temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
+ const char *filename = tmp.get_filename ();
+ line_table_test ltt (case_);
+ linemap_add (line_table, LC_ENTER, false, filename, 2);
+
+ /* Remove ".m_field". */
+ location_t start = linemap_position_for_column (line_table, 10);
+ location_t finish = linemap_position_for_column (line_table, 17);
+ rich_location richloc (line_table, start);
+ source_range range;
+ range.m_start = start;
+ range.m_finish = finish;
+ richloc.add_fixit_remove (range);
+
+ edit_context edit;
+ edit.add_fixits (&richloc);
+ auto_free <char *> new_content = edit.get_content (filename);
+ if (finish <= LINE_MAP_MAX_LOCATION_WITH_COLS)
+ {
+ ASSERT_STREQ ("/* before */\n"
+ "foo = bar;\n"
+ "/* after */\n", new_content);
+
+ /* Verify location of ";" after the change. */
+ ASSERT_EQ (10, edit.get_effective_column (filename, 2, 18));
+
+ /* Verify diff. */
+ auto_free <char *> diff = edit.generate_diff (false);
+ ASSERT_STREQ ("@@ -1,3 +1,3 @@\n"
+ " /* before */\n"
+ "-foo = bar.m_field;\n"
+ "+foo = bar;\n"
+ " /* after */\n", diff);
+ }
+}
+
+/* Test applying multiple fixits to one line. */
+
+static void
+test_applying_fixits_multiple (const line_table_case &case_)
+{
+ /* Create a tempfile and write some text to it.
+ .........................00000000011111111.
+ .........................12345678901234567. */
+ const char *old_content = ("/* before */\n"
+ "foo = bar.field;\n"
+ "/* after */\n");
+ temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
+ const char *filename = tmp.get_filename ();
+ line_table_test ltt (case_);
+ linemap_add (line_table, LC_ENTER, false, filename, 2);
+
+ location_t c7 = linemap_position_for_column (line_table, 7);
+ location_t c9 = linemap_position_for_column (line_table, 9);
+ location_t c11 = linemap_position_for_column (line_table, 11);
+ location_t c15 = linemap_position_for_column (line_table, 15);
+ location_t c17 = linemap_position_for_column (line_table, 17);
+
+ if (c17 > LINE_MAP_MAX_LOCATION_WITH_COLS)
+ return;
+
+ /* Add a comment in front of "bar.field". */
+ rich_location insert_a (line_table, c7);
+ insert_a.add_fixit_insert (c7, "/* alpha */");
+
+ /* Add a comment after "bar.field;". */
+ rich_location insert_b (line_table, c17);
+ insert_b.add_fixit_insert (c17, "/* beta */");
+
+ /* Replace "bar" with "pub". */
+ rich_location replace_a (line_table, c7);
+ replace_a.add_fixit_replace (source_range::from_locations (c7, c9),
+ "pub");
+
+ /* Replace "field" with "meadow". */
+ rich_location replace_b (line_table, c7);
+ replace_b.add_fixit_replace (source_range::from_locations (c11, c15),
+ "meadow");
+
+ edit_context edit;
+ edit.add_fixits (&insert_a);
+ ASSERT_EQ (100, edit.get_effective_column (filename, 1, 100));
+ ASSERT_EQ (1, edit.get_effective_column (filename, 2, 1));
+ ASSERT_EQ (6, edit.get_effective_column (filename, 2, 6));
+ ASSERT_EQ (18, edit.get_effective_column (filename, 2, 7));
+ ASSERT_EQ (27, edit.get_effective_column (filename, 2, 16));
+ ASSERT_EQ (100, edit.get_effective_column (filename, 3, 100));
+
+ edit.add_fixits (&insert_b);
+ edit.add_fixits (&replace_a);
+ edit.add_fixits (&replace_b);
+
+ if (c17 <= LINE_MAP_MAX_LOCATION_WITH_COLS)
+ {
+ auto_free <char *> new_content = edit.get_content (tmp.get_filename ());
+ ASSERT_STREQ ("/* before */\n"
+ "foo = /* alpha */pub.meadow;/* beta */\n"
+ "/* after */\n",
+ new_content);
+
+ /* Verify diff. */
+ auto_free <char *> diff = edit.generate_diff (false);
+ ASSERT_STREQ ("@@ -1,3 +1,3 @@\n"
+ " /* before */\n"
+ "-foo = bar.field;\n"
+ "+foo = /* alpha */pub.meadow;/* beta */\n"
+ " /* after */\n", diff);
+ }
+}
+
+/* Subroutine of test_applying_fixits_multiple_lines.
+ Add the text "CHANGED: " to the front of the given line. */
+
+static location_t
+change_line (edit_context &edit, int line_num)
+{
+ const line_map_ordinary *ord_map
+ = LINEMAPS_LAST_ORDINARY_MAP (line_table);
+ const int column = 1;
+ location_t loc =
+ linemap_position_for_line_and_column (line_table, ord_map,
+ line_num, column);
+
+ expanded_location exploc = expand_location (loc);
+ if (loc <= LINE_MAP_MAX_LOCATION_WITH_COLS)
+ {
+ ASSERT_EQ (line_num, exploc.line);
+ ASSERT_EQ (column, exploc.column);
+ }
+
+ rich_location insert (line_table, loc);
+ insert.add_fixit_insert ("CHANGED: ");
+ edit.add_fixits (&insert);
+ return loc;
+}
+
+/* Test of editing multiple lines within a long file,
+ to ensure that diffs are generated as expected. */
+
+static void
+test_applying_fixits_multiple_lines (const line_table_case &case_)
+{
+ /* Create a tempfile and write many lines of text to it. */
+ named_temp_file tmp (".txt");
+ const char *filename = tmp.get_filename ();
+ FILE *f = fopen (filename, "w");
+ ASSERT_NE (f, NULL);
+ for (int i = 1; i <= 1000; i++)
+ fprintf (f, "line %i\n", i);
+ fclose (f);
+
+ line_table_test ltt (case_);
+ linemap_add (line_table, LC_ENTER, false, filename, 1);
+ linemap_position_for_column (line_table, 127);
+
+ edit_context edit;
+
+ /* A run of consecutive lines. */
+ change_line (edit, 2);
+ change_line (edit, 3);
+ change_line (edit, 4);
+
+ /* A run of nearby lines, within the contextual limit. */
+ change_line (edit, 150);
+ change_line (edit, 151);
+ location_t last_loc = change_line (edit, 153);
+
+ if (last_loc > LINE_MAP_MAX_LOCATION_WITH_COLS)
+ return;
+
+ /* Verify diff. */
+ auto_free <char *> diff = edit.generate_diff (false);
+ ASSERT_STREQ ("@@ -1,7 +1,7 @@\n"
+ " line 1\n"
+ "-line 2\n"
+ "-line 3\n"
+ "-line 4\n"
+ "+CHANGED: line 2\n"
+ "+CHANGED: line 3\n"
+ "+CHANGED: line 4\n"
+ " line 5\n"
+ " line 6\n"
+ " line 7\n"
+ "@@ -147,10 +147,10 @@\n"
+ " line 147\n"
+ " line 148\n"
+ " line 149\n"
+ "-line 150\n"
+ "-line 151\n"
+ "+CHANGED: line 150\n"
+ "+CHANGED: line 151\n"
+ " line 152\n"
+ "-line 153\n"
+ "+CHANGED: line 153\n"
+ " line 154\n"
+ " line 155\n"
+ " line 156\n", diff);
+
+ /* Ensure tmp stays alive until this point, so that the tempfile
+ persists until after the generate_diff call. */
+ tmp.get_filename ();
+}
+
+/* Test of converting an initializer for a named field from
+ the old GCC extension to C99 syntax.
+ Exercises a shrinking replacement followed by a growing
+ replacement on the same line. */
+
+static void
+test_applying_fixits_modernize_named_init (const line_table_case &case_)
+{
+ /* Create a tempfile and write some text to it.
+ .........................00000000011111111.
+ .........................12345678901234567. */
+ const char *old_content = ("/* before */\n"
+ "bar : 1,\n"
+ "/* after */\n");
+ temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
+ const char *filename = tmp.get_filename ();
+ line_table_test ltt (case_);
+ linemap_add (line_table, LC_ENTER, false, filename, 2);
+
+ location_t c1 = linemap_position_for_column (line_table, 1);
+ location_t c3 = linemap_position_for_column (line_table, 3);
+ location_t c8 = linemap_position_for_column (line_table, 8);
+
+ if (c8 > LINE_MAP_MAX_LOCATION_WITH_COLS)
+ return;
+
+ /* Replace "bar" with ".". */
+ rich_location r1 (line_table, c8);
+ r1.add_fixit_replace (source_range::from_locations (c1, c3),
+ ".");
+
+ /* Replace ":" with "bar =". */
+ rich_location r2 (line_table, c8);
+ r2.add_fixit_replace (source_range::from_locations (c8, c8),
+ "bar =");
+
+ /* The order should not matter. Do r1 then r2. */
+ {
+ edit_context edit;
+ edit.add_fixits (&r1);
+
+ /* Verify state after first replacement. */
+ {
+ auto_free <char *> new_content = edit.get_content (tmp.get_filename ());
+ /* We should now have:
+ ............00000000011.
+ ............12345678901. */
+ ASSERT_STREQ ("/* before */\n"
+ ". : 1,\n"
+ "/* after */\n",
+ new_content);
+ /* Location of the "1". */
+ ASSERT_EQ (6, edit.get_effective_column (filename, 2, 8));
+ /* Location of the ",". */
+ ASSERT_EQ (9, edit.get_effective_column (filename, 2, 11));
+ }
+
+ edit.add_fixits (&r2);
+
+ auto_free <char *> new_content = edit.get_content (tmp.get_filename ());
+ /* Verify state after second replacement.
+ ............00000000011111111.
+ ............12345678901234567. */
+ ASSERT_STREQ ("/* before */\n"
+ ". bar = 1,\n"
+ "/* after */\n",
+ new_content);
+ }
+
+ /* Try again, doing r2 then r1; the new_content should be the same. */
+ {
+ edit_context edit;
+ edit.add_fixits (&r2);
+ edit.add_fixits (&r1);
+ auto_free <char *> new_content = edit.get_content (tmp.get_filename ());
+ /*.............00000000011111111.
+ .............12345678901234567. */
+ ASSERT_STREQ ("/* before */\n"
+ ". bar = 1,\n"
+ "/* after */\n",
+ new_content);
+ }
+}
+
+/* Test of a fixit affecting a file that can't be read. */
+
+static void
+test_applying_fixits_unreadable_file ()
+{
+ const char *filename = "this-does-not-exist.txt";
+ line_table_test ltt ();
+ linemap_add (line_table, LC_ENTER, false, filename, 1);
+
+ location_t loc = linemap_position_for_column (line_table, 1);
+
+ rich_location insert (line_table, loc);
+ insert.add_fixit_insert ("change 1");
+ insert.add_fixit_insert ("change 2");
+
+ edit_context edit;
+ /* Attempting to add the fixits affecting the unreadable file
+ should transition the edit from valid to invalid. */
+ ASSERT_TRUE (edit.valid_p ());
+ edit.add_fixits (&insert);
+ ASSERT_FALSE (edit.valid_p ());
+ ASSERT_EQ (NULL, edit.get_content (filename));
+ ASSERT_EQ (NULL, edit.generate_diff (false));
+}
+
+/* Verify that we gracefully handle an attempt to edit a line
+ that's beyond the end of the file. */
+
+static void
+test_applying_fixits_line_out_of_range ()
+{
+ /* Create a tempfile and write some text to it.
+ ........................00000000011111111.
+ ........................12345678901234567. */
+ const char *old_content = "One-liner file\n";
+ temp_source_file tmp (SELFTEST_LOCATION, ".txt", old_content);
+ const char *filename = tmp.get_filename ();
+ line_table_test ltt ();
+ linemap_add (line_table, LC_ENTER, false, filename, 2);
+
+ /* Try to insert a string in line 2. */
+ location_t loc = linemap_position_for_column (line_table, 1);
+
+ rich_location insert (line_table, loc);
+ insert.add_fixit_insert ("change");
+
+ /* Verify that attempting the insertion puts an edit_context
+ into an invalid state. */
+ edit_context edit;
+ ASSERT_TRUE (edit.valid_p ());
+ edit.add_fixits (&insert);
+ ASSERT_FALSE (edit.valid_p ());
+ ASSERT_EQ (NULL, edit.get_content (filename));
+ ASSERT_EQ (NULL, edit.generate_diff (false));
+}
+
+/* Verify the boundary conditions of column values in fix-it
+ hints applied to edit_context instances. */
+
+static void
+test_applying_fixits_column_validation (const line_table_case &case_)
+{
+ /* Create a tempfile and write some text to it.
+ ........................00000000011111111.
+ ........................12345678901234567. */
+ const char *old_content = "One-liner file\n";
+ temp_source_file tmp (SELFTEST_LOCATION, ".txt", old_content);
+ const char *filename = tmp.get_filename ();
+ line_table_test ltt (case_);
+ linemap_add (line_table, LC_ENTER, false, filename, 1);
+
+ location_t c11 = linemap_position_for_column (line_table, 11);
+ location_t c14 = linemap_position_for_column (line_table, 14);
+ location_t c15 = linemap_position_for_column (line_table, 15);
+ location_t c16 = linemap_position_for_column (line_table, 16);
+
+ /* Verify limits of valid columns in insertion fixits. */
+
+ /* Verify inserting at the end of the line. */
+ {
+ rich_location richloc (line_table, c11);
+ richloc.add_fixit_insert (c15, " change");
+
+ /* Col 15 is at the end of the line, so the insertion
+ should succeed. */
+ edit_context edit;
+ edit.add_fixits (&richloc);
+ auto_free <char *> new_content = edit.get_content (tmp.get_filename ());
+ if (c15 <= LINE_MAP_MAX_LOCATION_WITH_COLS)
+ ASSERT_STREQ ("One-liner file change\n", new_content);
+ else
+ ASSERT_EQ (NULL, new_content);
+ }
+
+ /* Verify inserting beyond the end of the line. */
+ {
+ rich_location richloc (line_table, c11);
+ richloc.add_fixit_insert (c16, " change");
+
+ /* Col 16 is beyond the end of the line, so the insertion
+ should fail gracefully. */
+ edit_context edit;
+ ASSERT_TRUE (edit.valid_p ());
+ edit.add_fixits (&richloc);
+ ASSERT_FALSE (edit.valid_p ());
+ ASSERT_EQ (NULL, edit.get_content (filename));
+ ASSERT_EQ (NULL, edit.generate_diff (false));
+ }
+
+ /* Verify limits of valid columns in replacement fixits. */
+
+ /* Verify replacing the end of the line. */
+ {
+ rich_location richloc (line_table, c11);
+ source_range range = source_range::from_locations (c11, c14);
+ richloc.add_fixit_replace (range, "change");
+
+ /* Col 14 is at the end of the line, so the replacement
+ should succeed. */
+ edit_context edit;
+ edit.add_fixits (&richloc);
+ auto_free <char *> new_content = edit.get_content (tmp.get_filename ());
+ if (c14 <= LINE_MAP_MAX_LOCATION_WITH_COLS)
+ ASSERT_STREQ ("One-liner change\n", new_content);
+ else
+ ASSERT_EQ (NULL, new_content);
+ }
+
+ /* Verify going beyond the end of the line. */
+ {
+ rich_location richloc (line_table, c11);
+ source_range range = source_range::from_locations (c11, c15);
+ richloc.add_fixit_replace (range, "change");
+
+ /* Col 15 is after the end of the line, so the replacement
+ should fail; verify that the attempt fails gracefully. */
+ edit_context edit;
+ ASSERT_TRUE (edit.valid_p ());
+ edit.add_fixits (&richloc);
+ ASSERT_FALSE (edit.valid_p ());
+ ASSERT_EQ (NULL, edit.get_content (filename));
+ ASSERT_EQ (NULL, edit.generate_diff (false));
+ }
+}
+
+/* Run all of the selftests within this file. */
+
+void
+edit_context_c_tests ()
+{
+ test_get_content ();
+ for_each_line_table_case (test_applying_fixits_insert);
+ for_each_line_table_case (test_applying_fixits_growing_replace);
+ for_each_line_table_case (test_applying_fixits_shrinking_replace);
+ for_each_line_table_case (test_applying_fixits_remove);
+ for_each_line_table_case (test_applying_fixits_multiple);
+ for_each_line_table_case (test_applying_fixits_multiple_lines);
+ for_each_line_table_case (test_applying_fixits_modernize_named_init);
+ test_applying_fixits_unreadable_file ();
+ test_applying_fixits_line_out_of_range ();
+ for_each_line_table_case (test_applying_fixits_column_validation);
+}
+
+} // namespace selftest
+
+#endif /* CHECKING_P */
diff --git a/gcc/edit-context.h b/gcc/edit-context.h
new file mode 100644
index 0000000..842da56
--- /dev/null
+++ b/gcc/edit-context.h
@@ -0,0 +1,68 @@
+/* Determining the results of applying fix-it hints.
+ Copyright (C) 2016 Free Software Foundation, Inc.
+
+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_EDIT_CONTEXT_H
+#define GCC_EDIT_CONTEXT_H
+
+#include "typed-splay-tree.h"
+
+class edit_context;
+class edited_file;
+
+/* A set of changes to the source code.
+
+ The changes are "atomic" - if any changes can't be applied,
+ none of them can be (tracked by the m_valid flag).
+ Similarly, attempts to add the changes from a rich_location flagged
+ as containing invalid changes mean that the whole of the edit_context
+ is flagged as invalid.
+
+ A complication here is that fix-its are expressed relative to coordinates
+ in the files when they were parsed, before any changes have been made, and
+ so if there's more that one fix-it to be applied, we have to adjust
+ later fix-its to allow for the changes made by earlier ones. This
+ is done by the various "get_effective_column" methods. */
+
+class edit_context
+{
+ public:
+ edit_context ();
+
+ bool valid_p () const { return m_valid; }
+
+ void add_fixits (rich_location *richloc);
+
+ char *get_content (const char *filename);
+
+ int get_effective_column (const char *filename, int line, int column);
+
+ char *generate_diff (bool show_filenames);
+ void print_diff (pretty_printer *pp, bool show_filenames);
+
+ private:
+ bool apply_insert (const fixit_insert *insert);
+ bool apply_replace (const fixit_replace *replace);
+ edited_file *get_file (const char *filename);
+ edited_file &get_or_insert_file (const char *filename);
+
+ bool m_valid;
+ typed_splay_tree<const char *, edited_file *> m_files;
+};
+
+#endif /* GCC_EDIT_CONTEXT_H. */
diff --git a/gcc/input.c b/gcc/input.c
index 2ff7cb8..55bff48 100644
--- a/gcc/input.c
+++ b/gcc/input.c
@@ -95,6 +95,11 @@ struct fcache
before the line map has seen the end of the file. */
size_t total_lines;
+ /* Could this file be missing a trailing newline on its final line?
+ Initially true (to cope with empty files), set to true/false
+ as each line is read. */
+ bool missing_trailing_newline;
+
/* This is a record of the beginning and end of the lines we've seen
while reading the file. This is useful to avoid walking the data
from the beginning when we are asked to read a line that is
@@ -280,6 +285,7 @@ diagnostics_file_cache_forcibly_evict_file (const char *file_path)
r->line_record.truncate (0);
r->use_count = 0;
r->total_lines = 0;
+ r->missing_trailing_newline = true;
}
/* Return the file cache that has been less used, recently, or the
@@ -348,6 +354,7 @@ add_file_to_cache_tab (const char *file_path)
add_file_to_cache_tab is called. */
r->use_count = ++highest_use_count;
r->total_lines = total_lines_num (file_path);
+ r->missing_trailing_newline = true;
return r;
}
@@ -372,7 +379,7 @@ lookup_or_add_file_to_cache_tab (const char *file_path)
fcache::fcache ()
: use_count (0), file_path (NULL), fp (NULL), data (0),
size (0), nb_read (0), line_start_idx (0), line_num (0),
- total_lines (0)
+ total_lines (0), missing_trailing_newline (true)
{
line_record.create (0);
}
@@ -507,16 +514,24 @@ get_next_line (fcache *c, char **line, ssize_t *line_len)
}
}
if (line_end == NULL)
- /* We've loadded all the file into the cache and still no
- '\n'. Let's say the line ends up at one byte passed the
- end of the file. This is to stay consistent with the case
- of when the line ends up with a '\n' and line_end points to
- that terminal '\n'. That consistency is useful below in
- the len calculation. */
- line_end = c->data + c->nb_read ;
+ {
+ /* We've loadded all the file into the cache and still no
+ '\n'. Let's say the line ends up at one byte passed the
+ end of the file. This is to stay consistent with the case
+ of when the line ends up with a '\n' and line_end points to
+ that terminal '\n'. That consistency is useful below in
+ the len calculation. */
+ line_end = c->data + c->nb_read ;
+ c->missing_trailing_newline = true;
+ }
+ else
+ c->missing_trailing_newline = false;
}
else
- next_line_start = line_end + 1;
+ {
+ next_line_start = line_end + 1;
+ c->missing_trailing_newline = false;
+ }
if (ferror (c->fp))
return -1;
@@ -751,6 +766,20 @@ location_get_source_line (const char *file_path, int line,
return read ? buffer : NULL;
}
+/* Determine if FILE_PATH missing a trailing newline on its final line.
+ Only valid to call once all of the file has been loaded, by
+ requesting a line number beyond the end of the file. */
+
+bool
+location_missing_trailing_newline (const char *file_path)
+{
+ fcache *c = lookup_or_add_file_to_cache_tab (file_path);
+ if (c == NULL)
+ return false;
+
+ return c->missing_trailing_newline;
+}
+
/* Test if the location originates from the spelling location of a
builtin-tokens. That is, return TRUE if LOC is a (possibly
virtual) location of a built-in token that appears in the expansion
diff --git a/gcc/input.h b/gcc/input.h
index fd21f34..e95bd3c 100644
--- a/gcc/input.h
+++ b/gcc/input.h
@@ -41,6 +41,7 @@ extern bool is_location_from_builtin_token (source_location);
extern expanded_location expand_location (source_location);
extern const char *location_get_source_line (const char *file_path, int line,
int *line_size);
+extern bool location_missing_trailing_newline (const char *file_path);
extern expanded_location expand_location_to_spelling_point (source_location);
extern source_location expansion_point_location_if_in_system_header (source_location);
extern source_location expansion_point_location (source_location);
diff --git a/gcc/selftest-run-tests.c b/gcc/selftest-run-tests.c
index e20bbd0..d9d3ea1 100644
--- a/gcc/selftest-run-tests.c
+++ b/gcc/selftest-run-tests.c
@@ -68,6 +68,7 @@ selftest::run_tests ()
rely on. */
diagnostic_show_locus_c_tests ();
diagnostic_c_tests ();
+ edit_context_c_tests ();
fold_const_c_tests ();
spellcheck_c_tests ();
spellcheck_tree_c_tests ();
diff --git a/gcc/selftest.h b/gcc/selftest.h
index 54a33f9..9b6fa95 100644
--- a/gcc/selftest.h
+++ b/gcc/selftest.h
@@ -151,6 +151,7 @@ for_each_line_table_case (void (*testcase) (const line_table_case &));
extern void bitmap_c_tests ();
extern void diagnostic_c_tests ();
extern void diagnostic_show_locus_c_tests ();
+extern void edit_context_c_tests ();
extern void et_forest_c_tests ();
extern void fold_const_c_tests ();
extern void fibonacci_heap_c_tests ();
diff --git a/libcpp/include/line-map.h b/libcpp/include/line-map.h
index bef7795..6b3c474 100644
--- a/libcpp/include/line-map.h
+++ b/libcpp/include/line-map.h
@@ -1567,6 +1567,7 @@ class rich_location
unsigned int get_num_fixit_hints () const { return m_fixit_hints.count (); }
fixit_hint *get_fixit_hint (int idx) const { return m_fixit_hints[idx]; }
fixit_hint *get_last_fixit_hint () const;
+ bool seen_impossible_fixit_p () const { return m_seen_impossible_fixit; }
private:
bool reject_impossible_fixit (source_location where);
--
1.8.5.3