1 //===- unittests/AST/TemplateNameTest.cpp --- Tests for TemplateName ------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "ASTPrint.h"
10 #include "clang/AST/ASTContext.h"
11 #include "clang/ASTMatchers/ASTMatchers.h"
12 #include "llvm/Support/raw_ostream.h"
13 #include "gtest/gtest.h"
14 
15 namespace clang {
16 namespace {
17 using namespace ast_matchers;
18 
19 std::string printTemplateName(TemplateName TN, const PrintingPolicy &Policy,
20                               TemplateName::Qualified Qual) {
21   std::string Result;
22   llvm::raw_string_ostream Out(Result);
23   TN.print(Out, Policy, Qual);
24   return Out.str();
25 }
26 
27 TEST(TemplateName, PrintUsingTemplate) {
28   std::string Code = R"cpp(
29     namespace std {
30       template <typename> struct vector {};
31     }
32     namespace absl { using std::vector; }
33 
34     template<template <typename> class T> class X;
35 
36     using absl::vector;
37     using A = X<vector>;
38   )cpp";
39   auto AST = tooling::buildASTFromCode(Code);
40   ASTContext &Ctx = AST->getASTContext();
41   // Match the template argument vector in X<vector>.
42   auto MatchResults = match(templateArgumentLoc().bind("id"), Ctx);
43   const auto *Template = selectFirst<TemplateArgumentLoc>("id", MatchResults);
44   ASSERT_TRUE(Template);
45 
46   TemplateName TN = Template->getArgument().getAsTemplate();
47   EXPECT_EQ(TN.getKind(), TemplateName::UsingTemplate);
48   EXPECT_EQ(TN.getAsUsingShadowDecl()->getTargetDecl(), TN.getAsTemplateDecl());
49 
50   EXPECT_EQ(printTemplateName(TN, Ctx.getPrintingPolicy(),
51                               TemplateName::Qualified::Fully),
52             "std::vector");
53   EXPECT_EQ(printTemplateName(TN, Ctx.getPrintingPolicy(),
54                               TemplateName::Qualified::AsWritten),
55             "vector");
56   EXPECT_EQ(printTemplateName(TN, Ctx.getPrintingPolicy(),
57                               TemplateName::Qualified::None),
58             "vector");
59 }
60 
61 TEST(TemplateName, QualifiedUsingTemplate) {
62   std::string Code = R"cpp(
63     namespace std {
64       template <typename> struct vector {};
65     }
66     namespace absl { using std::vector; }
67 
68     template<template <typename> class T> class X;
69 
70     using A = X<absl::vector>; // QualifiedTemplateName in a template argument.
71   )cpp";
72   auto AST = tooling::buildASTFromCode(Code);
73   // Match the template argument absl::vector in X<absl::vector>.
74   auto Matcher = templateArgumentLoc().bind("id");
75   auto MatchResults = match(Matcher, AST->getASTContext());
76   const auto *TAL = MatchResults.front().getNodeAs<TemplateArgumentLoc>("id");
77   ASSERT_TRUE(TAL);
78   TemplateName TN = TAL->getArgument().getAsTemplate();
79   EXPECT_EQ(TN.getKind(), TemplateName::QualifiedTemplate);
80   const auto *QTN = TN.getAsQualifiedTemplateName();
81   // Verify that we have the Using template name in the QualifiedTemplateName.
82   const auto *USD = QTN->getUnderlyingTemplate().getAsUsingShadowDecl();
83   EXPECT_TRUE(USD);
84   EXPECT_EQ(USD->getTargetDecl(), TN.getAsTemplateDecl());
85   EXPECT_EQ(TN.getAsUsingShadowDecl(), USD);
86 }
87 
88 TEST(TemplateName, UsingTemplate) {
89   auto AST = tooling::buildASTFromCode(R"cpp(
90     namespace std {
91       template <typename T> struct vector { vector(T); };
92     }
93     namespace absl { using std::vector; }
94     // The "absl::vector<int>" is an elaborated TemplateSpecializationType with
95     // an inner Using TemplateName (not a Qualified TemplateName, the qualifiers
96     // are rather part of the ElaboratedType)!
97     absl::vector<int> v(123);
98   )cpp");
99   auto Matcher = elaboratedTypeLoc(
100       hasNamedTypeLoc(loc(templateSpecializationType().bind("id"))));
101   auto MatchResults = match(Matcher, AST->getASTContext());
102   const auto *TST =
103       MatchResults.front().getNodeAs<TemplateSpecializationType>("id");
104   ASSERT_TRUE(TST);
105   EXPECT_EQ(TST->getTemplateName().getKind(), TemplateName::UsingTemplate);
106 
107   AST = tooling::buildASTFromCodeWithArgs(R"cpp(
108     namespace std {
109       template <typename T> struct vector { vector(T); };
110     }
111     namespace absl { using std::vector; }
112     // Similiar to the TemplateSpecializationType, absl::vector is an elaborated
113     // DeducedTemplateSpecializationType with an inner Using TemplateName!
114     absl::vector DTST(123);
115     )cpp",
116                                           {"-std=c++17"});
117   Matcher = elaboratedTypeLoc(
118       hasNamedTypeLoc(loc(deducedTemplateSpecializationType().bind("id"))));
119   MatchResults = match(Matcher, AST->getASTContext());
120   const auto *DTST =
121       MatchResults.front().getNodeAs<DeducedTemplateSpecializationType>("id");
122   ASSERT_TRUE(DTST);
123   EXPECT_EQ(DTST->getTemplateName().getKind(), TemplateName::UsingTemplate);
124 }
125 
126 } // namespace
127 } // namespace clang
128