clang  3.7.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;
595  UnqualifiedId Name;
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.
844  SourceLocation Loc;
845  IdentifierInfo *Id = nullptr;
846  SourceLocation EllipsisLoc;
847  ExprResult Init;
848 
849  if (Tok.is(tok::kw_this)) {
850  Kind = LCK_This;
851  Loc = ConsumeToken();
852  } else {
853  if (Tok.is(tok::amp)) {
854  Kind = LCK_ByRef;
855  ConsumeToken();
856 
857  if (Tok.is(tok::code_completion)) {
858  Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
859  /*AfterAmpersand=*/true);
860  cutOffParsing();
861  break;
862  }
863  }
864 
865  if (Tok.is(tok::identifier)) {
866  Id = Tok.getIdentifierInfo();
867  Loc = ConsumeToken();
868  } else if (Tok.is(tok::kw_this)) {
869  // FIXME: If we want to suggest a fixit here, will need to return more
870  // than just DiagnosticID. Perhaps full DiagnosticBuilder that can be
871  // Clear()ed to prevent emission in case of tentative parsing?
872  return DiagResult(diag::err_this_captured_by_reference);
873  } else {
874  return DiagResult(diag::err_expected_capture);
875  }
876 
877  if (Tok.is(tok::l_paren)) {
878  BalancedDelimiterTracker Parens(*this, tok::l_paren);
879  Parens.consumeOpen();
880 
881  ExprVector Exprs;
882  CommaLocsTy Commas;
883  if (SkippedInits) {
884  Parens.skipToEnd();
885  *SkippedInits = true;
886  } else if (ParseExpressionList(Exprs, Commas)) {
887  Parens.skipToEnd();
888  Init = ExprError();
889  } else {
890  Parens.consumeClose();
891  Init = Actions.ActOnParenListExpr(Parens.getOpenLocation(),
892  Parens.getCloseLocation(),
893  Exprs);
894  }
895  } else if (Tok.isOneOf(tok::l_brace, tok::equal)) {
896  // Each lambda init-capture forms its own full expression, which clears
897  // Actions.MaybeODRUseExprs. So create an expression evaluation context
898  // to save the necessary state, and restore it later.
901  bool HadEquals = TryConsumeToken(tok::equal);
902 
903  if (!SkippedInits) {
904  // Warn on constructs that will change meaning when we implement N3922
905  if (!HadEquals && Tok.is(tok::l_brace)) {
906  Diag(Tok, diag::warn_init_capture_direct_list_init)
908  }
909  Init = ParseInitializer();
910  } else if (Tok.is(tok::l_brace)) {
911  BalancedDelimiterTracker Braces(*this, tok::l_brace);
912  Braces.consumeOpen();
913  Braces.skipToEnd();
914  *SkippedInits = true;
915  } else {
916  // We're disambiguating this:
917  //
918  // [..., x = expr
919  //
920  // We need to find the end of the following expression in order to
921  // determine whether this is an Obj-C message send's receiver, a
922  // C99 designator, or a lambda init-capture.
923  //
924  // Parse the expression to find where it ends, and annotate it back
925  // onto the tokens. We would have parsed this expression the same way
926  // in either case: both the RHS of an init-capture and the RHS of an
927  // assignment expression are parsed as an initializer-clause, and in
928  // neither case can anything be added to the scope between the '[' and
929  // here.
930  //
931  // FIXME: This is horrible. Adding a mechanism to skip an expression
932  // would be much cleaner.
933  // FIXME: If there is a ',' before the next ']' or ':', we can skip to
934  // that instead. (And if we see a ':' with no matching '?', we can
935  // classify this as an Obj-C message send.)
936  SourceLocation StartLoc = Tok.getLocation();
937  InMessageExpressionRAIIObject MaybeInMessageExpression(*this, true);
938  Init = ParseInitializer();
939 
940  if (Tok.getLocation() != StartLoc) {
941  // Back out the lexing of the token after the initializer.
942  PP.RevertCachedTokens(1);
943 
944  // Replace the consumed tokens with an appropriate annotation.
945  Tok.setLocation(StartLoc);
946  Tok.setKind(tok::annot_primary_expr);
947  setExprAnnotation(Tok, Init);
949  PP.AnnotateCachedTokens(Tok);
950 
951  // Consume the annotated initializer.
952  ConsumeToken();
953  }
954  }
955  } else
956  TryConsumeToken(tok::ellipsis, EllipsisLoc);
957  }
958  // If this is an init capture, process the initialization expression
959  // right away. For lambda init-captures such as the following:
960  // const int x = 10;
961  // auto L = [i = x+1](int a) {
962  // return [j = x+2,
963  // &k = x](char b) { };
964  // };
965  // keep in mind that each lambda init-capture has to have:
966  // - its initialization expression executed in the context
967  // of the enclosing/parent decl-context.
968  // - but the variable itself has to be 'injected' into the
969  // decl-context of its lambda's call-operator (which has
970  // not yet been created).
971  // Each init-expression is a full-expression that has to get
972  // Sema-analyzed (for capturing etc.) before its lambda's
973  // call-operator's decl-context, scope & scopeinfo are pushed on their
974  // respective stacks. Thus if any variable is odr-used in the init-capture
975  // it will correctly get captured in the enclosing lambda, if one exists.
976  // The init-variables above are created later once the lambdascope and
977  // call-operators decl-context is pushed onto its respective stack.
978 
979  // Since the lambda init-capture's initializer expression occurs in the
980  // context of the enclosing function or lambda, therefore we can not wait
981  // till a lambda scope has been pushed on before deciding whether the
982  // variable needs to be captured. We also need to process all
983  // lvalue-to-rvalue conversions and discarded-value conversions,
984  // so that we can avoid capturing certain constant variables.
985  // For e.g.,
986  // void test() {
987  // const int x = 10;
988  // auto L = [&z = x](char a) { <-- don't capture by the current lambda
989  // return [y = x](int i) { <-- don't capture by enclosing lambda
990  // return y;
991  // }
992  // };
993  // If x was not const, the second use would require 'L' to capture, and
994  // that would be an error.
995 
996  ParsedType InitCaptureParsedType;
997  if (Init.isUsable()) {
998  // Get the pointer and store it in an lvalue, so we can use it as an
999  // out argument.
1000  Expr *InitExpr = Init.get();
1001  // This performs any lvalue-to-rvalue conversions if necessary, which
1002  // can affect what gets captured in the containing decl-context.
1003  QualType InitCaptureType = Actions.performLambdaInitCaptureInitialization(
1004  Loc, Kind == LCK_ByRef, Id, InitExpr);
1005  Init = InitExpr;
1006  InitCaptureParsedType.set(InitCaptureType);
1007  }
1008  Intro.addCapture(Kind, Loc, Id, EllipsisLoc, Init, InitCaptureParsedType);
1009  }
1010 
1011  T.consumeClose();
1012  Intro.Range.setEnd(T.getCloseLocation());
1013  return DiagResult();
1014 }
1015 
1016 /// TryParseLambdaIntroducer - Tentatively parse a lambda introducer.
1017 ///
1018 /// Returns true if it hit something unexpected.
1019 bool Parser::TryParseLambdaIntroducer(LambdaIntroducer &Intro) {
1020  TentativeParsingAction PA(*this);
1021 
1022  bool SkippedInits = false;
1023  Optional<unsigned> DiagID(ParseLambdaIntroducer(Intro, &SkippedInits));
1024 
1025  if (DiagID) {
1026  PA.Revert();
1027  return true;
1028  }
1029 
1030  if (SkippedInits) {
1031  // Parse it again, but this time parse the init-captures too.
1032  PA.Revert();
1033  Intro = LambdaIntroducer();
1034  DiagID = ParseLambdaIntroducer(Intro);
1035  assert(!DiagID && "parsing lambda-introducer failed on reparse");
1036  return false;
1037  }
1038 
1039  PA.Commit();
1040  return false;
1041 }
1042 
1043 /// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
1044 /// expression.
1045 ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
1046  LambdaIntroducer &Intro) {
1047  SourceLocation LambdaBeginLoc = Intro.Range.getBegin();
1048  Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);
1049 
1050  PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc,
1051  "lambda expression parsing");
1052 
1053 
1054 
1055  // FIXME: Call into Actions to add any init-capture declarations to the
1056  // scope while parsing the lambda-declarator and compound-statement.
1057 
1058  // Parse lambda-declarator[opt].
1059  DeclSpec DS(AttrFactory);
1061  TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
1062  Actions.PushLambdaScope();
1063 
1064  TypeResult TrailingReturnType;
1065  if (Tok.is(tok::l_paren)) {
1066  ParseScope PrototypeScope(this,
1070 
1071  SourceLocation DeclEndLoc;
1072  BalancedDelimiterTracker T(*this, tok::l_paren);
1073  T.consumeOpen();
1074  SourceLocation LParenLoc = T.getOpenLocation();
1075 
1076  // Parse parameter-declaration-clause.
1077  ParsedAttributes Attr(AttrFactory);
1079  SourceLocation EllipsisLoc;
1080 
1081  if (Tok.isNot(tok::r_paren)) {
1082  Actions.RecordParsingTemplateParameterDepth(TemplateParameterDepth);
1083  ParseParameterDeclarationClause(D, Attr, ParamInfo, EllipsisLoc);
1084  // For a generic lambda, each 'auto' within the parameter declaration
1085  // clause creates a template type parameter, so increment the depth.
1086  if (Actions.getCurGenericLambda())
1087  ++CurTemplateDepthTracker;
1088  }
1089  T.consumeClose();
1090  SourceLocation RParenLoc = T.getCloseLocation();
1091  DeclEndLoc = RParenLoc;
1092 
1093  // GNU-style attributes must be parsed before the mutable specifier to be
1094  // compatible with GCC.
1095  MaybeParseGNUAttributes(Attr, &DeclEndLoc);
1096 
1097  // MSVC-style attributes must be parsed before the mutable specifier to be
1098  // compatible with MSVC.
1099  MaybeParseMicrosoftDeclSpecs(Attr, &DeclEndLoc);
1100 
1101  // Parse 'mutable'[opt].
1102  SourceLocation MutableLoc;
1103  if (TryConsumeToken(tok::kw_mutable, MutableLoc))
1104  DeclEndLoc = MutableLoc;
1105 
1106  // Parse exception-specification[opt].
1108  SourceRange ESpecRange;
1109  SmallVector<ParsedType, 2> DynamicExceptions;
1110  SmallVector<SourceRange, 2> DynamicExceptionRanges;
1111  ExprResult NoexceptExpr;
1112  CachedTokens *ExceptionSpecTokens;
1113  ESpecType = tryParseExceptionSpecification(/*Delayed=*/false,
1114  ESpecRange,
1115  DynamicExceptions,
1116  DynamicExceptionRanges,
1117  NoexceptExpr,
1118  ExceptionSpecTokens);
1119 
1120  if (ESpecType != EST_None)
1121  DeclEndLoc = ESpecRange.getEnd();
1122 
1123  // Parse attribute-specifier[opt].
1124  MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
1125 
1126  SourceLocation FunLocalRangeEnd = DeclEndLoc;
1127 
1128  // Parse trailing-return-type[opt].
1129  if (Tok.is(tok::arrow)) {
1130  FunLocalRangeEnd = Tok.getLocation();
1131  SourceRange Range;
1132  TrailingReturnType = ParseTrailingReturnType(Range);
1133  if (Range.getEnd().isValid())
1134  DeclEndLoc = Range.getEnd();
1135  }
1136 
1137  PrototypeScope.Exit();
1138 
1139  SourceLocation NoLoc;
1140  D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
1141  /*isAmbiguous=*/false,
1142  LParenLoc,
1143  ParamInfo.data(), ParamInfo.size(),
1144  EllipsisLoc, RParenLoc,
1145  DS.getTypeQualifiers(),
1146  /*RefQualifierIsLValueRef=*/true,
1147  /*RefQualifierLoc=*/NoLoc,
1148  /*ConstQualifierLoc=*/NoLoc,
1149  /*VolatileQualifierLoc=*/NoLoc,
1150  /*RestrictQualifierLoc=*/NoLoc,
1151  MutableLoc,
1152  ESpecType, ESpecRange.getBegin(),
1153  DynamicExceptions.data(),
1154  DynamicExceptionRanges.data(),
1155  DynamicExceptions.size(),
1156  NoexceptExpr.isUsable() ?
1157  NoexceptExpr.get() : nullptr,
1158  /*ExceptionSpecTokens*/nullptr,
1159  LParenLoc, FunLocalRangeEnd, D,
1160  TrailingReturnType),
1161  Attr, DeclEndLoc);
1162  } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute) ||
1163  (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) {
1164  // It's common to forget that one needs '()' before 'mutable', an attribute
1165  // specifier, or the result type. Deal with this.
1166  unsigned TokKind = 0;
1167  switch (Tok.getKind()) {
1168  case tok::kw_mutable: TokKind = 0; break;
1169  case tok::arrow: TokKind = 1; break;
1170  case tok::kw___attribute:
1171  case tok::l_square: TokKind = 2; break;
1172  default: llvm_unreachable("Unknown token kind");
1173  }
1174 
1175  Diag(Tok, diag::err_lambda_missing_parens)
1176  << TokKind
1177  << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
1178  SourceLocation DeclLoc = Tok.getLocation();
1179  SourceLocation DeclEndLoc = DeclLoc;
1180 
1181  // GNU-style attributes must be parsed before the mutable specifier to be
1182  // compatible with GCC.
1183  ParsedAttributes Attr(AttrFactory);
1184  MaybeParseGNUAttributes(Attr, &DeclEndLoc);
1185 
1186  // Parse 'mutable', if it's there.
1187  SourceLocation MutableLoc;
1188  if (Tok.is(tok::kw_mutable)) {
1189  MutableLoc = ConsumeToken();
1190  DeclEndLoc = MutableLoc;
1191  }
1192 
1193  // Parse attribute-specifier[opt].
1194  MaybeParseCXX11Attributes(Attr, &DeclEndLoc);
1195 
1196  // Parse the return type, if there is one.
1197  if (Tok.is(tok::arrow)) {
1198  SourceRange Range;
1199  TrailingReturnType = ParseTrailingReturnType(Range);
1200  if (Range.getEnd().isValid())
1201  DeclEndLoc = Range.getEnd();
1202  }
1203 
1204  SourceLocation NoLoc;
1205  D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
1206  /*isAmbiguous=*/false,
1207  /*LParenLoc=*/NoLoc,
1208  /*Params=*/nullptr,
1209  /*NumParams=*/0,
1210  /*EllipsisLoc=*/NoLoc,
1211  /*RParenLoc=*/NoLoc,
1212  /*TypeQuals=*/0,
1213  /*RefQualifierIsLValueRef=*/true,
1214  /*RefQualifierLoc=*/NoLoc,
1215  /*ConstQualifierLoc=*/NoLoc,
1216  /*VolatileQualifierLoc=*/NoLoc,
1217  /*RestrictQualifierLoc=*/NoLoc,
1218  MutableLoc,
1219  EST_None,
1220  /*ESpecLoc=*/NoLoc,
1221  /*Exceptions=*/nullptr,
1222  /*ExceptionRanges=*/nullptr,
1223  /*NumExceptions=*/0,
1224  /*NoexceptExpr=*/nullptr,
1225  /*ExceptionSpecTokens=*/nullptr,
1226  DeclLoc, DeclEndLoc, D,
1227  TrailingReturnType),
1228  Attr, DeclEndLoc);
1229  }
1230 
1231 
1232  // FIXME: Rename BlockScope -> ClosureScope if we decide to continue using
1233  // it.
1234  unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope;
1235  ParseScope BodyScope(this, ScopeFlags);
1236 
1237  Actions.ActOnStartOfLambdaDefinition(Intro, D, getCurScope());
1238 
1239  // Parse compound-statement.
1240  if (!Tok.is(tok::l_brace)) {
1241  Diag(Tok, diag::err_expected_lambda_body);
1242  Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1243  return ExprError();
1244  }
1245 
1246  StmtResult Stmt(ParseCompoundStatementBody());
1247  BodyScope.Exit();
1248 
1249  if (!Stmt.isInvalid() && !TrailingReturnType.isInvalid())
1250  return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.get(), getCurScope());
1251 
1252  Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
1253  return ExprError();
1254 }
1255 
1256 /// ParseCXXCasts - This handles the various ways to cast expressions to another
1257 /// type.
1258 ///
1259 /// postfix-expression: [C++ 5.2p1]
1260 /// 'dynamic_cast' '<' type-name '>' '(' expression ')'
1261 /// 'static_cast' '<' type-name '>' '(' expression ')'
1262 /// 'reinterpret_cast' '<' type-name '>' '(' expression ')'
1263 /// 'const_cast' '<' type-name '>' '(' expression ')'
1264 ///
1265 ExprResult Parser::ParseCXXCasts() {
1266  tok::TokenKind Kind = Tok.getKind();
1267  const char *CastName = nullptr; // For error messages
1268 
1269  switch (Kind) {
1270  default: llvm_unreachable("Unknown C++ cast!");
1271  case tok::kw_const_cast: CastName = "const_cast"; break;
1272  case tok::kw_dynamic_cast: CastName = "dynamic_cast"; break;
1273  case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break;
1274  case tok::kw_static_cast: CastName = "static_cast"; break;
1275  }
1276 
1277  SourceLocation OpLoc = ConsumeToken();
1278  SourceLocation LAngleBracketLoc = Tok.getLocation();
1279 
1280  // Check for "<::" which is parsed as "[:". If found, fix token stream,
1281  // diagnose error, suggest fix, and recover parsing.
1282  if (Tok.is(tok::l_square) && Tok.getLength() == 2) {
1283  Token Next = NextToken();
1284  if (Next.is(tok::colon) && areTokensAdjacent(Tok, Next))
1285  FixDigraph(*this, PP, Tok, Next, Kind, /*AtDigraph*/true);
1286  }
1287 
1288  if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
1289  return ExprError();
1290 
1291  // Parse the common declaration-specifiers piece.
1292  DeclSpec DS(AttrFactory);
1293  ParseSpecifierQualifierList(DS);
1294 
1295  // Parse the abstract-declarator, if present.
1296  Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
1297  ParseDeclarator(DeclaratorInfo);
1298 
1299  SourceLocation RAngleBracketLoc = Tok.getLocation();
1300 
1301  if (ExpectAndConsume(tok::greater))
1302  return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << tok::less);
1303 
1304  SourceLocation LParenLoc, RParenLoc;
1305  BalancedDelimiterTracker T(*this, tok::l_paren);
1306 
1307  if (T.expectAndConsume(diag::err_expected_lparen_after, CastName))
1308  return ExprError();
1309 
1310  ExprResult Result = ParseExpression();
1311 
1312  // Match the ')'.
1313  T.consumeClose();
1314 
1315  if (!Result.isInvalid() && !DeclaratorInfo.isInvalidType())
1316  Result = Actions.ActOnCXXNamedCast(OpLoc, Kind,
1317  LAngleBracketLoc, DeclaratorInfo,
1318  RAngleBracketLoc,
1319  T.getOpenLocation(), Result.get(),
1320  T.getCloseLocation());
1321 
1322  return Result;
1323 }
1324 
1325 /// ParseCXXTypeid - This handles the C++ typeid expression.
1326 ///
1327 /// postfix-expression: [C++ 5.2p1]
1328 /// 'typeid' '(' expression ')'
1329 /// 'typeid' '(' type-id ')'
1330 ///
1331 ExprResult Parser::ParseCXXTypeid() {
1332  assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!");
1333 
1334  SourceLocation OpLoc = ConsumeToken();
1335  SourceLocation LParenLoc, RParenLoc;
1336  BalancedDelimiterTracker T(*this, tok::l_paren);
1337 
1338  // typeid expressions are always parenthesized.
1339  if (T.expectAndConsume(diag::err_expected_lparen_after, "typeid"))
1340  return ExprError();
1341  LParenLoc = T.getOpenLocation();
1342 
1344 
1345  // C++0x [expr.typeid]p3:
1346  // When typeid is applied to an expression other than an lvalue of a
1347  // polymorphic class type [...] The expression is an unevaluated
1348  // operand (Clause 5).
1349  //
1350  // Note that we can't tell whether the expression is an lvalue of a
1351  // polymorphic class type until after we've parsed the expression; we
1352  // speculatively assume the subexpression is unevaluated, and fix it up
1353  // later.
1354  //
1355  // We enter the unevaluated context before trying to determine whether we
1356  // have a type-id, because the tentative parse logic will try to resolve
1357  // names, and must treat them as unevaluated.
1360 
1361  if (isTypeIdInParens()) {
1362  TypeResult Ty = ParseTypeName();
1363 
1364  // Match the ')'.
1365  T.consumeClose();
1366  RParenLoc = T.getCloseLocation();
1367  if (Ty.isInvalid() || RParenLoc.isInvalid())
1368  return ExprError();
1369 
1370  Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true,
1371  Ty.get().getAsOpaquePtr(), RParenLoc);
1372  } else {
1373  Result = ParseExpression();
1374 
1375  // Match the ')'.
1376  if (Result.isInvalid())
1377  SkipUntil(tok::r_paren, StopAtSemi);
1378  else {
1379  T.consumeClose();
1380  RParenLoc = T.getCloseLocation();
1381  if (RParenLoc.isInvalid())
1382  return ExprError();
1383 
1384  Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false,
1385  Result.get(), RParenLoc);
1386  }
1387  }
1388 
1389  return Result;
1390 }
1391 
1392 /// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
1393 ///
1394 /// '__uuidof' '(' expression ')'
1395 /// '__uuidof' '(' type-id ')'
1396 ///
1397 ExprResult Parser::ParseCXXUuidof() {
1398  assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!");
1399 
1400  SourceLocation OpLoc = ConsumeToken();
1401  BalancedDelimiterTracker T(*this, tok::l_paren);
1402 
1403  // __uuidof expressions are always parenthesized.
1404  if (T.expectAndConsume(diag::err_expected_lparen_after, "__uuidof"))
1405  return ExprError();
1406 
1408 
1409  if (isTypeIdInParens()) {
1410  TypeResult Ty = ParseTypeName();
1411 
1412  // Match the ')'.
1413  T.consumeClose();
1414 
1415  if (Ty.isInvalid())
1416  return ExprError();
1417 
1418  Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), /*isType=*/true,
1419  Ty.get().getAsOpaquePtr(),
1420  T.getCloseLocation());
1421  } else {
1423  Result = ParseExpression();
1424 
1425  // Match the ')'.
1426  if (Result.isInvalid())
1427  SkipUntil(tok::r_paren, StopAtSemi);
1428  else {
1429  T.consumeClose();
1430 
1431  Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(),
1432  /*isType=*/false,
1433  Result.get(), T.getCloseLocation());
1434  }
1435  }
1436 
1437  return Result;
1438 }
1439 
1440 /// \brief Parse a C++ pseudo-destructor expression after the base,
1441 /// . or -> operator, and nested-name-specifier have already been
1442 /// parsed.
1443 ///
1444 /// postfix-expression: [C++ 5.2]
1445 /// postfix-expression . pseudo-destructor-name
1446 /// postfix-expression -> pseudo-destructor-name
1447 ///
1448 /// pseudo-destructor-name:
1449 /// ::[opt] nested-name-specifier[opt] type-name :: ~type-name
1450 /// ::[opt] nested-name-specifier template simple-template-id ::
1451 /// ~type-name
1452 /// ::[opt] nested-name-specifier[opt] ~type-name
1453 ///
1454 ExprResult
1455 Parser::ParseCXXPseudoDestructor(Expr *Base, SourceLocation OpLoc,
1456  tok::TokenKind OpKind,
1457  CXXScopeSpec &SS,
1458  ParsedType ObjectType) {
1459  // We're parsing either a pseudo-destructor-name or a dependent
1460  // member access that has the same form as a
1461  // pseudo-destructor-name. We parse both in the same way and let
1462  // the action model sort them out.
1463  //
1464  // Note that the ::[opt] nested-name-specifier[opt] has already
1465  // been parsed, and if there was a simple-template-id, it has
1466  // been coalesced into a template-id annotation token.
1467  UnqualifiedId FirstTypeName;
1468  SourceLocation CCLoc;
1469  if (Tok.is(tok::identifier)) {
1470  FirstTypeName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1471  ConsumeToken();
1472  assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1473  CCLoc = ConsumeToken();
1474  } else if (Tok.is(tok::annot_template_id)) {
1475  // FIXME: retrieve TemplateKWLoc from template-id annotation and
1476  // store it in the pseudo-dtor node (to be used when instantiating it).
1477  FirstTypeName.setTemplateId(
1479  ConsumeToken();
1480  assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1481  CCLoc = ConsumeToken();
1482  } else {
1483  FirstTypeName.setIdentifier(nullptr, SourceLocation());
1484  }
1485 
1486  // Parse the tilde.
1487  assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail");
1488  SourceLocation TildeLoc = ConsumeToken();
1489 
1490  if (Tok.is(tok::kw_decltype) && !FirstTypeName.isValid() && SS.isEmpty()) {
1491  DeclSpec DS(AttrFactory);
1492  ParseDecltypeSpecifier(DS);
1493  if (DS.getTypeSpecType() == TST_error)
1494  return ExprError();
1495  return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1496  TildeLoc, DS);
1497  }
1498 
1499  if (!Tok.is(tok::identifier)) {
1500  Diag(Tok, diag::err_destructor_tilde_identifier);
1501  return ExprError();
1502  }
1503 
1504  // Parse the second type.
1505  UnqualifiedId SecondTypeName;
1506  IdentifierInfo *Name = Tok.getIdentifierInfo();
1507  SourceLocation NameLoc = ConsumeToken();
1508  SecondTypeName.setIdentifier(Name, NameLoc);
1509 
1510  // If there is a '<', the second type name is a template-id. Parse
1511  // it as such.
1512  if (Tok.is(tok::less) &&
1513  ParseUnqualifiedIdTemplateId(SS, SourceLocation(),
1514  Name, NameLoc,
1515  false, ObjectType, SecondTypeName,
1516  /*AssumeTemplateName=*/true))
1517  return ExprError();
1518 
1519  return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc, OpKind,
1520  SS, FirstTypeName, CCLoc, TildeLoc,
1521  SecondTypeName);
1522 }
1523 
1524 /// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
1525 ///
1526 /// boolean-literal: [C++ 2.13.5]
1527 /// 'true'
1528 /// 'false'
1529 ExprResult Parser::ParseCXXBoolLiteral() {
1530  tok::TokenKind Kind = Tok.getKind();
1531  return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
1532 }
1533 
1534 /// ParseThrowExpression - This handles the C++ throw expression.
1535 ///
1536 /// throw-expression: [C++ 15]
1537 /// 'throw' assignment-expression[opt]
1538 ExprResult Parser::ParseThrowExpression() {
1539  assert(Tok.is(tok::kw_throw) && "Not throw!");
1540  SourceLocation ThrowLoc = ConsumeToken(); // Eat the throw token.
1541 
1542  // If the current token isn't the start of an assignment-expression,
1543  // then the expression is not present. This handles things like:
1544  // "C ? throw : (void)42", which is crazy but legal.
1545  switch (Tok.getKind()) { // FIXME: move this predicate somewhere common.
1546  case tok::semi:
1547  case tok::r_paren:
1548  case tok::r_square:
1549  case tok::r_brace:
1550  case tok::colon:
1551  case tok::comma:
1552  return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, nullptr);
1553 
1554  default:
1556  if (Expr.isInvalid()) return Expr;
1557  return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.get());
1558  }
1559 }
1560 
1561 /// ParseCXXThis - This handles the C++ 'this' pointer.
1562 ///
1563 /// C++ 9.3.2: In the body of a non-static member function, the keyword this is
1564 /// a non-lvalue expression whose value is the address of the object for which
1565 /// the function is called.
1566 ExprResult Parser::ParseCXXThis() {
1567  assert(Tok.is(tok::kw_this) && "Not 'this'!");
1568  SourceLocation ThisLoc = ConsumeToken();
1569  return Actions.ActOnCXXThis(ThisLoc);
1570 }
1571 
1572 /// ParseCXXTypeConstructExpression - Parse construction of a specified type.
1573 /// Can be interpreted either as function-style casting ("int(x)")
1574 /// or class type construction ("ClassType(x,y,z)")
1575 /// or creation of a value-initialized type ("int()").
1576 /// See [C++ 5.2.3].
1577 ///
1578 /// postfix-expression: [C++ 5.2p1]
1579 /// simple-type-specifier '(' expression-list[opt] ')'
1580 /// [C++0x] simple-type-specifier braced-init-list
1581 /// typename-specifier '(' expression-list[opt] ')'
1582 /// [C++0x] typename-specifier braced-init-list
1583 ///
1584 ExprResult
1585 Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
1586  Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
1587  ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
1588 
1589  assert((Tok.is(tok::l_paren) ||
1590  (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)))
1591  && "Expected '(' or '{'!");
1592 
1593  if (Tok.is(tok::l_brace)) {
1594  ExprResult Init = ParseBraceInitializer();
1595  if (Init.isInvalid())
1596  return Init;
1597  Expr *InitList = Init.get();
1598  return Actions.ActOnCXXTypeConstructExpr(TypeRep, SourceLocation(),
1599  MultiExprArg(&InitList, 1),
1600  SourceLocation());
1601  } else {
1602  BalancedDelimiterTracker T(*this, tok::l_paren);
1603  T.consumeOpen();
1604 
1605  ExprVector Exprs;
1606  CommaLocsTy CommaLocs;
1607 
1608  if (Tok.isNot(tok::r_paren)) {
1609  if (ParseExpressionList(Exprs, CommaLocs, [&] {
1611  TypeRep.get()->getCanonicalTypeInternal(),
1612  DS.getLocEnd(), Exprs);
1613  })) {
1614  SkipUntil(tok::r_paren, StopAtSemi);
1615  return ExprError();
1616  }
1617  }
1618 
1619  // Match the ')'.
1620  T.consumeClose();
1621 
1622  // TypeRep could be null, if it references an invalid typedef.
1623  if (!TypeRep)
1624  return ExprError();
1625 
1626  assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&
1627  "Unexpected number of commas!");
1628  return Actions.ActOnCXXTypeConstructExpr(TypeRep, T.getOpenLocation(),
1629  Exprs,
1630  T.getCloseLocation());
1631  }
1632 }
1633 
1634 /// ParseCXXCondition - if/switch/while condition expression.
1635 ///
1636 /// condition:
1637 /// expression
1638 /// type-specifier-seq declarator '=' assignment-expression
1639 /// [C++11] type-specifier-seq declarator '=' initializer-clause
1640 /// [C++11] type-specifier-seq declarator braced-init-list
1641 /// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
1642 /// '=' assignment-expression
1643 ///
1644 /// \param ExprOut if the condition was parsed as an expression, the parsed
1645 /// expression.
1646 ///
1647 /// \param DeclOut if the condition was parsed as a declaration, the parsed
1648 /// declaration.
1649 ///
1650 /// \param Loc The location of the start of the statement that requires this
1651 /// condition, e.g., the "for" in a for loop.
1652 ///
1653 /// \param ConvertToBoolean Whether the condition expression should be
1654 /// converted to a boolean value.
1655 ///
1656 /// \returns true if there was a parsing, false otherwise.
1657 bool Parser::ParseCXXCondition(ExprResult &ExprOut,
1658  Decl *&DeclOut,
1659  SourceLocation Loc,
1660  bool ConvertToBoolean) {
1661  if (Tok.is(tok::code_completion)) {
1663  cutOffParsing();
1664  return true;
1665  }
1666 
1667  ParsedAttributesWithRange attrs(AttrFactory);
1668  MaybeParseCXX11Attributes(attrs);
1669 
1670  if (!isCXXConditionDeclaration()) {
1671  ProhibitAttributes(attrs);
1672 
1673  // Parse the expression.
1674  ExprOut = ParseExpression(); // expression
1675  DeclOut = nullptr;
1676  if (ExprOut.isInvalid())
1677  return true;
1678 
1679  // If required, convert to a boolean value.
1680  if (ConvertToBoolean)
1681  ExprOut
1682  = Actions.ActOnBooleanCondition(getCurScope(), Loc, ExprOut.get());
1683  return ExprOut.isInvalid();
1684  }
1685 
1686  // type-specifier-seq
1687  DeclSpec DS(AttrFactory);
1688  DS.takeAttributesFrom(attrs);
1689  ParseSpecifierQualifierList(DS, AS_none, DSC_condition);
1690 
1691  // declarator
1692  Declarator DeclaratorInfo(DS, Declarator::ConditionContext);
1693  ParseDeclarator(DeclaratorInfo);
1694 
1695  // simple-asm-expr[opt]
1696  if (Tok.is(tok::kw_asm)) {
1697  SourceLocation Loc;
1698  ExprResult AsmLabel(ParseSimpleAsm(&Loc));
1699  if (AsmLabel.isInvalid()) {
1700  SkipUntil(tok::semi, StopAtSemi);
1701  return true;
1702  }
1703  DeclaratorInfo.setAsmLabel(AsmLabel.get());
1704  DeclaratorInfo.SetRangeEnd(Loc);
1705  }
1706 
1707  // If attributes are present, parse them.
1708  MaybeParseGNUAttributes(DeclaratorInfo);
1709 
1710  // Type-check the declaration itself.
1712  DeclaratorInfo);
1713  DeclOut = Dcl.get();
1714  ExprOut = ExprError();
1715 
1716  // '=' assignment-expression
1717  // If a '==' or '+=' is found, suggest a fixit to '='.
1718  bool CopyInitialization = isTokenEqualOrEqualTypo();
1719  if (CopyInitialization)
1720  ConsumeToken();
1721 
1722  ExprResult InitExpr = ExprError();
1723  if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
1724  Diag(Tok.getLocation(),
1725  diag::warn_cxx98_compat_generalized_initializer_lists);
1726  InitExpr = ParseBraceInitializer();
1727  } else if (CopyInitialization) {
1728  InitExpr = ParseAssignmentExpression();
1729  } else if (Tok.is(tok::l_paren)) {
1730  // This was probably an attempt to initialize the variable.
1731  SourceLocation LParen = ConsumeParen(), RParen = LParen;
1732  if (SkipUntil(tok::r_paren, StopAtSemi | StopBeforeMatch))
1733  RParen = ConsumeParen();
1734  Diag(DeclOut ? DeclOut->getLocation() : LParen,
1735  diag::err_expected_init_in_condition_lparen)
1736  << SourceRange(LParen, RParen);
1737  } else {
1738  Diag(DeclOut ? DeclOut->getLocation() : Tok.getLocation(),
1739  diag::err_expected_init_in_condition);
1740  }
1741 
1742  if (!InitExpr.isInvalid())
1743  Actions.AddInitializerToDecl(DeclOut, InitExpr.get(), !CopyInitialization,
1745  else
1746  Actions.ActOnInitializerError(DeclOut);
1747 
1748  // FIXME: Build a reference to this declaration? Convert it to bool?
1749  // (This is currently handled by Sema).
1750 
1751  Actions.FinalizeDeclaration(DeclOut);
1752 
1753  return false;
1754 }
1755 
1756 /// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
1757 /// This should only be called when the current token is known to be part of
1758 /// simple-type-specifier.
1759 ///
1760 /// simple-type-specifier:
1761 /// '::'[opt] nested-name-specifier[opt] type-name
1762 /// '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
1763 /// char
1764 /// wchar_t
1765 /// bool
1766 /// short
1767 /// int
1768 /// long
1769 /// signed
1770 /// unsigned
1771 /// float
1772 /// double
1773 /// void
1774 /// [GNU] typeof-specifier
1775 /// [C++0x] auto [TODO]
1776 ///
1777 /// type-name:
1778 /// class-name
1779 /// enum-name
1780 /// typedef-name
1781 ///
1782 void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
1783  DS.SetRangeStart(Tok.getLocation());
1784  const char *PrevSpec;
1785  unsigned DiagID;
1786  SourceLocation Loc = Tok.getLocation();
1787  const clang::PrintingPolicy &Policy =
1788  Actions.getASTContext().getPrintingPolicy();
1789 
1790  switch (Tok.getKind()) {
1791  case tok::identifier: // foo::bar
1792  case tok::coloncolon: // ::foo::bar
1793  llvm_unreachable("Annotation token should already be formed!");
1794  default:
1795  llvm_unreachable("Not a simple-type-specifier token!");
1796 
1797  // type-name
1798  case tok::annot_typename: {
1799  if (getTypeAnnotation(Tok))
1800  DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID,
1801  getTypeAnnotation(Tok), Policy);
1802  else
1803  DS.SetTypeSpecError();
1804 
1805  DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1806  ConsumeToken();
1807 
1808  DS.Finish(Diags, PP, Policy);
1809  return;
1810  }
1811 
1812  // builtin types
1813  case tok::kw_short:
1814  DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID, Policy);
1815  break;
1816  case tok::kw_long:
1817  DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, DiagID, Policy);
1818  break;
1819  case tok::kw___int64:
1820  DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, DiagID, Policy);
1821  break;
1822  case tok::kw_signed:
1823  DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID);
1824  break;
1825  case tok::kw_unsigned:
1826  DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, DiagID);
1827  break;
1828  case tok::kw_void:
1829  DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID, Policy);
1830  break;
1831  case tok::kw_char:
1832  DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID, Policy);
1833  break;
1834  case tok::kw_int:
1835  DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID, Policy);
1836  break;
1837  case tok::kw___int128:
1838  DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID, Policy);
1839  break;
1840  case tok::kw_half:
1841  DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID, Policy);
1842  break;
1843  case tok::kw_float:
1844  DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID, Policy);
1845  break;
1846  case tok::kw_double:
1847  DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID, Policy);
1848  break;
1849  case tok::kw_wchar_t:
1850  DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID, Policy);
1851  break;
1852  case tok::kw_char16_t:
1853  DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID, Policy);
1854  break;
1855  case tok::kw_char32_t:
1856  DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID, Policy);
1857  break;
1858  case tok::kw_bool:
1859  DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID, Policy);
1860  break;
1861  case tok::annot_decltype:
1862  case tok::kw_decltype:
1863  DS.SetRangeEnd(ParseDecltypeSpecifier(DS));
1864  return DS.Finish(Diags, PP, Policy);
1865 
1866  // GNU typeof support.
1867  case tok::kw_typeof:
1868  ParseTypeofSpecifier(DS);
1869  DS.Finish(Diags, PP, Policy);
1870  return;
1871  }
1872  if (Tok.is(tok::annot_typename))
1873  DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1874  else
1875  DS.SetRangeEnd(Tok.getLocation());
1876  ConsumeToken();
1877  DS.Finish(Diags, PP, Policy);
1878 }
1879 
1880 /// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
1881 /// [dcl.name]), which is a non-empty sequence of type-specifiers,
1882 /// e.g., "const short int". Note that the DeclSpec is *not* finished
1883 /// by parsing the type-specifier-seq, because these sequences are
1884 /// typically followed by some form of declarator. Returns true and
1885 /// emits diagnostics if this is not a type-specifier-seq, false
1886 /// otherwise.
1887 ///
1888 /// type-specifier-seq: [C++ 8.1]
1889 /// type-specifier type-specifier-seq[opt]
1890 ///
1891 bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
1892  ParseSpecifierQualifierList(DS, AS_none, DSC_type_specifier);
1893  DS.Finish(Diags, PP, Actions.getASTContext().getPrintingPolicy());
1894  return false;
1895 }
1896 
1897 /// \brief Finish parsing a C++ unqualified-id that is a template-id of
1898 /// some form.
1899 ///
1900 /// This routine is invoked when a '<' is encountered after an identifier or
1901 /// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
1902 /// whether the unqualified-id is actually a template-id. This routine will
1903 /// then parse the template arguments and form the appropriate template-id to
1904 /// return to the caller.
1905 ///
1906 /// \param SS the nested-name-specifier that precedes this template-id, if
1907 /// we're actually parsing a qualified-id.
1908 ///
1909 /// \param Name for constructor and destructor names, this is the actual
1910 /// identifier that may be a template-name.
1911 ///
1912 /// \param NameLoc the location of the class-name in a constructor or
1913 /// destructor.
1914 ///
1915 /// \param EnteringContext whether we're entering the scope of the
1916 /// nested-name-specifier.
1917 ///
1918 /// \param ObjectType if this unqualified-id occurs within a member access
1919 /// expression, the type of the base object whose member is being accessed.
1920 ///
1921 /// \param Id as input, describes the template-name or operator-function-id
1922 /// that precedes the '<'. If template arguments were parsed successfully,
1923 /// will be updated with the template-id.
1924 ///
1925 /// \param AssumeTemplateId When true, this routine will assume that the name
1926 /// refers to a template without performing name lookup to verify.
1927 ///
1928 /// \returns true if a parse error occurred, false otherwise.
1929 bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
1930  SourceLocation TemplateKWLoc,
1931  IdentifierInfo *Name,
1932  SourceLocation NameLoc,
1933  bool EnteringContext,
1934  ParsedType ObjectType,
1935  UnqualifiedId &Id,
1936  bool AssumeTemplateId) {
1937  assert((AssumeTemplateId || Tok.is(tok::less)) &&
1938  "Expected '<' to finish parsing a template-id");
1939 
1940  TemplateTy Template;
1942  switch (Id.getKind()) {
1946  if (AssumeTemplateId) {
1947  TNK = Actions.ActOnDependentTemplateName(getCurScope(), SS, TemplateKWLoc,
1948  Id, ObjectType, EnteringContext,
1949  Template);
1950  if (TNK == TNK_Non_template)
1951  return true;
1952  } else {
1953  bool MemberOfUnknownSpecialization;
1954  TNK = Actions.isTemplateName(getCurScope(), SS,
1955  TemplateKWLoc.isValid(), Id,
1956  ObjectType, EnteringContext, Template,
1957  MemberOfUnknownSpecialization);
1958 
1959  if (TNK == TNK_Non_template && MemberOfUnknownSpecialization &&
1960  ObjectType && IsTemplateArgumentList()) {
1961  // We have something like t->getAs<T>(), where getAs is a
1962  // member of an unknown specialization. However, this will only
1963  // parse correctly as a template, so suggest the keyword 'template'
1964  // before 'getAs' and treat this as a dependent template name.
1965  std::string Name;
1967  Name = Id.Identifier->getName();
1968  else {
1969  Name = "operator ";
1972  else
1973  Name += Id.Identifier->getName();
1974  }
1975  Diag(Id.StartLocation, diag::err_missing_dependent_template_keyword)
1976  << Name
1977  << FixItHint::CreateInsertion(Id.StartLocation, "template ");
1978  TNK = Actions.ActOnDependentTemplateName(getCurScope(),
1979  SS, TemplateKWLoc, Id,
1980  ObjectType, EnteringContext,
1981  Template);
1982  if (TNK == TNK_Non_template)
1983  return true;
1984  }
1985  }
1986  break;
1987 
1989  UnqualifiedId TemplateName;
1990  bool MemberOfUnknownSpecialization;
1991  TemplateName.setIdentifier(Name, NameLoc);
1992  TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
1993  TemplateName, ObjectType,
1994  EnteringContext, Template,
1995  MemberOfUnknownSpecialization);
1996  break;
1997  }
1998 
2000  UnqualifiedId TemplateName;
2001  bool MemberOfUnknownSpecialization;
2002  TemplateName.setIdentifier(Name, NameLoc);
2003  if (ObjectType) {
2004  TNK = Actions.ActOnDependentTemplateName(getCurScope(),
2005  SS, TemplateKWLoc, TemplateName,
2006  ObjectType, EnteringContext,
2007  Template);
2008  if (TNK == TNK_Non_template)
2009  return true;
2010  } else {
2011  TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
2012  TemplateName, ObjectType,
2013  EnteringContext, Template,
2014  MemberOfUnknownSpecialization);
2015 
2016  if (TNK == TNK_Non_template && !Id.DestructorName.get()) {
2017  Diag(NameLoc, diag::err_destructor_template_id)
2018  << Name << SS.getRange();
2019  return true;
2020  }
2021  }
2022  break;
2023  }
2024 
2025  default:
2026  return false;
2027  }
2028 
2029  if (TNK == TNK_Non_template)
2030  return false;
2031 
2032  // Parse the enclosed template argument list.
2033  SourceLocation LAngleLoc, RAngleLoc;
2034  TemplateArgList TemplateArgs;
2035  if (Tok.is(tok::less) &&
2036  ParseTemplateIdAfterTemplateName(Template, Id.StartLocation,
2037  SS, true, LAngleLoc,
2038  TemplateArgs,
2039  RAngleLoc))
2040  return true;
2041 
2042  if (Id.getKind() == UnqualifiedId::IK_Identifier ||
2045  // Form a parsed representation of the template-id to be stored in the
2046  // UnqualifiedId.
2047  TemplateIdAnnotation *TemplateId
2048  = TemplateIdAnnotation::Allocate(TemplateArgs.size(), TemplateIds);
2049 
2050  // FIXME: Store name for literal operator too.
2051  if (Id.getKind() == UnqualifiedId::IK_Identifier) {
2052  TemplateId->Name = Id.Identifier;
2053  TemplateId->Operator = OO_None;
2054  TemplateId->TemplateNameLoc = Id.StartLocation;
2055  } else {
2056  TemplateId->Name = nullptr;
2057  TemplateId->Operator = Id.OperatorFunctionId.Operator;
2058  TemplateId->TemplateNameLoc = Id.StartLocation;
2059  }
2060 
2061  TemplateId->SS = SS;
2062  TemplateId->TemplateKWLoc = TemplateKWLoc;
2063  TemplateId->Template = Template;
2064  TemplateId->Kind = TNK;
2065  TemplateId->LAngleLoc = LAngleLoc;
2066  TemplateId->RAngleLoc = RAngleLoc;
2067  ParsedTemplateArgument *Args = TemplateId->getTemplateArgs();
2068  for (unsigned Arg = 0, ArgEnd = TemplateArgs.size();
2069  Arg != ArgEnd; ++Arg)
2070  Args[Arg] = TemplateArgs[Arg];
2071 
2072  Id.setTemplateId(TemplateId);
2073  return false;
2074  }
2075 
2076  // Bundle the template arguments together.
2077  ASTTemplateArgsPtr TemplateArgsPtr(TemplateArgs);
2078 
2079  // Constructor and destructor names.
2081  = Actions.ActOnTemplateIdType(SS, TemplateKWLoc,
2082  Template, NameLoc,
2083  LAngleLoc, TemplateArgsPtr, RAngleLoc,
2084  /*IsCtorOrDtorName=*/true);
2085  if (Type.isInvalid())
2086  return true;
2087 
2089  Id.setConstructorName(Type.get(), NameLoc, RAngleLoc);
2090  else
2091  Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc);
2092 
2093  return false;
2094 }
2095 
2096 /// \brief Parse an operator-function-id or conversion-function-id as part
2097 /// of a C++ unqualified-id.
2098 ///
2099 /// This routine is responsible only for parsing the operator-function-id or
2100 /// conversion-function-id; it does not handle template arguments in any way.
2101 ///
2102 /// \code
2103 /// operator-function-id: [C++ 13.5]
2104 /// 'operator' operator
2105 ///
2106 /// operator: one of
2107 /// new delete new[] delete[]
2108 /// + - * / % ^ & | ~
2109 /// ! = < > += -= *= /= %=
2110 /// ^= &= |= << >> >>= <<= == !=
2111 /// <= >= && || ++ -- , ->* ->
2112 /// () []
2113 ///
2114 /// conversion-function-id: [C++ 12.3.2]
2115 /// operator conversion-type-id
2116 ///
2117 /// conversion-type-id:
2118 /// type-specifier-seq conversion-declarator[opt]
2119 ///
2120 /// conversion-declarator:
2121 /// ptr-operator conversion-declarator[opt]
2122 /// \endcode
2123 ///
2124 /// \param SS The nested-name-specifier that preceded this unqualified-id. If
2125 /// non-empty, then we are parsing the unqualified-id of a qualified-id.
2126 ///
2127 /// \param EnteringContext whether we are entering the scope of the
2128 /// nested-name-specifier.
2129 ///
2130 /// \param ObjectType if this unqualified-id occurs within a member access
2131 /// expression, the type of the base object whose member is being accessed.
2132 ///
2133 /// \param Result on a successful parse, contains the parsed unqualified-id.
2134 ///
2135 /// \returns true if parsing fails, false otherwise.
2136 bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
2137  ParsedType ObjectType,
2138  UnqualifiedId &Result) {
2139  assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword");
2140 
2141  // Consume the 'operator' keyword.
2142  SourceLocation KeywordLoc = ConsumeToken();
2143 
2144  // Determine what kind of operator name we have.
2145  unsigned SymbolIdx = 0;
2146  SourceLocation SymbolLocations[3];
2148  switch (Tok.getKind()) {
2149  case tok::kw_new:
2150  case tok::kw_delete: {
2151  bool isNew = Tok.getKind() == tok::kw_new;
2152  // Consume the 'new' or 'delete'.
2153  SymbolLocations[SymbolIdx++] = ConsumeToken();
2154  // Check for array new/delete.
2155  if (Tok.is(tok::l_square) &&
2156  (!getLangOpts().CPlusPlus11 || NextToken().isNot(tok::l_square))) {
2157  // Consume the '[' and ']'.
2158  BalancedDelimiterTracker T(*this, tok::l_square);
2159  T.consumeOpen();
2160  T.consumeClose();
2161  if (T.getCloseLocation().isInvalid())
2162  return true;
2163 
2164  SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2165  SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2166  Op = isNew? OO_Array_New : OO_Array_Delete;
2167  } else {
2168  Op = isNew? OO_New : OO_Delete;
2169  }
2170  break;
2171  }
2172 
2173 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2174  case tok::Token: \
2175  SymbolLocations[SymbolIdx++] = ConsumeToken(); \
2176  Op = OO_##Name; \
2177  break;
2178 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2179 #include "clang/Basic/OperatorKinds.def"
2180 
2181  case tok::l_paren: {
2182  // Consume the '(' and ')'.
2183  BalancedDelimiterTracker T(*this, tok::l_paren);
2184  T.consumeOpen();
2185  T.consumeClose();
2186  if (T.getCloseLocation().isInvalid())
2187  return true;
2188 
2189  SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2190  SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2191  Op = OO_Call;
2192  break;
2193  }
2194 
2195  case tok::l_square: {
2196  // Consume the '[' and ']'.
2197  BalancedDelimiterTracker T(*this, tok::l_square);
2198  T.consumeOpen();
2199  T.consumeClose();
2200  if (T.getCloseLocation().isInvalid())
2201  return true;
2202 
2203  SymbolLocations[SymbolIdx++] = T.getOpenLocation();
2204  SymbolLocations[SymbolIdx++] = T.getCloseLocation();
2205  Op = OO_Subscript;
2206  break;
2207  }
2208 
2209  case tok::code_completion: {
2210  // Code completion for the operator name.
2212  cutOffParsing();
2213  // Don't try to parse any further.
2214  return true;
2215  }
2216 
2217  default:
2218  break;
2219  }
2220 
2221  if (Op != OO_None) {
2222  // We have parsed an operator-function-id.
2223  Result.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations);
2224  return false;
2225  }
2226 
2227  // Parse a literal-operator-id.
2228  //
2229  // literal-operator-id: C++11 [over.literal]
2230  // operator string-literal identifier
2231  // operator user-defined-string-literal
2232 
2233  if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {
2234  Diag(Tok.getLocation(), diag::warn_cxx98_compat_literal_operator);
2235 
2236  SourceLocation DiagLoc;
2237  unsigned DiagId = 0;
2238 
2239  // We're past translation phase 6, so perform string literal concatenation
2240  // before checking for "".
2241  SmallVector<Token, 4> Toks;
2243  while (isTokenStringLiteral()) {
2244  if (!Tok.is(tok::string_literal) && !DiagId) {
2245  // C++11 [over.literal]p1:
2246  // The string-literal or user-defined-string-literal in a
2247  // literal-operator-id shall have no encoding-prefix [...].
2248  DiagLoc = Tok.getLocation();
2249  DiagId = diag::err_literal_operator_string_prefix;
2250  }
2251  Toks.push_back(Tok);
2252  TokLocs.push_back(ConsumeStringToken());
2253  }
2254 
2255  StringLiteralParser Literal(Toks, PP);
2256  if (Literal.hadError)
2257  return true;
2258 
2259  // Grab the literal operator's suffix, which will be either the next token
2260  // or a ud-suffix from the string literal.
2261  IdentifierInfo *II = nullptr;
2262  SourceLocation SuffixLoc;
2263  if (!Literal.getUDSuffix().empty()) {
2264  II = &PP.getIdentifierTable().get(Literal.getUDSuffix());
2265  SuffixLoc =
2266  Lexer::AdvanceToTokenCharacter(TokLocs[Literal.getUDSuffixToken()],
2267  Literal.getUDSuffixOffset(),
2268  PP.getSourceManager(), getLangOpts());
2269  } else if (Tok.is(tok::identifier)) {
2270  II = Tok.getIdentifierInfo();
2271  SuffixLoc = ConsumeToken();
2272  TokLocs.push_back(SuffixLoc);
2273  } else {
2274  Diag(Tok.getLocation(), diag::err_expected) << tok::identifier;
2275  return true;
2276  }
2277 
2278  // The string literal must be empty.
2279  if (!Literal.GetString().empty() || Literal.Pascal) {
2280  // C++11 [over.literal]p1:
2281  // The string-literal or user-defined-string-literal in a
2282  // literal-operator-id shall [...] contain no characters
2283  // other than the implicit terminating '\0'.
2284  DiagLoc = TokLocs.front();
2285  DiagId = diag::err_literal_operator_string_not_empty;
2286  }
2287 
2288  if (DiagId) {
2289  // This isn't a valid literal-operator-id, but we think we know
2290  // what the user meant. Tell them what they should have written.
2291  SmallString<32> Str;
2292  Str += "\"\" ";
2293  Str += II->getName();
2294  Diag(DiagLoc, DiagId) << FixItHint::CreateReplacement(
2295  SourceRange(TokLocs.front(), TokLocs.back()), Str);
2296  }
2297 
2298  Result.setLiteralOperatorId(II, KeywordLoc, SuffixLoc);
2299 
2300  return Actions.checkLiteralOperatorId(SS, Result);
2301  }
2302 
2303  // Parse a conversion-function-id.
2304  //
2305  // conversion-function-id: [C++ 12.3.2]
2306  // operator conversion-type-id
2307  //
2308  // conversion-type-id:
2309  // type-specifier-seq conversion-declarator[opt]
2310  //
2311  // conversion-declarator:
2312  // ptr-operator conversion-declarator[opt]
2313 
2314  // Parse the type-specifier-seq.
2315  DeclSpec DS(AttrFactory);
2316  if (ParseCXXTypeSpecifierSeq(DS)) // FIXME: ObjectType?
2317  return true;
2318 
2319  // Parse the conversion-declarator, which is merely a sequence of
2320  // ptr-operators.
2322  ParseDeclaratorInternal(D, /*DirectDeclParser=*/nullptr);
2323 
2324  // Finish up the type.
2325  TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D);
2326  if (Ty.isInvalid())
2327  return true;
2328 
2329  // Note that this is a conversion-function-id.
2330  Result.setConversionFunctionId(KeywordLoc, Ty.get(),
2331  D.getSourceRange().getEnd());
2332  return false;
2333 }
2334 
2335 /// \brief Parse a C++ unqualified-id (or a C identifier), which describes the
2336 /// name of an entity.
2337 ///
2338 /// \code
2339 /// unqualified-id: [C++ expr.prim.general]
2340 /// identifier
2341 /// operator-function-id
2342 /// conversion-function-id
2343 /// [C++0x] literal-operator-id [TODO]
2344 /// ~ class-name
2345 /// template-id
2346 ///
2347 /// \endcode
2348 ///
2349 /// \param SS The nested-name-specifier that preceded this unqualified-id. If
2350 /// non-empty, then we are parsing the unqualified-id of a qualified-id.
2351 ///
2352 /// \param EnteringContext whether we are entering the scope of the
2353 /// nested-name-specifier.
2354 ///
2355 /// \param AllowDestructorName whether we allow parsing of a destructor name.
2356 ///
2357 /// \param AllowConstructorName whether we allow parsing a constructor name.
2358 ///
2359 /// \param ObjectType if this unqualified-id occurs within a member access
2360 /// expression, the type of the base object whose member is being accessed.
2361 ///
2362 /// \param Result on a successful parse, contains the parsed unqualified-id.
2363 ///
2364 /// \returns true if parsing fails, false otherwise.
2365 bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext,
2366  bool AllowDestructorName,
2367  bool AllowConstructorName,
2368  ParsedType ObjectType,
2369  SourceLocation& TemplateKWLoc,
2370  UnqualifiedId &Result) {
2371 
2372  // Handle 'A::template B'. This is for template-ids which have not
2373  // already been annotated by ParseOptionalCXXScopeSpecifier().
2374  bool TemplateSpecified = false;
2375  if (getLangOpts().CPlusPlus && Tok.is(tok::kw_template) &&
2376  (ObjectType || SS.isSet())) {
2377  TemplateSpecified = true;
2378  TemplateKWLoc = ConsumeToken();
2379  }
2380 
2381  // unqualified-id:
2382  // identifier
2383  // template-id (when it hasn't already been annotated)
2384  if (Tok.is(tok::identifier)) {
2385  // Consume the identifier.
2386  IdentifierInfo *Id = Tok.getIdentifierInfo();
2387  SourceLocation IdLoc = ConsumeToken();
2388 
2389  if (!getLangOpts().CPlusPlus) {
2390  // If we're not in C++, only identifiers matter. Record the
2391  // identifier and return.
2392  Result.setIdentifier(Id, IdLoc);
2393  return false;
2394  }
2395 
2396  if (AllowConstructorName &&
2397  Actions.isCurrentClassName(*Id, getCurScope(), &SS)) {
2398  // We have parsed a constructor name.
2399  ParsedType Ty = Actions.getTypeName(*Id, IdLoc, getCurScope(),
2400  &SS, false, false,
2401  ParsedType(),
2402  /*IsCtorOrDtorName=*/true,
2403  /*NonTrivialTypeSourceInfo=*/true);
2404  Result.setConstructorName(Ty, IdLoc, IdLoc);
2405  } else {
2406  // We have parsed an identifier.
2407  Result.setIdentifier(Id, IdLoc);
2408  }
2409 
2410  // If the next token is a '<', we may have a template.
2411  if (TemplateSpecified || Tok.is(tok::less))
2412  return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc, Id, IdLoc,
2413  EnteringContext, ObjectType,
2414  Result, TemplateSpecified);
2415 
2416  return false;
2417  }
2418 
2419  // unqualified-id:
2420  // template-id (already parsed and annotated)
2421  if (Tok.is(tok::annot_template_id)) {
2422  TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
2423 
2424  // If the template-name names the current class, then this is a constructor
2425  if (AllowConstructorName && TemplateId->Name &&
2426  Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
2427  if (SS.isSet()) {
2428  // C++ [class.qual]p2 specifies that a qualified template-name
2429  // is taken as the constructor name where a constructor can be
2430  // declared. Thus, the template arguments are extraneous, so
2431  // complain about them and remove them entirely.
2432  Diag(TemplateId->TemplateNameLoc,
2433  diag::err_out_of_line_constructor_template_id)
2434  << TemplateId->Name
2436  SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc));
2437  ParsedType Ty = Actions.getTypeName(*TemplateId->Name,
2438  TemplateId->TemplateNameLoc,
2439  getCurScope(),
2440  &SS, false, false,
2441  ParsedType(),
2442  /*IsCtorOrDtorName=*/true,
2443  /*NontrivialTypeSourceInfo=*/true);
2444  Result.setConstructorName(Ty, TemplateId->TemplateNameLoc,
2445  TemplateId->RAngleLoc);
2446  ConsumeToken();
2447  return false;
2448  }
2449 
2450  Result.setConstructorTemplateId(TemplateId);
2451  ConsumeToken();
2452  return false;
2453  }
2454 
2455  // We have already parsed a template-id; consume the annotation token as
2456  // our unqualified-id.
2457  Result.setTemplateId(TemplateId);
2458  TemplateKWLoc = TemplateId->TemplateKWLoc;
2459  ConsumeToken();
2460  return false;
2461  }
2462 
2463  // unqualified-id:
2464  // operator-function-id
2465  // conversion-function-id
2466  if (Tok.is(tok::kw_operator)) {
2467  if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, Result))
2468  return true;
2469 
2470  // If we have an operator-function-id or a literal-operator-id and the next
2471  // token is a '<', we may have a
2472  //
2473  // template-id:
2474  // operator-function-id < template-argument-list[opt] >
2475  if ((Result.getKind() == UnqualifiedId::IK_OperatorFunctionId ||
2477  (TemplateSpecified || Tok.is(tok::less)))
2478  return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
2479  nullptr, SourceLocation(),
2480  EnteringContext, ObjectType,
2481  Result, TemplateSpecified);
2482 
2483  return false;
2484  }
2485 
2486  if (getLangOpts().CPlusPlus &&
2487  (AllowDestructorName || SS.isSet()) && Tok.is(tok::tilde)) {
2488  // C++ [expr.unary.op]p10:
2489  // There is an ambiguity in the unary-expression ~X(), where X is a
2490  // class-name. The ambiguity is resolved in favor of treating ~ as a
2491  // unary complement rather than treating ~X as referring to a destructor.
2492 
2493  // Parse the '~'.
2494  SourceLocation TildeLoc = ConsumeToken();
2495 
2496  if (SS.isEmpty() && Tok.is(tok::kw_decltype)) {
2497  DeclSpec DS(AttrFactory);
2498  SourceLocation EndLoc = ParseDecltypeSpecifier(DS);
2499  if (ParsedType Type = Actions.getDestructorType(DS, ObjectType)) {
2500  Result.setDestructorName(TildeLoc, Type, EndLoc);
2501  return false;
2502  }
2503  return true;
2504  }
2505 
2506  // Parse the class-name.
2507  if (Tok.isNot(tok::identifier)) {
2508  Diag(Tok, diag::err_destructor_tilde_identifier);
2509  return true;
2510  }
2511 
2512  // If the user wrote ~T::T, correct it to T::~T.
2513  DeclaratorScopeObj DeclScopeObj(*this, SS);
2514  if (!TemplateSpecified && NextToken().is(tok::coloncolon)) {
2515  // Don't let ParseOptionalCXXScopeSpecifier() "correct"
2516  // `int A; struct { ~A::A(); };` to `int A; struct { ~A:A(); };`,
2517  // it will confuse this recovery logic.
2518  ColonProtectionRAIIObject ColonRAII(*this, false);
2519 
2520  if (SS.isSet()) {
2521  AnnotateScopeToken(SS, /*NewAnnotation*/true);
2522  SS.clear();
2523  }
2524  if (ParseOptionalCXXScopeSpecifier(SS, ObjectType, EnteringContext))
2525  return true;
2526  if (SS.isNotEmpty())
2527  ObjectType = ParsedType();
2528  if (Tok.isNot(tok::identifier) || NextToken().is(tok::coloncolon) ||
2529  !SS.isSet()) {
2530  Diag(TildeLoc, diag::err_destructor_tilde_scope);
2531  return true;
2532  }
2533 
2534  // Recover as if the tilde had been written before the identifier.
2535  Diag(TildeLoc, diag::err_destructor_tilde_scope)
2536  << FixItHint::CreateRemoval(TildeLoc)
2537  << FixItHint::CreateInsertion(Tok.getLocation(), "~");
2538 
2539  // Temporarily enter the scope for the rest of this function.
2540  if (Actions.ShouldEnterDeclaratorScope(getCurScope(), SS))
2541  DeclScopeObj.EnterDeclaratorScope();
2542  }
2543 
2544  // Parse the class-name (or template-name in a simple-template-id).
2545  IdentifierInfo *ClassName = Tok.getIdentifierInfo();
2546  SourceLocation ClassNameLoc = ConsumeToken();
2547 
2548  if (TemplateSpecified || Tok.is(tok::less)) {
2549  Result.setDestructorName(TildeLoc, ParsedType(), ClassNameLoc);
2550  return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
2551  ClassName, ClassNameLoc,
2552  EnteringContext, ObjectType,
2553  Result, TemplateSpecified);
2554  }
2555 
2556  // Note that this is a destructor name.
2557  ParsedType Ty = Actions.getDestructorName(TildeLoc, *ClassName,
2558  ClassNameLoc, getCurScope(),
2559  SS, ObjectType,
2560  EnteringContext);
2561  if (!Ty)
2562  return true;
2563 
2564  Result.setDestructorName(TildeLoc, Ty, ClassNameLoc);
2565  return false;
2566  }
2567 
2568  Diag(Tok, diag::err_expected_unqualified_id)
2569  << getLangOpts().CPlusPlus;
2570  return true;
2571 }
2572 
2573 /// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
2574 /// memory in a typesafe manner and call constructors.
2575 ///
2576 /// This method is called to parse the new expression after the optional :: has
2577 /// been already parsed. If the :: was present, "UseGlobal" is true and "Start"
2578 /// is its location. Otherwise, "Start" is the location of the 'new' token.
2579 ///
2580 /// new-expression:
2581 /// '::'[opt] 'new' new-placement[opt] new-type-id
2582 /// new-initializer[opt]
2583 /// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2584 /// new-initializer[opt]
2585 ///
2586 /// new-placement:
2587 /// '(' expression-list ')'
2588 ///
2589 /// new-type-id:
2590 /// type-specifier-seq new-declarator[opt]
2591 /// [GNU] attributes type-specifier-seq new-declarator[opt]
2592 ///
2593 /// new-declarator:
2594 /// ptr-operator new-declarator[opt]
2595 /// direct-new-declarator
2596 ///
2597 /// new-initializer:
2598 /// '(' expression-list[opt] ')'
2599 /// [C++0x] braced-init-list
2600 ///
2601 ExprResult
2602 Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
2603  assert(Tok.is(tok::kw_new) && "expected 'new' token");
2604  ConsumeToken(); // Consume 'new'
2605 
2606  // A '(' now can be a new-placement or the '(' wrapping the type-id in the
2607  // second form of new-expression. It can't be a new-type-id.
2608 
2609  ExprVector PlacementArgs;
2610  SourceLocation PlacementLParen, PlacementRParen;
2611 
2612  SourceRange TypeIdParens;
2613  DeclSpec DS(AttrFactory);
2614  Declarator DeclaratorInfo(DS, Declarator::CXXNewContext);
2615  if (Tok.is(tok::l_paren)) {
2616  // If it turns out to be a placement, we change the type location.
2617  BalancedDelimiterTracker T(*this, tok::l_paren);
2618  T.consumeOpen();
2619  PlacementLParen = T.getOpenLocation();
2620  if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
2621  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2622  return ExprError();
2623  }
2624 
2625  T.consumeClose();
2626  PlacementRParen = T.getCloseLocation();
2627  if (PlacementRParen.isInvalid()) {
2628  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2629  return ExprError();
2630  }
2631 
2632  if (PlacementArgs.empty()) {
2633  // Reset the placement locations. There was no placement.
2634  TypeIdParens = T.getRange();
2635  PlacementLParen = PlacementRParen = SourceLocation();
2636  } else {
2637  // We still need the type.
2638  if (Tok.is(tok::l_paren)) {
2639  BalancedDelimiterTracker T(*this, tok::l_paren);
2640  T.consumeOpen();
2641  MaybeParseGNUAttributes(DeclaratorInfo);
2642  ParseSpecifierQualifierList(DS);
2643  DeclaratorInfo.SetSourceRange(DS.getSourceRange());
2644  ParseDeclarator(DeclaratorInfo);
2645  T.consumeClose();
2646  TypeIdParens = T.getRange();
2647  } else {
2648  MaybeParseGNUAttributes(DeclaratorInfo);
2649  if (ParseCXXTypeSpecifierSeq(DS))
2650  DeclaratorInfo.setInvalidType(true);
2651  else {
2652  DeclaratorInfo.SetSourceRange(DS.getSourceRange());
2653  ParseDeclaratorInternal(DeclaratorInfo,
2654  &Parser::ParseDirectNewDeclarator);
2655  }
2656  }
2657  }
2658  } else {
2659  // A new-type-id is a simplified type-id, where essentially the
2660  // direct-declarator is replaced by a direct-new-declarator.
2661  MaybeParseGNUAttributes(DeclaratorInfo);
2662  if (ParseCXXTypeSpecifierSeq(DS))
2663  DeclaratorInfo.setInvalidType(true);
2664  else {
2665  DeclaratorInfo.SetSourceRange(DS.getSourceRange());
2666  ParseDeclaratorInternal(DeclaratorInfo,
2667  &Parser::ParseDirectNewDeclarator);
2668  }
2669  }
2670  if (DeclaratorInfo.isInvalidType()) {
2671  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2672  return ExprError();
2673  }
2674 
2675  ExprResult Initializer;
2676 
2677  if (Tok.is(tok::l_paren)) {
2678  SourceLocation ConstructorLParen, ConstructorRParen;
2679  ExprVector ConstructorArgs;
2680  BalancedDelimiterTracker T(*this, tok::l_paren);
2681  T.consumeOpen();
2682  ConstructorLParen = T.getOpenLocation();
2683  if (Tok.isNot(tok::r_paren)) {
2684  CommaLocsTy CommaLocs;
2685  if (ParseExpressionList(ConstructorArgs, CommaLocs, [&] {
2686  ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(),
2687  DeclaratorInfo).get();
2689  TypeRep.get()->getCanonicalTypeInternal(),
2690  DeclaratorInfo.getLocEnd(),
2691  ConstructorArgs);
2692  })) {
2693  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2694  return ExprError();
2695  }
2696  }
2697  T.consumeClose();
2698  ConstructorRParen = T.getCloseLocation();
2699  if (ConstructorRParen.isInvalid()) {
2700  SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
2701  return ExprError();
2702  }
2703  Initializer = Actions.ActOnParenListExpr(ConstructorLParen,
2704  ConstructorRParen,
2705  ConstructorArgs);
2706  } else if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus11) {
2707  Diag(Tok.getLocation(),
2708  diag::warn_cxx98_compat_generalized_initializer_lists);
2709  Initializer = ParseBraceInitializer();
2710  }
2711  if (Initializer.isInvalid())
2712  return Initializer;
2713 
2714  return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen,
2715  PlacementArgs, PlacementRParen,
2716  TypeIdParens, DeclaratorInfo, Initializer.get());
2717 }
2718 
2719 /// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
2720 /// passed to ParseDeclaratorInternal.
2721 ///
2722 /// direct-new-declarator:
2723 /// '[' expression ']'
2724 /// direct-new-declarator '[' constant-expression ']'
2725 ///
2726 void Parser::ParseDirectNewDeclarator(Declarator &D) {
2727  // Parse the array dimensions.
2728  bool first = true;
2729  while (Tok.is(tok::l_square)) {
2730  // An array-size expression can't start with a lambda.
2731  if (CheckProhibitedCXX11Attribute())
2732  continue;
2733 
2734  BalancedDelimiterTracker T(*this, tok::l_square);
2735  T.consumeOpen();
2736 
2737  ExprResult Size(first ? ParseExpression()
2739  if (Size.isInvalid()) {
2740  // Recover
2741  SkipUntil(tok::r_square, StopAtSemi);
2742  return;
2743  }
2744  first = false;
2745 
2746  T.consumeClose();
2747 
2748  // Attributes here appertain to the array type. C++11 [expr.new]p5.
2749  ParsedAttributes Attrs(AttrFactory);
2750  MaybeParseCXX11Attributes(Attrs);
2751 
2753  /*static=*/false, /*star=*/false,
2754  Size.get(),
2755  T.getOpenLocation(),
2756  T.getCloseLocation()),
2757  Attrs, T.getCloseLocation());
2758 
2759  if (T.getCloseLocation().isInvalid())
2760  return;
2761  }
2762 }
2763 
2764 /// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
2765 /// This ambiguity appears in the syntax of the C++ new operator.
2766 ///
2767 /// new-expression:
2768 /// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2769 /// new-initializer[opt]
2770 ///
2771 /// new-placement:
2772 /// '(' expression-list ')'
2773 ///
2774 bool Parser::ParseExpressionListOrTypeId(
2775  SmallVectorImpl<Expr*> &PlacementArgs,
2776  Declarator &D) {
2777  // The '(' was already consumed.
2778  if (isTypeIdInParens()) {
2779  ParseSpecifierQualifierList(D.getMutableDeclSpec());
2781  ParseDeclarator(D);
2782  return D.isInvalidType();
2783  }
2784 
2785  // It's not a type, it has to be an expression list.
2786  // Discard the comma locations - ActOnCXXNew has enough parameters.
2787  CommaLocsTy CommaLocs;
2788  return ParseExpressionList(PlacementArgs, CommaLocs);
2789 }
2790 
2791 /// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
2792 /// to free memory allocated by new.
2793 ///
2794 /// This method is called to parse the 'delete' expression after the optional
2795 /// '::' has been already parsed. If the '::' was present, "UseGlobal" is true
2796 /// and "Start" is its location. Otherwise, "Start" is the location of the
2797 /// 'delete' token.
2798 ///
2799 /// delete-expression:
2800 /// '::'[opt] 'delete' cast-expression
2801 /// '::'[opt] 'delete' '[' ']' cast-expression
2802 ExprResult
2803 Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
2804  assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword");
2805  ConsumeToken(); // Consume 'delete'
2806 
2807  // Array delete?
2808  bool ArrayDelete = false;
2809  if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
2810  // C++11 [expr.delete]p1:
2811  // Whenever the delete keyword is followed by empty square brackets, it
2812  // shall be interpreted as [array delete].
2813  // [Footnote: A lambda expression with a lambda-introducer that consists
2814  // of empty square brackets can follow the delete keyword if
2815  // the lambda expression is enclosed in parentheses.]
2816  // FIXME: Produce a better diagnostic if the '[]' is unambiguously a
2817  // lambda-introducer.
2818  ArrayDelete = true;
2819  BalancedDelimiterTracker T(*this, tok::l_square);
2820 
2821  T.consumeOpen();
2822  T.consumeClose();
2823  if (T.getCloseLocation().isInvalid())
2824  return ExprError();
2825  }
2826 
2827  ExprResult Operand(ParseCastExpression(false));
2828  if (Operand.isInvalid())
2829  return Operand;
2830 
2831  return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.get());
2832 }
2833 
2835  switch (kind) {
2836  default: llvm_unreachable("Not a known type trait");
2837 #define TYPE_TRAIT_1(Spelling, Name, Key) \
2838 case tok::kw_ ## Spelling: return UTT_ ## Name;
2839 #define TYPE_TRAIT_2(Spelling, Name, Key) \
2840 case tok::kw_ ## Spelling: return BTT_ ## Name;
2841 #include "clang/Basic/TokenKinds.def"
2842 #define TYPE_TRAIT_N(Spelling, Name, Key) \
2843  case tok::kw_ ## Spelling: return TT_ ## Name;
2844 #include "clang/Basic/TokenKinds.def"
2845  }
2846 }
2847 
2849  switch(kind) {
2850  default: llvm_unreachable("Not a known binary type trait");
2851  case tok::kw___array_rank: return ATT_ArrayRank;
2852  case tok::kw___array_extent: return ATT_ArrayExtent;
2853  }
2854 }
2855 
2857  switch(kind) {
2858  default: llvm_unreachable("Not a known unary expression trait.");
2859  case tok::kw___is_lvalue_expr: return ET_IsLValueExpr;
2860  case tok::kw___is_rvalue_expr: return ET_IsRValueExpr;
2861  }
2862 }
2863 
2865  switch (kind) {
2866  default: llvm_unreachable("Not a known type trait");
2867 #define TYPE_TRAIT(N,Spelling,K) case tok::kw_##Spelling: return N;
2868 #include "clang/Basic/TokenKinds.def"
2869  }
2870 }
2871 
2872 /// \brief Parse the built-in type-trait pseudo-functions that allow
2873 /// implementation of the TR1/C++11 type traits templates.
2874 ///
2875 /// primary-expression:
2876 /// unary-type-trait '(' type-id ')'
2877 /// binary-type-trait '(' type-id ',' type-id ')'
2878 /// type-trait '(' type-id-seq ')'
2879 ///
2880 /// type-id-seq:
2881 /// type-id ...[opt] type-id-seq[opt]
2882 ///
2883 ExprResult Parser::ParseTypeTrait() {
2884  tok::TokenKind Kind = Tok.getKind();
2885  unsigned Arity = TypeTraitArity(Kind);
2886 
2887  SourceLocation Loc = ConsumeToken();
2888 
2889  BalancedDelimiterTracker Parens(*this, tok::l_paren);
2890  if (Parens.expectAndConsume())
2891  return ExprError();
2892 
2894  do {
2895  // Parse the next type.
2896  TypeResult Ty = ParseTypeName();
2897  if (Ty.isInvalid()) {
2898  Parens.skipToEnd();
2899  return ExprError();
2900  }
2901 
2902  // Parse the ellipsis, if present.
2903  if (Tok.is(tok::ellipsis)) {
2904  Ty = Actions.ActOnPackExpansion(Ty.get(), ConsumeToken());
2905  if (Ty.isInvalid()) {
2906  Parens.skipToEnd();
2907  return ExprError();
2908  }
2909  }
2910 
2911  // Add this type to the list of arguments.
2912  Args.push_back(Ty.get());
2913  } while (TryConsumeToken(tok::comma));
2914 
2915  if (Parens.consumeClose())
2916  return ExprError();
2917 
2918  SourceLocation EndLoc = Parens.getCloseLocation();
2919 
2920  if (Arity && Args.size() != Arity) {
2921  Diag(EndLoc, diag::err_type_trait_arity)
2922  << Arity << 0 << (Arity > 1) << (int)Args.size() << SourceRange(Loc);
2923  return ExprError();
2924  }
2925 
2926  if (!Arity && Args.empty()) {
2927  Diag(EndLoc, diag::err_type_trait_arity)
2928  << 1 << 1 << 1 << (int)Args.size() << SourceRange(Loc);
2929  return ExprError();
2930  }
2931 
2932  return Actions.ActOnTypeTrait(TypeTraitFromTokKind(Kind), Loc, Args, EndLoc);
2933 }
2934 
2935 /// ParseArrayTypeTrait - Parse the built-in array type-trait
2936 /// pseudo-functions.
2937 ///
2938 /// primary-expression:
2939 /// [Embarcadero] '__array_rank' '(' type-id ')'
2940 /// [Embarcadero] '__array_extent' '(' type-id ',' expression ')'
2941 ///
2942 ExprResult Parser::ParseArrayTypeTrait() {
2944  SourceLocation Loc = ConsumeToken();
2945 
2946  BalancedDelimiterTracker T(*this, tok::l_paren);
2947  if (T.expectAndConsume())
2948  return ExprError();
2949 
2950  TypeResult Ty = ParseTypeName();
2951  if (Ty.isInvalid()) {
2952  SkipUntil(tok::comma, StopAtSemi);
2953  SkipUntil(tok::r_paren, StopAtSemi);
2954  return ExprError();
2955  }
2956 
2957  switch (ATT) {
2958  case ATT_ArrayRank: {
2959  T.consumeClose();
2960  return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), nullptr,
2961  T.getCloseLocation());
2962  }
2963  case ATT_ArrayExtent: {
2964  if (ExpectAndConsume(tok::comma)) {
2965  SkipUntil(tok::r_paren, StopAtSemi);
2966  return ExprError();
2967  }
2968 
2969  ExprResult DimExpr = ParseExpression();
2970  T.consumeClose();
2971 
2972  return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), DimExpr.get(),
2973  T.getCloseLocation());
2974  }
2975  }
2976  llvm_unreachable("Invalid ArrayTypeTrait!");
2977 }
2978 
2979 /// ParseExpressionTrait - Parse built-in expression-trait
2980 /// pseudo-functions like __is_lvalue_expr( xxx ).
2981 ///
2982 /// primary-expression:
2983 /// [Embarcadero] expression-trait '(' expression ')'
2984 ///
2985 ExprResult Parser::ParseExpressionTrait() {
2987  SourceLocation Loc = ConsumeToken();
2988 
2989  BalancedDelimiterTracker T(*this, tok::l_paren);
2990  if (T.expectAndConsume())
2991  return ExprError();
2992 
2994 
2995  T.consumeClose();
2996 
2997  return Actions.ActOnExpressionTrait(ET, Loc, Expr.get(),
2998  T.getCloseLocation());
2999 }
3000 
3001 
3002 /// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
3003 /// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
3004 /// based on the context past the parens.
3005 ExprResult
3006 Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
3007  ParsedType &CastTy,
3008  BalancedDelimiterTracker &Tracker,
3009  ColonProtectionRAIIObject &ColonProt) {
3010  assert(getLangOpts().CPlusPlus && "Should only be called for C++!");
3011  assert(ExprType == CastExpr && "Compound literals are not ambiguous!");
3012  assert(isTypeIdInParens() && "Not a type-id!");
3013 
3014  ExprResult Result(true);
3015  CastTy = ParsedType();
3016 
3017  // We need to disambiguate a very ugly part of the C++ syntax:
3018  //
3019  // (T())x; - type-id
3020  // (T())*x; - type-id
3021  // (T())/x; - expression
3022  // (T()); - expression
3023  //
3024  // The bad news is that we cannot use the specialized tentative parser, since
3025  // it can only verify that the thing inside the parens can be parsed as
3026  // type-id, it is not useful for determining the context past the parens.
3027  //
3028  // The good news is that the parser can disambiguate this part without
3029  // making any unnecessary Action calls.
3030  //
3031  // It uses a scheme similar to parsing inline methods. The parenthesized
3032  // tokens are cached, the context that follows is determined (possibly by
3033  // parsing a cast-expression), and then we re-introduce the cached tokens
3034  // into the token stream and parse them appropriately.
3035 
3036  ParenParseOption ParseAs;
3037  CachedTokens Toks;
3038 
3039  // Store the tokens of the parentheses. We will parse them after we determine
3040  // the context that follows them.
3041  if (!ConsumeAndStoreUntil(tok::r_paren, Toks)) {
3042  // We didn't find the ')' we expected.
3043  Tracker.consumeClose();
3044  return ExprError();
3045  }
3046 
3047  if (Tok.is(tok::l_brace)) {
3048  ParseAs = CompoundLiteral;
3049  } else {
3050  bool NotCastExpr;
3051  if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) {
3052  NotCastExpr = true;
3053  } else {
3054  // Try parsing the cast-expression that may follow.
3055  // If it is not a cast-expression, NotCastExpr will be true and no token
3056  // will be consumed.
3057  ColonProt.restore();
3058  Result = ParseCastExpression(false/*isUnaryExpression*/,
3059  false/*isAddressofOperand*/,
3060  NotCastExpr,
3061  // type-id has priority.
3062  IsTypeCast);
3063  }
3064 
3065  // If we parsed a cast-expression, it's really a type-id, otherwise it's
3066  // an expression.
3067  ParseAs = NotCastExpr ? SimpleExpr : CastExpr;
3068  }
3069 
3070  // The current token should go after the cached tokens.
3071  Toks.push_back(Tok);
3072  // Re-enter the stored parenthesized tokens into the token stream, so we may
3073  // parse them now.
3074  PP.EnterTokenStream(Toks.data(), Toks.size(),
3075  true/*DisableMacroExpansion*/, false/*OwnsTokens*/);
3076  // Drop the current token and bring the first cached one. It's the same token
3077  // as when we entered this function.
3078  ConsumeAnyToken();
3079 
3080  if (ParseAs >= CompoundLiteral) {
3081  // Parse the type declarator.
3082  DeclSpec DS(AttrFactory);
3083  Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
3084  {
3085  ColonProtectionRAIIObject InnerColonProtection(*this);
3086  ParseSpecifierQualifierList(DS);
3087  ParseDeclarator(DeclaratorInfo);
3088  }
3089 
3090  // Match the ')'.
3091  Tracker.consumeClose();
3092  ColonProt.restore();
3093 
3094  if (ParseAs == CompoundLiteral) {
3095  ExprType = CompoundLiteral;
3096  if (DeclaratorInfo.isInvalidType())
3097  return ExprError();
3098 
3099  TypeResult Ty = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo);
3100  return ParseCompoundLiteralExpression(Ty.get(),
3101  Tracker.getOpenLocation(),
3102  Tracker.getCloseLocation());
3103  }
3104 
3105  // We parsed '(' type-id ')' and the thing after it wasn't a '{'.
3106  assert(ParseAs == CastExpr);
3107 
3108  if (DeclaratorInfo.isInvalidType())
3109  return ExprError();
3110 
3111  // Result is what ParseCastExpression returned earlier.
3112  if (!Result.isInvalid())
3113  Result = Actions.ActOnCastExpr(getCurScope(), Tracker.getOpenLocation(),
3114  DeclaratorInfo, CastTy,
3115  Tracker.getCloseLocation(), Result.get());
3116  return Result;
3117  }
3118 
3119  // Not a compound literal, and not followed by a cast-expression.
3120  assert(ParseAs == SimpleExpr);
3121 
3122  ExprType = SimpleExpr;
3123  Result = ParseExpression();
3124  if (!Result.isInvalid() && Tok.is(tok::r_paren))
3125  Result = Actions.ActOnParenExpr(Tracker.getOpenLocation(),
3126  Tok.getLocation(), Result.get());
3127 
3128  // Match the ')'.
3129  if (Result.isInvalid()) {
3130  SkipUntil(tok::r_paren, StopAtSemi);
3131  return ExprError();
3132  }
3133 
3134  Tracker.consumeClose();
3135  return Result;
3136 }
SourceManager & getSourceManager() const
Definition: Preprocessor.h:682
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:1032
ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT, SourceLocation KWLoc, ParsedType LhsTy, Expr *DimExpr, SourceLocation RParen)
IdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:966
ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc, Declarator &D, ParsedType &Ty, SourceLocation RParenLoc, Expr *CastExpr)
Definition: SemaExpr.cpp:5490
no exception specification
ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)
Simple precedence-based parser for binary/ternary operators.
Definition: ParseExpr.cpp:120
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:1072
static const TSS TSS_unsigned
Definition: DeclSpec.h:273
SourceLocation StartLocation
The location of the first token that describes this unqualified-id, which will be the location of the...
Definition: DeclSpec.h:943
IdentifierInfo * Name
FIXME: Temporarily stores the name of a specialization.
const LangOptions & getLangOpts() const
Definition: Parse/Parser.h:243
static const TST TST_wchar
Definition: DeclSpec.h:280
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
Definition: SemaExpr.cpp:5661
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:916
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)
void setEndLoc(SourceLocation Loc)
Definition: DeclSpec.h:76
static const TST TST_char16
Definition: DeclSpec.h:281
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
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.
ExprResult ActOnExpressionTrait(ExpressionTrait OET, SourceLocation KWLoc, Expr *Queried, SourceLocation RParen)
void CodeCompleteObjCMessageReceiver(Scope *S)
RAII object that enters a new expression evaluation context.
Definition: Sema.h:9016
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:1572
static const TST TST_char
Definition: DeclSpec.h:279
Like System, but searched after the system directories.
void setBegin(SourceLocation b)
SourceLocation getLastCachedTokenLocation() const
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:35
void Finish(DiagnosticsEngine &D, Preprocessor &PP, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:928
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:194
bool SkipUntil(tok::TokenKind T, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
Definition: Parse/Parser.h:861
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()
Definition: Parse/Parser.h:546
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:292
bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS, const DeclSpec &DS, SourceLocation ColonColonLoc)
void setConstructorTemplateId(TemplateIdAnnotation *TemplateId)
Specify that this unqualified-id was parsed as a template-id that names a constructor.
Definition: DeclSpec.cpp:49
bool isUnset() const
Definition: Ownership.h:161
OpaquePtr< QualType > ParsedType
Definition: Ownership.h:233
sema::LambdaScopeInfo * getCurGenericLambda()
Retrieve the current generic lambda info, if any.
Definition: Sema.cpp:1195
ExprResult ExprEmpty()
Definition: Ownership.h:273
void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &attrs, SourceLocation EndLoc)
Definition: DeclSpec.h:1930
void setConversionFunctionId(SourceLocation OperatorLoc, ParsedType Ty, SourceLocation EndLoc)
Specify that this unqualified-id was parsed as a conversion-function-id.
Definition: DeclSpec.h:1000
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:899
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:287
struct OFI OperatorFunctionId
When Kind == IK_OperatorFunctionId, the overloaded operator that we parsed.
Definition: DeclSpec.h:920
ExprResult ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc, bool isType, void *TyOrExpr, SourceLocation RParenLoc)
ActOnCXXUuidof - Parse __uuidof( something ).
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:1711
ExprResult ActOnBooleanCondition(Scope *S, SourceLocation Loc, Expr *SubExpr)
Definition: SemaExpr.cpp:13708
void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro, bool AfterAmpersand)
UnionParsedType DestructorName
When Kind == IK_DestructorName, the type referred to by the class-name.
Definition: DeclSpec.h:932
This is a scope that corresponds to a block/closure object. Blocks serve as top-level scopes for some...
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:869
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)
Definition: SemaDecl.cpp:9341
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
void SetInvalid(SourceRange R)
Indicate that this nested-name-specifier is invalid.
Definition: DeclSpec.h:204
ExprResult ActOnCXXThis(SourceLocation loc)
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:68
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:41
const SourceRange & getSourceRange() const LLVM_READONLY
Definition: DeclSpec.h:496
static SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, unsigned Character, const SourceManager &SM, const LangOptions &LangOpts)
Definition: Lexer.cpp:700
QualType getCanonicalTypeInternal() const
Definition: Type.h:1951
bool isInvalid() const
static const TST TST_float
Definition: DeclSpec.h:286
TypeTrait
Names for traits that operate specifically on types.
Definition: TypeTraits.h:21
AnnotatingParser & P
void * getAnnotationValue() const
Definition: Token.h:224
DeclSpec & getMutableDeclSpec()
Definition: DeclSpec.h:1683
static const TSW TSW_long
Definition: DeclSpec.h:260
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit, bool TypeMayContainAuto)
Definition: SemaDecl.cpp:8838
void SetRangeStart(SourceLocation Loc)
Definition: DeclSpec.h:596
TypeResult ParseTypeName(SourceRange *Range=nullptr, Declarator::TheContext Context=Declarator::TypeNameContext, AccessSpecifier AS=AS_none, Decl **OwnedType=nullptr, ParsedAttributes *Attrs=nullptr)
Definition: ParseDecl.cpp:41
SmallVector< LambdaCapture, 4 > Captures
Definition: DeclSpec.h:2274
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)
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)
This file defines the classes used to store parsed information about declaration-specifiers and decla...
TypeResult ActOnTypeName(Scope *S, Declarator &D)
Definition: SemaType.cpp:4868
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:260
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. Be careful when changing this: this...
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.
const SourceRange & getRange() const
Definition: DeclSpec.h:73
void setLiteralOperatorId(const IdentifierInfo *Id, SourceLocation OpLoc, SourceLocation IdLoc)
Specific that this unqualified-id was parsed as a literal-operator-id.
Definition: DeclSpec.h:1017
static const TST TST_int
Definition: DeclSpec.h:283
bool SetTypeSpecSign(TSS S, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID)
Definition: DeclSpec.cpp:594
static const TST TST_half
Definition: DeclSpec.h:285
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:1116
The result type of a method or function.
SourceLocation getAnnotationEndLoc() const
Definition: Token.h:138
static const TSW TSW_short
Definition: DeclSpec.h:259
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:486
bool SetTypeSpecWidth(TSW W, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:569
bool isValid() const
Determine whether this unqualified-id refers to a valid name.
Definition: DeclSpec.h:960
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:3488
static const TST TST_char32
Definition: DeclSpec.h:282
ParsedType getDestructorType(const DeclSpec &DS, ParsedType ObjectType)
bool isInvalid() const
Determine whether this unqualified-id refers to an invalid name.
Definition: DeclSpec.h:963
SourceLocation DefaultLoc
Definition: DeclSpec.h:2272
Kind
Represents the parsed form of a C++ template argument.
SmallVectorImpl< AnnotatedLine * >::const_iterator Next
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
void addCapture(LambdaCaptureKind Kind, SourceLocation Loc, IdentifierInfo *Id, SourceLocation EllipsisLoc, ExprResult Init, ParsedType InitCaptureType)
Append a capture in a lambda introducer.
Definition: DeclSpec.h:2280
void setLength(unsigned Len)
Definition: Token.h:133
An overloaded operator name, e.g., operator+.
Definition: DeclSpec.h:880
void FinalizeDeclaration(Decl *D)
Definition: SemaDecl.cpp:9850
bool isValid() const
Return true if this is a valid SourceLocation object.
ASTContext & getASTContext() const
Definition: Sema.h:1026
void setAnnotationEndLoc(SourceLocation L)
Definition: Token.h:142
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:685
Scope * getCurScope() const
Definition: Parse/Parser.h:250
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:272
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
QualType performLambdaInitCaptureInitialization(SourceLocation Loc, bool ByRef, IdentifierInfo *Id, Expr *&Init)
Perform initialization analysis of the init-capture and perform any implicit conversions such as an l...
Definition: SemaLambda.cpp:701
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, SourceLocation ESpecLoc, ParsedType *Exceptions, SourceRange *ExceptionRanges, unsigned NumExceptions, Expr *NoexceptExpr, CachedTokens *ExceptionSpecTokens, SourceLocation LocalRangeBegin, SourceLocation LocalRangeEnd, Declarator &TheDeclarator, TypeResult TrailingReturnType=TypeResult())
Definition: DeclSpec.cpp:162
SourceLocation getBegin() const
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:77
PtrTy get() const
Definition: Ownership.h:74
bool is(tok::TokenKind K) const
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:1468
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)
LambdaCaptureDefault Default
Definition: DeclSpec.h:2273
bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS, IdentifierInfo &Identifier, SourceLocation IdentifierLoc, SourceLocation ColonLoc, ParsedType ObjectType, bool EnteringContext)
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
static const TST TST_void
Definition: DeclSpec.h:278
CXXScopeSpec SS
The nested-name-specifier that precedes the template name.
static const TST TST_int128
Definition: DeclSpec.h:284
void RecordParsingTemplateParameterDepth(unsigned Depth)
This is used to inform Sema what the current TemplateParameterDepth is during Parsing. Currently it is used to pass on the depth when parsing generic lambda 'auto' parameters.
Definition: Sema.cpp:1122
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)
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:196
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition: Token.h:97
void ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro, Declarator &ParamInfo, Scope *CurScope)
Definition: SemaLambda.cpp:838
void takeAttributesFrom(ParsedAttributes &attrs)
Definition: DeclSpec.h:738
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)
void setOperatorFunctionId(SourceLocation OperatorLoc, OverloadedOperatorKind Op, SourceLocation SymbolLocations[3])
Specify that this unqualified-id was parsed as an operator-function-id.
Definition: DeclSpec.cpp:1215
static const TST TST_typename
Definition: DeclSpec.h:297
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
Capturing the this pointer.
Definition: Lambda.h:35
bool isUsable() const
Definition: Ownership.h:160
This is a scope that can contain a declaration. Some scopes just contain loop constructs but don't co...
Definition: Scope.h:57
bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const PrintingPolicy &Policy)
Definition: DeclSpec.cpp:683
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:2066
static ParsedType getTypeAnnotation(Token &Tok)
getTypeAnnotation - Read a parsed type out of an annotation token.
Definition: Parse/Parser.h:551
ExprResult ParseConstantExpression(TypeCastState isTypeCast=NotTypeCast)
Definition: ParseExpr.cpp:195
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:233
void setEnd(SourceLocation e)
bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS, SourceLocation IdLoc, IdentifierInfo &II, ParsedType ObjectType)
SourceLocation ConsumeToken()
Definition: Parse/Parser.h:284
static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind)
A user-defined literal name, e.g., operator "" _i.
Definition: DeclSpec.h:884
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:288
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
Represents a complete lambda introducer.
Definition: DeclSpec.h:2255
ExprResult ExprError()
Definition: Ownership.h:267
static const TSW TSW_longlong
Definition: DeclSpec.h:261
bool isSet() const
Definition: DeclSpec.h:214
Code completion occurs within the condition of an if, while, switch, or for statement.
Definition: Sema.h:8617
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:372
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Specify that this unqualified-id was parsed as an identifier.
Definition: DeclSpec.h:973
bool isInvalidType() const
Definition: DeclSpec.h:2163
bool SetTypeSpecError()
Definition: DeclSpec.cpp:748
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:1055
void SetRangeEnd(SourceLocation Loc)
Definition: DeclSpec.h:597
void set(PtrTy P)
Definition: Ownership.h:78
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
const DeclSpec & getDeclSpec() const
Definition: DeclSpec.h:1676
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:843
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:177