Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/Lex/PPCallbacks.h
Line
Count
Source (jump to first uncovered line)
1
//===--- PPCallbacks.h - Callbacks for Preprocessor actions -----*- C++ -*-===//
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
/// \file
10
/// Defines the PPCallbacks interface.
11
///
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_CLANG_LEX_PPCALLBACKS_H
15
#define LLVM_CLANG_LEX_PPCALLBACKS_H
16
17
#include "clang/Basic/DiagnosticIDs.h"
18
#include "clang/Basic/SourceLocation.h"
19
#include "clang/Basic/SourceManager.h"
20
#include "clang/Lex/ModuleLoader.h"
21
#include "clang/Lex/Pragma.h"
22
#include "llvm/ADT/StringRef.h"
23
24
namespace clang {
25
  class Token;
26
  class IdentifierInfo;
27
  class MacroDefinition;
28
  class MacroDirective;
29
  class MacroArgs;
30
31
/// This interface provides a way to observe the actions of the
32
/// preprocessor as it does its thing.
33
///
34
/// Clients can define their hooks here to implement preprocessor level tools.
35
class PPCallbacks {
36
public:
37
  virtual ~PPCallbacks();
38
39
  enum FileChangeReason {
40
    EnterFile, ExitFile, SystemHeaderPragma, RenameFile
41
  };
42
43
  /// Callback invoked whenever a source file is entered or exited.
44
  ///
45
  /// \param Loc Indicates the new location.
46
  /// \param PrevFID the file that was exited if \p Reason is ExitFile.
47
  virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
48
                           SrcMgr::CharacteristicKind FileType,
49
46.9k
                           FileID PrevFID = FileID()) {
50
46.9k
  }
51
52
  /// Callback invoked whenever a source file is skipped as the result
53
  /// of header guard optimization.
54
  ///
55
  /// \param SkippedFile The file that is skipped instead of entering \#include
56
  ///
57
  /// \param FilenameTok The file name token in \#include "FileName" directive
58
  /// or macro expanded file name token from \#include MACRO(PARAMS) directive.
59
  /// Note that FilenameTok contains corresponding quotes/angles symbols.
60
  virtual void FileSkipped(const FileEntry &SkippedFile,
61
                           const Token &FilenameTok,
62
519k
                           SrcMgr::CharacteristicKind FileType) {
63
519k
  }
64
65
  /// Callback invoked whenever an inclusion directive results in a
66
  /// file-not-found error.
67
  ///
68
  /// \param FileName The name of the file being included, as written in the
69
  /// source code.
70
  ///
71
  /// \param RecoveryPath If this client indicates that it can recover from
72
  /// this missing file, the client should set this as an additional header
73
  /// search patch.
74
  ///
75
  /// \returns true to indicate that the preprocessor should attempt to recover
76
  /// by adding \p RecoveryPath as a header search path.
77
  virtual bool FileNotFound(StringRef FileName,
78
125
                            SmallVectorImpl<char> &RecoveryPath) {
79
125
    return false;
80
125
  }
81
82
  /// Callback invoked whenever an inclusion directive of
83
  /// any kind (\c \#include, \c \#import, etc.) has been processed, regardless
84
  /// of whether the inclusion will actually result in an inclusion.
85
  ///
86
  /// \param HashLoc The location of the '#' that starts the inclusion
87
  /// directive.
88
  ///
89
  /// \param IncludeTok The token that indicates the kind of inclusion
90
  /// directive, e.g., 'include' or 'import'.
91
  ///
92
  /// \param FileName The name of the file being included, as written in the
93
  /// source code.
94
  ///
95
  /// \param IsAngled Whether the file name was enclosed in angle brackets;
96
  /// otherwise, it was enclosed in quotes.
97
  ///
98
  /// \param FilenameRange The character range of the quotes or angle brackets
99
  /// for the written file name.
100
  ///
101
  /// \param File The actual file that may be included by this inclusion
102
  /// directive.
103
  ///
104
  /// \param SearchPath Contains the search path which was used to find the file
105
  /// in the file system. If the file was found via an absolute include path,
106
  /// SearchPath will be empty. For framework includes, the SearchPath and
107
  /// RelativePath will be split up. For example, if an include of "Some/Some.h"
108
  /// is found via the framework path
109
  /// "path/to/Frameworks/Some.framework/Headers/Some.h", SearchPath will be
110
  /// "path/to/Frameworks/Some.framework/Headers" and RelativePath will be
111
  /// "Some.h".
112
  ///
113
  /// \param RelativePath The path relative to SearchPath, at which the include
114
  /// file was found. This is equal to FileName except for framework includes.
115
  ///
116
  /// \param Imported The module, whenever an inclusion directive was
117
  /// automatically turned into a module import or null otherwise.
118
  ///
119
  /// \param FileType The characteristic kind, indicates whether a file or
120
  /// directory holds normal user code, system code, or system code which is
121
  /// implicitly 'extern "C"' in C++ mode.
122
  ///
123
  virtual void InclusionDirective(SourceLocation HashLoc,
124
                                  const Token &IncludeTok,
125
                                  StringRef FileName,
126
                                  bool IsAngled,
127
                                  CharSourceRange FilenameRange,
128
                                  const FileEntry *File,
129
                                  StringRef SearchPath,
130
                                  StringRef RelativePath,
131
                                  const Module *Imported,
132
999k
                                  SrcMgr::CharacteristicKind FileType) {
133
999k
  }
134
135
  /// Callback invoked whenever a submodule was entered.
136
  ///
137
  /// \param M The submodule we have entered.
138
  ///
139
  /// \param ImportLoc The location of import directive token.
140
  ///
141
  /// \param ForPragma If entering from pragma directive.
142
  ///
143
  virtual void EnteredSubmodule(Module *M, SourceLocation ImportLoc,
144
3.02k
                                bool ForPragma) { }
145
146
  /// Callback invoked whenever a submodule was left.
147
  ///
148
  /// \param M The submodule we have left.
149
  ///
150
  /// \param ImportLoc The location of import directive token.
151
  ///
152
  /// \param ForPragma If entering from pragma directive.
153
  ///
154
  virtual void LeftSubmodule(Module *M, SourceLocation ImportLoc,
155
3.02k
                             bool ForPragma) { }
156
157
  /// Callback invoked whenever there was an explicit module-import
158
  /// syntax.
159
  ///
160
  /// \param ImportLoc The location of import directive token.
161
  ///
162
  /// \param Path The identifiers (and their locations) of the module
163
  /// "path", e.g., "std.vector" would be split into "std" and "vector".
164
  ///
165
  /// \param Imported The imported module; can be null if importing failed.
166
  ///
167
  virtual void moduleImport(SourceLocation ImportLoc,
168
                            ModuleIdPath Path,
169
1.13k
                            const Module *Imported) {
170
1.13k
  }
171
172
  /// Callback invoked when the end of the main file is reached.
173
  ///
174
  /// No subsequent callbacks will be made.
175
50.3k
  virtual void EndOfMainFile() {
176
50.3k
  }
177
178
  /// Callback invoked when a \#ident or \#sccs directive is read.
179
  /// \param Loc The location of the directive.
180
  /// \param str The text of the directive.
181
  ///
182
1
  virtual void Ident(SourceLocation Loc, StringRef str) {
183
1
  }
184
185
  /// Callback invoked when start reading any pragma directive.
186
  virtual void PragmaDirective(SourceLocation Loc,
187
405k
                               PragmaIntroducerKind Introducer) {
188
405k
  }
189
190
  /// Callback invoked when a \#pragma comment directive is read.
191
  virtual void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind,
192
52
                             StringRef Str) {
193
52
  }
