[clang-tidy] Made abseil-upgrade-duration-conversions tests pass on c++17

[jvikstrom]

Summary

Made abseil-upgrade-duration-conversions tests pass on c++17

clang-tools-extra/clang-tidy/abseil/UpgradeDurationConversionsCheck.cpp

Finder->addMatcher(
       cxxOperatorCallExpr(
           argumentCountIs(2),
           hasArgument(
               0, expr(hasType(cxxRecordDecl(hasName("::absl::Duration"))))),
           hasArgument(1, expr().bind("arg")),
           callee(functionDecl(
               hasParent(functionTemplateDecl()),
               unless(hasTemplateArgument(0, refersToType(builtinType()))),
-              hasAnyName("operator*=", "operator/=")))),
+              hasAnyName("operator*=", "operator/="))))
+          .bind("OuterExpr"),
       this);
 
   // Match expressions like `a.operator*=(b)` and `a.operator/=(b)` where `a`
   // has type `absl::Duration` and `b` is not of a built-in type.
   Finder->addMatcher(
       cxxMemberCallExpr(
           callee(cxxMethodDecl(
               ofClass(cxxRecordDecl(hasName("::absl::Duration"))),
               hasParent(functionTemplateDecl()),
               unless(hasTemplateArgument(0, refersToType(builtinType()))),
               hasAnyName("operator*=", "operator/="))),
-          argumentCountIs(1), hasArgument(0, expr().bind("arg"))),
+          argumentCountIs(1), hasArgument(0, expr().bind("arg")))
+          .bind("OuterExpr"),
       this);
 
   // Match expressions like `a * b`, `a / b`, `operator*(a, b)`, and
   // `operator/(a, b)` where `a` has type `absl::Duration` and `b` is not of a
   // built-in type.
   Finder->addMatcher(
       callExpr(callee(functionDecl(
                    hasParent(functionTemplateDecl()),
                    unless(hasTemplateArgument(0, refersToType(builtinType()))),
                    hasAnyName("::absl::operator*", "::absl::operator/"))),
                argumentCountIs(2),
                hasArgument(0, expr(hasType(
                                   cxxRecordDecl(hasName("::absl::Duration"))))),
-               hasArgument(1, expr().bind("arg"))),
+               hasArgument(1, expr().bind("arg")))
+          .bind("OuterExpr"),
       this);
 
   // Match expressions like `a * b` and `operator*(a, b)` where `a` is not of a
   // built-in type and `b` has type `absl::Duration`.
   Finder->addMatcher(
       callExpr(callee(functionDecl(
                    hasParent(functionTemplateDecl()),
                    unless(hasTemplateArgument(0, refersToType(builtinType()))),
                    hasName("::absl::operator*"))),
                argumentCountIs(2), hasArgument(0, expr().bind("arg")),
-               hasArgument(1, expr(hasType(cxxRecordDecl(
-                                  hasName("::absl::Duration")))))),
+               hasArgument(1, expr(hasType(
+                                  cxxRecordDecl(hasName("::absl::Duration"))))))
+          .bind("OuterExpr"),
       this);
 
   // For the factory functions, we match only the non-templated overloads that
   // take an `int64_t` parameter. Within these calls, we care about implicit
   // casts through a user defined conversion to `int64_t`.
   //
   // The factory functions will be updated to be templated and SFINAE on whether
   // the template parameter is an integral type. This complements the already
   // existing templated overloads that only accept floating point types.
 
   // Match calls like:
   //   `absl::Nanoseconds(x)`
   //   `absl::Microseconds(x)`
   //   `absl::Milliseconds(x)`
   //   `absl::Seconds(x)`
   //   `absl::Minutes(x)`
   //   `absl::Hours(x)`
   // where `x` is not of a built-in type.
   Finder->addMatcher(
       implicitCastExpr(
           anyOf(hasCastKind(CK_UserDefinedConversion),
                 has(implicitCastExpr(hasCastKind(CK_UserDefinedConversion)))),
           hasParent(callExpr(
               callee(functionDecl(DurationFactoryFunction(),
                                   unless(hasParent(functionTemplateDecl())))),
-              hasArgument(0, expr().bind("arg"))))),
+              hasArgument(0, expr().bind("arg")))))
+          .bind("OuterExpr"),
       this);
 }
 
 void UpgradeDurationConversionsCheck::check(
     const MatchFinder::MatchResult &Result) {
   const llvm::StringRef Message =
       "implicit conversion to 'int64_t' is deprecated in this context; use an "
       "explicit cast instead";
 
   const auto *ArgExpr = Result.Nodes.getNodeAs<Expr>("arg");
   SourceLocation Loc = ArgExpr->getBeginLoc();
 
-  if (!match(isInTemplateInstantiation(), *ArgExpr, *Result.Context).empty()) {
+  const auto *OuterExpr = Result.Nodes.getNodeAs<Expr>("OuterExpr");
+
+  if (!match(isInTemplateInstantiation(), *OuterExpr, *Result.Context)
+           .empty()) {
     if (MatchedTemplateLocations.count(Loc.getRawEncoding()) == 0) {
       // For each location matched in a template instantiation, we check if the
       // location can also be found in `MatchedTemplateLocations`. If it is not
       // found, that means the expression did not create a match without the
       // instantiation and depends on template parameters. A manual fix is
       // probably required so we provide only a warning.
       diag(Loc, Message);
     }

clang-tools-extra/test/clang-tidy/abseil-upgrade-duration-conversions.cpp

-// RUN: %check_clang_tidy -std=c++11,c++14 %s abseil-upgrade-duration-conversions %t -- -- -I%S/Inputs
+// RUN: %check_clang_tidy -std=c++11-or-later %s abseil-upgrade-duration-conversions %t -- -- -I%S/Inputs
 // FIXME: Fix the checker to work in C++17 mode.
 
 using int64_t = long long;
 
 #include "absl/time/time.h"
 
 template <typename T> struct ConvertibleTo {
   operator T() const;