clang  7.0.0
Parser.h
Go to the documentation of this file.
1 //===--- Parser.h - C Language Parser ---------------------------*- C++ -*-===//
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 // This file defines the Parser interface.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_PARSE_PARSER_H
15 #define LLVM_CLANG_PARSE_PARSER_H
16 
17 #include "clang/AST/Availability.h"
21 #include "clang/Basic/Specifiers.h"
23 #include "clang/Lex/Preprocessor.h"
24 #include "clang/Sema/DeclSpec.h"
25 #include "clang/Sema/LoopHint.h"
26 #include "clang/Sema/Sema.h"
27 #include "llvm/ADT/SmallVector.h"
28 #include "llvm/Support/Compiler.h"
29 #include "llvm/Support/PrettyStackTrace.h"
30 #include "llvm/Support/SaveAndRestore.h"
31 #include <memory>
32 #include <stack>
33 
34 namespace clang {
35  class PragmaHandler;
36  class Scope;
37  class BalancedDelimiterTracker;
38  class CorrectionCandidateCallback;
39  class DeclGroupRef;
40  class DiagnosticBuilder;
41  class Parser;
42  class ParsingDeclRAIIObject;
43  class ParsingDeclSpec;
44  class ParsingDeclarator;
45  class ParsingFieldDeclarator;
46  class ColonProtectionRAIIObject;
47  class InMessageExpressionRAIIObject;
48  class PoisonSEHIdentifiersRAIIObject;
49  class OMPClause;
50  class ObjCTypeParamList;
51  class ObjCTypeParameter;
52 
53 /// Parser - This implements a parser for the C family of languages. After
54 /// parsing units of the grammar, productions are invoked to handle whatever has
55 /// been read.
56 ///
57 class Parser : public CodeCompletionHandler {
61  friend class ObjCDeclContextSwitch;
64 
65  Preprocessor &PP;
66 
67  /// Tok - The current token we are peeking ahead. All parsing methods assume
68  /// that this is valid.
69  Token Tok;
70 
71  // PrevTokLocation - The location of the token we previously
72  // consumed. This token is used for diagnostics where we expected to
73  // see a token following another token (e.g., the ';' at the end of
74  // a statement).
75  SourceLocation PrevTokLocation;
76 
77  unsigned short ParenCount = 0, BracketCount = 0, BraceCount = 0;
78  unsigned short MisplacedModuleBeginCount = 0;
79 
80  /// Actions - These are the callbacks we invoke as we parse various constructs
81  /// in the file.
82  Sema &Actions;
83 
84  DiagnosticsEngine &Diags;
85 
86  /// ScopeCache - Cache scopes to reduce malloc traffic.
87  enum { ScopeCacheSize = 16 };
88  unsigned NumCachedScopes;
89  Scope *ScopeCache[ScopeCacheSize];
90 
91  /// Identifiers used for SEH handling in Borland. These are only
92  /// allowed in particular circumstances
93  // __except block
94  IdentifierInfo *Ident__exception_code,
95  *Ident___exception_code,
96  *Ident_GetExceptionCode;
97  // __except filter expression
98  IdentifierInfo *Ident__exception_info,
99  *Ident___exception_info,
100  *Ident_GetExceptionInfo;
101  // __finally
102  IdentifierInfo *Ident__abnormal_termination,
103  *Ident___abnormal_termination,
104  *Ident_AbnormalTermination;
105 
106  /// Contextual keywords for Microsoft extensions.
107  IdentifierInfo *Ident__except;
108  mutable IdentifierInfo *Ident_sealed;
109 
110  /// Ident_super - IdentifierInfo for "super", to support fast
111  /// comparison.
112  IdentifierInfo *Ident_super;
113  /// Ident_vector, Ident_bool - cached IdentifierInfos for "vector" and
114  /// "bool" fast comparison. Only present if AltiVec or ZVector are enabled.
115  IdentifierInfo *Ident_vector;
116  IdentifierInfo *Ident_bool;
117  /// Ident_pixel - cached IdentifierInfos for "pixel" fast comparison.
118  /// Only present if AltiVec enabled.
119  IdentifierInfo *Ident_pixel;
120 
121  /// Objective-C contextual keywords.
122  mutable IdentifierInfo *Ident_instancetype;
123 
124  /// Identifier for "introduced".
125  IdentifierInfo *Ident_introduced;
126 
127  /// Identifier for "deprecated".
128  IdentifierInfo *Ident_deprecated;
129 
130  /// Identifier for "obsoleted".
131  IdentifierInfo *Ident_obsoleted;
132 
133  /// Identifier for "unavailable".
134  IdentifierInfo *Ident_unavailable;
135 
136  /// Identifier for "message".
137  IdentifierInfo *Ident_message;
138 
139  /// Identifier for "strict".
140  IdentifierInfo *Ident_strict;
141 
142  /// Identifier for "replacement".
143  IdentifierInfo *Ident_replacement;
144 
145  /// Identifiers used by the 'external_source_symbol' attribute.
146  IdentifierInfo *Ident_language, *Ident_defined_in,
147  *Ident_generated_declaration;
148 
149  /// C++0x contextual keywords.
150  mutable IdentifierInfo *Ident_final;
151  mutable IdentifierInfo *Ident_GNU_final;
152  mutable IdentifierInfo *Ident_override;
153 
154  // C++ type trait keywords that can be reverted to identifiers and still be
155  // used as type traits.
156  llvm::SmallDenseMap<IdentifierInfo *, tok::TokenKind> RevertibleTypeTraits;
157 
158  std::unique_ptr<PragmaHandler> AlignHandler;
159  std::unique_ptr<PragmaHandler> GCCVisibilityHandler;
160  std::unique_ptr<PragmaHandler> OptionsHandler;
161  std::unique_ptr<PragmaHandler> PackHandler;
162  std::unique_ptr<PragmaHandler> MSStructHandler;
163  std::unique_ptr<PragmaHandler> UnusedHandler;
164  std::unique_ptr<PragmaHandler> WeakHandler;
165  std::unique_ptr<PragmaHandler> RedefineExtnameHandler;
166  std::unique_ptr<PragmaHandler> FPContractHandler;
167  std::unique_ptr<PragmaHandler> OpenCLExtensionHandler;
168  std::unique_ptr<PragmaHandler> OpenMPHandler;
169  std::unique_ptr<PragmaHandler> PCSectionHandler;
170  std::unique_ptr<PragmaHandler> MSCommentHandler;
171  std::unique_ptr<PragmaHandler> MSDetectMismatchHandler;
172  std::unique_ptr<PragmaHandler> MSPointersToMembers;
173  std::unique_ptr<PragmaHandler> MSVtorDisp;
174  std::unique_ptr<PragmaHandler> MSInitSeg;
175  std::unique_ptr<PragmaHandler> MSDataSeg;
176  std::unique_ptr<PragmaHandler> MSBSSSeg;
177  std::unique_ptr<PragmaHandler> MSConstSeg;
178  std::unique_ptr<PragmaHandler> MSCodeSeg;
179  std::unique_ptr<PragmaHandler> MSSection;
180  std::unique_ptr<PragmaHandler> MSRuntimeChecks;
181  std::unique_ptr<PragmaHandler> MSIntrinsic;
182  std::unique_ptr<PragmaHandler> MSOptimize;
183  std::unique_ptr<PragmaHandler> CUDAForceHostDeviceHandler;
184  std::unique_ptr<PragmaHandler> OptimizeHandler;
185  std::unique_ptr<PragmaHandler> LoopHintHandler;
186  std::unique_ptr<PragmaHandler> UnrollHintHandler;
187  std::unique_ptr<PragmaHandler> NoUnrollHintHandler;
188  std::unique_ptr<PragmaHandler> FPHandler;
189  std::unique_ptr<PragmaHandler> STDCFENVHandler;
190  std::unique_ptr<PragmaHandler> STDCCXLIMITHandler;
191  std::unique_ptr<PragmaHandler> STDCUnknownHandler;
192  std::unique_ptr<PragmaHandler> AttributePragmaHandler;
193 
194  std::unique_ptr<CommentHandler> CommentSemaHandler;
195 
196  /// Whether the '>' token acts as an operator or not. This will be
197  /// true except when we are parsing an expression within a C++
198  /// template argument list, where the '>' closes the template
199  /// argument list.
200  bool GreaterThanIsOperator;
201 
202  /// ColonIsSacred - When this is false, we aggressively try to recover from
203  /// code like "foo : bar" as if it were a typo for "foo :: bar". This is not
204  /// safe in case statements and a few other things. This is managed by the
205  /// ColonProtectionRAIIObject RAII object.
206  bool ColonIsSacred;
207 
208  /// When true, we are directly inside an Objective-C message
209  /// send expression.
210  ///
211  /// This is managed by the \c InMessageExpressionRAIIObject class, and
212  /// should not be set directly.
213  bool InMessageExpression;
214 
215  /// The "depth" of the template parameters currently being parsed.
216  unsigned TemplateParameterDepth;
217 
218  /// RAII class that manages the template parameter depth.
219  class TemplateParameterDepthRAII {
220  unsigned &Depth;
221  unsigned AddedLevels;
222  public:
223  explicit TemplateParameterDepthRAII(unsigned &Depth)
224  : Depth(Depth), AddedLevels(0) {}
225 
226  ~TemplateParameterDepthRAII() {
227  Depth -= AddedLevels;
228  }
229 
230  void operator++() {
231  ++Depth;
232  ++AddedLevels;
233  }
234  void addDepth(unsigned D) {
235  Depth += D;
236  AddedLevels += D;
237  }
238  unsigned getDepth() const { return Depth; }
239  };
240 
241  /// Factory object for creating ParsedAttr objects.
242  AttributeFactory AttrFactory;
243 
244  /// Gathers and cleans up TemplateIdAnnotations when parsing of a
245  /// top-level declaration is finished.
247 
248  /// Identifiers which have been declared within a tentative parse.
249  SmallVector<IdentifierInfo *, 8> TentativelyDeclaredIdentifiers;
250 
251  /// Tracker for '<' tokens that might have been intended to be treated as an
252  /// angle bracket instead of a less-than comparison.
253  ///
254  /// This happens when the user intends to form a template-id, but typoes the
255  /// template-name or forgets a 'template' keyword for a dependent template
256  /// name.
257  ///
258  /// We track these locations from the point where we see a '<' with a
259  /// name-like expression on its left until we see a '>' or '>>' that might
260  /// match it.
261  struct AngleBracketTracker {
262  /// Flags used to rank candidate template names when there is more than one
263  /// '<' in a scope.
264  enum Priority : unsigned short {
265  /// A non-dependent name that is a potential typo for a template name.
266  PotentialTypo = 0x0,
267  /// A dependent name that might instantiate to a template-name.
268  DependentName = 0x2,
269 
270  /// A space appears before the '<' token.
271  SpaceBeforeLess = 0x0,
272  /// No space before the '<' token
273  NoSpaceBeforeLess = 0x1,
274 
275  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue*/ DependentName)
276  };
277 
278  struct Loc {
281  AngleBracketTracker::Priority Priority;
282  unsigned short ParenCount, BracketCount, BraceCount;
283 
284  bool isActive(Parser &P) const {
285  return P.ParenCount == ParenCount && P.BracketCount == BracketCount &&
286  P.BraceCount == BraceCount;
287  }
288 
289  bool isActiveOrNested(Parser &P) const {
290  return isActive(P) || P.ParenCount > ParenCount ||
291  P.BracketCount > BracketCount || P.BraceCount > BraceCount;
292  }
293  };
294 
295  SmallVector<Loc, 8> Locs;
296 
297  /// Add an expression that might have been intended to be a template name.
298  /// In the case of ambiguity, we arbitrarily select the innermost such
299  /// expression, for example in 'foo < bar < baz', 'bar' is the current
300  /// candidate. No attempt is made to track that 'foo' is also a candidate
301  /// for the case where we see a second suspicious '>' token.
302  void add(Parser &P, Expr *TemplateName, SourceLocation LessLoc,
303  Priority Prio) {
304  if (!Locs.empty() && Locs.back().isActive(P)) {
305  if (Locs.back().Priority <= Prio) {
306  Locs.back().TemplateName = TemplateName;
307  Locs.back().LessLoc = LessLoc;
308  Locs.back().Priority = Prio;
309  }
310  } else {
311  Locs.push_back({TemplateName, LessLoc, Prio,
312  P.ParenCount, P.BracketCount, P.BraceCount});
313  }
314  }
315 
316  /// Mark the current potential missing template location as having been
317  /// handled (this happens if we pass a "corresponding" '>' or '>>' token
318  /// or leave a bracket scope).
319  void clear(Parser &P) {
320  while (!Locs.empty() && Locs.back().isActiveOrNested(P))
321  Locs.pop_back();
322  }
323 
324  /// Get the current enclosing expression that might hve been intended to be
325  /// a template name.
326  Loc *getCurrent(Parser &P) {
327  if (!Locs.empty() && Locs.back().isActive(P))
328  return &Locs.back();
329  return nullptr;
330  }
331  };
332 
333  AngleBracketTracker AngleBrackets;
334 
335  IdentifierInfo *getSEHExceptKeyword();
336 
337  /// True if we are within an Objective-C container while parsing C-like decls.
338  ///
339  /// This is necessary because Sema thinks we have left the container
340  /// to parse the C-like decls, meaning Actions.getObjCDeclContext() will
341  /// be NULL.
342  bool ParsingInObjCContainer;
343 
344  /// Whether to skip parsing of function bodies.
345  ///
346  /// This option can be used, for example, to speed up searches for
347  /// declarations/definitions when indexing.
348  bool SkipFunctionBodies;
349 
350  /// The location of the expression statement that is being parsed right now.
351  /// Used to determine if an expression that is being parsed is a statement or
352  /// just a regular sub-expression.
353  SourceLocation ExprStatementTokLoc;
354 
355 public:
356  Parser(Preprocessor &PP, Sema &Actions, bool SkipFunctionBodies);
357  ~Parser() override;
358 
359  const LangOptions &getLangOpts() const { return PP.getLangOpts(); }
360  const TargetInfo &getTargetInfo() const { return PP.getTargetInfo(); }
361  Preprocessor &getPreprocessor() const { return PP; }
362  Sema &getActions() const { return Actions; }
363  AttributeFactory &getAttrFactory() { return AttrFactory; }
364 
365  const Token &getCurToken() const { return Tok; }
366  Scope *getCurScope() const { return Actions.getCurScope(); }
368  return Actions.incrementMSManglingNumber();
369  }
370 
371  Decl *getObjCDeclContext() const { return Actions.getObjCDeclContext(); }
372 
373  // Type forwarding. All of these are statically 'void*', but they may all be
374  // different actual classes based on the actions in place.
377 
379 
381 
382  // Parsing methods.
383 
384  /// Initialize - Warm up the parser.
385  ///
386  void Initialize();
387 
388  /// Parse the first top-level declaration in a translation unit.
389  bool ParseFirstTopLevelDecl(DeclGroupPtrTy &Result);
390 
391  /// ParseTopLevelDecl - Parse one top-level declaration. Returns true if
392  /// the EOF was encountered.
393  bool ParseTopLevelDecl(DeclGroupPtrTy &Result);
395  DeclGroupPtrTy Result;
396  return ParseTopLevelDecl(Result);
397  }
398 
399  /// ConsumeToken - Consume the current 'peek token' and lex the next one.
400  /// This does not work with special tokens: string literals, code completion,
401  /// annotation tokens and balanced tokens must be handled using the specific
402  /// consume methods.
403  /// Returns the location of the consumed token.
405  assert(!isTokenSpecial() &&
406  "Should consume special tokens with Consume*Token");
407  PrevTokLocation = Tok.getLocation();
408  PP.Lex(Tok);
409  return PrevTokLocation;
410  }
411 
413  if (Tok.isNot(Expected))
414  return false;
415  assert(!isTokenSpecial() &&
416  "Should consume special tokens with Consume*Token");
417  PrevTokLocation = Tok.getLocation();
418  PP.Lex(Tok);
419  return true;
420  }
421 
423  if (!TryConsumeToken(Expected))
424  return false;
425  Loc = PrevTokLocation;
426  return true;
427  }
428 
429  /// ConsumeAnyToken - Dispatch to the right Consume* method based on the
430  /// current token type. This should only be used in cases where the type of
431  /// the token really isn't known, e.g. in error recovery.
432  SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok = false) {
433  if (isTokenParen())
434  return ConsumeParen();
435  if (isTokenBracket())
436  return ConsumeBracket();
437  if (isTokenBrace())
438  return ConsumeBrace();
439  if (isTokenStringLiteral())
440  return ConsumeStringToken();
441  if (Tok.is(tok::code_completion))
442  return ConsumeCodeCompletionTok ? ConsumeCodeCompletionToken()
443  : handleUnexpectedCodeCompletionToken();
444  if (Tok.isAnnotation())
445  return ConsumeAnnotationToken();
446  return ConsumeToken();
447  }
448 
449 
451  return PP.getLocForEndOfToken(PrevTokLocation);
452  }
453 
454  /// Retrieve the underscored keyword (_Nonnull, _Nullable) that corresponds
455  /// to the given nullability kind.
457  return Actions.getNullabilityKeyword(nullability);
458  }
459 
460 private:
461  //===--------------------------------------------------------------------===//
462  // Low-Level token peeking and consumption methods.
463  //
464 
465  /// isTokenParen - Return true if the cur token is '(' or ')'.
466  bool isTokenParen() const {
467  return Tok.isOneOf(tok::l_paren, tok::r_paren);
468  }
469  /// isTokenBracket - Return true if the cur token is '[' or ']'.
470  bool isTokenBracket() const {
471  return Tok.isOneOf(tok::l_square, tok::r_square);
472  }
473  /// isTokenBrace - Return true if the cur token is '{' or '}'.
474  bool isTokenBrace() const {
475  return Tok.isOneOf(tok::l_brace, tok::r_brace);
476  }
477  /// isTokenStringLiteral - True if this token is a string-literal.
478  bool isTokenStringLiteral() const {
479  return tok::isStringLiteral(Tok.getKind());
480  }
481  /// isTokenSpecial - True if this token requires special consumption methods.
482  bool isTokenSpecial() const {
483  return isTokenStringLiteral() || isTokenParen() || isTokenBracket() ||
484  isTokenBrace() || Tok.is(tok::code_completion) || Tok.isAnnotation();
485  }
486 
487  /// Returns true if the current token is '=' or is a type of '='.
488  /// For typos, give a fixit to '='
489  bool isTokenEqualOrEqualTypo();
490 
491  /// Return the current token to the token stream and make the given
492  /// token the current token.
493  void UnconsumeToken(Token &Consumed) {
494  Token Next = Tok;
495  PP.EnterToken(Consumed);
496  PP.Lex(Tok);
497  PP.EnterToken(Next);
498  }
499 
500  SourceLocation ConsumeAnnotationToken() {
501  assert(Tok.isAnnotation() && "wrong consume method");
502  SourceLocation Loc = Tok.getLocation();
503  PrevTokLocation = Tok.getAnnotationEndLoc();
504  PP.Lex(Tok);
505  return Loc;
506  }
507 
508  /// ConsumeParen - This consume method keeps the paren count up-to-date.
509  ///
510  SourceLocation ConsumeParen() {
511  assert(isTokenParen() && "wrong consume method");
512  if (Tok.getKind() == tok::l_paren)
513  ++ParenCount;
514  else if (ParenCount) {
515  AngleBrackets.clear(*this);
516  --ParenCount; // Don't let unbalanced )'s drive the count negative.
517  }
518  PrevTokLocation = Tok.getLocation();
519  PP.Lex(Tok);
520  return PrevTokLocation;
521  }
522 
523  /// ConsumeBracket - This consume method keeps the bracket count up-to-date.
524  ///
525  SourceLocation ConsumeBracket() {
526  assert(isTokenBracket() && "wrong consume method");
527  if (Tok.getKind() == tok::l_square)
528  ++BracketCount;
529  else if (BracketCount) {
530  AngleBrackets.clear(*this);
531  --BracketCount; // Don't let unbalanced ]'s drive the count negative.
532  }
533 
534  PrevTokLocation = Tok.getLocation();
535  PP.Lex(Tok);
536  return PrevTokLocation;
537  }
538 
539  /// ConsumeBrace - This consume method keeps the brace count up-to-date.
540  ///
541  SourceLocation ConsumeBrace() {
542  assert(isTokenBrace() && "wrong consume method");
543  if (Tok.getKind() == tok::l_brace)
544  ++BraceCount;
545  else if (BraceCount) {
546  AngleBrackets.clear(*this);
547  --BraceCount; // Don't let unbalanced }'s drive the count negative.
548  }
549 
550  PrevTokLocation = Tok.getLocation();
551  PP.Lex(Tok);
552  return PrevTokLocation;
553  }
554 
555  /// ConsumeStringToken - Consume the current 'peek token', lexing a new one
556  /// and returning the token kind. This method is specific to strings, as it
557  /// handles string literal concatenation, as per C99 5.1.1.2, translation
558  /// phase #6.
559  SourceLocation ConsumeStringToken() {
560  assert(isTokenStringLiteral() &&
561  "Should only consume string literals with this method");
562  PrevTokLocation = Tok.getLocation();
563  PP.Lex(Tok);
564  return PrevTokLocation;
565  }
566 
567  /// Consume the current code-completion token.
568  ///
569  /// This routine can be called to consume the code-completion token and
570  /// continue processing in special cases where \c cutOffParsing() isn't
571  /// desired, such as token caching or completion with lookahead.
572  SourceLocation ConsumeCodeCompletionToken() {
573  assert(Tok.is(tok::code_completion));
574  PrevTokLocation = Tok.getLocation();
575  PP.Lex(Tok);
576  return PrevTokLocation;
577  }
578 
579  ///\ brief When we are consuming a code-completion token without having
580  /// matched specific position in the grammar, provide code-completion results
581  /// based on context.
582  ///
583  /// \returns the source location of the code-completion token.
584  SourceLocation handleUnexpectedCodeCompletionToken();
585 
586  /// Abruptly cut off parsing; mainly used when we have reached the
587  /// code-completion point.
588  void cutOffParsing() {
589  if (PP.isCodeCompletionEnabled())
591  // Cut off parsing by acting as if we reached the end-of-file.
592  Tok.setKind(tok::eof);
593  }
594 
595  /// Determine if we're at the end of the file or at a transition
596  /// between modules.
597  bool isEofOrEom() {
598  tok::TokenKind Kind = Tok.getKind();
599  return Kind == tok::eof || Kind == tok::annot_module_begin ||
600  Kind == tok::annot_module_end || Kind == tok::annot_module_include;
601  }
602 
603  /// Checks if the \p Level is valid for use in a fold expression.
604  bool isFoldOperator(prec::Level Level) const;
605 
606  /// Checks if the \p Kind is a valid operator for fold expressions.
607  bool isFoldOperator(tok::TokenKind Kind) const;
608 
609  /// Initialize all pragma handlers.
610  void initializePragmaHandlers();
611 
612  /// Destroy and reset all pragma handlers.
613  void resetPragmaHandlers();
614 
615  /// Handle the annotation token produced for #pragma unused(...)
616  void HandlePragmaUnused();
617 
618  /// Handle the annotation token produced for
619  /// #pragma GCC visibility...
620  void HandlePragmaVisibility();
621 
622  /// Handle the annotation token produced for
623  /// #pragma pack...
624  void HandlePragmaPack();
625 
626  /// Handle the annotation token produced for
627  /// #pragma ms_struct...
628  void HandlePragmaMSStruct();
629 
630  /// Handle the annotation token produced for
631  /// #pragma comment...
632  void HandlePragmaMSComment();
633 
634  void HandlePragmaMSPointersToMembers();
635 
636  void HandlePragmaMSVtorDisp();
637 
638  void HandlePragmaMSPragma();
639  bool HandlePragmaMSSection(StringRef PragmaName,
640  SourceLocation PragmaLocation);
641  bool HandlePragmaMSSegment(StringRef PragmaName,
642  SourceLocation PragmaLocation);
643  bool HandlePragmaMSInitSeg(StringRef PragmaName,
644  SourceLocation PragmaLocation);
645 
646  /// Handle the annotation token produced for
647  /// #pragma align...
648  void HandlePragmaAlign();
649 
650  /// Handle the annotation token produced for
651  /// #pragma clang __debug dump...
652  void HandlePragmaDump();
653 
654  /// Handle the annotation token produced for
655  /// #pragma weak id...
656  void HandlePragmaWeak();
657 
658  /// Handle the annotation token produced for
659  /// #pragma weak id = id...
660  void HandlePragmaWeakAlias();
661 
662  /// Handle the annotation token produced for
663  /// #pragma redefine_extname...
664  void HandlePragmaRedefineExtname();
665 
666  /// Handle the annotation token produced for
667  /// #pragma STDC FP_CONTRACT...
668  void HandlePragmaFPContract();
669 
670  /// Handle the annotation token produced for
671  /// #pragma clang fp ...
672  void HandlePragmaFP();
673 
674  /// Handle the annotation token produced for
675  /// #pragma OPENCL EXTENSION...
676  void HandlePragmaOpenCLExtension();
677 
678  /// Handle the annotation token produced for
679  /// #pragma clang __debug captured
680  StmtResult HandlePragmaCaptured();
681 
682  /// Handle the annotation token produced for
683  /// #pragma clang loop and #pragma unroll.
684  bool HandlePragmaLoopHint(LoopHint &Hint);
685 
686  bool ParsePragmaAttributeSubjectMatchRuleSet(
687  attr::ParsedSubjectMatchRuleSet &SubjectMatchRules,
688  SourceLocation &AnyLoc, SourceLocation &LastMatchRuleEndLoc);
689 
690  void HandlePragmaAttribute();
691 
692  /// GetLookAheadToken - This peeks ahead N tokens and returns that token
693  /// without consuming any tokens. LookAhead(0) returns 'Tok', LookAhead(1)
694  /// returns the token after Tok, etc.
695  ///
696  /// Note that this differs from the Preprocessor's LookAhead method, because
697  /// the Parser always has one token lexed that the preprocessor doesn't.
698  ///
699  const Token &GetLookAheadToken(unsigned N) {
700  if (N == 0 || Tok.is(tok::eof)) return Tok;
701  return PP.LookAhead(N-1);
702  }
703 
704 public:
705  /// NextToken - This peeks ahead one token and returns it without
706  /// consuming it.
707  const Token &NextToken() {
708  return PP.LookAhead(0);
709  }
710 
711  /// getTypeAnnotation - Read a parsed type out of an annotation token.
712  static ParsedType getTypeAnnotation(const Token &Tok) {
714  }
715 
716 private:
717  static void setTypeAnnotation(Token &Tok, ParsedType T) {
719  }
720 
721  /// Read an already-translated primary expression out of an annotation
722  /// token.
723  static ExprResult getExprAnnotation(const Token &Tok) {
724  return ExprResult::getFromOpaquePointer(Tok.getAnnotationValue());
725  }
726 
727  /// Set the primary expression corresponding to the given annotation
728  /// token.
729  static void setExprAnnotation(Token &Tok, ExprResult ER) {
730  Tok.setAnnotationValue(ER.getAsOpaquePointer());
731  }
732 
733 public:
734  // If NeedType is true, then TryAnnotateTypeOrScopeToken will try harder to
735  // find a type name by attempting typo correction.
738  bool IsNewScope);
739  bool TryAnnotateCXXScopeToken(bool EnteringContext = false);
740 
741 private:
742  enum AnnotatedNameKind {
743  /// Annotation has failed and emitted an error.
744  ANK_Error,
745  /// The identifier is a tentatively-declared name.
746  ANK_TentativeDecl,
747  /// The identifier is a template name. FIXME: Add an annotation for that.
748  ANK_TemplateName,
749  /// The identifier can't be resolved.
750  ANK_Unresolved,
751  /// Annotation was successful.
752  ANK_Success
753  };
754  AnnotatedNameKind
755  TryAnnotateName(bool IsAddressOfOperand,
756  std::unique_ptr<CorrectionCandidateCallback> CCC = nullptr);
757 
758  /// Push a tok::annot_cxxscope token onto the token stream.
759  void AnnotateScopeToken(CXXScopeSpec &SS, bool IsNewAnnotation);
760 
761  /// TryAltiVecToken - Check for context-sensitive AltiVec identifier tokens,
762  /// replacing them with the non-context-sensitive keywords. This returns
763  /// true if the token was replaced.
764  bool TryAltiVecToken(DeclSpec &DS, SourceLocation Loc,
765  const char *&PrevSpec, unsigned &DiagID,
766  bool &isInvalid) {
767  if (!getLangOpts().AltiVec && !getLangOpts().ZVector)
768  return false;
769 
770  if (Tok.getIdentifierInfo() != Ident_vector &&
771  Tok.getIdentifierInfo() != Ident_bool &&
772  (!getLangOpts().AltiVec || Tok.getIdentifierInfo() != Ident_pixel))
773  return false;
774 
775  return TryAltiVecTokenOutOfLine(DS, Loc, PrevSpec, DiagID, isInvalid);
776  }
777 
778  /// TryAltiVecVectorToken - Check for context-sensitive AltiVec vector
779  /// identifier token, replacing it with the non-context-sensitive __vector.
780  /// This returns true if the token was replaced.
781  bool TryAltiVecVectorToken() {
782  if ((!getLangOpts().AltiVec && !getLangOpts().ZVector) ||
783  Tok.getIdentifierInfo() != Ident_vector) return false;
784  return TryAltiVecVectorTokenOutOfLine();
785  }
786 
787  bool TryAltiVecVectorTokenOutOfLine();
788  bool TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc,
789  const char *&PrevSpec, unsigned &DiagID,
790  bool &isInvalid);
791 
792  /// Returns true if the current token is the identifier 'instancetype'.
793  ///
794  /// Should only be used in Objective-C language modes.
795  bool isObjCInstancetype() {
796  assert(getLangOpts().ObjC1);
797  if (Tok.isAnnotation())
798  return false;
799  if (!Ident_instancetype)
800  Ident_instancetype = PP.getIdentifierInfo("instancetype");
801  return Tok.getIdentifierInfo() == Ident_instancetype;
802  }
803 
804  /// TryKeywordIdentFallback - For compatibility with system headers using
805  /// keywords as identifiers, attempt to convert the current token to an
806  /// identifier and optionally disable the keyword for the remainder of the
807  /// translation unit. This returns false if the token was not replaced,
808  /// otherwise emits a diagnostic and returns true.
809  bool TryKeywordIdentFallback(bool DisableKeyword);
810 
811  /// Get the TemplateIdAnnotation from the token.
812  TemplateIdAnnotation *takeTemplateIdAnnotation(const Token &tok);
813 
814  /// TentativeParsingAction - An object that is used as a kind of "tentative
815  /// parsing transaction". It gets instantiated to mark the token position and
816  /// after the token consumption is done, Commit() or Revert() is called to
817  /// either "commit the consumed tokens" or revert to the previously marked
818  /// token position. Example:
819  ///
820  /// TentativeParsingAction TPA(*this);
821  /// ConsumeToken();
822  /// ....
823  /// TPA.Revert();
824  ///
825  class TentativeParsingAction {
826  Parser &P;
827  Token PrevTok;
828  size_t PrevTentativelyDeclaredIdentifierCount;
829  unsigned short PrevParenCount, PrevBracketCount, PrevBraceCount;
830  bool isActive;
831 
832  public:
833  explicit TentativeParsingAction(Parser& p) : P(p) {
834  PrevTok = P.Tok;
835  PrevTentativelyDeclaredIdentifierCount =
836  P.TentativelyDeclaredIdentifiers.size();
837  PrevParenCount = P.ParenCount;
838  PrevBracketCount = P.BracketCount;
839  PrevBraceCount = P.BraceCount;
841  isActive = true;
842  }
843  void Commit() {
844  assert(isActive && "Parsing action was finished!");
845  P.TentativelyDeclaredIdentifiers.resize(
846  PrevTentativelyDeclaredIdentifierCount);
848  isActive = false;
849  }
850  void Revert() {
851  assert(isActive && "Parsing action was finished!");
852  P.PP.Backtrack();
853  P.Tok = PrevTok;
854  P.TentativelyDeclaredIdentifiers.resize(
855  PrevTentativelyDeclaredIdentifierCount);
856  P.ParenCount = PrevParenCount;
857  P.BracketCount = PrevBracketCount;
858  P.BraceCount = PrevBraceCount;
859  isActive = false;
860  }
861  ~TentativeParsingAction() {
862  assert(!isActive && "Forgot to call Commit or Revert!");
863  }
864  };
865  /// A TentativeParsingAction that automatically reverts in its destructor.
866  /// Useful for disambiguation parses that will always be reverted.
867  class RevertingTentativeParsingAction
868  : private Parser::TentativeParsingAction {
869  public:
870  RevertingTentativeParsingAction(Parser &P)
871  : Parser::TentativeParsingAction(P) {}
872  ~RevertingTentativeParsingAction() { Revert(); }
873  };
874 
876 
877  /// ObjCDeclContextSwitch - An object used to switch context from
878  /// an objective-c decl context to its enclosing decl context and
879  /// back.
880  class ObjCDeclContextSwitch {
881  Parser &P;
882  Decl *DC;
883  SaveAndRestore<bool> WithinObjCContainer;
884  public:
885  explicit ObjCDeclContextSwitch(Parser &p)
886  : P(p), DC(p.getObjCDeclContext()),
887  WithinObjCContainer(P.ParsingInObjCContainer, DC != nullptr) {
888  if (DC)
889  P.Actions.ActOnObjCTemporaryExitContainerContext(cast<DeclContext>(DC));
890  }
892  if (DC)
893  P.Actions.ActOnObjCReenterContainerContext(cast<DeclContext>(DC));
894  }
895  };
896 
897  /// ExpectAndConsume - The parser expects that 'ExpectedTok' is next in the
898  /// input. If so, it is consumed and false is returned.
899  ///
900  /// If a trivial punctuator misspelling is encountered, a FixIt error
901  /// diagnostic is issued and false is returned after recovery.
902  ///
903  /// If the input is malformed, this emits the specified diagnostic and true is
904  /// returned.
905  bool ExpectAndConsume(tok::TokenKind ExpectedTok,
906  unsigned Diag = diag::err_expected,
907  StringRef DiagMsg = "");
908 
909  /// The parser expects a semicolon and, if present, will consume it.
910  ///
911  /// If the next token is not a semicolon, this emits the specified diagnostic,
912  /// or, if there's just some closing-delimiter noise (e.g., ')' or ']') prior
913  /// to the semicolon, consumes that extra token.
914  bool ExpectAndConsumeSemi(unsigned DiagID);
915 
916  /// The kind of extra semi diagnostic to emit.
917  enum ExtraSemiKind {
918  OutsideFunction = 0,
919  InsideStruct = 1,
920  InstanceVariableList = 2,
921  AfterMemberFunctionDefinition = 3
922  };
923 
924  /// Consume any extra semi-colons until the end of the line.
925  void ConsumeExtraSemi(ExtraSemiKind Kind, unsigned TST = TST_unspecified);
926 
927  /// Return false if the next token is an identifier. An 'expected identifier'
928  /// error is emitted otherwise.
929  ///
930  /// The parser tries to recover from the error by checking if the next token
931  /// is a C++ keyword when parsing Objective-C++. Return false if the recovery
932  /// was successful.
933  bool expectIdentifier();
934 
935 public:
936  //===--------------------------------------------------------------------===//
937  // Scope manipulation
938 
939  /// ParseScope - Introduces a new scope for parsing. The kind of
940  /// scope is determined by ScopeFlags. Objects of this type should
941  /// be created on the stack to coincide with the position where the
942  /// parser enters the new scope, and this object's constructor will
943  /// create that new scope. Similarly, once the object is destroyed
944  /// the parser will exit the scope.
945  class ParseScope {
946  Parser *Self;
947  ParseScope(const ParseScope &) = delete;
948  void operator=(const ParseScope &) = delete;
949 
950  public:
951  // ParseScope - Construct a new object to manage a scope in the
952  // parser Self where the new Scope is created with the flags
953  // ScopeFlags, but only when we aren't about to enter a compound statement.
954  ParseScope(Parser *Self, unsigned ScopeFlags, bool EnteredScope = true,
955  bool BeforeCompoundStmt = false)
956  : Self(Self) {
957  if (EnteredScope && !BeforeCompoundStmt)
958  Self->EnterScope(ScopeFlags);
959  else {
960  if (BeforeCompoundStmt)
962 
963  this->Self = nullptr;
964  }
965  }
966 
967  // Exit - Exit the scope associated with this object now, rather
968  // than waiting until the object is destroyed.
969  void Exit() {
970  if (Self) {
971  Self->ExitScope();
972  Self = nullptr;
973  }
974  }
975 
977  Exit();
978  }
979  };
980 
981  /// EnterScope - Start a new scope.
982  void EnterScope(unsigned ScopeFlags);
983 
984  /// ExitScope - Pop a scope off the scope stack.
985  void ExitScope();
986 
987 private:
988  /// RAII object used to modify the scope flags for the current scope.
989  class ParseScopeFlags {
990  Scope *CurScope;
991  unsigned OldFlags;
992  ParseScopeFlags(const ParseScopeFlags &) = delete;
993  void operator=(const ParseScopeFlags &) = delete;
994 
995  public:
996  ParseScopeFlags(Parser *Self, unsigned ScopeFlags, bool ManageFlags = true);
997  ~ParseScopeFlags();
998  };
999 
1000  //===--------------------------------------------------------------------===//
1001  // Diagnostic Emission and Error recovery.
1002 
1003 public:
1004  DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID);
1005  DiagnosticBuilder Diag(const Token &Tok, unsigned DiagID);
1006  DiagnosticBuilder Diag(unsigned DiagID) {
1007  return Diag(Tok, DiagID);
1008  }
1009 
1010 private:
1011  void SuggestParentheses(SourceLocation Loc, unsigned DK,
1012  SourceRange ParenRange);
1013  void CheckNestedObjCContexts(SourceLocation AtLoc);
1014 
1015 public:
1016 
1017  /// Control flags for SkipUntil functions.
1019  StopAtSemi = 1 << 0, ///< Stop skipping at semicolon
1020  /// Stop skipping at specified token, but don't skip the token itself
1022  StopAtCodeCompletion = 1 << 2 ///< Stop at code completion
1023  };
1024 
1026  SkipUntilFlags R) {
1027  return static_cast<SkipUntilFlags>(static_cast<unsigned>(L) |
1028  static_cast<unsigned>(R));
1029  }
1030 
1031  /// SkipUntil - Read tokens until we get to the specified token, then consume
1032  /// it (unless StopBeforeMatch is specified). Because we cannot guarantee
1033  /// that the token will ever occur, this skips to the next token, or to some
1034  /// likely good stopping point. If Flags has StopAtSemi flag, skipping will
1035  /// stop at a ';' character.
1036  ///
1037  /// If SkipUntil finds the specified token, it returns true, otherwise it
1038  /// returns false.
1040  SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) {
1041  return SkipUntil(llvm::makeArrayRef(T), Flags);
1042  }
1044  SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) {
1045  tok::TokenKind TokArray[] = {T1, T2};
1046  return SkipUntil(TokArray, Flags);
1047  }
1049  SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0)) {
1050  tok::TokenKind TokArray[] = {T1, T2, T3};
1051  return SkipUntil(TokArray, Flags);
1052  }
1054  SkipUntilFlags Flags = static_cast<SkipUntilFlags>(0));
1055 
1056  /// SkipMalformedDecl - Read tokens until we get to some likely good stopping
1057  /// point for skipping past a simple-declaration.
1058  void SkipMalformedDecl();
1059 
1060 private:
1061  //===--------------------------------------------------------------------===//
1062  // Lexing and parsing of C++ inline methods.
1063 
1064  struct ParsingClass;
1065 
1066  /// [class.mem]p1: "... the class is regarded as complete within
1067  /// - function bodies
1068  /// - default arguments
1069  /// - exception-specifications (TODO: C++0x)
1070  /// - and brace-or-equal-initializers for non-static data members
1071  /// (including such things in nested classes)."
1072  /// LateParsedDeclarations build the tree of those elements so they can
1073  /// be parsed after parsing the top-level class.
1074  class LateParsedDeclaration {
1075  public:
1076  virtual ~LateParsedDeclaration();
1077 
1078  virtual void ParseLexedMethodDeclarations();
1079  virtual void ParseLexedMemberInitializers();
1080  virtual void ParseLexedMethodDefs();
1081  virtual void ParseLexedAttributes();
1082  };
1083 
1084  /// Inner node of the LateParsedDeclaration tree that parses
1085  /// all its members recursively.
1086  class LateParsedClass : public LateParsedDeclaration {
1087  public:
1088  LateParsedClass(Parser *P, ParsingClass *C);
1089  ~LateParsedClass() override;
1090 
1091  void ParseLexedMethodDeclarations() override;
1092  void ParseLexedMemberInitializers() override;
1093  void ParseLexedMethodDefs() override;
1094  void ParseLexedAttributes() override;
1095 
1096  private:
1097  Parser *Self;
1098  ParsingClass *Class;
1099  };
1100 
1101  /// Contains the lexed tokens of an attribute with arguments that
1102  /// may reference member variables and so need to be parsed at the
1103  /// end of the class declaration after parsing all other member
1104  /// member declarations.
1105  /// FIXME: Perhaps we should change the name of LateParsedDeclaration to
1106  /// LateParsedTokens.
1107  struct LateParsedAttribute : public LateParsedDeclaration {
1108  Parser *Self;
1109  CachedTokens Toks;
1110  IdentifierInfo &AttrName;
1111  SourceLocation AttrNameLoc;
1112  SmallVector<Decl*, 2> Decls;
1113 
1114  explicit LateParsedAttribute(Parser *P, IdentifierInfo &Name,
1115  SourceLocation Loc)
1116  : Self(P), AttrName(Name), AttrNameLoc(Loc) {}
1117 
1118  void ParseLexedAttributes() override;
1119 
1120  void addDecl(Decl *D) { Decls.push_back(D); }
1121  };
1122 
1123  // A list of late-parsed attributes. Used by ParseGNUAttributes.
1124  class LateParsedAttrList: public SmallVector<LateParsedAttribute *, 2> {
1125  public:
1126  LateParsedAttrList(bool PSoon = false) : ParseSoon(PSoon) { }
1127 
1128  bool parseSoon() { return ParseSoon; }
1129 
1130  private:
1131  bool ParseSoon; // Are we planning to parse these shortly after creation?
1132  };
1133 
1134  /// Contains the lexed tokens of a member function definition
1135  /// which needs to be parsed at the end of the class declaration
1136  /// after parsing all other member declarations.
1137  struct LexedMethod : public LateParsedDeclaration {
1138  Parser *Self;
1139  Decl *D;
1140  CachedTokens Toks;
1141 
1142  /// Whether this member function had an associated template
1143  /// scope. When true, D is a template declaration.
1144  /// otherwise, it is a member function declaration.
1145  bool TemplateScope;
1146 
1147  explicit LexedMethod(Parser* P, Decl *MD)
1148  : Self(P), D(MD), TemplateScope(false) {}
1149 
1150  void ParseLexedMethodDefs() override;
1151  };
1152 
1153  /// LateParsedDefaultArgument - Keeps track of a parameter that may
1154  /// have a default argument that cannot be parsed yet because it
1155  /// occurs within a member function declaration inside the class
1156  /// (C++ [class.mem]p2).
1157  struct LateParsedDefaultArgument {
1158  explicit LateParsedDefaultArgument(Decl *P,
1159  std::unique_ptr<CachedTokens> Toks = nullptr)
1160  : Param(P), Toks(std::move(Toks)) { }
1161 
1162  /// Param - The parameter declaration for this parameter.
1163  Decl *Param;
1164 
1165  /// Toks - The sequence of tokens that comprises the default
1166  /// argument expression, not including the '=' or the terminating
1167  /// ')' or ','. This will be NULL for parameters that have no
1168  /// default argument.
1169  std::unique_ptr<CachedTokens> Toks;
1170  };
1171 
1172  /// LateParsedMethodDeclaration - A method declaration inside a class that
1173  /// contains at least one entity whose parsing needs to be delayed
1174  /// until the class itself is completely-defined, such as a default
1175  /// argument (C++ [class.mem]p2).
1176  struct LateParsedMethodDeclaration : public LateParsedDeclaration {
1177  explicit LateParsedMethodDeclaration(Parser *P, Decl *M)
1178  : Self(P), Method(M), TemplateScope(false),
1179  ExceptionSpecTokens(nullptr) {}
1180 
1181  void ParseLexedMethodDeclarations() override;
1182 
1183  Parser* Self;
1184 
1185  /// Method - The method declaration.
1186  Decl *Method;
1187 
1188  /// Whether this member function had an associated template
1189  /// scope. When true, D is a template declaration.
1190  /// otherwise, it is a member function declaration.
1191  bool TemplateScope;
1192 
1193  /// DefaultArgs - Contains the parameters of the function and
1194  /// their default arguments. At least one of the parameters will
1195  /// have a default argument, but all of the parameters of the
1196  /// method will be stored so that they can be reintroduced into
1197  /// scope at the appropriate times.
1199 
1200  /// The set of tokens that make up an exception-specification that
1201  /// has not yet been parsed.
1202  CachedTokens *ExceptionSpecTokens;
1203  };
1204 
1205  /// LateParsedMemberInitializer - An initializer for a non-static class data
1206  /// member whose parsing must to be delayed until the class is completely
1207  /// defined (C++11 [class.mem]p2).
1208  struct LateParsedMemberInitializer : public LateParsedDeclaration {
1209  LateParsedMemberInitializer(Parser *P, Decl *FD)
1210  : Self(P), Field(FD) { }
1211 
1212  void ParseLexedMemberInitializers() override;
1213 
1214  Parser *Self;
1215 
1216  /// Field - The field declaration.
1217  Decl *Field;
1218 
1219  /// CachedTokens - The sequence of tokens that comprises the initializer,
1220  /// including any leading '='.
1221  CachedTokens Toks;
1222  };
1223 
1224  /// LateParsedDeclarationsContainer - During parsing of a top (non-nested)
1225  /// C++ class, its method declarations that contain parts that won't be
1226  /// parsed until after the definition is completed (C++ [class.mem]p2),
1227  /// the method declarations and possibly attached inline definitions
1228  /// will be stored here with the tokens that will be parsed to create those
1229  /// entities.
1231 
1232  /// Representation of a class that has been parsed, including
1233  /// any member function declarations or definitions that need to be
1234  /// parsed after the corresponding top-level class is complete.
1235  struct ParsingClass {
1236  ParsingClass(Decl *TagOrTemplate, bool TopLevelClass, bool IsInterface)
1237  : TopLevelClass(TopLevelClass), TemplateScope(false),
1238  IsInterface(IsInterface), TagOrTemplate(TagOrTemplate) { }
1239 
1240  /// Whether this is a "top-level" class, meaning that it is
1241  /// not nested within another class.
1242  bool TopLevelClass : 1;
1243 
1244  /// Whether this class had an associated template
1245  /// scope. When true, TagOrTemplate is a template declaration;
1246  /// otherwise, it is a tag declaration.
1247  bool TemplateScope : 1;
1248 
1249  /// Whether this class is an __interface.
1250  bool IsInterface : 1;
1251 
1252  /// The class or class template whose definition we are parsing.
1253  Decl *TagOrTemplate;
1254 
1255  /// LateParsedDeclarations - Method declarations, inline definitions and
1256  /// nested classes that contain pieces whose parsing will be delayed until
1257  /// the top-level class is fully defined.
1258  LateParsedDeclarationsContainer LateParsedDeclarations;
1259  };
1260 
1261  /// The stack of classes that is currently being
1262  /// parsed. Nested and local classes will be pushed onto this stack
1263  /// when they are parsed, and removed afterward.
1264  std::stack<ParsingClass *> ClassStack;
1265 
1266  ParsingClass &getCurrentClass() {
1267  assert(!ClassStack.empty() && "No lexed method stacks!");
1268  return *ClassStack.top();
1269  }
1270 
1271  /// RAII object used to manage the parsing of a class definition.
1272  class ParsingClassDefinition {
1273  Parser &P;
1274  bool Popped;
1276 
1277  public:
1278  ParsingClassDefinition(Parser &P, Decl *TagOrTemplate, bool TopLevelClass,
1279  bool IsInterface)
1280  : P(P), Popped(false),
1281  State(P.PushParsingClass(TagOrTemplate, TopLevelClass, IsInterface)) {
1282  }
1283 
1284  /// Pop this class of the stack.
1285  void Pop() {
1286  assert(!Popped && "Nested class has already been popped");
1287  Popped = true;
1288  P.PopParsingClass(State);
1289  }
1290 
1291  ~ParsingClassDefinition() {
1292  if (!Popped)
1293  P.PopParsingClass(State);
1294  }
1295  };
1296 
1297  /// Contains information about any template-specific
1298  /// information that has been parsed prior to parsing declaration
1299  /// specifiers.
1300  struct ParsedTemplateInfo {
1301  ParsedTemplateInfo()
1302  : Kind(NonTemplate), TemplateParams(nullptr), TemplateLoc() { }
1303 
1304  ParsedTemplateInfo(TemplateParameterLists *TemplateParams,
1305  bool isSpecialization,
1306  bool lastParameterListWasEmpty = false)
1307  : Kind(isSpecialization? ExplicitSpecialization : Template),
1308  TemplateParams(TemplateParams),
1309  LastParameterListWasEmpty(lastParameterListWasEmpty) { }
1310 
1311  explicit ParsedTemplateInfo(SourceLocation ExternLoc,
1312  SourceLocation TemplateLoc)
1313  : Kind(ExplicitInstantiation), TemplateParams(nullptr),
1314  ExternLoc(ExternLoc), TemplateLoc(TemplateLoc),
1315  LastParameterListWasEmpty(false){ }
1316 
1317  /// The kind of template we are parsing.
1318  enum {
1319  /// We are not parsing a template at all.
1320  NonTemplate = 0,
1321  /// We are parsing a template declaration.
1322  Template,
1323  /// We are parsing an explicit specialization.
1324  ExplicitSpecialization,
1325  /// We are parsing an explicit instantiation.
1326  ExplicitInstantiation
1327  } Kind;
1328 
1329  /// The template parameter lists, for template declarations
1330  /// and explicit specializations.
1331  TemplateParameterLists *TemplateParams;
1332 
1333  /// The location of the 'extern' keyword, if any, for an explicit
1334  /// instantiation
1335  SourceLocation ExternLoc;
1336 
1337  /// The location of the 'template' keyword, for an explicit
1338  /// instantiation.
1339  SourceLocation TemplateLoc;
1340 
1341  /// Whether the last template parameter list was empty.
1342  bool LastParameterListWasEmpty;
1343 
1344  SourceRange getSourceRange() const LLVM_READONLY;
1345  };
1346 
1347  void LexTemplateFunctionForLateParsing(CachedTokens &Toks);
1348  void ParseLateTemplatedFuncDef(LateParsedTemplate &LPT);
1349 
1350  static void LateTemplateParserCallback(void *P, LateParsedTemplate &LPT);
1351  static void LateTemplateParserCleanupCallback(void *P);
1352 
1354  PushParsingClass(Decl *TagOrTemplate, bool TopLevelClass, bool IsInterface);
1355  void DeallocateParsedClasses(ParsingClass *Class);
1356  void PopParsingClass(Sema::ParsingClassState);
1357 
1358  enum CachedInitKind {
1359  CIK_DefaultArgument,
1360  CIK_DefaultInitializer
1361  };
1362 
1363  NamedDecl *ParseCXXInlineMethodDef(AccessSpecifier AS,
1364  ParsedAttributes &AccessAttrs,
1365  ParsingDeclarator &D,
1366  const ParsedTemplateInfo &TemplateInfo,
1367  const VirtSpecifiers &VS,
1368  SourceLocation PureSpecLoc);
1369  void ParseCXXNonStaticMemberInitializer(Decl *VarD);
1370  void ParseLexedAttributes(ParsingClass &Class);
1371  void ParseLexedAttributeList(LateParsedAttrList &LAs, Decl *D,
1372  bool EnterScope, bool OnDefinition);
1373  void ParseLexedAttribute(LateParsedAttribute &LA,
1374  bool EnterScope, bool OnDefinition);
1375  void ParseLexedMethodDeclarations(ParsingClass &Class);
1376  void ParseLexedMethodDeclaration(LateParsedMethodDeclaration &LM);
1377  void ParseLexedMethodDefs(ParsingClass &Class);
1378  void ParseLexedMethodDef(LexedMethod &LM);
1379  void ParseLexedMemberInitializers(ParsingClass &Class);
1380  void ParseLexedMemberInitializer(LateParsedMemberInitializer &MI);
1381  void ParseLexedObjCMethodDefs(LexedMethod &LM, bool parseMethod);
1382  bool ConsumeAndStoreFunctionPrologue(CachedTokens &Toks);
1383  bool ConsumeAndStoreInitializer(CachedTokens &Toks, CachedInitKind CIK);
1384  bool ConsumeAndStoreConditional(CachedTokens &Toks);
1385  bool ConsumeAndStoreUntil(tok::TokenKind T1,
1386  CachedTokens &Toks,
1387  bool StopAtSemi = true,
1388  bool ConsumeFinalToken = true) {
1389  return ConsumeAndStoreUntil(T1, T1, Toks, StopAtSemi, ConsumeFinalToken);
1390  }
1391  bool ConsumeAndStoreUntil(tok::TokenKind T1, tok::TokenKind T2,
1392  CachedTokens &Toks,
1393  bool StopAtSemi = true,
1394  bool ConsumeFinalToken = true);
1395 
1396  //===--------------------------------------------------------------------===//
1397  // C99 6.9: External Definitions.
1398  struct ParsedAttributesWithRange : ParsedAttributes {
1399  ParsedAttributesWithRange(AttributeFactory &factory)
1400  : ParsedAttributes(factory) {}
1401 
1402  void clear() {
1404  Range = SourceRange();
1405  }
1406 
1407  SourceRange Range;
1408  };
1409  struct ParsedAttributesViewWithRange : ParsedAttributesView {
1410  ParsedAttributesViewWithRange() : ParsedAttributesView() {}
1411  void clearListOnly() {
1413  Range = SourceRange();
1414  }
1415 
1416  SourceRange Range;
1417  };
1418 
1419  DeclGroupPtrTy ParseExternalDeclaration(ParsedAttributesWithRange &attrs,
1420  ParsingDeclSpec *DS = nullptr);
1421  bool isDeclarationAfterDeclarator();
1422  bool isStartOfFunctionDefinition(const ParsingDeclarator &Declarator);
1423  DeclGroupPtrTy ParseDeclarationOrFunctionDefinition(
1424  ParsedAttributesWithRange &attrs,
1425  ParsingDeclSpec *DS = nullptr,
1426  AccessSpecifier AS = AS_none);
1427  DeclGroupPtrTy ParseDeclOrFunctionDefInternal(ParsedAttributesWithRange &attrs,
1428  ParsingDeclSpec &DS,
1429  AccessSpecifier AS);
1430 
1431  void SkipFunctionBody();
1432  Decl *ParseFunctionDefinition(ParsingDeclarator &D,
1433  const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
1434  LateParsedAttrList *LateParsedAttrs = nullptr);
1435  void ParseKNRParamDeclarations(Declarator &D);
1436  // EndLoc, if non-NULL, is filled with the location of the last token of
1437  // the simple-asm.
1438  ExprResult ParseSimpleAsm(SourceLocation *EndLoc = nullptr);
1439  ExprResult ParseAsmStringLiteral();
1440 
1441  // Objective-C External Declarations
1442  void MaybeSkipAttributes(tok::ObjCKeywordKind Kind);
1443  DeclGroupPtrTy ParseObjCAtDirectives(ParsedAttributesWithRange &Attrs);
1444  DeclGroupPtrTy ParseObjCAtClassDeclaration(SourceLocation atLoc);
1445  Decl *ParseObjCAtInterfaceDeclaration(SourceLocation AtLoc,
1446  ParsedAttributes &prefixAttrs);
1447  class ObjCTypeParamListScope;
1448  ObjCTypeParamList *parseObjCTypeParamList();
1449  ObjCTypeParamList *parseObjCTypeParamListOrProtocolRefs(
1451  SmallVectorImpl<IdentifierLocPair> &protocolIdents,
1452  SourceLocation &rAngleLoc, bool mayBeProtocolList = true);
1453 
1454  void HelperActionsForIvarDeclarations(Decl *interfaceDecl, SourceLocation atLoc,
1456  SmallVectorImpl<Decl *> &AllIvarDecls,
1457  bool RBraceMissing);
1458  void ParseObjCClassInstanceVariables(Decl *interfaceDecl,
1459  tok::ObjCKeywordKind visibility,
1460  SourceLocation atLoc);
1461  bool ParseObjCProtocolReferences(SmallVectorImpl<Decl *> &P,
1463  bool WarnOnDeclarations,
1464  bool ForObjCContainer,
1465  SourceLocation &LAngleLoc,
1466  SourceLocation &EndProtoLoc,
1467  bool consumeLastToken);
1468 
1469  /// Parse the first angle-bracket-delimited clause for an
1470  /// Objective-C object or object pointer type, which may be either
1471  /// type arguments or protocol qualifiers.
1472  void parseObjCTypeArgsOrProtocolQualifiers(
1473  ParsedType baseType,
1474  SourceLocation &typeArgsLAngleLoc,
1475  SmallVectorImpl<ParsedType> &typeArgs,
1476  SourceLocation &typeArgsRAngleLoc,
1477  SourceLocation &protocolLAngleLoc,
1478  SmallVectorImpl<Decl *> &protocols,
1479  SmallVectorImpl<SourceLocation> &protocolLocs,
1480  SourceLocation &protocolRAngleLoc,
1481  bool consumeLastToken,
1482  bool warnOnIncompleteProtocols);
1483 
1484  /// Parse either Objective-C type arguments or protocol qualifiers; if the
1485  /// former, also parse protocol qualifiers afterward.
1486  void parseObjCTypeArgsAndProtocolQualifiers(
1487  ParsedType baseType,
1488  SourceLocation &typeArgsLAngleLoc,
1489  SmallVectorImpl<ParsedType> &typeArgs,
1490  SourceLocation &typeArgsRAngleLoc,
1491  SourceLocation &protocolLAngleLoc,
1492  SmallVectorImpl<Decl *> &protocols,
1493  SmallVectorImpl<SourceLocation> &protocolLocs,
1494  SourceLocation &protocolRAngleLoc,
1495  bool consumeLastToken);
1496 
1497  /// Parse a protocol qualifier type such as '<NSCopying>', which is
1498  /// an anachronistic way of writing 'id<NSCopying>'.
1499  TypeResult parseObjCProtocolQualifierType(SourceLocation &rAngleLoc);
1500 
1501  /// Parse Objective-C type arguments and protocol qualifiers, extending the
1502  /// current type with the parsed result.
1503  TypeResult parseObjCTypeArgsAndProtocolQualifiers(SourceLocation loc,
1504  ParsedType type,
1505  bool consumeLastToken,
1506  SourceLocation &endLoc);
1507 
1508  void ParseObjCInterfaceDeclList(tok::ObjCKeywordKind contextKey,
1509  Decl *CDecl);
1510  DeclGroupPtrTy ParseObjCAtProtocolDeclaration(SourceLocation atLoc,
1511  ParsedAttributes &prefixAttrs);
1512 
1513  struct ObjCImplParsingDataRAII {
1514  Parser &P;
1515  Decl *Dcl;
1516  bool HasCFunction;
1517  typedef SmallVector<LexedMethod*, 8> LateParsedObjCMethodContainer;
1518  LateParsedObjCMethodContainer LateParsedObjCMethods;
1519 
1520  ObjCImplParsingDataRAII(Parser &parser, Decl *D)
1521  : P(parser), Dcl(D), HasCFunction(false) {
1522  P.CurParsedObjCImpl = this;
1523  Finished = false;
1524  }
1525  ~ObjCImplParsingDataRAII();
1526 
1527  void finish(SourceRange AtEnd);
1528  bool isFinished() const { return Finished; }
1529 
1530  private:
1531  bool Finished;
1532  };
1533  ObjCImplParsingDataRAII *CurParsedObjCImpl;
1534  void StashAwayMethodOrFunctionBodyTokens(Decl *MDecl);
1535 
1536  DeclGroupPtrTy ParseObjCAtImplementationDeclaration(SourceLocation AtLoc);
1537  DeclGroupPtrTy ParseObjCAtEndDeclaration(SourceRange atEnd);
1538  Decl *ParseObjCAtAliasDeclaration(SourceLocation atLoc);
1539  Decl *ParseObjCPropertySynthesize(SourceLocation atLoc);
1540  Decl *ParseObjCPropertyDynamic(SourceLocation atLoc);
1541 
1542  IdentifierInfo *ParseObjCSelectorPiece(SourceLocation &MethodLocation);
1543  // Definitions for Objective-c context sensitive keywords recognition.
1544  enum ObjCTypeQual {
1545  objc_in=0, objc_out, objc_inout, objc_oneway, objc_bycopy, objc_byref,
1546  objc_nonnull, objc_nullable, objc_null_unspecified,
1547  objc_NumQuals
1548  };
1549  IdentifierInfo *ObjCTypeQuals[objc_NumQuals];
1550 
1551  bool isTokIdentifier_in() const;
1552 
1553  ParsedType ParseObjCTypeName(ObjCDeclSpec &DS, DeclaratorContext Ctx,
1554  ParsedAttributes *ParamAttrs);
1555  void ParseObjCMethodRequirement();
1556  Decl *ParseObjCMethodPrototype(
1557  tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword,
1558  bool MethodDefinition = true);
1559  Decl *ParseObjCMethodDecl(SourceLocation mLoc, tok::TokenKind mType,
1560  tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword,
1561  bool MethodDefinition=true);
1562  void ParseObjCPropertyAttribute(ObjCDeclSpec &DS);
1563 
1564  Decl *ParseObjCMethodDefinition();
1565 
1566 public:
1567  //===--------------------------------------------------------------------===//
1568  // C99 6.5: Expressions.
1569 
1570  /// TypeCastState - State whether an expression is or may be a type cast.
1575  };
1576 
1579  TypeCastState isTypeCast = NotTypeCast);
1583  // Expr that doesn't include commas.
1585 
1587  unsigned &NumLineToksConsumed,
1588  bool IsUnevaluated);
1589 
1590 private:
1591  ExprResult ParseExpressionWithLeadingAt(SourceLocation AtLoc);
1592 
1593  ExprResult ParseExpressionWithLeadingExtension(SourceLocation ExtLoc);
1594 
1595  ExprResult ParseRHSOfBinaryExpression(ExprResult LHS,
1596  prec::Level MinPrec);
1597  ExprResult ParseCastExpression(bool isUnaryExpression,
1598  bool isAddressOfOperand,
1599  bool &NotCastExpr,
1600  TypeCastState isTypeCast,
1601  bool isVectorLiteral = false);
1602  ExprResult ParseCastExpression(bool isUnaryExpression,
1603  bool isAddressOfOperand = false,
1604  TypeCastState isTypeCast = NotTypeCast,
1605  bool isVectorLiteral = false);
1606 
1607  /// Returns true if the next token cannot start an expression.
1608  bool isNotExpressionStart();
1609 
1610  /// Returns true if the next token would start a postfix-expression
1611  /// suffix.
1612  bool isPostfixExpressionSuffixStart() {
1613  tok::TokenKind K = Tok.getKind();
1614  return (K == tok::l_square || K == tok::l_paren ||
1615  K == tok::period || K == tok::arrow ||
1616  K == tok::plusplus || K == tok::minusminus);
1617  }
1618 
1619  bool diagnoseUnknownTemplateId(ExprResult TemplateName, SourceLocation Less);
1620  void checkPotentialAngleBracket(ExprResult &PotentialTemplateName);
1621  bool checkPotentialAngleBracketDelimiter(const AngleBracketTracker::Loc &,
1622  const Token &OpToken);
1623  bool checkPotentialAngleBracketDelimiter(const Token &OpToken) {
1624  if (auto *Info = AngleBrackets.getCurrent(*this))
1625  return checkPotentialAngleBracketDelimiter(*Info, OpToken);
1626  return false;
1627  }
1628 
1629  ExprResult ParsePostfixExpressionSuffix(ExprResult LHS);
1630  ExprResult ParseUnaryExprOrTypeTraitExpression();
1631  ExprResult ParseBuiltinPrimaryExpression();
1632 
1633  ExprResult ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok,
1634  bool &isCastExpr,
1635  ParsedType &CastTy,
1636  SourceRange &CastRange);
1637 
1640 
1641  /// ParseExpressionList - Used for C/C++ (argument-)expression-list.
1642  bool ParseExpressionList(
1643  SmallVectorImpl<Expr *> &Exprs,
1645  llvm::function_ref<void()> Completer = llvm::function_ref<void()>());
1646 
1647  /// ParseSimpleExpressionList - A simple comma-separated list of expressions,
1648  /// used for misc language extensions.
1649  bool ParseSimpleExpressionList(SmallVectorImpl<Expr*> &Exprs,
1650  SmallVectorImpl<SourceLocation> &CommaLocs);
1651 
1652 
1653  /// ParenParseOption - Control what ParseParenExpression will parse.
1654  enum ParenParseOption {
1655  SimpleExpr, // Only parse '(' expression ')'
1656  FoldExpr, // Also allow fold-expression <anything>
1657  CompoundStmt, // Also allow '(' compound-statement ')'
1658  CompoundLiteral, // Also allow '(' type-name ')' '{' ... '}'
1659  CastExpr // Also allow '(' type-name ')' <anything>
1660  };
1661  ExprResult ParseParenExpression(ParenParseOption &ExprType,
1662  bool stopIfCastExpr,
1663  bool isTypeCast,
1664  ParsedType &CastTy,
1665  SourceLocation &RParenLoc);
1666 
1667  ExprResult ParseCXXAmbiguousParenExpression(
1668  ParenParseOption &ExprType, ParsedType &CastTy,
1670  ExprResult ParseCompoundLiteralExpression(ParsedType Ty,
1671  SourceLocation LParenLoc,
1672  SourceLocation RParenLoc);
1673 
1674  ExprResult ParseStringLiteralExpression(bool AllowUserDefinedLiteral = false);
1675 
1676  ExprResult ParseGenericSelectionExpression();
1677 
1678  ExprResult ParseObjCBoolLiteral();
1679 
1680  ExprResult ParseFoldExpression(ExprResult LHS, BalancedDelimiterTracker &T);
1681 
1682  //===--------------------------------------------------------------------===//
1683  // C++ Expressions
1684  ExprResult tryParseCXXIdExpression(CXXScopeSpec &SS, bool isAddressOfOperand,
1685  Token &Replacement);
1686  ExprResult ParseCXXIdExpression(bool isAddressOfOperand = false);
1687 
1688  bool areTokensAdjacent(const Token &A, const Token &B);
1689 
1690  void CheckForTemplateAndDigraph(Token &Next, ParsedType ObjectTypePtr,
1691  bool EnteringContext, IdentifierInfo &II,
1692  CXXScopeSpec &SS);
1693 
1694  bool ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
1695  ParsedType ObjectType,
1696  bool EnteringContext,
1697  bool *MayBePseudoDestructor = nullptr,
1698  bool IsTypename = false,
1699  IdentifierInfo **LastII = nullptr,
1700  bool OnlyNamespace = false);
1701 
1702  //===--------------------------------------------------------------------===//
1703  // C++0x 5.1.2: Lambda expressions
1704 
1705  // [...] () -> type {...}
1706  ExprResult ParseLambdaExpression();
1707  ExprResult TryParseLambdaExpression();
1708  Optional<unsigned> ParseLambdaIntroducer(LambdaIntroducer &Intro,
1709  bool *SkippedInits = nullptr);
1710  bool TryParseLambdaIntroducer(LambdaIntroducer &Intro);
1711  ExprResult ParseLambdaExpressionAfterIntroducer(
1712  LambdaIntroducer &Intro);
1713 
1714  //===--------------------------------------------------------------------===//
1715  // C++ 5.2p1: C++ Casts
1716  ExprResult ParseCXXCasts();
1717 
1718  //===--------------------------------------------------------------------===//
1719  // C++ 5.2p1: C++ Type Identification
1720  ExprResult ParseCXXTypeid();
1721 
1722  //===--------------------------------------------------------------------===//
1723  // C++ : Microsoft __uuidof Expression
1724  ExprResult ParseCXXUuidof();
1725 
1726  //===--------------------------------------------------------------------===//
1727  // C++ 5.2.4: C++ Pseudo-Destructor Expressions
1728  ExprResult ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc,
1729  tok::TokenKind OpKind,
1730  CXXScopeSpec &SS,
1731  ParsedType ObjectType);
1732 
1733  //===--------------------------------------------------------------------===//
1734  // C++ 9.3.2: C++ 'this' pointer
1735  ExprResult ParseCXXThis();
1736 
1737  //===--------------------------------------------------------------------===//
1738  // C++ 15: C++ Throw Expression
1739  ExprResult ParseThrowExpression();
1740 
1741  ExceptionSpecificationType tryParseExceptionSpecification(
1742  bool Delayed,
1743  SourceRange &SpecificationRange,
1744  SmallVectorImpl<ParsedType> &DynamicExceptions,
1745  SmallVectorImpl<SourceRange> &DynamicExceptionRanges,
1746  ExprResult &NoexceptExpr,
1747  CachedTokens *&ExceptionSpecTokens);
1748 
1749  // EndLoc is filled with the location of the last token of the specification.
1750  ExceptionSpecificationType ParseDynamicExceptionSpecification(
1751  SourceRange &SpecificationRange,
1752  SmallVectorImpl<ParsedType> &Exceptions,
1754 
1755  //===--------------------------------------------------------------------===//
1756  // C++0x 8: Function declaration trailing-return-type
1757  TypeResult ParseTrailingReturnType(SourceRange &Range,
1758  bool MayBeFollowedByDirectInit);
1759 
1760  //===--------------------------------------------------------------------===//
1761  // C++ 2.13.5: C++ Boolean Literals
1762  ExprResult ParseCXXBoolLiteral();
1763 
1764  //===--------------------------------------------------------------------===//
1765  // C++ 5.2.3: Explicit type conversion (functional notation)
1766  ExprResult ParseCXXTypeConstructExpression(const DeclSpec &DS);
1767 
1768  /// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
1769  /// This should only be called when the current token is known to be part of
1770  /// simple-type-specifier.
1771  void ParseCXXSimpleTypeSpecifier(DeclSpec &DS);
1772 
1773  bool ParseCXXTypeSpecifierSeq(DeclSpec &DS);
1774 
1775  //===--------------------------------------------------------------------===//
1776  // C++ 5.3.4 and 5.3.5: C++ new and delete
1777  bool ParseExpressionListOrTypeId(SmallVectorImpl<Expr*> &Exprs,
1778  Declarator &D);
1779  void ParseDirectNewDeclarator(Declarator &D);
1780  ExprResult ParseCXXNewExpression(bool UseGlobal, SourceLocation Start);
1781  ExprResult ParseCXXDeleteExpression(bool UseGlobal,
1782  SourceLocation Start);
1783 
1784  //===--------------------------------------------------------------------===//
1785  // C++ if/switch/while condition expression.
1786  Sema::ConditionResult ParseCXXCondition(StmtResult *InitStmt,
1787  SourceLocation Loc,
1788  Sema::ConditionKind CK);
1789 
1790  //===--------------------------------------------------------------------===//
1791  // C++ Coroutines
1792 
1793  ExprResult ParseCoyieldExpression();
1794 
1795  //===--------------------------------------------------------------------===//
1796  // C99 6.7.8: Initialization.
1797 
1798  /// ParseInitializer
1799  /// initializer: [C99 6.7.8]
1800  /// assignment-expression
1801  /// '{' ...
1802  ExprResult ParseInitializer() {
1803  if (Tok.isNot(tok::l_brace))
1804  return ParseAssignmentExpression();
1805  return ParseBraceInitializer();
1806  }
1807  bool MayBeDesignationStart();
1808  ExprResult ParseBraceInitializer();
1809  ExprResult ParseInitializerWithPotentialDesignator();
1810 
1811  //===--------------------------------------------------------------------===//
1812  // clang Expressions
1813 
1814  ExprResult ParseBlockLiteralExpression(); // ^{...}
1815 
1816  //===--------------------------------------------------------------------===//
1817  // Objective-C Expressions
1818  ExprResult ParseObjCAtExpression(SourceLocation AtLocation);
1819  ExprResult ParseObjCStringLiteral(SourceLocation AtLoc);
1820  ExprResult ParseObjCCharacterLiteral(SourceLocation AtLoc);
1821  ExprResult ParseObjCNumericLiteral(SourceLocation AtLoc);
1822  ExprResult ParseObjCBooleanLiteral(SourceLocation AtLoc, bool ArgValue);
1823  ExprResult ParseObjCArrayLiteral(SourceLocation AtLoc);
1824  ExprResult ParseObjCDictionaryLiteral(SourceLocation AtLoc);
1825  ExprResult ParseObjCBoxedExpr(SourceLocation AtLoc);
1826  ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc);
1827  ExprResult ParseObjCSelectorExpression(SourceLocation AtLoc);
1828  ExprResult ParseObjCProtocolExpression(SourceLocation AtLoc);
1829  bool isSimpleObjCMessageExpression();
1830  ExprResult ParseObjCMessageExpression();
1831  ExprResult ParseObjCMessageExpressionBody(SourceLocation LBracloc,
1832  SourceLocation SuperLoc,
1833  ParsedType ReceiverType,
1834  Expr *ReceiverExpr);
1835  ExprResult ParseAssignmentExprWithObjCMessageExprStart(
1836  SourceLocation LBracloc, SourceLocation SuperLoc,
1837  ParsedType ReceiverType, Expr *ReceiverExpr);
1838  bool ParseObjCXXMessageReceiver(bool &IsExpr, void *&TypeOrExpr);
1839 
1840  //===--------------------------------------------------------------------===//
1841  // C99 6.8: Statements and Blocks.
1842 
1843  /// A SmallVector of statements, with stack size 32 (as that is the only one
1844  /// used.)
1846  /// A SmallVector of expressions, with stack size 12 (the maximum used.)
1848  /// A SmallVector of types.
1850 
1851  StmtResult ParseStatement(SourceLocation *TrailingElseLoc = nullptr,
1852  bool AllowOpenMPStandalone = false);
1853  enum AllowedConstructsKind {
1854  /// Allow any declarations, statements, OpenMP directives.
1855  ACK_Any,
1856  /// Allow only statements and non-standalone OpenMP directives.
1857  ACK_StatementsOpenMPNonStandalone,
1858  /// Allow statements and all executable OpenMP directives
1859  ACK_StatementsOpenMPAnyExecutable
1860  };
1861  StmtResult
1862  ParseStatementOrDeclaration(StmtVector &Stmts, AllowedConstructsKind Allowed,
1863  SourceLocation *TrailingElseLoc = nullptr);
1864  StmtResult ParseStatementOrDeclarationAfterAttributes(
1865  StmtVector &Stmts,
1866  AllowedConstructsKind Allowed,
1867  SourceLocation *TrailingElseLoc,
1868  ParsedAttributesWithRange &Attrs);
1869  StmtResult ParseExprStatement();
1870  StmtResult ParseLabeledStatement(ParsedAttributesWithRange &attrs);
1871  StmtResult ParseCaseStatement(bool MissingCase = false,
1872  ExprResult Expr = ExprResult());
1873  StmtResult ParseDefaultStatement();
1874  StmtResult ParseCompoundStatement(bool isStmtExpr = false);
1875  StmtResult ParseCompoundStatement(bool isStmtExpr,
1876  unsigned ScopeFlags);
1877  void ParseCompoundStatementLeadingPragmas();
1878  StmtResult ParseCompoundStatementBody(bool isStmtExpr = false);
1879  bool ParseParenExprOrCondition(StmtResult *InitStmt,
1880  Sema::ConditionResult &CondResult,
1881  SourceLocation Loc,
1882  Sema::ConditionKind CK);
1883  StmtResult ParseIfStatement(SourceLocation *TrailingElseLoc);
1884  StmtResult ParseSwitchStatement(SourceLocation *TrailingElseLoc);
1885  StmtResult ParseWhileStatement(SourceLocation *TrailingElseLoc);
1886  StmtResult ParseDoStatement();
1887  StmtResult ParseForStatement(SourceLocation *TrailingElseLoc);
1888  StmtResult ParseGotoStatement();
1889  StmtResult ParseContinueStatement();
1890  StmtResult ParseBreakStatement();
1891  StmtResult ParseReturnStatement();
1892  StmtResult ParseAsmStatement(bool &msAsm);
1893  StmtResult ParseMicrosoftAsmStatement(SourceLocation AsmLoc);
1894  StmtResult ParsePragmaLoopHint(StmtVector &Stmts,
1895  AllowedConstructsKind Allowed,
1896  SourceLocation *TrailingElseLoc,
1897  ParsedAttributesWithRange &Attrs);
1898 
1899  /// Describes the behavior that should be taken for an __if_exists
1900  /// block.
1901  enum IfExistsBehavior {
1902  /// Parse the block; this code is always used.
1903  IEB_Parse,
1904  /// Skip the block entirely; this code is never used.
1905  IEB_Skip,
1906  /// Parse the block as a dependent block, which may be used in
1907  /// some template instantiations but not others.
1908  IEB_Dependent
1909  };
1910 
1911  /// Describes the condition of a Microsoft __if_exists or
1912  /// __if_not_exists block.
1913  struct IfExistsCondition {
1914  /// The location of the initial keyword.
1915  SourceLocation KeywordLoc;
1916  /// Whether this is an __if_exists block (rather than an
1917  /// __if_not_exists block).
1918  bool IsIfExists;
1919 
1920  /// Nested-name-specifier preceding the name.
1921  CXXScopeSpec SS;
1922 
1923  /// The name we're looking for.
1924  UnqualifiedId Name;
1925 
1926  /// The behavior of this __if_exists or __if_not_exists block
1927  /// should.
1928  IfExistsBehavior Behavior;
1929  };
1930 
1931  bool ParseMicrosoftIfExistsCondition(IfExistsCondition& Result);
1932  void ParseMicrosoftIfExistsStatement(StmtVector &Stmts);
1933  void ParseMicrosoftIfExistsExternalDeclaration();
1934  void ParseMicrosoftIfExistsClassDeclaration(DeclSpec::TST TagType,
1935  ParsedAttributes &AccessAttrs,
1936  AccessSpecifier &CurAS);
1937  bool ParseMicrosoftIfExistsBraceInitializer(ExprVector &InitExprs,
1938  bool &InitExprsOk);
1939  bool ParseAsmOperandsOpt(SmallVectorImpl<IdentifierInfo *> &Names,
1940  SmallVectorImpl<Expr *> &Constraints,
1941  SmallVectorImpl<Expr *> &Exprs);
1942 
1943  //===--------------------------------------------------------------------===//
1944  // C++ 6: Statements and Blocks
1945 
1946  StmtResult ParseCXXTryBlock();
1947  StmtResult ParseCXXTryBlockCommon(SourceLocation TryLoc, bool FnTry = false);
1948  StmtResult ParseCXXCatchBlock(bool FnCatch = false);
1949 
1950  //===--------------------------------------------------------------------===//
1951  // MS: SEH Statements and Blocks
1952 
1953  StmtResult ParseSEHTryBlock();
1954  StmtResult ParseSEHExceptBlock(SourceLocation Loc);
1955  StmtResult ParseSEHFinallyBlock(SourceLocation Loc);
1956  StmtResult ParseSEHLeaveStatement();
1957 
1958  //===--------------------------------------------------------------------===//
1959  // Objective-C Statements
1960 
1961  StmtResult ParseObjCAtStatement(SourceLocation atLoc);
1962  StmtResult ParseObjCTryStmt(SourceLocation atLoc);
1963  StmtResult ParseObjCThrowStmt(SourceLocation atLoc);
1964  StmtResult ParseObjCSynchronizedStmt(SourceLocation atLoc);
1965  StmtResult ParseObjCAutoreleasePoolStmt(SourceLocation atLoc);
1966 
1967 
1968  //===--------------------------------------------------------------------===//
1969  // C99 6.7: Declarations.
1970 
1971  /// A context for parsing declaration specifiers. TODO: flesh this
1972  /// out, there are other significant restrictions on specifiers than
1973  /// would be best implemented in the parser.
1974  enum class DeclSpecContext {
1975  DSC_normal, // normal context
1976  DSC_class, // class context, enables 'friend'
1977  DSC_type_specifier, // C++ type-specifier-seq or C specifier-qualifier-list
1978  DSC_trailing, // C++11 trailing-type-specifier in a trailing return type
1979  DSC_alias_declaration, // C++11 type-specifier-seq in an alias-declaration
1980  DSC_top_level, // top-level/namespace declaration context
1981  DSC_template_param, // template parameter context
1982  DSC_template_type_arg, // template type argument context
1983  DSC_objc_method_result, // ObjC method result context, enables 'instancetype'
1984  DSC_condition // condition declaration context
1985  };
1986 
1987  /// Is this a context in which we are parsing just a type-specifier (or
1988  /// trailing-type-specifier)?
1989  static bool isTypeSpecifier(DeclSpecContext DSC) {
1990  switch (DSC) {
1991  case DeclSpecContext::DSC_normal:
1992  case DeclSpecContext::DSC_template_param:
1993  case DeclSpecContext::DSC_class:
1994  case DeclSpecContext::DSC_top_level:
1995  case DeclSpecContext::DSC_objc_method_result:
1996  case DeclSpecContext::DSC_condition:
1997  return false;
1998 
1999  case DeclSpecContext::DSC_template_type_arg:
2000  case DeclSpecContext::DSC_type_specifier:
2001  case DeclSpecContext::DSC_trailing:
2002  case DeclSpecContext::DSC_alias_declaration:
2003  return true;
2004  }
2005  llvm_unreachable("Missing DeclSpecContext case");
2006  }
2007 
2008  /// Is this a context in which we can perform class template argument
2009  /// deduction?
2010  static bool isClassTemplateDeductionContext(DeclSpecContext DSC) {
2011  switch (DSC) {
2012  case DeclSpecContext::DSC_normal:
2013  case DeclSpecContext::DSC_template_param:
2014  case DeclSpecContext::DSC_class:
2015  case DeclSpecContext::DSC_top_level:
2016  case DeclSpecContext::DSC_condition:
2017  case DeclSpecContext::DSC_type_specifier:
2018  return true;
2019 
2020  case DeclSpecContext::DSC_objc_method_result:
2021  case DeclSpecContext::DSC_template_type_arg:
2022  case DeclSpecContext::DSC_trailing:
2023  case DeclSpecContext::DSC_alias_declaration:
2024  return false;
2025  }
2026  llvm_unreachable("Missing DeclSpecContext case");
2027  }
2028 
2029  /// Information on a C++0x for-range-initializer found while parsing a
2030  /// declaration which turns out to be a for-range-declaration.
2031  struct ForRangeInit {
2033  ExprResult RangeExpr;
2034 
2035  bool ParsedForRangeDecl() { return !ColonLoc.isInvalid(); }
2036  };
2037 
2038  DeclGroupPtrTy ParseDeclaration(DeclaratorContext Context,
2039  SourceLocation &DeclEnd,
2040  ParsedAttributesWithRange &attrs);
2041  DeclGroupPtrTy ParseSimpleDeclaration(DeclaratorContext Context,
2042  SourceLocation &DeclEnd,
2043  ParsedAttributesWithRange &attrs,
2044  bool RequireSemi,
2045  ForRangeInit *FRI = nullptr);
2046  bool MightBeDeclarator(DeclaratorContext Context);
2047  DeclGroupPtrTy ParseDeclGroup(ParsingDeclSpec &DS, DeclaratorContext Context,
2048  SourceLocation *DeclEnd = nullptr,
2049  ForRangeInit *FRI = nullptr);
2050  Decl *ParseDeclarationAfterDeclarator(Declarator &D,
2051  const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo());
2052  bool ParseAsmAttributesAfterDeclarator(Declarator &D);
2053  Decl *ParseDeclarationAfterDeclaratorAndAttributes(
2054  Declarator &D,
2055  const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
2056  ForRangeInit *FRI = nullptr);
2057  Decl *ParseFunctionStatementBody(Decl *Decl, ParseScope &BodyScope);
2058  Decl *ParseFunctionTryBlock(Decl *Decl, ParseScope &BodyScope);
2059 
2060  /// When in code-completion, skip parsing of the function/method body
2061  /// unless the body contains the code-completion point.
2062  ///
2063  /// \returns true if the function body was skipped.
2064  bool trySkippingFunctionBody();
2065 
2066  bool ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
2067  const ParsedTemplateInfo &TemplateInfo,
2068  AccessSpecifier AS, DeclSpecContext DSC,
2069  ParsedAttributesWithRange &Attrs);
2070  DeclSpecContext
2071  getDeclSpecContextFromDeclaratorContext(DeclaratorContext Context);
2072  void ParseDeclarationSpecifiers(
2073  DeclSpec &DS,
2074  const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
2075  AccessSpecifier AS = AS_none,
2076  DeclSpecContext DSC = DeclSpecContext::DSC_normal,
2077  LateParsedAttrList *LateAttrs = nullptr);
2078  bool DiagnoseMissingSemiAfterTagDefinition(
2079  DeclSpec &DS, AccessSpecifier AS, DeclSpecContext DSContext,
2080  LateParsedAttrList *LateAttrs = nullptr);
2081 
2082  void ParseSpecifierQualifierList(
2083  DeclSpec &DS, AccessSpecifier AS = AS_none,
2084  DeclSpecContext DSC = DeclSpecContext::DSC_normal);
2085 
2086  void ParseObjCTypeQualifierList(ObjCDeclSpec &DS,
2087  DeclaratorContext Context);
2088 
2089  void ParseEnumSpecifier(SourceLocation TagLoc, DeclSpec &DS,
2090  const ParsedTemplateInfo &TemplateInfo,
2091  AccessSpecifier AS, DeclSpecContext DSC);
2092  void ParseEnumBody(SourceLocation StartLoc, Decl *TagDecl);
2093  void ParseStructUnionBody(SourceLocation StartLoc, unsigned TagType,
2094  Decl *TagDecl);
2095 
2096  void ParseStructDeclaration(
2097  ParsingDeclSpec &DS,
2098  llvm::function_ref<void(ParsingFieldDeclarator &)> FieldsCallback);
2099 
2100  bool isDeclarationSpecifier(bool DisambiguatingWithExpression = false);
2101  bool isTypeSpecifierQualifier();
2102 
2103  /// isKnownToBeTypeSpecifier - Return true if we know that the specified token
2104  /// is definitely a type-specifier. Return false if it isn't part of a type
2105  /// specifier or if we're not sure.
2106  bool isKnownToBeTypeSpecifier(const Token &Tok) const;
2107 
2108  /// Return true if we know that we are definitely looking at a
2109  /// decl-specifier, and isn't part of an expression such as a function-style
2110  /// cast. Return false if it's no a decl-specifier, or we're not sure.
2111  bool isKnownToBeDeclarationSpecifier() {
2112  if (getLangOpts().CPlusPlus)
2113  return isCXXDeclarationSpecifier() == TPResult::True;
2114  return isDeclarationSpecifier(true);
2115  }
2116 
2117  /// isDeclarationStatement - Disambiguates between a declaration or an
2118  /// expression statement, when parsing function bodies.
2119  /// Returns true for declaration, false for expression.
2120  bool isDeclarationStatement() {
2121  if (getLangOpts().CPlusPlus)
2122  return isCXXDeclarationStatement();
2123  return isDeclarationSpecifier(true);
2124  }
2125 
2126  /// isForInitDeclaration - Disambiguates between a declaration or an
2127  /// expression in the context of the C 'clause-1' or the C++
2128  // 'for-init-statement' part of a 'for' statement.
2129  /// Returns true for declaration, false for expression.
2130  bool isForInitDeclaration() {
2131  if (getLangOpts().CPlusPlus)
2132  return isCXXSimpleDeclaration(/*AllowForRangeDecl=*/true);
2133  return isDeclarationSpecifier(true);
2134  }
2135 
2136  /// Determine whether this is a C++1z for-range-identifier.
2137  bool isForRangeIdentifier();
2138 
2139  /// Determine whether we are currently at the start of an Objective-C
2140  /// class message that appears to be missing the open bracket '['.
2141  bool isStartOfObjCClassMessageMissingOpenBracket();
2142 
2143  /// Starting with a scope specifier, identifier, or
2144  /// template-id that refers to the current class, determine whether
2145  /// this is a constructor declarator.
2146  bool isConstructorDeclarator(bool Unqualified, bool DeductionGuide = false);
2147 
2148  /// Specifies the context in which type-id/expression
2149  /// disambiguation will occur.
2150  enum TentativeCXXTypeIdContext {
2151  TypeIdInParens,
2152  TypeIdUnambiguous,
2153  TypeIdAsTemplateArgument
2154  };
2155 
2156 
2157  /// isTypeIdInParens - Assumes that a '(' was parsed and now we want to know
2158  /// whether the parens contain an expression or a type-id.
2159  /// Returns true for a type-id and false for an expression.
2160  bool isTypeIdInParens(bool &isAmbiguous) {
2161  if (getLangOpts().CPlusPlus)
2162  return isCXXTypeId(TypeIdInParens, isAmbiguous);
2163  isAmbiguous = false;
2164  return isTypeSpecifierQualifier();
2165  }
2166  bool isTypeIdInParens() {
2167  bool isAmbiguous;
2168  return isTypeIdInParens(isAmbiguous);
2169  }
2170 
2171  /// Checks if the current tokens form type-id or expression.
2172  /// It is similar to isTypeIdInParens but does not suppose that type-id
2173  /// is in parenthesis.
2174  bool isTypeIdUnambiguously() {
2175  bool IsAmbiguous;
2176  if (getLangOpts().CPlusPlus)
2177  return isCXXTypeId(TypeIdUnambiguous, IsAmbiguous);
2178  return isTypeSpecifierQualifier();
2179  }
2180 
2181  /// isCXXDeclarationStatement - C++-specialized function that disambiguates
2182  /// between a declaration or an expression statement, when parsing function
2183  /// bodies. Returns true for declaration, false for expression.
2184  bool isCXXDeclarationStatement();
2185 
2186  /// isCXXSimpleDeclaration - C++-specialized function that disambiguates
2187  /// between a simple-declaration or an expression-statement.
2188  /// If during the disambiguation process a parsing error is encountered,
2189  /// the function returns true to let the declaration parsing code handle it.
2190  /// Returns false if the statement is disambiguated as expression.
2191  bool isCXXSimpleDeclaration(bool AllowForRangeDecl);
2192 
2193  /// isCXXFunctionDeclarator - Disambiguates between a function declarator or
2194  /// a constructor-style initializer, when parsing declaration statements.
2195  /// Returns true for function declarator and false for constructor-style
2196  /// initializer. Sets 'IsAmbiguous' to true to indicate that this declaration
2197  /// might be a constructor-style initializer.
2198  /// If during the disambiguation process a parsing error is encountered,
2199  /// the function returns true to let the declaration parsing code handle it.
2200  bool isCXXFunctionDeclarator(bool *IsAmbiguous = nullptr);
2201 
2203  enum class ConditionOrInitStatement {
2204  Expression, ///< Disambiguated as an expression (either kind).
2205  ConditionDecl, ///< Disambiguated as the declaration form of condition.
2206  InitStmtDecl, ///< Disambiguated as a simple-declaration init-statement.
2207  Error ///< Can't be any of the above!
2208  };
2209  /// Disambiguates between the different kinds of things that can happen
2210  /// after 'if (' or 'switch ('. This could be one of two different kinds of
2211  /// declaration (depending on whether there is a ';' later) or an expression.
2212  ConditionOrInitStatement
2213  isCXXConditionDeclarationOrInitStatement(bool CanBeInitStmt);
2214 
2215  bool isCXXTypeId(TentativeCXXTypeIdContext Context, bool &isAmbiguous);
2216  bool isCXXTypeId(TentativeCXXTypeIdContext Context) {
2217  bool isAmbiguous;
2218  return isCXXTypeId(Context, isAmbiguous);
2219  }
2220 
2221  /// TPResult - Used as the result value for functions whose purpose is to
2222  /// disambiguate C++ constructs by "tentatively parsing" them.
2223  enum class TPResult {
2224  True, False, Ambiguous, Error
2225  };
2226 
2227  /// Based only on the given token kind, determine whether we know that
2228  /// we're at the start of an expression or a type-specifier-seq (which may
2229  /// be an expression, in C++).
2230  ///
2231  /// This routine does not attempt to resolve any of the trick cases, e.g.,
2232  /// those involving lookup of identifiers.
2233  ///
2234  /// \returns \c TPR_true if this token starts an expression, \c TPR_false if
2235  /// this token starts a type-specifier-seq, or \c TPR_ambiguous if it cannot
2236  /// tell.
2237  TPResult isExpressionOrTypeSpecifierSimple(tok::TokenKind Kind);
2238 
2239  /// isCXXDeclarationSpecifier - Returns TPResult::True if it is a
2240  /// declaration specifier, TPResult::False if it is not,
2241  /// TPResult::Ambiguous if it could be either a decl-specifier or a
2242  /// function-style cast, and TPResult::Error if a parsing error was
2243  /// encountered. If it could be a braced C++11 function-style cast, returns
2244  /// BracedCastResult.
2245  /// Doesn't consume tokens.
2246  TPResult
2247  isCXXDeclarationSpecifier(TPResult BracedCastResult = TPResult::False,
2248  bool *HasMissingTypename = nullptr);
2249 
2250  /// Given that isCXXDeclarationSpecifier returns \c TPResult::True or
2251  /// \c TPResult::Ambiguous, determine whether the decl-specifier would be
2252  /// a type-specifier other than a cv-qualifier.
2253  bool isCXXDeclarationSpecifierAType();
2254 
2255  /// Determine whether an identifier has been tentatively declared as a
2256  /// non-type. Such tentative declarations should not be found to name a type
2257  /// during a tentative parse, but also should not be annotated as a non-type.
2258  bool isTentativelyDeclared(IdentifierInfo *II);
2259 
2260  // "Tentative parsing" functions, used for disambiguation. If a parsing error
2261  // is encountered they will return TPResult::Error.
2262  // Returning TPResult::True/False indicates that the ambiguity was
2263  // resolved and tentative parsing may stop. TPResult::Ambiguous indicates
2264  // that more tentative parsing is necessary for disambiguation.
2265  // They all consume tokens, so backtracking should be used after calling them.
2266 
2267  TPResult TryParseSimpleDeclaration(bool AllowForRangeDecl);
2268  TPResult TryParseTypeofSpecifier();
2269  TPResult TryParseProtocolQualifiers();
2270  TPResult TryParsePtrOperatorSeq();
2271  TPResult TryParseOperatorId();
2272  TPResult TryParseInitDeclaratorList();
2273  TPResult TryParseDeclarator(bool mayBeAbstract, bool mayHaveIdentifier = true,
2274  bool mayHaveDirectInit = false);
2275  TPResult
2276  TryParseParameterDeclarationClause(bool *InvalidAsDeclaration = nullptr,
2277  bool VersusTemplateArg = false);
2278  TPResult TryParseFunctionDeclarator();
2279  TPResult TryParseBracketDeclarator();
2280  TPResult TryConsumeDeclarationSpecifier();
2281 
2282 public:
2283  TypeResult ParseTypeName(SourceRange *Range = nullptr,
2284  DeclaratorContext Context
2286  AccessSpecifier AS = AS_none,
2287  Decl **OwnedType = nullptr,
2288  ParsedAttributes *Attrs = nullptr);
2289 
2290 private:
2291  void ParseBlockId(SourceLocation CaretLoc);
2292 
2293  /// Are [[]] attributes enabled?
2294  bool standardAttributesAllowed() const {
2295  const LangOptions &LO = getLangOpts();
2296  return LO.DoubleSquareBracketAttributes;
2297  }
2298 
2299  // Check for the start of an attribute-specifier-seq in a context where an
2300  // attribute is not allowed.
2301  bool CheckProhibitedCXX11Attribute() {
2302  assert(Tok.is(tok::l_square));
2303  if (!standardAttributesAllowed() || NextToken().isNot(tok::l_square))
2304  return false;
2305  return DiagnoseProhibitedCXX11Attribute();
2306  }
2307 
2308  bool DiagnoseProhibitedCXX11Attribute();
2309  void CheckMisplacedCXX11Attribute(ParsedAttributesWithRange &Attrs,
2310  SourceLocation CorrectLocation) {
2311  if (!standardAttributesAllowed())
2312  return;
2313  if ((Tok.isNot(tok::l_square) || NextToken().isNot(tok::l_square)) &&
2314  Tok.isNot(tok::kw_alignas))
2315  return;
2316  DiagnoseMisplacedCXX11Attribute(Attrs, CorrectLocation);
2317  }
2318  void DiagnoseMisplacedCXX11Attribute(ParsedAttributesWithRange &Attrs,
2319  SourceLocation CorrectLocation);
2320 
2321  void stripTypeAttributesOffDeclSpec(ParsedAttributesWithRange &Attrs,
2322  DeclSpec &DS, Sema::TagUseKind TUK);
2323 
2324  // FixItLoc = possible correct location for the attributes
2325  void ProhibitAttributes(ParsedAttributesWithRange &Attrs,
2326  SourceLocation FixItLoc = SourceLocation()) {
2327  if (Attrs.Range.isInvalid())
2328  return;
2329  DiagnoseProhibitedAttributes(Attrs.Range, FixItLoc);
2330  Attrs.clear();
2331  }
2332 
2333  void ProhibitAttributes(ParsedAttributesViewWithRange &Attrs,
2334  SourceLocation FixItLoc = SourceLocation()) {
2335  if (Attrs.Range.isInvalid())
2336  return;
2337  DiagnoseProhibitedAttributes(Attrs.Range, FixItLoc);
2338  Attrs.clearListOnly();
2339  }
2340  void DiagnoseProhibitedAttributes(const SourceRange &Range,
2341  SourceLocation FixItLoc);
2342 
2343  // Forbid C++11 and C2x attributes that appear on certain syntactic locations
2344  // which standard permits but we don't supported yet, for example, attributes
2345  // appertain to decl specifiers.
2346  void ProhibitCXX11Attributes(ParsedAttributesWithRange &Attrs,
2347  unsigned DiagID);
2348 
2349  /// Skip C++11 and C2x attributes and return the end location of the
2350  /// last one.
2351  /// \returns SourceLocation() if there are no attributes.
2352  SourceLocation SkipCXX11Attributes();
2353 
2354  /// Diagnose and skip C++11 and C2x attributes that appear in syntactic
2355  /// locations where attributes are not allowed.
2356  void DiagnoseAndSkipCXX11Attributes();
2357 
2358  /// Parses syntax-generic attribute arguments for attributes which are
2359  /// known to the implementation, and adds them to the given ParsedAttributes
2360  /// list with the given attribute syntax. Returns the number of arguments
2361  /// parsed for the attribute.
2362  unsigned
2363  ParseAttributeArgsCommon(IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
2364  ParsedAttributes &Attrs, SourceLocation *EndLoc,
2365  IdentifierInfo *ScopeName, SourceLocation ScopeLoc,
2366  ParsedAttr::Syntax Syntax);
2367 
2368  void MaybeParseGNUAttributes(Declarator &D,
2369  LateParsedAttrList *LateAttrs = nullptr) {
2370  if (Tok.is(tok::kw___attribute)) {
2371  ParsedAttributes attrs(AttrFactory);
2372  SourceLocation endLoc;
2373  ParseGNUAttributes(attrs, &endLoc, LateAttrs, &D);
2374  D.takeAttributes(attrs, endLoc);
2375  }
2376  }
2377  void MaybeParseGNUAttributes(ParsedAttributes &attrs,
2378  SourceLocation *endLoc = nullptr,
2379  LateParsedAttrList *LateAttrs = nullptr) {
2380  if (Tok.is(tok::kw___attribute))
2381  ParseGNUAttributes(attrs, endLoc, LateAttrs);
2382  }
2383  void ParseGNUAttributes(ParsedAttributes &attrs,
2384  SourceLocation *endLoc = nullptr,
2385  LateParsedAttrList *LateAttrs = nullptr,
2386  Declarator *D = nullptr);
2387  void ParseGNUAttributeArgs(IdentifierInfo *AttrName,
2388  SourceLocation AttrNameLoc,
2389  ParsedAttributes &Attrs, SourceLocation *EndLoc,
2390  IdentifierInfo *ScopeName, SourceLocation ScopeLoc,
2391  ParsedAttr::Syntax Syntax, Declarator *D);
2392  IdentifierLoc *ParseIdentifierLoc();
2393 
2394  unsigned
2395  ParseClangAttributeArgs(IdentifierInfo *AttrName, SourceLocation AttrNameLoc,
2396  ParsedAttributes &Attrs, SourceLocation *EndLoc,
2397  IdentifierInfo *ScopeName, SourceLocation ScopeLoc,
2398  ParsedAttr::Syntax Syntax);
2399 
2400  void MaybeParseCXX11Attributes(Declarator &D) {
2401  if (standardAttributesAllowed() && isCXX11AttributeSpecifier()) {
2402  ParsedAttributesWithRange attrs(AttrFactory);
2403  SourceLocation endLoc;
2404  ParseCXX11Attributes(attrs, &endLoc);
2405  D.takeAttributes(attrs, endLoc);
2406  }
2407  }
2408  void MaybeParseCXX11Attributes(ParsedAttributes &attrs,
2409  SourceLocation *endLoc = nullptr) {
2410  if (standardAttributesAllowed() && isCXX11AttributeSpecifier()) {
2411  ParsedAttributesWithRange attrsWithRange(AttrFactory);
2412  ParseCXX11Attributes(attrsWithRange, endLoc);
2413  attrs.takeAllFrom(attrsWithRange);
2414  }
2415  }
2416  void MaybeParseCXX11Attributes(ParsedAttributesWithRange &attrs,
2417  SourceLocation *endLoc = nullptr,
2418  bool OuterMightBeMessageSend = false) {
2419  if (standardAttributesAllowed() &&
2420  isCXX11AttributeSpecifier(false, OuterMightBeMessageSend))
2421  ParseCXX11Attributes(attrs, endLoc);
2422  }
2423 
2424  void ParseCXX11AttributeSpecifier(ParsedAttributes &attrs,
2425  SourceLocation *EndLoc = nullptr);
2426  void ParseCXX11Attributes(ParsedAttributesWithRange &attrs,
2427  SourceLocation *EndLoc = nullptr);
2428  /// Parses a C++11 (or C2x)-style attribute argument list. Returns true
2429  /// if this results in adding an attribute to the ParsedAttributes list.
2430  bool ParseCXX11AttributeArgs(IdentifierInfo *AttrName,
2431  SourceLocation AttrNameLoc,
2432  ParsedAttributes &Attrs, SourceLocation *EndLoc,
2433  IdentifierInfo *ScopeName,
2434  SourceLocation ScopeLoc);
2435 
2436  IdentifierInfo *TryParseCXX11AttributeIdentifier(SourceLocation &Loc);
2437 
2438  void MaybeParseMicrosoftAttributes(ParsedAttributes &attrs,
2439  SourceLocation *endLoc = nullptr) {
2440  if (getLangOpts().MicrosoftExt && Tok.is(tok::l_square))
2441  ParseMicrosoftAttributes(attrs, endLoc);
2442  }
2443  void ParseMicrosoftUuidAttributeArgs(ParsedAttributes &Attrs);
2444  void ParseMicrosoftAttributes(ParsedAttributes &attrs,
2445  SourceLocation *endLoc = nullptr);
2446  void MaybeParseMicrosoftDeclSpecs(ParsedAttributes &Attrs,
2447  SourceLocation *End = nullptr) {
2448  const auto &LO = getLangOpts();
2449  if (LO.DeclSpecKeyword && Tok.is(tok::kw___declspec))
2450  ParseMicrosoftDeclSpecs(Attrs, End);
2451  }
2452  void ParseMicrosoftDeclSpecs(ParsedAttributes &Attrs,
2453  SourceLocation *End = nullptr);
2454  bool ParseMicrosoftDeclSpecArgs(IdentifierInfo *AttrName,
2455  SourceLocation AttrNameLoc,
2456  ParsedAttributes &Attrs);
2457  void ParseMicrosoftTypeAttributes(ParsedAttributes &attrs);
2458  void DiagnoseAndSkipExtendedMicrosoftTypeAttributes();
2459  SourceLocation SkipExtendedMicrosoftTypeAttributes();
2460  void ParseMicrosoftInheritanceClassAttributes(ParsedAttributes &attrs);
2461  void ParseBorlandTypeAttributes(ParsedAttributes &attrs);
2462  void ParseOpenCLKernelAttributes(ParsedAttributes &attrs);
2463  void ParseOpenCLQualifiers(ParsedAttributes &Attrs);
2464  /// Parses opencl_unroll_hint attribute if language is OpenCL v2.0
2465  /// or higher.
2466  /// \return false if error happens.
2467  bool MaybeParseOpenCLUnrollHintAttribute(ParsedAttributes &Attrs) {
2468  if (getLangOpts().OpenCL)
2469  return ParseOpenCLUnrollHintAttribute(Attrs);
2470  return true;
2471  }
2472  /// Parses opencl_unroll_hint attribute.
2473  /// \return false if error happens.
2474  bool ParseOpenCLUnrollHintAttribute(ParsedAttributes &Attrs);
2475  void ParseNullabilityTypeSpecifiers(ParsedAttributes &attrs);
2476 
2477  VersionTuple ParseVersionTuple(SourceRange &Range);
2478  void ParseAvailabilityAttribute(IdentifierInfo &Availability,
2479  SourceLocation AvailabilityLoc,
2480  ParsedAttributes &attrs,
2481  SourceLocation *endLoc,
2482  IdentifierInfo *ScopeName,
2483  SourceLocation ScopeLoc,
2484  ParsedAttr::Syntax Syntax);
2485 
2486  Optional<AvailabilitySpec> ParseAvailabilitySpec();
2487  ExprResult ParseAvailabilityCheckExpr(SourceLocation StartLoc);
2488 
2489  void ParseExternalSourceSymbolAttribute(IdentifierInfo &ExternalSourceSymbol,
2490  SourceLocation Loc,
2491  ParsedAttributes &Attrs,
2492  SourceLocation *EndLoc,
2493  IdentifierInfo *ScopeName,
2494  SourceLocation ScopeLoc,
2495  ParsedAttr::Syntax Syntax);
2496 
2497  void ParseObjCBridgeRelatedAttribute(IdentifierInfo &ObjCBridgeRelated,
2498  SourceLocation ObjCBridgeRelatedLoc,
2499  ParsedAttributes &attrs,
2500  SourceLocation *endLoc,
2501  IdentifierInfo *ScopeName,
2502  SourceLocation ScopeLoc,
2503  ParsedAttr::Syntax Syntax);
2504 
2505  void ParseTypeTagForDatatypeAttribute(IdentifierInfo &AttrName,
2506  SourceLocation AttrNameLoc,
2507  ParsedAttributes &Attrs,
2508  SourceLocation *EndLoc,
2509  IdentifierInfo *ScopeName,
2510  SourceLocation ScopeLoc,
2511  ParsedAttr::Syntax Syntax);
2512 
2513  void
2514  ParseAttributeWithTypeArg(IdentifierInfo &AttrName,
2515  SourceLocation AttrNameLoc, ParsedAttributes &Attrs,
2516  SourceLocation *EndLoc, IdentifierInfo *ScopeName,
2517  SourceLocation ScopeLoc, ParsedAttr::Syntax Syntax);
2518 
2519  void ParseTypeofSpecifier(DeclSpec &DS);
2520  SourceLocation ParseDecltypeSpecifier(DeclSpec &DS);
2521  void AnnotateExistingDecltypeSpecifier(const DeclSpec &DS,
2522  SourceLocation StartLoc,
2523  SourceLocation EndLoc);
2524  void ParseUnderlyingTypeSpecifier(DeclSpec &DS);
2525  void ParseAtomicSpecifier(DeclSpec &DS);
2526 
2527  ExprResult ParseAlignArgument(SourceLocation Start,
2528  SourceLocation &EllipsisLoc);
2529  void ParseAlignmentSpecifier(ParsedAttributes &Attrs,
2530  SourceLocation *endLoc = nullptr);
2531 
2532  VirtSpecifiers::Specifier isCXX11VirtSpecifier(const Token &Tok) const;
2533  VirtSpecifiers::Specifier isCXX11VirtSpecifier() const {
2534  return isCXX11VirtSpecifier(Tok);
2535  }
2536  void ParseOptionalCXX11VirtSpecifierSeq(VirtSpecifiers &VS, bool IsInterface,
2537  SourceLocation FriendLoc);
2538 
2539  bool isCXX11FinalKeyword() const;
2540 
2541  /// DeclaratorScopeObj - RAII object used in Parser::ParseDirectDeclarator to
2542  /// enter a new C++ declarator scope and exit it when the function is
2543  /// finished.
2544  class DeclaratorScopeObj {
2545  Parser &P;
2546  CXXScopeSpec &SS;
2547  bool EnteredScope;
2548  bool CreatedScope;
2549  public:
2550  DeclaratorScopeObj(Parser &p, CXXScopeSpec &ss)
2551  : P(p), SS(ss), EnteredScope(false), CreatedScope(false) {}
2552 
2553  void EnterDeclaratorScope() {
2554  assert(!EnteredScope && "Already entered the scope!");
2555  assert(SS.isSet() && "C++ scope was not set!");
2556 
2557  CreatedScope = true;
2558  P.EnterScope(0); // Not a decl scope.
2559 
2560  if (!P.Actions.ActOnCXXEnterDeclaratorScope(P.getCurScope(), SS))
2561  EnteredScope = true;
2562  }
2563 
2564  ~DeclaratorScopeObj() {
2565  if (EnteredScope) {
2566  assert(SS.isSet() && "C++ scope was cleared ?");
2567  P.Actions.ActOnCXXExitDeclaratorScope(P.getCurScope(), SS);
2568  }
2569  if (CreatedScope)
2570  P.ExitScope();
2571  }
2572  };
2573 
2574  /// ParseDeclarator - Parse and verify a newly-initialized declarator.
2575  void ParseDeclarator(Declarator &D);
2576  /// A function that parses a variant of direct-declarator.
2577  typedef void (Parser::*DirectDeclParseFunction)(Declarator&);
2578  void ParseDeclaratorInternal(Declarator &D,
2579  DirectDeclParseFunction DirectDeclParser);
2580 
2581  enum AttrRequirements {
2582  AR_NoAttributesParsed = 0, ///< No attributes are diagnosed.
2583  AR_GNUAttributesParsedAndRejected = 1 << 0, ///< Diagnose GNU attributes.
2584  AR_GNUAttributesParsed = 1 << 1,
2585  AR_CXX11AttributesParsed = 1 << 2,
2586  AR_DeclspecAttributesParsed = 1 << 3,
2587  AR_AllAttributesParsed = AR_GNUAttributesParsed |
2588  AR_CXX11AttributesParsed |
2589  AR_DeclspecAttributesParsed,
2590  AR_VendorAttributesParsed = AR_GNUAttributesParsed |
2591  AR_DeclspecAttributesParsed
2592  };
2593 
2594  void ParseTypeQualifierListOpt(
2595  DeclSpec &DS, unsigned AttrReqs = AR_AllAttributesParsed,
2596  bool AtomicAllowed = true, bool IdentifierRequired = false,
2597  Optional<llvm::function_ref<void()>> CodeCompletionHandler = None);
2598  void ParseDirectDeclarator(Declarator &D);
2599  void ParseDecompositionDeclarator(Declarator &D);
2600  void ParseParenDeclarator(Declarator &D);
2601  void ParseFunctionDeclarator(Declarator &D,
2602  ParsedAttributes &attrs,
2603  BalancedDelimiterTracker &Tracker,
2604  bool IsAmbiguous,
2605  bool RequiresArg = false);
2606  bool ParseRefQualifier(bool &RefQualifierIsLValueRef,
2607  SourceLocation &RefQualifierLoc);
2608  bool isFunctionDeclaratorIdentifierList();
2609  void ParseFunctionDeclaratorIdentifierList(
2610  Declarator &D,
2612  void ParseParameterDeclarationClause(
2613  Declarator &D,
2614  ParsedAttributes &attrs,
2616  SourceLocation &EllipsisLoc);
2617  void ParseBracketDeclarator(Declarator &D);
2618  void ParseMisplacedBracketDeclarator(Declarator &D);
2619 
2620  //===--------------------------------------------------------------------===//
2621  // C++ 7: Declarations [dcl.dcl]
2622 
2623  /// The kind of attribute specifier we have found.
2624  enum CXX11AttributeKind {
2625  /// This is not an attribute specifier.
2626  CAK_NotAttributeSpecifier,
2627  /// This should be treated as an attribute-specifier.
2628  CAK_AttributeSpecifier,
2629  /// The next tokens are '[[', but this is not an attribute-specifier. This
2630  /// is ill-formed by C++11 [dcl.attr.grammar]p6.
2631  CAK_InvalidAttributeSpecifier
2632  };
2633  CXX11AttributeKind
2634  isCXX11AttributeSpecifier(bool Disambiguate = false,
2635  bool OuterMightBeMessageSend = false);
2636 
2637  void DiagnoseUnexpectedNamespace(NamedDecl *Context);
2638 
2639  DeclGroupPtrTy ParseNamespace(DeclaratorContext Context,
2640  SourceLocation &DeclEnd,
2641  SourceLocation InlineLoc = SourceLocation());
2642  void ParseInnerNamespace(std::vector<SourceLocation> &IdentLoc,
2643  std::vector<IdentifierInfo *> &Ident,
2644  std::vector<SourceLocation> &NamespaceLoc,
2645  unsigned int index, SourceLocation &InlineLoc,
2646  ParsedAttributes &attrs,
2647  BalancedDelimiterTracker &Tracker);
2648  Decl *ParseLinkage(ParsingDeclSpec &DS, DeclaratorContext Context);
2649  Decl *ParseExportDeclaration();
2650  DeclGroupPtrTy ParseUsingDirectiveOrDeclaration(
2651  DeclaratorContext Context, const ParsedTemplateInfo &TemplateInfo,
2652  SourceLocation &DeclEnd, ParsedAttributesWithRange &attrs);
2653  Decl *ParseUsingDirective(DeclaratorContext Context,
2654  SourceLocation UsingLoc,
2655  SourceLocation &DeclEnd,
2656  ParsedAttributes &attrs);
2657 
2658  struct UsingDeclarator {
2659  SourceLocation TypenameLoc;
2660  CXXScopeSpec SS;
2661  UnqualifiedId Name;
2662  SourceLocation EllipsisLoc;
2663 
2664  void clear() {
2665  TypenameLoc = EllipsisLoc = SourceLocation();
2666  SS.clear();
2667  Name.clear();
2668  }
2669  };
2670 
2671  bool ParseUsingDeclarator(DeclaratorContext Context, UsingDeclarator &D);
2672  DeclGroupPtrTy ParseUsingDeclaration(DeclaratorContext Context,
2673  const ParsedTemplateInfo &TemplateInfo,
2674  SourceLocation UsingLoc,
2675  SourceLocation &DeclEnd,
2676  AccessSpecifier AS = AS_none);
2677  Decl *ParseAliasDeclarationAfterDeclarator(
2678  const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc,
2679  UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS,
2680  ParsedAttributes &Attrs, Decl **OwnedType = nullptr);
2681 
2682  Decl *ParseStaticAssertDeclaration(SourceLocation &DeclEnd);
2683  Decl *ParseNamespaceAlias(SourceLocation NamespaceLoc,
2684  SourceLocation AliasLoc, IdentifierInfo *Alias,
2685  SourceLocation &DeclEnd);
2686 
2687  //===--------------------------------------------------------------------===//
2688  // C++ 9: classes [class] and C structs/unions.
2689  bool isValidAfterTypeSpecifier(bool CouldBeBitfield);
2690  void ParseClassSpecifier(tok::TokenKind TagTokKind, SourceLocation TagLoc,
2691  DeclSpec &DS, const ParsedTemplateInfo &TemplateInfo,
2692  AccessSpecifier AS, bool EnteringContext,
2693  DeclSpecContext DSC,
2694  ParsedAttributesWithRange &Attributes);
2695  void SkipCXXMemberSpecification(SourceLocation StartLoc,
2696  SourceLocation AttrFixitLoc,
2697  unsigned TagType,
2698  Decl *TagDecl);
2699  void ParseCXXMemberSpecification(SourceLocation StartLoc,
2700  SourceLocation AttrFixitLoc,
2701  ParsedAttributesWithRange &Attrs,
2702  unsigned TagType,
2703  Decl *TagDecl);
2704  ExprResult ParseCXXMemberInitializer(Decl *D, bool IsFunction,
2705  SourceLocation &EqualLoc);
2706  bool ParseCXXMemberDeclaratorBeforeInitializer(Declarator &DeclaratorInfo,
2707  VirtSpecifiers &VS,
2708  ExprResult &BitfieldSize,
2709  LateParsedAttrList &LateAttrs);
2710  void MaybeParseAndDiagnoseDeclSpecAfterCXX11VirtSpecifierSeq(Declarator &D,
2711  VirtSpecifiers &VS);
2712  DeclGroupPtrTy ParseCXXClassMemberDeclaration(
2714  const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
2715  ParsingDeclRAIIObject *DiagsFromTParams = nullptr);
2716  DeclGroupPtrTy ParseCXXClassMemberDeclarationWithPragmas(
2717  AccessSpecifier &AS, ParsedAttributesWithRange &AccessAttrs,
2718  DeclSpec::TST TagType, Decl *Tag);
2719  void ParseConstructorInitializer(Decl *ConstructorDecl);
2720  MemInitResult ParseMemInitializer(Decl *ConstructorDecl);
2721  void HandleMemberFunctionDeclDelays(Declarator& DeclaratorInfo,
2722  Decl *ThisDecl);
2723 
2724  //===--------------------------------------------------------------------===//
2725  // C++ 10: Derived classes [class.derived]
2726  TypeResult ParseBaseTypeSpecifier(SourceLocation &BaseLoc,
2727  SourceLocation &EndLocation);
2728  void ParseBaseClause(Decl *ClassDecl);
2729  BaseResult ParseBaseSpecifier(Decl *ClassDecl);
2730  AccessSpecifier getAccessSpecifierIfPresent() const;
2731 
2732  bool ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
2733  SourceLocation TemplateKWLoc,
2734  IdentifierInfo *Name,
2735  SourceLocation NameLoc,
2736  bool EnteringContext,
2737  ParsedType ObjectType,
2738  UnqualifiedId &Id,
2739  bool AssumeTemplateId);
2740  bool ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
2741  ParsedType ObjectType,
2743 
2744  //===--------------------------------------------------------------------===//
2745  // OpenMP: Directives and clauses.
2746  /// Parse clauses for '#pragma omp declare simd'.
2747  DeclGroupPtrTy ParseOMPDeclareSimdClauses(DeclGroupPtrTy Ptr,
2748  CachedTokens &Toks,
2749  SourceLocation Loc);
2750  /// Parses declarative OpenMP directives.
2751  DeclGroupPtrTy ParseOpenMPDeclarativeDirectiveWithExtDecl(
2752  AccessSpecifier &AS, ParsedAttributesWithRange &Attrs,
2754  Decl *TagDecl = nullptr);
2755  /// Parse 'omp declare reduction' construct.
2756  DeclGroupPtrTy ParseOpenMPDeclareReductionDirective(AccessSpecifier AS);
2757  /// Parses initializer for provided omp_priv declaration inside the reduction
2758  /// initializer.
2759  void ParseOpenMPReductionInitializerForDecl(VarDecl *OmpPrivParm);
2760 
2761  /// Parses simple list of variables.
2762  ///
2763  /// \param Kind Kind of the directive.
2764  /// \param Callback Callback function to be called for the list elements.
2765  /// \param AllowScopeSpecifier true, if the variables can have fully
2766  /// qualified names.
2767  ///
2768  bool ParseOpenMPSimpleVarList(
2769  OpenMPDirectiveKind Kind,
2770  const llvm::function_ref<void(CXXScopeSpec &, DeclarationNameInfo)> &
2771  Callback,
2772  bool AllowScopeSpecifier);
2773  /// Parses declarative or executable directive.
2774  ///
2775  /// \param Allowed ACK_Any, if any directives are allowed,
2776  /// ACK_StatementsOpenMPAnyExecutable - if any executable directives are
2777  /// allowed, ACK_StatementsOpenMPNonStandalone - if only non-standalone
2778  /// executable directives are allowed.
2779  ///
2780  StmtResult
2781  ParseOpenMPDeclarativeOrExecutableDirective(AllowedConstructsKind Allowed);
2782  /// Parses clause of kind \a CKind for directive of a kind \a Kind.
2783  ///
2784  /// \param DKind Kind of current directive.
2785  /// \param CKind Kind of current clause.
2786  /// \param FirstClause true, if this is the first clause of a kind \a CKind
2787  /// in current directive.
2788  ///
2789  OMPClause *ParseOpenMPClause(OpenMPDirectiveKind DKind,
2790  OpenMPClauseKind CKind, bool FirstClause);
2791  /// Parses clause with a single expression of a kind \a Kind.
2792  ///
2793  /// \param Kind Kind of current clause.
2794  /// \param ParseOnly true to skip the clause's semantic actions and return
2795  /// nullptr.
2796  ///
2797  OMPClause *ParseOpenMPSingleExprClause(OpenMPClauseKind Kind,
2798  bool ParseOnly);
2799  /// Parses simple clause of a kind \a Kind.
2800  ///
2801  /// \param Kind Kind of current clause.
2802  /// \param ParseOnly true to skip the clause's semantic actions and return
2803  /// nullptr.
2804  ///
2805  OMPClause *ParseOpenMPSimpleClause(OpenMPClauseKind Kind, bool ParseOnly);
2806  /// Parses clause with a single expression and an additional argument
2807  /// of a kind \a Kind.
2808  ///
2809  /// \param Kind Kind of current clause.
2810  /// \param ParseOnly true to skip the clause's semantic actions and return
2811  /// nullptr.
2812  ///
2813  OMPClause *ParseOpenMPSingleExprWithArgClause(OpenMPClauseKind Kind,
2814  bool ParseOnly);
2815  /// Parses clause without any additional arguments.
2816  ///
2817  /// \param Kind Kind of current clause.
2818  /// \param ParseOnly true to skip the clause's semantic actions and return
2819  /// nullptr.
2820  ///
2821  OMPClause *ParseOpenMPClause(OpenMPClauseKind Kind, bool ParseOnly = false);
2822  /// Parses clause with the list of variables of a kind \a Kind.
2823  ///
2824  /// \param Kind Kind of current clause.
2825  /// \param ParseOnly true to skip the clause's semantic actions and return
2826  /// nullptr.
2827  ///
2828  OMPClause *ParseOpenMPVarListClause(OpenMPDirectiveKind DKind,
2829  OpenMPClauseKind Kind, bool ParseOnly);
2830 
2831 public:
2832  /// Parses simple expression in parens for single-expression clauses of OpenMP
2833  /// constructs.
2834  /// \param RLoc Returned location of right paren.
2835  ExprResult ParseOpenMPParensExpr(StringRef ClauseName, SourceLocation &RLoc);
2836 
2837  /// Data used for parsing list of variables in OpenMP clauses.
2839  Expr *TailExpr = nullptr;
2845  OpenMPLinearClauseKind LinKind = OMPC_LINEAR_val;
2848  bool IsMapTypeImplicit = false;
2850  };
2851 
2852  /// Parses clauses with list.
2855  OpenMPVarListDataTy &Data);
2856  bool ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext,
2857  bool AllowDestructorName,
2858  bool AllowConstructorName,
2859  bool AllowDeductionGuide,
2860  ParsedType ObjectType,
2861  SourceLocation *TemplateKWLoc,
2863 
2864 private:
2865  //===--------------------------------------------------------------------===//
2866  // C++ 14: Templates [temp]
2867 
2868  // C++ 14.1: Template Parameters [temp.param]
2869  Decl *ParseDeclarationStartingWithTemplate(DeclaratorContext Context,
2870  SourceLocation &DeclEnd,
2871  ParsedAttributes &AccessAttrs,
2872  AccessSpecifier AS = AS_none);
2873  Decl *ParseTemplateDeclarationOrSpecialization(DeclaratorContext Context,
2874  SourceLocation &DeclEnd,
2875  ParsedAttributes &AccessAttrs,
2876  AccessSpecifier AS);
2877  Decl *ParseSingleDeclarationAfterTemplate(
2878  DeclaratorContext Context, const ParsedTemplateInfo &TemplateInfo,
2879  ParsingDeclRAIIObject &DiagsFromParams, SourceLocation &DeclEnd,
2880  ParsedAttributes &AccessAttrs, AccessSpecifier AS = AS_none);
2881  bool ParseTemplateParameters(unsigned Depth,
2882  SmallVectorImpl<NamedDecl *> &TemplateParams,
2883  SourceLocation &LAngleLoc,
2884  SourceLocation &RAngleLoc);
2885  bool ParseTemplateParameterList(unsigned Depth,
2886  SmallVectorImpl<NamedDecl*> &TemplateParams);
2887  bool isStartOfTemplateTypeParameter();
2888  NamedDecl *ParseTemplateParameter(unsigned Depth, unsigned Position);
2889  NamedDecl *ParseTypeParameter(unsigned Depth, unsigned Position);
2890  NamedDecl *ParseTemplateTemplateParameter(unsigned Depth, unsigned Position);
2891  NamedDecl *ParseNonTypeTemplateParameter(unsigned Depth, unsigned Position);
2892  void DiagnoseMisplacedEllipsis(SourceLocation EllipsisLoc,
2893  SourceLocation CorrectLoc,
2894  bool AlreadyHasEllipsis,
2895  bool IdentifierHasName);
2896  void DiagnoseMisplacedEllipsisInDeclarator(SourceLocation EllipsisLoc,
2897  Declarator &D);
2898  // C++ 14.3: Template arguments [temp.arg]
2900 
2901  bool ParseGreaterThanInTemplateList(SourceLocation &RAngleLoc,
2902  bool ConsumeLastToken,
2903  bool ObjCGenericList);
2904  bool ParseTemplateIdAfterTemplateName(bool ConsumeLastToken,
2905  SourceLocation &LAngleLoc,
2906  TemplateArgList &TemplateArgs,
2907  SourceLocation &RAngleLoc);
2908 
2909  bool AnnotateTemplateIdToken(TemplateTy Template, TemplateNameKind TNK,
2910  CXXScopeSpec &SS,
2911  SourceLocation TemplateKWLoc,
2913  bool AllowTypeAnnotation = true);
2914  void AnnotateTemplateIdTokenAsType(bool IsClassName = false);
2915  bool IsTemplateArgumentList(unsigned Skip = 0);
2916  bool ParseTemplateArgumentList(TemplateArgList &TemplateArgs);
2917  ParsedTemplateArgument ParseTemplateTemplateArgument();
2918  ParsedTemplateArgument ParseTemplateArgument();
2919  Decl *ParseExplicitInstantiation(DeclaratorContext Context,
2920  SourceLocation ExternLoc,
2921  SourceLocation TemplateLoc,
2922  SourceLocation &DeclEnd,
2923  ParsedAttributes &AccessAttrs,
2924  AccessSpecifier AS = AS_none);
2925 
2926  //===--------------------------------------------------------------------===//
2927  // Modules
2928  DeclGroupPtrTy ParseModuleDecl();
2929  Decl *ParseModuleImport(SourceLocation AtLoc);
2930  bool parseMisplacedModuleImport();
2931  bool tryParseMisplacedModuleImport() {
2932  tok::TokenKind Kind = Tok.getKind();
2933  if (Kind == tok::annot_module_begin || Kind == tok::annot_module_end ||
2934  Kind == tok::annot_module_include)
2935  return parseMisplacedModuleImport();
2936  return false;
2937  }
2938 
2939  bool ParseModuleName(
2940  SourceLocation UseLoc,
2941  SmallVectorImpl<std::pair<IdentifierInfo *, SourceLocation>> &Path,
2942  bool IsImport);
2943 
2944  //===--------------------------------------------------------------------===//
2945  // C++11/G++: Type Traits [Type-Traits.html in the GCC manual]
2946  ExprResult ParseTypeTrait();
2947 
2948  //===--------------------------------------------------------------------===//
2949  // Embarcadero: Arary and Expression Traits
2950  ExprResult ParseArrayTypeTrait();
2951  ExprResult ParseExpressionTrait();
2952 
2953  //===--------------------------------------------------------------------===//
2954  // Preprocessor code-completion pass-through
2955  void CodeCompleteDirective(bool InConditional) override;
2956  void CodeCompleteInConditionalExclusion() override;
2957  void CodeCompleteMacroName(bool IsDefinition) override;
2958  void CodeCompletePreprocessorExpression() override;
2959  void CodeCompleteMacroArgument(IdentifierInfo *Macro, MacroInfo *MacroInfo,
2960  unsigned ArgumentIndex) override;
2961  void CodeCompleteNaturalLanguage() override;
2962 };
2963 
2964 } // end namespace clang
2965 
2966 #endif
Sema::FullExprArg FullExprArg
Definition: Parser.h:380
IdentifierInfo * getNullabilityKeyword(NullabilityKind nullability)
Retrieve the underscored keyword (_Nonnull, _Nullable) that corresponds to the given nullability kind...
Definition: Parser.h:456
ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)
Simple precedence-based parser for binary/ternary operators.
Definition: ParseExpr.cpp:123
ParseScope - Introduces a new scope for parsing.
Definition: Parser.h:945
DeclarationNameInfo ReductionId
Definition: Parser.h:2843
SourceLocation getEndOfPreviousToken()
Definition: Parser.h:450
void Initialize()
Initialize - Warm up the parser.
Definition: Parser.cpp:438
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
Class to handle popping type parameters when leaving the scope.
Definition: ParseObjc.cpp:98
const Token & LookAhead(unsigned N)
Peeks ahead N tokens and returns that token without consuming any tokens.
NullabilityKind
Describes the nullability of a particular type.
Definition: Specifiers.h:285
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:95
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
RAII object used to inform the actions that we&#39;re currently parsing a declaration.
Captures information about "declaration specifiers" specific to Objective-C.
Definition: DeclSpec.h:777
StringRef P
bool TryAnnotateCXXScopeToken(bool EnteringContext=false)
TryAnnotateScopeToken - Like TryAnnotateTypeOrScopeToken but only annotates C++ scope specifiers and ...
Definition: Parser.cpp:1872
virtual void clear()
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:98
Wrapper for void* pointer.
Definition: Ownership.h:51
Parser - This implements a parser for the C family of languages.
Definition: Parser.h:57
TypeCastState
TypeCastState - State whether an expression is or may be a type cast.
Definition: Parser.h:1571
void setCodeCompletionReached()
Note that we hit the code-completion point.
void ActOnObjCReenterContainerContext(DeclContext *DC)
Definition: SemaDecl.cpp:14927
void EnterToken(const Token &Tok)
Enters a token in the token stream to be lexed next.
Represents a variable declaration or definition.
Definition: Decl.h:814
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1752
bool isStringLiteral(TokenKind K)
Return true if this is a C or C++ string-literal (or C++11 user-defined-string-literal) token...
Definition: TokenKinds.h:79
TypeSpecifierType
Specifies the kind of type.
Definition: Specifiers.h:45
void ActOnObjCTemporaryExitContainerContext(DeclContext *DC)
Invoked when we must temporarily exit the objective-c container scope for parsing/looking-up C constr...
Definition: SemaDecl.cpp:14921
void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS)
ActOnCXXExitDeclaratorScope - Called when a declarator that previously invoked ActOnCXXEnterDeclarato...
RAII object that makes sure paren/bracket/brace count is correct after declaration/statement parsing...
bool isAnnotation() const
Return true if this is any of tok::annot_* kind tokens.
Definition: Token.h:118
friend class ObjCDeclContextSwitch
Definition: Parser.h:61
ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed...
tok::TokenKind getKind() const
Definition: Token.h:90
bool SkipUntil(tok::TokenKind T, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
SkipUntil - Read tokens until we get to the specified token, then consume it (unless StopBeforeMatch ...
Definition: Parser.h:1039
Information about a template-id annotation token.
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
Definition: Parser.h:707
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Computes the source location just past the end of the token at this source location.
bool TryConsumeToken(tok::TokenKind Expected)
Definition: Parser.h:412
One of these records is kept for each identifier that is lexed.
SourceLocation getAnnotationEndLoc() const
Definition: Token.h:138
LineState State
OpenMPLinearClauseKind
OpenMP attributes for &#39;linear&#39; clause.
Definition: OpenMPKinds.h:84
const TargetInfo & getTargetInfo() const
Definition: Preprocessor.h:822
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
void setKind(tok::TokenKind K)
Definition: Token.h:91
RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ...
Defines some OpenMP-specific enums and functions.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:821
void * getAsOpaquePtr() const
Definition: Ownership.h:91
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:922
friend constexpr SkipUntilFlags operator|(SkipUntilFlags L, SkipUntilFlags R)
Definition: Parser.h:1025
static ParsedType getTypeAnnotation(const Token &Tok)
getTypeAnnotation - Read a parsed type out of an annotation token.
Definition: Parser.h:712
const FormatToken & Tok
bool TryConsumeToken(tok::TokenKind Expected, SourceLocation &Loc)
Definition: Parser.h:422
Decl * getObjCDeclContext() const
Definition: SemaDecl.cpp:17193
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
void incrementMSManglingNumber() const
Definition: Sema.h:10620
void takeAllFrom(ParsedAttributes &attrs)
Definition: ParsedAttr.h:810
bool SkipUntil(tok::TokenKind T1, tok::TokenKind T2, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
Definition: Parser.h:1043
void CommitBacktrackedTokens()
Disable the last EnableBacktrackAtThisPos call.
Definition: PPCaching.cpp:32
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2827
SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok=false)
ConsumeAnyToken - Dispatch to the right Consume* method based on the current token type...
Definition: Parser.h:432
AttributeFactory & getAttrFactory()
Definition: Parser.h:363
bool isActiveOrNested(Parser &P) const
Definition: Parser.h:289
void incrementMSManglingNumber() const
Definition: Parser.h:367
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:277
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:1042
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:616
A class for parsing a declarator.
Stop at code completion.
Definition: Parser.h:1022
void Backtrack()
Make Preprocessor re-lex the tokens that were lexed since EnableBacktrackAtThisPos() was previously c...
Definition: PPCaching.cpp:63
Scope * getCurScope() const
Retrieve the parser&#39;s current scope.
Definition: Sema.h:10618
Exposes information about the current target.
Definition: TargetInfo.h:54
void setAnnotationValue(void *val)
Definition: Token.h:228
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
Expr - This represents one expression.
Definition: Expr.h:106
SourceLocation End
int Id
Definition: ASTDiff.cpp:191
void EnableBacktrackAtThisPos()
From the point that this method is called, and until CommitBacktrackedTokens() or Backtrack() is call...
Definition: PPCaching.cpp:26
This file defines the classes used to store parsed information about declaration-specifiers and decla...
Sema & getActions() const
Definition: Parser.h:362
void SkipMalformedDecl()
SkipMalformedDecl - Read tokens until we get to some likely good stopping point for skipping past a s...
Definition: ParseDecl.cpp:1825
bool ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext, bool AllowDestructorName, bool AllowConstructorName, bool AllowDeductionGuide, ParsedType ObjectType, SourceLocation *TemplateKWLoc, UnqualifiedId &Result)
Parse a C++ unqualified-id (or a C identifier), which describes the name of an entity.
const Token & getCurToken() const
Definition: Parser.h:365
OpaquePtr< TemplateName > TemplateTy
Definition: Parser.h:376
void clear()
Clear out this unqualified-id, setting it to default (invalid) state.
Definition: DeclSpec.h:990
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Definition: Token.h:124
Defines the clang::Preprocessor interface.
OpenMPClauseKind
OpenMP clauses.
Definition: OpenMPKinds.h:33
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
int Depth
Definition: ASTDiff.cpp:191
A class for parsing a field declarator.
TemplateNameKind
Specifies the kind of template name that an identifier refers to.
Definition: TemplateKinds.h:21
Provides LLVM&#39;s BitmaskEnum facility to enumeration types declared in namespace clang.
Preprocessor & getPreprocessor() const
Definition: Parser.h:361
DeclaratorContext
Definition: DeclSpec.h:1710
Defines and computes precedence levels for binary/ternary operators.
ConditionKind
Definition: Sema.h:9824
Wraps an identifier and optional source location for the identifier.
Definition: ParsedAttr.h:83
The result type of a method or function.
ObjCKeywordKind
Provides a namespace for Objective-C keywords which start with an &#39;@&#39;.
Definition: TokenKinds.h:41
OpaquePtr< DeclGroupRef > DeclGroupPtrTy
Definition: Parser.h:375
const LangOptions & getLangOpts() const
Definition: Parser.h:359
A class for parsing a DeclSpec.
#define false
Definition: stdbool.h:33
Kind
Stop skipping at semicolon.
Definition: Parser.h:1019
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:157
Represents the parsed form of a C++ template argument.
bool ParseTopLevelDecl()
Definition: Parser.h:394
Encodes a location in the source.
OpenMPDependClauseKind
OpenMP attributes for &#39;depend&#39; clause.
Definition: OpenMPKinds.h:76
bool TryAnnotateTypeOrScopeToken()
TryAnnotateTypeOrScopeToken - If the current token position is on a typename (possibly qualified in C...
Definition: Parser.cpp:1651
DiagnosticBuilder Diag(unsigned DiagID)
Definition: Parser.h:1006
bool ParseOpenMPVarList(OpenMPDirectiveKind DKind, OpenMPClauseKind Kind, SmallVectorImpl< Expr *> &Vars, OpenMPVarListDataTy &Data)
Parses clauses with list.
Syntax
The style used to specify an attribute.
Definition: ParsedAttr.h:108
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3020
void ExitScope()
ExitScope - Pop a scope off the scope stack.
Definition: Parser.cpp:370
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:177
Parser(Preprocessor &PP, Sema &Actions, bool SkipFunctionBodies)
Definition: Parser.cpp:51
OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:23
ExprResult ParseMSAsmIdentifier(llvm::SmallVectorImpl< Token > &LineToks, unsigned &NumLineToksConsumed, bool IsUnevaluated)
Parse an identifier in an MS-style inline assembly block.
A tentative parsing action that can also revert token annotations.
void Lex(Token &Result)
Lex the next token for this preprocessor.
void EnterScope(unsigned ScopeFlags)
EnterScope - Start a new scope.
Definition: Parser.cpp:359
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:51
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
Represents a C++11 virt-specifier-seq.
Definition: DeclSpec.h:2488
Scope * getCurScope() const
Definition: Parser.h:366
ExprResult ParseOpenMPParensExpr(StringRef ClauseName, SourceLocation &RLoc)
Parses simple expression in parens for single-expression clauses of OpenMP constructs.
ExprResult ParseConstantExpressionInExprEvalContext(TypeCastState isTypeCast=NotTypeCast)
Definition: ParseExpr.cpp:200
Defines various enumerations that describe declaration and type specifiers.
void takeAttributes(ParsedAttributes &attrs, SourceLocation lastLoc)
takeAttributes - Takes attributes from the given parsed-attributes set and add them to this declarato...
Definition: DeclSpec.h:2391
bool isNot(tok::TokenKind K) const
Definition: Token.h:96
ParseScope(Parser *Self, unsigned ScopeFlags, bool EnteredScope=true, bool BeforeCompoundStmt=false)
Definition: Parser.h:954
bool isActive(Parser &P) const
Definition: Parser.h:284
static bool isInvalid(LocType Loc, bool *Invalid)
Dataflow Directional Tag Classes.
SourceRange getSourceRange(const SourceRange &Range)
Returns the SourceRange of a SourceRange.
Definition: FixIt.h:34
ExprResult ParseCaseExpression(SourceLocation CaseLoc)
Definition: ParseExpr.cpp:220
ExprResult ParseConstraintExpression()
Parse a constraint-expression.
Definition: ParseExpr.cpp:234
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition: Token.h:97
SkipUntilFlags
Control flags for SkipUntil functions.
Definition: Parser.h:1018
Data used for parsing list of variables in OpenMP clauses.
Definition: Parser.h:2838
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
static const TST TST_unspecified
Definition: DeclSpec.h:272
const Expr * Replacement
Definition: ParsedAttr.h:67
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:40
const TargetInfo & getTargetInfo() const
Definition: Parser.h:360
~Parser() override
Definition: Parser.cpp:409
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Definition: Parser.cpp:73
ExprResult ParseAssignmentExpression(TypeCastState isTypeCast=NotTypeCast)
Parse an expr that doesn&#39;t include (top-level) commas.
Definition: ParseExpr.cpp:160
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
SmallVector< TemplateParameterList *, 4 > TemplateParameterLists
Definition: Parser.h:378
bool ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS)
ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global scope or nested-name-specifi...
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
ExprResult ParseConstantExpression(TypeCastState isTypeCast=NotTypeCast)
Definition: ParseExpr.cpp:210
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
ActionResult< Expr * > ExprResult
Definition: Ownership.h:267
SourceLocation ConsumeToken()
ConsumeToken - Consume the current &#39;peek token&#39; and lex the next one.
Definition: Parser.h:404
A factory, from which one makes pools, from which one creates individual attributes which are dealloc...
Definition: ParsedAttr.h:552
OpenMPMapClauseKind
OpenMP mapping kind for &#39;map&#39; clause.
Definition: OpenMPKinds.h:92
llvm::DenseMap< int, SourceRange > ParsedSubjectMatchRuleSet
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition: DeclObjC.h:656
Decl * getObjCDeclContext() const
Definition: Parser.h:371
IdentifierInfo * getNullabilityKeyword(NullabilityKind nullability)
Retrieve the keyword associated.
Definition: SemaType.cpp:3408
Represents a complete lambda introducer.
Definition: DeclSpec.h:2538
bool TryAnnotateTypeOrScopeTokenAfterScopeSpec(CXXScopeSpec &SS, bool IsNewScope)
Try to annotate a type or scope token, having already parsed an optional scope specifier.
Definition: Parser.cpp:1765
bool SkipUntil(tok::TokenKind T1, tok::TokenKind T2, tok::TokenKind T3, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
Definition: Parser.h:1048
Contains a late templated function.
Definition: Sema.h:10788
Loop optimization hint for loop and unroll pragmas.
Definition: LoopHint.h:21
AngleBracketTracker::Priority Priority
Definition: Parser.h:281
A trivial tuple used to represent a source range.
This represents a decl that may have a name.
Definition: Decl.h:248
Callback handler that receives notifications when performing code completion within the preprocessor...
void * getAnnotationValue() const
Definition: Token.h:224
static OpaquePtr getFromOpaquePtr(void *P)
Definition: Ownership.h:92
ParsedAttributes - A collection of parsed attributes.
Definition: ParsedAttr.h:803
SourceLocation ColonLoc
Location of &#39;:&#39;.
Definition: OpenMPClause.h:102
TypeResult ParseTypeName(SourceRange *Range=nullptr, DeclaratorContext Context=DeclaratorContext::TypeNameContext, AccessSpecifier AS=AS_none, Decl **OwnedType=nullptr, ParsedAttributes *Attrs=nullptr)
ParseTypeName type-name: [C99 6.7.6] specifier-qualifier-list abstract-declarator[opt].
Definition: ParseDecl.cpp:44
Attr - This represents one attribute.
Definition: Attr.h:43
bool ParseFirstTopLevelDecl(DeclGroupPtrTy &Result)
Parse the first top-level declaration in a translation unit.
Definition: Parser.cpp:529
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:127
Stop skipping at specified token, but don&#39;t skip the token itself.
Definition: Parser.h:1021