[clang][NFC] Inclusive terms: Replace uses of whitelist in clang/lib/StaticAnalyzer

[ZarkoCA]

Summary

Replace variable and functions names, as well as comments that contain whitelist with
more inclusive terms.

[aaron.ballman]

Thank you for this! Mostly just bikeshedding on names (allowlist as a verb sounds weird to me), feel free to take or leave the suggestions. LG aside from the formatting nits.

clang/lib/StaticAnalyzer/Checkers/EnumCastOutOfRangeChecker.cpp

96–97

clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp

1191–1199

clang/lib/StaticAnalyzer/Checkers/VforkChecker.cpp

12

53–54

96–97

Also, should fix the clang-format issue.

183–184

188–189

Might as well handle this formatting issue.

[martong]

Thanks @ZarkoCA, LGTM, but please address the sensible changes advised by Aaron. And thanks @aaron.ballman for the review!

[ZarkoCA]

• Fix formatting and change variable names to make better grammatical sense

[ZarkoCA]

In D112642#3093559, @aaron.ballman wrote:

Thank you for this! Mostly just bikeshedding on names (allowlist as a verb sounds weird to me), feel free to take or leave the suggestions. LG aside from the formatting nits.

Yes, it didn't seem that right to me either but thought I'd get the ball rolling with something for now. Thanks for the suggestions, it looks much better to me now.

[aaron.ballman]

LGTM!

clang/lib/StaticAnalyzer/Checkers/EnumCastOutOfRangeChecker.cpp

