diff options
Diffstat (limited to 'clang/unittests')
28 files changed, 982 insertions, 287 deletions
diff --git a/clang/unittests/Analysis/CMakeLists.txt b/clang/unittests/Analysis/CMakeLists.txt index 059a748..52e7d28 100644 --- a/clang/unittests/Analysis/CMakeLists.txt +++ b/clang/unittests/Analysis/CMakeLists.txt @@ -4,6 +4,7 @@ add_clang_unittest(ClangAnalysisTests CloneDetectionTest.cpp ExprMutationAnalyzerTest.cpp IntervalPartitionTest.cpp + LifetimeSafetyTest.cpp MacroExpansionContextTest.cpp UnsafeBufferUsageTest.cpp CLANG_LIBS diff --git a/clang/unittests/Analysis/LifetimeSafetyTest.cpp b/clang/unittests/Analysis/LifetimeSafetyTest.cpp new file mode 100644 index 0000000..a48dc45 --- /dev/null +++ b/clang/unittests/Analysis/LifetimeSafetyTest.cpp @@ -0,0 +1,710 @@ +//===- LifetimeSafetyTest.cpp - Lifetime Safety Tests -*---------- C++-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "clang/Analysis/Analyses/LifetimeSafety.h" +#include "clang/ASTMatchers/ASTMatchFinder.h" +#include "clang/ASTMatchers/ASTMatchers.h" +#include "clang/Testing/TestAST.h" +#include "llvm/ADT/StringMap.h" +#include "gmock/gmock.h" +#include "gtest/gtest.h" +#include <optional> +#include <vector> + +namespace clang::lifetimes::internal { +namespace { + +using namespace ast_matchers; +using ::testing::UnorderedElementsAreArray; + +// A helper class to run the full lifetime analysis on a piece of code +// and provide an interface for querying the results. +class LifetimeTestRunner { +public: + LifetimeTestRunner(llvm::StringRef Code) { + std::string FullCode = R"( + #define POINT(name) void("__lifetime_test_point_" #name) + struct MyObj { ~MyObj() {} int i; }; + )"; + FullCode += Code.str(); + + AST = std::make_unique<clang::TestAST>(FullCode); + ASTCtx = &AST->context(); + + // Find the target function using AST matchers. + auto MatchResult = + match(functionDecl(hasName("target")).bind("target"), *ASTCtx); + auto *FD = selectFirst<FunctionDecl>("target", MatchResult); + if (!FD) { + ADD_FAILURE() << "Test case must have a function named 'target'"; + return; + } + AnalysisCtx = std::make_unique<AnalysisDeclContext>(nullptr, FD); + CFG::BuildOptions &BuildOptions = AnalysisCtx->getCFGBuildOptions(); + BuildOptions.setAllAlwaysAdd(); + BuildOptions.AddImplicitDtors = true; + BuildOptions.AddTemporaryDtors = true; + + // Run the main analysis. + Analysis = std::make_unique<LifetimeSafetyAnalysis>(*AnalysisCtx); + Analysis->run(); + + AnnotationToPointMap = Analysis->getTestPoints(); + } + + LifetimeSafetyAnalysis &getAnalysis() { return *Analysis; } + ASTContext &getASTContext() { return *ASTCtx; } + + ProgramPoint getProgramPoint(llvm::StringRef Annotation) { + auto It = AnnotationToPointMap.find(Annotation); + if (It == AnnotationToPointMap.end()) { + ADD_FAILURE() << "Annotation '" << Annotation << "' not found."; + return nullptr; + } + return It->second; + } + +private: + std::unique_ptr<TestAST> AST; + ASTContext *ASTCtx = nullptr; + std::unique_ptr<AnalysisDeclContext> AnalysisCtx; + std::unique_ptr<LifetimeSafetyAnalysis> Analysis; + llvm::StringMap<ProgramPoint> AnnotationToPointMap; +}; + +// A convenience wrapper that uses the LifetimeSafetyAnalysis public API. +class LifetimeTestHelper { +public: + LifetimeTestHelper(LifetimeTestRunner &Runner) + : Runner(Runner), Analysis(Runner.getAnalysis()) {} + + std::optional<OriginID> getOriginForDecl(llvm::StringRef VarName) { + auto *VD = findDecl<ValueDecl>(VarName); + if (!VD) + return std::nullopt; + auto OID = Analysis.getOriginIDForDecl(VD); + if (!OID) + ADD_FAILURE() << "Origin for '" << VarName << "' not found."; + return OID; + } + + std::optional<LoanID> getLoanForVar(llvm::StringRef VarName) { + auto *VD = findDecl<VarDecl>(VarName); + if (!VD) + return std::nullopt; + std::vector<LoanID> LID = Analysis.getLoanIDForVar(VD); + if (LID.empty()) { + ADD_FAILURE() << "Loan for '" << VarName << "' not found."; + return std::nullopt; + } + // TODO: Support retrieving more than one loans to a var. + if (LID.size() > 1) { + ADD_FAILURE() << "More than 1 loans found for '" << VarName; + return std::nullopt; + } + return LID[0]; + } + + std::optional<LoanSet> getLoansAtPoint(OriginID OID, + llvm::StringRef Annotation) { + ProgramPoint PP = Runner.getProgramPoint(Annotation); + if (!PP) + return std::nullopt; + return Analysis.getLoansAtPoint(OID, PP); + } + + std::optional<LoanSet> getExpiredLoansAtPoint(llvm::StringRef Annotation) { + ProgramPoint PP = Runner.getProgramPoint(Annotation); + if (!PP) + return std::nullopt; + return Analysis.getExpiredLoansAtPoint(PP); + } + +private: + template <typename DeclT> DeclT *findDecl(llvm::StringRef Name) { + auto &Ctx = Runner.getASTContext(); + auto Results = match(valueDecl(hasName(Name)).bind("v"), Ctx); + if (Results.empty()) { + ADD_FAILURE() << "Declaration '" << Name << "' not found in AST."; + return nullptr; + } + return const_cast<DeclT *>(selectFirst<DeclT>("v", Results)); + } + + LifetimeTestRunner &Runner; + LifetimeSafetyAnalysis &Analysis; +}; + +// ========================================================================= // +// GTest Matchers & Fixture +// ========================================================================= // + +// A helper class to represent a set of loans, identified by variable names. +class LoanSetInfo { +public: + LoanSetInfo(const std::vector<std::string> &Vars, LifetimeTestHelper &H) + : LoanVars(Vars), Helper(H) {} + std::vector<std::string> LoanVars; + LifetimeTestHelper &Helper; +}; + +// It holds the name of the origin variable and a reference to the helper. +class OriginInfo { +public: + OriginInfo(llvm::StringRef OriginVar, LifetimeTestHelper &Helper) + : OriginVar(OriginVar), Helper(Helper) {} + llvm::StringRef OriginVar; + LifetimeTestHelper &Helper; +}; + +/// Matcher to verify the set of loans held by an origin at a specific +/// program point. +/// +/// This matcher is intended to be used with an \c OriginInfo object. +/// +/// \param LoanVars A vector of strings, where each string is the name of a +/// variable expected to be the source of a loan. +/// \param Annotation A string identifying the program point (created with +/// POINT()) where the check should be performed. +MATCHER_P2(HasLoansToImpl, LoanVars, Annotation, "") { + const OriginInfo &Info = arg; + std::optional<OriginID> OIDOpt = Info.Helper.getOriginForDecl(Info.OriginVar); + if (!OIDOpt) { + *result_listener << "could not find origin for '" << Info.OriginVar.str() + << "'"; + return false; + } + + std::optional<LoanSet> ActualLoansSetOpt = + Info.Helper.getLoansAtPoint(*OIDOpt, Annotation); + if (!ActualLoansSetOpt) { + *result_listener << "could not get a valid loan set at point '" + << Annotation << "'"; + return false; + } + std::vector<LoanID> ActualLoans(ActualLoansSetOpt->begin(), + ActualLoansSetOpt->end()); + + std::vector<LoanID> ExpectedLoans; + for (const auto &LoanVar : LoanVars) { + std::optional<LoanID> ExpectedLIDOpt = Info.Helper.getLoanForVar(LoanVar); + if (!ExpectedLIDOpt) { + *result_listener << "could not find loan for var '" << LoanVar << "'"; + return false; + } + ExpectedLoans.push_back(*ExpectedLIDOpt); + } + + return ExplainMatchResult(UnorderedElementsAreArray(ExpectedLoans), + ActualLoans, result_listener); +} + +/// Matcher to verify that the complete set of expired loans at a program point +/// matches the expected loan set. +MATCHER_P(AreExpiredAt, Annotation, "") { + const LoanSetInfo &Info = arg; + auto &Helper = Info.Helper; + + auto ActualExpiredSetOpt = Helper.getExpiredLoansAtPoint(Annotation); + if (!ActualExpiredSetOpt) { + *result_listener << "could not get a valid expired loan set at point '" + << Annotation << "'"; + return false; + } + std::vector<LoanID> ActualExpiredLoans(ActualExpiredSetOpt->begin(), + ActualExpiredSetOpt->end()); + std::vector<LoanID> ExpectedExpiredLoans; + for (const auto &VarName : Info.LoanVars) { + auto LoanIDOpt = Helper.getLoanForVar(VarName); + if (!LoanIDOpt) { + *result_listener << "could not find a loan for variable '" << VarName + << "'"; + return false; + } + ExpectedExpiredLoans.push_back(*LoanIDOpt); + } + return ExplainMatchResult(UnorderedElementsAreArray(ExpectedExpiredLoans), + ActualExpiredLoans, result_listener); +} + +// Base test fixture to manage the runner and helper. +class LifetimeAnalysisTest : public ::testing::Test { +protected: + void SetupTest(llvm::StringRef Code) { + Runner = std::make_unique<LifetimeTestRunner>(Code); + Helper = std::make_unique<LifetimeTestHelper>(*Runner); + } + + OriginInfo Origin(llvm::StringRef OriginVar) { + return OriginInfo(OriginVar, *Helper); + } + + /// Factory function that hides the std::vector creation. + LoanSetInfo LoansTo(std::initializer_list<std::string> LoanVars) { + return LoanSetInfo({LoanVars}, *Helper); + } + + /// A convenience helper for asserting that no loans are expired. + LoanSetInfo NoLoans() { return LoansTo({}); } + + // Factory function that hides the std::vector creation. + auto HasLoansTo(std::initializer_list<std::string> LoanVars, + const char *Annotation) { + return HasLoansToImpl(std::vector<std::string>(LoanVars), Annotation); + } + + std::unique_ptr<LifetimeTestRunner> Runner; + std::unique_ptr<LifetimeTestHelper> Helper; +}; + +// ========================================================================= // +// TESTS +// ========================================================================= // + +TEST_F(LifetimeAnalysisTest, SimpleLoanAndOrigin) { + SetupTest(R"( + void target() { + int x; + int* p = &x; + POINT(p1); + } + )"); + EXPECT_THAT(Origin("p"), HasLoansTo({"x"}, "p1")); +} + +TEST_F(LifetimeAnalysisTest, OverwriteOrigin) { + SetupTest(R"( + void target() { + MyObj s1, s2; + + MyObj* p = &s1; + POINT(after_s1); + + p = &s2; + POINT(after_s2); + } + )"); + EXPECT_THAT(Origin("p"), HasLoansTo({"s1"}, "after_s1")); + EXPECT_THAT(Origin("p"), HasLoansTo({"s2"}, "after_s2")); +} + +TEST_F(LifetimeAnalysisTest, ConditionalLoan) { + SetupTest(R"( + void target(bool cond) { + int a, b; + int *p = nullptr; + if (cond) { + p = &a; + POINT(after_then); + } else { + p = &b; + POINT(after_else); + } + POINT(after_if); + } + )"); + EXPECT_THAT(Origin("p"), HasLoansTo({"a"}, "after_then")); + EXPECT_THAT(Origin("p"), HasLoansTo({"b"}, "after_else")); + EXPECT_THAT(Origin("p"), HasLoansTo({"a", "b"}, "after_if")); +} + +TEST_F(LifetimeAnalysisTest, PointerChain) { + SetupTest(R"( + void target() { + MyObj y; + MyObj* ptr1 = &y; + POINT(p1); + + MyObj* ptr2 = ptr1; + POINT(p2); + + ptr2 = ptr1; + POINT(p3); + + ptr2 = ptr2; // Self assignment + POINT(p4); + } + )"); + EXPECT_THAT(Origin("ptr1"), HasLoansTo({"y"}, "p1")); + EXPECT_THAT(Origin("ptr2"), HasLoansTo({"y"}, "p2")); + EXPECT_THAT(Origin("ptr2"), HasLoansTo({"y"}, "p3")); + EXPECT_THAT(Origin("ptr2"), HasLoansTo({"y"}, "p4")); +} + +TEST_F(LifetimeAnalysisTest, ReassignToNull) { + SetupTest(R"( + void target() { + MyObj s1; + MyObj* p = &s1; + POINT(before_null); + p = nullptr; + POINT(after_null); + } + )"); + EXPECT_THAT(Origin("p"), HasLoansTo({"s1"}, "before_null")); + EXPECT_THAT(Origin("p"), HasLoansTo({}, "after_null")); +} + +TEST_F(LifetimeAnalysisTest, ReassignInIf) { + SetupTest(R"( + void target(bool condition) { + MyObj s1, s2; + MyObj* p = &s1; + POINT(before_if); + if (condition) { + p = &s2; + POINT(after_reassign); + } + POINT(after_if); + } + )"); + EXPECT_THAT(Origin("p"), HasLoansTo({"s1"}, "before_if")); + EXPECT_THAT(Origin("p"), HasLoansTo({"s2"}, "after_reassign")); + EXPECT_THAT(Origin("p"), HasLoansTo({"s1", "s2"}, "after_if")); +} + +TEST_F(LifetimeAnalysisTest, AssignInSwitch) { + SetupTest(R"( + void target(int mode) { + MyObj s1, s2, s3; + MyObj* p = nullptr; + switch (mode) { + case 1: + p = &s1; + POINT(case1); + break; + case 2: + p = &s2; + POINT(case2); + break; + default: + p = &s3; + POINT(case3); + break; + } + POINT(after_switch); + } + )"); + EXPECT_THAT(Origin("p"), HasLoansTo({"s1"}, "case1")); + EXPECT_THAT(Origin("p"), HasLoansTo({"s2"}, "case2")); + EXPECT_THAT(Origin("p"), HasLoansTo({"s3"}, "case3")); + EXPECT_THAT(Origin("p"), HasLoansTo({"s1", "s2", "s3"}, "after_switch")); +} + +TEST_F(LifetimeAnalysisTest, LoanInLoop) { + SetupTest(R"( + void target(bool condition) { + MyObj* p = nullptr; + while (condition) { + POINT(start_loop); + MyObj inner; + p = &inner; + POINT(end_loop); + } + POINT(after_loop); + } + )"); + EXPECT_THAT(Origin("p"), HasLoansTo({"inner"}, "start_loop")); + EXPECT_THAT(LoansTo({"inner"}), AreExpiredAt("start_loop")); + + EXPECT_THAT(Origin("p"), HasLoansTo({"inner"}, "end_loop")); + EXPECT_THAT(NoLoans(), AreExpiredAt("end_loop")); + + EXPECT_THAT(Origin("p"), HasLoansTo({"inner"}, "after_loop")); + EXPECT_THAT(LoansTo({"inner"}), AreExpiredAt("after_loop")); +} + +TEST_F(LifetimeAnalysisTest, LoopWithBreak) { + SetupTest(R"( + void target(int count) { + MyObj s1; + MyObj s2; + MyObj* p = &s1; + POINT(before_loop); + for (int i = 0; i < count; ++i) { + if (i == 5) { + p = &s2; + POINT(inside_if); + break; + } + POINT(after_if); + } + POINT(after_loop); + } + )"); + EXPECT_THAT(Origin("p"), HasLoansTo({"s1"}, "before_loop")); + EXPECT_THAT(Origin("p"), HasLoansTo({"s2"}, "inside_if")); + // At the join point after if, s2 cannot make it to p without the if. + EXPECT_THAT(Origin("p"), HasLoansTo({"s1"}, "after_if")); + // At the join point after the loop, p could hold a loan to s1 (if the loop + // completed normally) or to s2 (if the loop was broken). + EXPECT_THAT(Origin("p"), HasLoansTo({"s1", "s2"}, "after_loop")); +} + +TEST_F(LifetimeAnalysisTest, PointersInACycle) { + SetupTest(R"( + void target(bool condition) { + MyObj v1, v2, v3; + MyObj *p1 = &v1, *p2 = &v2, *p3 = &v3; + + POINT(before_while); + while (condition) { + MyObj* temp = p1; + p1 = p2; + p2 = p3; + p3 = temp; + } + POINT(after_loop); + } + )"); + EXPECT_THAT(Origin("p1"), HasLoansTo({"v1"}, "before_while")); + EXPECT_THAT(Origin("p2"), HasLoansTo({"v2"}, "before_while")); + EXPECT_THAT(Origin("p3"), HasLoansTo({"v3"}, "before_while")); + + // At the fixed point after the loop, all pointers could point to any of + // the three variables. + EXPECT_THAT(Origin("p1"), HasLoansTo({"v1", "v2", "v3"}, "after_loop")); + EXPECT_THAT(Origin("p2"), HasLoansTo({"v1", "v2", "v3"}, "after_loop")); + EXPECT_THAT(Origin("p3"), HasLoansTo({"v1", "v2", "v3"}, "after_loop")); + EXPECT_THAT(Origin("temp"), HasLoansTo({"v1", "v2", "v3"}, "after_loop")); +} + +TEST_F(LifetimeAnalysisTest, PointersAndExpirationInACycle) { + SetupTest(R"( + void target(bool condition) { + MyObj v1, v2; + MyObj *p1 = &v1, *p2 = &v2; + + POINT(before_while); + while (condition) { + POINT(in_loop_before_temp); + MyObj temp; + p1 = &temp; + POINT(in_loop_after_temp); + + MyObj* q = p1; + p1 = p2; + p2 = q; + } + POINT(after_loop); + } + )"); + EXPECT_THAT(Origin("p1"), HasLoansTo({"v1"}, "before_while")); + EXPECT_THAT(Origin("p2"), HasLoansTo({"v2"}, "before_while")); + EXPECT_THAT(NoLoans(), AreExpiredAt("before_while")); + + EXPECT_THAT(Origin("p1"), + HasLoansTo({"v1", "v2", "temp"}, "in_loop_before_temp")); + EXPECT_THAT(Origin("p2"), HasLoansTo({"v2", "temp"}, "in_loop_before_temp")); + EXPECT_THAT(LoansTo({"temp"}), AreExpiredAt("in_loop_before_temp")); + + EXPECT_THAT(Origin("p1"), HasLoansTo({"temp"}, "in_loop_after_temp")); + EXPECT_THAT(Origin("p2"), HasLoansTo({"v2", "temp"}, "in_loop_after_temp")); + EXPECT_THAT(NoLoans(), AreExpiredAt("in_loop_after_temp")); + + EXPECT_THAT(Origin("p1"), HasLoansTo({"v1", "v2", "temp"}, "after_loop")); + EXPECT_THAT(Origin("p2"), HasLoansTo({"v2", "temp"}, "after_loop")); + EXPECT_THAT(LoansTo({"temp"}), AreExpiredAt("after_loop")); +} + +TEST_F(LifetimeAnalysisTest, NestedScopes) { + SetupTest(R"( + void target() { + MyObj* p = nullptr; + { + MyObj outer; + p = &outer; + POINT(before_inner_scope); + { + MyObj inner; + p = &inner; + POINT(inside_inner_scope); + } // inner expires + POINT(after_inner_scope); + } // outer expires + } + )"); + EXPECT_THAT(Origin("p"), HasLoansTo({"outer"}, "before_inner_scope")); + EXPECT_THAT(Origin("p"), HasLoansTo({"inner"}, "inside_inner_scope")); + EXPECT_THAT(Origin("p"), HasLoansTo({"inner"}, "after_inner_scope")); +} + +TEST_F(LifetimeAnalysisTest, SimpleExpiry) { + SetupTest(R"( + void target() { + MyObj* p = nullptr; + { + MyObj s; + p = &s; + POINT(before_expiry); + } // s goes out of scope here + POINT(after_expiry); + } + )"); + EXPECT_THAT(NoLoans(), AreExpiredAt("before_expiry")); + EXPECT_THAT(LoansTo({"s"}), AreExpiredAt("after_expiry")); +} + +TEST_F(LifetimeAnalysisTest, NestedExpiry) { + SetupTest(R"( + void target() { + MyObj s1; + MyObj* p = &s1; + POINT(before_inner); + { + MyObj s2; + p = &s2; + POINT(in_inner); + } // s2 expires + POINT(after_inner); + } + )"); + EXPECT_THAT(NoLoans(), AreExpiredAt("before_inner")); + EXPECT_THAT(NoLoans(), AreExpiredAt("in_inner")); + EXPECT_THAT(LoansTo({"s2"}), AreExpiredAt("after_inner")); +} + +TEST_F(LifetimeAnalysisTest, ConditionalExpiry) { + SetupTest(R"( + void target(bool cond) { + MyObj s1; + MyObj* p = &s1; + POINT(before_if); + if (cond) { + MyObj s2; + p = &s2; + POINT(then_block); + } // s2 expires here + POINT(after_if); + } + )"); + EXPECT_THAT(NoLoans(), AreExpiredAt("before_if")); + EXPECT_THAT(NoLoans(), AreExpiredAt("then_block")); + EXPECT_THAT(LoansTo({"s2"}), AreExpiredAt("after_if")); +} + +TEST_F(LifetimeAnalysisTest, LoopExpiry) { + SetupTest(R"( + void target() { + MyObj *p = nullptr; + for (int i = 0; i < 2; ++i) { + POINT(start_loop); + MyObj s; + p = &s; + POINT(end_loop); + } // s expires here on each iteration + POINT(after_loop); + } + )"); + EXPECT_THAT(LoansTo({"s"}), AreExpiredAt("start_loop")); + EXPECT_THAT(NoLoans(), AreExpiredAt("end_loop")); + EXPECT_THAT(LoansTo({"s"}), AreExpiredAt("after_loop")); +} + +TEST_F(LifetimeAnalysisTest, MultipleExpiredLoans) { + SetupTest(R"( + void target() { + MyObj *p1, *p2, *p3; + { + MyObj s1; + p1 = &s1; + POINT(p1); + } // s1 expires + POINT(p2); + { + MyObj s2; + p2 = &s2; + MyObj s3; + p3 = &s3; + POINT(p3); + } // s2, s3 expire + POINT(p4); + } + )"); + EXPECT_THAT(NoLoans(), AreExpiredAt("p1")); + EXPECT_THAT(LoansTo({"s1"}), AreExpiredAt("p2")); + EXPECT_THAT(LoansTo({"s1"}), AreExpiredAt("p3")); + EXPECT_THAT(LoansTo({"s1", "s2", "s3"}), AreExpiredAt("p4")); +} + +TEST_F(LifetimeAnalysisTest, GotoJumpsOutOfScope) { + SetupTest(R"( + void target(bool cond) { + MyObj *p = nullptr; + { + MyObj s; + p = &s; + POINT(before_goto); + if (cond) { + goto end; + } + } // `s` expires here on the path that doesn't jump + POINT(after_scope); + end: + POINT(after_goto); + } + )"); + EXPECT_THAT(NoLoans(), AreExpiredAt("before_goto")); + EXPECT_THAT(LoansTo({"s"}), AreExpiredAt("after_scope")); + EXPECT_THAT(LoansTo({"s"}), AreExpiredAt("after_goto")); +} + +TEST_F(LifetimeAnalysisTest, ContinueInLoop) { + SetupTest(R"( + void target(int count) { + MyObj *p = nullptr; + MyObj outer; + p = &outer; + POINT(before_loop); + + for (int i = 0; i < count; ++i) { + if (i % 2 == 0) { + MyObj s_even; + p = &s_even; + POINT(in_even_iter); + continue; + } + MyObj s_odd; + p = &s_odd; + POINT(in_odd_iter); + } + POINT(after_loop); + } + )"); + EXPECT_THAT(NoLoans(), AreExpiredAt("before_loop")); + EXPECT_THAT(LoansTo({"s_odd"}), AreExpiredAt("in_even_iter")); + EXPECT_THAT(LoansTo({"s_even"}), AreExpiredAt("in_odd_iter")); + EXPECT_THAT(LoansTo({"s_even", "s_odd"}), AreExpiredAt("after_loop")); +} + +TEST_F(LifetimeAnalysisTest, ReassignedPointerThenOriginalExpires) { + SetupTest(R"( + void target() { + MyObj* p = nullptr; + { + MyObj s1; + p = &s1; + POINT(p_has_s1); + { + MyObj s2; + p = &s2; + POINT(p_has_s2); + } + POINT(p_after_s2_expires); + } // s1 expires here. + POINT(p_after_s1_expires); + } + )"); + EXPECT_THAT(NoLoans(), AreExpiredAt("p_has_s1")); + EXPECT_THAT(NoLoans(), AreExpiredAt("p_has_s2")); + EXPECT_THAT(LoansTo({"s2"}), AreExpiredAt("p_after_s2_expires")); + EXPECT_THAT(LoansTo({"s1", "s2"}), AreExpiredAt("p_after_s1_expires")); +} + +} // anonymous namespace +} // namespace clang::lifetimes::internal diff --git a/clang/unittests/Format/BracesInserterTest.cpp b/clang/unittests/Format/BracesInserterTest.cpp index e0c447d..572e53e 100644 --- a/clang/unittests/Format/BracesInserterTest.cpp +++ b/clang/unittests/Format/BracesInserterTest.cpp @@ -257,9 +257,9 @@ TEST_F(BracesInserterTest, InsertBracesRange) { FormatStyle Style = getLLVMStyle(); Style.InsertBraces = true; - const StringRef Code("while (a)\n" - " if (b)\n" - " return;"); + constexpr StringRef Code("while (a)\n" + " if (b)\n" + " return;"); verifyFormat("while (a) {\n" " if (b)\n" diff --git a/clang/unittests/Format/ConfigParseTest.cpp b/clang/unittests/Format/ConfigParseTest.cpp index 65d8b36..9de3cca 100644 --- a/clang/unittests/Format/ConfigParseTest.cpp +++ b/clang/unittests/Format/ConfigParseTest.cpp @@ -249,6 +249,7 @@ TEST(ConfigParseTest, ParsesConfigurationBools) { CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterFunctionDefinitionName); CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterIfMacros); + CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterNot); CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterOverloadedOperator); CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterPlacementOperator); CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, BeforeNonEmptyParentheses); diff --git a/clang/unittests/Format/FormatTest.cpp b/clang/unittests/Format/FormatTest.cpp index 0bc1c6d..9c5aa11 100644 --- a/clang/unittests/Format/FormatTest.cpp +++ b/clang/unittests/Format/FormatTest.cpp @@ -3185,7 +3185,7 @@ TEST_F(FormatTest, FormatsLabels) { // The opening brace may either be on the same unwrapped line as the colon or // on a separate one. The formatter should recognize both. Style = getLLVMStyle(); - Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Allman; + Style.BreakBeforeBraces = FormatStyle::BS_Allman; verifyFormat("{\n" " some_code();\n" "test_label:\n" @@ -3206,7 +3206,7 @@ TEST_F(FormatTest, FormatsLabels) { TEST_F(FormatTest, MultiLineControlStatements) { FormatStyle Style = getLLVMStyleWithColumns(20); - Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; + Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine; // Short lines should keep opening brace on same line. verifyFormat("if (foo) {\n" @@ -3441,7 +3441,7 @@ TEST_F(FormatTest, MultiLineControlStatements) { TEST_F(FormatTest, BeforeWhile) { FormatStyle Style = getLLVMStyle(); - Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; + Style.BreakBeforeBraces = FormatStyle::BS_Custom; verifyFormat("do {\n" " foo();\n" @@ -4803,12 +4803,13 @@ TEST_F(FormatTest, FormatsInlineASM) { "int i;"); auto Style = getLLVMStyleWithColumns(0); - const StringRef Code1{"asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"}; - const StringRef Code2{"asm(\"xyz\"\n" - " : \"=a\"(a), \"=d\"(b)\n" - " : \"a\"(data));"}; - const StringRef Code3{"asm(\"xyz\" : \"=a\"(a), \"=d\"(b)\n" - " : \"a\"(data));"}; + constexpr StringRef Code1( + "asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); + constexpr StringRef Code2("asm(\"xyz\"\n" + " : \"=a\"(a), \"=d\"(b)\n" + " : \"a\"(data));"); + constexpr StringRef Code3("asm(\"xyz\" : \"=a\"(a), \"=d\"(b)\n" + " : \"a\"(data));"); Style.BreakBeforeInlineASMColon = FormatStyle::BBIAS_OnlyMultiline; verifyFormat(Code1, Style); @@ -6681,6 +6682,17 @@ TEST_F(FormatTest, EscapedNewlines) { " int x(int a);", AlignLeft); + // Escaped with a trigraph. The program just has to avoid crashing. + verifyNoCrash("#define A \?\?/\n" + "int i;\?\?/\n" + " int j;"); + verifyNoCrash("#define A \?\?/\r\n" + "int i;\?\?/\r\n" + " int j;"); + verifyNoCrash("#define A \?\?/\n" + "int i;", + getGoogleStyle(FormatStyle::LK_CSharp)); + // CRLF line endings verifyFormat("#define A \\\r\n int i; \\\r\n int j;", "#define A \\\r\nint i;\\\r\n int j;", Narrow); @@ -6693,16 +6705,16 @@ TEST_F(FormatTest, EscapedNewlines) { " int x(int a);", AlignLeft); - constexpr StringRef Code{"#define A \\\n" + constexpr StringRef Code("#define A \\\n" " int a123; \\\n" " int a; \\\n" - " int a1234;"}; + " int a1234;"); verifyFormat(Code, AlignLeft); - constexpr StringRef Code2{"#define A \\\n" + constexpr StringRef Code2("#define A \\\n" " int a123; \\\n" " int a; \\\n" - " int a1234;"}; + " int a1234;"); auto LastLine = getLLVMStyle(); LastLine.AlignEscapedNewlines = FormatStyle::ENAS_LeftWithLastLine; verifyFormat(Code2, LastLine); @@ -7771,6 +7783,16 @@ TEST_F(FormatTest, ConstructorInitializers) { "Constructor() :\n" " // Comment forcing unwanted break.\n" " aaaa(aaaa) {}"); + + // Braced initializers with trailing commas. + verifyFormat("MyClass::MyClass()\n" + " : aaaa{\n" + " 0,\n" + " },\n" + " bbbb{\n" + " 0,\n" + " } {}", + "MyClass::MyClass():aaaa{0,},bbbb{0,}{}"); } TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { @@ -8571,10 +8593,10 @@ TEST_F(FormatTest, BreaksFunctionDeclarations) { "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); verifyGoogleFormat( "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" - " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); + " const SomeLooooooooogType& a, const SomeLooooooooogType& b);"); verifyGoogleFormat( "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" - " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); + " const SomeLooooooooogType& a, const SomeLooooooooogType& b);"); verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); @@ -8583,7 +8605,7 @@ TEST_F(FormatTest, BreaksFunctionDeclarations) { verifyGoogleFormat( "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" - " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); + " bool* aaaaaaaaaaaaaaaaaa, bool* aa) {}"); verifyGoogleFormat("template <typename T>\n" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" @@ -12091,15 +12113,22 @@ TEST_F(FormatTest, UnderstandsFunctionRefQualification) { Prefix = "void a() const &;\n" "void b() const &;\n"; verifyFormat(Prefix + "int *x;", Prefix + "int* x;", DerivePointerAlignment); + + constexpr StringRef Code("MACRO(int*, std::function<void() &&>);"); + verifyFormat(Code, DerivePointerAlignment); + + auto Style = getGoogleStyle(); + Style.DerivePointerAlignment = true; + verifyFormat(Code, Style); } TEST_F(FormatTest, PointerAlignmentFallback) { FormatStyle Style = getLLVMStyle(); Style.DerivePointerAlignment = true; - const StringRef Code("int* p;\n" - "int *q;\n" - "int * r;"); + constexpr StringRef Code("int* p;\n" + "int *q;\n" + "int * r;"); EXPECT_EQ(Style.PointerAlignment, FormatStyle::PAS_Right); verifyFormat("int *p;\n" @@ -12891,27 +12920,31 @@ TEST_F(FormatTest, UnderstandsEllipsis) { } TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { + auto Style = getGoogleStyle(); + EXPECT_FALSE(Style.DerivePointerAlignment); + Style.DerivePointerAlignment = true; + verifyFormat("int *a;\n" "int *a;\n" "int *a;", "int *a;\n" "int* a;\n" "int *a;", - getGoogleStyle()); + Style); verifyFormat("int* a;\n" "int* a;\n" "int* a;", "int* a;\n" "int* a;\n" "int *a;", - getGoogleStyle()); + Style); verifyFormat("int *a;\n" "int *a;\n" "int *a;", "int *a;\n" "int * a;\n" "int * a;", - getGoogleStyle()); + Style); verifyFormat("auto x = [] {\n" " int *a;\n" " int *a;\n" @@ -12920,7 +12953,7 @@ TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { "auto x=[]{int *a;\n" "int * a;\n" "int * a;};", - getGoogleStyle()); + Style); } TEST_F(FormatTest, UnderstandsRvalueReferences) { @@ -13056,7 +13089,7 @@ TEST_F(FormatTest, FormatsCasts) { verifyFormat("virtual void foo(char &) const;"); verifyFormat("virtual void foo(int *a, char *) const;"); verifyFormat("int a = sizeof(int *) + b;"); - verifyGoogleFormat("int a = alignof(int *) + b;"); + verifyGoogleFormat("int a = alignof(int*) + b;"); verifyFormat("bool b = f(g<int>) && c;"); verifyFormat("typedef void (*f)(int i) func;"); verifyFormat("void operator++(int) noexcept;"); @@ -15014,7 +15047,7 @@ TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { " aaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {}"); - constexpr StringRef Code{"void foo() { /* Empty */ }"}; + constexpr StringRef Code("void foo() { /* Empty */ }"); verifyFormat(Code); verifyFormat(Code, "void foo() { /* Empty */\n" "}"); @@ -17652,6 +17685,12 @@ TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { verifyFormat("int x = int (y);", SomeSpace2); verifyFormat("auto lambda = []() { return 0; };", SomeSpace2); + auto Style = getLLVMStyle(); + Style.SpaceBeforeParens = FormatStyle::SBPO_Custom; + EXPECT_FALSE(Style.SpaceBeforeParensOptions.AfterNot); + Style.SpaceBeforeParensOptions.AfterNot = true; + verifyFormat("return not (a || b);", Style); + FormatStyle SpaceAfterOverloadedOperator = getLLVMStyle(); SpaceAfterOverloadedOperator.SpaceBeforeParens = FormatStyle::SBPO_Custom; SpaceAfterOverloadedOperator.SpaceBeforeParensOptions @@ -23779,7 +23818,7 @@ TEST_F(FormatTest, FormatsLambdas) { LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom; LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true; LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = - FormatStyle::ShortLambdaStyle::SLS_None; + FormatStyle::SLS_None; verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n" " []()\n" " {\n" @@ -23815,7 +23854,7 @@ TEST_F(FormatTest, FormatsLambdas) { LLVMWithBeforeLambdaBody); LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = - FormatStyle::ShortLambdaStyle::SLS_Empty; + FormatStyle::SLS_Empty; verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n" " []()\n" " {\n" @@ -23862,7 +23901,7 @@ TEST_F(FormatTest, FormatsLambdas) { LLVMWithBeforeLambdaBody); LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = - FormatStyle::ShortLambdaStyle::SLS_Inline; + FormatStyle::SLS_Inline; verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });", LLVMWithBeforeLambdaBody); verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});", @@ -23893,7 +23932,7 @@ TEST_F(FormatTest, FormatsLambdas) { LLVMWithBeforeLambdaBody); LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = - FormatStyle::ShortLambdaStyle::SLS_All; + FormatStyle::SLS_All; verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });", LLVMWithBeforeLambdaBody); verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});", @@ -24025,7 +24064,7 @@ TEST_F(FormatTest, FormatsLambdas) { LLVMWithBeforeLambdaBody); LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = - FormatStyle::ShortLambdaStyle::SLS_None; + FormatStyle::SLS_None; verifyFormat("auto select = [this]() -> const Library::Object *\n" "{\n" @@ -24273,7 +24312,7 @@ TEST_F(FormatTest, LambdaWithLineComments) { LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom; LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true; LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = - FormatStyle::ShortLambdaStyle::SLS_All; + FormatStyle::SLS_All; verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody); verifyFormat("auto k = []() // comment\n" @@ -25419,7 +25458,7 @@ TEST_F(FormatTest, AtomicQualifier) { verifyFormat("struct foo {\n" " int a1;\n" " _Atomic(a) a2;\n" - " _Atomic(_Atomic(int) *const) a3;\n" + " _Atomic(_Atomic(int)* const) a3;\n" "};", Google); verifyFormat("_Atomic(uint64_t) a;"); @@ -27244,7 +27283,7 @@ TEST_F(FormatTest, IndentAccessModifiers) { TEST_F(FormatTest, LimitlessStringsAndComments) { auto Style = getLLVMStyleWithColumns(0); - constexpr StringRef Code = + constexpr StringRef Code( "/**\n" " * This is a multiline comment with quite some long lines, at least for " "the LLVM Style.\n" @@ -27265,7 +27304,7 @@ TEST_F(FormatTest, LimitlessStringsAndComments) { " const std::string SmallString = \"Hello World\";\n" " // Small line comment\n" " return String.size() > SmallString.size();\n" - "}"; + "}"); verifyNoChange(Code, Style); } @@ -28371,10 +28410,15 @@ TEST_F(FormatTest, BreakAfterAttributes) { "Foo &operator-(Foo &);", Style); - Style.ReferenceAlignment = FormatStyle::ReferenceAlignmentStyle::RAS_Left; + Style.ReferenceAlignment = FormatStyle::RAS_Left; verifyFormat("[[nodiscard]]\n" "Foo& operator-(Foo&);", Style); + + Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; + verifyFormat("[[deprecated]]\n" + "void f() = delete;", + Style); } TEST_F(FormatTest, InsertNewlineAtEOF) { @@ -28384,9 +28428,9 @@ TEST_F(FormatTest, InsertNewlineAtEOF) { verifyNoChange("int i;\n", Style); verifyFormat("int i;\n", "int i;", Style); - constexpr StringRef Code{"namespace {\n" + constexpr StringRef Code("namespace {\n" "int i;\n" - "} // namespace"}; + "} // namespace"); verifyFormat(Code.str() + '\n', Code, Style, {tooling::Range(19, 13)}); // line 3 } @@ -28395,7 +28439,7 @@ TEST_F(FormatTest, KeepEmptyLinesAtEOF) { FormatStyle Style = getLLVMStyle(); Style.KeepEmptyLines.AtEndOfFile = true; - const StringRef Code{"int i;\n\n"}; + constexpr StringRef Code("int i;\n\n"); verifyNoChange(Code, Style); verifyFormat(Code, "int i;\n\n\n", Style); } @@ -28628,8 +28672,8 @@ TEST_F(FormatTest, PPDirectivesAndCommentsInBracedInit) { } TEST_F(FormatTest, BreakAdjacentStringLiterals) { - constexpr StringRef Code{ - "return \"Code\" \"\\0\\52\\26\\55\\55\\0\" \"x013\" \"\\02\\xBA\";"}; + constexpr StringRef Code( + "return \"Code\" \"\\0\\52\\26\\55\\55\\0\" \"x013\" \"\\02\\xBA\";"); verifyFormat("return \"Code\"\n" " \"\\0\\52\\26\\55\\55\\0\"\n" @@ -29040,9 +29084,9 @@ TEST_F(FormatTest, KeepFormFeed) { auto Style = getLLVMStyle(); Style.KeepFormFeed = true; - constexpr StringRef NoFormFeed{"int i;\n" + constexpr StringRef NoFormFeed("int i;\n" "\n" - "void f();"}; + "void f();"); verifyFormat(NoFormFeed, "int i;\n" " \f\n" @@ -29064,9 +29108,9 @@ TEST_F(FormatTest, KeepFormFeed) { "void f();\f", Style); - constexpr StringRef FormFeed{"int i;\n" + constexpr StringRef FormFeed("int i;\n" "\f\n" - "void f();"}; + "void f();"); verifyNoChange(FormFeed, Style); Style.LineEnding = FormatStyle::LE_LF; @@ -29076,10 +29120,10 @@ TEST_F(FormatTest, KeepFormFeed) { "void f();", Style); - constexpr StringRef FormFeedBeforeEmptyLine{"int i;\n" + constexpr StringRef FormFeedBeforeEmptyLine("int i;\n" "\f\n" "\n" - "void f();"}; + "void f();"); Style.MaxEmptyLinesToKeep = 2; verifyFormat(FormFeedBeforeEmptyLine, "int i;\n" diff --git a/clang/unittests/Format/FormatTestComments.cpp b/clang/unittests/Format/FormatTestComments.cpp index 8870755..69026bc 100644 --- a/clang/unittests/Format/FormatTestComments.cpp +++ b/clang/unittests/Format/FormatTestComments.cpp @@ -1120,11 +1120,11 @@ TEST_F(FormatTestComments, KeepsLevelOfCommentBeforePPDirective) { " }\n" "}")); - const StringRef Code("void func() {\n" - " // clang-format off\n" - " #define KV(value) #value, value\n" - " // clang-format on\n" - "}"); + constexpr StringRef Code("void func() {\n" + " // clang-format off\n" + " #define KV(value) #value, value\n" + " // clang-format on\n" + "}"); verifyNoChange(Code); auto Style = getLLVMStyle(); diff --git a/clang/unittests/Format/FormatTestJava.cpp b/clang/unittests/Format/FormatTestJava.cpp index ca5aba0..1275564 100644 --- a/clang/unittests/Format/FormatTestJava.cpp +++ b/clang/unittests/Format/FormatTestJava.cpp @@ -631,17 +631,17 @@ TEST_F(FormatTestJava, SwitchExpression) { "});", Style); - constexpr StringRef Code1{"i = switch (day) {\n" + constexpr StringRef Code1("i = switch (day) {\n" " case THURSDAY, SATURDAY -> 8;\n" " case WEDNESDAY -> 9;\n" " default -> 0;\n" - "};"}; + "};"); verifyFormat(Code1, Style); Style.IndentCaseLabels = true; verifyFormat(Code1, Style); - constexpr StringRef Code2{"i = switch (day) {\n" + constexpr StringRef Code2("i = switch (day) {\n" " case THURSDAY, SATURDAY -> {\n" " foo();\n" " yield 8;\n" @@ -653,17 +653,17 @@ TEST_F(FormatTestJava, SwitchExpression) { " default -> {\n" " yield 0;\n" " }\n" - "};"}; + "};"); verifyFormat(Code2, Style); Style.IndentCaseLabels = false; verifyFormat(Code2, Style); - constexpr StringRef Code3{"switch (day) {\n" + constexpr StringRef Code3("switch (day) {\n" "case THURSDAY, SATURDAY -> i = 8;\n" "case WEDNESDAY -> i = 9;\n" "default -> i = 0;\n" - "};"}; + "};"); verifyFormat(Code3, Style); Style.IndentCaseLabels = true; diff --git a/clang/unittests/Format/FormatTestSelective.cpp b/clang/unittests/Format/FormatTestSelective.cpp index 0b7ac21..1a01153 100644 --- a/clang/unittests/Format/FormatTestSelective.cpp +++ b/clang/unittests/Format/FormatTestSelective.cpp @@ -672,15 +672,14 @@ TEST_F(FormatTestSelective, FormatMacroRegardlessOfPreviousIndent) { // need to be adapted. Style = getLLVMStyle(); - const StringRef Code{" class Foo {\n" - " void test() {\n" - " #ifdef 1\n" - " #define some\n" // format this line - " #endif\n" - " }};"}; - - EXPECT_EQ(Style.IndentPPDirectives, - FormatStyle::PPDirectiveIndentStyle::PPDIS_None); + constexpr StringRef Code(" class Foo {\n" + " void test() {\n" + " #ifdef 1\n" + " #define some\n" // format this line + " #endif\n" + " }};"); + + EXPECT_EQ(Style.IndentPPDirectives, FormatStyle::PPDIS_None); EXPECT_EQ(" class Foo {\n" " void test() {\n" " #ifdef 1\n" @@ -689,8 +688,7 @@ TEST_F(FormatTestSelective, FormatMacroRegardlessOfPreviousIndent) { " }};", // Ditto: Bug? format(Code, 57, 0)); - Style.IndentPPDirectives = - FormatStyle::PPDirectiveIndentStyle::PPDIS_BeforeHash; + Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; EXPECT_EQ(" class Foo {\n" " void test() {\n" " #ifdef 1\n" @@ -699,8 +697,7 @@ TEST_F(FormatTestSelective, FormatMacroRegardlessOfPreviousIndent) { " }};", format(Code, 57, 0)); - Style.IndentPPDirectives = - FormatStyle::PPDirectiveIndentStyle::PPDIS_AfterHash; + Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; EXPECT_EQ(" class Foo {\n" " void test() {\n" " #ifdef 1\n" diff --git a/clang/unittests/Format/IntegerLiteralSeparatorTest.cpp b/clang/unittests/Format/IntegerLiteralSeparatorTest.cpp index b1e42e9..53b6dd8 100644 --- a/clang/unittests/Format/IntegerLiteralSeparatorTest.cpp +++ b/clang/unittests/Format/IntegerLiteralSeparatorTest.cpp @@ -24,7 +24,7 @@ TEST_F(IntegerLiteralSeparatorTest, SingleQuoteAsSeparator) { EXPECT_EQ(Style.IntegerLiteralSeparator.Decimal, 0); EXPECT_EQ(Style.IntegerLiteralSeparator.Hex, 0); - const StringRef Binary("b = 0b10011'11'0110'1u;"); + constexpr StringRef Binary("b = 0b10011'11'0110'1u;"); verifyFormat(Binary, Style); Style.IntegerLiteralSeparator.Binary = -1; verifyFormat("b = 0b100111101101u;", Binary, Style); @@ -33,14 +33,14 @@ TEST_F(IntegerLiteralSeparatorTest, SingleQuoteAsSeparator) { Style.IntegerLiteralSeparator.Binary = 4; verifyFormat("b = 0b1001'1110'1101u;", Binary, Style); - const StringRef Decimal("d = 184467'440737'0'95505'92Ull;"); + constexpr StringRef Decimal("d = 184467'440737'0'95505'92Ull;"); verifyFormat(Decimal, Style); Style.IntegerLiteralSeparator.Decimal = -1; verifyFormat("d = 18446744073709550592Ull;", Decimal, Style); Style.IntegerLiteralSeparator.Decimal = 3; verifyFormat("d = 18'446'744'073'709'550'592Ull;", Decimal, Style); - const StringRef Hex("h = 0xDEAD'BEEF'DE'AD'BEE'Fuz;"); + constexpr StringRef Hex("h = 0xDEAD'BEEF'DE'AD'BEE'Fuz;"); verifyFormat(Hex, Style); Style.IntegerLiteralSeparator.Hex = -1; verifyFormat("h = 0xDEADBEEFDEADBEEFuz;", Hex, Style); @@ -83,13 +83,16 @@ TEST_F(IntegerLiteralSeparatorTest, SingleQuoteAsSeparator) { "d = 5678_km;\n" "h = 0xDEF_u16;", Style); + + Style.Standard = FormatStyle::LS_Cpp11; + verifyFormat("ld = 1234L;", Style); } TEST_F(IntegerLiteralSeparatorTest, UnderscoreAsSeparator) { FormatStyle Style = getLLVMStyle(); - const StringRef Binary("B = 0B10011_11_0110_1;"); - const StringRef Decimal("d = 184467_440737_0_95505_92;"); - const StringRef Hex("H = 0XDEAD_BEEF_DE_AD_BEE_F;"); + constexpr StringRef Binary("B = 0B10011_11_0110_1;"); + constexpr StringRef Decimal("d = 184467_440737_0_95505_92;"); + constexpr StringRef Hex("H = 0XDEAD_BEEF_DE_AD_BEE_F;"); auto TestUnderscore = [&](auto Language) { Style.Language = Language; @@ -173,16 +176,16 @@ TEST_F(IntegerLiteralSeparatorTest, FixRanges) { FormatStyle Style = getLLVMStyle(); Style.IntegerLiteralSeparator.Decimal = 3; - const StringRef Code("i = -12'34;\n" - "// clang-format off\n" - "j = 123'4;\n" - "// clang-format on\n" - "k = +1'23'4;"); - const StringRef Expected("i = -1'234;\n" + constexpr StringRef Code("i = -12'34;\n" "// clang-format off\n" "j = 123'4;\n" "// clang-format on\n" - "k = +1'234;"); + "k = +1'23'4;"); + constexpr StringRef Expected("i = -1'234;\n" + "// clang-format off\n" + "j = 123'4;\n" + "// clang-format on\n" + "k = +1'234;"); verifyFormat(Expected, Code, Style); diff --git a/clang/unittests/Format/SortIncludesTest.cpp b/clang/unittests/Format/SortIncludesTest.cpp index 5194d65..48ecd5d 100644 --- a/clang/unittests/Format/SortIncludesTest.cpp +++ b/clang/unittests/Format/SortIncludesTest.cpp @@ -1084,10 +1084,10 @@ TEST_F(SortIncludesTest, DoNotSortLikelyXml) { } TEST_F(SortIncludesTest, DoNotSortCSharp) { - constexpr StringRef Code{"const string expectedDataStruct = @\"\n" + constexpr StringRef Code("const string expectedDataStruct = @\"\n" " #include <b.h>\n" " #include <a.h>\n" - " \";"}; + " \";"); FmtStyle.Language = FormatStyle::LK_CSharp; EXPECT_TRUE(sortIncludes(FmtStyle, Code, GetCodeRange(Code), "a.cs").empty()); } diff --git a/clang/unittests/Format/TokenAnnotatorTest.cpp b/clang/unittests/Format/TokenAnnotatorTest.cpp index ce7787e..7f99655 100644 --- a/clang/unittests/Format/TokenAnnotatorTest.cpp +++ b/clang/unittests/Format/TokenAnnotatorTest.cpp @@ -618,7 +618,7 @@ TEST_F(TokenAnnotatorTest, UnderstandsStructs) { EXPECT_TOKEN(Tokens[19], tok::l_brace, TT_StructLBrace); EXPECT_TOKEN(Tokens[20], tok::r_brace, TT_StructRBrace); - constexpr StringRef Code{"struct EXPORT StructName {};"}; + constexpr StringRef Code("struct EXPORT StructName {};"); Tokens = annotate(Code); ASSERT_EQ(Tokens.size(), 7u) << Tokens; @@ -3958,7 +3958,7 @@ TEST_F(TokenAnnotatorTest, SplitPenalty) { } TEST_F(TokenAnnotatorTest, TemplateName) { - constexpr StringRef Code{"return Foo < A || B > (C ^ D);"}; + constexpr StringRef Code("return Foo < A || B > (C ^ D);"); auto Tokens = annotate(Code); ASSERT_EQ(Tokens.size(), 14u) << Tokens; diff --git a/clang/unittests/Interpreter/InterpreterTest.cpp b/clang/unittests/Interpreter/InterpreterTest.cpp index b97f5ae..768058b 100644 --- a/clang/unittests/Interpreter/InterpreterTest.cpp +++ b/clang/unittests/Interpreter/InterpreterTest.cpp @@ -22,6 +22,8 @@ #include "clang/Sema/Lookup.h" #include "clang/Sema/Sema.h" +#include "llvm/TargetParser/Host.h" + #include "gmock/gmock.h" #include "gtest/gtest.h" @@ -158,12 +160,12 @@ TEST_F(InterpreterTest, UndoCommand) { // Fail to undo. auto Err1 = Interp->Undo(); - EXPECT_EQ("Operation failed. Too many undos", + EXPECT_EQ("Operation failed. No input left to undo", llvm::toString(std::move(Err1))); auto Err2 = Interp->Parse("int foo = 42;"); EXPECT_TRUE(!!Err2); auto Err3 = Interp->Undo(2); - EXPECT_EQ("Operation failed. Too many undos", + EXPECT_EQ("Operation failed. Wanted to undo 2 inputs, only have 1.", llvm::toString(std::move(Err3))); // Succeed to undo. @@ -389,6 +391,26 @@ TEST_F(InterpreterTest, Value) { EXPECT_TRUE(V9.getType()->isMemberFunctionPointerType()); EXPECT_EQ(V9.getKind(), Value::K_PtrOrObj); EXPECT_TRUE(V9.isManuallyAlloc()); + + Value V10; + llvm::cantFail(Interp->ParseAndExecute( + "enum D : unsigned int {Zero = 0, One}; One", &V10)); + + std::string prettyType; + llvm::raw_string_ostream OSType(prettyType); + V10.printType(OSType); + EXPECT_STREQ(prettyType.c_str(), "D"); + + // FIXME: We should print only the value or the constant not the type. + std::string prettyData; + llvm::raw_string_ostream OSData(prettyData); + V10.printData(OSData); + EXPECT_STREQ(prettyData.c_str(), "(One) : unsigned int 1"); + + std::string prettyPrint; + llvm::raw_string_ostream OSPrint(prettyPrint); + V10.print(OSPrint); + EXPECT_STREQ(prettyPrint.c_str(), "(D) (One) : unsigned int 1\n"); } TEST_F(InterpreterTest, TranslationUnit_CanonicalDecl) { diff --git a/clang/unittests/Lex/DependencyDirectivesScannerTest.cpp b/clang/unittests/Lex/DependencyDirectivesScannerTest.cpp index 46dbb4d..ddc8792 100644 --- a/clang/unittests/Lex/DependencyDirectivesScannerTest.cpp +++ b/clang/unittests/Lex/DependencyDirectivesScannerTest.cpp @@ -640,14 +640,14 @@ TEST(MinimizeSourceToDependencyDirectivesTest, AtImport) { EXPECT_STREQ("@import A;\n", Out.data()); ASSERT_FALSE(minimizeSourceToDependencyDirectives("@import A\n;", Out)); - EXPECT_STREQ("@import A;\n", Out.data()); + EXPECT_STREQ("@import A\n;\n", Out.data()); ASSERT_FALSE(minimizeSourceToDependencyDirectives("@import A.B;\n", Out)); EXPECT_STREQ("@import A.B;\n", Out.data()); ASSERT_FALSE(minimizeSourceToDependencyDirectives( - "@import /*x*/ A /*x*/ . /*x*/ B /*x*/ \n /*x*/ ; /*x*/", Out)); - EXPECT_STREQ("@import A.B;\n", Out.data()); + "@import /*x*/ A /*x*/ . /*x*/ B /*x*/ \\n /*x*/ ; /*x*/", Out)); + EXPECT_STREQ("@import A.B\\n;\n", Out.data()); } TEST(MinimizeSourceToDependencyDirectivesTest, EmptyIncludesAndImports) { @@ -1122,16 +1122,23 @@ ort \ )"; ASSERT_FALSE( minimizeSourceToDependencyDirectives(Source, Out, Tokens, Directives)); - EXPECT_STREQ("#include \"textual-header.h\"\nexport module m;" - "exp\\\nort import:l[[rename]];" - "import<<=3;import a b d e d e f e;" - "import foo[[no_unique_address]];import foo();" - "import f(:sefse);import f(->a=3);" + + EXPECT_STREQ("module;\n" + "#include \"textual-header.h\"\n" + "export module m;\n" + "exp\\\nort import:l[[rename]];\n" + "import<<=3;\n" + "import a b d e d e f e;\n" + "import foo[[no_unique_address]];\n" + "import foo();\n" + "import f(:sefse);\n" + "import f(->a=3);\n" "<TokBeforeEOF>\n", Out.data()); - ASSERT_EQ(Directives.size(), 11u); - EXPECT_EQ(Directives[0].Kind, pp_include); - EXPECT_EQ(Directives[1].Kind, cxx_export_module_decl); + ASSERT_EQ(Directives.size(), 12u); + EXPECT_EQ(Directives[0].Kind, cxx_module_decl); + EXPECT_EQ(Directives[1].Kind, pp_include); + EXPECT_EQ(Directives[2].Kind, cxx_export_module_decl); } TEST(MinimizeSourceToDependencyDirectivesTest, ObjCMethodArgs) { diff --git a/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp b/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp index 4b24800..4d08f8d 100644 --- a/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp +++ b/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp @@ -136,15 +136,13 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseEmptyTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test no diagnostics produced Consumer->setNoDiag(); ASSERT_FALSE(Parser.parse()); - ASSERT_EQ((int)Elements.size(), 0); + ASSERT_EQ((int)Parser.getElements().size(), 0); ASSERT_TRUE(Consumer->isSatisfied()); } @@ -172,15 +170,14 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test no diagnostics produced Consumer->setNoDiag(); ASSERT_FALSE(Parser.parse()); + auto Elements = Parser.getElements(); // First Descriptor Table with 4 elements RootElement Elem = Elements[0].getElement(); ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); @@ -277,15 +274,14 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseStaticSamplerTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test no diagnostics produced Consumer->setNoDiag(); ASSERT_FALSE(Parser.parse()); + auto Elements = Parser.getElements(); ASSERT_EQ(Elements.size(), 2u); // Check default values are as expected @@ -364,15 +360,14 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseFloatsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test no diagnostics produced Consumer->setNoDiag(); ASSERT_FALSE(Parser.parse()); + auto Elements = Parser.getElements(); RootElement Elem = Elements[0].getElement(); ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 0.f); @@ -441,15 +436,14 @@ TEST_F(ParseHLSLRootSignatureTest, ValidSamplerFlagsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test no diagnostics produced Consumer->setNoDiag(); ASSERT_FALSE(Parser.parse()); + auto Elements = Parser.getElements(); RootElement Elem = Elements[0].getElement(); ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::Sampler); @@ -474,15 +468,14 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootConsantsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test no diagnostics produced Consumer->setNoDiag(); ASSERT_FALSE(Parser.parse()); + auto Elements = Parser.getElements(); ASSERT_EQ(Elements.size(), 2u); RootElement Elem = Elements[0].getElement(); @@ -533,15 +526,14 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootFlagsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test no diagnostics produced Consumer->setNoDiag(); ASSERT_FALSE(Parser.parse()); + auto Elements = Parser.getElements(); ASSERT_EQ(Elements.size(), 3u); RootElement Elem = Elements[0].getElement(); @@ -588,15 +580,14 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test no diagnostics produced Consumer->setNoDiag(); ASSERT_FALSE(Parser.parse()); + auto Elements = Parser.getElements(); ASSERT_EQ(Elements.size(), 4u); RootElement Elem = Elements[0].getElement(); @@ -664,9 +655,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidTrailingCommaTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test no diagnostics produced Consumer->setNoDiag(); @@ -697,15 +686,14 @@ TEST_F(ParseHLSLRootSignatureTest, ValidVersion10Test) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_0, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_0, Signature, *PP); // Test no diagnostics produced Consumer->setNoDiag(); ASSERT_FALSE(Parser.parse()); + auto Elements = Parser.getElements(); auto DefRootDescriptorFlag = llvm::dxbc::RootDescriptorFlags::DataVolatile; RootElement Elem = Elements[0].getElement(); ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); @@ -770,15 +758,14 @@ TEST_F(ParseHLSLRootSignatureTest, ValidVersion11Test) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test no diagnostics produced Consumer->setNoDiag(); ASSERT_FALSE(Parser.parse()); + auto Elements = Parser.getElements(); RootElement Elem = Elements[0].getElement(); ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, DescriptorType::CBuffer); @@ -838,9 +825,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidParseUnexpectedTokenTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_expected_either); @@ -860,9 +845,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidParseInvalidTokenTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced - invalid token Consumer->setExpected(diag::err_hlsl_invalid_token); @@ -882,9 +865,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidParseUnexpectedEndOfStreamTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced - expected '(' after DescriptorTable Consumer->setExpected(diag::err_expected_after); @@ -909,9 +890,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidMissingDTParameterTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_rootsig_missing_param); @@ -933,9 +912,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidMissingRDParameterTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_rootsig_missing_param); @@ -957,9 +934,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidMissingRCParameterTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_rootsig_missing_param); @@ -983,9 +958,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRepeatedMandatoryDTParameterTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_rootsig_repeat_param); @@ -1007,9 +980,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRepeatedMandatoryRCParameterTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_rootsig_repeat_param); @@ -1033,9 +1004,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRepeatedOptionalDTParameterTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_rootsig_repeat_param); @@ -1061,9 +1030,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRepeatedOptionalRCParameterTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_rootsig_repeat_param); @@ -1086,9 +1053,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidLexOverflowedNumberTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_number_literal_overflow); @@ -1110,9 +1075,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidParseOverflowedNegativeNumberTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_number_literal_overflow); @@ -1133,9 +1096,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidLexOverflowedFloatTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_number_literal_overflow); @@ -1156,9 +1117,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidLexNegOverflowedFloatTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_number_literal_overflow); @@ -1179,9 +1138,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidLexOverflowedDoubleTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_number_literal_overflow); @@ -1202,9 +1159,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidLexUnderflowFloatTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_number_literal_underflow); @@ -1228,9 +1183,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidNonZeroFlagsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_rootsig_non_zero_flag); @@ -1253,9 +1206,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRootElementMissingCommaTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_expected_either); @@ -1280,9 +1231,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidDescriptorTableMissingCommaTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_expected_either); @@ -1307,9 +1256,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRootConstantParamsCommaTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_expected_either); @@ -1334,9 +1281,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRootDescriptorParamsCommaTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_expected_either); @@ -1363,9 +1308,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidDescriptorClauseParamsCommaTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_expected_either); @@ -1390,9 +1333,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidStaticSamplerCommaTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_expected_either); @@ -1414,9 +1355,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRootDescriptorParamTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_invalid_token); @@ -1441,9 +1380,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidDescriptorTableParamTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_invalid_token); @@ -1467,9 +1404,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidDescriptorTableClauseParamTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_invalid_token); @@ -1496,9 +1431,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidStaticSamplerParamTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_invalid_token); @@ -1523,9 +1456,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidVisibilityValueTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_invalid_token); @@ -1549,9 +1480,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRegisterValueTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_invalid_token); @@ -1576,9 +1505,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidFilterValueTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_invalid_token); @@ -1603,9 +1530,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidTextureAddressModeValueTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_invalid_token); @@ -1630,9 +1555,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidComparisonFuncValueTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_invalid_token); @@ -1657,9 +1580,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidStaticBorderColorValueTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_invalid_token); @@ -1681,9 +1602,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRootFlagsValueTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_invalid_token); @@ -1705,9 +1624,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRootDescriptorFlagsValueTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_invalid_token); @@ -1733,9 +1650,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidDescriptorRangeFlagsValueTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootSignatureElement> Elements; - hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, - Signature, *PP); + hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Signature, *PP); // Test correct diagnostic produced Consumer->setExpected(diag::err_hlsl_invalid_token); diff --git a/clang/unittests/StaticAnalyzer/BlockEntranceCallbackTest.cpp b/clang/unittests/StaticAnalyzer/BlockEntranceCallbackTest.cpp index 0f05c39..d15bec0 100644 --- a/clang/unittests/StaticAnalyzer/BlockEntranceCallbackTest.cpp +++ b/clang/unittests/StaticAnalyzer/BlockEntranceCallbackTest.cpp @@ -91,8 +91,7 @@ void addBlockEntranceTester(AnalysisASTConsumer &AnalysisConsumer, AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { Registry.addChecker(®isterChecker<BlockEntranceCallbackTester>, &shouldAlwaysRegister, "test.BlockEntranceTester", - "EmptyDescription", "EmptyDocsUri", - /*IsHidden=*/false); + "EmptyDescription"); }); } @@ -102,8 +101,7 @@ void addBranchConditionTester(AnalysisASTConsumer &AnalysisConsumer, AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { Registry.addChecker(®isterChecker<BranchConditionCallbackTester>, &shouldAlwaysRegister, "test.BranchConditionTester", - "EmptyDescription", "EmptyDocsUri", - /*IsHidden=*/false); + "EmptyDescription"); }); } diff --git a/clang/unittests/StaticAnalyzer/BugReportInterestingnessTest.cpp b/clang/unittests/StaticAnalyzer/BugReportInterestingnessTest.cpp index 0ef63b0..fc50f00 100644 --- a/clang/unittests/StaticAnalyzer/BugReportInterestingnessTest.cpp +++ b/clang/unittests/StaticAnalyzer/BugReportInterestingnessTest.cpp @@ -120,7 +120,7 @@ public: std::move(ExpectedDiags), Compiler.getSourceManager())); AnalysisConsumer->AddCheckerRegistrationFn([](CheckerRegistry &Registry) { Registry.addChecker<InterestingnessTestChecker>("test.Interestingness", - "Description", ""); + "MockDescription"); }); Compiler.getAnalyzerOpts().CheckersAndPackages = { {"test.Interestingness", true}}; diff --git a/clang/unittests/StaticAnalyzer/CallDescriptionTest.cpp b/clang/unittests/StaticAnalyzer/CallDescriptionTest.cpp index 4cb6bd3..e2007a9 100644 --- a/clang/unittests/StaticAnalyzer/CallDescriptionTest.cpp +++ b/clang/unittests/StaticAnalyzer/CallDescriptionTest.cpp @@ -616,8 +616,8 @@ void addCallDescChecker(AnalysisASTConsumer &AnalysisConsumer, AnalyzerOptions &AnOpts) { AnOpts.CheckersAndPackages = {{"test.CallDescChecker", true}}; AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { - Registry.addChecker<CallDescChecker>("test.CallDescChecker", "Description", - ""); + Registry.addChecker<CallDescChecker>("test.CallDescChecker", + "MockDescription"); }); } diff --git a/clang/unittests/StaticAnalyzer/CallEventTest.cpp b/clang/unittests/StaticAnalyzer/CallEventTest.cpp index 2843572e..8b5289e 100644 --- a/clang/unittests/StaticAnalyzer/CallEventTest.cpp +++ b/clang/unittests/StaticAnalyzer/CallEventTest.cpp @@ -56,7 +56,7 @@ void addCXXDeallocatorChecker(AnalysisASTConsumer &AnalysisConsumer, AnOpts.CheckersAndPackages = {{"test.CXXDeallocator", true}}; AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { Registry.addChecker<CXXDeallocatorChecker>("test.CXXDeallocator", - "Description", ""); + "MockDescription"); }); } diff --git a/clang/unittests/StaticAnalyzer/ConflictingEvalCallsTest.cpp b/clang/unittests/StaticAnalyzer/ConflictingEvalCallsTest.cpp index e410cca..cffdbf1 100644 --- a/clang/unittests/StaticAnalyzer/ConflictingEvalCallsTest.cpp +++ b/clang/unittests/StaticAnalyzer/ConflictingEvalCallsTest.cpp @@ -33,10 +33,8 @@ void addEvalFooCheckers(AnalysisASTConsumer &AnalysisConsumer, AnOpts.CheckersAndPackages = {{"test.EvalFoo1", true}, {"test.EvalFoo2", true}}; AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { - Registry.addChecker<EvalCallFoo1>("test.EvalFoo1", "EmptyDescription", - "EmptyDocsUri"); - Registry.addChecker<EvalCallFoo2>("test.EvalFoo2", "EmptyDescription", - "EmptyDocsUri"); + Registry.addChecker<EvalCallFoo1>("test.EvalFoo1", "MockDescription"); + Registry.addChecker<EvalCallFoo2>("test.EvalFoo2", "MockDescription"); }); } } // namespace diff --git a/clang/unittests/StaticAnalyzer/ExprEngineVisitTest.cpp b/clang/unittests/StaticAnalyzer/ExprEngineVisitTest.cpp index b6eeb9c..12be228 100644 --- a/clang/unittests/StaticAnalyzer/ExprEngineVisitTest.cpp +++ b/clang/unittests/StaticAnalyzer/ExprEngineVisitTest.cpp @@ -78,7 +78,7 @@ void addExprEngineVisitPreChecker(AnalysisASTConsumer &AnalysisConsumer, AnOpts.CheckersAndPackages = {{"ExprEngineVisitPreChecker", true}}; AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { Registry.addChecker<ExprEngineVisitPreChecker>("ExprEngineVisitPreChecker", - "Desc", "DocsURI"); + "MockDescription"); }); } @@ -87,7 +87,7 @@ void addExprEngineVisitPostChecker(AnalysisASTConsumer &AnalysisConsumer, AnOpts.CheckersAndPackages = {{"ExprEngineVisitPostChecker", true}}; AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { Registry.addChecker<ExprEngineVisitPostChecker>( - "ExprEngineVisitPostChecker", "Desc", "DocsURI"); + "ExprEngineVisitPostChecker", "MockDescription"); }); } @@ -95,8 +95,8 @@ void addMemAccessChecker(AnalysisASTConsumer &AnalysisConsumer, AnalyzerOptions &AnOpts) { AnOpts.CheckersAndPackages = {{"MemAccessChecker", true}}; AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { - Registry.addChecker<MemAccessChecker>("MemAccessChecker", "Desc", - "DocsURI"); + Registry.addChecker<MemAccessChecker>("MemAccessChecker", + "MockDescription"); }); } diff --git a/clang/unittests/StaticAnalyzer/FalsePositiveRefutationBRVisitorTest.cpp b/clang/unittests/StaticAnalyzer/FalsePositiveRefutationBRVisitorTest.cpp index 8f0a96d..146797f 100644 --- a/clang/unittests/StaticAnalyzer/FalsePositiveRefutationBRVisitorTest.cpp +++ b/clang/unittests/StaticAnalyzer/FalsePositiveRefutationBRVisitorTest.cpp @@ -92,8 +92,8 @@ void addFalsePositiveGenerator(AnalysisASTConsumer &AnalysisConsumer, AnOpts.CheckersAndPackages = {{"test.FalsePositiveGenerator", true}, {"debug.ViewExplodedGraph", false}}; AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { - Registry.addChecker<FalsePositiveGenerator>( - "test.FalsePositiveGenerator", "EmptyDescription", "EmptyDocsUri"); + Registry.addChecker<FalsePositiveGenerator>("test.FalsePositiveGenerator", + "MockDescription"); }); } diff --git a/clang/unittests/StaticAnalyzer/MemRegionDescriptiveNameTest.cpp b/clang/unittests/StaticAnalyzer/MemRegionDescriptiveNameTest.cpp index 0f6e49b..7b837f3 100644 --- a/clang/unittests/StaticAnalyzer/MemRegionDescriptiveNameTest.cpp +++ b/clang/unittests/StaticAnalyzer/MemRegionDescriptiveNameTest.cpp @@ -46,7 +46,7 @@ void addDescriptiveNameChecker(AnalysisASTConsumer &AnalysisConsumer, AnOpts.CheckersAndPackages = {{"DescriptiveNameChecker", true}}; AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { Registry.addChecker<DescriptiveNameChecker>("DescriptiveNameChecker", - "Desc", "DocsURI"); + "MockDescription"); }); } diff --git a/clang/unittests/StaticAnalyzer/NoStateChangeFuncVisitorTest.cpp b/clang/unittests/StaticAnalyzer/NoStateChangeFuncVisitorTest.cpp index a903342..68d2678 100644 --- a/clang/unittests/StaticAnalyzer/NoStateChangeFuncVisitorTest.cpp +++ b/clang/unittests/StaticAnalyzer/NoStateChangeFuncVisitorTest.cpp @@ -140,7 +140,7 @@ void addNonThoroughStatefulChecker(AnalysisASTConsumer &AnalysisConsumer, AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { Registry .addChecker<StatefulChecker<NonThoroughErrorNotPreventedFuncVisitor>>( - "test.StatefulChecker", "Description", ""); + "test.StatefulChecker", "MockDescription"); }); } @@ -233,7 +233,7 @@ void addThoroughStatefulChecker(AnalysisASTConsumer &AnalysisConsumer, AnOpts.CheckersAndPackages = {{"test.StatefulChecker", true}}; AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { Registry.addChecker<StatefulChecker<ThoroughErrorNotPreventedFuncVisitor>>( - "test.StatefulChecker", "Description", ""); + "test.StatefulChecker", "MockDescription"); }); } diff --git a/clang/unittests/StaticAnalyzer/ObjcBug-124477.cpp b/clang/unittests/StaticAnalyzer/ObjcBug-124477.cpp index 51bd332..ab78090 100644 --- a/clang/unittests/StaticAnalyzer/ObjcBug-124477.cpp +++ b/clang/unittests/StaticAnalyzer/ObjcBug-124477.cpp @@ -37,7 +37,7 @@ void addFlagFlipperChecker(AnalysisASTConsumer &AnalysisConsumer, AnOpts.CheckersAndPackages = {{"test.FlipFlagOnCheckLocation", true}}; AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { Registry.addChecker<FlipFlagOnCheckLocation>("test.FlipFlagOnCheckLocation", - "Description", ""); + "MockDescription"); }); } diff --git a/clang/unittests/StaticAnalyzer/RegisterCustomCheckersTest.cpp b/clang/unittests/StaticAnalyzer/RegisterCustomCheckersTest.cpp index 454eee9..e17d107 100644 --- a/clang/unittests/StaticAnalyzer/RegisterCustomCheckersTest.cpp +++ b/clang/unittests/StaticAnalyzer/RegisterCustomCheckersTest.cpp @@ -44,7 +44,7 @@ void addCustomChecker(AnalysisASTConsumer &AnalysisConsumer, AnalyzerOptions &AnOpts) { AnOpts.CheckersAndPackages = {{"test.CustomChecker", true}}; AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { - Registry.addChecker<CustomChecker>("test.CustomChecker", "Description", ""); + Registry.addChecker<CustomChecker>("test.CustomChecker", "MockDescription"); }); } @@ -73,8 +73,8 @@ void addLocIncDecChecker(AnalysisASTConsumer &AnalysisConsumer, AnalyzerOptions &AnOpts) { AnOpts.CheckersAndPackages = {{"test.LocIncDecChecker", true}}; AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { - Registry.addChecker<CustomChecker>("test.LocIncDecChecker", "Description", - ""); + Registry.addChecker<CustomChecker>("test.LocIncDecChecker", + "MockDescription"); }); } @@ -119,10 +119,10 @@ bool shouldRegisterCheckerRegistrationOrderPrinter(const CheckerManager &mgr) { void addCheckerRegistrationOrderPrinter(CheckerRegistry &Registry) { Registry.addChecker(registerCheckerRegistrationOrderPrinter, shouldRegisterCheckerRegistrationOrderPrinter, - "test.RegistrationOrder", "Description", "", false); + "test.RegistrationOrder", "Description"); } -#define UNITTEST_CHECKER(CHECKER_NAME, DIAG_MSG) \ +#define UNITTEST_CHECKER(CHECKER_NAME) \ class CHECKER_NAME : public Checker<check::PreStmt<DeclStmt>> { \ public: \ void checkPreStmt(const DeclStmt *DS, CheckerContext &C) const {} \ @@ -137,11 +137,11 @@ void addCheckerRegistrationOrderPrinter(CheckerRegistry &Registry) { } \ void add##CHECKER_NAME(CheckerRegistry &Registry) { \ Registry.addChecker(register##CHECKER_NAME, shouldRegister##CHECKER_NAME, \ - "test." #CHECKER_NAME, "Description", "", false); \ + "test." #CHECKER_NAME, "Description"); \ } -UNITTEST_CHECKER(StrongDep, "Strong") -UNITTEST_CHECKER(Dep, "Dep") +UNITTEST_CHECKER(StrongDep) +UNITTEST_CHECKER(Dep) bool shouldRegisterStrongFALSE(const CheckerManager &mgr) { return false; @@ -154,7 +154,7 @@ void addDep(AnalysisASTConsumer &AnalysisConsumer, {"test.RegistrationOrder", true}}; AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { Registry.addChecker(registerStrongDep, shouldRegisterStrongFALSE, - "test.Strong", "Description", "", false); + "test.Strong", "Description"); addStrongDep(Registry); addDep(Registry); addCheckerRegistrationOrderPrinter(Registry); @@ -172,7 +172,7 @@ TEST(RegisterDeps, UnsatisfiedDependency) { // Weak checker dependencies. //===----------------------------------------------------------------------===// -UNITTEST_CHECKER(WeakDep, "Weak") +UNITTEST_CHECKER(WeakDep) void addWeakDepCheckerBothEnabled(AnalysisASTConsumer &AnalysisConsumer, AnalyzerOptions &AnOpts) { @@ -225,8 +225,8 @@ void addWeakDepCheckerDepUnspecified(AnalysisASTConsumer &AnalysisConsumer, }); } -UNITTEST_CHECKER(WeakDep2, "Weak2") -UNITTEST_CHECKER(Dep2, "Dep2") +UNITTEST_CHECKER(WeakDep2) +UNITTEST_CHECKER(Dep2) void addWeakDepHasWeakDep(AnalysisASTConsumer &AnalysisConsumer, AnalyzerOptions &AnOpts) { diff --git a/clang/unittests/StaticAnalyzer/SValSimplifyerTest.cpp b/clang/unittests/StaticAnalyzer/SValSimplifyerTest.cpp index 85cfe2c..4331ffc 100644 --- a/clang/unittests/StaticAnalyzer/SValSimplifyerTest.cpp +++ b/clang/unittests/StaticAnalyzer/SValSimplifyerTest.cpp @@ -68,8 +68,7 @@ static void addSimplifyChecker(AnalysisASTConsumer &AnalysisConsumer, AnalyzerOptions &AnOpts) { AnOpts.CheckersAndPackages = {{"SimplifyChecker", true}}; AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { - Registry.addChecker<SimplifyChecker>("SimplifyChecker", "EmptyDescription", - "EmptyDocsUri"); + Registry.addChecker<SimplifyChecker>("SimplifyChecker", "MockDescription"); }); } diff --git a/clang/unittests/StaticAnalyzer/SValTest.cpp b/clang/unittests/StaticAnalyzer/SValTest.cpp index d8897b0..58e9a8d 100644 --- a/clang/unittests/StaticAnalyzer/SValTest.cpp +++ b/clang/unittests/StaticAnalyzer/SValTest.cpp @@ -139,10 +139,10 @@ class SValTest : public testing::TestWithParam<TestClangConfig> {}; \ void add##NAME##SValCollector(AnalysisASTConsumer &AnalysisConsumer, \ AnalyzerOptions &AnOpts) { \ - AnOpts.CheckersAndPackages = {{"test.##NAME##SValCollector", true}}; \ + AnOpts.CheckersAndPackages = {{"test." #NAME "SValColl", true}}; \ AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { \ - Registry.addChecker<NAME##SValCollector>("test.##NAME##SValCollector", \ - "Description", ""); \ + Registry.addChecker<NAME##SValCollector>("test." #NAME "SValColl", \ + "MockDescription"); \ }); \ } \ \ diff --git a/clang/unittests/StaticAnalyzer/TestReturnValueUnderConstruction.cpp b/clang/unittests/StaticAnalyzer/TestReturnValueUnderConstruction.cpp index 5fc084a..0cb3c59 100644 --- a/clang/unittests/StaticAnalyzer/TestReturnValueUnderConstruction.cpp +++ b/clang/unittests/StaticAnalyzer/TestReturnValueUnderConstruction.cpp @@ -49,9 +49,9 @@ void addTestReturnValueUnderConstructionChecker( AnOpts.CheckersAndPackages = {{"test.TestReturnValueUnderConstruction", true}}; AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) { - Registry.addChecker<TestReturnValueUnderConstructionChecker>( - "test.TestReturnValueUnderConstruction", "", ""); - }); + Registry.addChecker<TestReturnValueUnderConstructionChecker>( + "test.TestReturnValueUnderConstruction", "MockDescription"); + }); } TEST(TestReturnValueUnderConstructionChecker, |