[lldb] Add YAML traits for ConstString and FileSpec

[JDevlieghere]

Summary

Add YAML traits for ConstString and FileSpec so they can be serialized as part of ProcessInfo.

[labath]

Looks fine, we just need to avoid ODR violations

lldb/include/lldb/Utility/FileSpec.h

444

FileSpec::Style is a typedef for llvm::sys::path::Style. Typedefs are not separate types so this code is defining a specialization for a type it does not own.

I think the simplest solution for that is to define a LLVM_YAML_STRONG_TYPEDEF(FileSpec::Style, MyStyle)
and then do something like

MyStyle style = f.m_style;
io.mapRequired("style", style);
f.m_style = style

in MappingTraits<FileSpec>

[labath]

lldb/include/lldb/Utility/FileSpec.h

401

BTW, you can also friend a specific template instantiation: friend struct llvm::yaml::MappingTraits<FileSpec>.

lldb/include/lldb/Utility/ConstString.h

 //===-- ConstString.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UTILITY_CONSTSTRING_H
 #define LLDB_UTILITY_CONSTSTRING_H
 
-#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/YAMLTraits.h"
 
 #include <stddef.h>
 
 namespace lldb_private {
 class Stream;
 }
 namespace llvm {
 class raw_ostream;
static unsigned getHashValue(lldb_private::ConstString val) {
     return DenseMapInfo<const char *>::getHashValue(val.m_string);
   }
   static bool isEqual(lldb_private::ConstString LHS,
                       lldb_private::ConstString RHS) {
     return LHS == RHS;
   }
 };
 /// \}
-}
+
+namespace yaml {
+template <> struct ScalarTraits<lldb_private::ConstString> {
+  static void output(const lldb_private::ConstString &, void *, raw_ostream &);
+  static StringRef input(StringRef, void *, lldb_private::ConstString &);
+  static QuotingType mustQuote(StringRef S) { return QuotingType::Double; }
+};
+} // namespace yaml
+} // namespace llvm
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(lldb_private::ConstString)
 
 #endif // LLDB_UTILITY_CONSTSTRING_H

lldb/include/lldb/Utility/FileSpec.h

 #include <string>
 
 #include "lldb/Utility/ConstString.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/YAMLTraits.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 namespace lldb_private {
 class Stream;
 }
 namespace llvm {
public:
   ///
   /// \return
   ///     A boolean value indicating whether the path was updated.
   bool RemoveLastPathComponent();
 
   ConstString GetLastPathComponent() const;
 
 protected:
+  template <class T> friend struct llvm::yaml::MappingTraits;
+
   // Convenience method for setting the file without changing the style.
   void SetFile(llvm::StringRef path);
 
   // Member variables
   ConstString m_directory;            ///< The uniqued directory path
   ConstString m_filename;             ///< The uniqued filename path
   mutable bool m_is_resolved = false; ///< True if this path has been resolved.
   Style m_style; ///< The syntax that this path uses (e.g. Windows / Posix)

 ///   =======================================================
 ///
 /// Any other value is considered an invalid format string.
 ///
 template <> struct format_provider<lldb_private::FileSpec> {
   static void format(const lldb_private::FileSpec &F, llvm::raw_ostream &Stream,
                      StringRef Style);
 };
+
+namespace yaml {
+template <> struct ScalarEnumerationTraits<lldb_private::FileSpec::Style> {
+  static void enumeration(IO &io, lldb_private::FileSpec::Style &style);
+};
+
+template <> struct MappingTraits<lldb_private::FileSpec> {
+  static void mapping(IO &io, lldb_private::FileSpec &f);
+};
+} // namespace yaml
 } // namespace llvm
 
 #endif // LLDB_UTILITY_FILESPEC_H

lldb/source/Utility/ConstString.cpp

size_t ConstString::StaticMemorySize() {
   return StringPool().MemorySize();
 }
 
 void llvm::format_provider<ConstString>::format(const ConstString &CS,
                                                 llvm::raw_ostream &OS,
                                                 llvm::StringRef Options) {
   format_provider<StringRef>::format(CS.GetStringRef(), OS, Options);
 }
