rm not needed typeofstr match kind

Author: 5chmidti

clang/include/clang/ASTMatchers/ASTMatchers.h

@@ -1588,10 +1588,10 @@ extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXConversionDecl>
 ///
 /// The matcher \matcher{cxxDeductionGuideDecl()}
 /// matches the written deduction guide
-/// \match{type=typeofstr$auto (int) -> X<int>},
-/// the implicit copy deduction guide \match{type=typeofstr$auto (int) -> X<T>}
+/// \match{type=typestr$auto (int) -> X<int>},
+/// the implicit copy deduction guide \match{type=typestr$auto (int) -> X<T>}
 /// and the implicitly declared deduction guide
-/// \match{type=typeofstr$auto (X<T>) -> X<T>}.
+/// \match{type=typestr$auto (X<T>) -> X<T>}.
 extern const internal::VariadicDynCastAllOfMatcher<Decl, CXXDeductionGuideDecl>
     cxxDeductionGuideDecl;
 
@@ -10116,7 +10116,7 @@ AST_MATCHER(CXXConstructorDecl, isDelegatingConstructor) {
 /// The matcher \matcher{cxxDeductionGuideDecl(isExplicit())}
 /// matches the deduction guide \match{explicit S(double) -> S<false>},
 /// the implicit copy deduction candiate
-/// \match{type=typeofstr$auto (double) -> S<b>} and
+/// \match{type=typestr$auto (double) -> S<b>} and
 /// the implicitly generated deduction guide for \match{explicit(true) S(char)},
 /// but does not match \nomatch{S(int) -> S<true>}.
 AST_POLYMORPHIC_MATCHER(isExplicit, AST_POLYMORPHIC_SUPPORTED_TYPES(
@@ -10156,7 +10156,7 @@ AST_POLYMORPHIC_MATCHER(isExplicit, AST_POLYMORPHIC_SUPPORTED_TYPES(
 /// The matcher
 /// \matcher{cxxDeductionGuideDecl(hasExplicitSpecifier(declRefExpr()))}
 /// matches the implicitly generated deduction guide
-/// \match{type=typeofstr$auto (float) -> S<b>} of the constructor
+/// \match{type=typestr$auto (float) -> S<b>} of the constructor
 /// \c{explicit(b) S(float)}.
 AST_MATCHER_P(FunctionDecl, hasExplicitSpecifier, internal::Matcher<Expr>,
               InnerMatcher) {

clang/unittests/ASTMatchers/ASTMatchersTest.h

@@ -596,7 +596,6 @@ enum class MatchKind {
   Code,
   Name,
   TypeStr,
-  TypeOfStr,
 };
 
 inline llvm::StringRef toString(const MatchKind Kind) {
@@ -607,8 +606,6 @@ inline llvm::StringRef toString(const MatchKind Kind) {
     return "Name";
   case MatchKind::TypeStr:
     return "TypeStr";
-  case MatchKind::TypeOfStr:
-    return "TypeOfStr";
   }
   llvm_unreachable("Unhandled MatchKind");
 }
@@ -651,8 +648,6 @@ template <typename T> class VerifyBoundNodeMatch : public BoundNodesCallback {
         return getNameText(Node, EmitFailures);
       case MatchKind::TypeStr:
         return getTypeStrText(Node, EmitFailures);
-      case MatchKind::TypeOfStr:
-        return getTypeOfStrText(Node, EmitFailures);
       }
     }
 
@@ -695,27 +690,14 @@ template <typename T> class VerifyBoundNodeMatch : public BoundNodesCallback {
     getTypeStrText(const U *const Node, const bool EmitFailures = true) {
       if constexpr (std::is_base_of_v<Type, U>)
         return QualType(Node, 0).getAsString();
-      if constexpr (std::is_base_of_v<Decl, U>)
+      if constexpr (std::is_base_of_v<Decl, U>) {
         if (const auto *const TDecl = llvm::dyn_cast<TypeDecl>(Node))
           return getTypeStrText(TDecl->getTypeForDecl());
-
-      if (EmitFailures)
-        ADD_FAILURE() << "Match kind is 'TypeStr', but node of type 'U' is "
-                         "not handled.";
-      return std::nullopt;
-    }
-
-    template <typename U>
-    static std::optional<std::string>
-    getTypeOfStrText(const U *const Node, const bool EmitFailures = true) {
-      if constexpr (std::is_base_of_v<Decl, U>) {
         if (const auto *const VDecl = llvm::dyn_cast<ValueDecl>(Node))
           return VDecl->getType().getAsString();
-      } else if constexpr (std::is_base_of_v<Expr, U>)
-        return Node->getType().getAsString();
-
+      }
       if (EmitFailures)
-        ADD_FAILURE() << "Match kind is 'TypeOfStr', but node of type 'U' is "
+        ADD_FAILURE() << "Match kind is 'TypeStr', but node of type 'U' is "
                          "not handled.";
       return std::nullopt;
     }
@@ -823,8 +805,8 @@ template <typename T> class VerifyBoundNodeMatch : public BoundNodesCallback {
   static std::string getPossibleMatchStrings(const T *Node,
                                              const ASTContext &Context) {
     std::string MatchStrings{"\n"};
-    for (const auto Kind : {MatchKind::Code, MatchKind::Name,
-                            MatchKind::TypeStr, MatchKind::TypeOfStr})
+    for (const auto Kind :
+         {MatchKind::Code, MatchKind::Name, MatchKind::TypeStr})
       MatchStrings +=
           llvm::formatv("\tMatchKind:  {0}: '{1}',\n", toString(Kind),
                         Match::getMatchText(Node, Context, Kind, false)

clang/utils/generate_ast_matcher_doc_tests.py

@@ -496,15 +496,12 @@ class MatchType(Enum):
         Name: Use the name of the matched node to check if it matches
         TypeStr: Use the string representation of the matched type to check if
                  it matches
-        TypeOfStr: Use the string representation of the type of a matched node
-                   to check if it matches
     """
 
     Invalid = 0
     Code = 1
     Name = 2
     TypeStr = 3
-    TypeOfStr = 4
 
 
 def get_match_type(match: Match) -> MatchType:
@@ -515,9 +512,7 @@ def get_match_type(match: Match) -> MatchType:
         return MatchType.Code
     if match_type == "typestr":
         return MatchType.TypeStr
-    if match_type == "typeofstr":
-        return MatchType.TypeOfStr
-    print(f"match {match} has an invalid match type, tags: {match.tags}")
+    print(f"match {match} has an invalid match type: {match_type}")
     statistics["match_type_invalid"] += 1
     return MatchType.Invalid