• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===- unittests/AST/EvaluateAsRValueTest.cpp -----------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // \file
11 // \brief Unit tests for evaluation of constant initializers.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/AST/ASTConsumer.h"
16 #include "clang/AST/ASTConsumer.h"
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/RecursiveASTVisitor.h"
19 #include "clang/Tooling/Tooling.h"
20 #include "gtest/gtest.h"
21 #include <map>
22 #include <string>
23 
24 using namespace clang::tooling;
25 
26 namespace {
27 // For each variable name encountered, whether its initializer was a
28 // constant.
29 typedef std::map<std::string, bool> VarInfoMap;
30 
31 /// \brief Records information on variable initializers to a map.
32 class EvaluateConstantInitializersVisitor
33     : public clang::RecursiveASTVisitor<EvaluateConstantInitializersVisitor> {
34  public:
EvaluateConstantInitializersVisitor(VarInfoMap & VarInfo)35   explicit EvaluateConstantInitializersVisitor(VarInfoMap &VarInfo)
36       : VarInfo(VarInfo) {}
37 
38   /// \brief Checks that isConstantInitializer and EvaluateAsRValue agree
39   /// and don't crash.
40   ///
41   /// For each VarDecl with an initializer this also records in VarInfo
42   /// whether the initializer could be evaluated as a constant.
VisitVarDecl(const clang::VarDecl * VD)43   bool VisitVarDecl(const clang::VarDecl *VD) {
44     if (const clang::Expr *Init = VD->getInit()) {
45       clang::Expr::EvalResult Result;
46       bool WasEvaluated = Init->EvaluateAsRValue(Result, VD->getASTContext());
47       VarInfo[VD->getNameAsString()] = WasEvaluated;
48       EXPECT_EQ(WasEvaluated, Init->isConstantInitializer(VD->getASTContext(),
49                                                           false /*ForRef*/));
50     }
51     return true;
52   }
53 
54  private:
55   VarInfoMap &VarInfo;
56 };
57 
58 class EvaluateConstantInitializersAction : public clang::ASTFrontendAction {
59  public:
60    std::unique_ptr<clang::ASTConsumer>
CreateASTConsumer(clang::CompilerInstance & Compiler,llvm::StringRef FilePath)61    CreateASTConsumer(clang::CompilerInstance &Compiler,
62                      llvm::StringRef FilePath) override {
63      return llvm::make_unique<Consumer>();
64   }
65 
66  private:
67   class Consumer : public clang::ASTConsumer {
68    public:
~Consumer()69     ~Consumer() override {}
70 
HandleTranslationUnit(clang::ASTContext & Ctx)71     void HandleTranslationUnit(clang::ASTContext &Ctx) override {
72       VarInfoMap VarInfo;
73       EvaluateConstantInitializersVisitor Evaluator(VarInfo);
74       Evaluator.TraverseDecl(Ctx.getTranslationUnitDecl());
75       EXPECT_EQ(2u, VarInfo.size());
76       EXPECT_FALSE(VarInfo["Dependent"]);
77       EXPECT_TRUE(VarInfo["Constant"]);
78       EXPECT_EQ(2u, VarInfo.size());
79     }
80   };
81 };
82 }
83 
TEST(EvaluateAsRValue,FailsGracefullyForUnknownTypes)84 TEST(EvaluateAsRValue, FailsGracefullyForUnknownTypes) {
85   // This is a regression test; the AST library used to trigger assertion
86   // failures because it assumed that the type of initializers was always
87   // known (which is true only after template instantiation).
88   std::string ModesToTest[] = {"-std=c++03", "-std=c++11", "-std=c++1y"};
89   for (std::string const &Mode : ModesToTest) {
90     std::vector<std::string> Args(1, Mode);
91     Args.push_back("-fno-delayed-template-parsing");
92     ASSERT_TRUE(runToolOnCodeWithArgs(
93       new EvaluateConstantInitializersAction(),
94       "template <typename T>"
95       "struct vector {"
96       "  explicit vector(int size);"
97       "};"
98       "template <typename R>"
99       "struct S {"
100       "  vector<R> intervals() const {"
101       "    vector<R> Dependent(2);"
102       "    return Dependent;"
103       "  }"
104       "};"
105       "void doSomething() {"
106       "  int Constant = 2 + 2;"
107       "  (void) Constant;"
108       "}",
109       Args));
110   }
111 }
112