MatCat.OpenSource/8sa1-gcc
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

re PR c++/21799 (Spurious ambiguity with pointers to members)

Browse Source 
cp:
	PR c++/21799
	PR c++/8271
        * pt.c (unify) <METHOD_TYPE>: Check this-pointer cv-qualifiers
	explicitly.

	PR c++/21799
	Revert my 2005-07-08 patch
	* pt.c (type_unification_real): Remove is_method_argument and
	assoicated checks.
	(fn_type_unification, unify): Adjust type_unification_real calls.

From-SVN: r103021
This commit is contained in:
Nathan Sidwell 2005-08-12 09:23:43 +00:00
parent ec92bd4bd8
commit 38d18b1a1e
2 changed files with 32 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
gcc/cp/ChangeLog
View File

@ -1,3 +1,19 @@
2005-08-12 Giovanni Bajo <giovannibajo@libero.it>
Nathan Sidwell <nathan@codesourcery.com>
PR c++/21799
PR c++/8271
* pt.c (unify) <METHOD_TYPE>: Check this-pointer cv-qualifiers
explicitly.
2005-08-12 Nathan Sidwell <nathan@codesourcery.com>
PR c++/21799
Revert my 2005-07-08 patch
* pt.c (type_unification_real): Remove is_method_argument and
assoicated checks.
(fn_type_unification, unify): Adjust type_unification_real calls.
2005-08-11 Volker Reichelt <reichelt@igpm.rwth-aachen.de> 2005-08-11 Volker Reichelt <reichelt@igpm.rwth-aachen.de>
PR c++/23266 PR c++/23266

45
gcc/cp/pt.c
View File

@ -109,7 +109,7 @@ static tree add_outermost_template_args (tree, tree);
static bool check_instantiated_args (tree, tree, tsubst_flags_t); static bool check_instantiated_args (tree, tree, tsubst_flags_t);
static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*); static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*);
static int type_unification_real (tree, tree, tree, tree, static int type_unification_real (tree, tree, tree, tree,
int, unification_kind_t, int); int, unification_kind_t);
static void note_template_header (int); static void note_template_header (int);
static tree convert_nontype_argument_function (tree, tree); static tree convert_nontype_argument_function (tree, tree);
static tree convert_nontype_argument (tree, tree); static tree convert_nontype_argument (tree, tree);
@ -9197,7 +9197,7 @@ fn_type_unification (tree fn,
event. */ event. */
result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn), result = type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
targs, parms, args, /*subr=*/0, targs, parms, args, /*subr=*/0,
strict, 0); strict);
if (result == 0) if (result == 0)
/* All is well so far. Now, check: /* All is well so far. Now, check:
@ -9305,9 +9305,7 @@ maybe_adjust_types_for_deduction (unification_kind_t strict,
If SUBR is 1, we're being called recursively (to unify the If SUBR is 1, we're being called recursively (to unify the
arguments of a function or method parameter of a function arguments of a function or method parameter of a function
template). If IS_METHOD is true, XPARMS are the parms of a template). */
member function, and special rules apply to cv qualification
deduction on the this parameter. */
static int static int
type_unification_real (tree tparms, type_unification_real (tree tparms,
@ -9315,8 +9313,7 @@ type_unification_real (tree tparms,
tree xparms, tree xparms,
tree xargs, tree xargs,
int subr, int subr,
unification_kind_t strict, unification_kind_t strict)
int is_method)
{ {
tree parm, arg; tree parm, arg;
int i; int i;
@ -9368,26 +9365,6 @@ type_unification_real (tree tparms,
template args from other function args. */ template args from other function args. */
continue; continue;
if (is_method)
{
/* The cv qualifiers on the this pointer argument must match
exactly. We cannot deduce a T as const X against a const
member function for instance. */
gcc_assert (TREE_CODE (parm) == POINTER_TYPE);
gcc_assert (TREE_CODE (arg) == POINTER_TYPE);
/* The restrict qualifier will be on the pointer. */
if (cp_type_quals (parm) != cp_type_quals (arg))
return 1;
parm = TREE_TYPE (parm);
arg = TREE_TYPE (arg);
if (cp_type_quals (parm) != cp_type_quals (arg))
return 1;
parm = TYPE_MAIN_VARIANT (parm);
arg = TYPE_MAIN_VARIANT (arg);
is_method = 0;
}
/* Conversions will be performed on a function argument that /* Conversions will be performed on a function argument that
corresponds with a function parameter that contains only corresponds with a function parameter that contains only
non-deducible template parameters and explicitly specified non-deducible template parameters and explicitly specified
@ -10288,12 +10265,22 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict)
if (TREE_CODE (arg) != TREE_CODE (parm)) if (TREE_CODE (arg) != TREE_CODE (parm))
return 1; return 1;
/* CV qualifications for methods can never be deduced, they must
match exactly. We need to check them explicitly here,
because type_unification_real treats them as any other
cvqualified parameter. */
if (TREE_CODE (parm) == METHOD_TYPE
&& (!check_cv_quals_for_unify
(UNIFY_ALLOW_NONE,
TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (arg))),
TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (parm))))))
return 1;
if (unify (tparms, targs, TREE_TYPE (parm), if (unify (tparms, targs, TREE_TYPE (parm),
TREE_TYPE (arg), UNIFY_ALLOW_NONE)) TREE_TYPE (arg), UNIFY_ALLOW_NONE))
return 1; return 1;
return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm), return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm),
TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT, TYPE_ARG_TYPES (arg), 1, DEDUCE_EXACT);
TREE_CODE (parm) == METHOD_TYPE);
case OFFSET_TYPE: case OFFSET_TYPE:
/* Unify a pointer to member with a pointer to member function, which /* Unify a pointer to member with a pointer to member function, which