llvm-project

1
//===--- DirectiveTreeTest.cpp --------------------------------------------===//
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 "clang-pseudo/DirectiveTree.h"
10

11
#include "clang-pseudo/Token.h"
12
#include "clang/Basic/LangOptions.h"
13
#include "clang/Basic/TokenKinds.h"
14
#include "llvm/ADT/StringExtras.h"
15
#include "llvm/ADT/StringRef.h"
16
#include "gmock/gmock.h"
17
#include "gtest/gtest.h"
18

19
namespace clang {
20
namespace pseudo {
21
namespace {
22

23
using testing::_;
24
using testing::ElementsAre;
25
using testing::Matcher;
26
using testing::Pair;
27
using testing::StrEq;
28
using Chunk = DirectiveTree::Chunk;
29

30
// Matches text of a list of tokens against a string (joined with spaces).
31
// e.g. EXPECT_THAT(Stream.tokens(), tokens("int main ( ) { }"));
32
MATCHER_P(tokens, Tokens, "") {
33
  std::vector<llvm::StringRef> Texts;
34
  for (const Token &Tok : arg)
35
    Texts.push_back(Tok.text());
36
  return Matcher<std::string>(StrEq(Tokens))
37
      .MatchAndExplain(llvm::join(Texts, " "), result_listener);
38
}
39

40
// Matches tokens covered a directive chunk (with a Tokens property) against a
41
// string, similar to tokens() above.
42
// e.g. EXPECT_THAT(SomeDirective, tokensAre(Stream, "# include < vector >"));
43
MATCHER_P2(tokensAre, TS, Tokens, "tokens are " + std::string(Tokens)) {
44
  return testing::Matches(tokens(Tokens))(TS.tokens(arg.Tokens));
45
}
46

47
MATCHER(directiveChunk, "") {
48
  return std::holds_alternative<DirectiveTree::Directive>(arg);
49
}
50
MATCHER(codeChunk, "") {
51
  return std::holds_alternative<DirectiveTree::Code>(arg);
52
}
53
MATCHER(conditionalChunk, "") {
54
  return std::holds_alternative<DirectiveTree::Conditional>(arg);
55
}
56

57
TEST(DirectiveTree, Parse) {
58
  LangOptions Opts;
59
  std::string Code = R"cpp(
60
  #include <foo.h>
61

62
  int main() {
63
  #ifdef HAS_FOO
64
  #if HAS_BAR
65
    foo(bar);
66
  #else
67
    foo(0)
68
  #endif
69
  #elif NEEDS_FOO
70
    #error missing_foo
71
  #endif
72
  }
73
  )cpp";
74

75
  TokenStream S = cook(lex(Code, Opts), Opts);
76
  DirectiveTree PP = DirectiveTree::parse(S);
77
  ASSERT_THAT(PP.Chunks, ElementsAre(directiveChunk(), codeChunk(),
78
                                     conditionalChunk(), codeChunk()));
79

80
  EXPECT_THAT(std::get<DirectiveTree::Directive>(PP.Chunks[0]),
81
              tokensAre(S, "# include < foo . h >"));
82
  EXPECT_THAT(std::get<DirectiveTree::Code>(PP.Chunks[1]),
83
              tokensAre(S, "int main ( ) {"));
84
  EXPECT_THAT(std::get<DirectiveTree::Code>(PP.Chunks[3]), tokensAre(S, "}"));
85

86
  const auto &Ifdef = std::get<DirectiveTree::Conditional>(PP.Chunks[2]);
87
  EXPECT_THAT(Ifdef.Branches,
88
              ElementsAre(Pair(tokensAre(S, "# ifdef HAS_FOO"), _),
89
                          Pair(tokensAre(S, "# elif NEEDS_FOO"), _)));
90
  EXPECT_THAT(Ifdef.End, tokensAre(S, "# endif"));
91

92
  const DirectiveTree &HasFoo(Ifdef.Branches[0].second);
93
  const DirectiveTree &NeedsFoo(Ifdef.Branches[1].second);
94

95
  EXPECT_THAT(HasFoo.Chunks, ElementsAre(conditionalChunk()));
96
  const auto &If = std::get<DirectiveTree::Conditional>(HasFoo.Chunks[0]);
97
  EXPECT_THAT(If.Branches, ElementsAre(Pair(tokensAre(S, "# if HAS_BAR"), _),
98
                                       Pair(tokensAre(S, "# else"), _)));
99
  EXPECT_THAT(If.Branches[0].second.Chunks, ElementsAre(codeChunk()));
100
  EXPECT_THAT(If.Branches[1].second.Chunks, ElementsAre(codeChunk()));
101

102
  EXPECT_THAT(NeedsFoo.Chunks, ElementsAre(directiveChunk()));
103
  const auto &Error = std::get<DirectiveTree::Directive>(NeedsFoo.Chunks[0]);
104
  EXPECT_THAT(Error, tokensAre(S, "# error missing_foo"));
105
  EXPECT_EQ(Error.Kind, tok::pp_error);
106
}
107

108
TEST(DirectiveTree, ParseUgly) {
109
  LangOptions Opts;
110
  std::string Code = R"cpp(
111
  /*A*/ # /*B*/ \
112
   /*C*/ \
113
define \
114
BAR /*D*/
115
/*E*/
116
)cpp";
117
  TokenStream S = cook(lex(Code, Opts), Opts);
118
  DirectiveTree PP = DirectiveTree::parse(S);
119

120
  ASSERT_THAT(PP.Chunks,
121
              ElementsAre(codeChunk(), directiveChunk(), codeChunk()));
122
  EXPECT_THAT(std::get<DirectiveTree::Code>(PP.Chunks[0]),
123
              tokensAre(S, "/*A*/"));
124
  const auto &Define = std::get<DirectiveTree::Directive>(PP.Chunks[1]);
125
  EXPECT_EQ(Define.Kind, tok::pp_define);
126
  EXPECT_THAT(Define, tokensAre(S, "# /*B*/ /*C*/ define BAR /*D*/"));
127
  EXPECT_THAT(std::get<DirectiveTree::Code>(PP.Chunks[2]),
128
              tokensAre(S, "/*E*/"));
129
}
130

131
TEST(DirectiveTree, ParseBroken) {
132
  LangOptions Opts;
133
  std::string Code = R"cpp(
134
  a
135
  #endif // mismatched
136
  #if X
137
  b
138
)cpp";
139
  TokenStream S = cook(lex(Code, Opts), Opts);
140
  DirectiveTree PP = DirectiveTree::parse(S);
141

142
  ASSERT_THAT(PP.Chunks,
143
              ElementsAre(codeChunk(), directiveChunk(), conditionalChunk()));
144
  EXPECT_THAT(std::get<DirectiveTree::Code>(PP.Chunks[0]), tokensAre(S, "a"));
145
  const auto &Endif = std::get<DirectiveTree::Directive>(PP.Chunks[1]);
146
  EXPECT_EQ(Endif.Kind, tok::pp_endif);
147
  EXPECT_THAT(Endif, tokensAre(S, "# endif // mismatched"));
148

149
  const auto &X = std::get<DirectiveTree::Conditional>(PP.Chunks[2]);
150
  EXPECT_EQ(1u, X.Branches.size());
151
  // The (only) branch of the broken conditional section runs until eof.
152
  EXPECT_EQ(tok::pp_if, X.Branches.front().first.Kind);
153
  EXPECT_THAT(X.Branches.front().second.Chunks, ElementsAre(codeChunk()));
154
  // The missing terminating directive is marked as pp_not_keyword.
155
  EXPECT_EQ(tok::pp_not_keyword, X.End.Kind);
156
  EXPECT_EQ(0u, X.End.Tokens.size());
157
}
158

