dr101.C, [...]: New tests.

	* g++.dg/tc1/dr101.C, g++.dg/tc1/dr135.C, g++.dg/tc1/dr142.C,
	g++.dg/tc1/dr152.C, g++.dg/tc1/dr159.C, g++.dg/tc1/dr161.C,
	g++.dg/tc1/dr166.C, g++.dg/tc1/dr176.C, g++.dg/tc1/dr188.C,
	g++.dg/tc1/dr193.C, g++.dg/tc1/dr194.C, g++.dg/tc1/dr217.C,
	g++.dg/tc1/dr48.C, g++.dg/tc1/dr56.C, g++.dg/tc1/dr68.C,
	g++.dg/tc1/dr76.C, g++.dg/tc1/dr80.C, g++.dg/tc1/dr94.C: New tests.

From-SVN: r77943

gcc/testsuite/ChangeLog

+2004-02-16  Giovanni Bajo  <giovannibajo@gcc.gnu.org>
+
+	* g++.dg/tc1/dr101.C, g++.dg/tc1/dr135.C, g++.dg/tc1/dr142.C,
+	g++.dg/tc1/dr152.C, g++.dg/tc1/dr159.C, g++.dg/tc1/dr161.C,
+	g++.dg/tc1/dr166.C, g++.dg/tc1/dr176.C, g++.dg/tc1/dr188.C,
+	g++.dg/tc1/dr193.C, g++.dg/tc1/dr194.C, g++.dg/tc1/dr217.C,
+	g++.dg/tc1/dr48.C, g++.dg/tc1/dr56.C, g++.dg/tc1/dr68.C,
+	g++.dg/tc1/dr76.C, g++.dg/tc1/dr80.C, g++.dg/tc1/dr94.C: New tests.
+
 2004-02-16  Eric Botcazou  <ebotcazou@libertysurf.fr>
 
 	* gcc.c-torture/execute/20020720-1.x: XFAIL on SPARC with -fPIC.

gcc/testsuite/g++.dg/tc1/dr101.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR101: Redeclaration of extern "C" names via using-declarations 
+
+namespace Test1 {
+
+  typedef unsigned int X;
+  extern "C" void f1();
+  namespace N {
+    typedef unsigned int X;
+    extern "C" void f1();
+  }
+  using N::f1; // { dg-bogus "" "redeclaration through 'using' should not be ambiguous" }
+  using N::X;  // { dg-bogus "" "redeclaration through 'using' should not be ambiguous" }
+}
+
+
+namespace Test2 {
+
+  typedef unsigned int X;
+  extern "C" int f2();
+  namespace N {
+    typedef unsigned int X;
+    extern "C" int f2();
+  }
+  using namespace N;
+  int i = f2(); // { dg-bogus "" "redeclaration through 'using' should not be ambiguous" }
+  X x;          // { dg-bogus "" "redeclaration through 'using' should not be ambiguous" { xfail *-*-* } }
+
+}
+

gcc/testsuite/g++.dg/tc1/dr135.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR135: Class type in in-class member function definitions 
+
+struct S {
+  S f() { return S(); }  // { dg-bogus "" "incomplete class type is allowed as return type" }
+  void g(S) { }          // { dg-bogus "" "incomplete class type is allowed as parameter type" }
+};

gcc/testsuite/g++.dg/tc1/dr142.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR142: Injection-related errors in access example 
+
+class B {                 // { dg-error "inaccessible" }
+public:
+  int mi;                 // { dg-error "inaccessible" }
+  static int si;          // { dg-error "inaccessible" }
+};
+
+class D: private B {
+};
+
+class DD: public D {
+  void f();
+};
+
+void DD::f() {
+  mi = 3;          // { dg-error "within this context" "" }
+  si = 3;          // { dg-error "within this context" "" }
+  ::B b;
+  b.mi = 3;
+  b.si = 3;
+  ::B::si = 3;
+  ::B* bp1 = this;        // { dg-error "inaccessible base" "" }
+  ::B* bp2 = (::B*)this;
+  bp2->mi = 3;
+
+
+  B b2;                   // { dg-error "within this context" "" }
+  B::si = 3;              // { dg-error "within this context" "" }
+}

