diff mbox

[C++] Fix some simple location issues

Message ID 5756F060.3020609@oracle.com
State New
Headers show

Commit Message

Paolo Carlini June 7, 2016, 4:03 p.m. UTC 
Hi,

in parallel with other work, I'm auditing the front-end for simple 
location issues which can be fixed immediately. These I noticed in 
decl.c over the last couple of days. Slightly more interesting, for some 
error messages we didn't seem to have testcases, certainly not in 
g++.dg, thus I added some elementary ones covering the locations too. 
Tested x86_64-linux.

Thanks,
Paolo.

///////////////////////////
/cp
2016-06-07  Paolo Carlini  <paolo.carlini@oracle.com>

	* decl.c (maybe_deduce_size_from_array_init): Use
	DECL_SOURCE_LOCATION in error_at.
	(layout_var_decl): Likewise.
	(check_array_initializer): Likewise.
	(check_initializer): Likewise.
	(duplicate_decls, check_elaborated_type_specifier): Tidy.

/testsuite
2016-06-07  Paolo Carlini  <paolo.carlini@oracle.com>

	* g++.dg/init/array42.C: New.
	* g++.dg/init/array43.C: Likewise.
	* g++.dg/init/array44.C: Likewise.
	* g++.dg/init/array45.C: Likewise.
	* g++.dg/cpp0x/constexpr-ice10.C: Test column number too.
	* g++.dg/cpp0x/constexpr-incomplete1.C: Likewise.
	* g++.dg/cpp1y/auto-fn27.C: Likewise.
	* g++.dg/gomp/pr35751.C: Likewise.
	* g++.dg/init/array23.C: Likewise.
	* g++.dg/init/brace2.C: Likewise.
	* g++.dg/init/brace6.C: Likewise.

Comments

Jason Merrill June 7, 2016, 7:40 p.m. UTC | #1 
For diagnostics about an initializer, I think it would be better to give 
the location of the initializer rather than the declaration.  Maybe use

location_t loc = EXPR_LOC_OR_LOC (init, DECL_SOURCE_LOCATION (decl));

?

Jason
diff mbox

Patch

Index: cp/decl.c
===================================================================
--- cp/decl.c	(revision 237171)
+++ cp/decl.c	(working copy)
@@ -1393,7 +1393,7 @@  duplicate_decls (tree newdecl, tree olddecl, bool
     {
       if (DECL_INITIAL (olddecl))
 	inform (DECL_SOURCE_LOCATION (olddecl),
-		"previous definition of %q+D was here", olddecl);
+		"previous definition of %qD was here", olddecl);
       else
 	inform (DECL_SOURCE_LOCATION (olddecl),
 		"previous declaration of %qD was here", olddecl);
@@ -5266,13 +5266,15 @@  maybe_deduce_size_from_array_init (tree decl, tree
 					    do_default);
 	  if (failure == 1)
 	    {
-	      error ("initializer fails to determine size of %qD", decl);
+	      error_at (DECL_SOURCE_LOCATION (decl),
+			"initializer fails to determine size of %qD", decl);
 	    }
 	  else if (failure == 2)
 	    {
 	      if (do_default)
 		{
-		  error ("array size missing in %qD", decl);
+		  error_at (DECL_SOURCE_LOCATION (decl),
+			    "array size missing in %qD", decl);
 		}
 	      /* If a `static' var's size isn't known, make it extern as
 		 well as static, so it does not get allocated.  If it's not
@@ -5283,7 +5285,8 @@  maybe_deduce_size_from_array_init (tree decl, tree
 	    }
 	  else if (failure == 3)
 	    {
-	      error ("zero-size array %qD", decl);
+	      error_at (DECL_SOURCE_LOCATION (decl),
+			"zero-size array %qD", decl);
 	    }
 	}
 
@@ -5322,7 +5325,8 @@  layout_var_decl (tree decl)
       /* An automatic variable with an incomplete type: that is an error.
 	 Don't talk about array types here, since we took care of that
 	 message in grokdeclarator.  */
-      error ("storage size of %qD isn%'t known", decl);
+      error_at (DECL_SOURCE_LOCATION (decl),
+		"storage size of %qD isn%'t known", decl);
       TREE_TYPE (decl) = error_mark_node;
     }
 #if 0
@@ -5345,7 +5349,8 @@  layout_var_decl (tree decl)
 	constant_expression_warning (DECL_SIZE (decl));
       else
 	{
-	  error ("storage size of %qD isn%'t constant", decl);
+	  error_at (DECL_SOURCE_LOCATION (decl),
+		    "storage size of %qD isn%'t constant", decl);
 	  TREE_TYPE (decl) = error_mark_node;
 	}
     }