C.emitReport(std::make_unique<PathSensitiveBugReport>(
         N));
   }
 }
 
 void EnumCastOutOfRangeChecker::checkPreStmt(const CastExpr *CE,
                                              CheckerContext &C) const {
 
   // Only perform enum range check on casts where such checks are valid.  For
   // all other cast kinds (where enum range checks are unnecessary or invalid),
-  // just return immediately.  TODO: The set of casts whitelisted for enum
-  // range checking may be incomplete.  Better to add a missing cast kind to
-  // enable a missing check than to generate false negatives and have to remove
-  // those later.
+  // just return immediately.  TODO: The set of casts allowed for enum range
+  // checking may be incomplete.  Better to add a missing cast kind to enable a
+  // missing check than to generate false negatives and have to remove those
+  // later.
   switch (CE->getCastKind()) {
   case CK_IntegralCast:
     break;
 
   default:
     return;
     break;
   }

clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp

 ProgramStateRef RetainCountChecker::checkRegionChanges(
     ProgramStateRef state, const InvalidatedSymbols *invalidated,
     ArrayRef<const MemRegion *> ExplicitRegions,
     ArrayRef<const MemRegion *> Regions, const LocationContext *LCtx,
     const CallEvent *Call) const {
   if (!invalidated)
     return state;
 
-  llvm::SmallPtrSet<SymbolRef, 8> WhitelistedSymbols;
+  llvm::SmallPtrSet<SymbolRef, 8> AllowedSymbols;
 
   for (const MemRegion *I : ExplicitRegions)
     if (const SymbolicRegion *SR = I->StripCasts()->getAs<SymbolicRegion>())
-      WhitelistedSymbols.insert(SR->getSymbol());
+      AllowedSymbols.insert(SR->getSymbol());
 
   for (SymbolRef sym : *invalidated) {
-    if (WhitelistedSymbols.count(sym))
+    if (AllowedSymbols.count(sym))
       continue;
     // Remove any existing reference-count binding.
     state = removeRefBinding(state, sym);
   }
   return state;
 }
 
 ProgramStateRef
 RetainCountChecker::handleAutoreleaseCounts(ProgramStateRef state,

clang/lib/StaticAnalyzer/Checkers/VforkChecker.cpp

 //===- VforkChecker.cpp -------- Vfork usage checks --------------*- C++ -*-==//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines vfork checker which checks for dangerous uses of vfork.
 //  Vforked process shares memory (including stack) with parent so it's
 //  range of actions is significantly limited: can't write variables,
-//  can't call functions not in whitelist, etc. For more details, see
+//  can't call functions not in the allowed list, etc. For more details, see
 //  http://man7.org/linux/man-pages/man2/vfork.2.html
 //
 //  This checker checks for prohibited constructs in vforked process.
 //  The state transition diagram:
 //  PARENT ---(vfork() == 0)--> CHILD
 //                                   |
 //                                   --(*p = ...)--> bug
 //                                   |

 using namespace clang;
 using namespace ento;
 
 namespace {
 
 class VforkChecker : public Checker<check::PreCall, check::PostCall,
                                     check::Bind, check::PreStmt<ReturnStmt>> {
   mutable std::unique_ptr<BuiltinBug> BT;
-  mutable llvm::SmallSet<const IdentifierInfo *, 10> VforkWhitelist;
+  mutable llvm::SmallSet<const IdentifierInfo *, 10> VforkAllowlist;
   mutable const IdentifierInfo *II_vfork;
 
   static bool isChildProcess(const ProgramStateRef State);
 
   bool isVforkCall(const Decl *D, CheckerContext &C) const;
-  bool isCallWhitelisted(const IdentifierInfo *II, CheckerContext &C) const;
+  bool isCallExplicitelyAllowed(const IdentifierInfo *II,
+                                CheckerContext &C) const;
 
   void reportBug(const char *What, CheckerContext &C,
                  const char *Details = nullptr) const;
 
 public:
   VforkChecker() : II_vfork(nullptr) {}
 
   void checkPreCall(const CallEvent &Call, CheckerContext &C) const;
bool VforkChecker::isVforkCall(const Decl *D, CheckerContext &C) const {
   if (!II_vfork) {
     ASTContext &AC = C.getASTContext();
     II_vfork = &AC.Idents.get("vfork");
   }
 
   return FD->getIdentifier() == II_vfork;
 }
 
 // Returns true iff ok to call function after successful vfork.
-bool VforkChecker::isCallWhitelisted(const IdentifierInfo *II,
+bool VforkChecker::isCallExplicitelyAllowed(const IdentifierInfo *II,
                                             CheckerContext &C) const {
-  if (VforkWhitelist.empty()) {
+  if (VforkAllowlist.empty()) {
     // According to manpage.
     const char *ids[] = {
       "_Exit",
       "_exit",
       "execl",
       "execle",
       "execlp",
       "execv",
       "execve",
       "execvp",
       "execvpe",
       nullptr
     };
 
     ASTContext &AC = C.getASTContext();
     for (const char **id = ids; *id; ++id)
-      VforkWhitelist.insert(&AC.Idents.get(*id));
+      VforkAllowlist.insert(&AC.Idents.get(*id));
   }
 
-  return VforkWhitelist.count(II);
+  return VforkAllowlist.count(II);
 }
 
 void VforkChecker::reportBug(const char *What, CheckerContext &C,
                              const char *Details) const {
   if (ExplodedNode *N = C.generateErrorNode(C.getState())) {
     if (!BT)
       BT.reset(new BuiltinBug(this,
                               "Dangerous construct in a vforked process"));
void VforkChecker::checkPostCall(const CallEvent &Call,
   // Parent branch gets nonzero return value (according to manpage).
   ProgramStateRef ParentState, ChildState;
   std::tie(ParentState, ChildState) = C.getState()->assume(*DVal);
   C.addTransition(ParentState);
   ChildState = ChildState->set<VforkResultRegion>(LhsDeclReg);
   C.addTransition(ChildState);
 }
 
-// Prohibit calls to non-whitelist functions in child process.
+// Prohibit calls to functions in child process which are not explicitly
+// allowed.
 void VforkChecker::checkPreCall(const CallEvent &Call,
                                 CheckerContext &C) const {
   ProgramStateRef State = C.getState();
-  if (isChildProcess(State)
-      && !isCallWhitelisted(Call.getCalleeIdentifier(), C))
+  if (isChildProcess(State) &&
+      !isCallExplicitelyAllowed(Call.getCalleeIdentifier(), C))
     reportBug("This function call", C);
 }
 
 // Prohibit writes in child process (except for vfork's lhs).
 void VforkChecker::checkBind(SVal L, SVal V, const Stmt *S,
                              CheckerContext &C) const {
   ProgramStateRef State = C.getState();
   if (!isChildProcess(State))

clang/lib/StaticAnalyzer/Checkers/WebKit/ASTUtils.h

 class Expr;
 
 /// This function de-facto defines a set of transformations that we consider
 /// safe (in heuristical sense). These transformation if passed a safe value as
 /// an input should provide a safe value (or an object that provides safe
 /// values).
 ///
 /// For more context see Static Analyzer checkers documentation - specifically
-/// webkit.UncountedCallArgsChecker checker. Whitelist of transformations:
+/// webkit.UncountedCallArgsChecker checker. Allowed list of transformations:
 /// - constructors of ref-counted types (including factory methods)
 /// - getters of ref-counted types
 /// - member overloaded operators
 /// - casts
 /// - unary operators like ``&`` or ``*``
 ///
 /// If passed expression is of type uncounted pointer/reference we try to find
 /// the "origin" of the pointer value.

clang/lib/StaticAnalyzer/Core/MemRegion.cpp

const VarRegion *MemRegionManager::getVarRegion(const VarDecl *D,
 
   D = D->getCanonicalDecl();
   const MemRegion *sReg = nullptr;
 
   if (D->hasGlobalStorage() && !D->isStaticLocal()) {
 
     // First handle the globals defined in system headers.
     if (Ctx.getSourceManager().isInSystemHeader(D->getLocation())) {
-      // Whitelist the system globals which often DO GET modified, assume the
+      //  Allow the system globals which often DO GET modified, assume the
       // rest are immutable.
       if (D->getName().contains("errno"))
         sReg = getGlobalsRegion(MemRegion::GlobalSystemSpaceRegionKind);
       else
         sReg = getGlobalsRegion(MemRegion::GlobalImmutableSpaceRegionKind);
 
     // Treat other globals as GlobalInternal unless they are constants.
     } else {

clang/test/Analysis/vfork.c

int f1(int x, int y) {
   pid_t pid = vfork(); // expected-warning{{Call to function 'vfork' is insecure}}
   if (pid != 0)
     return 0;
 
   switch (x) {
   case 0:
     // Ensure that modifying pid is ok.
     pid = 1; // no-warning
-    // Ensure that calling whitelisted routines is ok.
+    // Ensure that calling allowlisted routines is ok.
     switch (y) {
     case 0:
       execl("", "", 0); // no-warning
       break;
     case 1:
       execle("", "", 0); // no-warning
       break;
     case 2:

 // Same as previous but without explicit pid variable.
 int f2(int x) {
   pid_t pid = vfork(); // expected-warning{{Call to function 'vfork' is insecure}}
 
   switch (x) {
   case 0:
     // Ensure that writing pid is ok.
     pid = 1; // no-warning
-    // Ensure that calling whitelisted routines is ok.
+    // Ensure that calling allowlisted routines is ok.
     execl("", "", 0); // no-warning
     _exit(1); // no-warning
     break;
   case 1:
     // Ensure that writing variables is prohibited.
     x = 0; // expected-warning{{This assignment is prohibited after a successful vfork}}
     break;
   case 2: