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

Hi,

I was looking at Bug 19551.

The test case is as follows :

<i>template<typename T> auto f(T) { return 0; }
int k = f(0); // #1
template auto f(int); // #2
template int f(int); // #3</i>
Without line #1, clang accept #2 and reject #3.
With line #1, clang reject #2 and accept #3.

I debug this code and found following :

1. When the function template is instantiated (#1), clang visits functions

   *Sema::AddTemplateOverloadCandidate*
 *Sema::DeduceTemplateArguments*
 *Sema::FinishTemplateArgumentDeduction*

In *Sema::FinishTemplateArgumentDeduction* function, it creates a Specialization of the functiontemplate :

 *Specialization = cast_or_null<FunctionDecl>(*
 *SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner,*
 _MultiLevelTemplateArgumentList(*DeducedArgumentList)));_

The return type of the created Specialization is 'auto' at this point. After this, 
it completes deduction of TemplateArguments and adds this Specialization as overloaded 

candidate. The return type still remains 'auto'.

2. When clang process #2 (explicit instantiation), clang visits following function :

     *Sema::ActOnExplicitInstantiation*
 *Sema::DeduceTemplateArguments*

 *Sema::FinishTemplateArgumentDeduction*

Again clang creates Specialization as in point 1 above, but strangely, 
this time the return type of Specialization is 'int' though the return type of 

FunctionTemplate remains 'auto'. Since this return type 'int' does not match with 
return type of explicit instantiation i.e. 'auto', the DeduceTemplateArguments return 
failure.

 *Sema::DeduceTemplateArguments{*
 *.................*
 *................*
<i>
          ..................</i>

 *else if(!InOverloadResolution && !AT &&*
 *!Context.hasSameType(Specialization->getType(), ArgFunctionType)) //ArgFunctionType - auto* 
<i>

                                                                              // SpecializationType - int</i>
 *return TDK_MiscellaneousDeductionFailure;*

*}*

Hence, we get error for line #2. For Line #3, the Specialization Type and ArgFunctionType 

both are 'int'*,* hence we get no error for Line #3.

If there is no prior instantiation, Line #2 will succeed while Line #3 will throw error.

Do we deduce return type during function template instantiation along with template parameters?
( Which i guess we should not but we are probably doing it as evident as the return type of second Specialization becomes 'int')

How should we prevent deduction of return type for second Specialization? (I tried a lot but couldn't find a way).
GCC 4.8.2 is also behaving same as clang as described in the bug. 

Richard, any comment/help ? This bug was filed by you :)