Line data Source code
1 : /* Determining the results of applying fix-it hints.
2 : Copyright (C) 2016-2026 Free Software Foundation, Inc.
3 :
4 : This file is part of GCC.
5 :
6 : GCC is free software; you can redistribute it and/or modify it under
7 : the terms of the GNU General Public License as published by the Free
8 : Software Foundation; either version 3, or (at your option) any later
9 : version.
10 :
11 : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 : WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 : for more details.
15 :
16 : You should have received a copy of the GNU General Public License
17 : along with GCC; see the file COPYING3. If not see
18 : <http://www.gnu.org/licenses/>. */
19 :
20 : #include "config.h"
21 : #include "system.h"
22 : #include "coretypes.h"
23 : #include "line-map.h"
24 : #include "diagnostics/changes.h"
25 : #include "pretty-print.h"
26 : #include "diagnostics/color.h"
27 : #include "diagnostics/file-cache.h"
28 : #include "selftest.h"
29 :
30 : namespace diagnostics {
31 : namespace changes {
32 :
33 : /* This file implements a way to track the effect of fix-its,
34 : via a class change_set; the other classes are support classes for
35 : change_set.
36 :
37 : A complication here is that fix-its are expressed relative to coordinates
38 : in the file when it was parsed, before any changes have been made, and
39 : so if there's more that one fix-it to be applied, we have to adjust
40 : later fix-its to allow for the changes made by earlier ones. This
41 : is done by the various "get_effective_column" methods.
42 :
43 : The "filename" params are required to outlive the change_set (no
44 : copy of the underlying str is taken, just the ptr). */
45 :
46 : /* Forward decls. class change_set is declared within changes.h.
47 : The other types are declared here. */
48 : class change_set;
49 : class changed_file;
50 : class changed_line;
51 : class line_event;
52 :
53 : /* A struct to hold the params of a print_diff call. */
54 :
55 : class diff
56 : {
57 : public:
58 2717 : diff (pretty_printer *pp, bool show_filenames)
59 2717 : : m_pp (pp), m_show_filenames (show_filenames) {}
60 :
61 : pretty_printer *m_pp;
62 : bool m_show_filenames;
63 : };
64 :
65 : /* The state of one named file within an change_set: the filename,
66 : and the lines that have been edited so far. */
67 :
68 3611 : class changed_file
69 : {
70 : public:
71 : changed_file (change_set &ec, const char *filename);
72 : static void delete_cb (changed_file *file);
73 :
74 : const char *get_filename () const { return m_filename; }
75 : char *get_content ();
76 :
77 : bool apply_fixit (int line, int start_column,
78 : int next_column,
79 : const char *replacement_str,
80 : int replacement_len);
81 : int get_effective_column (int line, int column);
82 :
83 2645 : static int call_print_diff (const char *, changed_file *file,
84 : void *user_data)
85 : {
86 2645 : diff *d = (diff *)user_data;
87 2645 : file->print_diff (d->m_pp, d->m_show_filenames);
88 2645 : return 0;
89 : }
90 :
91 89180 : file_cache &get_file_cache () const
92 : {
93 89180 : return m_change_set.get_file_cache ();
94 : }
95 :
96 : private:
97 : bool print_content (pretty_printer *pp);
98 : void print_diff (pretty_printer *pp, bool show_filenames);
99 : int print_diff_hunk (pretty_printer *pp, int old_start_of_hunk,
100 : int old_end_of_hunk, int new_start_of_hunk);
101 : changed_line *get_line (int line);
102 : changed_line *get_or_insert_line (int line);
103 : int get_num_lines (bool *missing_trailing_newline);
104 :
105 : int get_effective_line_count (int old_start_of_hunk,
106 : int old_end_of_hunk);
107 :
108 : void print_run_of_changed_lines (pretty_printer *pp,
109 : int start_of_run,
110 : int end_of_run);
111 :
112 : change_set &m_change_set;
113 : const char *m_filename;
114 : typed_splay_tree<int, changed_line *> m_changed_lines;
115 : int m_num_lines;
116 : };
117 :
118 : /* A line added before an changed_line. */
119 :
120 : class added_line
121 : {
122 : public:
123 142 : added_line (const char *content, int len)
124 284 : : m_content (xstrndup (content, len)), m_len (len) {}
125 142 : ~added_line () { free (m_content); }
126 :
127 206 : const char *get_content () const { return m_content; }
128 142 : int get_len () const { return m_len; }
129 :
130 : private:
131 : char *m_content;
132 : int m_len;
133 : };
134 :
135 : /* Class for representing edit events that have occurred on one line of
136 : one file: the replacement of some text between some columns
137 : on the line.
138 :
139 : Subsequent events will need their columns adjusting if they're
140 : are on this line and their column is >= the start point. */
141 :
142 : class line_event
143 : {
144 : public:
145 3433 : line_event (int start, int next, int len) : m_start (start),
146 3433 : m_delta (len - (next - start)) {}
147 :
148 1860 : int get_effective_column (int orig_column) const
149 : {
150 1860 : if (orig_column >= m_start)
151 1220 : return orig_column += m_delta;
152 : else
153 : return orig_column;
154 : }
155 :
156 : private:
157 : int m_start;
158 : int m_delta;
159 : };
160 :
161 : /* The state of one edited line within an changed_file.
162 : As well as the current content of the line, it contains a record of
163 : the changes, so that further changes can be applied in the correct
164 : place.
165 :
166 : When handling fix-it hints containing newlines, new lines are added
167 : as added_line predecessors to an changed_line. Hence it's possible
168 : for an "changed_line" to not actually have been changed, but to merely
169 : be a placeholder for the lines added before it. This can be tested
170 : for with actuall_edited_p, and has a slight effect on how diff hunks
171 : are generated. */
172 :
173 : class changed_line
174 : {
175 : public:
176 : changed_line (file_cache &fc, const char *filename, int line_num);
177 : ~changed_line ();
178 : static void delete_cb (changed_line *el);
179 :
180 11786 : int get_line_num () const { return m_line_num; }
181 3940 : const char *get_content () const { return m_content; }
182 : int get_len () const { return m_len; }
183 :
184 : int get_effective_column (int orig_column) const;
185 : bool apply_fixit (int start_column,
186 : int next_column,
187 : const char *replacement_str,
188 : int replacement_len);
189 :
190 : int get_effective_line_count () const;
191 :
192 : /* Has the content of this line actually changed, or are we merely
193 : recording predecessor added_lines? */
194 20885 : bool actually_edited_p () const { return m_line_events.length () > 0; }
195 :
196 : void print_content (pretty_printer *pp) const;
197 : void print_diff_lines (pretty_printer *pp) const;
198 :
199 : private:
200 : void ensure_capacity (int len);
201 : void ensure_terminated ();
202 :
203 : int m_line_num;
204 : char *m_content;
205 : int m_len;
206 : int m_alloc_sz;
207 : auto_vec <line_event> m_line_events;
208 : auto_vec <added_line *> m_predecessors;
209 : };
210 :
211 : /* Forward decls. */
212 :
213 : static void
214 : print_diff_line (pretty_printer *pp, char prefix_char,
215 : const char *line, int line_size);
216 :
217 : /* Implementation of class change_set. */
218 :
219 : /* change_set's ctor. */
220 :
221 10443 : change_set::change_set (file_cache &fc)
222 10443 : : m_file_cache (fc),
223 10443 : m_valid (true),
224 10443 : m_files (strcmp, NULL, changed_file::delete_cb)
225 10443 : {}
226 :
227 : /* Add any fixits within RICHLOC to this context, recording the
228 : changes that they make. */
229 :
230 : void
231 11368 : change_set::add_fixits (rich_location *richloc)
232 : {
233 11368 : if (!m_valid)
234 : return;
235 11136 : if (richloc->seen_impossible_fixit_p ())
236 : {
237 6768 : m_valid = false;
238 6768 : return;
239 : }
240 8633 : for (unsigned i = 0; i < richloc->get_num_fixit_hints (); i++)
241 : {
242 4265 : const fixit_hint *hint = richloc->get_fixit_hint (i);
243 4265 : if (!apply_fixit (hint))
244 690 : m_valid = false;
245 : }
246 : }
247 :
248 : /* Get the content of the given file, with fix-its applied.
249 : If any errors occurred in this change_set, return NULL.
250 : The ptr should be freed by the caller. */
251 :
252 : char *
253 1288 : change_set::get_content (const char *filename)
254 : {
255 1288 : if (!m_valid)
256 : return NULL;
257 844 : changed_file &file = get_or_insert_file (filename);
258 844 : return file.get_content ();
259 : }
260 :
261 : /* Map a location before the edits to a column number after the edits.
262 : This method is for the selftests. */
263 :
264 : int
265 1088 : change_set::get_effective_column (const char *filename, int line,
266 : int column)
267 : {
268 1088 : changed_file *file = get_file (filename);
269 1088 : if (!file)
270 : return column;
271 1088 : return file->get_effective_column (line, column);
272 : }
273 :
274 : /* Generate a unified diff. The resulting string should be freed by the
275 : caller. Primarily for selftests.
276 : If any errors occurred in this change_set, return NULL. */
277 :
278 : char *
279 9894 : change_set::generate_diff (bool show_filenames)
280 : {
281 9894 : if (!m_valid)
282 : return NULL;
283 :
284 2700 : pretty_printer pp;
285 2700 : print_diff (&pp, show_filenames);
286 2700 : return xstrdup (pp_formatted_text (&pp));
287 2700 : }
288 :
289 : /* Print a unified diff to PP, showing the changes made within the
290 : context. */
291 :
292 : void
293 2717 : change_set::print_diff (pretty_printer *pp, bool show_filenames)
294 : {
295 2717 : if (!m_valid)
296 0 : return;
297 2717 : diff d (pp, show_filenames);
298 2717 : m_files.foreach (changed_file::call_print_diff, &d);
299 : }
300 :
301 : /* Attempt to apply the given fixit. Return true if it can be
302 : applied, or false otherwise. */
303 :
304 : bool
305 4265 : change_set::apply_fixit (const fixit_hint *hint)
306 : {
307 4265 : expanded_location start = expand_location (hint->get_start_loc ());
308 4265 : expanded_location next_loc = expand_location (hint->get_next_loc ());
309 4265 : if (start.file != next_loc.file)
310 : return false;
311 4265 : if (start.line != next_loc.line)
312 : return false;
313 4265 : if (start.column == 0)
314 : return false;
315 4265 : if (next_loc.column == 0)
316 : return false;
317 :
318 4265 : changed_file &file = get_or_insert_file (start.file);
319 4265 : if (!m_valid)
320 : return false;
321 4265 : return file.apply_fixit (start.line, start.column, next_loc.column,
322 : hint->get_string (),
323 4265 : hint->get_length ());
324 : }
325 :
326 : /* Locate the changed_file * for FILENAME, if any
327 : Return NULL if there isn't one. */
328 :
329 : changed_file *
330 6197 : change_set::get_file (const char *filename)
331 : {
332 6197 : gcc_assert (filename);
333 6197 : return m_files.lookup (filename);
334 : }
335 :
336 : /* Locate the changed_file for FILENAME, adding one if there isn't one. */
337 :
338 : changed_file &
339 5109 : change_set::get_or_insert_file (const char *filename)
340 : {
341 5109 : gcc_assert (filename);
342 :
343 5109 : changed_file *file = get_file (filename);
344 5109 : if (file)
345 : return *file;
346 :
347 : /* Not found. */
348 3611 : file = new changed_file (*this, filename);
349 3611 : m_files.insert (filename, file);
350 3611 : return *file;
351 : }
352 :
353 : /* Implementation of class changed_file. */
354 :
355 : /* Callback for m_changed_lines, for comparing line numbers. */
356 :
357 67131 : static int line_comparator (int a, int b)
358 : {
359 67131 : return a - b;
360 : }
361 :
362 : /* changed_file's constructor. */
363 :
364 3611 : changed_file::changed_file (change_set &ec, const char *filename)
365 3611 : : m_change_set (ec),
366 3611 : m_filename (filename),
367 3611 : m_changed_lines (line_comparator, NULL, changed_line::delete_cb),
368 3611 : m_num_lines (-1)
369 : {
370 3611 : }
371 :
372 : /* A callback for deleting changed_file *, for use as a
373 : delete_value_fn for change_set::m_files. */
374 :
375 : void
376 3611 : changed_file::delete_cb (changed_file *file)
377 : {
378 7222 : delete file;
379 3611 : }
380 :
381 : /* Get the content of the file, with fix-its applied.
382 : The ptr should be freed by the caller. */
383 :
384 : char *
385 844 : changed_file::get_content ()
386 : {
387 844 : pretty_printer pp;
388 844 : if (!print_content (&pp))
389 : return NULL;
390 844 : return xstrdup (pp_formatted_text (&pp));
391 844 : }
392 :
393 : /* Attempt to replace columns START_COLUMN up to but not including NEXT_COLUMN
394 : of LINE with the string REPLACEMENT_STR of length REPLACEMENT_LEN,
395 : updating the in-memory copy of the line, and the record of edits to
396 : the line. */
397 :
398 : bool
399 4265 : changed_file::apply_fixit (int line, int start_column, int next_column,
400 : const char *replacement_str,
401 : int replacement_len)
402 : {
403 4265 : changed_line *el = get_or_insert_line (line);
404 4265 : if (!el)
405 : return false;
406 4161 : return el->apply_fixit (start_column, next_column, replacement_str,
407 4161 : replacement_len);
408 : }
409 :
410 : /* Given line LINE, map from COLUMN in the input file to its current
411 : column after edits have been applied. */
412 :
413 : int
414 1088 : changed_file::get_effective_column (int line, int column)
415 : {
416 1088 : const changed_line *el = get_line (line);
417 1088 : if (!el)
418 : return column;
419 832 : return el->get_effective_column (column);
420 : }
421 :
422 : /* Attempt to print the content of the file to PP, with edits applied.
423 : Return true if successful, false otherwise. */
424 :
425 : bool
426 844 : changed_file::print_content (pretty_printer *pp)
427 : {
428 844 : bool missing_trailing_newline;
429 844 : int line_count = get_num_lines (&missing_trailing_newline);
430 3172 : for (int line_num = 1; line_num <= line_count; line_num++)
431 : {
432 2328 : changed_line *el = get_line (line_num);
433 2328 : if (el)
434 832 : el->print_content (pp);
435 : else
436 : {
437 1496 : char_span line
438 1496 : = get_file_cache ().get_source_line (m_filename, line_num);
439 1496 : if (!line)
440 0 : return false;
441 18896 : for (size_t i = 0; i < line.length (); i++)
442 17400 : pp_character (pp, line[i]);
443 : }
444 2328 : if (line_num < line_count)
445 1488 : pp_character (pp, '\n');
446 : }
447 :
448 844 : if (!missing_trailing_newline)
449 836 : pp_character (pp, '\n');
450 :
451 : return true;
452 : }
453 :
454 : /* Print a unified diff to PP, showing any changes that have occurred
455 : to this file. */
456 :
457 : void
458 2645 : changed_file::print_diff (pretty_printer *pp, bool show_filenames)
459 : {
460 2645 : if (show_filenames)
461 : {
462 2077 : pp_string (pp, colorize_start (pp_show_color (pp), "diff-filename"));
463 : /* Avoid -Wformat-diag in non-diagnostic output. */
464 2077 : pp_string (pp, "--- ");
465 2077 : pp_string (pp, m_filename);
466 2077 : pp_newline (pp);
467 2077 : pp_string (pp, "+++ ");
468 2077 : pp_string (pp, m_filename);
469 2077 : pp_newline (pp);
470 2077 : pp_string (pp, colorize_stop (pp_show_color (pp)));
471 : }
472 :
473 2645 : changed_line *el = m_changed_lines.min ();
474 :
475 2645 : bool missing_trailing_newline;
476 2645 : int line_count = get_num_lines (&missing_trailing_newline);
477 :
478 2645 : const int context_lines = 3;
479 :
480 : /* Track new line numbers minus old line numbers. */
481 :
482 2645 : int line_delta = 0;
483 :
484 2645 : while (el)
485 : {
486 2706 : int start_of_hunk = el->get_line_num ();
487 2706 : start_of_hunk -= context_lines;
488 2706 : if (start_of_hunk < 1)
489 : start_of_hunk = 1;
490 :
491 : /* Locate end of hunk, merging in changed lines
492 : that are sufficiently close. */
493 2986 : while (true)
494 : {
495 2986 : changed_line *next_el
496 2986 : = m_changed_lines.successor (el->get_line_num ());
497 341 : if (!next_el)
498 : break;
499 :
500 341 : int end_of_printed_hunk = el->get_line_num () + context_lines;
501 341 : if (!el->actually_edited_p ())
502 57 : end_of_printed_hunk--;
503 :
504 341 : if (end_of_printed_hunk
505 341 : >= next_el->get_line_num () - context_lines)
506 : el = next_el;
507 : else
508 : break;
509 : }
510 :
511 2706 : int end_of_hunk = el->get_line_num ();
512 2706 : end_of_hunk += context_lines;
513 2706 : if (!el->actually_edited_p ())
514 139 : end_of_hunk--;
515 2706 : if (end_of_hunk > line_count)
516 : end_of_hunk = line_count;
517 :
518 2706 : int new_start_of_hunk = start_of_hunk + line_delta;
519 2706 : line_delta += print_diff_hunk (pp, start_of_hunk, end_of_hunk,
520 : new_start_of_hunk);
521 8057 : el = m_changed_lines.successor (el->get_line_num ());
522 : }
523 2645 : }
524 :
525 : /* Print one hunk within a unified diff to PP, covering the
526 : given range of lines. OLD_START_OF_HUNK and OLD_END_OF_HUNK are
527 : line numbers in the unedited version of the file.
528 : NEW_START_OF_HUNK is a line number in the edited version of the file.
529 : Return the change in the line count within the hunk. */
530 :
531 : int
532 2706 : changed_file::print_diff_hunk (pretty_printer *pp, int old_start_of_hunk,
533 : int old_end_of_hunk, int new_start_of_hunk)
534 : {
535 2706 : int old_num_lines = old_end_of_hunk - old_start_of_hunk + 1;
536 2706 : int new_num_lines
537 2706 : = get_effective_line_count (old_start_of_hunk, old_end_of_hunk);
538 :
539 2706 : pp_string (pp, colorize_start (pp_show_color (pp), "diff-hunk"));
540 2706 : pp_printf (pp, "%s -%i,%i +%i,%i %s",
541 : "@@", old_start_of_hunk, old_num_lines,
542 : new_start_of_hunk, new_num_lines, "@@\n");
543 2706 : pp_string (pp, colorize_stop (pp_show_color (pp)));
544 :
545 2706 : int line_num = old_start_of_hunk;
546 10100 : while (line_num <= old_end_of_hunk)
547 : {
548 4688 : changed_line *el = get_line (line_num);
549 4688 : if (el)
550 : {
551 : /* We have an edited line.
552 : Consolidate into runs of changed lines. */
553 : const int first_changed_line_in_run = line_num;
554 5748 : while (get_line (line_num))
555 2986 : line_num++;
556 2762 : const int last_changed_line_in_run = line_num - 1;
557 2762 : print_run_of_changed_lines (pp, first_changed_line_in_run,
558 : last_changed_line_in_run);
559 : }
560 : else
561 : {
562 : /* Unchanged line. */
563 1926 : char_span old_line
564 1926 : = get_file_cache ().get_source_line (m_filename, line_num);
565 1926 : print_diff_line (pp, ' ', old_line.get_buffer (), old_line.length ());
566 1926 : line_num++;
567 : }
568 : }
569 :
570 2706 : return new_num_lines - old_num_lines;
571 : }
572 :
573 : /* Subroutine of changed_file::print_diff_hunk: given a run of lines
574 : from START_OF_RUN to END_OF_RUN that all have changed_line instances,
575 : print the diff to PP. */
576 :
577 : void
578 2762 : changed_file::print_run_of_changed_lines (pretty_printer *pp,
579 : int start_of_run,
580 : int end_of_run)
581 : {
582 : /* Show old version of lines. */
583 2762 : pp_string (pp, colorize_start (pp_show_color (pp),
584 : "diff-delete"));
585 2762 : for (int line_num = start_of_run;
586 5748 : line_num <= end_of_run;
587 : line_num++)
588 : {
589 2986 : changed_line *el_in_run = get_line (line_num);
590 2986 : gcc_assert (el_in_run);
591 5833 : if (el_in_run->actually_edited_p ())
592 : {
593 2847 : char_span old_line
594 2847 : = get_file_cache ().get_source_line (m_filename, line_num);
595 2847 : print_diff_line (pp, '-', old_line.get_buffer (),
596 2847 : old_line.length ());
597 : }
598 : }
599 2762 : pp_string (pp, colorize_stop (pp_show_color (pp)));
600 :
601 : /* Show new version of lines. */
602 2762 : pp_string (pp, colorize_start (pp_show_color (pp),
603 : "diff-insert"));
604 5748 : for (int line_num = start_of_run;
605 5748 : line_num <= end_of_run;
606 : line_num++)
607 : {
608 2986 : changed_line *el_in_run = get_line (line_num);
609 2986 : gcc_assert (el_in_run);
610 2986 : el_in_run->print_diff_lines (pp);
611 : }
612 2762 : pp_string (pp, colorize_stop (pp_show_color (pp)));
613 2762 : }
614 :
615 : /* Print one line within a diff, starting with PREFIX_CHAR,
616 : followed by the LINE of content, of length LEN. LINE is
617 : not necessarily 0-terminated. Print a trailing newline. */
618 :
619 : static void
620 7901 : print_diff_line (pretty_printer *pp, char prefix_char,
621 : const char *line, int len)
622 : {
623 7901 : pp_character (pp, prefix_char);
624 17385105 : for (int i = 0; i < len; i++)
625 17377204 : pp_character (pp, line[i]);
626 7901 : pp_character (pp, '\n');
627 7901 : }
628 :
629 : /* Determine the number of lines that will be present after
630 : editing for the range of lines from OLD_START_OF_HUNK to
631 : OLD_END_OF_HUNK inclusive. */
632 :
633 : int
634 2706 : changed_file::get_effective_line_count (int old_start_of_hunk,
635 : int old_end_of_hunk)
636 : {
637 2706 : int line_count = 0;
638 7618 : for (int old_line_num = old_start_of_hunk; old_line_num <= old_end_of_hunk;
639 : old_line_num++)
640 : {
641 4912 : changed_line *el = get_line (old_line_num);
642 4912 : if (el)
643 2986 : line_count += el->get_effective_line_count ();
644 : else
645 1926 : line_count++;
646 : }
647 2706 : return line_count;
648 : }
649 :
650 : /* Get the state of LINE within the file, or NULL if it is untouched. */
651 :
652 : changed_line *
653 29001 : changed_file::get_line (int line)
654 : {
655 29001 : return m_changed_lines.lookup (line);
656 : }
657 :
658 : /* Get the state of LINE within the file, creating a state for it
659 : if necessary. Return NULL if an error occurs. */
660 :
661 : changed_line *
662 4265 : changed_file::get_or_insert_line (int line)
663 : {
664 4265 : changed_line *el = get_line (line);
665 4265 : if (el)
666 : return el;
667 3940 : el = new changed_line (get_file_cache (), m_filename, line);
668 3940 : if (el->get_content () == NULL)
669 : {
670 104 : delete el;
671 104 : return NULL;
672 : }
673 3836 : m_changed_lines.insert (line, el);
674 3836 : return el;
675 : }
676 :
677 : /* Get the total number of lines in m_content, writing
678 : true to *MISSING_TRAILING_NEWLINE if the final line
679 : if missing a newline, false otherwise. */
680 :
681 : int
682 3489 : changed_file::get_num_lines (bool *missing_trailing_newline)
683 : {
684 3489 : gcc_assert (missing_trailing_newline);
685 3489 : if (m_num_lines == -1)
686 : {
687 2913 : m_num_lines = 0;
688 148051 : while (true)
689 : {
690 75482 : char_span line
691 75482 : = get_file_cache ().get_source_line (m_filename, m_num_lines + 1);
692 75482 : if (line)
693 72569 : m_num_lines++;
694 : else
695 : break;
696 72569 : }
697 : }
698 3489 : *missing_trailing_newline
699 3489 : = get_file_cache ().missing_trailing_newline_p (m_filename);
700 3489 : return m_num_lines;
701 : }
702 :
703 : /* Implementation of class changed_line. */
704 :
705 : /* changed_line's ctor. */
706 :
707 3940 : changed_line::changed_line (file_cache &fc, const char *filename, int line_num)
708 3940 : : m_line_num (line_num),
709 3940 : m_content (NULL), m_len (0), m_alloc_sz (0),
710 3940 : m_line_events (),
711 3940 : m_predecessors ()
712 : {
713 3940 : char_span line = fc.get_source_line (filename, line_num);
714 3940 : if (!line)
715 104 : return;
716 3836 : m_len = line.length ();
717 3836 : ensure_capacity (m_len);
718 3836 : memcpy (m_content, line.get_buffer (), m_len);
719 3836 : ensure_terminated ();
720 : }
721 :
722 : /* changed_line's dtor. */
723 :
724 3940 : changed_line::~changed_line ()
725 : {
726 3940 : unsigned i;
727 3940 : added_line *pred;
728 :
729 3940 : free (m_content);
730 4082 : FOR_EACH_VEC_ELT (m_predecessors, i, pred)
731 142 : delete pred;
732 3940 : }
733 :
734 : /* A callback for deleting changed_line *, for use as a
735 : delete_value_fn for changed_file::m_changed_lines. */
736 :
737 : void
738 3836 : changed_line::delete_cb (changed_line *el)
739 : {
740 3836 : delete el;
741 3836 : }
742 :
743 : /* Map a location before the edits to a column number after the edits,
744 : within a specific line. */
745 :
746 : int
747 8870 : changed_line::get_effective_column (int orig_column) const
748 : {
749 8870 : int i;
750 8870 : line_event *event;
751 10730 : FOR_EACH_VEC_ELT (m_line_events, i, event)
752 3080 : orig_column = event->get_effective_column (orig_column);
753 8870 : return orig_column;
754 : }
755 :
756 : /* Attempt to replace columns START_COLUMN up to but not including
757 : NEXT_COLUMN of the line with the string REPLACEMENT_STR of
758 : length REPLACEMENT_LEN, updating the in-memory copy of the line,
759 : and the record of edits to the line.
760 : Return true if successful; false if an error occurred. */
761 :
762 : bool
763 4161 : changed_line::apply_fixit (int start_column,
764 : int next_column,
765 : const char *replacement_str,
766 : int replacement_len)
767 : {
768 : /* Handle newlines. They will only ever be at the end of the
769 : replacement text, thanks to the filtering in rich_location. */
770 4161 : if (replacement_len > 1)
771 3430 : if (replacement_str[replacement_len - 1] == '\n')
772 : {
773 : /* Stash in m_predecessors, stripping off newline. */
774 426 : m_predecessors.safe_push (new added_line (replacement_str,
775 142 : replacement_len - 1));
776 142 : return true;
777 : }
778 :
779 4019 : start_column = get_effective_column (start_column);
780 4019 : next_column = get_effective_column (next_column);
781 :
782 4019 : int start_offset = start_column - 1;
783 4019 : int next_offset = next_column - 1;
784 :
785 4019 : gcc_assert (start_offset >= 0);
786 4019 : gcc_assert (next_offset >= 0);
787 :
788 4019 : if (start_column > next_column)
789 : return false;
790 4019 : if (start_offset >= (m_len + 1))
791 : return false;
792 3637 : if (next_offset >= (m_len + 1))
793 : return false;
794 :
795 3433 : size_t victim_len = next_offset - start_offset;
796 :
797 : /* Ensure buffer is big enough. */
798 3433 : size_t new_len = m_len + replacement_len - victim_len;
799 3433 : ensure_capacity (new_len);
800 :
801 3433 : char *suffix = m_content + next_offset;
802 3433 : gcc_assert (suffix <= m_content + m_len);
803 3433 : size_t len_suffix = (m_content + m_len) - suffix;
804 :
805 : /* Move successor content into position. They overlap, so use memmove. */
806 3433 : memmove (m_content + start_offset + replacement_len,
807 : suffix, len_suffix);
808 :
809 : /* Replace target content. They don't overlap, so use memcpy. */
810 3433 : memcpy (m_content + start_offset,
811 : replacement_str,
812 : replacement_len);
813 :
814 3433 : m_len = new_len;
815 :
816 3433 : ensure_terminated ();
817 :
818 : /* Record the replacement, so that future changes to the line can have
819 : their column information adjusted accordingly. */
820 6866 : m_line_events.safe_push (line_event (start_column, next_column,
821 3433 : replacement_len));
822 3433 : return true;
823 : }
824 :
825 : /* Determine the number of lines that will be present after
826 : editing for this line. Typically this is just 1, but
827 : if newlines have been added before this line, they will
828 : also be counted. */
829 :
830 : int
831 2986 : changed_line::get_effective_line_count () const
832 : {
833 2986 : return m_predecessors.length () + 1;
834 : }
835 :
836 : /* Subroutine of changed_file::print_content.
837 : Print this line and any new lines added before it, to PP. */
838 :
839 : void
840 832 : changed_line::print_content (pretty_printer *pp) const
841 : {
842 832 : unsigned i;
843 832 : added_line *pred;
844 896 : FOR_EACH_VEC_ELT (m_predecessors, i, pred)
845 : {
846 64 : pp_string (pp, pred->get_content ());
847 64 : pp_newline (pp);
848 : }
849 832 : pp_string (pp, m_content);
850 832 : }
851 :
852 : /* Subroutine of changed_file::print_run_of_changed_lines for
853 : printing diff hunks to PP.
854 : Print the '+' line for this line, and any newlines added
855 : before it.
856 : Note that if this changed_line was actually edited, the '-'
857 : line has already been printed. If it wasn't, then we merely
858 : have a placeholder changed_line for adding newlines to, and
859 : we need to print a ' ' line for the changed_line as we haven't
860 : printed it yet. */
861 :
862 : void
863 2986 : changed_line::print_diff_lines (pretty_printer *pp) const
864 : {
865 2986 : unsigned i;
866 2986 : added_line *pred;
867 3128 : FOR_EACH_VEC_ELT (m_predecessors, i, pred)
868 142 : print_diff_line (pp, '+', pred->get_content (),
869 : pred->get_len ());
870 2986 : if (actually_edited_p ())
871 2847 : print_diff_line (pp, '+', m_content, m_len);
872 : else
873 139 : print_diff_line (pp, ' ', m_content, m_len);
874 2986 : }
875 :
876 : /* Ensure that the buffer for m_content is at least large enough to hold
877 : a string of length LEN and its 0-terminator, doubling on repeated
878 : allocations. */
879 :
880 : void
881 7269 : changed_line::ensure_capacity (int len)
882 : {
883 : /* Allow 1 extra byte for 0-termination. */
884 7269 : if (m_alloc_sz < (len + 1))
885 : {
886 4341 : size_t new_alloc_sz = (len + 1) * 2;
887 4341 : m_content = (char *)xrealloc (m_content, new_alloc_sz);
888 4341 : m_alloc_sz = new_alloc_sz;
889 : }
890 7269 : }
891 :
892 : /* Ensure that m_content is 0-terminated. */
893 :
894 : void
895 7269 : changed_line::ensure_terminated ()
896 : {
897 : /* 0-terminate the buffer. */
898 7269 : gcc_assert (m_len < m_alloc_sz);
899 7269 : m_content[m_len] = '\0';
900 7269 : }
901 :
902 : #if CHECKING_P
903 :
904 : /* Selftests of code-editing. */
905 :
906 : namespace selftest {
907 :
908 : using line_table_case = ::selftest::line_table_case;
909 : using line_table_test = ::selftest::line_table_test;
910 : using temp_source_file = ::selftest::temp_source_file;
911 : using named_temp_file = ::selftest::named_temp_file;
912 :
913 : /* A wrapper class for ensuring that the underlying pointer is freed. */
914 :
915 : template <typename POINTER_T>
916 : class auto_free
917 : {
918 : public:
919 1636 : auto_free (POINTER_T p) : m_ptr (p) {}
920 1316 : ~auto_free () { free (m_ptr); }
921 :
922 : operator POINTER_T () { return m_ptr; }
923 :
924 : private:
925 : POINTER_T m_ptr;
926 : };
927 :
928 : /* Verify that change_set::get_content works for unedited files. */
929 :
930 : static void
931 4 : test_get_content ()
932 : {
933 : /* Test of empty file. */
934 4 : {
935 4 : const char *content = ("");
936 4 : temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
937 4 : file_cache fc;
938 4 : change_set edit (fc);
939 4 : auto_free <char *> result = edit.get_content (tmp.get_filename ());
940 4 : ASSERT_STREQ ("", result);
941 4 : }
942 :
943 : /* Test of simple content. */
944 4 : {
945 4 : const char *content = ("/* before */\n"
946 : "foo = bar.field;\n"
947 : "/* after */\n");
948 4 : temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
949 4 : file_cache fc;
950 4 : change_set edit (fc);
951 4 : auto_free <char *> result = edit.get_content (tmp.get_filename ());
952 4 : ASSERT_STREQ ("/* before */\n"
953 : "foo = bar.field;\n"
954 : "/* after */\n", result);
955 4 : }
956 :
957 : /* Test of omitting the trailing newline on the final line. */
958 4 : {
959 4 : const char *content = ("/* before */\n"
960 : "foo = bar.field;\n"
961 : "/* after */");
962 4 : temp_source_file tmp (SELFTEST_LOCATION, ".c", content);
963 4 : file_cache fc;
964 4 : change_set edit (fc);
965 4 : auto_free <char *> result = edit.get_content (tmp.get_filename ());
966 : /* We should respect the omitted trailing newline. */
967 4 : ASSERT_STREQ ("/* before */\n"
968 : "foo = bar.field;\n"
969 : "/* after */", result);
970 4 : }
971 4 : }
972 :
973 : /* Test applying an "insert" fixit, using insert_before. */
974 :
975 : static void
976 96 : test_applying_fixits_insert_before (const line_table_case &case_)
977 : {
978 : /* Create a tempfile and write some text to it.
979 : .........................0000000001111111.
980 : .........................1234567890123456. */
981 96 : const char *old_content = ("/* before */\n"
982 : "foo = bar.field;\n"
983 : "/* after */\n");
984 96 : temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
985 96 : const char *filename = tmp.get_filename ();
986 96 : line_table_test ltt (case_);
987 96 : linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 2);
988 :
989 : /* Add a comment in front of "bar.field". */
990 96 : location_t start = linemap_position_for_column (line_table, 7);
991 96 : rich_location richloc (line_table, start);
992 96 : richloc.add_fixit_insert_before ("/* inserted */");
993 :
994 96 : if (start > LINE_MAP_MAX_LOCATION_WITH_COLS)
995 32 : return;
996 :
997 64 : file_cache fc;
998 64 : change_set edit (fc);
999 64 : edit.add_fixits (&richloc);
1000 64 : auto_free <char *> new_content = edit.get_content (filename);
1001 64 : if (start <= LINE_MAP_MAX_LOCATION_WITH_COLS)
1002 64 : ASSERT_STREQ ("/* before */\n"
1003 : "foo = /* inserted */bar.field;\n"
1004 : "/* after */\n", new_content);
1005 :
1006 : /* Verify that locations on other lines aren't affected by the change. */
1007 64 : ASSERT_EQ (100, edit.get_effective_column (filename, 1, 100));
1008 64 : ASSERT_EQ (100, edit.get_effective_column (filename, 3, 100));
1009 :
1010 : /* Verify locations on the line before the change. */
1011 64 : ASSERT_EQ (1, edit.get_effective_column (filename, 2, 1));
1012 64 : ASSERT_EQ (6, edit.get_effective_column (filename, 2, 6));
1013 :
1014 : /* Verify locations on the line at and after the change. */
1015 64 : ASSERT_EQ (21, edit.get_effective_column (filename, 2, 7));
1016 64 : ASSERT_EQ (22, edit.get_effective_column (filename, 2, 8));
1017 :
1018 : /* Verify diff. */
1019 64 : auto_free <char *> diff = edit.generate_diff (false);
1020 64 : ASSERT_STREQ ("@@ -1,3 +1,3 @@\n"
1021 : " /* before */\n"
1022 : "-foo = bar.field;\n"
1023 : "+foo = /* inserted */bar.field;\n"
1024 : " /* after */\n", diff);
1025 96 : }
1026 :
1027 : /* Test applying an "insert" fixit, using insert_after, with
1028 : a range of length > 1 (to ensure that the end-point of
1029 : the input range is used). */
1030 :
1031 : static void
1032 96 : test_applying_fixits_insert_after (const line_table_case &case_)
1033 : {
1034 : /* Create a tempfile and write some text to it.
1035 : .........................0000000001111111.
1036 : .........................1234567890123456. */
1037 96 : const char *old_content = ("/* before */\n"
1038 : "foo = bar.field;\n"
1039 : "/* after */\n");
1040 96 : temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
1041 96 : const char *filename = tmp.get_filename ();
1042 96 : line_table_test ltt (case_);
1043 96 : linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 2);
1044 :
1045 : /* Add a comment after "field". */
1046 96 : location_t start = linemap_position_for_column (line_table, 11);
1047 96 : location_t finish = linemap_position_for_column (line_table, 15);
1048 96 : location_t field = make_location (start, start, finish);
1049 96 : rich_location richloc (line_table, field);
1050 96 : richloc.add_fixit_insert_after ("/* inserted */");
1051 :
1052 96 : if (finish > LINE_MAP_MAX_LOCATION_WITH_COLS)
1053 32 : return;
1054 :
1055 : /* Verify that the text was inserted after the end of "field". */
1056 64 : file_cache fc;
1057 64 : change_set edit (fc);
1058 64 : edit.add_fixits (&richloc);
1059 64 : auto_free <char *> new_content = edit.get_content (filename);
1060 64 : ASSERT_STREQ ("/* before */\n"
1061 : "foo = bar.field/* inserted */;\n"
1062 : "/* after */\n", new_content);
1063 :
1064 : /* Verify diff. */
1065 64 : auto_free <char *> diff = edit.generate_diff (false);
1066 64 : ASSERT_STREQ ("@@ -1,3 +1,3 @@\n"
1067 : " /* before */\n"
1068 : "-foo = bar.field;\n"
1069 : "+foo = bar.field/* inserted */;\n"
1070 : " /* after */\n", diff);
1071 96 : }
1072 :
1073 : /* Test applying an "insert" fixit, using insert_after at the end of
1074 : a line (contrast with test_applying_fixits_insert_after_failure
1075 : below). */
1076 :
1077 : static void
1078 96 : test_applying_fixits_insert_after_at_line_end (const line_table_case &case_)
1079 : {
1080 : /* Create a tempfile and write some text to it.
1081 : .........................0000000001111111.
1082 : .........................1234567890123456. */
1083 96 : const char *old_content = ("/* before */\n"
1084 : "foo = bar.field;\n"
1085 : "/* after */\n");
1086 96 : temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
1087 96 : const char *filename = tmp.get_filename ();
1088 96 : line_table_test ltt (case_);
1089 96 : linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 2);
1090 :
1091 : /* Add a comment after the semicolon. */
1092 96 : location_t loc = linemap_position_for_column (line_table, 16);
1093 96 : rich_location richloc (line_table, loc);
1094 96 : richloc.add_fixit_insert_after ("/* inserted */");
1095 :
1096 96 : if (loc > LINE_MAP_MAX_LOCATION_WITH_COLS)
1097 32 : return;
1098 :
1099 64 : file_cache fc;
1100 64 : change_set edit (fc);
1101 64 : edit.add_fixits (&richloc);
1102 64 : auto_free <char *> new_content = edit.get_content (filename);
1103 64 : ASSERT_STREQ ("/* before */\n"
1104 : "foo = bar.field;/* inserted */\n"
1105 : "/* after */\n", new_content);
1106 :
1107 : /* Verify diff. */
1108 64 : auto_free <char *> diff = edit.generate_diff (false);
1109 64 : ASSERT_STREQ ("@@ -1,3 +1,3 @@\n"
1110 : " /* before */\n"
1111 : "-foo = bar.field;\n"
1112 : "+foo = bar.field;/* inserted */\n"
1113 : " /* after */\n", diff);
1114 96 : }
1115 :
1116 : /* Test of a failed attempt to apply an "insert" fixit, using insert_after,
1117 : due to the relevant linemap ending. Contrast with
1118 : test_applying_fixits_insert_after_at_line_end above. */
1119 :
1120 : static void
1121 96 : test_applying_fixits_insert_after_failure (const line_table_case &case_)
1122 : {
1123 : /* Create a tempfile and write some text to it.
1124 : .........................0000000001111111.
1125 : .........................1234567890123456. */
1126 96 : const char *old_content = ("/* before */\n"
1127 : "foo = bar.field;\n"
1128 : "/* after */\n");
1129 96 : temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
1130 96 : const char *filename = tmp.get_filename ();
1131 96 : line_table_test ltt (case_);
1132 96 : linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 2);
1133 :
1134 : /* Add a comment after the semicolon. */
1135 96 : location_t loc = linemap_position_for_column (line_table, 16);
1136 96 : rich_location richloc (line_table, loc);
1137 :
1138 : /* We want a failure of linemap_position_for_loc_and_offset.
1139 : We can do this by starting a new linemap at line 3, so that
1140 : there is no appropriate location value for the insertion point
1141 : within the linemap for line 2. */
1142 96 : linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 3);
1143 :
1144 : /* The failure fails to happen at the transition point from
1145 : packed ranges to unpacked ranges (where there are some "spare"
1146 : location_t values). Skip the test there. */
1147 96 : if (loc >= LINE_MAP_MAX_LOCATION_WITH_PACKED_RANGES)
1148 76 : return;
1149 :
1150 : /* Offsetting "loc" should now fail (by returning the input loc. */
1151 20 : ASSERT_EQ (loc, linemap_position_for_loc_and_offset (line_table, loc, 1));
1152 :
1153 : /* Hence attempting to use add_fixit_insert_after at the end of the line
1154 : should now fail. */
1155 20 : richloc.add_fixit_insert_after ("/* inserted */");
1156 20 : ASSERT_TRUE (richloc.seen_impossible_fixit_p ());
1157 :
1158 20 : file_cache fc;
1159 20 : change_set edit (fc);
1160 20 : edit.add_fixits (&richloc);
1161 20 : ASSERT_FALSE (edit.valid_p ());
1162 20 : ASSERT_EQ (NULL, edit.get_content (filename));
1163 20 : ASSERT_EQ (NULL, edit.generate_diff (false));
1164 96 : }
1165 :
1166 : /* Test applying an "insert" fixit that adds a newline. */
1167 :
1168 : static void
1169 96 : test_applying_fixits_insert_containing_newline (const line_table_case &case_)
1170 : {
1171 : /* Create a tempfile and write some text to it.
1172 : .........................0000000001111111.
1173 : .........................1234567890123456. */
1174 96 : const char *old_content = (" case 'a':\n" /* line 1. */
1175 : " x = a;\n" /* line 2. */
1176 : " case 'b':\n" /* line 3. */
1177 : " x = b;\n");/* line 4. */
1178 :
1179 96 : temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
1180 96 : const char *filename = tmp.get_filename ();
1181 96 : line_table_test ltt (case_);
1182 96 : linemap_add (line_table, LC_ENTER, false, tmp.get_filename (), 3);
1183 :
1184 : /* Add a "break;" on a line by itself before line 3 i.e. before
1185 : column 1 of line 3. */
1186 96 : location_t case_start = linemap_position_for_column (line_table, 5);
1187 96 : location_t case_finish = linemap_position_for_column (line_table, 13);
1188 96 : location_t case_loc = make_location (case_start, case_start, case_finish);
1189 96 : rich_location richloc (line_table, case_loc);
1190 96 : location_t line_start = linemap_position_for_column (line_table, 1);
1191 96 : richloc.add_fixit_insert_before (line_start, " break;\n");
1192 :
1193 96 : if (case_finish > LINE_MAP_MAX_LOCATION_WITH_COLS)
1194 32 : return;
1195 :
1196 64 : file_cache fc;
1197 64 : change_set edit (fc);
1198 64 : edit.add_fixits (&richloc);
1199 64 : auto_free <char *> new_content = edit.get_content (filename);
1200 64 : ASSERT_STREQ ((" case 'a':\n"
1201 : " x = a;\n"
1202 : " break;\n"
1203 : " case 'b':\n"
1204 : " x = b;\n"),
1205 : new_content);
1206 :
1207 : /* Verify diff. */
1208 64 : auto_free <char *> diff = edit.generate_diff (false);
1209 64 : ASSERT_STREQ (("@@ -1,4 +1,5 @@\n"
1210 : " case 'a':\n"
1211 : " x = a;\n"
1212 : "+ break;\n"
1213 : " case 'b':\n"
1214 : " x = b;\n"),
1215 : diff);
1216 96 : }
1217 :
1218 : /* Test applying a "replace" fixit that grows the affected line. */
1219 :
1220 : static void
1221 96 : test_applying_fixits_growing_replace (const line_table_case &case_)
1222 : {
1223 : /* Create a tempfile and write some text to it.
1224 : .........................0000000001111111.
1225 : .........................1234567890123456. */
1226 96 : const char *old_content = ("/* before */\n"
1227 : "foo = bar.field;\n"
1228 : "/* after */\n");
1229 96 : temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
1230 96 : const char *filename = tmp.get_filename ();
1231 96 : line_table_test ltt (case_);
1232 96 : linemap_add (line_table, LC_ENTER, false, filename, 2);
1233 :
1234 : /* Replace "field" with "m_field". */
1235 96 : location_t start = linemap_position_for_column (line_table, 11);
1236 96 : location_t finish = linemap_position_for_column (line_table, 15);
1237 96 : location_t field = make_location (start, start, finish);
1238 96 : rich_location richloc (line_table, field);
1239 96 : richloc.add_fixit_replace ("m_field");
1240 :
1241 96 : file_cache fc;
1242 96 : change_set edit (fc);
1243 96 : edit.add_fixits (&richloc);
1244 96 : auto_free <char *> new_content = edit.get_content (filename);
1245 96 : if (finish <= LINE_MAP_MAX_LOCATION_WITH_COLS)
1246 : {
1247 64 : ASSERT_STREQ ("/* before */\n"
1248 : "foo = bar.m_field;\n"
1249 : "/* after */\n", new_content);
1250 :
1251 : /* Verify location of ";" after the change. */
1252 64 : ASSERT_EQ (18, edit.get_effective_column (filename, 2, 16));
1253 :
1254 : /* Verify diff. */
1255 64 : auto_free <char *> diff = edit.generate_diff (false);
1256 64 : ASSERT_STREQ ("@@ -1,3 +1,3 @@\n"
1257 : " /* before */\n"
1258 : "-foo = bar.field;\n"
1259 : "+foo = bar.m_field;\n"
1260 : " /* after */\n", diff);
1261 64 : }
1262 96 : }
1263 :
1264 : /* Test applying a "replace" fixit that shrinks the affected line. */
1265 :
1266 : static void
1267 96 : test_applying_fixits_shrinking_replace (const line_table_case &case_)
1268 : {
1269 : /* Create a tempfile and write some text to it.
1270 : .........................000000000111111111.
1271 : .........................123456789012345678. */
1272 96 : const char *old_content = ("/* before */\n"
1273 : "foo = bar.m_field;\n"
1274 : "/* after */\n");
1275 96 : temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
1276 96 : const char *filename = tmp.get_filename ();
1277 96 : line_table_test ltt (case_);
1278 96 : linemap_add (line_table, LC_ENTER, false, filename, 2);
1279 :
1280 : /* Replace "field" with "m_field". */
1281 96 : location_t start = linemap_position_for_column (line_table, 11);
1282 96 : location_t finish = linemap_position_for_column (line_table, 17);
1283 96 : location_t m_field = make_location (start, start, finish);
1284 96 : rich_location richloc (line_table, m_field);
1285 96 : richloc.add_fixit_replace ("field");
1286 :
1287 96 : file_cache fc;
1288 96 : change_set edit (fc);
1289 96 : edit.add_fixits (&richloc);
1290 96 : auto_free <char *> new_content = edit.get_content (filename);
1291 96 : if (finish <= LINE_MAP_MAX_LOCATION_WITH_COLS)
1292 : {
1293 64 : ASSERT_STREQ ("/* before */\n"
1294 : "foo = bar.field;\n"
1295 : "/* after */\n", new_content);
1296 :
1297 : /* Verify location of ";" after the change. */
1298 64 : ASSERT_EQ (16, edit.get_effective_column (filename, 2, 18));
1299 :
1300 : /* Verify diff. */
1301 64 : auto_free <char *> diff = edit.generate_diff (false);
1302 64 : ASSERT_STREQ ("@@ -1,3 +1,3 @@\n"
1303 : " /* before */\n"
1304 : "-foo = bar.m_field;\n"
1305 : "+foo = bar.field;\n"
1306 : " /* after */\n", diff);
1307 64 : }
1308 96 : }
1309 :
1310 : /* Replacement fix-it hint containing a newline. */
1311 :
1312 : static void
1313 96 : test_applying_fixits_replace_containing_newline (const line_table_case &case_)
1314 : {
1315 : /* Create a tempfile and write some text to it.
1316 : .........................0000000001111.
1317 : .........................1234567890123. */
1318 96 : const char *old_content = "foo = bar ();\n";
1319 :
1320 96 : temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
1321 96 : const char *filename = tmp.get_filename ();
1322 96 : line_table_test ltt (case_);
1323 96 : linemap_add (line_table, LC_ENTER, false, filename, 1);
1324 :
1325 : /* Replace the " = " with "\n = ", as if we were reformatting an
1326 : overly long line. */
1327 96 : location_t start = linemap_position_for_column (line_table, 4);
1328 96 : location_t finish = linemap_position_for_column (line_table, 6);
1329 96 : location_t loc = linemap_position_for_column (line_table, 13);
1330 96 : rich_location richloc (line_table, loc);
1331 96 : source_range range = source_range::from_locations (start, finish);
1332 96 : richloc.add_fixit_replace (range, "\n = ");
1333 :
1334 : /* Newlines are only supported within fix-it hints that
1335 : are at the start of lines (for entirely new lines), hence
1336 : this fix-it should not be displayed. */
1337 96 : ASSERT_TRUE (richloc.seen_impossible_fixit_p ());
1338 :
1339 96 : if (finish > LINE_MAP_MAX_LOCATION_WITH_COLS)
1340 32 : return;
1341 :
1342 64 : file_cache fc;
1343 64 : change_set edit (fc);
1344 64 : edit.add_fixits (&richloc);
1345 64 : auto_free <char *> new_content = edit.get_content (filename);
1346 : //ASSERT_STREQ ("foo\n = bar ();\n", new_content);
1347 96 : }
1348 :
1349 : /* Test applying a "remove" fixit. */
1350 :
1351 : static void
1352 96 : test_applying_fixits_remove (const line_table_case &case_)
1353 : {
1354 : /* Create a tempfile and write some text to it.
1355 : .........................000000000111111111.
1356 : .........................123456789012345678. */
1357 96 : const char *old_content = ("/* before */\n"
1358 : "foo = bar.m_field;\n"
1359 : "/* after */\n");
1360 96 : temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
1361 96 : const char *filename = tmp.get_filename ();
1362 96 : line_table_test ltt (case_);
1363 96 : linemap_add (line_table, LC_ENTER, false, filename, 2);
1364 :
1365 : /* Remove ".m_field". */
1366 96 : location_t start = linemap_position_for_column (line_table, 10);
1367 96 : location_t finish = linemap_position_for_column (line_table, 17);
1368 96 : rich_location richloc (line_table, start);
1369 96 : source_range range;
1370 96 : range.m_start = start;
1371 96 : range.m_finish = finish;
1372 96 : richloc.add_fixit_remove (range);
1373 :
1374 96 : file_cache fc;
1375 96 : change_set edit (fc);
1376 96 : edit.add_fixits (&richloc);
1377 96 : auto_free <char *> new_content = edit.get_content (filename);
1378 96 : if (finish <= LINE_MAP_MAX_LOCATION_WITH_COLS)
1379 : {
1380 64 : ASSERT_STREQ ("/* before */\n"
1381 : "foo = bar;\n"
1382 : "/* after */\n", new_content);
1383 :
1384 : /* Verify location of ";" after the change. */
1385 64 : ASSERT_EQ (10, edit.get_effective_column (filename, 2, 18));
1386 :
1387 : /* Verify diff. */
1388 64 : auto_free <char *> diff = edit.generate_diff (false);
1389 64 : ASSERT_STREQ ("@@ -1,3 +1,3 @@\n"
1390 : " /* before */\n"
1391 : "-foo = bar.m_field;\n"
1392 : "+foo = bar;\n"
1393 : " /* after */\n", diff);
1394 64 : }
1395 96 : }
1396 :
1397 : /* Test applying multiple fixits to one line. */
1398 :
1399 : static void
1400 96 : test_applying_fixits_multiple (const line_table_case &case_)
1401 : {
1402 : /* Create a tempfile and write some text to it.
1403 : .........................00000000011111111.
1404 : .........................12345678901234567. */
1405 96 : const char *old_content = ("/* before */\n"
1406 : "foo = bar.field;\n"
1407 : "/* after */\n");
1408 96 : temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
1409 96 : const char *filename = tmp.get_filename ();
1410 96 : line_table_test ltt (case_);
1411 96 : linemap_add (line_table, LC_ENTER, false, filename, 2);
1412 :
1413 96 : location_t c7 = linemap_position_for_column (line_table, 7);
1414 96 : location_t c9 = linemap_position_for_column (line_table, 9);
1415 96 : location_t c11 = linemap_position_for_column (line_table, 11);
1416 96 : location_t c15 = linemap_position_for_column (line_table, 15);
1417 96 : location_t c17 = linemap_position_for_column (line_table, 17);
1418 :
1419 96 : if (c17 > LINE_MAP_MAX_LOCATION_WITH_COLS)
1420 32 : return;
1421 :
1422 : /* Add a comment in front of "bar.field". */
1423 64 : rich_location insert_a (line_table, c7);
1424 64 : insert_a.add_fixit_insert_before (c7, "/* alpha */");
1425 :
1426 : /* Add a comment after "bar.field;". */
1427 64 : rich_location insert_b (line_table, c17);
1428 64 : insert_b.add_fixit_insert_before (c17, "/* beta */");
1429 :
1430 : /* Replace "bar" with "pub". */
1431 64 : rich_location replace_a (line_table, c7);
1432 64 : replace_a.add_fixit_replace (source_range::from_locations (c7, c9),
1433 : "pub");
1434 :
1435 : /* Replace "field" with "meadow". */
1436 64 : rich_location replace_b (line_table, c7);
1437 64 : replace_b.add_fixit_replace (source_range::from_locations (c11, c15),
1438 : "meadow");
1439 :
1440 64 : file_cache fc;
1441 64 : change_set edit (fc);
1442 64 : edit.add_fixits (&insert_a);
1443 64 : ASSERT_EQ (100, edit.get_effective_column (filename, 1, 100));
1444 64 : ASSERT_EQ (1, edit.get_effective_column (filename, 2, 1));
1445 64 : ASSERT_EQ (6, edit.get_effective_column (filename, 2, 6));
1446 64 : ASSERT_EQ (18, edit.get_effective_column (filename, 2, 7));
1447 64 : ASSERT_EQ (27, edit.get_effective_column (filename, 2, 16));
1448 64 : ASSERT_EQ (100, edit.get_effective_column (filename, 3, 100));
1449 :
1450 64 : edit.add_fixits (&insert_b);
1451 64 : edit.add_fixits (&replace_a);
1452 64 : edit.add_fixits (&replace_b);
1453 :
1454 64 : if (c17 <= LINE_MAP_MAX_LOCATION_WITH_COLS)
1455 : {
1456 64 : auto_free <char *> new_content = edit.get_content (tmp.get_filename ());
1457 64 : ASSERT_STREQ ("/* before */\n"
1458 : "foo = /* alpha */pub.meadow;/* beta */\n"
1459 : "/* after */\n",
1460 : new_content);
1461 :
1462 : /* Verify diff. */
1463 64 : auto_free <char *> diff = edit.generate_diff (false);
1464 64 : ASSERT_STREQ ("@@ -1,3 +1,3 @@\n"
1465 : " /* before */\n"
1466 : "-foo = bar.field;\n"
1467 : "+foo = /* alpha */pub.meadow;/* beta */\n"
1468 : " /* after */\n", diff);
1469 64 : }
1470 96 : }
1471 :
1472 : /* Subroutine of test_applying_fixits_multiple_lines.
1473 : Add the text "CHANGED: " to the front of the given line. */
1474 :
1475 : static location_t
1476 576 : change_line (change_set &edit, int line_num)
1477 : {
1478 576 : const line_map_ordinary *ord_map
1479 576 : = LINEMAPS_LAST_ORDINARY_MAP (line_table);
1480 576 : const int column = 1;
1481 576 : location_t loc =
1482 576 : linemap_position_for_line_and_column (line_table, ord_map,
1483 : line_num, column);
1484 :
1485 576 : expanded_location exploc = expand_location (loc);
1486 576 : if (loc <= LINE_MAP_MAX_LOCATION_WITH_COLS)
1487 : {
1488 344 : ASSERT_EQ (line_num, exploc.line);
1489 344 : ASSERT_EQ (column, exploc.column);
1490 : }
1491 :
1492 576 : rich_location insert (line_table, loc);
1493 576 : insert.add_fixit_insert_before ("CHANGED: ");
1494 576 : edit.add_fixits (&insert);
1495 1152 : return loc;
1496 576 : }
1497 :
1498 : /* Subroutine of test_applying_fixits_multiple_lines.
1499 : Add the text "INSERTED\n" in front of the given line. */
1500 :
1501 : static location_t
1502 96 : insert_line (change_set &edit, int line_num)
1503 : {
1504 96 : const line_map_ordinary *ord_map
1505 96 : = LINEMAPS_LAST_ORDINARY_MAP (line_table);
1506 96 : const int column = 1;
1507 96 : location_t loc =
1508 96 : linemap_position_for_line_and_column (line_table, ord_map,
1509 : line_num, column);
1510 :
1511 96 : expanded_location exploc = expand_location (loc);
1512 96 : if (loc <= LINE_MAP_MAX_LOCATION_WITH_COLS)
1513 : {
1514 56 : ASSERT_EQ (line_num, exploc.line);
1515 56 : ASSERT_EQ (column, exploc.column);
1516 : }
1517 :
1518 96 : rich_location insert (line_table, loc);
1519 96 : insert.add_fixit_insert_before ("INSERTED\n");
1520 96 : edit.add_fixits (&insert);
1521 192 : return loc;
1522 96 : }
1523 :
1524 : /* Test of editing multiple lines within a long file,
1525 : to ensure that diffs are generated as expected. */
1526 :
1527 : static void
1528 96 : test_applying_fixits_multiple_lines (const line_table_case &case_)
1529 : {
1530 : /* Create a tempfile and write many lines of text to it. */
1531 96 : named_temp_file tmp (".txt");
1532 96 : const char *filename = tmp.get_filename ();
1533 96 : FILE *f = fopen (filename, "w");
1534 96 : ASSERT_NE (f, NULL);
1535 96096 : for (int i = 1; i <= 1000; i++)
1536 96000 : fprintf (f, "line %i\n", i);
1537 96 : fclose (f);
1538 :
1539 96 : line_table_test ltt (case_);
1540 96 : linemap_add (line_table, LC_ENTER, false, filename, 1);
1541 96 : linemap_position_for_column (line_table, 127);
1542 :
1543 96 : file_cache fc;
1544 96 : change_set edit (fc);
1545 :
1546 : /* A run of consecutive lines. */
1547 96 : change_line (edit, 2);
1548 96 : change_line (edit, 3);
1549 96 : change_line (edit, 4);
1550 96 : insert_line (edit, 5);
1551 :
1552 : /* A run of nearby lines, within the contextual limit. */
1553 96 : change_line (edit, 150);
1554 96 : change_line (edit, 151);
1555 96 : location_t last_loc = change_line (edit, 153);
1556 :
1557 96 : if (last_loc > LINE_MAP_MAX_LOCATION_WITH_COLS)
1558 40 : return;
1559 :
1560 : /* Verify diff. */
1561 56 : auto_free <char *> diff = edit.generate_diff (false);
1562 56 : ASSERT_STREQ ("@@ -1,7 +1,8 @@\n"
1563 : " line 1\n"
1564 : "-line 2\n"
1565 : "-line 3\n"
1566 : "-line 4\n"
1567 : "+CHANGED: line 2\n"
1568 : "+CHANGED: line 3\n"
1569 : "+CHANGED: line 4\n"
1570 : "+INSERTED\n"
1571 : " line 5\n"
1572 : " line 6\n"
1573 : " line 7\n"
1574 : "@@ -147,10 +148,10 @@\n"
1575 : " line 147\n"
1576 : " line 148\n"
1577 : " line 149\n"
1578 : "-line 150\n"
1579 : "-line 151\n"
1580 : "+CHANGED: line 150\n"
1581 : "+CHANGED: line 151\n"
1582 : " line 152\n"
1583 : "-line 153\n"
1584 : "+CHANGED: line 153\n"
1585 : " line 154\n"
1586 : " line 155\n"
1587 : " line 156\n", diff);
1588 :
1589 : /* Ensure tmp stays alive until this point, so that the tempfile
1590 : persists until after the generate_diff call. */
1591 56 : tmp.get_filename ();
1592 96 : }
1593 :
1594 : /* Test of converting an initializer for a named field from
1595 : the old GCC extension to C99 syntax.
1596 : Exercises a shrinking replacement followed by a growing
1597 : replacement on the same line. */
1598 :
1599 : static void
1600 96 : test_applying_fixits_modernize_named_init (const line_table_case &case_)
1601 : {
1602 : /* Create a tempfile and write some text to it.
1603 : .........................00000000011111111.
1604 : .........................12345678901234567. */
1605 96 : const char *old_content = ("/* before */\n"
1606 : "bar : 1,\n"
1607 : "/* after */\n");
1608 96 : temp_source_file tmp (SELFTEST_LOCATION, ".c", old_content);
1609 96 : const char *filename = tmp.get_filename ();
1610 96 : line_table_test ltt (case_);
1611 96 : linemap_add (line_table, LC_ENTER, false, filename, 2);
1612 :
1613 96 : location_t c1 = linemap_position_for_column (line_table, 1);
1614 96 : location_t c3 = linemap_position_for_column (line_table, 3);
1615 96 : location_t c8 = linemap_position_for_column (line_table, 8);
1616 :
1617 96 : if (c8 > LINE_MAP_MAX_LOCATION_WITH_COLS)
1618 32 : return;
1619 :
1620 : /* Replace "bar" with ".". */
1621 64 : rich_location r1 (line_table, c8);
1622 64 : r1.add_fixit_replace (source_range::from_locations (c1, c3),
1623 : ".");
1624 :
1625 : /* Replace ":" with "bar =". */
1626 64 : rich_location r2 (line_table, c8);
1627 64 : r2.add_fixit_replace (source_range::from_locations (c8, c8),
1628 : "bar =");
1629 :
1630 : /* The order should not matter. Do r1 then r2. */
1631 64 : {
1632 64 : file_cache fc;
1633 64 : change_set edit (fc);
1634 64 : edit.add_fixits (&r1);
1635 :
1636 : /* Verify state after first replacement. */
1637 64 : {
1638 64 : auto_free <char *> new_content = edit.get_content (tmp.get_filename ());
1639 : /* We should now have:
1640 : ............00000000011.
1641 : ............12345678901. */
1642 64 : ASSERT_STREQ ("/* before */\n"
1643 : ". : 1,\n"
1644 : "/* after */\n",
1645 : new_content);
1646 : /* Location of the "1". */
1647 64 : ASSERT_EQ (6, edit.get_effective_column (filename, 2, 8));
1648 : /* Location of the ",". */
1649 64 : ASSERT_EQ (9, edit.get_effective_column (filename, 2, 11));
1650 64 : }
1651 :
1652 64 : edit.add_fixits (&r2);
1653 :
1654 64 : auto_free <char *> new_content = edit.get_content (tmp.get_filename ());
1655 : /* Verify state after second replacement.
1656 : ............00000000011111111.
1657 : ............12345678901234567. */
1658 64 : ASSERT_STREQ ("/* before */\n"
1659 : ". bar = 1,\n"
1660 : "/* after */\n",
1661 : new_content);
1662 64 : }
1663 :
1664 : /* Try again, doing r2 then r1; the new_content should be the same. */
1665 64 : {
1666 64 : file_cache fc;
1667 64 : change_set edit (fc);
1668 64 : edit.add_fixits (&r2);
1669 64 : edit.add_fixits (&r1);
1670 64 : auto_free <char *> new_content = edit.get_content (tmp.get_filename ());
1671 : /*.............00000000011111111.
1672 : .............12345678901234567. */
1673 64 : ASSERT_STREQ ("/* before */\n"
1674 : ". bar = 1,\n"
1675 : "/* after */\n",
1676 : new_content);
1677 64 : }
1678 96 : }
1679 :
1680 : /* Test of a fixit affecting a file that can't be read. */
1681 :
1682 : static void
1683 4 : test_applying_fixits_unreadable_file ()
1684 : {
1685 4 : const char *filename = "this-does-not-exist.txt";
1686 4 : line_table_test ltt;
1687 4 : linemap_add (line_table, LC_ENTER, false, filename, 1);
1688 :
1689 4 : location_t loc = linemap_position_for_column (line_table, 1);
1690 :
1691 4 : rich_location insert (line_table, loc);
1692 4 : insert.add_fixit_insert_before ("change 1");
1693 4 : insert.add_fixit_insert_before ("change 2");
1694 :
1695 4 : file_cache fc;
1696 4 : change_set edit (fc);
1697 : /* Attempting to add the fixits affecting the unreadable file
1698 : should transition the edit from valid to invalid. */
1699 4 : ASSERT_TRUE (edit.valid_p ());
1700 4 : edit.add_fixits (&insert);
1701 4 : ASSERT_FALSE (edit.valid_p ());
1702 4 : ASSERT_EQ (NULL, edit.get_content (filename));
1703 4 : ASSERT_EQ (NULL, edit.generate_diff (false));
1704 4 : }
1705 :
1706 : /* Verify that we gracefully handle an attempt to edit a line
1707 : that's beyond the end of the file. */
1708 :
1709 : static void
1710 4 : test_applying_fixits_line_out_of_range ()
1711 : {
1712 : /* Create a tempfile and write some text to it.
1713 : ........................00000000011111111.
1714 : ........................12345678901234567. */
1715 4 : const char *old_content = "One-liner file\n";
1716 4 : temp_source_file tmp (SELFTEST_LOCATION, ".txt", old_content);
1717 4 : const char *filename = tmp.get_filename ();
1718 4 : line_table_test ltt;
1719 4 : linemap_add (line_table, LC_ENTER, false, filename, 2);
1720 :
1721 : /* Try to insert a string in line 2. */
1722 4 : location_t loc = linemap_position_for_column (line_table, 1);
1723 :
1724 4 : rich_location insert (line_table, loc);
1725 4 : insert.add_fixit_insert_before ("change");
1726 :
1727 : /* Verify that attempting the insertion puts an change_set
1728 : into an invalid state. */
1729 4 : file_cache fc;
1730 4 : change_set edit (fc);
1731 4 : ASSERT_TRUE (edit.valid_p ());
1732 4 : edit.add_fixits (&insert);
1733 4 : ASSERT_FALSE (edit.valid_p ());
1734 4 : ASSERT_EQ (NULL, edit.get_content (filename));
1735 4 : ASSERT_EQ (NULL, edit.generate_diff (false));
1736 4 : }
1737 :
1738 : /* Verify the boundary conditions of column values in fix-it
1739 : hints applied to change_set instances. */
1740 :
1741 : static void
1742 96 : test_applying_fixits_column_validation (const line_table_case &case_)
1743 : {
1744 : /* Create a tempfile and write some text to it.
1745 : ........................00000000011111111.
1746 : ........................12345678901234567. */
1747 96 : const char *old_content = "One-liner file\n";
1748 96 : temp_source_file tmp (SELFTEST_LOCATION, ".txt", old_content);
1749 96 : const char *filename = tmp.get_filename ();
1750 96 : line_table_test ltt (case_);
1751 96 : linemap_add (line_table, LC_ENTER, false, filename, 1);
1752 :
1753 96 : location_t c11 = linemap_position_for_column (line_table, 11);
1754 96 : location_t c14 = linemap_position_for_column (line_table, 14);
1755 96 : location_t c15 = linemap_position_for_column (line_table, 15);
1756 96 : location_t c16 = linemap_position_for_column (line_table, 16);
1757 :
1758 : /* Verify limits of valid columns in insertion fixits. */
1759 :
1760 : /* Verify inserting at the end of the line. */
1761 96 : {
1762 96 : rich_location richloc (line_table, c11);
1763 96 : richloc.add_fixit_insert_before (c15, " change");
1764 :
1765 : /* Col 15 is at the end of the line, so the insertion
1766 : should succeed. */
1767 96 : file_cache fc;
1768 96 : change_set edit (fc);
1769 96 : edit.add_fixits (&richloc);
1770 96 : auto_free <char *> new_content = edit.get_content (tmp.get_filename ());
1771 96 : if (c15 <= LINE_MAP_MAX_LOCATION_WITH_COLS)
1772 64 : ASSERT_STREQ ("One-liner file change\n", new_content);
1773 : else
1774 32 : ASSERT_EQ (NULL, new_content);
1775 96 : }
1776 :
1777 : /* Verify inserting beyond the end of the line. */
1778 96 : {
1779 96 : rich_location richloc (line_table, c11);
1780 96 : richloc.add_fixit_insert_before (c16, " change");
1781 :
1782 : /* Col 16 is beyond the end of the line, so the insertion
1783 : should fail gracefully. */
1784 96 : file_cache fc;
1785 96 : change_set edit (fc);
1786 96 : ASSERT_TRUE (edit.valid_p ());
1787 96 : edit.add_fixits (&richloc);
1788 96 : ASSERT_FALSE (edit.valid_p ());
1789 96 : ASSERT_EQ (NULL, edit.get_content (filename));
1790 96 : ASSERT_EQ (NULL, edit.generate_diff (false));
1791 96 : }
1792 :
1793 : /* Verify limits of valid columns in replacement fixits. */
1794 :
1795 : /* Verify replacing the end of the line. */
1796 96 : {
1797 96 : rich_location richloc (line_table, c11);
1798 96 : source_range range = source_range::from_locations (c11, c14);
1799 96 : richloc.add_fixit_replace (range, "change");
1800 :
1801 : /* Col 14 is at the end of the line, so the replacement
1802 : should succeed. */
1803 96 : file_cache fc;
1804 96 : change_set edit (fc);
1805 96 : edit.add_fixits (&richloc);
1806 96 : auto_free <char *> new_content = edit.get_content (tmp.get_filename ());
1807 96 : if (c14 <= LINE_MAP_MAX_LOCATION_WITH_COLS)
1808 64 : ASSERT_STREQ ("One-liner change\n", new_content);
1809 : else
1810 32 : ASSERT_EQ (NULL, new_content);
1811 96 : }
1812 :
1813 : /* Verify going beyond the end of the line. */
1814 96 : {
1815 96 : rich_location richloc (line_table, c11);
1816 96 : source_range range = source_range::from_locations (c11, c15);
1817 96 : richloc.add_fixit_replace (range, "change");
1818 :
1819 : /* Col 15 is after the end of the line, so the replacement
1820 : should fail; verify that the attempt fails gracefully. */
1821 96 : file_cache fc;
1822 96 : change_set edit (fc);
1823 96 : ASSERT_TRUE (edit.valid_p ());
1824 96 : edit.add_fixits (&richloc);
1825 96 : ASSERT_FALSE (edit.valid_p ());
1826 96 : ASSERT_EQ (NULL, edit.get_content (filename));
1827 96 : ASSERT_EQ (NULL, edit.generate_diff (false));
1828 96 : }
1829 96 : }
1830 :
1831 : static void
1832 4 : run_all_tests ()
1833 : {
1834 4 : test_get_content ();
1835 4 : for_each_line_table_case (test_applying_fixits_insert_before);
1836 4 : for_each_line_table_case (test_applying_fixits_insert_after);
1837 4 : for_each_line_table_case (test_applying_fixits_insert_after_at_line_end);
1838 4 : for_each_line_table_case (test_applying_fixits_insert_after_failure);
1839 4 : for_each_line_table_case (test_applying_fixits_insert_containing_newline);
1840 4 : for_each_line_table_case (test_applying_fixits_growing_replace);
1841 4 : for_each_line_table_case (test_applying_fixits_shrinking_replace);
1842 4 : for_each_line_table_case (test_applying_fixits_replace_containing_newline);
1843 4 : for_each_line_table_case (test_applying_fixits_remove);
1844 4 : for_each_line_table_case (test_applying_fixits_multiple);
1845 4 : for_each_line_table_case (test_applying_fixits_multiple_lines);
1846 4 : for_each_line_table_case (test_applying_fixits_modernize_named_init);
1847 4 : test_applying_fixits_unreadable_file ();
1848 4 : test_applying_fixits_line_out_of_range ();
1849 4 : for_each_line_table_case (test_applying_fixits_column_validation);
1850 4 : }
1851 :
1852 : } // namespace diagnostics::changes::selftest
1853 :
1854 : #endif /* CHECKING_P */
1855 :
1856 : } // namespace diagnostics::changes
1857 :
1858 : #if CHECKING_P
1859 :
1860 : namespace selftest { // diagnostics::selftest
1861 :
1862 : /* Run all of the selftests within this file. */
1863 :
1864 : void
1865 4 : changes_cc_tests ()
1866 : {
1867 4 : diagnostics::changes::selftest::run_all_tests ();
1868 4 : }
1869 :
1870 : } // namespace selftest
1871 :
1872 : #endif /* CHECKING_P */
1873 :
1874 : } // namespace diagnostics
|
