fix ODR violations due to abuse of LLVM_YAML_IS_(FLOW_)?SEQUENCE_VECTOR

[rsmith]

Summary

This is a short-term fix for PR33650 aimed to get the modules build bots green again.

Remove all the places where we use the LLVM_YAML_IS_(FLOW_)?SEQUENCE_VECTOR macros to try to locally specialize a global template for a global type. That's not how C++ works.

Instead, we now centrally define how to format vectors of fundamental types and of string (std::string and StringRef). We use flow formatting for the former cases, since that's the obvious right thing to do; in the latter case, it's less clear what the right choice is, but flow formatting is really bad for some cases (due to very long strings), so we pick block formatting. (Many of the cases that were using flow formatting for strings are improved by this change.)

Other than the flow -> block formatting change for some vectors of strings, this should result in no functionality change.

[zturner]

I don't have any comments, this seems fine to me. Long term I think the best solution is to get rid of these global specializations entirely, and instead provide adapters called flow and block, and instead of just saying IO.mapOptional("Foo", Sequence); and having it be picked up by a specialization, you would say IO.mapOptional("Foo", flow(Sequence));

[rsmith]

Committed as r306878-360881.

llvm/trunk/include/llvm/IR/ModuleSummaryIndexYAML.h

std::vector<FunctionSummary::VFuncId> TypeTestAssumeVCalls,
       TypeCheckedLoadVCalls;
   std::vector<FunctionSummary::ConstVCall> TypeTestAssumeConstVCalls,
       TypeCheckedLoadConstVCalls;
 };
 
 } // End yaml namespace
 } // End llvm namespace
 
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint64_t)
-
 namespace llvm {
 namespace yaml {
 
 template <> struct MappingTraits<FunctionSummary::VFuncId> {
   static void mapping(IO &io, FunctionSummary::VFuncId& id) {
     io.mapOptional("GUID", id.GUID);
     io.mapOptional("Offset", id.Offset);
   }
template <> struct MappingTraits<FunctionSummaryYaml> {
   }
 };
 
 } // End yaml namespace
 } // End llvm namespace
 
 LLVM_YAML_IS_STRING_MAP(TypeIdSummary)
 LLVM_YAML_IS_SEQUENCE_VECTOR(FunctionSummaryYaml)
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(std::string)
 
 namespace llvm {
 namespace yaml {
 
 // FIXME: Add YAML mappings for the rest of the module summary.
 template <> struct CustomMappingTraits<GlobalValueSummaryMapTy> {
   static void inputOne(IO &io, StringRef Key, GlobalValueSummaryMapTy &V) {
     std::vector<FunctionSummaryYaml> FSums;

llvm/trunk/include/llvm/ObjectYAML/DWARFYAML.h

struct Data {
   std::vector<LineTable> DebugLines;
 
   bool isEmpty() const;
 };
 
 } // namespace llvm::DWARFYAML
 } // namespace llvm
 
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint8_t)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::Hex64)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::StringRef)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::Hex8)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AttributeAbbrev)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Abbrev)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARangeDescriptor)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARange)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::PubEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Unit)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::FormValue)

llvm/trunk/include/llvm/ObjectYAML/MachOYAML.h

struct UniversalBinary {
   std::vector<Object> Slices;
 };
 
 } // namespace llvm::MachOYAML
 } // namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::LoadCommand)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::Section)
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(int64_t)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::RebaseOpcode)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::BindOpcode)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::ExportEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::NListEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::Object)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachOYAML::FatArch)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MachO::build_tool_version)
 

