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

Author: Endilll

clang/include/clang/Sema/Sema.h

@@ -804,6 +804,20 @@ enum class CorrectTypoKind {
   ErrorRecovery // CorrectTypo used in normal error recovery.
 };
 
+enum class OverloadKind {
+  /// This is a legitimate overload: the existing declarations are
+  /// functions or function templates with different signatures.
+  Overload,
+
+  /// This is not an overload because the signature exactly matches
+  /// an existing declaration.
+  Match,
+
+  /// This is not an overload because the lookup results contain a
+  /// non-function.
+  NonFunction
+};
+
 /// Sema - This implements semantic analysis and AST building for C.
 /// \nosubgrouping
 class Sema final : public SemaBase {
@@ -9987,28 +10001,14 @@ class Sema final : public SemaBase {
   /// if Sema is already doing so, which would cause infinite recursions.
   bool IsBuildingRecoveryCallExpr;
 
-  enum OverloadKind {
-    /// This is a legitimate overload: the existing declarations are
-    /// functions or function templates with different signatures.
-    Ovl_Overload,
-
-    /// This is not an overload because the signature exactly matches
-    /// an existing declaration.
-    Ovl_Match,
-
-    /// This is not an overload because the lookup results contain a
-    /// non-function.
-    Ovl_NonFunction
-  };
-
   /// Determine whether the given New declaration is an overload of the
-  /// declarations in Old. This routine returns Ovl_Match or Ovl_NonFunction if
-  /// New and Old cannot be overloaded, e.g., if New has the same signature as
-  /// some function in Old (C++ 1.3.10) or if the Old declarations aren't
-  /// functions (or function templates) at all. When it does return Ovl_Match or
-  /// Ovl_NonFunction, MatchedDecl will point to the decl that New cannot be
-  /// overloaded with. This decl may be a UsingShadowDecl on top of the
-  /// underlying declaration.
+  /// declarations in Old. This routine returns OverloadKind::Match or
+  /// OverloadKind::NonFunction if New and Old cannot be overloaded, e.g., if
+  /// New has the same signature as some function in Old (C++ 1.3.10) or if the
+  /// Old declarations aren't functions (or function templates) at all. When it
+  /// does return OverloadKind::Match or OverloadKind::NonFunction, MatchedDecl
+  /// will point to the decl that New cannot be overloaded with. This decl may
+  /// be a UsingShadowDecl on top of the underlying declaration.
   ///
   /// Example: Given the following input:
   ///
@@ -10021,14 +10021,15 @@ class Sema final : public SemaBase {
   ///
   /// When we process #2, Old contains only the FunctionDecl for #1. By
   /// comparing the parameter types, we see that #1 and #2 are overloaded (since
-  /// they have different signatures), so this routine returns Ovl_Overload;
-  /// MatchedDecl is unchanged.
+  /// they have different signatures), so this routine returns
+  /// OverloadKind::Overload; MatchedDecl is unchanged.
   ///
   /// When we process #3, Old is an overload set containing #1 and #2. We
   /// compare the signatures of #3 to #1 (they're overloaded, so we do nothing)
   /// and then #3 to #2. Since the signatures of #3 and #2 are identical (return
   /// types of functions are not part of the signature), IsOverload returns
-  /// Ovl_Match and MatchedDecl will be set to point to the FunctionDecl for #2.
+  /// OverloadKind::Match and MatchedDecl will be set to point to the
+  /// FunctionDecl for #2.
   ///
   /// 'NewIsUsingShadowDecl' indicates that 'New' is being introduced into a
   /// class by a using declaration. The rules for whether to hide shadow

clang/lib/Sema/SemaDecl.cpp

@@ -12032,15 +12032,15 @@ bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD,
       MayNeedOverloadableChecks = true;
       switch (CheckOverload(S, NewFD, Previous, OldDecl,
                             /*NewIsUsingDecl*/ false)) {
-      case Ovl_Match:
+      case OverloadKind::Match:
         Redeclaration = true;
         break;
 
-      case Ovl_NonFunction:
+      case OverloadKind::NonFunction:
         Redeclaration = true;
         break;
 
-      case Ovl_Overload:
+      case OverloadKind::Overload:
         Redeclaration = false;
         break;
       }

clang/lib/Sema/SemaDeclCXX.cpp

@@ -12797,15 +12797,15 @@ bool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig,
     NamedDecl *OldDecl = nullptr;
     switch (CheckOverload(nullptr, FD, Previous, OldDecl,
                           /*IsForUsingDecl*/ true)) {
-    case Ovl_Overload:
+    case OverloadKind::Overload:
       return false;
 
-    case Ovl_NonFunction:
+    case OverloadKind::NonFunction:
       Diag(BUD->getLocation(), diag::err_using_decl_conflict);
       break;
 
     // We found a decl with the exact signature.
-    case Ovl_Match:
+    case OverloadKind::Match:
       // If we're in a record, we want to hide the target, so we
       // return true (without a diagnostic) to tell the caller not to
       // build a shadow decl.

clang/lib/Sema/SemaOverload.cpp

@@ -1200,9 +1200,9 @@ static bool checkArgPlaceholdersForOverload(Sema &S, MultiExprArg Args,
   return false;
 }
 
-Sema::OverloadKind
-Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old,
-                    NamedDecl *&Match, bool NewIsUsingDecl) {
+OverloadKind Sema::CheckOverload(Scope *S, FunctionDecl *New,
+                                 const LookupResult &Old, NamedDecl *&Match,
+                                 bool NewIsUsingDecl) {
   for (LookupResult::iterator I = Old.begin(), E = Old.end();
          I != E; ++I) {
     NamedDecl *OldD = *I;
@@ -1244,14 +1244,14 @@ Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old,
           continue;
 
         Match = *I;
-        return Ovl_Match;
+        return OverloadKind::Match;
       }
 
       // Builtins that have custom typechecking or have a reference should
       // not be overloadable or redeclarable.
       if (!getASTContext().canBuiltinBeRedeclared(OldF)) {
         Match = *I;
-        return Ovl_NonFunction;
+        return OverloadKind::NonFunction;
       }
     } else if (isa<UsingDecl>(OldD) || isa<UsingPackDecl>(OldD)) {
       // We can overload with these, which can show up when doing
@@ -1268,14 +1268,14 @@ Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old,
       // member, the using declaration can only introduce an enumerator.
       if (UUD->getQualifier()->isDependent() && !UUD->isCXXClassMember()) {
         Match = *I;
-        return Ovl_NonFunction;
+        return OverloadKind::NonFunction;
       }
     } else {
       // (C++ 13p1):
       //   Only function declarations can be overloaded; object and type
       //   declarations cannot be overloaded.
       Match = *I;
-      return Ovl_NonFunction;
+      return OverloadKind::NonFunction;
     }
   }
 
@@ -1303,14 +1303,14 @@ Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old,
     if (CheckFunctionTemplateSpecialization(New, nullptr, TemplateSpecResult,
                                             /*QualifiedFriend*/true)) {
       New->setInvalidDecl();
-      return Ovl_Overload;
+      return OverloadKind::Overload;
     }
 
     Match = TemplateSpecResult.getAsSingle<FunctionDecl>();
-    return Ovl_Match;
+    return OverloadKind::Match;
   }
 
-  return Ovl_Overload;
+  return OverloadKind::Overload;
 }
 
 template <typename AttrT> static bool hasExplicitAttr(const FunctionDecl *D) {