gcc/testsuite/g++.dg/tc1/dr152.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR152: explicit copy constructors 
+
+namespace N1 {
+  struct X {
+    X();
+    explicit X(const X&);
+  };
+  void f(X);
+  int foo() 
+  { 
+    X x; 
+    f(x);     // { dg-error "" "" }
+  }
+}
+
+namespace N2 {
+  template <class T>
+  struct X {
+    X();
+    explicit X(const X&);
+  };
+
+  template <class T>
+  void f(T ) {}
+  
+  template <class T>
+  int foo() 
+  { 
+    X<T> x; 
+    N2::f(x);   // { dg-error "" "" }
+  }
+
+  template int foo<float>();  // { dg-error "instantiated from here" }
+}

gcc/testsuite/g++.dg/tc1/dr159.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR159: Namespace qualification in declarators 
+
+namespace N {
+  namespace M {
+    void f();
+    void g();
+  }
+  void M::f(){}
+  void N::M::g(){}
+}

gcc/testsuite/g++.dg/tc1/dr161.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR161: Access to protected nested type 
+
+namespace N1 {
+  struct A 
+  {
+  protected:
+    typedef int type;
+  };
+
+  struct B : public A
+  {
+    void test(void)
+    {
+      A::type t;
+    }
+
+    friend void ftest(void)
+    {
+      A::type t;
+    }
+  };
+}
+
+
+namespace N2 {
+  template <class T>
+  struct A 
+  {
+  protected:
+    typedef int type;
+  };
+
+  template <class T>
+  struct B : public A<T>
+  {
+    void test(B b)
+    {
+      typename A<T>::type t;
+    }
+
+    friend void ftest(B b)
+    {
+      typename A<T>::type t;
+    }
+  };
+
+  template struct B<void>;
+}

gcc/testsuite/g++.dg/tc1/dr166.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR166: Friend declarations of template-ids 
+
+namespace N {
+  template <class T> void f(T);
+  void g();
+
+  namespace M {
+    class A {
+      friend void f<int>(int); // N::f
+      static int x;   // { dg-error "private" }
+    };
+    
+    class B {
+      template <class T> friend void f(T);  // M::f
+      static int x;   // { dg-error "private" }
+    };
+
+    class C {
+      friend void g(); // M::g
+      static int x;   // { dg-error "private" }
+    };
+
+    template <class T> void f(T)  // will be instantiated as f<long>
+    {
+      M::A::x = 0;    // { dg-error "within this context" }
+      M::B::x = 0;
+    }
+    template <> void f<int>(int)
+    { M::A::x = 0; }      // { dg-error "within this context" }
+    template <> void f<double>(double )
+    { 
+      M::B::x = 0; 
+      M::f<long>(0);   // { dg-error "instantiated" }
+    }
+
+    void g(void)
+    { M::C::x = 0; }
+  }
+
+  template <class T> void f(T)  // will be instantiated as f<long>
+  { 
+    M::A::x = 0;       // { dg-error "within this context" }
+    M::B::x = 0;       // { dg-error "within this context" }
+  }
+
+  template <> void f<int>(int )
+  { 
+    N::f<long>(0);        // { dg-error "instantiated" }
+    M::A::x = 0; 
+    M::B::x = 0;       // { dg-error "within this context" }
+  }
+
+  template <> void f<char>(char )
+  { M::A::x = 0; }      // { dg-error "within this context" }
+
+  void g(void)
+  { M::C::x = 0; }      // { dg-error "within this context" }
+}

gcc/testsuite/g++.dg/tc1/dr176.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR176: Name injection and templates 
+
+namespace N1 {
+  template <class T> struct Base {
+    Base* p;
+    Base<T*>* p2;
+    ::Base* p3;    // { dg-error "" "" }
+  };
+
+  template <class T> struct Derived: public Base<T> {
+    Base* p;     // { dg-bogus "" "injected class name in derived classes" { xfail *-*-* } }
+    Base<T*>* p2;
+    typename Derived::Base* p3;   // { dg-bogus "" "injected class name in derived classes" { xfail *-*-* } }
+  };
+
+  template struct Derived<void>;  // { dg-bogus "instantiated from here" "everything should be looked up at parsing time (after DR224)" { xfail *-*-* } }
+}
+
+
+namespace N2 {
+  template <class T> struct Base {};
+  template <class T> struct Derived: public Base<T> {
+    typename Derived::template Base<double>* p1;  // { dg-bogus "" "" { xfail *-*-* } }
+  }
+
+  template struct Derived<void>;
+}

