[AST] Fix location call storage with common last-invocation

[steveire]

Summary

Also fix the formatter to use the front element of a chained call
instead of the back element.

[njames93]

LGTM

clang/lib/Tooling/NodeIntrospection.cpp

40–41

nit: rebase, this no longer exists.

69–71

nit: This is quite an inefficient way to go about comparing these. Though it would require a bit of work to avoid creation of the temporary strings.

clang/lib/Tooling/NodeIntrospection.cpp

void LocationCallFormatterCpp::print(const LocationCall &Call,
   OS << Call.name();
   if (Call.args().empty()) {
     OS << "()";
     return;
   }
   OS << '(' << Call.args().front();
   for (const std::string &Arg : Call.args().drop_front()) {
     OS << ", " << Arg;
   }
   OS << ')';
 }
 
 std::string LocationCallFormatterCpp::format(const LocationCall &Call) {
   std::string Result;
   llvm::raw_string_ostream OS(Result);
   print(Call, OS);
   OS.flush();
   return Result;
bool RangeLessThan::operator()(
   else if (LHS.first.getBegin() != RHS.first.getBegin())
     return false;
 
   if (LHS.first.getEnd() < RHS.first.getEnd())
     return true;
   else if (LHS.first.getEnd() != RHS.first.getEnd())
     return false;
 
-  return LHS.second->name() < RHS.second->name();
+  return LocationCallFormatterCpp::format(*LHS.second) <
+         LocationCallFormatterCpp::format(*RHS.second);
 }
 bool RangeLessThan::operator()(
     std::pair<SourceLocation, SharedLocationCall> const &LHS,
     std::pair<SourceLocation, SharedLocationCall> const &RHS) const {
   if (LHS.first == RHS.first)
-    return LHS.second->name() < RHS.second->name();
+    return LocationCallFormatterCpp::format(*LHS.second) <
+           LocationCallFormatterCpp::format(*RHS.second);
   return LHS.first < RHS.first;
 }
 } // namespace internal
 
 } // namespace tooling
 } // namespace clang
 
 #include "clang/Tooling/NodeIntrospection.inc"

clang/unittests/Introspection/IntrospectionTest.cpp

llvm::transform(llvm::make_filter_range(Accessors,
                                               *Accessor.second.get()),
                                           Accessor.first);
                   });
   return Result;
 }
 
 #define STRING_LOCATION_PAIR(INSTANCE, LOC) Pair(#LOC, INSTANCE->LOC)
 
+TEST(Introspection, SourceLocations_CallContainer) {
+  SourceLocationMap slm;
+  SharedLocationCall Prefix;
+  slm.insert(std::make_pair(
+      SourceLocation(),
+      llvm::makeIntrusiveRefCnt<LocationCall>(Prefix, "getSourceRange")));
+  EXPECT_EQ(slm.size(), 1u);
+
+  auto callTypeLoc =
+      llvm::makeIntrusiveRefCnt<LocationCall>(Prefix, "getTypeLoc");
+  slm.insert(std::make_pair(
+      SourceLocation(),
+      llvm::makeIntrusiveRefCnt<LocationCall>(callTypeLoc, "getSourceRange")));
+  EXPECT_EQ(slm.size(), 2u);
+}
+
+TEST(Introspection, SourceLocations_CallChainFormatting) {
+  SharedLocationCall Prefix;
+  auto chainedCall = llvm::makeIntrusiveRefCnt<LocationCall>(
+      llvm::makeIntrusiveRefCnt<LocationCall>(Prefix, "getTypeLoc"),
+      "getSourceRange");
+  EXPECT_EQ(LocationCallFormatterCpp::format(*chainedCall),
+            "getTypeLoc().getSourceRange()");
+}
+
 TEST(Introspection, SourceLocations_Stmt) {
   if (!NodeIntrospection::hasIntrospectionSupport())
     return;
   auto AST = buildASTFromCode("void foo() {} void bar() { foo(); }", "foo.cpp",
                               std::make_shared<PCHContainerOperations>());
   auto &Ctx = AST->getASTContext();
   auto &TU = *Ctx.getTranslationUnitDecl();