194
195
  /// Callback invoked when a \#pragma detect_mismatch directive is
196
  /// read.
197
  virtual void PragmaDetectMismatch(SourceLocation Loc, StringRef Name,
198
10
                                    StringRef Value) {
199
10
  }
200
201
  /// Callback invoked when a \#pragma clang __debug directive is read.
202
  /// \param Loc The location of the debug directive.
203
  /// \param DebugType The identifier following __debug.
204
109
  virtual void PragmaDebug(SourceLocation Loc, StringRef DebugType) {
205
109
  }
206
207
  /// Determines the kind of \#pragma invoking a call to PragmaMessage.
208
  enum PragmaMessageKind {
209
    /// \#pragma message has been invoked.
210
    PMK_Message,
211
212
    /// \#pragma GCC warning has been invoked.
213
    PMK_Warning,
214
215
    /// \#pragma GCC error has been invoked.
216
    PMK_Error
217
  };
218
219
  /// Callback invoked when a \#pragma message directive is read.
220
  /// \param Loc The location of the message directive.
221
  /// \param Namespace The namespace of the message directive.
222
  /// \param Kind The type of the message directive.
223
  /// \param Str The text of the message directive.
224
  virtual void PragmaMessage(SourceLocation Loc, StringRef Namespace,
225
15
                             PragmaMessageKind Kind, StringRef Str) {
226
15
  }