+
+void llvm::yaml::ScalarTraits<ConstString>::output(const ConstString &Val,
+                                                   void *, raw_ostream &Out) {
+  Out << Val.GetStringRef();
+}
+
+llvm::StringRef
+llvm::yaml::ScalarTraits<ConstString>::input(llvm::StringRef Scalar, void *,
+                                             ConstString &Val) {
+  Val = ConstString(Scalar);
+  return {};
+}

lldb/source/Utility/FileSpec.cpp

if (Style.equals_lower("D")) {
     if (dir.empty())
       Stream << "(empty)";
     return;
   }
 
   if (!file.empty())
     Stream << file;
 }
+
+void llvm::yaml::ScalarEnumerationTraits<FileSpec::Style>::enumeration(
+    IO &io, FileSpec::Style &value) {
+  io.enumCase(value, "windows", FileSpec::Style::windows);
+  io.enumCase(value, "posix", FileSpec::Style::posix);
+  io.enumCase(value, "native", FileSpec::Style::native);
+}
+
+void llvm::yaml::MappingTraits<FileSpec>::mapping(IO &io, FileSpec &f) {
+  io.mapRequired("directory", f.m_directory);
+  io.mapRequired("file", f.m_filename);
+  io.mapRequired("resolved", f.m_is_resolved);
+  io.mapRequired("style", f.m_style);
+}

lldb/unittests/Utility/ConstStringTest.cpp

 //===-- ConstStringTest.cpp -----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/ConstString.h"
 #include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/YAMLParser.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 
 TEST(ConstStringTest, format_provider) {
   EXPECT_EQ("foo", llvm::formatv("{0}", ConstString("foo")).str());
 }
 
TEST(ConstStringTest, CompareStringRef) {
   EXPECT_TRUE(empty != "bar");
 
   ConstString null;
   EXPECT_FALSE(null == "foo");
   EXPECT_TRUE(null != "");
   EXPECT_TRUE(null == static_cast<const char *>(nullptr));
   EXPECT_TRUE(null != "bar");
 }
+
+TEST(ConstStringTest, YAML) {
+  std::string buffer;
+  llvm::raw_string_ostream os(buffer);
+
+  // Serialize.
+  std::vector<ConstString> strings = {ConstString("foo"), ConstString("bar"),
+                                      ConstString("")};
+  llvm::yaml::Output yout(os);
+  yout << strings;
+  os.flush();
+
+  // Deserialize.
+  std::vector<ConstString> deserialized;
+  llvm::yaml::Input yin(buffer);
+  yin >> deserialized;
+
+  EXPECT_EQ(strings, deserialized);
+}

lldb/unittests/Utility/FileSpecTest.cpp

TEST(FileSpecTest, Match) {
   EXPECT_TRUE(Match("bar", "bar"));
   EXPECT_FALSE(Match("bar", "baz"));
   EXPECT_FALSE(Match("bar", ""));
 
   EXPECT_TRUE(Match("", "/foo/bar"));
   EXPECT_TRUE(Match("", ""));
 
 }
+
+TEST(FileSpecTest, Yaml) {
+  std::string buffer;
+  llvm::raw_string_ostream os(buffer);
+
+  // Serialize.
+  FileSpec fs_windows("F:\\bar", FileSpec::Style::windows);
+  llvm::yaml::Output yout(os);
+  yout << fs_windows;
+  os.flush();
+
+  // Deserialize.
+  FileSpec deserialized;
+  llvm::yaml::Input yin(buffer);
+  yin >> deserialized;
+
+  EXPECT_EQ(deserialized.GetPathStyle(), fs_windows.GetPathStyle());
+  EXPECT_EQ(deserialized.GetFilename(), fs_windows.GetFilename());
+  EXPECT_EQ(deserialized.GetDirectory(), fs_windows.GetDirectory());
+  EXPECT_EQ(deserialized, fs_windows);
+}