From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- gcc/testsuite/g++.dg/tc1/dr1.C | 18 ++++++++++ gcc/testsuite/g++.dg/tc1/dr101.C | 30 +++++++++++++++++ gcc/testsuite/g++.dg/tc1/dr108.C | 13 ++++++++ gcc/testsuite/g++.dg/tc1/dr127.C | 28 ++++++++++++++++ gcc/testsuite/g++.dg/tc1/dr128.C | 17 ++++++++++ gcc/testsuite/g++.dg/tc1/dr135.C | 8 +++++ gcc/testsuite/g++.dg/tc1/dr137.C | 13 ++++++++ gcc/testsuite/g++.dg/tc1/dr142.C | 32 ++++++++++++++++++ gcc/testsuite/g++.dg/tc1/dr147.C | 66 ++++++++++++++++++++++++++++++++++++ gcc/testsuite/g++.dg/tc1/dr152.C | 38 +++++++++++++++++++++ gcc/testsuite/g++.dg/tc1/dr159.C | 12 +++++++ gcc/testsuite/g++.dg/tc1/dr161.C | 50 ++++++++++++++++++++++++++++ gcc/testsuite/g++.dg/tc1/dr164.C | 17 ++++++++++ gcc/testsuite/g++.dg/tc1/dr166.C | 60 +++++++++++++++++++++++++++++++++ gcc/testsuite/g++.dg/tc1/dr176.C | 29 ++++++++++++++++ gcc/testsuite/g++.dg/tc1/dr179.C | 13 ++++++++ gcc/testsuite/g++.dg/tc1/dr185.C | 26 +++++++++++++++ gcc/testsuite/g++.dg/tc1/dr188.C | 9 +++++ gcc/testsuite/g++.dg/tc1/dr193.C | 72 ++++++++++++++++++++++++++++++++++++++++ gcc/testsuite/g++.dg/tc1/dr194.C | 16 +++++++++ gcc/testsuite/g++.dg/tc1/dr20.C | 34 +++++++++++++++++++ gcc/testsuite/g++.dg/tc1/dr213.C | 27 +++++++++++++++ gcc/testsuite/g++.dg/tc1/dr217.C | 14 ++++++++ gcc/testsuite/g++.dg/tc1/dr48.C | 13 ++++++++ gcc/testsuite/g++.dg/tc1/dr49.C | 19 +++++++++++ gcc/testsuite/g++.dg/tc1/dr52.C | 34 +++++++++++++++++++ gcc/testsuite/g++.dg/tc1/dr68.C | 20 +++++++++++ gcc/testsuite/g++.dg/tc1/dr74.C | 9 +++++ gcc/testsuite/g++.dg/tc1/dr76.C | 8 +++++ gcc/testsuite/g++.dg/tc1/dr80.C | 53 +++++++++++++++++++++++++++++ gcc/testsuite/g++.dg/tc1/dr85.C | 8 +++++ gcc/testsuite/g++.dg/tc1/dr90.C | 20 +++++++++++ gcc/testsuite/g++.dg/tc1/dr94.C | 9 +++++ 33 files changed, 835 insertions(+) create mode 100644 gcc/testsuite/g++.dg/tc1/dr1.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr101.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr108.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr127.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr128.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr135.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr137.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr142.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr147.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr152.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr159.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr161.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr164.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr166.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr176.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr179.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr185.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr188.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr193.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr194.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr20.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr213.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr217.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr48.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr49.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr52.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr68.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr74.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr76.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr80.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr85.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr90.C create mode 100644 gcc/testsuite/g++.dg/tc1/dr94.C (limited to 'gcc/testsuite/g++.dg/tc1') diff --git a/gcc/testsuite/g++.dg/tc1/dr1.C b/gcc/testsuite/g++.dg/tc1/dr1.C new file mode 100644 index 000000000..9196218f1 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr1.C @@ -0,0 +1,18 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR1: What if two using-declarations refer to the same function but the +// declarations introduce different default-arguments? + +namespace A { + extern "C" void f(int = 5); +} +namespace B { + extern "C" void f(int = 5); +} +using A::f; +using B::f; + +void use() { + f(3); + f(); // { dg-error "" "" { xfail *-*-* } } +} diff --git a/gcc/testsuite/g++.dg/tc1/dr101.C b/gcc/testsuite/g++.dg/tc1/dr101.C new file mode 100644 index 000000000..0316aaaa7 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr101.C @@ -0,0 +1,30 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// 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; // { dg-bogus "X" "" } + extern "C" int f2(); + namespace N { + typedef unsigned int X; // { dg-bogus "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" } + +} diff --git a/gcc/testsuite/g++.dg/tc1/dr108.C b/gcc/testsuite/g++.dg/tc1/dr108.C new file mode 100644 index 000000000..43bae15ea --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr108.C @@ -0,0 +1,13 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR108: Are classes nested in templates dependent? + +template struct S { + struct I1 { + typedef int X; + }; + struct I2 : public I1 { + X x; // { dg-error "does not name a type" "name" } + // { dg-message "note" "note" { target *-*-* } 10 } + }; +}; diff --git a/gcc/testsuite/g++.dg/tc1/dr127.C b/gcc/testsuite/g++.dg/tc1/dr127.C new file mode 100644 index 000000000..4dddc6d77 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr127.C @@ -0,0 +1,28 @@ +// { dg-do link } +// Origin: Giovanni Bajo +// DR127: Ambiguity in description of matching deallocation function + +#include +#include + +struct A +{ + // placement new, but can be called through normal new syntax. + void* operator new(std::size_t size, float = 0.0f) + { + return ::operator new(size); + } + + // The matching deallocation function must be called, which means + // the placemente delete. + void operator delete(void*); + void operator delete(void*, float) {} + + A() + { throw 5; } +}; + +int main() +{ + (void)new A; +} diff --git a/gcc/testsuite/g++.dg/tc1/dr128.C b/gcc/testsuite/g++.dg/tc1/dr128.C new file mode 100644 index 000000000..4dd78d57f --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr128.C @@ -0,0 +1,17 @@ +// { dg-do run } +// Origin: Giovanni Bajo +// DR128: Casting between enum types + +extern "C" void abort(void); + +enum E1 { BLACK = 0, RED = 1 }; +enum E2 { WHITE = 0, YELLOW = 1}; + +int main(void) +{ + E1 e1 = RED; + E2 e2 = static_cast(e1); + if (e2 != YELLOW) + abort(); + return 0; +} diff --git a/gcc/testsuite/g++.dg/tc1/dr135.C b/gcc/testsuite/g++.dg/tc1/dr135.C new file mode 100644 index 000000000..beed8cdfd --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr135.C @@ -0,0 +1,8 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// 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" } +}; diff --git a/gcc/testsuite/g++.dg/tc1/dr137.C b/gcc/testsuite/g++.dg/tc1/dr137.C new file mode 100644 index 000000000..bc1beb021 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr137.C @@ -0,0 +1,13 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR137: static_cast of cv void* + +struct A; + +const void* v; + +void foo(void) +{ + (void)static_cast(v); + (void)static_cast(v); // { dg-error "" "static_cast cannot remove cv qualifiers" } +} diff --git a/gcc/testsuite/g++.dg/tc1/dr142.C b/gcc/testsuite/g++.dg/tc1/dr142.C new file mode 100644 index 000000000..c49f4dd20 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr142.C @@ -0,0 +1,32 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// 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" "" } +} diff --git a/gcc/testsuite/g++.dg/tc1/dr147.C b/gcc/testsuite/g++.dg/tc1/dr147.C new file mode 100644 index 000000000..6799b7dcc --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr147.C @@ -0,0 +1,66 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR147: Naming the constructor (PR 11764) + +namespace N1 { + +struct A { A(); void f(); }; +struct B: public A { B(); }; + +A::A() { } +B::B() { } + +B::A ba; +A::A a; // { dg-error "constructor" "the injected-class-name can never be found through qualified lookup" } + +void A::f() +{ + A::A(); // { dg-message "::A" "c++/42415" } +} + +void f() +{ + A::A a; // { dg-error "constructor" } +} // { dg-error "" "" { target *-*-* } 23 } error cascade +} + +namespace N2 { + +// This is nasty: if we allowed the injected-class-name to be looked as a +// qualified type, then the following code would be well-formed. Basically +// the last line is defining the static member (with redundant parenthesis). +// Instead, it should be rejected as a malformed constructor declaration. + +template struct A { + template A(T2); + static A x; +}; +template<> template <> A::A(char); +template<> A::A(A::x); // { dg-error "" "this is an invalid declaration of the constructor" } + +} + +// But DR 318 says that in situations where a type is syntactically +// required, lookup finds it. + +struct C +{ + C(); + typedef int T; +}; +struct C::C c; +C::C::T t; +struct D: C::C +{ + D(): C::C() { } +}; + +// And if lookup doesn't find the injected-class-name, we aren't naming the +// constructor (c++/44401). + +struct E +{ + int E; +}; + +int E::*p = &E::E; diff --git a/gcc/testsuite/g++.dg/tc1/dr152.C b/gcc/testsuite/g++.dg/tc1/dr152.C new file mode 100644 index 000000000..f930d2e28 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr152.C @@ -0,0 +1,38 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR152: explicit copy constructors + +namespace N1 { + struct X { + X(); // { dg-message "note" } + explicit X(const X&); + }; + void f(X); // { dg-error "initializing" } + int foo() + { + X x; + f(x); // { dg-error "matching" "matching" } + // { dg-message "candidate" "candidate note" { target *-*-* } 14 } + } +} + +namespace N2 { + template + struct X { + X(); // { dg-message "note" } + explicit X(const X&); + }; + + template + void f(T ) {} // { dg-error "initializing" } + + template + int foo() + { + X x; + N2::f(x); // { dg-error "matching" "matching" } + // { dg-message "candidate" "candidate note" { target *-*-* } 33 } + } + + template int foo(); // { dg-message "instantiated from here" } +} diff --git a/gcc/testsuite/g++.dg/tc1/dr159.C b/gcc/testsuite/g++.dg/tc1/dr159.C new file mode 100644 index 000000000..74d23f1cd --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr159.C @@ -0,0 +1,12 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR159: Namespace qualification in declarators + +namespace N { + namespace M { + void f(); + void g(); + } + void M::f(){} + void N::M::g(){} +} diff --git a/gcc/testsuite/g++.dg/tc1/dr161.C b/gcc/testsuite/g++.dg/tc1/dr161.C new file mode 100644 index 000000000..49f679a0c --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr161.C @@ -0,0 +1,50 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// 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 + struct A + { + protected: + typedef int type; + }; + + template + struct B : public A + { + void test(B b) + { + typename A::type t; + } + + friend void ftest(B b) + { + typename A::type t; + } + }; + + template struct B; +} diff --git a/gcc/testsuite/g++.dg/tc1/dr164.C b/gcc/testsuite/g++.dg/tc1/dr164.C new file mode 100644 index 000000000..026ec096f --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr164.C @@ -0,0 +1,17 @@ +// { dg-do link } +// Origin: Giovanni Bajo +// DR164: Overlap between Koenig and normal lookup + +void f(int); + +template void g(T t) { + f(t); +} + +enum E { e }; + +void f(E) {} + +int main() { + g(e); +} diff --git a/gcc/testsuite/g++.dg/tc1/dr166.C b/gcc/testsuite/g++.dg/tc1/dr166.C new file mode 100644 index 000000000..8c142906a --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr166.C @@ -0,0 +1,60 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR166: Friend declarations of template-ids + +namespace N { + template void f(T); + void g(); + + namespace M { + class A { + friend void f(int); // N::f + static int x; // { dg-error "private" } + }; + + class B { + template 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 void f(T) // will be instantiated as f + { + M::A::x = 0; // { dg-error "within this context" } + M::B::x = 0; + } + template <> void f(int) + { M::A::x = 0; } // { dg-error "within this context" } + template <> void f(double ) + { + M::B::x = 0; + M::f(0); // { dg-message "instantiated" } + } + + void g(void) + { M::C::x = 0; } + } + + template void f(T) // will be instantiated as f + { + M::A::x = 0; // { dg-error "within this context" } + M::B::x = 0; // { dg-error "within this context" } + } + + template <> void f(int ) + { + N::f(0); // { dg-message "instantiated" } + M::A::x = 0; + M::B::x = 0; // { dg-error "within this context" } + } + + template <> void f(char ) + { M::A::x = 0; } // { dg-error "within this context" } + + void g(void) + { M::C::x = 0; } // { dg-error "within this context" } +} diff --git a/gcc/testsuite/g++.dg/tc1/dr176.C b/gcc/testsuite/g++.dg/tc1/dr176.C new file mode 100644 index 000000000..2879ac4e7 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr176.C @@ -0,0 +1,29 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR176: Name injection and templates + +namespace N1 { + template struct Base { + Base* p; + Base* p2; + ::Base* p3; // { dg-error "" "" } + }; + + template struct Derived: public Base { + Base* p; // { dg-error "" "unqualified name binds to N1::Base" } + Base* p2; + typename Derived::Base* p3; // { dg-bogus "" "injected class name in derived classes" } + }; + + template struct Derived; // { dg-bogus "instantiated from here" "everything should be looked up at parsing time (after DR224)" } +} + + +namespace N2 { + template struct Base {}; + template struct Derived: public Base { + typename Derived::template Base* p1; // { dg-bogus "" "" } + }; + + template struct Derived; +} diff --git a/gcc/testsuite/g++.dg/tc1/dr179.C b/gcc/testsuite/g++.dg/tc1/dr179.C new file mode 100644 index 000000000..39e4164d2 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr179.C @@ -0,0 +1,13 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR179: Function pointers and subtraction + +void foo(void); +typedef void (*fp)(void); + +int main() +{ + fp f1 = foo; + fp f2 = foo; + (void)f2-f1; // { dg-error "" "cannot subtract pointers to function" } +} diff --git a/gcc/testsuite/g++.dg/tc1/dr185.C b/gcc/testsuite/g++.dg/tc1/dr185.C new file mode 100644 index 000000000..2cd4e397f --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr185.C @@ -0,0 +1,26 @@ +// { dg-do run } +// Origin: Giovanni Bajo +// DR185: "Named" temporaries and copy elision + +extern "C" void abort(void); + +struct A { + mutable int value; + explicit A(int i) : value(i) {} + void mutate(int i) const { value = i; } +}; + +int foo() { + A const& t = A(1); + A n(t); // can this copy be elided? NO! + t.mutate(2); + return n.value; // can this return 2? NO! +} + +int main() +{ + int x = foo(); + if (x != 1) + abort(); + return 0; +} diff --git a/gcc/testsuite/g++.dg/tc1/dr188.C b/gcc/testsuite/g++.dg/tc1/dr188.C new file mode 100644 index 000000000..3a10fa476 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr188.C @@ -0,0 +1,9 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR188: Comma operator and rvalue conversion + +template struct StaticAssert; +template <> struct StaticAssert {}; + +char arr[100]; +StaticAssert<(sizeof(0,arr) == 100)> check; diff --git a/gcc/testsuite/g++.dg/tc1/dr193.C b/gcc/testsuite/g++.dg/tc1/dr193.C new file mode 100644 index 000000000..40b065084 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr193.C @@ -0,0 +1,72 @@ +// { dg-do run } +// Origin: Giovanni Bajo +// 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 + struct A + { + ~A() + { + a_done = true; + } + }; + + template + struct B + { + ~B() + { + if (!a_done) + abort(); + } + }; + + template + struct C { + B x; + ~C() { + A y; + } + }; +} + + +int main(void) +{ + N1::C c1; + N2::C c2; + return 0; +} diff --git a/gcc/testsuite/g++.dg/tc1/dr194.C b/gcc/testsuite/g++.dg/tc1/dr194.C new file mode 100644 index 000000000..3ed130071 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr194.C @@ -0,0 +1,16 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR194: Identifying constructors + +struct A +{ + inline explicit A(); +}; + +template +struct B +{ + inline explicit B(); +}; + +template struct B; diff --git a/gcc/testsuite/g++.dg/tc1/dr20.C b/gcc/testsuite/g++.dg/tc1/dr20.C new file mode 100644 index 000000000..fe5862129 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr20.C @@ -0,0 +1,34 @@ +// { dg-do run } +// Origin: Giovanni Bajo +// DR20: Some clarifications needed for 12.8 para 15 + +extern "C" void printf(const char*, ...); +extern "C" void abort(void); + +int count = 0; + +class Thing { +public: + Thing() { + } + ~Thing() { + } + Thing(const Thing&) + { + count += 1; + } +}; + +Thing f() { + Thing t; + return t; +} + +int main(void) +{ + Thing t2 = f(); + printf("%d %x\n", count, &t2); + if (count != 0) + abort(); + return 0; +} diff --git a/gcc/testsuite/g++.dg/tc1/dr213.C b/gcc/testsuite/g++.dg/tc1/dr213.C new file mode 100644 index 000000000..2cc70138a --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr213.C @@ -0,0 +1,27 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR213: Lookup in dependent base classes + +// We should emit an error at *instantiation* time because g(t) can't be +// resolved to any function. + +template struct A : T { + void h(T t) { + f(t); + g(t); // { dg-error "" "" { xfail *-*-* } } + } +}; + +struct B { + void f(B); + void g(B) {} +}; + +void f(B) {} + +int main() +{ + A ab; // { dg-error "" "" { xfail *-*-* } } + B b; + ab.h(b); +} diff --git a/gcc/testsuite/g++.dg/tc1/dr217.C b/gcc/testsuite/g++.dg/tc1/dr217.C new file mode 100644 index 000000000..cfa280397 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr217.C @@ -0,0 +1,14 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR217: Default arguments for non-template member functions of class +// templates + +template +struct S +{ + void foo (int); +}; + +template +void S::foo (int = 0) // { dg-error "" "default arguments for parameters of member functions of class templates can be specified in the initial declaration only" { xfail *-*-* } } +{ } diff --git a/gcc/testsuite/g++.dg/tc1/dr48.C b/gcc/testsuite/g++.dg/tc1/dr48.C new file mode 100644 index 000000000..19c173878 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr48.C @@ -0,0 +1,13 @@ +// { dg-do link } +// Origin: Giovanni Bajo +// DR48: Definitions of unused static members + +struct A { + static const int size = 10; + int array[size]; +}; + +int main() { + A a; + return 0; +} diff --git a/gcc/testsuite/g++.dg/tc1/dr49.C b/gcc/testsuite/g++.dg/tc1/dr49.C new file mode 100644 index 000000000..753d96b69 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr49.C @@ -0,0 +1,19 @@ +// { dg-do compile } +// Contributed by: Giovanni Bajo +// DR 49: Non-constant pointers are invalid template arguments. + +template struct R { /* ... */ }; +template struct S { /* ... */ }; + +int p; +template struct R<&p>; // OK +template struct S<&p>; // OK due to parameter adjustment + +int *ptr; +template struct R; // { dg-error "argument" } +template struct S; // { dg-error "argument" } + +int v[5]; +template struct R; // OK due to implicit argument conversion +template struct S; // OK due to both adjustment and conversion + diff --git a/gcc/testsuite/g++.dg/tc1/dr52.C b/gcc/testsuite/g++.dg/tc1/dr52.C new file mode 100644 index 000000000..4f4015dc9 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr52.C @@ -0,0 +1,34 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR52: Non-static members, member selection and access checking + +struct A +{ + void foo(void); +}; + +struct B +{ +private: + void foo(void); +}; + +struct B1 : B {}; +struct B2 : B {}; + +struct C +{ // { dg-error "C" } + void foo(void); +}; + +struct D : private C {}; + +struct X: A, B1, B2, D +{ +public: + void bar(void) + { + this->B::foo(); // { dg-error "" } + this->C::foo(); // { dg-error "inaccessible|context" } + } +}; diff --git a/gcc/testsuite/g++.dg/tc1/dr68.C b/gcc/testsuite/g++.dg/tc1/dr68.C new file mode 100644 index 000000000..253f04943 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr68.C @@ -0,0 +1,20 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR68: Grammar does not allow "friend class A;" + +namespace A{ + class B{}; +} + +namespace B{ + class A{}; + class C{ + friend class ::A::B; + }; +} + + +template class K; +class J { + friend class K; +}; diff --git a/gcc/testsuite/g++.dg/tc1/dr74.C b/gcc/testsuite/g++.dg/tc1/dr74.C new file mode 100644 index 000000000..155c7981b --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr74.C @@ -0,0 +1,9 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR74: Enumeration value in direct-new-declarator + +struct A {}; +enum E1 { COUNT = 10 }; + +A* a = new A[COUNT]; + diff --git a/gcc/testsuite/g++.dg/tc1/dr76.C b/gcc/testsuite/g++.dg/tc1/dr76.C new file mode 100644 index 000000000..0859b0c73 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr76.C @@ -0,0 +1,8 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR76: Are const volatile variables considered "constant expressions"? + +volatile const int a = 5; + +template struct K; +template struct K; // { dg-error "" } diff --git a/gcc/testsuite/g++.dg/tc1/dr80.C b/gcc/testsuite/g++.dg/tc1/dr80.C new file mode 100644 index 000000000..2327428a0 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr80.C @@ -0,0 +1,53 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR80: Class members with same name as class + +struct A +{ + int A; +}; + +struct A2 +{ + static int A2; // { dg-error "same name as" } +}; + + +template +struct A3 +{ + int A3; +}; + +template +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 +struct B3 +{ + B3(); + int B3; // { dg-error "same name as" "this error should appear at parsing time" { xfail *-*-* } } +}; + +template +struct B4 +{ + B4(); + static int B4; // { dg-error "same name as" } +}; diff --git a/gcc/testsuite/g++.dg/tc1/dr85.C b/gcc/testsuite/g++.dg/tc1/dr85.C new file mode 100644 index 000000000..31dde8cbb --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr85.C @@ -0,0 +1,8 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR85: Redeclaration of member class + +struct Base { + struct Data {}; + struct Data; // { dg-error "" "redeclaration of nested class is invalid" { xfail *-*-* } } +}; diff --git a/gcc/testsuite/g++.dg/tc1/dr90.C b/gcc/testsuite/g++.dg/tc1/dr90.C new file mode 100644 index 000000000..b6ec24cc8 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr90.C @@ -0,0 +1,20 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR90: Should the enclosing class be an "associated class" too? + +struct A { + union U {}; + friend void f(U); +}; + +struct B { + struct S {}; + friend void f(S); +}; + +int main() { + A::U u; + f(u); + B::S s; + f(s); +} diff --git a/gcc/testsuite/g++.dg/tc1/dr94.C b/gcc/testsuite/g++.dg/tc1/dr94.C new file mode 100644 index 000000000..97cf0c256 --- /dev/null +++ b/gcc/testsuite/g++.dg/tc1/dr94.C @@ -0,0 +1,9 @@ +// { dg-do compile } +// Origin: Giovanni Bajo +// DR94: Inconsistencies in the descriptions of constant expressions + +struct S { + static const int c = 5; +}; +int a[S::c]; + -- cgit v1.2.3