[llvm-tapi] Don't override SequenceTraits for std::string

[amontanez]

Summary

Change the ELF YAML implementation of TextAPI so NeededLibs uses flow
sequence vector correctly instead of overriding the YAML implementation
for std::vector<std::string>>.

This should fix the test failure with the LLVM_LINK_LLVM_DYLIB build mentioned in D55381.

Still passes existing tests that cover this.

[sbc100]

Thanks. lgtm

llvm/lib/TextAPI/ELF/TBEHandler.cpp

148 ↗

(On Diff #177064)

Do you need this template? Isn't it enough to simply declare it as LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR?

llvm/trunk/lib/TextAPI/ELF/TBEHandler.cpp

 #include "llvm/Support/Error.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/TextAPI/ELF/ELFStub.h"
 
 using namespace llvm;
 using namespace llvm::elfabi;
 
 LLVM_YAML_STRONG_TYPEDEF(ELFArch, ELFArchMapper)
+LLVM_YAML_STRONG_TYPEDEF(std::string, ELFNeededEntry)
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(ELFNeededEntry)
 
 namespace llvm {
 namespace yaml {
 
 /// YAML traits for ELFSymbolType.
 template <> struct ScalarEnumerationTraits<ELFSymbolType> {
   static void enumeration(IO &IO, ELFSymbolType &SymbolType) {
     IO.enumCase(SymbolType, "NoType", ELFSymbolType::NoType);
template <> struct CustomMappingTraits<std::set<ELFSymbol>> {
   }
 
   static void output(IO &IO, std::set<ELFSymbol> &Set) {
     for (auto &Sym : Set)
       IO.mapRequired(Sym.Name.c_str(), const_cast<ELFSymbol &>(Sym));
   }
 };
 
-/// YAML traits for generic string vectors (i.e. list of needed libraries).
-template <> struct SequenceTraits<std::vector<std::string>> {
-  static size_t size(IO &IO, std::vector<std::string> &List) {
-    return List.size();
+/// YAML traits for ELFNeededEntry. This is required to enable flow mapping on
+/// NeededLibs.
+template <> struct ScalarTraits<ELFNeededEntry> {
+  static void output(const ELFNeededEntry &Value, void *,
+                     llvm::raw_ostream &Out) {
+    Out << Value.value;
   }
 
-  static std::string &element(IO &IO, std::vector<std::string> &List,
-                              size_t Index) {
-    if (Index >= List.size())
-      List.resize(Index + 1);
-    return List[Index];
+  static StringRef input(StringRef Scalar, void *, ELFNeededEntry &Value) {
+    Value = Scalar.str();
+
+    // Returning empty StringRef indicates successful parse.
+    return StringRef();
   }
 
-  // Compacts list of needed libraries into a single line.
-  static const bool flow = true;
+  // Don't place quotation marks around needed entries.
+  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 /// YAML traits for ELFStub objects.
 template <> struct MappingTraits<ELFStub> {
   static void mapping(IO &IO, ELFStub &Stub) {
     if (!IO.mapTag("!tapi-tbe", true))
       IO.setError("Not a .tbe YAML file.");
     IO.mapRequired("TbeVersion", Stub.TbeVersion);
     IO.mapRequired("SoName", Stub.SoName);
     IO.mapRequired("Arch", (ELFArchMapper &)Stub.Arch);
-    IO.mapOptional("NeededLibs", Stub.NeededLibs);
+    IO.mapOptional("NeededLibs",
+                   (std::vector<ELFNeededEntry> &)Stub.NeededLibs);
     IO.mapRequired("Symbols", Stub.Symbols);
   }
 };
 
 } // end namespace yaml
 } // end namespace llvm
 
 std::unique_ptr<ELFStub> TBEHandler::readFile(StringRef Buf) {