[M68k][NFC] Rename M68kOperand::Kind to KindTy

[ricky26]

Summary

Rename the M68kOperand::Type enumeration to KindTy to avoid ambiguity
with the Kind field when referencing enumeration values e.g.
Kind::Value.

This works around a compilation error under GCC 5, where GCC won't
lookup enum class values if you have a similarly named field
(see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60994).

The error in question is:
M68kAsmParser.cpp:857:8: error: 'Kind' is not a class, namespace, or enumeration

[glaubitz]

As suggested here [1] by @jrtc27, I think the better solution is to rename the enum Kind to KindTy.

[1] https://github.com/rust-lang/rust/pull/88321#discussion_r696043053

Edit: Rename because that would match the naming scheme also used by the RISCV AsmParser.

[ricky26]

In D108723#2965766, @glaubitz wrote:

As suggested here [1] by @jrtc27, I think the better solution is to rename the enum Kind to KindTy.

[1] https://github.com/rust-lang/rust/pull/88321#discussion_r696043053

Edit: Rename because that would match the naming scheme also used by the RISCV AsmParser.

Ah, I missed that comment. I agree, I'll swap it over. Thanks for adding in @jrtc27.

[ricky26]

Change over to using KindTy as the name of the enumeration.

[jrtc27]

Commit message needs updating, and should probably also be clearer that it's a workaround for a bug, perhaps linking to the bug in question too. Patch itself looks fine and boring.

[ricky26]

Update the commit message.

[jrtc27]

Subject too please; message looks good now.

[ricky26]

Make the commit title more precise.

[jrtc27]

Thanks

llvm/lib/Target/M68k/AsmParser/M68kAsmParser.cpp

 //===---- M68kAsmParser.cpp - Parse M68k assembly to MCInst instructions --===//
 //
 // 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 "M68kInstrInfo.h"
 #include "M68kRegisterInfo.h"
 #include "TargetInfo/M68kTargetInfo.h"
 
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Support/TargetRegistry.h"
struct M68kMemOp {
 
   void print(raw_ostream &OS) const;
 };
 
 /// An parsed M68k assembly operand.
 class M68kOperand : public MCParsedAsmOperand {
   typedef MCParsedAsmOperand Base;
 
-  enum class Kind {
+  enum class KindTy {
     Invalid,
     Token,
     Imm,
     MemOp,
   };
 
-  Kind Kind;
+  KindTy Kind;
   SMLoc Start, End;
   union {
     StringRef Token;
     int64_t Imm;
     const MCExpr *Expr;
     M68kMemOp MemOp;
   };
 
   template <unsigned N> bool isAddrN() const;
 
 public:
-  M68kOperand(enum Kind Kind, SMLoc Start, SMLoc End)
+  M68kOperand(KindTy Kind, SMLoc Start, SMLoc End)
       : Base(), Kind(Kind), Start(Start), End(End) {}
 
   SMLoc getStartLoc() const override { return Start; }
   SMLoc getEndLoc() const override { return End; }
 
   void print(raw_ostream &OS) const override;
 
   bool isMem() const override { return false; }
-  bool isMemOp() const { return Kind == Kind::MemOp; }
+  bool isMemOp() const { return Kind == KindTy::MemOp; }
 
   static void addExpr(MCInst &Inst, const MCExpr *Expr);
 
   // Reg
   bool isReg() const override;
   bool isAReg() const;
   bool isDReg() const;
   unsigned getReg() const override;
if (auto Const = dyn_cast<MCConstantExpr>(Expr)) {
     return;
   }
 
   Inst.addOperand(MCOperand::createExpr(Expr));
 }
 
 // Reg
 bool M68kOperand::isReg() const {
-  return Kind == Kind::MemOp && MemOp.Op == M68kMemOp::Kind::Reg;
+  return Kind == KindTy::MemOp && MemOp.Op == M68kMemOp::Kind::Reg;
 }
 
 unsigned M68kOperand::getReg() const {
   assert(isReg());
   return MemOp.OuterReg;
 }
 
 void M68kOperand::addRegOperands(MCInst &Inst, unsigned N) const {
   assert(isReg() && "wrong operand kind");
   assert((N == 1) && "can only handle one register operand");
 
   Inst.addOperand(MCOperand::createReg(getReg()));
 }
 
 std::unique_ptr<M68kOperand> M68kOperand::createMemOp(M68kMemOp MemOp,
                                                       SMLoc Start, SMLoc End) {
-  auto Op = std::make_unique<M68kOperand>(Kind::MemOp, Start, End);
+  auto Op = std::make_unique<M68kOperand>(KindTy::MemOp, Start, End);
   Op->MemOp = MemOp;
   return Op;
 }
 
 // Token
-bool M68kOperand::isToken() const { return Kind == Kind::Token; }
+bool M68kOperand::isToken() const { return Kind == KindTy::Token; }
 StringRef M68kOperand::getToken() const {
   assert(isToken());
   return Token;
 }
 
 std::unique_ptr<M68kOperand> M68kOperand::createToken(StringRef Token,
                                                       SMLoc Start, SMLoc End) {
-  auto Op = std::make_unique<M68kOperand>(Kind::Token, Start, End);
+  auto Op = std::make_unique<M68kOperand>(KindTy::Token, Start, End);
   Op->Token = Token;
   return Op;
 }
 
 // Imm
-bool M68kOperand::isImm() const { return Kind == Kind::Imm; }
+bool M68kOperand::isImm() const { return Kind == KindTy::Imm; }
 void M68kOperand::addImmOperands(MCInst &Inst, unsigned N) const {
   assert(isImm() && "wrong operand kind");
   assert((N == 1) && "can only handle one register operand");
 
   M68kOperand::addExpr(Inst, Expr);
 }
 
 std::unique_ptr<M68kOperand> M68kOperand::createImm(const MCExpr *Expr,
                                                     SMLoc Start, SMLoc End) {
-  auto Op = std::make_unique<M68kOperand>(Kind::Imm, Start, End);
+  auto Op = std::make_unique<M68kOperand>(KindTy::Imm, Start, End);
   Op->Expr = Expr;
   return Op;
 }
 
 // MoveMask
 bool M68kOperand::isMoveMask() const {
   if (!isMemOp())
     return false;
case Match_MnemonicFail:
     return Error(Loc, "invalid instruction");
   default:
     return true;
   }
 }
 
 void M68kOperand::print(raw_ostream &OS) const {
   switch (Kind) {
-  case Kind::Invalid:
+  case KindTy::Invalid:
     OS << "invalid";
     break;
 
-  case Kind::Token:
+  case KindTy::Token:
     OS << "token '" << Token << "'";
     break;
 
-  case Kind::Imm:
+  case KindTy::Imm:
     OS << "immediate " << Imm;
     break;
 
-  case Kind::MemOp:
+  case KindTy::MemOp:
     MemOp.print(OS);
     break;
   }
 }