227
228
  /// Callback invoked when a \#pragma gcc diagnostic push directive
229
  /// is read.
230
  virtual void PragmaDiagnosticPush(SourceLocation Loc,
231
393
                                    StringRef Namespace) {
232
393
  }
233
234
  /// Callback invoked when a \#pragma gcc diagnostic pop directive
235
  /// is read.
236
  virtual void PragmaDiagnosticPop(SourceLocation Loc,
237
391
                                   StringRef Namespace) {
238
391
  }
239
240
  /// Callback invoked when a \#pragma gcc diagnostic directive is read.
241
  virtual void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace,
242
494
                                diag::Severity mapping, StringRef Str) {}
243
244
  /// Called when an OpenCL extension is either disabled or
245
  /// enabled with a pragma.
246
  virtual void PragmaOpenCLExtension(SourceLocation NameLoc,
247
                                     const IdentifierInfo *Name,
248
2.30k
                                     SourceLocation StateLoc, unsigned State) {
249
2.30k
  }
250
251
  /// Callback invoked when a \#pragma warning directive is read.
252
  virtual void PragmaWarning(SourceLocation Loc, StringRef WarningSpec,
253
12
                             ArrayRef<int> Ids) {
254
12
  }
255
256
  /// Callback invoked when a \#pragma warning(push) directive is read.
257
7
  virtual void PragmaWarningPush(SourceLocation Loc, int Level) {
258
7
  }
259
260
  /// Callback invoked when a \#pragma warning(pop) directive is read.
261
4
  virtual void PragmaWarningPop(SourceLocation Loc) {
262
4
  }
263
264
  /// Callback invoked when a \#pragma execution_character_set(push) directive
265
  /// is read.
266
4
  virtual void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) {}
267
268
  /// Callback invoked when a \#pragma execution_character_set(pop) directive
269
  /// is read.
270
3
  virtual void PragmaExecCharsetPop(SourceLocation Loc) {}
271
272
  /// Callback invoked when a \#pragma clang assume_nonnull begin directive
273
  /// is read.
274
8.63k
  virtual void PragmaAssumeNonNullBegin(SourceLocation Loc) {}
275
276
  /// Callback invoked when a \#pragma clang assume_nonnull end directive
277
  /// is read.
278
8.63k
  virtual void PragmaAssumeNonNullEnd(SourceLocation Loc) {}
279
280
  /// Called by Preprocessor::HandleMacroExpandedIdentifier when a
281
  /// macro invocation is found.
282
  virtual void MacroExpands(const Token &MacroNameTok,
283
                            const MacroDefinition &MD, SourceRange Range,
284
36.5M
                            const MacroArgs *Args) {}
285
286
  /// Hook called whenever a macro definition is seen.
