[AST] Add a print method to Introspection LocationCall

[njames93]

Summary

Add a print method that takes a raw_ostream.
Change LocationCallFormatterCpp::format to call that method.

[steveire]

clang/lib/Tooling/NodeIntrospection.cpp

26

The reason for the LocationCallFormatterCpp is that we can write a LocationCallFormatterPython for example which skips over casts (not needed) and always uses ., never ->. I can add a unit test for that once we do chaining and casting for typelocs (coming soon).

We shouldn't encode c++-ness into the LocationCall. I think the only remaining change in this MR is the ArrayRef change, which I think you can just go ahead and commit in an NFC commit.

[njames93]

Tweak implementaion to make the print a static method of FormatterCpp.

[steveire]

Thanks!

clang/include/clang/Tooling/NodeIntrospection.h

private:
   LocationCallFlags m_flags;
   SharedLocationCall m_on;
   std::string m_name;
   std::vector<std::string> m_args;
 };
 
 class LocationCallFormatterCpp {
 public:
-  static std::string format(LocationCall *Call);
+  static void print(const LocationCall &Call, llvm::raw_ostream &OS);
+  static std::string format(const LocationCall &Call);
 };
 
 namespace internal {
 struct RangeLessThan {
   bool operator()(std::pair<SourceRange, SharedLocationCall> const &LHS,
                   std::pair<SourceRange, SharedLocationCall> const &RHS) const;
   bool
   operator()(std::pair<SourceLocation, SharedLocationCall> const &LHS,

clang/lib/Tooling/NodeIntrospection.cpp

 //===- NodeIntrospection.h -----------------------------------*- C++ -*----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file contains the implementation of the NodeIntrospection.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Tooling/NodeIntrospection.h"
 
 #include "clang/AST/AST.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 
 namespace tooling {
 
-std::string LocationCallFormatterCpp::format(LocationCall *Call) {
-  SmallVector<LocationCall *> vec;
-  while (Call) {
-    vec.push_back(Call);
-    Call = Call->on();
-  }
-  std::string result;
-  for (auto *VecCall : llvm::reverse(llvm::makeArrayRef(vec).drop_front())) {
-    result +=
-        (VecCall->name() + "()" + (VecCall->returnsPointer() ? "->" : "."))
-            .str();
+void LocationCallFormatterCpp::print(const LocationCall &Call,
+                                     llvm::raw_ostream &OS) {
+  if (const LocationCall *On = Call.on()) {
+    print(*On, OS);
+    if (On->returnsPointer())
+      OS << "->";
+    else
+      OS << '.';
   }
-  result += (vec.back()->name() + "()").str();
-  return result;
+
+  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;
 }
 
 namespace internal {
 bool RangeLessThan::operator()(
     std::pair<SourceRange, SharedLocationCall> const &LHS,
     std::pair<SourceRange, SharedLocationCall> const &RHS) const {
   if (!LHS.first.isValid() || !RHS.first.isValid())
     return false;

clang/unittests/Introspection/IntrospectionTest.cpp

 FormatExpected(const MapType &Accessors) {
   std::map<std::string, T> Result;
   llvm::transform(llvm::make_filter_range(Accessors,
                                           [](const auto &Accessor) {
                                             return Accessor.first.isValid();
                                           }),
                   std::inserter(Result, Result.end()),
                   [](const auto &Accessor) {
-                    return std::make_pair(
-                        LocationCallFormatterCpp::format(Accessor.second.get()),
+                    return std::make_pair(LocationCallFormatterCpp::format(
+                                              *Accessor.second.get()),
                                           Accessor.first);
                   });
   return Result;
 }
 
 #define STRING_LOCATION_PAIR(INSTANCE, LOC) Pair(#LOC, INSTANCE->LOC)
 
 TEST(Introspection, SourceLocations_Stmt) {
   auto AST = buildASTFromCode("void foo() {} void bar() { foo(); }", "foo.cpp",