[clang-tidy] Small refactor for ExceptionAnalyzer

[AMS21]

Summary

• Use llvm::DenseMap<> with pre-allocation instead of std::map<> for FunctionCache
• Avoid double lookup for FunctionCache
• Use try_emplace instead of insert
• Simplify definition of State enum

[PiotrZSL]

LGTM.

[AMS21]

In D147376#4239421, @PiotrZSL wrote:

LGTM.

I would kindly ask for someone to commit this on my behalf.

clang-tools-extra/clang-tidy/utils/ExceptionAnalyzer.h

 
 namespace clang::tidy::utils {
 
 /// This class analysis if a `FunctionDecl` can in principle throw an
 /// exception, either directly or indirectly. It can be configured to ignore
 /// custom exception types.
 class ExceptionAnalyzer {
 public:
-  enum class State : std::int8_t {
-    Throwing = 0,    ///< The function can definitely throw given an AST.
-    NotThrowing = 1, ///< This function can not throw, given an AST.
-    Unknown = 2,     ///< This can happen for extern functions without available
-                     ///< definition.
+  enum class State {
+    Throwing,    ///< The function can definitely throw given an AST.
+    NotThrowing, ///< This function can not throw, given an AST.
+    Unknown,     ///< This can happen for extern functions without available
   };
 
   /// Bundle the gathered information about an entity like a function regarding
   /// it's exception behaviour. The 'NonThrowing'-state can be considered as the
   /// neutral element in terms of information propagation.
   /// In the case of 'Throwing' state it is possible that 'getExceptionTypes'
   /// does not include *ALL* possible types as there is the possibility that
   /// an 'Unknown' function is called that might throw a previously unknown
private:
 
   ExceptionInfo analyzeImpl(const FunctionDecl *Func);
   ExceptionInfo analyzeImpl(const Stmt *Stmt);
 
   template <typename T> ExceptionInfo analyzeDispatch(const T *Node);
 
   bool IgnoreBadAlloc = true;
   llvm::StringSet<> IgnoredExceptions;
-  std::map<const FunctionDecl *, ExceptionInfo> FunctionCache;
+  llvm::DenseMap<const FunctionDecl *, ExceptionInfo> FunctionCache{32u};
 };
 
 } // namespace clang::tidy::utils
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_EXCEPTION_ANALYZER_H

clang-tools-extra/clang-tidy/utils/ExceptionAnalyzer.cpp

ExceptionAnalyzer::ExceptionInfo ExceptionAnalyzer::throwsException(
   return Results;
 }
 
 ExceptionAnalyzer::ExceptionInfo
 ExceptionAnalyzer::analyzeImpl(const FunctionDecl *Func) {
   ExceptionInfo ExceptionList;
 
   // Check if the function has already been analyzed and reuse that result.
-  if (FunctionCache.count(Func) == 0) {
+  const auto CacheEntry = FunctionCache.find(Func);
+  if (CacheEntry == FunctionCache.end()) {
     llvm::SmallSet<const FunctionDecl *, 32> CallStack;
     ExceptionList = throwsException(Func, CallStack);
 
     // Cache the result of the analysis. This is done prior to filtering
     // because it is best to keep as much information as possible.
     // The results here might be relevant to different analysis passes
     // with different needs as well.
-    FunctionCache.insert(std::make_pair(Func, ExceptionList));
+    FunctionCache.try_emplace(Func, ExceptionList);
   } else
-    ExceptionList = FunctionCache[Func];
+    ExceptionList = CacheEntry->getSecond();
 
   return ExceptionList;
 }
 
 ExceptionAnalyzer::ExceptionInfo
 ExceptionAnalyzer::analyzeImpl(const Stmt *Stmt) {
   llvm::SmallSet<const FunctionDecl *, 32> CallStack;
   return throwsException(Stmt, ExceptionInfo::Throwables(), CallStack);
ExceptionAnalyzer::analyzeDispatch(const T *Node) {
   return ExceptionList;
 }
 
 ExceptionAnalyzer::ExceptionInfo
 ExceptionAnalyzer::analyze(const FunctionDecl *Func) {
   return analyzeDispatch(Func);
 }
 
-ExceptionAnalyzer::ExceptionInfo
-ExceptionAnalyzer::analyze(const Stmt *Stmt) {
+ExceptionAnalyzer::ExceptionInfo ExceptionAnalyzer::analyze(const Stmt *Stmt) {
   return analyzeDispatch(Stmt);
 }
 
 } // namespace clang::tidy::utils