1 /* Implementation of -Wmisleading-indentation
2 Copyright (C) 2015-2018 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");
73 char_span line
= location_get_source_line (exploc
.file
, exploc
.line
);
76 unsigned int vis_column
= 0;
77 for (int i
= 1; i
< exploc
.column
; i
++)
79 unsigned char ch
= line
[i
- 1];
81 if (first_nws
!= NULL
&& !ISSPACE (ch
))
83 *first_nws
= vis_column
;
88 vis_column
= next_tab_stop (vis_column
);
93 if (first_nws
!= NULL
)
94 *first_nws
= vis_column
;
100 /* Attempt to determine the first non-whitespace character in line LINE_NUM
103 If this is possible, return true and write its "visual column" to
105 Otherwise, return false, leaving *FIRST_NWS untouched. */
108 get_first_nws_vis_column (const char *file
, int line_num
,
109 unsigned int *first_nws
)
111 gcc_assert (first_nws
);
113 char_span line
= location_get_source_line (file
, line_num
);
116 unsigned int vis_column
= 0;
117 for (size_t i
= 1; i
< line
.length (); i
++)
119 unsigned char ch
= line
[i
- 1];
123 *first_nws
= vis_column
;
128 vis_column
= next_tab_stop (vis_column
);
133 /* No non-whitespace characters found. */
137 /* Determine if there is an unindent/outdent between
138 BODY_EXPLOC and NEXT_STMT_EXPLOC, to ensure that we don't
139 issue a warning for cases like the following:
141 (1) Preprocessor logic
146 #if SOME_CONDITION_THAT_DOES_NOT_HOLD
152 "bar ();" is visually aligned below "foo ();" and
153 is (as far as the parser sees) the next token, but
154 this isn't misleading to a human reader.
156 (2) Empty macro with bad indentation
158 In the following, the
160 is poorly indented, and ought to be on the same column as
161 "engine_ref_debug(e, 0, -1)"
162 However, it is not misleadingly indented, due to the presence
165 #define engine_ref_debug(X, Y, Z)
171 engine_ref_debug(e, 0, -1)
175 Return true if such an unindent/outdent is detected. */
178 detect_intervening_unindent (const char *file
,
181 unsigned int vis_column
)
184 gcc_assert (next_stmt_line
> body_line
);
186 for (int line
= body_line
+ 1; line
< next_stmt_line
; line
++)
188 unsigned int line_vis_column
;
189 if (get_first_nws_vis_column (file
, line
, &line_vis_column
))
190 if (line_vis_column
< vis_column
)
199 /* Helper function for warn_for_misleading_indentation; see
200 description of that function below. */
203 should_warn_for_misleading_indentation (const token_indent_info
&guard_tinfo
,
204 const token_indent_info
&body_tinfo
,
205 const token_indent_info
&next_tinfo
)
207 location_t guard_loc
= guard_tinfo
.location
;
208 location_t body_loc
= body_tinfo
.location
;
209 location_t next_stmt_loc
= next_tinfo
.location
;
211 enum cpp_ttype body_type
= body_tinfo
.type
;
212 enum cpp_ttype next_tok_type
= next_tinfo
.type
;
214 /* Don't attempt to compare the indentation of BODY_LOC and NEXT_STMT_LOC
215 if either are within macros. */
216 if (linemap_location_from_macro_expansion_p (line_table
, body_loc
)
217 || linemap_location_from_macro_expansion_p (line_table
, next_stmt_loc
))
220 /* Don't attempt to compare indentation if #line or # 44 "file"-style
221 directives are present, suggesting generated code.
223 All bets are off if these are present: the file that the #line
224 directive could have an entirely different coding layout to C/C++
227 To determine if a #line is present, in theory we could look for a
228 map with reason == LC_RENAME_VERBATIM. However, if there has
229 subsequently been a long line requiring a column number larger than
230 that representable by the original LC_RENAME_VERBATIM map, then
231 we'll have a map with reason LC_RENAME.
232 Rather than attempting to search all of the maps for a
233 LC_RENAME_VERBATIM, instead we have libcpp set a flag whenever one
234 is seen, and we check for the flag here.
236 if (line_table
->seen_line_directive
)
239 /* We can't usefully warn about do-while and switch statements since the
240 bodies of these statements are always explicitly delimited at both ends,
241 so control flow is quite obvious. */
242 if (guard_tinfo
.keyword
== RID_DO
243 || guard_tinfo
.keyword
== RID_SWITCH
)
246 /* If the token following the body is a close brace or an "else"
247 then while indentation may be sloppy, there is not much ambiguity
248 about control flow, e.g.
260 if (next_tok_type
== CPP_CLOSE_BRACE
261 || next_tinfo
.keyword
== RID_ELSE
)
264 /* Likewise, if the body of the guard is a compound statement then control
265 flow is quite visually explicit regardless of the code's possibly poor
274 Things only get muddy when the body of the guard does not have
281 if (body_type
== CPP_OPEN_BRACE
)
284 /* Don't warn here about spurious semicolons. */
285 if (next_tok_type
== CPP_SEMICOLON
)
288 expanded_location body_exploc
= expand_location (body_loc
);
289 expanded_location next_stmt_exploc
= expand_location (next_stmt_loc
);
290 expanded_location guard_exploc
= expand_location (guard_loc
);
292 /* They must be in the same file. */
293 if (next_stmt_exploc
.file
!= body_exploc
.file
)
296 /* If NEXT_STMT_LOC and BODY_LOC are on the same line, consider
297 the location of the guard.
299 Cases where we want to issue a warning:
305 if (flag) foo (); bar ();
316 Cases where we don't want to issue a warning:
318 various_code (); if (flag) foo (); bar (); more_code ();
319 ^ DON'T WARN HERE. */
320 if (next_stmt_exploc
.line
== body_exploc
.line
)
322 if (guard_exploc
.file
!= body_exploc
.file
)
324 if (guard_exploc
.line
< body_exploc
.line
)
325 /* The guard is on a line before a line that contains both
326 the body and the next stmt. */
328 else if (guard_exploc
.line
== body_exploc
.line
)
330 /* They're all on the same line. */
331 gcc_assert (guard_exploc
.file
== next_stmt_exploc
.file
);
332 gcc_assert (guard_exploc
.line
== next_stmt_exploc
.line
);
333 unsigned int guard_vis_column
;
334 unsigned int guard_line_first_nws
;
335 if (!get_visual_column (guard_exploc
, guard_loc
,
337 &guard_line_first_nws
))
339 /* Heuristic: only warn if the guard is the first thing
341 if (guard_vis_column
== guard_line_first_nws
)
346 /* If NEXT_STMT_LOC is on a line after BODY_LOC, consider
347 their relative locations, and of the guard.
349 Cases where we want to issue a warning:
355 Cases where we don't want to issue a warning:
359 ^ DON'T WARN HERE (autogenerated code?)
363 #if SOME_CONDITION_THAT_DOES_NOT_HOLD
381 if (next_stmt_exploc
.line
> body_exploc
.line
)
383 /* Determine if GUARD_LOC and NEXT_STMT_LOC are aligned on the same
384 "visual column"... */
385 unsigned int next_stmt_vis_column
;
386 unsigned int next_stmt_line_first_nws
;
387 unsigned int body_vis_column
;
388 unsigned int body_line_first_nws
;
389 unsigned int guard_vis_column
;
390 unsigned int guard_line_first_nws
;
391 /* If we can't determine it, don't issue a warning. This is sometimes
392 the case for input files containing #line directives, and these
393 are often for autogenerated sources (e.g. from .md files), where
394 it's not clear that it's meaningful to look at indentation. */
395 if (!get_visual_column (next_stmt_exploc
, next_stmt_loc
,
396 &next_stmt_vis_column
,
397 &next_stmt_line_first_nws
))
399 if (!get_visual_column (body_exploc
, body_loc
,
401 &body_line_first_nws
))
403 if (!get_visual_column (guard_exploc
, guard_loc
,
405 &guard_line_first_nws
))
408 /* If the line where the next stmt starts has non-whitespace
409 on it before the stmt, then don't warn:
416 if (next_stmt_line_first_nws
< next_stmt_vis_column
)
419 if ((body_type
!= CPP_SEMICOLON
420 && next_stmt_vis_column
== body_vis_column
)
421 /* As a special case handle the case where the body is a semicolon
422 that may be hidden by a preceding comment, e.g. */
428 /* by looking instead at the column of the first non-whitespace
429 character on the body line. */
430 || (body_type
== CPP_SEMICOLON
431 && body_exploc
.line
> guard_exploc
.line
432 && body_line_first_nws
!= body_vis_column
433 && next_stmt_vis_column
> guard_line_first_nws
))
435 /* Don't warn if they are aligned on the same column
436 as the guard itself (suggesting autogenerated code that doesn't
437 bother indenting at all).
438 For "else" clauses, we consider the column of the first
439 non-whitespace character on the guard line instead of the column
440 of the actual guard token itself because it is more sensible.
457 If we just used the column of the "else" token, we would warn on
458 the first example and not warn on the second. But we want the
459 exact opposite to happen: to not warn on the first example (which
460 is probably autogenerated) and to warn on the second (whose
461 indentation is misleading). Using the column of the first
462 non-whitespace character on the guard line makes that
464 unsigned int guard_column
= (guard_tinfo
.keyword
== RID_ELSE
465 ? guard_line_first_nws
467 if (guard_column
== body_vis_column
)
470 /* We may have something like:
479 in which case the columns are not aligned but the code is not
480 misleadingly indented. If the column of the body isn't indented
481 more than the guard line then don't warn. */
482 if (body_vis_column
<= guard_line_first_nws
)
485 /* Don't warn if there is an unindent between the two statements. */
486 int vis_column
= MIN (next_stmt_vis_column
, body_vis_column
);
487 if (detect_intervening_unindent (body_exploc
.file
, body_exploc
.line
,
488 next_stmt_exploc
.line
,
492 /* Otherwise, they are visually aligned: issue a warning. */
496 /* Also issue a warning for code having the form:
516 where the semicolon at the end of each guard is most likely spurious.
523 where the next statement is aligned with the guard.
525 if (body_type
== CPP_SEMICOLON
)
527 if (body_exploc
.line
== guard_exploc
.line
)
529 if (next_stmt_vis_column
> guard_line_first_nws
530 || (next_tok_type
== CPP_OPEN_BRACE
531 && next_stmt_vis_column
== guard_line_first_nws
))
540 /* Return the string identifier corresponding to the given guard token. */
543 guard_tinfo_to_string (enum rid keyword
)
564 /* Called by the C/C++ frontends when we have a guarding statement at
565 GUARD_LOC containing a statement at BODY_LOC, where the block wasn't
566 written using braces, like this:
571 along with the location of the next token, at NEXT_STMT_LOC,
572 so that we can detect followup statements that are within
573 the same "visual block" as the guarded statement, but which
574 aren't logically grouped within the guarding statement, such
582 bar (); <- NEXT_STMT_LOC
584 In the above, "bar ();" isn't guarded by the "if", but
585 is indented to misleadingly suggest that it is in the same
588 GUARD_KIND identifies the kind of clause e.g. "if", "else" etc. */
591 warn_for_misleading_indentation (const token_indent_info
&guard_tinfo
,
592 const token_indent_info
&body_tinfo
,
593 const token_indent_info
&next_tinfo
)
595 /* Early reject for the case where -Wmisleading-indentation is disabled,
596 to avoid doing work only to have the warning suppressed inside the
597 diagnostic machinery. */
598 if (!warn_misleading_indentation
)
601 if (should_warn_for_misleading_indentation (guard_tinfo
,
605 if (warning_at (guard_tinfo
.location
, OPT_Wmisleading_indentation
,
606 "this %qs clause does not guard...",
607 guard_tinfo_to_string (guard_tinfo
.keyword
)))
608 inform (next_tinfo
.location
,
609 "...this statement, but the latter is misleadingly indented"
610 " as if it were guarded by the %qs",
611 guard_tinfo_to_string (guard_tinfo
.keyword
));