[Patch] BUG 19551 explicit instantiation confusion for a function with a deduced return type already been instantiated

Clang Frontend
1

Hi,

Attaching Patch for bug 19551. Please help in reviewing it.

I am checking for return type as auto in template declaration and explicit template instantiation. This patch resolves bug 19551 and has no regressions. I am not sure though if this is the correct approach.

Please help in reviewing and corrections.

PR_19551.patch (2.72 KB)

2

The patch isn't correct. It allows a return type of 'auto' to match a
return type of 'auto *', for instance.

The right thing to do here is to compare the declared return type (obtained
from the type source info on the function declaration), not the actual
return type. (If the declared return type is missing the 'auto', that's a
bug.)

3

Thanks Richard for your review.

Just to be sure, clarifying things. In our test case :

template auto f(T) { return 0; } // Line 1
int k = f(0); // Line 2
template auto f(int); // Line 3
template int f(int); // Line 4

Do you mean that we should compare the declared return type i.e return type declared in
template declaration (i.e the line 1) with declared return type in explicit instantiation(line 3)?
And those we will get from type source info for both ?

Also is this the right way to compare two auto types - (A->getContainedAutoType() && B->getContainedAutoType()) ?
Context.hasSameType for both being auto don’t return true, probably because two auto’s will not necessarily deduce to same type.

(If true, ArgFunctionType passed in the function as argument is already from TypeSource info of the instantiation, so we need only return type from type source info of template declaration, and compare them for auto type.)

Thanks again for quick review.

4

Thanks Richard for your review.

Just to be sure, clarifying things. In our test case :

*template<typename T> auto f(T) { return 0; } // Line 1*
*int k = f(0); // Line 2*
*template auto f(int); // Line 3*
*template int f(int); // Line 4*

Do you mean that we should compare the declared return type i.e return
type declared in
template declaration (i.e the line 1) with declared return type in
explicit instantiation(line 3)?
And those we will get from type source info for both ?

What I mean is, we should compare the return type in the type source info
(getTypeSourceInfo) not the return type in the type (getType) of the
function. The former should have 'auto' in it, the latter will have an
actual type. The types in the type source info should be the same; the
types in the declaration might not be.

Also is this the right way to compare two auto types - *(A->getContainedAutoType()
&& B->getContainedAutoType()) ?*
*Context.hasSameType* for both being auto don't return true, probably
because two auto's will not necessarily deduce to same type.

hasSameType is the right check, once you get hold of the declared/undeduced
type. Note that 'auto *' and 'const auto &' will both have a contained auto
type, so your comparison won't do the right thing there.

(If true, ArgFunctionType passed in the function as argument is already

5

Hi Richard,

As per your comments, I am now comparing return type from type source info.
By this way we are able to catch hold of ’ auto ’ as return type of declared function.
If the return types from type source info do not match, then error is emitted.

I am doing this only for auto types, as there can be return type of template
parameter of the declared template (in which, we do not compare as template parameter can equal actual return type).

Patch Code highlight:

TypeSourceInfo *TI = Function->getTypeSourceInfo();
QualType FuncReturnType = TI->getType()->castAs()->getReturnType();
if (isa(ArgFunctionType)){
QualType ArgFunctionReturnType = ArgFunctionType->getAs()->getReturnType();
// We check for auto contained type to eliminate checking template parameter as return type
if (FuncReturnType->getContainedAutoType()){
if (!Context.hasSameType(ArgFunctionReturnType,FuncReturnType))
return TDK_MiscellaneousDeductionFailure;
else
return TDK_Success;
}
}

Bug 19551 gets resolved with this patch.

Test case :

template auto f(T) { return 0; }
int k = f(0); // #1
template auto f(int); // #2
template int f(int); // #3

Output with patch :

suyog@suyog-Inspiron-N5010:~$ llvm/llvm/build/bin/clang bug_19551.C -std=c++1y
bug_19551.C:4:14: error: explicit instantiation of ‘f’ does not refer to a function template, variable template, member function, member class,
or static data member
template int f(int); // #3
^
bug_19551.C:1:27: note: candidate template ignored: failed template argument deduction
template auto f(T) { return 0; }
^
1 error generated.

This patch also differentiates between ’ auto ’ and ’ auto* ’ and throws error for such case too.

However, I am getting 1 regression in file test/SemaCXX/cxx1y-deduced-return-type.cpp.

It contains cases where return types are same and we also need to check if Specialization type

matches with ArgFunction Type - which is exactly opposite to our test case
(Specialization type doesn’t match with ArgFunction Type in our test case 19551). Its like trying to validate true and false

at the same time.

I am attaching patch for the reference. (test case excluded for a while).

Your comment will be a great help to resolve this. Thanks !

19551.patch (2.89 KB)