clang/unittests/Tooling/SourceCodeBuildersTest.cpp - llvm-project - Git at Google

 //===- unittest/Tooling/SourceCodeBuildersTest.cpp ------------------------===//
 //
 // 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/Tooling/Transformer/SourceCodeBuilders.h"
 #include "clang/AST/Type.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Testing/Support/SupportHelpers.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <optional>

 using namespace clang;
 using namespace tooling;
 using namespace ast_matchers;

 namespace {
 using MatchResult = MatchFinder::MatchResult;
 using llvm::ValueIs;

 // Create a valid translation unit from a statement.
 static std::string wrapSnippet(StringRef StatementCode) {
   return ("namespace std {\n"
           "template <typename T> struct unique_ptr {\n"
           "  T* operator->() const;\n"
           "  T& operator*() const;\n"
           "};\n"
           "template <typename T> struct shared_ptr {\n"
           "  T* operator->() const;\n"
           "  T& operator*() const;\n"
           "};\n"
           "}\n"
           "struct A { void super(); };\n"
           "struct S : public A { S(); S(int); int Field; };\n"
           "S operator+(const S &a, const S &b);\n"
           "struct Smart {\n"
           "  S* operator->() const;\n"
           "  S& operator*() const;\n"
           "};\n"
           "auto test_snippet = []{" +
           StatementCode + "};")
       .str();
 }

 static DeclarationMatcher wrapMatcher(const StatementMatcher &Matcher) {
   return varDecl(hasName("test_snippet"),
                  hasDescendant(compoundStmt(hasAnySubstatement(Matcher))));
 }

 struct TestMatch {
   // The AST unit from which `result` is built. We bundle it because it backs
   // the result. Users are not expected to access it.
   std::unique_ptr<ASTUnit> AstUnit;
   // The result to use in the test. References `ast_unit`.
   MatchResult Result;
 };

 // Matches `Matcher` against the statement `StatementCode` and returns the
 // result. Handles putting the statement inside a function and modifying the
 // matcher correspondingly. `Matcher` should match one of the statements in
 // `StatementCode` exactly -- that is, produce exactly one match. However,
 // `StatementCode` may contain other statements not described by `Matcher`.
 static std::optional<TestMatch> matchStmt(StringRef StatementCode,
                                           StatementMatcher Matcher) {
   auto AstUnit = buildASTFromCodeWithArgs(wrapSnippet(StatementCode),
                                           {"-Wno-unused-value"});
   if (AstUnit == nullptr) {
     ADD_FAILURE() << "AST construction failed";
     return std::nullopt;
   }
   ASTContext &Context = AstUnit->getASTContext();
   auto Matches = ast_matchers::match(wrapMatcher(Matcher), Context);
   // We expect a single, exact match for the statement.
   if (Matches.size() != 1) {
     ADD_FAILURE() << "Wrong number of matches: " << Matches.size();
     return std::nullopt;
   }
   return TestMatch{std::move(AstUnit), MatchResult(Matches[0], &Context)};
 }

 static void testPredicate(bool (*Pred)(const Expr &), StringRef Snippet,
                           bool Expected) {
   auto StmtMatch = matchStmt(Snippet, expr().bind("expr"));
   ASSERT_TRUE(StmtMatch) << "Snippet: " << Snippet;
   EXPECT_EQ(Expected, Pred(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr")))
       << "Snippet: " << Snippet;
 }

 // Tests the predicate on the call argument, assuming `Snippet` is a function
 // call.
 static void testPredicateOnArg(bool (*Pred)(const Expr &), StringRef Snippet,
                                bool Expected) {
   auto StmtMatch = matchStmt(
       Snippet, expr(ignoringImplicit(callExpr(hasArgument(
                    0, ignoringElidableConstructorCall(expr().bind("arg")))))));
   ASSERT_TRUE(StmtMatch) << "Snippet: " << Snippet;
   EXPECT_EQ(Expected, Pred(*StmtMatch->Result.Nodes.getNodeAs<Expr>("arg")))
       << "Snippet: " << Snippet;
 }

 TEST(SourceCodeBuildersTest, needParensAfterUnaryOperator) {
   testPredicate(needParensAfterUnaryOperator, "3 + 5;", true);
   testPredicate(needParensAfterUnaryOperator, "true ? 3 : 5;", true);
   testPredicate(needParensAfterUnaryOperator, "S(3) + S(5);", true);

   testPredicate(needParensAfterUnaryOperator, "int x; x;", false);
   testPredicate(needParensAfterUnaryOperator, "int(3.0);", false);
   testPredicate(needParensAfterUnaryOperator, "void f(); f();", false);
   testPredicate(needParensAfterUnaryOperator, "int a[3]; a[0];", false);
   testPredicate(needParensAfterUnaryOperator, "S x; x.Field;", false);
   testPredicate(needParensAfterUnaryOperator, "int x = 1; --x;", false);
   testPredicate(needParensAfterUnaryOperator, "int x = 1; -x;", false);
 }

 TEST(SourceCodeBuildersTest, needParensAfterUnaryOperatorInImplicitConversion) {
   // The binary operation will be embedded in various implicit
   // expressions. Verify they are ignored.
   testPredicateOnArg(needParensAfterUnaryOperator, "void f(S); f(3 + 5);",
                      true);
 }

 TEST(SourceCodeBuildersTest, mayEverNeedParens) {
   testPredicate(mayEverNeedParens, "3 + 5;", true);
   testPredicate(mayEverNeedParens, "true ? 3 : 5;", true);
   testPredicate(mayEverNeedParens, "int x = 1; --x;", true);
   testPredicate(mayEverNeedParens, "int x = 1; -x;", true);

   testPredicate(mayEverNeedParens, "int x; x;", false);
   testPredicate(mayEverNeedParens, "int(3.0);", false);
   testPredicate(mayEverNeedParens, "void f(); f();", false);
   testPredicate(mayEverNeedParens, "int a[3]; a[0];", false);
   testPredicate(mayEverNeedParens, "S x; x.Field;", false);
 }

 TEST(SourceCodeBuildersTest, mayEverNeedParensInImplictConversion) {
   // The binary operation will be embedded in various implicit
   // expressions. Verify they are ignored.
   testPredicateOnArg(mayEverNeedParens, "void f(S); f(3 + 5);", true);
 }

 TEST(SourceCodeBuildersTest, isKnownPointerLikeTypeUniquePtr) {
   std::string Snippet = "std::unique_ptr<int> P; P;";
   auto StmtMatch =
       matchStmt(Snippet, declRefExpr(hasType(qualType().bind("ty"))));
   ASSERT_TRUE(StmtMatch) << "Snippet: " << Snippet;
   EXPECT_TRUE(
       isKnownPointerLikeType(*StmtMatch->Result.Nodes.getNodeAs<QualType>("ty"),
                              *StmtMatch->Result.Context))
       << "Snippet: " << Snippet;
 }

 TEST(SourceCodeBuildersTest, isKnownPointerLikeTypeSharedPtr) {
   std::string Snippet = "std::shared_ptr<int> P; P;";
   auto StmtMatch =
       matchStmt(Snippet, declRefExpr(hasType(qualType().bind("ty"))));
   ASSERT_TRUE(StmtMatch) << "Snippet: " << Snippet;
   EXPECT_TRUE(
       isKnownPointerLikeType(*StmtMatch->Result.Nodes.getNodeAs<QualType>("ty"),
                              *StmtMatch->Result.Context))
       << "Snippet: " << Snippet;
 }

 TEST(SourceCodeBuildersTest, isKnownPointerLikeTypeUnknownTypeFalse) {
   std::string Snippet = "Smart P; P;";
   auto StmtMatch =
       matchStmt(Snippet, declRefExpr(hasType(qualType().bind("ty"))));
   ASSERT_TRUE(StmtMatch) << "Snippet: " << Snippet;
   EXPECT_FALSE(
       isKnownPointerLikeType(*StmtMatch->Result.Nodes.getNodeAs<QualType>("ty"),
                              *StmtMatch->Result.Context))
       << "Snippet: " << Snippet;
 }

 TEST(SourceCodeBuildersTest, isKnownPointerLikeTypeNormalTypeFalse) {
   std::string Snippet = "int *P; P;";
   auto StmtMatch =
       matchStmt(Snippet, declRefExpr(hasType(qualType().bind("ty"))));
   ASSERT_TRUE(StmtMatch) << "Snippet: " << Snippet;
   EXPECT_FALSE(
       isKnownPointerLikeType(*StmtMatch->Result.Nodes.getNodeAs<QualType>("ty"),
                              *StmtMatch->Result.Context))
       << "Snippet: " << Snippet;
 }

 static void testBuilder(
     std::optional<std::string> (*Builder)(const Expr &, const ASTContext &),
     StringRef Snippet, StringRef Expected) {
   auto StmtMatch = matchStmt(Snippet, expr().bind("expr"));
   ASSERT_TRUE(StmtMatch);
   EXPECT_THAT(Builder(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr"),
                       *StmtMatch->Result.Context),
               ValueIs(std::string(Expected)));
 }

 static void testBuildAccess(StringRef Snippet, StringRef Expected,
                             PLTClass C = PLTClass::Pointer) {
   auto StmtMatch = matchStmt(Snippet, expr().bind("expr"));
   ASSERT_TRUE(StmtMatch);
   EXPECT_THAT(buildAccess(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr"),
                           *StmtMatch->Result.Context, C),
               ValueIs(std::string(Expected)));
 }

 TEST(SourceCodeBuildersTest, BuildParensUnaryOp) {
   testBuilder(buildParens, "-4;", "(-4)");
 }

 TEST(SourceCodeBuildersTest, BuildParensBinOp) {
   testBuilder(buildParens, "4 + 4;", "(4 + 4)");
 }

 TEST(SourceCodeBuildersTest, BuildParensValue) {
   testBuilder(buildParens, "4;", "4");
 }

 TEST(SourceCodeBuildersTest, BuildParensSubscript) {
   testBuilder(buildParens, "int a[3]; a[0];", "a[0]");
 }

 TEST(SourceCodeBuildersTest, BuildParensCall) {
   testBuilder(buildParens, "int f(int); f(4);", "f(4)");
 }

 TEST(SourceCodeBuildersTest, BuildAddressOfValue) {
   testBuilder(buildAddressOf, "S x; x;", "&x");
 }

 TEST(SourceCodeBuildersTest, BuildAddressOfPointerDereference) {
   testBuilder(buildAddressOf, "S *x; *x;", "x");
 }

 TEST(SourceCodeBuildersTest, BuildAddressOfPointerDereferenceIgnoresParens) {
   testBuilder(buildAddressOf, "S *x; *(x);", "x");
 }

 TEST(SourceCodeBuildersTest, BuildAddressOfBinaryOperation) {
   testBuilder(buildAddressOf, "S x; x + x;", "&(x + x)");
 }

 TEST(SourceCodeBuildersTest, BuildAddressOfImplicitThis) {
   StringRef Snippet = R"cc(
     struct Struct {
       void foo() {}
       void bar() {
         foo();
       }
     };
   )cc";
   auto StmtMatch = matchStmt(
       Snippet,
       cxxMemberCallExpr(onImplicitObjectArgument(cxxThisExpr().bind("expr"))));
   ASSERT_TRUE(StmtMatch);
   EXPECT_THAT(buildAddressOf(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr"),
                              *StmtMatch->Result.Context),
               ValueIs(std::string("this")));
 }

 TEST(SourceCodeBuildersTest, BuildDereferencePointer) {
   testBuilder(buildDereference, "S *x; x;", "*x");
 }

 TEST(SourceCodeBuildersTest, BuildDereferenceValueAddress) {
   testBuilder(buildDereference, "S x; &x;", "x");
 }

 TEST(SourceCodeBuildersTest, BuildDereferenceValueAddressIgnoresParens) {
   testBuilder(buildDereference, "S x; &(x);", "x");
 }

 TEST(SourceCodeBuildersTest, BuildDereferenceBinaryOperation) {
   testBuilder(buildDereference, "S *x; x + 1;", "*(x + 1)");
 }

 TEST(SourceCodeBuildersTest, BuildDotValue) {
   testBuilder(buildDot, "S x; x;", "x.");
 }

 TEST(SourceCodeBuildersTest, BuildDotPointerDereference) {
   testBuilder(buildDot, "S *x; *x;", "x->");
 }

 TEST(SourceCodeBuildersTest, BuildDotPointerDereferenceIgnoresParens) {
   testBuilder(buildDot, "S *x; *(x);", "x->");
 }

 TEST(SourceCodeBuildersTest, BuildDotBinaryOperation) {
   testBuilder(buildDot, "S x; x + x;", "(x + x).");
 }

 TEST(SourceCodeBuildersTest, BuildDotPointerDereferenceExprWithParens) {
   testBuilder(buildDot, "S *x; *(x + 1);", "(x + 1)->");
 }

 TEST(SourceCodeBuildersTest, BuildArrowPointer) {
   testBuilder(buildArrow, "S *x; x;", "x->");
 }

 TEST(SourceCodeBuildersTest, BuildArrowValueAddress) {
   testBuilder(buildArrow, "S x; &x;", "x.");
 }

 TEST(SourceCodeBuildersTest, BuildArrowValueAddressIgnoresParens) {
   testBuilder(buildArrow, "S x; &(x);", "x.");
 }

 TEST(SourceCodeBuildersTest, BuildArrowBinaryOperation) {
   testBuilder(buildArrow, "S *x; x + 1;", "(x + 1)->");
 }

 TEST(SourceCodeBuildersTest, BuildArrowValueAddressWithParens) {
   testBuilder(buildArrow, "S x; &(true ? x : x);", "(true ? x : x).");
 }

 TEST(SourceCodeBuildersTest, BuildAccessValue) {
   testBuildAccess("S x; x;", "x.");
 }

 TEST(SourceCodeBuildersTest, BuildAccessPointerDereference) {
   testBuildAccess("S *x; *x;", "x->");
 }

 TEST(SourceCodeBuildersTest, BuildAccessPointerDereferenceIgnoresParens) {
   testBuildAccess("S *x; *(x);", "x->");
 }

 TEST(SourceCodeBuildersTest, BuildAccessValueBinaryOperation) {
   testBuildAccess("S x; x + x;", "(x + x).");
 }

 TEST(SourceCodeBuildersTest, BuildAccessPointerDereferenceExprWithParens) {
   testBuildAccess("S *x; *(x + 1);", "(x + 1)->");
 }

 TEST(SourceCodeBuildersTest, BuildAccessPointer) {
   testBuildAccess("S *x; x;", "x->");
 }

 TEST(SourceCodeBuildersTest, BuildAccessValueAddress) {
   testBuildAccess("S x; &x;", "x.");
 }

 TEST(SourceCodeBuildersTest, BuildAccessValueAddressIgnoresParens) {
   testBuildAccess("S x; &(x);", "x.");
 }

 TEST(SourceCodeBuildersTest, BuildAccessPointerBinaryOperation) {
   testBuildAccess("S *x; x + 1;", "(x + 1)->");
 }

 TEST(SourceCodeBuildersTest, BuildAccessValueAddressWithParens) {
   testBuildAccess("S x; &(true ? x : x);", "(true ? x : x).");
 }

 TEST(SourceCodeBuildersTest, BuildAccessSmartPointer) {
   testBuildAccess("std::unique_ptr<int> x; x;", "x->");
 }

 TEST(SourceCodeBuildersTest, BuildAccessSmartPointerAsValue) {
   testBuildAccess("std::unique_ptr<int> x; x;", "x.", PLTClass::Value);
 }

 TEST(SourceCodeBuildersTest, BuildAccessSmartPointerDeref) {
   testBuildAccess("std::unique_ptr<int> x; *x;", "x->");
 }

 TEST(SourceCodeBuildersTest, BuildAccessSmartPointerDerefAsValue) {
   testBuildAccess("std::unique_ptr<int> x; *x;", "(*x).", PLTClass::Value);
 }

 TEST(SourceCodeBuildersTest, BuildAccessSmartPointerMemberCall) {
   StringRef Snippet = R"cc(
     Smart x;
     x->Field;
   )cc";
   auto StmtMatch =
       matchStmt(Snippet, memberExpr(hasObjectExpression(expr().bind("expr"))));
   ASSERT_TRUE(StmtMatch);
   EXPECT_THAT(buildAccess(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr"),
                           *StmtMatch->Result.Context),
               ValueIs(std::string("x->")));
 }

 TEST(SourceCodeBuildersTest, BuildAccessIgnoreImplicit) {
   StringRef Snippet = R"cc(
     S x;
     A *a;
     a = &x;
   )cc";
   auto StmtMatch =
       matchStmt(Snippet, binaryOperator(isAssignmentOperator(),
                                         hasRHS(expr().bind("expr"))));
   ASSERT_TRUE(StmtMatch);
   EXPECT_THAT(buildAccess(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr"),
                           *StmtMatch->Result.Context),
               ValueIs(std::string("x.")));
 }

 TEST(SourceCodeBuildersTest, BuildAccessImplicitThis) {
   StringRef Snippet = R"cc(
     struct Struct {
       void foo() {}
       void bar() {
         foo();
       }
     };
   )cc";
   auto StmtMatch = matchStmt(
       Snippet,
       cxxMemberCallExpr(onImplicitObjectArgument(cxxThisExpr().bind("expr"))));
   ASSERT_TRUE(StmtMatch);
   EXPECT_THAT(buildAccess(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr"),
                           *StmtMatch->Result.Context),
               ValueIs(std::string()));
 }

 TEST(SourceCodeBuildersTest, BuildAccessImplicitThisIgnoreImplicitCasts) {
   StringRef Snippet = "struct B : public A { void f() { super(); } };";
   auto StmtMatch = matchStmt(
       Snippet,
       cxxMemberCallExpr(onImplicitObjectArgument(expr().bind("expr"))));
   ASSERT_TRUE(StmtMatch);
   EXPECT_THAT(buildAccess(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr"),
                           *StmtMatch->Result.Context),
               ValueIs(std::string()));
 }
 } // namespace
	//===- unittest/Tooling/SourceCodeBuildersTest.cpp ------------------------===//
	//
	// 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/Tooling/Transformer/SourceCodeBuilders.h"
	#include "clang/AST/Type.h"
	#include "clang/ASTMatchers/ASTMatchFinder.h"
	#include "clang/ASTMatchers/ASTMatchers.h"
	#include "clang/Tooling/Tooling.h"
	#include "llvm/Testing/Support/SupportHelpers.h"
	#include "gmock/gmock.h"
	#include "gtest/gtest.h"
	#include <optional>

	using namespace clang;
	using namespace tooling;
	using namespace ast_matchers;

	namespace {
	using MatchResult = MatchFinder::MatchResult;
	using llvm::ValueIs;

	// Create a valid translation unit from a statement.
	static std::string wrapSnippet(StringRef StatementCode) {
	return ("namespace std {\n"
	"template <typename T> struct unique_ptr {\n"
	" T* operator->() const;\n"
	" T& operator*() const;\n"
	"};\n"
	"template <typename T> struct shared_ptr {\n"
	" T* operator->() const;\n"
	" T& operator*() const;\n"
	"};\n"
	"}\n"
	"struct A { void super(); };\n"
	"struct S : public A { S(); S(int); int Field; };\n"
	"S operator+(const S &a, const S &b);\n"
	"struct Smart {\n"
	" S* operator->() const;\n"
	" S& operator*() const;\n"
	"};\n"
	"auto test_snippet = []{" +
	StatementCode + "};")
	.str();
	}

	static DeclarationMatcher wrapMatcher(const StatementMatcher &Matcher) {
	return varDecl(hasName("test_snippet"),
	hasDescendant(compoundStmt(hasAnySubstatement(Matcher))));
	}

	struct TestMatch {
	// The AST unit from which `result` is built. We bundle it because it backs
	// the result. Users are not expected to access it.
	std::unique_ptr<ASTUnit> AstUnit;
	// The result to use in the test. References `ast_unit`.
	MatchResult Result;
	};

	// Matches `Matcher` against the statement `StatementCode` and returns the
	// result. Handles putting the statement inside a function and modifying the
	// matcher correspondingly. `Matcher` should match one of the statements in
	// `StatementCode` exactly -- that is, produce exactly one match. However,
	// `StatementCode` may contain other statements not described by `Matcher`.
	static std::optional<TestMatch> matchStmt(StringRef StatementCode,
	StatementMatcher Matcher) {
	auto AstUnit = buildASTFromCodeWithArgs(wrapSnippet(StatementCode),
	{"-Wno-unused-value"});
	if (AstUnit == nullptr) {
	ADD_FAILURE() << "AST construction failed";
	return std::nullopt;
	}
	ASTContext &Context = AstUnit->getASTContext();
	auto Matches = ast_matchers::match(wrapMatcher(Matcher), Context);
	// We expect a single, exact match for the statement.
	if (Matches.size() != 1) {
	ADD_FAILURE() << "Wrong number of matches: " << Matches.size();
	return std::nullopt;
	}
	return TestMatch{std::move(AstUnit), MatchResult(Matches[0], &Context)};
	}

	static void testPredicate(bool (*Pred)(const Expr &), StringRef Snippet,
	bool Expected) {
	auto StmtMatch = matchStmt(Snippet, expr().bind("expr"));
	ASSERT_TRUE(StmtMatch) << "Snippet: " << Snippet;
	EXPECT_EQ(Expected, Pred(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr")))
	<< "Snippet: " << Snippet;
	}

	// Tests the predicate on the call argument, assuming `Snippet` is a function
	// call.
	static void testPredicateOnArg(bool (*Pred)(const Expr &), StringRef Snippet,
	bool Expected) {
	auto StmtMatch = matchStmt(
	Snippet, expr(ignoringImplicit(callExpr(hasArgument(
	0, ignoringElidableConstructorCall(expr().bind("arg")))))));
	ASSERT_TRUE(StmtMatch) << "Snippet: " << Snippet;
	EXPECT_EQ(Expected, Pred(*StmtMatch->Result.Nodes.getNodeAs<Expr>("arg")))
	<< "Snippet: " << Snippet;
	}

	TEST(SourceCodeBuildersTest, needParensAfterUnaryOperator) {
	testPredicate(needParensAfterUnaryOperator, "3 + 5;", true);
	testPredicate(needParensAfterUnaryOperator, "true ? 3 : 5;", true);
	testPredicate(needParensAfterUnaryOperator, "S(3) + S(5);", true);

	testPredicate(needParensAfterUnaryOperator, "int x; x;", false);
	testPredicate(needParensAfterUnaryOperator, "int(3.0);", false);
	testPredicate(needParensAfterUnaryOperator, "void f(); f();", false);
	testPredicate(needParensAfterUnaryOperator, "int a[3]; a[0];", false);
	testPredicate(needParensAfterUnaryOperator, "S x; x.Field;", false);
	testPredicate(needParensAfterUnaryOperator, "int x = 1; --x;", false);
	testPredicate(needParensAfterUnaryOperator, "int x = 1; -x;", false);
	}

	TEST(SourceCodeBuildersTest, needParensAfterUnaryOperatorInImplicitConversion) {
	// The binary operation will be embedded in various implicit
	// expressions. Verify they are ignored.
	testPredicateOnArg(needParensAfterUnaryOperator, "void f(S); f(3 + 5);",
	true);
	}

	TEST(SourceCodeBuildersTest, mayEverNeedParens) {
	testPredicate(mayEverNeedParens, "3 + 5;", true);
	testPredicate(mayEverNeedParens, "true ? 3 : 5;", true);
	testPredicate(mayEverNeedParens, "int x = 1; --x;", true);
	testPredicate(mayEverNeedParens, "int x = 1; -x;", true);

	testPredicate(mayEverNeedParens, "int x; x;", false);
	testPredicate(mayEverNeedParens, "int(3.0);", false);
	testPredicate(mayEverNeedParens, "void f(); f();", false);
	testPredicate(mayEverNeedParens, "int a[3]; a[0];", false);
	testPredicate(mayEverNeedParens, "S x; x.Field;", false);
	}

	TEST(SourceCodeBuildersTest, mayEverNeedParensInImplictConversion) {
	// The binary operation will be embedded in various implicit
	// expressions. Verify they are ignored.
	testPredicateOnArg(mayEverNeedParens, "void f(S); f(3 + 5);", true);
	}

	TEST(SourceCodeBuildersTest, isKnownPointerLikeTypeUniquePtr) {
	std::string Snippet = "std::unique_ptr<int> P; P;";
	auto StmtMatch =
	matchStmt(Snippet, declRefExpr(hasType(qualType().bind("ty"))));
	ASSERT_TRUE(StmtMatch) << "Snippet: " << Snippet;
	EXPECT_TRUE(
	isKnownPointerLikeType(*StmtMatch->Result.Nodes.getNodeAs<QualType>("ty"),
	*StmtMatch->Result.Context))
	<< "Snippet: " << Snippet;
	}

	TEST(SourceCodeBuildersTest, isKnownPointerLikeTypeSharedPtr) {
	std::string Snippet = "std::shared_ptr<int> P; P;";
	auto StmtMatch =
	matchStmt(Snippet, declRefExpr(hasType(qualType().bind("ty"))));
	ASSERT_TRUE(StmtMatch) << "Snippet: " << Snippet;
	EXPECT_TRUE(
	isKnownPointerLikeType(*StmtMatch->Result.Nodes.getNodeAs<QualType>("ty"),
	*StmtMatch->Result.Context))
	<< "Snippet: " << Snippet;
	}

	TEST(SourceCodeBuildersTest, isKnownPointerLikeTypeUnknownTypeFalse) {
	std::string Snippet = "Smart P; P;";
	auto StmtMatch =
	matchStmt(Snippet, declRefExpr(hasType(qualType().bind("ty"))));
	ASSERT_TRUE(StmtMatch) << "Snippet: " << Snippet;
	EXPECT_FALSE(
	isKnownPointerLikeType(*StmtMatch->Result.Nodes.getNodeAs<QualType>("ty"),
	*StmtMatch->Result.Context))
	<< "Snippet: " << Snippet;
	}

	TEST(SourceCodeBuildersTest, isKnownPointerLikeTypeNormalTypeFalse) {
	std::string Snippet = "int *P; P;";
	auto StmtMatch =
	matchStmt(Snippet, declRefExpr(hasType(qualType().bind("ty"))));
	ASSERT_TRUE(StmtMatch) << "Snippet: " << Snippet;
	EXPECT_FALSE(
	isKnownPointerLikeType(*StmtMatch->Result.Nodes.getNodeAs<QualType>("ty"),
	*StmtMatch->Result.Context))
	<< "Snippet: " << Snippet;
	}

	static void testBuilder(
	std::optional<std::string> (*Builder)(const Expr &, const ASTContext &),
	StringRef Snippet, StringRef Expected) {
	auto StmtMatch = matchStmt(Snippet, expr().bind("expr"));
	ASSERT_TRUE(StmtMatch);
	EXPECT_THAT(Builder(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr"),
	*StmtMatch->Result.Context),
	ValueIs(std::string(Expected)));
	}

	static void testBuildAccess(StringRef Snippet, StringRef Expected,
	PLTClass C = PLTClass::Pointer) {
	auto StmtMatch = matchStmt(Snippet, expr().bind("expr"));
	ASSERT_TRUE(StmtMatch);
	EXPECT_THAT(buildAccess(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr"),
	*StmtMatch->Result.Context, C),
	ValueIs(std::string(Expected)));
	}

	TEST(SourceCodeBuildersTest, BuildParensUnaryOp) {
	testBuilder(buildParens, "-4;", "(-4)");
	}

	TEST(SourceCodeBuildersTest, BuildParensBinOp) {
	testBuilder(buildParens, "4 + 4;", "(4 + 4)");
	}

	TEST(SourceCodeBuildersTest, BuildParensValue) {
	testBuilder(buildParens, "4;", "4");
	}

	TEST(SourceCodeBuildersTest, BuildParensSubscript) {
	testBuilder(buildParens, "int a[3]; a[0];", "a[0]");
	}

	TEST(SourceCodeBuildersTest, BuildParensCall) {
	testBuilder(buildParens, "int f(int); f(4);", "f(4)");
	}

	TEST(SourceCodeBuildersTest, BuildAddressOfValue) {
	testBuilder(buildAddressOf, "S x; x;", "&x");
	}

	TEST(SourceCodeBuildersTest, BuildAddressOfPointerDereference) {
	testBuilder(buildAddressOf, "S x; x;", "x");
	}

	TEST(SourceCodeBuildersTest, BuildAddressOfPointerDereferenceIgnoresParens) {
	testBuilder(buildAddressOf, "S x; (x);", "x");
	}

	TEST(SourceCodeBuildersTest, BuildAddressOfBinaryOperation) {
	testBuilder(buildAddressOf, "S x; x + x;", "&(x + x)");
	}

	TEST(SourceCodeBuildersTest, BuildAddressOfImplicitThis) {
	StringRef Snippet = R"cc(
	struct Struct {
	void foo() {}
	void bar() {
	foo();
	}
	};
	)cc";
	auto StmtMatch = matchStmt(
	Snippet,
	cxxMemberCallExpr(onImplicitObjectArgument(cxxThisExpr().bind("expr"))));
	ASSERT_TRUE(StmtMatch);
	EXPECT_THAT(buildAddressOf(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr"),
	*StmtMatch->Result.Context),
	ValueIs(std::string("this")));
	}

	TEST(SourceCodeBuildersTest, BuildDereferencePointer) {
	testBuilder(buildDereference, "S x; x;", "x");
	}

	TEST(SourceCodeBuildersTest, BuildDereferenceValueAddress) {
	testBuilder(buildDereference, "S x; &x;", "x");
	}

	TEST(SourceCodeBuildersTest, BuildDereferenceValueAddressIgnoresParens) {
	testBuilder(buildDereference, "S x; &(x);", "x");
	}

	TEST(SourceCodeBuildersTest, BuildDereferenceBinaryOperation) {
	testBuilder(buildDereference, "S x; x + 1;", "(x + 1)");
	}

	TEST(SourceCodeBuildersTest, BuildDotValue) {
	testBuilder(buildDot, "S x; x;", "x.");
	}

	TEST(SourceCodeBuildersTest, BuildDotPointerDereference) {
	testBuilder(buildDot, "S x; x;", "x->");
	}

	TEST(SourceCodeBuildersTest, BuildDotPointerDereferenceIgnoresParens) {
	testBuilder(buildDot, "S x; (x);", "x->");
	}

	TEST(SourceCodeBuildersTest, BuildDotBinaryOperation) {
	testBuilder(buildDot, "S x; x + x;", "(x + x).");
	}

	TEST(SourceCodeBuildersTest, BuildDotPointerDereferenceExprWithParens) {
	testBuilder(buildDot, "S x; (x + 1);", "(x + 1)->");
	}

	TEST(SourceCodeBuildersTest, BuildArrowPointer) {
	testBuilder(buildArrow, "S *x; x;", "x->");
	}

	TEST(SourceCodeBuildersTest, BuildArrowValueAddress) {
	testBuilder(buildArrow, "S x; &x;", "x.");
	}

	TEST(SourceCodeBuildersTest, BuildArrowValueAddressIgnoresParens) {
	testBuilder(buildArrow, "S x; &(x);", "x.");
	}

	TEST(SourceCodeBuildersTest, BuildArrowBinaryOperation) {
	testBuilder(buildArrow, "S *x; x + 1;", "(x + 1)->");
	}

	TEST(SourceCodeBuildersTest, BuildArrowValueAddressWithParens) {
	testBuilder(buildArrow, "S x; &(true ? x : x);", "(true ? x : x).");
	}

	TEST(SourceCodeBuildersTest, BuildAccessValue) {
	testBuildAccess("S x; x;", "x.");
	}

	TEST(SourceCodeBuildersTest, BuildAccessPointerDereference) {
	testBuildAccess("S x; x;", "x->");
	}

	TEST(SourceCodeBuildersTest, BuildAccessPointerDereferenceIgnoresParens) {
	testBuildAccess("S x; (x);", "x->");
	}

	TEST(SourceCodeBuildersTest, BuildAccessValueBinaryOperation) {
	testBuildAccess("S x; x + x;", "(x + x).");
	}

	TEST(SourceCodeBuildersTest, BuildAccessPointerDereferenceExprWithParens) {
	testBuildAccess("S x; (x + 1);", "(x + 1)->");
	}

	TEST(SourceCodeBuildersTest, BuildAccessPointer) {
	testBuildAccess("S *x; x;", "x->");
	}

	TEST(SourceCodeBuildersTest, BuildAccessValueAddress) {
	testBuildAccess("S x; &x;", "x.");
	}

	TEST(SourceCodeBuildersTest, BuildAccessValueAddressIgnoresParens) {
	testBuildAccess("S x; &(x);", "x.");
	}

	TEST(SourceCodeBuildersTest, BuildAccessPointerBinaryOperation) {
	testBuildAccess("S *x; x + 1;", "(x + 1)->");
	}

	TEST(SourceCodeBuildersTest, BuildAccessValueAddressWithParens) {
	testBuildAccess("S x; &(true ? x : x);", "(true ? x : x).");
	}

	TEST(SourceCodeBuildersTest, BuildAccessSmartPointer) {
	testBuildAccess("std::unique_ptr<int> x; x;", "x->");
	}

	TEST(SourceCodeBuildersTest, BuildAccessSmartPointerAsValue) {
	testBuildAccess("std::unique_ptr<int> x; x;", "x.", PLTClass::Value);
	}

	TEST(SourceCodeBuildersTest, BuildAccessSmartPointerDeref) {
	testBuildAccess("std::unique_ptr<int> x; *x;", "x->");
	}

	TEST(SourceCodeBuildersTest, BuildAccessSmartPointerDerefAsValue) {
	testBuildAccess("std::unique_ptr<int> x; x;", "(x).", PLTClass::Value);
	}

	TEST(SourceCodeBuildersTest, BuildAccessSmartPointerMemberCall) {
	StringRef Snippet = R"cc(
	Smart x;
	x->Field;
	)cc";
	auto StmtMatch =
	matchStmt(Snippet, memberExpr(hasObjectExpression(expr().bind("expr"))));
	ASSERT_TRUE(StmtMatch);
	EXPECT_THAT(buildAccess(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr"),
	*StmtMatch->Result.Context),
	ValueIs(std::string("x->")));
	}

	TEST(SourceCodeBuildersTest, BuildAccessIgnoreImplicit) {
	StringRef Snippet = R"cc(
	S x;
	A *a;
	a = &x;
	)cc";
	auto StmtMatch =
	matchStmt(Snippet, binaryOperator(isAssignmentOperator(),
	hasRHS(expr().bind("expr"))));
	ASSERT_TRUE(StmtMatch);
	EXPECT_THAT(buildAccess(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr"),
	*StmtMatch->Result.Context),
	ValueIs(std::string("x.")));
	}

	TEST(SourceCodeBuildersTest, BuildAccessImplicitThis) {
	StringRef Snippet = R"cc(
	struct Struct {
	void foo() {}
	void bar() {
	foo();
	}
	};
	)cc";
	auto StmtMatch = matchStmt(
	Snippet,
	cxxMemberCallExpr(onImplicitObjectArgument(cxxThisExpr().bind("expr"))));
	ASSERT_TRUE(StmtMatch);
	EXPECT_THAT(buildAccess(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr"),
	*StmtMatch->Result.Context),
	ValueIs(std::string()));
	}

	TEST(SourceCodeBuildersTest, BuildAccessImplicitThisIgnoreImplicitCasts) {
	StringRef Snippet = "struct B : public A { void f() { super(); } };";
	auto StmtMatch = matchStmt(
	Snippet,
	cxxMemberCallExpr(onImplicitObjectArgument(expr().bind("expr"))));
	ASSERT_TRUE(StmtMatch);
	EXPECT_THAT(buildAccess(*StmtMatch->Result.Nodes.getNodeAs<Expr>("expr"),
	*StmtMatch->Result.Context),
	ValueIs(std::string()));
	}
	} // namespace