PR c++/19733

	* class.c (add_method): Don't set TYPE_HAS_DESTRUCTOR.
	(check_bases): Give warnings about a base class with a
	non-virtual destructor, even if it is implicit.
	(finish_struct_bits): Don't copy TYPE_HAS_DESTRUCTOR.
	(maybe_warn_about_overly_private_class): Don't use
	TYPE_HAS_DESTRUCTOR.
	(finish_struct_methods): Don't set TYPE_HAS_DESTRUCTOR.
	(check_for_override): Give it external linkage.
	(add_implicitly_declared_members): Generate destructors lazily.
	(check_field_decls): Use TYPE_HAS_NONTRIVIAL_DESTRUCTOR, not
	TYPE_HAS_DESTRUCTOR.
	(check_bases_and_members): Call check_methods before
	check_field_decls.
	(check_bases_and_members): Use TYPE_HAS_NONTRIVIAL_DESTRUCTOR, not
	TYPE_HAS_DESTRUCTOR.
	(finish_struct_1): Do not use TYPE_HAS_DESTRUCTOR.
	* cp-tree.def (PSEUDO_DTOR_EXPR): Document.
	* cp-tree.h (TYPE_HAS_DESTRUCTOR): Remove.
	(lang_type_class): Add lazy_destructor.
	(CLASSTYPE_LAZY_DESTRUCTOR): New macro.
	(CLASSTYPE_DESTRUCTORS): Robustify.
	(TYPE_HAS_DESTRUCTOR): Remove.
	(check_for_override): Declare.
	(build_vbase_delete): Remove.
	* cvt.c (convert_to_void): Issue errors about pseudo-destructor
	expressions.
	* decl.c (cxx_maybe_build_cleanup): Remove dead code.
	* except.c (dtor_nothrow): Lazily create destructors if necessary.
	(build_throw): Use TYPE_HAS_NONTRIVIAL_DESTRUCTOR.
	* init.c (build_delete): Lazily create destructors, if necessary.
	(build_vbase_delete): Remove.
	* method.c (locate_dtor): Simplify.
	(implicitly_declare_fn): Add support for destructors.
	* parser.c (cp_parser_lookup_name): Lazily create destructors, if
	necessary.
	* pt.c (check_explicit_specialization): Don't use
	TYPE_HAS_DESTRUCTOR.
	(instantiate_class_template): Likewise.
	* ptree.c (cxx_print_type): Don't print TYPE_HAS_DESTRUCTOR.
	* rtti.c (emit_support_tinfos): Robustify.
	* search.c (lookup_fnfields_1): Lazily create destructors.
	* typeck.c (build_class_member_access_expr): Remove
	PSEUDO_DTOR_EXPR handling.
	(lookup_destructor): Likewise.

	PR c++/19733
	* g++.dg/parse/crash23.C: New test.
	* g++.dg/warn/Weff1.C: New test.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@94759 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 16 insertions, 9 deletions

diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 58e0fa8066c..0b4959ba373 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -80,7 +80,7 @@ struct diagnostic_context;
    Usage of TYPE_LANG_FLAG_?:
    0: TYPE_DEPENDENT_P
    1: TYPE_HAS_CONSTRUCTOR.
-   2: TYPE_HAS_DESTRUCTOR.
+   2: Unused
    3: TYPE_FOR_JAVA.
    4: TYPE_HAS_NONTRIVIAL_DESTRUCTOR
    5: IS_AGGR_TYPE.
@@ -1035,8 +1035,9 @@ struct lang_type_class GTY(())
   unsigned lazy_default_ctor : 1;
   unsigned lazy_copy_ctor : 1;
   unsigned lazy_assignment_op : 1;
+  unsigned lazy_destructor : 1;
+
   unsigned has_const_init_ref : 1;
-  
   unsigned has_complex_init_ref : 1;
   unsigned has_complex_assign_ref : 1;
   unsigned non_aggregate : 1;
@@ -1049,7 +1050,7 @@ struct lang_type_class GTY(())
   /* There are some bits left to fill out a 32-bit word.  Keep track
      of this by updating the size of this bitfield whenever you add or
      remove a flag.  */
-  unsigned dummy : 12;
+  unsigned dummy : 11;
 
   tree primary_base;
   VEC (tree_pair_s) *vcall_indices;
@@ -1153,6 +1154,11 @@ struct lang_type GTY(())
 #define CLASSTYPE_LAZY_ASSIGNMENT_OP(NODE) \
   (LANG_TYPE_CLASS_CHECK (NODE)->lazy_assignment_op)
 
+/* Nonzero means that NODE (a class type) has a destructor -- but that
+   it has not yet been declared.  */
+#define CLASSTYPE_LAZY_DESTRUCTOR(NODE) \
+  (LANG_TYPE_CLASS_CHECK (NODE)->lazy_destructor)
+ 
 /* Nonzero means that this _CLASSTYPE node overloads operator=(X&).  */
 #define TYPE_HAS_ASSIGN_REF(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->has_assign_ref)
 
@@ -1236,9 +1242,13 @@ struct lang_type GTY(())
   (VEC_index (tree, CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_CONSTRUCTOR_SLOT))
 
 /* A FUNCTION_DECL for the destructor for NODE.  These are the
-   destructors that take an in-charge parameter.  */
+   destructors that take an in-charge parameter.  If
+   CLASSTYPE_LAZY_DESTRUCTOR is true, then this entry will be NULL
+   until the destructor is created with lazily_declare_fn.  */
 #define CLASSTYPE_DESTRUCTORS(NODE) \
-  (VEC_index (tree, CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_DESTRUCTOR_SLOT))
+  (CLASSTYPE_METHOD_VEC (NODE)						      \
+   ? VEC_index (tree, CLASSTYPE_METHOD_VEC (NODE), CLASSTYPE_DESTRUCTOR_SLOT) \
+   : NULL_TREE)
 
 /* A dictionary of the nested user-defined-types (class-types, or enums)
    found within this class.  This table includes nested member class
@@ -2412,9 +2422,6 @@ struct lang_decl GTY(())
 				   && CONSTRUCTOR_ELTS (NODE) == NULL_TREE \
 				   && ! TREE_HAS_CONSTRUCTOR (NODE))
 
-/* Nonzero for _TYPE means that the _TYPE defines a destructor.  */
-#define TYPE_HAS_DESTRUCTOR(NODE) (TYPE_LANG_FLAG_2 (NODE))
-
 /* Nonzero means that an object of this type can not be initialized using
    an initializer list.  */
 #define CLASSTYPE_NON_AGGREGATE(NODE) \
@@ -3721,6 +3728,7 @@ extern void debug_thunks 			(tree);
 extern tree cp_fold_obj_type_ref		(tree, tree);
 extern void set_linkage_according_to_type       (tree, tree);
 extern void determine_key_method                (tree);
+extern void check_for_override                  (tree, tree);
 
 /* in cvt.c */
 extern tree convert_to_reference (tree, tree, int, int, tree);
@@ -3924,7 +3932,6 @@ extern tree build_vec_init			(tree, tree, tree, int);
 extern tree build_x_delete			(tree, int, tree);
 extern tree build_delete			(tree, tree, special_function_kind, int, int);
 extern void push_base_cleanups			(void);
-extern tree build_vbase_delete			(tree, tree);
 extern tree build_vec_delete			(tree, tree, special_function_kind, int);
 extern tree create_temporary_var                (tree);
 extern void initialize_vtbl_ptrs                (tree);