This is an archive of the discontinued LLVM Phabricator instance.

Differential D156229

[clang][dataflow] Remove checks that test for consistency between `StructValue` and `AggregateStorageLocation`.
AbandonedPublic

Authored by mboehme on Jul 25 2023, 4:57 AM.

Details

Reviewers
xazax.hun
Summary

Now that the redundancy between these two classes has been eliminated, these
checks aren't needed any more.

Diff Detail

Event Timeline

mboehme created this revision.Jul 25 2023, 4:57 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 25 2023, 4:57 AM
Herald added subscribers: martong, xazax.hun. · View Herald Transcript
mboehme requested review of this revision.Jul 25 2023, 4:57 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 25 2023, 4:57 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
mboehme added a child revision: D156230: [clang][dataflow][NFC] Eliminate variable only used in assertion..Jul 25 2023, 4:57 AM
Harbormaster completed remote builds in B247957: Diff 543925.Jul 25 2023, 4:57 AM
mboehme removed a child revision: D156230: [clang][dataflow][NFC] Eliminate variable only used in assertion..Jul 25 2023, 4:58 AM
mboehme added a child revision: D156230: [clang][dataflow][NFC] Eliminate variable only used in assertion..Jul 25 2023, 5:00 AM
xazax.hun accepted this revision.Jul 25 2023, 8:28 AM
This revision is now accepted and ready to land.Jul 25 2023, 8:28 AM
mboehme abandoned this revision.Jul 26 2023, 5:18 AM

This is a duplicate of https://reviews.llvm.org/D155813 that I uploaded for some reason. Sorry for the noise.

Revision Contents

PathSize
clang/
unittests/
Analysis/
FlowSensitive/
84 lines

Diff 543925

clang/unittests/Analysis/FlowSensitive/TransferTest.cpp

