Author: Emilia Kond Date: 2023-06-29T19:51:27+03:00 New Revision: 4986f3f2f220e4fd2fef4b08e550b399c9f45a9f
URL: https://github.com/llvm/llvm-project/commit/4986f3f2f220e4fd2fef4b08e550b399c9f45a9f DIFF: https://github.com/llvm/llvm-project/commit/4986f3f2f220e4fd2fef4b08e550b399c9f45a9f.diff LOG: [clang-format] Correctly annotate operator free function call The annotator correctly annotates an overloaded operator call when called as a member function, like `x.operator+(y)`, however, when called as a free function, like `operator+(x, y)`, the annotator assumed it was an overloaded operator function *declaration*, instead of a call. This patch allows for a free function call to correctly be annotated as a call, but only if the current like cannot be a declaration, usually within the bodies of a function. Fixes https://github.com/llvm/llvm-project/issues/49973 Reviewed By: HazardyKnusperkeks, owenpan, MyDeveloperDay, Nuullll Differential Revision: https://reviews.llvm.org/D153798 Added: Modified: clang/lib/Format/TokenAnnotator.cpp clang/unittests/Format/FormatTest.cpp clang/unittests/Format/TokenAnnotatorTest.cpp Removed: ################################################################################ diff --git a/clang/lib/Format/TokenAnnotator.cpp b/clang/lib/Format/TokenAnnotator.cpp index 27814b8f46862..735089f1ad9d7 100644 --- a/clang/lib/Format/TokenAnnotator.cpp +++ b/clang/lib/Format/TokenAnnotator.cpp @@ -310,9 +310,14 @@ class AnnotatingParser { // If faced with "a.operator*(argument)" or "a->operator*(argument)", // i.e. the operator is called as a member function, // then the argument must be an expression. - bool OperatorCalledAsMemberFunction = - Prev->Previous && Prev->Previous->isOneOf(tok::period, tok::arrow); - Contexts.back().IsExpression = OperatorCalledAsMemberFunction; + // If faced with "operator+(argument)", i.e. the operator is called as + // a free function, then the argument is an expression only if the current + // line can't be a declaration. + bool IsOperatorCallSite = + (Prev->Previous && + Prev->Previous->isOneOf(tok::period, tok::arrow)) || + (!Line.MustBeDeclaration && !Line.InMacroBody); + Contexts.back().IsExpression = IsOperatorCallSite; } else if (OpeningParen.is(TT_VerilogInstancePortLParen)) { Contexts.back().IsExpression = true; Contexts.back().ContextType = Context::VerilogInstancePortList; diff --git a/clang/unittests/Format/FormatTest.cpp b/clang/unittests/Format/FormatTest.cpp index 8338799dc2ba6..e1e9719761723 100644 --- a/clang/unittests/Format/FormatTest.cpp +++ b/clang/unittests/Format/FormatTest.cpp @@ -11580,6 +11580,14 @@ TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { " }", getLLVMStyleWithColumns(50))); +// FIXME: We should be able to figure out this is an operator call +#if 0 + verifyFormat("#define FOO \\\n" + " void foo() { \\\n" + " operator+(a * b); \\\n" + " }", getLLVMStyleWithColumns(25)); +#endif + // FIXME: We cannot handle this case yet; we might be able to figure out that // foo<x> d > v; doesn't make sense. verifyFormat("foo<a<b && c> d> v;"); diff --git a/clang/unittests/Format/TokenAnnotatorTest.cpp b/clang/unittests/Format/TokenAnnotatorTest.cpp index b7980bb6d923d..b6fbe7380d5d2 100644 --- a/clang/unittests/Format/TokenAnnotatorTest.cpp +++ b/clang/unittests/Format/TokenAnnotatorTest.cpp @@ -668,6 +668,33 @@ TEST_F(TokenAnnotatorTest, UnderstandsOverloadedOperators) { EXPECT_TOKEN(Tokens[2], tok::l_paren, TT_OverloadedOperator); EXPECT_TOKEN(Tokens[3], tok::r_paren, TT_OverloadedOperator); EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_OverloadedOperatorLParen); + + Tokens = annotate("class Foo {\n" + " int operator+(a* b);\n" + "}"); + ASSERT_EQ(Tokens.size(), 14u) << Tokens; + EXPECT_TOKEN(Tokens[4], tok::kw_operator, TT_FunctionDeclarationName); + EXPECT_TOKEN(Tokens[5], tok::plus, TT_OverloadedOperator); + EXPECT_TOKEN(Tokens[6], tok::l_paren, TT_OverloadedOperatorLParen); + EXPECT_TOKEN(Tokens[8], tok::star, TT_PointerOrReference); + + Tokens = annotate("void foo() {\n" + " operator+(a * b);\n" + "}"); + ASSERT_EQ(Tokens.size(), 15u) << Tokens; + EXPECT_TOKEN(Tokens[6], tok::plus, TT_OverloadedOperator); + EXPECT_TOKEN(Tokens[7], tok::l_paren, TT_OverloadedOperatorLParen); + EXPECT_TOKEN(Tokens[9], tok::star, TT_BinaryOperator); + + Tokens = annotate("class Foo {\n" + " void foo() {\n" + " operator+(a * b);\n" + " }\n" + "}"); + ASSERT_EQ(Tokens.size(), 19u) << Tokens; + EXPECT_TOKEN(Tokens[9], tok::plus, TT_OverloadedOperator); + EXPECT_TOKEN(Tokens[10], tok::l_paren, TT_OverloadedOperatorLParen); + EXPECT_TOKEN(Tokens[12], tok::star, TT_BinaryOperator); } TEST_F(TokenAnnotatorTest, OverloadedOperatorInTemplate) { _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
