clang  6.0.0svn
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.
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  // 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 
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;
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;
550  UnqualifiedId Name;
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.isInvalid())
970  Init = Actions.CorrectDelayedTyposInExpr(Init.get());
971  if (Init.isUsable()) {
972  // Get the pointer and store it in an lvalue, so we can use it as an
973  // out argument.
974  Expr *InitExpr = Init.get();
975  // This performs any lvalue-to-rvalue conversions if necessary, which
976  // can affect what gets captured in the containing decl-context.
977  InitCaptureType = Actions.actOnLambdaInitCaptureInitialization(
978  Loc, Kind == LCK_ByRef, Id, InitKind, InitExpr);
979  Init = InitExpr;
980  }
981  Intro.addCapture(Kind, Loc, Id, EllipsisLoc, InitKind, Init,
982  InitCaptureType);
983  }
984 
985  T.consumeClose();
986  Intro.Range.setEnd(T.getCloseLocation());
987  return DiagResult();
988 }
989 
990 /// TryParseLambdaIntroducer - Tentatively parse a lambda introducer.
991 ///
992 /// Returns true if it hit something unexpected.
993 bool Parser::TryParseLambdaIntroducer(LambdaIntroducer &Intro) {
994  {
995  bool SkippedInits = false;
996  TentativeParsingAction PA1(*this);
997 
998  if (ParseLambdaIntroducer(Intro, &SkippedInits)) {
999  PA1.Revert();
1000  return true;
1001  }
1002 
1003  if (!SkippedInits) {
1004  PA1.Commit();
1005  return false;
1006  }
1007 
1008  PA1.Revert();
1009  }
1010 
1011  // Try to parse it again, but this time parse the init-captures too.
1012  Intro = LambdaIntroducer();
1013  TentativeParsingAction PA2(*this);
1014 
1015  if (!ParseLambdaIntroducer(Intro)) {
1016  PA2.Commit();
1017  return false;
1018  }
1019 
1020  PA2.Revert();
1021  return true;
1022 }
1023 
1024 static void
1026  SourceLocation &ConstexprLoc,
1027  SourceLocation &DeclEndLoc) {
1028  assert(MutableLoc.isInvalid());
1029  assert(ConstexprLoc.isInvalid());
1030  // Consume constexpr-opt mutable-opt in any sequence, and set the DeclEndLoc
1031  // to the final of those locations. Emit an error if we have multiple
1032  // copies of those keywords and recover.
1033 
1034  while (true) {
1035  switch (P.getCurToken().getKind()) {
1036  case tok::kw_mutable: {
1037  if (MutableLoc.isValid()) {
1038  P.Diag(P.getCurToken().getLocation(),
1039  diag::err_lambda_decl_specifier_repeated)
1041  }
1042  MutableLoc = P.ConsumeToken();
1043  DeclEndLoc = MutableLoc;
1044  break /*switch*/;
1045  }
1046  case tok::kw_constexpr:
1047  if (ConstexprLoc.isValid()) {
1048  P.Diag(P.getCurToken().getLocation(),
1049  diag::err_lambda_decl_specifier_repeated)
1051  }
1052  ConstexprLoc = P.ConsumeToken();
1053  DeclEndLoc = ConstexprLoc;
1054  break /*switch*/;
1055  default:
1056  return;
1057  }
1058  }
1059 }
1060 
1061 static void
1063  DeclSpec &DS) {
1064  if (ConstexprLoc.isValid()) {
1065  P.Diag(ConstexprLoc, !P.getLangOpts().CPlusPlus17
1066  ? diag::ext_constexpr_on_lambda_cxx17
1067  : diag::warn_cxx14_compat_constexpr_on_lambda);
1068  const char *PrevSpec = nullptr;
1069  unsigned DiagID = 0;
1070  DS.SetConstexprSpec(ConstexprLoc, PrevSpec, DiagID);
1071  assert(PrevSpec == nullptr && DiagID == 0 &&
1072  "Constexpr cannot have been set previously!");
1073  }
1074 }
1075 
1076 /// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
1077 /// expression.
1078 ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
1079  LambdaIntroducer &Intro) {
1080  SourceLocation LambdaBeginLoc = Intro.Range.getBegin();
1081  Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);
1082 
1083  PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc,
1084  "lambda expression parsing");
1085 
1086 
1087 
1088  // FIXME: Call into Actions to add any init-capture declarations to the
1089  // scope while parsing the lambda-declarator and compound-statement.
1090 
1091  // Parse lambda-declarator[opt].
1092  DeclSpec DS(AttrFactory);
1094  TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
1095  Actions.PushLambdaScope();
1096 
1097  ParsedAttributes Attr(AttrFactory);
1098  SourceLocation DeclLoc = Tok.getLocation();
1099  if (getLangOpts().CUDA) {
1100  // In CUDA code, GNU attributes are allowed to appear immediately after the
1101  // "[...]", even if there is no "(...)" before the lambda body.
1102  MaybeParseGNUAttributes(D);
1103  }
1104 
1105  // Helper to emit a warning if we see a CUDA host/device/global attribute
1106  // after '(...)'. nvcc doesn't accept this.
1107  auto WarnIfHasCUDATargetAttr = [&] {
1108  if (getLangOpts().CUDA)
1109  for (auto *A = Attr.getList(); A != nullptr; A = A->getNext())
1110  if (A->getKind() == AttributeList::AT_CUDADevice ||
1111  A->getKind() == AttributeList::AT_CUDAHost ||
1112  A->getKind() == AttributeList::AT_CUDAGlobal)
1113  Diag(A->getLoc(), diag::warn_cuda_attr_lambda_position)
1114  << A->getName()->getName();
1115  };
1116 
1117  TypeResult TrailingReturnType;
1118  if (Tok.is(tok::l_paren)) {
1119  ParseScope PrototypeScope(this,
1123 
1124  BalancedDelimiterTracker T(*this, tok::l_paren);
1125  T.consumeOpen();
1126  SourceLocation LParenLoc = T.getOpenLocation();
1127 
1128  // Parse parameter-declaration-clause.
1130  SourceLocation EllipsisLoc;
1131 
1132  if (Tok.isNot(tok::r_paren)) {
1133  Actions.RecordParsingTemplateParameterDepth(TemplateParameterDepth);
1134  ParseParameterDeclarationClause(D, Attr, ParamInfo, EllipsisLoc);
1135  // For a generic lambda, each 'auto' within the parameter declaration
1136  // clause creates a template type parameter, so increment the depth.
1137  if (Actions.getCurGenericLambda())
1138  ++CurTemplateDepthTracker;
1139  }
1140  T.consumeClose();
1141  SourceLocation RParenLoc = T.getCloseLocation();
1142  SourceLocation DeclEndLoc = RParenLoc;
1143 
1144  // GNU-style attributes must be parsed before the mutable specifier to be
1145  // compatible with GCC.
1146  MaybeParseGNUAttributes(Attr, &DeclEndLoc);
1147 
1148  // MSVC-style attributes must be parsed before the mutable specifier to be
1149  // compatible with MSVC.
1150  MaybeParseMicrosoftDeclSpecs(Attr, &DeclEndLoc);
1151 
1152  // Parse mutable-opt and/or constexpr-opt, and update the DeclEndLoc.
1153  SourceLocation MutableLoc;
1154  SourceLocation ConstexprLoc;
1155  tryConsumeMutableOrConstexprToken(*this, MutableLoc, ConstexprLoc,
1156  DeclEndLoc);
1157 
1158  addConstexprToLambdaDeclSpecifier(*this, ConstexprLoc, DS);
1159 
1160  // Parse exception-specification[opt].
1162  SourceRange ESpecRange;
1163  SmallVector<ParsedType, 2> DynamicExceptions;
1164  SmallVector<SourceRange, 2> DynamicExceptionRanges;
1165  ExprResult NoexceptExpr;
1166  CachedTokens *ExceptionSpecTokens;
1167  ESpecType = tryParseExceptionSpecification(/*Delayed=*/false,
1168  ESpecRange,
1169  DynamicExceptions,
1170  DynamicExceptionRanges,
1171  NoexceptExpr,
1172  ExceptionSpecTokens);
1173 
1174  if (ESpecType != EST_None)
1175  DeclEndLoc = ESpecRange.getEnd();
1176 
1177  // Parse attribute-specifier[opt].
1178  MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
1179 
1180  SourceLocation FunLocalRangeEnd = DeclEndLoc;
1181 
1182  // Parse trailing-return-type[opt].
1183  if (Tok.is(tok::arrow)) {
1184  FunLocalRangeEnd = Tok.getLocation();
1185  SourceRange Range;
1186  TrailingReturnType = ParseTrailingReturnType(Range);
1187  if (Range.getEnd().isValid())
1188  DeclEndLoc = Range.getEnd();
1189  }
1190 
1191  PrototypeScope.Exit();
1192 
1193  WarnIfHasCUDATargetAttr();
1194 
1195  SourceLocation NoLoc;
1196  D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
1197  /*isAmbiguous=*/false,
1198  LParenLoc,
1199  ParamInfo.data(), ParamInfo.size(),
1200  EllipsisLoc, RParenLoc,
1201  DS.getTypeQualifiers(),
1202  /*RefQualifierIsLValueRef=*/true,
1203  /*RefQualifierLoc=*/NoLoc,
1204  /*ConstQualifierLoc=*/NoLoc,
1205  /*VolatileQualifierLoc=*/NoLoc,
1206  /*RestrictQualifierLoc=*/NoLoc,
1207  MutableLoc,
1208  ESpecType, ESpecRange,
1209  DynamicExceptions.data(),
1210  DynamicExceptionRanges.data(),
1211  DynamicExceptions.size(),
1212  NoexceptExpr.isUsable() ?
1213  NoexceptExpr.get() : nullptr,
1214  /*ExceptionSpecTokens*/nullptr,
1215  /*DeclsInPrototype=*/None,
1216  LParenLoc, FunLocalRangeEnd, D,
1217  TrailingReturnType),
1218  Attr, DeclEndLoc);
1219  } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
1220  tok::kw_constexpr) ||
1221  (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) {
1222  // It's common to forget that one needs '()' before 'mutable', an attribute
1223  // specifier, or the result type. Deal with this.
1224  unsigned TokKind = 0;
1225  switch (Tok.getKind()) {
1226  case tok::kw_mutable: TokKind = 0; break;
1227  case tok::arrow: TokKind = 1; break;
1228  case tok::kw___attribute:
1229  case tok::l_square: TokKind = 2; break;
1230  case tok::kw_constexpr: TokKind = 3; break;
1231  default: llvm_unreachable("Unknown token kind");
1232  }
1233 
1234  Diag(Tok, diag::err_lambda_missing_parens)
1235  << TokKind
1236  << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
1237  SourceLocation DeclEndLoc = DeclLoc;
1238 
1239  // GNU-style attributes must be parsed before the mutable specifier to be
1240  // compatible with GCC.
1241  MaybeParseGNUAttributes(Attr, &DeclEndLoc);
1242 
1243  // Parse 'mutable', if it's there.
1244  SourceLocation MutableLoc;
1245  if (Tok.is(tok::kw_mutable)) {
1246  MutableLoc = ConsumeToken();
1247  DeclEndLoc = MutableLoc;
1248  }
1249 
1250  // Parse attribute-specifier[opt].
1251  MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
1252 
1253  // Parse the return type, if there is one.
1254  if (Tok.is(tok::arrow)) {
1255  SourceRange Range;
1256  TrailingReturnType = ParseTrailingReturnType(Range);
1257  if (Range.getEnd().isValid())
1258  DeclEndLoc = Range.getEnd();
1259  }
1260 
1261  WarnIfHasCUDATargetAttr();
1262 
1263  SourceLocation NoLoc;
1264  D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
1265  /*isAmbiguous=*/false,
1266  /*LParenLoc=*/NoLoc,
1267  /*Params=*/nullptr,
1268  /*NumParams=*/0,
1269  /*EllipsisLoc=*/NoLoc,
1270  /*RParenLoc=*/NoLoc,
1271  /*TypeQuals=*/0,
1272  /*RefQualifierIsLValueRef=*/true,
1273  /*RefQualifierLoc=*/NoLoc,
1274  /*ConstQualifierLoc=*/NoLoc,
1275  /*VolatileQualifierLoc=*/NoLoc,
1276  /*RestrictQualifierLoc=*/NoLoc,
1277  MutableLoc,
1278  EST_None,
1279  /*ESpecRange=*/SourceRange(),
1280  /*Exceptions=*/nullptr,
1281  /*ExceptionRanges=*/nullptr,
1282  /*NumExceptions=*/0,
1283  /*NoexceptExpr=*/nullptr,
1284  /*ExceptionSpecTokens=*/nullptr,
1285  /*DeclsInPrototype=*/None,
1286  DeclLoc, DeclEndLoc, D,
1287  TrailingReturnType),
1288  Attr, DeclEndLoc);
1289  }
1290 
1291  // FIXME: Rename BlockScope -> ClosureScope if we decide to continue using
1292  // it.
1293  unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope |
1295  ParseScope BodyScope(this, ScopeFlags);
1296 
1297  Actions.ActOnStartOfLambdaDefinition(Intro, D, getCurScope());
1298 
1299  // Parse compound-statement.
1300  if (!Tok.is(tok::l_brace)) {
1301  Diag(Tok, diag::err_expected_lambda_body);
1302  Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1303  return ExprError();
1304  }
1305 
1306  StmtResult Stmt(ParseCompoundStatementBody());
1307  BodyScope.Exit();
1308 
1309  if (!Stmt.isInvalid() && !TrailingReturnType.isInvalid())
1310  return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.get(), getCurScope());
1311 
1312  Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1313  return ExprError();
1314 }
1315 
1316 /// ParseCXXCasts - This handles the various ways to cast expressions to another
1317 /// type.
1318 ///
1319 /// postfix-expression: [C++ 5.2p1]
1320 /// 'dynamic_cast' '<' type-name '>' '(' expression ')'
1321 /// 'static_cast' '<' type-name '>' '(' expression ')'
1322 /// 'reinterpret_cast' '<' type-name '>' '(' expression ')'
1323 /// 'const_cast' '<' type-name '>' '(' expression ')'
1324 ///
1325 ExprResult Parser::ParseCXXCasts() {
1326  tok::TokenKind Kind = Tok.getKind();
1327  const char *CastName = nullptr; // For error messages
1328 
1329  switch (Kind) {
1330  default: llvm_unreachable("Unknown C++ cast!");
1331  case tok::kw_const_cast: CastName = "const_cast"; break;
1332  case tok::kw_dynamic_cast: CastName = "dynamic_cast"; break;
1333  case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break;
1334  case tok::kw_static_cast: CastName = "static_cast"; break;
1335  }
1336 
1337  SourceLocation OpLoc = ConsumeToken();
1338  SourceLocation LAngleBracketLoc = Tok.getLocation();
1339 
1340  // Check for "<::" which is parsed as "[:". If found, fix token stream,
1341  // diagnose error, suggest fix, and recover parsing.
1342  if (Tok.is(tok::l_square) && Tok.getLength() == 2) {
1343  Token Next = NextToken();
1344  if (Next.is(tok::colon) && areTokensAdjacent(Tok, Next))
1345  FixDigraph(*this, PP, Tok, Next, Kind, /*AtDigraph*/true);
1346  }
1347 
1348  if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
1349  return ExprError();
1350 
1351  // Parse the common declaration-specifiers piece.
1352  DeclSpec DS(AttrFactory);
1353  ParseSpecifierQualifierList(DS);
1354 
1355  // Parse the abstract-declarator, if present.
1356  Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
1357  ParseDeclarator(DeclaratorInfo);
1358 
1359  SourceLocation RAngleBracketLoc = Tok.getLocation();
1360 
1361  if (ExpectAndConsume(tok::greater))
1362  return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << tok::less);
1363 
1364  BalancedDelimiterTracker T(*this, tok::l_paren);
1365 
1366  if (T.expectAndConsume(diag::err_expected_lparen_after, CastName))
1367  return ExprError();
1368 
1370 
1371  // Match the ')'.
1372  T.consumeClose();
1373 
1374  if (!Result.isInvalid() && !DeclaratorInfo.isInvalidType())
1375  Result = Actions.ActOnCXXNamedCast(OpLoc, Kind,
1376  LAngleBracketLoc, DeclaratorInfo,
1377  RAngleBracketLoc,
1378  T.getOpenLocation(), Result.get(),
1379  T.getCloseLocation());
1380 
1381  return Result;
1382 }
1383 
1384 /// ParseCXXTypeid - This handles the C++ typeid expression.
1385 ///
1386 /// postfix-expression: [C++ 5.2p1]
1387 /// 'typeid' '(' expression ')'
1388 /// 'typeid' '(' type-id ')'
1389 ///
1390 ExprResult Parser::ParseCXXTypeid() {
1391  assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!");
1392 
1393  SourceLocation OpLoc = ConsumeToken();
1394  SourceLocation LParenLoc, RParenLoc;
1395  BalancedDelimiterTracker T(*this, tok::l_paren);
1396 
1397  // typeid expressions are always parenthesized.
1398  if (T.expectAndConsume(diag::err_expected_lparen_after, "typeid"))
1399  return ExprError();
1400  LParenLoc = T.getOpenLocation();
1401 
1403 
1404  // C++0x [expr.typeid]p3:
1405  // When typeid is applied to an expression other than an lvalue of a
1406  // polymorphic class type [...] The expression is an unevaluated
1407  // operand (Clause 5).
1408  //
1409  // Note that we can't tell whether the expression is an lvalue of a
1410  // polymorphic class type until after we've parsed the expression; we
1411  // speculatively assume the subexpression is unevaluated, and fix it up
1412  // later.
1413  //
1414  // We enter the unevaluated context before trying to determine whether we
1415  // have a type-id, because the tentative parse logic will try to resolve
1416  // names, and must treat them as unevaluated.
1420 
1421  if (isTypeIdInParens()) {
1422  TypeResult Ty = ParseTypeName();
1423 
1424  // Match the ')'.
1425  T.consumeClose();
1426  RParenLoc = T.getCloseLocation();
1427  if (Ty.isInvalid() || RParenLoc.isInvalid())
1428  return ExprError();
1429 
1430  Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true,
1431  Ty.get().getAsOpaquePtr(), RParenLoc);
1432  } else {
1433  Result = ParseExpression();
1434 
1435  // Match the ')'.
1436  if (Result.isInvalid())
1437  SkipUntil(tok::r_paren, StopAtSemi);
1438  else {
1439  T.consumeClose();
1440  RParenLoc = T.getCloseLocation();
1441  if (RParenLoc.isInvalid())
1442  return ExprError();
1443 
1444  Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false,
1445  Result.get(), RParenLoc);
1446  }
1447  }
1448 
1449  return Result;
1450 }
1451 
1452 /// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
1453 ///
1454 /// '__uuidof' '(' expression ')'
1455 /// '__uuidof' '(' type-id ')'
1456 ///
1457 ExprResult Parser::ParseCXXUuidof() {
1458  assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!");
1459 
1460  SourceLocation OpLoc = ConsumeToken();
1461  BalancedDelimiterTracker T(*this, tok::l_paren);
1462 
1463  // __uuidof expressions are always parenthesized.
1464  if (T.expectAndConsume(diag::err_expected_lparen_after, "__uuidof"))
1465  return ExprError();
1466 
1468 
1469  if (isTypeIdInParens()) {
1470  TypeResult Ty = ParseTypeName();
1471 
1472  // Match the ')'.
1473  T.consumeClose();
1474 
1475  if (Ty.isInvalid())
1476  return ExprError();
1477 
1478  Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), /*isType=*/true,
1479  Ty.get().getAsOpaquePtr(),
1480  T.getCloseLocation());
1481  } else {
1484  Result = ParseExpression();
1485 
1486  // Match the ')'.
1487  if (Result.isInvalid())
1488  SkipUntil(tok::r_paren, StopAtSemi);
1489  else {
1490  T.consumeClose();
1491 
1492  Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(),
1493  /*isType=*/false,
1494  Result.get(), T.getCloseLocation());
1495  }
1496  }
1497 
1498  return Result;
1499 }
1500 
1501 /// \brief Parse a C++ pseudo-destructor expression after the base,
1502 /// . or -> operator, and nested-name-specifier have already been
1503 /// parsed.
1504 ///
1505 /// postfix-expression: [C++ 5.2]
1506 /// postfix-expression . pseudo-destructor-name
1507 /// postfix-expression -> pseudo-destructor-name
1508 ///
1509 /// pseudo-destructor-name:
1510 /// ::[opt] nested-name-specifier[opt] type-name :: ~type-name
1511 /// ::[opt] nested-name-specifier template simple-template-id ::
1512 /// ~type-name
1513 /// ::[opt] nested-name-specifier[opt] ~type-name
1514 ///
1515 ExprResult
1516 Parser::ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc,
1517  tok::TokenKind OpKind,
1518  CXXScopeSpec &SS,
1519  ParsedType ObjectType) {
1520  // We're parsing either a pseudo-destructor-name or a dependent
1521  // member access that has the same form as a
1522  // pseudo-destructor-name. We parse both in the same way and let
1523  // the action model sort them out.
1524  //
1525  // Note that the ::[opt] nested-name-specifier[opt] has already
1526  // been parsed, and if there was a simple-template-id, it has
1527  // been coalesced into a template-id annotation token.
1528  UnqualifiedId FirstTypeName;
1529  SourceLocation CCLoc;
1530  if (Tok.is(tok::identifier)) {
1531  FirstTypeName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1532  ConsumeToken();
1533  assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1534  CCLoc = ConsumeToken();
1535  } else if (Tok.is(tok::annot_template_id)) {
1536  // FIXME: retrieve TemplateKWLoc from template-id annotation and
1537  // store it in the pseudo-dtor node (to be used when instantiating it).
1538  FirstTypeName.setTemplateId(
1540  ConsumeAnnotationToken();
1541  assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1542  CCLoc = ConsumeToken();
1543  } else {
1544  FirstTypeName.setIdentifier(nullptr, SourceLocation());
1545  }
1546 
1547  // Parse the tilde.
1548  assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail");
1549  SourceLocation TildeLoc = ConsumeToken();
1550 
1551  if (Tok.is(tok::kw_decltype) && !FirstTypeName.isValid() && SS.isEmpty()) {
1552  DeclSpec DS(AttrFactory);
1553  ParseDecltypeSpecifier(DS);
1554  if (DS.getTypeSpecType() == TST_error)
1555  return ExprError();
1556  return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1557  TildeLoc, DS);
1558  }
1559 
1560  if (!Tok.is(tok::identifier)) {
1561  Diag(Tok, diag::err_destructor_tilde_identifier);
1562  return ExprError();
1563  }
1564 
1565  // Parse the second type.
1566  UnqualifiedId SecondTypeName;
1567  IdentifierInfo *Name = Tok.getIdentifierInfo();
1568  SourceLocation NameLoc = ConsumeToken();
1569  SecondTypeName.setIdentifier(Name, NameLoc);
1570 
1571  // If there is a '<', the second type name is a template-id. Parse
1572  // it as such.
1573  if (Tok.is(tok::less) &&
1574  ParseUnqualifiedIdTemplateId(SS, SourceLocation(),
1575  Name, NameLoc,
1576  false, ObjectType, SecondTypeName,
1577  /*AssumeTemplateName=*/true))
1578  return ExprError();
1579 
1580  return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1581  SS, FirstTypeName, CCLoc, TildeLoc,
1582  SecondTypeName);
1583 }
1584 
1585 /// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
1586 ///
1587 /// boolean-literal: [C++ 2.13.5]
1588 /// 'true'
1589 /// 'false'
1590 ExprResult Parser::ParseCXXBoolLiteral() {
1591  tok::TokenKind Kind = Tok.getKind();
1592  return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
1593 }
1594 
1595 /// ParseThrowExpression - This handles the C++ throw expression.
1596 ///
1597 /// throw-expression: [C++ 15]
1598 /// 'throw' assignment-expression[opt]
1599 ExprResult Parser::ParseThrowExpression() {
1600  assert(Tok.is(tok::kw_throw) && "Not throw!");
1601  SourceLocation ThrowLoc = ConsumeToken(); // Eat the throw token.
1602 
1603  // If the current token isn't the start of an assignment-expression,
1604  // then the expression is not present. This handles things like:
1605  // "C ? throw : (void)42", which is crazy but legal.
1606  switch (Tok.getKind()) { // FIXME: move this predicate somewhere common.
1607  case tok::semi:
1608  case tok::r_paren:
1609  case tok::r_square:
1610  case tok::r_brace:
1611  case tok::colon:
1612  case tok::comma:
1613  return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, nullptr);
1614 
1615  default:
1617  if (Expr.isInvalid()) return Expr;
1618  return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.get());
1619  }
1620 }
1621 
1622 /// \brief Parse the C++ Coroutines co_yield expression.
1623 ///
1624 /// co_yield-expression:
1625 /// 'co_yield' assignment-expression[opt]
1626 ExprResult Parser::ParseCoyieldExpression() {
1627  assert(Tok.is(tok::kw_co_yield) && "Not co_yield!");
1628 
1629  SourceLocation Loc = ConsumeToken();
1630  ExprResult Expr = Tok.is(tok::l_brace) ? ParseBraceInitializer()
1632  if (!Expr.isInvalid())
1633  Expr = Actions.ActOnCoyieldExpr(getCurScope(), Loc, Expr.get());
1634  return Expr;
1635 }
1636 
1637 /// ParseCXXThis - This handles the C++ 'this' pointer.
1638 ///
1639 /// C++ 9.3.2: In the body of a non-static member function, the keyword this is
1640 /// a non-lvalue expression whose value is the address of the object for which
1641 /// the function is called.
1642 ExprResult Parser::ParseCXXThis() {
1643  assert(Tok.is(tok::kw_this) && "Not 'this'!");
1644  SourceLocation ThisLoc = ConsumeToken();
1645  return Actions.ActOnCXXThis(ThisLoc);
1646 }
1647 
1648 /// ParseCXXTypeConstructExpression - Parse construction of a specified type.
1649 /// Can be interpreted either as function-style casting ("int(x)")
1650 /// or class type construction ("ClassType(x,y,z)")
1651 /// or creation of a value-initialized type ("int()").
1652 /// See [C++ 5.2.3].
1653 ///
1654 /// postfix-expression: [C++ 5.2p1]
1655 /// simple-type-specifier '(' expression-list[opt] ')'
1656 /// [C++0x] simple-type-specifier braced-init-list
1657 /// typename-specifier '(' expression-list[opt] ')'
1658 /// [C++0x] typename-specifier braced-init-list
1659 ///
1660 /// In C++1z onwards, the type specifier can also be a template-name.
1661 ExprResult
1662 Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
1663  Declarator DeclaratorInfo(DS, Declarator::FunctionalCastContext);
1664  ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
1665 
1666  assert((Tok.is(tok::l_paren) ||
1667  (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)))
1668  && "Expected '(' or '{'!");
1669 
1670  if (Tok.is(tok::l_brace)) {
1671  ExprResult Init = ParseBraceInitializer();
1672  if (Init.isInvalid())
1673  return Init;
1674  Expr *InitList = Init.get();
1675  return Actions.ActOnCXXTypeConstructExpr(TypeRep, SourceLocation(),
1676  MultiExprArg(&InitList, 1),
1677  SourceLocation());
1678  } else {
1679  BalancedDelimiterTracker T(*this, tok::l_paren);
1680  T.consumeOpen();
1681 
1682  ExprVector Exprs;
1683  CommaLocsTy CommaLocs;
1684 
1685  if (Tok.isNot(tok::r_paren)) {
1686  if (ParseExpressionList(Exprs, CommaLocs, [&] {
1688  TypeRep.get()->getCanonicalTypeInternal(),
1689  DS.getLocEnd(), Exprs);
1690  })) {
1691  SkipUntil(tok::r_paren, StopAtSemi);
1692  return ExprError();
1693  }
1694  }
1695 
1696  // Match the ')'.
1697  T.consumeClose();
1698 
1699  // TypeRep could be null, if it references an invalid typedef.
1700  if (!TypeRep)
1701  return ExprError();
1702 
1703  assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&
1704  "Unexpected number of commas!");
1705  return Actions.ActOnCXXTypeConstructExpr(TypeRep, T.getOpenLocation(),
1706  Exprs,
1707  T.getCloseLocation());
1708  }
1709 }
1710 
1711 /// ParseCXXCondition - if/switch/while condition expression.
1712 ///
1713 /// condition:
1714 /// expression
1715 /// type-specifier-seq declarator '=' assignment-expression
1716 /// [C++11] type-specifier-seq declarator '=' initializer-clause
1717 /// [C++11] type-specifier-seq declarator braced-init-list
1718 /// [Clang] type-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
1719 /// brace-or-equal-initializer
1720 /// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
1721 /// '=' assignment-expression
1722 ///
1723 /// In C++1z, a condition may in some contexts be preceded by an
1724 /// optional init-statement. This function will parse that too.
1725 ///
1726 /// \param InitStmt If non-null, an init-statement is permitted, and if present
1727 /// will be parsed and stored here.
1728 ///
1729 /// \param Loc The location of the start of the statement that requires this
1730 /// condition, e.g., the "for" in a for loop.
1731 ///
1732 /// \returns The parsed condition.
1733 Sema::ConditionResult Parser::ParseCXXCondition(StmtResult *InitStmt,
1734  SourceLocation Loc,
1735  Sema::ConditionKind CK) {
1736  if (Tok.is(tok::code_completion)) {
1738  cutOffParsing();
1739  return Sema::ConditionError();
1740  }
1741 
1742  ParsedAttributesWithRange attrs(AttrFactory);
1743  MaybeParseCXX11Attributes(attrs);
1744 
1745  // Determine what kind of thing we have.
1746  switch (isCXXConditionDeclarationOrInitStatement(InitStmt)) {
1747  case ConditionOrInitStatement::Expression: {
1748  ProhibitAttributes(attrs);
1749 
1750  // Parse the expression.
1751  ExprResult Expr = ParseExpression(); // expression
1752  if (Expr.isInvalid())
1753  return Sema::ConditionError();
1754 
1755  if (InitStmt && Tok.is(tok::semi)) {
1756  *InitStmt = Actions.ActOnExprStmt(Expr.get());
1757  ConsumeToken();
1758  return ParseCXXCondition(nullptr, Loc, CK);
1759  }
1760 
1761  return Actions.ActOnCondition(getCurScope(), Loc, Expr.get(), CK);
1762  }
1763 
1764  case ConditionOrInitStatement::InitStmtDecl: {
1765  Diag(Tok.getLocation(), getLangOpts().CPlusPlus17
1766  ? diag::warn_cxx14_compat_init_statement
1767  : diag::ext_init_statement)
1768  << (CK == Sema::ConditionKind::Switch);
1769  SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
1770  DeclGroupPtrTy DG = ParseSimpleDeclaration(
1771  Declarator::InitStmtContext, DeclEnd, attrs, /*RequireSemi=*/true);
1772  *InitStmt = Actions.ActOnDeclStmt(DG, DeclStart, DeclEnd);
1773  return ParseCXXCondition(nullptr, Loc, CK);
1774  }
1775 
1776  case ConditionOrInitStatement::ConditionDecl:
1777  case ConditionOrInitStatement::Error:
1778  break;
1779  }
1780 
1781  // type-specifier-seq
1782  DeclSpec DS(AttrFactory);
1783  DS.takeAttributesFrom(attrs);
1784  ParseSpecifierQualifierList(DS, AS_none, DSC_condition);
1785 
1786  // declarator
1787  Declarator DeclaratorInfo(DS, Declarator::ConditionContext);
1788  ParseDeclarator(DeclaratorInfo);
1789 
1790  // simple-asm-expr[opt]
1791  if (Tok.is(tok::kw_asm)) {
1792  SourceLocation Loc;
1793  ExprResult AsmLabel(ParseSimpleAsm(&Loc));
1794  if (AsmLabel.isInvalid()) {
1795  SkipUntil(tok::semi, StopAtSemi);
1796  return Sema::ConditionError();
1797  }
1798  DeclaratorInfo.setAsmLabel(AsmLabel.get());
1799  DeclaratorInfo.SetRangeEnd(Loc);
1800  }
1801 
1802  // If attributes are present, parse them.
1803  MaybeParseGNUAttributes(DeclaratorInfo);
1804 
1805  // Type-check the declaration itself.
1807  DeclaratorInfo);
1808  if (Dcl.isInvalid())
1809  return Sema::ConditionError();
1810  Decl *DeclOut = Dcl.get();
1811 
1812  // '=' assignment-expression
1813  // If a '==' or '+=' is found, suggest a fixit to '='.
1814  bool CopyInitialization = isTokenEqualOrEqualTypo();
1815  if (CopyInitialization)
1816  ConsumeToken();
1817 
1818  ExprResult InitExpr = ExprError();
1819  if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
1820  Diag(Tok.getLocation(),
1821  diag::warn_cxx98_compat_generalized_initializer_lists);
1822  InitExpr = ParseBraceInitializer();
1823  } else if (CopyInitialization) {
1824  InitExpr = ParseAssignmentExpression();
1825  } else if (Tok.is(tok::l_paren)) {
1826  // This was probably an attempt to initialize the variable.
1827  SourceLocation LParen = ConsumeParen(), RParen = LParen;
1828  if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch))
1829  RParen = ConsumeParen();
1830  Diag(DeclOut->getLocation(),
1831  diag::err_expected_init_in_condition_lparen)
1832  << SourceRange(LParen, RParen);
1833  } else {
1834  Diag(DeclOut->getLocation(), diag::err_expected_init_in_condition);
1835  }
1836 
1837  if (!InitExpr.isInvalid())
1838  Actions.AddInitializerToDecl(DeclOut, InitExpr.get(), !CopyInitialization);
1839  else
1840  Actions.ActOnInitializerError(DeclOut);
1841 
1842  Actions.FinalizeDeclaration(DeclOut);
1843  return Actions.ActOnConditionVariable(DeclOut, Loc, CK);
1844 }
1845 
1846 /// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
1847 /// This should only be called when the current token is known to be part of
1848 /// simple-type-specifier.
1849 ///
1850 /// simple-type-specifier:
1851 /// '::'[opt] nested-name-specifier[opt] type-name
1852 /// '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
1853 /// char
1854 /// wchar_t
1855 /// bool
1856 /// short
1857 /// int
1858 /// long
1859 /// signed
1860 /// unsigned
1861 /// float
1862 /// double
1863 /// void
1864 /// [GNU] typeof-specifier
1865 /// [C++0x] auto [TODO]
1866 ///
1867 /// type-name:
1868 /// class-name
1869 /// enum-name
1870 /// typedef-name
1871 ///
1872 void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
1873  DS.SetRangeStart(Tok.getLocation());
1874  const char *PrevSpec;
1875  unsigned DiagID;
1876  SourceLocation Loc = Tok.getLocation();
1877  const clang::PrintingPolicy &Policy =
1878  Actions.getASTContext().getPrintingPolicy();
1879 
1880  switch (Tok.getKind()) {
1881  case tok::identifier: // foo::bar
1882  case tok::coloncolon: // ::foo::bar
1883  llvm_unreachable("Annotation token should already be formed!");
1884  default:
1885  llvm_unreachable("Not a simple-type-specifier token!");
1886 
1887  // type-name
1888  case tok::annot_typename: {
1889  if (getTypeAnnotation(Tok))
1890  DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID,
1891  getTypeAnnotation(Tok), Policy);
1892  else
1893  DS.SetTypeSpecError();
1894 
1895  DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1896  ConsumeAnnotationToken();
1897 
1898  DS.Finish(Actions, Policy);
1899  return;
1900  }
1901 
1902  // builtin types
1903  case tok::kw_short:
1904  DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID, Policy);
1905  break;
1906  case tok::kw_long:
1907  DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, DiagID, Policy);
1908  break;
1909  case tok::kw___int64:
1910  DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, DiagID, Policy);
1911  break;
1912  case tok::kw_signed:
1913  DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID);
1914  break;
1915  case tok::kw_unsigned:
1916  DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, DiagID);
1917  break;
1918  case tok::kw_void:
1919  DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID, Policy);
1920  break;
1921  case tok::kw_char:
1922  DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID, Policy);
1923  break;
1924  case tok::kw_int:
1925  DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID, Policy);
1926  break;
1927  case tok::kw___int128:
1928  DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID, Policy);
1929  break;
1930  case tok::kw_half:
1931  DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID, Policy);
1932  break;
1933  case tok::kw_float:
1934  DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID, Policy);
1935  break;
1936  case tok::kw_double:
1937  DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID, Policy);
1938  break;
1939  case tok::kw__Float16:
1940  DS.SetTypeSpecType(DeclSpec::TST_float16, Loc, PrevSpec, DiagID, Policy);
1941  break;
1942  case tok::kw___float128:
1943  DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec, DiagID, Policy);
1944  break;
1945  case tok::kw_wchar_t:
1946  DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID, Policy);
1947  break;
1948  case tok::kw_char16_t:
1949  DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID, Policy);
1950  break;
1951  case tok::kw_char32_t:
1952  DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID, Policy);
1953  break;
1954  case tok::kw_bool:
1955  DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID, Policy);
1956  break;
1957  case tok::annot_decltype:
1958  case tok::kw_decltype:
1959  DS.SetRangeEnd(ParseDecltypeSpecifier(DS));
1960  return DS.Finish(Actions, Policy);
1961 
1962  // GNU typeof support.
1963  case tok::kw_typeof:
1964  ParseTypeofSpecifier(DS);
1965  DS.Finish(Actions, Policy);
1966  return;
1967  }
1968  ConsumeAnyToken();
1969  DS.SetRangeEnd(PrevTokLocation);
1970  DS.Finish(Actions, Policy);
1971 }
1972 
1973 /// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
1974 /// [dcl.name]), which is a non-empty sequence of type-specifiers,
1975 /// e.g., "const short int". Note that the DeclSpec is *not* finished
1976 /// by parsing the type-specifier-seq, because these sequences are
1977 /// typically followed by some form of declarator. Returns true and
1978 /// emits diagnostics if this is not a type-specifier-seq, false
1979 /// otherwise.
1980 ///
1981 /// type-specifier-seq: [C++ 8.1]
1982 /// type-specifier type-specifier-seq[opt]
1983 ///
1984 bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
1985  ParseSpecifierQualifierList(DS, AS_none, DSC_type_specifier);
1986  DS.Finish(Actions, Actions.getASTContext().getPrintingPolicy());
1987  return false;
1988 }
1989 
1990 /// \brief Finish parsing a C++ unqualified-id that is a template-id of
1991 /// some form.
1992 ///
1993 /// This routine is invoked when a '<' is encountered after an identifier or
1994 /// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
1995 /// whether the unqualified-id is actually a template-id. This routine will
1996 /// then parse the template arguments and form the appropriate template-id to
1997 /// return to the caller.
1998 ///
1999 /// \param SS the nested-name-specifier that precedes this template-id, if
2000 /// we're actually parsing a qualified-id.
2001 ///
2002 /// \param Name for constructor and destructor names, this is the actual
2003 /// identifier that may be a template-name.
2004 ///
2005 /// \param NameLoc the location of the class-name in a constructor or
2006 /// destructor.
2007 ///
2008 /// \param EnteringContext whether we're entering the scope of the
2009 /// nested-name-specifier.
2010 ///
2011 /// \param ObjectType if this unqualified-id occurs within a member access
2012 /// expression, the type of the base object whose member is being accessed.
2013 ///
2014 /// \param Id as input, describes the template-name or operator-function-id
2015 /// that precedes the '<'. If template arguments were parsed successfully,
2016 /// will be updated with the template-id.
2017 ///
2018 /// \param AssumeTemplateId When true, this routine will assume that the name
2019 /// refers to a template without performing name lookup to verify.
2020 ///
2021 /// \returns true if a parse error occurred, false otherwise.
2022 bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
2023  SourceLocation TemplateKWLoc,
2024  IdentifierInfo *Name,
2025  SourceLocation NameLoc,
2026  bool EnteringContext,
2027  ParsedType ObjectType,
2028  UnqualifiedId &Id,
2029  bool AssumeTemplateId) {
2030  assert((AssumeTemplateId || Tok.is(tok::less)) &&
2031  "Expected '<' to finish parsing a template-id");
2032 
2033  TemplateTy Template;
2035  switch (Id.getKind()) {
2039  if (AssumeTemplateId) {
2040  // We defer the injected-class-name checks until we've found whether
2041  // this template-id is used to form a nested-name-specifier or not.
2042  TNK = Actions.ActOnDependentTemplateName(
2043  getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
2044  Template, /*AllowInjectedClassName*/ true);
2045  if (TNK == TNK_Non_template)
2046  return true;
2047  } else {
2048  bool MemberOfUnknownSpecialization;
2049  TNK = Actions.isTemplateName(getCurScope(), SS,
2050  TemplateKWLoc.isValid(), Id,
2051  ObjectType, EnteringContext, Template,
2052  MemberOfUnknownSpecialization);
2053 
2054  if (TNK == TNK_Non_template && MemberOfUnknownSpecialization &&
2055  ObjectType && IsTemplateArgumentList()) {
2056  // We have something like t->getAs<T>(), where getAs is a
2057  // member of an unknown specialization. However, this will only
2058  // parse correctly as a template, so suggest the keyword 'template'
2059  // before 'getAs' and treat this as a dependent template name.
2060  std::string Name;
2062  Name = Id.Identifier->getName();
2063  else {
2064  Name = "operator ";
2067  else
2068  Name += Id.Identifier->getName();
2069  }
2070  Diag(Id.StartLocation, diag::err_missing_dependent_template_keyword)
2071  << Name
2072  << FixItHint::CreateInsertion(Id.StartLocation, "template ");
2073  TNK = Actions.ActOnDependentTemplateName(
2074  getCurScope(), SS, TemplateKWLoc, Id, ObjectType, EnteringContext,
2075  Template, /*AllowInjectedClassName*/ true);
2076  if (TNK == TNK_Non_template)
2077  return true;
2078  }
2079  }
2080  break;
2081 
2084  bool MemberOfUnknownSpecialization;
2085  TemplateName.setIdentifier(Name, NameLoc);
2086  TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
2087  TemplateName, ObjectType,
2088  EnteringContext, Template,
2089  MemberOfUnknownSpecialization);
2090  break;
2091  }
2092 
2095  bool MemberOfUnknownSpecialization;
2096  TemplateName.setIdentifier(Name, NameLoc);
2097  if (ObjectType) {
2098  TNK = Actions.ActOnDependentTemplateName(
2099  getCurScope(), SS, TemplateKWLoc, TemplateName, ObjectType,
2100  EnteringContext, Template, /*AllowInjectedClassName*/ true);
2101  if (TNK == TNK_Non_template)
2102  return true;
2103  } else {
2104  TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
2105  TemplateName, ObjectType,
2106  EnteringContext, Template,
2107  MemberOfUnknownSpecialization);
2108 
2109  if (TNK == TNK_Non_template && !Id.DestructorName.get()) {
2110  Diag(NameLoc, diag::err_destructor_template_id)
2111  << Name << SS.getRange();
2112  return true;
2113  }
2114  }
2115  break;
2116  }
2117 
2118  default:
2119  return false;
2120  }
2121 
2122  if (TNK == TNK_Non_template)
2123  return false;
2124 
2125  // Parse the enclosed template argument list.
2126  SourceLocation LAngleLoc, RAngleLoc;
2127  TemplateArgList TemplateArgs;
2128  if (Tok.is(tok::less) && ParseTemplateIdAfterTemplateName(
2129  true, LAngleLoc, TemplateArgs, RAngleLoc))
2130  return true;
2131 
2132  if (Id.getKind() == UnqualifiedId::IK_Identifier ||
2135  // Form a parsed representation of the template-id to be stored in the
2136  // UnqualifiedId.
2137 
2138  // FIXME: Store name for literal operator too.
2139  IdentifierInfo *TemplateII =
2140  Id.getKind() == UnqualifiedId::IK_Identifier ? Id.Identifier : nullptr;
2142  ? OO_None
2144 
2146  SS, TemplateKWLoc, Id.StartLocation, TemplateII, OpKind, Template, TNK,
2147  LAngleLoc, RAngleLoc, TemplateArgs, TemplateIds);
2148 
2149  Id.setTemplateId(TemplateId);
2150  return false;
2151  }
2152 
2153  // Bundle the template arguments together.
2154  ASTTemplateArgsPtr TemplateArgsPtr(TemplateArgs);
2155 
2156  // Constructor and destructor names.
2158  = Actions.ActOnTemplateIdType(SS, TemplateKWLoc,
2159  Template, Name, NameLoc,
2160  LAngleLoc, TemplateArgsPtr, RAngleLoc,
2161  /*IsCtorOrDtorName=*/true);
2162  if (Type.isInvalid())
2163  return true;
2164 
2166  Id.setConstructorName(Type.get(), NameLoc, RAngleLoc);
2167  else
2168  Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc);
2169 
2170  return false;
2171 }
2172 
2173 /// \brief Parse an operator-function-id or conversion-function-id as part
2174 /// of a C++ unqualified-id.
2175 ///
2176 /// This routine is responsible only for parsing the operator-function-id or
2177 /// conversion-function-id; it does not handle template arguments in any way.
2178 ///
2179 /// \code
2180 /// operator-function-id: [C++ 13.5]
2181 /// 'operator' operator
2182 ///
2183 /// operator: one of
2184 /// new delete new[] delete[]
2185 /// + - * / % ^ & | ~
2186 /// ! = < > += -= *= /= %=
2187 /// ^= &= |= << >> >>= <<= == !=
2188 /// <= >= && || ++ -- , ->* ->
2189 /// () [] <=>
2190 ///
2191 /// conversion-function-id: [C++ 12.3.2]
2192 /// operator conversion-type-id
2193 ///
2194 /// conversion-type-id:
2195 /// type-specifier-seq conversion-declarator[opt]
2196 ///
2197 /// conversion-declarator:
2198 /// ptr-operator conversion-declarator[opt]
2199 /// \endcode
2200 ///
2201 /// \param SS The nested-name-specifier that preceded this unqualified-id. If
2202 /// non-empty, then we are parsing the unqualified-id of a qualified-id.
2203 ///
2204 /// \param EnteringContext whether we are entering the scope of the
2205 /// nested-name-specifier.
2206 ///
2207 /// \param ObjectType if this unqualified-id occurs within a member access
2208 /// expression, the type of the base object whose member is being accessed.
2209 ///
2210 /// \param Result on a successful parse, contains the parsed unqualified-id.
2211 ///
2212 /// \returns true if parsing fails, false otherwise.
2213 bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
2214  ParsedType ObjectType,
2215  UnqualifiedId &Result) {
2216  assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword");
2217 
2218  // Consume the 'operator' keyword.
2219  SourceLocation KeywordLoc = ConsumeToken();
2220 
2221  // Determine what kind of operator name we have.
2222  unsigned SymbolIdx = 0;
2223  SourceLocation SymbolLocations[3];
2225  switch (Tok.getKind()) {
2226  case tok::kw_new:
2227  case tok::kw_delete: {
2228  bool isNew = Tok.getKind() == tok::kw_new;
2229  // Consume the 'new' or 'delete'.
2230  SymbolLocations[SymbolIdx++] = ConsumeToken();
2231  // Check for array new/delete.
2232  if (Tok.is(tok::l_square) &&
2233  (!getLangOpts().CPlusPlus11 || NextToken().isNot(tok::l_square))) {
2234  // Consume the '[' and ']'.
2235  BalancedDelimiterTracker T(*this, tok::l_square);
2236  T.consumeOpen();
2237  T.consumeClose();
2238  if (T.getCloseLocation().isInvalid())
2239  return true;
2240 
2241  SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2242  SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2243  Op = isNew? OO_Array_New : OO_Array_Delete;
2244  } else {
2245  Op = isNew? OO_New : OO_Delete;
2246  }
2247  break;
2248  }
2249 
2250 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2251  case tok::Token: \
2252  SymbolLocations[SymbolIdx++] = ConsumeToken(); \
2253  Op = OO_##Name; \
2254  break;
2255 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2256 #include "clang/Basic/OperatorKinds.def"
2257 
2258  case tok::l_paren: {
2259  // Consume the '(' and ')'.
2260  BalancedDelimiterTracker T(*this, tok::l_paren);
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_Call;
2269  break;
2270  }
2271 
2272  case tok::l_square: {
2273  // Consume the '[' and ']'.
2274  BalancedDelimiterTracker T(*this, tok::l_square);
2275  T.consumeOpen();
2276  T.consumeClose();
2277  if (T.getCloseLocation().isInvalid())
2278  return true;
2279 
2280  SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2281  SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2282  Op = OO_Subscript;
2283  break;
2284  }
2285 
2286  case tok::code_completion: {
2287  // Code completion for the operator name.
2289  cutOffParsing();
2290  // Don't try to parse any further.
2291  return true;
2292  }
2293 
2294  default:
2295  break;
2296  }
2297 
2298  if (Op != OO_None) {
2299  // We have parsed an operator-function-id.
2300  Result.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations);
2301  return false;
2302  }
2303 
2304  // Parse a literal-operator-id.
2305  //
2306  // literal-operator-id: C++11 [over.literal]
2307  // operator string-literal identifier
2308  // operator user-defined-string-literal
2309 
2310  if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {
2311  Diag(Tok.getLocation(), diag::warn_cxx98_compat_literal_operator);
2312 
2313  SourceLocation DiagLoc;
2314  unsigned DiagId = 0;
2315 
2316  // We're past translation phase 6, so perform string literal concatenation
2317  // before checking for "".
2318  SmallVector<Token, 4> Toks;
2320  while (isTokenStringLiteral()) {
2321  if (!Tok.is(tok::string_literal) && !DiagId) {
2322  // C++11 [over.literal]p1:
2323  // The string-literal or user-defined-string-literal in a
2324  // literal-operator-id shall have no encoding-prefix [...].
2325  DiagLoc = Tok.getLocation();
2326  DiagId = diag::err_literal_operator_string_prefix;
2327  }
2328  Toks.push_back(Tok);
2329  TokLocs.push_back(ConsumeStringToken());
2330  }
2331 
2332  StringLiteralParser Literal(Toks, PP);
2333  if (Literal.hadError)
2334  return true;
2335 
2336  // Grab the literal operator's suffix, which will be either the next token
2337  // or a ud-suffix from the string literal.
2338  IdentifierInfo *II = nullptr;
2339  SourceLocation SuffixLoc;
2340  if (!Literal.getUDSuffix().empty()) {
2341  II = &PP.getIdentifierTable().get(Literal.getUDSuffix());
2342  SuffixLoc =
2344  Literal.getUDSuffixOffset(),
2345  PP.getSourceManager(), getLangOpts());
2346  } else if (Tok.is(tok::identifier)) {
2347  II = Tok.getIdentifierInfo();
2348  SuffixLoc = ConsumeToken();
2349  TokLocs.push_back(SuffixLoc);
2350  } else {
2351  Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
2352  return true;
2353  }
2354 
2355  // The string literal must be empty.
2356  if (!Literal.GetString().empty() || Literal.Pascal) {
2357  // C++11 [over.literal]p1:
2358  // The string-literal or user-defined-string-literal in a
2359  // literal-operator-id shall [...] contain no characters
2360  // other than the implicit terminating '\0'.
2361  DiagLoc = TokLocs.front();
2362  DiagId = diag::err_literal_operator_string_not_empty;
2363  }
2364 
2365  if (DiagId) {
2366  // This isn't a valid literal-operator-id, but we think we know
2367  // what the user meant. Tell them what they should have written.
2368  SmallString<32> Str;
2369  Str += "\"\"";
2370  Str += II->getName();
2371  Diag(DiagLoc, DiagId) << FixItHint::CreateReplacement(
2372  SourceRange(TokLocs.front(), TokLocs.back()), Str);
2373  }
2374 
2375  Result.setLiteralOperatorId(II, KeywordLoc, SuffixLoc);
2376 
2377  return Actions.checkLiteralOperatorId(SS, Result);
2378  }
2379 
2380  // Parse a conversion-function-id.
2381  //
2382  // conversion-function-id: [C++ 12.3.2]
2383  // operator conversion-type-id
2384  //
2385  // conversion-type-id:
2386  // type-specifier-seq conversion-declarator[opt]
2387  //
2388  // conversion-declarator:
2389  // ptr-operator conversion-declarator[opt]
2390 
2391  // Parse the type-specifier-seq.
2392  DeclSpec DS(AttrFactory);
2393  if (ParseCXXTypeSpecifierSeq(DS)) // FIXME: ObjectType?
2394  return true;
2395 
2396  // Parse the conversion-declarator, which is merely a sequence of
2397  // ptr-operators.
2399  ParseDeclaratorInternal(D, /*DirectDeclParser=*/nullptr);
2400 
2401  // Finish up the type.
2402  TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D);
2403  if (Ty.isInvalid())
2404  return true;
2405 
2406  // Note that this is a conversion-function-id.
2407  Result.setConversionFunctionId(KeywordLoc, Ty.get(),
2408  D.getSourceRange().getEnd());
2409  return false;
2410 }
2411 
2412 /// \brief Parse a C++ unqualified-id (or a C identifier), which describes the
2413 /// name of an entity.
2414 ///
2415 /// \code
2416 /// unqualified-id: [C++ expr.prim.general]
2417 /// identifier
2418 /// operator-function-id
2419 /// conversion-function-id
2420 /// [C++0x] literal-operator-id [TODO]
2421 /// ~ class-name
2422 /// template-id
2423 ///
2424 /// \endcode
2425 ///
2426 /// \param SS The nested-name-specifier that preceded this unqualified-id. If
2427 /// non-empty, then we are parsing the unqualified-id of a qualified-id.
2428 ///
2429 /// \param EnteringContext whether we are entering the scope of the
2430 /// nested-name-specifier.
2431 ///
2432 /// \param AllowDestructorName whether we allow parsing of a destructor name.
2433 ///
2434 /// \param AllowConstructorName whether we allow parsing a constructor name.
2435 ///
2436 /// \param AllowDeductionGuide whether we allow parsing a deduction guide name.
2437 ///
2438 /// \param ObjectType if this unqualified-id occurs within a member access
2439 /// expression, the type of the base object whose member is being accessed.
2440 ///
2441 /// \param Result on a successful parse, contains the parsed unqualified-id.
2442 ///
2443 /// \returns true if parsing fails, false otherwise.
2444 bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext,
2445  bool AllowDestructorName,
2446  bool AllowConstructorName,
2447  bool AllowDeductionGuide,
2448  ParsedType ObjectType,
2449  SourceLocation& TemplateKWLoc,
2450  UnqualifiedId &Result) {
2451 
2452  // Handle 'A::template B'. This is for template-ids which have not
2453  // already been annotated by ParseOptionalCXXScopeSpecifier().
2454  bool TemplateSpecified = false;
2455  if (getLangOpts().CPlusPlus && Tok.is(tok::kw_template) &&
2456  (ObjectType || SS.isSet())) {
2457  TemplateSpecified = true;
2458  TemplateKWLoc = ConsumeToken();
2459  }
2460 
2461  // unqualified-id:
2462  // identifier
2463  // template-id (when it hasn't already been annotated)
2464  if (Tok.is(tok::identifier)) {
2465  // Consume the identifier.
2466  IdentifierInfo *Id = Tok.getIdentifierInfo();
2467  SourceLocation IdLoc = ConsumeToken();
2468 
2469  if (!getLangOpts().CPlusPlus) {
2470  // If we're not in C++, only identifiers matter. Record the
2471  // identifier and return.
2472  Result.setIdentifier(Id, IdLoc);
2473  return false;
2474  }
2475 
2477  if (AllowConstructorName &&
2478  Actions.isCurrentClassName(*Id, getCurScope(), &SS)) {
2479  // We have parsed a constructor name.
2480  ParsedType Ty = Actions.getTypeName(*Id, IdLoc, getCurScope(), &SS, false,
2481  false, nullptr,
2482  /*IsCtorOrDtorName=*/true,
2483  /*NonTrivialTypeSourceInfo=*/true);
2484  Result.setConstructorName(Ty, IdLoc, IdLoc);
2485  } else if (getLangOpts().CPlusPlus17 &&
2486  AllowDeductionGuide && SS.isEmpty() &&
2487  Actions.isDeductionGuideName(getCurScope(), *Id, IdLoc,
2488  &TemplateName)) {
2489  // We have parsed a template-name naming a deduction guide.
2490  Result.setDeductionGuideName(TemplateName, IdLoc);
2491  } else {
2492  // We have parsed an identifier.
2493  Result.setIdentifier(Id, IdLoc);
2494  }
2495 
2496  // If the next token is a '<', we may have a template.
2497  if (TemplateSpecified || Tok.is(tok::less))
2498  return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc, Id, IdLoc,
2499  EnteringContext, ObjectType,
2500  Result, TemplateSpecified);
2501 
2502  return false;
2503  }
2504 
2505  // unqualified-id:
2506  // template-id (already parsed and annotated)
2507  if (Tok.is(tok::annot_template_id)) {
2508  TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
2509 
2510  // If the template-name names the current class, then this is a constructor
2511  if (AllowConstructorName && TemplateId->Name &&
2512  Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
2513  if (SS.isSet()) {
2514  // C++ [class.qual]p2 specifies that a qualified template-name
2515  // is taken as the constructor name where a constructor can be
2516  // declared. Thus, the template arguments are extraneous, so
2517  // complain about them and remove them entirely.
2518  Diag(TemplateId->TemplateNameLoc,
2519  diag::err_out_of_line_constructor_template_id)
2520  << TemplateId->Name
2522  SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc));
2523  ParsedType Ty =
2524  Actions.getTypeName(*TemplateId->Name, TemplateId->TemplateNameLoc,
2525  getCurScope(), &SS, false, false, nullptr,
2526  /*IsCtorOrDtorName=*/true,
2527  /*NontrivialTypeSourceInfo=*/true);
2528  Result.setConstructorName(Ty, TemplateId->TemplateNameLoc,
2529  TemplateId->RAngleLoc);
2530  ConsumeAnnotationToken();
2531  return false;
2532  }
2533 
2534  Result.setConstructorTemplateId(TemplateId);
2535  ConsumeAnnotationToken();
2536  return false;
2537  }
2538 
2539  // We have already parsed a template-id; consume the annotation token as
2540  // our unqualified-id.
2541  Result.setTemplateId(TemplateId);
2542  TemplateKWLoc = TemplateId->TemplateKWLoc;
2543  ConsumeAnnotationToken();
2544  return false;
2545  }
2546 
2547  // unqualified-id:
2548  // operator-function-id
2549  // conversion-function-id
2550  if (Tok.is(tok::kw_operator)) {
2551  if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, Result))
2552  return true;
2553 
2554  // If we have an operator-function-id or a literal-operator-id and the next
2555  // token is a '<', we may have a
2556  //
2557  // template-id:
2558  // operator-function-id < template-argument-list[opt] >
2559  if ((Result.getKind() == UnqualifiedId::IK_OperatorFunctionId ||
2561  (TemplateSpecified || Tok.is(tok::less)))
2562  return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
2563  nullptr, SourceLocation(),
2564  EnteringContext, ObjectType,
2565  Result, TemplateSpecified);
2566 
2567  return false;
2568  }
2569 
2570  if (getLangOpts().CPlusPlus &&
2571  (AllowDestructorName || SS.isSet()) && Tok.is(tok::tilde)) {
2572  // C++ [expr.unary.op]p10:
2573  // There is an ambiguity in the unary-expression ~X(), where X is a
2574  // class-name. The ambiguity is resolved in favor of treating ~ as a
2575  // unary complement rather than treating ~X as referring to a destructor.
2576 
2577  // Parse the '~'.
2578  SourceLocation TildeLoc = ConsumeToken();
2579 
2580  if (SS.isEmpty() && Tok.is(tok::kw_decltype)) {
2581  DeclSpec DS(AttrFactory);
2582  SourceLocation EndLoc = ParseDecltypeSpecifier(DS);
2583  if (ParsedType Type =
2584  Actions.getDestructorTypeForDecltype(DS, ObjectType)) {
2585  Result.setDestructorName(TildeLoc, Type, EndLoc);
2586  return false;
2587  }
2588  return true;
2589  }
2590 
2591  // Parse the class-name.
2592  if (Tok.isNot(tok::identifier)) {
2593  Diag(Tok, diag::err_destructor_tilde_identifier);
2594  return true;
2595  }
2596 
2597  // If the user wrote ~T::T, correct it to T::~T.
2598  DeclaratorScopeObj DeclScopeObj(*this, SS);
2599  if (!TemplateSpecified && NextToken().is(tok::coloncolon)) {
2600  // Don't let ParseOptionalCXXScopeSpecifier() "correct"
2601  // `int A; struct { ~A::A(); };` to `int A; struct { ~A:A(); };`,
2602  // it will confuse this recovery logic.
2603  ColonProtectionRAIIObject ColonRAII(*this, false);
2604 
2605  if (SS.isSet()) {
2606  AnnotateScopeToken(SS, /*NewAnnotation*/true);
2607  SS.clear();
2608  }
2609  if (ParseOptionalCXXScopeSpecifier(SS, ObjectType, EnteringContext))
2610  return true;
2611  if (SS.isNotEmpty())
2612  ObjectType = nullptr;
2613  if (Tok.isNot(tok::identifier) || NextToken().is(tok::coloncolon) ||
2614  !SS.isSet()) {
2615  Diag(TildeLoc, diag::err_destructor_tilde_scope);
2616  return true;
2617  }
2618 
2619  // Recover as if the tilde had been written before the identifier.
2620  Diag(TildeLoc, diag::err_destructor_tilde_scope)
2621  << FixItHint::CreateRemoval(TildeLoc)
2622  << FixItHint::CreateInsertion(Tok.getLocation(), "~");
2623 
2624  // Temporarily enter the scope for the rest of this function.
2625  if (Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
2626  DeclScopeObj.EnterDeclaratorScope();
2627  }
2628 
2629  // Parse the class-name (or template-name in a simple-template-id).
2630  IdentifierInfo *ClassName = Tok.getIdentifierInfo();
2631  SourceLocation ClassNameLoc = ConsumeToken();
2632 
2633  if (TemplateSpecified || Tok.is(tok::less)) {
2634  Result.setDestructorName(TildeLoc, nullptr, ClassNameLoc);
2635  return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
2636  ClassName, ClassNameLoc,
2637  EnteringContext, ObjectType,
2638  Result, TemplateSpecified);
2639  }
2640 
2641  // Note that this is a destructor name.
2642  ParsedType Ty = Actions.getDestructorName(TildeLoc, *ClassName,
2643  ClassNameLoc, getCurScope(),
2644  SS, ObjectType,
2645  EnteringContext);
2646  if (!Ty)
2647  return true;
2648 
2649  Result.setDestructorName(TildeLoc, Ty, ClassNameLoc);
2650  return false;
2651  }
2652 
2653  Diag(Tok, diag::err_expected_unqualified_id)
2654  << getLangOpts().CPlusPlus;
2655  return true;
2656 }
2657 
2658 /// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
2659 /// memory in a typesafe manner and call constructors.
2660 ///
2661 /// This method is called to parse the new expression after the optional :: has
2662 /// been already parsed. If the :: was present, "UseGlobal" is true and "Start"
2663 /// is its location. Otherwise, "Start" is the location of the 'new' token.
2664 ///
2665 /// new-expression:
2666 /// '::'[opt] 'new' new-placement[opt] new-type-id
2667 /// new-initializer[opt]
2668 /// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2669 /// new-initializer[opt]
2670 ///
2671 /// new-placement:
2672 /// '(' expression-list ')'
2673 ///
2674 /// new-type-id:
2675 /// type-specifier-seq new-declarator[opt]
2676 /// [GNU] attributes type-specifier-seq new-declarator[opt]
2677 ///
2678 /// new-declarator:
2679 /// ptr-operator new-declarator[opt]
2680 /// direct-new-declarator
2681 ///
2682 /// new-initializer:
2683 /// '(' expression-list[opt] ')'
2684 /// [C++0x] braced-init-list
2685 ///
2686 ExprResult
2687 Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
2688  assert(Tok.is(tok::kw_new) && "expected 'new' token");
2689  ConsumeToken(); // Consume 'new'
2690 
2691  // A '(' now can be a new-placement or the '(' wrapping the type-id in the
2692  // second form of new-expression. It can't be a new-type-id.
2693 
2694  ExprVector PlacementArgs;
2695  SourceLocation PlacementLParen, PlacementRParen;
2696 
2697  SourceRange TypeIdParens;
2698  DeclSpec DS(AttrFactory);
2699  Declarator DeclaratorInfo(DS, Declarator::CXXNewContext);
2700  if (Tok.is(tok::l_paren)) {
2701  // If it turns out to be a placement, we change the type location.
2702  BalancedDelimiterTracker T(*this, tok::l_paren);
2703  T.consumeOpen();
2704  PlacementLParen = T.getOpenLocation();
2705  if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
2706  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2707  return ExprError();
2708  }
2709 
2710  T.consumeClose();
2711  PlacementRParen = T.getCloseLocation();
2712  if (PlacementRParen.isInvalid()) {
2713  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2714  return ExprError();
2715  }
2716 
2717  if (PlacementArgs.empty()) {
2718  // Reset the placement locations. There was no placement.
2719  TypeIdParens = T.getRange();
2720  PlacementLParen = PlacementRParen = SourceLocation();
2721  } else {
2722  // We still need the type.
2723  if (Tok.is(tok::l_paren)) {
2724  BalancedDelimiterTracker T(*this, tok::l_paren);
2725  T.consumeOpen();
2726  MaybeParseGNUAttributes(DeclaratorInfo);
2727  ParseSpecifierQualifierList(DS);
2728  DeclaratorInfo.SetSourceRange(DS.getSourceRange());
2729  ParseDeclarator(DeclaratorInfo);
2730  T.consumeClose();
2731  TypeIdParens = T.getRange();
2732  } else {
2733  MaybeParseGNUAttributes(DeclaratorInfo);
2734  if (ParseCXXTypeSpecifierSeq(DS))
2735  DeclaratorInfo.setInvalidType(true);
2736  else {
2737  DeclaratorInfo.SetSourceRange(DS.getSourceRange());
2738  ParseDeclaratorInternal(DeclaratorInfo,
2739  &Parser::ParseDirectNewDeclarator);
2740  }
2741  }
2742  }
2743  } else {
2744  // A new-type-id is a simplified type-id, where essentially the
2745  // direct-declarator is replaced by a direct-new-declarator.
2746  MaybeParseGNUAttributes(DeclaratorInfo);
2747  if (ParseCXXTypeSpecifierSeq(DS))
2748  DeclaratorInfo.setInvalidType(true);
2749  else {
2750  DeclaratorInfo.SetSourceRange(DS.getSourceRange());
2751  ParseDeclaratorInternal(DeclaratorInfo,
2752  &Parser::ParseDirectNewDeclarator);
2753  }
2754  }
2755  if (DeclaratorInfo.isInvalidType()) {
2756  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2757  return ExprError();
2758  }
2759 
2760  ExprResult Initializer;
2761 
2762  if (Tok.is(tok::l_paren)) {
2763  SourceLocation ConstructorLParen, ConstructorRParen;
2764  ExprVector ConstructorArgs;
2765  BalancedDelimiterTracker T(*this, tok::l_paren);
2766  T.consumeOpen();
2767  ConstructorLParen = T.getOpenLocation();
2768  if (Tok.isNot(tok::r_paren)) {
2769  CommaLocsTy CommaLocs;
2770  if (ParseExpressionList(ConstructorArgs, CommaLocs, [&] {
2771  ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(),
2772  DeclaratorInfo).get();
2774  TypeRep.get()->getCanonicalTypeInternal(),
2775  DeclaratorInfo.getLocEnd(),
2776  ConstructorArgs);
2777  })) {
2778  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2779  return ExprError();
2780  }
2781  }
2782  T.consumeClose();
2783  ConstructorRParen = T.getCloseLocation();
2784  if (ConstructorRParen.isInvalid()) {
2785  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2786  return ExprError();
2787  }
2788  Initializer = Actions.ActOnParenListExpr(ConstructorLParen,
2789  ConstructorRParen,
2790  ConstructorArgs);
2791  } else if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus11) {
2792  Diag(Tok.getLocation(),
2793  diag::warn_cxx98_compat_generalized_initializer_lists);
2794  Initializer = ParseBraceInitializer();
2795  }
2796  if (Initializer.isInvalid())
2797  return Initializer;
2798 
2799  return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen,
2800  PlacementArgs, PlacementRParen,
2801  TypeIdParens, DeclaratorInfo, Initializer.get());
2802 }
2803 
2804 /// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
2805 /// passed to ParseDeclaratorInternal.
2806 ///
2807 /// direct-new-declarator:
2808 /// '[' expression ']'
2809 /// direct-new-declarator '[' constant-expression ']'
2810 ///
2811 void Parser::ParseDirectNewDeclarator(Declarator &D) {
2812  // Parse the array dimensions.
2813  bool first = true;
2814  while (Tok.is(tok::l_square)) {
2815  // An array-size expression can't start with a lambda.
2816  if (CheckProhibitedCXX11Attribute())
2817  continue;
2818 
2819  BalancedDelimiterTracker T(*this, tok::l_square);
2820  T.consumeOpen();
2821 
2822  ExprResult Size(first ? ParseExpression()
2824  if (Size.isInvalid()) {
2825  // Recover
2826  SkipUntil(tok::r_square, StopAtSemi);
2827  return;
2828  }
2829  first = false;
2830 
2831  T.consumeClose();
2832 
2833  // Attributes here appertain to the array type. C++11 [expr.new]p5.
2834  ParsedAttributes Attrs(AttrFactory);
2835  MaybeParseCXX11Attributes(Attrs);
2836 
2838  /*static=*/false, /*star=*/false,
2839  Size.get(),
2840  T.getOpenLocation(),
2841  T.getCloseLocation()),
2842  Attrs, T.getCloseLocation());
2843 
2844  if (T.getCloseLocation().isInvalid())
2845  return;
2846  }
2847 }
2848 
2849 /// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
2850 /// This ambiguity appears in the syntax of the C++ new operator.
2851 ///
2852 /// new-expression:
2853 /// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2854 /// new-initializer[opt]
2855 ///
2856 /// new-placement:
2857 /// '(' expression-list ')'
2858 ///
2859 bool Parser::ParseExpressionListOrTypeId(
2860  SmallVectorImpl<Expr*> &PlacementArgs,
2861  Declarator &D) {
2862  // The '(' was already consumed.
2863  if (isTypeIdInParens()) {
2864  ParseSpecifierQualifierList(D.getMutableDeclSpec());
2866  ParseDeclarator(D);
2867  return D.isInvalidType();
2868  }
2869 
2870  // It's not a type, it has to be an expression list.
2871  // Discard the comma locations - ActOnCXXNew has enough parameters.
2872  CommaLocsTy CommaLocs;
2873  return ParseExpressionList(PlacementArgs, CommaLocs);
2874 }
2875 
2876 /// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
2877 /// to free memory allocated by new.
2878 ///
2879 /// This method is called to parse the 'delete' expression after the optional
2880 /// '::' has been already parsed. If the '::' was present, "UseGlobal" is true
2881 /// and "Start" is its location. Otherwise, "Start" is the location of the
2882 /// 'delete' token.
2883 ///
2884 /// delete-expression:
2885 /// '::'[opt] 'delete' cast-expression
2886 /// '::'[opt] 'delete' '[' ']' cast-expression
2887 ExprResult
2888 Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
2889  assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword");
2890  ConsumeToken(); // Consume 'delete'
2891 
2892  // Array delete?
2893  bool ArrayDelete = false;
2894  if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
2895  // C++11 [expr.delete]p1:
2896  // Whenever the delete keyword is followed by empty square brackets, it
2897  // shall be interpreted as [array delete].
2898  // [Footnote: A lambda expression with a lambda-introducer that consists
2899  // of empty square brackets can follow the delete keyword if
2900  // the lambda expression is enclosed in parentheses.]
2901  // FIXME: Produce a better diagnostic if the '[]' is unambiguously a
2902  // lambda-introducer.
2903  ArrayDelete = true;
2904  BalancedDelimiterTracker T(*this, tok::l_square);
2905 
2906  T.consumeOpen();
2907  T.consumeClose();
2908  if (T.getCloseLocation().isInvalid())
2909  return ExprError();
2910  }
2911 
2912  ExprResult Operand(ParseCastExpression(false));
2913  if (Operand.isInvalid())
2914  return Operand;
2915 
2916  return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.get());
2917 }
2918 
2920  switch (kind) {
2921  default: llvm_unreachable("Not a known type trait");
2922 #define TYPE_TRAIT_1(Spelling, Name, Key) \
2923 case tok::kw_ ## Spelling: return UTT_ ## Name;
2924 #define TYPE_TRAIT_2(Spelling, Name, Key) \
2925 case tok::kw_ ## Spelling: return BTT_ ## Name;
2926 #include "clang/Basic/TokenKinds.def"
2927 #define TYPE_TRAIT_N(Spelling, Name, Key) \
2928  case tok::kw_ ## Spelling: return TT_ ## Name;
2929 #include "clang/Basic/TokenKinds.def"
2930  }
2931 }
2932 
2934  switch(kind) {
2935  default: llvm_unreachable("Not a known binary type trait");
2936  case tok::kw___array_rank: return ATT_ArrayRank;
2937  case tok::kw___array_extent: return ATT_ArrayExtent;
2938  }
2939 }
2940 
2942  switch(kind) {
2943  default: llvm_unreachable("Not a known unary expression trait.");
2944  case tok::kw___is_lvalue_expr: return ET_IsLValueExpr;
2945  case tok::kw___is_rvalue_expr: return ET_IsRValueExpr;
2946  }
2947 }
2948 
2950  switch (kind) {
2951  default: llvm_unreachable("Not a known type trait");
2952 #define TYPE_TRAIT(N,Spelling,K) case tok::kw_##Spelling: return N;
2953 #include "clang/Basic/TokenKinds.def"
2954  }
2955 }
2956 
2957 /// \brief Parse the built-in type-trait pseudo-functions that allow
2958 /// implementation of the TR1/C++11 type traits templates.
2959 ///
2960 /// primary-expression:
2961 /// unary-type-trait '(' type-id ')'
2962 /// binary-type-trait '(' type-id ',' type-id ')'
2963 /// type-trait '(' type-id-seq ')'
2964 ///
2965 /// type-id-seq:
2966 /// type-id ...[opt] type-id-seq[opt]
2967 ///
2968 ExprResult Parser::ParseTypeTrait() {
2969  tok::TokenKind Kind = Tok.getKind();
2970  unsigned Arity = TypeTraitArity(Kind);
2971 
2972  SourceLocation Loc = ConsumeToken();
2973 
2974  BalancedDelimiterTracker Parens(*this, tok::l_paren);
2975  if (Parens.expectAndConsume())
2976  return ExprError();
2977 
2979  do {
2980  // Parse the next type.
2981  TypeResult Ty = ParseTypeName();
2982  if (Ty.isInvalid()) {
2983  Parens.skipToEnd();
2984  return ExprError();
2985  }
2986 
2987  // Parse the ellipsis, if present.
2988  if (Tok.is(tok::ellipsis)) {
2989  Ty = Actions.ActOnPackExpansion(Ty.get(), ConsumeToken());
2990  if (Ty.isInvalid()) {
2991  Parens.skipToEnd();
2992  return ExprError();
2993  }
2994  }
2995 
2996  // Add this type to the list of arguments.
2997  Args.push_back(Ty.get());
2998  } while (TryConsumeToken(tok::comma));
2999 
3000  if (Parens.consumeClose())
3001  return ExprError();
3002 
3003  SourceLocation EndLoc = Parens.getCloseLocation();
3004 
3005  if (Arity && Args.size() != Arity) {
3006  Diag(EndLoc, diag::err_type_trait_arity)
3007  << Arity << 0 << (Arity > 1) << (int)Args.size() << SourceRange(Loc);
3008  return ExprError();
3009  }
3010 
3011  if (!Arity && Args.empty()) {
3012  Diag(EndLoc, diag::err_type_trait_arity)
3013  << 1 << 1 << 1 << (int)Args.size() << SourceRange(Loc);
3014  return ExprError();
3015  }
3016 
3017  return Actions.ActOnTypeTrait(TypeTraitFromTokKind(Kind), Loc, Args, EndLoc);
3018 }
3019 
3020 /// ParseArrayTypeTrait - Parse the built-in array type-trait
3021 /// pseudo-functions.
3022 ///
3023 /// primary-expression:
3024 /// [Embarcadero] '__array_rank' '(' type-id ')'
3025 /// [Embarcadero] '__array_extent' '(' type-id ',' expression ')'
3026 ///
3027 ExprResult Parser::ParseArrayTypeTrait() {
3029  SourceLocation Loc = ConsumeToken();
3030 
3031  BalancedDelimiterTracker T(*this, tok::l_paren);
3032  if (T.expectAndConsume())
3033  return ExprError();
3034 
3035  TypeResult Ty = ParseTypeName();
3036  if (Ty.isInvalid()) {
3037  SkipUntil(tok::comma, StopAtSemi);
3038  SkipUntil(tok::r_paren, StopAtSemi);
3039  return ExprError();
3040  }
3041 
3042  switch (ATT) {
3043  case ATT_ArrayRank: {
3044  T.consumeClose();
3045  return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), nullptr,
3046  T.getCloseLocation());
3047  }
3048  case ATT_ArrayExtent: {
3049  if (ExpectAndConsume(tok::comma)) {
3050  SkipUntil(tok::r_paren, StopAtSemi);
3051  return ExprError();
3052  }
3053 
3054  ExprResult DimExpr = ParseExpression();
3055  T.consumeClose();
3056 
3057  return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), DimExpr.get(),
3058  T.getCloseLocation());
3059  }
3060  }
3061  llvm_unreachable("Invalid ArrayTypeTrait!");
3062 }
3063 
3064 /// ParseExpressionTrait - Parse built-in expression-trait
3065 /// pseudo-functions like __is_lvalue_expr( xxx ).
3066 ///
3067 /// primary-expression:
3068 /// [Embarcadero] expression-trait '(' expression ')'
3069 ///
3070 ExprResult Parser::ParseExpressionTrait() {
3072  SourceLocation Loc = ConsumeToken();
3073 
3074  BalancedDelimiterTracker T(*this, tok::l_paren);
3075  if (T.expectAndConsume())
3076  return ExprError();
3077 
3079 
3080  T.consumeClose();
3081 
3082  return Actions.ActOnExpressionTrait(ET, Loc, Expr.get(),
3083  T.getCloseLocation());
3084 }
3085 
3086 
3087 /// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
3088 /// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
3089 /// based on the context past the parens.
3090 ExprResult
3091 Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
3092  ParsedType &CastTy,
3093  BalancedDelimiterTracker &Tracker,
3094  ColonProtectionRAIIObject &ColonProt) {
3095  assert(getLangOpts().CPlusPlus && "Should only be called for C++!");
3096  assert(ExprType == CastExpr && "Compound literals are not ambiguous!");
3097  assert(isTypeIdInParens() && "Not a type-id!");
3098 
3099  ExprResult Result(true);
3100  CastTy = nullptr;
3101 
3102  // We need to disambiguate a very ugly part of the C++ syntax:
3103  //
3104  // (T())x; - type-id
3105  // (T())*x; - type-id
3106  // (T())/x; - expression
3107  // (T()); - expression
3108  //
3109  // The bad news is that we cannot use the specialized tentative parser, since
3110  // it can only verify that the thing inside the parens can be parsed as
3111  // type-id, it is not useful for determining the context past the parens.
3112  //
3113  // The good news is that the parser can disambiguate this part without
3114  // making any unnecessary Action calls.
3115  //
3116  // It uses a scheme similar to parsing inline methods. The parenthesized
3117  // tokens are cached, the context that follows is determined (possibly by
3118  // parsing a cast-expression), and then we re-introduce the cached tokens
3119  // into the token stream and parse them appropriately.
3120 
3121  ParenParseOption ParseAs;
3122  CachedTokens Toks;
3123 
3124  // Store the tokens of the parentheses. We will parse them after we determine
3125  // the context that follows them.
3126  if (!ConsumeAndStoreUntil(tok::r_paren, Toks)) {
3127  // We didn't find the ')' we expected.
3128  Tracker.consumeClose();
3129  return ExprError();
3130  }
3131 
3132  if (Tok.is(tok::l_brace)) {
3133  ParseAs = CompoundLiteral;
3134  } else {
3135  bool NotCastExpr;
3136  if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) {
3137  NotCastExpr = true;
3138  } else {
3139  // Try parsing the cast-expression that may follow.
3140  // If it is not a cast-expression, NotCastExpr will be true and no token
3141  // will be consumed.
3142  ColonProt.restore();
3143  Result = ParseCastExpression(false/*isUnaryExpression*/,
3144  false/*isAddressofOperand*/,
3145  NotCastExpr,
3146  // type-id has priority.
3147  IsTypeCast);
3148  }
3149 
3150  // If we parsed a cast-expression, it's really a type-id, otherwise it's
3151  // an expression.
3152  ParseAs = NotCastExpr ? SimpleExpr : CastExpr;
3153  }
3154 
3155  // Create a fake EOF to mark end of Toks buffer.
3156  Token AttrEnd;
3157  AttrEnd.startToken();
3158  AttrEnd.setKind(tok::eof);
3159  AttrEnd.setLocation(Tok.getLocation());
3160  AttrEnd.setEofData(Toks.data());
3161  Toks.push_back(AttrEnd);
3162 
3163  // The current token should go after the cached tokens.
3164  Toks.push_back(Tok);
3165  // Re-enter the stored parenthesized tokens into the token stream, so we may
3166  // parse them now.
3167  PP.EnterTokenStream(Toks, true /*DisableMacroExpansion*/);
3168  // Drop the current token and bring the first cached one. It's the same token
3169  // as when we entered this function.
3170  ConsumeAnyToken();
3171 
3172  if (ParseAs >= CompoundLiteral) {
3173  // Parse the type declarator.
3174  DeclSpec DS(AttrFactory);
3175  Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
3176  {
3177  ColonProtectionRAIIObject InnerColonProtection(*this);
3178  ParseSpecifierQualifierList(DS);
3179  ParseDeclarator(DeclaratorInfo);
3180  }
3181 
3182  // Match the ')'.
3183  Tracker.consumeClose();
3184  ColonProt.restore();
3185 
3186  // Consume EOF marker for Toks buffer.
3187  assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData());
3188  ConsumeAnyToken();
3189 
3190  if (ParseAs == CompoundLiteral) {
3191  ExprType = CompoundLiteral;
3192  if (DeclaratorInfo.isInvalidType())
3193  return ExprError();
3194 
3195  TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
3196  return ParseCompoundLiteralExpression(Ty.get(),
3197  Tracker.getOpenLocation(),
3198  Tracker.getCloseLocation());
3199  }
3200 
3201  // We parsed '(' type-id ')' and the thing after it wasn't a '{'.
3202  assert(ParseAs == CastExpr);
3203 
3204  if (DeclaratorInfo.isInvalidType())
3205  return ExprError();
3206 
3207  // Result is what ParseCastExpression returned earlier.
3208  if (!Result.isInvalid())
3209  Result = Actions.ActOnCastExpr(getCurScope(), Tracker.getOpenLocation(),
3210  DeclaratorInfo, CastTy,
3211  Tracker.getCloseLocation(), Result.get());
3212  return Result;
3213  }
3214 
3215  // Not a compound literal, and not followed by a cast-expression.
3216  assert(ParseAs == SimpleExpr);
3217 
3218  ExprType = SimpleExpr;
3219  Result = ParseExpression();
3220  if (!Result.isInvalid() && Tok.is(tok::r_paren))
3221  Result = Actions.ActOnParenExpr(Tracker.getOpenLocation(),
3222  Tok.getLocation(), Result.get());
3223 
3224  // Match the ')'.
3225  if (Result.isInvalid()) {
3226  while (Tok.isNot(tok::eof))
3227  ConsumeAnyToken();
3228  assert(Tok.getEofData() == AttrEnd.getEofData());
3229  ConsumeAnyToken();
3230  return ExprError();
3231  }
3232 
3233  Tracker.consumeClose();
3234  // Consume EOF marker for Toks buffer.
3235  assert(Tok.is(tok::eof) && Tok.getEofData() == AttrEnd.getEofData());
3236  ConsumeAnyToken();
3237  return Result;
3238 }
static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind)
Defines the clang::ASTContext interface.
void setConstructorName(ParsedType ClassType, SourceLocation ClassNameLoc, SourceLocation EndLoc)
Specify that this unqualified-id was parsed as a constructor name.
Definition: DeclSpec.h:1054
ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, Expr *SubExpr, ConditionKind CK)
Definition: SemaExpr.cpp:15382
ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, ParsedType LhsTy, Expr *DimExpr, SourceLocation RParen)
ActOnArrayTypeTrait - Parsed one of the binary type trait support pseudo-functions.
StringRef getUDSuffix() const
ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc, Declarator &D, ParsedType &Ty, SourceLocation RParenLoc, Expr *CastExpr)
Definition: SemaExpr.cpp:6061
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
no exception specification
PtrTy get() const
Definition: Ownership.h:74
ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)
Simple precedence-based parser for binary/ternary operators.
Definition: ParseExpr.cpp:123
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:5292
This is a scope that corresponds to the parameters within a function prototype.
Definition: Scope.h:80
ConditionResult ActOnConditionVariable(Decl *ConditionVar, SourceLocation StmtLoc, ConditionKind CK)
bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id)
AttributeList * getNext() const
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
Definition: DeclSpec.h:1106
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 &#39;identifier::&#39;.
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
Definition: DeclSpec.h:965
IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
static const TST TST_wchar
Definition: DeclSpec.h:275
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
Definition: SemaExpr.cpp:6234
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
static ConditionResult ConditionError()
Definition: Sema.h:9738
const Token & LookAhead(unsigned N)
Peeks ahead N tokens and returns that token without consuming any tokens.
Stmt - This represents one statement.
Definition: Stmt.h:66
IdentifierInfo * Identifier
When Kind == IK_Identifier, the parsed identifier, or when Kind == IK_UserLiteralId, the identifier suffix.
Definition: DeclSpec.h:935
StmtResult ActOnExprStmt(ExprResult Arg)
Definition: SemaStmt.cpp:44
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
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
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:86
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:958
Defines the C++ template declaration subclasses.
StringRef P
The base class of the type hierarchy.
Definition: Type.h:1353
SourceLocation getCloseLocation() const
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.
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. ...
void CodeCompleteObjCMessageReceiver(Scope *S)
RAII object that enters a new expression evaluation context.
Definition: Sema.h:10632
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:1720
static const TST TST_char
Definition: DeclSpec.h:274
Like System, but searched after the system directories.
void setBegin(SourceLocation b)
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:274
ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed...
AttributeList * getList() const
bool isUnset() const
Definition: Ownership.h:160
tok::TokenKind getKind() const
Definition: Token.h:90
bool SkipUntil(tok::TokenKind T, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
SkipUntil - Read tokens until we get to the specified token, then consume it (unless StopBeforeMatch ...
Definition: Parser.h:945
Information about a template-id annotation token.
void CodeCompleteOrdinaryName(Scope *S, ParserCompletionContext CompletionContext)
const Token & NextToken()
NextToken - This peeks ahead one token and returns it without consuming it.
Definition: Parser.h:613
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:324
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
SourceLocation getAnnotationEndLoc() const
Definition: Token.h:138
sema::LambdaScopeInfo * getCurGenericLambda()
Retrieve the current generic lambda info, if any.
Definition: Sema.cpp:1452
IdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:988
ExprResult ExprEmpty()
Definition: Ownership.h:273
void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &attrs, SourceLocation EndLoc)
AddTypeInfo - Add a chunk to this declarator.
Definition: DeclSpec.h:2122
void setConversionFunctionId(SourceLocation OperatorLoc, ParsedType Ty, SourceLocation EndLoc)
Specify that this unqualified-id was parsed as a conversion-function-id.
Definition: DeclSpec.h:1022
void CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc, ArrayRef< Expr *> Args)
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:918
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:939
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:83
void SetSourceRange(SourceRange R)
Definition: DeclSpec.h:1875
bool isInvalidType() const
Definition: DeclSpec.h:2404
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:951
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:886
static ParsedType getTypeAnnotation(const Token &Tok)
getTypeAnnotation - Read a parsed type out of an annotation token.
Definition: Parser.h:618
PtrTy get() const
Definition: Ownership.h:162
< 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:10571
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...
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:635
SourceRange getAnnotationRange() const
SourceRange of the group of tokens that this annotation token represents.
Definition: Token.h:158
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:2710
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID. ...
ArrayTypeTrait
Names for the array type traits.
Definition: TypeTraits.h:90
SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok=false)
ConsumeAnyToken - Dispatch to the right Consume* method based on the current token type...
Definition: Parser.h:344
void setTemplateId(TemplateIdAnnotation *TemplateId)
Specify that this unqualified-id was parsed as a template-id.
Definition: DeclSpec.cpp:31
LambdaCaptureInitKind
Definition: DeclSpec.h:2500
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:713
SourceRange getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:500
const char * getName() const
Definition: Token.h:166
bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS, NestedNameSpecInfo &IdInfo)
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 &#39;<&#39; before the template argument list.
DeclSpec & getMutableDeclSpec()
getMutableDeclSpec - Return a non-const version of the DeclSpec.
Definition: DeclSpec.h:1843
static const TSW TSW_long
Definition: DeclSpec.h:255
StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, SourceLocation StartLoc, SourceLocation EndLoc)
Definition: SemaStmt.cpp:72
void SetRangeStart(SourceLocation Loc)
Definition: DeclSpec.h:606
SourceRange getRange() const
Definition: DeclSpec.h:68
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:2529
TST getTypeSpecType() const
Definition: DeclSpec.h:477
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:106
bool ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc, CXXScopeSpec &SS)
The parser has parsed a global nested-name-specifier &#39;::&#39;.
void setDeductionGuideName(ParsedTemplateTy Template, SourceLocation TemplateLoc)
Specify that this unqualified-id was parsed as a template-name for a deduction-guide.
Definition: DeclSpec.h:1098
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
int Id
Definition: ASTDiff.cpp:191
void AnnotateCachedTokens(const Token &Tok)
We notify the Preprocessor that if it is caching tokens (because backtrack is enabled) it should repl...
const FunctionProtoType * T
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:5600
OpaquePtr< T > get() const
Definition: Ownership.h:98
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)
const Token & getCurToken() const
Definition: Parser.h:277
OpaquePtr< TemplateName > TemplateTy
Definition: Parser.h:288
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Definition: Token.h:124
void setAsmLabel(Expr *E)
Definition: DeclSpec.h:2391
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:72
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
This is a compound statement scope.
Definition: Scope.h:129
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
TemplateNameKind
Specifies the kind of template name that an identifier refers to.
Definition: TemplateKinds.h:21
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:1039
static const TST TST_int
Definition: DeclSpec.h:278
ConditionKind
Definition: Sema.h:9740
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 isInvalid() const
Definition: Ownership.h:158
SourceLocation getEnd() const
bool SetTypeSpecSign(TSS S, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:653
SourceLocation getOpenLocation() const
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++ &#39;delete&#39; expression.
bool isUsable() const
Definition: Ownership.h:159
sema::LambdaScopeInfo * PushLambdaScope()
Definition: Sema.cpp:1362
The result type of a method or function.
static const TSW TSW_short
Definition: DeclSpec.h:254
StringRef GetString() const
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:1337
bool isValid() const
Determine whether this unqualified-id refers to a valid name.
Definition: DeclSpec.h:982
OpaquePtr< DeclGroupRef > DeclGroupPtrTy
Definition: Parser.h:287
const LangOptions & getLangOpts() const
Definition: Parser.h:271
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:626
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:3488
SourceManager & getSourceManager() const
Definition: Preprocessor.h:819
static const TST TST_char32
Definition: DeclSpec.h:277
unsigned getUDSuffixOffset() const
Get the spelling offset of the first byte of the ud-suffix.
SourceLocation DefaultLoc
Definition: DeclSpec.h:2527
Kind
Stop skipping at semicolon.
Definition: Parser.h:925
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:144
unsigned getUDSuffixToken() const
Get the index of a token containing a ud-suffix.
ASTContext & getASTContext() const
Definition: Sema.h:1200
static const TST TST_float16
Definition: DeclSpec.h:283
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:2535
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:897
void FinalizeDeclaration(Decl *D)
FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...
Definition: SemaDecl.cpp:11157
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...
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:177
void setAnnotationEndLoc(SourceLocation L)
Definition: Token.h:142
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:823
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&#39;s.
Definition: SemaCast.cpp:217
void CodeCompleteOperatorName(Scope *S)
void Lex(Token &Result)
Lex the next token for this preprocessor.
const void * getEofData() const
Definition: Token.h:190
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
Scope * getCurScope() const
Definition: Parser.h:278
static DeclaratorChunk getArray(unsigned TypeQuals, bool isStatic, bool isStar, Expr *NumElts, SourceLocation LBLoc, SourceLocation RBLoc)
Return a DeclaratorChunk for an array.
Definition: DeclSpec.h:1552
ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, Declarator &D, Expr *Initializer)
ActOnCXXNew - Parsed a C++ &#39;new&#39; expression.
MutableArrayRef< Expr * > MultiExprArg
Definition: Ownership.h:261
static void FixDigraph(Parser &P, Preprocessor &PP, Token &DigraphToken, Token &ColonToken, tok::TokenKind Kind, bool AtDigraph)
StringRef getName() const
Return the actual identifier string.
SourceRange getSourceRange() const LLVM_READONLY
Get the source range that spans this declarator.
Definition: DeclSpec.h:1871
bool isNot(tok::TokenKind K) const
Definition: Token.h:96
static const TST TST_decltype_auto
Definition: DeclSpec.h:298
The name does not refer to a template.
Definition: TemplateKinds.h:23
Dataflow Directional Tag Classes.
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...
bool isValid() const
Return true if this is a valid SourceLocation object.
LambdaCaptureDefault Default
Definition: DeclSpec.h:2528
bool expectAndConsume(unsigned DiagID=diag::err_expected, const char *Msg="", tok::TokenKind SkipToTok=tok::unknown)
Definition: Parser.cpp:2218
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 &#39;>&#39; 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:1368
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:116
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition: Token.h:97
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclSpec.h:502
SourceLocation getLastCachedTokenLocation() const
Get the location of the last cached token, suitable for setting the end location of an annotation tok...
bool ActOnSuperScopeSpecifier(SourceLocation SuperLoc, SourceLocation ColonColonLoc, CXXScopeSpec &SS)
The parser has parsed a &#39;__super&#39; nested-name-specifier.
unsigned getLength() const
Definition: Token.h:127
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
Definition: SemaDecl.cpp:10158
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
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:825
QualType getCanonicalTypeInternal() const
Definition: Type.h:2109
void takeAttributesFrom(ParsedAttributes &attrs)
Definition: DeclSpec.h:741
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:1281
static const TST TST_typename
Definition: DeclSpec.h:294
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:252
void SetRangeEnd(SourceLocation Loc)
SetRangeEnd - Set the end of the source range to Loc, unless it&#39;s invalid.
Definition: DeclSpec.h:1883
ExprResult ParseAssignmentExpression(TypeCastState isTypeCast=NotTypeCast)
Parse an expr that doesn&#39;t include (top-level) commas.
Definition: ParseExpr.cpp:160
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
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:742
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:2017
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
ExprResult ParseConstantExpression(TypeCastState isTypeCast=NotTypeCast)
Definition: ParseExpr.cpp:210
void setInvalidType(bool Val=true)
Definition: DeclSpec.h:2403
An integral condition for a &#39;switch&#39; 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 &#39;peek token&#39; and lex the next one.
Definition: Parser.h:316
static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind)
A user-defined literal name, e.g., operator "" _i.
Definition: DeclSpec.h:901
static int SelectDigraphErrorMessage(tok::TokenKind Kind)
bool isNotEmpty() const
A scope specifier is present, but may be valid or invalid.
Definition: DeclSpec.h:191
Capturing by reference.
Definition: Lambda.h:38
static const TST TST_float128
Definition: DeclSpec.h:284
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1836
static const TST TST_bool
Definition: DeclSpec.h:285
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:61
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:992
Represents a complete lambda introducer.
Definition: DeclSpec.h:2508
ExprResult ExprError()
Definition: Ownership.h:267
static const TSW TSW_longlong
Definition: DeclSpec.h:256
Code completion occurs within the condition of an if, while, switch, or for statement.
Definition: Sema.h:10129
static unsigned TypeTraitArity(tok::TokenKind kind)
void setLocation(SourceLocation L)
Definition: Token.h:132
A trivial tuple used to represent a source range.
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Specify that this unqualified-id was parsed as an identifier.
Definition: DeclSpec.h:995
bool SetTypeSpecError()
Definition: DeclSpec.cpp:823
unsigned NumArgs
NumArgs - The number of template arguments.
void * getAnnotationValue() const
Definition: Token.h:224
void setDestructorName(SourceLocation TildeLoc, ParsedType ClassType, SourceLocation EndLoc)
Specify that this unqualified-id was parsed as a destructor name.
Definition: DeclSpec.h:1077
SourceLocation getLocEnd() const LLVM_READONLY
Definition: DeclSpec.h:1873
void SetRangeEnd(SourceLocation Loc)
Definition: DeclSpec.h:607
SourceLocation getBegin() const
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
SourceLocation getLocation() const
Definition: DeclBase.h:416
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:5488
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:127
Stop skipping at specified token, but don&#39;t skip the token itself.
Definition: Parser.h:927