[Bug c++/77335] New: templates and ambiguous call to overloaded function

["pyer4 at free dot fr" <gcc-bugzilla at gcc dot gnu dot org>]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77335

            Bug ID: 77335
           Summary: templates and ambiguous call to overloaded function
           Product: gcc
           Version: 6.2.1
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: pyer4 at free dot fr
  Target Milestone: ---

In some cases, function overloading seems to create ambiguity. When the
function contains multiple template arguments. Encountered on MSVC2015, and
tested at : http://melpon.org/wandbox/permlink/mtfWJXEtQ8lEP8ub

template<class> struct A { };
template<template<class> class, class> struct B { };
template<class, class> struct C { };

template<template<class> class TT, class T, class U> void f(TT<T>, B<TT, T>, U)
{ }
template<template<class> class TT, class T, class V> void f(TT<T>, B<TT, T>,
C<TT<T>, V>) { }

int main()
{
   A<int> a;
   B<A, int> b;
   C<A<int>, long> c;
   f(a, b, c);//ambiguity error
}

--------------------------------------------------
Another example :

template <class T>
class BX {
public :
    BX() {}
    ~BX() {}
};

template <class T1, class T2>
class G {
public :
    G() {}
    ~G() {}
};

template <template <class T> class T1, class T>
class DT {};

class B {
public :
    template <template <class T> class T1, class T, class M>
    static void func(const M& m, const DT<T1, T>* dt, T1<T>& val) {}

    template <template <class T> class T1, class T, class M>
    static void func(const G<T1<T>, M>& g, const DT<T1, T>* dt, T1<T>& val) {}

    //here is a small variation of func as a test
    template <template <class T> class T1, class T, class M>
    static void func2(const M& m, const DT<T1, T>* dt) {}

    template <template <class T> class T1, class T, class M>
    static void func2(const G<T1<T>, M>& g, const DT<T1, T>* dt) {}
};

int main() {
    BX< int > bx;
    G<BX< int >, int> g;
    DT<BX, int>* dt;
    B::func(g, dt, bx);//Error  C2668   'B::func': ambiguous call to overloaded
function
    B::func2(g, dt);//no error
}

Problem also submitted at :
http://stackoverflow.com/questions/39060180/c-templates-and-ambiguous-call-to-overloaded-function