On Thu, 2015-04-16 at 10:26 -0700, Mike Stump wrote:
> On Apr 16, 2015, at 8:01 AM, David Malcolm <dmalc...@redhat.com> wrote:
> > Attached is a work-in-progress patch for a new
> > -Wmisleading-indentation
> > warning I've been experimenting with, for GCC 6.
>
> Seems like a nice idea in general.
>
> Does it also handle:
>
> if (cone);
> stmt;
>
> ? Would be good to add that to the test suite, as that is another hard to
> spot common error that should be caught.
Not yet, but I agree that it would be a good thing to issue a warning
for.
> I do think that it is reasonable to warn for things like:
>
> stmt;
> stmt;
>
> one of those two lines is likely misindented, though, maybe you want to start
> with the high payback things first.
> > An issue here is how to determine (i), or if it's OK to default to 8
>
> Yes, 8 is the proper value to default it to.
>
> > and have a command-line option (param?) to override it? (though what about,
> > say, each header file?)
>
> I’ll abstain from this. The purist in me says no option for other
> than 8, life goes on. 20 years ago, someone was confused over hard v
> soft tabbing and what exactly the editor key TAB does. That confusion
> is over, the 8 people have won. Catering to other than 8 gives the
> impression that the people that lost still have a chance at
> winning. :-)
>
> > Thoughts on this, and on the patch?
>
> Would be nice to have a stricter version that warns about all wildly
> inconsistently or wrongly indented lines.
>
> {
> stmt;
> stmt; // must be same as above
> }
>
> {
> stmt; // must be indented at least 1
> }
>
> if (cond)
> stmt; // must be indented at least 1
I think I want to make a distinction between
(A) classic C "gotchas", like the one in my mail and the:
if (cond);
stmt;
one you mentioned above
vs
(B) wrong/inconsistent indentation.
I think (A) is high-value, since it detects subtly wrong code, likely to
have misled the reader, whereas I don't find (B) as interesting. I
think (A) is "misleading", whereas (B) is "wrong"; the ugliness of the
(B) cases tends to give me a "this code is ugly; beware, danger Will
Robinson!" reaction, whereas (A) is less ugly and thus more dangerous.
(if that makes sense; this may just be my own visceral reaction to the
erroneous code).
Or to put it another way, I hope to make (A) good enough to go into
-Wall, whereas I think (B) would meet more resistance.
Also, I think autogenerated code is more likely to run into (B) than
(A).
I have the patch working now for the C++ frontend. Am attaching the
work-in-progress (sans ChangeLog). This one (v2) bootstrapped and
regrtested on x86_64-unknown-linux-gnu (Fedora 20), with:
63 new "PASS" results in gcc.sum
189 new "PASS" results in g++.sum
for the new test cases (relative to a control build of r222248).
I also moved the visual-parser.c/h to c-family, to make use of the
-ftabstop option Tom mentioned in another mail.
I also made it identify the kind of clause, so error messages say things
like:
./Wmisleading-indentation-1.c:10:7: warning: statement is indented as if
it were guarded by... [-Wmisleading-indentation]
./Wmisleading-indentation-1.c:8:3: note: ...this 'if' clause, but it is
not
which makes it easier to read, especially when dealing with nesting.
This hasn't yet had any performance/leak fixes so it isn't ready as is.
I plan to look at making it warn about the:
if (cond);
stmt;
gotcha next, before trying to optimize it.
(and no ChangeLog yet)
Dave
diff --git a/gcc/Makefile.in b/gcc/Makefile.in
index 80c91f0..8154469 100644
--- a/gcc/Makefile.in
+++ b/gcc/Makefile.in
@@ -1143,7 +1143,8 @@ C_COMMON_OBJS = c-family/c-common.o c-family/c-cppbuiltin.o c-family/c-dump.o \
c-family/c-ppoutput.o c-family/c-pragma.o c-family/c-pretty-print.o \
c-family/c-semantics.o c-family/c-ada-spec.o \
c-family/c-cilkplus.o \
- c-family/array-notation-common.o c-family/cilk.o c-family/c-ubsan.o
+ c-family/array-notation-common.o c-family/cilk.o c-family/c-ubsan.o \
+ c-family/visual-parser.o
# Language-independent object files.
# We put the insn-*.o files first so that a parallel make will build
diff --git a/gcc/c-family/c.opt b/gcc/c-family/c.opt
index 983f4a8..88f1f94 100644
--- a/gcc/c-family/c.opt
+++ b/gcc/c-family/c.opt
@@ -554,6 +554,10 @@ Wmemset-transposed-args
C ObjC C++ ObjC++ Var(warn_memset_transposed_args) Warning LangEnabledBy(C ObjC C++ ObjC++,Wall)
Warn about suspicious calls to memset where the third argument is constant literal zero and the second is not
+Wmisleading-indentation
+C C++ Common Var(warn_misleading_indentation) Warning
+Warn when the indentation of the code does not reflect the block structure
+
Wmissing-braces
C ObjC C++ ObjC++ Var(warn_missing_braces) Warning LangEnabledBy(C ObjC,Wall)
Warn about possibly missing braces around initializers
diff --git a/gcc/c-family/visual-parser.c b/gcc/c-family/visual-parser.c
new file mode 100644
index 0000000..b1fcb8b
--- /dev/null
+++ b/gcc/c-family/visual-parser.c
@@ -0,0 +1,337 @@
+/* "Visual parser" for detecting misleading indentation.
+ Copyright (C) 2015 Free Software Foundation, Inc.
+ Contributed by David Malcolm <dmalc...@redhat.com>.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h" /* For rtl.h: needs enum reg_class. */
+#include "hash-set.h"
+#include "machmode.h"
+#include "vec.h"
+#include "double-int.h"
+#include "input.h"
+#include "alias.h"
+#include "symtab.h"
+#include "wide-int.h"
+#include "inchash.h"
+#include "tree.h"
+#include "stringpool.h"
+#include "attribs.h"
+#include "stor-layout.h"
+#include "varasm.h"
+#include "trans-mem.h"
+#include "langhooks.h"
+#include "input.h"
+#include "cpplib.h"
+#include "timevar.h"
+#include "c-family/c-pragma.h"
+#include "flags.h"
+#include "ggc.h"
+#include "vec.h"
+#include "target.h"
+#include "visual-parser.h"
+#include "diagnostic-core.h"
+#include "tree-iterator.h"
+
+extern cpp_options *cpp_opts;
+
+/* Ptr to the singleton instance of visual_parser. */
+visual_parser *vis_parser;
+
+/* The ctor for visual_parser. */
+visual_parser::visual_parser ()
+{
+ m_debug = false;
+ m_last_xloc.file = NULL;
+ m_last_xloc.line = 0;
+ m_last_xloc.column = 0;
+}
+
+static expanded_location
+expand_location_with_visual_column (location_t loc)
+{
+ /* Get file/line info. */
+ expanded_location xloc = expand_location (loc);
+
+ /* Convert libcpp's notion of a column (a 1-based char count) to
+ the "visual column" (respecting tabs), by reading the
+ relevant line. */
+ int line_len;
+ const char *line = location_get_source_line (xloc, &line_len);
+ int vis_column = 0;
+ for (int i = 1; i < xloc.column; i++)
+ {
+ unsigned char ch = line[i - 1];
+ if (ch == '\t')
+ {
+ /* Round up to nearest tab stop. */
+ const unsigned int tab_width = cpp_opts->tabstop;
+ vis_column = ((vis_column + tab_width) * tab_width) / tab_width;
+ }
+ else
+ vis_column++;
+ }
+
+ xloc.column = vis_column;
+ //inform (loc, "vis column is %i", vis_column);
+ return xloc;
+}
+
+/* Token-handling. This takes a stream of locations, examining their
+ spelling locations, and calling on_indent, on_line, on_outdent
+ accordingly. */
+
+void
+visual_parser::on_token (location_t loc)
+{
+ if (m_debug)
+ inform (loc, "on_token");
+
+ /* TODO: only do the perhaps-expensive vis_column work if the line changed? */
+ expanded_location xloc = expand_location_with_visual_column (loc);
+ if (xloc.line != m_last_xloc.line)
+ {
+ //inform (loc, "first token on new line");
+ visual_block *curblock = get_stack_top ();
+ if (curblock)
+ {
+ /* FIXME: what about entirely empty lines???
+ Presumably they simply don't get tokens. */
+ int last_indent = curblock->get_column ();
+ if (xloc.column > last_indent)
+ {
+ /* This line starts more indented than any current
+ indentation level; begin a new "visual block". */
+ visual_block *block = new visual_block (loc, xloc.column);
+ if (m_debug)
+ inform (loc, "new visual block here: %p", (void *)block);
+ m_block_stack.safe_push (block);
+ on_indent (loc);
+ }
+ else if (xloc.column == last_indent)
+ {
+ /* This line is at the same indentation level as before,
+ within the current "visual block". */
+ on_line (loc);
+ }
+ else
+ {
+ /* We have some amount of outdenting; how much? */
+ while (m_block_stack.length ())
+ {
+ visual_block *block = m_block_stack.pop ();
+ if (m_debug)
+ inform (block->get_location (),
+ "closing visual block %p", (void *)block);
+ on_outdent (loc);
+ visual_block *new_top = get_stack_top ();
+ if (new_top)
+ if (new_top->get_column () <= xloc.column)
+ {
+ if (m_debug)
+ inform (new_top->get_location (),
+ "outdented to within visual block %p",
+ (void *)new_top);
+ break;
+ }
+ }
+ }
+ }
+ else
+ {
+ /* No current indentation level; start one. */
+ visual_block *block = new visual_block (loc, xloc.column);
+ m_block_stack.safe_push (block);
+ on_indent (loc);
+ }
+ }
+ m_last_xloc = xloc;
+}
+
+/* Called when we have a token that's on a new line that's more indented
+ than the token that began the last line. */
+void
+visual_parser::on_indent (location_t loc)
+{
+ if (m_debug)
+ inform (loc, "on_indent");
+}
+
+/* Called when we have a token that's on a new line that's less indented
+ than the token that began the last line. */
+
+void
+visual_parser::on_outdent (location_t loc)
+{
+ if (m_debug)
+ inform (loc, "on_outdent");
+}
+
+/* Called for the first token on a new line that's at the same indentation
+ level as the previous line. */
+void
+visual_parser::on_line (location_t loc)
+{
+ if (m_debug)
+ inform (loc, "on_line");
+ visual_block *curblock = get_stack_top ();
+ curblock->on_line (loc);
+}
+
+/* FIXME. */
+visual_block *
+visual_parser::get_block_containing_loc (location_t loc) const
+{
+ int i;
+ visual_block *vis_block;
+ visual_block *candidate = NULL;
+ FOR_EACH_VEC_ELT(m_block_stack, i, vis_block)
+ if (vis_block->get_location () <= loc)
+ candidate = vis_block;
+ else
+ break;
+
+ return candidate;
+}
+
+/* Called by the C/C++ FE when we have a guarding statement at GUARD_LOC
+ containing BLOCK, where the block wasn't written using braces, like
+ this:
+
+ guard-loc
+ |
+ V
+ if (flag)
+ foo (); <--BLOCK
+
+ so that we can detect followup statements that are within
+ the same "visual block" as the guarded statement, but which
+ aren't logically grouped within the guarding statement, such
+ as:
+
+ if (flag)
+ foo ();
+ bar ();
+
+ In the above, "bar ();" isn't guarded by the "if", but
+ misleading is in the same visual block as "foo ();". */
+
+void
+visual_parser::on_solo_stmt (tree block, location_t guard_loc,
+ const char *guard_kind)
+{
+ /* Locate the visual block containing the solo-stmt, and mark
+ it as such. */
+
+ tree_stmt_iterator tsi = tsi_start (block);
+ tree stmt = tsi_stmt (tsi);
+ location_t loc_solo_stmt = EXPR_LOCATION (stmt);
+ visual_block *vis_block = get_block_containing_loc (loc_solo_stmt);
+
+ vis_block->on_solo_stmt (stmt, guard_loc, guard_kind);
+}
+
+/* See comment above for visual_parser::on_solo_stmt.
+ Mark the visual block containing the solo statement STMT as
+ (supposedly) only containing a solo statement. */
+
+void
+visual_block::on_solo_stmt (tree stmt, location_t guard_loc,
+ const char *guard_kind)
+{
+ m_loc_solo_stmt = EXPR_LOCATION (stmt);
+ m_loc_guard = guard_loc;
+
+ m_exploc_solo_stmt
+ = expand_location_with_visual_column (m_loc_solo_stmt);
+ m_exploc_guard
+ = expand_location_with_visual_column (guard_loc);
+
+ /* If the solo-stmt is on a new line and more indented than
+ the guard location, mark the current visual block (which
+ presumably contains the solo stmt) for checking.
+ Doing this rejects cases such as
+ if (foo) bar (); baz ();
+ where it's not clear whether or not we ought to warn about
+ "baz ();" and hence we don't. */
+ if (m_exploc_solo_stmt.file == m_exploc_guard.file)
+ if (m_exploc_solo_stmt.line > m_exploc_guard.line)
+ if (m_exploc_solo_stmt.column > m_exploc_guard.column)
+ {
+ if (0)
+ {
+ inform (m_loc,
+ "visual_block here (this=%p)", (void *)this);
+ inform (m_loc_solo_stmt,
+ "solo statement here (this=%p)", (void *)this);
+ inform (m_loc_guard,
+ "visually guarded here (this=%p)", (void *)this);
+ }
+ m_has_solo_stmt = true;
+ m_guard_kind = guard_kind;
+ }
+}
+
+/* Check NEW_STMT for misleading indentation.
+ Called when adding NEW_STMT to a statement list.
+
+ If we have a solo statement, and we're in the same
+ visual block, and NEW_STMT is visually after the
+ solo statement, then NEW_STMT is misleadingly indented as
+ if were guarded by the guard, but it isn't.
+ Issue a warning for such a statement. */
+
+void
+visual_parser::check_stmt (tree new_stmt)
+{
+ if (m_debug)
+ inform (EXPR_LOCATION (new_stmt), "check_stmt");
+ get_stack_top ()->check_stmt (new_stmt);
+}
+
+/* See comment above for visual_parser::check_stmt. */
+
+void
+visual_block::check_stmt (tree new_stmt)
+{
+ if (!m_has_solo_stmt)
+ return;
+
+ location_t loc_new_stmt = EXPR_LOCATION (new_stmt);
+ //inform (loc_new_stmt, "checking stmt here");
+
+ expanded_location exploc_new_stmt
+ = expand_location_with_visual_column (loc_new_stmt);
+
+ if (exploc_new_stmt.file == m_exploc_guard.file)
+ {
+ if (/* Statement is visually after the guarded stmt. */
+ (exploc_new_stmt.line == m_exploc_solo_stmt.line
+ && exploc_new_stmt.column > m_exploc_solo_stmt.column)
+ || (exploc_new_stmt.line > m_exploc_solo_stmt.line))
+ if (warning_at (loc_new_stmt,
+ OPT_Wmisleading_indentation,
+ "statement is indented as if it"
+ " were guarded by..."))
+ inform (m_loc_guard,
+ "...this '%s' clause, but it is not",
+ m_guard_kind);
+ }
+}
diff --git a/gcc/c-family/visual-parser.h b/gcc/c-family/visual-parser.h
new file mode 100644
index 0000000..bbc0483
--- /dev/null
+++ b/gcc/c-family/visual-parser.h
@@ -0,0 +1,172 @@
+/* "Visual parser" for detecting misleading indentation.
+ Copyright (C) 2015 Free Software Foundation, Inc.
+ Contributed by David Malcolm <dmalc...@redhat.com>.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
+
+/* Forward declaration. */
+class visual_block;
+
+/* A "visual parser" for detecting misleading indentation.
+
+ This is fed three things by the frontend:
+
+ (A) a series of location_t by the frontend's tokenizer,
+ corresponding to the locations of the token stream. It uses
+ this to model a stack of "visual blocks", corresponding to
+ indentation levels within the source code.
+ For example:
+
+ Source VBlock # VBlock stack
+ ------ -------- ------------
+ void 0 [b0]
+ foo (int i) 0 [b0]
+ { 0 [b0]
+ int j; .1 [b0, b1]
+ if (i) .1 [b0, b1]
+ { ..2 [b0, b1, b2]
+ foo (0); ...3 [b0, b1, b2, b3]
+ bar (0); ...3 [b0, b1, b2, b3]
+ } ..2 [b0, b1, b2]
+ else .1 [b0, b1]
+ foo (1); ..4 [b0, b1, b4]
+ bar (1); ..4 [b0, b1, b4] <-- WARNING!
+ } 0 [b0]
+
+ Note how the call to "bar (1);" called out with "WARNING!" is
+ indented as if it's in the same block as the call to "foo (1);",
+ guarded by the "else" (both are in visual block 4), but they are
+ *not* in the same actual block as far as the real frontend
+ (and language standards) see it.
+ The purpose of this class is to issue a warning about this
+ misleading indentation.
+
+ (2) The frontend notifies the class about "solo statements", that
+ is, non-compound statements guarded by control-flow statements,
+ such as "foo (1);", a non-compound statement guarded by the else
+ clause. Misleading indentation can occur in the statement
+ immediately following such a non-compound statement, if the
+ successor statement is indented in the same way
+ (i.e. it is within the same visual block).
+
+ (3) The frontend notifiees the class about statements being added
+ to a statement list. If we have a guarded non-compound statement,
+ the new statements can be checked for misleading indentation.
+
+ Note that we can't simply use statement locations; for example, in:
+ if (flag)
+ x = 1;
+ the "if (flag)"'s location is at the open-paren, and that of the
+ assignment "x = 1;" is at the equals-sign, so any attempt to use
+ statement locations can be fooled by varying the spacing:
+
+ V
+ if (flag)
+ x = 1;
+ ^ apparent indentation relative to conditional
+
+ V
+ if (flag)
+ x = 1;
+ ^ same column as conditional
+
+ V
+ if (flag)
+ x = 1;
+ ^ apparent "outdent" relative to conditional
+
+ Hence we have to use token locations. */
+
+class GTY(()) visual_parser {
+ public:
+ visual_parser ();
+ void on_token (location_t loc);
+ void on_solo_stmt (tree block, location_t guard_loc,
+ const char *guard_kind);
+ void check_stmt (tree stmt);
+
+ private:
+ void on_newline (location_t loc);
+
+ void on_indent (location_t loc);
+ void on_outdent (location_t loc);
+ void on_line (location_t loc);
+
+ visual_block * get_stack_top () const
+ {
+ if (m_block_stack.length ())
+ return m_block_stack[m_block_stack.length () - 1];
+ else
+ return NULL;
+ }
+
+ visual_block * get_block_containing_loc (location_t loc) const;
+
+ private:
+ bool m_debug;
+ expanded_location m_last_xloc;
+ /* A stack of indentation levels. */
+ auto_vec<visual_block *> m_block_stack;
+};
+
+/* A visual block: a run of lines with the same initial indentation. */
+
+class visual_block
+{
+ public:
+ visual_block (location_t loc, int column_start)
+ : m_loc (loc),
+ m_loc_last_line (loc),
+ m_column_start (column_start),
+ m_has_solo_stmt (false)
+ {}
+
+ location_t get_location () const { return m_loc; }
+ location_t get_last_location () const { return m_loc_last_line; }
+ int get_column () const { return m_column_start; }
+
+ void on_line (location_t loc) { m_loc_last_line = loc; }
+
+ void on_solo_stmt (tree stmt, location_t guard_loc,
+ const char *guard_kind);
+ void check_stmt (tree stmt);
+
+ private:
+ location_t m_loc;
+ location_t m_loc_last_line;
+ int m_column_start;
+
+ /* Detection of misleading indentation.
+ If m_has_solo_stmt is true, then this visual
+ block contains a "solo statement" i.e. one within a block
+ created without braces, such as:
+ if (flag) <- guard
+ foo (); <- solo stmt in this visblock
+ Any followup statements that are in the same visual block as
+ "foo ();" are therefore misleadingly indented. */
+ bool m_has_solo_stmt;
+ const char *m_guard_kind;
+ location_t m_loc_solo_stmt;
+ location_t m_loc_guard;
+ expanded_location m_exploc_solo_stmt;
+ expanded_location m_exploc_guard;
+
+};
+
+/* The singleton instance of the visual_parser, created by the
+ C/C++ frontend if -Wmisleading-indentation is enabled. */
+extern visual_parser *vis_parser;
diff --git a/gcc/c/c-decl.c b/gcc/c/c-decl.c
index e28a294..ec7a0a4 100644
--- a/gcc/c/c-decl.c
+++ b/gcc/c/c-decl.c
@@ -81,6 +81,7 @@ along with GCC; see the file COPYING3. If not see
#include "c-family/c-ada-spec.h"
#include "cilk.h"
#include "builtins.h"
+#include "c-family/visual-parser.h"
/* In grokdeclarator, distinguish syntactic contexts of declarators. */
enum decl_context
@@ -651,6 +652,10 @@ add_stmt (tree t)
recorded during statement expressions. */
if (!building_stmt_list_p ())
push_stmt_list ();
+
+ if (vis_parser)
+ vis_parser->check_stmt (t);
+
append_to_statement_list_force (t, &cur_stmt_list);
return t;
diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c
index f5e2ac2c..47186cb 100644
--- a/gcc/c/c-parser.c
+++ b/gcc/c/c-parser.c
@@ -82,6 +82,7 @@ along with GCC; see the file COPYING3. If not see
#include "omp-low.h"
#include "builtins.h"
#include "gomp-constants.h"
+#include "c-family/visual-parser.h"
/* Initialization routine for this file. */
@@ -242,7 +243,6 @@ typedef struct GTY(()) c_parser {
vec <c_token, va_gc> *cilk_simd_fn_tokens;
} c_parser;
-
/* The actual parser and external interface. ??? Does this need to be
garbage-collected? */
@@ -262,6 +262,9 @@ c_lex_one_token (c_parser *parser, c_token *token)
token->keyword = RID_MAX;
token->pragma_kind = PRAGMA_NONE;
+ if (vis_parser)
+ vis_parser->on_token (token->location);
+
switch (token->type)
{
case CPP_NAME:
@@ -5168,11 +5171,14 @@ c_parser_paren_condition (c_parser *parser)
/* Parse a statement which is a block in C99. */
static tree
-c_parser_c99_block_statement (c_parser *parser)
+c_parser_c99_block_statement (c_parser *parser, location_t guard_loc,
+ const char *guard_kind)
{
tree block = c_begin_compound_stmt (flag_isoc99);
location_t loc = c_parser_peek_token (parser)->location;
c_parser_statement (parser);
+ if (vis_parser)
+ vis_parser->on_solo_stmt (block, guard_loc, guard_kind);
return c_end_compound_stmt (loc, block, flag_isoc99);
}
@@ -5185,7 +5191,7 @@ c_parser_c99_block_statement (c_parser *parser)
parser->in_if_block. */
static tree
-c_parser_if_body (c_parser *parser, bool *if_p)
+c_parser_if_body (c_parser *parser, bool *if_p, location_t if_loc)
{
tree block = c_begin_compound_stmt (flag_isoc99);
location_t body_loc = c_parser_peek_token (parser)->location;
@@ -5203,7 +5209,11 @@ c_parser_if_body (c_parser *parser, bool *if_p)
else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
add_stmt (c_parser_compound_statement (parser));
else
- c_parser_statement_after_labels (parser);
+ {
+ c_parser_statement_after_labels (parser);
+ if (vis_parser)
+ vis_parser->on_solo_stmt (block, if_loc, "if");
+ }
return c_end_compound_stmt (body_loc, block, flag_isoc99);
}
@@ -5212,7 +5222,7 @@ c_parser_if_body (c_parser *parser, bool *if_p)
specially for the sake of -Wempty-body warnings. */
static tree
-c_parser_else_body (c_parser *parser)
+c_parser_else_body (c_parser *parser, location_t else_tok_loc)
{
location_t else_loc = c_parser_peek_token (parser)->location;
tree block = c_begin_compound_stmt (flag_isoc99);
@@ -5227,7 +5237,12 @@ c_parser_else_body (c_parser *parser)
c_parser_consume_token (parser);
}
else
- c_parser_statement_after_labels (parser);
+ {
+ c_parser_statement_after_labels (parser);
+ if (vis_parser)
+ vis_parser->on_solo_stmt (block, else_tok_loc, "else");
+ }
+
return c_end_compound_stmt (else_loc, block, flag_isoc99);
}
@@ -5242,7 +5257,7 @@ static void
c_parser_if_statement (c_parser *parser)
{
tree block;
- location_t loc;
+ location_t if_loc, cond_loc;
tree cond;
bool first_if = false;
tree first_body, second_body;
@@ -5250,28 +5265,30 @@ c_parser_if_statement (c_parser *parser)
tree if_stmt;
gcc_assert (c_parser_next_token_is_keyword (parser, RID_IF));
+ if_loc = c_parser_peek_token (parser)->location;
c_parser_consume_token (parser);
block = c_begin_compound_stmt (flag_isoc99);
- loc = c_parser_peek_token (parser)->location;
+ cond_loc = c_parser_peek_token (parser)->location;
cond = c_parser_paren_condition (parser);
if (flag_cilkplus && contains_cilk_spawn_stmt (cond))
{
- error_at (loc, "if statement cannot contain %<Cilk_spawn%>");
+ error_at (cond_loc, "if statement cannot contain %<Cilk_spawn%>");
cond = error_mark_node;
}
in_if_block = parser->in_if_block;
parser->in_if_block = true;
- first_body = c_parser_if_body (parser, &first_if);
+ first_body = c_parser_if_body (parser, &first_if, if_loc);
parser->in_if_block = in_if_block;
if (c_parser_next_token_is_keyword (parser, RID_ELSE))
{
+ location_t else_tok_loc = c_parser_peek_token (parser)->location;
c_parser_consume_token (parser);
- second_body = c_parser_else_body (parser);
+ second_body = c_parser_else_body (parser, else_tok_loc);
}
else
second_body = NULL_TREE;
- c_finish_if_stmt (loc, cond, first_body, second_body, first_if);
- if_stmt = c_end_compound_stmt (loc, block, flag_isoc99);
+ c_finish_if_stmt (cond_loc, cond, first_body, second_body, first_if);
+ if_stmt = c_end_compound_stmt (cond_loc, block, flag_isoc99);
/* If the if statement contains array notations, then we expand them. */
if (flag_cilkplus && contains_array_notation_expr (if_stmt))
@@ -5321,7 +5338,7 @@ c_parser_switch_statement (c_parser *parser)
c_start_case (switch_loc, switch_cond_loc, expr, explicit_cast_p);
save_break = c_break_label;
c_break_label = NULL_TREE;
- body = c_parser_c99_block_statement (parser);
+ body = c_parser_c99_block_statement (parser, switch_loc, "switch");
c_finish_case (body, ce.original_type);
if (c_break_label)
{
@@ -5346,6 +5363,7 @@ c_parser_while_statement (c_parser *parser, bool ivdep)
tree block, cond, body, save_break, save_cont;
location_t loc;
gcc_assert (c_parser_next_token_is_keyword (parser, RID_WHILE));
+ location_t while_tok_loc = c_parser_peek_token (parser)->location;
c_parser_consume_token (parser);
block = c_begin_compound_stmt (flag_isoc99);
loc = c_parser_peek_token (parser)->location;
@@ -5362,7 +5380,7 @@ c_parser_while_statement (c_parser *parser, bool ivdep)
c_break_label = NULL_TREE;
save_cont = c_cont_label;
c_cont_label = NULL_TREE;
- body = c_parser_c99_block_statement (parser);
+ body = c_parser_c99_block_statement (parser, while_tok_loc, "while");
c_finish_loop (loc, cond, NULL, body, c_break_label, c_cont_label, true);
add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
c_break_label = save_break;
@@ -5381,6 +5399,7 @@ c_parser_do_statement (c_parser *parser, bool ivdep)
tree block, cond, body, save_break, save_cont, new_break, new_cont;
location_t loc;
gcc_assert (c_parser_next_token_is_keyword (parser, RID_DO));
+ location_t do_tok_loc = c_parser_peek_token (parser)->location;
c_parser_consume_token (parser);
if (c_parser_next_token_is (parser, CPP_SEMICOLON))
warning_at (c_parser_peek_token (parser)->location,
@@ -5392,7 +5411,7 @@ c_parser_do_statement (c_parser *parser, bool ivdep)
c_break_label = NULL_TREE;
save_cont = c_cont_label;
c_cont_label = NULL_TREE;
- body = c_parser_c99_block_statement (parser);
+ body = c_parser_c99_block_statement (parser, do_tok_loc, "do");
c_parser_require_keyword (parser, RID_WHILE, "expected %<while%>");
new_break = c_break_label;
c_break_label = save_break;
@@ -5640,7 +5659,7 @@ c_parser_for_statement (c_parser *parser, bool ivdep)
c_break_label = NULL_TREE;
save_cont = c_cont_label;
c_cont_label = NULL_TREE;
- body = c_parser_c99_block_statement (parser);
+ body = c_parser_c99_block_statement (parser, for_loc, "for");
if (is_foreach_statement)
objc_finish_foreach_loop (loc, object_expression, collection_expression, body, c_break_label, c_cont_label);
else
@@ -13000,7 +13019,7 @@ c_parser_omp_for_loop (location_t loc, c_parser *parser, enum tree_code code,
add_stmt (c_end_compound_stmt (here, stmt, true));
}
else
- add_stmt (c_parser_c99_block_statement (parser));
+ add_stmt (c_parser_c99_block_statement (parser, loc, "omp for"));
if (c_cont_label)
{
tree t = build1 (LABEL_EXPR, void_type_node, c_cont_label);
@@ -15403,6 +15422,9 @@ c_parse_file (void)
tparser.tokens = &tparser.tokens_buf[0];
the_parser = &tparser;
+ if (warn_misleading_indentation)
+ vis_parser = new visual_parser ();
+
if (c_parser_peek_token (&tparser)->pragma_kind == PRAGMA_GCC_PCH_PREPROCESS)
c_parser_pragma_pch_preprocess (&tparser);
@@ -15416,6 +15438,10 @@ c_parse_file (void)
using_eh_for_cleanups ();
c_parser_translation_unit (the_parser);
+
+ delete vis_parser;
+ vis_parser = NULL;
+
the_parser = NULL;
}
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 4ea2ca2..d6c8b89 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -61,6 +61,7 @@ along with GCC; see the file COPYING3. If not see
#include "type-utils.h"
#include "omp-low.h"
#include "gomp-constants.h"
+#include "c-family/visual-parser.h"
/* The lexer. */
@@ -651,6 +652,11 @@ cp_lexer_new_main (void)
lexer = cp_lexer_alloc ();
+ if (warn_misleading_indentation)
+ vis_parser = new visual_parser ();
+
+ /* FIXME: delete this. */
+
/* Put the first token in the buffer. */
lexer->buffer->quick_push (token);
@@ -1058,6 +1064,9 @@ cp_lexer_consume_token (cp_lexer* lexer)
gcc_assert (token != &eof_token);
gcc_assert (!lexer->in_pragma || token->type != CPP_PRAGMA_EOL);
+ if (vis_parser)
+ vis_parser->on_token (lexer->next_token->location);
+
do
{
lexer->next_token++;
@@ -2065,9 +2074,9 @@ static void cp_parser_declaration_statement
(cp_parser *);
static tree cp_parser_implicitly_scoped_statement
- (cp_parser *, bool *);
+ (cp_parser *, bool *, location_t, const char *);
static void cp_parser_already_scoped_statement
- (cp_parser *);
+ (cp_parser *, location_t, const char *);
/* Declarations [gram.dcl.dcl] */
@@ -10174,7 +10183,8 @@ cp_parser_selection_statement (cp_parser* parser, bool *if_p)
nested_if = false;
}
else
- cp_parser_implicitly_scoped_statement (parser, &nested_if);
+ cp_parser_implicitly_scoped_statement (parser, &nested_if,
+ token->location, "if");
parser->in_statement = in_statement;
finish_then_clause (statement);
@@ -10184,7 +10194,8 @@ cp_parser_selection_statement (cp_parser* parser, bool *if_p)
RID_ELSE))
{
/* Consume the `else' keyword. */
- cp_lexer_consume_token (parser->lexer);
+ location_t else_tok_loc
+ = cp_lexer_consume_token (parser->lexer)->location;
begin_else_clause (statement);
/* Parse the else-clause. */
if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
@@ -10198,7 +10209,8 @@ cp_parser_selection_statement (cp_parser* parser, bool *if_p)
cp_lexer_consume_token (parser->lexer);
}
else
- cp_parser_implicitly_scoped_statement (parser, NULL);
+ cp_parser_implicitly_scoped_statement (parser, NULL,
+ else_tok_loc, "else");
finish_else_clause (statement);
@@ -10238,7 +10250,8 @@ cp_parser_selection_statement (cp_parser* parser, bool *if_p)
in_statement = parser->in_statement;
parser->in_switch_statement_p = true;
parser->in_statement |= IN_SWITCH_STMT;
- cp_parser_implicitly_scoped_statement (parser, NULL);
+ cp_parser_implicitly_scoped_statement (parser, NULL,
+ 0, "switch");
parser->in_switch_statement_p = in_switch_statement_p;
parser->in_statement = in_statement;
@@ -10783,6 +10796,7 @@ static tree
cp_parser_iteration_statement (cp_parser* parser, bool ivdep)
{
cp_token *token;
+ location_t tok_loc;
enum rid keyword;
tree statement;
unsigned char in_statement;
@@ -10792,6 +10806,8 @@ cp_parser_iteration_statement (cp_parser* parser, bool ivdep)
if (!token)
return error_mark_node;
+ tok_loc = token->location;
+
/* Remember whether or not we are already within an iteration
statement. */
in_statement = parser->in_statement;
@@ -10815,7 +10831,7 @@ cp_parser_iteration_statement (cp_parser* parser, bool ivdep)
cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
/* Parse the dependent statement. */
parser->in_statement = IN_ITERATION_STMT;
- cp_parser_already_scoped_statement (parser);
+ cp_parser_already_scoped_statement (parser, tok_loc, "while");
parser->in_statement = in_statement;
/* We're done with the while-statement. */
finish_while_stmt (statement);
@@ -10830,7 +10846,7 @@ cp_parser_iteration_statement (cp_parser* parser, bool ivdep)
statement = begin_do_stmt ();
/* Parse the body of the do-statement. */
parser->in_statement = IN_ITERATION_STMT;
- cp_parser_implicitly_scoped_statement (parser, NULL);
+ cp_parser_implicitly_scoped_statement (parser, NULL, 0, "do");
parser->in_statement = in_statement;
finish_do_body (statement);
/* Look for the `while' keyword. */
@@ -10860,7 +10876,7 @@ cp_parser_iteration_statement (cp_parser* parser, bool ivdep)
/* Parse the body of the for-statement. */
parser->in_statement = IN_ITERATION_STMT;
- cp_parser_already_scoped_statement (parser);
+ cp_parser_already_scoped_statement (parser, tok_loc, "for");
parser->in_statement = in_statement;
/* We're done with the for-statement. */
@@ -11129,7 +11145,9 @@ cp_parser_declaration_statement (cp_parser* parser)
Returns the new statement. */
static tree
-cp_parser_implicitly_scoped_statement (cp_parser* parser, bool *if_p)
+cp_parser_implicitly_scoped_statement (cp_parser* parser, bool *if_p,
+ location_t guard_loc,
+ const char *guard_kind)
{
tree statement;
@@ -11155,6 +11173,9 @@ cp_parser_implicitly_scoped_statement (cp_parser* parser, bool *if_p)
cp_parser_statement (parser, NULL_TREE, false, if_p);
/* Finish the dummy compound-statement. */
finish_compound_stmt (statement);
+ /* FIXME. */
+ if (vis_parser)
+ vis_parser->on_solo_stmt (cur_stmt_list, guard_loc, guard_kind);
}
/* Return the statement. */
@@ -11167,11 +11188,17 @@ cp_parser_implicitly_scoped_statement (cp_parser* parser, bool *if_p)
scope. */
static void
-cp_parser_already_scoped_statement (cp_parser* parser)
+cp_parser_already_scoped_statement (cp_parser* parser, location_t guard_loc,
+ const char *guard_kind)
{
/* If the token is a `{', then we must take special action. */
if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
- cp_parser_statement (parser, NULL_TREE, false, NULL);
+ {
+ cp_parser_statement (parser, NULL_TREE, false, NULL);
+ if (vis_parser)
+ vis_parser->on_solo_stmt (cur_stmt_list, guard_loc,
+ guard_kind);
+ }
else
{
/* Avoid calling cp_parser_compound_statement, so that we
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 0fc08b5f..2eab2ca 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -67,6 +67,7 @@ along with GCC; see the file COPYING3. If not see
#include "builtins.h"
#include "convert.h"
#include "gomp-constants.h"
+#include "c-family/visual-parser.h"
/* There routines provide a modular interface to perform many parsing
operations. They may therefore be used during actual parsing, or
@@ -400,6 +401,9 @@ add_stmt (tree t)
if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
STATEMENT_LIST_HAS_LABEL (cur_stmt_list) = 1;
+ if (vis_parser)
+ vis_parser->check_stmt (t);
+
/* Add T to the statement-tree. Non-side-effect statements need to be
recorded during statement expressions. */
gcc_checking_assert (!stmt_list_stack->is_empty ());
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-1.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-1.c
new file mode 100644
index 0000000..dc0deb1
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-1.c
@@ -0,0 +1,12 @@
+/* { dg-options "-Wmisleading-indentation" } */
+/* { dg-do compile } */
+
+int
+foo (int flag)
+{
+ int x = 4, y = 5;
+ if (flag) /* { dg-message "3: ...this 'if' clause, but it is not" } */
+ x = 3;
+ y = 2; /* { dg-warning "statement is indented as if it were guarded by..." } */
+ return x * y;
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-10.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-10.c
new file mode 100644
index 0000000..8417e02
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-10.c
@@ -0,0 +1,15 @@
+/* { dg-options "-Wmisleading-indentation" } */
+/* { dg-do compile } */
+extern void bar (int);
+
+void foo (int flag)
+{
+ if (flag) /* { dg-message "3: ...this 'if' clause, but it is not" } */
+ if (flag / 2)
+ {
+ bar (0);
+ bar (1);
+ }
+ bar (2); /* { dg-warning "statement is indented as if it were guarded by..." } */
+ bar (3);
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-11.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-11.c
new file mode 100644
index 0000000..dfcefe2
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-11.c
@@ -0,0 +1,12 @@
+/* { dg-options "-Wmisleading-indentation" } */
+extern void foo (void);
+extern void bar (void);
+
+int test (int flagA, int flagB, int flagC)
+{
+ if (flagA)
+ if (flagB)
+ if (flagC) /* { dg-message "7: ...this 'if' clause, but it is not" } */
+ foo ();
+ bar (); /* { dg-warning "statement is indented as if it were guarded by..." } */
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-12.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-12.c
new file mode 100644
index 0000000..5c01d3e
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-12.c
@@ -0,0 +1,12 @@
+/* { dg-options "-Wmisleading-indentation" } */
+extern void foo (void);
+extern void bar (void);
+
+int test (int flagA, int flagB, int flagC)
+{
+ if (flagA)
+ if (flagB) /* { dg-message "5: ...this 'if' clause, but it is not" } */
+ if (flagC)
+ foo ();
+ bar (); /* { dg-warning "statement is indented as if it were guarded by..." } */
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-13.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-13.c
new file mode 100644
index 0000000..198395f
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-13.c
@@ -0,0 +1,12 @@
+/* { dg-options "-Wmisleading-indentation" } */
+extern void foo (void);
+extern void bar (void);
+
+int test (int flagA, int flagB, int flagC)
+{
+ if (flagA) /* { dg-message "3: ...this 'if' clause, but it is not" } */
+ if (flagB)
+ if (flagC)
+ foo ();
+ bar (); /* { dg-warning "statement is indented as if it were guarded by..." } */
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-14.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-14.c
new file mode 100644
index 0000000..87a9040
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-14.c
@@ -0,0 +1,14 @@
+/* { dg-options "-Wmisleading-indentation" } */
+extern void foo (void);
+extern void bar (void);
+
+#define FOR_EACH(VAR, START, STOP) \
+ for ((VAR) = (START); (VAR) < (STOP); (VAR++)) /* { dg-message "3: ...this 'for' clause, but it is not" } */
+
+int test (void)
+{
+ int i;
+ FOR_EACH (i, 0, 10) /* { dg-message "3: in expansion of macro" } */
+ foo ();
+ bar (); /* { dg-warning "statement is indented as if it were guarded by..." } */
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-15.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-15.c
new file mode 100644
index 0000000..d8e2815
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-15.c
@@ -0,0 +1,13 @@
+/* { dg-options "-Wmisleading-indentation" } */
+extern void foo (void);
+extern void bar (void);
+
+#define FOR_EACH(VAR, START, STOP) for ((VAR) = (START); (VAR) < (STOP); (VAR++)) /* { dg-message "36: ...this 'for' clause, but it is not" } */
+
+int test (void)
+{
+ int i;
+ FOR_EACH (i, 0, 10) /* { dg-message "3: in expansion of macro" } */
+ foo ();
+ bar (); /* { dg-warning "statement is indented as if it were guarded by..." } */
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-16-tabs.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-16-tabs.c
new file mode 100644
index 0000000..f224f9e
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-16-tabs.c
@@ -0,0 +1,16 @@
+/* { dg-options "-Wmisleading-indentation" } */
+extern void foo (void);
+extern void bar (void);
+
+extern int flagA;
+extern int flagB;
+
+int test (void)
+{
+ int i;
+ for (i = 0; i < 10; i++)
+ while (flagA)
+ if (flagB) /* { dg-message "7: ...this 'if' clause, but it is not" } */
+ foo ();
+ bar (); /* { dg-warning "statement is indented as if it were guarded by..." } */
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-16.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-16.c
new file mode 100644
index 0000000..e8e63ca
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-16.c
@@ -0,0 +1,16 @@
+/* { dg-options "-Wmisleading-indentation" } */
+extern void foo (void);
+extern void bar (void);
+
+extern int flagA;
+extern int flagB;
+
+int test (void)
+{
+ int i;
+ for (i = 0; i < 10; i++)
+ while (flagA)
+ if (flagB) /* { dg-message "7: ...this 'if' clause, but it is not" } */
+ foo ();
+ bar (); /* { dg-warning "statement is indented as if it were guarded by..." } */
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-17-tabs.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-17-tabs.c
new file mode 100644
index 0000000..db25945f
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-17-tabs.c
@@ -0,0 +1,16 @@
+/* { dg-options "-Wmisleading-indentation" } */
+extern void foo (void);
+extern void bar (void);
+
+extern int flagA;
+extern int flagB;
+
+int test (void)
+{
+ int i;
+ for (i = 0; i < 10; i++) /* { dg-message "3: ...this 'for' clause, but it is not" } */
+ while (flagA)
+ if (flagB)
+ foo ();
+ bar (); /* { dg-warning "statement is indented as if it were guarded by..." } */
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-17.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-17.c
new file mode 100644
index 0000000..61c3890
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-17.c
@@ -0,0 +1,16 @@
+/* { dg-options "-Wmisleading-indentation" } */
+extern void foo (void);
+extern void bar (void);
+
+extern int flagA;
+extern int flagB;
+
+int test (void)
+{
+ int i;
+ for (i = 0; i < 10; i++) /* { dg-message "3: ...this 'for' clause, but it is not" } */
+ while (flagA)
+ if (flagB)
+ foo ();
+ bar (); /* { dg-warning "statement is indented as if it were guarded by..." } */
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-18-tabs.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-18-tabs.c
new file mode 100644
index 0000000..12d9443
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-18-tabs.c
@@ -0,0 +1,16 @@
+/* { dg-options "-Wmisleading-indentation" } */
+extern void foo (void);
+extern void bar (void);
+
+extern int flagA;
+extern int flagB;
+
+int test (void)
+{
+ int i;
+ for (i = 0; i < 10; i++)
+ while (flagA) /* { dg-message "5: ...this 'while' clause, but it is not" } */
+ if (flagB)
+ foo ();
+ bar (); /* { dg-warning "statement is indented as if it were guarded by..." } */
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-18.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-18.c
new file mode 100644
index 0000000..b42dbd6
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-18.c
@@ -0,0 +1,16 @@
+/* { dg-options "-Wmisleading-indentation" } */
+extern void foo (void);
+extern void bar (void);
+
+extern int flagA;
+extern int flagB;
+
+int test (void)
+{
+ int i;
+ for (i = 0; i < 10; i++)
+ while (flagA) /* { dg-message "5: ...this 'while' clause, but it is not" } */
+ if (flagB)
+ foo ();
+ bar (); /* { dg-warning "statement is indented as if it were guarded by..." } */
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-2.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-2.c
new file mode 100644
index 0000000..4aeb4e6
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-2.c
@@ -0,0 +1,11 @@
+/* { dg-options "-Wmisleading-indentation" } */
+/* { dg-do compile } */
+
+int
+foo (int flag, int x, int y)
+{
+ if (flag) /* { dg-message "3: ...this 'if' clause, but it is not" } */
+ x++; y++; /* { dg-warning "statement is indented as if it were guarded by..." } */
+
+ return x * y;
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-3.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-3.c
new file mode 100644
index 0000000..e37080d
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-3.c
@@ -0,0 +1,14 @@
+/* { dg-options "-Wmisleading-indentation" } */
+/* { dg-do compile } */
+
+int
+foo (int flag)
+{
+ int x = 4, y = 5;
+ if (flag)
+ x = 3;
+ else /* { dg-message "3: ...this 'else' clause, but it is not" } */
+ x = 2;
+ y = 2; /* { dg-warning "statement is indented as if it were guarded by..." } */
+ return x * y;
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-4.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-4.c
new file mode 100644
index 0000000..0c72782
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-4.c
@@ -0,0 +1,11 @@
+/* { dg-options "-Wmisleading-indentation" } */
+/* { dg-do compile } */
+
+void
+foo (double *a, double *b, double *c)
+{
+ int i = 0;
+ while (i < 10) /* { dg-message "3: ...this 'while' clause, but it is not" } */
+ a[i] = b[i] * c[i];
+ i++; /* { dg-warning "statement is indented as if it were guarded by..." } */
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-5.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-5.c
new file mode 100644
index 0000000..7537e8f
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-5.c
@@ -0,0 +1,11 @@
+/* { dg-options "-Wmisleading-indentation" } */
+/* { dg-do compile } */
+
+void
+foo (double *a, double *b, double *sum, double *prod)
+{
+ int i = 0;
+ for (i = 0; i < 10; i++) /* { dg-output "3: ...this 'for' clause, but it is not" } */
+ sum[i] = a[i] * b[i];
+ prod[i] = a[i] * b[i]; /* { dg-warning "statement is indented as if it were guarded by..." } */
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-6.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-6.c
new file mode 100644
index 0000000..fc19537
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-6.c
@@ -0,0 +1,22 @@
+/* Based on CVE-2014-1266 aka "goto fail" */
+/* { dg-options "-Wmisleading-indentation" } */
+extern int foo (int);
+
+static int
+goto_fail(int a, int b, int c)
+{
+ int err;
+
+ /* ... */
+ if ((err = foo (a)) != 0)
+ goto fail;
+ if ((err = foo (b)) != 0) /* { dg-message "2: ...this 'if' clause, but it is not" } */
+ goto fail;
+ goto fail; /* { dg-warning "statement is indented as if it were guarded by..." } */
+ if ((err = foo (c)) != 0)
+ goto fail;
+ /* ... */
+
+fail:
+ return err;
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-7.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-7.c
new file mode 100644
index 0000000..500884a
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-7.c
@@ -0,0 +1,15 @@
+/* { dg-options "-Wmisleading-indentation" } */
+
+extern int bar (int, int);
+
+int foo (int p, int q, int r, int s, int t)
+{
+ if (bar (p, q))
+ {
+ if (p) /* { dg-message "7: ...this 'if' clause, but it is not" } */
+ q++; r++; /* { dg-warning "statement is indented as if it were guarded by..." } */
+ s++; /* { dg-warning "statement is indented as if it were guarded by..." } */
+ t++;
+ }
+ return p + q + r + s + t;
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-8.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-8.c
new file mode 100644
index 0000000..82c1e6b
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-8.c
@@ -0,0 +1,6 @@
+/* { dg-options "-Wmisleading-indentation" } */
+int foo (int a, int b, int c)
+{
+ /* This should *not* be flagged as misleading indentation. */
+ if (a) return b; else return c;
+}
diff --git a/gcc/testsuite/c-c++-common/Wmisleading-indentation-9.c b/gcc/testsuite/c-c++-common/Wmisleading-indentation-9.c
new file mode 100644
index 0000000..3fcba34
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/Wmisleading-indentation-9.c
@@ -0,0 +1,10 @@
+/* { dg-options "-Wmisleading-indentation" } */
+/* { dg-do compile } */
+extern void bar (int);
+
+void foo (int flag)
+{
+ if (flag) /* { dg-message "3: ...this 'if' clause, but it is not" } */
+ bar (0);
+ bar (1); /* { dg-warning "statement is indented as if it were guarded by..." } */
+}
