blob: 77f64bf7397174b2c42f4fa0d4f1cbcc2d2d2f2b [file] [log] [blame]
// Part of the Crubit project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#include "nullability_verification/pointer_nullability_analysis.h"
#include <string>
#include "third_party/llvm/llvm-project/clang/unittests/Analysis/FlowSensitive/TestingSupport.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Error.h"
#include "llvm/Testing/Support/Error.h"
#include "third_party/llvm/llvm-project/llvm/utils/unittest/googletest/include/gtest/gtest.h"
namespace clang {
namespace tidy {
namespace nullability {
namespace {
using ::testing::Pair;
using ::testing::Test;
using ::testing::UnorderedElementsAre;
using dataflow::DataflowAnalysisState;
using dataflow::Environment;
using dataflow::test::checkDataflow;
MATCHER(IsSafe, "") { return arg.Lattice.isSafe(); }
MATCHER(IsUnsafe, "") { return !arg.Lattice.isSafe(); }
class PointerNullabilityTest : public Test {
protected:
template <typename Matcher>
void expectDataflow(llvm::StringRef Code, Matcher Expectations) {
ASSERT_THAT_ERROR(
checkDataflow<PointerNullabilityAnalysis>(
Code, "target",
[](ASTContext &ASTCtx, Environment &) {
return PointerNullabilityAnalysis(ASTCtx);
},
[&Expectations](
llvm::ArrayRef<
std::pair<std::string,
DataflowAnalysisState<PointerNullabilityLattice>>>
Results,
ASTContext &) { EXPECT_THAT(Results, Expectations); },
{"-fsyntax-only", "-std=c++17", "-Wno-unused-value"}),
llvm::Succeeded());
}
};
TEST_F(PointerNullabilityTest, NoPointerOperations) {
std::string Code = R"(
void target() {
1 + 2;
/*[[safe]]*/
}
)";
expectDataflow(Code, UnorderedElementsAre(Pair("safe", IsSafe())));
}
TEST_F(PointerNullabilityTest, DereferenceWithoutACheck) {
std::string Code = R"(
void target(int* maybeNull) {
*maybeNull;
/*[[unsafe]]*/
}
)";
expectDataflow(Code, UnorderedElementsAre(Pair("unsafe", IsUnsafe())));
}
TEST_F(PointerNullabilityTest, InitializedWithNullPtrLiteral) {
std::string NullPtr = R"(
void target() {
int *null = nullptr;
*null;
/*[[unsafe]]*/
}
)";
expectDataflow(NullPtr, UnorderedElementsAre(Pair("unsafe", IsUnsafe())));
std::string ZeroAsNull = R"(
void target() {
int *null = 0;
*null;
/*[[unsafe]]*/
}
)";
expectDataflow(ZeroAsNull, UnorderedElementsAre(Pair("unsafe", IsUnsafe())));
}
TEST_F(PointerNullabilityTest, InitializedWithAddressOf) {
std::string Code = R"(
void target(int x) {
int *nonNull = &x;
*nonNull;
/*[[safe]]*/
}
)";
expectDataflow(Code, UnorderedElementsAre(Pair("safe", IsSafe())));
}
TEST_F(PointerNullabilityTest, InitializedWithOtherPointer) {
std::string DerefCopyOfNonNull = R"(
void target(int x) {
int *nonNull = &x;
int *nonNullCopy = nonNull;
*nonNullCopy;
/*[[safe]]*/
}
)";
expectDataflow(DerefCopyOfNonNull,
UnorderedElementsAre(Pair("safe", IsSafe())));
std::string DerefCopyOfNullable = R"(
void target(int* nullable) {
int *nullableCopy = nullable;
*nullableCopy;
/*[[unsafe]]*/
}
)";
expectDataflow(DerefCopyOfNullable,
UnorderedElementsAre(Pair("unsafe", IsUnsafe())));
std::string DerefCopyOfNullableCheckOriginal = R"(
void target(int* nullable) {
int *nullableCopy = nullable;
if (nullable) {
*nullableCopy;
/*[[safe]]*/
} else {
*nullableCopy;
/*[[unsafe-1]]*/
}
*nullableCopy;
/*[[unsafe-2]]*/
}
)";
expectDataflow(
DerefCopyOfNullableCheckOriginal,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
std::string DerefNullableCheckCopy = R"(
void target(int* nullable) {
int *nullableCopy = nullable;
if (nullableCopy) {
*nullable;
/*[[safe]]*/
} else {
*nullable;
/*[[unsafe-1]]*/
}
*nullable;
/*[[unsafe-2]]*/
}
)";
expectDataflow(
DerefNullableCheckCopy,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
}
TEST_F(PointerNullabilityTest, CheckByComparisonToNullPtr) {
std::string NENullRight = R"(
void target(int *maybeNull) {
if (maybeNull != nullptr) {
*maybeNull;
/*[[safe]]*/
} else {
*maybeNull;
/*[[unsafe-1]]*/
}
*maybeNull;
/*[[unsafe-2]]*/
}
)";
expectDataflow(
NENullRight,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
std::string NENullLeft = R"(
void target(int *maybeNull) {
if (nullptr != maybeNull) {
*maybeNull;
/*[[safe]]*/
} else {
*maybeNull;
/*[[unsafe-1]]*/
}
*maybeNull;
/*[[unsafe-2]]*/
}
)";
expectDataflow(
NENullLeft,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
std::string EQNullRight = R"(
void target(int* maybeNull) {
if (maybeNull == nullptr) {
*maybeNull;
/*[[unsafe-1]]*/
} else {
*maybeNull;
/*[[safe]]*/
}
*maybeNull;
/*[[unsafe-2]]*/
}
)";
expectDataflow(
EQNullRight,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
std::string EQNullLeft = R"(
void target(int* maybeNull) {
if (nullptr == maybeNull) {
*maybeNull;
/*[[unsafe-1]]*/
} else {
*maybeNull;
/*[[safe]]*/
}
*maybeNull;
/*[[unsafe-2]]*/
}
)";
expectDataflow(
EQNullLeft,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
}
TEST_F(PointerNullabilityTest, CheckByImplicitCastToBool) {
std::string PointerAsBool = R"(
void target(int* maybeNull) {
if (maybeNull) {
*maybeNull;
/*[[safe]]*/
} else {
*maybeNull;
/*[[unsafe-1]]*/
}
*maybeNull;
/*[[unsafe-2]]*/
}
)";
expectDataflow(
PointerAsBool,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
std::string PointerAsBoolNegated = R"(
void target(int* maybeNull) {
if (!maybeNull) {
*maybeNull;
/*[[unsafe-1]]*/
} else {
*maybeNull;
/*[[safe]]*/
}
*maybeNull;
/*[[unsafe-2]]*/
}
)";
expectDataflow(
PointerAsBoolNegated,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
}
TEST_F(PointerNullabilityTest, CheckByComparisonToOtherNullPtr) {
std::string NEOtherNullPtr = R"(
void target(int* maybeNull) {
int *null = nullptr;
if (maybeNull != null) {
*maybeNull;
/*[[safe]]*/
} else {
*maybeNull;
/*[[unsafe-1]]*/
}
*maybeNull;
/*[[unsafe-2]]*/
}
)";
expectDataflow(
NEOtherNullPtr,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
std::string EQOtherNullPtr = R"(
void target(int* maybeNull) {
int *null = nullptr;
if (maybeNull == null) {
*maybeNull;
/*[[unsafe-1]]*/
} else {
*maybeNull;
/*[[safe]]*/
}
*maybeNull;
/*[[unsafe-2]]*/
}
)";
expectDataflow(
EQOtherNullPtr,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
}
TEST_F(PointerNullabilityTest, CheckByComparisonToOtherNonNullPtr) {
std::string NEOtherNonNullPtr = R"(
void target(int* maybeNull, int x) {
int* nonNull = &x;
if (maybeNull != nonNull) {
*maybeNull;
/*[[unsafe-1]]*/
} else {
*maybeNull;
/*[[safe]]*/
}
*maybeNull;
/*[[unsafe-2]]*/
}
)";
expectDataflow(NEOtherNonNullPtr,
UnorderedElementsAre(Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe()),
Pair("safe", IsSafe())));
std::string EQOtherNonNullPtr = R"(
void target(int* maybeNull, int x) {
int* nonNull = &x;
if (maybeNull == nonNull) {
*maybeNull;
/*[[safe]]*/
} else {
*maybeNull;
/*[[unsafe-1]]*/
}
*maybeNull;
/*[[unsafe-2]]*/
}
)";
expectDataflow(
EQOtherNonNullPtr,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
}
TEST_F(PointerNullabilityTest, CheckByComparisonToOtherUnknownPtr) {
std::string NEOtherUnknownPtr = R"(
void target(int* x, int* y) {
if (x != y) {
*x;
/*[[unsafe-1]]*/
} else {
*x;
/*[[unsafe-2]]*/
}
*x;
/*[[unsafe-3]]*/
}
)";
expectDataflow(NEOtherUnknownPtr,
UnorderedElementsAre(Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe()),
Pair("unsafe-3", IsUnsafe())));
std::string EQOtherUnknownPtr = R"(
void target(int* x, int* y) {
if (x == y) {
*x;
/*[[unsafe-1]]*/
} else {
*x;
/*[[unsafe-2]]*/
}
*x;
/*[[unsafe-3]]*/
}
)";
expectDataflow(EQOtherUnknownPtr,
UnorderedElementsAre(Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe()),
Pair("unsafe-3", IsUnsafe())));
}
TEST_F(PointerNullabilityTest, BinaryExpressions) {
std::string And = R"(
void target(int* x, int* y) {
if (x && y) {
*x;
/*[[safe]]*/
} else {
*x;
/*[[unsafe-1]]*/
}
*x;
/*[[unsafe-2]]*/
}
)";
expectDataflow(And, UnorderedElementsAre(Pair("safe", IsSafe()),
Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
std::string Or = R"(
void target(int* x, int* y) {
if (x || y) {
*x;
/*[[unsafe-1]]*/
} else {
*x;
/*[[unsafe-2]]*/
}
*x;
/*[[unsafe-3]]*/
}
)";
expectDataflow(Or, UnorderedElementsAre(Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe()),
Pair("unsafe-3", IsUnsafe())));
std::string AndNegatedBoth = R"(
void target(int* x, int* y) {
if (!x && !y) {
*x;
/*[[unsafe-1]]*/
} else {
*x;
/*[[unsafe-2]]*/
}
*x;
/*[[unsafe-3]]*/
}
)";
expectDataflow(AndNegatedBoth,
UnorderedElementsAre(Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe()),
Pair("unsafe-3", IsUnsafe())));
std::string OrNegatedBoth = R"(
void target(int* x, int* y) {
if (!x || !y) {
*x;
/*[[unsafe-1]]*/
} else {
*x;
/*[[safe]]*/
}
*x;
/*[[unsafe-2]]*/
}
)";
expectDataflow(
OrNegatedBoth,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
}
TEST_F(PointerNullabilityTest, MemberPointers) {
std::string DerefStructMember = R"(
struct Foo {
Foo* ptr;
};
void target(Foo foo) {
if (foo.ptr) {
*foo.ptr;
/*[[safe]]*/
} else {
*foo.ptr;
/*[[unsafe-1]]*/
}
*foo.ptr;
/*[[unsafe-2]]*/
}
)";
expectDataflow(
DerefStructMember,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
std::string DerefStructMemberInsideMemberFunction = R"(
struct Foo {
Foo* ptr;
void target() {
if (ptr) {
*ptr;
/*[[safe]]*/
} else {
*ptr;
/*[[unsafe-1]]*/
}
*ptr;
/*[[unsafe-2]]*/
}
};
)";
expectDataflow(
DerefStructMemberInsideMemberFunction,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
std::string DerefClassMember = R"(
class Foo {
public:
Foo* ptr;
};
void target(Foo foo) {
if (foo.ptr) {
*foo.ptr;
/*[[safe]]*/
} else {
*foo.ptr;
/*[[unsafe-1]]*/
}
*foo.ptr;
/*[[unsafe-2]]*/
}
)";
expectDataflow(
DerefClassMember,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
}
TEST_F(PointerNullabilityTest, MemberAccessOnPointer) {
std::string MemberAccess = R"(
struct Foo {
void foo();
};
void target(Foo* foo) {
if (foo) {
foo->foo();
/*[[safe]]*/
} else {
foo->foo();
/*[[unsafe-1]]*/
}
foo->foo();
/*[[unsafe-2]]*/
}
)";
expectDataflow(
MemberAccess,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
std::string MemberAccessOnImplicitThis = R"(
struct Foo {
void foo();
void target() {
foo();
/*[[safe]]*/
}
};
)";
expectDataflow(MemberAccessOnImplicitThis,
UnorderedElementsAre(Pair("safe", IsSafe())));
std::string MemberAccessOnExplicitThis = R"(
struct Foo {
void foo();
void target() {
this->foo();
/*[[safe]]*/
}
};
)";
expectDataflow(MemberAccessOnExplicitThis,
UnorderedElementsAre(Pair("safe", IsSafe())));
std::string MemberAccessOnCopyOfThis = R"(
struct Foo {
void foo();
void target() {
Foo *thisCopy = this;
thisCopy->foo();
/*[[safe]]*/
}
};
)";
expectDataflow(MemberAccessOnCopyOfThis,
UnorderedElementsAre(Pair("safe", IsSafe())));
std::string AccessChainOnlyCheckOnFirst = R"(
struct Foo {
Foo* foo;
};
void target(Foo* foo) {
if (foo) {
foo->foo->foo;
/*[[unsafe-1]]*/
} else {
foo->foo->foo;
/*[[unsafe-2]]*/
}
foo->foo->foo;
/*[[unsafe-3]]*/
}
)";
expectDataflow(AccessChainOnlyCheckOnFirst,
UnorderedElementsAre(Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe()),
Pair("unsafe-3", IsUnsafe())));
std::string AccessChainCheckOnAll = R"(
struct Foo {
Foo* foo;
};
void target(Foo* foo) {
if (foo && foo->foo) {
foo->foo->foo;
/*[[safe]]*/
} else {
foo->foo;
/*[[unsafe-1]]*/
}
foo->foo;
/*[[unsafe-2]]*/
}
)";
expectDataflow(
AccessChainCheckOnAll,
UnorderedElementsAre(Pair("safe", IsSafe()), Pair("unsafe-1", IsUnsafe()),
Pair("unsafe-2", IsUnsafe())));
}
} // namespace
} // namespace nullability
} // namespace tidy
} // namespace clang