llvm/trunk/include/llvm/ObjectYAML/WasmYAML.h

 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Limits)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::DataSegment)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Global)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Function)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::LocalDecl)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Relocation)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::NameEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SymbolInfo)
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint32_t)
 
 namespace llvm {
 namespace yaml {
 
 template <> struct MappingTraits<WasmYAML::FileHeader> {
   static void mapping(IO &IO, WasmYAML::FileHeader &FileHdr);
 };
 

llvm/trunk/include/llvm/Support/YAMLTraits.h

struct BlockScalarTraits {
   // StringRef on success or an error string if string is malformed:
   // static StringRef input(StringRef Scalar, void *ctxt, T &Value);
 };
 
 /// This class should be specialized by any type that needs to be converted
 /// to/from a YAML sequence.  For example:
 ///
 ///    template<>
-///    struct SequenceTraits< std::vector<MyType>> {
-///      static size_t size(IO &io, std::vector<MyType> &seq) {
+///    struct SequenceTraits<MyContainer> {
+///      static size_t size(IO &io, MyContainer &seq) {
 ///        return seq.size();
 ///      }
-///      static MyType& element(IO &, std::vector<MyType> &seq, size_t index) {
+///      static MyType& element(IO &, MyContainer &seq, size_t index) {
 ///        if ( index >= seq.size() )
 ///          seq.resize(index+1);
 ///        return seq[index];
 ///      }
 ///    };
-template<typename T>
+template<typename T, typename EnableIf = void>
 struct SequenceTraits {
   // Must provide:
   // static size_t size(IO &io, T &seq);
   // static T::value_type& element(IO &io, T &seq, size_t index);
   //
   // The following is option and will cause generated YAML to use
   // a flow sequence (e.g. [a,b,c]).
   // static const bool flow = true;
 };
 
+/// This class should be specialized by any type for which vectors of that
+/// type need to be converted to/from a YAML sequence.
+template<typename T, typename EnableIf = void>
+struct SequenceElementTraits {
+  // Must provide:
+  // static const bool flow;
+};
+
 /// This class should be specialized by any type that needs to be converted
 /// to/from a list of YAML documents.
 template<typename T>
 struct DocumentListTraits {
   // Must provide:
   // static size_t size(IO &io, T &seq);
   // static T::value_type& element(IO &io, T &seq, size_t index);
 };

 template <typename T>
 inline typename std::enable_if<missingTraits<T, EmptyContext>::value,
                                Output &>::type
 operator<<(Output &yout, T &seq) {
   char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)];
   return yout;
 }
 
-template <typename T> struct SequenceTraitsImpl {
-  using _type = typename T::value_type;
+template <bool B> struct IsFlowSequenceBase {};
+template <> struct IsFlowSequenceBase<true> { static const bool flow = true; };
 
+template <typename T, bool Flow>
+struct SequenceTraitsImpl : IsFlowSequenceBase<Flow> {
+private:
+  using type = typename T::value_type;
+
+public:
   static size_t size(IO &io, T &seq) { return seq.size(); }
 
-  static _type &element(IO &io, T &seq, size_t index) {
+  static type &element(IO &io, T &seq, size_t index) {
     if (index >= seq.size())
       seq.resize(index + 1);
     return seq[index];
   }
 };
 
+// Simple helper to check an expression can be used as a bool-valued template
+// argument.
+template <bool> struct CheckIsBool { static const bool value = true; };
+
+// If T has SequenceElementTraits, then vector<T> and SmallVector<T, N> have
+// SequenceTraits that do the obvious thing.
+template <typename T>
+struct SequenceTraits<std::vector<T>,
+                      typename std::enable_if<CheckIsBool<
+                          SequenceElementTraits<T>::flow>::value>::type>
+    : SequenceTraitsImpl<std::vector<T>, SequenceElementTraits<T>::flow> {};
+template <typename T, unsigned N>
+struct SequenceTraits<SmallVector<T, N>,
+                      typename std::enable_if<CheckIsBool<
+                          SequenceElementTraits<T>::flow>::value>::type>
+    : SequenceTraitsImpl<SmallVector<T, N>, SequenceElementTraits<T>::flow> {};
+
+// Sequences of fundamental types use flow formatting.
+template <typename T>
+struct SequenceElementTraits<
+    T, typename std::enable_if<std::is_fundamental<T>::value>::type> {
+  static const bool flow = true;
+};
+
+// Sequences of strings use block formatting.
+template<> struct SequenceElementTraits<std::string> {
+  static const bool flow = false;
+};
+template<> struct SequenceElementTraits<StringRef> {
+  static const bool flow = false;
+};
+template<> struct SequenceElementTraits<std::pair<std::string, std::string>> {
+  static const bool flow = false;
+};
+
 /// Implementation of CustomMappingTraits for std::map<std::string, T>.
 template <typename T> struct StdMapStringCustomMappingTraitsImpl {
   using map_type = std::map<std::string, T>;
 
   static void inputOne(IO &io, StringRef key, map_type &v) {
     io.mapRequired(key.str().c_str(), v[key]);
   }
 
   static void output(IO &io, map_type &v) {
     for (auto &p : v)
       io.mapRequired(p.first.c_str(), p.second);
   }
 };
 
 } // end namespace yaml
 } // end namespace llvm
 
