return true;
}
+ bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc &TL) {
+ // TemplateTypeParmTypeLoc does not have a TagDecl in its type ptr.
+ addToken(TL.getBeginLoc(), TL.getDecl());
+ return true;
+ }
+
+ bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc &TL) {
+ if (const TemplateDecl *TD =
+ TL.getTypePtr()->getTemplateName().getAsTemplateDecl())
+ addToken(TL.getBeginLoc(), TD);
+ return true;
+ }
+
bool VisitTypeLoc(TypeLoc &TL) {
// This check is for not getting two entries when there are anonymous
// structs. It also makes us not highlight certain namespace qualifiers
// We highlight class decls, constructor decls and destructor decls as
// `Class` type. The destructor decls are handled in `VisitTypeLoc` (we will
// visit a TypeLoc where the underlying Type is a CXXRecordDecl).
+ if (isa<ClassTemplateDecl>(D)) {
+ addToken(Loc, HighlightingKind::Class);
+ return;
+ }
if (isa<RecordDecl>(D)) {
addToken(Loc, HighlightingKind::Class);
return;
addToken(Loc, HighlightingKind::Namespace);
return;
}
+ if (isa<TemplateTemplateParmDecl>(D)) {
+ addToken(Loc, HighlightingKind::TemplateParameter);
+ return;
+ }
+ if (isa<TemplateTypeParmDecl>(D)) {
+ addToken(Loc, HighlightingKind::TemplateParameter);
+ return;
+ }
}
void addToken(SourceLocation Loc, HighlightingKind Kind) {
return "variable.other.enummember.cpp";
case HighlightingKind::Namespace:
return "entity.name.namespace.cpp";
+ case HighlightingKind::TemplateParameter:
+ return "entity.name.type.template.cpp";
case HighlightingKind::NumKinds:
llvm_unreachable("must not pass NumKinds to the function");
}
{HighlightingKind::Namespace, "Namespace"},
{HighlightingKind::EnumConstant, "EnumConstant"},
{HighlightingKind::Field, "Field"},
- {HighlightingKind::Method, "Method"}};
+ {HighlightingKind::Method, "Method"},
+ {HighlightingKind::TemplateParameter, "TemplateParameter"}};
std::vector<HighlightingToken> ExpectedTokens;
for (const auto &KindString : KindToString) {
std::vector<HighlightingToken> Toks = makeHighlightingTokens(
)cpp",
R"cpp(
namespace $Namespace[[abc]] {
- template<typename T>
+ template<typename $TemplateParameter[[T]]>
struct $Class[[A]] {
- T $Field[[t]];
+ $TemplateParameter[[T]] $Field[[t]];
};
}
- template<typename T>
- struct $Class[[C]] : $Namespace[[abc]]::A<T> {
- typename T::A* $Field[[D]];
+ template<typename $TemplateParameter[[T]]>
+ struct $Class[[C]] : $Namespace[[abc]]::$Class[[A]]<$TemplateParameter[[T]]> {
+ typename $TemplateParameter[[T]]::A* $Field[[D]];
};
$Namespace[[abc]]::$Class[[A]]<int> $Variable[[AA]];
typedef $Namespace[[abc]]::$Class[[A]]<int> $Class[[AAA]];
using $Enum[[CD]] = $Enum[[CC]];
$Enum[[CC]] $Function[[f]]($Class[[B]]);
$Enum[[CD]] $Function[[f]]($Class[[BB]]);
+ )cpp",
+ R"cpp(
+ template<typename $TemplateParameter[[T]], typename = void>
+ class $Class[[A]] {
+ $TemplateParameter[[T]] $Field[[AA]];
+ $TemplateParameter[[T]] $Method[[foo]]();
+ };
+ template<class $TemplateParameter[[TT]]>
+ class $Class[[B]] {
+ $Class[[A]]<$TemplateParameter[[TT]]> $Field[[AA]];
+ };
+ template<class $TemplateParameter[[TT]], class $TemplateParameter[[GG]]>
+ class $Class[[BB]] {};
+ template<class $TemplateParameter[[T]]>
+ class $Class[[BB]]<$TemplateParameter[[T]], int> {};
+ template<class $TemplateParameter[[T]]>
+ class $Class[[BB]]<$TemplateParameter[[T]], $TemplateParameter[[T]]*> {};
+
+ template<template<class> class $TemplateParameter[[T]], class $TemplateParameter[[C]]>
+ $TemplateParameter[[T]]<$TemplateParameter[[C]]> $Function[[f]]();
+
+ template<typename>
+ class $Class[[Foo]] {};
+
+ template<typename $TemplateParameter[[T]]>
+ void $Function[[foo]]($TemplateParameter[[T]] ...);
)cpp"};
for (const auto &TestCase : TestCases) {
checkHighlightings(TestCase);