Thread safety: small formatting change in test comments
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@139306 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/test/SemaCXX/warn-thread-safety-parsing.cpp b/test/SemaCXX/warn-thread-safety-parsing.cpp
index 8fcac40..67882d0 100644
--- a/test/SemaCXX/warn-thread-safety-parsing.cpp
+++ b/test/SemaCXX/warn-thread-safety-parsing.cpp
@@ -76,32 +76,32 @@
void noanal_fun() __attribute__((no_thread_safety_analysis));
void noanal_fun_args() __attribute__((no_thread_safety_analysis(1))); // \
- expected-error {{attribute takes no arguments}}
+ // expected-error {{attribute takes no arguments}}
int noanal_testfn(int y) __attribute__((no_thread_safety_analysis));
int noanal_testfn(int y) {
int x __attribute__((no_thread_safety_analysis)) = y; // \
- expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
+ // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
return x;
};
int noanal_test_var __attribute__((no_thread_safety_analysis)); // \
- expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
+ // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
class NoanalFoo {
private:
int test_field __attribute__((no_thread_safety_analysis)); // \
- expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
+ // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
void test_method() __attribute__((no_thread_safety_analysis));
};
class __attribute__((no_thread_safety_analysis)) NoanalTestClass { // \
- expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
+ // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
};
void noanal_fun_params(int lvar __attribute__((no_thread_safety_analysis))); // \
- expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
+ // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
//-----------------------------------------//
@@ -115,28 +115,28 @@
int gv_var_noargs __attribute__((guarded_var));
int gv_var_args __attribute__((guarded_var(1))); // \
- expected-error {{attribute takes no arguments}}
+ // expected-error {{attribute takes no arguments}}
class GVFoo {
private:
int gv_field_noargs __attribute__((guarded_var));
int gv_field_args __attribute__((guarded_var(1))); // \
- expected-error {{attribute takes no arguments}}
+ // expected-error {{attribute takes no arguments}}
};
class __attribute__((guarded_var)) GV { // \
- expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
+ // expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
};
void gv_function() __attribute__((guarded_var)); // \
- expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
+ // expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
void gv_function_params(int gv_lvar __attribute__((guarded_var))); // \
- expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
+ // expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
int gv_testfn(int y){
int x __attribute__((guarded_var)) = y; // \
- expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
+ // expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
return x;
}
@@ -153,34 +153,34 @@
int *pgv_pt_var_noargs __attribute__((pt_guarded_var));
int pgv_var_noargs __attribute__((pt_guarded_var)); // \
- expected-warning {{'pt_guarded_var' only applies to pointer types; type here is 'int'}}
+ // expected-warning {{'pt_guarded_var' only applies to pointer types; type here is 'int'}}
class PGVFoo {
private:
int *pt_field_noargs __attribute__((pt_guarded_var));
int field_noargs __attribute__((pt_guarded_var)); // \
- expected-warning {{'pt_guarded_var' only applies to pointer types; type here is 'int'}}
+ // expected-warning {{'pt_guarded_var' only applies to pointer types; type here is 'int'}}
int *gv_field_args __attribute__((pt_guarded_var(1))); // \
- expected-error {{attribute takes no arguments}}
+ // expected-error {{attribute takes no arguments}}
};
class __attribute__((pt_guarded_var)) PGV { // \
- expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
+ // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
};
int *pgv_var_args __attribute__((pt_guarded_var(1))); // \
- expected-error {{attribute takes no arguments}}
+ // expected-error {{attribute takes no arguments}}
void pgv_function() __attribute__((pt_guarded_var)); // \
- expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
+ // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
void pgv_function_params(int *gv_lvar __attribute__((pt_guarded_var))); // \
- expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
+ // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
void pgv_testfn(int y){
int *x __attribute__((pt_guarded_var)) = new int(0); // \
- expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
+ // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
delete x;
}
@@ -198,32 +198,32 @@
};
class __attribute__((lockable (1))) LTestClass_args { // \
- expected-error {{attribute takes no arguments}}
+ // expected-error {{attribute takes no arguments}}
};
void l_test_function() __attribute__((lockable)); // \
- expected-warning {{'lockable' attribute only applies to classes}}
+ // expected-warning {{'lockable' attribute only applies to classes}}
int l_testfn(int y) {
int x __attribute__((lockable)) = y; // \
- expected-warning {{'lockable' attribute only applies to classes}}
+ // expected-warning {{'lockable' attribute only applies to classes}}
return x;
}
int l_test_var __attribute__((lockable)); // \
- expected-warning {{'lockable' attribute only applies to classes}}
+ // expected-warning {{'lockable' attribute only applies to classes}}
class LFoo {
private:
int test_field __attribute__((lockable)); // \
- expected-warning {{'lockable' attribute only applies to classes}}
+ // expected-warning {{'lockable' attribute only applies to classes}}
void test_method() __attribute__((lockable)); // \
- expected-warning {{'lockable' attribute only applies to classes}}
+ // expected-warning {{'lockable' attribute only applies to classes}}
};
void l_function_params(int lvar __attribute__((lockable))); // \
- expected-warning {{'lockable' attribute only applies to classes}}
+ // expected-warning {{'lockable' attribute only applies to classes}}
//-----------------------------------------//
@@ -238,32 +238,32 @@
};
class __attribute__((scoped_lockable (1))) SLTestClass_args { // \
- expected-error {{attribute takes no arguments}}
+ // expected-error {{attribute takes no arguments}}
};
void sl_test_function() __attribute__((scoped_lockable)); // \
- expected-warning {{'scoped_lockable' attribute only applies to classes}}
+ // expected-warning {{'scoped_lockable' attribute only applies to classes}}
int sl_testfn(int y) {
int x __attribute__((scoped_lockable)) = y; // \
- expected-warning {{'scoped_lockable' attribute only applies to classes}}
+ // expected-warning {{'scoped_lockable' attribute only applies to classes}}
return x;
}
int sl_test_var __attribute__((scoped_lockable)); // \
- expected-warning {{'scoped_lockable' attribute only applies to classes}}
+ // expected-warning {{'scoped_lockable' attribute only applies to classes}}
class SLFoo {
private:
int test_field __attribute__((scoped_lockable)); // \
- expected-warning {{'scoped_lockable' attribute only applies to classes}}
+ // expected-warning {{'scoped_lockable' attribute only applies to classes}}
void test_method() __attribute__((scoped_lockable)); // \
- expected-warning {{'scoped_lockable' attribute only applies to classes}}
+ // expected-warning {{'scoped_lockable' attribute only applies to classes}}
};
void sl_function_params(int lvar __attribute__((scoped_lockable))); // \
- expected-warning {{'scoped_lockable' attribute only applies to classes}}
+ // expected-warning {{'scoped_lockable' attribute only applies to classes}}
//-----------------------------------------//
@@ -281,31 +281,31 @@
int gb_var_arg __attribute__((guarded_by(mu1)));
int gb_var_args __attribute__((guarded_by(mu1, mu2))); // \
- expected-error {{attribute takes one argument}}
+ // expected-error {{attribute takes one argument}}
int gb_var_noargs __attribute__((guarded_by)); // \
- expected-error {{attribute takes one argument}}
+ // expected-error {{attribute takes one argument}}
class GBFoo {
private:
int gb_field_noargs __attribute__((guarded_by)); // \
- expected-error {{attribute takes one argument}}
+ // expected-error {{attribute takes one argument}}
int gb_field_args __attribute__((guarded_by(mu1)));
};
class __attribute__((guarded_by(mu1))) GB { // \
- expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
+ // expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
};
void gb_function() __attribute__((guarded_by(mu1))); // \
- expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
+ // expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
void gb_function_params(int gv_lvar __attribute__((guarded_by(mu1)))); // \
- expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
+ // expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
int gb_testfn(int y){
int x __attribute__((guarded_by(mu1))) = y; // \
- expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
+ // expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
return x;
}
@@ -324,13 +324,13 @@
// illegal attribute arguments
int gb_var_arg_bad_1 __attribute__((guarded_by(1))); // \
- expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}}
int gb_var_arg_bad_2 __attribute__((guarded_by("mu"))); // \
- expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}}
int gb_var_arg_bad_3 __attribute__((guarded_by(muDoublePointer))); // \
- expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}}
int gb_var_arg_bad_4 __attribute__((guarded_by(umu))); // \
- expected-error {{'guarded_by' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+ // expected-error {{'guarded_by' attribute requires arguments whose type is annotated with 'lockable' attribute}}
//3.
// Thread Safety analysis tests
@@ -347,36 +347,36 @@
//1. Check applied to the right types & argument number
int *pgb_var_noargs __attribute__((pt_guarded_by)); // \
- expected-error {{attribute takes one argument}}
+ // expected-error {{attribute takes one argument}}
int *pgb_ptr_var_arg __attribute__((pt_guarded_by(mu1)));
int *pgb_ptr_var_args __attribute__((guarded_by(mu1, mu2))); // \
- expected-error {{attribute takes one argument}}
+ // expected-error {{attribute takes one argument}}
int pgb_var_args __attribute__((pt_guarded_by(mu1))); // \
- expected-warning {{'pt_guarded_by' only applies to pointer types; type here is 'int'}}
+ // expected-warning {{'pt_guarded_by' only applies to pointer types; type here is 'int'}}
class PGBFoo {
private:
int *pgb_field_noargs __attribute__((pt_guarded_by)); // \
- expected-error {{attribute takes one argument}}
+ // expected-error {{attribute takes one argument}}
int *pgb_field_args __attribute__((pt_guarded_by(mu1)));
};
class __attribute__((pt_guarded_by(mu1))) PGB { // \
- expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
+ // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
};
void pgb_function() __attribute__((pt_guarded_by(mu1))); // \
- expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
+ // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
void pgb_function_params(int gv_lvar __attribute__((pt_guarded_by(mu1)))); // \
- expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
+ // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
void pgb_testfn(int y){
int *x __attribute__((pt_guarded_by(mu1))) = new int(0); // \
- expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
+ // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
delete x;
}
@@ -395,13 +395,13 @@
// illegal attribute arguments
int * pgb_var_arg_bad_1 __attribute__((pt_guarded_by(1))); // \
- expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}}
int * pgb_var_arg_bad_2 __attribute__((pt_guarded_by("mu"))); // \
- expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}}
int * pgb_var_arg_bad_3 __attribute__((pt_guarded_by(muDoublePointer))); // \
- expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}}
int * pgb_var_arg_bad_4 __attribute__((pt_guarded_by(umu))); // \
- expected-error {{'pt_guarded_by' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+ // expected-error {{'pt_guarded_by' attribute requires arguments whose type is annotated with 'lockable' attribute}}
//-----------------------------------------//
@@ -417,28 +417,28 @@
Mu mu_aa __attribute__((acquired_after(mu1)));
Mu aa_var_noargs __attribute__((acquired_after)); // \
- expected-error {{attribute takes at least 1 argument}}
+ // expected-error {{attribute takes at least 1 argument}}
class AAFoo {
private:
Mu aa_field_noargs __attribute__((acquired_after)); // \
- expected-error {{attribute takes at least 1 argument}}
+ // expected-error {{attribute takes at least 1 argument}}
Mu aa_field_args __attribute__((acquired_after(mu1)));
};
class __attribute__((acquired_after(mu1))) AA { // \
- expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
+ // expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
};
void aa_function() __attribute__((acquired_after(mu1))); // \
- expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
+ // expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
void aa_function_params(int gv_lvar __attribute__((acquired_after(mu1)))); // \
- expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
+ // expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
void aa_testfn(int y){
Mu x __attribute__((acquired_after(mu1))) = Mu(); // \
- expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
+ // expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
}
//Check argument parsing.
@@ -456,15 +456,15 @@
// illegal attribute arguments
Mu aa_var_arg_bad_1 __attribute__((acquired_after(1))); // \
- expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}}
Mu aa_var_arg_bad_2 __attribute__((acquired_after("mu"))); // \
- expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}}
Mu aa_var_arg_bad_3 __attribute__((acquired_after(muDoublePointer))); // \
- expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}}
Mu aa_var_arg_bad_4 __attribute__((acquired_after(umu))); // \
- expected-error {{'acquired_after' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+ // expected-error {{'acquired_after' attribute requires arguments whose type is annotated with 'lockable' attribute}}
UnlockableMu aa_var_arg_bad_5 __attribute__((acquired_after(mu_aa))); // \
- expected-error {{'acquired_after' attribute can only be applied in a context annotated with 'lockable' attribute}}
+ // expected-error {{'acquired_after' attribute can only be applied in a context annotated with 'lockable' attribute}}
//-----------------------------------------//
// Acquired Before (ab)
@@ -477,28 +477,28 @@
Mu mu_ab __attribute__((acquired_before(mu1)));
Mu ab_var_noargs __attribute__((acquired_before)); // \
- expected-error {{attribute takes at least 1 argument}}
+ // expected-error {{attribute takes at least 1 argument}}
class ABFoo {
private:
Mu ab_field_noargs __attribute__((acquired_before)); // \
- expected-error {{attribute takes at least 1 argument}}
+ // expected-error {{attribute takes at least 1 argument}}
Mu ab_field_args __attribute__((acquired_before(mu1)));
};
class __attribute__((acquired_before(mu1))) AB { // \
- expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
+ // expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
};
void ab_function() __attribute__((acquired_before(mu1))); // \
- expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
+ // expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
void ab_function_params(int gv_lvar __attribute__((acquired_before(mu1)))); // \
- expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
+ // expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
void ab_testfn(int y){
Mu x __attribute__((acquired_before(mu1))) = Mu(); // \
- expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
+ // expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
}
// Note: illegal int ab_int __attribute__((acquired_before(mu1))) will
@@ -519,15 +519,15 @@
// illegal attribute arguments
Mu ab_var_arg_bad_1 __attribute__((acquired_before(1))); // \
- expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}}
Mu ab_var_arg_bad_2 __attribute__((acquired_before("mu"))); // \
- expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}}
Mu ab_var_arg_bad_3 __attribute__((acquired_before(muDoublePointer))); // \
- expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}}
Mu ab_var_arg_bad_4 __attribute__((acquired_before(umu))); // \
- expected-error {{'acquired_before' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+ // expected-error {{'acquired_before' attribute requires arguments whose type is annotated with 'lockable' attribute}}
UnlockableMu ab_var_arg_bad_5 __attribute__((acquired_before(mu_ab))); // \
- expected-error {{'acquired_before' attribute can only be applied in a context annotated with 'lockable' attribute}}
+ // expected-error {{'acquired_before' attribute can only be applied in a context annotated with 'lockable' attribute}}
//-----------------------------------------//
@@ -548,26 +548,26 @@
int elf_testfn(int y) {
int x __attribute__((exclusive_lock_function)) = y; // \
- expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
return x;
};
int elf_test_var __attribute__((exclusive_lock_function)); // \
- expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
class ElfFoo {
private:
int test_field __attribute__((exclusive_lock_function)); // \
- expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
void test_method() __attribute__((exclusive_lock_function));
};
class __attribute__((exclusive_lock_function)) ElfTestClass { // \
- expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
};
void elf_fun_params(int lvar __attribute__((exclusive_lock_function))); // \
- expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
// Check argument parsing.
@@ -586,20 +586,20 @@
// illegal attribute arguments
int elf_function_bad_2() __attribute__((exclusive_lock_function("mu"))); // \
- expected-error {{'exclusive_lock_function' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'exclusive_lock_function' attribute requires arguments that are class type or point to class type}}
int elf_function_bad_3() __attribute__((exclusive_lock_function(muDoublePointer))); // \
- expected-error {{'exclusive_lock_function' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'exclusive_lock_function' attribute requires arguments that are class type or point to class type}}
int elf_function_bad_4() __attribute__((exclusive_lock_function(umu))); // \
- expected-error {{'exclusive_lock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+ // expected-error {{'exclusive_lock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
int elf_function_bad_1() __attribute__((exclusive_lock_function(1))); // \
- expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
+ // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
int elf_function_bad_5(Mu x) __attribute__((exclusive_lock_function(0))); // \
- expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}}
+ // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}}
int elf_function_bad_6(Mu x, Mu y) __attribute__((exclusive_lock_function(0))); // \
- expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}}
+ // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}}
int elf_function_bad_7() __attribute__((exclusive_lock_function(0))); // \
- expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
+ // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
//-----------------------------------------//
@@ -620,25 +620,25 @@
int slf_testfn(int y) {
int x __attribute__((shared_lock_function)) = y; // \
- expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
return x;
};
int slf_test_var __attribute__((shared_lock_function)); // \
- expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
void slf_fun_params(int lvar __attribute__((shared_lock_function))); // \
- expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
class SlfFoo {
private:
int test_field __attribute__((shared_lock_function)); // \
- expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
void test_method() __attribute__((shared_lock_function));
};
class __attribute__((shared_lock_function)) SlfTestClass { // \
- expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
};
// Check argument parsing.
@@ -658,20 +658,20 @@
// illegal attribute arguments
int slf_function_bad_2() __attribute__((shared_lock_function("mu"))); // \
- expected-error {{'shared_lock_function' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'shared_lock_function' attribute requires arguments that are class type or point to class type}}
int slf_function_bad_3() __attribute__((shared_lock_function(muDoublePointer))); // \
- expected-error {{'shared_lock_function' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'shared_lock_function' attribute requires arguments that are class type or point to class type}}
int slf_function_bad_4() __attribute__((shared_lock_function(umu))); // \
- expected-error {{'shared_lock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+ // expected-error {{'shared_lock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
int slf_function_bad_1() __attribute__((shared_lock_function(1))); // \
- expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
+ // expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
int slf_function_bad_5(Mu x) __attribute__((shared_lock_function(0))); // \
- expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}}
+ // expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}}
int slf_function_bad_6(Mu x, Mu y) __attribute__((shared_lock_function(0))); // \
- expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}}
+ // expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}}
int slf_function_bad_7() __attribute__((shared_lock_function(0))); // \
- expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
+ // expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
//-----------------------------------------//
@@ -686,7 +686,7 @@
// plus an optional list of locks (vars/fields)
void etf_function() __attribute__((exclusive_trylock_function)); // \
- expected-error {{attribute takes attribute takes at least 1 argument arguments}}
+ // expected-error {{attribute takes attribute takes at least 1 argument arguments}}
void etf_function_args() __attribute__((exclusive_trylock_function(1, mu2)));
@@ -696,26 +696,26 @@
int etf_testfn(int y) {
int x __attribute__((exclusive_trylock_function(1))) = y; // \
- expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}}
return x;
};
int etf_test_var __attribute__((exclusive_trylock_function(1))); // \
- expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}}
class EtfFoo {
private:
int test_field __attribute__((exclusive_trylock_function(1))); // \
- expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}}
void test_method() __attribute__((exclusive_trylock_function(1)));
};
class __attribute__((exclusive_trylock_function(1))) EtfTestClass { // \
- expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}}
};
void etf_fun_params(int lvar __attribute__((exclusive_trylock_function(1)))); // \
- expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}}
// Check argument parsing.
@@ -733,18 +733,18 @@
// illegal attribute arguments
int etf_function_bad_1() __attribute__((exclusive_trylock_function(mu1))); // \
- expected-error {{'exclusive_trylock_function' attribute first argument must be of int or bool type}}
+ // expected-error {{'exclusive_trylock_function' attribute first argument must be of int or bool type}}
int etf_function_bad_2() __attribute__((exclusive_trylock_function("mu"))); // \
- expected-error {{'exclusive_trylock_function' attribute first argument must be of int or bool type}}
+ // expected-error {{'exclusive_trylock_function' attribute first argument must be of int or bool type}}
int etf_function_bad_3() __attribute__((exclusive_trylock_function(muDoublePointer))); // \
- expected-error {{'exclusive_trylock_function' attribute first argument must be of int or bool type}}
+ // expected-error {{'exclusive_trylock_function' attribute first argument must be of int or bool type}}
int etf_function_bad_4() __attribute__((exclusive_trylock_function(1, "mu"))); // \
- expected-error {{'exclusive_trylock_function' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'exclusive_trylock_function' attribute requires arguments that are class type or point to class type}}
int etf_function_bad_5() __attribute__((exclusive_trylock_function(1, muDoublePointer))); // \
- expected-error {{'exclusive_trylock_function' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'exclusive_trylock_function' attribute requires arguments that are class type or point to class type}}
int etf_function_bad_6() __attribute__((exclusive_trylock_function(1, umu))); // \
- expected-error {{'exclusive_trylock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+ // expected-error {{'exclusive_trylock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
//-----------------------------------------//
@@ -759,7 +759,7 @@
// plus an optional list of locks (vars/fields)
void stf_function() __attribute__((shared_trylock_function)); // \
- expected-error {{attribute takes at least 1 argument}}
+ // expected-error {{attribute takes at least 1 argument}}
void stf_function_args() __attribute__((shared_trylock_function(1, mu2)));
@@ -769,26 +769,26 @@
int stf_testfn(int y) {
int x __attribute__((shared_trylock_function(1))) = y; // \
- expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}}
return x;
};
int stf_test_var __attribute__((shared_trylock_function(1))); // \
- expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}}
void stf_fun_params(int lvar __attribute__((shared_trylock_function(1)))); // \
- expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}}
class StfFoo {
private:
int test_field __attribute__((shared_trylock_function(1))); // \
- expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}}
void test_method() __attribute__((shared_trylock_function(1)));
};
class __attribute__((shared_trylock_function(1))) StfTestClass { // \
- expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}}
};
// Check argument parsing.
@@ -807,18 +807,18 @@
// illegal attribute arguments
int stf_function_bad_1() __attribute__((shared_trylock_function(mu1))); // \
- expected-error {{'shared_trylock_function' attribute first argument must be of int or bool type}}
+ // expected-error {{'shared_trylock_function' attribute first argument must be of int or bool type}}
int stf_function_bad_2() __attribute__((shared_trylock_function("mu"))); // \
- expected-error {{'shared_trylock_function' attribute first argument must be of int or bool type}}
+ // expected-error {{'shared_trylock_function' attribute first argument must be of int or bool type}}
int stf_function_bad_3() __attribute__((shared_trylock_function(muDoublePointer))); // \
- expected-error {{'shared_trylock_function' attribute first argument must be of int or bool type}}
+ // expected-error {{'shared_trylock_function' attribute first argument must be of int or bool type}}
int stf_function_bad_4() __attribute__((shared_trylock_function(1, "mu"))); // \
- expected-error {{'shared_trylock_function' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'shared_trylock_function' attribute requires arguments that are class type or point to class type}}
int stf_function_bad_5() __attribute__((shared_trylock_function(1, muDoublePointer))); // \
- expected-error {{'shared_trylock_function' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'shared_trylock_function' attribute requires arguments that are class type or point to class type}}
int stf_function_bad_6() __attribute__((shared_trylock_function(1, umu))); // \
- expected-error {{'shared_trylock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+ // expected-error {{'shared_trylock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
//-----------------------------------------//
@@ -839,26 +839,26 @@
int uf_testfn(int y) {
int x __attribute__((unlock_function)) = y; // \
- expected-warning {{'unlock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'unlock_function' attribute only applies to functions and methods}}
return x;
};
int uf_test_var __attribute__((unlock_function)); // \
- expected-warning {{'unlock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'unlock_function' attribute only applies to functions and methods}}
class UfFoo {
private:
int test_field __attribute__((unlock_function)); // \
- expected-warning {{'unlock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'unlock_function' attribute only applies to functions and methods}}
void test_method() __attribute__((unlock_function));
};
class __attribute__((no_thread_safety_analysis)) UfTestClass { // \
- expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
+ // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
};
void uf_fun_params(int lvar __attribute__((unlock_function))); // \
- expected-warning {{'unlock_function' attribute only applies to functions and methods}}
+ // expected-warning {{'unlock_function' attribute only applies to functions and methods}}
// Check argument parsing.
@@ -877,20 +877,20 @@
// illegal attribute arguments
int uf_function_bad_2() __attribute__((unlock_function("mu"))); // \
- expected-error {{'unlock_function' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'unlock_function' attribute requires arguments that are class type or point to class type}}
int uf_function_bad_3() __attribute__((unlock_function(muDoublePointer))); // \
-expected-error {{'unlock_function' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'unlock_function' attribute requires arguments that are class type or point to class type}}
int uf_function_bad_4() __attribute__((unlock_function(umu))); // \
- expected-error {{'unlock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+ // expected-error {{'unlock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
int uf_function_bad_1() __attribute__((unlock_function(1))); // \
- expected-error {{'unlock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
+ // expected-error {{'unlock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
int uf_function_bad_5(Mu x) __attribute__((unlock_function(0))); // \
- expected-error {{'unlock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}}
+ // expected-error {{'unlock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}}
int uf_function_bad_6(Mu x, Mu y) __attribute__((unlock_function(0))); // \
- expected-error {{'unlock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}}
+ // expected-error {{'unlock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}}
int uf_function_bad_7() __attribute__((unlock_function(0))); // \
- expected-error {{'unlock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
+ // expected-error {{'unlock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
//-----------------------------------------//
@@ -904,36 +904,36 @@
// Takes exactly one argument, a var/field
void lr_function() __attribute__((lock_returned)); // \
- expected-error {{attribute takes one argument}}
+ // expected-error {{attribute takes one argument}}
void lr_function_arg() __attribute__((lock_returned(mu1)));
void lr_function_args() __attribute__((lock_returned(mu1, mu2))); // \
- expected-error {{attribute takes one argument}}
+ // expected-error {{attribute takes one argument}}
int lr_testfn(int y) __attribute__((lock_returned(mu1)));
int lr_testfn(int y) {
int x __attribute__((lock_returned(mu1))) = y; // \
- expected-warning {{'lock_returned' attribute only applies to functions and methods}}
+ // expected-warning {{'lock_returned' attribute only applies to functions and methods}}
return x;
};
int lr_test_var __attribute__((lock_returned(mu1))); // \
- expected-warning {{'lock_returned' attribute only applies to functions and methods}}
+ // expected-warning {{'lock_returned' attribute only applies to functions and methods}}
void lr_fun_params(int lvar __attribute__((lock_returned(mu1)))); // \
- expected-warning {{'lock_returned' attribute only applies to functions and methods}}
+ // expected-warning {{'lock_returned' attribute only applies to functions and methods}}
class LrFoo {
private:
int test_field __attribute__((lock_returned(mu1))); // \
- expected-warning {{'lock_returned' attribute only applies to functions and methods}}
+ // expected-warning {{'lock_returned' attribute only applies to functions and methods}}
void test_method() __attribute__((lock_returned(mu1)));
};
class __attribute__((lock_returned(mu1))) LrTestClass { // \
- expected-warning {{'lock_returned' attribute only applies to functions and methods}}
+ // expected-warning {{'lock_returned' attribute only applies to functions and methods}}
};
// Check argument parsing.
@@ -951,13 +951,13 @@
// illegal attribute arguments
int lr_function_bad_1() __attribute__((lock_returned(1))); // \
- expected-error {{'lock_returned' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'lock_returned' attribute requires arguments that are class type or point to class type}}
int lr_function_bad_2() __attribute__((lock_returned("mu"))); // \
- expected-error {{'lock_returned' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'lock_returned' attribute requires arguments that are class type or point to class type}}
int lr_function_bad_3() __attribute__((lock_returned(muDoublePointer))); // \
- expected-error {{'lock_returned' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'lock_returned' attribute requires arguments that are class type or point to class type}}
int lr_function_bad_4() __attribute__((lock_returned(umu))); // \
- expected-error {{'lock_returned' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+ // expected-error {{'lock_returned' attribute requires arguments whose type is annotated with 'lockable' attribute}}
@@ -972,7 +972,7 @@
// takes one or more arguments, all locks (vars/fields)
void le_function() __attribute__((locks_excluded)); // \
- expected-error {{attribute takes at least 1 argument}}
+ // expected-error {{attribute takes at least 1 argument}}
void le_function_arg() __attribute__((locks_excluded(mu1)));
@@ -982,25 +982,25 @@
int le_testfn(int y) {
int x __attribute__((locks_excluded(mu1))) = y; // \
- expected-warning {{'locks_excluded' attribute only applies to functions and methods}}
+ // expected-warning {{'locks_excluded' attribute only applies to functions and methods}}
return x;
};
int le_test_var __attribute__((locks_excluded(mu1))); // \
- expected-warning {{'locks_excluded' attribute only applies to functions and methods}}
+ // expected-warning {{'locks_excluded' attribute only applies to functions and methods}}
void le_fun_params(int lvar __attribute__((locks_excluded(mu1)))); // \
- expected-warning {{'locks_excluded' attribute only applies to functions and methods}}
+ // expected-warning {{'locks_excluded' attribute only applies to functions and methods}}
class LeFoo {
private:
int test_field __attribute__((locks_excluded(mu1))); // \
- expected-warning {{'locks_excluded' attribute only applies to functions and methods}}
+ // expected-warning {{'locks_excluded' attribute only applies to functions and methods}}
void test_method() __attribute__((locks_excluded(mu1)));
};
class __attribute__((locks_excluded(mu1))) LeTestClass { // \
- expected-warning {{'locks_excluded' attribute only applies to functions and methods}}
+ // expected-warning {{'locks_excluded' attribute only applies to functions and methods}}
};
// Check argument parsing.
@@ -1018,13 +1018,13 @@
// illegal attribute arguments
int le_function_bad_1() __attribute__((locks_excluded(1))); // \
- expected-error {{'locks_excluded' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'locks_excluded' attribute requires arguments that are class type or point to class type}}
int le_function_bad_2() __attribute__((locks_excluded("mu"))); // \
- expected-error {{'locks_excluded' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'locks_excluded' attribute requires arguments that are class type or point to class type}}
int le_function_bad_3() __attribute__((locks_excluded(muDoublePointer))); // \
- expected-error {{'locks_excluded' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'locks_excluded' attribute requires arguments that are class type or point to class type}}
int le_function_bad_4() __attribute__((locks_excluded(umu))); // \
- expected-error {{'locks_excluded' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+ // expected-error {{'locks_excluded' attribute requires arguments whose type is annotated with 'lockable' attribute}}
@@ -1039,7 +1039,7 @@
// takes one or more arguments, all locks (vars/fields)
void elr_function() __attribute__((exclusive_locks_required)); // \
- expected-error {{attribute takes at least 1 argument}}
+ // expected-error {{attribute takes at least 1 argument}}
void elr_function_arg() __attribute__((exclusive_locks_required(mu1)));
@@ -1049,25 +1049,25 @@
int elr_testfn(int y) {
int x __attribute__((exclusive_locks_required(mu1))) = y; // \
- expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}}
+ // expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}}
return x;
};
int elr_test_var __attribute__((exclusive_locks_required(mu1))); // \
- expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}}
+ // expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}}
void elr_fun_params(int lvar __attribute__((exclusive_locks_required(mu1)))); // \
- expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}}
+ // expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}}
class ElrFoo {
private:
int test_field __attribute__((exclusive_locks_required(mu1))); // \
- expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}}
+ // expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}}
void test_method() __attribute__((exclusive_locks_required(mu1)));
};
class __attribute__((exclusive_locks_required(mu1))) ElrTestClass { // \
- expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}}
+ // expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}}
};
// Check argument parsing.
@@ -1085,13 +1085,13 @@
// illegal attribute arguments
int elr_function_bad_1() __attribute__((exclusive_locks_required(1))); // \
- expected-error {{'exclusive_locks_required' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'exclusive_locks_required' attribute requires arguments that are class type or point to class type}}
int elr_function_bad_2() __attribute__((exclusive_locks_required("mu"))); // \
- expected-error {{'exclusive_locks_required' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'exclusive_locks_required' attribute requires arguments that are class type or point to class type}}
int elr_function_bad_3() __attribute__((exclusive_locks_required(muDoublePointer))); // \
- expected-error {{'exclusive_locks_required' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'exclusive_locks_required' attribute requires arguments that are class type or point to class type}}
int elr_function_bad_4() __attribute__((exclusive_locks_required(umu))); // \
- expected-error {{'exclusive_locks_required' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+ // expected-error {{'exclusive_locks_required' attribute requires arguments whose type is annotated with 'lockable' attribute}}
@@ -1107,7 +1107,7 @@
// takes one or more arguments, all locks (vars/fields)
void slr_function() __attribute__((shared_locks_required)); // \
- expected-error {{attribute takes at least 1 argument}}
+ // expected-error {{attribute takes at least 1 argument}}
void slr_function_arg() __attribute__((shared_locks_required(mu1)));
@@ -1117,25 +1117,25 @@
int slr_testfn(int y) {
int x __attribute__((shared_locks_required(mu1))) = y; // \
- expected-warning {{'shared_locks_required' attribute only applies to functions and methods}}
+ // expected-warning {{'shared_locks_required' attribute only applies to functions and methods}}
return x;
};
int slr_test_var __attribute__((shared_locks_required(mu1))); // \
- expected-warning {{'shared_locks_required' attribute only applies to functions and methods}}
+ // expected-warning {{'shared_locks_required' attribute only applies to functions and methods}}
void slr_fun_params(int lvar __attribute__((shared_locks_required(mu1)))); // \
- expected-warning {{'shared_locks_required' attribute only applies to functions and methods}}
+ // expected-warning {{'shared_locks_required' attribute only applies to functions and methods}}
class SlrFoo {
private:
int test_field __attribute__((shared_locks_required(mu1))); // \
- expected-warning {{'shared_locks_required' attribute only applies to functions and methods}}
+ // expected-warning {{'shared_locks_required' attribute only applies to functions and methods}}
void test_method() __attribute__((shared_locks_required(mu1)));
};
class __attribute__((shared_locks_required(mu1))) SlrTestClass { // \
- expected-warning {{'shared_locks_required' attribute only applies to functions and methods}}
+ // expected-warning {{'shared_locks_required' attribute only applies to functions and methods}}
};
// Check argument parsing.
@@ -1153,13 +1153,13 @@
// illegal attribute arguments
int slr_function_bad_1() __attribute__((shared_locks_required(1))); // \
- expected-error {{'shared_locks_required' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'shared_locks_required' attribute requires arguments that are class type or point to class type}}
int slr_function_bad_2() __attribute__((shared_locks_required("mu"))); // \
- expected-error {{'shared_locks_required' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'shared_locks_required' attribute requires arguments that are class type or point to class type}}
int slr_function_bad_3() __attribute__((shared_locks_required(muDoublePointer))); // \
- expected-error {{'shared_locks_required' attribute requires arguments that are class type or point to class type}}
+ // expected-error {{'shared_locks_required' attribute requires arguments that are class type or point to class type}}
int slr_function_bad_4() __attribute__((shared_locks_required(umu))); // \
- expected-error {{'shared_locks_required' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+ // expected-error {{'shared_locks_required' attribute requires arguments whose type is annotated with 'lockable' attribute}}
//-----------------------------------------//
@@ -1238,7 +1238,7 @@
void foo4(FooLate *f) __attribute__((exclusive_locks_required(f->mu)));
static void foo5() __attribute__((exclusive_locks_required(mu))); // \
- expected-error {{invalid use of member 'mu' in static member function}}
+ // expected-error {{invalid use of member 'mu' in static member function}}
template <class T>
void foo6() __attribute__((exclusive_locks_required(T::statmu))) { }