-/// Utility for declaring that a std::vector of a particular type
-/// should be considered a YAML sequence.
-#define LLVM_YAML_IS_SEQUENCE_VECTOR(_type)                                    \
+#define LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(TYPE, FLOW)                          \
   namespace llvm {                                                             \
   namespace yaml {                                                             \
-  template <>                                                                  \
-  struct SequenceTraits<std::vector<_type>>                                    \
-      : public SequenceTraitsImpl<std::vector<_type>> {};                      \
-  template <unsigned N>                                                        \
-  struct SequenceTraits<SmallVector<_type, N>>                                 \
-      : public SequenceTraitsImpl<SmallVector<_type, N>> {};                   \
+  static_assert(                                                               \
+      !std::is_fundamental<TYPE>::value &&                                     \
+      !std::is_same<TYPE, std::string>::value &&                               \
+      !std::is_same<TYPE, llvm::StringRef>::value,                             \
+      "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control");          \
+  template <> struct SequenceElementTraits<TYPE> {                             \
+    static const bool flow = FLOW;                                             \
+  };                                                                           \
   }                                                                            \
   }
 
 /// Utility for declaring that a std::vector of a particular type
+/// should be considered a YAML sequence.
+#define LLVM_YAML_IS_SEQUENCE_VECTOR(type)                                     \
+  LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, false)
+
+/// Utility for declaring that a std::vector of a particular type
 /// should be considered a YAML flow sequence.
