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