Function aliasing problem

[Jean-Louis Leroy via Digitalmars-d-learn]

I can alias a function template:

    T f(T)(T x) { return x; }
    alias g = f;
    int a = g(42);

I can alias a static function:

    struct S
    {
      static int f(int i) { return i; }
    }

    alias sf = S.f;
    int b = sf(42);

I can alias to a static function in a template instance:

    struct SS(T)
    {
      static T f(T i) { return i; }
    }

    alias ssi = SS!int.f;
    int c = ssi(42);

Of course an alias can be templatized:

    alias SSS(T) = SS!T;

I would like to combine them all, e.g.:

    alias sst(T) = SS!T.f;
    int d = sst(42); // <=> SS!int.f(42)

But it fails like this:

    aliasstaticfunction.d(23): Error: template 
`aliasstaticfunction.sst` cannot deduce function from argument 
types `!()(int)`, candidates are:
    aliasstaticfunction.d(22):        `sst(T)`

In fact this simpler attempt fails in the same fashion:

    alias g2(X) = f!X;
    int e = g(42);

    aliasstaticfunction.d(25): Error: template 
`aliasstaticfunction.g2` cannot deduce function from argument 
types `!()(int)`, candidates are:
    aliasstaticfunction.d(24):        `g2(X)`

I tried with an eponymous template declaring an alias, in place 
of the alias template. Unsurprisingly, I get the same error (the 
latter is lowered to the former isn't it?).

I also tried std.meta.Alias, to no avail.

Is there a solution, other than building a templatized forwarder 
function, e.g.:

    T sst(T)(T i) { return SS!T.f(i); }
    int d = sst(42);

(and this is not good anyway, as it drops function attributes, 
parameter storage classes, UDAs etc).