+2002-09-05 Jason Merrill <jason@redhat.com>
+
+ * typeck2.c (add_exception_specifier): Only pedwarn for an
+ incomplete type.
+ (require_complete_eh_spec_types): New fn.
+ (cxx_incomplete_type_diagnostic): Also support pedwarning.
+ * typeck.c (complete_type_or_diagnostic): Likewise.
+ * call.c (build_call): Call require_complete_eh_spec_types.
+ * rtti.c (get_pseudo_ti_desc): Give an error rather than aborting
+ on an incomplete type.
+
2002-09-04 Jakub Jelinek <jakub@redhat.com>
* decl.c (start_cleanup_fn): Clear interface_only before
tree tmp;
tree decl;
tree result_type;
+ tree fntype;
function = build_addr_func (function);
return error_mark_node;
}
- result_type = TREE_TYPE (TREE_TYPE (TREE_TYPE (function)));
+ fntype = TREE_TYPE (TREE_TYPE (function));
+ result_type = TREE_TYPE (fntype);
if (TREE_CODE (function) == ADDR_EXPR
&& TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
if (decl && TREE_DEPRECATED (decl))
warn_deprecated_use (decl);
+ require_complete_eh_spec_types (fntype, decl);
if (decl && DECL_CONSTRUCTOR_P (decl))
is_constructor = 1;
return ptm_desc_type_node;
else if (!COMPLETE_TYPE_P (type))
{
- my_friendly_assert (at_eof, 20020609);
+ if (!at_eof)
+ cxx_incomplete_type_error (NULL_TREE, type);
return class_desc_type_node;
}
else if (!CLASSTYPE_N_BASECLASSES (type))
return type;
}
-/* Like complete_type, but issue an error if the TYPE cannot be
- completed. VALUE is used for informative diagnostics. WARN_ONLY
- will cause a warning message to be printed, instead of an error.
+/* Like complete_type, but issue an error if the TYPE cannot be completed.
+ VALUE is used for informative diagnostics. DIAG_TYPE indicates the type
+ of diagnostic: 0 for an error, 1 for a warning, 2 for a pedwarn.
Returns NULL_TREE if the type cannot be made complete. */
tree
-complete_type_or_diagnostic (type, value, warn_only)
+complete_type_or_diagnostic (type, value, diag_type)
tree type;
tree value;
- int warn_only;
+ int diag_type;
{
type = complete_type (type);
if (type == error_mark_node)
return NULL_TREE;
else if (!COMPLETE_TYPE_P (type))
{
- cxx_incomplete_type_diagnostic (value, type, warn_only);
+ cxx_incomplete_type_diagnostic (value, type, diag_type);
return NULL_TREE;
}
else
/* Print an error message for invalid use of an incomplete type.
VALUE is the expression that was used (or 0 if that isn't known)
- and TYPE is the type that was invalid. If WARN_ONLY is nonzero, a
- warning is printed, otherwise an error is printed. */
+ and TYPE is the type that was invalid. DIAG_TYPE indicates the
+ type of diagnostic: 0 for an error, 1 for a warning, 2 for a
+ pedwarn. */
void
-cxx_incomplete_type_diagnostic (value, type, warn_only)
+cxx_incomplete_type_diagnostic (value, type, diag_type)
tree value;
tree type;
- int warn_only;
+ int diag_type;
{
int decl = 0;
void (*p_msg) PARAMS ((const char *, ...));
void (*p_msg_at) PARAMS ((const char *, ...));
- if (warn_only)
+ if (diag_type == 1)
{
p_msg = warning;
p_msg_at = cp_warning_at;
}
+ else if (diag_type == 2)
+ {
+ p_msg = pedwarn;
+ p_msg_at = cp_pedwarn_at;
+ }
else
{
p_msg = error;
int ok;
tree core = spec;
int is_ptr;
+ int diag_type = -1; /* none */
if (spec == error_mark_node)
return list;
else if (processing_template_decl)
ok = 1;
else
- ok = COMPLETE_TYPE_P (complete_type (core));
+ {
+ ok = 1;
+ /* 15.4/1 says that types in an exception specifier must be complete,
+ but it seems more reasonable to only require this on definitions
+ and calls. So just give a pedwarn at this point; we will give an
+ error later if we hit one of those two cases. */
+ if (!COMPLETE_TYPE_P (complete_type (core)))
+ diag_type = 2; /* pedwarn */
+ }
if (ok)
{
if (!probe)
list = tree_cons (NULL_TREE, spec, list);
}
- else if (complain)
- cxx_incomplete_type_error (NULL_TREE, core);
+ else
+ diag_type = 0; /* error */
+
+ if (diag_type >= 0 && complain)
+ cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type);
+
return list;
}
}
return list;
}
+
+/* Subroutine of build_call. Ensure that each of the types in the
+ exception specification is complete. Technically, 15.4/1 says that
+ they need to be complete when we see a declaration of the function,
+ but we should be able to get away with only requiring this when the
+ function is defined or called. See also add_exception_specifier. */
+
+void
+require_complete_eh_spec_types (fntype, decl)
+ tree fntype, decl;
+{
+ tree raises;
+ /* Don't complain about calls to op new. */
+ if (decl && DECL_ARTIFICIAL (decl))
+ return;
+ for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises;
+ raises = TREE_CHAIN (raises))
+ {
+ tree type = TREE_VALUE (raises);
+ if (type && !COMPLETE_TYPE_P (type))
+ {
+ if (decl)
+ error
+ ("call to function `%D' which throws incomplete type `%#T'",
+ decl, type);
+ else
+ error ("call to function which throws incomplete type `%#T'",
+ decl);
+ }
+ }
+}
--- /dev/null
+// Test for extension to allow incomplete types in an
+// exception-specification for a declaration.
+
+// { dg-do run }
+// { dg-options "-fpermissive -w" }
+
+struct A;
+
+struct B
+{
+ void f () throw (A);
+};
+
+struct A {};
+
+void B::f () throw (A) {}
+
+int main ()
+{
+ B b;
+ b.f();
+}
--- /dev/null
+// Test that we don't allow incomplete types in an exception-specification
+// for a definition, or at a call site.
+
+// { dg-options "-fpermissive -w" }
+
+struct A; // { dg-error "" }
+
+struct B
+{
+ void f () throw (A);
+};
+
+void B::f () throw (A) {} // { dg-error "A" }
+
+int main ()
+{
+ B b;
+ b.f(); // { dg-error "A" }
+}
projects / thirdparty / gcc.git / commitdiff