287
  virtual void MacroDefined(const Token &MacroNameTok,
288
36.2M
                            const MacroDirective *MD) {
289
36.2M
  }
290
291
  /// Hook called whenever a macro \#undef is seen.
292
  /// \param MacroNameTok The active Token
293
  /// \param MD A MacroDefinition for the named macro.
294
  /// \param Undef New MacroDirective if the macro was defined, null otherwise.
295
  ///
296
  /// MD is released immediately following this callback.
297
  virtual void MacroUndefined(const Token &MacroNameTok,
298
                              const MacroDefinition &MD,
299
559k
                              const MacroDirective *Undef) {
300
559k
  }
301
302
  /// Hook called whenever the 'defined' operator is seen.
303
  /// \param MD The MacroDirective if the name was a macro, null otherwise.
304
  virtual void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
305
3.78M
                       SourceRange Range) {
306
3.78M
  }
307
308
  /// Hook called when a '__has_include' or '__has_include_next' directive is
309
  /// read.
310
  virtual void HasInclude(SourceLocation Loc, StringRef FileName, bool IsAngled,
311
                          const FileEntry *File,
312
23.0k
                          SrcMgr::CharacteristicKind FileType) {}
313
314
  /// Hook called when a source range is skipped.
315
  /// \param Range The SourceRange that was skipped. The range begins at the
316
  /// \#if/\#else directive and ends after the \#endif/\#else directive.
317
  /// \param EndifLoc The end location of the 'endif' token, which may precede
318
  /// the range skipped by the directive (e.g excluding comments after an
319
  /// 'endif').
320
7.98M
  virtual void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) {
321
7.98M
  }
322
323
  enum ConditionValueKind {
324
    CVK_NotEvaluated, CVK_False, CVK_True
325
  };
326
327
  /// Hook called whenever an \#if is seen.
328
  /// \param Loc the source location of the directive.
329
  /// \param ConditionRange The SourceRange of the expression being tested.
330
  /// \param ConditionValue The evaluated value of the condition.
331
  ///
332
  // FIXME: better to pass in a list (or tree!) of Tokens.
333
  virtual void If(SourceLocation Loc, SourceRange ConditionRange,
334
7.58M
                  ConditionValueKind ConditionValue) {
335
7.58M
  }
336
337
  /// Hook called whenever an \#elif is seen.
338
  /// \param Loc the source location of the directive.
339
  /// \param ConditionRange The SourceRange of the expression being tested.
340
  /// \param ConditionValue The evaluated value of the condition.
341
  /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
342
  // FIXME: better to pass in a list (or tree!) of Tokens.
343
  virtual void Elif(SourceLocation Loc, SourceRange ConditionRange,
344
378k
                    ConditionValueKind ConditionValue, SourceLocation IfLoc) {
345
378k
  }
346
347
  /// Hook called whenever an \#ifdef is seen.
348
  /// \param Loc the source location of the directive.
349
  /// \param MacroNameTok Information on the token being tested.
350
  /// \param MD The MacroDefinition if the name was a macro, null otherwise.
351
  virtual void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
352
1.32M
                     const MacroDefinition &MD) {
353
1.32M
  }
354
355
  /// Hook called whenever an \#ifndef is seen.
356
  /// \param Loc the source location of the directive.
357
  /// \param MacroNameTok Information on the token being tested.
358
  /// \param MD The MacroDefiniton if the name was a macro, null otherwise.
359
  virtual void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
360
1.96M
                      const MacroDefinition &MD) {
361
1.96M
  }
362
363
  /// Hook called whenever an \#else is seen.
364
  /// \param Loc the source location of the directive.
365
  /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
366
6.26M
  virtual void Else(SourceLocation Loc, SourceLocation IfLoc) {
367
6.26M
  }
368
369
  /// Hook called whenever an \#endif is seen.
370
  /// \param Loc the source location of the directive.
371
  /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
