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