Add concrete type overloads to PDBSymbol::findChildren().

Frequently you only want to iterate over children of a specific
type (e.g. functions).  Previously you would get back a generic
interface that allowed iteration over the base symbol type,
which you would have to dyn_cast<> each one of.  With this patch,
we allow the user to specify the concrete type as a template
parameter, and it will return an iterator which returns instances
of the concrete type directly.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@228960 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/DebugInfo/PDB/ConcreteSymbolEnumerator.h

@@ -0,0 +1,58 @@
+//===- ConcreteSymbolEnumerator.h -------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_PDB_CONCRETESYMBOLENUMERATOR_H
+#define LLVM_DEBUGINFO_PDB_CONCRETESYMBOLENUMERATOR_H
+
+#include <memory>
+#include "IPDBEnumChildren.h"
+
+namespace llvm {
+
+template <typename ChildType>
+class ConcreteSymbolEnumerator : public IPDBEnumChildren<ChildType> {
+public:
+  ConcreteSymbolEnumerator(std::unique_ptr<IPDBEnumSymbols> SymbolEnumerator)
+      : Enumerator(std::move(SymbolEnumerator)) {}
+
+  virtual ~ConcreteSymbolEnumerator() {}
+
+  uint32_t getChildCount() const override {
+    return Enumerator->getChildCount();
+  }
+
+  std::unique_ptr<ChildType> getChildAtIndex(uint32_t Index) const {
+    std::unique_ptr<PDBSymbol> Child = Enumerator->getChildAtIndex(Index);
+    return make_concrete_child(std::move(Child));
+  }
+
+  std::unique_ptr<ChildType> getNext() {
+    std::unique_ptr<PDBSymbol> Child = Enumerator->getNext();
+    return make_concrete_child(std::move(Child));
+  }
+
+  void reset() { Enumerator->reset(); }
+
+  MyType *clone() const {
+    std::unique_ptr<IPDBEnumSymbols> WrappedClone(Enumerator->clone());
+    return new ConcreteSymbolEnumerator<ChildType>(std::move(WrappedClone));
+  }
+
+private:
+  std::unique_ptr<ChildType>
+  make_concrete_child(std::unique_ptr<PDBSymbol> Child) const {
+    ChildType *ConcreteChild = dyn_cast_or_null<ChildType>(Child.release());
+    return std::unique_ptr<ChildType>(ConcreteChild);
+  }
+
+  std::unique_ptr<IPDBEnumSymbols> Enumerator;
+};
+}
+
+#endif

include/llvm/DebugInfo/PDB/PDBSymbol.h

@@ -16,6 +16,7 @@
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
 
+#include "ConcreteSymbolEnumerator.h"
 #include "IPDBRawSymbol.h"
 #include "PDBExtras.h"
 #include "PDBTypes.h"
@@ -30,6 +31,10 @@ namespace llvm {
 class IPDBRawSymbol;
 class raw_ostream;
 
+#define DECLARE_PDB_SYMBOL_CONCRETE_TYPE(TagValue)                             \
+  static const PDB_SymType Tag = TagValue;                                     \
+  static bool classof(const PDBSymbol *S) { return S->getSymTag() == Tag; }
+
 /// PDBSymbol defines the base of the inheritance hierarchy for concrete symbol
 /// types (e.g. functions, executables, vtables, etc).  All concrete symbol
 /// types inherit from PDBSymbol and expose the exact set of methods that are
@@ -55,7 +60,18 @@ public:
 
   PDB_SymType getSymTag() const;
 
-  std::unique_ptr<IPDBEnumSymbols> findChildren(PDB_SymType Type) const;
+  template <typename T> std::unique_ptr<T> findOneChild() const {
+    auto Enumerator(findAllChildren<T>());
+    return Enumerator->getNext();
+  }
+
+  template <typename T>
+  std::unique_ptr<ConcreteSymbolEnumerator<T>> findAllChildren() const {
+    auto BaseIter = RawSymbol->findChildren(T::Tag);
+    return std::make_unique<ConcreteSymbolEnumerator<T>>(std::move(BaseIter));
+  }
+
+  std::unique_ptr<IPDBEnumSymbols> findAllChildren() const;
   std::unique_ptr<IPDBEnumSymbols>
   findChildren(PDB_SymType Type, StringRef Name,
                PDB_NameSearchFlags Flags) const;

include/llvm/DebugInfo/PDB/PDBSymbolAnnotation.h

@@ -23,6 +23,8 @@ public:
   PDBSymbolAnnotation(const IPDBSession &PDBSession,
                       std::unique_ptr<IPDBRawSymbol> Symbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::Annotation)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getAddressOffset)
