tor-browser

TestMustReturnFromCaller.cpp (5573B)

---

#include <cstddef>
#include <utility>

#define MOZ_MUST_RETURN_FROM_CALLER_IF_THIS_IS_ARG __attribute__((annotate("moz_must_return_from_caller_if_this_is_arg")))
#define MOZ_MAY_CALL_AFTER_MUST_RETURN __attribute__((annotate("moz_may_call_after_must_return")))

struct Thrower {
 void MOZ_MUST_RETURN_FROM_CALLER_IF_THIS_IS_ARG Throw() {}
};

void DoAnythingElse();
int MakeAnInt();
int MOZ_MAY_CALL_AFTER_MUST_RETURN SafeMakeInt();
bool Condition();

// It might be nicer to #include "mozilla/ScopeExit.h" and use that here -- but
// doing so also will #define the two attribute-macros defined above, running a
// risk of redefinition errors.  Just stick to the normal clang-plugin test
// style and use as little external code as possible.

template<typename Func>
class ScopeExit {
 Func exitFunction;
 bool callOnDestruction;
public:
 explicit ScopeExit(Func&& func)
   : exitFunction(std::move(func))
   , callOnDestruction(true)
 {}

 ~ScopeExit() {
   if (callOnDestruction) {
     exitFunction();
   }
 }

 void release() { callOnDestruction = false; }
};

template<typename ExitFunction>
ScopeExit<ExitFunction>
MakeScopeExit(ExitFunction&& func)
{
 return ScopeExit<ExitFunction>(std::move(func));
}

class Foo {
public:
 __attribute__((annotate("moz_implicit"))) Foo(std::nullptr_t);
 Foo();
};

void a1(Thrower& thrower) {
 thrower.Throw();
}

int a2(Thrower& thrower) {
 thrower.Throw(); // expected-error {{You must immediately return after calling this function}}
 return MakeAnInt();
}

int a3(Thrower& thrower) {
 // RAII operations happening after a must-immediately-return are fine.
 auto atExit = MakeScopeExit([] { DoAnythingElse(); });
 thrower.Throw();
 return 5;
}

int a4(Thrower& thrower) {
 thrower.Throw(); // expected-error {{You must immediately return after calling this function}}
 return Condition() ? MakeAnInt() : MakeAnInt();
}

void a5(Thrower& thrower) {
 thrower.Throw(); // expected-error {{You must immediately return after calling this function}}
 DoAnythingElse();
}

int a6(Thrower& thrower) {
 thrower.Throw(); // expected-error {{You must immediately return after calling this function}}
 DoAnythingElse();
 return MakeAnInt();
}

int a7(Thrower& thrower) {
 thrower.Throw(); // expected-error {{You must immediately return after calling this function}}
 DoAnythingElse();
 return Condition() ? MakeAnInt() : MakeAnInt();
}

int a8(Thrower& thrower) {
 thrower.Throw();
 return SafeMakeInt();
}

int a9(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw();
 }
 return SafeMakeInt();
}

int a10(Thrower& thrower) {
 auto atExit = MakeScopeExit([] { DoAnythingElse(); });

 if (Condition()) {
   thrower.Throw();
   return SafeMakeInt();
 }

 atExit.release();
 DoAnythingElse();
 return 5;
}

void b1(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw();
 }
}

int b2(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw(); // expected-error {{You must immediately return after calling this function}}
 }
 return MakeAnInt();
}

int b3(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw();
 }
 return 5;
}

// Explicit test in orer to also verify the `UnaryOperator` node in the `CFG`
int b3a(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw();
 }
 return -1;
}

float b3b(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw();
 }
 return 1.0f;
}

bool b3c(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw();
 }
 return false;
}

int b4(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw(); // expected-error {{You must immediately return after calling this function}}
 }
 return Condition() ? MakeAnInt() : MakeAnInt();
}

void b5(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw(); // expected-error {{You must immediately return after calling this function}}
 }
 DoAnythingElse();
}

void b6(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw(); // expected-error {{You must immediately return after calling this function}}
   DoAnythingElse();
 }
}

void b7(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw();
   return;
 }
 DoAnythingElse();
}

void b8(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw(); // expected-error {{You must immediately return after calling this function}}
   DoAnythingElse();
   return;
 }
 DoAnythingElse();
}

void b9(Thrower& thrower) {
 while (Condition()) {
   thrower.Throw(); // expected-error {{You must immediately return after calling this function}}
 }
}

void b10(Thrower& thrower) {
 while (Condition()) {
   thrower.Throw();
   return;
 }
}

void b11(Thrower& thrower) {
 thrower.Throw(); // expected-error {{You must immediately return after calling this function}}
 if (Condition()) {
   return;
 } else {
   return;
 }
}

void b12(Thrower& thrower) {
 switch (MakeAnInt()) {
 case 1:
   break;
 default:
   thrower.Throw();
   return;
 }
}

void b13(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw();
 }
 return;
}

Foo b14(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw();
   return nullptr;
 }
 return nullptr;
}

Foo b15(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw();
 }
 return nullptr;
}

Foo b16(Thrower& thrower) {
 if (Condition()) {
   thrower.Throw();
 }
 return Foo();
}

void c1() {
 Thrower thrower;
 thrower.Throw();
 DoAnythingElse(); // Should be allowed, since our thrower is not an arg
}

class TestRet {
 TestRet *b13(Thrower &thrower) {
   if (Condition()) {
     thrower.Throw();
   }
   return this;
 }
};