[ASTMatchers] add matcher for decltypeType and its underlyingType

[JonasToth]

Summary

This patch introduces a new matcher for DecltypeType and its underlying type
in order to fix a bug in clang-tidy, see https://reviews.llvm.org/D48717 for more.

[alexfh]

Please add a test.

[aaron.ballman]

Once this goes in, you can also update TrailingReturnTypeCheck.cpp to remove its local instance of this type matcher.

lib/ASTMatchers/Dynamic/Registry.cpp

137

Please keep this list sorted in alphabetical order.

[JonasToth]

• [Misc] add test and more doc
• Merge branch 'master' into matcher_decltypetype

[aaron.ballman]

LGTM!

[JonasToth]

• rebase to master

include/clang/ASTMatchers/ASTMatchers.h

 ///   auto n = 4;
 ///   int v[] = { 2, 3 }
 ///   for (auto i : v) { }
 /// \endcode
 /// autoType()
 ///   matches "auto n" and "auto i"
 extern const AstTypeMatcher<AutoType> autoType;
 
+/// Matches types nodes representing C++11 decltype(<expr>) types.
+///
+/// Given:
+/// \code
+///   short i = 1;
+///   int j = 42;
+///   decltype(i + j) result = i + j;
+/// \endcode
+/// decltypeType() 
+///   matches "decltype(i + j)"
+extern const AstTypeMatcher<DecltypeType> decltypeType;
+
 /// Matches \c AutoType nodes where the deduced type is a specific type.
 ///
 /// Note: There is no \c TypeLoc for the deduced type and thus no
 /// \c getDeducedLoc() matcher.
 ///
 /// Given
 /// \code
 ///   auto a = 1;
 ///   auto b = 2.0;
 /// \endcode
 /// autoType(hasDeducedType(isInteger()))
 ///   matches "auto a"
 ///
 /// Usable as: Matcher<AutoType>
 AST_TYPE_TRAVERSE_MATCHER(hasDeducedType, getDeducedType,
                           AST_POLYMORPHIC_SUPPORTED_TYPES(AutoType));
 
+/// Matches \c DecltypeType nodes to find out the underlying type.
+AST_TYPE_TRAVERSE_MATCHER(hasUnderlyingType, getUnderlyingType,
+                          AST_POLYMORPHIC_SUPPORTED_TYPES(DecltypeType));
+
 /// Matches \c FunctionType nodes.
 ///
 /// Given
 /// \code
 ///   int (*f)(int);
 ///   void g();
 /// \endcode
 /// functionType()

lib/ASTMatchers/ASTMatchersInternal.cpp

 const AstTypeMatcher<ArrayType> arrayType;
 const AstTypeMatcher<ComplexType> complexType;
 const AstTypeMatcher<ConstantArrayType> constantArrayType;
 const AstTypeMatcher<DependentSizedArrayType> dependentSizedArrayType;
 const AstTypeMatcher<IncompleteArrayType> incompleteArrayType;
 const AstTypeMatcher<VariableArrayType> variableArrayType;
 const AstTypeMatcher<AtomicType> atomicType;
 const AstTypeMatcher<AutoType> autoType;
+const AstTypeMatcher<DecltypeType> decltypeType;
 const AstTypeMatcher<FunctionType> functionType;
 const AstTypeMatcher<FunctionProtoType> functionProtoType;
 const AstTypeMatcher<ParenType> parenType;
 const AstTypeMatcher<BlockPointerType> blockPointerType;
 const AstTypeMatcher<MemberPointerType> memberPointerType;
 const AstTypeMatcher<PointerType> pointerType;
 const AstTypeMatcher<ObjCObjectPointerType> objcObjectPointerType;
 const AstTypeMatcher<ReferenceType> referenceType;

lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(argumentCountIs);
   REGISTER_MATCHER(arraySubscriptExpr);
   REGISTER_MATCHER(arrayType);
   REGISTER_MATCHER(asmStmt);
   REGISTER_MATCHER(asString);
   REGISTER_MATCHER(atomicExpr);
   REGISTER_MATCHER(atomicType);
   REGISTER_MATCHER(autoType);
+  REGISTER_MATCHER(decltypeType);
   REGISTER_MATCHER(binaryOperator);
   REGISTER_MATCHER(binaryConditionalOperator);
   REGISTER_MATCHER(blockDecl);
   REGISTER_MATCHER(blockPointerType);
   REGISTER_MATCHER(booleanType);
   REGISTER_MATCHER(breakStmt);
   REGISTER_MATCHER(builtinType);
   REGISTER_MATCHER(callExpr);