clang  5.0.0
ParseExprCXX.cpp
Go to the documentation of this file.
1 //===--- ParseExprCXX.cpp - C++ Expression Parsing ------------------------===//
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 implements the Expression parsing implementation for C++.
11 //
12 //===----------------------------------------------------------------------===//
13 #include "clang/Parse/Parser.h"
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/DeclTemplate.h"
20 #include "clang/Sema/DeclSpec.h"
22 #include "clang/Sema/Scope.h"
23 #include "llvm/Support/ErrorHandling.h"
24 
25 
26 using namespace clang;
27 
29  switch (Kind) {
30  // template name
31  case tok::unknown: return 0;
32  // casts
33  case tok::kw_const_cast: return 1;
34  case tok::kw_dynamic_cast: return 2;
35  case tok::kw_reinterpret_cast: return 3;
36  case tok::kw_static_cast: return 4;
37  default:
38  llvm_unreachable("Unknown type for digraph error message.");
39  }
40 }
41 
42 // Are the two tokens adjacent in the same source file?
43 bool Parser::areTokensAdjacent(const Token &First, const Token &Second) {
45  SourceLocation FirstLoc = SM.getSpellingLoc(First.getLocation());
46  SourceLocation FirstEnd = FirstLoc.getLocWithOffset(First.getLength());
47  return FirstEnd == SM.getSpellingLoc(Second.getLocation());
48 }
49 
50 // Suggest fixit for "<::" after a cast.
51 static void FixDigraph(Parser &P, Preprocessor &PP, Token &DigraphToken,
52  Token &ColonToken, tok::TokenKind Kind, bool AtDigraph) {
53  // Pull '<:' and ':' off token stream.
54  if (!AtDigraph)
55  PP.Lex(DigraphToken);
56  PP.Lex(ColonToken);
57 
58  SourceRange Range;
59  Range.setBegin(DigraphToken.getLocation());
60  Range.setEnd(ColonToken.getLocation());
61  P.Diag(DigraphToken.getLocation(), diag::err_missing_whitespace_digraph)
63  << FixItHint::CreateReplacement(Range, "< ::");
64 
65  // Update token information to reflect their change in token type.
66  ColonToken.setKind(tok::coloncolon);
67  ColonToken.setLocation(ColonToken.getLocation().getLocWithOffset(-1));
68  ColonToken.setLength(2);
69  DigraphToken.setKind(tok::less);
70  DigraphToken.setLength(1);
71 
72  // Push new tokens back to token stream.
73  PP.EnterToken(ColonToken);
74  if (!AtDigraph)
75  PP.EnterToken(DigraphToken);
76 }
77 
78 // Check for '<::' which should be '< ::' instead of '[:' when following
79 // a template name.
80 void Parser::CheckForTemplateAndDigraph(Token &Next, ParsedType ObjectType,
81  bool EnteringContext,
82  IdentifierInfo &II, CXXScopeSpec &SS) {
83  if (!Next.is(tok::l_square) || Next.getLength() != 2)
84  return;
85 
86  Token SecondToken = GetLookAheadToken(2);
87  if (!SecondToken.is(tok::colon) || !areTokensAdjacent(Next, SecondToken))
88  return;
89 
90  TemplateTy Template;
92  TemplateName.setIdentifier(&II, Tok.getLocation());
93  bool MemberOfUnknownSpecialization;
94  if (!Actions.isTemplateName(getCurScope(), SS, /*hasTemplateKeyword=*/false,
95  TemplateName, ObjectType, EnteringContext,
96  Template, MemberOfUnknownSpecialization))
97  return;
98 
99  FixDigraph(*this, PP, Next, SecondToken, tok::unknown,
100  /*AtDigraph*/false);
101 }
102 
103 /// \brief Parse global scope or nested-name-specifier if present.
104 ///
105 /// Parses a C++ global scope specifier ('::') or nested-name-specifier (which
106 /// may be preceded by '::'). Note that this routine will not parse ::new or
107 /// ::delete; it will just leave them in the token stream.
108 ///
109 /// '::'[opt] nested-name-specifier
110 /// '::'
111 ///
112 /// nested-name-specifier:
113 /// type-name '::'
114 /// namespace-name '::'
115 /// nested-name-specifier identifier '::'
116 /// nested-name-specifier 'template'[opt] simple-template-id '::'
117 ///
118 ///
119 /// \param SS the scope specifier that will be set to the parsed
120 /// nested-name-specifier (or empty)
121 ///
122 /// \param ObjectType if this nested-name-specifier is being parsed following
123 /// the "." or "->" of a member access expression, this parameter provides the
124 /// type of the object whose members are being accessed.
125 ///
126 /// \param EnteringContext whether we will be entering into the context of
127 /// the nested-name-specifier after parsing it.
128 ///
129 /// \param MayBePseudoDestructor When non-NULL, points to a flag that
130 /// indicates whether this nested-name-specifier may be part of a
131 /// pseudo-destructor name. In this case, the flag will be set false
132 /// if we don't actually end up parsing a destructor name. Moreorover,
133 /// if we do end up determining that we are parsing a destructor name,
134 /// the last component of the nested-name-specifier is not parsed as
135 /// part of the scope specifier.
136 ///
137 /// \param IsTypename If \c true, this nested-name-specifier is known to be
138 /// part of a type name. This is used to improve error recovery.
139 ///
140 /// \param LastII When non-NULL, points to an IdentifierInfo* that will be
141 /// filled in with the leading identifier in the last component of the
142 /// nested-name-specifier, if any.
143 ///
144 /// \param OnlyNamespace If true, only considers namespaces in lookup.
145 ///
146 /// \returns true if there was an error parsing a scope specifier
147 bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
148  ParsedType ObjectType,
149  bool EnteringContext,
150  bool *MayBePseudoDestructor,
151  bool IsTypename,
152  IdentifierInfo **LastII,
153  bool OnlyNamespace) {
154  assert(getLangOpts().CPlusPlus &&
155  "Call sites of this function should be guarded by checking for C++");
156 
157  if (Tok.is(tok::annot_cxxscope)) {
158  assert(!LastII && "want last identifier but have already annotated scope");
159  assert(!MayBePseudoDestructor && "unexpected annot_cxxscope");
161  Tok.getAnnotationRange(),
162  SS);
163  ConsumeAnnotationToken();
164  return false;
165  }
166 
167  if (Tok.is(tok::annot_template_id)) {
168  // If the current token is an annotated template id, it may already have
169  // a scope specifier. Restore it.
170  TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
171  SS = TemplateId->SS;
172  }
173 
174  // Has to happen before any "return false"s in this function.
175  bool CheckForDestructor = false;
176  if (MayBePseudoDestructor && *MayBePseudoDestructor) {
177  CheckForDestructor = true;
178  *MayBePseudoDestructor = false;
179  }
180 
181  if (LastII)
182  *LastII = nullptr;
183 
184  bool HasScopeSpecifier = false;
185 
186  if (Tok.is(tok::coloncolon)) {
187  // ::new and ::delete aren't nested-name-specifiers.
188  tok::TokenKind NextKind = NextToken().getKind();
189  if (NextKind == tok::kw_new || NextKind == tok::kw_delete)
190  return false;
191 
192  if (NextKind == tok::l_brace) {
193  // It is invalid to have :: {, consume the scope qualifier and pretend
194  // like we never saw it.
195  Diag(ConsumeToken(), diag::err_expected) << tok::identifier;
196  } else {
197  // '::' - Global scope qualifier.
198  if (Actions.ActOnCXXGlobalScopeSpecifier(ConsumeToken(), SS))
199  return true;
200 
201  HasScopeSpecifier = true;
202  }
203  }
204 
205  if (Tok.is(tok::kw___super)) {
206  SourceLocation SuperLoc = ConsumeToken();
207  if (!Tok.is(tok::coloncolon)) {
208  Diag(Tok.getLocation(), diag::err_expected_coloncolon_after_super);
209  return true;
210  }
211 
212  return Actions.ActOnSuperScopeSpecifier(SuperLoc, ConsumeToken(), SS);
213  }
214 
215  if (!HasScopeSpecifier &&
216  Tok.isOneOf(tok::kw_decltype, tok::annot_decltype)) {
217  DeclSpec DS(AttrFactory);
218  SourceLocation DeclLoc = Tok.getLocation();
219  SourceLocation EndLoc = ParseDecltypeSpecifier(DS);
220 
221  SourceLocation CCLoc;
222  // Work around a standard defect: 'decltype(auto)::' is not a
223  // nested-name-specifier.
224  if (DS.getTypeSpecType() == DeclSpec::TST_decltype_auto ||
225  !TryConsumeToken(tok::coloncolon, CCLoc)) {
226  AnnotateExistingDecltypeSpecifier(DS, DeclLoc, EndLoc);
227  return false;
228  }
229 
230  if (Actions.ActOnCXXNestedNameSpecifierDecltype(SS, DS, CCLoc))
231  SS.SetInvalid(SourceRange(DeclLoc, CCLoc));
232 
233  HasScopeSpecifier = true;
234  }
235 
236  while (true) {
237  if (HasScopeSpecifier) {
238  // C++ [basic.lookup.classref]p5:
239  // If the qualified-id has the form
240  //
241  // ::class-name-or-namespace-name::...
242  //
243  // the class-name-or-namespace-name is looked up in global scope as a
244  // class-name or namespace-name.
245  //
246  // To implement this, we clear out the object type as soon as we've
247  // seen a leading '::' or part of a nested-name-specifier.
248  ObjectType = nullptr;
249 
250  if (Tok.is(tok::code_completion)) {
251  // Code completion for a nested-name-specifier, where the code
252  // code completion token follows the '::'.
253  Actions.CodeCompleteQualifiedId(getCurScope(), SS, EnteringContext);
254  // Include code completion token into the range of the scope otherwise
255  // when we try to annotate the scope tokens the dangling code completion
256  // token will cause assertion in
257  // Preprocessor::AnnotatePreviousCachedTokens.
258  SS.setEndLoc(Tok.getLocation());
259  cutOffParsing();
260  return true;
261  }
262  }
263 
264  // nested-name-specifier:
265  // nested-name-specifier 'template'[opt] simple-template-id '::'
266 
267  // Parse the optional 'template' keyword, then make sure we have
268  // 'identifier <' after it.
269  if (Tok.is(tok::kw_template)) {
270  // If we don't have a scope specifier or an object type, this isn't a
271  // nested-name-specifier, since they aren't allowed to start with
272  // 'template'.
273  if (!HasScopeSpecifier && !ObjectType)
274  break;
275 
276  TentativeParsingAction TPA(*this);
277  SourceLocation TemplateKWLoc = ConsumeToken();
278 
279  UnqualifiedId TemplateName;
280  if (Tok.is(tok::identifier)) {
281  // Consume the identifier.
282  TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
283  ConsumeToken();
284  } else if (Tok.is(tok::kw_operator)) {
285  // We don't need to actually parse the unqualified-id in this case,
286  // because a simple-template-id cannot start with 'operator', but
287  // go ahead and parse it anyway for consistency with the case where
288  // we already annotated the template-id.
289  if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType,
290  TemplateName)) {
291  TPA.Commit();
292  break;
293  }
294 
295  if (TemplateName.getKind() != UnqualifiedId::IK_OperatorFunctionId &&
296  TemplateName.getKind() != UnqualifiedId::IK_LiteralOperatorId) {
297  Diag(TemplateName.getSourceRange().getBegin(),
298  diag::err_id_after_template_in_nested_name_spec)
299  << TemplateName.getSourceRange();
300  TPA.Commit();
301  break;
302  }
303  } else {
304  TPA.Revert();
305  break;
306  }
307 
308  // If the next token is not '<', we have a qualified-id that refers
309  // to a template name, such as T::template apply, but is not a
310  // template-id.
311  if (Tok.isNot(tok::less)) {
312  TPA.Revert();
313  break;
314  }
315 
316  // Commit to parsing the template-id.
317  TPA.Commit();
318  TemplateTy Template;
320  getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
321  EnteringContext, Template, /*AllowInjectedClassName*/ true)) {
322  if (AnnotateTemplateIdToken(Template, TNK, SS, TemplateKWLoc,
323  TemplateName, false))
324  return true;
325  } else
326  return true;
327 
328  continue;
329  }
330 
331  if (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) {
332  // We have
333  //
334  // template-id '::'
335  //
336  // So we need to check whether the template-id is a simple-template-id of
337  // the right kind (it should name a type or be dependent), and then
338  // convert it into a type within the nested-name-specifier.
339  TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
340  if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) {
341  *MayBePseudoDestructor = true;
342  return false;
343  }
344 
345  if (LastII)
346  *LastII = TemplateId->Name;
347 
348  // Consume the template-id token.
349  ConsumeAnnotationToken();
350 
351  assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!");
352  SourceLocation CCLoc = ConsumeToken();
353 
354  HasScopeSpecifier = true;
355 
356  ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
357  TemplateId->NumArgs);
358 
360  SS,
361  TemplateId->TemplateKWLoc,
362  TemplateId->Template,
363  TemplateId->TemplateNameLoc,
364  TemplateId->LAngleLoc,
365  TemplateArgsPtr,
366  TemplateId->RAngleLoc,
367  CCLoc,
368  EnteringContext)) {
369  SourceLocation StartLoc
370  = SS.getBeginLoc().isValid()? SS.getBeginLoc()
371  : TemplateId->TemplateNameLoc;
372  SS.SetInvalid(SourceRange(StartLoc, CCLoc));
373  }
374 
375  continue;
376  }
377 
378  // The rest of the nested-name-specifier possibilities start with
379  // tok::identifier.
380  if (Tok.isNot(tok::identifier))
381  break;
382 
383  IdentifierInfo &II = *Tok.getIdentifierInfo();
384 
385  // nested-name-specifier:
386  // type-name '::'
387  // namespace-name '::'
388  // nested-name-specifier identifier '::'
389  Token Next = NextToken();
390  Sema::NestedNameSpecInfo IdInfo(&II, Tok.getLocation(), Next.getLocation(),
391  ObjectType);
392 
393  // If we get foo:bar, this is almost certainly a typo for foo::bar. Recover
394  // and emit a fixit hint for it.
395  if (Next.is(tok::colon) && !ColonIsSacred) {
396  if (Actions.IsInvalidUnlessNestedName(getCurScope(), SS, IdInfo,
397  EnteringContext) &&
398  // If the token after the colon isn't an identifier, it's still an
399  // error, but they probably meant something else strange so don't
400  // recover like this.
401  PP.LookAhead(1).is(tok::identifier)) {
402  Diag(Next, diag::err_unexpected_colon_in_nested_name_spec)
403  << FixItHint::CreateReplacement(Next.getLocation(), "::");
404  // Recover as if the user wrote '::'.
405  Next.setKind(tok::coloncolon);
406  }
407  }
408 
409  if (Next.is(tok::coloncolon) && GetLookAheadToken(2).is(tok::l_brace)) {
410  // It is invalid to have :: {, consume the scope qualifier and pretend
411  // like we never saw it.
412  Token Identifier = Tok; // Stash away the identifier.
413  ConsumeToken(); // Eat the identifier, current token is now '::'.
414  Diag(PP.getLocForEndOfToken(ConsumeToken()), diag::err_expected)
415  << tok::identifier;
416  UnconsumeToken(Identifier); // Stick the identifier back.
417  Next = NextToken(); // Point Next at the '{' token.
418  }
419 
420  if (Next.is(tok::coloncolon)) {
421  if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde) &&
422  !Actions.isNonTypeNestedNameSpecifier(getCurScope(), SS, IdInfo)) {
423  *MayBePseudoDestructor = true;
424  return false;
425  }
426 
427  if (ColonIsSacred) {
428  const Token &Next2 = GetLookAheadToken(2);
429  if (Next2.is(tok::kw_private) || Next2.is(tok::kw_protected) ||
430  Next2.is(tok::kw_public) || Next2.is(tok::kw_virtual)) {
431  Diag(Next2, diag::err_unexpected_token_in_nested_name_spec)
432  << Next2.getName()
434  Token ColonColon;
435  PP.Lex(ColonColon);
436  ColonColon.setKind(tok::colon);
437  PP.EnterToken(ColonColon);
438  break;
439  }
440  }
441 
442  if (LastII)
443  *LastII = &II;
444 
445  // We have an identifier followed by a '::'. Lookup this name
446  // as the name in a nested-name-specifier.
447  Token Identifier = Tok;
448  SourceLocation IdLoc = ConsumeToken();
449  assert(Tok.isOneOf(tok::coloncolon, tok::colon) &&
450  "NextToken() not working properly!");
451  Token ColonColon = Tok;
452  SourceLocation CCLoc = ConsumeToken();
453 
454  bool IsCorrectedToColon = false;
455  bool *CorrectionFlagPtr = ColonIsSacred ? &IsCorrectedToColon : nullptr;
456  if (Actions.ActOnCXXNestedNameSpecifier(
457  getCurScope(), IdInfo, EnteringContext, SS, false,
458  CorrectionFlagPtr, OnlyNamespace)) {
459  // Identifier is not recognized as a nested name, but we can have
460  // mistyped '::' instead of ':'.
461  if (CorrectionFlagPtr && IsCorrectedToColon) {
462  ColonColon.setKind(tok::colon);
463  PP.EnterToken(Tok);
464  PP.EnterToken(ColonColon);
465  Tok = Identifier;
466  break;
467  }
468  SS.SetInvalid(SourceRange(IdLoc, CCLoc));
469  }
470  HasScopeSpecifier = true;
471  continue;
472  }
473 
474  CheckForTemplateAndDigraph(Next, ObjectType, EnteringContext, II, SS);
475 
476  // nested-name-specifier:
477  // type-name '<'
478  if (Next.is(tok::less)) {
479  TemplateTy Template;
480  UnqualifiedId TemplateName;
481  TemplateName.setIdentifier(&II, Tok.getLocation());
482  bool MemberOfUnknownSpecialization;
483  if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS,
484  /*hasTemplateKeyword=*/false,
485  TemplateName,
486  ObjectType,
487  EnteringContext,
488  Template,
489  MemberOfUnknownSpecialization)) {
490  // We have found a template name, so annotate this token
491  // with a template-id annotation. We do not permit the
492  // template-id to be translated into a type annotation,
493  // because some clients (e.g., the parsing of class template
494  // specializations) still want to see the original template-id
495  // token.
496  ConsumeToken();
497  if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
498  TemplateName, false))
499  return true;
500  continue;
501  }
502 
503  if (MemberOfUnknownSpecialization && (ObjectType || SS.isSet()) &&
504  (IsTypename || IsTemplateArgumentList(1))) {
505  // We have something like t::getAs<T>, where getAs is a
506  // member of an unknown specialization. However, this will only
507  // parse correctly as a template, so suggest the keyword 'template'
508  // before 'getAs' and treat this as a dependent template name.
509  unsigned DiagID = diag::err_missing_dependent_template_keyword;
510  if (getLangOpts().MicrosoftExt)
511  DiagID = diag::warn_missing_dependent_template_keyword;
512 
513  Diag(Tok.getLocation(), DiagID)
514  << II.getName()
515  << FixItHint::CreateInsertion(Tok.getLocation(), "template ");
516 
518  getCurScope(), SS, SourceLocation(), TemplateName, ObjectType,
519  EnteringContext, Template, /*AllowInjectedClassName*/ true)) {
520  // Consume the identifier.
521  ConsumeToken();
522  if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
523  TemplateName, false))
524  return true;
525  }
526  else
527  return true;
528 
529  continue;
530  }
531  }
532 
533  // We don't have any tokens that form the beginning of a
534  // nested-name-specifier, so we're done.
535  break;
536  }
537 
538  // Even if we didn't see any pieces of a nested-name-specifier, we
539  // still check whether there is a tilde in this position, which
540  // indicates a potential pseudo-destructor.
541  if (CheckForDestructor && Tok.is(tok::tilde))
542  *MayBePseudoDestructor = true;
543 
544  return false;
545 }
546 
547 ExprResult Parser::tryParseCXXIdExpression(CXXScopeSpec &SS, bool isAddressOfOperand,
548  Token &Replacement) {
549  SourceLocation TemplateKWLoc;
551  if (ParseUnqualifiedId(SS,
552  /*EnteringContext=*/false,
553  /*AllowDestructorName=*/false,
554  /*AllowConstructorName=*/false,
555  /*AllowDeductionGuide=*/false,
556  /*ObjectType=*/nullptr, TemplateKWLoc, Name))
557  return ExprError();
558 
559  // This is only the direct operand of an & operator if it is not
560  // followed by a postfix-expression suffix.
561  if (isAddressOfOperand && isPostfixExpressionSuffixStart())
562  isAddressOfOperand = false;
563 
564  return Actions.ActOnIdExpression(getCurScope(), SS, TemplateKWLoc, Name,
565  Tok.is(tok::l_paren), isAddressOfOperand,
566  nullptr, /*IsInlineAsmIdentifier=*/false,
567  &Replacement);
568 }
569 
570 /// ParseCXXIdExpression - Handle id-expression.
571 ///
572 /// id-expression:
573 /// unqualified-id
574 /// qualified-id
575 ///
576 /// qualified-id:
577 /// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
578 /// '::' identifier
579 /// '::' operator-function-id
580 /// '::' template-id
581 ///
582 /// NOTE: The standard specifies that, for qualified-id, the parser does not
583 /// expect:
584 ///
585 /// '::' conversion-function-id
586 /// '::' '~' class-name
587 ///
588 /// This may cause a slight inconsistency on diagnostics:
589 ///
590 /// class C {};
591 /// namespace A {}
592 /// void f() {
593 /// :: A :: ~ C(); // Some Sema error about using destructor with a
594 /// // namespace.
595 /// :: ~ C(); // Some Parser error like 'unexpected ~'.
596 /// }
597 ///
598 /// We simplify the parser a bit and make it work like:
599 ///
600 /// qualified-id:
601 /// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
602 /// '::' unqualified-id
603 ///
604 /// That way Sema can handle and report similar errors for namespaces and the
605 /// global scope.
606 ///
607 /// The isAddressOfOperand parameter indicates that this id-expression is a
608 /// direct operand of the address-of operator. This is, besides member contexts,
609 /// the only place where a qualified-id naming a non-static class member may
610 /// appear.
611 ///
612 ExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) {
613  // qualified-id:
614  // '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
615  // '::' unqualified-id
616  //
617  CXXScopeSpec SS;
618  ParseOptionalCXXScopeSpecifier(SS, nullptr, /*EnteringContext=*/false);
619 
622  tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
623  if (Result.isUnset()) {
624  // If the ExprResult is valid but null, then typo correction suggested a
625  // keyword replacement that needs to be reparsed.
626  UnconsumeToken(Replacement);
627  Result = tryParseCXXIdExpression(SS, isAddressOfOperand, Replacement);
628  }
629  assert(!Result.isUnset() && "Typo correction suggested a keyword replacement "
630  "for a previous keyword suggestion");
631  return Result;
632 }
633 
634 /// ParseLambdaExpression - Parse a C++11 lambda expression.
635 ///
636 /// lambda-expression:
637 /// lambda-introducer lambda-declarator[opt] compound-statement
638 ///
639 /// lambda-introducer:
640 /// '[' lambda-capture[opt] ']'
641 ///
642 /// lambda-capture:
643 /// capture-default
644 /// capture-list
645 /// capture-default ',' capture-list
646 ///
647 /// capture-default:
648 /// '&'
649 /// '='
650 ///
651 /// capture-list:
652 /// capture
653 /// capture-list ',' capture
654 ///
655 /// capture:
656 /// simple-capture
657 /// init-capture [C++1y]
658 ///
659 /// simple-capture:
660 /// identifier
661 /// '&' identifier
662 /// 'this'
663 ///
664 /// init-capture: [C++1y]
665 /// identifier initializer
666 /// '&' identifier initializer
667 ///
668 /// lambda-declarator:
669 /// '(' parameter-declaration-clause ')' attribute-specifier[opt]
670 /// 'mutable'[opt] exception-specification[opt]
671 /// trailing-return-type[opt]
672 ///
673 ExprResult Parser::ParseLambdaExpression() {
674  // Parse lambda-introducer.
675  LambdaIntroducer Intro;
676  Optional<unsigned> DiagID = ParseLambdaIntroducer(Intro);
677  if (DiagID) {
678  Diag(Tok, DiagID.getValue());
679  SkipUntil(tok::r_square, StopAtSemi);
680  SkipUntil(tok::l_brace, StopAtSemi);
681  SkipUntil(tok::r_brace, StopAtSemi);
682  return ExprError();
683  }
684 
685  return ParseLambdaExpressionAfterIntroducer(Intro);
686 }
687 
688 /// TryParseLambdaExpression - Use lookahead and potentially tentative
689 /// parsing to determine if we are looking at a C++0x lambda expression, and parse
690 /// it if we are.
691 ///
692 /// If we are not looking at a lambda expression, returns ExprError().
693 ExprResult Parser::TryParseLambdaExpression() {
694  assert(getLangOpts().CPlusPlus11
695  && Tok.is(tok::l_square)
696  && "Not at the start of a possible lambda expression.");
697 
698  const Token Next = NextToken();
699  if (Next.is(tok::eof)) // Nothing else to lookup here...
700  return ExprEmpty();
701 
702  const Token After = GetLookAheadToken(2);
703  // If lookahead indicates this is a lambda...
704  if (Next.is(tok::r_square) || // []
705  Next.is(tok::equal) || // [=
706  (Next.is(tok::amp) && // [&] or [&,
707  (After.is(tok::r_square) ||
708  After.is(tok::comma))) ||
709  (Next.is(tok::identifier) && // [identifier]
710  After.is(tok::r_square))) {
711  return ParseLambdaExpression();
712  }
713 
714  // If lookahead indicates an ObjC message send...
715  // [identifier identifier
716  if (Next.is(tok::identifier) && After.is(tok::identifier)) {
717  return ExprEmpty();
718  }
719 
720  // Here, we're stuck: lambda introducers and Objective-C message sends are
721  // unambiguous, but it requires arbitrary lookhead. [a,b,c,d,e,f,g] is a
722  // lambda, and [a,b,c,d,e,f,g h] is a Objective-C message send. Instead of
723  // writing two routines to parse a lambda introducer, just try to parse
724  // a lambda introducer first, and fall back if that fails.
725  // (TryParseLambdaIntroducer never produces any diagnostic output.)
726  LambdaIntroducer Intro;
727  if (TryParseLambdaIntroducer(Intro))
728  return ExprEmpty();
729 
730  return ParseLambdaExpressionAfterIntroducer(Intro);
731 }
732 
733 /// \brief Parse a lambda introducer.
734 /// \param Intro A LambdaIntroducer filled in with information about the
735 /// contents of the lambda-introducer.
736 /// \param SkippedInits If non-null, we are disambiguating between an Obj-C
737 /// message send and a lambda expression. In this mode, we will
738 /// sometimes skip the initializers for init-captures and not fully
739 /// populate \p Intro. This flag will be set to \c true if we do so.
740 /// \return A DiagnosticID if it hit something unexpected. The location for
741 /// the diagnostic is that of the current token.
742 Optional<unsigned> Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro,
743  bool *SkippedInits) {
744  typedef Optional<unsigned> DiagResult;
745 
746  assert(Tok.is(tok::l_square) && "Lambda expressions begin with '['.");
747  BalancedDelimiterTracker T(*this, tok::l_square);
748  T.consumeOpen();
749 
750  Intro.Range.setBegin(T.getOpenLocation());
751 
752  bool first = true;
753 
754  // Parse capture-default.
755  if (Tok.is(tok::amp) &&
756  (NextToken().is(tok::comma) || NextToken().is(tok::r_square))) {
757  Intro.Default = LCD_ByRef;
758  Intro.DefaultLoc = ConsumeToken();
759  first = false;
760  } else if (Tok.is(tok::equal)) {
761  Intro.Default = LCD_ByCopy;
762  Intro.DefaultLoc = ConsumeToken();
763  first = false;
764  }
765 
766  while (Tok.isNot(tok::r_square)) {
767  if (!first) {
768  if (Tok.isNot(tok::comma)) {
769  // Provide a completion for a lambda introducer here. Except
770  // in Objective-C, where this is Almost Surely meant to be a message
771  // send. In that case, fail here and let the ObjC message
772  // expression parser perform the completion.
773  if (Tok.is(tok::code_completion) &&
774  !(getLangOpts().ObjC1 && Intro.Default == LCD_None &&
775  !Intro.Captures.empty())) {
776  Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
777  /*AfterAmpersand=*/false);
778  cutOffParsing();
779  break;
780  }
781 
782  return DiagResult(diag::err_expected_comma_or_rsquare);
783  }
784  ConsumeToken();
785  }
786 
787  if (Tok.is(tok::code_completion)) {
788  // If we're in Objective-C++ and we have a bare '[', then this is more
789  // likely to be a message receiver.
790  if (getLangOpts().ObjC1 && first)
792  else
793  Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
794  /*AfterAmpersand=*/false);
795  cutOffParsing();
796  break;
797  }
798 
799  first = false;
800 
801  // Parse capture.
804  SourceLocation Loc;
805  IdentifierInfo *Id = nullptr;
806  SourceLocation EllipsisLoc;
807  ExprResult Init;
808 
809  if (Tok.is(tok::star)) {
810  Loc = ConsumeToken();
811  if (Tok.is(tok::kw_this)) {
812  ConsumeToken();
813  Kind = LCK_StarThis;
814  } else {
815  return DiagResult(diag::err_expected_star_this_capture);
816  }
817  } else if (Tok.is(tok::kw_this)) {
818  Kind = LCK_This;
819  Loc = ConsumeToken();
820  } else {
821  if (Tok.is(tok::amp)) {
822  Kind = LCK_ByRef;
823  ConsumeToken();
824 
825  if (Tok.is(tok::code_completion)) {
826  Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
827  /*AfterAmpersand=*/true);
828  cutOffParsing();
829  break;
830  }
831  }
832 
833  if (Tok.is(tok::identifier)) {
834  Id = Tok.getIdentifierInfo();
835  Loc = ConsumeToken();
836  } else if (Tok.is(tok::kw_this)) {
837  // FIXME: If we want to suggest a fixit here, will need to return more
838  // than just DiagnosticID. Perhaps full DiagnosticBuilder that can be
839  // Clear()ed to prevent emission in case of tentative parsing?
840  return DiagResult(diag::err_this_captured_by_reference);
841  } else {
842  return DiagResult(diag::err_expected_capture);
843  }
844 
845  if (Tok.is(tok::l_paren)) {
846  BalancedDelimiterTracker Parens(*this, tok::l_paren);
847  Parens.consumeOpen();
848 
850 
851  ExprVector Exprs;
852  CommaLocsTy Commas;
853  if (SkippedInits) {
854  Parens.skipToEnd();
855  *SkippedInits = true;
856  } else if (ParseExpressionList(Exprs, Commas)) {
857  Parens.skipToEnd();
858  Init = ExprError();
859  } else {
860  Parens.consumeClose();
861  Init = Actions.ActOnParenListExpr(Parens.getOpenLocation(),
862  Parens.getCloseLocation(),
863  Exprs);
864  }
865  } else if (Tok.isOneOf(tok::l_brace, tok::equal)) {
866  // Each lambda init-capture forms its own full expression, which clears
867  // Actions.MaybeODRUseExprs. So create an expression evaluation context
868  // to save the necessary state, and restore it later.
871 
872  if (TryConsumeToken(tok::equal))
874  else
876 
877  if (!SkippedInits) {
878  Init = ParseInitializer();
879  } else if (Tok.is(tok::l_brace)) {
880  BalancedDelimiterTracker Braces(*this, tok::l_brace);
881  Braces.consumeOpen();
882  Braces.skipToEnd();
883  *SkippedInits = true;
884  } else {
885  // We're disambiguating this:
886  //
887  // [..., x = expr
888  //
889  // We need to find the end of the following expression in order to
890  // determine whether this is an Obj-C message send's receiver, a
891  // C99 designator, or a lambda init-capture.
892  //
893  // Parse the expression to find where it ends, and annotate it back
894  // onto the tokens. We would have parsed this expression the same way
895  // in either case: both the RHS of an init-capture and the RHS of an
896  // assignment expression are parsed as an initializer-clause, and in
897  // neither case can anything be added to the scope between the '[' and
898  // here.
899  //
900  // FIXME: This is horrible. Adding a mechanism to skip an expression
901  // would be much cleaner.
902  // FIXME: If there is a ',' before the next ']' or ':', we can skip to
903  // that instead. (And if we see a ':' with no matching '?', we can
904  // classify this as an Obj-C message send.)
905  SourceLocation StartLoc = Tok.getLocation();
906  InMessageExpressionRAIIObject MaybeInMessageExpression(*this, true);
907  Init = ParseInitializer();
908  if (!Init.isInvalid())
909  Init = Actions.CorrectDelayedTyposInExpr(Init.get());
910 
911  if (Tok.getLocation() != StartLoc) {
912  // Back out the lexing of the token after the initializer.
913  PP.RevertCachedTokens(1);
914 
915  // Replace the consumed tokens with an appropriate annotation.
916  Tok.setLocation(StartLoc);
917  Tok.setKind(tok::annot_primary_expr);
918  setExprAnnotation(Tok, Init);
920  PP.AnnotateCachedTokens(Tok);
921 
922  // Consume the annotated initializer.
923  ConsumeAnnotationToken();
924  }
925  }
926  } else
927  TryConsumeToken(tok::ellipsis, EllipsisLoc);
928  }
929  // If this is an init capture, process the initialization expression
930  // right away. For lambda init-captures such as the following:
931  // const int x = 10;
932  // auto L = [i = x+1](int a) {
933  // return [j = x+2,
934  // &k = x](char b) { };
935  // };
936  // keep in mind that each lambda init-capture has to have:
937  // - its initialization expression executed in the context
938  // of the enclosing/parent decl-context.
939  // - but the variable itself has to be 'injected' into the
940  // decl-context of its lambda's call-operator (which has
941  // not yet been created).
942  // Each init-expression is a full-expression that has to get
943  // Sema-analyzed (for capturing etc.) before its lambda's
944  // call-operator's decl-context, scope & scopeinfo are pushed on their
945  // respective stacks. Thus if any variable is odr-used in the init-capture
946  // it will correctly get captured in the enclosing lambda, if one exists.
947  // The init-variables above are created later once the lambdascope and
948  // call-operators decl-context is pushed onto its respective stack.
949 
950  // Since the lambda init-capture's initializer expression occurs in the
951  // context of the enclosing function or lambda, therefore we can not wait
952  // till a lambda scope has been pushed on before deciding whether the
953  // variable needs to be captured. We also need to process all
954  // lvalue-to-rvalue conversions and discarded-value conversions,
955  // so that we can avoid capturing certain constant variables.
956  // For e.g.,
957  // void test() {
958  // const int x = 10;
959  // auto L = [&z = x](char a) { <-- don't capture by the current lambda
960  // return [y = x](int i) { <-- don't capture by enclosing lambda
961  // return y;
962  // }
963  // };
964  // }
965  // If x was not const, the second use would require 'L' to capture, and
966  // that would be an error.
967 
968  ParsedType InitCaptureType;
969  if (Init.isUsable()) {
970  // Get the pointer and store it in an lvalue, so we can use it as an
971  // out argument.
972  Expr *InitExpr = Init.get();
973  // This performs any lvalue-to-rvalue conversions if necessary, which
974  // can affect what gets captured in the containing decl-context.
975  InitCaptureType = Actions.actOnLambdaInitCaptureInitialization(
976  Loc, Kind == LCK_ByRef, Id, InitKind, InitExpr);
977  Init = InitExpr;
978  }
979  Intro.addCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init,
980  InitCaptureType);
981  }
982 
983  T.consumeClose();
984  Intro.Range.setEnd(T.getCloseLocation());
985  return DiagResult();
986 }
987 
988 /// TryParseLambdaIntroducer - Tentatively parse a lambda introducer.
989 ///
990 /// Returns true if it hit something unexpected.
991 bool Parser::TryParseLambdaIntroducer(LambdaIntroducer &Intro) {
992  TentativeParsingAction PA(*this);
993 
994  bool SkippedInits = false;
995  Optional<unsigned> DiagID(ParseLambdaIntroducer(Intro, &SkippedInits));
996 
997  if (DiagID) {
998  PA.Revert();
999  return true;
1000  }
1001 
1002  if (SkippedInits) {
1003  // Parse it again, but this time parse the init-captures too.
1004  PA.Revert();
1005  Intro = LambdaIntroducer();
1006  DiagID = ParseLambdaIntroducer(Intro);
1007  assert(!DiagID && "parsing lambda-introducer failed on reparse");
1008  return false;
1009  }
1010 
1011  PA.Commit();
1012  return false;
1013 }
1014 
1015 static void
1017  SourceLocation &ConstexprLoc,
1018  SourceLocation &DeclEndLoc) {
1019  assert(MutableLoc.isInvalid());
1020  assert(ConstexprLoc.isInvalid());
1021  // Consume constexpr-opt mutable-opt in any sequence, and set the DeclEndLoc
1022  // to the final of those locations. Emit an error if we have multiple
1023  // copies of those keywords and recover.
1024 
1025  while (true) {
1026  switch (P.getCurToken().getKind()) {
1027  case tok::kw_mutable: {
1028  if (MutableLoc.isValid()) {
1029  P.Diag(P.getCurToken().getLocation(),
1030  diag::err_lambda_decl_specifier_repeated)
1032  }
1033  MutableLoc = P.ConsumeToken();
1034  DeclEndLoc = MutableLoc;
1035  break /*switch*/;
1036  }
1037  case tok::kw_constexpr:
1038  if (ConstexprLoc.isValid()) {
1039  P.Diag(P.getCurToken().getLocation(),
1040  diag::err_lambda_decl_specifier_repeated)
1042  }
1043  ConstexprLoc = P.ConsumeToken();
1044  DeclEndLoc = ConstexprLoc;
1045  break /*switch*/;
1046  default:
1047  return;
1048  }
1049  }
1050 }
1051 
1052 static void
1054  DeclSpec &DS) {
1055  if (ConstexprLoc.isValid()) {
1056  P.Diag(ConstexprLoc, !P.getLangOpts().CPlusPlus1z
1057  ? diag::ext_constexpr_on_lambda_cxx1z
1058  : diag::warn_cxx14_compat_constexpr_on_lambda);
1059  const char *PrevSpec = nullptr;
1060  unsigned DiagID = 0;
1061  DS.SetConstexprSpec(ConstexprLoc, PrevSpec, DiagID);
1062  assert(PrevSpec == nullptr && DiagID == 0 &&
1063  "Constexpr cannot have been set previously!");
1064  }
1065 }
1066 
1067 /// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
1068 /// expression.
1069 ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
1070  LambdaIntroducer &Intro) {
1071  SourceLocation LambdaBeginLoc = Intro.Range.getBegin();
1072  Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);
1073 
1074  PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc,
1075  "lambda expression parsing");
1076 
1077 
1078 
1079  // FIXME: Call into Actions to add any init-capture declarations to the
1080  // scope while parsing the lambda-declarator and compound-statement.
1081 
1082  // Parse lambda-declarator[opt].
1083  DeclSpec DS(AttrFactory);
1085  TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
1086  Actions.PushLambdaScope();
1087 
1088  ParsedAttributes Attr(AttrFactory);
1089  SourceLocation DeclLoc = Tok.getLocation();
1090  if (getLangOpts().CUDA) {
1091  // In CUDA code, GNU attributes are allowed to appear immediately after the
1092  // "[...]", even if there is no "(...)" before the lambda body.
1093  MaybeParseGNUAttributes(D);
1094  }
1095 
1096  // Helper to emit a warning if we see a CUDA host/device/global attribute
1097  // after '(...)'. nvcc doesn't accept this.
1098  auto WarnIfHasCUDATargetAttr = [&] {
1099  if (getLangOpts().CUDA)
1100  for (auto *A = Attr.getList(); A != nullptr; A = A->getNext())
1101  if (A->getKind() == AttributeList::AT_CUDADevice ||
1102  A->getKind() == AttributeList::AT_CUDAHost ||
1103  A->getKind() == AttributeList::AT_CUDAGlobal)
1104  Diag(A->getLoc(), diag::warn_cuda_attr_lambda_position)
1105  << A->getName()->getName();
1106  };
1107 
1108  TypeResult TrailingReturnType;
1109  if (Tok.is(tok::l_paren)) {
1110  ParseScope PrototypeScope(this,
1114 
1115  BalancedDelimiterTracker T(*this, tok::l_paren);
1116  T.consumeOpen();
1117  SourceLocation LParenLoc = T.getOpenLocation();
1118 
1119  // Parse parameter-declaration-clause.
1121  SourceLocation EllipsisLoc;
1122 
1123  if (Tok.isNot(tok::r_paren)) {
1124  Actions.RecordParsingTemplateParameterDepth(TemplateParameterDepth);
1125  ParseParameterDeclarationClause(D, Attr, ParamInfo, EllipsisLoc);
1126  // For a generic lambda, each 'auto' within the parameter declaration
1127  // clause creates a template type parameter, so increment the depth.
1128  if (Actions.getCurGenericLambda())
1129  ++CurTemplateDepthTracker;
1130  }
1131  T.consumeClose();
1132  SourceLocation RParenLoc = T.getCloseLocation();
1133  SourceLocation DeclEndLoc = RParenLoc;
1134 
1135  // GNU-style attributes must be parsed before the mutable specifier to be
1136  // compatible with GCC.
1137  MaybeParseGNUAttributes(Attr, &DeclEndLoc);
1138 
1139  // MSVC-style attributes must be parsed before the mutable specifier to be
1140  // compatible with MSVC.
1141  MaybeParseMicrosoftDeclSpecs(Attr, &DeclEndLoc);
1142 
1143  // Parse mutable-opt and/or constexpr-opt, and update the DeclEndLoc.
1144  SourceLocation MutableLoc;
1145  SourceLocation ConstexprLoc;
1146  tryConsumeMutableOrConstexprToken(*this, MutableLoc, ConstexprLoc,
1147  DeclEndLoc);
1148 
1149  addConstexprToLambdaDeclSpecifier(*this, ConstexprLoc, DS);
1150 
1151  // Parse exception-specification[opt].
1153  SourceRange ESpecRange;
1154  SmallVector<ParsedType, 2> DynamicExceptions;
1155  SmallVector<SourceRange, 2> DynamicExceptionRanges;
1156  ExprResult NoexceptExpr;
1157  CachedTokens *ExceptionSpecTokens;
1158  ESpecType = tryParseExceptionSpecification(/*Delayed=*/false,
1159  ESpecRange,
1160  DynamicExceptions,
1161  DynamicExceptionRanges,
1162  NoexceptExpr,
1163  ExceptionSpecTokens);
1164 
1165  if (ESpecType != EST_None)
1166  DeclEndLoc = ESpecRange.getEnd();
1167 
1168  // Parse attribute-specifier[opt].
1169  MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
1170 
1171  SourceLocation FunLocalRangeEnd = DeclEndLoc;
1172 
1173  // Parse trailing-return-type[opt].
1174  if (Tok.is(tok::arrow)) {
1175  FunLocalRangeEnd = Tok.getLocation();
1176  SourceRange Range;
1177  TrailingReturnType = ParseTrailingReturnType(Range);
1178  if (Range.getEnd().isValid())
1179  DeclEndLoc = Range.getEnd();
1180  }
1181 
1182  PrototypeScope.Exit();
1183 
1184  WarnIfHasCUDATargetAttr();
1185 
1186  SourceLocation NoLoc;
1187  D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
1188  /*isAmbiguous=*/false,
1189  LParenLoc,
1190  ParamInfo.data(), ParamInfo.size(),
1191  EllipsisLoc, RParenLoc,
1192  DS.getTypeQualifiers(),
1193  /*RefQualifierIsLValueRef=*/true,
1194  /*RefQualifierLoc=*/NoLoc,
1195  /*ConstQualifierLoc=*/NoLoc,
1196  /*VolatileQualifierLoc=*/NoLoc,
1197  /*RestrictQualifierLoc=*/NoLoc,
1198  MutableLoc,
1199  ESpecType, ESpecRange,
1200  DynamicExceptions.data(),
1201  DynamicExceptionRanges.data(),
1202  DynamicExceptions.size(),
1203  NoexceptExpr.isUsable() ?
1204  NoexceptExpr.get() : nullptr,
1205  /*ExceptionSpecTokens*/nullptr,
1206  /*DeclsInPrototype=*/None,
1207  LParenLoc, FunLocalRangeEnd, D,
1208  TrailingReturnType),
1209  Attr, DeclEndLoc);
1210  } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
1211  tok::kw_constexpr) ||
1212  (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) {
1213  // It's common to forget that one needs '()' before 'mutable', an attribute
1214  // specifier, or the result type. Deal with this.
1215  unsigned TokKind = 0;
1216  switch (Tok.getKind()) {
1217  case tok::kw_mutable: TokKind = 0; break;
1218  case tok::arrow: TokKind = 1; break;
1219  case tok::kw___attribute:
1220  case tok::l_square: TokKind = 2; break;
1221  case tok::kw_constexpr: TokKind = 3; break;
1222  default: llvm_unreachable("Unknown token kind");
1223  }
1224 
1225  Diag(Tok, diag::err_lambda_missing_parens)
1226  << TokKind
1227  << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
1228  SourceLocation DeclEndLoc = DeclLoc;
1229 
1230  // GNU-style attributes must be parsed before the mutable specifier to be
1231  // compatible with GCC.
1232  MaybeParseGNUAttributes(Attr, &DeclEndLoc);
1233 
1234  // Parse 'mutable', if it's there.
1235  SourceLocation MutableLoc;
1236  if (Tok.is(tok::kw_mutable)) {
1237  MutableLoc = ConsumeToken();
1238  DeclEndLoc = MutableLoc;
1239  }
1240 
1241  // Parse attribute-specifier[opt].
1242  MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
1243 
1244  // Parse the return type, if there is one.
1245  if (Tok.is(tok::arrow)) {
1246  SourceRange Range;
1247  TrailingReturnType = ParseTrailingReturnType(Range);
1248  if (Range.getEnd().isValid())
1249  DeclEndLoc = Range.getEnd();
1250  }
1251 
1252  WarnIfHasCUDATargetAttr();
1253 
1254  SourceLocation NoLoc;
1255  D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
1256  /*isAmbiguous=*/false,
1257  /*LParenLoc=*/NoLoc,
1258  /*Params=*/nullptr,
1259  /*NumParams=*/0,
1260  /*EllipsisLoc=*/NoLoc,
1261  /*RParenLoc=*/NoLoc,
1262  /*TypeQuals=*/0,
1263  /*RefQualifierIsLValueRef=*/true,
1264  /*RefQualifierLoc=*/NoLoc,
1265  /*ConstQualifierLoc=*/NoLoc,
1266  /*VolatileQualifierLoc=*/NoLoc,
1267  /*RestrictQualifierLoc=*/NoLoc,
1268  MutableLoc,
1269  EST_None,
1270  /*ESpecRange=*/SourceRange(),
1271  /*Exceptions=*/nullptr,
1272  /*ExceptionRanges=*/nullptr,
1273  /*NumExceptions=*/0,
1274  /*NoexceptExpr=*/nullptr,
1275  /*ExceptionSpecTokens=*/nullptr,
1276  /*DeclsInPrototype=*/None,
1277  DeclLoc, DeclEndLoc, D,
1278  TrailingReturnType),
1279  Attr, DeclEndLoc);
1280  }
1281 
1282  // FIXME: Rename BlockScope -> ClosureScope if we decide to continue using
1283  // it.
1284  unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope;
1285  ParseScope BodyScope(this, ScopeFlags);
1286 
1287  Actions.ActOnStartOfLambdaDefinition(Intro, D, getCurScope());
1288 
1289  // Parse compound-statement.
1290  if (!Tok.is(tok::l_brace)) {
1291  Diag(Tok, diag::err_expected_lambda_body);
1292  Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1293  return ExprError();
1294  }
1295 
1296  StmtResult Stmt(ParseCompoundStatementBody());
1297  BodyScope.Exit();
1298 
1299  if (!Stmt.isInvalid() && !TrailingReturnType.isInvalid())
1300  return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.get(), getCurScope());
1301 
1302  Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1303  return ExprError();
1304 }
1305 
1306 /// ParseCXXCasts - This handles the various ways to cast expressions to another
1307 /// type.
1308 ///
1309 /// postfix-expression: [C++ 5.2p1]
1310 /// 'dynamic_cast' '<' type-name '>' '(' expression ')'
1311 /// 'static_cast' '<' type-name '>' '(' expression ')'
1312 /// 'reinterpret_cast' '<' type-name '>' '(' expression ')'
1313 /// 'const_cast' '<' type-name '>' '(' expression ')'
1314 ///
1315 ExprResult Parser::ParseCXXCasts() {
1316  tok::TokenKind Kind = Tok.getKind();
1317  const char *CastName = nullptr; // For error messages
1318 
1319  switch (Kind) {
1320  default: llvm_unreachable("Unknown C++ cast!");
1321  case tok::kw_const_cast: CastName = "const_cast"; break;
1322  case tok::kw_dynamic_cast: CastName = "dynamic_cast"; break;
1323  case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break;
1324  case tok::kw_static_cast: CastName = "static_cast"; break;
1325  }
1326 
1327  SourceLocation OpLoc = ConsumeToken();
1328  SourceLocation LAngleBracketLoc = Tok.getLocation();
1329 
1330  // Check for "<::" which is parsed as "[:". If found, fix token stream,
1331  // diagnose error, suggest fix, and recover parsing.
1332  if (Tok.is(tok::l_square) && Tok.getLength() == 2) {
1333  Token Next = NextToken();
1334  if (Next.is(tok::colon) && areTokensAdjacent(Tok, Next))
1335  FixDigraph(*this, PP, Tok, Next, Kind, /*AtDigraph*/true);
1336  }
1337 
1338  if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
1339  return ExprError();
1340 
1341  // Parse the common declaration-specifiers piece.
1342  DeclSpec DS(AttrFactory);
1343  ParseSpecifierQualifierList(DS);
1344 
1345  // Parse the abstract-declarator, if present.
1346  Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
1347  ParseDeclarator(DeclaratorInfo);
1348 
1349  SourceLocation RAngleBracketLoc = Tok.getLocation();
1350 
1351  if (ExpectAndConsume(tok::greater))
1352  return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << tok::less);
1353 
1354  SourceLocation LParenLoc, RParenLoc;
1355  BalancedDelimiterTracker T(*this, tok::l_paren);
1356 
1357  if (T.expectAndConsume(diag::err_expected_lparen_after, CastName))
1358  return ExprError();
1359 
1360  ExprResult Result = ParseExpression();
1361 
1362  // Match the ')'.
1363  T.consumeClose();
1364 
1365  if (!Result.isInvalid() && !DeclaratorInfo.isInvalidType())
1366  Result = Actions.ActOnCXXNamedCast(OpLoc, Kind,
1367  LAngleBracketLoc, DeclaratorInfo,
1368  RAngleBracketLoc,
1369  T.getOpenLocation(), Result.get(),
1370  T.getCloseLocation());
1371 
1372  return Result;
1373 }
1374 
1375 /// ParseCXXTypeid - This handles the C++ typeid expression.
1376 ///
1377 /// postfix-expression: [C++ 5.2p1]
1378 /// 'typeid' '(' expression ')'
1379 /// 'typeid' '(' type-id ')'
1380 ///
1381 ExprResult Parser::ParseCXXTypeid() {
1382  assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!");
1383 
1384  SourceLocation OpLoc = ConsumeToken();
1385  SourceLocation LParenLoc, RParenLoc;
1386  BalancedDelimiterTracker T(*this, tok::l_paren);
1387 
1388  // typeid expressions are always parenthesized.
1389  if (T.expectAndConsume(diag::err_expected_lparen_after, "typeid"))
1390  return ExprError();
1391  LParenLoc = T.getOpenLocation();
1392 
1394 
1395  // C++0x [expr.typeid]p3:
1396  // When typeid is applied to an expression other than an lvalue of a
1397  // polymorphic class type [...] The expression is an unevaluated
1398  // operand (Clause 5).
1399  //
1400  // Note that we can't tell whether the expression is an lvalue of a
1401  // polymorphic class type until after we've parsed the expression; we
1402  // speculatively assume the subexpression is unevaluated, and fix it up
1403  // later.
1404  //
1405  // We enter the unevaluated context before trying to determine whether we
1406  // have a type-id, because the tentative parse logic will try to resolve
1407  // names, and must treat them as unevaluated.
1411 
1412  if (isTypeIdInParens()) {
1413  TypeResult Ty = ParseTypeName();
1414 
1415  // Match the ')'.
1416  T.consumeClose();
1417  RParenLoc = T.getCloseLocation();
1418  if (Ty.isInvalid() || RParenLoc.isInvalid())
1419  return ExprError();
1420 
1421  Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true,
1422  Ty.get().getAsOpaquePtr(), RParenLoc);
1423  } else {
1424  Result = ParseExpression();
1425 
1426  // Match the ')'.
1427  if (Result.isInvalid())
1428  SkipUntil(tok::r_paren, StopAtSemi);
1429  else {
1430  T.consumeClose();
1431  RParenLoc = T.getCloseLocation();
1432  if (RParenLoc.isInvalid())
1433  return ExprError();
1434 
1435  Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false,
1436  Result.get(), RParenLoc);
1437  }
1438  }
1439 
1440  return Result;
1441 }
1442 
1443 /// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
1444 ///
1445 /// '__uuidof' '(' expression ')'
1446 /// '__uuidof' '(' type-id ')'
1447 ///
1448 ExprResult Parser::ParseCXXUuidof() {
1449  assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!");
1450 
1451  SourceLocation OpLoc = ConsumeToken();
1452  BalancedDelimiterTracker T(*this, tok::l_paren);
1453 
1454  // __uuidof expressions are always parenthesized.
1455  if (T.expectAndConsume(diag::err_expected_lparen_after, "__uuidof"))
1456  return ExprError();
1457 
1459 
1460  if (isTypeIdInParens()) {
1461  TypeResult Ty = ParseTypeName();
1462 
1463  // Match the ')'.
1464  T.consumeClose();
1465 
1466  if (Ty.isInvalid())
1467  return ExprError();
1468 
1469  Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), /*isType=*/true,
1470  Ty.get().getAsOpaquePtr(),
1471  T.getCloseLocation());
1472  } else {
1475  Result = ParseExpression();
1476 
1477  // Match the ')'.
1478  if (Result.isInvalid())
1479  SkipUntil(tok::r_paren, StopAtSemi);
1480  else {
1481  T.consumeClose();
1482 
1483  Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(),
1484  /*isType=*/false,
1485  Result.get(), T.getCloseLocation());
1486  }
1487  }
1488 
1489  return Result;
1490 }
1491 
1492 /// \brief Parse a C++ pseudo-destructor expression after the base,
1493 /// . or -> operator, and nested-name-specifier have already been
1494 /// parsed.
1495 ///
1496 /// postfix-expression: [C++ 5.2]
1497 /// postfix-expression . pseudo-destructor-name
1498 /// postfix-expression -> pseudo-destructor-name
1499 ///
1500 /// pseudo-destructor-name:
1501 /// ::[opt] nested-name-specifier[opt] type-name :: ~type-name
1502 /// ::[opt] nested-name-specifier template simple-template-id ::
1503 /// ~type-name
1504 /// ::[opt] nested-name-specifier[opt] ~type-name
1505 ///
1506 ExprResult
1507 Parser::ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc,
1508  tok::TokenKind OpKind,
1509  CXXScopeSpec &SS,
1510  ParsedType ObjectType) {
1511  // We're parsing either a pseudo-destructor-name or a dependent
1512  // member access that has the same form as a
1513  // pseudo-destructor-name. We parse both in the same way and let
1514  // the action model sort them out.
1515  //
1516  // Note that the ::[opt] nested-name-specifier[opt] has already
1517  // been parsed, and if there was a simple-template-id, it has
1518  // been coalesced into a template-id annotation token.
1519  UnqualifiedId FirstTypeName;
1520  SourceLocation CCLoc;
1521  if (Tok.is(tok::identifier)) {
1522  FirstTypeName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1523  ConsumeToken();
1524  assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1525  CCLoc = ConsumeToken();
1526  } else if (Tok.is(tok::annot_template_id)) {
1527  // FIXME: retrieve TemplateKWLoc from template-id annotation and
1528  // store it in the pseudo-dtor node (to be used when instantiating it).
1529  FirstTypeName.setTemplateId(
1531  ConsumeAnnotationToken();
1532  assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1533  CCLoc = ConsumeToken();
1534  } else {
1535  FirstTypeName.setIdentifier(nullptr, SourceLocation());
1536  }
1537 
1538  // Parse the tilde.
1539  assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail");
1540  SourceLocation TildeLoc = ConsumeToken();
1541 
1542  if (Tok.is(tok::kw_decltype) && !FirstTypeName.isValid() && SS.isEmpty()) {
1543  DeclSpec DS(AttrFactory);
1544  ParseDecltypeSpecifier(DS);
1545  if (DS.getTypeSpecType() == TST_error)
1546  return ExprError();
1547  return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1548  TildeLoc, DS);
1549  }
1550 
1551  if (!Tok.is(tok::identifier)) {
1552  Diag(Tok, diag::err_destructor_tilde_identifier);
1553  return ExprError();
1554  }
1555 
1556  // Parse the second type.
1557  UnqualifiedId SecondTypeName;
1558  IdentifierInfo *Name = Tok.getIdentifierInfo();
1559  SourceLocation NameLoc = ConsumeToken();
1560  SecondTypeName.setIdentifier(Name, NameLoc);
1561 
1562  // If there is a '<', the second type name is a template-id. Parse
1563  // it as such.
1564  if (Tok.is(tok::less) &&
1565  ParseUnqualifiedIdTemplateId(SS, SourceLocation(),
1566  Name, NameLoc,
1567  false, ObjectType, SecondTypeName,
1568  /*AssumeTemplateName=*/true))
1569  return ExprError();
1570 
1571  return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1572  SS, FirstTypeName, CCLoc, TildeLoc,
1573  SecondTypeName);
1574 }
1575 
1576 /// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
1577 ///
1578 /// boolean-literal: [C++ 2.13.5]
1579 /// 'true'
1580 /// 'false'
1581 ExprResult Parser::ParseCXXBoolLiteral() {
1582  tok::TokenKind Kind = Tok.getKind();
1583  return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
1584 }
1585 
1586 /// ParseThrowExpression - This handles the C++ throw expression.
1587 ///
1588 /// throw-expression: [C++ 15]
1589 /// 'throw' assignment-expression[opt]
1590 ExprResult Parser::ParseThrowExpression() {
1591  assert(Tok.is(tok::kw_throw) && "Not throw!");
1592  SourceLocation ThrowLoc = ConsumeToken(); // Eat the throw token.
1593 
1594  // If the current token isn't the start of an assignment-expression,
1595  // then the expression is not present. This handles things like:
1596  // "C ? throw : (void)42", which is crazy but legal.
1597  switch (Tok.getKind()) { // FIXME: move this predicate somewhere common.
1598  case tok::semi:
1599  case tok::r_paren:
1600  case tok::r_square:
1601  case tok::r_brace:
1602  case tok::colon:
1603  case tok::comma:
1604  return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, nullptr);
1605 
1606  default:
1608  if (Expr.isInvalid()) return Expr;
1609  return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.get());
1610  }
1611 }
1612 
1613 /// \brief Parse the C++ Coroutines co_yield expression.
1614 ///
1615 /// co_yield-expression:
1616 /// 'co_yield' assignment-expression[opt]
1617 ExprResult Parser::ParseCoyieldExpression() {
1618  assert(Tok.is(tok::kw_co_yield) && "Not co_yield!");
1619 
1620  SourceLocation Loc = ConsumeToken();
1621  ExprResult Expr = Tok.is(tok::l_brace) ? ParseBraceInitializer()
1623  if (!Expr.isInvalid())
1624  Expr = Actions.ActOnCoyieldExpr(getCurScope(), Loc, Expr.get());
1625  return Expr;
1626 }
1627 
1628 /// ParseCXXThis - This handles the C++ 'this' pointer.
1629 ///
1630 /// C++ 9.3.2: In the body of a non-static member function, the keyword this is
1631 /// a non-lvalue expression whose value is the address of the object for which
1632 /// the function is called.
1633 ExprResult Parser::ParseCXXThis() {
1634  assert(Tok.is(tok::kw_this) && "Not 'this'!");
1635  SourceLocation ThisLoc = ConsumeToken();
1636  return Actions.ActOnCXXThis(ThisLoc);
1637 }
1638 
1639 /// ParseCXXTypeConstructExpression - Parse construction of a specified type.
1640 /// Can be interpreted either as function-style casting ("int(x)")
1641 /// or class type construction ("ClassType(x,y,z)")
1642 /// or creation of a value-initialized type ("int()").
1643 /// See [C++ 5.2.3].
1644 ///
1645 /// postfix-expression: [C++ 5.2p1]
1646 /// simple-type-specifier '(' expression-list[opt] ')'
1647 /// [C++0x] simple-type-specifier braced-init-list
1648 /// typename-specifier '(' expression-list[opt] ')'
1649 /// [C++0x] typename-specifier braced-init-list
1650 ///
1651 /// In C++1z onwards, the type specifier can also be a template-name.
1652 ExprResult
1653 Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
1654  Declarator DeclaratorInfo(DS, Declarator::FunctionalCastContext);
1655  ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
1656 
1657  assert((Tok.is(tok::l_paren) ||
1658  (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)))
1659  && "Expected '(' or '{'!");
1660 
1661  if (Tok.is(tok::l_brace)) {
1662  ExprResult Init = ParseBraceInitializer();
1663  if (Init.isInvalid())
1664  return Init;
1665  Expr *InitList = Init.get();
1666  return Actions.ActOnCXXTypeConstructExpr(TypeRep, SourceLocation(),
1667  MultiExprArg(&InitList, 1),
1668  SourceLocation());
1669  } else {
1670  BalancedDelimiterTracker T(*this, tok::l_paren);
1671  T.consumeOpen();
1672 
1673  ExprVector Exprs;
1674  CommaLocsTy CommaLocs;
1675 
1676  if (Tok.isNot(tok::r_paren)) {
1677  if (ParseExpressionList(Exprs, CommaLocs, [&] {
1679  TypeRep.get()->getCanonicalTypeInternal(),
1680  DS.getLocEnd(), Exprs);
1681  })) {
1682  SkipUntil(tok::r_paren, StopAtSemi);
1683  return ExprError();
1684  }
1685  }
1686 
1687  // Match the ')'.
1688  T.consumeClose();
1689 
1690  // TypeRep could be null, if it references an invalid typedef.
1691  if (!TypeRep)
1692  return ExprError();
1693 
1694  assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&
1695  "Unexpected number of commas!");
1696  return Actions.ActOnCXXTypeConstructExpr(TypeRep, T.getOpenLocation(),
1697  Exprs,
1698  T.getCloseLocation());
1699  }
1700 }
1701 
1702 /// ParseCXXCondition - if/switch/while condition expression.
1703 ///
1704 /// condition:
1705 /// expression
1706 /// type-specifier-seq declarator '=' assignment-expression
1707 /// [C++11] type-specifier-seq declarator '=' initializer-clause
1708 /// [C++11] type-specifier-seq declarator braced-init-list
1709 /// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
1710 /// '=' assignment-expression
1711 ///
1712 /// In C++1z, a condition may in some contexts be preceded by an
1713 /// optional init-statement. This function will parse that too.
1714 ///
1715 /// \param InitStmt If non-null, an init-statement is permitted, and if present
1716 /// will be parsed and stored here.
1717 ///
1718 /// \param Loc The location of the start of the statement that requires this
1719 /// condition, e.g., the "for" in a for loop.
1720 ///
1721 /// \returns The parsed condition.
1722 Sema::ConditionResult Parser::ParseCXXCondition(StmtResult *InitStmt,
1723  SourceLocation Loc,
1724  Sema::ConditionKind CK) {
1725  if (Tok.is(tok::code_completion)) {
1727  cutOffParsing();
1728  return Sema::ConditionError();
1729  }
1730 
1731  ParsedAttributesWithRange attrs(AttrFactory);
1732  MaybeParseCXX11Attributes(attrs);
1733 
1734  // Determine what kind of thing we have.
1735  switch (isCXXConditionDeclarationOrInitStatement(InitStmt)) {
1737  ProhibitAttributes(attrs);
1738 
1739  // Parse the expression.
1740  ExprResult Expr = ParseExpression(); // expression
1741  if (Expr.isInvalid())
1742  return Sema::ConditionError();
1743 
1744  if (InitStmt && Tok.is(tok::semi)) {
1745  *InitStmt = Actions.ActOnExprStmt(Expr.get());
1746  ConsumeToken();
1747  return ParseCXXCondition(nullptr, Loc, CK);
1748  }
1749 
1750  return Actions.ActOnCondition(getCurScope(), Loc, Expr.get(), CK);
1751  }
1752 
1754  Diag(Tok.getLocation(), getLangOpts().CPlusPlus1z
1755  ? diag::warn_cxx14_compat_init_statement
1756  : diag::ext_init_statement)
1757  << (CK == Sema::ConditionKind::Switch);
1758  SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
1759  DeclGroupPtrTy DG = ParseSimpleDeclaration(
1760  Declarator::InitStmtContext, DeclEnd, attrs, /*RequireSemi=*/true);
1761  *InitStmt = Actions.ActOnDeclStmt(DG, DeclStart, DeclEnd);
1762  return ParseCXXCondition(nullptr, Loc, CK);
1763  }
1764 
1767  break;
1768  }
1769 
1770  // type-specifier-seq
1771  DeclSpec DS(AttrFactory);
1772  DS.takeAttributesFrom(attrs);
1773  ParseSpecifierQualifierList(DS, AS_none, DSC_condition);
1774 
1775  // declarator
1776  Declarator DeclaratorInfo(DS, Declarator::ConditionContext);
1777  ParseDeclarator(DeclaratorInfo);
1778 
1779  // simple-asm-expr[opt]
1780  if (Tok.is(tok::kw_asm)) {
1781  SourceLocation Loc;
1782  ExprResult AsmLabel(ParseSimpleAsm(&Loc));
1783  if (AsmLabel.isInvalid()) {
1784  SkipUntil(tok::semi, StopAtSemi);
1785  return Sema::ConditionError();
1786  }
1787  DeclaratorInfo.setAsmLabel(AsmLabel.get());
1788  DeclaratorInfo.SetRangeEnd(Loc);
1789  }
1790 
1791  // If attributes are present, parse them.
1792  MaybeParseGNUAttributes(DeclaratorInfo);
1793 
1794  // Type-check the declaration itself.
1796  DeclaratorInfo);
1797  if (Dcl.isInvalid())
1798  return Sema::ConditionError();
1799  Decl *DeclOut = Dcl.get();
1800 
1801  // '=' assignment-expression
1802  // If a '==' or '+=' is found, suggest a fixit to '='.
1803  bool CopyInitialization = isTokenEqualOrEqualTypo();
1804  if (CopyInitialization)
1805  ConsumeToken();
1806 
1807  ExprResult InitExpr = ExprError();
1808  if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
1809  Diag(Tok.getLocation(),
1810  diag::warn_cxx98_compat_generalized_initializer_lists);
1811  InitExpr = ParseBraceInitializer();
1812  } else if (CopyInitialization) {
1813  InitExpr = ParseAssignmentExpression();
1814  } else if (Tok.is(tok::l_paren)) {
1815  // This was probably an attempt to initialize the variable.
1816  SourceLocation LParen = ConsumeParen(), RParen = LParen;
1817  if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch))
1818  RParen = ConsumeParen();
1819  Diag(DeclOut->getLocation(),
1820  diag::err_expected_init_in_condition_lparen)
1821  << SourceRange(LParen, RParen);
1822  } else {
1823  Diag(DeclOut->getLocation(), diag::err_expected_init_in_condition);
1824  }
1825 
1826  if (!InitExpr.isInvalid())
1827  Actions.AddInitializerToDecl(DeclOut, InitExpr.get(), !CopyInitialization);
1828  else
1829  Actions.ActOnInitializerError(DeclOut);
1830 
1831  Actions.FinalizeDeclaration(DeclOut);
1832  return Actions.ActOnConditionVariable(DeclOut, Loc, CK);
1833 }
1834 
1835 /// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
1836 /// This should only be called when the current token is known to be part of
1837 /// simple-type-specifier.
1838 ///
1839 /// simple-type-specifier:
1840 /// '::'[opt] nested-name-specifier[opt] type-name
1841 /// '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
1842 /// char
1843 /// wchar_t
1844 /// bool
1845 /// short
1846 /// int
1847 /// long
1848 /// signed
1849 /// unsigned
1850 /// float
1851 /// double
1852 /// void
1853 /// [GNU] typeof-specifier
1854 /// [C++0x] auto [TODO]
1855 ///
1856 /// type-name:
1857 /// class-name
1858 /// enum-name
1859 /// typedef-name
1860 ///
1861 void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
1862  DS.SetRangeStart(Tok.getLocation());
1863  const char *PrevSpec;
1864  unsigned DiagID;
1865  SourceLocation Loc = Tok.getLocation();
1866  const clang::PrintingPolicy &Policy =
1867  Actions.getASTContext().getPrintingPolicy();
1868 
1869  switch (Tok.getKind()) {
1870  case tok::identifier: // foo::bar
1871  case tok::coloncolon: // ::foo::bar
1872  llvm_unreachable("Annotation token should already be formed!");
1873  default:
1874  llvm_unreachable("Not a simple-type-specifier token!");
1875 
1876  // type-name
1877  case tok::annot_typename: {
1878  if (getTypeAnnotation(Tok))
1879  DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID,
1880  getTypeAnnotation(Tok), Policy);
1881  else
1882  DS.SetTypeSpecError();
1883 
1884  DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1885  ConsumeAnnotationToken();
1886 
1887  DS.Finish(Actions, Policy);
1888  return;
1889  }
1890 
1891  // builtin types
1892  case tok::kw_short:
1893  DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID, Policy);
1894  break;
1895  case tok::kw_long:
1896  DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, DiagID, Policy);
1897  break;
1898  case tok::kw___int64:
1899  DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, DiagID, Policy);
1900  break;
1901  case tok::kw_signed:
1902  DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID);
1903  break;
1904  case tok::kw_unsigned:
1905  DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, DiagID);
1906  break;
1907  case tok::kw_void:
1908  DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID, Policy);
1909  break;
1910  case tok::kw_char:
1911  DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID, Policy);
1912  break;
1913  case tok::kw_int:
1914  DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID, Policy);
1915  break;
1916  case tok::kw___int128:
1917  DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID, Policy);
1918  break;
1919  case tok::kw_half:
1920  DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID, Policy);
1921  break;
1922  case tok::kw_float:
1923  DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID, Policy);
1924  break;
1925  case tok::kw_double:
1926  DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID, Policy);
1927  break;
1928  case tok::kw___float128:
1929  DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec, DiagID, Policy);
1930  break;
1931  case tok::kw_wchar_t:
1932  DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID, Policy);
1933  break;
1934  case tok::kw_char16_t:
1935  DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID, Policy);
1936  break;
1937  case tok::kw_char32_t:
1938  DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID, Policy);
1939  break;
1940  case tok::kw_bool:
1941  DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID, Policy);
1942  break;
1943  case tok::annot_decltype:
1944  case tok::kw_decltype:
1945  DS.SetRangeEnd(ParseDecltypeSpecifier(DS));
1946  return DS.Finish(Actions, Policy);
1947 
1948  // GNU typeof support.
1949  case tok::kw_typeof:
1950  ParseTypeofSpecifier(DS);
1951  DS.Finish(Actions, Policy);
1952  return;
1953  }
1954  ConsumeAnyToken();
1955  DS.SetRangeEnd(PrevTokLocation);
1956  DS.Finish(Actions, Policy);
1957 }
1958 
1959 /// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
1960 /// [dcl.name]), which is a non-empty sequence of type-specifiers,
1961 /// e.g., "const short int". Note that the DeclSpec is *not* finished
1962 /// by parsing the type-specifier-seq, because these sequences are
1963 /// typically followed by some form of declarator. Returns true and
1964 /// emits diagnostics if this is not a type-specifier-seq, false
1965 /// otherwise.
1966 ///
1967 /// type-specifier-seq: [C++ 8.1]
1968 /// type-specifier type-specifier-seq[opt]
1969 ///
1970 bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
1971  ParseSpecifierQualifierList(DS, AS_none, DSC_type_specifier);
1972  DS.Finish(Actions, Actions.getASTContext().getPrintingPolicy());
1973  return false;
1974 }
1975 
1976 /// \brief Finish parsing a C++ unqualified-id that is a template-id of
1977 /// some form.
1978 ///
1979 /// This routine is invoked when a '<' is encountered after an identifier or
1980 /// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
1981 /// whether the unqualified-id is actually a template-id. This routine will
1982 /// then parse the template arguments and form the appropriate template-id to
1983 /// return to the caller.
1984 ///
1985 /// \param SS the nested-name-specifier that precedes this template-id, if
1986 /// we're actually parsing a qualified-id.
1987 ///
1988 /// \param Name for constructor and destructor names, this is the actual
1989 /// identifier that may be a template-name.
1990 ///
1991 /// \param NameLoc the location of the class-name in a constructor or
1992 /// destructor.
1993 ///
1994 /// \param EnteringContext whether we're entering the scope of the
1995 /// nested-name-specifier.
1996 ///
1997 /// \param ObjectType if this unqualified-id occurs within a member access
1998 /// expression, the type of the base object whose member is being accessed.
1999 ///
2000 /// \param Id as input, describes the template-name or operator-function-id
2001 /// that precedes the '<'. If template arguments were parsed successfully,
2002 /// will be updated with the template-id.
2003 ///
2004 /// \param AssumeTemplateId When true, this routine will assume that the name
2005 /// refers to a template without performing name lookup to verify.
2006 ///
2007 /// \returns true if a parse error occurred, false otherwise.
2008 bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
2009  SourceLocation TemplateKWLoc,
2010  IdentifierInfo *Name,
2011  SourceLocation NameLoc,
2012  bool EnteringContext,
2013  ParsedType ObjectType,
2014  UnqualifiedId &Id,
2015  bool AssumeTemplateId) {
2016  assert((AssumeTemplateId || Tok.is(tok::less)) &&
2017  "Expected '<' to finish parsing a template-id");
2018 
2019  TemplateTy Template;
2021  switch (Id.getKind()) {
2025  if (AssumeTemplateId) {
2026  // We defer the injected-class-name checks until we've found whether
2027  // this template-id is used to form a nested-name-specifier or not.
2028  TNK = Actions.ActOnDependentTemplateName(
2029  getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
2030  Template, /*AllowInjectedClassName*/ true);
2031  if (TNK == TNK_Non_template)
2032  return true;
2033  } else {
2034  bool MemberOfUnknownSpecialization;
2035  TNK = Actions.isTemplateName(getCurScope(), SS,
2036  TemplateKWLoc.isValid(), Id,
2037  ObjectType, EnteringContext, Template,
2038  MemberOfUnknownSpecialization);
2039 
2040  if (TNK == TNK_Non_template && MemberOfUnknownSpecialization &&
2041  ObjectType && IsTemplateArgumentList()) {
2042  // We have something like t->getAs<T>(), where getAs is a
2043  // member of an unknown specialization. However, this will only
2044  // parse correctly as a template, so suggest the keyword 'template'
2045  // before 'getAs' and treat this as a dependent template name.
2046  std::string Name;
2048  Name = Id.Identifier->getName();
2049  else {
2050  Name = "operator ";
2053  else
2054  Name += Id.Identifier->getName();
2055  }
2056  Diag(Id.StartLocation, diag::err_missing_dependent_template_keyword)
2057  << Name
2058  << FixItHint::CreateInsertion(Id.StartLocation, "template ");
2059  TNK = Actions.ActOnDependentTemplateName(
2060  getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
2061  Template, /*AllowInjectedClassName*/ true);
2062  if (TNK == TNK_Non_template)
2063  return true;
2064  }
2065  }
2066  break;
2067 
2069  UnqualifiedId TemplateName;
2070  bool MemberOfUnknownSpecialization;
2071  TemplateName.setIdentifier(Name, NameLoc);
2072  TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
2073  TemplateName, ObjectType,
2074  EnteringContext, Template,
2075  MemberOfUnknownSpecialization);
2076  break;
2077  }
2078 
2080  UnqualifiedId TemplateName;
2081  bool MemberOfUnknownSpecialization;
2082  TemplateName.setIdentifier(Name, NameLoc);
2083  if (ObjectType) {
2084  TNK = Actions.ActOnDependentTemplateName(
2085  getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
2086  EnteringContext, Template, /*AllowInjectedClassName*/ true);
2087  if (TNK == TNK_Non_template)
2088  return true;
2089  } else {
2090  TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
2091  TemplateName, ObjectType,
2092  EnteringContext, Template,
2093  MemberOfUnknownSpecialization);
2094 
2095  if (TNK == TNK_Non_template && !Id.DestructorName.get()) {
2096  Diag(NameLoc, diag::err_destructor_template_id)
2097  << Name << SS.getRange();
2098  return true;
2099  }
2100  }
2101  break;
2102  }
2103 
2104  default:
2105  return false;
2106  }
2107 
2108  if (TNK == TNK_Non_template)
2109  return false;
2110 
2111  // Parse the enclosed template argument list.
2112  SourceLocation LAngleLoc, RAngleLoc;
2113  TemplateArgList TemplateArgs;
2114  if (Tok.is(tok::less) && ParseTemplateIdAfterTemplateName(
2115  true, LAngleLoc, TemplateArgs, RAngleLoc))
2116  return true;
2117 
2118  if (Id.getKind() == UnqualifiedId::IK_Identifier ||
2121  // Form a parsed representation of the template-id to be stored in the
2122  // UnqualifiedId.
2123 
2124  // FIXME: Store name for literal operator too.
2125  IdentifierInfo *TemplateII =
2126  Id.getKind() == UnqualifiedId::IK_Identifier ? Id.Identifier : nullptr;
2128  ? OO_None
2130 
2132  SS, TemplateKWLoc, Id.StartLocation, TemplateII, OpKind, Template, TNK,
2133  LAngleLoc, RAngleLoc, TemplateArgs, TemplateIds);
2134 
2135  Id.setTemplateId(TemplateId);
2136  return false;
2137  }
2138 
2139  // Bundle the template arguments together.
2140  ASTTemplateArgsPtr TemplateArgsPtr(TemplateArgs);
2141 
2142  // Constructor and destructor names.
2144  = Actions.ActOnTemplateIdType(SS, TemplateKWLoc,
2145  Template, Name, NameLoc,
2146  LAngleLoc, TemplateArgsPtr, RAngleLoc,
2147  /*IsCtorOrDtorName=*/true);
2148  if (Type.isInvalid())
2149  return true;
2150 
2152  Id.setConstructorName(Type.get(), NameLoc, RAngleLoc);
2153  else
2154  Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc);
2155 
2156  return false;
2157 }
2158 
2159 /// \brief Parse an operator-function-id or conversion-function-id as part
2160 /// of a C++ unqualified-id.
2161 ///
2162 /// This routine is responsible only for parsing the operator-function-id or
2163 /// conversion-function-id; it does not handle template arguments in any way.
2164 ///
2165 /// \code
2166 /// operator-function-id: [C++ 13.5]
2167 /// 'operator' operator
2168 ///
2169 /// operator: one of
2170 /// new delete new[] delete[]
2171 /// + - * / % ^ & | ~
2172 /// ! = < > += -= *= /= %=
2173 /// ^= &= |= << >> >>= <<= == !=
2174 /// <= >= && || ++ -- , ->* ->
2175 /// () []
2176 ///
2177 /// conversion-function-id: [C++ 12.3.2]
2178 /// operator conversion-type-id
2179 ///
2180 /// conversion-type-id:
2181 /// type-specifier-seq conversion-declarator[opt]
2182 ///
2183 /// conversion-declarator:
2184 /// ptr-operator conversion-declarator[opt]
2185 /// \endcode
2186 ///
2187 /// \param SS The nested-name-specifier that preceded this unqualified-id. If
2188 /// non-empty, then we are parsing the unqualified-id of a qualified-id.
2189 ///
2190 /// \param EnteringContext whether we are entering the scope of the
2191 /// nested-name-specifier.
2192 ///
2193 /// \param ObjectType if this unqualified-id occurs within a member access
2194 /// expression, the type of the base object whose member is being accessed.
2195 ///
2196 /// \param Result on a successful parse, contains the parsed unqualified-id.
2197 ///
2198 /// \returns true if parsing fails, false otherwise.
2199 bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
2200  ParsedType ObjectType,
2201  UnqualifiedId &Result) {
2202  assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword");
2203 
2204  // Consume the 'operator' keyword.
2205  SourceLocation KeywordLoc = ConsumeToken();
2206 
2207  // Determine what kind of operator name we have.
2208  unsigned SymbolIdx = 0;
2209  SourceLocation SymbolLocations[3];
2211  switch (Tok.getKind()) {
2212  case tok::kw_new:
2213  case tok::kw_delete: {
2214  bool isNew = Tok.getKind() == tok::kw_new;
2215  // Consume the 'new' or 'delete'.
2216  SymbolLocations[SymbolIdx++] = ConsumeToken();
2217  // Check for array new/delete.
2218  if (Tok.is(tok::l_square) &&
2219  (!getLangOpts().CPlusPlus11 || NextToken().isNot(tok::l_square))) {
2220  // Consume the '[' and ']'.
2221  BalancedDelimiterTracker T(*this, tok::l_square);
2222  T.consumeOpen();
2223  T.consumeClose();
2224  if (T.getCloseLocation().isInvalid())
2225  return true;
2226 
2227  SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2228  SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2229  Op = isNew? OO_Array_New : OO_Array_Delete;
2230  } else {
2231  Op = isNew? OO_New : OO_Delete;
2232  }
2233  break;
2234  }
2235 
2236 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2237  case tok::Token: \
2238  SymbolLocations[SymbolIdx++] = ConsumeToken(); \
2239  Op = OO_##Name; \
2240  break;
2241 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2242 #include "clang/Basic/OperatorKinds.def"
2243 
2244  case tok::l_paren: {
2245  // Consume the '(' and ')'.
2246  BalancedDelimiterTracker T(*this, tok::l_paren);
2247  T.consumeOpen();
2248  T.consumeClose();
2249  if (T.getCloseLocation().isInvalid())
2250  return true;
2251 
2252  SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2253  SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2254  Op = OO_Call;
2255  break;
2256  }
2257 
2258  case tok::l_square: {
2259  // Consume the '[' and ']'.
2260  BalancedDelimiterTracker T(*this, tok::l_square);
2261  T.consumeOpen();
2262  T.consumeClose();
2263  if (T.getCloseLocation().isInvalid())
2264  return true;
2265 
2266  SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2267  SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2268  Op = OO_Subscript;
2269  break;
2270  }
2271 
2272  case tok::code_completion: {
2273  // Code completion for the operator name.
2275  cutOffParsing();
2276  // Don't try to parse any further.
2277  return true;
2278  }
2279 
2280  default:
2281  break;
2282  }
2283 
2284  if (Op != OO_None) {
2285  // We have parsed an operator-function-id.
2286  Result.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations);
2287  return false;
2288  }
2289 
2290  // Parse a literal-operator-id.
2291  //
2292  // literal-operator-id: C++11 [over.literal]
2293  // operator string-literal identifier
2294  // operator user-defined-string-literal
2295 
2296  if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {
2297  Diag(Tok.getLocation(), diag::warn_cxx98_compat_literal_operator);
2298 
2299  SourceLocation DiagLoc;
2300  unsigned DiagId = 0;
2301 
2302  // We're past translation phase 6, so perform string literal concatenation
2303  // before checking for "".
2304  SmallVector<Token, 4> Toks;
2306  while (isTokenStringLiteral()) {
2307  if (!Tok.is(tok::string_literal) && !DiagId) {
2308  // C++11 [over.literal]p1:
2309  // The string-literal or user-defined-string-literal in a
2310  // literal-operator-id shall have no encoding-prefix [...].
2311  DiagLoc = Tok.getLocation();
2312  DiagId = diag::err_literal_operator_string_prefix;
2313  }
2314  Toks.push_back(Tok);
2315  TokLocs.push_back(ConsumeStringToken());
2316  }
2317 
2318  StringLiteralParser Literal(Toks, PP);
2319  if (Literal.hadError)
2320  return true;
2321 
2322  // Grab the literal operator's suffix, which will be either the next token
2323  // or a ud-suffix from the string literal.
2324  IdentifierInfo *II = nullptr;
2325  SourceLocation SuffixLoc;
2326  if (!Literal.getUDSuffix().empty()) {
2327  II = &PP.getIdentifierTable().get(Literal.getUDSuffix());
2328  SuffixLoc =
2329  Lexer::AdvanceToTokenCharacter(TokLocs[Literal.getUDSuffixToken()],
2330  Literal.getUDSuffixOffset(),
2331  PP.getSourceManager(), getLangOpts());
2332  } else if (Tok.is(tok::identifier)) {
2333  II = Tok.getIdentifierInfo();
2334  SuffixLoc = ConsumeToken();
2335  TokLocs.push_back(SuffixLoc);
2336  } else {
2337  Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
2338  return true;
2339  }
2340 
2341  // The string literal must be empty.
2342  if (!Literal.GetString().empty() || Literal.Pascal) {
2343  // C++11 [over.literal]p1:
2344  // The string-literal or user-defined-string-literal in a
2345  // literal-operator-id shall [...] contain no characters
2346  // other than the implicit terminating '\0'.
2347  DiagLoc = TokLocs.front();
2348  DiagId = diag::err_literal_operator_string_not_empty;
2349  }
2350 
2351  if (DiagId) {
2352  // This isn't a valid literal-operator-id, but we think we know
2353  // what the user meant. Tell them what they should have written.
2354  SmallString<32> Str;
2355  Str += "\"\"";
2356  Str += II->getName();
2357  Diag(DiagLoc, DiagId) << FixItHint::CreateReplacement(
2358  SourceRange(TokLocs.front(), TokLocs.back()), Str);
2359  }
2360 
2361  Result.setLiteralOperatorId(II, KeywordLoc, SuffixLoc);
2362 
2363  return Actions.checkLiteralOperatorId(SS, Result);
2364  }
2365 
2366  // Parse a conversion-function-id.
2367  //
2368  // conversion-function-id: [C++ 12.3.2]
2369  // operator conversion-type-id
2370  //
2371  // conversion-type-id:
2372  // type-specifier-seq conversion-declarator[opt]
2373  //
2374  // conversion-declarator:
2375  // ptr-operator conversion-declarator[opt]
2376 
2377  // Parse the type-specifier-seq.
2378  DeclSpec DS(AttrFactory);
2379  if (ParseCXXTypeSpecifierSeq(DS)) // FIXME: ObjectType?
2380  return true;
2381 
2382  // Parse the conversion-declarator, which is merely a sequence of
2383  // ptr-operators.
2385  ParseDeclaratorInternal(D, /*DirectDeclParser=*/nullptr);
2386 
2387  // Finish up the type.
2388  TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D);
2389  if (Ty.isInvalid())
2390  return true;
2391 
2392  // Note that this is a conversion-function-id.
2393  Result.setConversionFunctionId(KeywordLoc, Ty.get(),
2394  D.getSourceRange().getEnd());
2395  return false;
2396 }
2397 
2398 /// \brief Parse a C++ unqualified-id (or a C identifier), which describes the
2399 /// name of an entity.
2400 ///
2401 /// \code
2402 /// unqualified-id: [C++ expr.prim.general]
2403 /// identifier
2404 /// operator-function-id
2405 /// conversion-function-id
2406 /// [C++0x] literal-operator-id [TODO]
2407 /// ~ class-name
2408 /// template-id
2409 ///
2410 /// \endcode
2411 ///
2412 /// \param SS The nested-name-specifier that preceded this unqualified-id. If
2413 /// non-empty, then we are parsing the unqualified-id of a qualified-id.
2414 ///
2415 /// \param EnteringContext whether we are entering the scope of the
2416 /// nested-name-specifier.
2417 ///
2418 /// \param AllowDestructorName whether we allow parsing of a destructor name.
2419 ///
2420 /// \param AllowConstructorName whether we allow parsing a constructor name.
2421 ///
2422 /// \param AllowDeductionGuide whether we allow parsing a deduction guide name.
2423 ///
2424 /// \param ObjectType if this unqualified-id occurs within a member access
2425 /// expression, the type of the base object whose member is being accessed.
2426 ///
2427 /// \param Result on a successful parse, contains the parsed unqualified-id.
2428 ///
2429 /// \returns true if parsing fails, false otherwise.
2430 bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext,
2431  bool AllowDestructorName,
2432  bool AllowConstructorName,
2433  bool AllowDeductionGuide,
2434  ParsedType ObjectType,
2435  SourceLocation& TemplateKWLoc,
2436  UnqualifiedId &Result) {
2437 
2438  // Handle 'A::template B'. This is for template-ids which have not
2439  // already been annotated by ParseOptionalCXXScopeSpecifier().
2440  bool TemplateSpecified = false;
2441  if (getLangOpts().CPlusPlus && Tok.is(tok::kw_template) &&
2442  (ObjectType || SS.isSet())) {
2443  TemplateSpecified = true;
2444  TemplateKWLoc = ConsumeToken();
2445  }
2446 
2447  // unqualified-id:
2448  // identifier
2449  // template-id (when it hasn't already been annotated)
2450  if (Tok.is(tok::identifier)) {
2451  // Consume the identifier.
2452  IdentifierInfo *Id = Tok.getIdentifierInfo();
2453  SourceLocation IdLoc = ConsumeToken();
2454 
2455  if (!getLangOpts().CPlusPlus) {
2456  // If we're not in C++, only identifiers matter. Record the
2457  // identifier and return.
2458  Result.setIdentifier(Id, IdLoc);
2459  return false;
2460  }
2461 
2462  ParsedTemplateTy TemplateName;
2463  if (AllowConstructorName &&
2464  Actions.isCurrentClassName(*Id, getCurScope(), &SS)) {
2465  // We have parsed a constructor name.
2466  ParsedType Ty = Actions.getTypeName(*Id, IdLoc, getCurScope(), &SS, false,
2467  false, nullptr,
2468  /*IsCtorOrDtorName=*/true,
2469  /*NonTrivialTypeSourceInfo=*/true);
2470  Result.setConstructorName(Ty, IdLoc, IdLoc);
2471  } else if (getLangOpts().CPlusPlus1z &&
2472  AllowDeductionGuide && SS.isEmpty() &&
2473  Actions.isDeductionGuideName(getCurScope(), *Id, IdLoc,
2474  &TemplateName)) {
2475  // We have parsed a template-name naming a deduction guide.
2476  Result.setDeductionGuideName(TemplateName, IdLoc);
2477  } else {
2478  // We have parsed an identifier.
2479  Result.setIdentifier(Id, IdLoc);
2480  }
2481 
2482  // If the next token is a '<', we may have a template.
2483  if (TemplateSpecified || Tok.is(tok::less))
2484  return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc, Id, IdLoc,
2485  EnteringContext, ObjectType,
2486  Result, TemplateSpecified);
2487 
2488  return false;
2489  }
2490 
2491  // unqualified-id:
2492  // template-id (already parsed and annotated)
2493  if (Tok.is(tok::annot_template_id)) {
2494  TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
2495 
2496  // If the template-name names the current class, then this is a constructor
2497  if (AllowConstructorName && TemplateId->Name &&
2498  Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
2499  if (SS.isSet()) {
2500  // C++ [class.qual]p2 specifies that a qualified template-name
2501  // is taken as the constructor name where a constructor can be
2502  // declared. Thus, the template arguments are extraneous, so
2503  // complain about them and remove them entirely.
2504  Diag(TemplateId->TemplateNameLoc,
2505  diag::err_out_of_line_constructor_template_id)
2506  << TemplateId->Name
2508  SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc));
2509  ParsedType Ty =
2510  Actions.getTypeName(*TemplateId->Name, TemplateId->TemplateNameLoc,
2511  getCurScope(), &SS, false, false, nullptr,
2512  /*IsCtorOrDtorName=*/true,
2513  /*NontrivialTypeSourceInfo=*/true);
2514  Result.setConstructorName(Ty, TemplateId->TemplateNameLoc,
2515  TemplateId->RAngleLoc);
2516  ConsumeAnnotationToken();
2517  return false;
2518  }
2519 
2520  Result.setConstructorTemplateId(TemplateId);
2521  ConsumeAnnotationToken();
2522  return false;
2523  }
2524 
2525  // We have already parsed a template-id; consume the annotation token as
2526  // our unqualified-id.
2527  Result.setTemplateId(TemplateId);
2528  TemplateKWLoc = TemplateId->TemplateKWLoc;
2529  ConsumeAnnotationToken();
2530  return false;
2531  }
2532 
2533  // unqualified-id:
2534  // operator-function-id
2535  // conversion-function-id
2536  if (Tok.is(tok::kw_operator)) {
2537  if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, Result))
2538  return true;
2539 
2540  // If we have an operator-function-id or a literal-operator-id and the next
2541  // token is a '<', we may have a
2542  //
2543  // template-id:
2544  // operator-function-id < template-argument-list[opt] >
2545  if ((Result.getKind() == UnqualifiedId::IK_OperatorFunctionId ||
2547  (TemplateSpecified || Tok.is(tok::less)))
2548  return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
2549  nullptr, SourceLocation(),
2550  EnteringContext, ObjectType,
2551  Result, TemplateSpecified);
2552 
2553  return false;
2554  }
2555 
2556  if (getLangOpts().CPlusPlus &&
2557  (AllowDestructorName || SS.isSet()) && Tok.is(tok::tilde)) {
2558  // C++ [expr.unary.op]p10:
2559  // There is an ambiguity in the unary-expression ~X(), where X is a
2560  // class-name. The ambiguity is resolved in favor of treating ~ as a
2561  // unary complement rather than treating ~X as referring to a destructor.
2562 
2563  // Parse the '~'.
2564  SourceLocation TildeLoc = ConsumeToken();
2565 
2566  if (SS.isEmpty() && Tok.is(tok::kw_decltype)) {
2567  DeclSpec DS(AttrFactory);
2568  SourceLocation EndLoc = ParseDecltypeSpecifier(DS);
2569  if (ParsedType Type =
2570  Actions.getDestructorTypeForDecltype(DS, ObjectType)) {
2571  Result.setDestructorName(TildeLoc, Type, EndLoc);
2572  return false;
2573  }
2574  return true;
2575  }
2576 
2577  // Parse the class-name.
2578  if (Tok.isNot(tok::identifier)) {
2579  Diag(Tok, diag::err_destructor_tilde_identifier);
2580  return true;
2581  }
2582 
2583  // If the user wrote ~T::T, correct it to T::~T.
2584  DeclaratorScopeObj DeclScopeObj(*this, SS);
2585  if (!TemplateSpecified && NextToken().is(tok::coloncolon)) {
2586  // Don't let ParseOptionalCXXScopeSpecifier() "correct"
2587  // `int A; struct { ~A::A(); };` to `int A; struct { ~A:A(); };`,
2588  // it will confuse this recovery logic.
2589  ColonProtectionRAIIObject ColonRAII(*this, false);
2590 
2591  if (SS.isSet()) {
2592  AnnotateScopeToken(SS, /*NewAnnotation*/true);
2593  SS.clear();
2594  }
2595  if (ParseOptionalCXXScopeSpecifier(SS, ObjectType, EnteringContext))
2596  return true;
2597  if (SS.isNotEmpty())
2598  ObjectType = nullptr;
2599  if (Tok.isNot(tok::identifier) || NextToken().is(tok::coloncolon) ||
2600  !SS.isSet()) {
2601  Diag(TildeLoc, diag::err_destructor_tilde_scope);
2602  return true;
2603  }
2604 
2605  // Recover as if the tilde had been written before the identifier.
2606  Diag(TildeLoc, diag::err_destructor_tilde_scope)
2607  << FixItHint::CreateRemoval(TildeLoc)
2608  << FixItHint::CreateInsertion(Tok.getLocation(), "~");
2609 
2610  // Temporarily enter the scope for the rest of this function.
2611  if (Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
2612  DeclScopeObj.EnterDeclaratorScope();
2613  }
2614 
2615  // Parse the class-name (or template-name in a simple-template-id).
2616  IdentifierInfo *ClassName = Tok.getIdentifierInfo();
2617  SourceLocation ClassNameLoc = ConsumeToken();
2618 
2619  if (TemplateSpecified || Tok.is(tok::less)) {
2620  Result.setDestructorName(TildeLoc, nullptr, ClassNameLoc);
2621  return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
2622  ClassName, ClassNameLoc,
2623  EnteringContext, ObjectType,
2624  Result, TemplateSpecified);
2625  }
2626 
2627  // Note that this is a destructor name.
2628  ParsedType Ty = Actions.getDestructorName(TildeLoc, *ClassName,
2629  ClassNameLoc, getCurScope(),
2630  SS, ObjectType,
2631  EnteringContext);
2632  if (!Ty)
2633  return true;
2634 
2635  Result.setDestructorName(TildeLoc, Ty, ClassNameLoc);
2636  return false;
2637  }
2638 
2639  Diag(Tok, diag::err_expected_unqualified_id)
2640  << getLangOpts().CPlusPlus;
2641  return true;
2642 }
2643 
2644 /// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
2645 /// memory in a typesafe manner and call constructors.
2646 ///
2647 /// This method is called to parse the new expression after the optional :: has
2648 /// been already parsed. If the :: was present, "UseGlobal" is true and "Start"
2649 /// is its location. Otherwise, "Start" is the location of the 'new' token.
2650 ///
2651 /// new-expression:
2652 /// '::'[opt] 'new' new-placement[opt] new-type-id
2653 /// new-initializer[opt]
2654 /// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2655 /// new-initializer[opt]
2656 ///
2657 /// new-placement:
2658 /// '(' expression-list ')'
2659 ///
2660 /// new-type-id:
2661 /// type-specifier-seq new-declarator[opt]
2662 /// [GNU] attributes type-specifier-seq new-declarator[opt]
2663 ///
2664 /// new-declarator:
2665 /// ptr-operator new-declarator[opt]
2666 /// direct-new-declarator
2667 ///
2668 /// new-initializer:
2669 /// '(' expression-list[opt] ')'
2670 /// [C++0x] braced-init-list
2671 ///
2672 ExprResult
2673 Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
2674  assert(Tok.is(tok::kw_new) && "expected 'new' token");
2675  ConsumeToken(); // Consume 'new'
2676 
2677  // A '(' now can be a new-placement or the '(' wrapping the type-id in the
2678  // second form of new-expression. It can't be a new-type-id.
2679 
2680  ExprVector PlacementArgs;
2681  SourceLocation PlacementLParen, PlacementRParen;
2682 
2683  SourceRange TypeIdParens;
2684  DeclSpec DS(AttrFactory);
2685  Declarator DeclaratorInfo(DS, Declarator::CXXNewContext);
2686  if (Tok.is(tok::l_paren)) {
2687  // If it turns out to be a placement, we change the type location.
2688  BalancedDelimiterTracker T(*this, tok::l_paren);
2689  T.consumeOpen();
2690  PlacementLParen = T.getOpenLocation();
2691  if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
2692  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2693  return ExprError();
2694  }
2695 
2696  T.consumeClose();
2697  PlacementRParen = T.getCloseLocation();
2698  if (PlacementRParen.isInvalid()) {
2699  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2700  return ExprError();
2701  }
2702 
2703  if (PlacementArgs.empty()) {
2704  // Reset the placement locations. There was no placement.
2705  TypeIdParens = T.getRange();
2706  PlacementLParen = PlacementRParen = SourceLocation();
2707  } else {
2708  // We still need the type.
2709  if (Tok.is(tok::l_paren)) {
2710  BalancedDelimiterTracker T(*this, tok::l_paren);
2711  T.consumeOpen();
2712  MaybeParseGNUAttributes(DeclaratorInfo);
2713  ParseSpecifierQualifierList(DS);
2714  DeclaratorInfo.SetSourceRange(DS.getSourceRange());
2715  ParseDeclarator(DeclaratorInfo);
2716  T.consumeClose();
2717  TypeIdParens = T.getRange();
2718  } else {
2719  MaybeParseGNUAttributes(DeclaratorInfo);
2720  if (ParseCXXTypeSpecifierSeq(DS))
2721  DeclaratorInfo.setInvalidType(true);
2722  else {
2723  DeclaratorInfo.SetSourceRange(DS.getSourceRange());
2724  ParseDeclaratorInternal(DeclaratorInfo,
2725  &Parser::ParseDirectNewDeclarator);
2726  }
2727  }
2728  }
2729  } else {
2730  // A new-type-id is a simplified type-id, where essentially the
2731  // direct-declarator is replaced by a direct-new-declarator.
2732  MaybeParseGNUAttributes(DeclaratorInfo);
2733  if (ParseCXXTypeSpecifierSeq(DS))
2734  DeclaratorInfo.setInvalidType(true);
2735  else {
2736  DeclaratorInfo.SetSourceRange(DS.getSourceRange());
2737  ParseDeclaratorInternal(DeclaratorInfo,
2738  &Parser::ParseDirectNewDeclarator);
2739  }
2740  }
2741  if (DeclaratorInfo.isInvalidType()) {
2742  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2743  return ExprError();
2744  }
2745 
2746  ExprResult Initializer;
2747 
2748  if (Tok.is(tok::l_paren)) {
2749  SourceLocation ConstructorLParen, ConstructorRParen;
2750  ExprVector ConstructorArgs;
2751  BalancedDelimiterTracker T(*this, tok::l_paren);
2752  T.consumeOpen();
2753  ConstructorLParen = T.getOpenLocation();
2754  if (Tok.isNot(tok::r_paren)) {
2755  CommaLocsTy CommaLocs;
2756  if (ParseExpressionList(ConstructorArgs, CommaLocs, [&] {
2757  ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(),
2758  DeclaratorInfo).get();
2760  TypeRep.get()->getCanonicalTypeInternal(),
2761  DeclaratorInfo.getLocEnd(),
2762  ConstructorArgs);
2763  })) {
2764  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2765  return ExprError();
2766  }
2767  }
2768  T.consumeClose();
2769  ConstructorRParen = T.getCloseLocation();
2770  if (ConstructorRParen.isInvalid()) {
2771  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2772  return ExprError();
2773  }
2774  Initializer = Actions.ActOnParenListExpr(ConstructorLParen,
2775  ConstructorRParen,
2776  ConstructorArgs);
2777  } else if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus11) {
2778  Diag(Tok.getLocation(),
2779  diag::warn_cxx98_compat_generalized_initializer_lists);
2780  Initializer = ParseBraceInitializer();
2781  }
2782  if (Initializer.isInvalid())
2783  return Initializer;
2784 
2785  return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen,
2786  PlacementArgs, PlacementRParen,
2787  TypeIdParens, DeclaratorInfo, Initializer.get());
2788 }
2789 
2790 /// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
2791 /// passed to ParseDeclaratorInternal.
2792 ///
2793 /// direct-new-declarator:
2794 /// '[' expression ']'
2795 /// direct-new-declarator '[' constant-expression ']'
2796 ///
2797 void Parser::ParseDirectNewDeclarator(Declarator &D) {
2798  // Parse the array dimensions.
2799  bool first = true;
2800  while (Tok.is(tok::l_square)) {
2801  // An array-size expression can't start with a lambda.
2802  if (CheckProhibitedCXX11Attribute())
2803  continue;
2804 
2805  BalancedDelimiterTracker T(*this, tok::l_square);
2806  T.consumeOpen();
2807 
2808  ExprResult Size(first ? ParseExpression()
2810  if (Size.isInvalid()) {
2811  // Recover
2812  SkipUntil(tok::r_square, StopAtSemi);
2813  return;
2814  }
2815  first = false;
2816 
2817  T.consumeClose();
2818 
2819  // Attributes here appertain to the array type. C++11 [expr.new]p5.
2820  ParsedAttributes Attrs(AttrFactory);
2821  MaybeParseCXX11Attributes(Attrs);
2822 
2824  /*static=*/false, /*star=*/false,
2825  Size.get(),
2826  T.getOpenLocation(),
2827  T.getCloseLocation()),
2828  Attrs, T.getCloseLocation());
2829 
2830  if (T.getCloseLocation().isInvalid())
2831  return;
2832  }
2833 }
2834 
2835 /// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
2836 /// This ambiguity appears in the syntax of the C++ new operator.
2837 ///
2838 /// new-expression:
2839 /// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2840 /// new-initializer[opt]
2841 ///
2842 /// new-placement:
2843 /// '(' expression-list ')'
2844 ///
2845 bool Parser::ParseExpressionListOrTypeId(
2846  SmallVectorImpl<Expr*> &PlacementArgs,
2847  Declarator &D) {
2848  // The '(' was already consumed.
2849  if (isTypeIdInParens()) {
2850  ParseSpecifierQualifierList(D.getMutableDeclSpec());
2852  ParseDeclarator(D);
2853  return D.isInvalidType();
2854  }
2855 
2856  // It's not a type, it has to be an expression list.
2857  // Discard the comma locations - ActOnCXXNew has enough parameters.
2858  CommaLocsTy CommaLocs;
2859  return ParseExpressionList(PlacementArgs, CommaLocs);
2860 }
2861 
2862 /// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
2863 /// to free memory allocated by new.
2864 ///
2865 /// This method is called to parse the 'delete' expression after the optional
2866 /// '::' has been already parsed. If the '::' was present, "UseGlobal" is true
2867 /// and "Start" is its location. Otherwise, "Start" is the location of the
2868 /// 'delete' token.
2869 ///
2870 /// delete-expression:
2871 /// '::'[opt] 'delete' cast-expression
2872 /// '::'[opt] 'delete' '[' ']' cast-expression
2873 ExprResult
2874 Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
2875  assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword");
2876  ConsumeToken(); // Consume 'delete'
2877 
2878  // Array delete?
2879  bool ArrayDelete = false;
2880  if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
2881  // C++11 [expr.delete]p1:
2882  // Whenever the delete keyword is followed by empty square brackets, it
2883  // shall be interpreted as [array delete].
2884  // [Footnote: A lambda expression with a lambda-introducer that consists
2885  // of empty square brackets can follow the delete keyword if
2886  // the lambda expression is enclosed in parentheses.]
2887  // FIXME: Produce a better diagnostic if the '[]' is unambiguously a
2888  // lambda-introducer.
2889  ArrayDelete = true;
2890  BalancedDelimiterTracker T(*this, tok::l_square);
2891 
2892  T.consumeOpen();
2893  T.consumeClose();
2894  if (T.getCloseLocation().isInvalid())
2895  return ExprError();
2896  }
2897 
2898  ExprResult Operand(ParseCastExpression(false));
2899  if (Operand.isInvalid())
2900  return Operand;
2901 
2902  return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.get());
2903 }
2904 
2906  switch (kind) {
2907  default: llvm_unreachable("Not a known type trait");
2908 #define TYPE_TRAIT_1(Spelling, Name, Key) \
2909 case tok::kw_ ## Spelling: return UTT_ ## Name;
2910 #define TYPE_TRAIT_2(Spelling, Name, Key) \
2911 case tok::kw_ ## Spelling: return BTT_ ## Name;
2912 #include "clang/Basic/TokenKinds.def"
2913 #define TYPE_TRAIT_N(Spelling, Name, Key) \
2914  case tok::kw_ ## Spelling: return TT_ ## Name;
2915 #include "clang/Basic/TokenKinds.def"
2916  }
2917 }
2918 
2920  switch(kind) {
2921  default: llvm_unreachable("Not a known binary type trait");
2922  case tok::kw___array_rank: return ATT_ArrayRank;
2923  case tok::kw___array_extent: return ATT_ArrayExtent;
2924  }
2925 }
2926 
2928  switch(kind) {
2929  default: llvm_unreachable("Not a known unary expression trait.");
2930  case tok::kw___is_lvalue_expr: return ET_IsLValueExpr;
2931  case tok::kw___is_rvalue_expr: return ET_IsRValueExpr;
2932  }
2933 }
2934 
2936  switch (kind) {
2937  default: llvm_unreachable("Not a known type trait");
2938 #define TYPE_TRAIT(N,Spelling,K) case tok::kw_##Spelling: return N;
2939 #include "clang/Basic/TokenKinds.def"
2940  }
2941 }
2942 
2943 /// \brief Parse the built-in type-trait pseudo-functions that allow
2944 /// implementation of the TR1/C++11 type traits templates.
2945 ///
2946 /// primary-expression:
2947 /// unary-type-trait '(' type-id ')'
2948 /// binary-type-trait '(' type-id ',' type-id ')'
2949 /// type-trait '(' type-id-seq ')'
2950 ///
2951 /// type-id-seq:
2952 /// type-id ...[opt] type-id-seq[opt]
2953 ///
2954 ExprResult Parser::ParseTypeTrait() {
2955  tok::TokenKind Kind = Tok.getKind();
2956  unsigned Arity = TypeTraitArity(Kind);
2957 
2958  SourceLocation Loc = ConsumeToken();
2959 
2960  BalancedDelimiterTracker Parens(*this, tok::l_paren);
2961  if (Parens.expectAndConsume())
2962  return ExprError();
2963 
2965  do {
2966  // Parse the next type.
2967  TypeResult Ty = ParseTypeName();
2968  if (Ty.isInvalid()) {
2969  Parens.skipToEnd();
2970  return ExprError();
2971  }
2972 
2973  // Parse the ellipsis, if present.
2974  if (Tok.is(tok::ellipsis)) {
2975  Ty = Actions.ActOnPackExpansion(Ty.get(), ConsumeToken());
2976  if (Ty.isInvalid()) {
2977  Parens.skipToEnd();
2978  return ExprError();
2979  }
2980  }
2981 
2982  // Add this type to the list of arguments.
2983  Args.push_back(Ty.get());
2984  } while (TryConsumeToken(tok::comma));
2985 
2986  if (Parens.consumeClose())
2987  return ExprError();
2988 
2989  SourceLocation EndLoc = Parens.getCloseLocation();
2990 
2991  if (Arity && Args.size() != Arity) {
2992  Diag(EndLoc, diag::err_type_trait_arity)
2993  << Arity << 0 << (Arity > 1) << (int)Args.size() << SourceRange(Loc);
2994  return ExprError();
2995  }
2996 
2997  if (!Arity && Args.empty()) {
2998  Diag(EndLoc, diag::err_type_trait_arity)
2999  << 1 << 1 << 1 << (int)Args.size() << SourceRange(Loc);
3000  return ExprError();
3001  }
3002 
3003  return Actions.ActOnTypeTrait(TypeTraitFromTokKind(Kind), Loc, Args, EndLoc);
3004 }
3005 
3006 /// ParseArrayTypeTrait - Parse the built-in array type-trait
3007 /// pseudo-functions.
3008 ///
3009 /// primary-expression:
3010 /// [Embarcadero] '__array_rank' '(' type-id ')'
3011 /// [Embarcadero] '__array_extent' '(' type-id ',' expression ')'
3012 ///
3013 ExprResult Parser::ParseArrayTypeTrait() {
3015  SourceLocation Loc = ConsumeToken();
3016 
3017  BalancedDelimiterTracker T(*this, tok::l_paren);
3018  if (T.expectAndConsume())
3019  return ExprError();
3020 
3021  TypeResult Ty = ParseTypeName();
3022  if (Ty.isInvalid()) {
3023  SkipUntil(tok::comma, StopAtSemi);
3024  SkipUntil(tok::r_paren, StopAtSemi);
3025  return ExprError();
3026  }
3027 
3028  switch (ATT) {
3029  case ATT_ArrayRank: {
3030  T.consumeClose();
3031  return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), nullptr,
3032  T.getCloseLocation());
3033  }
3034  case ATT_ArrayExtent: {
3035  if (ExpectAndConsume(tok::comma)) {
3036  SkipUntil(tok::r_paren, StopAtSemi);
3037  return ExprError();
3038  }
3039 
3040  ExprResult DimExpr = ParseExpression();
3041  T.consumeClose();
3042 
3043  return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), DimExpr.get(),
3044  T.getCloseLocation());
3045  }
3046  }
3047  llvm_unreachable("Invalid ArrayTypeTrait!");
3048 }
3049 
3050 /// ParseExpressionTrait - Parse built-in expression-trait
3051 /// pseudo-functions like __is_lvalue_expr( xxx ).
3052 ///
3053 /// primary-expression:
3054 /// [Embarcadero] expression-trait '(' expression ')'
3055 ///
3056 ExprResult Parser::ParseExpressionTrait() {
3058  SourceLocation Loc = ConsumeToken();
3059 
3060  BalancedDelimiterTracker T(*this, tok::l_paren);
3061  if (T.expectAndConsume())
3062  return ExprError();
3063 
3064  ExprResult Expr = ParseExpression();
3065 
3066  T.consumeClose();
3067 
3068  return Actions.ActOnExpressionTrait(ET, Loc, Expr.get(),
3069  T.getCloseLocation());
3070 }
3071 
3072 
3073 /// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
3074 /// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
3075 /// based on the context past the parens.
3076 ExprResult
3077 Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
3078  ParsedType &CastTy,
3079  BalancedDelimiterTracker &Tracker,
3080  ColonProtectionRAIIObject &ColonProt) {
3081  assert(getLangOpts().CPlusPlus && "Should only be called for C++!");
3082  assert(ExprType == CastExpr && "Compound literals are not ambiguous!");
3083  assert(isTypeIdInParens() && "Not a type-id!");
3084 
3085  ExprResult Result(true);
3086  CastTy = nullptr;
3087 
3088  // We need to disambiguate a very ugly part of the C++ syntax:
3089  //
3090  // (T())x; - type-id
3091  // (T())*x; - type-id
3092  // (T())/x; - expression
3093  // (T()); - expression
3094  //
3095  // The bad news is that we cannot use the specialized tentative parser, since
3096  // it can only verify that the thing inside the parens can be parsed as
3097  // type-id, it is not useful for determining the context past the parens.
3098  //
3099  // The good news is that the parser can disambiguate this part without
3100  // making any unnecessary Action calls.
3101  //
3102  // It uses a scheme similar to parsing inline methods. The parenthesized
3103  // tokens are cached, the context that follows is determined (possibly by
3104  // parsing a cast-expression), and then we re-introduce the cached tokens
3105  // into the token stream and parse them appropriately.
3106 
3107  ParenParseOption ParseAs;
3108  CachedTokens Toks;
3109 
3110  // Store the tokens of the parentheses. We will parse them after we determine
3111  // the context that follows them.
3112  if (!ConsumeAndStoreUntil(tok::r_paren, Toks)) {
3113  // We didn't find the ')' we expected.
3114  Tracker.consumeClose();
3115  return ExprError();
3116  }
3117 
3118  if (Tok.is(tok::l_brace)) {
3119  ParseAs = CompoundLiteral;
3120  } else {
3121  bool NotCastExpr;
3122  if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) {
3123  NotCastExpr = true;
3124  } else {
3125  // Try parsing the cast-expression that may follow.
3126  // If it is not a cast-expression, NotCastExpr will be true and no token
3127  // will be consumed.
3128  ColonProt.restore();
3129  Result = ParseCastExpression(false/*isUnaryExpression*/,
3130  false/*isAddressofOperand*/,
3131  NotCastExpr,
3132  // type-id has priority.
3133  IsTypeCast);
3134  }
3135 
3136  // If we parsed a cast-expression, it's really a type-id, otherwise it's
3137  // an expression.
3138  ParseAs = NotCastExpr ? SimpleExpr : CastExpr;
3139  }
3140 
3141  // Create a fake EOF to mark end of Toks buffer.
3142  Token AttrEnd;
3143  AttrEnd.startToken();
3144  AttrEnd.setKind(tok::eof);
3145  AttrEnd.setLocation(Tok.getLocation());
3146  AttrEnd.setEofData(Toks.data());
3147  Toks.push_back(AttrEnd);
3148 
3149  // The current token should go after the cached tokens.
3150  Toks.push_back(Tok);
3151  // Re-enter the stored parenthesized tokens into the token stream, so we may
3152  // parse them now.
3153  PP.EnterTokenStream(Toks, true /*DisableMacroExpansion*/);
3154  // Drop the current token and bring the first cached one. It's the same token
3155  // as when we entered this function.
3156  ConsumeAnyToken();
3157 
3158  if (ParseAs >= CompoundLiteral) {
3159  // Parse the type declarator.
3160  DeclSpec DS(AttrFactory);
3161  Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
3162  {
3163  ColonProtectionRAIIObject InnerColonProtection(*this);
3164  ParseSpecifierQualifierList(DS);
3165  ParseDeclarator(DeclaratorInfo);
3166  }
3167 
3168  // Match the ')'.
3169  Tracker.consumeClose();
3170  ColonProt.restore();
3171 
3172  // Consume EOF marker for Toks buffer.
3173  assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData());
3174  ConsumeAnyToken();
3175 
3176  if (ParseAs == CompoundLiteral) {
3177  ExprType = CompoundLiteral;
3178  if (DeclaratorInfo.isInvalidType())
3179  return ExprError();
3180 
3181  TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
3182  return ParseCompoundLiteralExpression(Ty.get(),
3183  Tracker.getOpenLocation(),
3184  Tracker.getCloseLocation());
3185  }
3186 
3187  // We parsed '(' type-id ')' and the thing after it wasn't a '{'.
3188  assert(ParseAs == CastExpr);
3189 
3190  if (DeclaratorInfo.isInvalidType())
3191  return ExprError();
3192 
3193  // Result is what ParseCastExpression returned earlier.
3194  if (!Result.isInvalid())
3195  Result = Actions.ActOnCastExpr(getCurScope(), Tracker.getOpenLocation(),
3196  DeclaratorInfo, CastTy,
3197  Tracker.getCloseLocation(), Result.get());
3198  return Result;
3199  }
3200 
3201  // Not a compound literal, and not followed by a cast-expression.
3202  assert(ParseAs == SimpleExpr);
3203 
3204  ExprType = SimpleExpr;
3205  Result = ParseExpression();
3206  if (!Result.isInvalid() && Tok.is(tok::r_paren))
3207  Result = Actions.ActOnParenExpr(Tracker.getOpenLocation(),
3208  Tok.getLocation(), Result.get());
3209 
3210  // Match the ')'.
3211  if (Result.isInvalid()) {
3212  while (Tok.isNot(tok::eof))
3213  ConsumeAnyToken();
3214  assert(Tok.getEofData() == AttrEnd.getEofData());
3215  ConsumeAnyToken();
3216  return ExprError();
3217  }
3218 
3219  Tracker.consumeClose();
3220  // Consume EOF marker for Toks buffer.
3221  assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData());
3222  ConsumeAnyToken();
3223  return Result;
3224 }
SourceManager & getSourceManager() const
Definition: Preprocessor.h:729
static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind)
SourceLocation getCloseLocation() const
Defines the clang::ASTContext interface.
SourceLocation getEnd() const
void setConstructorName(ParsedType ClassType, SourceLocation ClassNameLoc, SourceLocation EndLoc)
Specify that this unqualified-id was parsed as a constructor name.
Definition: DeclSpec.h:1067
ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, Expr *SubExpr, ConditionKind CK)
Definition: SemaExpr.cpp:14981
ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, ParsedType LhsTy, Expr *DimExpr, SourceLocation RParen)
ActOnArrayTypeTrait - Parsed one of the binary type trait support pseudo-functions.
IdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:1001
ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc, Declarator &D, ParsedType &Ty, SourceLocation RParenLoc, Expr *CastExpr)
Definition: SemaExpr.cpp:5951
Disambiguated as an expression (either kind).
no exception specification
ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)
Simple precedence-based parser for binary/ternary operators.
Definition: ParseExpr.cpp:119
void restore()
restore - This can be used to restore the state early, before the dtor is run.
Keeps information about an identifier in a nested-name-spec.
Definition: Sema.h:5232
This is a scope that corresponds to the parameters within a function prototype.
Definition: Scope.h:80
bool isInvalid() const
Definition: Ownership.h:159
ConditionResult ActOnConditionVariable(Decl *ConditionVar, SourceLocation StmtLoc, ConditionKind CK)
bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id)
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
Definition: DeclSpec.h:1119
static const TSS TSS_unsigned
Definition: DeclSpec.h:268
bool ActOnCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo, bool EnteringContext, CXXScopeSpec &SS, bool ErrorRecoveryLookup=false, bool *IsCorrectedToColon=nullptr, bool OnlyNamespace=false)
The parser has parsed a nested-name-specifier 'identifier::'.
const Token & getCurToken() const
Definition: Parser.h:273
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
Definition: DeclSpec.h:978
IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
const LangOptions & getLangOpts() const
Definition: Parser.h:267
static const TST TST_wchar
Definition: DeclSpec.h:275
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
Definition: SemaExpr.cpp:6124
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
static ConditionResult ConditionError()
Definition: Sema.h:9639
const Token & LookAhead(unsigned N)
Peeks ahead N tokens and returns that token without consuming any tokens.
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID. ...
Stmt - This represents one statement.
Definition: Stmt.h:60
IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId, the identifier suffix.
Definition: DeclSpec.h:948
StmtResult ActOnExprStmt(ExprResult Arg)
Definition: SemaStmt.cpp:44
DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D)
ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a C++ if/switch/while/for statem...
void setEndLoc(SourceLocation Loc)
Definition: DeclSpec.h:71
static const TST TST_char16
Definition: DeclSpec.h:276
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:81
Defines the PrettyStackTraceEntry class, which is used to make crashes give more contextual informati...
bool SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:956
Defines the C++ template declaration subclasses.
StringRef P
const char * getName() const
Definition: Token.h:166
PtrTy get() const
Definition: Ownership.h:163
The base class of the type hierarchy.
Definition: Type.h:1303
This indicates that the scope corresponds to a function, which means that labels are set here...
Definition: Scope.h:46
void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, bool EnteringContext)
Parser - This implements a parser for the C family of languages.
Definition: Parser.h:57
bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS, NestedNameSpecInfo &IdInfo, bool EnteringContext)
IsInvalidUnlessNestedName - This method is used for error recovery purposes to determine whether the ...
ExprResult ActOnExpressionTrait(ExpressionTrait OET, SourceLocation KWLoc, Expr *Queried, SourceLocation RParen)
ActOnExpressionTrait - Parsed one of the unary type trait support pseudo-functions.
void CodeCompleteObjCMessageReceiver(Scope *S)
RAII object that enters a new expression evaluation context.
Definition: Sema.h:10497
void EnterToken(const Token &Tok)
Enters a token in the token stream to be lexed next.
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1733
static const TST TST_char
Definition: DeclSpec.h:274
Like System, but searched after the system directories.
void setBegin(SourceLocation b)
SourceLocation getLastCachedTokenLocation() const
Get the location of the last cached token, suitable for setting the end location of an annotation tok...
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, bool IsClassTemplateDeductionContext=true, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type...
Definition: SemaDecl.cpp:273
ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed...
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
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:934
Information about a template-id annotation token.
void CodeCompleteOrdinaryName(Scope *S, ParserCompletionContext CompletionContext)
void CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc, ArrayRef< Expr * > Args)
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
Definition: Parser.h:602
Disambiguated as a simple-declaration init-statement.
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:320
static TemplateIdAnnotation * Create(CXXScopeSpec SS, SourceLocation TemplateKWLoc, SourceLocation TemplateNameLoc, IdentifierInfo *Name, OverloadedOperatorKind OperatorKind, ParsedTemplateTy OpaqueTemplateName, TemplateNameKind TemplateKind, SourceLocation LAngleLoc, SourceLocation RAngleLoc, ArrayRef< ParsedTemplateArgument > TemplateArgs, SmallVectorImpl< TemplateIdAnnotation * > &CleanupList)
Creates a new TemplateIdAnnotation with NumArgs arguments and appends it to List. ...
bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS, const DeclSpec &DS, SourceLocation ColonColonLoc)
One of these records is kept for each identifier that is lexed.
void setConstructorTemplateId(TemplateIdAnnotation *TemplateId)
Specify that this unqualified-id was parsed as a template-id that names a constructor.
Definition: DeclSpec.cpp:39
bool isUnset() const
Definition: Ownership.h:161
sema::LambdaScopeInfo * getCurGenericLambda()
Retrieve the current generic lambda info, if any.
Definition: Sema.cpp:1323
ExprResult ExprEmpty()
Definition: Ownership.h:274
void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &attrs, SourceLocation EndLoc)
AddTypeInfo - Add a chunk to this declarator.
Definition: DeclSpec.h:2135
void setConversionFunctionId(SourceLocation OperatorLoc, ParsedType Ty, SourceLocation EndLoc)
Specify that this unqualified-id was parsed as a conversion-function-id.
Definition: DeclSpec.h:1035
LambdaCaptureKind
The different capture forms in a lambda introducer.
Definition: Lambda.h:34
The current expression is potentially evaluated at run time, which means that code may be generated t...
bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS)
OverloadedOperatorKind Operator
The kind of overloaded operator.
Definition: DeclSpec.h:931
static const TST TST_double
Definition: DeclSpec.h:282
struct OFI OperatorFunctionId
When Kind == IK_OperatorFunctionId, the overloaded operator that we parsed.
Definition: DeclSpec.h:952
ExprResult ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)
ActOnCXXUuidof - Parse __uuidof( something ).
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
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.
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 { ...
ParsedType getDestructorName(SourceLocation TildeLoc, IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, ParsedType ObjectType, bool EnteringContext)
Definition: SemaExprCXX.cpp:82
void SetSourceRange(SourceRange R)
Definition: DeclSpec.h:1888
void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro, bool AfterAmpersand)
UnionParsedType DestructorName
When Kind == IK_DestructorName, the type referred to by the class-name.
Definition: DeclSpec.h:964
This is a scope that corresponds to a block/closure object.
Definition: Scope.h:70
ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr)
ActOnCXXThrow - Parse throw expressions.
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:899
static ParsedType getTypeAnnotation(const Token &Tok)
getTypeAnnotation - Read a parsed type out of an annotation token.
Definition: Parser.h:607
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
< Capturing the *this object by copy
Definition: Lambda.h:37
void ActOnInitializerError(Decl *Dcl)
ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...
Definition: SemaDecl.cpp:10652
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
If a crash happens while one of these objects are live, the message is printed out along with the spe...
void SetInvalid(SourceRange R)
Indicate that this nested-name-specifier is invalid.
Definition: DeclSpec.h:199
ExprResult ActOnCXXThis(SourceLocation loc)
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:2701
ArrayTypeTrait
Names for the array type traits.
Definition: TypeTraits.h:89
tok::TokenKind getKind() const
Definition: Token.h:90
void setTemplateId(TemplateIdAnnotation *TemplateId)
Specify that this unqualified-id was parsed as a template-id.
Definition: DeclSpec.cpp:31
LambdaCaptureInitKind
Definition: DeclSpec.h:2477
static SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, unsigned Character, const SourceManager &SM, const LangOptions &LangOpts)
AdvanceToTokenCharacter - If the current SourceLocation specifies a location at the start of a token...
Definition: Lexer.cpp:701
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:503
QualType getCanonicalTypeInternal() const
Definition: Type.h:2045
bool isInvalid() const
bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS, NestedNameSpecInfo &IdInfo)
SourceRange getRange() const
Definition: DeclSpec.h:68
SourceLocation TemplateKWLoc
TemplateKWLoc - The location of the template keyword.
static const TST TST_float
Definition: DeclSpec.h:281
TypeTrait
Names for traits that operate specifically on types.
Definition: TypeTraits.h:21
SourceLocation LAngleLoc
The location of the '<' before the template argument list.
void * getAnnotationValue() const
Definition: Token.h:224
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1856
static const TSW TSW_long
Definition: DeclSpec.h:255
StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, SourceLocation StartLoc, SourceLocation EndLoc)
Definition: SemaStmt.cpp:72
const void * getEofData() const
Definition: Token.h:190
void SetRangeStart(SourceLocation Loc)
Definition: DeclSpec.h:609
Disambiguated as the declaration form of condition.
TypeResult ParseTypeName(SourceRange *Range=nullptr, Declarator::TheContext Context=Declarator::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:45
SmallVector< LambdaCapture, 4 > Captures
Definition: DeclSpec.h:2506
SourceRange getAnnotationRange() const
SourceRange of the group of tokens that this annotation token represents.
Definition: Token.h:158
ExprResult ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body, Scope *CurScope)
ActOnLambdaExpr - This is called when the body of a lambda expression was successfully completed...
Expr - This represents one expression.
Definition: Expr.h:105
StringRef getName() const
Return the actual identifier string.
bool ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc, CXXScopeSpec &SS)
The parser has parsed a global nested-name-specifier '::'.
void setDeductionGuideName(ParsedTemplateTy Template, SourceLocation TemplateLoc)
Specify that this unqualified-id was parsed as a template-name for a deduction-guide.
Definition: DeclSpec.h:1111
void AnnotateCachedTokens(const Token &Tok)
We notify the Preprocessor that if it is caching tokens (because backtrack is enabled) it should repl...
ParsedType getDestructorTypeForDecltype(const DeclSpec &DS, ParsedType ObjectType)
This file defines the classes used to store parsed information about declaration-specifiers and decla...
TypeResult ActOnTypeName(Scope *S, Declarator &D)
Definition: SemaType.cpp:5456
void setEofData(const void *D)
Definition: Token.h:194
void RevertCachedTokens(unsigned N)
When backtracking is enabled and tokens are cached, this allows to revert a specific number of tokens...
ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, CXXScopeSpec &SS, UnqualifiedId &FirstTypeName, SourceLocation CCLoc, SourceLocation TildeLoc, UnqualifiedId &SecondTypeName)
OpaquePtr< TemplateName > TemplateTy
Definition: Parser.h:284
Represents a C++ template name within the type system.
Definition: TemplateName.h:176
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Definition: Token.h:124
TemplateNameKind
Specifies the kind of template name that an identifier refers to.
Definition: TemplateKinds.h:21
bool isNot(tok::TokenKind K) const
Definition: Token.h:96
ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc, ArrayRef< ParsedType > Args, SourceLocation RParenLoc)
Parsed one of the type trait support pseudo-functions.
void setLiteralOperatorId(const IdentifierInfo *Id, SourceLocation OpLoc, SourceLocation IdLoc)
Specific that this unqualified-id was parsed as a literal-operator-id.
Definition: DeclSpec.h:1052
static const TST TST_int
Definition: DeclSpec.h:278
ConditionKind
Definition: Sema.h:9641
TemplateNameKind ActOnDependentTemplateName(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool AllowInjectedClassName=false)
Form a dependent template name.
bool SetTypeSpecSign(TSS S, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:651
static const TST TST_half
Definition: DeclSpec.h:280
TemplateNameKind isTemplateName(Scope *S, CXXScopeSpec &SS, bool hasTemplateKeyword, UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Template, bool &MemberOfUnknownSpecialization)
ExprResult ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *Operand)
ActOnCXXDelete - Parsed a C++ 'delete' expression.
sema::LambdaScopeInfo * PushLambdaScope()
Definition: Sema.cpp:1233
The result type of a method or function.
SourceLocation getAnnotationEndLoc() const
Definition: Token.h:138
static const TSW TSW_short
Definition: DeclSpec.h:254
ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg, SourceLocation EllipsisLoc)
Invoked when parsing a template argument followed by an ellipsis, which creates a pack expansion...
const SourceManager & SM
Definition: Format.cpp:1293
OpaquePtr< DeclGroupRef > DeclGroupPtrTy
Definition: Parser.h:283
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:608
bool SetTypeSpecWidth(TSW W, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
These methods set the specified attribute of the DeclSpec, but return true and ignore the request if ...
Definition: DeclSpec.cpp:624
bool isValid() const
Determine whether this unqualified-id refers to a valid name.
Definition: DeclSpec.h:995
OpaquePtr< T > get() const
Definition: Ownership.h:98
This is a scope that corresponds to the parameters within a function prototype for a function declara...
Definition: Scope.h:86
ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)
Definition: SemaExpr.cpp:3480
static const TST TST_char32
Definition: DeclSpec.h:277
bool isInvalid() const
Determine whether this unqualified-id refers to an invalid name.
Definition: DeclSpec.h:998
SourceLocation DefaultLoc
Definition: DeclSpec.h:2504
Kind
Stop skipping at semicolon.
Definition: Parser.h:914
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:145
SmallVectorImpl< AnnotatedLine * >::const_iterator Next
Encodes a location in the source.
void addCapture(LambdaCaptureKind Kind, SourceLocation Loc, IdentifierInfo *Id, SourceLocation EllipsisLoc, LambdaCaptureInitKind InitKind, ExprResult Init, ParsedType InitCaptureType)
Append a capture in a lambda introducer.
Definition: DeclSpec.h:2512
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
void setLength(unsigned Len)
Definition: Token.h:133
static void addConstexprToLambdaDeclSpecifier(Parser &P, SourceLocation ConstexprLoc, DeclSpec &DS)
An overloaded operator name, e.g., operator+.
Definition: DeclSpec.h:910
void FinalizeDeclaration(Decl *D)
FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...
Definition: SemaDecl.cpp:11249
bool isValid() const
Return true if this is a valid SourceLocation object.
bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name, SourceLocation NameLoc, ParsedTemplateTy *Template=nullptr)
Determine whether a particular identifier might be the name in a C++1z deduction-guide declaration...
ASTContext & getASTContext() const
Definition: Sema.h:1173
static DeclaratorChunk getFunction(bool HasProto, bool IsAmbiguous, SourceLocation LParenLoc, ParamInfo *Params, unsigned NumParams, SourceLocation EllipsisLoc, SourceLocation RParenLoc, unsigned TypeQuals, bool RefQualifierIsLvalueRef, SourceLocation RefQualifierLoc, SourceLocation ConstQualifierLoc, SourceLocation VolatileQualifierLoc, SourceLocation RestrictQualifierLoc, SourceLocation MutableLoc, ExceptionSpecificationType ESpecType, SourceRange ESpecRange, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, ArrayRef< NamedDecl * > DeclsInPrototype, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult())
DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function.
Definition: DeclSpec.cpp:152
void setAnnotationEndLoc(SourceLocation L)
Definition: Token.h:142
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:733
Scope * getCurScope() const
Definition: Parser.h:274
static const TSS TSS_signed
Definition: DeclSpec.h:267
ExprResult ActOnCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, SourceLocation LAngleBracketLoc, Declarator &D, SourceLocation RAngleBracketLoc, SourceLocation LParenLoc, Expr *E, SourceLocation RParenLoc)
ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
Definition: SemaCast.cpp:217
void CodeCompleteOperatorName(Scope *S)
void Lex(Token &Result)
Lex the next token for this preprocessor.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
SourceLocation getBegin() const
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:72
PtrTy get() const
Definition: Ownership.h:74
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
static DeclaratorChunk getArray(unsigned TypeQuals, bool isStatic, bool isStar, Expr *NumElts, SourceLocation LBLoc, SourceLocation RBLoc)
Return a DeclaratorChunk for an array.
Definition: DeclSpec.h:1565
ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, Declarator &D, Expr *Initializer)
ActOnCXXNew - Parsed a C++ 'new' expression.
MutableArrayRef< Expr * > MultiExprArg
Definition: Ownership.h:262
static void FixDigraph(Parser &P, Preprocessor &PP, Token &DigraphToken, Token &ColonToken, tok::TokenKind Kind, bool AtDigraph)
SourceLocation getOpenLocation() const
static const TST TST_decltype_auto
Definition: DeclSpec.h:297
The name does not refer to a template.
Definition: TemplateKinds.h:23
void ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope, bool IsInstantiation=false)
ActOnLambdaError - If there is an error parsing a lambda, this callback is invoked to pop the informa...
LambdaCaptureDefault Default
Definition: DeclSpec.h:2505
StringRef Name
Definition: USRFinder.cpp:123
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
static const TST TST_void
Definition: DeclSpec.h:273
CXXScopeSpec SS
The nested-name-specifier that precedes the template name.
SourceLocation RAngleLoc
The location of the '>' after the template argument list.
static const TST TST_int128
Definition: DeclSpec.h:279
void RecordParsingTemplateParameterDepth(unsigned Depth)
This is used to inform Sema what the current TemplateParameterDepth is during Parsing.
Definition: Sema.cpp:1239
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:116
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclSpec.h:505
bool ActOnSuperScopeSpecifier(SourceLocation SuperLoc, SourceLocation ColonColonLoc, CXXScopeSpec &SS)
The parser has parsed a '__super' nested-name-specifier.
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
Definition: SemaDecl.cpp:10239
bool isCurrentClassName(const IdentifierInfo &II, Scope *S, const CXXScopeSpec *SS=nullptr)
isCurrentClassName - Determine whether the identifier II is the name of the class type currently bein...
Not an overloaded operator.
Definition: OperatorKinds.h:23
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition: DeclSpec.h:191
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition: Token.h:97
void ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro, Declarator &ParamInfo, Scope *CurScope)
ActOnStartOfLambdaDefinition - This is called just before we start parsing the body of a lambda; it a...
Definition: SemaLambda.cpp:811
void takeAttributesFrom(ParsedAttributes &attrs)
Definition: DeclSpec.h:754
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Definition: Parser.cpp:72
static void tryConsumeMutableOrConstexprToken(Parser &P, SourceLocation &MutableLoc, SourceLocation &ConstexprLoc, SourceLocation &DeclEndLoc)
void RestoreNestedNameSpecifierAnnotation(void *Annotation, SourceRange AnnotationRange, CXXScopeSpec &SS)
Given an annotation pointer for a nested-name-specifier, restore the nested-name-specifier structure...
const char * getOperatorSpelling(OverloadedOperatorKind Operator)
Retrieve the spelling of the given overloaded operator, without the preceding "operator" keyword...
ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnCXXBoolLiteral - Parse {true,false} literals.
ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep, SourceLocation LParenLoc, MultiExprArg Exprs, SourceLocation RParenLoc)
ActOnCXXTypeConstructExpr - Parse construction of a specified type.
void setOperatorFunctionId(SourceLocation OperatorLoc, OverloadedOperatorKind Op, SourceLocation SymbolLocations[3])
Specify that this unqualified-id was parsed as an operator-function-id.
Definition: DeclSpec.cpp:1291
static const TST TST_typename
Definition: DeclSpec.h:293
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:253
ExprResult ParseAssignmentExpression(TypeCastState isTypeCast=NotTypeCast)
Parse an expr that doesn't include (top-level) commas.
Definition: ParseExpr.cpp:156
ExprResult ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)
ActOnCXXTypeid - Parse typeid( something ).
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:90
ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E)
Capturing the *this object by reference.
Definition: Lambda.h:35
const Expr * Replacement
Definition: AttributeList.h:59
bool isUsable() const
Definition: Ownership.h:160
This is a scope that can contain a declaration.
Definition: Scope.h:58
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:740
ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, std::unique_ptr< CorrectionCandidateCallback > CCC=nullptr, bool IsInlineAsmIdentifier=false, Token *KeywordReplacement=nullptr)
Definition: SemaExpr.cpp:2019
ExprResult ParseConstantExpression(TypeCastState isTypeCast=NotTypeCast)
Definition: ParseExpr.cpp:206
An integral condition for a 'switch' statement.
TypeResult ActOnTemplateIdType(CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy Template, IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc, bool IsCtorOrDtorName=false, bool IsClassName=false)
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
void setEnd(SourceLocation e)
SourceLocation ConsumeToken()
ConsumeToken - Consume the current 'peek token' and lex the next one.
Definition: Parser.h:312
static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind)
A user-defined literal name, e.g., operator "" _i.
Definition: DeclSpec.h:914
static int SelectDigraphErrorMessage(tok::TokenKind Kind)
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult{return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
Capturing by reference.
Definition: Lambda.h:38
static const TST TST_float128
Definition: DeclSpec.h:283
static const TST TST_bool
Definition: DeclSpec.h:284
StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:44
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:127
void Finish(Sema &S, const PrintingPolicy &Policy)
Finish - This does final analysis of the declspec, issuing diagnostics for things like "_Imaginary" (...
Definition: DeclSpec.cpp:1002
Represents a complete lambda introducer.
Definition: DeclSpec.h:2485
ExprResult ExprError()
Definition: Ownership.h:268
static const TSW TSW_longlong
Definition: DeclSpec.h:256
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
Code completion occurs within the condition of an if, while, switch, or for statement.
Definition: Sema.h:10030
unsigned getLength() const
Definition: Token.h:127
static unsigned TypeTraitArity(tok::TokenKind kind)
void setLocation(SourceLocation L)
Definition: Token.h:132
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:407
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Specify that this unqualified-id was parsed as an identifier.
Definition: DeclSpec.h:1008
bool isInvalidType() const
Definition: DeclSpec.h:2381
bool SetTypeSpecError()
Definition: DeclSpec.cpp:821
unsigned NumArgs
NumArgs - The number of template arguments.
void setDestructorName(SourceLocation TildeLoc, ParsedType ClassType, SourceLocation EndLoc)
Specify that this unqualified-id was parsed as a destructor name.
Definition: DeclSpec.h:1090
void SetRangeEnd(SourceLocation Loc)
Definition: DeclSpec.h:610
ParsedAttributes - A collection of parsed attributes.
This class handles loading and caching of source files into memory.
static ArrayTypeTrait ArrayTypeTraitFromTokKind(tok::TokenKind kind)
Attr - This represents one attribute.
Definition: Attr.h:43
void startToken()
Reset all flags to cleared.
Definition: Token.h:169
ParsedType actOnLambdaInitCaptureInitialization(SourceLocation Loc, bool ByRef, IdentifierInfo *Id, LambdaCaptureInitKind InitKind, Expr *&Init)
Perform initialization analysis of the init-capture and perform any implicit conversions such as an l...
Definition: Sema.h:5428
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1849
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:98
Stop skipping at specified token, but don't skip the token itself.
Definition: Parser.h:916
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:177