[clangd] Added an early return from VisitMemberExpr in SemanticHighlighting if the MemberLoc is invalid.

[jvikstrom]

Summary

Conversion operators contain invalid MemberLocs which causes SemanticHighlighting to emit a lot of error logs in large files as they can occur fairly often (for example converting StringRef to std string).
As the only thing happening was a lot of error logs being emited there doesn't really seem to be any way to test this (no erroneous tokens are added). But emiting as many logs as were being emited is not wanted.

Can't really be patched elsewhere. RecursiveASTVisitor should still traverse the expr as it can contain other "non-implicit" decls/exprs that must be visited (for example DeclRefs). A potential fix could be to special case the TraverseMemberExpr function to not Walk* the Expr if it has an invalid MemberLoc. But that would change the behaviour of RecursiveASTVisitor to be unexpected. (and to change the behaviour to be this for all exprs would change the contract of RecursiveASTVisitor to much)

[hokein]

clang-tools-extra/clangd/SemanticHighlighting.cpp

56 ↗

(On Diff #214083)

I think we only want to ignore the conversion operator, we could do an early return when MD is a cxx conversion decl, e.g. isa<CXXConversionDecl>(MD)?

[jvikstrom]

Changed to do an isa<CXXConversion> check instead of checking if MemberLoc is invalid.

[hokein]

clang-tools-extra/clangd/SemanticHighlighting.cpp

56 ↗

(On Diff #214110)

Maybe just The MemberLoc is invalid for C++ conversion operato , we don't attempt to add a token for an invalid location?

Does the location is always invalid? or just for builtin types? e.g.

class Foo {};
struct Bar {
  explicit operator Foo*() const; // 1
  explicit operator int() const; // 2
};

[jvikstrom]

Added test for conversion operators. Also changed comment.

[jvikstrom]

clang-tools-extra/clangd/SemanticHighlighting.cpp

56 ↗

(On Diff #214110)

Builtin types has nothing to do with it. It's invalid for every conversion operator. Will actually add a test just to make sure that everything else is still highlighted correctly.

[hokein]

clang-tools-extra/clangd/SemanticHighlighting.cpp

56 ↗

(On Diff #214110)

ah, I thought it is the operator declaration, but here we mean expression.

clang-tools-extra/clangd/unittests/SemanticHighlightingTests.cpp

268 ↗

(On Diff #214117)

nit: could you add a comment describing the purpose of this test?

[hokein]

please update the patch description.

clang-tools-extra/trunk/clangd/SemanticHighlighting.cpp

public:
   }
 
   bool VisitMemberExpr(MemberExpr *ME) {
     const auto *MD = ME->getMemberDecl();
     if (isa<CXXDestructorDecl>(MD))
       // When calling the destructor manually like: AAA::~A(); The ~ is a
       // MemberExpr. Other methods should still be highlighted though.
       return true;
+    if (isa<CXXConversionDecl>(MD))
+      // The MemberLoc is invalid for C++ conversion operators. We do not
+      // attempt to add tokens with invalid locations.
+      return true;
     addToken(ME->getMemberLoc(), MD);
     return true;
   }
 
   bool VisitNamedDecl(NamedDecl *ND) {
     // UsingDirectiveDecl's namespaces do not show up anywhere else in the
     // Visit/Traverse mehods. But they should also be highlighted as a
     // namespace.

clang-tools-extra/trunk/clangd/unittests/SemanticHighlightingTests.cpp

R"cpp(
       template<typename $TemplateParameter[[T]]>
       void $Function[[foo]]($TemplateParameter[[T]] ...);
     )cpp",
     R"cpp(
       template <class $TemplateParameter[[T]]>
       struct $Class[[Tmpl]] {$TemplateParameter[[T]] $Field[[x]] = 0;};
       extern template struct $Class[[Tmpl]]<float>;
       template struct $Class[[Tmpl]]<double>;
+    )cpp",
+    // This test is to guard against highlightings disappearing when using
+    // conversion operators as their behaviour in the clang AST differ from
+    // other CXXMethodDecls.
+    R"cpp(
+      class $Class[[Foo]] {};
+      struct $Class[[Bar]] {
+        explicit operator $Class[[Foo]]*() const;
+        explicit operator int() const;
+        operator $Class[[Foo]]();
+      };
+      void $Function[[f]]() {
+        $Class[[Bar]] $Variable[[B]];
+        $Class[[Foo]] $Variable[[F]] = $Variable[[B]];
+        $Class[[Foo]] *$Variable[[FP]] = ($Class[[Foo]]*)$Variable[[B]];
+        int $Variable[[I]] = (int)$Variable[[B]];
+      }
     )cpp"};
   for (const auto &TestCase : TestCases) {
     checkHighlightings(TestCase);
   }
 }
 
 TEST(SemanticHighlighting, GeneratesHighlightsWhenFileChange) {
   class HighlightingsCounterDiagConsumer : public DiagnosticsConsumer {