Fixed in r208825, but I'm leaving this open because we're not done here yet. We still incorrectly accept these:

  template<typename T> struct S {
    void f(T);
  };
  S<void () const> s1;
  S<void () &> s2;

... because we don't properly validate the pointer type we build when performing function-to-pointer decay.

Fixed in r208825, but I'm leaving this open because we're not done here yet.
We still incorrectly accept these:

template struct S {
void f(T);
};
S<void () const> s1;
S<void () &> s2;

... because we don't properly validate the pointer type we build when
performing function-to-pointer decay.

Good afternoon,

so, in the context of this question I would like to clarify, that this rule (8.3.1/4):

Forming a reference to function type is ill-formed if the function type has cv-qualifiers or a ref-qualifier

applicable for this code:

#include <iostream>

template <typename F>
void (* test()) (F);

template <typename X> 
char (& probe( void(*) ( X * ) ) )[1];

template <typename X> 
char (& probe( void(*) ( X   ) ) )[2];

int main()
{
    std::cout << sizeof(probe(test<void() const>()));
}

in context of C++14 standard (for versions 3.4 and earlier this code prints 1, 3.5 and higher prints 2)?

And what about C++03 (in which there is no explicit limitation)? Behaviour whould same, or not?

And what about C++03 (in which there is no explicit limitation)? Behaviour whould same, or not?

The explicit limitation was added by DR CWG1417, so the behavior should be same in old modes.

@llvm/issue-subscribers-clang-frontend

Author: None (llvmbot)

-Wall -Wextra -std=c++11 -pedantic 

-Wall -Wextra -std=c++1y -pedantic

//---------------------
template<class T>
struct add_ptr 
{
  using type = T*;
};

int main() {
  using FC = void () const;
  using PFC = add_ptr<FC>::type;
  using FLR = void () &;
  using PFLR = add_ptr<FLR>::type;
  using FRR = void () &&;
  using PFRR = add_ptr<FRR>::type;
}
//---------------------