372
10.8M
  virtual void Endif(SourceLocation Loc, SourceLocation IfLoc) {
373
10.8M
  }
374
};
375
376
/// Simple wrapper class for chaining callbacks.
377
class PPChainedCallbacks : public PPCallbacks {
378
  virtual void anchor();
379
  std::unique_ptr<PPCallbacks> First, Second;
380
381
public:
382
  PPChainedCallbacks(std::unique_ptr<PPCallbacks> _First,
383
                     std::unique_ptr<PPCallbacks> _Second)
384
16.4k
    : First(std::move(_First)), Second(std::move(_Second)) {}
385
386
  void FileChanged(SourceLocation Loc, FileChangeReason Reason,
387
                   SrcMgr::CharacteristicKind FileType,
388
1.03M
                   FileID PrevFID) override {
389
1.03M
    First->FileChanged(Loc, Reason, FileType, PrevFID);
390
1.03M
    Second->FileChanged(Loc, Reason, FileType, PrevFID);
391
1.03M
  }
392
393
  void FileSkipped(const FileEntry &SkippedFile,
394
                   const Token &FilenameTok,
395
516k
                   SrcMgr::CharacteristicKind FileType) override {
396
516k
    First->FileSkipped(SkippedFile, FilenameTok, FileType);
397
516k
    Second->FileSkipped(SkippedFile, FilenameTok, FileType);
398
516k
  }
399
400
  bool FileNotFound(StringRef FileName,
401
43
                    SmallVectorImpl<char> &RecoveryPath) override {
402
43
    return First->FileNotFound(FileName, RecoveryPath) ||
403
43
           Second->FileNotFound(FileName, RecoveryPath);
404
43
  }
405
406
  void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
407
                          StringRef FileName, bool IsAngled,
408
                          CharSourceRange FilenameRange, const FileEntry *File,
409
                          StringRef SearchPath, StringRef RelativePath,
410
                          const Module *Imported,
411
973k
                          SrcMgr::CharacteristicKind FileType) override {
412
973k
    First->InclusionDirective(HashLoc, IncludeTok, FileName, IsAngled,
413
973k
                              FilenameRange, File, SearchPath, RelativePath,
414
973k
                              Imported, FileType);
415
973k
    Second->InclusionDirective(HashLoc, IncludeTok, FileName, IsAngled,
416
973k
                               FilenameRange, File, SearchPath, RelativePath,
417
973k
                               Imported, FileType);
418
973k
  }
419
420
  void EnteredSubmodule(Module *M, SourceLocation ImportLoc,
421
156
                        bool ForPragma) override {
422
156
    First->EnteredSubmodule(M, ImportLoc, ForPragma);
423
156
    Second->EnteredSubmodule(M, ImportLoc, ForPragma);
424
156
  }
425
426
  void LeftSubmodule(Module *M, SourceLocation ImportLoc,
427
154
                     bool ForPragma) override {
428
154
    First->LeftSubmodule(M, ImportLoc, ForPragma);
429
154
    Second->LeftSubmodule(M, ImportLoc, ForPragma);
430
154
  }
431
432
  void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path,
433
103
                    const Module *Imported) override {
434
103
    First->moduleImport(ImportLoc, Path, Imported);
435
103
    Second->moduleImport(ImportLoc, Path, Imported);
436
103
  }
437
438
16.3k
  void EndOfMainFile() override {
439
16.3k
    First->EndOfMainFile();
440
16.3k
    Second->EndOfMainFile();
441
16.3k
  }
442
443
0
  void Ident(SourceLocation Loc, StringRef str) override {
444
0
    First->Ident(Loc, str);
445
0
    Second->Ident(Loc, str);
446
0
  }
447
448
  void PragmaDirective(SourceLocation Loc,
449
140k
                       PragmaIntroducerKind Introducer) override {
450
140k
    First->PragmaDirective(Loc, Introducer);
451
140k
    Second->PragmaDirective(Loc, Introducer);
452
140k
  }
453
454
  void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind,
