[Bug libstdc++/49107] New: [C++0x] incomplete type regression with std::pair

[Bug libstdc++/49107] New: [C++0x] incomplete type regression with std::pair

[marc.glisse at normalesup dot org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

           Summary: [C++0x] incomplete type regression with std::pair
           Product: gcc
           Version: 4.7.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: libstdc++
        AssignedTo: unassigned@gcc.gnu.org
        ReportedBy: marc.glisse@normalesup.org


Hello,

this code very recently stopped compiling. I am reporting it against libstdc++
because it uses std::pair, but feel free to reassign to the C++ FE if
appropriate, I didn't have time to investigate further.

#include <utility>

template < class R_ >
struct VectorH3
{
  typedef typename R_::RT                   RT;
  typedef typename R_::Ray_3                Ray_3;
  typedef typename R_::Line_3               Line_3;
  VectorH3() {}
  VectorH3(const Ray_3& r) ; 
  VectorH3(const Line_3& l) ; 
  VectorH3(const RT& x, const RT& y, const RT& z, const RT& w) ;
};

template < class R_ >
class RayH3
{
   typedef typename R_::Point_3              Point_3;
   typedef typename R_::Vector_3             Vector_3;
   typedef std::pair<Point_3, Vector_3>             Rep;
   Rep base;
};

template < class R_ >
struct LineC3
{
  typedef typename R_::Point_3              Point_3;
  typedef typename R_::Vector_3             Vector_3;
  typedef std::pair<Point_3, Vector_3>             Rep;
  Rep base;
};

template < typename Kernel >
struct Homogeneous_base
{
    typedef double                                  RT;
    struct Point_3{};
    typedef VectorH3<Kernel>                        Vector_3;
    typedef LineC3<Kernel>                          Line_3;
    typedef RayH3<Kernel>                           Ray_3;
    struct Construct_vector_3
    {
    Vector_3 operator()(const RT& x, const RT& y, const RT& z, const RT& w)
const
    { return Vector_3(x, y, z, w); }
    };
};

struct Simple_homogeneous
  : public Homogeneous_base< Simple_homogeneous >
{};

int main()
{
  Simple_homogeneous::Construct_vector_3()( 8, 2, 4, 1);
}



$ c++ -std=gnu++0x -c Simple_homogeneous.cpp
Simple_homogeneous.cpp: In instantiation of 'LineC3<Simple_homogeneous>':
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:730:46:
  instantiated from
'std::__is_direct_constructible_impl<VectorH3<Simple_homogeneous>,
VectorH3<Simple_homogeneous>&&>'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:79:12:
  instantiated from
'std::__and_<std::is_destructible<VectorH3<Simple_homogeneous> >,
std::__is_direct_constructible_impl<VectorH3<Simple_homogeneous>,
VectorH3<Simple_homogeneous>&&> >'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:734:12:
  instantiated from
'std::__is_direct_constructible_new_safe<VectorH3<Simple_homogeneous>,
VectorH3<Simple_homogeneous>&&>'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:806:12:
  instantiated from
'std::__is_direct_constructible_new<VectorH3<Simple_homogeneous>,
VectorH3<Simple_homogeneous>&&>'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:814:12:
  instantiated from
'std::__is_direct_constructible<VectorH3<Simple_homogeneous>,
VectorH3<Simple_homogeneous>&&>'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:853:12:
  [ skipping 4 instantiation contexts ]
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:981:12:
  instantiated from
'std::__is_nothrow_move_constructible_impl<VectorH3<Simple_homogeneous>,
false>'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:987:12:
  instantiated from
'std::is_nothrow_move_constructible<VectorH3<Simple_homogeneous> >'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/bits/stl_pair.h:185:7:
  instantiated from 'std::pair<Homogeneous_base<Simple_homogeneous>::Point_3,
VectorH3<Simple_homogeneous> >'
Simple_homogeneous.cpp:21:8:   instantiated from 'RayH3<Simple_homogeneous>'
Simple_homogeneous.cpp:44:30:   instantiated from
'Homogeneous_base<Kernel>::Vector_3
Homogeneous_base<Kernel>::Construct_vector_3::operator()(const RT&, const RT&,
const RT&, const RT&) const [with Kernel = Simple_homogeneous,
Homogeneous_base<Kernel>::Vector_3 = VectorH3<Simple_homogeneous>,
Homogeneous_base<Kernel>::RT = double]'
Simple_homogeneous.cpp:54:55:   instantiated from here
Simple_homogeneous.cpp:30:7: error: 'LineC3<R_>::base' has incomplete type
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/bits/stl_pair.h:88:12:
error: declaration of 'LineC3<Simple_homogeneous>::Rep'

[Bug libstdc++/49107] [C++0x] incomplete type regression with std::pair

[paolo.carlini at oracle dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

Paolo Carlini <paolo.carlini at oracle dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |NEW
   Last reconfirmed|                            |2011.05.22 11:27:24
                 CC|                            |daniel.kruegler at
                   |                            |googlemail dot com, jason
                   |                            |at redhat dot com
     Ever Confirmed|0                           |1

--- Comment #1 from Paolo Carlini <paolo.carlini at oracle dot com> 2011-05-22 11:27:24 UTC ---
I think since std::pair started using noexcept and therefore is_constructible &
co. Frankly doesn't look to me like a library-proper issue, I'm adding Daniel
and Jason in CC... If you could reduce it a bit more, it would be great.

[Bug libstdc++/49107] [C++0x] incomplete type regression with std::pair

[paolo.carlini at oracle dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

Paolo Carlini <paolo.carlini at oracle dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |paolo.carlini at oracle dot
                   |                            |com

--- Comment #2 from Paolo Carlini <paolo.carlini at oracle dot com> 2011-05-22 11:50:57 UTC ---
The path is from the noexcept is pair::swap to the noexcept in std::swap. Both
are completely straightforward implementation of the FDIS. Thus, either
something in std::is_constructible or the C++ front-end.

[Bug libstdc++/49107] [C++0x] incomplete type regression with std::pair

[marc.glisse at normalesup dot org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #3 from Marc Glisse <marc.glisse at normalesup dot org> 2011-05-22 12:12:50 UTC ---
(In reply to comment #1)
> I think since std::pair started using noexcept and therefore is_constructible &
> co. Frankly doesn't look to me like a library-proper issue, I'm adding Daniel
> and Jason in CC... If you could reduce it a bit more, it would be great.

Slightly reduced below. I hope noexcept doesn't have the same issues as the
concept checking mode of the library...


#include <type_traits>

namespace std
{
  template<typename _Tp>
    inline void
    swap(_Tp& __a, _Tp& __b)
    noexcept(is_nothrow_move_constructible<_Tp>::value
             && is_nothrow_move_assignable<_Tp>::value) ;

  template<class _T1, class _T2>
    struct pair
    {
      _T1 first;
      _T2 second;

      void
      swap(pair& __p)
      noexcept(noexcept(swap(first, __p.first))
               && noexcept(swap(second, __p.second))) ;

    };
}

template < class R_ >
struct VectorH3
{
  typedef typename R_::RT                   RT;
  typedef typename R_::Ray_3                Ray_3;
  typedef typename R_::Line_3               Line_3;
  VectorH3() {}
  VectorH3(const Ray_3& r) ;
  VectorH3(const Line_3& l) ;
  VectorH3(const RT& x, const RT& y, const RT& z, const RT& w) ;
};

template < class R_ >
class RayH3
{
   typedef typename R_::Point_3              Point_3;
   typedef typename R_::Vector_3             Vector_3;
   typedef std::pair<Point_3, Vector_3>             Rep;
   Rep base;
};

template < class R_ >
struct LineC3
{
  typedef typename R_::Point_3              Point_3;
  typedef typename R_::Vector_3             Vector_3;
  typedef std::pair<Point_3, Vector_3>             Rep;
  Rep base;
};

struct Kernel
{
    typedef double                                  RT;
    struct Point_3{};
    typedef VectorH3<Kernel>                        Vector_3;
    typedef LineC3<Kernel>                          Line_3;
    typedef RayH3<Kernel>                           Ray_3;
    struct Construct_vector_3
    {
    Vector_3 operator()(const RT& x, const RT& y, const RT& z, const RT& w)
const
    { return Vector_3(x, y, z, w); }
    };
};


int main()
{
  Kernel::Construct_vector_3()( 8, 2, 4, 1);
}

[Bug c++/49107] [C++0x] incomplete type regression with std::pair

[paolo.carlini at oracle dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

Paolo Carlini <paolo.carlini at oracle dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
          Component|libstdc++                   |c++

--- Comment #4 from Paolo Carlini <paolo.carlini at oracle dot com> 2011-05-22 12:28:51 UTC ---
Thanks Marc. Well, now I would say it's a C++ front-end issue.

Consider the below: uncomment the seemingly unrelated VectorH3 constructor from
const Line_3&, and doesn't compile anymore.

////////////////

#include <type_traits>

template<typename _Tp>
  inline void
  swap(_Tp& __a, _Tp& __b)
  noexcept(std::is_nothrow_move_constructible<_Tp>::value) ;

template<class _T1>
  struct pair
  {
    _T1 first;

    void
    swap(pair& __p)
    noexcept(noexcept(swap(first, __p.first)));
  };

template < class R_ >
struct VectorH3
{
  typedef typename R_::RT                   RT;
  typedef typename R_::Ray_3                Ray_3;
  typedef typename R_::Line_3               Line_3;
  VectorH3() {}
  VectorH3(const Ray_3& r) ;
  // VectorH3(const Line_3& l) ;
  VectorH3(const RT& x, const RT& y, const RT& z, const RT& w) ;
};

template < class R_ >
class RayH3
{
   typedef typename R_::Vector_3             Vector_3;
   typedef pair<Vector_3>             Rep;
   Rep base;
};

template < class R_ >
struct LineC3
{
  typedef typename R_::Vector_3             Vector_3;
  typedef pair<Vector_3>             Rep;
  Rep base;
};

struct Kernel
{
    typedef double                                  RT;
    typedef VectorH3<Kernel>                        Vector_3;
    typedef LineC3<Kernel>                          Line_3;
    typedef RayH3<Kernel>                           Ray_3;
    struct Construct_vector_3
    {
    Vector_3
    operator()(const RT& x, const RT& y, const RT& z, const RT& w) const
    { return Vector_3(x, y, z, w); }
    };
};


int main()
{
  Kernel::Construct_vector_3()( 8, 2, 4, 1);
}

[Bug c++/49107] [C++0x] incomplete type regression with std::pair

[marc.glisse at normalesup dot org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #5 from Marc Glisse <marc.glisse at normalesup dot org> 2011-05-22 13:03:53 UTC ---
(In reply to comment #4)
> Thanks Marc. Well, now I would say it's a C++ front-end issue.

Ok.

> Consider the below: uncomment the seemingly unrelated VectorH3 constructor from
> const Line_3&, and doesn't compile anymore.

Yes, I left it there for a reason ;-)

Stripping <type_traits> to have 0 includes:

namespace std
{
        template<typename _Tp>
                _Tp declval() noexcept;

        template<typename _Tp , typename = decltype(::new
_Tp(declval<_Tp&&>()))>
                struct ploum
                {
                        static const bool value=true;
                };

        template<class _T2>
                struct pair
                {
                        _T2 second;
                        void swap(pair& __p)
                                noexcept(ploum<_T2>::value);
                };
}

template < class R_ >
struct VectorH3
{
        typedef typename R_::RT                   RT;
        typedef typename R_::Ray_3                Ray_3;
        typedef typename R_::Line_3               Line_3;
        VectorH3() {}
        VectorH3(const Ray_3& r) ;
        VectorH3(const Line_3& l) ;
        VectorH3(const RT& x, const RT& y) ;
};

template < class R_ >
class RayH3
{
        typedef typename R_::Vector_3             Vector_3;
        typedef std::pair<Vector_3>             Rep;
        Rep base;
};

template < class R_ >
struct LineC3
{
        typedef typename R_::Vector_3             Vector_3;
        typedef std::pair<Vector_3>             Rep;
        Rep base;
};

struct Kernel
{
        typedef double                                  RT;
        typedef VectorH3<Kernel>                        Vector_3;
        typedef LineC3<Kernel>                          Line_3;
        typedef RayH3<Kernel>                           Ray_3;
        struct Construct_vector_3
        {
                Vector_3 operator()(const RT& x, const RT& y)
                        const
                        { return Vector_3(x, y); }
        };
};


int main()
{
        Kernel::Construct_vector_3()( 8, 2);
}

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[paolo.carlini at oracle dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #7 from Paolo Carlini <paolo.carlini at oracle dot com> 2011-05-25 12:16:45 UTC ---
To be honest, the behavior vs the original testcase, which just uses pair, can
be considered a regression; the reduced one, in Comment #5, fails also with
4.6.

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[paolo.carlini at oracle dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

Paolo Carlini <paolo.carlini at oracle dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
            Summary|[C++0x] incomplete type     |[C++0x][4.7 Regression]
                   |regression with std::pair   |incomplete type regression
                   |                            |with std::pair

--- Comment #6 from Paolo Carlini <paolo.carlini at oracle dot com> 2011-05-25 12:13:12 UTC ---
Jason, sorry for bothering, just wanted to make sure you noticed this
regression.

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[jason at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

Jason Merrill <jason at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |jason at gcc dot gnu.org

--- Comment #8 from Jason Merrill <jason at gcc dot gnu.org> 2011-06-04 05:55:15 UTC ---
This is not an arg-dependent lookup issue.  Here, instantiating
std::pair<VectorH3<Kernel>> involves evaluating
noexcept(ploum<VectorH3<Kernel>>::value), which means evaluating decltype(::new
VectorH3<Kernel>(declval<VectorH3<Kernel>>())), so invoking a VectorH3
constructor, so considering all the possible constructors, in particular
VectorH3(const Line_3&).  To evaluate how good that match is, we need to
instantiate Line_3, which fails as you see.

The resolution of core 1092 might make this work, though.  It isn't reflected
in the issues list, but the discussion in Madrid suggested that we should
always ignore constructors taking non-related types when trying to copy an
object of the same type.

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[jason at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

Jason Merrill <jason at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
         AssignedTo|unassigned at gcc dot       |jason at gcc dot gnu.org
                   |gnu.org                     |

--- Comment #9 from Jason Merrill <jason at gcc dot gnu.org> 2011-06-04 06:17:27 UTC ---
(In reply to comment #8)
> The resolution of core 1092 might make this work, though.  It isn't reflected
> in the issues list, but the discussion in Madrid suggested that we should
> always ignore constructors taking non-related types when trying to copy an
> object of the same type.

But doing this breaks auto_ptr.  And v3 future as well, for some reason.

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[paolo.carlini at oracle dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #10 from Paolo Carlini <paolo.carlini at oracle dot com> 2011-06-04 06:57:59 UTC ---
Thanks Jason, seems a nasty issue. I'm trying to understand how the specific
testcase in Comment #4 fits in the picture, ie why it compiles only because I
commented out that VectorH3 constructor which seems unrelated?!?

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[paolo.carlini at oracle dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #11 from Paolo Carlini <paolo.carlini at oracle dot com> 2011-06-04 07:05:34 UTC ---
I'm sorry, now I see that typedef. Hum, I'm worried, I have no idea how I coul
possibly simplify or workaround this type of issue in the library, among other
things.

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[paolo.carlini at oracle dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #12 from Paolo Carlini <paolo.carlini at oracle dot com> 2011-06-04 07:33:15 UTC ---
I'd like to understand as soon as possible if this type of issue means that
these traits cannot really be implemented with sfinae or not. Actually, as
usual, the library is just an example and in case people should know if
sfinae-based techniques have limitations beyond access-control (which by itself
is being fixed) and our users should know.

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[marc.glisse at normalesup dot org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #13 from Marc Glisse <marc.glisse at normalesup dot org> 2011-06-04 09:31:40 UTC ---
(In reply to comment #8)
> Here, instantiating
> std::pair<VectorH3<Kernel>> involves evaluating
> noexcept(ploum<VectorH3<Kernel>>::value),

Hello,

I am far from a specialist. Is it necessary to evaluate the noexcept expression
so early? It feels like it could lazily wait until something really looks at
the swap function, but the standard may require that early evaluation.

(clang currently rejects this code for the same reason)

PR c++/49266 is another example of code that started failing to compile. I hope
we will manage to avoid a situation where people reimplement their own
pair/tuple to avoid the noexcept limitations...

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[redi at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #14 from Jonathan Wakely <redi at gcc dot gnu.org> 2011-06-04 12:27:50 UTC ---
(In reply to comment #9)
> But doing this breaks auto_ptr.  And v3 future as well, for some reason.

I can take care of any necessary changes to future if you let me know what
breaks (or let me know what to change in the FE to reproduce the breakage)

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[jason at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #15 from Jason Merrill <jason at gcc dot gnu.org> 2011-06-04 23:35:38 UTC ---
Created attachment 24433
  --> http://gcc.gnu.org/bugzilla/attachment.cgi?id=24433
Patch to generalize the copy hack in the compiler

Here's the patch I was working with, if you're interested.  I don't think we
want to go this way, since it breaks auto_ptr, but perhaps we don't need the
auto_ptr hack in C++0x since we have rvalue references...

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[jason at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #16 from Jason Merrill <jason at gcc dot gnu.org> 2011-06-04 23:42:03 UTC ---
*** Bug 49266 has been marked as a duplicate of this bug. ***

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[paolo.carlini at oracle dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #17 from Paolo Carlini <paolo.carlini at oracle dot com> 2011-06-05 07:16:43 UTC ---
Well, auto_ptr is already deprecated in the FDIS. Personally, I would have no
objections to breaking auto_ptr in c++0x mode if this is the only way to save
the noexcept machinery. We really want it for performance reasons, otherwise
when we start using move_if_noexcept in the containers (for correctness vs
exceptions) the containers always fall back to copying instead of moving. 

Anyway, I understand now this is purely a Standard issue, there is nothing
special to our implementation, I also saw Jason' message arriving on the
reflector. There is hope. By the way, I would be still curious to see what an
implementation using intrinsics does in such cases, probably an ICE?!?

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[paolo.carlini at oracle dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #18 from Paolo Carlini <paolo.carlini at oracle dot com> 2011-06-05 08:48:38 UTC ---
It's Core/1092

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[jason at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #19 from Jason Merrill <jason at gcc dot gnu.org> 2011-06-08 21:35:05 UTC ---
Author: jason
Date: Wed Jun  8 21:35:02 2011
New Revision: 174820

URL: http://gcc.gnu.org/viewcvs?root=gcc&view=rev&rev=174820
Log:
    PR c++/49107
    * cp-tree.def (DEFERRED_NOEXCEPT): New.
    * cp-tree.h (struct tree_deferred_noexcept): New.
    (DEFERRED_NOEXCEPT_PATTERN, DEFERRED_NOEXCEPT_ARGS): New.
    (DEFERRED_NOEXCEPT_SPEC_P): New.
    (enum cp_tree_node_structure_enum): Add TS_CP_DEFERRED_NOEXCEPT.
    (union lang_tree_node): Add tree_deferred_noexcept.
    (maybe_instantiate_noexcept): Declare.
    * cp-objcp-common.c (cp_tree_size): Handle DEFERRED_NOEXCEPT.
    * error.c (dump_exception_spec): Likewise.
    * cxx-pretty-print.c (pp_cxx_exception_specification): Likewise.
    * ptree.c (cxx_print_xnode): Likewise.
    * tree.c (cp_tree_equal): Likewise.
    * decl.c (cp_tree_node_structure): Likewise.
    (duplicate_decls): Call maybe_instantiate_noexcept.
    * except.c (build_noexcept_spec): Handle DEFERRED_NOEXCEPT.
    (nothrow_spec_p, type_noexcept_p, type_throw_all_p): Check
    DEFERRED_NOEXCEPT_SPEC_P.
    * typeck2.c (merge_exception_specifiers): Likewise.
    * decl2.c (mark_used): Call maybe_instantiate_noexcept.
    * method.c (process_subob_fn, defaulted_late_check): Likewise.
    * pt.c (tsubst_exception_specification): Add defer_ok parm.
    Build DEFERRED_NOEXCEPT.
    (maybe_instantiate_noexcept): New.
    (tsubst, regenerate_decl_from_template, instantiate_decl): Adjust.
    * search.c (check_final_overrider): Call maybe_instantiate_noexcept.

Added:
    trunk/gcc/testsuite/g++.dg/cpp0x/noexcept11.C
    trunk/gcc/testsuite/g++.dg/cpp0x/noexcept12.C
Modified:
    trunk/gcc/cp/ChangeLog
    trunk/gcc/cp/cp-objcp-common.c
    trunk/gcc/cp/cp-tree.def
    trunk/gcc/cp/cp-tree.h
    trunk/gcc/cp/cxx-pretty-print.c
    trunk/gcc/cp/decl.c
    trunk/gcc/cp/decl2.c
    trunk/gcc/cp/error.c
    trunk/gcc/cp/except.c
    trunk/gcc/cp/method.c
    trunk/gcc/cp/pt.c
    trunk/gcc/cp/ptree.c
    trunk/gcc/cp/search.c
    trunk/gcc/cp/tree.c
    trunk/gcc/cp/typeck2.c
    trunk/gcc/testsuite/ChangeLog
    trunk/gcc/testsuite/g++.dg/cpp0x/sfinae11.C

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[marc.glisse at normalesup dot org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #20 from Marc Glisse <marc.glisse at normalesup dot org> 2011-06-10 20:39:59 UTC ---
The patch fixes the example (thanks), but I still have trouble with the
following (and I also get a different type of failure elsewhere that I'll
investigate later):

#include <utility>

template <class R_>
struct Vector3
{
        typedef typename R_::Ray_3                 Ray_3;
        Vector3() {}
        explicit Vector3(const Ray_3& r);
};

template < class R_ > class LineC3
{
        typedef typename R_::Vector_3             Vector_3;
        std::pair<int, Vector_3> x;
};

template < class R_ > class RayH3
{
        typedef typename R_::Vector_3             Vector_3;
        std::pair<int, Vector_3> x;
};

template <typename Kernel >
struct Homogeneous_base
{
        typedef LineC3<Kernel>                          Line_3;
        typedef RayH3<Kernel>                           Ray_3;
};

template < typename RT_>
struct Simple_homogeneous
: public Homogeneous_base< Simple_homogeneous<RT_> >
{
        typedef Vector3<Simple_homogeneous<RT_> > Vector_3;
};

int main()
{
        typedef   Simple_homogeneous<double>     R;
        R::Line_3 l3;
}




which fails with:
In file included from
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/utility:72:0,
                 from Simple_homogeneous.cpp:1:
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/bits/stl_pair.h:
In constructor 'std::pair<_T1, _T2>::pair(std::pair<_T1, _T2>&&) [with _T1 =
int, _T2 = Vector3<Simple_homogeneous<double> >, std::pair<_T1, _T2> =
std::pair<int, Vector3<Simple_homogeneous<double> > >]':
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:740:46:
  required from 'struct
std::__is_direct_constructible_impl<Vector3<Simple_homogeneous<double> >,
Vector3<Simple_homogeneous<double> >&&>'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:89:12:
  required from 'struct
std::__and_<std::is_destructible<Vector3<Simple_homogeneous<double> > >,
std::__is_direct_constructible_impl<Vector3<Simple_homogeneous<double> >,
Vector3<Simple_homogeneous<double> >&&> >'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:744:12:
  required from 'struct
std::__is_direct_constructible_new_safe<Vector3<Simple_homogeneous<double> >,
Vector3<Simple_homogeneous<double> >&&>'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:816:12:
  required from 'struct
std::__is_direct_constructible_new<Vector3<Simple_homogeneous<double> >,
Vector3<Simple_homogeneous<double> >&&>'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:824:12:
  required from 'struct
std::__is_direct_constructible<Vector3<Simple_homogeneous<double> >,
Vector3<Simple_homogeneous<double> >&&>'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:863:12:
  [ skipping 3 instantiation contexts ]
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:960:12:
  required from 'struct
std::is_nothrow_constructible<Vector3<Simple_homogeneous<double> >,
Vector3<Simple_homogeneous<double> >&&>'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:991:12:
  required from 'struct
std::__is_nothrow_move_constructible_impl<Vector3<Simple_homogeneous<double> >,
false>'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:997:12:
  required from 'struct
std::is_nothrow_move_constructible<Vector3<Simple_homogeneous<double> > >'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/type_traits:89:12:
  required from 'struct std::__and_<std::is_nothrow_move_constructible<int>,
std::is_nothrow_move_constructible<Vector3<Simple_homogeneous<double> > > >'
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/bits/stl_pair.h:122:7:
  required from 'std::pair<_T1, _T2>::pair(std::pair<_T1, _T2>&&) [with _T1 =
int, _T2 = Vector3<Simple_homogeneous<double> >, std::pair<_T1, _T2> =
std::pair<int, Vector3<Simple_homogeneous<double> > >]'
Simple_homogeneous.cpp:40:12:   required from here
/tmp/gcc/inst/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/bits/stl_pair.h:122:7:
error: incomplete type 'std::__and_<std::is_nothrow_move_constructible<int>,
std::is_nothrow_move_constructible<Vector3<Simple_homogeneous<double> > > >'
used in nested name specifier

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[jason at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

Jason Merrill <jason at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |ASSIGNED

--- Comment #21 from Jason Merrill <jason at gcc dot gnu.org> 2011-06-14 19:30:25 UTC ---
(In reply to comment #20)
> The patch fixes the example (thanks), but I still have trouble with the
> following

Hmm, looks like I need to delay evaluation of noexcept for implicitly declared
functions, too.

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[jason at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #22 from Jason Merrill <jason at gcc dot gnu.org> 2011-06-15 03:52:02 UTC ---
Author: jason
Date: Wed Jun 15 03:51:59 2011
New Revision: 175073

URL: http://gcc.gnu.org/viewcvs?root=gcc&view=rev&rev=175073
Log:
    PR c++/49107
    * cp-tree.h (DEFERRED_NOEXCEPT_SPEC_P): Handle overload.
    * method.c (defaulted_late_check): Only maybe_instantiate_noexcept
    if the declaration had an exception-specifier.
    (process_subob_fn): Don't maybe_instantiate_noexcept.
    * pt.c (maybe_instantiate_noexcept): Handle overload.
    * typeck2.c (nothrow_spec_p_uninst): New.
    (merge_exception_specifiers): Add 'fn' parm.  Build up overload.
    * typeck.c (merge_types): Adjust.

Added:
    trunk/gcc/testsuite/g++.dg/cpp0x/noexcept13.C
Modified:
    trunk/gcc/cp/ChangeLog
    trunk/gcc/cp/cp-tree.h
    trunk/gcc/cp/method.c
    trunk/gcc/cp/pt.c
    trunk/gcc/cp/typeck.c
    trunk/gcc/cp/typeck2.c
    trunk/gcc/testsuite/ChangeLog

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[jason at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

Jason Merrill <jason at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|ASSIGNED                    |RESOLVED
         Resolution|                            |FIXED

--- Comment #23 from Jason Merrill <jason at gcc dot gnu.org> 2011-06-15 03:58:07 UTC ---
Fixed.

[Bug c++/49107] [C++0x][4.7 Regression] incomplete type regression with std::pair

[marc.glisse at normalesup dot org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=49107

--- Comment #24 from Marc Glisse <marc.glisse at normalesup dot org> 2011-06-16 15:59:11 UTC ---
(In reply to comment #21)
> Hmm, looks like I need to delay evaluation of noexcept for implicitly declared
> functions, too.

Hello,

just to confirm: this has solved for us all the problems that appeared when
libstdc++ started using noexcept, thank you.