[clang][NFC] Convert Sema::BuiltinCountedByRefKind to scoped enum

Author: Endilll

clang/include/clang/Sema/Sema.h

@@ -519,6 +519,15 @@ enum class VariadicCallType {
   DoesNotApply
 };
 
+enum class BuiltinCountedByRefKind {
+  Assignment,
+  Initializer,
+  FunctionArg,
+  ReturnArg,
+  ArraySubscript,
+  BinaryExpr,
+};
+
 /// Sema - This implements semantic analysis and AST building for C.
 /// \nosubgrouping
 class Sema final : public SemaBase {
@@ -2636,15 +2645,6 @@ class Sema final : public SemaBase {
 
   bool BuiltinNonDeterministicValue(CallExpr *TheCall);
 
-  enum BuiltinCountedByRefKind {
-    AssignmentKind,
-    InitializerKind,
-    FunctionArgKind,
-    ReturnArgKind,
-    ArraySubscriptKind,
-    BinaryExprKind,
-  };
-
   bool CheckInvalidBuiltinCountedByRef(const Expr *E,
                                        BuiltinCountedByRefKind K);
   bool BuiltinCountedByRef(CallExpr *TheCall);

clang/lib/Sema/SemaChecking.cpp

@@ -5809,27 +5809,27 @@ bool Sema::CheckInvalidBuiltinCountedByRef(const Expr *E,
     return false;
 
   switch (K) {
-  case AssignmentKind:
-  case InitializerKind:
+  case BuiltinCountedByRefKind::Assignment:
+  case BuiltinCountedByRefKind::Initializer:
     Diag(E->getExprLoc(),
          diag::err_builtin_counted_by_ref_cannot_leak_reference)
         << 0 << E->getSourceRange();
     break;
-  case FunctionArgKind:
+  case BuiltinCountedByRefKind::FunctionArg:
     Diag(E->getExprLoc(),
          diag::err_builtin_counted_by_ref_cannot_leak_reference)
         << 1 << E->getSourceRange();
     break;
-  case ReturnArgKind:
+  case BuiltinCountedByRefKind::ReturnArg:
     Diag(E->getExprLoc(),
          diag::err_builtin_counted_by_ref_cannot_leak_reference)
         << 2 << E->getSourceRange();
     break;
-  case ArraySubscriptKind:
+  case BuiltinCountedByRefKind::ArraySubscript:
     Diag(E->getExprLoc(), diag::err_builtin_counted_by_ref_invalid_use)
         << 0 << E->getSourceRange();
     break;
-  case BinaryExprKind:
+  case BuiltinCountedByRefKind::BinaryExpr:
     Diag(E->getExprLoc(), diag::err_builtin_counted_by_ref_invalid_use)
         << 1 << E->getSourceRange();
     break;

clang/lib/Sema/SemaDecl.cpp

@@ -14904,7 +14904,8 @@ void Sema::FinalizeDeclaration(Decl *ThisDecl) {
     }
   }
 
-  CheckInvalidBuiltinCountedByRef(VD->getInit(), InitializerKind);
+  CheckInvalidBuiltinCountedByRef(VD->getInit(),
+                                  BuiltinCountedByRefKind::Initializer);
 
   checkAttributesAfterMerging(*this, *VD);
 

clang/lib/Sema/SemaExpr.cpp

@@ -4963,7 +4963,8 @@ ExprResult Sema::ActOnArraySubscriptExpr(Scope *S, Expr *base,
     return ExprError();
   }
 
-  CheckInvalidBuiltinCountedByRef(base, ArraySubscriptKind);
+  CheckInvalidBuiltinCountedByRef(base,
+                                  BuiltinCountedByRefKind::ArraySubscript);
 
   // Handle any non-overload placeholder types in the base and index
   // expressions.  We can't handle overloads here because the other
@@ -6554,7 +6555,8 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
   // The result of __builtin_counted_by_ref cannot be used as a function
   // argument. It allows leaking and modification of bounds safety information.
   for (const Expr *Arg : ArgExprs)
-    if (CheckInvalidBuiltinCountedByRef(Arg, FunctionArgKind))
+    if (CheckInvalidBuiltinCountedByRef(Arg,
+                                        BuiltinCountedByRefKind::FunctionArg))
       return ExprError();
 
   if (getLangOpts().CPlusPlus) {
@@ -15430,8 +15432,9 @@ ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc,
   // Emit warnings for tricky precedence issues, e.g. "bitfield & 0x4 == 0"
   DiagnoseBinOpPrecedence(*this, Opc, TokLoc, LHSExpr, RHSExpr);
 
-  BuiltinCountedByRefKind K =
-      BinaryOperator::isAssignmentOp(Opc) ? AssignmentKind : BinaryExprKind;
+  BuiltinCountedByRefKind K = BinaryOperator::isAssignmentOp(Opc)
+                                  ? BuiltinCountedByRefKind::Assignment
+                                  : BuiltinCountedByRefKind::BinaryExpr;
 
   CheckInvalidBuiltinCountedByRef(LHSExpr, K);
   CheckInvalidBuiltinCountedByRef(RHSExpr, K);

clang/lib/Sema/SemaStmt.cpp

@@ -3858,7 +3858,8 @@ Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
         << FSI->getFirstCoroutineStmtKeyword();
   }
 
-  CheckInvalidBuiltinCountedByRef(RetVal.get(), ReturnArgKind);
+  CheckInvalidBuiltinCountedByRef(RetVal.get(),
+                                  BuiltinCountedByRefKind::ReturnArg);
 
   StmtResult R =
       BuildReturnStmt(ReturnLoc, RetVal.get(), /*AllowRecovery=*/true);