Hi,
On 07/23/2013 05:27 PM, Jason Merrill wrote:
Hmm, I suppose this could still end up doing unnecessary completions
if both types are incomplete. What happens if X is also incomplete?
Indeed, it fails and shouldn't. I thought I had tested this case but
didn't. Thus I extended a bit the testcase.
The version that returns false if either is incomplete would give the
wrong answer if the types are the same.
I think a better way would be to use COMPARE_STRICT if either type is
incomplete.
I see. Just don't bother looking for inheritance in all such cases, can
only cause troubles. Thus shall we implement this like in the below? It
passes testing.
Thanks!
Paolo.
////////////////////
Index: cp/cp-tree.h
===================================================================
--- cp/cp-tree.h (revision 201148)
+++ cp/cp-tree.h (working copy)
@@ -6022,7 +6022,7 @@ extern tree convert_for_initialization (tree,
tre
extern int comp_ptr_ttypes (tree, tree);
extern bool comp_ptr_ttypes_const (tree, tree);
extern bool error_type_p (const_tree);
-extern int ptr_reasonably_similar (const_tree, const_tree);
+extern bool ptr_reasonably_similar (const_tree, const_tree);
extern tree build_ptrmemfunc (tree, tree, int, bool,
tsubst_flags_t);
extern int cp_type_quals (const_tree);
Index: cp/typeck.c
===================================================================
--- cp/typeck.c (revision 201148)
+++ cp/typeck.c (working copy)
@@ -8599,10 +8599,10 @@ error_type_p (const_tree type)
}
}
-/* Returns 1 if to and from are (possibly multi-level) pointers to the same
+/* Returns true if to and from are (possibly multi-level) pointers to the same
type or inheritance-related types, regardless of cv-quals. */
-int
+bool
ptr_reasonably_similar (const_tree to, const_tree from)
{
for (; ; to = TREE_TYPE (to), from = TREE_TYPE (from))
@@ -8614,7 +8614,7 @@ ptr_reasonably_similar (const_tree to, const_tree
return !error_type_p (to);
if (TREE_CODE (to) != TREE_CODE (from))
- return 0;
+ return false;
if (TREE_CODE (from) == OFFSET_TYPE
&& comptypes (TYPE_OFFSET_BASETYPE (to),
@@ -8624,19 +8624,24 @@ ptr_reasonably_similar (const_tree to, const_tree
if (TREE_CODE (to) == VECTOR_TYPE
&& vector_types_convertible_p (to, from, false))
- return 1;
+ return true;
if (TREE_CODE (to) == INTEGER_TYPE
&& TYPE_PRECISION (to) == TYPE_PRECISION (from))
- return 1;
+ return true;
if (TREE_CODE (to) == FUNCTION_TYPE)
return !error_type_p (to) && !error_type_p (from);
if (!TYPE_PTR_P (to))
- return comptypes
- (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
- COMPARE_BASE | COMPARE_DERIVED);
+ {
+ /* When either type is incomplete avoid DERIVED_FROM_P,
+ which may call complete_type (c++/57942). */
+ bool b = !COMPLETE_TYPE_P (to) || !COMPLETE_TYPE_P (from);
+ return comptypes
+ (TYPE_MAIN_VARIANT (to), TYPE_MAIN_VARIANT (from),
+ b ? COMPARE_STRICT : COMPARE_BASE | COMPARE_DERIVED);
+ }
}
}
Index: testsuite/g++.dg/inherit/pr57942.C
===================================================================
--- testsuite/g++.dg/inherit/pr57942.C (revision 0)
+++ testsuite/g++.dg/inherit/pr57942.C (working copy)
@@ -0,0 +1,9 @@
+// PR c++/57942
+
+template<typename T> struct S { typename T::error type; };
+struct X {};
+void f(S<int>*);
+void f(...);
+void g() { f((X*)0); }
+struct Y;
+void h() { f((Y*)0); }
