[clangd][nfc] cleanup of remaining clang-tidy findings

[kuhnel]

Summary

There were some left-overs (or new things) from the previous patches.

This will get us down to 0 open findings except:
clang-tidy is complaining in some files about
warning: #includes are not sorted properly [llvm-include-order]
however, clang-format does revert these changes.
It looks like clang-tidy and clang-format disagree there.

Not sure how we can fix that...

[sammccall]

clang-tidy is complaining in some files about

Which files? And which clang-tidy --version vs clang-format --version?
I can take a look

clang-tools-extra/clangd/ConfigYAML.cpp

llvm::Optional<Located<std::string>> scalarValue(Node &N,
     warning(Desc + " should be scalar", N);
     return llvm::None;
   }
 
   llvm::Optional<Located<bool>> boolValue(Node &N, llvm::StringRef Desc) {
     if (auto Scalar = scalarValue(N, Desc)) {
       if (auto Bool = llvm::yaml::parseBool(**Scalar))
         return Located<bool>(*Bool, Scalar->Range);
-      else
-        warning(Desc + " should be a boolean", N);
     }
     return llvm::None;
   }
 
   // Try to parse a list of single scalar values, or just a single value.
   llvm::Optional<std::vector<Located<std::string>>> scalarValues(Node &N) {
     std::vector<Located<std::string>> Result;
     if (auto *S = llvm::dyn_cast<ScalarNode>(&N)) {

clang-tools-extra/clangd/XRefs.cpp

if (const auto *PT = T->getAs<PointerType>())
     return unwrapFindType(PT->getPointeeType());
   if (const auto *RT = T->getAs<ReferenceType>())
     return unwrapFindType(RT->getPointeeType());
   if (const auto *AT = T->getAsArrayTypeUnsafe())
     return unwrapFindType(AT->getElementType());
   // FIXME: use HeuristicResolver to unwrap smart pointers?
 
   // Function type => return type.
-  if (auto FT = T->getAs<FunctionType>())
+  if (auto *FT = T->getAs<FunctionType>())
     return unwrapFindType(FT->getReturnType());
-  if (auto CRD = T->getAsCXXRecordDecl()) {
+  if (auto *CRD = T->getAsCXXRecordDecl()) {
     if (CRD->isLambda())
       return unwrapFindType(CRD->getLambdaCallOperator()->getReturnType());
     // FIXME: more cases we'd prefer the return type of the call operator?
     //        std::function etc?
   }
 
   return T;
 }

clang-tools-extra/clangd/refactor/tweaks/AddUsing.cpp

bool AddUsing::prepare(const Selection &Inputs) {
   // DeclRefExpr.
   for (; Node->Parent; Node = Node->Parent) {
     if (Node->ASTNode.get<NestedNameSpecifierLoc>()) {
       continue;
     }
     if (auto *T = Node->ASTNode.get<TypeLoc>()) {
       if (T->getAs<ElaboratedTypeLoc>()) {
         break;
-      } else if (Node->Parent->ASTNode.get<TypeLoc>() ||
-                 Node->Parent->ASTNode.get<NestedNameSpecifierLoc>()) {
+      }
+      if (Node->Parent->ASTNode.get<TypeLoc>() ||
         // Node is TypeLoc, but it's parent is either TypeLoc or
         // NestedNameSpecifier. In both cases, we want to go up, to find
         // the outermost TypeLoc.
         continue;
       }
     }
     break;
   }

clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp

 using ::testing::AllOf;
 using ::testing::Contains;
 using ::testing::ElementsAre;
 using ::testing::Field;
 using ::testing::IsEmpty;
 using ::testing::Pair;
 using ::testing::SizeIs;
 using ::testing::UnorderedElementsAre;
-using testing::UnorderedElementsAreArray;
 
 ::testing::Matcher<const Diag &> withFix(::testing::Matcher<Fix> FixMatcher) {
   return Field(&Diag::Fixes, ElementsAre(FixMatcher));
 }
 
 ::testing::Matcher<const Diag &> withFix(::testing::Matcher<Fix> FixMatcher1,
                                          ::testing::Matcher<Fix> FixMatcher2) {
   return Field(&Diag::Fixes, UnorderedElementsAre(FixMatcher1, FixMatcher2));