c++: Check constant array bounds later.

We give a better diagnostic for non-constant array bounds in
compute_array_index_type_loc, we don't need to diagnose it in the parser.
But to avoid a regression on parse/varmod1.C we need to actually check
non-dependent expressions in a template.

gcc/cp/ChangeLog:

	* decl.c (compute_array_index_type_loc): Diagnose expressions
	in a template that can't be constant.
	* parser.c (cp_parser_direct_declarator): Don't check
	non-constant array bounds here.

gcc/testsuite/ChangeLog:

	* c-c++-common/gomp/depend-iterator-2.c: Adjust.
	* g++.dg/ext/vla1.C: Adjust.
	* g++.dg/template/array9.C: Adjust.
	* g++.dg/template/error41.C: Adjust.

diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 6d1c08e064aec2150fd7c470dd4ff59dfbac99df..2e1390837e86c94dafaa066c466d5aa8a23fc2b6 100644 (file)
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -10328,13 +10328,14 @@ compute_array_index_type_loc (location_t name_loc, tree name, tree size,
      dependent type or whose size is specified by a constant expression
      that is value-dependent.  */
   /* We can only call value_dependent_expression_p on integral constant
-     expressions; treat non-constant expressions as dependent, too.  */
+     expressions.  */
   if (processing_template_decl
-      && (!TREE_CONSTANT (size) || value_dependent_expression_p (size)))
+      && potential_constant_expression (size)
+      && value_dependent_expression_p (size))
     {
-      /* We cannot do any checking for a SIZE that isn't known to be
-        constant. Just build the index type and mark that it requires
+      /* Just build the index type and mark that it requires
         structural equality checks.  */
+    in_template:
       itype = build_index_type (build_min (MINUS_EXPR, sizetype,
                                           size, size_one_node));
       TYPE_DEPENDENT_P (itype) = 1;
@@ -10447,8 +10448,7 @@ compute_array_index_type_loc (location_t name_loc, tree name, tree size,
     }
 
   if (processing_template_decl && !TREE_CONSTANT (size))
-    /* A variable sized array.  */
-    itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
+    goto in_template;
   else
     {
       if (!TREE_CONSTANT (size))

diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 6a0ef4d76ee2f0c46b914735a47f251fe9a858bc..54ca875ce54c3673b3b02bfcb65c2afdfd944a54 100644 (file)
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -21366,6 +21366,8 @@ cp_parser_direct_declarator (cp_parser* parser,
                /* OK */;
              else if (error_operand_p (bounds))
                /* Already gave an error.  */;
+             else if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
+               /* Let compute_array_index_type diagnose this.  */;
              else if (!parser->in_function_body
                       || current_binding_level->kind == sk_function_parms)
                {

diff --git a/gcc/testsuite/c-c++-common/gomp/depend-iterator-2.c b/gcc/testsuite/c-c++-common/gomp/depend-iterator-2.c
index 127528271ee968ddfe45674a170bf6dca583a674..fff32a4761fb4ffcda48afbed969948e99d7e098 100644 (file)
--- a/gcc/testsuite/c-c++-common/gomp/depend-iterator-2.c
+++ b/gcc/testsuite/c-c++-common/gomp/depend-iterator-2.c
@@ -41,7 +41,7 @@ f1 (void)
   ;
   #pragma omp task depend (iterator (int i = 0:4, \
                                     struct U { int (*p)[i + 2]; } *p = 0:2) , in : a)  /* { dg-error "type of iterator 'p' refers to outer iterator 'i'" "" { target c } } */
-  ;                                                                    /* { dg-error "types may not be defined in iterator type|not an integer constant" "" { target c++ } .-1 } */
+  ;                                                                    /* { dg-error "types may not be defined in iterator type|not an integral constant" "" { target c++ } .-1 } */
   #pragma omp task depend (iterator (i = 0:4, j = i:16) , in : a)      /* { dg-error "begin expression refers to outer iterator 'i'" } */
   ;
   #pragma omp task depend (iterator (i = 0:4, j = 2:i:1) , in : a)     /* { dg-error "end expression refers to outer iterator 'i'" } */

diff --git a/gcc/testsuite/g++.dg/ext/vla1.C b/gcc/testsuite/g++.dg/ext/vla1.C
index c017b6e90ed8fb4fd97be6ee0107b27a0535ba12..cae3f82135a53556ef331fcb1a5b39927fdb8860 100644 (file)
--- a/gcc/testsuite/g++.dg/ext/vla1.C
+++ b/gcc/testsuite/g++.dg/ext/vla1.C
@@ -19,8 +19,7 @@ class B { B (int); };
 B::B (int i)
 {
   struct S {
-    int ar[1][i];  // { dg-error "15:size of array .ar. is not an integral" "" { target c++11 } }
-// { dg-error "array bound" "" { target c++98_only } .-1 }
+    int ar[1][i];  // { dg-error "15:size of array .ar. is not an integral" }
   } s;
 
   s.ar[0][0] = 0;  // { dg-prune-output "no member" }

diff --git a/gcc/testsuite/g++.dg/template/array9.C b/gcc/testsuite/g++.dg/template/array9.C
index f3e8335c943fb2a102fb6b79041d69ff058e7e8f..ce9fb649d3a22d35ae6cc823ee3bc2a6f8643f0f 100644 (file)
--- a/gcc/testsuite/g++.dg/template/array9.C
+++ b/gcc/testsuite/g++.dg/template/array9.C
@@ -7,8 +7,8 @@ struct Tree {
   Tree* R[subtrees]; // { dg-error "" }
   ~Tree()
   {
-    delete [] L[0]; // { dg-error "" }
-    delete [] R[0]; // { dg-error "" }
+    delete [] L[0];
+    delete [] R[0];
   }
 };
 

diff --git a/gcc/testsuite/g++.dg/template/error41.C b/gcc/testsuite/g++.dg/template/error41.C
index c92b8497aff2c791eda1045cd1cc2e8ff1d92727..21e8ffbc20ecd715d41554b9c7e9d6e4f2d0a0c1 100644 (file)
--- a/gcc/testsuite/g++.dg/template/error41.C
+++ b/gcc/testsuite/g++.dg/template/error41.C
@@ -8,5 +8,5 @@ struct A
 
 template <int> struct B
 {
-  int x[A::i]; // { dg-error "array bound is not an integer constant" }
+  int x[A::i]; // { dg-error "not an integral constant-expression" }
 };