clang  9.0.0svn
RAIIObjectsForParser.h
Go to the documentation of this file.
1 //===--- RAIIObjectsForParser.h - RAII helpers for the parser ---*- 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 // This file defines and implements the some simple RAII objects that are used
10 // by the parser to manage bits in recursion.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_LIB_PARSE_RAIIOBJECTSFORPARSER_H
15 #define LLVM_CLANG_LIB_PARSE_RAIIOBJECTSFORPARSER_H
16 
18 #include "clang/Parse/Parser.h"
21 #include "clang/Sema/Sema.h"
22 
23 namespace clang {
24  // TODO: move ParsingClassDefinition here.
25  // TODO: move TentativeParsingAction here.
26 
27  /// A RAII object used to temporarily suppress access-like
28  /// checking. Access-like checks are those associated with
29  /// controlling the use of a declaration, like C++ access control
30  /// errors and deprecation warnings. They are contextually
31  /// dependent, in that they can only be resolved with full
32  /// information about what's being declared. They are also
33  /// suppressed in certain contexts, like the template arguments of
34  /// an explicit instantiation. However, those suppression contexts
35  /// cannot necessarily be fully determined in advance; for
36  /// example, something starting like this:
37  /// template <> class std::vector<A::PrivateType>
38  /// might be the entirety of an explicit instantiation:
39  /// template <> class std::vector<A::PrivateType>;
40  /// or just an elaborated type specifier:
41  /// template <> class std::vector<A::PrivateType> make_vector<>();
42  /// Therefore this class collects all the diagnostics and permits
43  /// them to be re-delayed in a new context.
45  Sema &S;
46  sema::DelayedDiagnosticPool DiagnosticPool;
48  bool Active;
49 
50  public:
51  /// Begin suppressing access-like checks
52  SuppressAccessChecks(Parser &P, bool activate = true)
53  : S(P.getActions()), DiagnosticPool(nullptr) {
54  if (activate) {
55  State = S.PushParsingDeclaration(DiagnosticPool);
56  Active = true;
57  } else {
58  Active = false;
59  }
60  }
62  : S(Other.S), DiagnosticPool(std::move(Other.DiagnosticPool)),
63  State(Other.State), Active(Other.Active) {
64  Other.Active = false;
65  }
66  void operator=(SuppressAccessChecks &&Other) = delete;
67 
68  void done() {
69  assert(Active && "trying to end an inactive suppression");
70  S.PopParsingDeclaration(State, nullptr);
71  Active = false;
72  }
73 
74  void redelay() {
75  assert(!Active && "redelaying without having ended first");
76  if (!DiagnosticPool.pool_empty())
77  S.redelayDiagnostics(DiagnosticPool);
78  assert(DiagnosticPool.pool_empty());
79  }
80 
82  if (Active) done();
83  }
84  };
85 
86  /// RAII object used to inform the actions that we're
87  /// currently parsing a declaration. This is active when parsing a
88  /// variable's initializer, but not when parsing the body of a
89  /// class or function definition.
91  Sema &Actions;
92  sema::DelayedDiagnosticPool DiagnosticPool;
94  bool Popped;
95 
97  void operator=(const ParsingDeclRAIIObject &) = delete;
98 
99  public:
100  enum NoParent_t { NoParent };
102  : Actions(P.getActions()), DiagnosticPool(nullptr) {
103  push();
104  }
105 
106  /// Creates a RAII object whose pool is optionally parented by another.
108  const sema::DelayedDiagnosticPool *parentPool)
109  : Actions(P.getActions()), DiagnosticPool(parentPool) {
110  push();
111  }
112 
113  /// Creates a RAII object and, optionally, initialize its
114  /// diagnostics pool by stealing the diagnostics from another
115  /// RAII object (which is assumed to be the current top pool).
117  : Actions(P.getActions()),
118  DiagnosticPool(other ? other->DiagnosticPool.getParent() : nullptr) {
119  if (other) {
120  DiagnosticPool.steal(other->DiagnosticPool);
121  other->abort();
122  }
123  push();
124  }
125 
127  abort();
128  }
129 
131  return DiagnosticPool;
132  }
134  return DiagnosticPool;
135  }
136 
137  /// Resets the RAII object for a new declaration.
138  void reset() {
139  abort();
140  push();
141  }
142 
143  /// Signals that the context was completed without an appropriate
144  /// declaration being parsed.
145  void abort() {
146  pop(nullptr);
147  }
148 
149  void complete(Decl *D) {
150  assert(!Popped && "ParsingDeclaration has already been popped!");
151  pop(D);
152  }
153 
154  /// Unregister this object from Sema, but remember all the
155  /// diagnostics that were emitted into it.
157  pop(nullptr);
158  }
159 
160  private:
161  void push() {
162  State = Actions.PushParsingDeclaration(DiagnosticPool);
163  Popped = false;
164  }
165 
166  void pop(Decl *D) {
167  if (!Popped) {
168  Actions.PopParsingDeclaration(State, D);
169  Popped = true;
170  }
171  }
172  };
173 
174  /// A class for parsing a DeclSpec.
175  class ParsingDeclSpec : public DeclSpec {
176  ParsingDeclRAIIObject ParsingRAII;
177 
178  public:
180  : DeclSpec(P.getAttrFactory()),
181  ParsingRAII(P, ParsingDeclRAIIObject::NoParent) {}
183  : DeclSpec(P.getAttrFactory()),
184  ParsingRAII(P, RAII) {}
185 
187  return ParsingRAII.getDelayedDiagnosticPool();
188  }
189 
190  void complete(Decl *D) {
191  ParsingRAII.complete(D);
192  }
193 
194  void abort() {
195  ParsingRAII.abort();
196  }
197  };
198 
199  /// A class for parsing a declarator.
200  class ParsingDeclarator : public Declarator {
201  ParsingDeclRAIIObject ParsingRAII;
202 
203  public:
205  : Declarator(DS, C), ParsingRAII(P, &DS.getDelayedDiagnosticPool()) {
206  }
207 
208  const ParsingDeclSpec &getDeclSpec() const {
209  return static_cast<const ParsingDeclSpec&>(Declarator::getDeclSpec());
210  }
211 
213  return const_cast<ParsingDeclSpec&>(getDeclSpec());
214  }
215 
216  void clear() {
218  ParsingRAII.reset();
219  }
220 
221  void complete(Decl *D) {
222  ParsingRAII.complete(D);
223  }
224  };
225 
226  /// A class for parsing a field declarator.
228  ParsingDeclRAIIObject ParsingRAII;
229 
230  public:
232  : FieldDeclarator(DS), ParsingRAII(P, &DS.getDelayedDiagnosticPool()) {
233  }
234 
235  const ParsingDeclSpec &getDeclSpec() const {
236  return static_cast<const ParsingDeclSpec&>(D.getDeclSpec());
237  }
238 
240  return const_cast<ParsingDeclSpec&>(getDeclSpec());
241  }
242 
243  void complete(Decl *D) {
244  ParsingRAII.complete(D);
245  }
246  };
247 
248  /// ExtensionRAIIObject - This saves the state of extension warnings when
249  /// constructed and disables them. When destructed, it restores them back to
250  /// the way they used to be. This is used to handle __extension__ in the
251  /// parser.
253  ExtensionRAIIObject(const ExtensionRAIIObject &) = delete;
254  void operator=(const ExtensionRAIIObject &) = delete;
255 
256  DiagnosticsEngine &Diags;
257  public:
258  ExtensionRAIIObject(DiagnosticsEngine &diags) : Diags(diags) {
260  }
261 
264  }
265  };
266 
267  /// ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and
268  /// restores it when destroyed. This says that "foo:" should not be
269  /// considered a possible typo for "foo::" for error recovery purposes.
271  Parser &P;
272  bool OldVal;
273  public:
275  : P(p), OldVal(P.ColonIsSacred) {
276  P.ColonIsSacred = Value;
277  }
278 
279  /// restore - This can be used to restore the state early, before the dtor
280  /// is run.
281  void restore() {
282  P.ColonIsSacred = OldVal;
283  }
284 
286  restore();
287  }
288  };
289 
290  /// RAII object that makes '>' behave either as an operator
291  /// or as the closing angle bracket for a template argument list.
293  bool &GreaterThanIsOperator;
294  bool OldGreaterThanIsOperator;
295  public:
296  GreaterThanIsOperatorScope(bool &GTIO, bool Val)
297  : GreaterThanIsOperator(GTIO), OldGreaterThanIsOperator(GTIO) {
298  GreaterThanIsOperator = Val;
299  }
300 
302  GreaterThanIsOperator = OldGreaterThanIsOperator;
303  }
304  };
305 
307  bool &InMessageExpression;
308  bool OldValue;
309 
310  public:
312  : InMessageExpression(P.InMessageExpression),
313  OldValue(P.InMessageExpression) {
314  InMessageExpression = Value;
315  }
316 
318  InMessageExpression = OldValue;
319  }
320  };
321 
322  /// RAII object that makes sure paren/bracket/brace count is correct
323  /// after declaration/statement parsing, even when there's a parsing error.
325  Parser &P;
326  unsigned short ParenCount, BracketCount, BraceCount;
327  public:
329  : P(p), ParenCount(p.ParenCount), BracketCount(p.BracketCount),
330  BraceCount(p.BraceCount) { }
331 
333  P.AngleBrackets.clear(P);
334  P.ParenCount = ParenCount;
335  P.BracketCount = BracketCount;
336  P.BraceCount = BraceCount;
337  }
338  };
339 
341  PoisonIdentifierRAIIObject Ident_AbnormalTermination;
342  PoisonIdentifierRAIIObject Ident_GetExceptionCode;
343  PoisonIdentifierRAIIObject Ident_GetExceptionInfo;
344  PoisonIdentifierRAIIObject Ident__abnormal_termination;
345  PoisonIdentifierRAIIObject Ident__exception_code;
346  PoisonIdentifierRAIIObject Ident__exception_info;
347  PoisonIdentifierRAIIObject Ident___abnormal_termination;
348  PoisonIdentifierRAIIObject Ident___exception_code;
349  PoisonIdentifierRAIIObject Ident___exception_info;
350  public:
352  : Ident_AbnormalTermination(Self.Ident_AbnormalTermination, NewValue),
353  Ident_GetExceptionCode(Self.Ident_GetExceptionCode, NewValue),
354  Ident_GetExceptionInfo(Self.Ident_GetExceptionInfo, NewValue),
355  Ident__abnormal_termination(Self.Ident__abnormal_termination, NewValue),
356  Ident__exception_code(Self.Ident__exception_code, NewValue),
357  Ident__exception_info(Self.Ident__exception_info, NewValue),
358  Ident___abnormal_termination(Self.Ident___abnormal_termination, NewValue),
359  Ident___exception_code(Self.Ident___exception_code, NewValue),
360  Ident___exception_info(Self.Ident___exception_info, NewValue) {
361  }
362  };
363 
364  /// RAII class that helps handle the parsing of an open/close delimiter
365  /// pair, such as braces { ... } or parentheses ( ... ).
367  Parser& P;
368  tok::TokenKind Kind, Close, FinalToken;
369  SourceLocation (Parser::*Consumer)();
370  SourceLocation LOpen, LClose;
371 
372  unsigned short &getDepth() {
373  switch (Kind) {
374  case tok::l_brace: return P.BraceCount;
375  case tok::l_square: return P.BracketCount;
376  case tok::l_paren: return P.ParenCount;
377  default: llvm_unreachable("Wrong token kind");
378  }
379  }
380 
381  bool diagnoseOverflow();
382  bool diagnoseMissingClose();
383 
384  public:
386  tok::TokenKind FinalToken = tok::semi)
387  : GreaterThanIsOperatorScope(p.GreaterThanIsOperator, true),
388  P(p), Kind(k), FinalToken(FinalToken)
389  {
390  switch (Kind) {
391  default: llvm_unreachable("Unexpected balanced token");
392  case tok::l_brace:
393  Close = tok::r_brace;
394  Consumer = &Parser::ConsumeBrace;
395  break;
396  case tok::l_paren:
397  Close = tok::r_paren;
398  Consumer = &Parser::ConsumeParen;
399  break;
400 
401  case tok::l_square:
402  Close = tok::r_square;
403  Consumer = &Parser::ConsumeBracket;
404  break;
405  }
406  }
407 
408  SourceLocation getOpenLocation() const { return LOpen; }
409  SourceLocation getCloseLocation() const { return LClose; }
410  SourceRange getRange() const { return SourceRange(LOpen, LClose); }
411 
412  bool consumeOpen() {
413  if (!P.Tok.is(Kind))
414  return true;
415 
416  if (getDepth() < P.getLangOpts().BracketDepth) {
417  LOpen = (P.*Consumer)();
418  return false;
419  }
420 
421  return diagnoseOverflow();
422  }
423 
424  bool expectAndConsume(unsigned DiagID = diag::err_expected,
425  const char *Msg = "",
426  tok::TokenKind SkipToTok = tok::unknown);
427  bool consumeClose() {
428  if (P.Tok.is(Close)) {
429  LClose = (P.*Consumer)();
430  return false;
431  } else if (P.Tok.is(tok::semi) && P.NextToken().is(Close)) {
432  SourceLocation SemiLoc = P.ConsumeToken();
433  P.Diag(SemiLoc, diag::err_unexpected_semi)
434  << Close << FixItHint::CreateRemoval(SourceRange(SemiLoc, SemiLoc));
435  LClose = (P.*Consumer)();
436  return false;
437  }
438 
439  return diagnoseMissingClose();
440  }
441  void skipToEnd();
442  };
443 
444  /// RAIIObject to destroy the contents of a SmallVector of
445  /// TemplateIdAnnotation pointers and clear the vector.
448 
449  public:
452  : Container(Container) {}
453 
456  Container.begin(),
457  E = Container.end();
458  I != E; ++I)
459  (*I)->Destroy();
460  Container.clear();
461  }
462  };
463 } // end namespace clang
464 
465 #endif
DestroyTemplateIdAnnotationsRAIIObj(SmallVectorImpl< TemplateIdAnnotation *> &Container)
void restore()
restore - This can be used to restore the state early, before the dtor is run.
void clear()
Reset the contents of this Declarator.
Definition: DeclSpec.h:1916
ParsingDeclarator(Parser &P, const ParsingDeclSpec &DS, DeclaratorContext C)
SuppressAccessChecks(SuppressAccessChecks &&Other)
ColonProtectionRAIIObject(Parser &p, bool Value=true)
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {...
Definition: Token.h:94
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
RAII object used to inform the actions that we&#39;re currently parsing a declaration.
A RAII object used to temporarily suppress access-like checking.
void PopParsingDeclaration(ParsingDeclState state, Decl *decl)
StringRef P
SourceLocation getCloseLocation() const
Parser - This implements a parser for the C family of languages.
Definition: Parser.h:57
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1764
RAIIObject to destroy the contents of a SmallVector of TemplateIdAnnotation pointers and clear the ve...
ExtensionRAIIObject(DiagnosticsEngine &diags)
RAII object that makes sure paren/bracket/brace count is correct after declaration/statement parsing...
ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed...
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
Definition: Parser.h:749
void operator=(SuppressAccessChecks &&Other)=delete
LineState State
void IncrementAllExtensionsSilenced()
Counter bumped when an extension block is/ encountered.
Definition: Diagnostic.h:697
Definition: Format.h:2222
const sema::DelayedDiagnosticPool & getDelayedDiagnosticPool() const
ParsingDeclState PushParsingDeclaration(sema::DelayedDiagnosticPool &pool)
Definition: Sema.h:4091
RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ...
ParsingFieldDeclarator(Parser &P, const ParsingDeclSpec &DS)
This little struct is used to capture information about structure field declarators, which is basically just a bitfield size.
Definition: DeclSpec.h:2489
void reset()
Resets the RAII object for a new declaration.
void abortAndRemember()
Unregister this object from Sema, but remember all the diagnostics that were emitted into it...
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:148
ParsingDeclSpec & getMutableDeclSpec() const
void steal(DelayedDiagnosticPool &pool)
Steal the diagnostics from the given pool.
const ParsingDeclSpec & getDeclSpec() const
GreaterThanIsOperatorScope(bool &GTIO, bool Val)
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:328
A class for parsing a declarator.
ParsingDeclSpec(Parser &P, ParsingDeclRAIIObject *RAII)
ParsingDeclRAIIObject(Parser &P, const sema::DelayedDiagnosticPool *parentPool)
Creates a RAII object whose pool is optionally parented by another.
ParsingDeclRAIIObject(Parser &P, NoParent_t _)
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
ParsingDeclRAIIObject(Parser &P, ParsingDeclRAIIObject *other)
Creates a RAII object and, optionally, initialize its diagnostics pool by stealing the diagnostics fr...
SuppressAccessChecks(Parser &P, bool activate=true)
Begin suppressing access-like checks.
A class for parsing a field declarator.
DeclaratorContext
Definition: DeclSpec.h:1722
SourceLocation getOpenLocation() const
RAII object that makes &#39;>&#39; behave either as an operator or as the closing angle bracket for a templat...
const LangOptions & getLangOpts() const
Definition: Parser.h:397
A class for parsing a DeclSpec.
Kind
Encodes a location in the source.
const ParsingDeclSpec & getDeclSpec() const
ExtensionRAIIObject - This saves the state of extension warnings when constructed and disables them...
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:24
InMessageExpressionRAIIObject(Parser &P, bool Value)
Dataflow Directional Tag Classes.
void redelayDiagnostics(sema::DelayedDiagnosticPool &pool)
BalancedDelimiterTracker(Parser &p, tok::TokenKind k, tok::TokenKind FinalToken=tok::semi)
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:117
const sema::DelayedDiagnosticPool & getDelayedDiagnosticPool() const
sema::DelayedDiagnosticPool & getDelayedDiagnosticPool()
void abort()
Signals that the context was completed without an appropriate declaration being parsed.
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Definition: Parser.cpp:72
ParsingDeclSpec & getMutableDeclSpec() const
void DecrementAllExtensionsSilenced()
Definition: Diagnostic.h:698
Captures information about "declaration specifiers".
Definition: DeclSpec.h:227
SourceLocation ConsumeToken()
ConsumeToken - Consume the current &#39;peek token&#39; and lex the next one.
Definition: Parser.h:442
PoisonSEHIdentifiersRAIIObject(Parser &Self, bool NewValue)
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1853
A collection of diagnostics which were delayed.
#define true
Definition: stdbool.h:16
A trivial tuple used to represent a source range.
An RAII object for [un]poisoning an identifier within a scope.