This is an archive of the discontinued LLVM Phabricator instance.

Differential D133865

[clang][dataflow] Replace usage of the deprecated overload of `checkDataflow`.
ClosedPublic

Authored by wyt on Sep 14 2022, 8:18 AM.

Details

Reviewers
gribozavr2
hlopko
sgatev
ymandel
Commits
rG9cbdef610339: [clang][dataflow] Replace usage of the deprecated overload of `checkDataflow`.
Summary

Updated files:

  • ChromiumCheckModelTest.cpp.
  • MatchSwitchTest.cpp.
  • MultiVarConstantPropagationTest.cpp.
  • SingleVarConstantPropagationTest.cpp.
  • TestingSupportTest.cpp.
  • TransferTest.cpp.

Diff Detail

Event Timeline

wyt created this revision.Sep 14 2022, 8:18 AM
Herald added a project: Restricted Project. · View Herald TranscriptSep 14 2022, 8:18 AM
Herald added subscribers: martong, xazax.hun. · View Herald Transcript
wyt requested review of this revision.Sep 14 2022, 8:18 AM
Herald added a project: Restricted Project. · View Herald TranscriptSep 14 2022, 8:18 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
wyt added reviewers: gribozavr2, hlopko, sgatev, ymandel.Sep 14 2022, 8:19 AM
Harbormaster completed remote builds in B186633: Diff 460102.Sep 14 2022, 8:51 AM
gribozavr2 accepted this revision.Sep 14 2022, 10:40 AM
This revision is now accepted and ready to land.Sep 14 2022, 10:40 AM
sgatev accepted this revision.Sep 15 2022, 12:29 AM
sgatev added inline comments.
clang/unittests/Analysis/FlowSensitive/TestingSupportTest.cpp
83–88

Do we need .withASTBuildArgs({"-fsyntax-only", "-std=c++17"}) here?

wyt updated this revision to Diff 460349.Sep 15 2022, 3:22 AM

Address comment.

wyt marked an inline comment as done.Sep 15 2022, 3:22 AM
Harbormaster completed remote builds in B186818: Diff 460349.Sep 15 2022, 4:14 AM
Closed by commit rG9cbdef610339: [clang][dataflow] Replace usage of the deprecated overload of `checkDataflow`. (authored by wyt). · Explain WhySep 16 2022, 9:20 AM
This revision was automatically updated to reflect the committed changes.
wyt added a commit: rG9cbdef610339: [clang][dataflow] Replace usage of the deprecated overload of `checkDataflow`..

Revision Contents

Diff 460796

clang/unittests/Analysis/FlowSensitive/ChromiumCheckModelTest.cpp

//===- ChromiumCheckModelTest.cpp -----------------------------------------===// //===- ChromiumCheckModelTest.cpp -----------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// FIXME: Move this to clang/unittests/Analysis/FlowSensitive/Models. // FIXME: Move this to clang/unittests/Analysis/FlowSensitive/Models.
#include "clang/Analysis/FlowSensitive/Models/ChromiumCheckModel.h" #include "clang/Analysis/FlowSensitive/Models/ChromiumCheckModel.h"
#include "TestingSupport.h" #include "TestingSupport.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Analysis/FlowSensitive/NoopAnalysis.h" #include "clang/Analysis/FlowSensitive/NoopLattice.h"
#include "clang/Tooling/Tooling.h" #include "clang/Tooling/Tooling.h"
#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/Error.h" #include "llvm/Support/Error.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 <string> #include <string>
using namespace clang; using namespace clang;
using namespace dataflow; using namespace dataflow;
using namespace test; using namespace test;
namespace { namespace {
using ::testing::_;
using ::testing::ElementsAre;
using ::testing::NotNull; using ::testing::NotNull;
using ::testing::Pair; using ::testing::UnorderedElementsAre;
static constexpr char ChromiumCheckHeader[] = R"( static constexpr char ChromiumCheckHeader[] = R"(
namespace std { namespace std {
class ostream; class ostream;
} // namespace std } // namespace std
namespace logging { namespace logging {
class VoidifyStream { class VoidifyStream {
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Lines
}; };
template <typename Matcher> template <typename Matcher>
void runDataflow(llvm::StringRef Code, Matcher Match) { void runDataflow(llvm::StringRef Code, Matcher Match) {
const tooling::FileContentMappings FileContents = { const tooling::FileContentMappings FileContents = {
{"check.h", ChromiumCheckHeader}, {"othercheck.h", OtherCheckHeader}}; {"check.h", ChromiumCheckHeader}, {"othercheck.h", OtherCheckHeader}};
ASSERT_THAT_ERROR( ASSERT_THAT_ERROR(
test::checkDataflow<ModelAdaptorAnalysis<ChromiumCheckModel>>( checkDataflow<ModelAdaptorAnalysis<ChromiumCheckModel>>(
Code, "target", AnalysisInputs<ModelAdaptorAnalysis<ChromiumCheckModel>>(
Code, ast_matchers::hasName("target"),
[](ASTContext &C, Environment &) { [](ASTContext &C, Environment &) {
return ModelAdaptorAnalysis<ChromiumCheckModel>(C); return ModelAdaptorAnalysis<ChromiumCheckModel>(C);
}, })
[&Match]( .withASTBuildArgs({"-fsyntax-only",
llvm::ArrayRef< "-fno-delayed-template-parsing", "-std=c++17"})
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> .withASTBuildVirtualMappedFiles(std::move(FileContents)),
Results, /*VerifyResults=*/
ASTContext &ASTCtx) { Match(Results, ASTCtx); }, [&Match](const llvm::StringMap<DataflowAnalysisState<NoopLattice>>
{"-fsyntax-only", "-fno-delayed-template-parsing", "-std=c++17"}, &Results,
FileContents), const AnalysisOutputs &AO) { Match(Results, AO.ASTCtx); }),
llvm::Succeeded()); llvm::Succeeded());
} }
TEST(ChromiumCheckModelTest, CheckSuccessImpliesConditionHolds) { TEST(ChromiumCheckModelTest, CheckSuccessImpliesConditionHolds) {
auto Expectations = auto Expectations =
[](llvm::ArrayRef< [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto *FooVal = cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None)); auto *FooVal = cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(*FooVal)); EXPECT_TRUE(Env.flowConditionImplies(*FooVal));
}; };
Show All 11 LinesTEST(ChromiumCheckModelTest, CheckSuccessImpliesConditionHolds) {
runDataflow(ReplacePattern(Code, "$check", "CHECK"), Expectations); runDataflow(ReplacePattern(Code, "$check", "CHECK"), Expectations);
runDataflow(ReplacePattern(Code, "$check", "DCHECK"), Expectations); runDataflow(ReplacePattern(Code, "$check", "DCHECK"), Expectations);
runDataflow(ReplacePattern(Code, "$check", "PCHECK"), Expectations); runDataflow(ReplacePattern(Code, "$check", "PCHECK"), Expectations);
runDataflow(ReplacePattern(Code, "$check", "DPCHECK"), Expectations); runDataflow(ReplacePattern(Code, "$check", "DPCHECK"), Expectations);
} }
TEST(ChromiumCheckModelTest, UnrelatedCheckIgnored) { TEST(ChromiumCheckModelTest, UnrelatedCheckIgnored) {
auto Expectations = auto Expectations =
[](llvm::ArrayRef< [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto *FooVal = cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None)); auto *FooVal = cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_FALSE(Env.flowConditionImplies(*FooVal)); EXPECT_FALSE(Env.flowConditionImplies(*FooVal));
}; };
Show All 16 Lines

clang/unittests/Analysis/FlowSensitive/MatchSwitchTest.cpp

Show All 13 Lines
#include "clang/AST/Stmt.h" #include "clang/AST/Stmt.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Analysis/FlowSensitive/DataflowAnalysis.h" #include "clang/Analysis/FlowSensitive/DataflowAnalysis.h"
#include "clang/Analysis/FlowSensitive/DataflowEnvironment.h" #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
#include "clang/Analysis/FlowSensitive/DataflowLattice.h" #include "clang/Analysis/FlowSensitive/DataflowLattice.h"
#include "clang/Analysis/FlowSensitive/MapLattice.h" #include "clang/Analysis/FlowSensitive/MapLattice.h"
#include "clang/Tooling/Tooling.h" #include "clang/Tooling/Tooling.h"
#include "llvm/ADT/None.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Twine.h" #include "llvm/ADT/Twine.h"
#include "llvm/Support/Error.h" #include "llvm/Support/Error.h"
#include "llvm/Testing/Support/Annotations.h" #include "llvm/Testing/ADT/StringMapEntry.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 <cstdint> #include <cstdint>
#include <memory> #include <memory>
#include <ostream> #include <ostream>
#include <string> #include <string>
#include <utility> #include <utility>
using namespace clang; using namespace clang;
using namespace dataflow; using namespace dataflow;
namespace { namespace {
using ::testing::Pair; using ::llvm::IsStringMapEntry;
using ::testing::UnorderedElementsAre; using ::testing::UnorderedElementsAre;
class BooleanLattice { class BooleanLattice {
public: public:
BooleanLattice() : Value(false) {} BooleanLattice() : Value(false) {}
explicit BooleanLattice(bool B) : Value(B) {} explicit BooleanLattice(bool B) : Value(B) {}
static BooleanLattice bottom() { return BooleanLattice(false); } static BooleanLattice bottom() { return BooleanLattice(false); }
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Linespublic:
void transfer(const Stmt *S, BooleanLattice &L, Environment &Env) { void transfer(const Stmt *S, BooleanLattice &L, Environment &Env) {
TransferState<BooleanLattice> State(L, Env); TransferState<BooleanLattice> State(L, Env);
TransferSwitch(*S, getASTContext(), State); TransferSwitch(*S, getASTContext(), State);
} }
}; };
template <typename Matcher> template <typename Matcher>
void RunDataflow(llvm::StringRef Code, Matcher Expectations) { void RunDataflow(llvm::StringRef Code, Matcher Expectations) {
using namespace ast_matchers;
using namespace test;
ASSERT_THAT_ERROR( ASSERT_THAT_ERROR(
test::checkDataflow<TestAnalysis>( checkDataflow<TestAnalysis>(
Code, "fun", AnalysisInputs<TestAnalysis>(
[](ASTContext &C, Environment &) { return TestAnalysis(C); }, Code, hasName("fun"),
[](ASTContext &C, Environment &) { return TestAnalysis(C); })
.withASTBuildArgs({"-fsyntax-only", "-std=c++17"}),
/*VerifyResults=*/
[&Expectations]( [&Expectations](
llvm::ArrayRef<std::pair< const llvm::StringMap<
std::string, DataflowAnalysisState<TestAnalysis::Lattice>>> DataflowAnalysisState<TestAnalysis::Lattice>> &Results,
Results, const AnalysisOutputs &) { EXPECT_THAT(Results, Expectations); }),
ASTContext &) { EXPECT_THAT(Results, Expectations); },
{"-fsyntax-only", "-std=c++17"}),
llvm::Succeeded()); llvm::Succeeded());
} }
TEST(MatchSwitchTest, JustX) { TEST(MatchSwitchTest, JustX) {
std::string Code = R"( std::string Code = R"(
void fun() { void fun() {
int X = 1; int X = 1;
(void)X; (void)X;
// [[p]] // [[p]]
} }
)"; )";
RunDataflow(Code, RunDataflow(Code, UnorderedElementsAre(
UnorderedElementsAre(Pair("p", Holds(BooleanLattice(true))))); IsStringMapEntry("p", Holds(BooleanLattice(true)))));
} }
TEST(MatchSwitchTest, JustFoo) { TEST(MatchSwitchTest, JustFoo) {
std::string Code = R"( std::string Code = R"(
void Foo(); void Foo();
void fun() { void fun() {
Foo(); Foo();
// [[p]] // [[p]]
} }
)"; )";
RunDataflow(Code, RunDataflow(Code, UnorderedElementsAre(
UnorderedElementsAre(Pair("p", Holds(BooleanLattice(false))))); IsStringMapEntry("p", Holds(BooleanLattice(false)))));
} }
TEST(MatchSwitchTest, XThenFoo) { TEST(MatchSwitchTest, XThenFoo) {
std::string Code = R"( std::string Code = R"(
void Foo(); void Foo();
void fun() { void fun() {
int X = 1; int X = 1;
(void)X; (void)X;
Foo(); Foo();
// [[p]] // [[p]]
} }
)"; )";
RunDataflow(Code, RunDataflow(Code, UnorderedElementsAre(
UnorderedElementsAre(Pair("p", Holds(BooleanLattice(false))))); IsStringMapEntry("p", Holds(BooleanLattice(false)))));
} }
TEST(MatchSwitchTest, FooThenX) { TEST(MatchSwitchTest, FooThenX) {
std::string Code = R"( std::string Code = R"(
void Foo(); void Foo();
void fun() { void fun() {
Foo(); Foo();
int X = 1; int X = 1;
(void)X; (void)X;
// [[p]] // [[p]]
} }
)"; )";
RunDataflow(Code, RunDataflow(Code, UnorderedElementsAre(
UnorderedElementsAre(Pair("p", Holds(BooleanLattice(true))))); IsStringMapEntry("p", Holds(BooleanLattice(true)))));
} }
TEST(MatchSwitchTest, Neither) { TEST(MatchSwitchTest, Neither) {
std::string Code = R"( std::string Code = R"(
void Bar(); void Bar();
void fun(bool b) { void fun(bool b) {
Bar(); Bar();
// [[p]] // [[p]]
} }
)"; )";
RunDataflow(Code, RunDataflow(Code, UnorderedElementsAre(
UnorderedElementsAre(Pair("p", Holds(BooleanLattice(false))))); IsStringMapEntry("p", Holds(BooleanLattice(false)))));
} }
TEST(MatchSwitchTest, ReturnNonVoid) { TEST(MatchSwitchTest, ReturnNonVoid) {
using namespace ast_matchers; using namespace ast_matchers;
auto Unit = auto Unit =
tooling::buildASTFromCode("void f() { int x = 42; }", "input.cc", tooling::buildASTFromCode("void f() { int x = 42; }", "input.cc",
std::make_shared<PCHContainerOperations>()); std::make_shared<PCHContainerOperations>());
Show All 19 Lines

clang/unittests/Analysis/FlowSensitive/MultiVarConstantPropagationTest.cpp

Show All 17 Lines
#include "clang/AST/Expr.h" #include "clang/AST/Expr.h"
#include "clang/AST/Stmt.h" #include "clang/AST/Stmt.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Analysis/FlowSensitive/DataflowAnalysis.h" #include "clang/Analysis/FlowSensitive/DataflowAnalysis.h"
#include "clang/Analysis/FlowSensitive/DataflowEnvironment.h" #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
#include "clang/Analysis/FlowSensitive/DataflowLattice.h" #include "clang/Analysis/FlowSensitive/DataflowLattice.h"
#include "clang/Analysis/FlowSensitive/MapLattice.h" #include "clang/Analysis/FlowSensitive/MapLattice.h"
#include "clang/Tooling/Tooling.h"
#include "llvm/ADT/None.h" #include "llvm/ADT/None.h"
#include "llvm/ADT/Optional.h" #include "llvm/ADT/Optional.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Twine.h" #include "llvm/ADT/Twine.h"
#include "llvm/Support/Error.h" #include "llvm/Support/Error.h"
#include "llvm/Testing/Support/Annotations.h" #include "llvm/Testing/ADT/StringMapEntry.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 <cstdint> #include <cstdint>
#include <memory> #include <memory>
#include <ostream> #include <ostream>
#include <string> #include <string>
#include <utility> #include <utility>
▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 Lines if (Nodes.getNodeAs<clang::VarDecl>(kDecl) != nullptr) {
// Any assignment involving the expression itself resets the variable to // Any assignment involving the expression itself resets the variable to
// "unknown". A more advanced analysis could try to evaluate the compound // "unknown". A more advanced analysis could try to evaluate the compound
// assignment. For example, `x += 0` need not invalidate `x`. // assignment. For example, `x += 0` need not invalidate `x`.
Vars[Var] = ValueLattice::top(); Vars[Var] = ValueLattice::top();
} }
} }
}; };
using ::testing::IsEmpty; using ::clang::dataflow::test::AnalysisInputs;
using ::clang::dataflow::test::AnalysisOutputs;
using ::clang::dataflow::test::checkDataflow;
using ::llvm::IsStringMapEntry;
using ::testing::Pair; using ::testing::Pair;
using ::testing::UnorderedElementsAre; using ::testing::UnorderedElementsAre;
MATCHER_P(Var, name, MATCHER_P(Var, name,
(llvm::Twine(negation ? "isn't" : "is") + " a variable named `" + (llvm::Twine(negation ? "isn't" : "is") + " a variable named `" +
name + "`") name + "`")
.str()) { .str()) {
return arg->getName() == name; return arg->getName() == name;
Show All 9 LinesMATCHER_P(HoldsCPLattice, m,
::testing::DescribeMatcher<ConstantPropagationLattice>(m, negation)) ::testing::DescribeMatcher<ConstantPropagationLattice>(m, negation))
.str()) { .str()) {
return ExplainMatchResult(m, arg.Lattice, result_listener); return ExplainMatchResult(m, arg.Lattice, result_listener);
} }
template <typename Matcher> template <typename Matcher>
void RunDataflow(llvm::StringRef Code, Matcher Expectations) { void RunDataflow(llvm::StringRef Code, Matcher Expectations) {
ASSERT_THAT_ERROR( ASSERT_THAT_ERROR(
test::checkDataflow<ConstantPropagationAnalysis>( checkDataflow<ConstantPropagationAnalysis>(
Code, "fun", AnalysisInputs<ConstantPropagationAnalysis>(
Code, hasName("fun"),
[](ASTContext &C, Environment &) { [](ASTContext &C, Environment &) {
return ConstantPropagationAnalysis(C); return ConstantPropagationAnalysis(C);
}, })
[&Expectations]( .withASTBuildArgs({"-fsyntax-only", "-std=c++17"}),
llvm::ArrayRef<std::pair< /*VerifyResults=*/
std::string, [&Expectations](const llvm::StringMap<DataflowAnalysisState<
DataflowAnalysisState<ConstantPropagationAnalysis::Lattice>>> ConstantPropagationAnalysis::Lattice>> &Results,
Results, const AnalysisOutputs &) {
ASTContext &) { EXPECT_THAT(Results, Expectations); }, EXPECT_THAT(Results, Expectations);
{"-fsyntax-only", "-std=c++17"}), }),
llvm::Succeeded()); llvm::Succeeded());
} }
TEST(MultiVarConstantPropagationTest, JustInit) { TEST(MultiVarConstantPropagationTest, JustInit) {
std::string Code = R"( std::string Code = R"(
void fun() { void fun() {
int target = 1; int target = 1;
// [[p]] // [[p]]
} }
)"; )";
RunDataflow(Code, UnorderedElementsAre( RunDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
Pair("p", HoldsCPLattice(UnorderedElementsAre(Pair( "p", HoldsCPLattice(UnorderedElementsAre(
Var("target"), HasConstantVal(1))))))); Pair(Var("target"), HasConstantVal(1)))))));
} }
TEST(MultiVarConstantPropagationTest, Assignment) { TEST(MultiVarConstantPropagationTest, Assignment) {
std::string Code = R"( std::string Code = R"(
void fun() { void fun() {
int target = 1; int target = 1;
// [[p1]] // [[p1]]
target = 2; target = 2;
// [[p2]] // [[p2]]
} }
)"; )";
RunDataflow(Code, UnorderedElementsAre( RunDataflow(
Pair("p1", HoldsCPLattice(UnorderedElementsAre(Pair( Code,
Var("target"), HasConstantVal(1))))), UnorderedElementsAre(
Pair("p2", HoldsCPLattice(UnorderedElementsAre(Pair( IsStringMapEntry("p1", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), HasConstantVal(1))))),
IsStringMapEntry("p2", HoldsCPLattice(UnorderedElementsAre(Pair(
Var("target"), HasConstantVal(2))))))); Var("target"), HasConstantVal(2)))))));
} }
TEST(MultiVarConstantPropagationTest, AssignmentCall) { TEST(MultiVarConstantPropagationTest, AssignmentCall) {
std::string Code = R"( std::string Code = R"(
int g(); int g();
void fun() { void fun() {
int target; int target;
target = g(); target = g();
// [[p]] // [[p]]
} }
)"; )";
RunDataflow(Code, UnorderedElementsAre( RunDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
Pair("p", HoldsCPLattice(UnorderedElementsAre( "p", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), Varies())))))); Pair(Var("target"), Varies()))))));
} }
TEST(MultiVarConstantPropagationTest, AssignmentBinOp) { TEST(MultiVarConstantPropagationTest, AssignmentBinOp) {
std::string Code = R"( std::string Code = R"(
void fun() { void fun() {
int target; int target;
target = 2 + 3; target = 2 + 3;
// [[p]] // [[p]]
} }
)"; )";
RunDataflow(Code, UnorderedElementsAre( RunDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
Pair("p", HoldsCPLattice(UnorderedElementsAre(Pair( "p", HoldsCPLattice(UnorderedElementsAre(
Var("target"), HasConstantVal(5))))))); Pair(Var("target"), HasConstantVal(5)))))));
} }
TEST(MultiVarConstantPropagationTest, PlusAssignment) { TEST(MultiVarConstantPropagationTest, PlusAssignment) {
std::string Code = R"( std::string Code = R"(
void fun() { void fun() {
int target = 1; int target = 1;
// [[p1]] // [[p1]]
target += 2; target += 2;
// [[p2]] // [[p2]]
} }
)"; )";
RunDataflow(Code, UnorderedElementsAre( RunDataflow(
Pair("p1", HoldsCPLattice(UnorderedElementsAre(Pair( Code, UnorderedElementsAre(
IsStringMapEntry("p1", HoldsCPLattice(UnorderedElementsAre(Pair(
Var("target"), HasConstantVal(1))))), Var("target"), HasConstantVal(1))))),
Pair("p2", HoldsCPLattice(UnorderedElementsAre( IsStringMapEntry("p2", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), Varies())))))); Pair(Var("target"), Varies()))))));
} }
TEST(MultiVarConstantPropagationTest, SameAssignmentInBranches) { TEST(MultiVarConstantPropagationTest, SameAssignmentInBranches) {
std::string Code = R"cc( std::string Code = R"cc(
void fun(bool b) { void fun(bool b) {
int target; int target;
// [[p1]] // [[p1]]
if (b) { if (b) {
target = 2; target = 2;
// [[pT]] // [[pT]]
} else { } else {
target = 2; target = 2;
// [[pF]] // [[pF]]
} }
(void)0; (void)0;
// [[p2]] // [[p2]]
} }
)cc"; )cc";
RunDataflow(Code, RunDataflow(
Code,
UnorderedElementsAre( UnorderedElementsAre(
Pair("p1", HoldsCPLattice(UnorderedElementsAre( IsStringMapEntry("p1", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), Varies())))), Pair(Var("target"), Varies())))),
Pair("pT", HoldsCPLattice(UnorderedElementsAre( IsStringMapEntry("pT", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), HasConstantVal(2))))), Pair(Var("target"), HasConstantVal(2))))),
Pair("pF", HoldsCPLattice(UnorderedElementsAre( IsStringMapEntry("pF", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), HasConstantVal(2))))), Pair(Var("target"), HasConstantVal(2))))),
Pair("p2", HoldsCPLattice(UnorderedElementsAre( IsStringMapEntry("p2", HoldsCPLattice(UnorderedElementsAre(Pair(
Pair(Var("target"), HasConstantVal(2))))))); Var("target"), HasConstantVal(2)))))));
} }
// Verifies that the analysis tracks multiple variables simultaneously. // Verifies that the analysis tracks multiple variables simultaneously.
TEST(MultiVarConstantPropagationTest, TwoVariables) { TEST(MultiVarConstantPropagationTest, TwoVariables) {
std::string Code = R"( std::string Code = R"(
void fun() { void fun() {
int target = 1; int target = 1;
// [[p1]] // [[p1]]
int other = 2; int other = 2;
// [[p2]] // [[p2]]
target = 3; target = 3;
// [[p3]] // [[p3]]
} }
)"; )";
RunDataflow(Code, RunDataflow(
Code,
UnorderedElementsAre( UnorderedElementsAre(
Pair("p1", HoldsCPLattice(UnorderedElementsAre( IsStringMapEntry("p1", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), HasConstantVal(1))))), Pair(Var("target"), HasConstantVal(1))))),
Pair("p2", HoldsCPLattice(UnorderedElementsAre( IsStringMapEntry("p2", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), HasConstantVal(1)), Pair(Var("target"), HasConstantVal(1)),
Pair(Var("other"), HasConstantVal(2))))), Pair(Var("other"), HasConstantVal(2))))),
Pair("p3", HoldsCPLattice(UnorderedElementsAre( IsStringMapEntry("p3", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), HasConstantVal(3)), Pair(Var("target"), HasConstantVal(3)),
Pair(Var("other"), HasConstantVal(2))))))); Pair(Var("other"), HasConstantVal(2)))))));
} }
TEST(MultiVarConstantPropagationTest, TwoVariablesInBranches) { TEST(MultiVarConstantPropagationTest, TwoVariablesInBranches) {
std::string Code = R"cc( std::string Code = R"cc(
void fun(bool b) { void fun(bool b) {
int target; int target;
int other; int other;
// [[p1]] // [[p1]]
if (b) { if (b) {
target = 2; target = 2;
// [[pT]] // [[pT]]
} else { } else {
other = 3; other = 3;
// [[pF]] // [[pF]]
} }
(void)0; (void)0;
// [[p2]] // [[p2]]
} }
)cc"; )cc";
RunDataflow(Code, UnorderedElementsAre( RunDataflow(
Pair("p1", HoldsCPLattice(UnorderedElementsAre( Code,
UnorderedElementsAre(
IsStringMapEntry("p1", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), Varies()), Pair(Var("target"), Varies()),
Pair(Var("other"), Varies())))), Pair(Var("other"), Varies())))),
Pair("pT", HoldsCPLattice(UnorderedElementsAre( IsStringMapEntry("pT", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), HasConstantVal(2)), Pair(Var("target"), HasConstantVal(2)),
Pair(Var("other"), Varies())))), Pair(Var("other"), Varies())))),
Pair("pF", HoldsCPLattice(UnorderedElementsAre( IsStringMapEntry("pF", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("other"), HasConstantVal(3)), Pair(Var("other"), HasConstantVal(3)),
Pair(Var("target"), Varies())))), Pair(Var("target"), Varies())))),
Pair("p2", HoldsCPLattice(UnorderedElementsAre( IsStringMapEntry("p2", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), Varies()), Pair(Var("target"), Varies()),
Pair(Var("other"), Varies())))))); Pair(Var("other"), Varies()))))));
} }
TEST(MultiVarConstantPropagationTest, SameAssignmentInBranch) { TEST(MultiVarConstantPropagationTest, SameAssignmentInBranch) {
std::string Code = R"cc( std::string Code = R"cc(
void fun(bool b) { void fun(bool b) {
int target = 1; int target = 1;
// [[p1]] // [[p1]]
if (b) { if (b) {
target = 1; target = 1;
} }
(void)0; (void)0;
// [[p2]] // [[p2]]
} }
)cc"; )cc";
RunDataflow(Code, UnorderedElementsAre( RunDataflow(
Pair("p1", HoldsCPLattice(UnorderedElementsAre(Pair( Code,
Var("target"), HasConstantVal(1))))), UnorderedElementsAre(
Pair("p2", HoldsCPLattice(UnorderedElementsAre(Pair( IsStringMapEntry("p1", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), HasConstantVal(1))))),
IsStringMapEntry("p2", HoldsCPLattice(UnorderedElementsAre(Pair(
Var("target"), HasConstantVal(1))))))); Var("target"), HasConstantVal(1)))))));
} }
TEST(MultiVarConstantPropagationTest, NewVarInBranch) { TEST(MultiVarConstantPropagationTest, NewVarInBranch) {
std::string Code = R"cc( std::string Code = R"cc(
void fun(bool b) { void fun(bool b) {
if (b) { if (b) {
int target; int target;
// [[p1]] // [[p1]]
target = 1; target = 1;
// [[p2]] // [[p2]]
} else { } else {
int target; int target;
// [[p3]] // [[p3]]
target = 1; target = 1;
// [[p4]] // [[p4]]
} }
} }
)cc"; )cc";
RunDataflow(Code, UnorderedElementsAre( RunDataflow(
Pair("p1", HoldsCPLattice(UnorderedElementsAre( Code,
UnorderedElementsAre(
IsStringMapEntry("p1", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), Varies())))), Pair(Var("target"), Varies())))),
Pair("p2", HoldsCPLattice(UnorderedElementsAre(Pair( IsStringMapEntry("p2", HoldsCPLattice(UnorderedElementsAre(
Var("target"), HasConstantVal(1))))), Pair(Var("target"), HasConstantVal(1))))),
Pair("p3", HoldsCPLattice(UnorderedElementsAre( IsStringMapEntry("p3", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), Varies())))), Pair(Var("target"), Varies())))),
Pair("p4", HoldsCPLattice(UnorderedElementsAre(Pair( IsStringMapEntry("p4", HoldsCPLattice(UnorderedElementsAre(Pair(
Var("target"), HasConstantVal(1))))))); Var("target"), HasConstantVal(1)))))));
} }
TEST(MultiVarConstantPropagationTest, DifferentAssignmentInBranches) { TEST(MultiVarConstantPropagationTest, DifferentAssignmentInBranches) {
std::string Code = R"cc( std::string Code = R"cc(
void fun(bool b) { void fun(bool b) {
int target; int target;
// [[p1]] // [[p1]]
if (b) { if (b) {
target = 1; target = 1;
// [[pT]] // [[pT]]
} else { } else {
target = 2; target = 2;
// [[pF]] // [[pF]]
} }
(void)0; (void)0;
// [[p2]] // [[p2]]
} }
)cc"; )cc";
RunDataflow(Code, UnorderedElementsAre( RunDataflow(
Pair("p1", HoldsCPLattice(UnorderedElementsAre( Code, UnorderedElementsAre(
IsStringMapEntry("p1", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), Varies())))), Pair(Var("target"), Varies())))),
Pair("pT", HoldsCPLattice(UnorderedElementsAre(Pair( IsStringMapEntry("pT", HoldsCPLattice(UnorderedElementsAre(Pair(
Var("target"), HasConstantVal(1))))), Var("target"), HasConstantVal(1))))),
Pair("pF", HoldsCPLattice(UnorderedElementsAre(Pair( IsStringMapEntry("pF", HoldsCPLattice(UnorderedElementsAre(Pair(
Var("target"), HasConstantVal(2))))), Var("target"), HasConstantVal(2))))),
Pair("p2", HoldsCPLattice(UnorderedElementsAre( IsStringMapEntry("p2", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), Varies())))))); Pair(Var("target"), Varies()))))));
} }
TEST(MultiVarConstantPropagationTest, DifferentAssignmentInBranch) { TEST(MultiVarConstantPropagationTest, DifferentAssignmentInBranch) {
std::string Code = R"cc( std::string Code = R"cc(
void fun(bool b) { void fun(bool b) {
int target = 1; int target = 1;
// [[p1]] // [[p1]]
if (b) { if (b) {
target = 3; target = 3;
} }
(void)0; (void)0;
// [[p2]] // [[p2]]
} }
)cc"; )cc";
RunDataflow(Code, UnorderedElementsAre( RunDataflow(
Pair("p1", HoldsCPLattice(UnorderedElementsAre(Pair( Code, UnorderedElementsAre(
IsStringMapEntry("p1", HoldsCPLattice(UnorderedElementsAre(Pair(
Var("target"), HasConstantVal(1))))), Var("target"), HasConstantVal(1))))),
Pair("p2", HoldsCPLattice(UnorderedElementsAre( IsStringMapEntry("p2", HoldsCPLattice(UnorderedElementsAre(
Pair(Var("target"), Varies())))))); Pair(Var("target"), Varies()))))));
} }
} // namespace } // namespace
} // namespace dataflow } // namespace dataflow
} // namespace clang } // namespace clang