@@ -5954,7 +5959,8 @@  check_array_initializer (tree decl, tree type, tre
   if (!COMPLETE_TYPE_P (complete_type (element_type)))
     {
       if (decl)
-	error ("elements of array %q#D have incomplete type", decl);
+	error_at (DECL_SOURCE_LOCATION (decl),
+		  "elements of array %q#D have incomplete type", decl);
       else
 	error ("elements of array %q#T have incomplete type", type);
       return true;
@@ -6018,7 +6024,8 @@  check_initializer (tree decl, tree init, int flags
     }
   else if (!COMPLETE_TYPE_P (type))
     {
-      error ("%q#D has incomplete type", decl);
+      error_at (DECL_SOURCE_LOCATION (decl),
+		"%q#D has incomplete type", decl);
       TREE_TYPE (decl) = error_mark_node;
       return NULL_TREE;
     }
@@ -6038,8 +6045,9 @@  check_initializer (tree decl, tree init, int flags
 	    }
 	  else if (init_len != 1 && TREE_CODE (type) != COMPLEX_TYPE)
 	    {
-	      error ("scalar object %qD requires one element in initializer",
-		     decl);
+	      error_at (DECL_SOURCE_LOCATION (decl),
+			"scalar object %qD requires one element in "
+			"initializer", decl);
 	      TREE_TYPE (decl) = error_mark_node;
 	      return NULL_TREE;
 	    }
@@ -6081,9 +6089,10 @@  check_initializer (tree decl, tree init, int flags
 	    {
 	      /* Don't reshape if the class has constructors.  */
 	      if (cxx_dialect == cxx98)
-		error ("in C++98 %qD must be initialized by constructor, "
-		       "not by %<{...}%>",
-		       decl);
+		error_at (DECL_SOURCE_LOCATION (decl),
+			  "in C++98 %qD must be initialized by "
+			  "constructor, not by %<{...}%>",
+			  decl);
 	    }
 	  else if (VECTOR_TYPE_P (type) && TYPE_VECTOR_OPAQUE (type))
 	    {
@@ -6175,8 +6184,10 @@  check_initializer (tree decl, tree init, int flags
 	      && DECL_INITIAL (decl)
 	      && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
 	      && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
-	    warning (0, "array %qD initialized by parenthesized string literal %qE",
-		     decl, DECL_INITIAL (decl));
+	    warning_at (DECL_SOURCE_LOCATION (decl), 0,
+			"array %qD initialized by parenthesized "
+			"string literal %qE",
+			decl, DECL_INITIAL (decl));
 	  init = NULL;
 	}
     }
@@ -12528,7 +12539,7 @@  check_elaborated_type_specifier (enum tag_types ta
 	   && tag_code != typename_type)
     {
       error ("%qT referred to as %qs", type, tag_name (tag_code));
-      inform (input_location, "%q+T has a previous declaration here", type);
+      inform (location_of (type), "%qT has a previous declaration here", type);
       return error_mark_node;
     }
   else if (TREE_CODE (type) != ENUMERAL_TYPE
@@ -12535,7 +12546,7 @@  check_elaborated_type_specifier (enum tag_types ta
 	   && tag_code == enum_type)
     {
       error ("%qT referred to as enum", type);
-      inform (input_location, "%q+T has a previous declaration here", type);
+      inform (location_of (type), "%qT has a previous declaration here", type);
       return error_mark_node;
     }
   else if (!allow_template_p
Index: testsuite/g++.dg/cpp0x/constexpr-ice10.C
===================================================================
--- testsuite/g++.dg/cpp0x/constexpr-ice10.C	(revision 237171)
+++ testsuite/g++.dg/cpp0x/constexpr-ice10.C	(working copy)
@@ -4,5 +4,5 @@ 
 struct A
 {
   constexpr A() {}
-  static constexpr A a[2] = {};  // { dg-error "incomplete" }
+  static constexpr A a[2] = {};  // { dg-error "22:elements of array 'constexpr const A A::a \\\[2\\\]' have incomplete type" }
 };
Index: testsuite/g++.dg/cpp0x/constexpr-incomplete1.C
===================================================================
--- testsuite/g++.dg/cpp0x/constexpr-incomplete1.C	(revision 237171)
+++ testsuite/g++.dg/cpp0x/constexpr-incomplete1.C	(working copy)
@@ -2,6 +2,6 @@ 
 
 struct A
 {
-  static constexpr A a = 1;	// { dg-error "incomplete" }
+  static constexpr A a = 1;  // { dg-error "22:'constexpr const A A::a' has incomplete type" }
   constexpr A(int i) { }
 };
Index: testsuite/g++.dg/cpp1y/auto-fn27.C
===================================================================
--- testsuite/g++.dg/cpp1y/auto-fn27.C	(revision 237171)
+++ testsuite/g++.dg/cpp1y/auto-fn27.C	(working copy)
@@ -31,7 +31,7 @@  F<T>::bar (const G &)
 {
   auto s = I;
   typedef decltype (s) L;
-  auto u =[&](L) { auto t = foo (J::K (), 0); }; // { dg-error "" }
+  auto u =[&](L) { auto t = foo (J::K (), 0); }; // { dg-error "25:'void t' has incomplete type" }
 }
 struct B {
   typedef int G;
Index: testsuite/g++.dg/gomp/pr35751.C
===================================================================
--- testsuite/g++.dg/gomp/pr35751.C	(revision 237171)
+++ testsuite/g++.dg/gomp/pr35751.C	(working copy)
@@ -5,8 +5,8 @@ 
 void
 foo (int i)
 {
-  extern int a[i];	// { dg-error "storage size of" }
-  static int b[i];	// { dg-error "storage size of" }
+  extern int a[i];	// { dg-error "14:storage size of" }
+  static int b[i];	// { dg-error "14:storage size of" }
 
 #pragma omp parallel
   {
Index: testsuite/g++.dg/init/array23.C
===================================================================
--- testsuite/g++.dg/init/array23.C	(revision 237171)
+++ testsuite/g++.dg/init/array23.C	(working copy)
@@ -3,4 +3,4 @@ 
 //  array
 
 struct A {A();int A::* t;};
-A x[]; // { dg-error "size" }
+A x[]; // { dg-error "3:array size missing" }
Index: testsuite/g++.dg/init/array42.C
===================================================================
--- testsuite/g++.dg/init/array42.C	(revision 0)
+++ testsuite/g++.dg/init/array42.C	(working copy)
@@ -0,0 +1 @@ 
+char a[] = ("abc");  // { dg-warning "6:array 'a' initialized by parenthesized string literal" }
Index: testsuite/g++.dg/init/array43.C
===================================================================
--- testsuite/g++.dg/init/array43.C	(revision 0)
+++ testsuite/g++.dg/init/array43.C	(working copy)
@@ -0,0 +1,2 @@ 
+int a[] = 0;  // { dg-error "5:initializer fails to determine size" }
+// { dg-error "11:array must be initialized" "" { target *-*-* } 1 }
Index: testsuite/g++.dg/init/array44.C
===================================================================
--- testsuite/g++.dg/init/array44.C	(revision 0)
+++ testsuite/g++.dg/init/array44.C	(working copy)
@@ -0,0 +1 @@ 
+int a[] = { };  // { dg-error "5:zero-size array" } 
Index: testsuite/g++.dg/init/array45.C
===================================================================
--- testsuite/g++.dg/init/array45.C	(revision 0)
+++ testsuite/g++.dg/init/array45.C	(working copy)
@@ -0,0 +1 @@ 
+int a[];  // { dg-error "5:storage size" }
Index: testsuite/g++.dg/init/brace2.C
===================================================================
--- testsuite/g++.dg/init/brace2.C	(revision 237171)
+++ testsuite/g++.dg/init/brace2.C	(working copy)
@@ -3,6 +3,6 @@ 
 int x = { 2 };
 const char * y = { "hello" };
 int a = 2;
-int b = { 2,3 }; // { dg-error "requires one element in initializer" }
+int b = { 2,3 }; // { dg-error "5:scalar object 'b' requires one element in initializer" }
 int c = { { 2 } } ; // { dg-error "braces around scalar initializer" }
 int d = {}; // { dg-error "initializer" "" { target { ! c++11 } } }
Index: testsuite/g++.dg/init/brace6.C
===================================================================
--- testsuite/g++.dg/init/brace6.C	(revision 237171)
+++ testsuite/g++.dg/init/brace6.C	(working copy)
@@ -17,8 +17,8 @@  struct D { int c; };
 int main()
 {
    int i = { 1 };
-   int j = { 1, 2 }; /* { dg-error "requires one element" } */
-   A a = { 6 }; /* { dg-error "initialize" "" { target { ! c++11 } } } */
+   int j = { 1, 2 }; /* { dg-error "8:scalar object 'j' requires one element" } */
+   A a = { 6 }; /* { dg-error "6:in C\\+\\+98 'a' must be initialized" "" { target { ! c++11 } } } */
    B b = { 6 }; /* { dg-error "" } */
    C c = { 6 }; /* { dg-error "too many initializers" } */
    D d = { 6 };