clang/unittests/AST/TemplateNameTest.cpp

   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