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
14 #include "clang/Parse/ParseDiagnostic.h"
15 #include "clang/Parse/Parser.h"
16 #include "RAIIObjectsForParser.h"
17 #include "clang/Basic/PrettyStackTrace.h"
18 #include "clang/Lex/LiteralSupport.h"
19 #include "clang/Sema/DeclSpec.h"
20 #include "clang/Sema/Scope.h"
21 #include "clang/Sema/ParsedTemplate.h"
22 #include "llvm/Support/ErrorHandling.h"
23
24 using namespace clang;
25
SelectDigraphErrorMessage(tok::TokenKind Kind)26 static int SelectDigraphErrorMessage(tok::TokenKind Kind) {
27 switch (Kind) {
28 case tok::kw_template: return 0;
29 case tok::kw_const_cast: return 1;
30 case tok::kw_dynamic_cast: return 2;
31 case tok::kw_reinterpret_cast: return 3;
32 case tok::kw_static_cast: return 4;
33 default:
34 llvm_unreachable("Unknown type for digraph error message.");
35 }
36 }
37
38 // Are the two tokens adjacent in the same source file?
areTokensAdjacent(const Token & First,const Token & Second)39 bool Parser::areTokensAdjacent(const Token &First, const Token &Second) {
40 SourceManager &SM = PP.getSourceManager();
41 SourceLocation FirstLoc = SM.getSpellingLoc(First.getLocation());
42 SourceLocation FirstEnd = FirstLoc.getLocWithOffset(First.getLength());
43 return FirstEnd == SM.getSpellingLoc(Second.getLocation());
44 }
45
46 // Suggest fixit for "<::" after a cast.
FixDigraph(Parser & P,Preprocessor & PP,Token & DigraphToken,Token & ColonToken,tok::TokenKind Kind,bool AtDigraph)47 static void FixDigraph(Parser &P, Preprocessor &PP, Token &DigraphToken,
48 Token &ColonToken, tok::TokenKind Kind, bool AtDigraph) {
49 // Pull '<:' and ':' off token stream.
50 if (!AtDigraph)
51 PP.Lex(DigraphToken);
52 PP.Lex(ColonToken);
53
54 SourceRange Range;
55 Range.setBegin(DigraphToken.getLocation());
56 Range.setEnd(ColonToken.getLocation());
57 P.Diag(DigraphToken.getLocation(), diag::err_missing_whitespace_digraph)
58 << SelectDigraphErrorMessage(Kind)
59 << FixItHint::CreateReplacement(Range, "< ::");
60
61 // Update token information to reflect their change in token type.
62 ColonToken.setKind(tok::coloncolon);
63 ColonToken.setLocation(ColonToken.getLocation().getLocWithOffset(-1));
64 ColonToken.setLength(2);
65 DigraphToken.setKind(tok::less);
66 DigraphToken.setLength(1);
67
68 // Push new tokens back to token stream.
69 PP.EnterToken(ColonToken);
70 if (!AtDigraph)
71 PP.EnterToken(DigraphToken);
72 }
73
74 // Check for '<::' which should be '< ::' instead of '[:' when following
75 // a template name.
CheckForTemplateAndDigraph(Token & Next,ParsedType ObjectType,bool EnteringContext,IdentifierInfo & II,CXXScopeSpec & SS)76 void Parser::CheckForTemplateAndDigraph(Token &Next, ParsedType ObjectType,
77 bool EnteringContext,
78 IdentifierInfo &II, CXXScopeSpec &SS) {
79 if (!Next.is(tok::l_square) || Next.getLength() != 2)
80 return;
81
82 Token SecondToken = GetLookAheadToken(2);
83 if (!SecondToken.is(tok::colon) || !areTokensAdjacent(Next, SecondToken))
84 return;
85
86 TemplateTy Template;
87 UnqualifiedId TemplateName;
88 TemplateName.setIdentifier(&II, Tok.getLocation());
89 bool MemberOfUnknownSpecialization;
90 if (!Actions.isTemplateName(getCurScope(), SS, /*hasTemplateKeyword=*/false,
91 TemplateName, ObjectType, EnteringContext,
92 Template, MemberOfUnknownSpecialization))
93 return;
94
95 FixDigraph(*this, PP, Next, SecondToken, tok::kw_template,
96 /*AtDigraph*/false);
97 }
98
99 /// \brief Parse global scope or nested-name-specifier if present.
100 ///
101 /// Parses a C++ global scope specifier ('::') or nested-name-specifier (which
102 /// may be preceded by '::'). Note that this routine will not parse ::new or
103 /// ::delete; it will just leave them in the token stream.
104 ///
105 /// '::'[opt] nested-name-specifier
106 /// '::'
107 ///
108 /// nested-name-specifier:
109 /// type-name '::'
110 /// namespace-name '::'
111 /// nested-name-specifier identifier '::'
112 /// nested-name-specifier 'template'[opt] simple-template-id '::'
113 ///
114 ///
115 /// \param SS the scope specifier that will be set to the parsed
116 /// nested-name-specifier (or empty)
117 ///
118 /// \param ObjectType if this nested-name-specifier is being parsed following
119 /// the "." or "->" of a member access expression, this parameter provides the
120 /// type of the object whose members are being accessed.
121 ///
122 /// \param EnteringContext whether we will be entering into the context of
123 /// the nested-name-specifier after parsing it.
124 ///
125 /// \param MayBePseudoDestructor When non-NULL, points to a flag that
126 /// indicates whether this nested-name-specifier may be part of a
127 /// pseudo-destructor name. In this case, the flag will be set false
128 /// if we don't actually end up parsing a destructor name. Moreorover,
129 /// if we do end up determining that we are parsing a destructor name,
130 /// the last component of the nested-name-specifier is not parsed as
131 /// part of the scope specifier.
132
133 /// member access expression, e.g., the \p T:: in \p p->T::m.
134 ///
135 /// \returns true if there was an error parsing a scope specifier
ParseOptionalCXXScopeSpecifier(CXXScopeSpec & SS,ParsedType ObjectType,bool EnteringContext,bool * MayBePseudoDestructor,bool IsTypename)136 bool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS,
137 ParsedType ObjectType,
138 bool EnteringContext,
139 bool *MayBePseudoDestructor,
140 bool IsTypename) {
141 assert(getLangOpts().CPlusPlus &&
142 "Call sites of this function should be guarded by checking for C++");
143
144 if (Tok.is(tok::annot_cxxscope)) {
145 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
146 Tok.getAnnotationRange(),
147 SS);
148 ConsumeToken();
149 return false;
150 }
151
152 bool HasScopeSpecifier = false;
153
154 if (Tok.is(tok::coloncolon)) {
155 // ::new and ::delete aren't nested-name-specifiers.
156 tok::TokenKind NextKind = NextToken().getKind();
157 if (NextKind == tok::kw_new || NextKind == tok::kw_delete)
158 return false;
159
160 // '::' - Global scope qualifier.
161 if (Actions.ActOnCXXGlobalScopeSpecifier(getCurScope(), ConsumeToken(), SS))
162 return true;
163
164 HasScopeSpecifier = true;
165 }
166
167 bool CheckForDestructor = false;
168 if (MayBePseudoDestructor && *MayBePseudoDestructor) {
169 CheckForDestructor = true;
170 *MayBePseudoDestructor = false;
171 }
172
173 if (Tok.is(tok::kw_decltype) || Tok.is(tok::annot_decltype)) {
174 DeclSpec DS(AttrFactory);
175 SourceLocation DeclLoc = Tok.getLocation();
176 SourceLocation EndLoc = ParseDecltypeSpecifier(DS);
177 if (Tok.isNot(tok::coloncolon)) {
178 AnnotateExistingDecltypeSpecifier(DS, DeclLoc, EndLoc);
179 return false;
180 }
181
182 SourceLocation CCLoc = ConsumeToken();
183 if (Actions.ActOnCXXNestedNameSpecifierDecltype(SS, DS, CCLoc))
184 SS.SetInvalid(SourceRange(DeclLoc, CCLoc));
185
186 HasScopeSpecifier = true;
187 }
188
189 while (true) {
190 if (HasScopeSpecifier) {
191 // C++ [basic.lookup.classref]p5:
192 // If the qualified-id has the form
193 //
194 // ::class-name-or-namespace-name::...
195 //
196 // the class-name-or-namespace-name is looked up in global scope as a
197 // class-name or namespace-name.
198 //
199 // To implement this, we clear out the object type as soon as we've
200 // seen a leading '::' or part of a nested-name-specifier.
201 ObjectType = ParsedType();
202
203 if (Tok.is(tok::code_completion)) {
204 // Code completion for a nested-name-specifier, where the code
205 // code completion token follows the '::'.
206 Actions.CodeCompleteQualifiedId(getCurScope(), SS, EnteringContext);
207 // Include code completion token into the range of the scope otherwise
208 // when we try to annotate the scope tokens the dangling code completion
209 // token will cause assertion in
210 // Preprocessor::AnnotatePreviousCachedTokens.
211 SS.setEndLoc(Tok.getLocation());
212 cutOffParsing();
213 return true;
214 }
215 }
216
217 // nested-name-specifier:
218 // nested-name-specifier 'template'[opt] simple-template-id '::'
219
220 // Parse the optional 'template' keyword, then make sure we have
221 // 'identifier <' after it.
222 if (Tok.is(tok::kw_template)) {
223 // If we don't have a scope specifier or an object type, this isn't a
224 // nested-name-specifier, since they aren't allowed to start with
225 // 'template'.
226 if (!HasScopeSpecifier && !ObjectType)
227 break;
228
229 TentativeParsingAction TPA(*this);
230 SourceLocation TemplateKWLoc = ConsumeToken();
231
232 UnqualifiedId TemplateName;
233 if (Tok.is(tok::identifier)) {
234 // Consume the identifier.
235 TemplateName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
236 ConsumeToken();
237 } else if (Tok.is(tok::kw_operator)) {
238 if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType,
239 TemplateName)) {
240 TPA.Commit();
241 break;
242 }
243
244 if (TemplateName.getKind() != UnqualifiedId::IK_OperatorFunctionId &&
245 TemplateName.getKind() != UnqualifiedId::IK_LiteralOperatorId) {
246 Diag(TemplateName.getSourceRange().getBegin(),
247 diag::err_id_after_template_in_nested_name_spec)
248 << TemplateName.getSourceRange();
249 TPA.Commit();
250 break;
251 }
252 } else {
253 TPA.Revert();
254 break;
255 }
256
257 // If the next token is not '<', we have a qualified-id that refers
258 // to a template name, such as T::template apply, but is not a
259 // template-id.
260 if (Tok.isNot(tok::less)) {
261 TPA.Revert();
262 break;
263 }
264
265 // Commit to parsing the template-id.
266 TPA.Commit();
267 TemplateTy Template;
268 if (TemplateNameKind TNK
269 = Actions.ActOnDependentTemplateName(getCurScope(),
270 SS, TemplateKWLoc, TemplateName,
271 ObjectType, EnteringContext,
272 Template)) {
273 if (AnnotateTemplateIdToken(Template, TNK, SS, TemplateKWLoc,
274 TemplateName, false))
275 return true;
276 } else
277 return true;
278
279 continue;
280 }
281
282 if (Tok.is(tok::annot_template_id) && NextToken().is(tok::coloncolon)) {
283 // We have
284 //
285 // simple-template-id '::'
286 //
287 // So we need to check whether the simple-template-id is of the
288 // right kind (it should name a type or be dependent), and then
289 // convert it into a type within the nested-name-specifier.
290 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
291 if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde)) {
292 *MayBePseudoDestructor = true;
293 return false;
294 }
295
296 // Consume the template-id token.
297 ConsumeToken();
298
299 assert(Tok.is(tok::coloncolon) && "NextToken() not working properly!");
300 SourceLocation CCLoc = ConsumeToken();
301
302 HasScopeSpecifier = true;
303
304 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
305 TemplateId->NumArgs);
306
307 if (Actions.ActOnCXXNestedNameSpecifier(getCurScope(),
308 SS,
309 TemplateId->TemplateKWLoc,
310 TemplateId->Template,
311 TemplateId->TemplateNameLoc,
312 TemplateId->LAngleLoc,
313 TemplateArgsPtr,
314 TemplateId->RAngleLoc,
315 CCLoc,
316 EnteringContext)) {
317 SourceLocation StartLoc
318 = SS.getBeginLoc().isValid()? SS.getBeginLoc()
319 : TemplateId->TemplateNameLoc;
320 SS.SetInvalid(SourceRange(StartLoc, CCLoc));
321 }
322
323 continue;
324 }
325
326
327 // The rest of the nested-name-specifier possibilities start with
328 // tok::identifier.
329 if (Tok.isNot(tok::identifier))
330 break;
331
332 IdentifierInfo &II = *Tok.getIdentifierInfo();
333
334 // nested-name-specifier:
335 // type-name '::'
336 // namespace-name '::'
337 // nested-name-specifier identifier '::'
338 Token Next = NextToken();
339
340 // If we get foo:bar, this is almost certainly a typo for foo::bar. Recover
341 // and emit a fixit hint for it.
342 if (Next.is(tok::colon) && !ColonIsSacred) {
343 if (Actions.IsInvalidUnlessNestedName(getCurScope(), SS, II,
344 Tok.getLocation(),
345 Next.getLocation(), ObjectType,
346 EnteringContext) &&
347 // If the token after the colon isn't an identifier, it's still an
348 // error, but they probably meant something else strange so don't
349 // recover like this.
350 PP.LookAhead(1).is(tok::identifier)) {
351 Diag(Next, diag::err_unexected_colon_in_nested_name_spec)
352 << FixItHint::CreateReplacement(Next.getLocation(), "::");
353
354 // Recover as if the user wrote '::'.
355 Next.setKind(tok::coloncolon);
356 }
357 }
358
359 if (Next.is(tok::coloncolon)) {
360 if (CheckForDestructor && GetLookAheadToken(2).is(tok::tilde) &&
361 !Actions.isNonTypeNestedNameSpecifier(getCurScope(), SS, Tok.getLocation(),
362 II, ObjectType)) {
363 *MayBePseudoDestructor = true;
364 return false;
365 }
366
367 // We have an identifier followed by a '::'. Lookup this name
368 // as the name in a nested-name-specifier.
369 SourceLocation IdLoc = ConsumeToken();
370 assert((Tok.is(tok::coloncolon) || Tok.is(tok::colon)) &&
371 "NextToken() not working properly!");
372 SourceLocation CCLoc = ConsumeToken();
373
374 HasScopeSpecifier = true;
375 if (Actions.ActOnCXXNestedNameSpecifier(getCurScope(), II, IdLoc, CCLoc,
376 ObjectType, EnteringContext, SS))
377 SS.SetInvalid(SourceRange(IdLoc, CCLoc));
378
379 continue;
380 }
381
382 CheckForTemplateAndDigraph(Next, ObjectType, EnteringContext, II, SS);
383
384 // nested-name-specifier:
385 // type-name '<'
386 if (Next.is(tok::less)) {
387 TemplateTy Template;
388 UnqualifiedId TemplateName;
389 TemplateName.setIdentifier(&II, Tok.getLocation());
390 bool MemberOfUnknownSpecialization;
391 if (TemplateNameKind TNK = Actions.isTemplateName(getCurScope(), SS,
392 /*hasTemplateKeyword=*/false,
393 TemplateName,
394 ObjectType,
395 EnteringContext,
396 Template,
397 MemberOfUnknownSpecialization)) {
398 // We have found a template name, so annotate this token
399 // with a template-id annotation. We do not permit the
400 // template-id to be translated into a type annotation,
401 // because some clients (e.g., the parsing of class template
402 // specializations) still want to see the original template-id
403 // token.
404 ConsumeToken();
405 if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
406 TemplateName, false))
407 return true;
408 continue;
409 }
410
411 if (MemberOfUnknownSpecialization && (ObjectType || SS.isSet()) &&
412 (IsTypename || IsTemplateArgumentList(1))) {
413 // We have something like t::getAs<T>, where getAs is a
414 // member of an unknown specialization. However, this will only
415 // parse correctly as a template, so suggest the keyword 'template'
416 // before 'getAs' and treat this as a dependent template name.
417 unsigned DiagID = diag::err_missing_dependent_template_keyword;
418 if (getLangOpts().MicrosoftExt)
419 DiagID = diag::warn_missing_dependent_template_keyword;
420
421 Diag(Tok.getLocation(), DiagID)
422 << II.getName()
423 << FixItHint::CreateInsertion(Tok.getLocation(), "template ");
424
425 if (TemplateNameKind TNK
426 = Actions.ActOnDependentTemplateName(getCurScope(),
427 SS, SourceLocation(),
428 TemplateName, ObjectType,
429 EnteringContext, Template)) {
430 // Consume the identifier.
431 ConsumeToken();
432 if (AnnotateTemplateIdToken(Template, TNK, SS, SourceLocation(),
433 TemplateName, false))
434 return true;
435 }
436 else
437 return true;
438
439 continue;
440 }
441 }
442
443 // We don't have any tokens that form the beginning of a
444 // nested-name-specifier, so we're done.
445 break;
446 }
447
448 // Even if we didn't see any pieces of a nested-name-specifier, we
449 // still check whether there is a tilde in this position, which
450 // indicates a potential pseudo-destructor.
451 if (CheckForDestructor && Tok.is(tok::tilde))
452 *MayBePseudoDestructor = true;
453
454 return false;
455 }
456
457 /// ParseCXXIdExpression - Handle id-expression.
458 ///
459 /// id-expression:
460 /// unqualified-id
461 /// qualified-id
462 ///
463 /// qualified-id:
464 /// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
465 /// '::' identifier
466 /// '::' operator-function-id
467 /// '::' template-id
468 ///
469 /// NOTE: The standard specifies that, for qualified-id, the parser does not
470 /// expect:
471 ///
472 /// '::' conversion-function-id
473 /// '::' '~' class-name
474 ///
475 /// This may cause a slight inconsistency on diagnostics:
476 ///
477 /// class C {};
478 /// namespace A {}
479 /// void f() {
480 /// :: A :: ~ C(); // Some Sema error about using destructor with a
481 /// // namespace.
482 /// :: ~ C(); // Some Parser error like 'unexpected ~'.
483 /// }
484 ///
485 /// We simplify the parser a bit and make it work like:
486 ///
487 /// qualified-id:
488 /// '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
489 /// '::' unqualified-id
490 ///
491 /// That way Sema can handle and report similar errors for namespaces and the
492 /// global scope.
493 ///
494 /// The isAddressOfOperand parameter indicates that this id-expression is a
495 /// direct operand of the address-of operator. This is, besides member contexts,
496 /// the only place where a qualified-id naming a non-static class member may
497 /// appear.
498 ///
ParseCXXIdExpression(bool isAddressOfOperand)499 ExprResult Parser::ParseCXXIdExpression(bool isAddressOfOperand) {
500 // qualified-id:
501 // '::'[opt] nested-name-specifier 'template'[opt] unqualified-id
502 // '::' unqualified-id
503 //
504 CXXScopeSpec SS;
505 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), /*EnteringContext=*/false);
506
507 SourceLocation TemplateKWLoc;
508 UnqualifiedId Name;
509 if (ParseUnqualifiedId(SS,
510 /*EnteringContext=*/false,
511 /*AllowDestructorName=*/false,
512 /*AllowConstructorName=*/false,
513 /*ObjectType=*/ ParsedType(),
514 TemplateKWLoc,
515 Name))
516 return ExprError();
517
518 // This is only the direct operand of an & operator if it is not
519 // followed by a postfix-expression suffix.
520 if (isAddressOfOperand && isPostfixExpressionSuffixStart())
521 isAddressOfOperand = false;
522
523 return Actions.ActOnIdExpression(getCurScope(), SS, TemplateKWLoc, Name,
524 Tok.is(tok::l_paren), isAddressOfOperand);
525 }
526
527 /// ParseLambdaExpression - Parse a C++0x lambda expression.
528 ///
529 /// lambda-expression:
530 /// lambda-introducer lambda-declarator[opt] compound-statement
531 ///
532 /// lambda-introducer:
533 /// '[' lambda-capture[opt] ']'
534 ///
535 /// lambda-capture:
536 /// capture-default
537 /// capture-list
538 /// capture-default ',' capture-list
539 ///
540 /// capture-default:
541 /// '&'
542 /// '='
543 ///
544 /// capture-list:
545 /// capture
546 /// capture-list ',' capture
547 ///
548 /// capture:
549 /// identifier
550 /// '&' identifier
551 /// 'this'
552 ///
553 /// lambda-declarator:
554 /// '(' parameter-declaration-clause ')' attribute-specifier[opt]
555 /// 'mutable'[opt] exception-specification[opt]
556 /// trailing-return-type[opt]
557 ///
ParseLambdaExpression()558 ExprResult Parser::ParseLambdaExpression() {
559 // Parse lambda-introducer.
560 LambdaIntroducer Intro;
561
562 llvm::Optional<unsigned> DiagID(ParseLambdaIntroducer(Intro));
563 if (DiagID) {
564 Diag(Tok, DiagID.getValue());
565 SkipUntil(tok::r_square);
566 SkipUntil(tok::l_brace);
567 SkipUntil(tok::r_brace);
568 return ExprError();
569 }
570
571 return ParseLambdaExpressionAfterIntroducer(Intro);
572 }
573
574 /// TryParseLambdaExpression - Use lookahead and potentially tentative
575 /// parsing to determine if we are looking at a C++0x lambda expression, and parse
576 /// it if we are.
577 ///
578 /// If we are not looking at a lambda expression, returns ExprError().
TryParseLambdaExpression()579 ExprResult Parser::TryParseLambdaExpression() {
580 assert(getLangOpts().CPlusPlus0x
581 && Tok.is(tok::l_square)
582 && "Not at the start of a possible lambda expression.");
583
584 const Token Next = NextToken(), After = GetLookAheadToken(2);
585
586 // If lookahead indicates this is a lambda...
587 if (Next.is(tok::r_square) || // []
588 Next.is(tok::equal) || // [=
589 (Next.is(tok::amp) && // [&] or [&,
590 (After.is(tok::r_square) ||
591 After.is(tok::comma))) ||
592 (Next.is(tok::identifier) && // [identifier]
593 After.is(tok::r_square))) {
594 return ParseLambdaExpression();
595 }
596
597 // If lookahead indicates an ObjC message send...
598 // [identifier identifier
599 if (Next.is(tok::identifier) && After.is(tok::identifier)) {
600 return ExprEmpty();
601 }
602
603 // Here, we're stuck: lambda introducers and Objective-C message sends are
604 // unambiguous, but it requires arbitrary lookhead. [a,b,c,d,e,f,g] is a
605 // lambda, and [a,b,c,d,e,f,g h] is a Objective-C message send. Instead of
606 // writing two routines to parse a lambda introducer, just try to parse
607 // a lambda introducer first, and fall back if that fails.
608 // (TryParseLambdaIntroducer never produces any diagnostic output.)
609 LambdaIntroducer Intro;
610 if (TryParseLambdaIntroducer(Intro))
611 return ExprEmpty();
612 return ParseLambdaExpressionAfterIntroducer(Intro);
613 }
614
615 /// ParseLambdaExpression - Parse a lambda introducer.
616 ///
617 /// Returns a DiagnosticID if it hit something unexpected.
ParseLambdaIntroducer(LambdaIntroducer & Intro)618 llvm::Optional<unsigned> Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro){
619 typedef llvm::Optional<unsigned> DiagResult;
620
621 assert(Tok.is(tok::l_square) && "Lambda expressions begin with '['.");
622 BalancedDelimiterTracker T(*this, tok::l_square);
623 T.consumeOpen();
624
625 Intro.Range.setBegin(T.getOpenLocation());
626
627 bool first = true;
628
629 // Parse capture-default.
630 if (Tok.is(tok::amp) &&
631 (NextToken().is(tok::comma) || NextToken().is(tok::r_square))) {
632 Intro.Default = LCD_ByRef;
633 Intro.DefaultLoc = ConsumeToken();
634 first = false;
635 } else if (Tok.is(tok::equal)) {
636 Intro.Default = LCD_ByCopy;
637 Intro.DefaultLoc = ConsumeToken();
638 first = false;
639 }
640
641 while (Tok.isNot(tok::r_square)) {
642 if (!first) {
643 if (Tok.isNot(tok::comma)) {
644 // Provide a completion for a lambda introducer here. Except
645 // in Objective-C, where this is Almost Surely meant to be a message
646 // send. In that case, fail here and let the ObjC message
647 // expression parser perform the completion.
648 if (Tok.is(tok::code_completion) &&
649 !(getLangOpts().ObjC1 && Intro.Default == LCD_None &&
650 !Intro.Captures.empty())) {
651 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
652 /*AfterAmpersand=*/false);
653 ConsumeCodeCompletionToken();
654 break;
655 }
656
657 return DiagResult(diag::err_expected_comma_or_rsquare);
658 }
659 ConsumeToken();
660 }
661
662 if (Tok.is(tok::code_completion)) {
663 // If we're in Objective-C++ and we have a bare '[', then this is more
664 // likely to be a message receiver.
665 if (getLangOpts().ObjC1 && first)
666 Actions.CodeCompleteObjCMessageReceiver(getCurScope());
667 else
668 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
669 /*AfterAmpersand=*/false);
670 ConsumeCodeCompletionToken();
671 break;
672 }
673
674 first = false;
675
676 // Parse capture.
677 LambdaCaptureKind Kind = LCK_ByCopy;
678 SourceLocation Loc;
679 IdentifierInfo* Id = 0;
680 SourceLocation EllipsisLoc;
681
682 if (Tok.is(tok::kw_this)) {
683 Kind = LCK_This;
684 Loc = ConsumeToken();
685 } else {
686 if (Tok.is(tok::amp)) {
687 Kind = LCK_ByRef;
688 ConsumeToken();
689
690 if (Tok.is(tok::code_completion)) {
691 Actions.CodeCompleteLambdaIntroducer(getCurScope(), Intro,
692 /*AfterAmpersand=*/true);
693 ConsumeCodeCompletionToken();
694 break;
695 }
696 }
697
698 if (Tok.is(tok::identifier)) {
699 Id = Tok.getIdentifierInfo();
700 Loc = ConsumeToken();
701
702 if (Tok.is(tok::ellipsis))
703 EllipsisLoc = ConsumeToken();
704 } else if (Tok.is(tok::kw_this)) {
705 // FIXME: If we want to suggest a fixit here, will need to return more
706 // than just DiagnosticID. Perhaps full DiagnosticBuilder that can be
707 // Clear()ed to prevent emission in case of tentative parsing?
708 return DiagResult(diag::err_this_captured_by_reference);
709 } else {
710 return DiagResult(diag::err_expected_capture);
711 }
712 }
713
714 Intro.addCapture(Kind, Loc, Id, EllipsisLoc);
715 }
716
717 T.consumeClose();
718 Intro.Range.setEnd(T.getCloseLocation());
719
720 return DiagResult();
721 }
722
723 /// TryParseLambdaIntroducer - Tentatively parse a lambda introducer.
724 ///
725 /// Returns true if it hit something unexpected.
TryParseLambdaIntroducer(LambdaIntroducer & Intro)726 bool Parser::TryParseLambdaIntroducer(LambdaIntroducer &Intro) {
727 TentativeParsingAction PA(*this);
728
729 llvm::Optional<unsigned> DiagID(ParseLambdaIntroducer(Intro));
730
731 if (DiagID) {
732 PA.Revert();
733 return true;
734 }
735
736 PA.Commit();
737 return false;
738 }
739
740 /// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
741 /// expression.
ParseLambdaExpressionAfterIntroducer(LambdaIntroducer & Intro)742 ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
743 LambdaIntroducer &Intro) {
744 SourceLocation LambdaBeginLoc = Intro.Range.getBegin();
745 Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);
746
747 PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc,
748 "lambda expression parsing");
749
750 // Parse lambda-declarator[opt].
751 DeclSpec DS(AttrFactory);
752 Declarator D(DS, Declarator::LambdaExprContext);
753
754 if (Tok.is(tok::l_paren)) {
755 ParseScope PrototypeScope(this,
756 Scope::FunctionPrototypeScope |
757 Scope::DeclScope);
758
759 SourceLocation DeclLoc, DeclEndLoc;
760 BalancedDelimiterTracker T(*this, tok::l_paren);
761 T.consumeOpen();
762 DeclLoc = T.getOpenLocation();
763
764 // Parse parameter-declaration-clause.
765 ParsedAttributes Attr(AttrFactory);
766 llvm::SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
767 SourceLocation EllipsisLoc;
768
769 if (Tok.isNot(tok::r_paren))
770 ParseParameterDeclarationClause(D, Attr, ParamInfo, EllipsisLoc);
771
772 T.consumeClose();
773 DeclEndLoc = T.getCloseLocation();
774
775 // Parse 'mutable'[opt].
776 SourceLocation MutableLoc;
777 if (Tok.is(tok::kw_mutable)) {
778 MutableLoc = ConsumeToken();
779 DeclEndLoc = MutableLoc;
780 }
781
782 // Parse exception-specification[opt].
783 ExceptionSpecificationType ESpecType = EST_None;
784 SourceRange ESpecRange;
785 llvm::SmallVector<ParsedType, 2> DynamicExceptions;
786 llvm::SmallVector<SourceRange, 2> DynamicExceptionRanges;
787 ExprResult NoexceptExpr;
788 ESpecType = tryParseExceptionSpecification(ESpecRange,
789 DynamicExceptions,
790 DynamicExceptionRanges,
791 NoexceptExpr);
792
793 if (ESpecType != EST_None)
794 DeclEndLoc = ESpecRange.getEnd();
795
796 // Parse attribute-specifier[opt].
797 MaybeParseCXX0XAttributes(Attr, &DeclEndLoc);
798
799 // Parse trailing-return-type[opt].
800 TypeResult TrailingReturnType;
801 if (Tok.is(tok::arrow)) {
802 SourceRange Range;
803 TrailingReturnType = ParseTrailingReturnType(Range);
804 if (Range.getEnd().isValid())
805 DeclEndLoc = Range.getEnd();
806 }
807
808 PrototypeScope.Exit();
809
810 D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
811 /*isVariadic=*/EllipsisLoc.isValid(),
812 /*isAmbiguous=*/false, EllipsisLoc,
813 ParamInfo.data(), ParamInfo.size(),
814 DS.getTypeQualifiers(),
815 /*RefQualifierIsLValueRef=*/true,
816 /*RefQualifierLoc=*/SourceLocation(),
817 /*ConstQualifierLoc=*/SourceLocation(),
818 /*VolatileQualifierLoc=*/SourceLocation(),
819 MutableLoc,
820 ESpecType, ESpecRange.getBegin(),
821 DynamicExceptions.data(),
822 DynamicExceptionRanges.data(),
823 DynamicExceptions.size(),
824 NoexceptExpr.isUsable() ?
825 NoexceptExpr.get() : 0,
826 DeclLoc, DeclEndLoc, D,
827 TrailingReturnType),
828 Attr, DeclEndLoc);
829 } else if (Tok.is(tok::kw_mutable) || Tok.is(tok::arrow)) {
830 // It's common to forget that one needs '()' before 'mutable' or the
831 // result type. Deal with this.
832 Diag(Tok, diag::err_lambda_missing_parens)
833 << Tok.is(tok::arrow)
834 << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
835 SourceLocation DeclLoc = Tok.getLocation();
836 SourceLocation DeclEndLoc = DeclLoc;
837
838 // Parse 'mutable', if it's there.
839 SourceLocation MutableLoc;
840 if (Tok.is(tok::kw_mutable)) {
841 MutableLoc = ConsumeToken();
842 DeclEndLoc = MutableLoc;
843 }
844
845 // Parse the return type, if there is one.
846 TypeResult TrailingReturnType;
847 if (Tok.is(tok::arrow)) {
848 SourceRange Range;
849 TrailingReturnType = ParseTrailingReturnType(Range);
850 if (Range.getEnd().isValid())
851 DeclEndLoc = Range.getEnd();
852 }
853
854 ParsedAttributes Attr(AttrFactory);
855 D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
856 /*isVariadic=*/false,
857 /*isAmbiguous=*/false,
858 /*EllipsisLoc=*/SourceLocation(),
859 /*Params=*/0, /*NumParams=*/0,
860 /*TypeQuals=*/0,
861 /*RefQualifierIsLValueRef=*/true,
862 /*RefQualifierLoc=*/SourceLocation(),
863 /*ConstQualifierLoc=*/SourceLocation(),
864 /*VolatileQualifierLoc=*/SourceLocation(),
865 MutableLoc,
866 EST_None,
867 /*ESpecLoc=*/SourceLocation(),
868 /*Exceptions=*/0,
869 /*ExceptionRanges=*/0,
870 /*NumExceptions=*/0,
871 /*NoexceptExpr=*/0,
872 DeclLoc, DeclEndLoc, D,
873 TrailingReturnType),
874 Attr, DeclEndLoc);
875 }
876
877
878 // FIXME: Rename BlockScope -> ClosureScope if we decide to continue using
879 // it.
880 unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope;
881 ParseScope BodyScope(this, ScopeFlags);
882
883 Actions.ActOnStartOfLambdaDefinition(Intro, D, getCurScope());
884
885 // Parse compound-statement.
886 if (!Tok.is(tok::l_brace)) {
887 Diag(Tok, diag::err_expected_lambda_body);
888 Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
889 return ExprError();
890 }
891
892 StmtResult Stmt(ParseCompoundStatementBody());
893 BodyScope.Exit();
894
895 if (!Stmt.isInvalid())
896 return Actions.ActOnLambdaExpr(LambdaBeginLoc, Stmt.take(), getCurScope());
897
898 Actions.ActOnLambdaError(LambdaBeginLoc, getCurScope());
899 return ExprError();
900 }
901
902 /// ParseCXXCasts - This handles the various ways to cast expressions to another
903 /// type.
904 ///
905 /// postfix-expression: [C++ 5.2p1]
906 /// 'dynamic_cast' '<' type-name '>' '(' expression ')'
907 /// 'static_cast' '<' type-name '>' '(' expression ')'
908 /// 'reinterpret_cast' '<' type-name '>' '(' expression ')'
909 /// 'const_cast' '<' type-name '>' '(' expression ')'
910 ///
ParseCXXCasts()911 ExprResult Parser::ParseCXXCasts() {
912 tok::TokenKind Kind = Tok.getKind();
913 const char *CastName = 0; // For error messages
914
915 switch (Kind) {
916 default: llvm_unreachable("Unknown C++ cast!");
917 case tok::kw_const_cast: CastName = "const_cast"; break;
918 case tok::kw_dynamic_cast: CastName = "dynamic_cast"; break;
919 case tok::kw_reinterpret_cast: CastName = "reinterpret_cast"; break;
920 case tok::kw_static_cast: CastName = "static_cast"; break;
921 }
922
923 SourceLocation OpLoc = ConsumeToken();
924 SourceLocation LAngleBracketLoc = Tok.getLocation();
925
926 // Check for "<::" which is parsed as "[:". If found, fix token stream,
927 // diagnose error, suggest fix, and recover parsing.
928 if (Tok.is(tok::l_square) && Tok.getLength() == 2) {
929 Token Next = NextToken();
930 if (Next.is(tok::colon) && areTokensAdjacent(Tok, Next))
931 FixDigraph(*this, PP, Tok, Next, Kind, /*AtDigraph*/true);
932 }
933
934 if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
935 return ExprError();
936
937 // Parse the common declaration-specifiers piece.
938 DeclSpec DS(AttrFactory);
939 ParseSpecifierQualifierList(DS);
940
941 // Parse the abstract-declarator, if present.
942 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
943 ParseDeclarator(DeclaratorInfo);
944
945 SourceLocation RAngleBracketLoc = Tok.getLocation();
946
947 if (ExpectAndConsume(tok::greater, diag::err_expected_greater))
948 return ExprError(Diag(LAngleBracketLoc, diag::note_matching) << "<");
949
950 SourceLocation LParenLoc, RParenLoc;
951 BalancedDelimiterTracker T(*this, tok::l_paren);
952
953 if (T.expectAndConsume(diag::err_expected_lparen_after, CastName))
954 return ExprError();
955
956 ExprResult Result = ParseExpression();
957
958 // Match the ')'.
959 T.consumeClose();
960
961 if (!Result.isInvalid() && !DeclaratorInfo.isInvalidType())
962 Result = Actions.ActOnCXXNamedCast(OpLoc, Kind,
963 LAngleBracketLoc, DeclaratorInfo,
964 RAngleBracketLoc,
965 T.getOpenLocation(), Result.take(),
966 T.getCloseLocation());
967
968 return Result;
969 }
970
971 /// ParseCXXTypeid - This handles the C++ typeid expression.
972 ///
973 /// postfix-expression: [C++ 5.2p1]
974 /// 'typeid' '(' expression ')'
975 /// 'typeid' '(' type-id ')'
976 ///
ParseCXXTypeid()977 ExprResult Parser::ParseCXXTypeid() {
978 assert(Tok.is(tok::kw_typeid) && "Not 'typeid'!");
979
980 SourceLocation OpLoc = ConsumeToken();
981 SourceLocation LParenLoc, RParenLoc;
982 BalancedDelimiterTracker T(*this, tok::l_paren);
983
984 // typeid expressions are always parenthesized.
985 if (T.expectAndConsume(diag::err_expected_lparen_after, "typeid"))
986 return ExprError();
987 LParenLoc = T.getOpenLocation();
988
989 ExprResult Result;
990
991 // C++0x [expr.typeid]p3:
992 // When typeid is applied to an expression other than an lvalue of a
993 // polymorphic class type [...] The expression is an unevaluated
994 // operand (Clause 5).
995 //
996 // Note that we can't tell whether the expression is an lvalue of a
997 // polymorphic class type until after we've parsed the expression; we
998 // speculatively assume the subexpression is unevaluated, and fix it up
999 // later.
1000 //
1001 // We enter the unevaluated context before trying to determine whether we
1002 // have a type-id, because the tentative parse logic will try to resolve
1003 // names, and must treat them as unevaluated.
1004 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated);
1005
1006 if (isTypeIdInParens()) {
1007 TypeResult Ty = ParseTypeName();
1008
1009 // Match the ')'.
1010 T.consumeClose();
1011 RParenLoc = T.getCloseLocation();
1012 if (Ty.isInvalid() || RParenLoc.isInvalid())
1013 return ExprError();
1014
1015 Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/true,
1016 Ty.get().getAsOpaquePtr(), RParenLoc);
1017 } else {
1018 Result = ParseExpression();
1019
1020 // Match the ')'.
1021 if (Result.isInvalid())
1022 SkipUntil(tok::r_paren);
1023 else {
1024 T.consumeClose();
1025 RParenLoc = T.getCloseLocation();
1026 if (RParenLoc.isInvalid())
1027 return ExprError();
1028
1029 Result = Actions.ActOnCXXTypeid(OpLoc, LParenLoc, /*isType=*/false,
1030 Result.release(), RParenLoc);
1031 }
1032 }
1033
1034 return Result;
1035 }
1036
1037 /// ParseCXXUuidof - This handles the Microsoft C++ __uuidof expression.
1038 ///
1039 /// '__uuidof' '(' expression ')'
1040 /// '__uuidof' '(' type-id ')'
1041 ///
ParseCXXUuidof()1042 ExprResult Parser::ParseCXXUuidof() {
1043 assert(Tok.is(tok::kw___uuidof) && "Not '__uuidof'!");
1044
1045 SourceLocation OpLoc = ConsumeToken();
1046 BalancedDelimiterTracker T(*this, tok::l_paren);
1047
1048 // __uuidof expressions are always parenthesized.
1049 if (T.expectAndConsume(diag::err_expected_lparen_after, "__uuidof"))
1050 return ExprError();
1051
1052 ExprResult Result;
1053
1054 if (isTypeIdInParens()) {
1055 TypeResult Ty = ParseTypeName();
1056
1057 // Match the ')'.
1058 T.consumeClose();
1059
1060 if (Ty.isInvalid())
1061 return ExprError();
1062
1063 Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(), /*isType=*/true,
1064 Ty.get().getAsOpaquePtr(),
1065 T.getCloseLocation());
1066 } else {
1067 EnterExpressionEvaluationContext Unevaluated(Actions, Sema::Unevaluated);
1068 Result = ParseExpression();
1069
1070 // Match the ')'.
1071 if (Result.isInvalid())
1072 SkipUntil(tok::r_paren);
1073 else {
1074 T.consumeClose();
1075
1076 Result = Actions.ActOnCXXUuidof(OpLoc, T.getOpenLocation(),
1077 /*isType=*/false,
1078 Result.release(), T.getCloseLocation());
1079 }
1080 }
1081
1082 return Result;
1083 }
1084
1085 /// \brief Parse a C++ pseudo-destructor expression after the base,
1086 /// . or -> operator, and nested-name-specifier have already been
1087 /// parsed.
1088 ///
1089 /// postfix-expression: [C++ 5.2]
1090 /// postfix-expression . pseudo-destructor-name
1091 /// postfix-expression -> pseudo-destructor-name
1092 ///
1093 /// pseudo-destructor-name:
1094 /// ::[opt] nested-name-specifier[opt] type-name :: ~type-name
1095 /// ::[opt] nested-name-specifier template simple-template-id ::
1096 /// ~type-name
1097 /// ::[opt] nested-name-specifier[opt] ~type-name
1098 ///
1099 ExprResult
ParseCXXPseudoDestructor(ExprArg Base,SourceLocation OpLoc,tok::TokenKind OpKind,CXXScopeSpec & SS,ParsedType ObjectType)1100 Parser::ParseCXXPseudoDestructor(ExprArg Base, SourceLocation OpLoc,
1101 tok::TokenKind OpKind,
1102 CXXScopeSpec &SS,
1103 ParsedType ObjectType) {
1104 // We're parsing either a pseudo-destructor-name or a dependent
1105 // member access that has the same form as a
1106 // pseudo-destructor-name. We parse both in the same way and let
1107 // the action model sort them out.
1108 //
1109 // Note that the ::[opt] nested-name-specifier[opt] has already
1110 // been parsed, and if there was a simple-template-id, it has
1111 // been coalesced into a template-id annotation token.
1112 UnqualifiedId FirstTypeName;
1113 SourceLocation CCLoc;
1114 if (Tok.is(tok::identifier)) {
1115 FirstTypeName.setIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1116 ConsumeToken();
1117 assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1118 CCLoc = ConsumeToken();
1119 } else if (Tok.is(tok::annot_template_id)) {
1120 // FIXME: retrieve TemplateKWLoc from template-id annotation and
1121 // store it in the pseudo-dtor node (to be used when instantiating it).
1122 FirstTypeName.setTemplateId(
1123 (TemplateIdAnnotation *)Tok.getAnnotationValue());
1124 ConsumeToken();
1125 assert(Tok.is(tok::coloncolon) &&"ParseOptionalCXXScopeSpecifier fail");
1126 CCLoc = ConsumeToken();
1127 } else {
1128 FirstTypeName.setIdentifier(0, SourceLocation());
1129 }
1130
1131 // Parse the tilde.
1132 assert(Tok.is(tok::tilde) && "ParseOptionalCXXScopeSpecifier fail");
1133 SourceLocation TildeLoc = ConsumeToken();
1134
1135 if (Tok.is(tok::kw_decltype) && !FirstTypeName.isValid() && SS.isEmpty()) {
1136 DeclSpec DS(AttrFactory);
1137 ParseDecltypeSpecifier(DS);
1138 if (DS.getTypeSpecType() == TST_error)
1139 return ExprError();
1140 return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base, OpLoc,
1141 OpKind, TildeLoc, DS,
1142 Tok.is(tok::l_paren));
1143 }
1144
1145 if (!Tok.is(tok::identifier)) {
1146 Diag(Tok, diag::err_destructor_tilde_identifier);
1147 return ExprError();
1148 }
1149
1150 // Parse the second type.
1151 UnqualifiedId SecondTypeName;
1152 IdentifierInfo *Name = Tok.getIdentifierInfo();
1153 SourceLocation NameLoc = ConsumeToken();
1154 SecondTypeName.setIdentifier(Name, NameLoc);
1155
1156 // If there is a '<', the second type name is a template-id. Parse
1157 // it as such.
1158 if (Tok.is(tok::less) &&
1159 ParseUnqualifiedIdTemplateId(SS, SourceLocation(),
1160 Name, NameLoc,
1161 false, ObjectType, SecondTypeName,
1162 /*AssumeTemplateName=*/true))
1163 return ExprError();
1164
1165 return Actions.ActOnPseudoDestructorExpr(getCurScope(), Base,
1166 OpLoc, OpKind,
1167 SS, FirstTypeName, CCLoc,
1168 TildeLoc, SecondTypeName,
1169 Tok.is(tok::l_paren));
1170 }
1171
1172 /// ParseCXXBoolLiteral - This handles the C++ Boolean literals.
1173 ///
1174 /// boolean-literal: [C++ 2.13.5]
1175 /// 'true'
1176 /// 'false'
ParseCXXBoolLiteral()1177 ExprResult Parser::ParseCXXBoolLiteral() {
1178 tok::TokenKind Kind = Tok.getKind();
1179 return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind);
1180 }
1181
1182 /// ParseThrowExpression - This handles the C++ throw expression.
1183 ///
1184 /// throw-expression: [C++ 15]
1185 /// 'throw' assignment-expression[opt]
ParseThrowExpression()1186 ExprResult Parser::ParseThrowExpression() {
1187 assert(Tok.is(tok::kw_throw) && "Not throw!");
1188 SourceLocation ThrowLoc = ConsumeToken(); // Eat the throw token.
1189
1190 // If the current token isn't the start of an assignment-expression,
1191 // then the expression is not present. This handles things like:
1192 // "C ? throw : (void)42", which is crazy but legal.
1193 switch (Tok.getKind()) { // FIXME: move this predicate somewhere common.
1194 case tok::semi:
1195 case tok::r_paren:
1196 case tok::r_square:
1197 case tok::r_brace:
1198 case tok::colon:
1199 case tok::comma:
1200 return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, 0);
1201
1202 default:
1203 ExprResult Expr(ParseAssignmentExpression());
1204 if (Expr.isInvalid()) return Expr;
1205 return Actions.ActOnCXXThrow(getCurScope(), ThrowLoc, Expr.take());
1206 }
1207 }
1208
1209 /// ParseCXXThis - This handles the C++ 'this' pointer.
1210 ///
1211 /// C++ 9.3.2: In the body of a non-static member function, the keyword this is
1212 /// a non-lvalue expression whose value is the address of the object for which
1213 /// the function is called.
ParseCXXThis()1214 ExprResult Parser::ParseCXXThis() {
1215 assert(Tok.is(tok::kw_this) && "Not 'this'!");
1216 SourceLocation ThisLoc = ConsumeToken();
1217 return Actions.ActOnCXXThis(ThisLoc);
1218 }
1219
1220 /// ParseCXXTypeConstructExpression - Parse construction of a specified type.
1221 /// Can be interpreted either as function-style casting ("int(x)")
1222 /// or class type construction ("ClassType(x,y,z)")
1223 /// or creation of a value-initialized type ("int()").
1224 /// See [C++ 5.2.3].
1225 ///
1226 /// postfix-expression: [C++ 5.2p1]
1227 /// simple-type-specifier '(' expression-list[opt] ')'
1228 /// [C++0x] simple-type-specifier braced-init-list
1229 /// typename-specifier '(' expression-list[opt] ')'
1230 /// [C++0x] typename-specifier braced-init-list
1231 ///
1232 ExprResult
ParseCXXTypeConstructExpression(const DeclSpec & DS)1233 Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
1234 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
1235 ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
1236
1237 assert((Tok.is(tok::l_paren) ||
1238 (getLangOpts().CPlusPlus0x && Tok.is(tok::l_brace)))
1239 && "Expected '(' or '{'!");
1240
1241 if (Tok.is(tok::l_brace)) {
1242 ExprResult Init = ParseBraceInitializer();
1243 if (Init.isInvalid())
1244 return Init;
1245 Expr *InitList = Init.take();
1246 return Actions.ActOnCXXTypeConstructExpr(TypeRep, SourceLocation(),
1247 MultiExprArg(&InitList, 1),
1248 SourceLocation());
1249 } else {
1250 BalancedDelimiterTracker T(*this, tok::l_paren);
1251 T.consumeOpen();
1252
1253 ExprVector Exprs;
1254 CommaLocsTy CommaLocs;
1255
1256 if (Tok.isNot(tok::r_paren)) {
1257 if (ParseExpressionList(Exprs, CommaLocs)) {
1258 SkipUntil(tok::r_paren);
1259 return ExprError();
1260 }
1261 }
1262
1263 // Match the ')'.
1264 T.consumeClose();
1265
1266 // TypeRep could be null, if it references an invalid typedef.
1267 if (!TypeRep)
1268 return ExprError();
1269
1270 assert((Exprs.size() == 0 || Exprs.size()-1 == CommaLocs.size())&&
1271 "Unexpected number of commas!");
1272 return Actions.ActOnCXXTypeConstructExpr(TypeRep, T.getOpenLocation(),
1273 Exprs,
1274 T.getCloseLocation());
1275 }
1276 }
1277
1278 /// ParseCXXCondition - if/switch/while condition expression.
1279 ///
1280 /// condition:
1281 /// expression
1282 /// type-specifier-seq declarator '=' assignment-expression
1283 /// [C++11] type-specifier-seq declarator '=' initializer-clause
1284 /// [C++11] type-specifier-seq declarator braced-init-list
1285 /// [GNU] type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
1286 /// '=' assignment-expression
1287 ///
1288 /// \param ExprOut if the condition was parsed as an expression, the parsed
1289 /// expression.
1290 ///
1291 /// \param DeclOut if the condition was parsed as a declaration, the parsed
1292 /// declaration.
1293 ///
1294 /// \param Loc The location of the start of the statement that requires this
1295 /// condition, e.g., the "for" in a for loop.
1296 ///
1297 /// \param ConvertToBoolean Whether the condition expression should be
1298 /// converted to a boolean value.
1299 ///
1300 /// \returns true if there was a parsing, false otherwise.
ParseCXXCondition(ExprResult & ExprOut,Decl * & DeclOut,SourceLocation Loc,bool ConvertToBoolean)1301 bool Parser::ParseCXXCondition(ExprResult &ExprOut,
1302 Decl *&DeclOut,
1303 SourceLocation Loc,
1304 bool ConvertToBoolean) {
1305 if (Tok.is(tok::code_completion)) {
1306 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Condition);
1307 cutOffParsing();
1308 return true;
1309 }
1310
1311 ParsedAttributesWithRange attrs(AttrFactory);
1312 MaybeParseCXX0XAttributes(attrs);
1313
1314 if (!isCXXConditionDeclaration()) {
1315 ProhibitAttributes(attrs);
1316
1317 // Parse the expression.
1318 ExprOut = ParseExpression(); // expression
1319 DeclOut = 0;
1320 if (ExprOut.isInvalid())
1321 return true;
1322
1323 // If required, convert to a boolean value.
1324 if (ConvertToBoolean)
1325 ExprOut
1326 = Actions.ActOnBooleanCondition(getCurScope(), Loc, ExprOut.get());
1327 return ExprOut.isInvalid();
1328 }
1329
1330 // type-specifier-seq
1331 DeclSpec DS(AttrFactory);
1332 ParseSpecifierQualifierList(DS);
1333
1334 // declarator
1335 Declarator DeclaratorInfo(DS, Declarator::ConditionContext);
1336 ParseDeclarator(DeclaratorInfo);
1337
1338 // simple-asm-expr[opt]
1339 if (Tok.is(tok::kw_asm)) {
1340 SourceLocation Loc;
1341 ExprResult AsmLabel(ParseSimpleAsm(&Loc));
1342 if (AsmLabel.isInvalid()) {
1343 SkipUntil(tok::semi);
1344 return true;
1345 }
1346 DeclaratorInfo.setAsmLabel(AsmLabel.release());
1347 DeclaratorInfo.SetRangeEnd(Loc);
1348 }
1349
1350 // If attributes are present, parse them.
1351 MaybeParseGNUAttributes(DeclaratorInfo);
1352
1353 // Type-check the declaration itself.
1354 DeclResult Dcl = Actions.ActOnCXXConditionDeclaration(getCurScope(),
1355 DeclaratorInfo);
1356 DeclOut = Dcl.get();
1357 ExprOut = ExprError();
1358
1359 // '=' assignment-expression
1360 // If a '==' or '+=' is found, suggest a fixit to '='.
1361 bool CopyInitialization = isTokenEqualOrEqualTypo();
1362 if (CopyInitialization)
1363 ConsumeToken();
1364
1365 ExprResult InitExpr = ExprError();
1366 if (getLangOpts().CPlusPlus0x && Tok.is(tok::l_brace)) {
1367 Diag(Tok.getLocation(),
1368 diag::warn_cxx98_compat_generalized_initializer_lists);
1369 InitExpr = ParseBraceInitializer();
1370 } else if (CopyInitialization) {
1371 InitExpr = ParseAssignmentExpression();
1372 } else if (Tok.is(tok::l_paren)) {
1373 // This was probably an attempt to initialize the variable.
1374 SourceLocation LParen = ConsumeParen(), RParen = LParen;
1375 if (SkipUntil(tok::r_paren, true, /*DontConsume=*/true))
1376 RParen = ConsumeParen();
1377 Diag(DeclOut ? DeclOut->getLocation() : LParen,
1378 diag::err_expected_init_in_condition_lparen)
1379 << SourceRange(LParen, RParen);
1380 } else {
1381 Diag(DeclOut ? DeclOut->getLocation() : Tok.getLocation(),
1382 diag::err_expected_init_in_condition);
1383 }
1384
1385 if (!InitExpr.isInvalid())
1386 Actions.AddInitializerToDecl(DeclOut, InitExpr.take(), !CopyInitialization,
1387 DS.getTypeSpecType() == DeclSpec::TST_auto);
1388
1389 // FIXME: Build a reference to this declaration? Convert it to bool?
1390 // (This is currently handled by Sema).
1391
1392 Actions.FinalizeDeclaration(DeclOut);
1393
1394 return false;
1395 }
1396
1397 /// ParseCXXSimpleTypeSpecifier - [C++ 7.1.5.2] Simple type specifiers.
1398 /// This should only be called when the current token is known to be part of
1399 /// simple-type-specifier.
1400 ///
1401 /// simple-type-specifier:
1402 /// '::'[opt] nested-name-specifier[opt] type-name
1403 /// '::'[opt] nested-name-specifier 'template' simple-template-id [TODO]
1404 /// char
1405 /// wchar_t
1406 /// bool
1407 /// short
1408 /// int
1409 /// long
1410 /// signed
1411 /// unsigned
1412 /// float
1413 /// double
1414 /// void
1415 /// [GNU] typeof-specifier
1416 /// [C++0x] auto [TODO]
1417 ///
1418 /// type-name:
1419 /// class-name
1420 /// enum-name
1421 /// typedef-name
1422 ///
ParseCXXSimpleTypeSpecifier(DeclSpec & DS)1423 void Parser::ParseCXXSimpleTypeSpecifier(DeclSpec &DS) {
1424 DS.SetRangeStart(Tok.getLocation());
1425 const char *PrevSpec;
1426 unsigned DiagID;
1427 SourceLocation Loc = Tok.getLocation();
1428
1429 switch (Tok.getKind()) {
1430 case tok::identifier: // foo::bar
1431 case tok::coloncolon: // ::foo::bar
1432 llvm_unreachable("Annotation token should already be formed!");
1433 default:
1434 llvm_unreachable("Not a simple-type-specifier token!");
1435
1436 // type-name
1437 case tok::annot_typename: {
1438 if (getTypeAnnotation(Tok))
1439 DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID,
1440 getTypeAnnotation(Tok));
1441 else
1442 DS.SetTypeSpecError();
1443
1444 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1445 ConsumeToken();
1446
1447 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
1448 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
1449 // Objective-C interface. If we don't have Objective-C or a '<', this is
1450 // just a normal reference to a typedef name.
1451 if (Tok.is(tok::less) && getLangOpts().ObjC1)
1452 ParseObjCProtocolQualifiers(DS);
1453
1454 DS.Finish(Diags, PP);
1455 return;
1456 }
1457
1458 // builtin types
1459 case tok::kw_short:
1460 DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID);
1461 break;
1462 case tok::kw_long:
1463 DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, DiagID);
1464 break;
1465 case tok::kw___int64:
1466 DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, DiagID);
1467 break;
1468 case tok::kw_signed:
1469 DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID);
1470 break;
1471 case tok::kw_unsigned:
1472 DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, DiagID);
1473 break;
1474 case tok::kw_void:
1475 DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID);
1476 break;
1477 case tok::kw_char:
1478 DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID);
1479 break;
1480 case tok::kw_int:
1481 DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID);
1482 break;
1483 case tok::kw___int128:
1484 DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID);
1485 break;
1486 case tok::kw_half:
1487 DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID);
1488 break;
1489 case tok::kw_float:
1490 DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID);
1491 break;
1492 case tok::kw_double:
1493 DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID);
1494 break;
1495 case tok::kw_wchar_t:
1496 DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID);
1497 break;
1498 case tok::kw_char16_t:
1499 DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID);
1500 break;
1501 case tok::kw_char32_t:
1502 DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID);
1503 break;
1504 case tok::kw_bool:
1505 DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID);
1506 break;
1507 case tok::annot_decltype:
1508 case tok::kw_decltype:
1509 DS.SetRangeEnd(ParseDecltypeSpecifier(DS));
1510 return DS.Finish(Diags, PP);
1511
1512 // GNU typeof support.
1513 case tok::kw_typeof:
1514 ParseTypeofSpecifier(DS);
1515 DS.Finish(Diags, PP);
1516 return;
1517 }
1518 if (Tok.is(tok::annot_typename))
1519 DS.SetRangeEnd(Tok.getAnnotationEndLoc());
1520 else
1521 DS.SetRangeEnd(Tok.getLocation());
1522 ConsumeToken();
1523 DS.Finish(Diags, PP);
1524 }
1525
1526 /// ParseCXXTypeSpecifierSeq - Parse a C++ type-specifier-seq (C++
1527 /// [dcl.name]), which is a non-empty sequence of type-specifiers,
1528 /// e.g., "const short int". Note that the DeclSpec is *not* finished
1529 /// by parsing the type-specifier-seq, because these sequences are
1530 /// typically followed by some form of declarator. Returns true and
1531 /// emits diagnostics if this is not a type-specifier-seq, false
1532 /// otherwise.
1533 ///
1534 /// type-specifier-seq: [C++ 8.1]
1535 /// type-specifier type-specifier-seq[opt]
1536 ///
ParseCXXTypeSpecifierSeq(DeclSpec & DS)1537 bool Parser::ParseCXXTypeSpecifierSeq(DeclSpec &DS) {
1538 ParseSpecifierQualifierList(DS, AS_none, DSC_type_specifier);
1539 DS.Finish(Diags, PP);
1540 return false;
1541 }
1542
1543 /// \brief Finish parsing a C++ unqualified-id that is a template-id of
1544 /// some form.
1545 ///
1546 /// This routine is invoked when a '<' is encountered after an identifier or
1547 /// operator-function-id is parsed by \c ParseUnqualifiedId() to determine
1548 /// whether the unqualified-id is actually a template-id. This routine will
1549 /// then parse the template arguments and form the appropriate template-id to
1550 /// return to the caller.
1551 ///
1552 /// \param SS the nested-name-specifier that precedes this template-id, if
1553 /// we're actually parsing a qualified-id.
1554 ///
1555 /// \param Name for constructor and destructor names, this is the actual
1556 /// identifier that may be a template-name.
1557 ///
1558 /// \param NameLoc the location of the class-name in a constructor or
1559 /// destructor.
1560 ///
1561 /// \param EnteringContext whether we're entering the scope of the
1562 /// nested-name-specifier.
1563 ///
1564 /// \param ObjectType if this unqualified-id occurs within a member access
1565 /// expression, the type of the base object whose member is being accessed.
1566 ///
1567 /// \param Id as input, describes the template-name or operator-function-id
1568 /// that precedes the '<'. If template arguments were parsed successfully,
1569 /// will be updated with the template-id.
1570 ///
1571 /// \param AssumeTemplateId When true, this routine will assume that the name
1572 /// refers to a template without performing name lookup to verify.
1573 ///
1574 /// \returns true if a parse error occurred, false otherwise.
ParseUnqualifiedIdTemplateId(CXXScopeSpec & SS,SourceLocation TemplateKWLoc,IdentifierInfo * Name,SourceLocation NameLoc,bool EnteringContext,ParsedType ObjectType,UnqualifiedId & Id,bool AssumeTemplateId)1575 bool Parser::ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
1576 SourceLocation TemplateKWLoc,
1577 IdentifierInfo *Name,
1578 SourceLocation NameLoc,
1579 bool EnteringContext,
1580 ParsedType ObjectType,
1581 UnqualifiedId &Id,
1582 bool AssumeTemplateId) {
1583 assert((AssumeTemplateId || Tok.is(tok::less)) &&
1584 "Expected '<' to finish parsing a template-id");
1585
1586 TemplateTy Template;
1587 TemplateNameKind TNK = TNK_Non_template;
1588 switch (Id.getKind()) {
1589 case UnqualifiedId::IK_Identifier:
1590 case UnqualifiedId::IK_OperatorFunctionId:
1591 case UnqualifiedId::IK_LiteralOperatorId:
1592 if (AssumeTemplateId) {
1593 TNK = Actions.ActOnDependentTemplateName(getCurScope(), SS, TemplateKWLoc,
1594 Id, ObjectType, EnteringContext,
1595 Template);
1596 if (TNK == TNK_Non_template)
1597 return true;
1598 } else {
1599 bool MemberOfUnknownSpecialization;
1600 TNK = Actions.isTemplateName(getCurScope(), SS,
1601 TemplateKWLoc.isValid(), Id,
1602 ObjectType, EnteringContext, Template,
1603 MemberOfUnknownSpecialization);
1604
1605 if (TNK == TNK_Non_template && MemberOfUnknownSpecialization &&
1606 ObjectType && IsTemplateArgumentList()) {
1607 // We have something like t->getAs<T>(), where getAs is a
1608 // member of an unknown specialization. However, this will only
1609 // parse correctly as a template, so suggest the keyword 'template'
1610 // before 'getAs' and treat this as a dependent template name.
1611 std::string Name;
1612 if (Id.getKind() == UnqualifiedId::IK_Identifier)
1613 Name = Id.Identifier->getName();
1614 else {
1615 Name = "operator ";
1616 if (Id.getKind() == UnqualifiedId::IK_OperatorFunctionId)
1617 Name += getOperatorSpelling(Id.OperatorFunctionId.Operator);
1618 else
1619 Name += Id.Identifier->getName();
1620 }
1621 Diag(Id.StartLocation, diag::err_missing_dependent_template_keyword)
1622 << Name
1623 << FixItHint::CreateInsertion(Id.StartLocation, "template ");
1624 TNK = Actions.ActOnDependentTemplateName(getCurScope(),
1625 SS, TemplateKWLoc, Id,
1626 ObjectType, EnteringContext,
1627 Template);
1628 if (TNK == TNK_Non_template)
1629 return true;
1630 }
1631 }
1632 break;
1633
1634 case UnqualifiedId::IK_ConstructorName: {
1635 UnqualifiedId TemplateName;
1636 bool MemberOfUnknownSpecialization;
1637 TemplateName.setIdentifier(Name, NameLoc);
1638 TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
1639 TemplateName, ObjectType,
1640 EnteringContext, Template,
1641 MemberOfUnknownSpecialization);
1642 break;
1643 }
1644
1645 case UnqualifiedId::IK_DestructorName: {
1646 UnqualifiedId TemplateName;
1647 bool MemberOfUnknownSpecialization;
1648 TemplateName.setIdentifier(Name, NameLoc);
1649 if (ObjectType) {
1650 TNK = Actions.ActOnDependentTemplateName(getCurScope(),
1651 SS, TemplateKWLoc, TemplateName,
1652 ObjectType, EnteringContext,
1653 Template);
1654 if (TNK == TNK_Non_template)
1655 return true;
1656 } else {
1657 TNK = Actions.isTemplateName(getCurScope(), SS, TemplateKWLoc.isValid(),
1658 TemplateName, ObjectType,
1659 EnteringContext, Template,
1660 MemberOfUnknownSpecialization);
1661
1662 if (TNK == TNK_Non_template && !Id.DestructorName.get()) {
1663 Diag(NameLoc, diag::err_destructor_template_id)
1664 << Name << SS.getRange();
1665 return true;
1666 }
1667 }
1668 break;
1669 }
1670
1671 default:
1672 return false;
1673 }
1674
1675 if (TNK == TNK_Non_template)
1676 return false;
1677
1678 // Parse the enclosed template argument list.
1679 SourceLocation LAngleLoc, RAngleLoc;
1680 TemplateArgList TemplateArgs;
1681 if (Tok.is(tok::less) &&
1682 ParseTemplateIdAfterTemplateName(Template, Id.StartLocation,
1683 SS, true, LAngleLoc,
1684 TemplateArgs,
1685 RAngleLoc))
1686 return true;
1687
1688 if (Id.getKind() == UnqualifiedId::IK_Identifier ||
1689 Id.getKind() == UnqualifiedId::IK_OperatorFunctionId ||
1690 Id.getKind() == UnqualifiedId::IK_LiteralOperatorId) {
1691 // Form a parsed representation of the template-id to be stored in the
1692 // UnqualifiedId.
1693 TemplateIdAnnotation *TemplateId
1694 = TemplateIdAnnotation::Allocate(TemplateArgs.size(), TemplateIds);
1695
1696 if (Id.getKind() == UnqualifiedId::IK_Identifier) {
1697 TemplateId->Name = Id.Identifier;
1698 TemplateId->Operator = OO_None;
1699 TemplateId->TemplateNameLoc = Id.StartLocation;
1700 } else {
1701 TemplateId->Name = 0;
1702 TemplateId->Operator = Id.OperatorFunctionId.Operator;
1703 TemplateId->TemplateNameLoc = Id.StartLocation;
1704 }
1705
1706 TemplateId->SS = SS;
1707 TemplateId->TemplateKWLoc = TemplateKWLoc;
1708 TemplateId->Template = Template;
1709 TemplateId->Kind = TNK;
1710 TemplateId->LAngleLoc = LAngleLoc;
1711 TemplateId->RAngleLoc = RAngleLoc;
1712 ParsedTemplateArgument *Args = TemplateId->getTemplateArgs();
1713 for (unsigned Arg = 0, ArgEnd = TemplateArgs.size();
1714 Arg != ArgEnd; ++Arg)
1715 Args[Arg] = TemplateArgs[Arg];
1716
1717 Id.setTemplateId(TemplateId);
1718 return false;
1719 }
1720
1721 // Bundle the template arguments together.
1722 ASTTemplateArgsPtr TemplateArgsPtr(TemplateArgs);
1723
1724 // Constructor and destructor names.
1725 TypeResult Type
1726 = Actions.ActOnTemplateIdType(SS, TemplateKWLoc,
1727 Template, NameLoc,
1728 LAngleLoc, TemplateArgsPtr, RAngleLoc,
1729 /*IsCtorOrDtorName=*/true);
1730 if (Type.isInvalid())
1731 return true;
1732
1733 if (Id.getKind() == UnqualifiedId::IK_ConstructorName)
1734 Id.setConstructorName(Type.get(), NameLoc, RAngleLoc);
1735 else
1736 Id.setDestructorName(Id.StartLocation, Type.get(), RAngleLoc);
1737
1738 return false;
1739 }
1740
1741 /// \brief Parse an operator-function-id or conversion-function-id as part
1742 /// of a C++ unqualified-id.
1743 ///
1744 /// This routine is responsible only for parsing the operator-function-id or
1745 /// conversion-function-id; it does not handle template arguments in any way.
1746 ///
1747 /// \code
1748 /// operator-function-id: [C++ 13.5]
1749 /// 'operator' operator
1750 ///
1751 /// operator: one of
1752 /// new delete new[] delete[]
1753 /// + - * / % ^ & | ~
1754 /// ! = < > += -= *= /= %=
1755 /// ^= &= |= << >> >>= <<= == !=
1756 /// <= >= && || ++ -- , ->* ->
1757 /// () []
1758 ///
1759 /// conversion-function-id: [C++ 12.3.2]
1760 /// operator conversion-type-id
1761 ///
1762 /// conversion-type-id:
1763 /// type-specifier-seq conversion-declarator[opt]
1764 ///
1765 /// conversion-declarator:
1766 /// ptr-operator conversion-declarator[opt]
1767 /// \endcode
1768 ///
1769 /// \param SS The nested-name-specifier that preceded this unqualified-id. If
1770 /// non-empty, then we are parsing the unqualified-id of a qualified-id.
1771 ///
1772 /// \param EnteringContext whether we are entering the scope of the
1773 /// nested-name-specifier.
1774 ///
1775 /// \param ObjectType if this unqualified-id occurs within a member access
1776 /// expression, the type of the base object whose member is being accessed.
1777 ///
1778 /// \param Result on a successful parse, contains the parsed unqualified-id.
1779 ///
1780 /// \returns true if parsing fails, false otherwise.
ParseUnqualifiedIdOperator(CXXScopeSpec & SS,bool EnteringContext,ParsedType ObjectType,UnqualifiedId & Result)1781 bool Parser::ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
1782 ParsedType ObjectType,
1783 UnqualifiedId &Result) {
1784 assert(Tok.is(tok::kw_operator) && "Expected 'operator' keyword");
1785
1786 // Consume the 'operator' keyword.
1787 SourceLocation KeywordLoc = ConsumeToken();
1788
1789 // Determine what kind of operator name we have.
1790 unsigned SymbolIdx = 0;
1791 SourceLocation SymbolLocations[3];
1792 OverloadedOperatorKind Op = OO_None;
1793 switch (Tok.getKind()) {
1794 case tok::kw_new:
1795 case tok::kw_delete: {
1796 bool isNew = Tok.getKind() == tok::kw_new;
1797 // Consume the 'new' or 'delete'.
1798 SymbolLocations[SymbolIdx++] = ConsumeToken();
1799 // Check for array new/delete.
1800 if (Tok.is(tok::l_square) &&
1801 (!getLangOpts().CPlusPlus0x || NextToken().isNot(tok::l_square))) {
1802 // Consume the '[' and ']'.
1803 BalancedDelimiterTracker T(*this, tok::l_square);
1804 T.consumeOpen();
1805 T.consumeClose();
1806 if (T.getCloseLocation().isInvalid())
1807 return true;
1808
1809 SymbolLocations[SymbolIdx++] = T.getOpenLocation();
1810 SymbolLocations[SymbolIdx++] = T.getCloseLocation();
1811 Op = isNew? OO_Array_New : OO_Array_Delete;
1812 } else {
1813 Op = isNew? OO_New : OO_Delete;
1814 }
1815 break;
1816 }
1817
1818 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
1819 case tok::Token: \
1820 SymbolLocations[SymbolIdx++] = ConsumeToken(); \
1821 Op = OO_##Name; \
1822 break;
1823 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
1824 #include "clang/Basic/OperatorKinds.def"
1825
1826 case tok::l_paren: {
1827 // Consume the '(' and ')'.
1828 BalancedDelimiterTracker T(*this, tok::l_paren);
1829 T.consumeOpen();
1830 T.consumeClose();
1831 if (T.getCloseLocation().isInvalid())
1832 return true;
1833
1834 SymbolLocations[SymbolIdx++] = T.getOpenLocation();
1835 SymbolLocations[SymbolIdx++] = T.getCloseLocation();
1836 Op = OO_Call;
1837 break;
1838 }
1839
1840 case tok::l_square: {
1841 // Consume the '[' and ']'.
1842 BalancedDelimiterTracker T(*this, tok::l_square);
1843 T.consumeOpen();
1844 T.consumeClose();
1845 if (T.getCloseLocation().isInvalid())
1846 return true;
1847
1848 SymbolLocations[SymbolIdx++] = T.getOpenLocation();
1849 SymbolLocations[SymbolIdx++] = T.getCloseLocation();
1850 Op = OO_Subscript;
1851 break;
1852 }
1853
1854 case tok::code_completion: {
1855 // Code completion for the operator name.
1856 Actions.CodeCompleteOperatorName(getCurScope());
1857 cutOffParsing();
1858 // Don't try to parse any further.
1859 return true;
1860 }
1861
1862 default:
1863 break;
1864 }
1865
1866 if (Op != OO_None) {
1867 // We have parsed an operator-function-id.
1868 Result.setOperatorFunctionId(KeywordLoc, Op, SymbolLocations);
1869 return false;
1870 }
1871
1872 // Parse a literal-operator-id.
1873 //
1874 // literal-operator-id: [C++0x 13.5.8]
1875 // operator "" identifier
1876
1877 if (getLangOpts().CPlusPlus0x && isTokenStringLiteral()) {
1878 Diag(Tok.getLocation(), diag::warn_cxx98_compat_literal_operator);
1879
1880 SourceLocation DiagLoc;
1881 unsigned DiagId = 0;
1882
1883 // We're past translation phase 6, so perform string literal concatenation
1884 // before checking for "".
1885 llvm::SmallVector<Token, 4> Toks;
1886 llvm::SmallVector<SourceLocation, 4> TokLocs;
1887 while (isTokenStringLiteral()) {
1888 if (!Tok.is(tok::string_literal) && !DiagId) {
1889 DiagLoc = Tok.getLocation();
1890 DiagId = diag::err_literal_operator_string_prefix;
1891 }
1892 Toks.push_back(Tok);
1893 TokLocs.push_back(ConsumeStringToken());
1894 }
1895
1896 StringLiteralParser Literal(Toks.data(), Toks.size(), PP);
1897 if (Literal.hadError)
1898 return true;
1899
1900 // Grab the literal operator's suffix, which will be either the next token
1901 // or a ud-suffix from the string literal.
1902 IdentifierInfo *II = 0;
1903 SourceLocation SuffixLoc;
1904 if (!Literal.getUDSuffix().empty()) {
1905 II = &PP.getIdentifierTable().get(Literal.getUDSuffix());
1906 SuffixLoc =
1907 Lexer::AdvanceToTokenCharacter(TokLocs[Literal.getUDSuffixToken()],
1908 Literal.getUDSuffixOffset(),
1909 PP.getSourceManager(), getLangOpts());
1910 // This form is not permitted by the standard (yet).
1911 DiagLoc = SuffixLoc;
1912 DiagId = diag::err_literal_operator_missing_space;
1913 } else if (Tok.is(tok::identifier)) {
1914 II = Tok.getIdentifierInfo();
1915 SuffixLoc = ConsumeToken();
1916 TokLocs.push_back(SuffixLoc);
1917 } else {
1918 Diag(Tok.getLocation(), diag::err_expected_ident);
1919 return true;
1920 }
1921
1922 // The string literal must be empty.
1923 if (!Literal.GetString().empty() || Literal.Pascal) {
1924 DiagLoc = TokLocs.front();
1925 DiagId = diag::err_literal_operator_string_not_empty;
1926 }
1927
1928 if (DiagId) {
1929 // This isn't a valid literal-operator-id, but we think we know
1930 // what the user meant. Tell them what they should have written.
1931 llvm::SmallString<32> Str;
1932 Str += "\"\" ";
1933 Str += II->getName();
1934 Diag(DiagLoc, DiagId) << FixItHint::CreateReplacement(
1935 SourceRange(TokLocs.front(), TokLocs.back()), Str);
1936 }
1937
1938 Result.setLiteralOperatorId(II, KeywordLoc, SuffixLoc);
1939 return false;
1940 }
1941
1942 // Parse a conversion-function-id.
1943 //
1944 // conversion-function-id: [C++ 12.3.2]
1945 // operator conversion-type-id
1946 //
1947 // conversion-type-id:
1948 // type-specifier-seq conversion-declarator[opt]
1949 //
1950 // conversion-declarator:
1951 // ptr-operator conversion-declarator[opt]
1952
1953 // Parse the type-specifier-seq.
1954 DeclSpec DS(AttrFactory);
1955 if (ParseCXXTypeSpecifierSeq(DS)) // FIXME: ObjectType?
1956 return true;
1957
1958 // Parse the conversion-declarator, which is merely a sequence of
1959 // ptr-operators.
1960 Declarator D(DS, Declarator::TypeNameContext);
1961 ParseDeclaratorInternal(D, /*DirectDeclParser=*/0);
1962
1963 // Finish up the type.
1964 TypeResult Ty = Actions.ActOnTypeName(getCurScope(), D);
1965 if (Ty.isInvalid())
1966 return true;
1967
1968 // Note that this is a conversion-function-id.
1969 Result.setConversionFunctionId(KeywordLoc, Ty.get(),
1970 D.getSourceRange().getEnd());
1971 return false;
1972 }
1973
1974 /// \brief Parse a C++ unqualified-id (or a C identifier), which describes the
1975 /// name of an entity.
1976 ///
1977 /// \code
1978 /// unqualified-id: [C++ expr.prim.general]
1979 /// identifier
1980 /// operator-function-id
1981 /// conversion-function-id
1982 /// [C++0x] literal-operator-id [TODO]
1983 /// ~ class-name
1984 /// template-id
1985 ///
1986 /// \endcode
1987 ///
1988 /// \param SS The nested-name-specifier that preceded this unqualified-id. If
1989 /// non-empty, then we are parsing the unqualified-id of a qualified-id.
1990 ///
1991 /// \param EnteringContext whether we are entering the scope of the
1992 /// nested-name-specifier.
1993 ///
1994 /// \param AllowDestructorName whether we allow parsing of a destructor name.
1995 ///
1996 /// \param AllowConstructorName whether we allow parsing a constructor name.
1997 ///
1998 /// \param ObjectType if this unqualified-id occurs within a member access
1999 /// expression, the type of the base object whose member is being accessed.
2000 ///
2001 /// \param Result on a successful parse, contains the parsed unqualified-id.
2002 ///
2003 /// \returns true if parsing fails, false otherwise.
ParseUnqualifiedId(CXXScopeSpec & SS,bool EnteringContext,bool AllowDestructorName,bool AllowConstructorName,ParsedType ObjectType,SourceLocation & TemplateKWLoc,UnqualifiedId & Result)2004 bool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, bool EnteringContext,
2005 bool AllowDestructorName,
2006 bool AllowConstructorName,
2007 ParsedType ObjectType,
2008 SourceLocation& TemplateKWLoc,
2009 UnqualifiedId &Result) {
2010
2011 // Handle 'A::template B'. This is for template-ids which have not
2012 // already been annotated by ParseOptionalCXXScopeSpecifier().
2013 bool TemplateSpecified = false;
2014 if (getLangOpts().CPlusPlus && Tok.is(tok::kw_template) &&
2015 (ObjectType || SS.isSet())) {
2016 TemplateSpecified = true;
2017 TemplateKWLoc = ConsumeToken();
2018 }
2019
2020 // unqualified-id:
2021 // identifier
2022 // template-id (when it hasn't already been annotated)
2023 if (Tok.is(tok::identifier)) {
2024 // Consume the identifier.
2025 IdentifierInfo *Id = Tok.getIdentifierInfo();
2026 SourceLocation IdLoc = ConsumeToken();
2027
2028 if (!getLangOpts().CPlusPlus) {
2029 // If we're not in C++, only identifiers matter. Record the
2030 // identifier and return.
2031 Result.setIdentifier(Id, IdLoc);
2032 return false;
2033 }
2034
2035 if (AllowConstructorName &&
2036 Actions.isCurrentClassName(*Id, getCurScope(), &SS)) {
2037 // We have parsed a constructor name.
2038 ParsedType Ty = Actions.getTypeName(*Id, IdLoc, getCurScope(),
2039 &SS, false, false,
2040 ParsedType(),
2041 /*IsCtorOrDtorName=*/true,
2042 /*NonTrivialTypeSourceInfo=*/true);
2043 Result.setConstructorName(Ty, IdLoc, IdLoc);
2044 } else {
2045 // We have parsed an identifier.
2046 Result.setIdentifier(Id, IdLoc);
2047 }
2048
2049 // If the next token is a '<', we may have a template.
2050 if (TemplateSpecified || Tok.is(tok::less))
2051 return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc, Id, IdLoc,
2052 EnteringContext, ObjectType,
2053 Result, TemplateSpecified);
2054
2055 return false;
2056 }
2057
2058 // unqualified-id:
2059 // template-id (already parsed and annotated)
2060 if (Tok.is(tok::annot_template_id)) {
2061 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
2062
2063 // If the template-name names the current class, then this is a constructor
2064 if (AllowConstructorName && TemplateId->Name &&
2065 Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) {
2066 if (SS.isSet()) {
2067 // C++ [class.qual]p2 specifies that a qualified template-name
2068 // is taken as the constructor name where a constructor can be
2069 // declared. Thus, the template arguments are extraneous, so
2070 // complain about them and remove them entirely.
2071 Diag(TemplateId->TemplateNameLoc,
2072 diag::err_out_of_line_constructor_template_id)
2073 << TemplateId->Name
2074 << FixItHint::CreateRemoval(
2075 SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc));
2076 ParsedType Ty = Actions.getTypeName(*TemplateId->Name,
2077 TemplateId->TemplateNameLoc,
2078 getCurScope(),
2079 &SS, false, false,
2080 ParsedType(),
2081 /*IsCtorOrDtorName=*/true,
2082 /*NontrivialTypeSourceInfo=*/true);
2083 Result.setConstructorName(Ty, TemplateId->TemplateNameLoc,
2084 TemplateId->RAngleLoc);
2085 ConsumeToken();
2086 return false;
2087 }
2088
2089 Result.setConstructorTemplateId(TemplateId);
2090 ConsumeToken();
2091 return false;
2092 }
2093
2094 // We have already parsed a template-id; consume the annotation token as
2095 // our unqualified-id.
2096 Result.setTemplateId(TemplateId);
2097 TemplateKWLoc = TemplateId->TemplateKWLoc;
2098 ConsumeToken();
2099 return false;
2100 }
2101
2102 // unqualified-id:
2103 // operator-function-id
2104 // conversion-function-id
2105 if (Tok.is(tok::kw_operator)) {
2106 if (ParseUnqualifiedIdOperator(SS, EnteringContext, ObjectType, Result))
2107 return true;
2108
2109 // If we have an operator-function-id or a literal-operator-id and the next
2110 // token is a '<', we may have a
2111 //
2112 // template-id:
2113 // operator-function-id < template-argument-list[opt] >
2114 if ((Result.getKind() == UnqualifiedId::IK_OperatorFunctionId ||
2115 Result.getKind() == UnqualifiedId::IK_LiteralOperatorId) &&
2116 (TemplateSpecified || Tok.is(tok::less)))
2117 return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
2118 0, SourceLocation(),
2119 EnteringContext, ObjectType,
2120 Result, TemplateSpecified);
2121
2122 return false;
2123 }
2124
2125 if (getLangOpts().CPlusPlus &&
2126 (AllowDestructorName || SS.isSet()) && Tok.is(tok::tilde)) {
2127 // C++ [expr.unary.op]p10:
2128 // There is an ambiguity in the unary-expression ~X(), where X is a
2129 // class-name. The ambiguity is resolved in favor of treating ~ as a
2130 // unary complement rather than treating ~X as referring to a destructor.
2131
2132 // Parse the '~'.
2133 SourceLocation TildeLoc = ConsumeToken();
2134
2135 if (SS.isEmpty() && Tok.is(tok::kw_decltype)) {
2136 DeclSpec DS(AttrFactory);
2137 SourceLocation EndLoc = ParseDecltypeSpecifier(DS);
2138 if (ParsedType Type = Actions.getDestructorType(DS, ObjectType)) {
2139 Result.setDestructorName(TildeLoc, Type, EndLoc);
2140 return false;
2141 }
2142 return true;
2143 }
2144
2145 // Parse the class-name.
2146 if (Tok.isNot(tok::identifier)) {
2147 Diag(Tok, diag::err_destructor_tilde_identifier);
2148 return true;
2149 }
2150
2151 // Parse the class-name (or template-name in a simple-template-id).
2152 IdentifierInfo *ClassName = Tok.getIdentifierInfo();
2153 SourceLocation ClassNameLoc = ConsumeToken();
2154
2155 if (TemplateSpecified || Tok.is(tok::less)) {
2156 Result.setDestructorName(TildeLoc, ParsedType(), ClassNameLoc);
2157 return ParseUnqualifiedIdTemplateId(SS, TemplateKWLoc,
2158 ClassName, ClassNameLoc,
2159 EnteringContext, ObjectType,
2160 Result, TemplateSpecified);
2161 }
2162
2163 // Note that this is a destructor name.
2164 ParsedType Ty = Actions.getDestructorName(TildeLoc, *ClassName,
2165 ClassNameLoc, getCurScope(),
2166 SS, ObjectType,
2167 EnteringContext);
2168 if (!Ty)
2169 return true;
2170
2171 Result.setDestructorName(TildeLoc, Ty, ClassNameLoc);
2172 return false;
2173 }
2174
2175 Diag(Tok, diag::err_expected_unqualified_id)
2176 << getLangOpts().CPlusPlus;
2177 return true;
2178 }
2179
2180 /// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
2181 /// memory in a typesafe manner and call constructors.
2182 ///
2183 /// This method is called to parse the new expression after the optional :: has
2184 /// been already parsed. If the :: was present, "UseGlobal" is true and "Start"
2185 /// is its location. Otherwise, "Start" is the location of the 'new' token.
2186 ///
2187 /// new-expression:
2188 /// '::'[opt] 'new' new-placement[opt] new-type-id
2189 /// new-initializer[opt]
2190 /// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2191 /// new-initializer[opt]
2192 ///
2193 /// new-placement:
2194 /// '(' expression-list ')'
2195 ///
2196 /// new-type-id:
2197 /// type-specifier-seq new-declarator[opt]
2198 /// [GNU] attributes type-specifier-seq new-declarator[opt]
2199 ///
2200 /// new-declarator:
2201 /// ptr-operator new-declarator[opt]
2202 /// direct-new-declarator
2203 ///
2204 /// new-initializer:
2205 /// '(' expression-list[opt] ')'
2206 /// [C++0x] braced-init-list
2207 ///
2208 ExprResult
ParseCXXNewExpression(bool UseGlobal,SourceLocation Start)2209 Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
2210 assert(Tok.is(tok::kw_new) && "expected 'new' token");
2211 ConsumeToken(); // Consume 'new'
2212
2213 // A '(' now can be a new-placement or the '(' wrapping the type-id in the
2214 // second form of new-expression. It can't be a new-type-id.
2215
2216 ExprVector PlacementArgs;
2217 SourceLocation PlacementLParen, PlacementRParen;
2218
2219 SourceRange TypeIdParens;
2220 DeclSpec DS(AttrFactory);
2221 Declarator DeclaratorInfo(DS, Declarator::CXXNewContext);
2222 if (Tok.is(tok::l_paren)) {
2223 // If it turns out to be a placement, we change the type location.
2224 BalancedDelimiterTracker T(*this, tok::l_paren);
2225 T.consumeOpen();
2226 PlacementLParen = T.getOpenLocation();
2227 if (ParseExpressionListOrTypeId(PlacementArgs, DeclaratorInfo)) {
2228 SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
2229 return ExprError();
2230 }
2231
2232 T.consumeClose();
2233 PlacementRParen = T.getCloseLocation();
2234 if (PlacementRParen.isInvalid()) {
2235 SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
2236 return ExprError();
2237 }
2238
2239 if (PlacementArgs.empty()) {
2240 // Reset the placement locations. There was no placement.
2241 TypeIdParens = T.getRange();
2242 PlacementLParen = PlacementRParen = SourceLocation();
2243 } else {
2244 // We still need the type.
2245 if (Tok.is(tok::l_paren)) {
2246 BalancedDelimiterTracker T(*this, tok::l_paren);
2247 T.consumeOpen();
2248 MaybeParseGNUAttributes(DeclaratorInfo);
2249 ParseSpecifierQualifierList(DS);
2250 DeclaratorInfo.SetSourceRange(DS.getSourceRange());
2251 ParseDeclarator(DeclaratorInfo);
2252 T.consumeClose();
2253 TypeIdParens = T.getRange();
2254 } else {
2255 MaybeParseGNUAttributes(DeclaratorInfo);
2256 if (ParseCXXTypeSpecifierSeq(DS))
2257 DeclaratorInfo.setInvalidType(true);
2258 else {
2259 DeclaratorInfo.SetSourceRange(DS.getSourceRange());
2260 ParseDeclaratorInternal(DeclaratorInfo,
2261 &Parser::ParseDirectNewDeclarator);
2262 }
2263 }
2264 }
2265 } else {
2266 // A new-type-id is a simplified type-id, where essentially the
2267 // direct-declarator is replaced by a direct-new-declarator.
2268 MaybeParseGNUAttributes(DeclaratorInfo);
2269 if (ParseCXXTypeSpecifierSeq(DS))
2270 DeclaratorInfo.setInvalidType(true);
2271 else {
2272 DeclaratorInfo.SetSourceRange(DS.getSourceRange());
2273 ParseDeclaratorInternal(DeclaratorInfo,
2274 &Parser::ParseDirectNewDeclarator);
2275 }
2276 }
2277 if (DeclaratorInfo.isInvalidType()) {
2278 SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
2279 return ExprError();
2280 }
2281
2282 ExprResult Initializer;
2283
2284 if (Tok.is(tok::l_paren)) {
2285 SourceLocation ConstructorLParen, ConstructorRParen;
2286 ExprVector ConstructorArgs;
2287 BalancedDelimiterTracker T(*this, tok::l_paren);
2288 T.consumeOpen();
2289 ConstructorLParen = T.getOpenLocation();
2290 if (Tok.isNot(tok::r_paren)) {
2291 CommaLocsTy CommaLocs;
2292 if (ParseExpressionList(ConstructorArgs, CommaLocs)) {
2293 SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
2294 return ExprError();
2295 }
2296 }
2297 T.consumeClose();
2298 ConstructorRParen = T.getCloseLocation();
2299 if (ConstructorRParen.isInvalid()) {
2300 SkipUntil(tok::semi, /*StopAtSemi=*/true, /*DontConsume=*/true);
2301 return ExprError();
2302 }
2303 Initializer = Actions.ActOnParenListExpr(ConstructorLParen,
2304 ConstructorRParen,
2305 ConstructorArgs);
2306 } else if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus0x) {
2307 Diag(Tok.getLocation(),
2308 diag::warn_cxx98_compat_generalized_initializer_lists);
2309 Initializer = ParseBraceInitializer();
2310 }
2311 if (Initializer.isInvalid())
2312 return Initializer;
2313
2314 return Actions.ActOnCXXNew(Start, UseGlobal, PlacementLParen,
2315 PlacementArgs, PlacementRParen,
2316 TypeIdParens, DeclaratorInfo, Initializer.take());
2317 }
2318
2319 /// ParseDirectNewDeclarator - Parses a direct-new-declarator. Intended to be
2320 /// passed to ParseDeclaratorInternal.
2321 ///
2322 /// direct-new-declarator:
2323 /// '[' expression ']'
2324 /// direct-new-declarator '[' constant-expression ']'
2325 ///
ParseDirectNewDeclarator(Declarator & D)2326 void Parser::ParseDirectNewDeclarator(Declarator &D) {
2327 // Parse the array dimensions.
2328 bool first = true;
2329 while (Tok.is(tok::l_square)) {
2330 // An array-size expression can't start with a lambda.
2331 if (CheckProhibitedCXX11Attribute())
2332 continue;
2333
2334 BalancedDelimiterTracker T(*this, tok::l_square);
2335 T.consumeOpen();
2336
2337 ExprResult Size(first ? ParseExpression()
2338 : ParseConstantExpression());
2339 if (Size.isInvalid()) {
2340 // Recover
2341 SkipUntil(tok::r_square);
2342 return;
2343 }
2344 first = false;
2345
2346 T.consumeClose();
2347
2348 // Attributes here appertain to the array type. C++11 [expr.new]p5.
2349 ParsedAttributes Attrs(AttrFactory);
2350 MaybeParseCXX0XAttributes(Attrs);
2351
2352 D.AddTypeInfo(DeclaratorChunk::getArray(0,
2353 /*static=*/false, /*star=*/false,
2354 Size.release(),
2355 T.getOpenLocation(),
2356 T.getCloseLocation()),
2357 Attrs, T.getCloseLocation());
2358
2359 if (T.getCloseLocation().isInvalid())
2360 return;
2361 }
2362 }
2363
2364 /// ParseExpressionListOrTypeId - Parse either an expression-list or a type-id.
2365 /// This ambiguity appears in the syntax of the C++ new operator.
2366 ///
2367 /// new-expression:
2368 /// '::'[opt] 'new' new-placement[opt] '(' type-id ')'
2369 /// new-initializer[opt]
2370 ///
2371 /// new-placement:
2372 /// '(' expression-list ')'
2373 ///
ParseExpressionListOrTypeId(SmallVectorImpl<Expr * > & PlacementArgs,Declarator & D)2374 bool Parser::ParseExpressionListOrTypeId(
2375 SmallVectorImpl<Expr*> &PlacementArgs,
2376 Declarator &D) {
2377 // The '(' was already consumed.
2378 if (isTypeIdInParens()) {
2379 ParseSpecifierQualifierList(D.getMutableDeclSpec());
2380 D.SetSourceRange(D.getDeclSpec().getSourceRange());
2381 ParseDeclarator(D);
2382 return D.isInvalidType();
2383 }
2384
2385 // It's not a type, it has to be an expression list.
2386 // Discard the comma locations - ActOnCXXNew has enough parameters.
2387 CommaLocsTy CommaLocs;
2388 return ParseExpressionList(PlacementArgs, CommaLocs);
2389 }
2390
2391 /// ParseCXXDeleteExpression - Parse a C++ delete-expression. Delete is used
2392 /// to free memory allocated by new.
2393 ///
2394 /// This method is called to parse the 'delete' expression after the optional
2395 /// '::' has been already parsed. If the '::' was present, "UseGlobal" is true
2396 /// and "Start" is its location. Otherwise, "Start" is the location of the
2397 /// 'delete' token.
2398 ///
2399 /// delete-expression:
2400 /// '::'[opt] 'delete' cast-expression
2401 /// '::'[opt] 'delete' '[' ']' cast-expression
2402 ExprResult
ParseCXXDeleteExpression(bool UseGlobal,SourceLocation Start)2403 Parser::ParseCXXDeleteExpression(bool UseGlobal, SourceLocation Start) {
2404 assert(Tok.is(tok::kw_delete) && "Expected 'delete' keyword");
2405 ConsumeToken(); // Consume 'delete'
2406
2407 // Array delete?
2408 bool ArrayDelete = false;
2409 if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
2410 // C++11 [expr.delete]p1:
2411 // Whenever the delete keyword is followed by empty square brackets, it
2412 // shall be interpreted as [array delete].
2413 // [Footnote: A lambda expression with a lambda-introducer that consists
2414 // of empty square brackets can follow the delete keyword if
2415 // the lambda expression is enclosed in parentheses.]
2416 // FIXME: Produce a better diagnostic if the '[]' is unambiguously a
2417 // lambda-introducer.
2418 ArrayDelete = true;
2419 BalancedDelimiterTracker T(*this, tok::l_square);
2420
2421 T.consumeOpen();
2422 T.consumeClose();
2423 if (T.getCloseLocation().isInvalid())
2424 return ExprError();
2425 }
2426
2427 ExprResult Operand(ParseCastExpression(false));
2428 if (Operand.isInvalid())
2429 return Operand;
2430
2431 return Actions.ActOnCXXDelete(Start, UseGlobal, ArrayDelete, Operand.take());
2432 }
2433
UnaryTypeTraitFromTokKind(tok::TokenKind kind)2434 static UnaryTypeTrait UnaryTypeTraitFromTokKind(tok::TokenKind kind) {
2435 switch(kind) {
2436 default: llvm_unreachable("Not a known unary type trait.");
2437 case tok::kw___has_nothrow_assign: return UTT_HasNothrowAssign;
2438 case tok::kw___has_nothrow_constructor: return UTT_HasNothrowConstructor;
2439 case tok::kw___has_nothrow_copy: return UTT_HasNothrowCopy;
2440 case tok::kw___has_trivial_assign: return UTT_HasTrivialAssign;
2441 case tok::kw___has_trivial_constructor:
2442 return UTT_HasTrivialDefaultConstructor;
2443 case tok::kw___has_trivial_copy: return UTT_HasTrivialCopy;
2444 case tok::kw___has_trivial_destructor: return UTT_HasTrivialDestructor;
2445 case tok::kw___has_virtual_destructor: return UTT_HasVirtualDestructor;
2446 case tok::kw___is_abstract: return UTT_IsAbstract;
2447 case tok::kw___is_arithmetic: return UTT_IsArithmetic;
2448 case tok::kw___is_array: return UTT_IsArray;
2449 case tok::kw___is_class: return UTT_IsClass;
2450 case tok::kw___is_complete_type: return UTT_IsCompleteType;
2451 case tok::kw___is_compound: return UTT_IsCompound;
2452 case tok::kw___is_const: return UTT_IsConst;
2453 case tok::kw___is_empty: return UTT_IsEmpty;
2454 case tok::kw___is_enum: return UTT_IsEnum;
2455 case tok::kw___is_final: return UTT_IsFinal;
2456 case tok::kw___is_floating_point: return UTT_IsFloatingPoint;
2457 case tok::kw___is_function: return UTT_IsFunction;
2458 case tok::kw___is_fundamental: return UTT_IsFundamental;
2459 case tok::kw___is_integral: return UTT_IsIntegral;
2460 case tok::kw___is_lvalue_reference: return UTT_IsLvalueReference;
2461 case tok::kw___is_member_function_pointer: return UTT_IsMemberFunctionPointer;
2462 case tok::kw___is_member_object_pointer: return UTT_IsMemberObjectPointer;
2463 case tok::kw___is_member_pointer: return UTT_IsMemberPointer;
2464 case tok::kw___is_object: return UTT_IsObject;
2465 case tok::kw___is_literal: return UTT_IsLiteral;
2466 case tok::kw___is_literal_type: return UTT_IsLiteral;
2467 case tok::kw___is_pod: return UTT_IsPOD;
2468 case tok::kw___is_pointer: return UTT_IsPointer;
2469 case tok::kw___is_polymorphic: return UTT_IsPolymorphic;
2470 case tok::kw___is_reference: return UTT_IsReference;
2471 case tok::kw___is_rvalue_reference: return UTT_IsRvalueReference;
2472 case tok::kw___is_scalar: return UTT_IsScalar;
2473 case tok::kw___is_signed: return UTT_IsSigned;
2474 case tok::kw___is_standard_layout: return UTT_IsStandardLayout;
2475 case tok::kw___is_trivial: return UTT_IsTrivial;
2476 case tok::kw___is_trivially_copyable: return UTT_IsTriviallyCopyable;
2477 case tok::kw___is_union: return UTT_IsUnion;
2478 case tok::kw___is_unsigned: return UTT_IsUnsigned;
2479 case tok::kw___is_void: return UTT_IsVoid;
2480 case tok::kw___is_volatile: return UTT_IsVolatile;
2481 }
2482 }
2483
BinaryTypeTraitFromTokKind(tok::TokenKind kind)2484 static BinaryTypeTrait BinaryTypeTraitFromTokKind(tok::TokenKind kind) {
2485 switch(kind) {
2486 default: llvm_unreachable("Not a known binary type trait");
2487 case tok::kw___is_base_of: return BTT_IsBaseOf;
2488 case tok::kw___is_convertible: return BTT_IsConvertible;
2489 case tok::kw___is_same: return BTT_IsSame;
2490 case tok::kw___builtin_types_compatible_p: return BTT_TypeCompatible;
2491 case tok::kw___is_convertible_to: return BTT_IsConvertibleTo;
2492 case tok::kw___is_trivially_assignable: return BTT_IsTriviallyAssignable;
2493 }
2494 }
2495
TypeTraitFromTokKind(tok::TokenKind kind)2496 static TypeTrait TypeTraitFromTokKind(tok::TokenKind kind) {
2497 switch (kind) {
2498 default: llvm_unreachable("Not a known type trait");
2499 case tok::kw___is_trivially_constructible:
2500 return TT_IsTriviallyConstructible;
2501 }
2502 }
2503
ArrayTypeTraitFromTokKind(tok::TokenKind kind)2504 static ArrayTypeTrait ArrayTypeTraitFromTokKind(tok::TokenKind kind) {
2505 switch(kind) {
2506 default: llvm_unreachable("Not a known binary type trait");
2507 case tok::kw___array_rank: return ATT_ArrayRank;
2508 case tok::kw___array_extent: return ATT_ArrayExtent;
2509 }
2510 }
2511
ExpressionTraitFromTokKind(tok::TokenKind kind)2512 static ExpressionTrait ExpressionTraitFromTokKind(tok::TokenKind kind) {
2513 switch(kind) {
2514 default: llvm_unreachable("Not a known unary expression trait.");
2515 case tok::kw___is_lvalue_expr: return ET_IsLValueExpr;
2516 case tok::kw___is_rvalue_expr: return ET_IsRValueExpr;
2517 }
2518 }
2519
2520 /// ParseUnaryTypeTrait - Parse the built-in unary type-trait
2521 /// pseudo-functions that allow implementation of the TR1/C++0x type traits
2522 /// templates.
2523 ///
2524 /// primary-expression:
2525 /// [GNU] unary-type-trait '(' type-id ')'
2526 ///
ParseUnaryTypeTrait()2527 ExprResult Parser::ParseUnaryTypeTrait() {
2528 UnaryTypeTrait UTT = UnaryTypeTraitFromTokKind(Tok.getKind());
2529 SourceLocation Loc = ConsumeToken();
2530
2531 BalancedDelimiterTracker T(*this, tok::l_paren);
2532 if (T.expectAndConsume(diag::err_expected_lparen))
2533 return ExprError();
2534
2535 // FIXME: Error reporting absolutely sucks! If the this fails to parse a type
2536 // there will be cryptic errors about mismatched parentheses and missing
2537 // specifiers.
2538 TypeResult Ty = ParseTypeName();
2539
2540 T.consumeClose();
2541
2542 if (Ty.isInvalid())
2543 return ExprError();
2544
2545 return Actions.ActOnUnaryTypeTrait(UTT, Loc, Ty.get(), T.getCloseLocation());
2546 }
2547
2548 /// ParseBinaryTypeTrait - Parse the built-in binary type-trait
2549 /// pseudo-functions that allow implementation of the TR1/C++0x type traits
2550 /// templates.
2551 ///
2552 /// primary-expression:
2553 /// [GNU] binary-type-trait '(' type-id ',' type-id ')'
2554 ///
ParseBinaryTypeTrait()2555 ExprResult Parser::ParseBinaryTypeTrait() {
2556 BinaryTypeTrait BTT = BinaryTypeTraitFromTokKind(Tok.getKind());
2557 SourceLocation Loc = ConsumeToken();
2558
2559 BalancedDelimiterTracker T(*this, tok::l_paren);
2560 if (T.expectAndConsume(diag::err_expected_lparen))
2561 return ExprError();
2562
2563 TypeResult LhsTy = ParseTypeName();
2564 if (LhsTy.isInvalid()) {
2565 SkipUntil(tok::r_paren);
2566 return ExprError();
2567 }
2568
2569 if (ExpectAndConsume(tok::comma, diag::err_expected_comma)) {
2570 SkipUntil(tok::r_paren);
2571 return ExprError();
2572 }
2573
2574 TypeResult RhsTy = ParseTypeName();
2575 if (RhsTy.isInvalid()) {
2576 SkipUntil(tok::r_paren);
2577 return ExprError();
2578 }
2579
2580 T.consumeClose();
2581
2582 return Actions.ActOnBinaryTypeTrait(BTT, Loc, LhsTy.get(), RhsTy.get(),
2583 T.getCloseLocation());
2584 }
2585
2586 /// \brief Parse the built-in type-trait pseudo-functions that allow
2587 /// implementation of the TR1/C++11 type traits templates.
2588 ///
2589 /// primary-expression:
2590 /// type-trait '(' type-id-seq ')'
2591 ///
2592 /// type-id-seq:
2593 /// type-id ...[opt] type-id-seq[opt]
2594 ///
ParseTypeTrait()2595 ExprResult Parser::ParseTypeTrait() {
2596 TypeTrait Kind = TypeTraitFromTokKind(Tok.getKind());
2597 SourceLocation Loc = ConsumeToken();
2598
2599 BalancedDelimiterTracker Parens(*this, tok::l_paren);
2600 if (Parens.expectAndConsume(diag::err_expected_lparen))
2601 return ExprError();
2602
2603 llvm::SmallVector<ParsedType, 2> Args;
2604 do {
2605 // Parse the next type.
2606 TypeResult Ty = ParseTypeName();
2607 if (Ty.isInvalid()) {
2608 Parens.skipToEnd();
2609 return ExprError();
2610 }
2611
2612 // Parse the ellipsis, if present.
2613 if (Tok.is(tok::ellipsis)) {
2614 Ty = Actions.ActOnPackExpansion(Ty.get(), ConsumeToken());
2615 if (Ty.isInvalid()) {
2616 Parens.skipToEnd();
2617 return ExprError();
2618 }
2619 }
2620
2621 // Add this type to the list of arguments.
2622 Args.push_back(Ty.get());
2623
2624 if (Tok.is(tok::comma)) {
2625 ConsumeToken();
2626 continue;
2627 }
2628
2629 break;
2630 } while (true);
2631
2632 if (Parens.consumeClose())
2633 return ExprError();
2634
2635 return Actions.ActOnTypeTrait(Kind, Loc, Args, Parens.getCloseLocation());
2636 }
2637
2638 /// ParseArrayTypeTrait - Parse the built-in array type-trait
2639 /// pseudo-functions.
2640 ///
2641 /// primary-expression:
2642 /// [Embarcadero] '__array_rank' '(' type-id ')'
2643 /// [Embarcadero] '__array_extent' '(' type-id ',' expression ')'
2644 ///
ParseArrayTypeTrait()2645 ExprResult Parser::ParseArrayTypeTrait() {
2646 ArrayTypeTrait ATT = ArrayTypeTraitFromTokKind(Tok.getKind());
2647 SourceLocation Loc = ConsumeToken();
2648
2649 BalancedDelimiterTracker T(*this, tok::l_paren);
2650 if (T.expectAndConsume(diag::err_expected_lparen))
2651 return ExprError();
2652
2653 TypeResult Ty = ParseTypeName();
2654 if (Ty.isInvalid()) {
2655 SkipUntil(tok::comma);
2656 SkipUntil(tok::r_paren);
2657 return ExprError();
2658 }
2659
2660 switch (ATT) {
2661 case ATT_ArrayRank: {
2662 T.consumeClose();
2663 return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), NULL,
2664 T.getCloseLocation());
2665 }
2666 case ATT_ArrayExtent: {
2667 if (ExpectAndConsume(tok::comma, diag::err_expected_comma)) {
2668 SkipUntil(tok::r_paren);
2669 return ExprError();
2670 }
2671
2672 ExprResult DimExpr = ParseExpression();
2673 T.consumeClose();
2674
2675 return Actions.ActOnArrayTypeTrait(ATT, Loc, Ty.get(), DimExpr.get(),
2676 T.getCloseLocation());
2677 }
2678 }
2679 llvm_unreachable("Invalid ArrayTypeTrait!");
2680 }
2681
2682 /// ParseExpressionTrait - Parse built-in expression-trait
2683 /// pseudo-functions like __is_lvalue_expr( xxx ).
2684 ///
2685 /// primary-expression:
2686 /// [Embarcadero] expression-trait '(' expression ')'
2687 ///
ParseExpressionTrait()2688 ExprResult Parser::ParseExpressionTrait() {
2689 ExpressionTrait ET = ExpressionTraitFromTokKind(Tok.getKind());
2690 SourceLocation Loc = ConsumeToken();
2691
2692 BalancedDelimiterTracker T(*this, tok::l_paren);
2693 if (T.expectAndConsume(diag::err_expected_lparen))
2694 return ExprError();
2695
2696 ExprResult Expr = ParseExpression();
2697
2698 T.consumeClose();
2699
2700 return Actions.ActOnExpressionTrait(ET, Loc, Expr.get(),
2701 T.getCloseLocation());
2702 }
2703
2704
2705 /// ParseCXXAmbiguousParenExpression - We have parsed the left paren of a
2706 /// parenthesized ambiguous type-id. This uses tentative parsing to disambiguate
2707 /// based on the context past the parens.
2708 ExprResult
ParseCXXAmbiguousParenExpression(ParenParseOption & ExprType,ParsedType & CastTy,BalancedDelimiterTracker & Tracker)2709 Parser::ParseCXXAmbiguousParenExpression(ParenParseOption &ExprType,
2710 ParsedType &CastTy,
2711 BalancedDelimiterTracker &Tracker) {
2712 assert(getLangOpts().CPlusPlus && "Should only be called for C++!");
2713 assert(ExprType == CastExpr && "Compound literals are not ambiguous!");
2714 assert(isTypeIdInParens() && "Not a type-id!");
2715
2716 ExprResult Result(true);
2717 CastTy = ParsedType();
2718
2719 // We need to disambiguate a very ugly part of the C++ syntax:
2720 //
2721 // (T())x; - type-id
2722 // (T())*x; - type-id
2723 // (T())/x; - expression
2724 // (T()); - expression
2725 //
2726 // The bad news is that we cannot use the specialized tentative parser, since
2727 // it can only verify that the thing inside the parens can be parsed as
2728 // type-id, it is not useful for determining the context past the parens.
2729 //
2730 // The good news is that the parser can disambiguate this part without
2731 // making any unnecessary Action calls.
2732 //
2733 // It uses a scheme similar to parsing inline methods. The parenthesized
2734 // tokens are cached, the context that follows is determined (possibly by
2735 // parsing a cast-expression), and then we re-introduce the cached tokens
2736 // into the token stream and parse them appropriately.
2737
2738 ParenParseOption ParseAs;
2739 CachedTokens Toks;
2740
2741 // Store the tokens of the parentheses. We will parse them after we determine
2742 // the context that follows them.
2743 if (!ConsumeAndStoreUntil(tok::r_paren, Toks)) {
2744 // We didn't find the ')' we expected.
2745 Tracker.consumeClose();
2746 return ExprError();
2747 }
2748
2749 if (Tok.is(tok::l_brace)) {
2750 ParseAs = CompoundLiteral;
2751 } else {
2752 bool NotCastExpr;
2753 // FIXME: Special-case ++ and --: "(S())++;" is not a cast-expression
2754 if (Tok.is(tok::l_paren) && NextToken().is(tok::r_paren)) {
2755 NotCastExpr = true;
2756 } else {
2757 // Try parsing the cast-expression that may follow.
2758 // If it is not a cast-expression, NotCastExpr will be true and no token
2759 // will be consumed.
2760 Result = ParseCastExpression(false/*isUnaryExpression*/,
2761 false/*isAddressofOperand*/,
2762 NotCastExpr,
2763 // type-id has priority.
2764 IsTypeCast);
2765 }
2766
2767 // If we parsed a cast-expression, it's really a type-id, otherwise it's
2768 // an expression.
2769 ParseAs = NotCastExpr ? SimpleExpr : CastExpr;
2770 }
2771
2772 // The current token should go after the cached tokens.
2773 Toks.push_back(Tok);
2774 // Re-enter the stored parenthesized tokens into the token stream, so we may
2775 // parse them now.
2776 PP.EnterTokenStream(Toks.data(), Toks.size(),
2777 true/*DisableMacroExpansion*/, false/*OwnsTokens*/);
2778 // Drop the current token and bring the first cached one. It's the same token
2779 // as when we entered this function.
2780 ConsumeAnyToken();
2781
2782 if (ParseAs >= CompoundLiteral) {
2783 // Parse the type declarator.
2784 DeclSpec DS(AttrFactory);
2785 ParseSpecifierQualifierList(DS);
2786 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
2787 ParseDeclarator(DeclaratorInfo);
2788
2789 // Match the ')'.
2790 Tracker.consumeClose();
2791
2792 if (ParseAs == CompoundLiteral) {
2793 ExprType = CompoundLiteral;
2794 TypeResult Ty = ParseTypeName();
2795 return ParseCompoundLiteralExpression(Ty.get(),
2796 Tracker.getOpenLocation(),
2797 Tracker.getCloseLocation());
2798 }
2799
2800 // We parsed '(' type-id ')' and the thing after it wasn't a '{'.
2801 assert(ParseAs == CastExpr);
2802
2803 if (DeclaratorInfo.isInvalidType())
2804 return ExprError();
2805
2806 // Result is what ParseCastExpression returned earlier.
2807 if (!Result.isInvalid())
2808 Result = Actions.ActOnCastExpr(getCurScope(), Tracker.getOpenLocation(),
2809 DeclaratorInfo, CastTy,
2810 Tracker.getCloseLocation(), Result.take());
2811 return Result;
2812 }
2813
2814 // Not a compound literal, and not followed by a cast-expression.
2815 assert(ParseAs == SimpleExpr);
2816
2817 ExprType = SimpleExpr;
2818 Result = ParseExpression();
2819 if (!Result.isInvalid() && Tok.is(tok::r_paren))
2820 Result = Actions.ActOnParenExpr(Tracker.getOpenLocation(),
2821 Tok.getLocation(), Result.take());
2822
2823 // Match the ')'.
2824 if (Result.isInvalid()) {
2825 SkipUntil(tok::r_paren);
2826 return ExprError();
2827 }
2828
2829 Tracker.consumeClose();
2830 return Result;
2831 }
2832