159
TEST(DirectiveTree, ChooseBranches) {
160
  LangOptions Opts;
161
  const std::string Cases[] = {
162
      R"cpp(
163
        // Branches with no alternatives are taken
164
        #if COND // TAKEN
165
        int x;
166
        #endif
167
      )cpp",
168

169
      R"cpp(
170
        // Empty branches are better than nothing
171
        #if COND // TAKEN
172
        #endif
173
      )cpp",
174

175
      R"cpp(
176
        // Trivially false branches are not taken, even with no alternatives.
177
        #if 0
178
        int x;
179
        #endif
180
      )cpp",
181

182
      R"cpp(
183
        // Longer branches are preferred over shorter branches
184
        #if COND // TAKEN
185
        int x = 1;
186
        #else
187
        int x;
188
        #endif
189

190
        #if COND
191
        int x;
192
        #else // TAKEN
193
        int x = 1;
194
        #endif
195
      )cpp",
196

197
      R"cpp(
198
        // Trivially true branches are taken if previous branches are trivial.
199
        #if 1 // TAKEN
200
        #else
201
          int x = 1;
202
        #endif
203

204
        #if 0
205
          int x = 1;
206
        #elif 0
207
          int x = 2;
208
        #elif 1 // TAKEN
209
          int x;
210
        #endif