@@ -32,10 +34,6 @@ public:
   FORWARD_SYMBOL_METHOD(getSymIndexId)
   // FORWARD_SYMBOL_METHOD(getValue)
   FORWARD_SYMBOL_METHOD(getVirtualAddress)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::Annotation;
-  }
 };
 }
 

include/llvm/DebugInfo/PDB/PDBSymbolBlock.h

@@ -23,6 +23,8 @@ public:
   PDBSymbolBlock(const IPDBSession &PDBSession,
                  std::unique_ptr<IPDBRawSymbol> Symbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::Block)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getAddressOffset)
@@ -34,10 +36,6 @@ public:
   FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
   FORWARD_SYMBOL_METHOD(getSymIndexId)
   FORWARD_SYMBOL_METHOD(getVirtualAddress)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::Block;
-  }
 };
 }
 

include/llvm/DebugInfo/PDB/PDBSymbolCompiland.h

@@ -23,6 +23,8 @@ public:
   PDBSymbolCompiland(const IPDBSession &PDBSession,
                      std::unique_ptr<IPDBRawSymbol> CompilandSymbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::Compiland)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(isEditAndContinueEnabled)
@@ -31,10 +33,6 @@ public:
   FORWARD_SYMBOL_METHOD(getName)
   FORWARD_SYMBOL_METHOD(getSourceFileName)
   FORWARD_SYMBOL_METHOD(getSymIndexId)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::Compiland;
-  }
 };
 }
 

include/llvm/DebugInfo/PDB/PDBSymbolCompilandDetails.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolCompilandDetails(const IPDBSession &PDBSession,
                             std::unique_ptr<IPDBRawSymbol> Symbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::CompilandDetails)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   void getFrontEndVersion(VersionInfo &Version) const {
@@ -46,10 +48,6 @@ public:
   FORWARD_SYMBOL_METHOD(getLexicalParentId)
   FORWARD_SYMBOL_METHOD(getPlatform)
   FORWARD_SYMBOL_METHOD(getSymIndexId)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::CompilandDetails;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolCompilandEnv.h

@@ -22,16 +22,14 @@ public:
   PDBSymbolCompilandEnv(const IPDBSession &PDBSession,
                         std::unique_ptr<IPDBRawSymbol> Symbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::CompilandEnv)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getLexicalParentId)
   FORWARD_SYMBOL_METHOD(getName)
   FORWARD_SYMBOL_METHOD(getSymIndexId)
   std::string getValue() const;
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::CompilandEnv;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolCustom.h

@@ -27,14 +27,12 @@ public:
   PDBSymbolCustom(const IPDBSession &PDBSession,
                   std::unique_ptr<IPDBRawSymbol> CustomSymbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::Custom)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   void getDataBytes(llvm::SmallVector<uint8_t, 32> &bytes);
   FORWARD_SYMBOL_METHOD(getSymIndexId)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::Custom;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolData.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolData(const IPDBSession &PDBSession,
                 std::unique_ptr<IPDBRawSymbol> DataSymbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::Data)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getAccess)
@@ -50,10 +52,6 @@ public:
   // FORWARD_SYMBOL_METHOD(getValue)
   FORWARD_SYMBOL_METHOD(getVirtualAddress)
   FORWARD_SYMBOL_METHOD(isVolatileType)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::Data;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolExe.h

@@ -24,6 +24,8 @@ public:
   PDBSymbolExe(const IPDBSession &PDBSession,
                std::unique_ptr<IPDBRawSymbol> ExeSymbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::Exe)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getAge)
@@ -35,10 +37,6 @@ public:
   FORWARD_SYMBOL_METHOD(getSignature)
   FORWARD_SYMBOL_METHOD(getSymbolsFileName)
   FORWARD_SYMBOL_METHOD(getSymIndexId)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::Exe;
-  }
 };
 } // namespace llvm
 

include/llvm/DebugInfo/PDB/PDBSymbolFunc.h

@@ -24,6 +24,8 @@ public:
 
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::Function)
+
   FORWARD_SYMBOL_METHOD(getAccess)
   FORWARD_SYMBOL_METHOD(getAddressOffset)
   FORWARD_SYMBOL_METHOD(getAddressSection)
@@ -66,10 +68,6 @@ public:
   FORWARD_SYMBOL_METHOD(getVirtualAddress)
   FORWARD_SYMBOL_METHOD(getVirtualBaseOffset)
   FORWARD_SYMBOL_METHOD(isVolatileType)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::Function;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolFuncDebugEnd(const IPDBSession &PDBSession,
                         std::unique_ptr<IPDBRawSymbol> FuncDebugEndSymbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::FuncDebugEnd)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getAddressOffset)
