2014-05-01 08:35:04 +08:00
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
2015-10-20 08:31:42 +08:00
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
2009-06-26 11:54:13 +08:00
extern " C " { void f ( bool ) ; }
namespace std {
using : : f ;
inline void f ( ) { return f ( true ) ; }
}
2009-09-28 08:47:05 +08:00
namespace M {
void f ( float ) ;
}
namespace N {
using M : : f ;
void f ( int ) { } // expected-note{{previous}}
void f ( int ) { } // expected-error{{redefinition}}
}
2009-11-15 16:11:13 +08:00
namespace N {
void f ( double ) ;
void f ( long ) ;
}
struct X0 {
void operator ( ) ( int ) ;
void operator ( ) ( long ) ;
} ;
struct X1 : X0 {
// FIXME: give this operator() a 'float' parameter to test overloading
// behavior. It currently fails.
void operator ( ) ( ) ;
using X0 : : operator ( ) ;
void test ( ) {
( * this ) ( 1 ) ;
}
} ;
2009-12-09 12:26:02 +08:00
struct A { void f ( ) ; } ;
struct B : A { } ;
class C : B { using B : : f ; } ;
2009-12-29 14:17:27 +08:00
// PR5751: Resolve overloaded functions through using decls.
namespace O {
void f ( int i ) ;
void f ( double d ) ;
}
namespace P {
void f ( ) ;
void g ( void ( * ptr ) ( int ) ) ;
using O : : f ;
void test ( ) {
f ( ) ;
f ( 1 ) ;
void ( * f_ptr1 ) ( double ) = f ;
void ( * f_ptr2 ) ( ) = f ;
g ( f ) ;
}
}
2010-01-26 14:04:06 +08:00
// Make sure that ADL can find names brought in by using decls.
namespace test0 {
namespace ns {
class Foo { } ;
namespace inner {
void foo ( char * ) ; // expected-note {{no known conversion}}
}
using inner : : foo ;
}
void test ( ns : : Foo * p ) {
foo ( * p ) ; // expected-error {{no matching function for call to 'foo'}}
}
}
2010-01-26 15:16:45 +08:00
// Redeclarations!
namespace test1 {
namespace ns0 { struct Foo { } ; }
namespace A { void foo ( ns0 : : Foo * p , int y , int z ) ; }
namespace ns2 { using A : : foo ; }
namespace ns1 { struct Bar : ns0 : : Foo { } ; }
namespace A { void foo ( ns0 : : Foo * p , int y , int z = 0 ) ; } // expected-note {{candidate}}
namespace ns1 { using A : : foo ; }
namespace ns2 { struct Baz : ns1 : : Bar { } ; }
namespace A { void foo ( ns0 : : Foo * p , int y = 0 , int z ) ; }
void test ( ns2 : : Baz * p ) {
foo ( p , 0 , 0 ) ; // okay!
foo ( p , 0 ) ; // should be fine!
foo ( p ) ; // expected-error {{no matching function}}
}
}
2010-11-10 10:40:36 +08:00
namespace test2 {
namespace ns { int foo ; }
template < class T > using ns : : foo ; // expected-error {{cannot template a using declaration}}
// PR8022
struct A {
template < typename T > void f ( T ) ;
} ;
class B : A {
template < typename T > using A : : f < T > ; // expected-error {{cannot template a using declaration}}
} ;
}
2010-12-21 15:41:49 +08:00
// PR8756
namespace foo
{
class Class1 ; // expected-note{{forward declaration}}
class Class2
{
using : : foo : : Class1 : : Function ; // expected-error{{incomplete type 'foo::Class1' named in nested name specifier}}
} ;
}
2013-07-11 01:34:22 +08:00
// Don't suggest non-typenames for positions requiring typenames.
namespace using_suggestion_tyname_val {
namespace N { void FFF ( ) { } }
using typename N : : FFG ; // expected-error {{no member named 'FFG' in namespace 'using_suggestion_tyname_val::N'}}
}
namespace using_suggestion_member_tyname_val {
class CCC { public : void AAA ( ) { } } ;
class DDD : public CCC { public : using typename CCC : : AAB ; } ; // expected-error {{no member named 'AAB' in 'using_suggestion_member_tyname_val::CCC'}}
}
namespace using_suggestion_tyname_val_dropped_specifier {
void FFF ( ) { }
namespace N { }
using typename N : : FFG ; // expected-error {{no member named 'FFG' in namespace 'using_suggestion_tyname_val_dropped_specifier::N'}}
}
// Currently hints aren't provided to drop out the incorrect M::.
namespace using_suggestion_ty_dropped_nested_specifier {
namespace N {
2013-10-19 08:04:52 +08:00
class AAA { } ; // expected-note {{'N::AAA' declared here}}
2013-07-11 01:34:22 +08:00
namespace M { }
}
2013-10-19 08:04:52 +08:00
using N : : M : : AAA ; // expected-error {{no member named 'AAA' in namespace 'using_suggestion_ty_dropped_nested_specifier::N::M'; did you mean 'N::AAA'?}}
2013-07-11 01:34:22 +08:00
}
namespace using_suggestion_tyname_ty_dropped_nested_specifier {
namespace N {
2013-10-19 08:04:52 +08:00
class AAA { } ; // expected-note {{'N::AAA' declared here}}
2013-07-11 01:34:22 +08:00
namespace M { }
}
2013-10-19 08:04:52 +08:00
using typename N : : M : : AAA ; // expected-error {{no member named 'AAA' in namespace 'using_suggestion_tyname_ty_dropped_nested_specifier::N::M'; did you mean 'N::AAA'?}}
2013-07-11 01:34:22 +08:00
}
namespace using_suggestion_val_dropped_nested_specifier {
namespace N {
2013-10-19 08:04:52 +08:00
void FFF ( ) { } // expected-note {{'N::FFF' declared here}}
2013-07-11 01:34:22 +08:00
namespace M { }
}
2013-10-19 08:04:52 +08:00
using N : : M : : FFF ; // expected-error {{no member named 'FFF' in namespace 'using_suggestion_val_dropped_nested_specifier::N::M'; did you mean 'N::FFF'?}}
2013-07-11 01:34:22 +08:00
}
2014-04-11 09:03:38 +08:00
namespace UsingDeclVsHiddenName {
namespace A {
enum HiddenTag1 { } ; // expected-note {{previous use is here}}
enum HiddenTag2 { } ; // expected-note {{target}}
int HiddenFn1 ; // expected-note {{target}}
int HiddenFn2 ; // expected-note {{target}}
int HiddenLocalExtern1 ;
int HiddenLocalExtern2 ;
}
namespace B {
using A : : HiddenTag1 ;
using A : : HiddenFn1 ; // expected-note {{using declaration}}
using A : : HiddenLocalExtern1 ;
struct S {
friend struct HiddenTag1 ; // expected-error {{tag type that does not match previous}}
friend struct HiddenTag2 ; // expected-note {{conflicting declaration}}
friend void HiddenFn1 ( ) ; // expected-error {{cannot befriend target of using declaration}}
friend void HiddenFn2 ( ) ; // expected-note {{conflicting declaration}}
void f ( ) {
// OK, these are not in the scope of namespace B, even though they're
// members of the namespace.
void HiddenLocalExtern1 ( ) ;
void HiddenLocalExtern2 ( ) ;
}
} ;
using A : : HiddenTag2 ; // expected-error {{conflicts with declaration already in scope}}
using A : : HiddenFn2 ; // expected-error {{conflicts with declaration already in scope}}
using A : : HiddenLocalExtern2 ;
}
}
2014-05-01 01:40:35 +08:00
2014-05-01 02:15:00 +08:00
namespace PR19171 {
struct Z {
Z ( ) ;
} ;
2014-05-01 01:40:35 +08:00
2014-05-01 02:15:00 +08:00
typedef struct {
Z i ;
} S ;
2014-05-01 01:40:35 +08:00
2014-05-01 02:15:00 +08:00
struct Y : S {
2014-05-01 08:35:04 +08:00
using S : : S ;
# if __cplusplus < 201103L
// expected-error@-2 {{no member named 'S' in 'PR19171::S'}}
# endif
2014-05-01 02:15:00 +08:00
} ;
2014-05-01 01:40:35 +08:00
2014-05-01 02:15:00 +08:00
// [namespace.udecl]p3: In a using-declaration used as a member-declaration,
// the nested-name-specifier shall name a base class of the class being defined.
// If such a using-declaration names a constructor, the nested-name-specifier
// shall name a direct base class of the class being defined;
2014-05-01 01:40:35 +08:00
2014-05-01 08:35:04 +08:00
struct B_blah { } ;
struct C_blah : B_blah { C_blah ( int ) ; } ; // expected-note 0-1{{declared here}}
struct D1 : C_blah {
// FIXME: We should be able to correct this in C++11 mode.
using B_blah : : C_blah ; // expected-error-re {{no member named 'C_blah' in 'PR19171::B_blah'{{$}}}}
2014-05-01 02:15:00 +08:00
} ;
2014-05-01 08:35:04 +08:00
struct D2 : C_blah {
// Somewhat bizarrely, this names the injected-class-name of B_blah within
// C_blah, and is valid.
using C_blah : : B_blah ;
} ;
struct D3 : C_blah {
using C_blah : : D_blah ;
# if __cplusplus < 201103L
// expected-error-re@-2 {{no member named 'D_blah' in 'PR19171::C_blah'{{$}}}}
# else
// expected-error@-4 {{no member named 'D_blah' in 'PR19171::C_blah'; did you mean 'C_blah'?}}
# endif
} ;
# if __cplusplus >= 201103L
D3 d3 ( 0 ) ; // ok
# endif
2014-05-01 01:40:35 +08:00
2014-05-01 02:15:00 +08:00
struct E { } ;
struct EE { int EE ; } ;
struct F : E {
using E : : EE ; // expected-error-re {{no member named 'EE' in 'PR19171::E'{{$}}}}
} ;
}
namespace TypoCorrectTemplateMember {
struct A {
template < typename T > void foobar ( T ) ; // expected-note {{'foobar' declared here}}
} ;
struct B : A {
using A : : goobar ; // expected-error {{no member named 'goobar' in 'TypoCorrectTemplateMember::A'; did you mean 'foobar'?}}
} ;
}
2014-12-18 08:42:51 +08:00
namespace use_instance_in_static {
struct A { int n ; } ;
struct B : A {
using A : : n ;
static int f ( ) { return n ; } // expected-error {{invalid use of member 'n' in static member function}}
} ;
}
2015-07-06 12:43:58 +08:00
namespace PR24030 {
namespace X {
class A ; // expected-note {{target}}
int i ; // expected-note {{target}}
}
namespace Y {
using X : : A ; // expected-note {{using}}
using X : : i ; // expected-note {{using}}
class A { } ; // expected-error {{conflicts}}
int i ; // expected-error {{conflicts}}
}
}
namespace PR24033 {
extern int a ; // expected-note 2{{target of using declaration}}
void f ( ) ; // expected-note 2{{target of using declaration}}
struct s ; // expected-note 2{{target of using declaration}}
enum e { } ; // expected-note 2{{target of using declaration}}
template < typename > extern int vt ; // expected-note 2{{target of using declaration}} expected-warning 0-1{{extension}}
template < typename > void ft ( ) ; // expected-note 2{{target of using declaration}}
template < typename > struct st ; // expected-note 2{{target of using declaration}}
namespace X {
using PR24033 : : a ; // expected-note {{using declaration}}
using PR24033 : : f ; // expected-note {{using declaration}}
using PR24033 : : s ; // expected-note {{using declaration}}
using PR24033 : : e ; // expected-note {{using declaration}}
using PR24033 : : vt ; // expected-note {{using declaration}}
using PR24033 : : ft ; // expected-note {{using declaration}}
using PR24033 : : st ; // expected-note {{using declaration}}
extern int a ; // expected-error {{declaration conflicts with target of using declaration already in scope}}
void f ( ) ; // expected-error {{declaration conflicts with target of using declaration already in scope}}
struct s ; // expected-error {{declaration conflicts with target of using declaration already in scope}}
enum e { } ; // expected-error {{declaration conflicts with target of using declaration already in scope}}
template < typename > extern int vt ; // expected-error {{declaration conflicts with target of using declaration already in scope}} expected-warning 0-1{{extension}}
template < typename > void ft ( ) ; // expected-error {{declaration conflicts with target of using declaration already in scope}}
template < typename > struct st ; // expected-error {{declaration conflicts with target of using declaration already in scope}}
}
namespace Y {
extern int a ; // expected-note {{conflicting declaration}}
void f ( ) ; // expected-note {{conflicting declaration}}
struct s ; // expected-note {{conflicting declaration}}
enum e { } ; // expected-note {{conflicting declaration}}
template < typename > extern int vt ; // expected-note {{conflicting declaration}} expected-warning 0-1{{extension}}
template < typename > void ft ( ) ; // expected-note {{conflicting declaration}}
template < typename > struct st ; // expected-note {{conflicting declaration}}
using PR24033 : : a ; // expected-error {{target of using declaration conflicts with declaration already in scope}}
using PR24033 : : f ; // expected-error {{target of using declaration conflicts with declaration already in scope}}
using PR24033 : : s ; // expected-error {{target of using declaration conflicts with declaration already in scope}}
using PR24033 : : e ; // expected-error {{target of using declaration conflicts with declaration already in scope}}
using PR24033 : : vt ; // expected-error {{target of using declaration conflicts with declaration already in scope}}
using PR24033 : : ft ; // expected-error {{target of using declaration conflicts with declaration already in scope}}
using PR24033 : : st ; // expected-error {{target of using declaration conflicts with declaration already in scope}}
}
}
2015-10-21 02:12:08 +08:00
namespace field_use {
struct A { int field ; } ;
struct B : A {
// Previously Clang rejected this valid C++11 code because it didn't look
// through the UsingShadowDecl.
using A : : field ;
# if __cplusplus < 201103L
// expected-error@+2 {{invalid use of non-static data member 'field'}}
# endif
enum { X = sizeof ( field ) } ;
} ;
}