455
0
                     StringRef Str) override {
456
0
    First->PragmaComment(Loc, Kind, Str);
457
0
    Second->PragmaComment(Loc, Kind, Str);
458
0
  }
459
460
  void PragmaDetectMismatch(SourceLocation Loc, StringRef Name,
461
0
                            StringRef Value) override {
462
0
    First->PragmaDetectMismatch(Loc, Name, Value);
463
0
    Second->PragmaDetectMismatch(Loc, Name, Value);
464
0
  }
465
466
12
  void PragmaDebug(SourceLocation Loc, StringRef DebugType) override {
467
12
    First->PragmaDebug(Loc, DebugType);
468
12
    Second->PragmaDebug(Loc, DebugType);
469
12
  }
470
471
  void PragmaMessage(SourceLocation Loc, StringRef Namespace,
472
0
                     PragmaMessageKind Kind, StringRef Str) override {
473
0
    First->PragmaMessage(Loc, Namespace, Kind, Str);
474
0
    Second->PragmaMessage(Loc, Namespace, Kind, Str);
475
0
  }
476
477
155
  void PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace) override {
478
155
    First->PragmaDiagnosticPush(Loc, Namespace);
479
155
    Second->PragmaDiagnosticPush(Loc, Namespace);
480
155
  }
481
482
155
  void PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace) override {
483
155
    First->PragmaDiagnosticPop(Loc, Namespace);
484
155
    Second->PragmaDiagnosticPop(Loc, Namespace);
485
155
  }
486
487
  void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace,
488
166
                        diag::Severity mapping, StringRef Str) override {
489
166
    First->PragmaDiagnostic(Loc, Namespace, mapping, Str);
490
166
    Second->PragmaDiagnostic(Loc, Namespace, mapping, Str);
491
166
  }
492
493
  void HasInclude(SourceLocation Loc, StringRef FileName, bool IsAngled,
494
                  const FileEntry *File,
495
22.6k
                  SrcMgr::CharacteristicKind FileType) override {
496
22.6k
    First->HasInclude(Loc, FileName, IsAngled, File, FileType);
497
22.6k
    Second->HasInclude(Loc, FileName, IsAngled, File, FileType);
498
22.6k
  }
499
500
  void PragmaOpenCLExtension(SourceLocation NameLoc, const IdentifierInfo *Name,
501
10
                             SourceLocation StateLoc, unsigned State) override {
502
10
    First->PragmaOpenCLExtension(NameLoc, Name, StateLoc, State);
503
10
    Second->PragmaOpenCLExtension(NameLoc, Name, StateLoc, State);
504
10
  }
505
506
  void PragmaWarning(SourceLocation Loc, StringRef WarningSpec,
507
0
                     ArrayRef<int> Ids) override {
508
0
    First->PragmaWarning(Loc, WarningSpec, Ids);
509
0
    Second->PragmaWarning(Loc, WarningSpec, Ids);
510
0
  }
511
512
0
  void PragmaWarningPush(SourceLocation Loc, int Level) override {
513
0
    First->PragmaWarningPush(Loc, Level);
514
0
    Second->PragmaWarningPush(Loc, Level);
515
0
  }
516
517
0
  void PragmaWarningPop(SourceLocation Loc) override {
518
0
    First->PragmaWarningPop(Loc);
519
0
    Second->PragmaWarningPop(Loc);
520
0
  }
521
522
0
  void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) override {
523
0
    First->PragmaExecCharsetPush(Loc, Str);
524
0
    Second->PragmaExecCharsetPush(Loc, Str);
525
0
  }
526
527
0
  void PragmaExecCharsetPop(SourceLocation Loc) override {
528
0
    First->PragmaExecCharsetPop(Loc);
529
0
    Second->PragmaExecCharsetPop(Loc);
530
0
  }
531
532
4.31k
  void PragmaAssumeNonNullBegin(SourceLocation Loc) override {
533
4.31k
    First->PragmaAssumeNonNullBegin(Loc);
534
4.31k
    Second->PragmaAssumeNonNullBegin(Loc);
535
4.31k
  }