@@ -40,10 +42,6 @@ public:
   FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
   FORWARD_SYMBOL_METHOD(getSymIndexId)
   FORWARD_SYMBOL_METHOD(getVirtualAddress)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::FuncDebugEnd;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolFuncDebugStart(const IPDBSession &PDBSession,
                           std::unique_ptr<IPDBRawSymbol> FuncDebugStartSymbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::FuncDebugStart)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getAddressOffset)
@@ -40,10 +42,6 @@ public:
   FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
   FORWARD_SYMBOL_METHOD(getSymIndexId)
   FORWARD_SYMBOL_METHOD(getVirtualAddress)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::FuncDebugStart;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolLabel.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolLabel(const IPDBSession &PDBSession,
                  std::unique_ptr<IPDBRawSymbol> LabelSymbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::Label)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getAddressOffset)
@@ -40,10 +42,6 @@ public:
   FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
   FORWARD_SYMBOL_METHOD(getSymIndexId)
   FORWARD_SYMBOL_METHOD(getVirtualAddress)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::Label;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolPublicSymbol(const IPDBSession &PDBSession,
                         std::unique_ptr<IPDBRawSymbol> PublicSymbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::PublicSymbol)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getAddressOffset)
@@ -38,10 +40,6 @@ public:
   FORWARD_SYMBOL_METHOD(getRelativeVirtualAddress)
   FORWARD_SYMBOL_METHOD(getVirtualAddress)
   FORWARD_SYMBOL_METHOD(getUndecoratedName)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::PublicSymbol;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolThunk.h

@@ -24,6 +24,8 @@ public:
   PDBSymbolThunk(const IPDBSession &PDBSession,
                  std::unique_ptr<IPDBRawSymbol> ThunkSymbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::Thunk)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getAccess)
@@ -50,10 +52,6 @@ public:
   FORWARD_SYMBOL_METHOD(getVirtualAddress)
   FORWARD_SYMBOL_METHOD(getVirtualBaseOffset)
   FORWARD_SYMBOL_METHOD(isVolatileType)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::Thunk;
-  }
 };
 } // namespace llvm
 

include/llvm/DebugInfo/PDB/PDBSymbolTypeArray.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolTypeArray(const IPDBSession &PDBSession,
                      std::unique_ptr<IPDBRawSymbol> ArrayTypeSymbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::ArrayType)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getArrayIndexTypeId)
@@ -34,10 +36,6 @@ public:
   FORWARD_SYMBOL_METHOD(getTypeId)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(isVolatileType)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::ArrayType;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolTypeBaseClass.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolTypeBaseClass(const IPDBSession &PDBSession,
                          std::unique_ptr<IPDBRawSymbol> Symbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::BaseClass)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getAccess)
@@ -51,10 +53,6 @@ public:
   // FORWARD_SYMBOL_METHOD(getVirtualBaseTableType)
   FORWARD_SYMBOL_METHOD(getVirtualTableShapeId)
   FORWARD_SYMBOL_METHOD(isVolatileType)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::BaseClass;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolTypeBuiltin(const IPDBSession &PDBSession,
                        std::unique_ptr<IPDBRawSymbol> Symbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::BuiltinType)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getBuiltinType)
@@ -31,10 +33,6 @@ public:
   FORWARD_SYMBOL_METHOD(getSymIndexId)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(isVolatileType)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::BuiltinType;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolTypeCustom.h

@@ -22,15 +22,13 @@ public:
   PDBSymbolTypeCustom(const IPDBSession &PDBSession,
                       std::unique_ptr<IPDBRawSymbol> Symbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::CustomType)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getOemId)
   FORWARD_SYMBOL_METHOD(getOemSymbolId)
   FORWARD_SYMBOL_METHOD(getSymIndexId)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::CustomType;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolTypeDimension.h

@@ -22,15 +22,13 @@ public:
   PDBSymbolTypeDimension(const IPDBSession &PDBSession,
                          std::unique_ptr<IPDBRawSymbol> Symbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::Dimension)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getLowerBoundId)
   FORWARD_SYMBOL_METHOD(getUpperBoundId)
   FORWARD_SYMBOL_METHOD(getSymIndexId)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::Dimension;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolTypeEnum(const IPDBSession &PDBSession,
                     std::unique_ptr<IPDBRawSymbol> EnumTypeSymbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::Enum)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getBuiltinType)
