[clangd] Prefer the left character if the character on the right of the cursor is semicolon.

[hokein]

Summary

This would make go-to-def works on the cases like int A = abc^;

[merge_guards_bot]

Build result: pass - 60338 tests passed, 0 failed and 732 were skipped.

Log files: console-log.txt, CMakeCache.txt

[sammccall]

clang-tools-extra/clangd/Selection.cpp

517

Would you mind preserving the prev-character check?
I don't know how to observe it in tests, but when debugging SelectionTree (e.g. for (;;)) it's nice to have the internal state be what you expect.

I'd suggest extracting a lambda IsIgnoredChar or so to keep the condition simple.

[hokein]

address comments.

clang-tools-extra/clangd/Selection.cpp

static std::pair<unsigned, unsigned> pointBounds(unsigned Offset, FileID FID,
   if (Buf.size() == 0)
     return {0, 0};
   if (Offset == 0)
     return {0, 1};
   if (Offset == Buf.size())
     return {Offset - 1, Offset};
   // We could choose either this byte or the previous. Usually we prefer the
   // character on the right of the cursor (or under a block cursor).
-  // But if that's whitespace, we likely want the token on the left.
-  if (isWhitespace(Buf[Offset]) && !isWhitespace(Buf[Offset - 1]))
+  // But if that's whitespace/semicolon, we likely want the token on the left.
+  auto IsIgnoredChar = [](char C) { return isWhitespace(C) || C == ';'; };
+  if (IsIgnoredChar(Buf[Offset]) && !IsIgnoredChar(Buf[Offset - 1]))
     return {Offset - 1, Offset};
   return {Offset, Offset + 1};
 }
 
 SelectionTree::SelectionTree(ASTContext &AST, const syntax::TokenBuffer &Tokens,
                              unsigned Begin, unsigned End)
     : PrintPolicy(AST.getLangOpts()) {
   // No fundamental reason the selection needs to be in the main file,

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

Case Cases[] = {
 
       // Point selections.
       {"void foo() { [[^foo]](); }", "DeclRefExpr"},
       {"void foo() { [[f^oo]](); }", "DeclRefExpr"},
       {"void foo() { [[fo^o]](); }", "DeclRefExpr"},
       {"void foo() { [[foo^()]]; }", "CallExpr"},
       {"void foo() { [[foo^]] (); }", "DeclRefExpr"},
       {"int bar; void foo() [[{ foo (); }]]^", "CompoundStmt"},
+      {"int x = [[42]]^;", "IntegerLiteral"},
 
       // Ignores whitespace, comments, and semicolons in the selection.
       {"void foo() { [[foo^()]]; /*comment*/^}", "CallExpr"},
 
       // Tricky case: FunctionTypeLoc in FunctionDecl has a hole in it.
       {"[[^void]] foo();", "BuiltinTypeLoc"},
       {"[[void foo^()]];", "FunctionProtoTypeLoc"},
       {"[[^void foo^()]];", "FunctionDecl"},
Case Cases[] = {
       {"[[co^nst auto x = 42]];", "VarDecl"},
 
       {"^", nullptr},
       {"void foo() { [[foo^^]] (); }", "DeclRefExpr"},
 
       // FIXME: Ideally we'd get a declstmt or the VarDecl itself here.
       // This doesn't happen now; the RAV doesn't traverse a node containing ;.
       {"int x = 42;^", nullptr},
-      {"int x = 42^;", nullptr},
 
       // Common ancestor is logically TUDecl, but we never return that.
       {"^int x; int y;^", nullptr},
 
       // Node types that have caused problems in the past.
       {"template <typename T> void foo() { [[^T]] t; }",
        "TemplateTypeParmTypeLoc"},
 

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

const char *Tests[] = {
         }]]]]
        )cpp",
       // Empty file.
       "^",
       // FIXME: We should get the whole DeclStmt as a range.
       R"cpp( // Single statement in TU.
         [[int v = [[1^00]]]];
       )cpp",
-      // FIXME: No node found associated to the position.
       R"cpp( // Cursor at end of VarDecl.
-        void func() {
-          int v = 100 + 100^;
-        }
+        [[int v = [[100]]^]];
       )cpp",
       // FIXME: No node found associated to the position.
       R"cpp( // Cursor in between spaces.
         void func() {
           int v = 100 + ^  100;
         }
       )cpp",
       // Structs.