[clang][NFC] Convert LookupResultKind to scoped enum

Author: Endilll

clang/include/clang/Sema/Lookup.h

@@ -36,6 +36,34 @@ namespace clang {
 
 class CXXBasePaths;
 
+enum class LookupResultKind {
+  /// No entity found met the criteria.
+  NotFound = 0,
+
+  /// No entity found met the criteria within the current
+  /// instantiation,, but there were dependent base classes of the
+  /// current instantiation that could not be searched.
+  NotFoundInCurrentInstantiation,
+
+  /// Name lookup found a single declaration that met the
+  /// criteria.  getFoundDecl() will return this declaration.
+  Found,
+
+  /// Name lookup found a set of overloaded functions that
+  /// met the criteria.
+  FoundOverloaded,
+
+  /// Name lookup found an unresolvable value declaration
+  /// and cannot yet complete.  This only happens in C++ dependent
+  /// contexts with dependent using declarations.
+  FoundUnresolvedValue,
+
+  /// Name lookup results in an ambiguity; use
+  /// getAmbiguityKind to figure out what kind of ambiguity
+  /// we have.
+  Ambiguous
+};
+
 enum class LookupAmbiguityKind {
   /// Name lookup results in an ambiguity because multiple
   /// entities that meet the lookup criteria were found in
@@ -118,34 +146,6 @@ enum class LookupAmbiguityKind {
 /// results occurred for a given lookup.
 class LookupResult {
 public:
-  enum LookupResultKind {
-    /// No entity found met the criteria.
-    NotFound = 0,
-
-    /// No entity found met the criteria within the current
-    /// instantiation,, but there were dependent base classes of the
-    /// current instantiation that could not be searched.
-    NotFoundInCurrentInstantiation,
-
-    /// Name lookup found a single declaration that met the
-    /// criteria.  getFoundDecl() will return this declaration.
-    Found,
-
-    /// Name lookup found a set of overloaded functions that
-    /// met the criteria.
-    FoundOverloaded,
-
-    /// Name lookup found an unresolvable value declaration
-    /// and cannot yet complete.  This only happens in C++ dependent
-    /// contexts with dependent using declarations.
-    FoundUnresolvedValue,
-
-    /// Name lookup results in an ambiguity; use
-    /// getAmbiguityKind to figure out what kind of ambiguity
-    /// we have.
-    Ambiguous
-  };
-
   /// A little identifier for flagging temporary lookup results.
   enum TemporaryToken {
     Temporary
@@ -322,23 +322,23 @@ class LookupResult {
   bool isTemplateNameLookup() const { return TemplateNameLookup; }
 
   bool isAmbiguous() const {
-    return getResultKind() == Ambiguous;
+    return getResultKind() == LookupResultKind::Ambiguous;
   }
 
   /// Determines if this names a single result which is not an
   /// unresolved value using decl.  If so, it is safe to call
   /// getFoundDecl().
   bool isSingleResult() const {
-    return getResultKind() == Found;
+    return getResultKind() == LookupResultKind::Found;
   }
 
   /// Determines if the results are overloaded.
   bool isOverloadedResult() const {
-    return getResultKind() == FoundOverloaded;
+    return getResultKind() == LookupResultKind::FoundOverloaded;
   }
 
   bool isUnresolvableResult() const {
-    return getResultKind() == FoundUnresolvedValue;
+    return getResultKind() == LookupResultKind::FoundUnresolvedValue;
   }
 
   LookupResultKind getResultKind() const {
@@ -480,29 +480,29 @@ class LookupResult {
   /// Does not test the acceptance criteria.
   void addDecl(NamedDecl *D, AccessSpecifier AS) {
     Decls.addDecl(D, AS);
-    ResultKind = Found;
+    ResultKind = LookupResultKind::Found;
   }
 
   /// Add all the declarations from another set of lookup
   /// results.
   void addAllDecls(const LookupResult &Other) {
     Decls.append(Other.Decls.begin(), Other.Decls.end());
-    ResultKind = Found;
+    ResultKind = LookupResultKind::Found;
   }
 
   /// Determine whether no result was found because we could not
   /// search into dependent base classes of the current instantiation.
   bool wasNotFoundInCurrentInstantiation() const {
-    return ResultKind == NotFoundInCurrentInstantiation;
+    return ResultKind == LookupResultKind::NotFoundInCurrentInstantiation;
   }
 
   /// Note that while no result was found in the current instantiation,
   /// there were dependent base classes that could not be searched.
   void setNotFoundInCurrentInstantiation() {
-    assert((ResultKind == NotFound ||
-            ResultKind == NotFoundInCurrentInstantiation) &&
+    assert((ResultKind == LookupResultKind::NotFound ||
+            ResultKind == LookupResultKind::NotFoundInCurrentInstantiation) &&
            Decls.empty());
-    ResultKind = NotFoundInCurrentInstantiation;
+    ResultKind = LookupResultKind::NotFoundInCurrentInstantiation;
   }
 
   /// Determine whether the lookup result was shadowed by some other
@@ -524,8 +524,8 @@ class LookupResult {
   /// removals has been performed.
   void resolveKindAfterFilter() {
     if (Decls.empty()) {
-      if (ResultKind != NotFoundInCurrentInstantiation)
-        ResultKind = NotFound;
+      if (ResultKind != LookupResultKind::NotFoundInCurrentInstantiation)
+        ResultKind = LookupResultKind::NotFound;
 
       if (Paths) {
         deletePaths(Paths);
@@ -534,16 +534,16 @@ class LookupResult {
     } else {
       std::optional<LookupAmbiguityKind> SavedAK;
       bool WasAmbiguous = false;
-      if (ResultKind == Ambiguous) {
+      if (ResultKind == LookupResultKind::Ambiguous) {
         SavedAK = Ambiguity;
         WasAmbiguous = true;
       }
-      ResultKind = Found;
+      ResultKind = LookupResultKind::Found;
       resolveKind();
 
       // If we didn't make the lookup unambiguous, restore the old
       // ambiguity kind.
-      if (ResultKind == Ambiguous) {
+      if (ResultKind == LookupResultKind::Ambiguous) {
         (void)WasAmbiguous;
         assert(WasAmbiguous);
         Ambiguity = *SavedAK;
@@ -556,7 +556,8 @@ class LookupResult {
 
   template <class DeclClass>
   DeclClass *getAsSingle() const {
-    if (getResultKind() != Found) return nullptr;
+    if (getResultKind() != LookupResultKind::Found)
+      return nullptr;
     return dyn_cast<DeclClass>(getFoundDecl());
   }
 
@@ -566,8 +567,8 @@ class LookupResult {
   /// This is intended for users who have examined the result kind
   /// and are certain that there is only one result.
   NamedDecl *getFoundDecl() const {
-    assert(getResultKind() == Found
-           && "getFoundDecl called on non-unique result");
+    assert(getResultKind() == LookupResultKind::Found &&
+           "getFoundDecl called on non-unique result");
     return (*begin())->getUnderlyingDecl();
   }
 
@@ -579,7 +580,8 @@ class LookupResult {
 
   /// Asks if the result is a single tag decl.
   bool isSingleTagDecl() const {
-    return getResultKind() == Found && isa<TagDecl>(getFoundDecl());
+    return getResultKind() == LookupResultKind::Found &&
+           isa<TagDecl>(getFoundDecl());
   }
 
   /// Make these results show that the name was found in
@@ -603,7 +605,7 @@ class LookupResult {
 
   /// Clears out any current state.
   LLVM_ATTRIBUTE_REINITIALIZES void clear() {
-    ResultKind = NotFound;
+    ResultKind = LookupResultKind::NotFound;
     Decls.clear();
     if (Paths) deletePaths(Paths);
     Paths = nullptr;
@@ -770,7 +772,7 @@ class LookupResult {
   }
 
   void setAmbiguous(LookupAmbiguityKind AK) {
-    ResultKind = Ambiguous;
+    ResultKind = LookupResultKind::Ambiguous;
     Ambiguity = AK;
   }
 
@@ -789,7 +791,7 @@ class LookupResult {
   static void deletePaths(CXXBasePaths *);
 
   // Results.
-  LookupResultKind ResultKind = NotFound;
+  LookupResultKind ResultKind = LookupResultKind::NotFound;
   // ill-defined unless ambiguous. Still need to be initialized it will be
   // copied/moved.
   LookupAmbiguityKind Ambiguity = {};

clang/lib/Sema/SemaDecl.cpp

@@ -418,7 +418,7 @@ ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
   NamedDecl *IIDecl = nullptr;
   UsingShadowDecl *FoundUsingShadow = nullptr;
   switch (Result.getResultKind()) {
-  case LookupResult::NotFound:
+  case LookupResultKind::NotFound:
     if (CorrectedII) {
       TypeNameValidatorCCC CCC(/*AllowInvalid=*/true, isClassName,
                                AllowDeducedTemplate);
@@ -460,7 +460,7 @@ ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
     }
     Result.suppressDiagnostics();
     return nullptr;
-  case LookupResult::NotFoundInCurrentInstantiation:
+  case LookupResultKind::NotFoundInCurrentInstantiation:
     if (AllowImplicitTypename == ImplicitTypenameContext::Yes) {
       QualType T = Context.getDependentNameType(ElaboratedTypeKeyword::None,
                                                 SS->getScopeRep(), &II);
@@ -472,12 +472,12 @@ ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
       return CreateParsedType(T, TLB.getTypeSourceInfo(Context, T));
     }
     [[fallthrough]];
-  case LookupResult::FoundOverloaded:
-  case LookupResult::FoundUnresolvedValue:
+  case LookupResultKind::FoundOverloaded:
+  case LookupResultKind::FoundUnresolvedValue:
     Result.suppressDiagnostics();
     return nullptr;
 
-  case LookupResult::Ambiguous:
+  case LookupResultKind::Ambiguous:
     // Recover from type-hiding ambiguities by hiding the type.  We'll
     // do the lookup again when looking for an object, and we can
     // diagnose the error then.  If we don't do this, then the error
@@ -521,7 +521,7 @@ ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
     // perform the name lookup again.
     break;
 
-  case LookupResult::Found:
+  case LookupResultKind::Found:
     IIDecl = Result.getFoundDecl();
     FoundUsingShadow = dyn_cast<UsingShadowDecl>(*Result.begin());
     break;
@@ -657,7 +657,7 @@ DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
   LookupResult R(*this, &II, SourceLocation(), LookupTagName);
   LookupName(R, S, false);
   R.suppressDiagnostics();
-  if (R.getResultKind() == LookupResult::Found)
+  if (R.getResultKind() == LookupResultKind::Found)
     if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
       switch (TD->getTagKind()) {
       case TagTypeKind::Struct:
@@ -926,7 +926,7 @@ Sema::NameClassification Sema::ClassifyName(Scope *S, CXXScopeSpec &SS,
 
 Corrected:
   switch (Result.getResultKind()) {
-  case LookupResult::NotFound:
+  case LookupResultKind::NotFound:
     // If an unqualified-id is followed by a '(', then we have a function
     // call.
     if (SS.isEmpty() && NextToken.is(tok::l_paren)) {
@@ -1043,7 +1043,7 @@ Sema::NameClassification Sema::ClassifyName(Scope *S, CXXScopeSpec &SS,
     Result.suppressDiagnostics();
     return NameClassification::Unknown();
 
-  case LookupResult::NotFoundInCurrentInstantiation: {
+  case LookupResultKind::NotFoundInCurrentInstantiation: {
     // We performed name lookup into the current instantiation, and there were
     // dependent bases, so we treat this result the same way as any other
     // dependent nested-name-specifier.
@@ -1061,12 +1061,12 @@ Sema::NameClassification Sema::ClassifyName(Scope *S, CXXScopeSpec &SS,
     return NameClassification::DependentNonType();
   }
 
-  case LookupResult::Found:
-  case LookupResult::FoundOverloaded:
-  case LookupResult::FoundUnresolvedValue:
+  case LookupResultKind::Found:
+  case LookupResultKind::FoundOverloaded:
+  case LookupResultKind::FoundUnresolvedValue:
     break;
 
-  case LookupResult::Ambiguous:
+  case LookupResultKind::Ambiguous:
     if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
         hasAnyAcceptableTemplateNames(Result, /*AllowFunctionTemplates=*/true,
                                       /*AllowDependent=*/false)) {
@@ -1498,11 +1498,11 @@ static bool AllowOverloadingOfFunction(const LookupResult &Previous,
   // to check at least two; hence the 'any_of' check below. Note that
   // the overloadable attribute is implicitly added to declarations
   // that were required to have it but did not.
-  if (Previous.getResultKind() == LookupResult::FoundOverloaded) {
+  if (Previous.getResultKind() == LookupResultKind::FoundOverloaded) {
     return llvm::any_of(Previous, [](const NamedDecl *ND) {
       return ND->hasAttr<OverloadableAttr>();
     });
-  } else if (Previous.getResultKind() == LookupResult::Found)
+  } else if (Previous.getResultKind() == LookupResultKind::Found)
     return Previous.getFoundDecl()->hasAttr<OverloadableAttr>();
 
   return false;
@@ -8290,7 +8290,7 @@ static SourceLocation getCaptureLocation(const LambdaScopeInfo *LSI,
 static bool shouldWarnIfShadowedDecl(const DiagnosticsEngine &Diags,
                                      const LookupResult &R) {
   // Only diagnose if we're shadowing an unambiguous field or variable.
-  if (R.getResultKind() != LookupResult::Found)
+  if (R.getResultKind() != LookupResultKind::Found)
     return false;
 
   // Return false if warning is ignored.
@@ -10504,7 +10504,7 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
       // Recover gracefully from an invalid redeclaration.
       D.setRedeclaration(true);
     assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
-            Previous.getResultKind() != LookupResult::FoundOverloaded) &&
+            Previous.getResultKind() != LookupResultKind::FoundOverloaded) &&
            "previous declaration set still overloaded");
 
     // Diagnose no-prototype function declarations with calling conventions that
@@ -10671,7 +10671,7 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
 
     assert((NewFD->isInvalidDecl() || NewFD->isMultiVersion() ||
             !D.isRedeclaration() ||
-            Previous.getResultKind() != LookupResult::FoundOverloaded) &&
+            Previous.getResultKind() != LookupResultKind::FoundOverloaded) &&
            "previous declaration set still overloaded");
 
     NamedDecl *PrincipalDecl = (FunctionTemplate
@@ -18679,19 +18679,19 @@ FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record,
                         RedeclarationKind::ForVisibleRedeclaration);
   LookupName(Previous, S);
   switch (Previous.getResultKind()) {
-    case LookupResult::Found:
-    case LookupResult::FoundUnresolvedValue:
-      PrevDecl = Previous.getAsSingle<NamedDecl>();
-      break;
+  case LookupResultKind::Found:
+  case LookupResultKind::FoundUnresolvedValue:
+    PrevDecl = Previous.getAsSingle<NamedDecl>();
+    break;
 
-    case LookupResult::FoundOverloaded:
-      PrevDecl = Previous.getRepresentativeDecl();
-      break;
+  case LookupResultKind::FoundOverloaded:
+    PrevDecl = Previous.getRepresentativeDecl();
+    break;
 
-    case LookupResult::NotFound:
-    case LookupResult::NotFoundInCurrentInstantiation:
-    case LookupResult::Ambiguous:
-      break;
+  case LookupResultKind::NotFound:
+  case LookupResultKind::NotFoundInCurrentInstantiation:
+  case LookupResultKind::Ambiguous:
+    break;
   }
   Previous.suppressDiagnostics();