@@ -42,10 +44,6 @@ public:
   FORWARD_SYMBOL_METHOD(getTypeId)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(isVolatileType)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::Enum;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolTypeFriend.h

@@ -22,16 +22,14 @@ public:
   PDBSymbolTypeFriend(const IPDBSession &PDBSession,
                       std::unique_ptr<IPDBRawSymbol> Symbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::Friend)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getClassParentId)
   FORWARD_SYMBOL_METHOD(getName)
   FORWARD_SYMBOL_METHOD(getSymIndexId)
   FORWARD_SYMBOL_METHOD(getTypeId)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::Friend;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolTypeFunctionArg.h

@@ -22,16 +22,14 @@ public:
   PDBSymbolTypeFunctionArg(const IPDBSession &PDBSession,
                            std::unique_ptr<IPDBRawSymbol> Symbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::FunctionArg)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getClassParentId)
   FORWARD_SYMBOL_METHOD(getLexicalParentId)
   FORWARD_SYMBOL_METHOD(getSymIndexId)
   FORWARD_SYMBOL_METHOD(getTypeId)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::FunctionArg;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolTypeFunctionSig(const IPDBSession &PDBSession,
                            std::unique_ptr<IPDBRawSymbol> Symbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::FunctionSig)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getCallingConvention)
@@ -35,10 +37,6 @@ public:
   FORWARD_SYMBOL_METHOD(getTypeId)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(isVolatileType)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::FunctionSig;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolTypeManaged.h

@@ -22,14 +22,12 @@ public:
   PDBSymbolTypeManaged(const IPDBSession &PDBSession,
                        std::unique_ptr<IPDBRawSymbol> Symbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::ManagedType)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getName)
   FORWARD_SYMBOL_METHOD(getSymIndexId)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::ManagedType;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolTypePointer.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolTypePointer(const IPDBSession &PDBSession,
                        std::unique_ptr<IPDBRawSymbol> Symbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::PointerType)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(isConstType)
@@ -32,10 +34,6 @@ public:
   FORWARD_SYMBOL_METHOD(getTypeId)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(isVolatileType)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::PointerType;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolTypeTypedef(const IPDBSession &PDBSession,
                        std::unique_ptr<IPDBRawSymbol> Symbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::Typedef)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getBuiltinType)
@@ -45,10 +47,6 @@ public:
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(getVirtualTableShapeId)
   FORWARD_SYMBOL_METHOD(isVolatileType)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::Typedef;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolTypeUDT(const IPDBSession &PDBSession,
                    std::unique_ptr<IPDBRawSymbol> UDTSymbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::UDT)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getClassParentId)
@@ -42,10 +44,6 @@ public:
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(getVirtualTableShapeId)
   FORWARD_SYMBOL_METHOD(isVolatileType)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::UDT;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolTypeVTable.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolTypeVTable(const IPDBSession &PDBSession,
                       std::unique_ptr<IPDBRawSymbol> VtblSymbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::VTable)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getClassParentId)
@@ -31,10 +33,6 @@ public:
   FORWARD_SYMBOL_METHOD(getTypeId)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(isVolatileType)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::VTable;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolTypeVTableShape.h

@@ -22,6 +22,8 @@ public:
   PDBSymbolTypeVTableShape(const IPDBSession &PDBSession,
                            std::unique_ptr<IPDBRawSymbol> VtblShapeSymbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::VTableShape)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(isConstType)
@@ -30,10 +32,6 @@ public:
   FORWARD_SYMBOL_METHOD(getSymIndexId)
   FORWARD_SYMBOL_METHOD(isUnalignedType)
   FORWARD_SYMBOL_METHOD(isVolatileType)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::VTableShape;
-  }
 };
 
 } // namespace llvm

include/llvm/DebugInfo/PDB/PDBSymbolUsingNamespace.h

@@ -22,15 +22,13 @@ public:
   PDBSymbolUsingNamespace(const IPDBSession &PDBSession,
                           std::unique_ptr<IPDBRawSymbol> Symbol);
 
+  DECLARE_PDB_SYMBOL_CONCRETE_TYPE(PDB_SymType::UsingNamespace)
+
   void dump(raw_ostream &OS, int Indent, PDB_DumpLevel Level) const override;
 
   FORWARD_SYMBOL_METHOD(getLexicalParentId)
   FORWARD_SYMBOL_METHOD(getName)
   FORWARD_SYMBOL_METHOD(getSymIndexId)
-
-  static bool classof(const PDBSymbol *S) {
-    return S->getSymTag() == PDB_SymType::UsingNamespace;
-  }
 };
 
 } // namespace llvm