clang/unittests/Analysis/FlowSensitive/SingleVarConstantPropagationTest.cpp

Show All 22 Lines
#include "clang/Analysis/FlowSensitive/DataflowEnvironment.h" #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
#include "clang/Analysis/FlowSensitive/DataflowLattice.h" #include "clang/Analysis/FlowSensitive/DataflowLattice.h"
#include "clang/Tooling/Tooling.h" #include "clang/Tooling/Tooling.h"
#include "llvm/ADT/None.h" #include "llvm/ADT/None.h"
#include "llvm/ADT/Optional.h" #include "llvm/ADT/Optional.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Twine.h" #include "llvm/ADT/Twine.h"
#include "llvm/Support/Error.h" #include "llvm/Support/Error.h"
#include "llvm/Testing/ADT/StringMapEntry.h"
#include "llvm/Testing/Support/Annotations.h" #include "llvm/Testing/Support/Annotations.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 <cstdint> #include <cstdint>
#include <memory> #include <memory>
#include <ostream> #include <ostream>
#include <string> #include <string>
▲ Show 20 Lines • Show All 124 Lines • ▼ Show 20 Lines void transfer(const Stmt *S, ConstantPropagationLattice &Element,
} else if (Nodes.getNodeAs<clang::Expr>(kAssignment)) } else if (Nodes.getNodeAs<clang::Expr>(kAssignment))
// Any assignment involving the expression itself resets the variable to // Any assignment involving the expression itself resets the variable to
// "unknown". A more advanced analysis could try to evaluate the compound // "unknown". A more advanced analysis could try to evaluate the compound
// assignment. For example, `x += 0` need not invalidate `x`. // assignment. For example, `x += 0` need not invalidate `x`.
Element = ConstantPropagationLattice::top(); Element = ConstantPropagationLattice::top();
} }
}; };
using ::testing::Pair; using ::clang::dataflow::test::AnalysisInputs;
using ::clang::dataflow::test::AnalysisOutputs;
using ::clang::dataflow::test::checkDataflow;
using ::llvm::IsStringMapEntry;
using ::testing::UnorderedElementsAre; using ::testing::UnorderedElementsAre;
MATCHER_P(HasConstantVal, v, "") { return arg.Data && arg.Data->Value == v; } MATCHER_P(HasConstantVal, v, "") { return arg.Data && arg.Data->Value == v; }
MATCHER(IsUnknown, "") { return arg == arg.bottom(); } MATCHER(IsUnknown, "") { return arg == arg.bottom(); }
MATCHER(Varies, "") { return arg == arg.top(); } MATCHER(Varies, "") { return arg == arg.top(); }
MATCHER_P(HoldsCPLattice, m, MATCHER_P(HoldsCPLattice, m,
((negation ? "doesn't hold" : "holds") + ((negation ? "doesn't hold" : "holds") +
llvm::StringRef(" a lattice element that ") + llvm::StringRef(" a lattice element that ") +
::testing::DescribeMatcher<ConstantPropagationLattice>(m, negation)) ::testing::DescribeMatcher<ConstantPropagationLattice>(m, negation))
.str()) { .str()) {
return ExplainMatchResult(m, arg.Lattice, result_listener); return ExplainMatchResult(m, arg.Lattice, result_listener);
} }
template <typename Matcher> template <typename Matcher>
void RunDataflow(llvm::StringRef Code, Matcher Expectations) { void RunDataflow(llvm::StringRef Code, Matcher Expectations) {
ASSERT_THAT_ERROR( ASSERT_THAT_ERROR(
test::checkDataflow<ConstantPropagationAnalysis>( checkDataflow<ConstantPropagationAnalysis>(
Code, "fun", AnalysisInputs<ConstantPropagationAnalysis>(
Code, hasName("fun"),
[](ASTContext &C, Environment &) { [](ASTContext &C, Environment &) {
return ConstantPropagationAnalysis(C); return ConstantPropagationAnalysis(C);
}, })
[&Expectations]( .withASTBuildArgs({"-fsyntax-only", "-std=c++17"}),
llvm::ArrayRef<std::pair< /*VerifyResults=*/
std::string, [&Expectations](const llvm::StringMap<DataflowAnalysisState<
DataflowAnalysisState<ConstantPropagationAnalysis::Lattice>>> ConstantPropagationAnalysis::Lattice>> &Results,
Results, const AnalysisOutputs &) {
ASTContext &) { EXPECT_THAT(Results, Expectations); }, EXPECT_THAT(Results, Expectations);
{"-fsyntax-only", "-std=c++17"}), }),
llvm::Succeeded()); llvm::Succeeded());
} }
TEST(ConstantPropagationTest, JustInit) { TEST(ConstantPropagationTest, JustInit) {
std::string Code = R"( std::string Code = R"(
void fun() { void fun() {
int target = 1; int target = 1;
// [[p]] // [[p]]
} }
)"; )";
RunDataflow( RunDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
Code, UnorderedElementsAre(Pair("p", HoldsCPLattice(HasConstantVal(1))))); "p", HoldsCPLattice(HasConstantVal(1)))));
} }
// Verifies that the analysis tracks the last variable seen. // Verifies that the analysis tracks the last variable seen.
TEST(ConstantPropagationTest, TwoVariables) { TEST(ConstantPropagationTest, TwoVariables) {
std::string Code = R"( std::string Code = R"(
void fun() { void fun() {
int target = 1; int target = 1;
// [[p1]] // [[p1]]
int other = 2; int other = 2;
// [[p2]] // [[p2]]
target = 3; target = 3;
// [[p3]] // [[p3]]
} }
)"; )";
RunDataflow(Code, UnorderedElementsAre( RunDataflow(Code,
Pair("p1", HoldsCPLattice(HasConstantVal(1))), UnorderedElementsAre(
Pair("p2", HoldsCPLattice(HasConstantVal(2))), IsStringMapEntry("p1", HoldsCPLattice(HasConstantVal(1))),
Pair("p3", HoldsCPLattice(HasConstantVal(3))))); IsStringMapEntry("p2", HoldsCPLattice(HasConstantVal(2))),
IsStringMapEntry("p3", HoldsCPLattice(HasConstantVal(3)))));
} }
TEST(ConstantPropagationTest, Assignment) { TEST(ConstantPropagationTest, Assignment) {
std::string Code = R"( std::string Code = R"(
void fun() { void fun() {
int target = 1; int target = 1;
// [[p1]] // [[p1]]
target = 2; target = 2;
// [[p2]] // [[p2]]
} }
)"; )";
RunDataflow(Code, UnorderedElementsAre( RunDataflow(Code,
Pair("p1", HoldsCPLattice(HasConstantVal(1))), UnorderedElementsAre(
Pair("p2", HoldsCPLattice(HasConstantVal(2))))); IsStringMapEntry("p1", HoldsCPLattice(HasConstantVal(1))),
IsStringMapEntry("p2", HoldsCPLattice(HasConstantVal(2)))));
} }
TEST(ConstantPropagationTest, AssignmentCall) { TEST(ConstantPropagationTest, AssignmentCall) {
std::string Code = R"( std::string Code = R"(
int g(); int g();
void fun() { void fun() {
int target; int target;
target = g(); target = g();
// [[p]] // [[p]]
} }
)"; )";
RunDataflow(Code, UnorderedElementsAre(Pair("p", HoldsCPLattice(Varies())))); RunDataflow(Code, UnorderedElementsAre(
IsStringMapEntry("p", HoldsCPLattice(Varies()))));
} }
TEST(ConstantPropagationTest, AssignmentBinOp) { TEST(ConstantPropagationTest, AssignmentBinOp) {
std::string Code = R"( std::string Code = R"(
void fun() { void fun() {
int target; int target;
target = 2 + 3; target = 2 + 3;
// [[p]] // [[p]]
} }
)"; )";
RunDataflow( RunDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
Code, UnorderedElementsAre(Pair("p", HoldsCPLattice(HasConstantVal(5))))); "p", HoldsCPLattice(HasConstantVal(5)))));
} }
TEST(ConstantPropagationTest, PlusAssignment) { TEST(ConstantPropagationTest, PlusAssignment) {
std::string Code = R"( std::string Code = R"(
void fun() { void fun() {
int target = 1; int target = 1;
// [[p1]] // [[p1]]
target += 2; target += 2;
// [[p2]] // [[p2]]
} }
)"; )";
RunDataflow( RunDataflow(Code,
Code, UnorderedElementsAre(Pair("p1", HoldsCPLattice(HasConstantVal(1))), UnorderedElementsAre(
Pair("p2", HoldsCPLattice(Varies())))); IsStringMapEntry("p1", HoldsCPLattice(HasConstantVal(1))),
IsStringMapEntry("p2", HoldsCPLattice(Varies()))));
} }
TEST(ConstantPropagationTest, SameAssignmentInBranches) { TEST(ConstantPropagationTest, SameAssignmentInBranches) {
std::string Code = R"cc( std::string Code = R"cc(
void fun(bool b) { void fun(bool b) {
int target; int target;
// [[p1]] // [[p1]]
if (b) { if (b) {
target = 2; target = 2;
// [[pT]] // [[pT]]
} else { } else {
target = 2; target = 2;
// [[pF]] // [[pF]]
} }
(void)0; (void)0;
// [[p2]] // [[p2]]
} }
)cc"; )cc";
RunDataflow(Code, UnorderedElementsAre( RunDataflow(Code,
Pair("p1", HoldsCPLattice(IsUnknown())), UnorderedElementsAre(
Pair("pT", HoldsCPLattice(HasConstantVal(2))), IsStringMapEntry("p1", HoldsCPLattice(IsUnknown())),
Pair("pF", HoldsCPLattice(HasConstantVal(2))), IsStringMapEntry("pT", HoldsCPLattice(HasConstantVal(2))),
Pair("p2", HoldsCPLattice(HasConstantVal(2))))); IsStringMapEntry("pF", HoldsCPLattice(HasConstantVal(2))),
IsStringMapEntry("p2", HoldsCPLattice(HasConstantVal(2)))));
} }
TEST(ConstantPropagationTest, SameAssignmentInBranch) { TEST(ConstantPropagationTest, SameAssignmentInBranch) {
std::string Code = R"cc( std::string Code = R"cc(
void fun(bool b) { void fun(bool b) {
int target = 1; int target = 1;
// [[p1]] // [[p1]]
if (b) { if (b) {
target = 1; target = 1;
} }
(void)0; (void)0;
// [[p2]] // [[p2]]
} }
)cc"; )cc";
RunDataflow(Code, UnorderedElementsAre( RunDataflow(Code,
Pair("p1", HoldsCPLattice(HasConstantVal(1))), UnorderedElementsAre(
Pair("p2", HoldsCPLattice(HasConstantVal(1))))); IsStringMapEntry("p1", HoldsCPLattice(HasConstantVal(1))),
IsStringMapEntry("p2", HoldsCPLattice(HasConstantVal(1)))));
} }
TEST(ConstantPropagationTest, NewVarInBranch) { TEST(ConstantPropagationTest, NewVarInBranch) {
std::string Code = R"cc( std::string Code = R"cc(
void fun(bool b) { void fun(bool b) {
if (b) { if (b) {
int target; int target;
// [[p1]] // [[p1]]
target = 1; target = 1;
// [[p2]] // [[p2]]
} else { } else {
int target; int target;
// [[p3]] // [[p3]]
target = 1; target = 1;
// [[p4]] // [[p4]]
} }
} }
)cc"; )cc";
RunDataflow(Code, UnorderedElementsAre( RunDataflow(Code,
Pair("p1", HoldsCPLattice(IsUnknown())), UnorderedElementsAre(
Pair("p2", HoldsCPLattice(HasConstantVal(1))), IsStringMapEntry("p1", HoldsCPLattice(IsUnknown())),
Pair("p3", HoldsCPLattice(IsUnknown())), IsStringMapEntry("p2", HoldsCPLattice(HasConstantVal(1))),
Pair("p4", HoldsCPLattice(HasConstantVal(1))))); IsStringMapEntry("p3", HoldsCPLattice(IsUnknown())),
IsStringMapEntry("p4", HoldsCPLattice(HasConstantVal(1)))));
} }
TEST(ConstantPropagationTest, DifferentAssignmentInBranches) { TEST(ConstantPropagationTest, DifferentAssignmentInBranches) {
std::string Code = R"cc( std::string Code = R"cc(
void fun(bool b) { void fun(bool b) {
int target; int target;
// [[p1]] // [[p1]]
if (b) { if (b) {
target = 1; target = 1;
// [[pT]] // [[pT]]
} else { } else {
target = 2; target = 2;
// [[pF]] // [[pF]]
} }
(void)0; (void)0;
// [[p2]] // [[p2]]
} }
)cc"; )cc";
RunDataflow( RunDataflow(Code,
Code, UnorderedElementsAre(Pair("p1", HoldsCPLattice(IsUnknown())), UnorderedElementsAre(
Pair("pT", HoldsCPLattice(HasConstantVal(1))), IsStringMapEntry("p1", HoldsCPLattice(IsUnknown())),
Pair("pF", HoldsCPLattice(HasConstantVal(2))), IsStringMapEntry("pT", HoldsCPLattice(HasConstantVal(1))),
Pair("p2", HoldsCPLattice(Varies())))); IsStringMapEntry("pF", HoldsCPLattice(HasConstantVal(2))),
IsStringMapEntry("p2", HoldsCPLattice(Varies()))));
} }
TEST(ConstantPropagationTest, DifferentAssignmentInBranch) { TEST(ConstantPropagationTest, DifferentAssignmentInBranch) {
std::string Code = R"cc( std::string Code = R"cc(
void fun(bool b) { void fun(bool b) {
int target = 1; int target = 1;
// [[p1]] // [[p1]]
if (b) { if (b) {
target = 3; target = 3;
} }
(void)0; (void)0;
// [[p2]] // [[p2]]
} }
)cc"; )cc";
RunDataflow( RunDataflow(Code,
Code, UnorderedElementsAre(Pair("p1", HoldsCPLattice(HasConstantVal(1))), UnorderedElementsAre(
Pair("p2", HoldsCPLattice(Varies())))); IsStringMapEntry("p1", HoldsCPLattice(HasConstantVal(1))),
IsStringMapEntry("p2", HoldsCPLattice(Varies()))));
} }
} // namespace } // namespace
} // namespace dataflow } // namespace dataflow
} // namespace clang } // namespace clang

