[codeview] Remove unused parameter.

[ruiu]

Summary

I need to pass raw CVRecord to the visitor callback functions to
compute hash values, becaues in some cases we have to compute a
hash over the entire record as byte array rather than for some
field. But I don't want to make the callbacks to have tons of
parameters. In this patch, the first unused parameter is removed
from callbacks.

[zturner]

This should be fine because I believe the record structure contains the leaf kind anyway. Make sure you try to build the DebugInfoPDBTests target. It's not built by default, and this change might require fixing some things in that project.

[ruiu]

DebugInfoPDBTests built fine and ninja check passed. Submitting.

include/llvm/DebugInfo/CodeView/CVTypeVisitor.h

public:
   }
 
   /// Actions to take on known types. By default, they do nothing. Visit methods
   /// for member records take the FieldData by non-const reference and are
   /// expected to consume the trailing bytes used by the field.
   /// FIXME: Make the visitor interpret the trailing bytes so that clients don't
   /// need to.
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  void visit##Name(TypeLeafKind LeafType, Name##Record &Record) {}
+  void visit##Name(Name##Record &Record) {}
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  void visit##Name(TypeLeafKind LeafType, Name##Record &Record) {}
+  void visit##Name(Name##Record &Record) {}
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "TypeRecords.def"
 
   void visitTypeRecord(const CVRecord<TypeLeafKind> &Record) {
     ArrayRef<uint8_t> LeafData = Record.Data;
     ArrayRef<uint8_t> RecordData = LeafData;
     auto *DerivedThis = static_cast<Derived *>(this);
     DerivedThis->visitTypeBegin(Record.Type, RecordData);
     switch (Record.Type) {
     default:
       DerivedThis->visitUnknownType(Record.Type, RecordData);
       break;
     case LF_FIELDLIST:
       DerivedThis->visitFieldList(Record.Type, LeafData);
       break;
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
   case EnumName: {                                                             \
     TypeRecordKind RK = static_cast<TypeRecordKind>(EnumName);                 \
     auto Result = Name##Record::deserialize(RK, LeafData);                     \
     if (Result.getError())                                                     \
       return parseError();                                                     \
-    DerivedThis->visit##Name(Record.Type, *Result);                            \
+    DerivedThis->visit##Name(*Result);                                         \
     break;                                                                     \
   }
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                  \
   TYPE_RECORD(EnumVal, EnumVal, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)
 #include "TypeRecords.def"
       }
       DerivedThis->visitTypeEnd(Record.Type, RecordData);
while (!FieldData.empty()) {
         DerivedThis->visitUnknownMember(Leaf);
         return parseError();
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
   case EnumName: {                                                             \
     TypeRecordKind RK = static_cast<TypeRecordKind>(EnumName);                 \
     auto Result = Name##Record::deserialize(RK, FieldData);                    \
     if (Result.getError())                                                     \
       return parseError();                                                     \
-    DerivedThis->visit##Name(Leaf, *Result);                                   \
+    DerivedThis->visit##Name(*Result);                                         \
     break;                                                                     \
   }
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                \
   MEMBER_RECORD(EnumVal, EnumVal, AliasName)
 #include "TypeRecords.def"
       }
       FieldData = skipPadding(FieldData);
       if (hadError())

lib/DebugInfo/CodeView/TypeDumper.cpp

 /// the visitor out of TypeDumper.h.
 class CVTypeDumperImpl : public CVTypeVisitor<CVTypeDumperImpl> {
 public:
   CVTypeDumperImpl(CVTypeDumper &CVTD, ScopedPrinter &W, bool PrintRecordBytes)
       : CVTD(CVTD), W(W), PrintRecordBytes(PrintRecordBytes) {}
 
   /// CVTypeVisitor overrides.
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  void visit##Name(TypeLeafKind LeafType, Name##Record &Record);
+  void visit##Name(Name##Record &Record);
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  void visit##Name(TypeLeafKind LeafType, Name##Record &Record);
+  void visit##Name(Name##Record &Record);
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
   void visitUnknownMember(TypeLeafKind Leaf);
   void visitUnknownType(TypeLeafKind Leaf, ArrayRef<uint8_t> LeafData);
 
   void visitTypeBegin(TypeLeafKind Leaf, ArrayRef<uint8_t> LeafData);
   void visitTypeEnd(TypeLeafKind Leaf, ArrayRef<uint8_t> LeafData);
void CVTypeDumperImpl::visitTypeEnd(TypeLeafKind Leaf,
 
   if (PrintRecordBytes)
     W.printBinaryBlock("LeafData", getBytesAsCharacters(LeafData));
 
   W.unindent();
   W.startLine() << "}\n";
 }
 
-void CVTypeDumperImpl::visitStringId(TypeLeafKind Leaf,
-                                           StringIdRecord &String) {
+void CVTypeDumperImpl::visitStringId(StringIdRecord &String) {
   printTypeIndex("Id", String.getId());
   W.printString("StringData", String.getString());
   // Put this in CVUDTNames so it gets printed with LF_UDT_SRC_LINE.
   Name = String.getString();
 }
 
-void CVTypeDumperImpl::visitArgList(TypeLeafKind Leaf, ArgListRecord &Args) {
+void CVTypeDumperImpl::visitArgList(ArgListRecord &Args) {
   auto Indices = Args.getIndices();
   uint32_t Size = Indices.size();
   W.printNumber("NumArgs", Size);
   ListScope Arguments(W, "Arguments");
   SmallString<256> TypeName("(");
   for (uint32_t I = 0; I < Size; ++I) {
     printTypeIndex("ArgType", Indices[I]);
     StringRef ArgTypeName = getTypeName(Indices[I]);
     TypeName.append(ArgTypeName);
     if (I + 1 != Size)
       TypeName.append(", ");
   }
   TypeName.push_back(')');
   Name = CVTD.saveName(TypeName);
 }
 
-void CVTypeDumperImpl::visitClass(TypeLeafKind Leaf, ClassRecord &Class) {
+void CVTypeDumperImpl::visitClass(ClassRecord &Class) {
   uint16_t Props = static_cast<uint16_t>(Class.getOptions());
   W.printNumber("MemberCount", Class.getMemberCount());
   W.printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
   printTypeIndex("FieldList", Class.getFieldList());
   printTypeIndex("DerivedFrom", Class.getDerivationList());
   printTypeIndex("VShape", Class.getVTableShape());
   W.printNumber("SizeOf", Class.getSize());
   W.printString("Name", Class.getName());
   if (Props & uint16_t(ClassOptions::HasUniqueName))
     W.printString("LinkageName", Class.getUniqueName());
   Name = Class.getName();
 }
 
-void CVTypeDumperImpl::visitUnion(TypeLeafKind Leaf, UnionRecord &Union) {
+void CVTypeDumperImpl::visitUnion(UnionRecord &Union) {
   uint16_t Props = static_cast<uint16_t>(Union.getOptions());
   W.printNumber("MemberCount", Union.getMemberCount());
   W.printFlags("Properties", Props, makeArrayRef(ClassOptionNames));
   printTypeIndex("FieldList", Union.getFieldList());
   W.printNumber("SizeOf", Union.getSize());
   W.printString("Name", Union.getName());
   if (Props & uint16_t(ClassOptions::HasUniqueName))
     W.printString("LinkageName", Union.getUniqueName());
   Name = Union.getName();
 }
 
-void CVTypeDumperImpl::visitEnum(TypeLeafKind Leaf, EnumRecord &Enum) {
+void CVTypeDumperImpl::visitEnum(EnumRecord &Enum) {
   W.printNumber("NumEnumerators", Enum.getMemberCount());
   W.printFlags("Properties", uint16_t(Enum.getOptions()),
                makeArrayRef(ClassOptionNames));
   printTypeIndex("UnderlyingType", Enum.getUnderlyingType());
   printTypeIndex("FieldListType", Enum.getFieldList());
   W.printString("Name", Enum.getName());
   Name = Enum.getName();
 }
 
-void CVTypeDumperImpl::visitArray(TypeLeafKind Leaf, ArrayRecord &AT) {
+void CVTypeDumperImpl::visitArray(ArrayRecord &AT) {
   printTypeIndex("ElementType", AT.getElementType());
   printTypeIndex("IndexType", AT.getIndexType());
   W.printNumber("SizeOf", AT.getSize());
   W.printString("Name", AT.getName());
   Name = AT.getName();
 }
 
-void CVTypeDumperImpl::visitVFTable(TypeLeafKind Leaf, VFTableRecord &VFT) {
+void CVTypeDumperImpl::visitVFTable(VFTableRecord &VFT) {
   printTypeIndex("CompleteClass", VFT.getCompleteClass());
   printTypeIndex("OverriddenVFTable", VFT.getOverriddenVTable());
   W.printHex("VFPtrOffset", VFT.getVFPtrOffset());
   W.printString("VFTableName", VFT.getName());
   for (auto N : VFT.getMethodNames())
     W.printString("MethodName", N);
   Name = VFT.getName();
 }
 
-void CVTypeDumperImpl::visitMemberFuncId(TypeLeafKind Leaf,
-                                               MemberFuncIdRecord &Id) {
+void CVTypeDumperImpl::visitMemberFuncId(MemberFuncIdRecord &Id) {
   printTypeIndex("ClassType", Id.getClassType());
   printTypeIndex("FunctionType", Id.getFunctionType());
   W.printString("Name", Id.getName());
   Name = Id.getName();
 }
 
-void CVTypeDumperImpl::visitProcedure(TypeLeafKind Leaf,
-                                      ProcedureRecord &Proc) {
+void CVTypeDumperImpl::visitProcedure(ProcedureRecord &Proc) {
   printTypeIndex("ReturnType", Proc.getReturnType());
   W.printEnum("CallingConvention", uint8_t(Proc.getCallConv()),
               makeArrayRef(CallingConventions));
   W.printFlags("FunctionOptions", uint8_t(Proc.getOptions()),
                makeArrayRef(FunctionOptionEnum));
   W.printNumber("NumParameters", Proc.getParameterCount());
   printTypeIndex("ArgListType", Proc.getArgumentList());
 
   StringRef ReturnTypeName = getTypeName(Proc.getReturnType());
   StringRef ArgListTypeName = getTypeName(Proc.getArgumentList());
   SmallString<256> TypeName(ReturnTypeName);
   TypeName.push_back(' ');
   TypeName.append(ArgListTypeName);
   Name = CVTD.saveName(TypeName);
 }
 
-void CVTypeDumperImpl::visitMemberFunction(TypeLeafKind Leaf,
-                                           MemberFunctionRecord &MF) {
+void CVTypeDumperImpl::visitMemberFunction(MemberFunctionRecord &MF) {
   printTypeIndex("ReturnType", MF.getReturnType());
   printTypeIndex("ClassType", MF.getClassType());
   printTypeIndex("ThisType", MF.getThisType());
   W.printEnum("CallingConvention", uint8_t(MF.getCallConv()),
               makeArrayRef(CallingConventions));
   W.printFlags("FunctionOptions", uint8_t(MF.getOptions()),
                makeArrayRef(FunctionOptionEnum));
   W.printNumber("NumParameters", MF.getParameterCount());
   printTypeIndex("ArgListType", MF.getArgumentList());
   W.printNumber("ThisAdjustment", MF.getThisPointerAdjustment());
 
   StringRef ReturnTypeName = getTypeName(MF.getReturnType());
   StringRef ClassTypeName = getTypeName(MF.getClassType());
   StringRef ArgListTypeName = getTypeName(MF.getArgumentList());
   SmallString<256> TypeName(ReturnTypeName);
   TypeName.push_back(' ');
   TypeName.append(ClassTypeName);
   TypeName.append("::");
   TypeName.append(ArgListTypeName);
   Name = CVTD.saveName(TypeName);
 }
 
 void CVTypeDumperImpl::visitMethodOverloadList(
-    TypeLeafKind Leaf, MethodOverloadListRecord &MethodList) {
+    MethodOverloadListRecord &MethodList) {
   for (auto &M : MethodList.getMethods()) {
     ListScope S(W, "Method");
     printMemberAttributes(M.getAccess(), M.getKind(), M.getOptions());
     printTypeIndex("Type", M.getType());
     if (M.isIntroducingVirtual())
       W.printHex("VFTableOffset", M.getVFTableOffset());
   }
 }
 
-void CVTypeDumperImpl::visitFuncId(TypeLeafKind Leaf, FuncIdRecord &Func) {
+void CVTypeDumperImpl::visitFuncId(FuncIdRecord &Func) {
   printTypeIndex("ParentScope", Func.getParentScope());
   printTypeIndex("FunctionType", Func.getFunctionType());
   W.printString("Name", Func.getName());
   Name = Func.getName();
 }
 
-void CVTypeDumperImpl::visitTypeServer2(TypeLeafKind Leaf,
-                                        TypeServer2Record &TS) {
+void CVTypeDumperImpl::visitTypeServer2(TypeServer2Record &TS) {
   W.printBinary("Signature", TS.getGuid());
   W.printNumber("Age", TS.getAge());
   W.printString("Name", TS.getName());
   Name = TS.getName();
 }
 
-void CVTypeDumperImpl::visitPointer(TypeLeafKind Leaf, PointerRecord &Ptr) {
+void CVTypeDumperImpl::visitPointer(PointerRecord &Ptr) {
   printTypeIndex("PointeeType", Ptr.getReferentType());
   W.printHex("PointerAttributes", uint32_t(Ptr.getOptions()));
   W.printEnum("PtrType", unsigned(Ptr.getPointerKind()),
               makeArrayRef(PtrKindNames));
   W.printEnum("PtrMode", unsigned(Ptr.getMode()), makeArrayRef(PtrModeNames));
 
   W.printNumber("IsFlat", Ptr.isFlat());
   W.printNumber("IsConst", Ptr.isConst());
if (Ptr.isPointerToMember()) {
     else if (Ptr.getMode() == PointerMode::Pointer)
       TypeName.append("*");
 
     if (!TypeName.empty())
       Name = CVTD.saveName(TypeName);
   }
 }
 
-void CVTypeDumperImpl::visitModifier(TypeLeafKind Leaf, ModifierRecord &Mod) {
+void CVTypeDumperImpl::visitModifier(ModifierRecord &Mod) {
   uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());
   printTypeIndex("ModifiedType", Mod.getModifiedType());
   W.printFlags("Modifiers", Mods, makeArrayRef(TypeModifierNames));
 
   StringRef ModifiedName = getTypeName(Mod.getModifiedType());
   SmallString<256> TypeName;
   if (Mods & uint16_t(ModifierOptions::Const))
     TypeName.append("const ");
   if (Mods & uint16_t(ModifierOptions::Volatile))
     TypeName.append("volatile ");
   if (Mods & uint16_t(ModifierOptions::Unaligned))
     TypeName.append("__unaligned ");
   TypeName.append(ModifiedName);
   Name = CVTD.saveName(TypeName);
 }
 
-void CVTypeDumperImpl::visitBitField(TypeLeafKind Leaf,
-                                     BitFieldRecord &BitField) {
+void CVTypeDumperImpl::visitBitField(BitFieldRecord &BitField) {
   printTypeIndex("Type", BitField.getType());
   W.printNumber("BitSize", BitField.getBitSize());
   W.printNumber("BitOffset", BitField.getBitOffset());
 }
 
-void CVTypeDumperImpl::visitVFTableShape(TypeLeafKind Leaf,
-                                         VFTableShapeRecord &Shape) {
+void CVTypeDumperImpl::visitVFTableShape(VFTableShapeRecord &Shape) {
   W.printNumber("VFEntryCount", Shape.getEntryCount());
 }
 
-void CVTypeDumperImpl::visitUdtSourceLine(TypeLeafKind Leaf,
-                                          UdtSourceLineRecord &Line) {
+void CVTypeDumperImpl::visitUdtSourceLine(UdtSourceLineRecord &Line) {
   printTypeIndex("UDT", Line.getUDT());
   printTypeIndex("SourceFile", Line.getSourceFile());
   W.printNumber("LineNumber", Line.getLineNumber());
 }
 
-void CVTypeDumperImpl::visitUdtModSourceLine(TypeLeafKind Leaf,
-                                             UdtModSourceLineRecord &Line) {
+void CVTypeDumperImpl::visitUdtModSourceLine(UdtModSourceLineRecord &Line) {
   printTypeIndex("UDT", Line.getUDT());
   printTypeIndex("SourceFile", Line.getSourceFile());
   W.printNumber("LineNumber", Line.getLineNumber());
   W.printNumber("Module", Line.getModule());
 }
 
-void CVTypeDumperImpl::visitBuildInfo(TypeLeafKind Leaf,
-                                      BuildInfoRecord &Args) {
+void CVTypeDumperImpl::visitBuildInfo(BuildInfoRecord &Args) {
   W.printNumber("NumArgs", static_cast<uint32_t>(Args.getArgs().size()));
 
   ListScope Arguments(W, "Arguments");
   for (auto Arg : Args.getArgs()) {
     printTypeIndex("ArgType", Arg);
   }
 }
 

 
 void CVTypeDumperImpl::visitUnknownType(TypeLeafKind Leaf,
                                         ArrayRef<uint8_t> RecordData) {
   DictScope S(W, "UnknownType");
   W.printEnum("Kind", uint16_t(Leaf), makeArrayRef(LeafTypeNames));
   W.printNumber("Length", uint32_t(RecordData.size()));
 }
 
-void CVTypeDumperImpl::visitNestedType(TypeLeafKind Leaf,
-                                       NestedTypeRecord &Nested) {
+void CVTypeDumperImpl::visitNestedType(NestedTypeRecord &Nested) {
   DictScope S(W, "NestedType");
   printTypeIndex("Type", Nested.getNestedType());
   W.printString("Name", Nested.getName());
   Name = Nested.getName();
 }
 
-void CVTypeDumperImpl::visitOneMethod(TypeLeafKind Leaf,
-                                      OneMethodRecord &Method) {
+void CVTypeDumperImpl::visitOneMethod(OneMethodRecord &Method) {
   DictScope S(W, "OneMethod");
   MethodKind K = Method.getKind();
   printMemberAttributes(Method.getAccess(), K, Method.getOptions());
   printTypeIndex("Type", Method.getType());
   // If virtual, then read the vftable offset.
   if (Method.isIntroducingVirtual())
     W.printHex("VFTableOffset", Method.getVFTableOffset());
   W.printString("Name", Method.getName());
   Name = Method.getName();
 }
 
-void CVTypeDumperImpl::visitOverloadedMethod(TypeLeafKind Leaf,
-                                             OverloadedMethodRecord &Method) {
+void CVTypeDumperImpl::visitOverloadedMethod(OverloadedMethodRecord &Method) {
   DictScope S(W, "OverloadedMethod");
   W.printHex("MethodCount", Method.getNumOverloads());
   printTypeIndex("MethodListIndex", Method.getMethodList());
   W.printString("Name", Method.getName());
   Name = Method.getName();
 }
 
-void CVTypeDumperImpl::visitDataMember(TypeLeafKind Leaf,
-                                       DataMemberRecord &Field) {
+void CVTypeDumperImpl::visitDataMember(DataMemberRecord &Field) {
   DictScope S(W, "DataMember");
   printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   printTypeIndex("Type", Field.getType());
   W.printHex("FieldOffset", Field.getFieldOffset());
   W.printString("Name", Field.getName());
   Name = Field.getName();
 }
 
-void CVTypeDumperImpl::visitStaticDataMember(TypeLeafKind Leaf,
-                                             StaticDataMemberRecord &Field) {
+void CVTypeDumperImpl::visitStaticDataMember(StaticDataMemberRecord &Field) {
   DictScope S(W, "StaticDataMember");
   printMemberAttributes(Field.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   printTypeIndex("Type", Field.getType());
   W.printString("Name", Field.getName());
   Name = Field.getName();
 }
 
-void CVTypeDumperImpl::visitVFPtr(TypeLeafKind Leaf, VFPtrRecord &VFTable) {
+void CVTypeDumperImpl::visitVFPtr(VFPtrRecord &VFTable) {
   DictScope S(W, "VFPtr");
   printTypeIndex("Type", VFTable.getType());
 }
 
-void CVTypeDumperImpl::visitEnumerator(TypeLeafKind Leaf,
-                                       EnumeratorRecord &Enum) {
+void CVTypeDumperImpl::visitEnumerator(EnumeratorRecord &Enum) {
   DictScope S(W, "Enumerator");
   printMemberAttributes(Enum.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   W.printNumber("EnumValue", Enum.getValue());
   W.printString("Name", Enum.getName());
   Name = Enum.getName();
 }
 
-void CVTypeDumperImpl::visitBaseClass(TypeLeafKind Leaf,
-                                      BaseClassRecord &Base) {
+void CVTypeDumperImpl::visitBaseClass(BaseClassRecord &Base) {
   DictScope S(W, "BaseClass");
   printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   printTypeIndex("BaseType", Base.getBaseType());
   W.printHex("BaseOffset", Base.getBaseOffset());
 }
 
-void CVTypeDumperImpl::visitVirtualBaseClass(TypeLeafKind Leaf,
-                                             VirtualBaseClassRecord &Base) {
+void CVTypeDumperImpl::visitVirtualBaseClass(VirtualBaseClassRecord &Base) {
   DictScope S(W, "VirtualBaseClass");
   printMemberAttributes(Base.getAccess(), MethodKind::Vanilla,
                         MethodOptions::None);
   printTypeIndex("BaseType", Base.getBaseType());
   printTypeIndex("VBPtrType", Base.getVBPtrType());
   W.printHex("VBPtrOffset", Base.getVBPtrOffset());
   W.printHex("VBTableIndex", Base.getVTableIndex());
 }

lib/DebugInfo/CodeView/TypeStreamMerger.cpp

 class TypeStreamMerger : public CVTypeVisitor<TypeStreamMerger> {
 public:
   TypeStreamMerger(TypeTableBuilder &DestStream) : DestStream(DestStream) {
     assert(!hadError());
   }
 
   /// CVTypeVisitor overrides.
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  void visit##Name(TypeLeafKind LeafType, Name##Record &Record);
+  void visit##Name(Name##Record &Record);
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  void visit##Name(TypeLeafKind LeafType, Name##Record &Record);
+  void visit##Name(Name##Record &Record);
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
   void visitUnknownType(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData);
 
   void visitTypeBegin(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData);
   void visitTypeEnd(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData);
 

 void TypeStreamMerger::visitFieldList(TypeLeafKind Leaf,
                                       ArrayRef<uint8_t> FieldData) {
   CVTypeVisitor::visitFieldList(Leaf, FieldData);
   IndexMap.push_back(DestStream.writeFieldList(FieldBuilder));
   FieldBuilder.reset();
 }
 
 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
-  void TypeStreamMerger::visit##Name(TypeLeafKind LeafType,                    \
-                                     Name##Record &Record) {                   \
+  void TypeStreamMerger::visit##Name(Name##Record &Record) {                   \
     FoundBadTypeIndex |= !Record.remapTypeIndices(IndexMap);                   \
     IndexMap.push_back(DestStream.write##Name(Record));                        \
   }
 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
-  void TypeStreamMerger::visit##Name(TypeLeafKind LeafType,                    \
-                                     Name##Record &Record) {                   \
+  void TypeStreamMerger::visit##Name(Name##Record &Record) {                   \
     FoundBadTypeIndex |= !Record.remapTypeIndices(IndexMap);                   \
     FieldBuilder.write##Name(Record);                                          \
   }
 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 #include "llvm/DebugInfo/CodeView/TypeRecords.def"
 
 void TypeStreamMerger::visitUnknownType(TypeLeafKind Leaf,
                                         ArrayRef<uint8_t> RecordData) {

lib/DebugInfo/PDB/Raw/TpiStream.cpp

 
 namespace {
 class TpiHashVerifier : public CVTypeVisitor<TpiHashVerifier> {
 public:
   TpiHashVerifier(FixedStreamArray<support::ulittle32_t> &HashValues,
                   uint32_t NumHashBuckets)
       : HashValues(HashValues), NumHashBuckets(NumHashBuckets) {}
 
-  void visitUdtSourceLine(TypeLeafKind, UdtSourceLineRecord &Rec) {
-    verifySourceLine(Rec);
-  }
+  void visitUdtSourceLine(UdtSourceLineRecord &Rec) { verifySourceLine(Rec); }
 
-  void visitUdtModSourceLine(TypeLeafKind, UdtModSourceLineRecord &Rec) {
+  void visitUdtModSourceLine(UdtModSourceLineRecord &Rec) {
     verifySourceLine(Rec);
   }
 
-  void visitClass(TypeLeafKind, ClassRecord &Rec) { verify(Rec); }
-  void visitEnum(TypeLeafKind, EnumRecord &Rec) { verify(Rec); }
-  void visitInterface(TypeLeafKind, ClassRecord &Rec) { verify(Rec); }
-  void visitStruct(TypeLeafKind, ClassRecord &Rec) { verify(Rec); }
-  void visitUnion(TypeLeafKind, UnionRecord &Rec) { verify(Rec); }
+  void visitClass(ClassRecord &Rec) { verify(Rec); }
+  void visitEnum(EnumRecord &Rec) { verify(Rec); }
+  void visitInterface(ClassRecord &Rec) { verify(Rec); }
+  void visitStruct(ClassRecord &Rec) { verify(Rec); }
+  void visitUnion(UnionRecord &Rec) { verify(Rec); }
 
   void visitTypeEnd(TypeLeafKind Leaf, ArrayRef<uint8_t> RecordData) {
     ++Index;
   }
 
 private:
   template <typename T> void verify(T &Rec) {
     uint32_t Hash = getTpiHash(Rec);