[clang-tidy] Fix case of local variables in modernize-use-nodiscard checker

[MyDeveloperDay]

Summary

Correct the case of the local variables..

Rational:
I want to be able to run clang-tidy on new clang-tidy checker code prior to creating a review (to demonstrate we should dog food our own tools during development, not my suggestion but @Eugene.Zelenko)

To this end I am running the following in a script, prior to make a change.

tidy:
    @for source in $$(git status -suno | grep ".cpp$$" | cut -c4-) ;\
    do \
        clang-tidy -quiet  $$source -- $(TIDY_FLAGS);\
    done

I then want to go through the checkers and see which checkers most closely match the review style of the reviewers

---
Checks:          '
-clang-diagnostic-*,
readability-identifier-naming,
llvm-header-guard
'
WarningsAsErrors: ''
HeaderFilterRegex: ''
AnalyzeTemporaryDtors: false
FormatStyle:     LLVM
CheckOptions:
  - key:             readability-identifier-naming.IgnoreFailedSplit
    value:           '0'
  - key:             readability-identifier-naming.VariableCase
    value:           'CamelCase'
  - key:             readability-identifier-naming.LocalVariableCase
    value:           'CamelCase'
...

Unfortunately in doing so, I have identified that my previous review D55433: [clang-tidy] Adding a new modernize use nodiscard checker it violates what looks like to be the convention of local variables being in CamelCase.

Sending this small review in the hope it can be corrected.

[JonasToth]

LGTM.
I am in favour of running clang-tidy on LLVM (i do have a private buildbot doing so, but for testing clang-tidy itself).

Take a look at clang-tidy/utils/run-clang-tidy.py and https://reviews.llvm.org/D54141 for speed up and better error messages, because deduplicated output.

[JonasToth]

+ arc itself has the possibility to run linters, I see running clang-tidy-diff.py as a way to utilize that for the reviews.

[Eugene.Zelenko]

In D56536#1352526, @JonasToth wrote:

LGTM.
I am in favour of running clang-tidy on LLVM (i do have a private buildbot doing so, but for testing clang-tidy itself).

Take a look at clang-tidy/utils/run-clang-tidy.py and https://reviews.llvm.org/D54141 for speed up and better error messages, because deduplicated output.

Yes, run-clang-tidy.py is best way to run Clang-tidy.

By the words, set of Clang-tidy checks that I run for LLVM code base cleanups. Indeed, not all of them are cleaned in same degree.

-checks="-*,clang-diagnostic-extra-semi,bugprone-suspicious-string-compare,misc-unused-using-decls,modernize-deprecated-headers,modernize-redundant-void-arg,modernize-use-auto,modernize-use-bool-literals,modernize-use-default-member-init,modernize-use-equals-default,modernize-use-equals-delete,modernize-use-nullptr,modernize-use-override,modernize-use-using,readability-container-size-empty,readability-redundant-control-flow,readability-redundant-string-cstr,readability-redundant-member-init,readability-simplify-boolean-expr,readability-static-definition-in-anonymous-namespace,readability-redundant-string-init" -config="{CheckOptions: [:+bugprone-suspicious-string-compare.WarnOnLogicalNotComparison+,+value:+'1']}"

clang-tools-extra/trunk/clang-tidy/modernize/UseNodiscardCheck.cpp

 void UseNodiscardCheck::registerMatchers(MatchFinder *Finder) {
   // If we use ``[[nodiscard]]`` attribute, we require at least C++17. Use a
   // macro or ``__attribute__`` with pre c++17 compilers by using
   // ReplacementString option.
   if ((NoDiscardMacro == "[[nodiscard]]" && !getLangOpts().CPlusPlus17) ||
       !getLangOpts().CPlusPlus)
     return;
 
-  auto functionObj =
+  auto FunctionObj =
       cxxRecordDecl(hasAnyName("::std::function", "::boost::function"));
 
   // Find all non-void const methods which have not already been marked to
   // warn on unused result.
   Finder->addMatcher(
       cxxMethodDecl(
           allOf(isConst(), isDefinitionOrInline(),
                 unless(anyOf(
                     returns(voidType()), isNoReturn(), isOverloadedOperator(),
                     isVariadic(), hasTemplateReturnType(),
                     hasClassMutableFields(), isConversionOperator(),
                     hasAttr(clang::attr::WarnUnusedResult),
                     hasType(isInstantiationDependentType()),
                     hasAnyParameter(anyOf(
-                        parmVarDecl(anyOf(hasType(functionObj),
-                                          hasType(references(functionObj)))),
+                        parmVarDecl(anyOf(hasType(FunctionObj),
+                                          hasType(references(FunctionObj)))),
                         hasType(isNonConstReferenceOrPointer()),
                         hasParameterPack()))))))
           .bind("no_discard"),
       this);
 }
 
 void UseNodiscardCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedDecl = Result.Nodes.getNodeAs<CXXMethodDecl>("no_discard");
   // Don't make replacements if the location is invalid or in a macro.
   SourceLocation Loc = MatchedDecl->getLocation();
   if (Loc.isInvalid() || Loc.isMacroID())
     return;
 
-  SourceLocation retLoc = MatchedDecl->getInnerLocStart();
+  SourceLocation RetLoc = MatchedDecl->getInnerLocStart();
 
   ASTContext &Context = *Result.Context;
 
-  auto Diag = diag(retLoc, "function %0 should be marked " + NoDiscardMacro)
+  auto Diag = diag(RetLoc, "function %0 should be marked " + NoDiscardMacro)
               << MatchedDecl;
 
   // Check for the existence of the keyword being used as the ``[[nodiscard]]``.
   if (!doesNoDiscardMacroExist(Context, NoDiscardMacro))
     return;
 
   // Possible false positives include:
   // 1. A const member function which returns a variable which is ignored
   // but performs some external I/O operation and the return value could be
   // ignored.
-  Diag << FixItHint::CreateInsertion(retLoc, NoDiscardMacro + " ");
+  Diag << FixItHint::CreateInsertion(RetLoc, NoDiscardMacro + " ");
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang