2010-12-20 11:51:03 +08:00
// RUN: %clang_cc1 %s -fsyntax-only -Wno-unused-value -Wmicrosoft -verify -fms-extensions
2010-10-13 00:46:35 +08:00
/* Microsoft attribute tests */
[ repeatable ] [ source_annotation_attribute ( Parameter | ReturnValue ) ]
struct SA_Post { SA_Post ( ) ; int attr ; } ;
[ returnvalue : SA_Post ( attr = 1 ) ]
int foo1 ( [ SA_Post ( attr = 1 ) ] void * param ) ;
namespace {
[ returnvalue : SA_Post ( attr = 1 ) ]
int foo2 ( [ SA_Post ( attr = 1 ) ] void * param ) ;
}
class T {
[ returnvalue : SA_Post ( attr = 1 ) ]
int foo3 ( [ SA_Post ( attr = 1 ) ] void * param ) ;
} ;
extern " C " {
[ returnvalue : SA_Post ( attr = 1 ) ]
int foo5 ( [ SA_Post ( attr = 1 ) ] void * param ) ;
}
2011-01-31 12:54:32 +08:00
class class_attr {
public :
class_attr ( [ SA_Pre ( Null = SA_No , NullTerminated = SA_Yes ) ] int a )
{
}
} ;
2010-10-13 00:46:35 +08:00
2010-12-20 11:51:03 +08:00
void uuidof_test1 ( )
{
__uuidof ( 0 ) ; // expected-error {{you need to include <guiddef.h> before using the '__uuidof' operator}}
}
typedef struct _GUID
{
unsigned long Data1 ;
unsigned short Data2 ;
unsigned short Data3 ;
unsigned char Data4 [ 8 ] ;
} GUID ;
struct __declspec ( uuid ( L " 00000000-0000-0000-1234-000000000047 " ) ) uuid_attr_bad1 { } ; // expected-error {{'uuid' attribute requires parameter 1 to be a string}}
struct __declspec ( uuid ( 3 ) ) uuid_attr_bad2 { } ; // expected-error {{'uuid' attribute requires parameter 1 to be a string}}
struct __declspec ( uuid ( " 0000000-0000-0000-1234-0000500000047 " ) ) uuid_attr_bad3 { } ; // expected-error {{uuid attribute contains a malformed GUID}}
struct __declspec ( uuid ( " 0000000-0000-0000-Z234-000000000047 " ) ) uuid_attr_bad4 { } ; // expected-error {{uuid attribute contains a malformed GUID}}
struct __declspec ( uuid ( " 000000000000-0000-1234-000000000047 " ) ) uuid_attr_bad5 { } ; // expected-error {{uuid attribute contains a malformed GUID}}
struct __declspec ( uuid ( " 000000A0-0000-0000-C000-000000000046 " ) )
struct_with_uuid { } ;
struct struct_without_uuid { } ;
2010-12-27 09:32:00 +08:00
struct __declspec ( uuid ( " 000000A0-0000-0000-C000-000000000049 " ) )
struct_with_uuid2 ;
struct
struct_with_uuid2 { } ;
2010-12-20 11:51:03 +08:00
int uuid_sema_test ( )
{
struct_with_uuid var_with_uuid [ 1 ] ;
struct_without_uuid var_without_uuid [ 1 ] ;
__uuidof ( struct_with_uuid ) ;
2010-12-27 09:32:00 +08:00
__uuidof ( struct_with_uuid2 ) ;
2010-12-20 11:51:03 +08:00
__uuidof ( struct_without_uuid ) ; // expected-error {{cannot call operator __uuidof on a type with no GUID}}
__uuidof ( struct_with_uuid * ) ;
__uuidof ( struct_without_uuid * ) ; // expected-error {{cannot call operator __uuidof on a type with no GUID}}
__uuidof ( var_with_uuid ) ;
__uuidof ( var_without_uuid ) ; // expected-error {{cannot call operator __uuidof on a type with no GUID}}
__uuidof ( var_with_uuid [ 1 ] ) ;
__uuidof ( var_without_uuid [ 1 ] ) ; // expected-error {{cannot call operator __uuidof on a type with no GUID}}
__uuidof ( & var_with_uuid [ 1 ] ) ;
__uuidof ( & var_without_uuid [ 1 ] ) ; // expected-error {{cannot call operator __uuidof on a type with no GUID}}
__uuidof ( 0 ) ;
__uuidof ( 1 ) ; // expected-error {{cannot call operator __uuidof on a type with no GUID}}
}
2010-12-27 09:32:00 +08:00
template < class T >
void template_uuid ( )
{
T expr ;
__uuidof ( T ) ;
__uuidof ( expr ) ;
}
2011-01-18 13:04:39 +08:00
class CtorCall {
public :
CtorCall & operator = ( const CtorCall & that ) ;
int a ;
} ;
CtorCall & CtorCall : : operator = ( const CtorCall & that )
{
if ( this ! = & that ) {
this - > CtorCall : : ~ CtorCall ( ) ;
this - > CtorCall : : CtorCall ( that ) ; // expected-warning {{explicit constructor calls are a Microsoft extension}}
}
return * this ;
}
2011-03-28 03:41:34 +08:00
template < class A >
class C1 {
public :
template < int B >
class Iterator {
} ;
} ;
template < class T >
class C2 {
typename C1 < T > : : /*template*/ Iterator < 0 > Mypos ; // expected-warning {{use 'template' keyword to treat 'Iterator' as a dependent template name}}
} ;
template < class T >
void f ( ) {
typename C1 < T > : : /*template*/ Iterator < 0 > Mypos ; // expected-warning {{use 'template' keyword to treat 'Iterator' as a dependent template name}}
}
int main ( ) {
f < int > ( ) ;
}