211

212
        #if 0
213
          int x = 1;
214
        #elif FOO // TAKEN
215
          int x = 2;
216
        #elif 1
217
          int x;
218
        #endif
219
      )cpp",
220

221
      R"cpp(
222
        // #else is a trivially true branch
223
        #if 0
224
          int x = 1;
225
        #elif 0
226
          int x = 2;
227
        #else // TAKEN
228
          int x;
229
        #endif
230
      )cpp",
231

232
      R"cpp(
233
        // Directives break ties, but nondirective text is more important.
234
        #if FOO
235
          #define A 1 2 3
236
        #else // TAKEN
237
          #define B 4 5 6
238
          #define C 7 8 9
239
        #endif
240

241
        #if FOO // TAKEN
242
          ;
243
          #define A 1 2 3
244
        #else
245
          #define B 4 5 6
246
          #define C 7 8 9
247
        #endif
248
      )cpp",
249

250
      R"cpp(
251
        // Avoid #error directives.
252
        #if FOO
253
          int x = 42;
254
          #error This branch is no good
255
        #else // TAKEN
256
        #endif
257

258
        #if FOO
259
          // All paths here lead to errors.
260
          int x = 42;
261
          #if 1 // TAKEN
262
            #if COND // TAKEN
263
              #error This branch is no good
264
            #else
265
              #error This one is no good either
266
            #endif
267
          #endif
268
        #else // TAKEN
269
        #endif
270
      )cpp",
271

272
      R"cpp(
273
        // Populate taken branches recursively.
274
        #if FOO // TAKEN
275
          int x = 42;
276
          #if BAR
277
            ;
278
          #else // TAKEN
279
            int y = 43;
280
          #endif
281
        #else
282
          int x;
283
          #if BAR // TAKEN
284
            int y;
285
          #else
286
            ;
287
          #endif
288
        #endif
289
      )cpp",
290
  };
291
  for (const auto &Code : Cases) {
292
    TokenStream S = cook(lex(Code, Opts), Opts);
293

294
    std::function<void(const DirectiveTree &)> Verify =
295
        [&](const DirectiveTree &M) {
296
          for (const auto &C : M.Chunks) {
297
            if (!std::holds_alternative<DirectiveTree::Conditional>(C))
298
              continue;
299
            const DirectiveTree::Conditional &Cond =
300
                std::get<DirectiveTree::Conditional>(C);
301
            for (unsigned I = 0; I < Cond.Branches.size(); ++I) {
302
              auto Directive = S.tokens(Cond.Branches[I].first.Tokens);
303
              EXPECT_EQ(I == Cond.Taken, Directive.back().text() == "// TAKEN")
304
                  << "At line " << Directive.front().Line << " of: " << Code;
305
              Verify(Cond.Branches[I].second);
306
            }
307
          }
308
        };
309

310
    DirectiveTree Tree = DirectiveTree::parse(S);
311
    chooseConditionalBranches(Tree, S);
312
    Verify(Tree);
313
  }
314
}
315

316
TEST(DirectiveTree, StripDirectives) {
317
  LangOptions Opts;
318
  std::string Code = R"cpp(
319
    #include <stddef.h>
320
    a a a
321
    #warning AAA
322
    b b b
323
    #if 1
324
      c c c
325
      #warning BBB
326
      #if 0
327
        d d d
328
        #warning CC
329
      #else
330
        e e e
331
      #endif
332
      f f f
333
      #if 0
334
        g g g
335
      #endif
336
      h h h
337
    #else
338
      i i i
339
    #endif
340
    j j j
341
  )cpp";
342
  TokenStream S = lex(Code, Opts);
343

344
  DirectiveTree Tree = DirectiveTree::parse(S);
345
  chooseConditionalBranches(Tree, S);
346
  EXPECT_THAT(Tree.stripDirectives(S).tokens(),
347
              tokens("a a a b b b c c c e e e f f f h h h j j j"));
348

349
  const DirectiveTree &Part =
350
      std::get<DirectiveTree::Conditional>(Tree.Chunks[4]).Branches[0].second;
351
  EXPECT_THAT(Part.stripDirectives(S).tokens(),
352
              tokens("c c c e e e f f f h h h"));
353
}
354

355
} // namespace
356
} // namespace pseudo
357
} // namespace clang
358