clang/unittests/Analysis/FlowSensitive/TestingSupportTest.cpp

#include "TestingSupport.h" #include "TestingSupport.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Analysis/FlowSensitive/NoopAnalysis.h" #include "clang/Analysis/FlowSensitive/NoopAnalysis.h"
#include "clang/Tooling/Tooling.h" #include "clang/Tooling/Tooling.h"
#include "llvm/Testing/ADT/StringMapEntry.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"
using namespace clang; using namespace clang;
using namespace dataflow; using namespace dataflow;
namespace { namespace {
using ::clang::ast_matchers::functionDecl; using ::clang::ast_matchers::functionDecl;
using ::clang::ast_matchers::hasName; using ::clang::ast_matchers::hasName;
using ::clang::ast_matchers::isDefinition; using ::clang::ast_matchers::isDefinition;
using ::clang::dataflow::test::AnalysisInputs;
using ::clang::dataflow::test::AnalysisOutputs;
using ::clang::dataflow::test::checkDataflow;
using ::llvm::IsStringMapEntry;
using ::testing::_; using ::testing::_;
using ::testing::IsEmpty; using ::testing::IsEmpty;
using ::testing::Pair;
using ::testing::UnorderedElementsAre; using ::testing::UnorderedElementsAre;
template <typename T> template <typename T>
const FunctionDecl *findTargetFunc(ASTContext &Context, T FunctionMatcher) { const FunctionDecl *findTargetFunc(ASTContext &Context, T FunctionMatcher) {
auto TargetMatcher = auto TargetMatcher =
functionDecl(FunctionMatcher, isDefinition()).bind("target"); functionDecl(FunctionMatcher, isDefinition()).bind("target");
for (const auto &Node : ast_matchers::match(TargetMatcher, Context)) { for (const auto &Node : ast_matchers::match(TargetMatcher, Context)) {
const auto *Func = Node.template getNodeAs<FunctionDecl>("target"); const auto *Func = Node.template getNodeAs<FunctionDecl>("target");
Show All 36 Lines )",
ASSERT_EQ(Annotations.size(), static_cast<unsigned int>(1)); ASSERT_EQ(Annotations.size(), static_cast<unsigned int>(1));
EXPECT_TRUE(isa<ReturnStmt>(Annotations.begin()->first)); EXPECT_TRUE(isa<ReturnStmt>(Annotations.begin()->first));
EXPECT_EQ(Annotations.begin()->second, "ok"); EXPECT_EQ(Annotations.begin()->second, "ok");
}); });
} }
void checkDataflow( void checkDataflow(
llvm::StringRef Code, llvm::StringRef Target, llvm::StringRef Code, llvm::StringRef Target,
std::function<void(llvm::ArrayRef<std::pair< std::function<
std::string, DataflowAnalysisState<NoopLattice>>>, void(const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &,
ASTContext &)> const AnalysisOutputs &)>
Expectations) { Expectations) {
ASSERT_THAT_ERROR( ASSERT_THAT_ERROR(checkDataflow<NoopAnalysis>(
test::checkDataflow<NoopAnalysis>( AnalysisInputs<NoopAnalysis>(
Code, Target, Code, hasName(Target),
[](ASTContext &Context, Environment &) { [](ASTContext &Context, Environment &) {
return NoopAnalysis(Context, /*ApplyBuiltinTransfer=*/false); return NoopAnalysis(
}, Context, /*ApplyBuiltinTransfer=*/false);
std::move(Expectations), {"-fsyntax-only", "-std=c++17"}), })
sgatevUnsubmitted
Done
ReplyInline Actions

Do we need .withASTBuildArgs({"-fsyntax-only", "-std=c++17"}) here?

sgatev: Do we need `.withASTBuildArgs({"-fsyntax-only", "-std=c++17"})` here?
.withASTBuildArgs({"-fsyntax-only", "-std=c++17"}),
/*VerifyResults=*/
std::move(Expectations)),
llvm::Succeeded()); llvm::Succeeded());
} }
TEST(ProgramPointAnnotations, NoAnnotations) { TEST(ProgramPointAnnotations, NoAnnotations) {
::testing::MockFunction<void( ::testing::MockFunction<void(
llvm::ArrayRef< const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>>, const AnalysisOutputs &)>
ASTContext &)>
Expectations; Expectations;
EXPECT_CALL(Expectations, Call(IsEmpty(), _)).Times(1); EXPECT_CALL(Expectations, Call(IsEmpty(), _)).Times(1);
checkDataflow("void target() {}", "target", Expectations.AsStdFunction()); checkDataflow("void target() {}", "target", Expectations.AsStdFunction());
} }
TEST(ProgramPointAnnotations, NoAnnotationsDifferentTarget) { TEST(ProgramPointAnnotations, NoAnnotationsDifferentTarget) {
::testing::MockFunction<void( ::testing::MockFunction<void(
llvm::ArrayRef< const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>>, const AnalysisOutputs &)>
ASTContext &)>
Expectations; Expectations;
EXPECT_CALL(Expectations, Call(IsEmpty(), _)).Times(1); EXPECT_CALL(Expectations, Call(IsEmpty(), _)).Times(1);
checkDataflow("void fun() {}", "fun", Expectations.AsStdFunction()); checkDataflow("void fun() {}", "fun", Expectations.AsStdFunction());
} }
TEST(ProgramPointAnnotations, WithCodepoint) { TEST(ProgramPointAnnotations, WithCodepoint) {
::testing::MockFunction<void( ::testing::MockFunction<void(
llvm::ArrayRef< const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>>, const AnalysisOutputs &)>
ASTContext &)>
Expectations; Expectations;
EXPECT_CALL(Expectations, EXPECT_CALL(
Call(UnorderedElementsAre(Pair("program-point", _)), _)) Expectations,
Call(UnorderedElementsAre(IsStringMapEntry("program-point", _)), _))
.Times(1); .Times(1);
checkDataflow(R"cc(void target() { checkDataflow(R"cc(void target() {
int n; int n;
// [[program-point]] // [[program-point]]
})cc", })cc",
"target", Expectations.AsStdFunction()); "target", Expectations.AsStdFunction());
} }
TEST(ProgramPointAnnotations, MultipleCodepoints) { TEST(ProgramPointAnnotations, MultipleCodepoints) {
::testing::MockFunction<void( ::testing::MockFunction<void(
llvm::ArrayRef< const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>>, const AnalysisOutputs &)>
ASTContext &)>
Expectations; Expectations;
EXPECT_CALL(Expectations, EXPECT_CALL(Expectations,
Call(UnorderedElementsAre(Pair("program-point-1", _), Call(UnorderedElementsAre(IsStringMapEntry("program-point-1", _),
Pair("program-point-2", _)), IsStringMapEntry("program-point-2", _)),
_)) _))
.Times(1); .Times(1);
checkDataflow(R"cc(void target(bool b) { checkDataflow(R"cc(void target(bool b) {
if (b) { if (b) {
int n; int n;
// [[program-point-1]] // [[program-point-1]]
} else { } else {
int m; int m;
// [[program-point-2]] // [[program-point-2]]
} }
})cc", })cc",
"target", Expectations.AsStdFunction()); "target", Expectations.AsStdFunction());
} }
} // namespace } // namespace

clang/unittests/Analysis/FlowSensitive/TransferTest.cpp

