TestNonParameterChecker.cpp (9633B)
1 #define MOZ_NON_PARAM __attribute__((annotate("moz_non_param"))) 2 3 struct Param {}; 4 struct MOZ_NON_PARAM NonParam {}; 5 union MOZ_NON_PARAM NonParamUnion {}; 6 class MOZ_NON_PARAM NonParamClass {}; 7 enum MOZ_NON_PARAM NonParamEnum { X, Y, Z }; 8 enum class MOZ_NON_PARAM NonParamEnumClass { X, Y, Z }; 9 10 struct HasNonParamStruct { NonParam x; int y; }; // expected-note 14 {{'HasNonParamStruct' is a non-param type because member 'x' is a non-param type 'NonParam'}} 11 union HasNonParamUnion { NonParam x; int y; }; // expected-note 18 {{'HasNonParamUnion' is a non-param type because member 'x' is a non-param type 'NonParam'}} 12 struct HasNonParamStructUnion { HasNonParamUnion z; }; // expected-note 9 {{'HasNonParamStructUnion' is a non-param type because member 'z' is a non-param type 'HasNonParamUnion'}} 13 14 #define MAYBE_STATIC 15 #include "NonParameterTestCases.h" 16 #undef MAYBE_STATIC 17 18 // Do not check typedef and using. 19 typedef void (*funcTypeParam)(Param x); 20 typedef void (*funcTypeNonParam)(NonParam x); 21 22 using usingFuncTypeParam = void (*)(Param x); 23 using usingFuncTypeNonParam = void (*)(NonParam x); 24 25 class class_ 26 { 27 explicit class_(Param x) {} 28 explicit class_(NonParam x) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 29 explicit class_(HasNonParamStruct x) {} //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 30 explicit class_(HasNonParamUnion x) {} //expected-error {{Type 'HasNonParamUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 31 explicit class_(HasNonParamStructUnion x) {} //expected-error {{Type 'HasNonParamStructUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 32 33 #define MAYBE_STATIC 34 #include "NonParameterTestCases.h" 35 #undef MAYBE_STATIC 36 }; 37 38 class classWithStatic 39 { 40 #define MAYBE_STATIC static 41 #include "NonParameterTestCases.h" 42 #undef MAYBE_STATIC 43 }; 44 45 template <typename T> 46 class tmplClassForParam 47 { 48 public: 49 void raw(T x) {} 50 void rawDefault(T x = T()) {} 51 void const_(const T x) {} 52 void ptr(T* x) {} 53 void ref(T& x) {} 54 void constRef(const T& x) {} 55 56 void notCalled(T x) {} 57 }; 58 59 template <typename T> 60 class tmplClassForNonParam 61 { 62 public: 63 void raw(T x) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 64 void rawDefault(T x = T()) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 65 void const_(const T x) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 66 void ptr(T* x) {} 67 void ref(T& x) {} 68 void constRef(const T& x) {} 69 70 void notCalled(T x) {} 71 }; 72 73 template <typename T> 74 class tmplClassForHasNonParamStruct 75 { 76 public: 77 void raw(T x) {} //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 78 void rawDefault(T x = T()) {} //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 79 void const_(const T x) {} //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 80 void ptr(T* x) {} 81 void ref(T& x) {} 82 void constRef(const T& x) {} 83 84 void notCalled(T x) {} 85 }; 86 87 void testTemplateClass() 88 { 89 tmplClassForParam<Param> paramClass; 90 Param param; 91 paramClass.raw(param); 92 paramClass.rawDefault(); 93 paramClass.const_(param); 94 paramClass.ptr(¶m); 95 paramClass.ref(param); 96 paramClass.constRef(param); 97 98 tmplClassForNonParam<NonParam> nonParamClass; //expected-note 3 {{The bad argument was passed to 'tmplClassForNonParam' here}} 99 NonParam nonParam; 100 nonParamClass.raw(nonParam); 101 nonParamClass.rawDefault(); 102 nonParamClass.const_(nonParam); 103 nonParamClass.ptr(&nonParam); 104 nonParamClass.ref(nonParam); 105 nonParamClass.constRef(nonParam); 106 107 tmplClassForHasNonParamStruct<HasNonParamStruct> hasNonParamStructClass;//expected-note 3 {{The bad argument was passed to 'tmplClassForHasNonParamStruct' here}} 108 HasNonParamStruct hasNonParamStruct; 109 hasNonParamStructClass.raw(hasNonParamStruct); 110 hasNonParamStructClass.rawDefault(); 111 hasNonParamStructClass.const_(hasNonParamStruct); 112 hasNonParamStructClass.ptr(&hasNonParamStruct); 113 hasNonParamStructClass.ref(hasNonParamStruct); 114 hasNonParamStructClass.constRef(hasNonParamStruct); 115 } 116 117 template <typename T> 118 class NestedTemplateInner 119 { 120 public: 121 void raw(T x) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 122 }; 123 124 template <typename T> 125 class nestedTemplateOuter 126 { 127 public: 128 void constRef(const T& x) { 129 NestedTemplateInner<T> inner; //expected-note {{The bad argument was passed to 'NestedTemplateInner' here}} 130 inner.raw(x); 131 } 132 }; 133 134 void testNestedTemplateClass() 135 { 136 nestedTemplateOuter<NonParam> outer; 137 NonParam nonParam; 138 outer.constRef(nonParam); // FIXME: this line needs note "The bad argument was passed to 'constRef' here" 139 } 140 141 template <typename T> 142 void tmplFuncForParam(T x) {} 143 template <typename T> 144 void tmplFuncForNonParam(T x) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 145 template <typename T> 146 void tmplFuncForNonParamImplicit(T x) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 147 template <typename T> 148 void tmplFuncForHasNonParamStruct(T x) {} //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 149 template <typename T> 150 void tmplFuncForHasNonParamStructImplicit(T x) {} //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 151 152 void testTemplateFunc() 153 { 154 Param param; 155 tmplFuncForParam<Param>(param); 156 157 NonParam nonParam; 158 tmplFuncForNonParam<NonParam>(nonParam); // FIXME: this line needs note "The bad argument was passed to 'tmplFuncForNonParam' here" 159 tmplFuncForNonParamImplicit(nonParam); // FIXME: this line needs note "The bad argument was passed to 'tmplFuncForNonParamImplicit' here" 160 161 HasNonParamStruct hasNonParamStruct; 162 tmplFuncForHasNonParamStruct<HasNonParamStruct>(hasNonParamStruct); // FIXME: this line needs note "The bad argument was passed to 'tmplFuncForHasNonParamStruct' here" 163 tmplFuncForHasNonParamStructImplicit(hasNonParamStruct); // FIXME: this line needs note "The bad argument was passed to 'tmplFuncForHasNonParamStructImplicit' here" 164 } 165 166 void testLambda() 167 { 168 auto paramLambda = [](Param x) -> void {}; 169 auto nonParamLambda = [](NonParam x) -> void {}; //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 170 auto nonParamStructLambda = [](HasNonParamStruct x) -> void {}; //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 171 auto nonParamUnionLambda = [](HasNonParamUnion x) -> void {}; //expected-error {{Type 'HasNonParamUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 172 auto nonParamStructUnionLambda = [](HasNonParamStructUnion x) -> void {}; //expected-error {{Type 'HasNonParamStructUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 173 174 (void)[](Param x) -> void {}; 175 (void)[](NonParam x) -> void {}; //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 176 (void)[](HasNonParamStruct x) -> void {}; //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 177 (void)[](HasNonParamUnion x) -> void {}; //expected-error {{Type 'HasNonParamUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 178 (void)[](HasNonParamStructUnion x) -> void {}; //expected-error {{Type 'HasNonParamStructUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 179 } 180 181 struct alignas(16) AlignasStruct { char a; ~AlignasStruct(); }; // expected-note {{'AlignasStruct' is a non-param type because it has an explicit alignment of '16'}} 182 void takesAlignasStruct(AlignasStruct x) { } // expected-error {{Type 'AlignasStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 183 void takesAlignasStructByRef(const AlignasStruct& x) { } 184 185 struct AlignasMember { alignas(16) char a; ~AlignasMember(); }; // expected-note {{'AlignasMember' is a non-param type because member 'a' has an explicit alignment of '16'}} 186 void takesAlignasMember(AlignasMember x) { } // expected-error {{Type 'AlignasMember' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}} 187 void takesAlignasMemberByRef(const AlignasMember& x) { }