536
537
4.31k
  void PragmaAssumeNonNullEnd(SourceLocation Loc) override {
538
4.31k
    First->PragmaAssumeNonNullEnd(Loc);
539
4.31k
    Second->PragmaAssumeNonNullEnd(Loc);
540
4.31k
  }
541
542
  void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
543
16.9M
                    SourceRange Range, const MacroArgs *Args) override {
544
16.9M
    First->MacroExpands(MacroNameTok, MD, Range, Args);
545
16.9M
    Second->MacroExpands(MacroNameTok, MD, Range, Args);
546
16.9M
  }
547
548
  void MacroDefined(const Token &MacroNameTok,
549
14.7M
                    const MacroDirective *MD) override {
550
14.7M
    First->MacroDefined(MacroNameTok, MD);
551
14.7M
    Second->MacroDefined(MacroNameTok, MD);
552
14.7M
  }
553
554
  void MacroUndefined(const Token &MacroNameTok,
555
                      const MacroDefinition &MD,
556
268k
                      const MacroDirective *Undef) override {
557
268k
    First->MacroUndefined(MacroNameTok, MD, Undef);
558
268k
    Second->MacroUndefined(MacroNameTok, MD, Undef);
559
268k
  }
560
561
  void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
562
1.85M
               SourceRange Range) override {
563
1.85M
    First->Defined(MacroNameTok, MD, Range);
564
1.85M
    Second->Defined(MacroNameTok, MD, Range);
565
1.85M
  }
566
567
3.76M
  void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override {
568
3.76M
    First->SourceRangeSkipped(Range, EndifLoc);
569
3.76M
    Second->SourceRangeSkipped(Range, EndifLoc);
570
3.76M
  }
571
572
  /// Hook called whenever an \#if is seen.
573
  void If(SourceLocation Loc, SourceRange ConditionRange,
574
3.75M
          ConditionValueKind ConditionValue) override {
575
3.75M
    First->If(Loc, ConditionRange, ConditionValue);
576
3.75M
    Second->If(Loc, ConditionRange, ConditionValue);
577
3.75M
  }
578
579
  /// Hook called whenever an \#elif is seen.
580
  void Elif(SourceLocation Loc, SourceRange ConditionRange,
581
187k
            ConditionValueKind ConditionValue, SourceLocation IfLoc) override {
582
187k
    First->Elif(Loc, ConditionRange, ConditionValue, IfLoc);
583
187k
    Second->Elif(Loc, ConditionRange, ConditionValue, IfLoc);
584
187k
  }
585
586
  /// Hook called whenever an \#ifdef is seen.
587
  void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
588
457k
             const MacroDefinition &MD) override {
589
457k
    First->Ifdef(Loc, MacroNameTok, MD);
590
457k
    Second->Ifdef(Loc, MacroNameTok, MD);
591
457k
  }
592
593
  /// Hook called whenever an \#ifndef is seen.
594
  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
595
958k
              const MacroDefinition &MD) override {
596
958k
    First->Ifndef(Loc, MacroNameTok, MD);
597
958k
    Second->Ifndef(Loc, MacroNameTok, MD);
598
958k
  }
599
600
  /// Hook called whenever an \#else is seen.
601
2.93M
  void Else(SourceLocation Loc, SourceLocation IfLoc) override {
602
2.93M
    First->Else(Loc, IfLoc);
603
2.93M
    Second->Else(Loc, IfLoc);
604
2.93M
  }
605
606
  /// Hook called whenever an \#endif is seen.
607
5.16M
  void Endif(SourceLocation Loc, SourceLocation IfLoc) override {
608
5.16M
    First->Endif(Loc, IfLoc);
609
5.16M
    Second->Endif(Loc, IfLoc);
610
5.16M
  }
611
};
612
613
}  // end namespace clang
614
615
#endif