template<class T> struct A {
static T t; // 1
T *pt;      // 2
};

typedef int function();
A<function> a;  // ill-formed: would declare A<function>::t
                // as a static member function

14.3.1/3 If a declaration acquires a function type through a type dependent on a template-parameter and this causes a declaration that does not use the syntactic form of a function declarator to have function type, the program is ill-formed.

typedef int function();

template<class T> struct A {
  // static T t;     // 1 - ill-formed, type dependent on a template-parameter
  static function t; // 1a - Ok
  T *pt;             // 2 - ???
  typedef T T2;      // 3 - ???
};

A<function> a; // комментарии выше указаны исключительно для данной специализации

I submitted a reduced version of the code to Comeau and asked them why it didn't compile. It turns out to be 14.3.1/3

... and this causes a declaration ... to have function type

void helper()
{
}

struct foo
{
    void bar() {}
};

template <class T, class F>
void check(F T::*)
{
    F* ptr = &helper; // error C2440: 'initializing' : cannot convert from 'void (__cdecl *)(void)' to 'void (*)(void)'
}

int main()
{
    check(&foo::bar);
    return 0;
}

typedef void X();
void g(X)

template<class F>
struct A
{
  void f(F f);
};

8.3.5/3
The type of a function is determined using the following rules. The type of each parameter is determined from its own decl-specifier-seq and declarator. After determining the type of each parameter, any parameter of type “array of T” or “function returning T” is adjusted to be “pointer to T” or “pointer to function returning T,” respectively.

14.3.1/3
If a declaration acquires a function type through a type dependent on a template-parameter and this causes a declaration that does not use the syntactic form of a function declarator to have function type, the program is ill-formed.

A>void helper()
A>{
A>}

A>struct foo
A>{
A>    void bar() {}
A>};

A>template <class T, class F>
A>void check(F T::*)
A>{
A>    F* ptr = &helper; // error C2440: 'initializing' : cannot convert from 'void (__cdecl *)(void)' to 'void (*)(void)'
A>}

A>int main()
A>{
A>    check(&foo::bar);
A>    return 0;
A>}
A>

RT f(A);

А>template<class T> struct A {
А>static T t; // 1
А>T *pt;      // 2
А>};

А>typedef int function();
А>A<function> a;  // ill-formed: would declare A<function>::t
А>                // as a static member function
А>

8.3.5/7 A typedef of function type may be used to declare a function but shall not be used to define a function (dcl.fct.def). [Example:

typedef void F();
F fv; // OK: equivalent to void fv();
F fv { } // ill-formed
void fv() { } // OK: definition of fv


--- end example] A typedef of a function type whose declarator includes a cv-qualifier-seq shall be used only to declare the function type for a nonstatic member function, to declare the function type to which a pointer to member refers, or to declare the top-level function type of another function typedef declaration. [Example:

typedef int FIC(int) const;
FIC f; // ill-formed: does not declare a member function
struct S {
FIC f; // OK
};
FIC S::*pm = &S::f; // OK


--- end example]