Show All 21 Lines
#include "llvm/Support/Casting.h" #include "llvm/Support/Casting.h"
#include "llvm/Testing/Support/Error.h" #include "llvm/Testing/Support/Error.h"
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <optional> #include <optional>
#include <string> #include <string>
#include <utility> #include <utility>
// FIXME: There are still remaining checks here that check for consistency
// between `StructValue` and `AggregateStorageLocation`. Now that the redundancy
// between these two classes has been eliminated, these checks aren't needed any
// more, so remove them.
namespace { namespace {
using namespace clang; using namespace clang;
using namespace dataflow; using namespace dataflow;
using namespace test; using namespace test;
using ::testing::Eq; using ::testing::Eq;
using ::testing::IsNull; using ::testing::IsNull;
using ::testing::Ne; using ::testing::Ne;
▲ Show 20 Lines • Show All 220 Lines • ▼ Show 20 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *BarLoc = EXPECT_TRUE(isa<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env)));
cast<ScalarStorageLocation>(FooLoc->getChild(*BarDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env));
EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
}); });
} }
TEST(TransferTest, StructVarDeclWithInit) { TEST(TransferTest, StructVarDeclWithInit) {
std::string Code = R"( std::string Code = R"(
struct A { struct A {
int Bar; int Bar;
}; };
Show All 26 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *BarLoc = EXPECT_TRUE(isa<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env)));
cast<ScalarStorageLocation>(FooLoc->getChild(*BarDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env));
EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
}); });
} }
TEST(TransferTest, ClassVarDecl) { TEST(TransferTest, ClassVarDecl) {
std::string Code = R"( std::string Code = R"(
class A { class A {
public: public:
int Bar; int Bar;
Show All 25 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *BarLoc = EXPECT_TRUE(isa<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env)));
cast<ScalarStorageLocation>(FooLoc->getChild(*BarDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env));
EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
}); });
} }
TEST(TransferTest, ReferenceVarDecl) { TEST(TransferTest, ReferenceVarDecl) {
std::string Code = R"( std::string Code = R"(
struct A {}; struct A {};
A &getA(); A &getA();
▲ Show 20 Lines • Show All 658 Lines • ▼ Show 20 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *BarLoc = EXPECT_TRUE(isa<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env)));
cast<ScalarStorageLocation>(FooLoc->getChild(*BarDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env));
EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
}); });
} }
TEST(TransferTest, ReferenceParamDecl) { TEST(TransferTest, ReferenceParamDecl) {
std::string Code = R"( std::string Code = R"(
struct A {}; struct A {};
void target(A &Foo) { void target(A &Foo) {
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal = const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env)); cast<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env));
const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
EXPECT_EQ(Env.getValue(*BazDecl), BarVal); EXPECT_EQ(Env.getValue(*BazDecl), BarVal);
}); });
} }
▲ Show 20 Lines • Show All 223 Lines • ▼ Show 20 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal = const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env)); cast<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env));
const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
EXPECT_EQ(Env.getValue(*BazDecl), BarVal); EXPECT_EQ(Env.getValue(*BazDecl), BarVal);
}); });
} }
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
const auto *QuxLoc = const auto *QuxLoc =
cast<AggregateStorageLocation>(ThisLoc->getChild(*QuxDecl)); cast<AggregateStorageLocation>(ThisLoc->getChild(*QuxDecl));
const auto *QuxVal = dyn_cast<StructValue>(Env.getValue(*QuxLoc)); EXPECT_THAT(dyn_cast<StructValue>(Env.getValue(*QuxLoc)), NotNull());
ASSERT_THAT(QuxVal, NotNull());
const auto *BazLoc =
cast<ScalarStorageLocation>(QuxLoc->getChild(*BazDecl));
const auto *BazVal = const auto *BazVal =
cast<IntegerValue>(getFieldValue(QuxVal, *BazDecl, Env)); cast<IntegerValue>(getFieldValue(QuxLoc, *BazDecl, Env));
EXPECT_EQ(Env.getValue(*BazLoc), BazVal);
const ValueDecl *QuuxDecl = findValueDecl(ASTCtx, "Quux"); const ValueDecl *QuuxDecl = findValueDecl(ASTCtx, "Quux");
ASSERT_THAT(QuuxDecl, NotNull()); ASSERT_THAT(QuuxDecl, NotNull());
EXPECT_EQ(Env.getValue(*QuuxDecl), BazVal); EXPECT_EQ(Env.getValue(*QuuxDecl), BazVal);
}); });
} }
TEST(TransferTest, ClassThisMember) { TEST(TransferTest, ClassThisMember) {
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines runDataflow(
} else { } else {
FAIL() << "Unexpected field: " << Field->getNameAsString(); FAIL() << "Unexpected field: " << Field->getNameAsString();
} }
} }
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
const auto *QuxLoc = const auto *QuxLoc =
cast<AggregateStorageLocation>(ThisLoc->getChild(*QuxDecl)); cast<AggregateStorageLocation>(ThisLoc->getChild(*QuxDecl));
const auto *QuxVal = dyn_cast<StructValue>(Env.getValue(*QuxLoc)); EXPECT_THAT(dyn_cast<StructValue>(Env.getValue(*QuxLoc)), NotNull());
ASSERT_THAT(QuxVal, NotNull());
const auto *BazLoc =
cast<ScalarStorageLocation>(QuxLoc->getChild(*BazDecl));
const auto *BazVal = const auto *BazVal =
cast<IntegerValue>(getFieldValue(QuxVal, *BazDecl, Env)); cast<IntegerValue>(getFieldValue(QuxLoc, *BazDecl, Env));
EXPECT_EQ(Env.getValue(*BazLoc), BazVal);
const ValueDecl *QuuxDecl = findValueDecl(ASTCtx, "Quux"); const ValueDecl *QuuxDecl = findValueDecl(ASTCtx, "Quux");
ASSERT_THAT(QuuxDecl, NotNull()); ASSERT_THAT(QuuxDecl, NotNull());
EXPECT_EQ(Env.getValue(*QuuxDecl), BazVal); EXPECT_EQ(Env.getValue(*QuuxDecl), BazVal);
}); });
} }
TEST(TransferTest, UnionThisMember) { TEST(TransferTest, UnionThisMember) {
▲ Show 20 Lines • Show All 263 Lines • ▼ Show 20 Lines runDataflow(
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *BarLoc = EXPECT_TRUE(isa<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env)));
cast<ScalarStorageLocation>(FooLoc->getChild(*BarDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env));
EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
}); });
} }
TEST(TransferTest, ElidableConstructor) { TEST(TransferTest, ElidableConstructor) {
// This test is effectively the same as TransferTest.TemporaryObject, but // This test is effectively the same as TransferTest.TemporaryObject, but
// the code is compiled as C++ 14. // the code is compiled as C++ 14.
std::string Code = R"( std::string Code = R"(
struct A { struct A {
Show All 16 Lines runDataflow(
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *FooLoc = const auto *FooLoc =
cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl)); cast<AggregateStorageLocation>(Env.getStorageLocation(*FooDecl));
const auto *BarLoc = EXPECT_TRUE(isa<IntegerValue>(getFieldValue(FooLoc, *BarDecl, Env)));
cast<ScalarStorageLocation>(FooLoc->getChild(*BarDecl));
const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
const auto *BarVal =
cast<IntegerValue>(getFieldValue(FooVal, *BarDecl, Env));
EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
}, },
LangStandard::lang_cxx14); LangStandard::lang_cxx14);
} }
TEST(TransferTest, AssignmentOperator) { TEST(TransferTest, AssignmentOperator) {
std::string Code = R"( std::string Code = R"(
struct A { struct A {
int Baz; int Baz;
▲ Show 20 Lines • Show All 996 Lines • ▼ Show 20 Lines runDataflow(
} }
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const auto *BazLoc = dyn_cast_or_null<AggregateStorageLocation>( const auto *BazLoc = dyn_cast_or_null<AggregateStorageLocation>(
Env.getStorageLocation(*BazDecl)); Env.getStorageLocation(*BazDecl));
ASSERT_THAT(BazLoc, NotNull()); ASSERT_THAT(BazLoc, NotNull());
ASSERT_THAT(Env.getValue(*BazLoc), NotNull()); ASSERT_THAT(Env.getValue(*BazLoc), NotNull());
const auto *BazVal = cast<StructValue>(Env.getValue(*BazLoc)); const auto *FooVal =
const auto *FooValFromBazVal =
cast<IntegerValue>(getFieldValue(BazVal, *FooDecl, Env));
const auto *FooValFromBazLoc =
cast<IntegerValue>(getFieldValue(BazLoc, *FooDecl, Env)); cast<IntegerValue>(getFieldValue(BazLoc, *FooDecl, Env));
EXPECT_EQ(FooValFromBazLoc, FooValFromBazVal);
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *BarLoc = Env.getStorageLocation(*BarDecl); const auto *BarLoc = Env.getStorageLocation(*BarDecl);
ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(BarLoc)); ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(BarLoc));
EXPECT_EQ(Env.getValue(*BarLoc), FooValFromBazVal); EXPECT_EQ(Env.getValue(*BarLoc), FooVal);
EXPECT_EQ(Env.getValue(*BarLoc), FooValFromBazLoc);
}); });
} }
TEST(TransferTest, AssignFromBoolLiteral) { TEST(TransferTest, AssignFromBoolLiteral) {
std::string Code = R"( std::string Code = R"(
void target() { void target() {
bool Foo = true; bool Foo = true;
bool Bar = false; bool Bar = false;
▲ Show 20 Lines • Show All 2,655 Lines • Show Last 20 Lines