1 /* Implementation of -Wmisleading-indentation
2 Copyright (C) 2015-2017 Free Software Foundation, Inc.
4 This file is part of GCC.
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
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
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/>. */
22 #include "coretypes.h"
25 #include "c-indentation.h"
27 extern cpp_options
*cpp_opts
;
29 /* Round up VIS_COLUMN to nearest tab stop. */
32 next_tab_stop (unsigned int vis_column
)
34 const unsigned int tab_width
= cpp_opts
->tabstop
;
35 vis_column
= ((vis_column
+ tab_width
) / tab_width
) * tab_width
;
39 /* Convert libcpp's notion of a column (a 1-based char count) to
40 the "visual column" (0-based column, respecting tabs), by reading the
43 Returns true if a conversion was possible, writing the result to OUT,
44 otherwise returns false. If FIRST_NWS is not NULL, then write to it
45 the visual column corresponding to the first non-whitespace character
49 get_visual_column (expanded_location exploc
, location_t loc
,
51 unsigned int *first_nws
)
53 /* PR c++/68819: if the column number is zero, we presumably
54 had a location_t > LINE_MAP_MAX_LOCATION_WITH_COLS, and so
55 we have no column information.
56 Act as if no conversion was possible, triggering the
57 error-handling path in the caller. */
60 static bool issued_note
= false;
63 /* Notify the user the first time this happens. */
66 "-Wmisleading-indentation is disabled from this point"
67 " onwards, since column-tracking was disabled due to"
68 " the size of the code/headers");
74 const char *line
= location_get_source_line (exploc
.file
, exploc
.line
,
78 unsigned int vis_column
= 0;
79 for (int i
= 1; i
< exploc
.column
; i
++)
81 unsigned char ch
= line
[i
- 1];
83 if (first_nws
!= NULL
&& !ISSPACE (ch
))
85 *first_nws
= vis_column
;
90 vis_column
= next_tab_stop (vis_column
);
95 if (first_nws
!= NULL
)
96 *first_nws
= vis_column
;
102 /* Attempt to determine the first non-whitespace character in line LINE_NUM
105 If this is possible, return true and write its "visual column" to
107 Otherwise, return false, leaving *FIRST_NWS untouched. */
110 get_first_nws_vis_column (const char *file
, int line_num
,
111 unsigned int *first_nws
)
113 gcc_assert (first_nws
);
116 const char *line
= location_get_source_line (file
, line_num
, &line_len
);
119 unsigned int vis_column
= 0;
120 for (int i
= 1; i
< line_len
; i
++)
122 unsigned char ch
= line
[i
- 1];
126 *first_nws
= vis_column
;
131 vis_column
= next_tab_stop (vis_column
);
136 /* No non-whitespace characters found. */
140 /* Determine if there is an unindent/outdent between
141 BODY_EXPLOC and NEXT_STMT_EXPLOC, to ensure that we don't
142 issue a warning for cases like the following:
144 (1) Preprocessor logic
149 #if SOME_CONDITION_THAT_DOES_NOT_HOLD
155 "bar ();" is visually aligned below "foo ();" and
156 is (as far as the parser sees) the next token, but
157 this isn't misleading to a human reader.
159 (2) Empty macro with bad indentation
161 In the following, the
163 is poorly indented, and ought to be on the same column as
164 "engine_ref_debug(e, 0, -1)"
165 However, it is not misleadingly indented, due to the presence
168 #define engine_ref_debug(X, Y, Z)
174 engine_ref_debug(e, 0, -1)
178 Return true if such an unindent/outdent is detected. */
181 detect_intervening_unindent (const char *file
,
184 unsigned int vis_column
)
187 gcc_assert (next_stmt_line
> body_line
);
189 for (int line
= body_line
+ 1; line
< next_stmt_line
; line
++)
191 unsigned int line_vis_column
;
192 if (get_first_nws_vis_column (file
, line
, &line_vis_column
))
193 if (line_vis_column
< vis_column
)
202 /* Helper function for warn_for_misleading_indentation; see
203 description of that function below. */
206 should_warn_for_misleading_indentation (const token_indent_info
&guard_tinfo
,
207 const token_indent_info
&body_tinfo
,
208 const token_indent_info
&next_tinfo
)
210 location_t guard_loc
= guard_tinfo
.location
;
211 location_t body_loc
= body_tinfo
.location
;
212 location_t next_stmt_loc
= next_tinfo
.location
;
214 enum cpp_ttype body_type
= body_tinfo
.type
;
215 enum cpp_ttype next_tok_type
= next_tinfo
.type
;
217 /* Don't attempt to compare the indentation of BODY_LOC and NEXT_STMT_LOC
218 if either are within macros. */
219 if (linemap_location_from_macro_expansion_p (line_table
, body_loc
)
220 || linemap_location_from_macro_expansion_p (line_table
, next_stmt_loc
))
223 /* Don't attempt to compare indentation if #line or # 44 "file"-style
224 directives are present, suggesting generated code.
226 All bets are off if these are present: the file that the #line
227 directive could have an entirely different coding layout to C/C++
230 To determine if a #line is present, in theory we could look for a
231 map with reason == LC_RENAME_VERBATIM. However, if there has
232 subsequently been a long line requiring a column number larger than
233 that representable by the original LC_RENAME_VERBATIM map, then
234 we'll have a map with reason LC_RENAME.
235 Rather than attempting to search all of the maps for a
236 LC_RENAME_VERBATIM, instead we have libcpp set a flag whenever one
237 is seen, and we check for the flag here.
239 if (line_table
->seen_line_directive
)
242 /* We can't usefully warn about do-while and switch statements since the
243 bodies of these statements are always explicitly delimited at both ends,
244 so control flow is quite obvious. */
245 if (guard_tinfo
.keyword
== RID_DO
246 || guard_tinfo
.keyword
== RID_SWITCH
)
249 /* If the token following the body is a close brace or an "else"
250 then while indentation may be sloppy, there is not much ambiguity
251 about control flow, e.g.
263 if (next_tok_type
== CPP_CLOSE_BRACE
264 || next_tinfo
.keyword
== RID_ELSE
)
267 /* Likewise, if the body of the guard is a compound statement then control
268 flow is quite visually explicit regardless of the code's possibly poor
277 Things only get muddy when the body of the guard does not have
284 if (body_type
== CPP_OPEN_BRACE
)
287 /* Don't warn here about spurious semicolons. */
288 if (next_tok_type
== CPP_SEMICOLON
)
291 expanded_location body_exploc
= expand_location (body_loc
);
292 expanded_location next_stmt_exploc
= expand_location (next_stmt_loc
);
293 expanded_location guard_exploc
= expand_location (guard_loc
);
295 /* They must be in the same file. */
296 if (next_stmt_exploc
.file
!= body_exploc
.file
)
299 /* If NEXT_STMT_LOC and BODY_LOC are on the same line, consider
300 the location of the guard.
302 Cases where we want to issue a warning:
308 if (flag) foo (); bar ();
319 Cases where we don't want to issue a warning:
321 various_code (); if (flag) foo (); bar (); more_code ();
322 ^ DON'T WARN HERE. */
323 if (next_stmt_exploc
.line
== body_exploc
.line
)
325 if (guard_exploc
.file
!= body_exploc
.file
)
327 if (guard_exploc
.line
< body_exploc
.line
)
328 /* The guard is on a line before a line that contains both
329 the body and the next stmt. */
331 else if (guard_exploc
.line
== body_exploc
.line
)
333 /* They're all on the same line. */
334 gcc_assert (guard_exploc
.file
== next_stmt_exploc
.file
);
335 gcc_assert (guard_exploc
.line
== next_stmt_exploc
.line
);
336 unsigned int guard_vis_column
;
337 unsigned int guard_line_first_nws
;
338 if (!get_visual_column (guard_exploc
, guard_loc
,
340 &guard_line_first_nws
))
342 /* Heuristic: only warn if the guard is the first thing
344 if (guard_vis_column
== guard_line_first_nws
)
349 /* If NEXT_STMT_LOC is on a line after BODY_LOC, consider
350 their relative locations, and of the guard.
352 Cases where we want to issue a warning:
358 Cases where we don't want to issue a warning:
362 ^ DON'T WARN HERE (autogenerated code?)
366 #if SOME_CONDITION_THAT_DOES_NOT_HOLD
384 if (next_stmt_exploc
.line
> body_exploc
.line
)
386 /* Determine if GUARD_LOC and NEXT_STMT_LOC are aligned on the same
387 "visual column"... */
388 unsigned int next_stmt_vis_column
;
389 unsigned int next_stmt_line_first_nws
;
390 unsigned int body_vis_column
;
391 unsigned int body_line_first_nws
;
392 unsigned int guard_vis_column
;
393 unsigned int guard_line_first_nws
;
394 /* If we can't determine it, don't issue a warning. This is sometimes
395 the case for input files containing #line directives, and these
396 are often for autogenerated sources (e.g. from .md files), where
397 it's not clear that it's meaningful to look at indentation. */
398 if (!get_visual_column (next_stmt_exploc
, next_stmt_loc
,
399 &next_stmt_vis_column
,
400 &next_stmt_line_first_nws
))
402 if (!get_visual_column (body_exploc
, body_loc
,
404 &body_line_first_nws
))
406 if (!get_visual_column (guard_exploc
, guard_loc
,
408 &guard_line_first_nws
))
411 /* If the line where the next stmt starts has non-whitespace
412 on it before the stmt, then don't warn:
419 if (next_stmt_line_first_nws
< next_stmt_vis_column
)
422 if ((body_type
!= CPP_SEMICOLON
423 && next_stmt_vis_column
== body_vis_column
)
424 /* As a special case handle the case where the body is a semicolon
425 that may be hidden by a preceding comment, e.g. */
431 /* by looking instead at the column of the first non-whitespace
432 character on the body line. */
433 || (body_type
== CPP_SEMICOLON
434 && body_exploc
.line
> guard_exploc
.line
435 && body_line_first_nws
!= body_vis_column
436 && next_stmt_vis_column
> guard_line_first_nws
))
438 /* Don't warn if they are aligned on the same column
439 as the guard itself (suggesting autogenerated code that doesn't
440 bother indenting at all).
441 For "else" clauses, we consider the column of the first
442 non-whitespace character on the guard line instead of the column
443 of the actual guard token itself because it is more sensible.
460 If we just used the column of the "else" token, we would warn on
461 the first example and not warn on the second. But we want the
462 exact opposite to happen: to not warn on the first example (which
463 is probably autogenerated) and to warn on the second (whose
464 indentation is misleading). Using the column of the first
465 non-whitespace character on the guard line makes that
467 unsigned int guard_column
= (guard_tinfo
.keyword
== RID_ELSE
468 ? guard_line_first_nws
470 if (guard_column
== body_vis_column
)
473 /* We may have something like:
482 in which case the columns are not aligned but the code is not
483 misleadingly indented. If the column of the body isn't indented
484 more than the guard line then don't warn. */
485 if (body_vis_column
<= guard_line_first_nws
)
488 /* Don't warn if there is an unindent between the two statements. */
489 int vis_column
= MIN (next_stmt_vis_column
, body_vis_column
);
490 if (detect_intervening_unindent (body_exploc
.file
, body_exploc
.line
,
491 next_stmt_exploc
.line
,
495 /* Otherwise, they are visually aligned: issue a warning. */
499 /* Also issue a warning for code having the form:
519 where the semicolon at the end of each guard is most likely spurious.
526 where the next statement is aligned with the guard.
528 if (body_type
== CPP_SEMICOLON
)
530 if (body_exploc
.line
== guard_exploc
.line
)
532 if (next_stmt_vis_column
> guard_line_first_nws
533 || (next_tok_type
== CPP_OPEN_BRACE
534 && next_stmt_vis_column
== guard_line_first_nws
))
543 /* Return the string identifier corresponding to the given guard token. */
546 guard_tinfo_to_string (const token_indent_info
&guard_tinfo
)
548 switch (guard_tinfo
.keyword
)
565 /* Called by the C/C++ frontends when we have a guarding statement at
566 GUARD_LOC containing a statement at BODY_LOC, where the block wasn't
567 written using braces, like this:
572 along with the location of the next token, at NEXT_STMT_LOC,
573 so that we can detect followup statements that are within
574 the same "visual block" as the guarded statement, but which
575 aren't logically grouped within the guarding statement, such
583 bar (); <- NEXT_STMT_LOC
585 In the above, "bar ();" isn't guarded by the "if", but
586 is indented to misleadingly suggest that it is in the same
589 GUARD_KIND identifies the kind of clause e.g. "if", "else" etc. */
592 warn_for_misleading_indentation (const token_indent_info
&guard_tinfo
,
593 const token_indent_info
&body_tinfo
,
594 const token_indent_info
&next_tinfo
)
596 /* Early reject for the case where -Wmisleading-indentation is disabled,
597 to avoid doing work only to have the warning suppressed inside the
598 diagnostic machinery. */
599 if (!warn_misleading_indentation
)
602 if (should_warn_for_misleading_indentation (guard_tinfo
,
606 if (warning_at (guard_tinfo
.location
, OPT_Wmisleading_indentation
,
607 "this %qs clause does not guard...",
608 guard_tinfo_to_string (guard_tinfo
)))
609 inform (next_tinfo
.location
,
610 "...this statement, but the latter is misleadingly indented"
611 " as if it were guarded by the %qs",
612 guard_tinfo_to_string (guard_tinfo
));