-/// We need to do a partial specialization on the vector version, not a full.
-/// If this is a full specialization, the compiler is a bit too "smart" and
-/// decides to warn on -Wunused-const-variable.  This workaround can be
-/// removed and we can do a full specialization on std::vector<T> once
-/// PR28878 is fixed.
-#define LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(_type)                               \
-  namespace llvm {                                                             \
-  namespace yaml {                                                             \
-  template <unsigned N>                                                        \
-  struct SequenceTraits<SmallVector<_type, N>>                                 \
-      : public SequenceTraitsImpl<SmallVector<_type, N>> {                     \
-    static const bool flow = true;                                             \
-  };                                                                           \
-  template <typename Allocator>                                                \
-  struct SequenceTraits<std::vector<_type, Allocator>>                         \
-      : public SequenceTraitsImpl<std::vector<_type, Allocator>> {             \
-    static const bool flow = true;                                             \
-  };                                                                           \
-  }                                                                            \
-  }
+#define LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(type)                                \
+  LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, true)
 
 #define LLVM_YAML_DECLARE_MAPPING_TRAITS(Type)                                 \
   namespace llvm {                                                             \
   namespace yaml {                                                             \
   template <> struct MappingTraits<Type> {                                     \
     static void mapping(IO &IO, Type &Obj);                                    \
   };                                                                           \
   }                                                                            \

 
 /// Utility for declaring that a std::vector of a particular type
 /// should be considered a YAML document list.
 #define LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(_type)                               \
   namespace llvm {                                                             \
   namespace yaml {                                                             \
   template <unsigned N>                                                        \
   struct DocumentListTraits<SmallVector<_type, N>>                             \
-      : public SequenceTraitsImpl<SmallVector<_type, N>> {};                   \
+      : public SequenceTraitsImpl<SmallVector<_type, N>, false> {};            \
   template <>                                                                  \
   struct DocumentListTraits<std::vector<_type>>                                \
-      : public SequenceTraitsImpl<std::vector<_type>> {};                      \
+      : public SequenceTraitsImpl<std::vector<_type>, false> {};               \
   }                                                                            \
   }
 
 /// Utility for declaring that std::map<std::string, _type> should be considered
 /// a YAML map.
 #define LLVM_YAML_IS_STRING_MAP(_type)                                         \
   namespace llvm {                                                             \
   namespace yaml {                                                             \
   template <>                                                                  \
   struct CustomMappingTraits<std::map<std::string, _type>>                     \
       : public StdMapStringCustomMappingTraitsImpl<_type> {};                  \
   }                                                                            \
   }
 
 #endif // LLVM_SUPPORT_YAMLTRAITS_H

llvm/trunk/lib/ObjectYAML/CodeViewYAMLDebugSections.cpp

 LLVM_YAML_IS_SEQUENCE_VECTOR(SourceLineEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(SourceColumnEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(SourceLineBlock)
 LLVM_YAML_IS_SEQUENCE_VECTOR(SourceLineInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(InlineeSite)
 LLVM_YAML_IS_SEQUENCE_VECTOR(InlineeInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(CrossModuleExport)
 LLVM_YAML_IS_SEQUENCE_VECTOR(YAMLCrossModuleImport)
-LLVM_YAML_IS_SEQUENCE_VECTOR(StringRef)
 LLVM_YAML_IS_SEQUENCE_VECTOR(YAMLFrameData)
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint32_t)
 
 LLVM_YAML_DECLARE_SCALAR_TRAITS(HexFormattedString, false)
 LLVM_YAML_DECLARE_ENUM_TRAITS(DebugSubsectionKind)
 LLVM_YAML_DECLARE_ENUM_TRAITS(FileChecksumKind)
 LLVM_YAML_DECLARE_BITSET_TRAITS(LineFlags)
 
 LLVM_YAML_DECLARE_MAPPING_TRAITS(CrossModuleExport)
 LLVM_YAML_DECLARE_MAPPING_TRAITS(YAMLFrameData)

llvm/trunk/lib/ObjectYAML/CodeViewYAMLSymbols.cpp

 #include "llvm/DebugInfo/CodeView/SymbolSerializer.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::CodeViewYAML;
 using namespace llvm::CodeViewYAML::detail;
 using namespace llvm::yaml;
 
-LLVM_YAML_IS_SEQUENCE_VECTOR(StringRef)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)
 
 // We only need to declare these, the definitions are in CodeViewYAMLTypes.cpp
 LLVM_YAML_DECLARE_SCALAR_TRAITS(APSInt, false)
 LLVM_YAML_DECLARE_SCALAR_TRAITS(TypeIndex, false)
 
 LLVM_YAML_DECLARE_ENUM_TRAITS(SymbolKind)
 LLVM_YAML_DECLARE_ENUM_TRAITS(FrameCookieKind)

llvm/trunk/lib/ObjectYAML/CodeViewYAMLTypes.cpp

 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::CodeViewYAML;
 using namespace llvm::CodeViewYAML::detail;
 using namespace llvm::yaml;
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(OneMethodRecord)
-LLVM_YAML_IS_SEQUENCE_VECTOR(StringRef)
 LLVM_YAML_IS_SEQUENCE_VECTOR(VFTableSlotKind)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)
 
 LLVM_YAML_DECLARE_SCALAR_TRAITS(TypeIndex, false)
 LLVM_YAML_DECLARE_SCALAR_TRAITS(APSInt, false)
 
 LLVM_YAML_DECLARE_ENUM_TRAITS(TypeLeafKind)
 LLVM_YAML_DECLARE_ENUM_TRAITS(PointerToMemberRepresentation)

llvm/trunk/lib/Support/AMDGPUCodeObjectMetadata.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/AMDGPUCodeObjectMetadata.h"
 #include "llvm/Support/YAMLTraits.h"
 
 using namespace llvm::AMDGPU;
 using namespace llvm::AMDGPU::CodeObject;
 
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint32_t)
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(std::string)
 LLVM_YAML_IS_SEQUENCE_VECTOR(Kernel::Arg::Metadata)
 LLVM_YAML_IS_SEQUENCE_VECTOR(Kernel::Metadata)
 
 namespace llvm {
 namespace yaml {
 
 template <>
 struct ScalarEnumerationTraits<AccessQualifier> {

llvm/trunk/test/CodeGen/AMDGPU/code-object-metadata-from-llvm-ir-full.ll

 %opencl.image3d_t = type opaque
 %opencl.queue_t = type opaque
 %opencl.pipe_t = type opaque
 %struct.B = type { i32 addrspace(1)*}
 %opencl.clk_event_t = type opaque
 
 ; CHECK: ---
 ; CHECK:  Version: [ 1, 0 ]
-; CHECK:  Printf: [ '1:1:4:%d\n', '2:1:8:%g\n' ]
+; CHECK:  Printf:
+; CHECK:    - '1:1:4:%d\n'
+; CHECK:    - '2:1:8:%g\n'
 ; CHECK:  Kernels:
 
 ; CHECK:      - Name:            test_char
 ; CHECK-NEXT:   Language:        OpenCL C
 ; CHECK-NEXT:   LanguageVersion: [ 2, 0 ]
 ; CHECK-NEXT:   Args:
 ; CHECK-NEXT:     - Size:          1
 ; CHECK-NEXT:       Align:         1

 !94 = !{!"", !"", !"", !"", !"", !"", !""}
 !100 = !{!"1:1:4:%d\5Cn"}
 !101 = !{!"2:1:8:%g\5Cn"}
 
 ; NOTES: Displaying notes found at file offset 0x{{[0-9]+}}
 ; NOTES-NEXT: Owner    Data size    Description
 ; NOTES-NEXT: AMD      0x00000008   Unknown note type: (0x00000001)
 ; NOTES-NEXT: AMD      0x0000001b   Unknown note type: (0x00000003)
-; GFX700:     AMD      0x00008b06   Unknown note type: (0x0000000a)
-; GFX800:     AMD      0x00008e6a   Unknown note type: (0x0000000a)
-; GFX900:     AMD      0x00008b06   Unknown note type: (0x0000000a)
+; GFX700:     AMD      0x00008b0a   Unknown note type: (0x0000000a)
+; GFX800:     AMD      0x00008e6e   Unknown note type: (0x0000000a)
+; GFX900:     AMD      0x00008b0a   Unknown note type: (0x0000000a)
 
 ; PARSER: AMDGPU Code Object Metadata Parser Test: PASS

llvm/trunk/test/MC/AMDGPU/code-object-metadata-kernel-args.s

 // RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx700 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX700 %s
 // RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx800 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX800 %s
 // RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx900 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX900 %s
 
 // CHECK:  .amdgpu_code_object_metadata
 // CHECK:    Version: [ 1, 0 ]
-// CHECK:    Printf: [ '1:1:4:%d\n', '2:1:8:%g\n' ]
+// CHECK:    Printf:
+// CHECK:      - '1:1:4:%d\n'
+// CHECK:      - '2:1:8:%g\n'
 // CHECK:    Kernels:
 // CHECK:      - Name:            test_kernel
 // CHECK:        Language:        OpenCL C
 // CHECK:        LanguageVersion: [ 2, 0 ]
 // CHECK:        Args:
 // CHECK:          - Size:          1
 // CHECK:            Align:         1
 // CHECK:            ValueKind:     ByValue

llvm/trunk/test/MC/AMDGPU/code-object-metadata-kernel-attrs.s

 // RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx700 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX700 %s
 // RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx800 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX800 %s
 // RUN: llvm-mc -triple=amdgcn-amd-amdhsa -mcpu=gfx900 -show-encoding %s | FileCheck --check-prefix=CHECK --check-prefix=GFX900 %s
 
 // CHECK:  .amdgpu_code_object_metadata
 // CHECK:    Version: [ 1, 0 ]
-// CHECK:    Printf: [ '1:1:4:%d\n', '2:1:8:%g\n' ]
+// CHECK:    Printf:
+// CHECK:      - '1:1:4:%d\n'
+// CHECK:      - '2:1:8:%g\n'
 // CHECK:    Kernels:
 // CHECK:      - Name:            test_kernel
 // CHECK:        Language:        OpenCL C
 // CHECK:        LanguageVersion: [ 2, 0 ]
 // CHECK:    Attrs:
 // CHECK:        ReqdWorkGroupSize: [ 1, 2, 4 ]
 // CHECK:        WorkGroupSizeHint: [ 8, 16, 32 ]
 // CHECK:        VecTypeHint:       int

llvm/trunk/test/Transforms/LowerTypeTests/export-icall.ll

 ; SUMMARY-NEXT:       SizeM1BitWidth:  7
 ; SUMMARY-NEXT:     WPDRes:
 ; SUMMARY-NEXT:   typeid2:
 ; SUMMARY-NEXT:     TTRes:
 ; SUMMARY-NEXT:       Kind:            Single
 ; SUMMARY-NEXT:       SizeM1BitWidth:  0
 ; SUMMARY-NEXT:     WPDRes:
 
-; SUMMARY:      CfiFunctionDefs: [ f, g, h ]
-; SUMMARY-NEXT: CfiFunctionDecls: [ external, external_weak ]
+; SUMMARY:      CfiFunctionDefs:
+; SUMMARY-NEXT:   - f
+; SUMMARY-NEXT:   - g
+; SUMMARY-NEXT:   - h
+; SUMMARY-NEXT: CfiFunctionDecls:
+; SUMMARY-NEXT:   - external
+; SUMMARY-NEXT:   - external_weak
 ; SUMMARY-NEXT: ...

llvm/trunk/tools/llvm-pdbutil/PdbYaml.cpp

 #include "llvm/ObjectYAML/CodeViewYAMLDebugSections.h"
 #include "llvm/ObjectYAML/CodeViewYAMLTypes.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 using namespace llvm::pdb::yaml;
 using namespace llvm::yaml;
 
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint32_t)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::StringRef)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::NamedStreamMapping)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::PdbDbiModuleInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::pdb::yaml::StreamBlockList)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::pdb::PdbRaw_FeatureSig)
 
 namespace llvm {
 namespace yaml {
 

llvm/trunk/unittests/Support/YAMLIOTest.cpp

 }
 
 //===----------------------------------------------------------------------===//
 //  Test flow sequences
 //===----------------------------------------------------------------------===//
 
 LLVM_YAML_STRONG_TYPEDEF(int, MyNumber)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(MyNumber)
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(llvm::StringRef)
+LLVM_YAML_STRONG_TYPEDEF(llvm::StringRef, MyString)
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(MyString)
 
 namespace llvm {
 namespace yaml {
   template<>
   struct ScalarTraits<MyNumber> {
     static void output(const MyNumber &value, void *, llvm::raw_ostream &out) {
       out << value;
     }
 
     static StringRef input(StringRef scalar, void *, MyNumber &value) {
       long long n;
       if ( getAsSignedInteger(scalar, 0, n) )
         return "invalid number";
       value = n;
       return StringRef();
     }
 
     static bool mustQuote(StringRef) { return false; }
   };
+
+  template <> struct ScalarTraits<MyString> {
+    using Impl = ScalarTraits<StringRef>;
+    static void output(const MyString &V, void *Ctx, raw_ostream &OS) {
+      Impl::output(V, Ctx, OS);
+    }
+    static StringRef input(StringRef S, void *Ctx, MyString &V) {
+      return Impl::input(S, Ctx, V.value);
+    }
+    static bool mustQuote(StringRef S) { return Impl::mustQuote(S); }
+  };
 }
 }
 
 struct NameAndNumbers {
   llvm::StringRef               name;
-  std::vector<llvm::StringRef>  strings;
+  std::vector<MyString>         strings;
   std::vector<MyNumber>         single;
   std::vector<MyNumber>         numbers;
 };
 
 namespace llvm {
 namespace yaml {
   template <>
   struct MappingTraits<NameAndNumbers> {
TEST(YAMLIO, TestReadWriteMyFlowSequence) {
   {
     Input yin(intermediate);
     NameAndNumbers map2;
     yin >> map2;
 
     EXPECT_FALSE(yin.error());
     EXPECT_TRUE(map2.name.equals("hello"));
     EXPECT_EQ(map2.strings.size(), 2UL);
-    EXPECT_TRUE(map2.strings[0].equals("one"));
-    EXPECT_TRUE(map2.strings[1].equals("two"));
+    EXPECT_TRUE(map2.strings[0].value.equals("one"));
+    EXPECT_TRUE(map2.strings[1].value.equals("two"));
     EXPECT_EQ(map2.single.size(), 1UL);
     EXPECT_EQ(1,       map2.single[0]);
     EXPECT_EQ(map2.numbers.size(), 3UL);
     EXPECT_EQ(10,      map2.numbers[0]);
     EXPECT_EQ(-30,     map2.numbers[1]);
     EXPECT_EQ(1024,    map2.numbers[2]);
   }
 }
TEST(YAMLIO, TestFlagsReadError) {
 
   EXPECT_TRUE(!!yin.error());
 }
 
 
 //
 // Test error handling reading built-in uint8_t type
 //
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint8_t)
 TEST(YAMLIO, TestReadBuiltInTypesUint8Error) {
   std::vector<uint8_t> seq;
   Input yin("---\n"
             "- 255\n"
             "- 0\n"
             "- 257\n"
             "...\n",
             /*Ctxt=*/nullptr,
             suppressErrorMessages);
   yin >> seq;
 
   EXPECT_TRUE(!!yin.error());
 }
 
 
 //
 // Test error handling reading built-in uint16_t type
 //
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint16_t)
 TEST(YAMLIO, TestReadBuiltInTypesUint16Error) {
   std::vector<uint16_t> seq;
   Input yin("---\n"
             "- 65535\n"
             "- 0\n"
             "- 66000\n"
             "...\n",
             /*Ctxt=*/nullptr,
             suppressErrorMessages);
   yin >> seq;
 
   EXPECT_TRUE(!!yin.error());
 }
 
 
 //
 // Test error handling reading built-in uint32_t type
 //
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint32_t)
 TEST(YAMLIO, TestReadBuiltInTypesUint32Error) {
   std::vector<uint32_t> seq;
   Input yin("---\n"
             "- 4000000000\n"
             "- 0\n"
             "- 5000000000\n"
             "...\n",
             /*Ctxt=*/nullptr,
             suppressErrorMessages);
   yin >> seq;
 
   EXPECT_TRUE(!!yin.error());
 }
 
 
 //
 // Test error handling reading built-in uint64_t type
 //
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(uint64_t)
 TEST(YAMLIO, TestReadBuiltInTypesUint64Error) {
   std::vector<uint64_t> seq;
   Input yin("---\n"
             "- 18446744073709551615\n"
             "- 0\n"
             "- 19446744073709551615\n"
             "...\n",
             /*Ctxt=*/nullptr,
             suppressErrorMessages);
   yin >> seq;
 
   EXPECT_TRUE(!!yin.error());
 }
 
 
 //
 // Test error handling reading built-in int8_t type
 //
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(int8_t)
 TEST(YAMLIO, TestReadBuiltInTypesint8OverError) {
   std::vector<int8_t> seq;
   Input yin("---\n"
             "- -128\n"
             "- 0\n"
             "- 127\n"
             "- 128\n"
            "...\n",
TEST(YAMLIO, TestReadBuiltInTypesint8UnderError) {
 
   EXPECT_TRUE(!!yin.error());
 }
 
 
 //
 // Test error handling reading built-in int16_t type
 //
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(int16_t)
 TEST(YAMLIO, TestReadBuiltInTypesint16UnderError) {
   std::vector<int16_t> seq;
   Input yin("---\n"
             "- 32767\n"
             "- 0\n"
             "- -32768\n"
             "- -32769\n"
             "...\n",
TEST(YAMLIO, TestReadBuiltInTypesint16OverError) {
 
   EXPECT_TRUE(!!yin.error());
 }
 
 
 //
 // Test error handling reading built-in int32_t type
 //
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(int32_t)
 TEST(YAMLIO, TestReadBuiltInTypesint32UnderError) {
   std::vector<int32_t> seq;
   Input yin("---\n"
             "- 2147483647\n"
             "- 0\n"
             "- -2147483648\n"
             "- -2147483649\n"
             "...\n",
TEST(YAMLIO, TestReadBuiltInTypesint32OverError) {
 
   EXPECT_TRUE(!!yin.error());
 }
 
 
 //
 // Test error handling reading built-in int64_t type
 //
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(int64_t)
 TEST(YAMLIO, TestReadBuiltInTypesint64UnderError) {
   std::vector<int64_t> seq;
   Input yin("---\n"
             "- -9223372036854775808\n"
             "- 0\n"
             "- 9223372036854775807\n"
             "- -9223372036854775809\n"
             "...\n",
TEST(YAMLIO, TestReadBuiltInTypesint64OverError) {
   yin >> seq;
 
   EXPECT_TRUE(!!yin.error());
 }
 
 //
 // Test error handling reading built-in float type
 //
-LLVM_YAML_IS_SEQUENCE_VECTOR(float)
 TEST(YAMLIO, TestReadBuiltInTypesFloatError) {
   std::vector<float> seq;
   Input yin("---\n"
             "- 0.0\n"
             "- 1000.1\n"
             "- -123.456\n"
             "- 1.2.3\n"
             "...\n",
             /*Ctxt=*/nullptr,
             suppressErrorMessages);
   yin >> seq;
 
   EXPECT_TRUE(!!yin.error());
 }
 
 //
 // Test error handling reading built-in float type
 //
-LLVM_YAML_IS_SEQUENCE_VECTOR(double)
 TEST(YAMLIO, TestReadBuiltInTypesDoubleError) {
   std::vector<double> seq;
   Input yin("---\n"
             "- 0.0\n"
             "- 1000.1\n"
             "- -123.456\n"
             "- 1.2.3\n"
             "...\n",