Template expansion bug?

[Steven Schveighoffer]

While doing some testing, I came across this behavior:

template foo(T) {
     void foo() {}
}

void main()
{
     foo!(int).foo();
     //foo!(int)(); // this works
}

Error:
testbug.d(7): Error: template testbug.foo does not match any function  
template declaration. Candidates are:
testbug.d(1):        testbug.foo(T)()
testbug.d(7): Error: template testbug.foo(T)() cannot deduce template  
function from argument types !()(void)

This happens on 2.063 and 2.061.

 From D spec: http://dlang.org/template.html

If a template has exactly one member in it, and the name of that member is  
the same as the template name, that member is assumed to be referred to in  
a template instantiation:

template Foo(T) {
   T Foo; // declare variable Foo of type T
}

void test() {
   Foo!(int) = 6; // instead of Foo!(int).Foo
}

...



I would have expected that foo!(int).foo() is equivalent to foo!(int)().   
Is this no longer the case?  Is there some issue here with DMD  
aggressively evaluating foo!(int) to be a call because of the no-arg  
function?

Actually, it does seem that way, if I change foo to accept a parameter,  
and call:

foo!(int).foo(1);

I get:

testbug.d(7): Error: foo (int t) is not callable using argument types ()
testbug.d(7): Error: foo (int t) is not callable using argument types ()

(and yes, double the error).

I can't at the moment think of a reason why anyone would ever use the full  
syntax, but I would expect it to be accessible, and for the compiler to  
treat foo as a template first, function call second.

-Steve