gcc/testsuite/g++.dg/tc1/dr188.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR188: Comma operator and rvalue conversion
+
+template <bool> struct StaticAssert;
+template <> struct StaticAssert<true> {};
+
+char arr[100];
+StaticAssert<(sizeof(0,arr) == 100)> check;

gcc/testsuite/g++.dg/tc1/dr193.C

+// { dg-do run }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR193: Order of destruction of local automatics of destructor 
+
+extern "C" void abort(void);
+
+namespace N1 {
+  bool a_done = false;
+  struct A
+  { 
+    ~A()
+    {
+      a_done = true;
+    }
+  };
+
+  struct B
+  { 
+    ~B()
+    {
+      if (!a_done)
+        abort();
+    }
+  };
+
+  struct C {
+    B x;
+    ~C() {
+      A y;
+    };
+  };
+}
+
+
+namespace N2 {
+  bool a_done = false;
+
+  template <class>
+  struct A
+  { 
+    ~A()
+    {
+      a_done = true;
+    }
+  };
+
+  template <class>
+  struct B
+  { 
+    ~B()
+    {
+      if (!a_done)
+        abort();
+    }
+  };
+
+  template <class T>
+  struct C {
+    B<T> x;
+    ~C() {
+      A<T> y;
+    };
+  };
+}
+
+
+int main(void)
+{
+  N1::C c1;
+  N2::C<void> c2;
+  return 0;
+}

gcc/testsuite/g++.dg/tc1/dr194.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR194: Identifying constructors 
+
+struct A
+{
+  inline explicit A();
+};
+
+template <class>
+struct B
+{
+  inline explicit B();
+};
+
+template struct B<void>;

gcc/testsuite/g++.dg/tc1/dr217.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR217: Default arguments for non-template member functions of class 
+//  templates 
+
+template <class T>
+struct S
+{
+  void foo (int);
+};
+
+template <class T>
+void S<T>::foo (int = 0)  // { dg-error "" "default arguments for parameters of member functions of class templates can be specified in the initial declaration only" { xfail *-*-* } }
+{ }

gcc/testsuite/g++.dg/tc1/dr48.C

+// { dg-do link }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR48: Definitions of unused static members 
+
+struct A {
+  static const int size = 10;
+  int array[size];
+};
+
+int main() {
+  A a;
+  return 0;
+}

gcc/testsuite/g++.dg/tc1/dr56.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR56: Redeclaring typedefs within classes 
+
+class X { 
+  typedef int I; 
+  typedef int I;  // { dg-error "" "Cannot redeclare a typedef in a class scope" { xfail *-*-* } }
+};
+
+// In non-class scope, they are allowed.
+typedef int A;
+typedef int A;

gcc/testsuite/g++.dg/tc1/dr68.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR68: Grammar does not allow "friend class A<int>;" 
+
+namespace A{
+  class B{};
+}
+
+namespace B{
+  class A{};
+  class C{
+    friend class ::A::B;
+  };
+}
+
+
+template <typename> class K;
+class J {
+  friend class K<int>;
+};

gcc/testsuite/g++.dg/tc1/dr76.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR76: Are const volatile variables considered "constant expressions"? 
+
+volatile const int a = 5;
+
+template <int> struct K;
+template struct K<a>;	// { dg-error "non-constant" }

gcc/testsuite/g++.dg/tc1/dr80.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR80: Class members with same name as class 
+
+struct A 
+{
+  int A;
+};
+
+struct A2
+{
+  static int A2;  // { dg-error "same name as" }
+};
+
+
+template <class>
+struct A3
+{
+  int A3;
+};
+
+template <class>
+struct A4
+{
+  static int A4;  // { dg-error "same name as" }
+};
+
+
+struct B
+{
+  B();
+  int B;  // { dg-error "same name as" }
+};
+
+struct B2
+{
+  B2();
+  static int B2;  // { dg-error "same name as" }
+};
+
+template <class>
+struct B3
+{
+  B3();
+  int B3;  // { dg-error "same name as" "this error should appear at parsing time" { xfail *-*-* } }
+};
+
+template <class>
+struct B4
+{
+  B4();
+  static int B4;  // { dg-error "same name as" }
+};

gcc/testsuite/g++.dg/tc1/dr94.C

+// { dg-do compile }
+// Origin: Giovanni Bajo <giovannibajo at gcc dot gnu dot org>
+// DR94: Inconsistencies in the descriptions of constant expressions 
+
+struct S {
+  static const int c = 5;
+};
+int a[S::c];
+