[NFC] Remove unused variables declared in conditions

[hazohelet]

Summary

D152495 makes clang warn on unused variables that are declared in conditions like if (int var = init) {}
This patch is an NFC fix to suppress the new warning in llvm,clang,lld builds to pass CI in the above patch.

clang/include/clang/ASTMatchers/ASTMatchers.h

 ///   +(void)foo;
 ///   @end
 ///   ...
 ///   [I foo]
 /// \endcode
 AST_POLYMORPHIC_MATCHER_P_OVERLOAD(
     callee, AST_POLYMORPHIC_SUPPORTED_TYPES(ObjCMessageExpr, CallExpr),
     internal::Matcher<Decl>, InnerMatcher, 1) {
-  if (const auto *CallNode = dyn_cast<CallExpr>(&Node))
+  if (isa<CallExpr>(&Node))
     return callExpr(hasDeclaration(InnerMatcher))
         .matches(Node, Finder, Builder);
   else {
     // The dynamic cast below is guaranteed to succeed as there are only 2
     // supported return types.
     const auto *MsgNode = cast<ObjCMessageExpr>(&Node);
     const Decl *DeclNode = MsgNode->getMethodDecl();
     return (DeclNode != nullptr &&

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

bool ByteCodeStmtGen<Emitter>::visitIfStmt(const IfStmt *IS) {
   BlockScope<Emitter> IfScope(this);
 
   if (IS->isNonNegatedConsteval())
     return visitStmt(IS->getThen());
   if (IS->isNegatedConsteval())
     return IS->getElse() ? visitStmt(IS->getElse()) : true;
 
   if (auto *CondInit = IS->getInit())
-    if (!visitStmt(IS->getInit()))
+    if (!visitStmt(CondInit))
       return false;
 
   if (const DeclStmt *CondDecl = IS->getConditionVariableDeclStmt())
     if (!visitDeclStmt(CondDecl))
       return false;
 
   if (!this->visitBool(IS->getCond()))
     return false;

clang/lib/CodeGen/BackendUtil.cpp

 void clang::EmbedObject(llvm::Module *M, const CodeGenOptions &CGOpts,
                         DiagnosticsEngine &Diags) {
   if (CGOpts.OffloadObjects.empty())
     return;
 
   for (StringRef OffloadObject : CGOpts.OffloadObjects) {
     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ObjectOrErr =
         llvm::MemoryBuffer::getFileOrSTDIN(OffloadObject);
-    if (std::error_code EC = ObjectOrErr.getError()) {
+    if (ObjectOrErr.getError()) {
       auto DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
                                           "could not open '%0' for embedding");
       Diags.Report(DiagID) << OffloadObject;
       return;
     }
 
     llvm::embedBufferInModule(*M, **ObjectOrErr, ".llvm.offloading",
                               Align(object::OffloadBinary::getAlignment()));
   }
 }

clang/lib/CodeGen/CGOpenMPRuntime.cpp

static llvm::TargetRegionEntryInfo getEntryInfoFromPresumedLoc(
     CodeGenModule &CGM, llvm::OpenMPIRBuilder &OMPBuilder,
     SourceLocation BeginLoc, llvm::StringRef ParentName = "") {
 
   auto FileInfoCallBack = [&]() {
     SourceManager &SM = CGM.getContext().getSourceManager();
     PresumedLoc PLoc = SM.getPresumedLoc(BeginLoc);
 
     llvm::sys::fs::UniqueID ID;
-    if (auto EC = llvm::sys::fs::getUniqueID(PLoc.getFilename(), ID)) {
+    if (llvm::sys::fs::getUniqueID(PLoc.getFilename(), ID)) {
       PLoc = SM.getPresumedLoc(BeginLoc, /*UseLineDirectives=*/false);
     }
 
     return std::pair<std::string, uint64_t>(PLoc.getFilename(), PLoc.getLine());
   };
 
   return OMPBuilder.getTargetEntryUniqueInfo(FileInfoCallBack, ParentName);
 }

clang/lib/CodeGen/CodeGenModule.cpp

if (getLangOpts().CUID.empty()) {
     llvm::MD5 Hash;
     llvm::MD5::MD5Result Result;
     for (const auto &Arg : PreprocessorOpts.Macros)
       Hash.update(Arg.first);
     Hash.final(Result);
 
     // Get the UniqueID for the file containing the decl.
     llvm::sys::fs::UniqueID ID;
-    if (auto EC = llvm::sys::fs::getUniqueID(PLoc.getFilename(), ID)) {
+    if (llvm::sys::fs::getUniqueID(PLoc.getFilename(), ID)) {
       PLoc = SM.getPresumedLoc(D->getLocation(), /*UseLineDirectives=*/false);
       assert(PLoc.isValid() && "Source location is expected to be valid.");
       if (auto EC = llvm::sys::fs::getUniqueID(PLoc.getFilename(), ID))
         SM.getDiagnostics().Report(diag::err_cannot_open_file)
             << PLoc.getFilename() << EC.message();
     }
     OS << llvm::format("%x", ID.getFile()) << llvm::format("%x", ID.getDevice())
        << "_" << llvm::utohexstr(Result.low(), /*LowerCase=*/true, /*Width=*/8);

clang/lib/Driver/ToolChains/Cuda.cpp

for (const auto &II : Inputs) {
     if (llvm::sys::path::extension(InputFile) != ".cubin") {
       // If there are no actions above this one then this is direct input and we
       // can copy it. Otherwise the input is internal so a `.cubin` file should
       // exist.
       if (II.getAction() && II.getAction()->getInputs().size() == 0) {
         const char *CubinF =
             Args.MakeArgString(getToolChain().getDriver().GetTemporaryPath(
                 llvm::sys::path::stem(InputFile), "cubin"));
-        if (std::error_code EC =
-                llvm::sys::fs::copy_file(InputFile, C.addTempFile(CubinF)))
+        if (llvm::sys::fs::copy_file(InputFile, C.addTempFile(CubinF)))
           continue;
 
         CmdArgs.push_back(CubinF);
       } else {
         SmallString<256> Filename(InputFile);
         llvm::sys::path::replace_extension(Filename, "cubin");
         CmdArgs.push_back(Args.MakeArgString(Filename));
       }

clang/lib/StaticAnalyzer/Checkers/FuchsiaHandleChecker.cpp

if (const auto *TypeDefTy = FuncDecl->getReturnType()->getAs<TypedefType>())
     if (TypeDefTy->getDecl()->getName() == ErrorTypeName)
       ResultSymbol = Call.getReturnValue().getAsSymbol();
 
   // Function returns an open handle.
   if (hasFuchsiaAttr<AcquireHandleAttr>(FuncDecl)) {
     SymbolRef RetSym = Call.getReturnValue().getAsSymbol();
     Notes.push_back([RetSym, FuncDecl](BugReport &BR) -> std::string {
       auto *PathBR = static_cast<PathSensitiveBugReport *>(&BR);
-      if (auto IsInteresting = PathBR->getInterestingnessKind(RetSym)) {
+      if (PathBR->getInterestingnessKind(RetSym)) {
         std::string SBuf;
         llvm::raw_string_ostream OS(SBuf);
         OS << "Function '" << FuncDecl->getDeclName()
            << "' returns an open handle";
         return SBuf;
       } else
         return "";
     });
     State =
         State->set<HStateMap>(RetSym, HandleState::getMaybeAllocated(nullptr));
   } else if (hasFuchsiaUnownedAttr<AcquireHandleAttr>(FuncDecl)) {
     // Function returns an unowned handle
     SymbolRef RetSym = Call.getReturnValue().getAsSymbol();
     Notes.push_back([RetSym, FuncDecl](BugReport &BR) -> std::string {
       auto *PathBR = static_cast<PathSensitiveBugReport *>(&BR);
-      if (auto IsInteresting = PathBR->getInterestingnessKind(RetSym)) {
+      if (PathBR->getInterestingnessKind(RetSym)) {
         std::string SBuf;
         llvm::raw_string_ostream OS(SBuf);
         OS << "Function '" << FuncDecl->getDeclName()
            << "' returns an unowned handle";
         return SBuf;
       } else
         return "";
     });
for (SymbolRef Handle : Handles) {
           reportDoubleRelease(Handle, Call.getArgSourceRange(Arg), C);
           return;
         } else if (HState && HState->isUnowned()) {
           reportUnownedRelease(Handle, Call.getArgSourceRange(Arg), C);
           return;
         } else {
           Notes.push_back([Handle, ParamDiagIdx](BugReport &BR) -> std::string {
             auto *PathBR = static_cast<PathSensitiveBugReport *>(&BR);
-            if (auto IsInteresting = PathBR->getInterestingnessKind(Handle)) {
+            if (PathBR->getInterestingnessKind(Handle)) {
               std::string SBuf;
               llvm::raw_string_ostream OS(SBuf);
               OS << "Handle released through " << ParamDiagIdx
                  << llvm::getOrdinalSuffix(ParamDiagIdx) << " parameter";
               return SBuf;
             } else
               return "";
           });
           State = State->set<HStateMap>(Handle, HandleState::getReleased());
         }
       } else if (hasFuchsiaAttr<AcquireHandleAttr>(PVD)) {
         Notes.push_back([Handle, ParamDiagIdx](BugReport &BR) -> std::string {
           auto *PathBR = static_cast<PathSensitiveBugReport *>(&BR);
-          if (auto IsInteresting = PathBR->getInterestingnessKind(Handle)) {
+          if (PathBR->getInterestingnessKind(Handle)) {
             std::string SBuf;
             llvm::raw_string_ostream OS(SBuf);
             OS << "Handle allocated through " << ParamDiagIdx
                << llvm::getOrdinalSuffix(ParamDiagIdx) << " parameter";
             return SBuf;
           } else
             return "";
         });
         State = State->set<HStateMap>(
             Handle, HandleState::getMaybeAllocated(ResultSymbol));
       } else if (hasFuchsiaUnownedAttr<AcquireHandleAttr>(PVD)) {
         Notes.push_back([Handle, ParamDiagIdx](BugReport &BR) -> std::string {
           auto *PathBR = static_cast<PathSensitiveBugReport *>(&BR);
-          if (auto IsInteresting = PathBR->getInterestingnessKind(Handle)) {
+          if (PathBR->getInterestingnessKind(Handle)) {
             std::string SBuf;
             llvm::raw_string_ostream OS(SBuf);
             OS << "Unowned handle allocated through " << ParamDiagIdx
                << llvm::getOrdinalSuffix(ParamDiagIdx) << " parameter";
             return SBuf;
           } else
             return "";
         });

clang/lib/StaticAnalyzer/Checkers/Yaml.h

std::optional<T> getConfiguration(CheckerManager &Mgr, Checker *Chk,
                                   StringRef Option, StringRef ConfigFile) {
   if (ConfigFile.trim().empty())
     return std::nullopt;
 
   llvm::vfs::FileSystem *FS = llvm::vfs::getRealFileSystem().get();
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
       FS->getBufferForFile(ConfigFile.str());
 
-  if (std::error_code ec = Buffer.getError()) {
+  if (Buffer.getError()) {
     Mgr.reportInvalidCheckerOptionValue(Chk, Option,
                                         "a valid filename instead of '" +
                                             std::string(ConfigFile) + "'");
     return std::nullopt;
   }
 
   llvm::yaml::Input Input(Buffer.get()->getBuffer());
   T Config;

clang/tools/clang-scan-deps/ClangScanDeps.cpp

llvm::sys::fs::createTemporaryFile("print-resource-dir-error",
                                        "" /*no-suffix*/, ErrorFile);
     llvm::FileRemover OutputRemover(OutputFile.c_str());
     llvm::FileRemover ErrorRemover(ErrorFile.c_str());
     std::optional<StringRef> Redirects[] = {
         {""}, // Stdin
         OutputFile.str(),
         ErrorFile.str(),
     };
-    if (const int RC = llvm::sys::ExecuteAndWait(
-            ClangBinaryPath, PrintResourceDirArgs, {}, Redirects)) {
+    if (llvm::sys::ExecuteAndWait(ClangBinaryPath, PrintResourceDirArgs, {},
+                                  Redirects)) {
       auto ErrorBuf = llvm::MemoryBuffer::getFile(ErrorFile.c_str());
       llvm::errs() << ErrorBuf.get()->getBuffer();
       return "";
     }
 
     auto OutputBuf = llvm::MemoryBuffer::getFile(OutputFile.c_str());
     if (!OutputBuf)
       return "";

lld/MachO/Driver.cpp

if (entry == loadedArchives.end()) {
         return file;
     }
 
     bool isLCLinkerForceLoad = loadType == LoadType::LCLinkerOption &&
                                config->forceLoadSwift &&
                                path::filename(path).starts_with("libswift");
     if ((isCommandLineLoad && config->allLoad) ||
         loadType == LoadType::CommandLineForce || isLCLinkerForceLoad) {
-      if (std::optional<MemoryBufferRef> buffer = readFile(path)) {
+      if (readFile(path)) {
         Error e = Error::success();
         for (const object::Archive::Child &c : file->getArchive().children(e)) {
           StringRef reason;
           switch (loadType) {
             case LoadType::LCLinkerOption:
               reason = "LC_LINKER_OPTION";
               break;
             case LoadType::CommandLineForce:
if ((isCommandLineLoad && config->allLoad) ||
       }
     } else if (isCommandLineLoad && config->forceLoadObjC) {
       for (const object::Archive::Symbol &sym : file->getArchive().symbols())
         if (sym.getName().starts_with(objc::klass))
           file->fetch(sym);
 
       // TODO: no need to look for ObjC sections for a given archive member if
       // we already found that it contains an ObjC symbol.
-      if (std::optional<MemoryBufferRef> buffer = readFile(path)) {
+      if (readFile(path)) {
         Error e = Error::success();
         for (const object::Archive::Child &c : file->getArchive().children(e)) {
           Expected<MemoryBufferRef> mb = c.getMemoryBufferRef();
           if (!mb || !hasObjCSection(*mb))
             continue;
           if (Error e = file->fetch(c, "-ObjC"))
             error(toString(file) + ": -ObjC failed to load archive member: " +
                   toString(std::move(e)));

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

DWARFCompileUnit *DWARFContext::getCompileUnitForDataAddress(uint64_t Address) {
   //      put the globals in the aranges, but this isn't true for gcc.
   //   2. Even if the global variable is in a .debug_arange, global variables
   //      may not be captured in the [start, end) addresses described by the
   //      parent compile unit.
   //
   // So, we walk the CU's and their child DI's manually, looking for the
   // specific global variable.
   for (std::unique_ptr<DWARFUnit> &CU : compile_units()) {
-    if (DWARFDie Die = CU->getVariableForAddress(Address)) {
+    if (CU->getVariableForAddress(Address)) {
       return static_cast<DWARFCompileUnit *>(CU.get());
     }
   }
   return nullptr;
 }
 
 DWARFContext::DIEsForAddress DWARFContext::getDIEsForAddress(uint64_t Address) {
   DIEsForAddress Result;

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

for (const DWARFLocationExpression &Location : *Locations) {
     Address = LocationAddr;
     break;
   }
 
   // Get the size of the global variable. If all else fails (i.e. the global has
   // no type), then we use a size of one to still allow symbolization of the
   // exact address.
   uint64_t GVSize = 1;
-  if (DWARFDie BaseType = Die.getAttributeValueAsReferencedDie(DW_AT_type))
+  if (Die.getAttributeValueAsReferencedDie(DW_AT_type))
     if (std::optional<uint64_t> Size = Die.getTypeSize(getAddressByteSize()))
       GVSize = *Size;
 
   if (Address != UINT64_MAX)
     VariableDieMap[Address] = {Address + GVSize, Die};
 }
 
 DWARFDie DWARFUnit::getVariableForAddress(uint64_t Address) {

llvm/lib/DebugInfo/GSYM/DwarfTransformer.cpp

void DwarfTransformer::handleDie(raw_ostream *OS, CUInfo &CUI, DWARFDie Die) {
   for (DWARFDie ChildDie : Die.children())
     handleDie(OS, CUI, ChildDie);
 }
 
 Error DwarfTransformer::convert(uint32_t NumThreads, raw_ostream *OS) {
   size_t NumBefore = Gsym.getNumFunctionInfos();
   auto getDie = [&](DWARFUnit &DwarfUnit) -> DWARFDie {
     DWARFDie ReturnDie = DwarfUnit.getUnitDIE(false);
-    if (std::optional<uint64_t> DWOId = DwarfUnit.getDWOId()) {
+    if (DwarfUnit.getDWOId()) {
       DWARFUnit *DWOCU = DwarfUnit.getNonSkeletonUnitDIE(false).getDwarfUnit();
       if (OS && !DWOCU->isDWOUnit()) {
         std::string DWOName = dwarf::toString(
             DwarfUnit.getUnitDIE().find(
                 {dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name}),
             "");
         *OS << "warning: Unable to retrieve DWO .debug_info section for "
             << DWOName << "\n";

llvm/lib/IR/PrintPasses.cpp

 std::string llvm::doSystemDiff(StringRef Before, StringRef After,
                                StringRef OldLineFormat, StringRef NewLineFormat,
                                StringRef UnchangedLineFormat) {
   // Store the 2 bodies into temporary files and call diff on them
   // to get the body of the node.
   static SmallVector<int> FD{-1, -1, -1};
   SmallVector<StringRef> SR{Before, After};
   static SmallVector<std::string> FileName{"", "", ""};
-  if (auto Err = prepareTempFiles(FD, SR, FileName))
+  if (prepareTempFiles(FD, SR, FileName))
     return "Unable to create temporary file.";
 
   static ErrorOr<std::string> DiffExe = sys::findProgramByName(DiffBinary);
   if (!DiffExe)
     return "Unable to find diff executable.";
 
   SmallString<128> OLF, NLF, ULF;
   ("--old-line-format=" + OldLineFormat).toVector(OLF);
if (Result < 0)
     return "Error executing system diff.";
   std::string Diff;
   auto B = MemoryBuffer::getFile(FileName[2]);
   if (B && *B)
     Diff = (*B)->getBuffer().str();
   else
     return "Unable to read result.";
 
-  if (auto Err = cleanUpTempFiles(FileName))
+  if (cleanUpTempFiles(FileName))
     return "Unable to remove temporary file.";
 
   return Diff;
 }

llvm/lib/Passes/StandardInstrumentations.cpp

if (TestChanged != "")
     TextChangeReporter<std::string>::registerRequiredCallbacks(PIC);
 }
 
 void IRChangedTester::handleIR(const std::string &S, StringRef PassID) {
   // Store the body into a temporary file
   static SmallVector<int> FD{-1};
   SmallVector<StringRef> SR{S};
   static SmallVector<std::string> FileName{""};
-  if (auto Err = prepareTempFiles(FD, SR, FileName)) {
+  if (prepareTempFiles(FD, SR, FileName)) {
     dbgs() << "Unable to create temporary file.";
     return;
   }
   static ErrorOr<std::string> Exe = sys::findProgramByName(TestChanged);
   if (!Exe) {
     dbgs() << "Unable to find test-changed executable.";
     return;
   }
 
   StringRef Args[] = {TestChanged, FileName[0], PassID};
   int Result = sys::ExecuteAndWait(*Exe, Args);
   if (Result < 0) {
     dbgs() << "Error executing test-changed executable.";
     return;
   }
 
-  if (auto Err = cleanUpTempFiles(FileName))
+  if (cleanUpTempFiles(FileName))
     dbgs() << "Unable to remove temporary file.";
 }
 
 void IRChangedTester::handleInitialIR(Any IR) {
   // Always test the initial module.
   // Unwrap and print directly to avoid filtering problems in general routines.
   std::string S;
   generateIRRepresentation(IR, "Initial IR", S);

llvm/lib/Support/VirtualFileSystem.cpp

RedirectingFileSystem::setCurrentWorkingDirectory(const Twine &Path) {
   return {};
 }
 
 std::error_code RedirectingFileSystem::isLocal(const Twine &Path_,
                                                bool &Result) {
   SmallString<256> Path;
   Path_.toVector(Path);
 
-  if (std::error_code EC = makeCanonical(Path))
+  if (makeCanonical(Path))
     return {};
 
   return ExternalFS->isLocal(Path, Result);
 }
 
 std::error_code RedirectingFileSystem::makeAbsolute(SmallVectorImpl<char> &Path) const {
   // is_absolute(..., Style::windows_*) accepts paths with both slash types.
   if (llvm::sys::path::is_absolute(Path, llvm::sys::path::Style::posix) ||

llvm/tools/llvm-profgen/ProfiledBinary.cpp

if (!DebugContext)
     exitWithError("Error creating the debug info context", Path);
 
   for (const auto &CompilationUnit : DebugContext->compile_units())
     loadSymbolsFromDWARFUnit(*CompilationUnit.get());
 
   // Handles DWO sections that can either be in .o, .dwo or .dwp files.
   for (const auto &CompilationUnit : DebugContext->compile_units()) {
     DWARFUnit *const DwarfUnit = CompilationUnit.get();
-    if (std::optional<uint64_t> DWOId = DwarfUnit->getDWOId()) {
+    if (DwarfUnit->getDWOId()) {
       DWARFUnit *DWOCU = DwarfUnit->getNonSkeletonUnitDIE(false).getDwarfUnit();
       if (!DWOCU->isDWOUnit()) {
         std::string DWOName = dwarf::toString(
             DwarfUnit->getUnitDIE().find(
                 {dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name}),
             "");
         WithColor::warning()
             << "DWO debug information for " << DWOName