Show All 24 Lines
#include <string> #include <string>
#include <utility> #include <utility>
namespace { namespace {
using namespace clang; using namespace clang;
using namespace dataflow; using namespace dataflow;
using namespace test; using namespace test;
using ::testing::_;
using ::testing::ElementsAre;
using ::testing::IsNull; using ::testing::IsNull;
using ::testing::NotNull; using ::testing::NotNull;
using ::testing::Pair; using ::testing::UnorderedElementsAre;
using ::testing::SizeIs;
template <typename Matcher> template <typename Matcher>
void runDataflow(llvm::StringRef Code, Matcher Match, void runDataflow(llvm::StringRef Code, Matcher Match,
DataflowAnalysisOptions Options, DataflowAnalysisOptions Options,
LangStandard::Kind Std = LangStandard::lang_cxx17, LangStandard::Kind Std = LangStandard::lang_cxx17,
llvm::StringRef TargetFun = "target") { llvm::StringRef TargetFun = "target") {
using ast_matchers::hasName;
ASSERT_THAT_ERROR( ASSERT_THAT_ERROR(
test::checkDataflow<NoopAnalysis>( checkDataflow<NoopAnalysis>(
Code, TargetFun, AnalysisInputs<NoopAnalysis>(Code, hasName(TargetFun),
[Options](ASTContext &C, Environment &) { [Options](ASTContext &C, Environment &) {
return NoopAnalysis(C, Options); return NoopAnalysis(C, Options);
}, })
[&Match]( .withASTBuildArgs(
llvm::ArrayRef<
std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
Results,
ASTContext &ASTCtx) { Match(Results, ASTCtx); },
{"-fsyntax-only", "-fno-delayed-template-parsing", {"-fsyntax-only", "-fno-delayed-template-parsing",
"-std=" + std::string( "-std=" +
LangStandard::getLangStandardForKind(Std).getName())}), std::string(LangStandard::getLangStandardForKind(Std)
.getName())}),
/*VerifyResults=*/
[&Match](const llvm::StringMap<DataflowAnalysisState<NoopLattice>>
&Results,
const AnalysisOutputs &AO) { Match(Results, AO.ASTCtx); }),
llvm::Succeeded()); llvm::Succeeded());
} }
template <typename Matcher> template <typename Matcher>
void runDataflow(llvm::StringRef Code, Matcher Match, void runDataflow(llvm::StringRef Code, Matcher Match,
LangStandard::Kind Std = LangStandard::lang_cxx17, LangStandard::Kind Std = LangStandard::lang_cxx17,
bool ApplyBuiltinTransfer = true, bool ApplyBuiltinTransfer = true,
llvm::StringRef TargetFun = "target") { llvm::StringRef TargetFun = "target") {
runDataflow(Code, Match, runDataflow(Code, Match,
{ApplyBuiltinTransfer ? TransferOptions{} {ApplyBuiltinTransfer ? TransferOptions{}
: llvm::Optional<TransferOptions>()}, : llvm::Optional<TransferOptions>()},
Std, TargetFun); Std, TargetFun);
} }
TEST(TransferTest, IntVarDeclNotTrackedWhenTransferDisabled) { TEST(TransferTest, IntVarDeclNotTrackedWhenTransferDisabled) {
std::string Code = R"( std::string Code = R"(
void target() { void target() {
int Foo; int Foo;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, Code,
[](llvm::ArrayRef< [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
EXPECT_EQ(Env.getStorageLocation(*FooDecl, SkipPast::None), nullptr); EXPECT_EQ(Env.getStorageLocation(*FooDecl, SkipPast::None), nullptr);
}, },
LangStandard::lang_cxx17, LangStandard::lang_cxx17,
/*ApplyBuiltinTransfer=*/false); /*ApplyBuiltinTransfer=*/false);
} }
TEST(TransferTest, BoolVarDecl) { TEST(TransferTest, BoolVarDecl) {
std::string Code = R"( std::string Code = R"(
void target() { void target() {
bool Foo; bool Foo;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const StorageLocation *FooLoc = const StorageLocation *FooLoc =
Env.getStorageLocation(*FooDecl, SkipPast::None); Env.getStorageLocation(*FooDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc)); ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc));
const Value *FooVal = Env.getValue(*FooLoc); const Value *FooVal = Env.getValue(*FooLoc);
EXPECT_TRUE(isa_and_nonnull<BoolValue>(FooVal)); EXPECT_TRUE(isa_and_nonnull<BoolValue>(FooVal));
}); });
} }
TEST(TransferTest, IntVarDecl) { TEST(TransferTest, IntVarDecl) {
std::string Code = R"( std::string Code = R"(
void target() { void target() {
int Foo; int Foo;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const StorageLocation *FooLoc = const StorageLocation *FooLoc =
Env.getStorageLocation(*FooDecl, SkipPast::None); Env.getStorageLocation(*FooDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc)); ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc));
const Value *FooVal = Env.getValue(*FooLoc); const Value *FooVal = Env.getValue(*FooLoc);
EXPECT_TRUE(isa_and_nonnull<IntegerValue>(FooVal)); EXPECT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
}); });
} }
TEST(TransferTest, StructVarDecl) { TEST(TransferTest, StructVarDecl) {
std::string Code = R"( std::string Code = R"(
struct A { struct A {
int Bar; int Bar;
}; };
void target() { void target() {
A Foo; A Foo;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
ASSERT_TRUE(FooDecl->getType()->isStructureType()); ASSERT_TRUE(FooDecl->getType()->isStructureType());
auto FooFields = FooDecl->getType()->getAsRecordDecl()->fields(); auto FooFields = FooDecl->getType()->getAsRecordDecl()->fields();
FieldDecl *BarDecl = nullptr; FieldDecl *BarDecl = nullptr;
Show All 26 Lines std::string Code = R"(
A Gen(); A Gen();
void target() { void target() {
A Foo = Gen(); A Foo = Gen();
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
ASSERT_TRUE(FooDecl->getType()->isStructureType()); ASSERT_TRUE(FooDecl->getType()->isStructureType());
auto FooFields = FooDecl->getType()->getAsRecordDecl()->fields(); auto FooFields = FooDecl->getType()->getAsRecordDecl()->fields();
FieldDecl *BarDecl = nullptr; FieldDecl *BarDecl = nullptr;
Show All 24 Lines std::string Code = R"(
}; };
void target() { void target() {
A Foo; A Foo;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
ASSERT_TRUE(FooDecl->getType()->isClassType()); ASSERT_TRUE(FooDecl->getType()->isClassType());
auto FooFields = FooDecl->getType()->getAsRecordDecl()->fields(); auto FooFields = FooDecl->getType()->getAsRecordDecl()->fields();
FieldDecl *BarDecl = nullptr; FieldDecl *BarDecl = nullptr;
Show All 24 Lines std::string Code = R"(
A &getA(); A &getA();
void target() { void target() {
A &Foo = getA(); A &Foo = getA();
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const StorageLocation *FooLoc = const StorageLocation *FooLoc =
Env.getStorageLocation(*FooDecl, SkipPast::None); Env.getStorageLocation(*FooDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc)); ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc));
Show All 26 Lines std::string Code = R"(
A &getA(); A &getA();
void target() { void target() {
A &Foo = getA(); A &Foo = getA();
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, [](llvm::ArrayRef<std::pair< runDataflow(Code, [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>>
std::string, DataflowAnalysisState<NoopLattice>>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
ASSERT_TRUE(FooDecl->getType()->isReferenceType()); ASSERT_TRUE(FooDecl->getType()->isReferenceType());
ASSERT_TRUE(FooDecl->getType().getNonReferenceType()->isStructureType()); ASSERT_TRUE(FooDecl->getType().getNonReferenceType()->isStructureType());
const auto FooFields = const auto FooFields =
FooDecl->getType().getNonReferenceType()->getAsRecordDecl()->fields(); FooDecl->getType().getNonReferenceType()->getAsRecordDecl()->fields();
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines std::string Code = R"(
A *getA(); A *getA();
void target() { void target() {
A *Foo = getA(); A *Foo = getA();
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const StorageLocation *FooLoc = const StorageLocation *FooLoc =
Env.getStorageLocation(*FooDecl, SkipPast::None); Env.getStorageLocation(*FooDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc)); ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc));
Show All 26 Lines std::string Code = R"(
A *getA(); A *getA();
void target() { void target() {
A *Foo = getA(); A *Foo = getA();
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
ASSERT_TRUE(FooDecl->getType()->isPointerType()); ASSERT_TRUE(FooDecl->getType()->isPointerType());
ASSERT_TRUE(FooDecl->getType() ASSERT_TRUE(FooDecl->getType()
->getAs<PointerType>() ->getAs<PointerType>()
->getPointeeType() ->getPointeeType()
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines
TEST(TransferTest, MultipleVarsDecl) { TEST(TransferTest, MultipleVarsDecl) {
std::string Code = R"( std::string Code = R"(
void target() { void target() {
int Foo, Bar; int Foo, Bar;
(void)0; (void)0;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 StorageLocation *FooLoc = const StorageLocation *FooLoc =
Env.getStorageLocation(*FooDecl, SkipPast::None); Env.getStorageLocation(*FooDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc)); ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc));
const StorageLocation *BarLoc = const StorageLocation *BarLoc =
Env.getStorageLocation(*BarDecl, SkipPast::None); Env.getStorageLocation(*BarDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(BarLoc)); ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(BarLoc));
const Value *FooVal = Env.getValue(*FooLoc); const Value *FooVal = Env.getValue(*FooLoc);
EXPECT_TRUE(isa_and_nonnull<IntegerValue>(FooVal)); EXPECT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
const Value *BarVal = Env.getValue(*BarLoc); const Value *BarVal = Env.getValue(*BarLoc);
EXPECT_TRUE(isa_and_nonnull<IntegerValue>(BarVal)); EXPECT_TRUE(isa_and_nonnull<IntegerValue>(BarVal));
}); });
} }
TEST(TransferTest, JoinVarDecl) { TEST(TransferTest, JoinVarDecl) {
std::string Code = R"( std::string Code = R"(
void target(bool B) { void target(bool B) {
int Foo; int Foo;
// [[p1]] // [[p1]]
if (B) { if (B) {
int Bar; int Bar;
// [[p2]] // [[p2]]
} else { } else {
int Baz; int Baz;
// [[p3]] // [[p3]]
} }
(void)0; (void)0;
// [[p4]] // [[p4]]
} }
)"; )";
runDataflow(Code, [](llvm::ArrayRef<std::pair< runDataflow(Code, [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>>
std::string, DataflowAnalysisState<NoopLattice>>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p1", _), Pair("p2", _), ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1", "p2", "p3", "p4"));
Pair("p3", _), Pair("p4", _)));
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 ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
const Environment &Env1 = Results[0].second.Env; const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
const StorageLocation *FooLoc = const StorageLocation *FooLoc =
Env1.getStorageLocation(*FooDecl, SkipPast::None); Env1.getStorageLocation(*FooDecl, SkipPast::None);
EXPECT_THAT(FooLoc, NotNull()); EXPECT_THAT(FooLoc, NotNull());
EXPECT_THAT(Env1.getStorageLocation(*BarDecl, SkipPast::None), IsNull()); EXPECT_THAT(Env1.getStorageLocation(*BarDecl, SkipPast::None), IsNull());
EXPECT_THAT(Env1.getStorageLocation(*BazDecl, SkipPast::None), IsNull()); EXPECT_THAT(Env1.getStorageLocation(*BazDecl, SkipPast::None), IsNull());
const Environment &Env2 = Results[1].second.Env; const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
EXPECT_EQ(Env2.getStorageLocation(*FooDecl, SkipPast::None), FooLoc); EXPECT_EQ(Env2.getStorageLocation(*FooDecl, SkipPast::None), FooLoc);
EXPECT_THAT(Env2.getStorageLocation(*BarDecl, SkipPast::None), NotNull()); EXPECT_THAT(Env2.getStorageLocation(*BarDecl, SkipPast::None), NotNull());
EXPECT_THAT(Env2.getStorageLocation(*BazDecl, SkipPast::None), IsNull()); EXPECT_THAT(Env2.getStorageLocation(*BazDecl, SkipPast::None), IsNull());
const Environment &Env3 = Results[2].second.Env; const Environment &Env3 = getEnvironmentAtAnnotation(Results, "p3");
EXPECT_EQ(Env3.getStorageLocation(*FooDecl, SkipPast::None), FooLoc); EXPECT_EQ(Env3.getStorageLocation(*FooDecl, SkipPast::None), FooLoc);
EXPECT_THAT(Env3.getStorageLocation(*BarDecl, SkipPast::None), IsNull()); EXPECT_THAT(Env3.getStorageLocation(*BarDecl, SkipPast::None), IsNull());
EXPECT_THAT(Env3.getStorageLocation(*BazDecl, SkipPast::None), NotNull()); EXPECT_THAT(Env3.getStorageLocation(*BazDecl, SkipPast::None), NotNull());
const Environment &Env4 = Results[3].second.Env; const Environment &Env4 = getEnvironmentAtAnnotation(Results, "p4");
EXPECT_EQ(Env4.getStorageLocation(*FooDecl, SkipPast::None), FooLoc); EXPECT_EQ(Env4.getStorageLocation(*FooDecl, SkipPast::None), FooLoc);
EXPECT_THAT(Env4.getStorageLocation(*BarDecl, SkipPast::None), IsNull()); EXPECT_THAT(Env4.getStorageLocation(*BarDecl, SkipPast::None), IsNull());
EXPECT_THAT(Env4.getStorageLocation(*BazDecl, SkipPast::None), IsNull()); EXPECT_THAT(Env4.getStorageLocation(*BazDecl, SkipPast::None), IsNull());
}); });
} }
TEST(TransferTest, BinaryOperatorAssign) { TEST(TransferTest, BinaryOperatorAssign) {
std::string Code = R"( std::string Code = R"(
void target() { void target() {
int Foo; int Foo;
int Bar; int Bar;
(Bar) = (Foo); (Bar) = (Foo);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const Value *FooVal = Env.getValue(*FooDecl, SkipPast::None); const Value *FooVal = Env.getValue(*FooDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal)); ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
EXPECT_EQ(Env.getValue(*BarDecl, SkipPast::None), FooVal); EXPECT_EQ(Env.getValue(*BarDecl, SkipPast::None), FooVal);
}); });
} }
TEST(TransferTest, VarDeclInitAssign) { TEST(TransferTest, VarDeclInitAssign) {
std::string Code = R"( std::string Code = R"(
void target() { void target() {
int Foo; int Foo;
int Bar = Foo; int Bar = Foo;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const Value *FooVal = Env.getValue(*FooDecl, SkipPast::None); const Value *FooVal = Env.getValue(*FooDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal)); ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
EXPECT_EQ(Env.getValue(*BarDecl, SkipPast::None), FooVal); EXPECT_EQ(Env.getValue(*BarDecl, SkipPast::None), FooVal);
}); });
} }
TEST(TransferTest, VarDeclInitAssignChained) { TEST(TransferTest, VarDeclInitAssignChained) {
std::string Code = R"( std::string Code = R"(
void target() { void target() {
int Foo; int Foo;
int Bar; int Bar;
int Baz = (Bar = Foo); int Baz = (Bar = Foo);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const Value *FooVal = Env.getValue(*FooDecl, SkipPast::None); const Value *FooVal = Env.getValue(*FooDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal)); ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
EXPECT_EQ(Env.getValue(*BarDecl, SkipPast::None), FooVal); EXPECT_EQ(Env.getValue(*BarDecl, SkipPast::None), FooVal);
EXPECT_EQ(Env.getValue(*BazDecl, SkipPast::None), FooVal); EXPECT_EQ(Env.getValue(*BazDecl, SkipPast::None), FooVal);
}); });
} }
TEST(TransferTest, VarDeclInitAssignPtrDeref) { TEST(TransferTest, VarDeclInitAssignPtrDeref) {
std::string Code = R"( std::string Code = R"(
void target() { void target() {
int Foo; int Foo;
int *Bar; int *Bar;
*(Bar) = Foo; *(Bar) = Foo;
int Baz = *(Bar); int Baz = *(Bar);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const Value *FooVal = Env.getValue(*FooDecl, SkipPast::None); const Value *FooVal = Env.getValue(*FooDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal)); ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *BarVal = const auto *BarVal =
cast<PointerValue>(Env.getValue(*BarDecl, SkipPast::None)); cast<PointerValue>(Env.getValue(*BarDecl, SkipPast::None));
EXPECT_EQ(Env.getValue(BarVal->getPointeeLoc()), FooVal); EXPECT_EQ(Env.getValue(BarVal->getPointeeLoc()), FooVal);
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, SkipPast::None), FooVal); EXPECT_EQ(Env.getValue(*BazDecl, SkipPast::None), FooVal);
}); });
} }
TEST(TransferTest, AssignToAndFromReference) { TEST(TransferTest, AssignToAndFromReference) {
std::string Code = R"( std::string Code = R"(
void target() { void target() {
int Foo; int Foo;
int Bar; int Bar;
int &Baz = Foo; int &Baz = Foo;
// [[p1]] // [[p1]]
Baz = Bar; Baz = Bar;
int Qux = Baz; int Qux = Baz;
int &Quux = Baz; int &Quux = Baz;
// [[p2]] // [[p2]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results, ASTContext &ASTCtx) {
ASTContext &ASTCtx) { ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1", "p2"));
ASSERT_THAT(Results, ElementsAre(Pair("p1", _), Pair("p2", _))); const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
const Environment &Env1 = Results[0].second.Env; const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
const Environment &Env2 = Results[1].second.Env;
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const Value *FooVal = Env1.getValue(*FooDecl, SkipPast::None); const Value *FooVal = Env1.getValue(*FooDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal)); ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
Show All 22 Lines
TEST(TransferTest, MultipleParamDecls) { TEST(TransferTest, MultipleParamDecls) {
std::string Code = R"( std::string Code = R"(
void target(int Foo, int Bar) { void target(int Foo, int Bar) {
(void)0; (void)0;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const StorageLocation *FooLoc = const StorageLocation *FooLoc =
Env.getStorageLocation(*FooDecl, SkipPast::None); Env.getStorageLocation(*FooDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc)); ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc));
const Value *FooVal = Env.getValue(*FooLoc); const Value *FooVal = Env.getValue(*FooLoc);
ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal)); ASSERT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const StorageLocation *BarLoc = const StorageLocation *BarLoc =
Env.getStorageLocation(*BarDecl, SkipPast::None); Env.getStorageLocation(*BarDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(BarLoc)); ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(BarLoc));
const Value *BarVal = Env.getValue(*BarLoc); const Value *BarVal = Env.getValue(*BarLoc);
EXPECT_TRUE(isa_and_nonnull<IntegerValue>(BarVal)); EXPECT_TRUE(isa_and_nonnull<IntegerValue>(BarVal));
}); });
} }
TEST(TransferTest, StructParamDecl) { TEST(TransferTest, StructParamDecl) {
std::string Code = R"( std::string Code = R"(
struct A { struct A {
int Bar; int Bar;
}; };
void target(A Foo) { void target(A Foo) {
(void)0; (void)0;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
ASSERT_TRUE(FooDecl->getType()->isStructureType()); ASSERT_TRUE(FooDecl->getType()->isStructureType());
auto FooFields = FooDecl->getType()->getAsRecordDecl()->fields(); auto FooFields = FooDecl->getType()->getAsRecordDecl()->fields();
FieldDecl *BarDecl = nullptr; FieldDecl *BarDecl = nullptr;
Show All 22 Lines std::string Code = R"(
struct A {}; struct A {};
void target(A &Foo) { void target(A &Foo) {
(void)0; (void)0;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const StorageLocation *FooLoc = const StorageLocation *FooLoc =
Env.getStorageLocation(*FooDecl, SkipPast::None); Env.getStorageLocation(*FooDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc)); ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc));
Show All 14 Lines std::string Code = R"(
struct A {}; struct A {};
void target(A *Foo) { void target(A *Foo) {
(void)0; (void)0;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const StorageLocation *FooLoc = const StorageLocation *FooLoc =
Env.getStorageLocation(*FooDecl, SkipPast::None); Env.getStorageLocation(*FooDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc)); ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc));
Show All 13 Lines std::string Code = R"(
}; };
void target(A Foo) { void target(A Foo) {
int Baz = Foo.Bar; int Baz = Foo.Bar;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
ASSERT_TRUE(FooDecl->getType()->isStructureType()); ASSERT_TRUE(FooDecl->getType()->isStructureType());
auto FooFields = FooDecl->getType()->getAsRecordDecl()->fields(); auto FooFields = FooDecl->getType()->getAsRecordDecl()->fields();
FieldDecl *BarDecl = nullptr; FieldDecl *BarDecl = nullptr;
Show All 39 Lines std::string Code = R"(
}; };
void target() { void target() {
B Foo; B Foo;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
ASSERT_TRUE(FooDecl->getType()->isRecordType()); ASSERT_TRUE(FooDecl->getType()->isRecordType());
// Derived-class fields. // Derived-class fields.
const FieldDecl *BDefaultDecl = nullptr; const FieldDecl *BDefaultDecl = nullptr;
const FieldDecl *BProtectedDecl = nullptr; const FieldDecl *BProtectedDecl = nullptr;
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines runDataflow(
FooVal.getChild(*BProtectedDecl)); FooVal.getChild(*BProtectedDecl));
EXPECT_THAT(FooVal.getChild(*BPrivateDecl), NotNull()); EXPECT_THAT(FooVal.getChild(*BPrivateDecl), NotNull());
EXPECT_EQ(Env.getValue(FooLoc.getChild(*BPrivateDecl)), EXPECT_EQ(Env.getValue(FooLoc.getChild(*BPrivateDecl)),
FooVal.getChild(*BPrivateDecl)); FooVal.getChild(*BPrivateDecl));
}); });
} }
static void derivedBaseMemberExpectations( static void derivedBaseMemberExpectations(
llvm::ArrayRef<std::pair<std::string, DataflowAnalysisState<NoopLattice>>> const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
ASSERT_TRUE(FooDecl->getType()->isRecordType()); ASSERT_TRUE(FooDecl->getType()->isRecordType());
const FieldDecl *BarDecl = nullptr; const FieldDecl *BarDecl = nullptr;
for (const clang::CXXBaseSpecifier &Base : for (const clang::CXXBaseSpecifier &Base :
FooDecl->getType()->getAsCXXRecordDecl()->bases()) { FooDecl->getType()->getAsCXXRecordDecl()->bases()) {
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines std::string Code = R"(
}; };
void target(A Foo) { void target(A Foo) {
int Baz = Foo.Bar; int Baz = Foo.Bar;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
ASSERT_TRUE(FooDecl->getType()->isClassType()); ASSERT_TRUE(FooDecl->getType()->isClassType());
auto FooFields = FooDecl->getType()->getAsRecordDecl()->fields(); auto FooFields = FooDecl->getType()->getAsRecordDecl()->fields();
FieldDecl *BarDecl = nullptr; FieldDecl *BarDecl = nullptr;
Show All 34 Lines std::string Code = R"(
public: public:
B(int I) : A(I) { B(int I) : A(I) {
(void)0; (void)0;
// [[p]] // [[p]]
} }
}; };
)"; )";
ASSERT_THAT_ERROR( ASSERT_THAT_ERROR(
test::checkDataflow<NoopAnalysis>( checkDataflow<NoopAnalysis>(
AnalysisInputs<NoopAnalysis>(
Code, cxxConstructorDecl(ofClass(hasName("B"))), Code, cxxConstructorDecl(ofClass(hasName("B"))),
[](ASTContext &C, Environment &) { [](ASTContext &C, Environment &) {
return NoopAnalysis(C, /*ApplyBuiltinTransfer=*/true); return NoopAnalysis(C, /*ApplyBuiltinTransfer=*/true);
}, })
[](llvm::ArrayRef< .withASTBuildArgs(
std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
Results,
ASTContext &ASTCtx) {
// Regression test to verify that base-class initializers do not
// trigger an assertion. If we add support for such initializers in
// the future, we can expand this test to check more specific
// properties.
EXPECT_THAT(Results, ElementsAre(Pair("p", _)));
},
{"-fsyntax-only", "-fno-delayed-template-parsing", {"-fsyntax-only", "-fno-delayed-template-parsing",
"-std=" + std::string(LangStandard::getLangStandardForKind( "-std=" + std::string(LangStandard::getLangStandardForKind(
LangStandard::lang_cxx17) LangStandard::lang_cxx17)
.getName())}), .getName())}),
/*VerifyResults=*/
[](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
const AnalysisOutputs &) {
// Regression test to verify that base-class initializers do not
// trigger an assertion. If we add support for such initializers in
// the future, we can expand this test to check more specific
// properties.
EXPECT_THAT(Results.keys(), UnorderedElementsAre("p"));
}),
llvm::Succeeded()); llvm::Succeeded());
} }
TEST(TransferTest, ReferenceMember) { TEST(TransferTest, ReferenceMember) {
std::string Code = R"( std::string Code = R"(
struct A { struct A {
int &Bar; int &Bar;
}; };
void target(A Foo) { void target(A Foo) {
int Baz = Foo.Bar; int Baz = Foo.Bar;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
ASSERT_TRUE(FooDecl->getType()->isStructureType()); ASSERT_TRUE(FooDecl->getType()->isStructureType());
auto FooFields = FooDecl->getType()->getAsRecordDecl()->fields(); auto FooFields = FooDecl->getType()->getAsRecordDecl()->fields();
FieldDecl *BarDecl = nullptr; FieldDecl *BarDecl = nullptr;
Show All 34 Lines struct A {
void target() { void target() {
int Foo = Bar; int Foo = Bar;
int Quux = Qux.Baz; int Quux = Qux.Baz;
// [[p]] // [[p]]
} }
}; };
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const auto *ThisLoc = dyn_cast<AggregateStorageLocation>( const auto *ThisLoc = dyn_cast<AggregateStorageLocation>(
Env.getThisPointeeStorageLocation()); Env.getThisPointeeStorageLocation());
ASSERT_THAT(ThisLoc, NotNull()); ASSERT_THAT(ThisLoc, NotNull());
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines class A {
void target() { void target() {
int Foo = Bar; int Foo = Bar;
int Quux = Qux.Baz; int Quux = Qux.Baz;
// [[p]] // [[p]]
} }
}; };
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const auto *ThisLoc = const auto *ThisLoc =
cast<AggregateStorageLocation>(Env.getThisPointeeStorageLocation()); cast<AggregateStorageLocation>(Env.getThisPointeeStorageLocation());
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *BarLoc = const auto *BarLoc =
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines struct A {
}(); }();
} }
int Bar; int Bar;
}; };
)"; )";
runDataflow( runDataflow(
ThisCaptureCode, ThisCaptureCode,
[](llvm::ArrayRef< [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p1", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p1");
const auto *ThisLoc = dyn_cast<AggregateStorageLocation>( const auto *ThisLoc = dyn_cast<AggregateStorageLocation>(
Env.getThisPointeeStorageLocation()); Env.getThisPointeeStorageLocation());
ASSERT_THAT(ThisLoc, NotNull()); ASSERT_THAT(ThisLoc, NotNull());
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
Show All 19 Lines struct A {
}(); }();
} }
int Bar; int Bar;
}; };
)"; )";
runDataflow( runDataflow(
RefCaptureDefaultCode, RefCaptureDefaultCode,
[](llvm::ArrayRef< [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p2", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p2"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p2");
const auto *ThisLoc = dyn_cast<AggregateStorageLocation>( const auto *ThisLoc = dyn_cast<AggregateStorageLocation>(
Env.getThisPointeeStorageLocation()); Env.getThisPointeeStorageLocation());
ASSERT_THAT(ThisLoc, NotNull()); ASSERT_THAT(ThisLoc, NotNull());
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
Show All 16 Lines void foo() {
[&]() { [&]() {
int Foo = Bar; int Foo = Bar;
// [[p3]] // [[p3]]
}(); }();
} }
)"; )";
runDataflow( runDataflow(
FreeFunctionLambdaCode, FreeFunctionLambdaCode,
[](llvm::ArrayRef< [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p3", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p3"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p3");
EXPECT_THAT(Env.getThisPointeeStorageLocation(), IsNull()); EXPECT_THAT(Env.getThisPointeeStorageLocation(), IsNull());
}, },
LangStandard::lang_cxx17, /*ApplyBuiltinTransfer=*/true, "operator()"); LangStandard::lang_cxx17, /*ApplyBuiltinTransfer=*/true, "operator()");
} }
TEST(TransferTest, ConstructorInitializer) { TEST(TransferTest, ConstructorInitializer) {
std::string Code = R"( std::string Code = R"(
struct target { struct target {
int Bar; int Bar;
target(int Foo) : Bar(Foo) { target(int Foo) : Bar(Foo) {
int Qux = Bar; int Qux = Bar;
// [[p]] // [[p]]
} }
}; };
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const auto *ThisLoc = dyn_cast<AggregateStorageLocation>( const auto *ThisLoc = dyn_cast<AggregateStorageLocation>(
Env.getThisPointeeStorageLocation()); Env.getThisPointeeStorageLocation());
ASSERT_THAT(ThisLoc, NotNull()); ASSERT_THAT(ThisLoc, NotNull());
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const auto *FooVal = const auto *FooVal =
cast<IntegerValue>(Env.getValue(*FooDecl, SkipPast::None)); cast<IntegerValue>(Env.getValue(*FooDecl, SkipPast::None));
const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux"); const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux");
ASSERT_THAT(QuxDecl, NotNull()); ASSERT_THAT(QuxDecl, NotNull());
EXPECT_EQ(Env.getValue(*QuxDecl, SkipPast::None), FooVal); EXPECT_EQ(Env.getValue(*QuxDecl, SkipPast::None), FooVal);
}); });
} }
TEST(TransferTest, DefaultInitializer) { TEST(TransferTest, DefaultInitializer) {
std::string Code = R"( std::string Code = R"(
struct target { struct target {
int Bar; int Bar;
int Baz = Bar; int Baz = Bar;
target(int Foo) : Bar(Foo) { target(int Foo) : Bar(Foo) {
int Qux = Baz; int Qux = Baz;
// [[p]] // [[p]]
} }
}; };
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const auto *ThisLoc = dyn_cast<AggregateStorageLocation>( const auto *ThisLoc = dyn_cast<AggregateStorageLocation>(
Env.getThisPointeeStorageLocation()); Env.getThisPointeeStorageLocation());
ASSERT_THAT(ThisLoc, NotNull()); ASSERT_THAT(ThisLoc, NotNull());
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const auto *FooVal = const auto *FooVal =
cast<IntegerValue>(Env.getValue(*FooDecl, SkipPast::None)); cast<IntegerValue>(Env.getValue(*FooDecl, SkipPast::None));
const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux"); const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux");
ASSERT_THAT(QuxDecl, NotNull()); ASSERT_THAT(QuxDecl, NotNull());
EXPECT_EQ(Env.getValue(*QuxDecl, SkipPast::None), FooVal); EXPECT_EQ(Env.getValue(*QuxDecl, SkipPast::None), FooVal);
}); });
} }
TEST(TransferTest, DefaultInitializerReference) { TEST(TransferTest, DefaultInitializerReference) {
std::string Code = R"( std::string Code = R"(
struct target { struct target {
int &Bar; int &Bar;
int &Baz = Bar; int &Baz = Bar;
target(int &Foo) : Bar(Foo) { target(int &Foo) : Bar(Foo) {
int &Qux = Baz; int &Qux = Baz;
// [[p]] // [[p]]
} }
}; };
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const auto *ThisLoc = dyn_cast<AggregateStorageLocation>( const auto *ThisLoc = dyn_cast<AggregateStorageLocation>(
Env.getThisPointeeStorageLocation()); Env.getThisPointeeStorageLocation());
ASSERT_THAT(ThisLoc, NotNull()); ASSERT_THAT(ThisLoc, NotNull());
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
Show All 16 Lines std::string Code = R"(
}; };
void target() { void target() {
A Foo = A(); A Foo = A();
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 = cast<AggregateStorageLocation>( const auto *FooLoc = cast<AggregateStorageLocation>(
Show All 17 Lines std::string Code = R"(
void target() { void target() {
A Foo = A(); A Foo = A();
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, Code,
[](llvm::ArrayRef< [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 = cast<AggregateStorageLocation>( const auto *FooLoc = cast<AggregateStorageLocation>(
Show All 18 Lines void target() {
A Foo; A Foo;
A Bar; A Bar;
// [[p1]] // [[p1]]
Foo = Bar; Foo = Bar;
// [[p2]] // [[p2]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results, ASTContext &ASTCtx) {
ASTContext &ASTCtx) { ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1", "p2"));
ASSERT_THAT(Results, ElementsAre(Pair("p1", _), Pair("p2", _))); const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
const Environment &Env1 = Results[0].second.Env; const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
const Environment &Env2 = Results[1].second.Env;
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 ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
Show All 39 Lines std::string Code = R"(
void target() { void target() {
A Foo; A Foo;
A Bar = Foo; A Bar = Foo;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
Show All 24 Lines std::string Code = R"(
void target() { void target() {
A Foo; A Foo;
A Bar((A(Foo))); A Bar((A(Foo)));
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
Show All 40 Lines void target() {
A Foo; A Foo;
A Bar; A Bar;
// [[p1]] // [[p1]]
Foo = std::move(Bar); Foo = std::move(Bar);
// [[p2]] // [[p2]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results, ASTContext &ASTCtx) {
ASTContext &ASTCtx) { ASSERT_THAT(Results.keys(), UnorderedElementsAre("p1", "p2"));
ASSERT_THAT(Results, ElementsAre(Pair("p1", _), Pair("p2", _))); const Environment &Env1 = getEnvironmentAtAnnotation(Results, "p1");
const Environment &Env1 = Results[0].second.Env; const Environment &Env2 = getEnvironmentAtAnnotation(Results, "p2");
const Environment &Env2 = Results[1].second.Env;
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 ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
Show All 33 Lines struct A {
int Baz; int Baz;
}; };
void target(A Foo) { void target(A Foo) {
int Bar = A(Foo).Baz; int Bar = A(Foo).Baz;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
const auto &FooVal = const auto &FooVal =
*cast<StructValue>(Env.getValue(*FooDecl, SkipPast::None)); *cast<StructValue>(Env.getValue(*FooDecl, SkipPast::None));
const auto *BarVal = const auto *BarVal =
cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None)); cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None));
EXPECT_EQ(BarVal, FooVal.getChild(*BazDecl)); EXPECT_EQ(BarVal, FooVal.getChild(*BazDecl));
}); });
} }
TEST(TransferTest, StaticCast) { TEST(TransferTest, StaticCast) {
std::string Code = R"( std::string Code = R"(
void target(int Foo) { void target(int Foo) {
int Bar = static_cast<int>(Foo); int Bar = static_cast<int>(Foo);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 *FooVal = Env.getValue(*FooDecl, SkipPast::None); const auto *FooVal = Env.getValue(*FooDecl, SkipPast::None);
const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None); const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None);
EXPECT_TRUE(isa<IntegerValue>(FooVal)); EXPECT_TRUE(isa<IntegerValue>(FooVal));
EXPECT_TRUE(isa<IntegerValue>(BarVal)); EXPECT_TRUE(isa<IntegerValue>(BarVal));
EXPECT_EQ(FooVal, BarVal); EXPECT_EQ(FooVal, BarVal);
}); });
} }
TEST(TransferTest, IntegralCast) { TEST(TransferTest, IntegralCast) {
std::string Code = R"( std::string Code = R"(
void target(int Foo) { void target(int Foo) {
long Bar = Foo; long Bar = Foo;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 *FooVal = Env.getValue(*FooDecl, SkipPast::None); const auto *FooVal = Env.getValue(*FooDecl, SkipPast::None);
const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None); const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None);
EXPECT_TRUE(isa<IntegerValue>(FooVal)); EXPECT_TRUE(isa<IntegerValue>(FooVal));
EXPECT_TRUE(isa<IntegerValue>(BarVal)); EXPECT_TRUE(isa<IntegerValue>(BarVal));
EXPECT_EQ(FooVal, BarVal); EXPECT_EQ(FooVal, BarVal);
}); });
} }
TEST(TransferTest, IntegraltoBooleanCast) { TEST(TransferTest, IntegraltoBooleanCast) {
std::string Code = R"( std::string Code = R"(
void target(int Foo) { void target(int Foo) {
bool Bar = Foo; bool Bar = Foo;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 *FooVal = Env.getValue(*FooDecl, SkipPast::None); const auto *FooVal = Env.getValue(*FooDecl, SkipPast::None);
const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None); const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None);
EXPECT_TRUE(isa<IntegerValue>(FooVal)); EXPECT_TRUE(isa<IntegerValue>(FooVal));
EXPECT_TRUE(isa<BoolValue>(BarVal)); EXPECT_TRUE(isa<BoolValue>(BarVal));
}); });
} }
TEST(TransferTest, IntegralToBooleanCastFromBool) { TEST(TransferTest, IntegralToBooleanCastFromBool) {
std::string Code = R"( std::string Code = R"(
void target(bool Foo) { void target(bool Foo) {
int Zab = Foo; int Zab = Foo;
bool Bar = Zab; bool Bar = Zab;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 *FooVal = Env.getValue(*FooDecl, SkipPast::None); const auto *FooVal = Env.getValue(*FooDecl, SkipPast::None);
const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None); const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None);
EXPECT_TRUE(isa<BoolValue>(FooVal)); EXPECT_TRUE(isa<BoolValue>(FooVal));
EXPECT_TRUE(isa<BoolValue>(BarVal)); EXPECT_TRUE(isa<BoolValue>(BarVal));
EXPECT_EQ(FooVal, BarVal); EXPECT_EQ(FooVal, BarVal);
}); });
} }
TEST(TransferTest, NullToPointerCast) { TEST(TransferTest, NullToPointerCast) {
std::string Code = R"( std::string Code = R"(
using my_nullptr_t = decltype(nullptr); using my_nullptr_t = decltype(nullptr);
struct Baz {}; struct Baz {};
void target() { void target() {
int *FooX = nullptr; int *FooX = nullptr;
int *FooY = nullptr; int *FooY = nullptr;
bool **Bar = nullptr; bool **Bar = nullptr;
Baz *Baz = nullptr; Baz *Baz = nullptr;
my_nullptr_t Null = 0; my_nullptr_t Null = 0;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooXDecl = findValueDecl(ASTCtx, "FooX"); const ValueDecl *FooXDecl = findValueDecl(ASTCtx, "FooX");
ASSERT_THAT(FooXDecl, NotNull()); ASSERT_THAT(FooXDecl, NotNull());
const ValueDecl *FooYDecl = findValueDecl(ASTCtx, "FooY"); const ValueDecl *FooYDecl = findValueDecl(ASTCtx, "FooY");
ASSERT_THAT(FooYDecl, NotNull()); ASSERT_THAT(FooYDecl, NotNull());
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
const ValueDecl *NullDecl = findValueDecl(ASTCtx, "Null"); const ValueDecl *NullDecl = findValueDecl(ASTCtx, "Null");
ASSERT_THAT(NullDecl, NotNull()); ASSERT_THAT(NullDecl, NotNull());
const auto *FooXVal = const auto *FooXVal =
cast<PointerValue>(Env.getValue(*FooXDecl, SkipPast::None)); cast<PointerValue>(Env.getValue(*FooXDecl, SkipPast::None));
const auto *FooYVal = const auto *FooYVal =
cast<PointerValue>(Env.getValue(*FooYDecl, SkipPast::None)); cast<PointerValue>(Env.getValue(*FooYDecl, SkipPast::None));
const auto *BarVal = const auto *BarVal =
cast<PointerValue>(Env.getValue(*BarDecl, SkipPast::None)); cast<PointerValue>(Env.getValue(*BarDecl, SkipPast::None));
const auto *BazVal = const auto *BazVal =
cast<PointerValue>(Env.getValue(*BazDecl, SkipPast::None)); cast<PointerValue>(Env.getValue(*BazDecl, SkipPast::None));
const auto *NullVal = const auto *NullVal =
cast<PointerValue>(Env.getValue(*NullDecl, SkipPast::None)); cast<PointerValue>(Env.getValue(*NullDecl, SkipPast::None));
EXPECT_EQ(FooXVal, FooYVal); EXPECT_EQ(FooXVal, FooYVal);
EXPECT_NE(FooXVal, BarVal); EXPECT_NE(FooXVal, BarVal);
EXPECT_NE(FooXVal, BazVal); EXPECT_NE(FooXVal, BazVal);
EXPECT_NE(BarVal, BazVal); EXPECT_NE(BarVal, BazVal);
const StorageLocation &FooPointeeLoc = FooXVal->getPointeeLoc(); const StorageLocation &FooPointeeLoc = FooXVal->getPointeeLoc();
EXPECT_TRUE(isa<ScalarStorageLocation>(FooPointeeLoc)); EXPECT_TRUE(isa<ScalarStorageLocation>(FooPointeeLoc));
EXPECT_THAT(Env.getValue(FooPointeeLoc), IsNull()); EXPECT_THAT(Env.getValue(FooPointeeLoc), IsNull());
const StorageLocation &BarPointeeLoc = BarVal->getPointeeLoc(); const StorageLocation &BarPointeeLoc = BarVal->getPointeeLoc();
EXPECT_TRUE(isa<ScalarStorageLocation>(BarPointeeLoc)); EXPECT_TRUE(isa<ScalarStorageLocation>(BarPointeeLoc));
EXPECT_THAT(Env.getValue(BarPointeeLoc), IsNull()); EXPECT_THAT(Env.getValue(BarPointeeLoc), IsNull());
const StorageLocation &BazPointeeLoc = BazVal->getPointeeLoc(); const StorageLocation &BazPointeeLoc = BazVal->getPointeeLoc();
EXPECT_TRUE(isa<AggregateStorageLocation>(BazPointeeLoc)); EXPECT_TRUE(isa<AggregateStorageLocation>(BazPointeeLoc));
EXPECT_THAT(Env.getValue(BazPointeeLoc), IsNull()); EXPECT_THAT(Env.getValue(BazPointeeLoc), IsNull());
const StorageLocation &NullPointeeLoc = const StorageLocation &NullPointeeLoc = NullVal->getPointeeLoc();
NullVal->getPointeeLoc();
EXPECT_TRUE(isa<ScalarStorageLocation>(NullPointeeLoc)); EXPECT_TRUE(isa<ScalarStorageLocation>(NullPointeeLoc));
EXPECT_THAT(Env.getValue(NullPointeeLoc), IsNull()); EXPECT_THAT(Env.getValue(NullPointeeLoc), IsNull());
}); });
} }
TEST(TransferTest, NullToMemberPointerCast) { TEST(TransferTest, NullToMemberPointerCast) {
std::string Code = R"( std::string Code = R"(
struct Foo {}; struct Foo {};
void target(Foo *Foo) { void target(Foo *Foo) {
int Foo::*MemberPointer = nullptr; int Foo::*MemberPointer = nullptr;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *MemberPointerDecl = const ValueDecl *MemberPointerDecl =
findValueDecl(ASTCtx, "MemberPointer"); findValueDecl(ASTCtx, "MemberPointer");
ASSERT_THAT(MemberPointerDecl, NotNull()); ASSERT_THAT(MemberPointerDecl, NotNull());
const auto *MemberPointerVal = cast<PointerValue>( const auto *MemberPointerVal = cast<PointerValue>(
Env.getValue(*MemberPointerDecl, SkipPast::None)); Env.getValue(*MemberPointerDecl, SkipPast::None));
const StorageLocation &MemberLoc = MemberPointerVal->getPointeeLoc(); const StorageLocation &MemberLoc = MemberPointerVal->getPointeeLoc();
EXPECT_THAT(Env.getValue(MemberLoc), IsNull()); EXPECT_THAT(Env.getValue(MemberLoc), IsNull());
}); });
} }
TEST(TransferTest, AddrOfValue) { TEST(TransferTest, AddrOfValue) {
std::string Code = R"( std::string Code = R"(
void target() { void target() {
int Foo; int Foo;
int *Bar = &Foo; int *Bar = &Foo;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 = cast<ScalarStorageLocation>( const auto *FooLoc = cast<ScalarStorageLocation>(
Env.getStorageLocation(*FooDecl, SkipPast::None)); Env.getStorageLocation(*FooDecl, SkipPast::None));
const auto *BarVal = const auto *BarVal =
cast<PointerValue>(Env.getValue(*BarDecl, SkipPast::None)); cast<PointerValue>(Env.getValue(*BarDecl, SkipPast::None));
EXPECT_EQ(&BarVal->getPointeeLoc(), FooLoc); EXPECT_EQ(&BarVal->getPointeeLoc(), FooLoc);
}); });
} }
TEST(TransferTest, AddrOfReference) { TEST(TransferTest, AddrOfReference) {
std::string Code = R"( std::string Code = R"(
void target(int *Foo) { void target(int *Foo) {
int *Bar = &(*Foo); int *Bar = &(*Foo);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 *FooVal = const auto *FooVal =
cast<PointerValue>(Env.getValue(*FooDecl, SkipPast::None)); cast<PointerValue>(Env.getValue(*FooDecl, SkipPast::None));
const auto *BarVal = const auto *BarVal =
cast<PointerValue>(Env.getValue(*BarDecl, SkipPast::None)); cast<PointerValue>(Env.getValue(*BarDecl, SkipPast::None));
EXPECT_EQ(&BarVal->getPointeeLoc(), &FooVal->getPointeeLoc()); EXPECT_EQ(&BarVal->getPointeeLoc(), &FooVal->getPointeeLoc());
}); });
} }
TEST(TransferTest, DerefDependentPtr) { TEST(TransferTest, DerefDependentPtr) {
std::string Code = R"( std::string Code = R"(
template <typename T> template <typename T>
void target(T *Foo) { void target(T *Foo) {
T &Bar = *Foo; T &Bar = *Foo;
/*[[p]]*/ /*[[p]]*/
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 *FooVal = const auto *FooVal =
Show All 9 Lines std::string Code = R"(
struct A {}; struct A {};
void target(A Foo, A Bar, bool Cond) { void target(A Foo, A Bar, bool Cond) {
A Baz = Cond ? Foo : Bar; A Baz = Cond ? Foo : Bar;
/*[[p]]*/ /*[[p]]*/
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
Show All 18 Lines std::string Code = R"(
void target(int *Foo) { void target(int *Foo) {
do { do {
int Bar = *Foo; int Bar = *Foo;
} while (true); } while (true);
(void)0; (void)0;
/*[[p]]*/ /*[[p]]*/
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 *FooVal = const auto *FooVal =
cast<PointerValue>(Env.getValue(*FooDecl, SkipPast::None)); cast<PointerValue>(Env.getValue(*FooDecl, SkipPast::None));
const auto *FooPointeeVal = const auto *FooPointeeVal =
cast<IntegerValue>(Env.getValue(FooVal->getPointeeLoc())); cast<IntegerValue>(Env.getValue(FooVal->getPointeeLoc()));
const auto *BarVal = dyn_cast_or_null<IntegerValue>( const auto *BarVal = dyn_cast_or_null<IntegerValue>(
Env.getValue(*BarDecl, SkipPast::None)); Env.getValue(*BarDecl, SkipPast::None));
ASSERT_THAT(BarVal, NotNull()); ASSERT_THAT(BarVal, NotNull());
EXPECT_EQ(BarVal, FooPointeeVal); EXPECT_EQ(BarVal, FooPointeeVal);
}); });
} }
TEST(TransferTest, AggregateInitialization) { TEST(TransferTest, AggregateInitialization) {
std::string BracesCode = R"( std::string BracesCode = R"(
struct A { struct A {
int Foo; int Foo;
}; };
Show All 21 Lines std::string BraceEllisionCode = R"(
void target(int BarArg, int FooArg, int QuxArg) { void target(int BarArg, int FooArg, int QuxArg) {
B Quux = {BarArg, FooArg, QuxArg}; B Quux = {BarArg, FooArg, QuxArg};
/*[[p]]*/ /*[[p]]*/
} }
)"; )";
for (const std::string &Code : {BracesCode, BraceEllisionCode}) { for (const std::string &Code : {BracesCode, BraceEllisionCode}) {
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines std::string Code = R"(
}; };
void target(int Bar) { void target(int Bar) {
A Baz; A Baz;
Baz.Foo = Bar; Baz.Foo = Bar;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
ASSERT_TRUE(BazDecl->getType()->isUnionType()); ASSERT_TRUE(BazDecl->getType()->isUnionType());
const auto *BazLoc = dyn_cast_or_null<AggregateStorageLocation>( const auto *BazLoc = dyn_cast_or_null<AggregateStorageLocation>(
Env.getStorageLocation(*BazDecl, SkipPast::None)); Env.getStorageLocation(*BazDecl, SkipPast::None));
ASSERT_THAT(BazLoc, NotNull()); ASSERT_THAT(BazLoc, NotNull());
// FIXME: Add support for union types. // FIXME: Add support for union types.
EXPECT_THAT(Env.getValue(*BazLoc), IsNull()); EXPECT_THAT(Env.getValue(*BazLoc), IsNull());
}); });
} }
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;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const auto *FooVal = dyn_cast_or_null<AtomicBoolValue>( const auto *FooVal = dyn_cast_or_null<AtomicBoolValue>(
Env.getValue(*FooDecl, SkipPast::None)); Env.getValue(*FooDecl, SkipPast::None));
ASSERT_THAT(FooVal, NotNull()); ASSERT_THAT(FooVal, NotNull());
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *BarVal = dyn_cast_or_null<AtomicBoolValue>( const auto *BarVal = dyn_cast_or_null<AtomicBoolValue>(
Env.getValue(*BarDecl, SkipPast::None)); Env.getValue(*BarDecl, SkipPast::None));
ASSERT_THAT(BarVal, NotNull()); ASSERT_THAT(BarVal, NotNull());
EXPECT_EQ(FooVal, &Env.getBoolLiteralValue(true)); EXPECT_EQ(FooVal, &Env.getBoolLiteralValue(true));
EXPECT_EQ(BarVal, &Env.getBoolLiteralValue(false)); EXPECT_EQ(BarVal, &Env.getBoolLiteralValue(false));
}); });
} }
TEST(TransferTest, AssignFromCompositeBoolExpression) { TEST(TransferTest, AssignFromCompositeBoolExpression) {
{ {
std::string Code = R"( std::string Code = R"(
void target(bool Foo, bool Bar, bool Qux) { void target(bool Foo, bool Bar, bool Qux) {
bool Baz = (Foo) && (Bar || Qux); bool Baz = (Foo) && (Bar || Qux);
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const auto *FooVal = dyn_cast_or_null<BoolValue>( const auto *FooVal = dyn_cast_or_null<BoolValue>(
Env.getValue(*FooDecl, SkipPast::None)); Env.getValue(*FooDecl, SkipPast::None));
ASSERT_THAT(FooVal, NotNull()); ASSERT_THAT(FooVal, NotNull());
Show All 29 LinesTEST(TransferTest, AssignFromCompositeBoolExpression) {
{ {
std::string Code = R"( std::string Code = R"(
void target(bool Foo, bool Bar, bool Qux) { void target(bool Foo, bool Bar, bool Qux) {
bool Baz = (Foo && Qux) || (Bar); bool Baz = (Foo && Qux) || (Bar);
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const auto *FooVal = dyn_cast_or_null<BoolValue>( const auto *FooVal = dyn_cast_or_null<BoolValue>(
Env.getValue(*FooDecl, SkipPast::None)); Env.getValue(*FooDecl, SkipPast::None));
ASSERT_THAT(FooVal, NotNull()); ASSERT_THAT(FooVal, NotNull());
Show All 30 LinesTEST(TransferTest, AssignFromCompositeBoolExpression) {
{ {
std::string Code = R"( std::string Code = R"(
void target(bool A, bool B, bool C, bool D) { void target(bool A, bool B, bool C, bool D) {
bool Foo = ((A && B) && C) && D; bool Foo = ((A && B) && C) && D;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *ADecl = findValueDecl(ASTCtx, "A"); const ValueDecl *ADecl = findValueDecl(ASTCtx, "A");
ASSERT_THAT(ADecl, NotNull()); ASSERT_THAT(ADecl, NotNull());
const auto *AVal = const auto *AVal =
dyn_cast_or_null<BoolValue>(Env.getValue(*ADecl, SkipPast::None)); dyn_cast_or_null<BoolValue>(Env.getValue(*ADecl, SkipPast::None));
ASSERT_THAT(AVal, NotNull()); ASSERT_THAT(AVal, NotNull());
Show All 40 Lines
TEST(TransferTest, AssignFromBoolNegation) { TEST(TransferTest, AssignFromBoolNegation) {
std::string Code = R"( std::string Code = R"(
void target() { void target() {
bool Foo = true; bool Foo = true;
bool Bar = !(Foo); bool Bar = !(Foo);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const auto *FooVal = dyn_cast_or_null<AtomicBoolValue>( const auto *FooVal = dyn_cast_or_null<AtomicBoolValue>(
Env.getValue(*FooDecl, SkipPast::None)); Env.getValue(*FooDecl, SkipPast::None));
ASSERT_THAT(FooVal, NotNull()); ASSERT_THAT(FooVal, NotNull());
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const auto *BarVal = dyn_cast_or_null<NegationValue>( const auto *BarVal = dyn_cast_or_null<NegationValue>(
Env.getValue(*BarDecl, SkipPast::None)); Env.getValue(*BarDecl, SkipPast::None));
ASSERT_THAT(BarVal, NotNull()); ASSERT_THAT(BarVal, NotNull());
EXPECT_EQ(&BarVal->getSubVal(), FooVal); EXPECT_EQ(&BarVal->getSubVal(), FooVal);
}); });
} }
TEST(TransferTest, BuiltinExpect) { TEST(TransferTest, BuiltinExpect) {
std::string Code = R"( std::string Code = R"(
void target(long Foo) { void target(long Foo) {
long Bar = __builtin_expect(Foo, true); long Bar = __builtin_expect(Foo, true);
/*[[p]]*/ /*[[p]]*/
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const auto &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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());
EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None), EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None),
Env.getValue(*BarDecl, SkipPast::None)); Env.getValue(*BarDecl, SkipPast::None));
}); });
} }
// `__builtin_expect` takes and returns a `long` argument, so other types // `__builtin_expect` takes and returns a `long` argument, so other types
// involve casts. This verifies that we identify the input and output in that // involve casts. This verifies that we identify the input and output in that
// case. // case.
TEST(TransferTest, BuiltinExpectBoolArg) { TEST(TransferTest, BuiltinExpectBoolArg) {
std::string Code = R"( std::string Code = R"(
void target(bool Foo) { void target(bool Foo) {
bool Bar = __builtin_expect(Foo, true); bool Bar = __builtin_expect(Foo, true);
/*[[p]]*/ /*[[p]]*/
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const auto &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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());
EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None), EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None),
Env.getValue(*BarDecl, SkipPast::None)); Env.getValue(*BarDecl, SkipPast::None));
}); });
} }
TEST(TransferTest, BuiltinUnreachable) { TEST(TransferTest, BuiltinUnreachable) {
std::string Code = R"( std::string Code = R"(
void target(bool Foo) { void target(bool Foo) {
bool Bar = false; bool Bar = false;
if (Foo) if (Foo)
Bar = Foo; Bar = Foo;
else else
__builtin_unreachable(); __builtin_unreachable();
(void)0; (void)0;
/*[[p]]*/ /*[[p]]*/
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const auto &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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());
// `__builtin_unreachable` promises that the code is // `__builtin_unreachable` promises that the code is
// unreachable, so the compiler treats the "then" branch as the // unreachable, so the compiler treats the "then" branch as the
// only possible predecessor of this statement. // only possible predecessor of this statement.
EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None), EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None),
Env.getValue(*BarDecl, SkipPast::None)); Env.getValue(*BarDecl, SkipPast::None));
}); });
} }
TEST(TransferTest, BuiltinTrap) { TEST(TransferTest, BuiltinTrap) {
std::string Code = R"( std::string Code = R"(
void target(bool Foo) { void target(bool Foo) {
bool Bar = false; bool Bar = false;
if (Foo) if (Foo)
Bar = Foo; Bar = Foo;
else else
__builtin_trap(); __builtin_trap();
(void)0; (void)0;
/*[[p]]*/ /*[[p]]*/
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const auto &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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());
// `__builtin_trap` ensures program termination, so only the // `__builtin_trap` ensures program termination, so only the
// "then" branch is a predecessor of this statement. // "then" branch is a predecessor of this statement.
EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None), EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None),
Env.getValue(*BarDecl, SkipPast::None)); Env.getValue(*BarDecl, SkipPast::None));
}); });
} }
TEST(TransferTest, BuiltinDebugTrap) { TEST(TransferTest, BuiltinDebugTrap) {
std::string Code = R"( std::string Code = R"(
void target(bool Foo) { void target(bool Foo) {
bool Bar = false; bool Bar = false;
if (Foo) if (Foo)
Bar = Foo; Bar = Foo;
else else
__builtin_debugtrap(); __builtin_debugtrap();
(void)0; (void)0;
/*[[p]]*/ /*[[p]]*/
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const auto &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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());
// `__builtin_debugtrap` doesn't ensure program termination. // `__builtin_debugtrap` doesn't ensure program termination.
EXPECT_NE(Env.getValue(*FooDecl, SkipPast::None), EXPECT_NE(Env.getValue(*FooDecl, SkipPast::None),
Env.getValue(*BarDecl, SkipPast::None)); Env.getValue(*BarDecl, SkipPast::None));
}); });
} }
TEST(TransferTest, StaticIntSingleVarDecl) { TEST(TransferTest, StaticIntSingleVarDecl) {
std::string Code = R"( std::string Code = R"(
void target() { void target() {
static int Foo; static int Foo;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
const StorageLocation *FooLoc = const StorageLocation *FooLoc =
Env.getStorageLocation(*FooDecl, SkipPast::None); Env.getStorageLocation(*FooDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc)); ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc));
const Value *FooVal = Env.getValue(*FooLoc); const Value *FooVal = Env.getValue(*FooLoc);
EXPECT_TRUE(isa_and_nonnull<IntegerValue>(FooVal)); EXPECT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
}); });
} }
TEST(TransferTest, StaticIntGroupVarDecl) { TEST(TransferTest, StaticIntGroupVarDecl) {
std::string Code = R"( std::string Code = R"(
void target() { void target() {
static int Foo, Bar; static int Foo, Bar;
(void)0; (void)0;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 StorageLocation *FooLoc = const StorageLocation *FooLoc =
Env.getStorageLocation(*FooDecl, SkipPast::None); Env.getStorageLocation(*FooDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc)); ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc));
const StorageLocation *BarLoc = const StorageLocation *BarLoc =
Env.getStorageLocation(*BarDecl, SkipPast::None); Env.getStorageLocation(*BarDecl, SkipPast::None);
ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(BarLoc)); ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(BarLoc));
const Value *FooVal = Env.getValue(*FooLoc); const Value *FooVal = Env.getValue(*FooLoc);
EXPECT_TRUE(isa_and_nonnull<IntegerValue>(FooVal)); EXPECT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
const Value *BarVal = Env.getValue(*BarLoc); const Value *BarVal = Env.getValue(*BarLoc);
EXPECT_TRUE(isa_and_nonnull<IntegerValue>(BarVal)); EXPECT_TRUE(isa_and_nonnull<IntegerValue>(BarVal));
EXPECT_NE(FooVal, BarVal); EXPECT_NE(FooVal, BarVal);
}); });
} }
TEST(TransferTest, GlobalIntVarDecl) { TEST(TransferTest, GlobalIntVarDecl) {
std::string Code = R"( std::string Code = R"(
static int Foo; static int Foo;
void target() { void target() {
int Bar = Foo; int Bar = Foo;
int Baz = Foo; int Baz = Foo;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
const Value *BarVal = const Value *BarVal =
cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None)); cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None));
const Value *BazVal = const Value *BazVal =
cast<IntegerValue>(Env.getValue(*BazDecl, SkipPast::None)); cast<IntegerValue>(Env.getValue(*BazDecl, SkipPast::None));
EXPECT_EQ(BarVal, BazVal); EXPECT_EQ(BarVal, BazVal);
}); });
} }
TEST(TransferTest, StaticMemberIntVarDecl) { TEST(TransferTest, StaticMemberIntVarDecl) {
std::string Code = R"( std::string Code = R"(
struct A { struct A {
static int Foo; static int Foo;
}; };
void target(A a) { void target(A a) {
int Bar = a.Foo; int Bar = a.Foo;
int Baz = a.Foo; int Baz = a.Foo;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
const Value *BarVal = const Value *BarVal =
cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None)); cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None));
const Value *BazVal = const Value *BazVal =
cast<IntegerValue>(Env.getValue(*BazDecl, SkipPast::None)); cast<IntegerValue>(Env.getValue(*BazDecl, SkipPast::None));
EXPECT_EQ(BarVal, BazVal); EXPECT_EQ(BarVal, BazVal);
}); });
} }
TEST(TransferTest, StaticMemberRefVarDecl) { TEST(TransferTest, StaticMemberRefVarDecl) {
std::string Code = R"( std::string Code = R"(
struct A { struct A {
static int &Foo; static int &Foo;
}; };
void target(A a) { void target(A a) {
int Bar = a.Foo; int Bar = a.Foo;
int Baz = a.Foo; int Baz = a.Foo;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
const Value *BarVal = const Value *BarVal =
cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None)); cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None));
const Value *BazVal = const Value *BazVal =
cast<IntegerValue>(Env.getValue(*BazDecl, SkipPast::None)); cast<IntegerValue>(Env.getValue(*BazDecl, SkipPast::None));
EXPECT_EQ(BarVal, BazVal); EXPECT_EQ(BarVal, BazVal);
}); });
} }
TEST(TransferTest, AssignMemberBeforeCopy) { TEST(TransferTest, AssignMemberBeforeCopy) {
std::string Code = R"( std::string Code = R"(
struct A { struct A {
int Foo; int Foo;
}; };
void target() { void target() {
A A1; A A1;
A A2; A A2;
int Bar; int Bar;
A1.Foo = Bar; A1.Foo = Bar;
A2 = A1; A2 = A1;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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 ValueDecl *A1Decl = findValueDecl(ASTCtx, "A1"); const ValueDecl *A1Decl = findValueDecl(ASTCtx, "A1");
ASSERT_THAT(A1Decl, NotNull()); ASSERT_THAT(A1Decl, NotNull());
const ValueDecl *A2Decl = findValueDecl(ASTCtx, "A2"); const ValueDecl *A2Decl = findValueDecl(ASTCtx, "A2");
ASSERT_THAT(A2Decl, NotNull()); ASSERT_THAT(A2Decl, NotNull());
const auto *BarVal = const auto *BarVal =
cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None)); cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None));
const auto *A2Val = const auto *A2Val =
cast<StructValue>(Env.getValue(*A2Decl, SkipPast::None)); cast<StructValue>(Env.getValue(*A2Decl, SkipPast::None));
EXPECT_EQ(A2Val->getChild(*FooDecl), BarVal); EXPECT_EQ(A2Val->getChild(*FooDecl), BarVal);
}); });
} }
TEST(TransferTest, BooleanEquality) { TEST(TransferTest, BooleanEquality) {
std::string Code = R"( std::string Code = R"(
void target(bool Bar) { void target(bool Bar) {
bool Foo = true; bool Foo = true;
if (Bar == Foo) { if (Bar == Foo) {
(void)0; (void)0;
/*[[p-then]]*/ /*[[p-then]]*/
} else { } else {
(void)0; (void)0;
/*[[p-else]]*/ /*[[p-else]]*/
} }
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results, ASTContext &ASTCtx) {
ASTContext &ASTCtx) { ASSERT_THAT(Results.keys(), UnorderedElementsAre("p-then", "p-else"));
ASSERT_THAT(Results, ElementsAre(Pair("p-else", _), Pair("p-then", _))); const Environment &EnvThen =
const Environment &EnvElse = Results[0].second.Env; getEnvironmentAtAnnotation(Results, "p-then");
const Environment &EnvThen = Results[1].second.Env; const Environment &EnvElse =
getEnvironmentAtAnnotation(Results, "p-else");
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
auto &BarValThen = auto &BarValThen =
*cast<BoolValue>(EnvThen.getValue(*BarDecl, SkipPast::None)); *cast<BoolValue>(EnvThen.getValue(*BarDecl, SkipPast::None));
EXPECT_TRUE(EnvThen.flowConditionImplies(BarValThen)); EXPECT_TRUE(EnvThen.flowConditionImplies(BarValThen));
Show All 12 Lines void target(bool Bar) {
/*[[p-then]]*/ /*[[p-then]]*/
} else { } else {
(void)0; (void)0;
/*[[p-else]]*/ /*[[p-else]]*/
} }
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results, ASTContext &ASTCtx) {
ASTContext &ASTCtx) { ASSERT_THAT(Results.keys(), UnorderedElementsAre("p-then", "p-else"));
ASSERT_THAT(Results, ElementsAre(Pair("p-else", _), Pair("p-then", _))); const Environment &EnvThen =
const Environment &EnvElse = Results[0].second.Env; getEnvironmentAtAnnotation(Results, "p-then");
const Environment &EnvThen = Results[1].second.Env; const Environment &EnvElse =
getEnvironmentAtAnnotation(Results, "p-else");
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
auto &BarValThen = auto &BarValThen =
*cast<BoolValue>(EnvThen.getValue(*BarDecl, SkipPast::None)); *cast<BoolValue>(EnvThen.getValue(*BarDecl, SkipPast::None));
EXPECT_FALSE(EnvThen.flowConditionImplies(BarValThen)); EXPECT_FALSE(EnvThen.flowConditionImplies(BarValThen));
Show All 17 Lines void target(bool B, bool C) {
} }
if (B) { if (B) {
(void)0; (void)0;
/*[[p2]]*/ /*[[p2]]*/
} }
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, SizeIs(3)); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p0", "p1", "p2"));
const ValueDecl *CDecl = findValueDecl(ASTCtx, "C"); const ValueDecl *CDecl = findValueDecl(ASTCtx, "C");
ASSERT_THAT(CDecl, NotNull()); ASSERT_THAT(CDecl, NotNull());
{ {
ASSERT_THAT(Results[0], Pair("p0", _)); const Environment &Env = getEnvironmentAtAnnotation(Results, "p0");
const Environment &Env = Results[0].second.Env;
const ValueDecl *BDecl = findValueDecl(ASTCtx, "B"); const ValueDecl *BDecl = findValueDecl(ASTCtx, "B");
ASSERT_THAT(BDecl, NotNull()); ASSERT_THAT(BDecl, NotNull());
auto &BVal = *cast<BoolValue>(Env.getValue(*BDecl, SkipPast::None)); auto &BVal = *cast<BoolValue>(Env.getValue(*BDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BVal))); EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BVal)));
} }
{ {
ASSERT_THAT(Results[1], Pair("p1", _)); const Environment &Env = getEnvironmentAtAnnotation(Results, "p1");
const Environment &Env = Results[1].second.Env;
auto &CVal = *cast<BoolValue>(Env.getValue(*CDecl, SkipPast::None)); auto &CVal = *cast<BoolValue>(Env.getValue(*CDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(CVal)); EXPECT_TRUE(Env.flowConditionImplies(CVal));
} }
{ {
ASSERT_THAT(Results[2], Pair("p2", _)); const Environment &Env = getEnvironmentAtAnnotation(Results, "p2");
const Environment &Env = Results[2].second.Env;
auto &CVal = *cast<BoolValue>(Env.getValue(*CDecl, SkipPast::None)); auto &CVal = *cast<BoolValue>(Env.getValue(*CDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(CVal)); EXPECT_TRUE(Env.flowConditionImplies(CVal));
} }
}); });
} }
TEST(TransferTest, LoopWithAssignmentConverges) { TEST(TransferTest, LoopWithAssignmentConverges) {
std::string Code = R"( std::string Code = R"(
bool &foo(); bool &foo();
void target() { void target() {
do { do {
bool Bar = foo(); bool Bar = foo();
if (Bar) break; if (Bar) break;
(void)Bar; (void)Bar;
/*[[p]]*/ /*[[p]]*/
} while (true); } while (true);
} }
)"; )";
// The key property that we are verifying is implicit in `runDataflow` -- // The key property that we are verifying is implicit in `runDataflow` --
// namely, that the analysis succeeds, rather than hitting the maximum number // namely, that the analysis succeeds, rather than hitting the maximum number
// of iterations. // of iterations.
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::None)); auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal))); EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal)));
}); });
} }
Show All 11 Lines void target() {
/*[[p]]*/ /*[[p]]*/
} while (true); } while (true);
} }
)"; )";
// The key property that we are verifying is implicit in `runDataflow` -- // The key property that we are verifying is implicit in `runDataflow` --
// namely, that the analysis succeeds, rather than hitting the maximum number // namely, that the analysis succeeds, rather than hitting the maximum number
// of iterations. // of iterations.
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
auto &BarVal = auto &BarVal =
*cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::Reference)); *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::Reference));
EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal))); EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal)));
}); });
Show All 14 Lines void target(Lookup val, bool b) {
(void)0; (void)0;
/*[[p-outer]]*/ /*[[p-outer]]*/
} }
)"; )";
// The key property that we are verifying is implicit in `runDataflow` -- // The key property that we are verifying is implicit in `runDataflow` --
// namely, that the analysis succeeds, rather than hitting the maximum number // namely, that the analysis succeeds, rather than hitting the maximum number
// of iterations. // of iterations.
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results, ASTContext &ASTCtx) {
ASTContext &ASTCtx) { ASSERT_THAT(Results.keys(), UnorderedElementsAre("p-inner", "p-outer"));
ASSERT_THAT(Results, const Environment &InnerEnv =
ElementsAre(Pair("p-inner", _), Pair("p-outer", _))); getEnvironmentAtAnnotation(Results, "p-inner");
const Environment &InnerEnv = Results[0].second.Env; const Environment &OuterEnv =
const Environment &OuterEnv = Results[1].second.Env; getEnvironmentAtAnnotation(Results, "p-outer");
const ValueDecl *ValDecl = findValueDecl(ASTCtx, "val"); const ValueDecl *ValDecl = findValueDecl(ASTCtx, "val");
ASSERT_THAT(ValDecl, NotNull()); ASSERT_THAT(ValDecl, NotNull());
const ValueDecl *LDecl = findValueDecl(ASTCtx, "l"); const ValueDecl *LDecl = findValueDecl(ASTCtx, "l");
ASSERT_THAT(LDecl, NotNull()); ASSERT_THAT(LDecl, NotNull());
// Inner. // Inner.
Show All 28 Lines void foo() {
Union B; Union B;
A = B; A = B;
} }
)"; )";
// This is a crash regression test when calling the transfer function on a // This is a crash regression test when calling the transfer function on a
// `CXXThisExpr` that refers to a union. // `CXXThisExpr` that refers to a union.
runDataflow( runDataflow(
Code, Code,
[](llvm::ArrayRef< [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>>,
ASTContext &) {}, ASTContext &) {},
LangStandard::lang_cxx17, /*ApplyBuiltinTransfer=*/true, "operator="); LangStandard::lang_cxx17, /*ApplyBuiltinTransfer=*/true, "operator=");
} }
TEST(TransferTest, StructuredBindingAssignFromStructIntMembersToRefs) { TEST(TransferTest, StructuredBindingAssignFromStructIntMembersToRefs) {
std::string Code = R"( std::string Code = R"(
struct A { struct A {
int Foo; int Foo;
int Bar; int Bar;
}; };
void target() { void target() {
int Qux; int Qux;
A Baz; A Baz;
Baz.Foo = Qux; Baz.Foo = Qux;
auto &FooRef = Baz.Foo; auto &FooRef = Baz.Foo;
auto &BarRef = Baz.Bar; auto &BarRef = Baz.Bar;
auto &[BoundFooRef, BoundBarRef] = Baz; auto &[BoundFooRef, BoundBarRef] = Baz;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooRefDecl = findValueDecl(ASTCtx, "FooRef"); const ValueDecl *FooRefDecl = findValueDecl(ASTCtx, "FooRef");
ASSERT_THAT(FooRefDecl, NotNull()); ASSERT_THAT(FooRefDecl, NotNull());
const ValueDecl *BarRefDecl = findValueDecl(ASTCtx, "BarRef"); const ValueDecl *BarRefDecl = findValueDecl(ASTCtx, "BarRef");
ASSERT_THAT(BarRefDecl, NotNull()); ASSERT_THAT(BarRefDecl, NotNull());
const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux"); const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux");
Show All 40 Lines void target(A Baz) {
Baz.Foo = Qux; Baz.Foo = Qux;
auto &FooRef = Baz.Foo; auto &FooRef = Baz.Foo;
auto &BarRef = Baz.Bar; auto &BarRef = Baz.Bar;
auto &[BoundFooRef, BoundBarRef] = Baz; auto &[BoundFooRef, BoundBarRef] = Baz;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooRefDecl = findValueDecl(ASTCtx, "FooRef"); const ValueDecl *FooRefDecl = findValueDecl(ASTCtx, "FooRef");
ASSERT_THAT(FooRefDecl, NotNull()); ASSERT_THAT(FooRefDecl, NotNull());
const ValueDecl *BarRefDecl = findValueDecl(ASTCtx, "BarRef"); const ValueDecl *BarRefDecl = findValueDecl(ASTCtx, "BarRef");
ASSERT_THAT(BarRefDecl, NotNull()); ASSERT_THAT(BarRefDecl, NotNull());
const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux"); const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux");
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines void target() {
Baz.Foo = Qux; Baz.Foo = Qux;
auto &FooRef = Baz.Foo; auto &FooRef = Baz.Foo;
auto &BarRef = Baz.Bar; auto &BarRef = Baz.Bar;
auto [BoundFoo, BoundBar] = Baz; auto [BoundFoo, BoundBar] = Baz;
// [[p]] // [[p]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooRefDecl = findValueDecl(ASTCtx, "FooRef"); const ValueDecl *FooRefDecl = findValueDecl(ASTCtx, "FooRef");
ASSERT_THAT(FooRefDecl, NotNull()); ASSERT_THAT(FooRefDecl, NotNull());
const ValueDecl *BarRefDecl = findValueDecl(ASTCtx, "BarRef"); const ValueDecl *BarRefDecl = findValueDecl(ASTCtx, "BarRef");
ASSERT_THAT(BarRefDecl, NotNull()); ASSERT_THAT(BarRefDecl, NotNull());
const ValueDecl *BoundFooDecl = findValueDecl(ASTCtx, "BoundFoo"); const ValueDecl *BoundFooDecl = findValueDecl(ASTCtx, "BoundFoo");
Show All 30 Lines
TEST(TransferTest, BinaryOperatorComma) { TEST(TransferTest, BinaryOperatorComma) {
std::string Code = R"( std::string Code = R"(
void target(int Foo, int Bar) { void target(int Foo, int Bar) {
int &Baz = (Foo, Bar); int &Baz = (Foo, Bar);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
const StorageLocation *BarLoc = const StorageLocation *BarLoc =
Env.getStorageLocation(*BarDecl, SkipPast::Reference); Env.getStorageLocation(*BarDecl, SkipPast::Reference);
ASSERT_THAT(BarLoc, NotNull()); ASSERT_THAT(BarLoc, NotNull());
const StorageLocation *BazLoc = const StorageLocation *BazLoc =
Env.getStorageLocation(*BazDecl, SkipPast::Reference); Env.getStorageLocation(*BazDecl, SkipPast::Reference);
EXPECT_EQ(BazLoc, BarLoc); EXPECT_EQ(BazLoc, BarLoc);
}); });
} }
TEST(TransferTest, IfStmtBranchExtendsFlowCondition) { TEST(TransferTest, IfStmtBranchExtendsFlowCondition) {
std::string Code = R"( std::string Code = R"(
void target(bool Foo) { void target(bool Foo) {
if (Foo) { if (Foo) {
(void)0; (void)0;
// [[if_then]] // [[if_then]]
} else { } else {
(void)0; (void)0;
// [[if_else]] // [[if_else]]
} }
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results, ASTContext &ASTCtx) {
ASTContext &ASTCtx) { ASSERT_THAT(Results.keys(), UnorderedElementsAre("if_then", "if_else"));
ASSERT_THAT(Results, const Environment &ThenEnv =
ElementsAre(Pair("if_else", _), Pair("if_then", _))); getEnvironmentAtAnnotation(Results, "if_then");
const Environment &ThenEnv = Results[1].second.Env; const Environment &ElseEnv =
const Environment &ElseEnv = Results[0].second.Env; getEnvironmentAtAnnotation(Results, "if_else");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
BoolValue &ThenFooVal = BoolValue &ThenFooVal =
*cast<BoolValue>(ThenEnv.getValue(*FooDecl, SkipPast::None)); *cast<BoolValue>(ThenEnv.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(ThenEnv.flowConditionImplies(ThenFooVal)); EXPECT_TRUE(ThenEnv.flowConditionImplies(ThenFooVal));
Show All 10 Lines void target(bool Foo) {
(void)0; (void)0;
// [[loop_body]] // [[loop_body]]
} }
(void)0; (void)0;
// [[after_loop]] // [[after_loop]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results, ASTContext &ASTCtx) {
ASTContext &ASTCtx) { ASSERT_THAT(Results.keys(),
ASSERT_THAT(Results, UnorderedElementsAre("loop_body", "after_loop"));
ElementsAre(Pair("after_loop", _), Pair("loop_body", _))); const Environment &LoopBodyEnv =
const Environment &LoopBodyEnv = Results[1].second.Env; getEnvironmentAtAnnotation(Results, "loop_body");
const Environment &AfterLoopEnv = Results[0].second.Env; const Environment &AfterLoopEnv =
getEnvironmentAtAnnotation(Results, "after_loop");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
BoolValue &LoopBodyFooVal = BoolValue &LoopBodyFooVal =
*cast<BoolValue>(LoopBodyEnv.getValue(*FooDecl, SkipPast::None)); *cast<BoolValue>(LoopBodyEnv.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(LoopBodyEnv.flowConditionImplies(LoopBodyFooVal)); EXPECT_TRUE(LoopBodyEnv.flowConditionImplies(LoopBodyFooVal));
Show All 13 Lines void target(bool Foo) {
// [[loop_body]] // [[loop_body]]
Bar = false; Bar = false;
} while (Foo); } while (Foo);
(void)0; (void)0;
// [[after_loop]] // [[after_loop]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results, ASTContext &ASTCtx) {
ASTContext &ASTCtx) { ASSERT_THAT(Results.keys(),
ASSERT_THAT(Results, UnorderedElementsAre("loop_body", "after_loop"));
ElementsAre(Pair("after_loop", _), Pair("loop_body", _))); const Environment &LoopBodyEnv =
const Environment &LoopBodyEnv = Results[1].second.Env; getEnvironmentAtAnnotation(Results, "loop_body");
const Environment &AfterLoopEnv = Results[0].second.Env; const Environment &AfterLoopEnv =
getEnvironmentAtAnnotation(Results, "after_loop");
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());
BoolValue &LoopBodyFooVal = BoolValue &LoopBodyFooVal =
Show All 21 Lines void target(bool Foo) {
(void)0; (void)0;
// [[loop_body]] // [[loop_body]]
} }
(void)0; (void)0;
// [[after_loop]] // [[after_loop]]
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results, ASTContext &ASTCtx) {
ASTContext &ASTCtx) { ASSERT_THAT(Results.keys(),
ASSERT_THAT(Results, UnorderedElementsAre("loop_body", "after_loop"));
ElementsAre(Pair("after_loop", _), Pair("loop_body", _))); const Environment &LoopBodyEnv =
const Environment &LoopBodyEnv = Results[1].second.Env; getEnvironmentAtAnnotation(Results, "loop_body");
const Environment &AfterLoopEnv = Results[0].second.Env; const Environment &AfterLoopEnv =
getEnvironmentAtAnnotation(Results, "after_loop");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
BoolValue &LoopBodyFooVal = BoolValue &LoopBodyFooVal =
*cast<BoolValue>(LoopBodyEnv.getValue(*FooDecl, SkipPast::None)); *cast<BoolValue>(LoopBodyEnv.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(LoopBodyEnv.flowConditionImplies(LoopBodyFooVal)); EXPECT_TRUE(LoopBodyEnv.flowConditionImplies(LoopBodyFooVal));
Show All 9 Lines std::string Code = R"(
void target(bool Foo) { void target(bool Foo) {
for (;;) { for (;;) {
(void)0; (void)0;
// [[loop_body]] // [[loop_body]]
} }
} }
)"; )";
runDataflow( runDataflow(
Code, [](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("loop_body", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("loop_body"));
const Environment &LoopBodyEnv = Results[0].second.Env; const Environment &LoopBodyEnv =
getEnvironmentAtAnnotation(Results, "loop_body");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
BoolValue &LoopBodyFooVal = BoolValue &LoopBodyFooVal =
*cast<BoolValue>(LoopBodyEnv.getValue(*FooDecl, SkipPast::None)); *cast<BoolValue>(LoopBodyEnv.getValue(*FooDecl, SkipPast::None));
EXPECT_FALSE(LoopBodyEnv.flowConditionImplies(LoopBodyFooVal)); EXPECT_FALSE(LoopBodyEnv.flowConditionImplies(LoopBodyFooVal));
}); });
} }
TEST(TransferTest, ContextSensitiveOptionDisabled) { TEST(TransferTest, ContextSensitiveOptionDisabled) {
std::string Code = R"( std::string Code = R"(
bool GiveBool(); bool GiveBool();
void SetBool(bool &Var) { Var = true; } void SetBool(bool &Var) { Var = true; }
void target() { void target() {
bool Foo = GiveBool(); bool Foo = GiveBool();
SetBool(Foo); SetBool(Foo);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_FALSE(Env.flowConditionImplies(FooVal)); EXPECT_FALSE(Env.flowConditionImplies(FooVal));
EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal))); EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal)));
}, },
{TransferOptions{/*.ContextSensitiveOpts=*/llvm::None}}); {TransferOptions{/*.ContextSensitiveOpts=*/llvm::None}});
} }
TEST(TransferTest, ContextSensitiveDepthZero) { TEST(TransferTest, ContextSensitiveDepthZero) {
std::string Code = R"( std::string Code = R"(
bool GiveBool(); bool GiveBool();
void SetBool(bool &Var) { Var = true; } void SetBool(bool &Var) { Var = true; }
void target() { void target() {
bool Foo = GiveBool(); bool Foo = GiveBool();
SetBool(Foo); SetBool(Foo);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_FALSE(Env.flowConditionImplies(FooVal)); EXPECT_FALSE(Env.flowConditionImplies(FooVal));
EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal))); EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal)));
}, },
{TransferOptions{ContextSensitiveOptions{/*.Depth=*/0}}}); {TransferOptions{ContextSensitiveOptions{/*.Depth=*/0}}});
} }
TEST(TransferTest, ContextSensitiveSetTrue) { TEST(TransferTest, ContextSensitiveSetTrue) {
std::string Code = R"( std::string Code = R"(
bool GiveBool(); bool GiveBool();
void SetBool(bool &Var) { Var = true; } void SetBool(bool &Var) { Var = true; }
void target() { void target() {
bool Foo = GiveBool(); bool Foo = GiveBool();
SetBool(Foo); SetBool(Foo);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(FooVal)); EXPECT_TRUE(Env.flowConditionImplies(FooVal));
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveSetFalse) { TEST(TransferTest, ContextSensitiveSetFalse) {
std::string Code = R"( std::string Code = R"(
bool GiveBool(); bool GiveBool();
void SetBool(bool &Var) { Var = false; } void SetBool(bool &Var) { Var = false; }
void target() { void target() {
bool Foo = GiveBool(); bool Foo = GiveBool();
SetBool(Foo); SetBool(Foo);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(FooVal))); EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(FooVal)));
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveSetBothTrueAndFalse) { TEST(TransferTest, ContextSensitiveSetBothTrueAndFalse) {
std::string Code = R"( std::string Code = R"(
bool GiveBool(); bool GiveBool();
void SetBool(bool &Var, bool Val) { Var = Val; } void SetBool(bool &Var, bool Val) { Var = Val; }
void target() { void target() {
bool Foo = GiveBool(); bool Foo = GiveBool();
bool Bar = GiveBool(); bool Bar = GiveBool();
SetBool(Foo, true); SetBool(Foo, true);
SetBool(Bar, false); SetBool(Bar, false);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(FooVal)); EXPECT_TRUE(Env.flowConditionImplies(FooVal));
EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal))); EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal)));
auto &BarVal = auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::None));
EXPECT_FALSE(Env.flowConditionImplies(BarVal)); EXPECT_FALSE(Env.flowConditionImplies(BarVal));
EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal))); EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal)));
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveSetTwoLayersDepthOne) { TEST(TransferTest, ContextSensitiveSetTwoLayersDepthOne) {
std::string Code = R"( std::string Code = R"(
bool GiveBool(); bool GiveBool();
void SetBool1(bool &Var) { Var = true; } void SetBool1(bool &Var) { Var = true; }
void SetBool2(bool &Var) { SetBool1(Var); } void SetBool2(bool &Var) { SetBool1(Var); }
void target() { void target() {
bool Foo = GiveBool(); bool Foo = GiveBool();
SetBool2(Foo); SetBool2(Foo);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_FALSE(Env.flowConditionImplies(FooVal)); EXPECT_FALSE(Env.flowConditionImplies(FooVal));
EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal))); EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal)));
}, },
{TransferOptions{ContextSensitiveOptions{/*.Depth=*/1}}}); {TransferOptions{ContextSensitiveOptions{/*.Depth=*/1}}});
} }
TEST(TransferTest, ContextSensitiveSetTwoLayersDepthTwo) { TEST(TransferTest, ContextSensitiveSetTwoLayersDepthTwo) {
std::string Code = R"( std::string Code = R"(
bool GiveBool(); bool GiveBool();
void SetBool1(bool &Var) { Var = true; } void SetBool1(bool &Var) { Var = true; }
void SetBool2(bool &Var) { SetBool1(Var); } void SetBool2(bool &Var) { SetBool1(Var); }
void target() { void target() {
bool Foo = GiveBool(); bool Foo = GiveBool();
SetBool2(Foo); SetBool2(Foo);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(FooVal)); EXPECT_TRUE(Env.flowConditionImplies(FooVal));
}, },
{TransferOptions{ContextSensitiveOptions{/*.Depth=*/2}}}); {TransferOptions{ContextSensitiveOptions{/*.Depth=*/2}}});
} }
TEST(TransferTest, ContextSensitiveSetThreeLayersDepthTwo) { TEST(TransferTest, ContextSensitiveSetThreeLayersDepthTwo) {
std::string Code = R"( std::string Code = R"(
bool GiveBool(); bool GiveBool();
void SetBool1(bool &Var) { Var = true; } void SetBool1(bool &Var) { Var = true; }
void SetBool2(bool &Var) { SetBool1(Var); } void SetBool2(bool &Var) { SetBool1(Var); }
void SetBool3(bool &Var) { SetBool2(Var); } void SetBool3(bool &Var) { SetBool2(Var); }
void target() { void target() {
bool Foo = GiveBool(); bool Foo = GiveBool();
SetBool3(Foo); SetBool3(Foo);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_FALSE(Env.flowConditionImplies(FooVal)); EXPECT_FALSE(Env.flowConditionImplies(FooVal));
EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal))); EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal)));
}, },
{TransferOptions{ContextSensitiveOptions{/*.Depth=*/2}}}); {TransferOptions{ContextSensitiveOptions{/*.Depth=*/2}}});
} }
TEST(TransferTest, ContextSensitiveSetThreeLayersDepthThree) { TEST(TransferTest, ContextSensitiveSetThreeLayersDepthThree) {
std::string Code = R"( std::string Code = R"(
bool GiveBool(); bool GiveBool();
void SetBool1(bool &Var) { Var = true; } void SetBool1(bool &Var) { Var = true; }
void SetBool2(bool &Var) { SetBool1(Var); } void SetBool2(bool &Var) { SetBool1(Var); }
void SetBool3(bool &Var) { SetBool2(Var); } void SetBool3(bool &Var) { SetBool2(Var); }
void target() { void target() {
bool Foo = GiveBool(); bool Foo = GiveBool();
SetBool3(Foo); SetBool3(Foo);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(FooVal)); EXPECT_TRUE(Env.flowConditionImplies(FooVal));
}, },
{TransferOptions{ContextSensitiveOptions{/*.Depth=*/3}}}); {TransferOptions{ContextSensitiveOptions{/*.Depth=*/3}}});
} }
TEST(TransferTest, ContextSensitiveMutualRecursion) { TEST(TransferTest, ContextSensitiveMutualRecursion) {
std::string Code = R"( std::string Code = R"(
bool Pong(bool X, bool Y); bool Pong(bool X, bool Y);
bool Ping(bool X, bool Y) { bool Ping(bool X, bool Y) {
if (X) { if (X) {
Show All 11 Lines bool Pong(bool X, bool Y) {
} }
} }
void target() { void target() {
bool Foo = Ping(false, false); bool Foo = Ping(false, false);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
// The analysis doesn't crash... // The analysis doesn't crash...
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
// ... but it also can't prove anything here. // ... but it also can't prove anything here.
EXPECT_FALSE(Env.flowConditionImplies(FooVal)); EXPECT_FALSE(Env.flowConditionImplies(FooVal));
EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal))); EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal)));
}, },
{TransferOptions{ContextSensitiveOptions{/*.Depth=*/4}}}); {TransferOptions{ContextSensitiveOptions{/*.Depth=*/4}}});
} }
TEST(TransferTest, ContextSensitiveSetMultipleLines) { TEST(TransferTest, ContextSensitiveSetMultipleLines) {
std::string Code = R"( std::string Code = R"(
void SetBools(bool &Var1, bool &Var2) { void SetBools(bool &Var1, bool &Var2) {
Var1 = true; Var1 = true;
Var2 = false; Var2 = false;
} }
void target() { void target() {
bool Foo = false; bool Foo = false;
bool Bar = true; bool Bar = true;
SetBools(Foo, Bar); SetBools(Foo, Bar);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
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());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(FooVal)); EXPECT_TRUE(Env.flowConditionImplies(FooVal));
EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal))); EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(FooVal)));
auto &BarVal = auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::None));
EXPECT_FALSE(Env.flowConditionImplies(BarVal)); EXPECT_FALSE(Env.flowConditionImplies(BarVal));
EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal))); EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal)));
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveSetMultipleBlocks) { TEST(TransferTest, ContextSensitiveSetMultipleBlocks) {
std::string Code = R"( std::string Code = R"(
void IfCond(bool Cond, bool &Then, bool &Else) { void IfCond(bool Cond, bool &Then, bool &Else) {
if (Cond) { if (Cond) {
Then = true; Then = true;
} else { } else {
Else = true; Else = true;
} }
} }
void target() { void target() {
bool Foo = false; bool Foo = false;
bool Bar = false; bool Bar = false;
bool Baz = false; bool Baz = false;
IfCond(Foo, Bar, Baz); IfCond(Foo, Bar, Baz);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar"); const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
ASSERT_THAT(BarDecl, NotNull()); ASSERT_THAT(BarDecl, NotNull());
const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
auto &BarVal = auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::None));
EXPECT_FALSE(Env.flowConditionImplies(BarVal)); EXPECT_FALSE(Env.flowConditionImplies(BarVal));
EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal))); EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal)));
auto &BazVal = auto &BazVal = *cast<BoolValue>(Env.getValue(*BazDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*BazDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(BazVal)); EXPECT_TRUE(Env.flowConditionImplies(BazVal));
EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(BazVal))); EXPECT_FALSE(Env.flowConditionImplies(Env.makeNot(BazVal)));
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveReturnVoid) { TEST(TransferTest, ContextSensitiveReturnVoid) {
std::string Code = R"( std::string Code = R"(
void Noop() { return; } void Noop() { return; }
void target() { void target() {
Noop(); Noop();
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
// This just tests that the analysis doesn't crash. // This just tests that the analysis doesn't crash.
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveReturnTrue) { TEST(TransferTest, ContextSensitiveReturnTrue) {
std::string Code = R"( std::string Code = R"(
bool GiveBool() { return true; } bool GiveBool() { return true; }
void target() { void target() {
bool Foo = GiveBool(); bool Foo = GiveBool();
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(FooVal)); EXPECT_TRUE(Env.flowConditionImplies(FooVal));
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveReturnFalse) { TEST(TransferTest, ContextSensitiveReturnFalse) {
std::string Code = R"( std::string Code = R"(
bool GiveBool() { return false; } bool GiveBool() { return false; }
void target() { void target() {
bool Foo = GiveBool(); bool Foo = GiveBool();
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(FooVal))); EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(FooVal)));
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveReturnArg) { TEST(TransferTest, ContextSensitiveReturnArg) {
std::string Code = R"( std::string Code = R"(
bool GiveBool(); bool GiveBool();
bool GiveBack(bool Arg) { return Arg; } bool GiveBack(bool Arg) { return Arg; }
void target() { void target() {
bool Foo = GiveBool(); bool Foo = GiveBool();
bool Bar = GiveBack(Foo); bool Bar = GiveBack(Foo);
bool Baz = Foo == Bar; bool Baz = Foo == Bar;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz"); const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
ASSERT_THAT(BazDecl, NotNull()); ASSERT_THAT(BazDecl, NotNull());
auto &BazVal = auto &BazVal = *cast<BoolValue>(Env.getValue(*BazDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*BazDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(BazVal)); EXPECT_TRUE(Env.flowConditionImplies(BazVal));
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveReturnInt) { TEST(TransferTest, ContextSensitiveReturnInt) {
std::string Code = R"( std::string Code = R"(
int identity(int x) { return x; } int identity(int x) { return x; }
void target() { void target() {
int y = identity(42); int y = identity(42);
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
// This just tests that the analysis doesn't crash. // This just tests that the analysis doesn't crash.
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveMethodLiteral) { TEST(TransferTest, ContextSensitiveMethodLiteral) {
std::string Code = R"( std::string Code = R"(
class MyClass { class MyClass {
public: public:
bool giveBool() { return true; } bool giveBool() { return true; }
}; };
void target() { void target() {
MyClass MyObj; MyClass MyObj;
bool Foo = MyObj.giveBool(); bool Foo = MyObj.giveBool();
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(FooVal)); EXPECT_TRUE(Env.flowConditionImplies(FooVal));
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveMethodGetter) { TEST(TransferTest, ContextSensitiveMethodGetter) {
std::string Code = R"( std::string Code = R"(
class MyClass { class MyClass {
public: public:
bool getField() { return Field; } bool getField() { return Field; }
bool Field; bool Field;
}; };
void target() { void target() {
MyClass MyObj; MyClass MyObj;
MyObj.Field = true; MyObj.Field = true;
bool Foo = MyObj.getField(); bool Foo = MyObj.getField();
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(FooVal)); EXPECT_TRUE(Env.flowConditionImplies(FooVal));
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveMethodSetter) { TEST(TransferTest, ContextSensitiveMethodSetter) {
std::string Code = R"( std::string Code = R"(
class MyClass { class MyClass {
public: public:
bool setField(bool Val) { Field = Val; } bool setField(bool Val) { Field = Val; }
bool Field; bool Field;
}; };
void target() { void target() {
MyClass MyObj; MyClass MyObj;
MyObj.setField(true); MyObj.setField(true);
bool Foo = MyObj.Field; bool Foo = MyObj.Field;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(FooVal)); EXPECT_TRUE(Env.flowConditionImplies(FooVal));
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveMethodGetterAndSetter) { TEST(TransferTest, ContextSensitiveMethodGetterAndSetter) {
std::string Code = R"( std::string Code = R"(
class MyClass { class MyClass {
public: public:
bool getField() { return Field; } bool getField() { return Field; }
bool setField(bool Val) { Field = Val; } bool setField(bool Val) { Field = Val; }
private: private:
bool Field; bool Field;
}; };
void target() { void target() {
MyClass MyObj; MyClass MyObj;
MyObj.setField(true); MyObj.setField(true);
bool Foo = MyObj.getField(); bool Foo = MyObj.getField();
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(FooVal)); EXPECT_TRUE(Env.flowConditionImplies(FooVal));
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveConstructorBody) { TEST(TransferTest, ContextSensitiveConstructorBody) {
std::string Code = R"( std::string Code = R"(
class MyClass { class MyClass {
public: public:
MyClass() { MyField = true; } MyClass() { MyField = true; }
bool MyField; bool MyField;
}; };
void target() { void target() {
MyClass MyObj; MyClass MyObj;
bool Foo = MyObj.MyField; bool Foo = MyObj.MyField;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(FooVal)); EXPECT_TRUE(Env.flowConditionImplies(FooVal));
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveConstructorInitializer) { TEST(TransferTest, ContextSensitiveConstructorInitializer) {
std::string Code = R"( std::string Code = R"(
class MyClass { class MyClass {
public: public:
MyClass() : MyField(true) {} MyClass() : MyField(true) {}
bool MyField; bool MyField;
}; };
void target() { void target() {
MyClass MyObj; MyClass MyObj;
bool Foo = MyObj.MyField; bool Foo = MyObj.MyField;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(FooVal)); EXPECT_TRUE(Env.flowConditionImplies(FooVal));
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
TEST(TransferTest, ContextSensitiveConstructorDefault) { TEST(TransferTest, ContextSensitiveConstructorDefault) {
std::string Code = R"( std::string Code = R"(
class MyClass { class MyClass {
public: public:
MyClass() = default; MyClass() = default;
bool MyField = true; bool MyField = true;
}; };
void target() { void target() {
MyClass MyObj; MyClass MyObj;
bool Foo = MyObj.MyField; bool Foo = MyObj.MyField;
// [[p]] // [[p]]
} }
)"; )";
runDataflow(Code, runDataflow(
[](llvm::ArrayRef< Code,
std::pair<std::string, DataflowAnalysisState<NoopLattice>>> [](const llvm::StringMap<DataflowAnalysisState<NoopLattice>> &Results,
Results,
ASTContext &ASTCtx) { ASTContext &ASTCtx) {
ASSERT_THAT(Results, ElementsAre(Pair("p", _))); ASSERT_THAT(Results.keys(), UnorderedElementsAre("p"));
const Environment &Env = Results[0].second.Env; const Environment &Env = getEnvironmentAtAnnotation(Results, "p");
const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo"); const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
ASSERT_THAT(FooDecl, NotNull()); ASSERT_THAT(FooDecl, NotNull());
auto &FooVal = auto &FooVal = *cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
*cast<BoolValue>(Env.getValue(*FooDecl, SkipPast::None));
EXPECT_TRUE(Env.flowConditionImplies(FooVal)); EXPECT_TRUE(Env.flowConditionImplies(FooVal));
}, },
{TransferOptions{ContextSensitiveOptions{}}}); {TransferOptions{ContextSensitiveOptions{}}});
} }
} // namespace } // namespace
clang/unittests/Analysis/FlowSensitive/TestingSupportTest.cpp